myvtm/libtoolkit/log.c

#include "precompile.h"

#include "log.h"
#include "log_mgr.h"
#include "log_single.h"
#include "log_periodic.h"
#include "log_udpclient.h"
#include "log_udpdaemon.h"
#include "iniutil.h"
#include "fileutil.h"
#include "sockutil.h"
#include "modCheck.h"

#define XLOG_VERSION	0x0101



TOOLKIT_API int xlog_version();
TOOLKIT_API int xlog_init2(const char *inifile, const char *sections);
TOOLKIT_API int xlog_set_level(const char* inst, int level);
TOOLKIT_API int xlog_get_level(const char* inst, int *level);
TOOLKIT_API int xlog_log_f(const char *inst, int level, const char *fmt, ...);
// #define XLOG_TRACE(inst, fmt, ...)	\
// 	xlog_log_f(inst, XLOG_LEVEL_TRACE, fmt, __VA_ARGS__)
// #define XLOG_DEBUG(inst, fmt, ...)	\
// 	xlog_log_f(inst, XLOG_LEVEL_DEBUG, fmt, __VA_ARGS__)
// #define XLOG_INFO(inst, fmt, ...)	\
// 	xlog_log_f(inst, XLOG_LEVEL_INFO, fmt, __VA_ARGS__)
// #define XLOG_WARN(inst, fmt, ...)	\
// 	xlog_log_f(inst, XLOG_LEVEL_WARN, fmt, __VA_ARGS__)
// #define XLOG_ERROR(inst, fmt, ...)	\
// 	xlog_log_f(inst, XLOG_LEVEL_ERROR, fmt, __VA_ARGS__)
// #define XLOG_FATAL(inst, fmt, ...)	\
// 	xlog_log_f(inst, XLOG_LEVEL_FATAL, fmt, __VA_ARGS__)

static char *find_best_config()
{
	char path[MAX_PATH];
	char *filepart;
	GetModuleFileNameA(NULL, path, MAX_PATH);
	filepart = strrchr(path, '\\');
	if (filepart) {
		*filepart = 0;
		filepart++;
		if (strlen(filepart) > 4) {
			int i;
			struct {
				char *fmt;
				char *str1;
				char *str2;
			}defaultfilepath[] = {
				{"%s\\ini\\log\\%s.ini", path, filepart},
				{"%s\\etc\\log\\%s.ini", path, filepart},
				{"%s\\conf\\log\\%s.ini", path, filepart},
				{"%s\\log.ini", path, NULL},
				{"%s\\ini\\log.ini", path, filepart},
				{"%s\\etc\\log.ini", path, filepart},
				{"%s\\conf\\log.ini", path, filepart},
				{NULL, NULL, NULL},
			};
			filepart[strlen(filepart)-4] = 0;
			for (i = 0; defaultfilepath[i].fmt != NULL; ++i) {
				char tmp[MAX_PATH];
				sprintf(tmp, defaultfilepath[i].fmt, defaultfilepath[i].str1, defaultfilepath->str2);
				if (ExistsFileA(tmp))
					return _strdup(tmp);
			}
		}
	}
	return NULL;
}

static int contains_name(va_list arg, const char *name)
{
	char *p;
	while((p = va_arg(arg, char*)) != NULL) {
		if (_stricmp(name, p) == 0)
			return TRUE;
	}
	return 0;
}

TOOLKIT_API int xlog_version()
{
	return XLOG_VERSION;
}

TOOLKIT_API int xlog_init(const char *file)
{
	return xlog_init2(file, NULL);
}

TOOLKIT_API int xlog_init2(const char *file, const char *sections)
{
	logfactory_t *fac;
	array_header_t *arr_section = NULL;
	char *copysections = NULL;
	char *best_config_file = NULL;
	int rc = 0;

	if (toolkit_getResource()->g_initialized++) {
		return 0;
	}

	winsock_init();

	if (sections) {
		const char *delimers = ",| ";
		char *p;
		copysections = _strdup(sections);
		arr_section = array_make(3, sizeof(char*));
		p = strtok(copysections, delimers);
		while (p) {
			ARRAY_PUSH(arr_section, char*) = p;
			p = strtok(NULL, delimers);
		}
	}

	logmgr_create(&((logmgr_t *)(toolkit_getResource()->g_mgr)));
	singlefilefactory_create(&fac);
	logmgr_register_factory((logmgr_t *)(toolkit_getResource()->g_mgr), fac);
	periodicfilefactory_create(&fac);
	logmgr_register_factory((logmgr_t *)(toolkit_getResource()->g_mgr), fac);
	udplogfactory_create(&fac);
	logmgr_register_factory((logmgr_t *)(toolkit_getResource()->g_mgr), fac);
	udplogdaemonfactory_create(&fac);
	logmgr_register_factory((logmgr_t *)(toolkit_getResource()->g_mgr), fac);

	if (!file) {
		best_config_file = find_best_config();
	}

	if (best_config_file)
	{
		int i;
		array_header_t *arr_sec = inifile_read_section_all(best_config_file);
		if (arr_sec) {
			for (i = 0; i < arr_sec->nelts; ++i) {
				int found = 0;
				int kk;
				char *sec = ARRAY_IDX(arr_sec, i, char*);
				if (sections) {
					for (kk = 0; kk < arr_section->nelts; ++kk)
						if (_stricmp(sec, ARRAY_IDX(arr_section, kk, char*)) == 0)
							found = 1;
				}
				if (!sections || found) {
					array_header_t *arr_key = inifile_read_section_key_all(best_config_file, sec);
					if (arr_key) {
						char *type_tag = ARRAY_IDX(arr_key, 0, char*);
						if (type_tag && _stricmp(type_tag, "type") == 0) {
							char *type_value = inifile_read_str(best_config_file, sec, type_tag, "");
							if (type_value) {
								if (strlen(type_value) > 0) {
									logbase_t *log;
									rc = logmgr_create_log((logmgr_t *)(toolkit_getResource()->g_mgr), type_value, sec, &log);
									if (rc == 0) {
										int k;
										for (k = 1; k < arr_key->nelts; ++k) {
											char *key_tag = ARRAY_IDX(arr_key, k, char*);
											char *key_value = inifile_read_str(best_config_file, sec, key_tag, "");
											if (key_value) {
												logfactory_set_log_param(log->factory, log, key_tag, key_value);
												free(key_value);
											}
										}
										rc = logmgr_init_log((logmgr_t *)(toolkit_getResource()->g_mgr), log);
										if (rc != 0) {
											logmgr_destroy_log((logmgr_t *)(toolkit_getResource()->g_mgr), log);
										}
									}
								}
								free(type_value);
							}
						}
						array_free2(arr_key);
					}
				}
			}
			array_free2(arr_sec);
		}
	}

//on_error:

	if (copysections)
		free(copysections);
	if (arr_section)
		array_free(arr_section);
	if (rc < 0) {
		logmgr_destroy((logmgr_t *)(toolkit_getResource()->g_mgr));
		(logmgr_t *)(toolkit_getResource()->g_mgr) = NULL;
	}

	return rc;
}

TOOLKIT_API int xlog_add_logger(const char *name, const char *type, ...)
{
	logbase_t *log;
	int rc;
	
	if (!name || !strlen(name))
		return -1;
	if (!type || !strlen(type))
		return -1;

	rc = logmgr_create_log((logmgr_t *)(toolkit_getResource()->g_mgr), type, name, &log);
	if (rc == 0) {
		va_list arg;
		const char *key, *value;
		va_start(arg, type);
		key = va_arg(arg, const char*);
		while (key) {
			value = va_arg(arg, const char*);
			logfactory_set_log_param(log->factory, log, key, value);
			key = va_arg(arg, const char*);
		}
		va_end(arg);
		rc = logmgr_init_log((logmgr_t *)(toolkit_getResource()->g_mgr), log);
		if (rc != 0) {
			logmgr_destroy_log((logmgr_t *)(toolkit_getResource()->g_mgr), log);
		}
	}

	return rc;
}

TOOLKIT_API int xlog_remove_logger(const char *name)
{
	logbase_t *log;

	if (name) {
		log = logmgr_find_log((logmgr_t *)(toolkit_getResource()->g_mgr), name);
		if (log) {
			logmgr_term_log((logmgr_t *)(toolkit_getResource()->g_mgr), log);
			logmgr_destroy_log((logmgr_t *)(toolkit_getResource()->g_mgr), log);
			return 0;
		}
	}

	return -1;
}

TOOLKIT_API int xlog_term()
{
	toolkit_getResource()->g_initialized--;
	if (toolkit_getResource()->g_initialized) {
		return 0;
	}
	if ((logmgr_t *)(toolkit_getResource()->g_mgr)) {
		logmgr_destroy((logmgr_t *)(toolkit_getResource()->g_mgr));
		(toolkit_getResource()->g_mgr) = 0;
		winsock_term();
		return 0;
	}
	return -1;	
}

TOOLKIT_API int xlog_set_level(const char* inst, int level)
{
	if (!inst)
		return -1;

	if ((logmgr_t *)(toolkit_getResource()->g_mgr)) {
		logbase_t *log = logmgr_find_log((logmgr_t *)(toolkit_getResource()->g_mgr), inst);
		if (log) {
			log->level = level;
			return 0;
		}
	}

	return -1;
}

TOOLKIT_API int xlog_get_level(const char* inst, int *level)
{
	if (!inst)
		return -1;

	if ((logmgr_t *)(toolkit_getResource()->g_mgr)) {
		logbase_t *log = logmgr_find_log((logmgr_t *)(toolkit_getResource()->g_mgr), inst);
		if (log) {
			*level = log->level;
			return 0;
		}
	}

	return -1;
}

TOOLKIT_API int xlog_log(const char *inst, int level, const char *str)
{
	logbase_t *log;
	int n;

	if (!(logmgr_t *)(toolkit_getResource()->g_mgr))
		return -1;

	n = str ? strlen(str) : 0;

	if (n == 0)
		return 0;

	log = logmgr_find_log((logmgr_t *)(toolkit_getResource()->g_mgr), inst);
	if (log) {
		FILETIME ft;
		SYSTEMTIME st;
		GetSystemTime(&st);
		SystemTimeToFileTime(&st, &ft);
		logfactory_log_record(log->factory, log, level, ft.dwLowDateTime, ft.dwHighDateTime, str, n);
		return 0;
	}

	return -1;
}

TOOLKIT_API int xlog_log_f(const char *inst, int level, const char *fmt, ...)
{
	va_list arg;
	va_start(arg, fmt);
	return xlog_log_v(inst, level, fmt, arg);	
}

TOOLKIT_API int xlog_log_v(const char *inst, int level, const char *fmt, va_list arg)
{
	int n;
	logbase_t *log;

	if (!(logmgr_t *)(toolkit_getResource()->g_mgr))
		return -1;

	log = logmgr_find_log((logmgr_t *)(toolkit_getResource()->g_mgr), inst);
	if (!log)
		return -1;

	if (level < log->level)
		return 0;

	n = _vscprintf(fmt, arg);//因为添加了Debug {}， 所以可能超过了1024长度
	if (n >= 0 && n < 1050) {
		FILETIME ft;
		SYSTEMTIME st;
		char *buf = _alloca(n+1);
		vsprintf(buf, fmt, arg);
		GetSystemTime(&st);
		SystemTimeToFileTime(&st, &ft);
		logfactory_log_record(log->factory, log, level, ft.dwLowDateTime, ft.dwHighDateTime, buf, n);
		return 0;
	}
	return -1;
}

TOOLKIT_API logbase_t *xlog_find_log(const char *inst)
{
	return logmgr_find_log((logmgr_t *)(toolkit_getResource()->g_mgr), inst);
}