myvtm/Other/liblog4rvcother/log4upload.cpp

#include "log4upload.h"
#include "log4rvcother.h"
#include "SpDefine.h"
#include <algorithm>
#include <string>
#include <cctype>

#if defined(_MSC_VER)
#include <Windows.h>
#define LOG_SDKNAME "RvcLogSdk.dll"

static void log4vendor__format_fallback_error(log4vendor_lib_t* lib, int errorno) 
{
	static const CHAR fallback_error[] = "error: %1!d!";
	DWORD_PTR args[1];
	args[0] = (DWORD_PTR)errorno;

	FormatMessageA(FORMAT_MESSAGE_FROM_STRING |
		FORMAT_MESSAGE_ARGUMENT_ARRAY |
		FORMAT_MESSAGE_ALLOCATE_BUFFER,
		fallback_error, 0, 0,
		(LPSTR)&lib->errmsg,
		0, (va_list*)args);
}

int log4vendor__dlerror(log4vendor_lib_t* lib, const char* filename, DWORD errorno)
{
		DWORD_PTR arg;
	DWORD res;
	char* msg;

	if (lib->errmsg) {
		LocalFree(lib->errmsg);
		lib->errmsg = NULL;
	}

	if (errorno == 0)
		return 0;

	res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
		FORMAT_MESSAGE_FROM_SYSTEM |
		FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
		MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
		(LPSTR)&lib->errmsg, 0, NULL);

	if (!res && (GetLastError() == ERROR_MUI_FILE_NOT_FOUND ||
		GetLastError() == ERROR_RESOURCE_TYPE_NOT_FOUND)) {
		res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_FROM_SYSTEM |
			FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorno,
			0, (LPSTR)&lib->errmsg, 0, NULL);
	}

	if (res && errorno == ERROR_BAD_EXE_FORMAT && strstr(lib->errmsg, "%1")) {
		msg = lib->errmsg;
		lib->errmsg = NULL;
		arg = (DWORD_PTR)filename;
		res = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_ARGUMENT_ARRAY |
			FORMAT_MESSAGE_FROM_STRING,
			msg,
			0, 0, (LPSTR)&lib->errmsg, 0, (va_list*)&arg);
		LocalFree(msg);
	}

	if (!res)
		log4vendor__format_fallback_error(lib, errorno);

	return -1;
}

int log4vendor_dlopen(const char* filename, log4vendor_lib_t* lib)
{
	WCHAR filename_w[1024];

	lib->handle = NULL;
	lib->errmsg = NULL;

	if (!MultiByteToWideChar(CP_UTF8,
		0,
		filename,
		-1,
		filename_w,
		(sizeof(filename_w)/sizeof((filename_w)[0])))) {
		return log4vendor__dlerror(lib, filename, GetLastError());
	}

	lib->handle = LoadLibraryExW(filename_w, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
	if (lib->handle == NULL) {
		return log4vendor__dlerror(lib, filename, GetLastError());
	}

	return 0;
}

void log4vendor_dlclose(log4vendor_lib_t* lib)
{
	if (lib->errmsg) {
		LocalFree((void*)lib->errmsg);
		lib->errmsg = NULL;
	}

	if (lib->handle) {
		/* Ignore errors. No good way to signal them without leaking memory. */
		FreeLibrary(lib->handle);
		lib->handle = NULL;
	}
}

int log4vendor_dlsym(log4vendor_lib_t* lib, const char* name, void** ptr)
{
	*ptr = (void*)(uintptr_t)GetProcAddress(lib->handle, name);
	return log4vendor__dlerror(lib, "", *ptr ? 0 : GetLastError());
}

#else
#include <dlfcn.h>
#include <errno.h>
#include <string.h>
#include <locale.h>


#define LOG_SDKNAME "libRVCLogSDK.so"

int log4vendor__dlerror(log4vendor_lib_t* lib)
{
    const char* errmsg;
    free(lib->errmsg);
    errmsg = dlerror();
    if (errmsg) {
        lib->errmsg = strdup(errmsg);
        return -1;
    } else {
        lib->errmsg = NULL;
        return 0;
    }
}

int log4vendor_dlopen(const char* filename, log4vendor_lib_t* lib)
{
    dlerror(); /* Reset error status. */
    lib->errmsg = NULL;
    lib->handle = dlopen(filename, RTLD_LAZY);
    return lib->handle ? 0 : log4vendor__dlerror(lib);
}

void log4vendor_dlclose(log4vendor_lib_t* lib)
{
    if (lib->errmsg) {
        free(lib->errmsg);
        lib->errmsg = NULL;
    }
    if (lib->handle) {
        /* Ignore errors. No good way to signal them without leaking memory. */
        dlclose(lib->handle);
        lib->handle = NULL;
    }
}

int log4vendor_dlsym(log4vendor_lib_t* lib, const char* name, void** ptr)
{
    dlerror(); /* Reset error status. */
    *ptr = dlsym(lib->handle, name);
    return log4vendor__dlerror(lib);
}


#endif //_MSC_VER

const char* log4vendor_dlerror(const log4vendor_lib_t* lib)
{
    return lib->errmsg ? lib->errmsg : "no error";
}

std::string to_lower(std::string str)
{
    std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) {
        return static_cast<char>(std::tolower(c));
                   });
    return str;
}

bool upload_helper::initialize(const cmb::log_init_config& cfg)
{
    if (is_initialized()) return false;

    bool res = (0 == load_logsdk());
    if (res) {
        log_producer_config* config = pinst_create_log_producer_config();
        pinst_log_producer_config_set_packet_log_bytes(config, 4 * 1024 * 1024);
        pinst_log_producer_config_set_packet_log_count(config, 24);//最大发送条数
        pinst_log_producer_config_set_max_buffer_limit(config, 64 * 1024 * 1024);
        //set send thread count
        pinst_log_producer_config_set_send_thread_count(config, 1);
        pinst_log_producer_config_set_persistent_max_log_count(config, 50 * 1000);
        pinst_log_producer_config_set_skyeye_servname(config, (char*)"Terminal");
        pinst_log_producer_config_set_skyeye_cmptId(config, (char*)SpDefine::cmptId);
        pinst_log_producer_config_set_skyeye_cmptname(config, (char*)SpDefine::CmptName);
        pinst_log_producer_config_set_skyeye_version(config, (char*)"1.0");
        pinst_log_producer_config_set_persistent(config, 1);

        //本地日志开关
        //pinst_log_producer_config_switch_debug_mode(config, 1);

        char value[128] = { '\0' };
        strcpy(value, to_lower(cfg.dev_name).c_str());
        pinst_log_producer_config_set_skyeye_entityname(config, value);

        memset(value, '\0', sizeof(value));
        strcpy(value, "0");
        pinst_log_producer_config_set_skyeye_item(config, value);
#if defined(_MSC_VER)
		pinst_log_producer_config_set_persistent_file_path(config, "C:\\rvc\\terminaldbstorage");
#else
		pinst_log_producer_config_set_persistent_file_path(config, "/opt/rvc/terminaldbstorage");
#endif

        //新加统一日志配置
        pinst_log_producer_config_set_united_appname(config, (char*)SpDefine::cmptId);
        pinst_log_producer_config_set_united_version(config, (char*)"2.0");
        pinst_log_producer_config_set_united_needArchived(config, 0);
        pinst_log_producer_config_set_united_deployUnitId(config, (char*)SpDefine::deployUnitId);
        pinst_log_producer_config_set_united_serviceUnitId(config, (char*)SpDefine::serviceUnitId);

        _client = pinst_create_log_producer_client(config, NULL, NULL);
        res = (_client != nullptr);

        if (!res) {
            unload_logsdk();
        }
    }

    _initialized = res;

    return res;
}

int upload_helper::load_logsdk()
{
    LOG4VTM(DEBUG, "pre load sdk...");
    int res = log4vendor_dlopen(LOG_SDKNAME, &m_lib);
    if (res != 0) {
        LOG4VTM(ERROR, ("log4vendor_dlopen failed with error") << LOG_SDKNAME << log4vendor_dlerror(&m_lib));
        return res;
    }
    do {
        res = -1;

        if (log4vendor_dlsym(&m_lib, "create_log_producer_config", (void**)&pinst_create_log_producer_config) != 0 || pinst_create_log_producer_config == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_packet_log_bytes", (void**)&pinst_log_producer_config_set_packet_log_bytes) != 0 || pinst_log_producer_config_set_packet_log_bytes == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_packet_log_count", (void**)&pinst_log_producer_config_set_packet_log_count) != 0 || pinst_log_producer_config_set_packet_log_count == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_max_buffer_limit", (void**)&pinst_log_producer_config_set_max_buffer_limit) != 0 || pinst_log_producer_config_set_max_buffer_limit == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_send_thread_count", (void**)&pinst_log_producer_config_set_send_thread_count) != 0 || pinst_log_producer_config_set_send_thread_count == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_persistent_max_log_count", (void**)&pinst_log_producer_config_set_persistent_max_log_count) != 0 || pinst_log_producer_config_set_persistent_max_log_count == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_skyeye_servname", (void**)&pinst_log_producer_config_set_skyeye_servname) != 0 || pinst_log_producer_config_set_skyeye_servname == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_skyeye_cmptId", (void**)&pinst_log_producer_config_set_skyeye_cmptId) != 0 || pinst_log_producer_config_set_skyeye_cmptId == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_skyeye_cmptname", (void**)&pinst_log_producer_config_set_skyeye_cmptname) != 0 || pinst_log_producer_config_set_skyeye_cmptname == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_skyeye_version", (void**)&pinst_log_producer_config_set_skyeye_version) != 0 || pinst_log_producer_config_set_skyeye_version == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_persistent", (void**)&pinst_log_producer_config_set_persistent) != 0 || pinst_log_producer_config_set_persistent == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_skyeye_entityname", (void**)&pinst_log_producer_config_set_skyeye_entityname) != 0 || pinst_log_producer_config_set_skyeye_entityname == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_skyeye_item", (void**)&pinst_log_producer_config_set_skyeye_item) != 0 || pinst_log_producer_config_set_skyeye_item == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_persistent_file_path", (void**)&pinst_log_producer_config_set_persistent_file_path) != 0 || pinst_log_producer_config_set_persistent_file_path == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_united_appname", (void**)&pinst_log_producer_config_set_united_appname) != 0 || pinst_log_producer_config_set_united_appname == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_united_version", (void**)&pinst_log_producer_config_set_united_version) != 0 || pinst_log_producer_config_set_united_version == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_united_needArchived", (void**)&pinst_log_producer_config_set_united_needArchived) != 0 || pinst_log_producer_config_set_united_needArchived == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_united_deployUnitId", (void**)&pinst_log_producer_config_set_united_deployUnitId) != 0 || pinst_log_producer_config_set_united_deployUnitId == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_set_united_serviceUnitId", (void**)&pinst_log_producer_config_set_united_serviceUnitId) != 0 || pinst_log_producer_config_set_united_serviceUnitId == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "create_log_producer_client", (void**)&pinst_create_log_producer_client) != 0 || pinst_create_log_producer_client == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_client_add_log", (void**)&pinst_log_producer_client_add_log) != 0 || pinst_log_producer_client_add_log == nullptr) break;
        if (log4vendor_dlsym(&m_lib, "log_producer_config_switch_debug_mode", (void**)&pinst_log_producer_config_switch_debug_mode) != 0 || pinst_log_producer_config_switch_debug_mode == nullptr) break;

        res = 0;
    } while (false);

    if (0 != res) {
        LOG4VTM(ERROR, ("get funcs' address failed with error ") << log4vendor_dlerror(&m_lib));
        log4vendor_dlclose(&m_lib);
    } else {
        LOG4VTM(DEBUG, "load_logsdk succ");
    }
    return res;
}

int upload_helper::unload_logsdk()
{
    log4vendor_dlclose(&m_lib);
    return 0;
}