init

.clang-format

+---
+Language: Cpp
+# BasedOnStyle:	LLVM
+SortIncludes: false
+AccessModifierOffset: -2
+AlignAfterOpenBracket: DontAlign
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+DerivePointerAlignment: false
+PointerAlignment: Left
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+AlwaysBreakBeforeMultilineStrings: false
+BreakBeforeBinaryOperators: None
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: true
+ColumnLimit: 120
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+DerivePointerBinding: true
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 200
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+PointerBindsToType: true
+Cpp11BracedListStyle: true
+Standard:        Auto
+IndentWidth:     2
+TabWidth:        4
+UseTab:          Never
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   true
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+IndentFunctionDeclarationAfterType: true
+SpacesInParentheses: false
+SpacesInAngles: false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpaceAfterControlStatementKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpacesBeforeTrailingComments: 2
+ContinuationIndentWidth: 4
+CommentPragmas:  '^lint'
+MacroBlockBegin: "
+
+END_CATCH_ERROR$"
+...

.gitignore

+*.iml
+*.swp
+.idea
+
+.DS_Store
+
+bin
+target
+
+./log
+
+cmake-build-debug/
+buildenv/
+build/
+
+*.pb.*
\ No newline at end of file

CMakeLists.txt

+cmake_minimum_required(VERSION 3.2)
+project(oblogproxy CXX)
+
+option(WITH_DEBUG "With debug symbols" ON)
+option(WITH_ASAN "Compile with AddressSanitizer" OFF)
+option(WITH_TEST "With Tests" OFF)
+option(WITH_DEMO "With Demos" OFF)
+option(WITH_JNI_LIB "With oblogreader jni lib" OFF)
+option(WITH_GLOG "With google log" ON)
+option(USE_OBLOGMSG "Use pre-compiled oblogmsg library" OFF)
+option(USE_LIBOBLOG "Use pre-compiled liboblog library" ON)
+option(USE_CXX11_ABI "Build with C++11 ABI" OFF)
+
+SET(OMS_PROJECT_SRC_PATH ${CMAKE_CURRENT_SOURCE_DIR})
+SET(OMS_PROJECT_BUILD_PATH ${CMAKE_CURRENT_BINARY_DIR})
+SET(EXECUTABLE_OUTPUT_PATH ${OMS_PROJECT_BUILD_PATH})
+SET(LIBRARY_OUTPUT_PATH ${OMS_PROJECT_BUILD_PATH})
+
+SET(DEP_VAR $ENV{DEP_VAR})
+message(STATUS "DEP_VAR: ${DEP_VAR}")
+SET(JAVA_HOME $ENV{JAVA_HOME})
+message(STATUS "JAVA_HOME: ${JAVA_HOME}")
+
+# compiler
+find_program(CC NAMES gcc PATHS ${DEP_VAR}/usr/local/gcc-5.2.0/bin/ /usr/bin/ NO_DEFAULT_PATH)
+find_program(CXX NAMES g++ PATHS ${DEP_VAR}/usr/local/gcc-5.2.0/bin/ /usr/bin/ NO_DEFAULT_PATH)
+find_program(AR NAMES gcc-ar ar PATHS ${DEP_VAR}/usr/local/gcc-5.2.0/bin/ /usr/bin/ NO_DEFAULT_PATH)
+SET(CMAKE_C_COMPILER ${CC})
+SET(CMAKE_CXX_COMPILER ${CXX})
+SET(CMAKE_C_COMPILER_AR ${AR})
+SET(CMAKE_CXX_COMPILER_AR ${AR})
+message(STATUS "C compiler: ${CMAKE_C_COMPILER}")
+message(STATUS "C++ compiler: ${CMAKE_CXX_COMPILER}")
+message(STATUS "AR compiler: ${CMAKE_C_COMPILER_AR}")
+
+if (NOT USE_CXX11_ABI)
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_GLIBCXX_USE_CXX11_ABI=0")
+endif ()
+
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+SET(THIRD_PARTY_PATH ${CMAKE_CURRENT_BINARY_DIR}/third-party)
+SET(THIRD_PARTY_BUILD_TYPE Release)
+SET(EXTERNAL_PROJECT_LOG_ARGS
+        LOG_DOWNLOAD 0
+        LOG_UPDATE 0
+        LOG_CONFIGURE 0
+        LOG_BUILD 0
+        LOG_TEST 0
+        LOG_INSTALL 0)
+
+INCLUDE(ProcessorCount)
+ProcessorCount(NUM_OF_PROCESSOR)
+message(NUM_OF_PROCESSOR: ${NUM_OF_PROCESSOR})
+
+#thread
+include(FindThreads)
+
+#openssl
+find_package(OpenSSL REQUIRED)
+
+message(STATUS "ssl:" ${OPENSSL_SSL_LIBRARY})
+message(STATUS "crypto:" ${OPENSSL_CRYPTO_LIBRARY})
+
+ADD_LIBRARY(ssl SHARED IMPORTED GLOBAL)
+SET_PROPERTY(TARGET ssl PROPERTY IMPORTED_LOCATION ${OPENSSL_SSL_LIBRARY})
+
+ADD_LIBRARY(crypto SHARED IMPORTED GLOBAL)
+SET_PROPERTY(TARGET crypto PROPERTY IMPORTED_LOCATION ${OPENSSL_CRYPTO_LIBRARY})
+
+if (WITH_JNI_LIB)
+    SET(JAVA_INCLUDE_DIR ${JAVA_HOME}/include ${JAVA_HOME}/include/linux ${JAVA_HOME}/include/darwin)
+    SET(JAVA_LIB_DIR ${JAVA_HOME}/jre/lib)
+else ()
+    SET(JAVA_INCLUDE_DIR "")
+    SET(JAVA_LIB_DIR "")
+endif ()
+
+include(lz4)
+include(jsoncpp)
+include(libevent)
+
+if (WITH_GLOG)
+    include(gflags)
+    include(glog)
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DWITH_GLOG=1")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DWITH_GLOG=1")
+else ()
+    SET(GFLAGS_INCLUDE_DIR "")
+    SET(GLOG_INCLUDE_DIR "")
+    SET(GFLAGS_LIBRARIES "")
+    SET(GLOG_LIBRARIES "")
+endif ()
+
+if (WITH_TEST)
+    include(gtest)
+else ()
+    SET(GTEST_INCLUDE_DIR "")
+    SET(GTEST_LIBRARIES "")
+endif ()
+
+#protobuf
+include(protobuf)
+
+file(GLOB PROTO_FILES ${CMAKE_SOURCE_DIR}/proto/*.proto)
+message("protoc: ${PROTOBUF_PROTOC_EXECUTABLE}, proto inc: ${PROTOBUF_INCLUDE_DIRS}, lib: ${PROTOBUF_LIBRARIES}, ${PROTOBUF_PROTOC_LIBRARY}, protos: ${PROTO_FILES}")
+file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/proto)
+foreach (PROTO ${PROTO_FILES})
+    message(proto : ${PROTO})
+    get_filename_component(PROTO_WE ${PROTO} NAME_WE)
+    list(APPEND PROTO_HDRS "${CMAKE_CURRENT_BINARY_DIR}/proto/${PROTO_WE}.pb.h")
+    list(APPEND PROTO_SRCS "${CMAKE_CURRENT_BINARY_DIR}/proto/${PROTO_WE}.pb.cc")
+    add_custom_command(
+            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/proto/${PROTO_WE}.pb.h ${CMAKE_CURRENT_BINARY_DIR}/proto/${PROTO_WE}.pb.cc
+            COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
+            --cpp_out=${CMAKE_CURRENT_BINARY_DIR}/proto
+            --proto_path=${PROTOBUF_INCLUDE_DIR}
+            --proto_path=${CMAKE_SOURCE_DIR}/proto ${PROTO}
+            DEPENDS protobuf
+    )
+endforeach ()
+add_library(PROTO_OBJS OBJECT ${PROTO_SRCS} ${PROTO_HDRS})
+message("protoc: ${PROTOBUF_PROTOC_EXECUTABLE}, proto srcs : ${PROTO_SRCS}")
+
+# oblogmsg
+if (USE_OBLOGMSG)
+    find_path(OBLOGMSG_INCLUDE_DIR NAMES LogRecord.h)
+    find_library(OBLOGMSG_LIBRARIES NAMES liboblogmsg.so)
+    if ((NOT OBLOGMSG_INCLUDE_DIR) OR (NOT OBLOGMSG_LIBRARIES))
+        message(FATAL_ERROR "Fail to find oblogmsg")
+    endif ()
+    ADD_LIBRARY(oblogmsg SHARED IMPORTED GLOBAL)
+else ()
+    include(oblogmsg)
+    SET(OBLOGMSG_MAPPING "")
+endif ()
+
+# obliboblog
+if (USE_LIBOBLOG)
+    find_path(LIBOBLOG_INCLUDE_PATH NAMES liboblog.h)
+    find_library(LIBOBLOG_LIBRARIES NAMES liboblog.so)
+    if ((NOT LIBOBLOG_INCLUDE_PATH) OR (NOT LIBOBLOG_LIBRARIES))
+        message(FATAL_ERROR "Fail to find liboblog")
+    endif ()
+    GET_FILENAME_COMPONENT(LIBOBLOG_LIB_DIR ${LIBOBLOG_LIBRARIES} DIRECTORY)
+else ()
+    SET(LIBOBLOG_INCLUDE_PATH "")
+    SET(LIBOBLOG_LIB_DIR "")
+endif ()
+
+message("oblogmsg: ${OBLOGMSG_INCLUDE_DIR}, ${OBLOGMSG_LIBRARIES}")
+message("liboblog: ${LIBOBLOG_INCLUDE_PATH}, ${LIBOBLOG_LIB_DIR}")
+
+execute_process(
+        COMMAND git log -1 --format=%H
+        OUTPUT_VARIABLE GIT_VERSION
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+)
+
+if (WITH_DEBUG)
+    SET(DEBUG_SYMBOL "-ggdb")
+else ()
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNDEBUG")
+    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNDEBUG")
+endif ()
+
+if (WITH_ASAN)
+    SET(ASAN_COMPILE_OPTION "-fsanitize=address -fno-omit-frame-pointer")
+    SET(ASAN_LINK_OPTION "-fsanitize=address")
+endif ()
+
+SET(CMAKE_CXX_STANDARD 11)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -static-libstdc++ ${DEBUG_SYMBOL} -pipe -m64 -Wall -fPIC -Wno-reorder ${ASAN_COMPILE_OPTION} -D__OMS_VERSION__=\\\"${GIT_VERSION}\\\" ${OBLOGMSG_MAPPING}")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 ${DEBUG_SYMBOL} -pipe -m64 -Wall -fPIC ${ASAN_COMPILE_OPTION} -D__STDC_LIMIT_MACROS -D__OMS_VERSION__=\\\"${GIT_VERSION}\\\" ${OBLOGMSG_MAPPING}")
+
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    SET(PLATFORM_SPEC rt)
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc")
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    SET(PLATFORM_SPEC ${DEP_LIB}
+            "-framework CoreFoundation"
+            "-framework CoreGraphics"
+            "-framework CoreData"
+            "-framework CoreText"
+            "-framework Security"
+            "-framework Foundation"
+            "-Wl,-U,_MallocExtension_ReleaseFreeMemory"
+            "-Wl,-U,_ProfilerStart"
+            "-Wl,-U,_ProfilerStop")
+endif ()
+
+########### start define deps #############################################################################################
+set(DEP_INC
+        ${JAVA_INCLUDE_DIR}
+        ${OBLOGMSG_INCLUDE_DIR}
+        ${LZ4_INCLUDE_DIR}
+        ${JSONCPP_INCLUDE_DIR}
+        ${LIBEVENT_INCLUDE_DIR}
+        ${GFLAGS_INCLUDE_DIR}
+        ${GLOG_INCLUDE_DIR}
+        ${PROTOBUF_INCLUDE_DIR}
+        ${GTEST_INCLUDE_DIR}
+        ${OPENSSL_INCLUDE_DIR}
+        )
+set(DEP_LIB_PATH
+        ${JAVA_LIB_DIR}
+        ${OBLOGMSG_LIB_DIR}
+        ${LIBOBLOG_LIB_DIR}
+        ${CMAKE_CURRENT_BINARY_DIR}
+        )
+set(DEP_LIBS
+        ${OBLOGMSG_LIBRARIES}
+        ${GTEST_LIBRARIES}
+        ${GLOG_LIBRARIES}
+        ${GFLAGS_LIBRARIES}
+        ${PROTOBUF_LIBRARIES}
+        ${PROTOBUF_PROTOC_LIBRARY}
+        ${LIBEVENT_LIBRARIES}
+        ${JSONCPP_LIBRARIES}
+        ${LZ4_LIBRARIES}
+        ${OPENSSL_LIBRARIES}
+        m
+        ${PLATFORM_SPEC}
+        ${CMAKE_THREAD_LIBS_INIT}
+        )
+message("DEP_INC: ${DEP_INC}")
+message("DEP_LIBS: ${DEP_LIBS}")
+########### end define deps ###############################################################################################
+
+# common
+set(COMMON_INC
+        ${DEP_INC}
+        ${CMAKE_CURRENT_BINARY_DIR}/proto
+        ./src
+        ./src/common/
+        )
+file(GLOB COMMON_SRC
+        ./src/common/*.cpp
+        ./src/common/*.hpp
+        ./src/codec/*.cpp
+        ./src/communication/*.cpp
+        ./src/obaccess/*.cpp
+        )
+add_library(common STATIC ${COMMON_SRC} $<TARGET_OBJECTS:PROTO_OBJS>)
+add_dependencies(common oblogmsg lz4 jsoncpp libevent protobuf)
+if (WITH_GLOG)
+    add_dependencies(common glog)
+endif ()
+target_include_directories(common PUBLIC ${COMMON_INC})
+
+# oblogreader
+set(OBLOGREADER_INC ${COMMON_INC} ./src/oblogreader/ ${LIBOBLOG_INCLUDE_PATH})
+file(GLOB OBLOGREADER_SRC ./src/oblogreader/*.cpp)
+add_library(oblogreader_static STATIC ${OBLOGREADER_SRC})
+add_dependencies(oblogreader_static common oblogmsg)
+set_target_properties(oblogreader_static PROPERTIES OUTPUT_NAME "oblogreader")
+target_include_directories(oblogreader_static PUBLIC ${OBLOGREADER_INC})
+target_link_directories(oblogreader_static PUBLIC ${DEP_LIB_PATH})
+target_link_libraries(oblogreader_static libcommon.a oblog ${DEP_LIBS})
+
+# oblogreader_jni
+if (WITH_JNI_LIB)
+    set(OBLOGREADER_JNI_INC ${OBLOGREADER_INC} src/jni)
+    file(GLOB OBLOGREADER_JNI_SRC src/jni/*.cpp)
+    add_library(oblogreader_jni STATIC ${OBLOGREADER_JNI_SRC})
+    add_dependencies(oblogreader_jni oblogreader_static)
+    target_include_directories(oblogreader_jni PUBLIC ${OBLOGREADER_JNI_INC})
+    target_link_directories(oblogreader_jni PUBLIC ${DEP_LIB_PATH})
+    target_link_libraries(oblogreader_jni liboblogreader.a libcommon.a oblog ${DEP_LIBS})
+endif ()
+
+# logproxy static
+set(LOGPROXY_INC ${OBLOGREADER_INC} src/arranger/)
+file(GLOB LOGPROXY_SRC ./src/arranger/*.cpp)
+message("SRC: ${LOGPROXY_SRC}")
+add_library(logproxy_static STATIC ${LOGPROXY_SRC})
+add_dependencies(logproxy_static oblogreader_static oblogmsg)
+set_target_properties(logproxy_static PROPERTIES OUTPUT_NAME "logproxy")
+target_include_directories(logproxy_static PUBLIC ${LOGPROXY_INC})
+target_link_directories(logproxy_static PUBLIC ${DEP_LIB_PATH})
+target_link_libraries(logproxy_static liboblogreader.a libcommon.a oblog ${DEP_LIBS})
+
+SET(BASE_LIBS liblogproxy.a liboblogreader.a libcommon.a)
+
+# logproxy
+add_executable(logproxy ./src/entry.cpp)
+add_dependencies(logproxy logproxy_static)
+target_include_directories(logproxy PUBLIC ${DEP_INC} ${LOGPROXY_INC})
+target_link_directories(logproxy PUBLIC ${DEP_LIB_PATH})
+target_link_libraries(logproxy ${BASE_LIBS} oblog ${DEP_LIBS})
+target_link_options(logproxy PUBLIC "${ASAN_LINK_OPTION}")
+
+if (WITH_DEMO)
+    # demo client
+    file(GLOB DEMO_CLIENT_SRC ./src/demo/client_demo.cpp)
+    add_executable(demo_client ${DEMO_CLIENT_SRC})
+    add_dependencies(demo_client common)
+    target_include_directories(demo_client PUBLIC ${COMMON_INC})
+    target_link_directories(demo_client PUBLIC ${DEP_LIB_PATH})
+    target_link_libraries(demo_client libcommon.a ${DEP_LIBS})
+    target_link_libraries(demo_client libcommon.a ${DEP_LIBS})
+    target_link_options(demo_client PUBLIC ${ASAN_LINK_OPTION})
+endif ()
+
+if (WITH_TEST)
+    # test_base
+    file(GLOB TEST_BASE_SRC ./src/test/test_entry.cpp)
+    add_executable(test_base ${TEST_BASE_SRC})
+    add_dependencies(test_base logproxy_static gtest)
+    target_include_directories(test_base PUBLIC ${LOGPROXY_INC})
+    target_link_directories(test_base PUBLIC ${DEP_LIB_PATH})
+    target_link_libraries(test_base ${BASE_LIBS} ${DEP_LIBS})
+    target_link_options(test_base PUBLIC ${ASAN_LINK_OPTION})
+
+    # test_oblogreader
+    file(GLOB TEST_OBLOGREADER_SRC ./src/test/test_oblogreader.cpp)
+    add_executable(test_oblogreader ${TEST_OBLOGREADER_SRC})
+    add_dependencies(test_oblogreader logproxy_static gtest)
+    target_include_directories(test_oblogreader PUBLIC ${LOGPROXY_INC})
+    target_link_directories(test_oblogreader PUBLIC ${DEP_LIB_PATH})
+    target_link_libraries(test_oblogreader ${BASE_LIBS} oblog ${DEP_LIBS})
+    target_link_options(test_oblogreader PUBLIC ${ASAN_LINK_OPTION})
+endif ()

LEGAL.md

+Legal Disclaimer
+
+Within this source code, the comments in Chinese shall be the original, governing version. Any comment in other languages are for reference only. In the event of any conflict between the Chinese language version comments and other language version comments, the Chinese language version shall prevail.
+
+法律免责声明
+
+关于代码注释部分，中文注释为官方版本，其它语言注释仅做参考。中文注释可能与其它语言注释存在不一致，当中文注释与其它语言注释存在不一致时，请以中文注释为准。
\ No newline at end of file

LICENSE

+木兰公共许可证, 第2版
+木兰公共许可证， 第2版
+
+2021年5月 http://license.coscl.org.cn/MulanPubL-2.0
+
+您对“贡献”的复制、使用、修改及分发受木兰公共许可证,第2版（以下简称“本许可证”）的如下条款的约束：
+
+0.   定义
+
+“贡献” 是指由“贡献者”许可在“本许可证”下的受版权法保护的作品，包括最初“贡献者”许可在“本许可证”下的作品及后续“贡献者”许可在“本许可证”下的“衍生作品”。
+
+“贡献者” 是指将受版权法保护的作品许可在“本许可证”下的自然人或“法人实体”。
+
+“法人实体” 是指提交贡献的机构及其“关联实体”。
+
+“关联实体” 是指，对“本许可证”下的行为方而言，控制、受控制或与其共同受控制的机构，此处的“控制”是指拥有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。
+
+“衍生作品” 是指基于“贡献”创作的作品，具体包括对全部或部分“贡献”进行修改、重写、翻译、注释、组合或与之链接（包括动态链接或静态链接）而形成的作品。仅与“贡献”进行进程间通信或系统调用的作品是独立作品，不属于“衍生作品”。
+
+“对应源代码” 是指生成、安装和(对于可执行作品)运行目标代码所需的所有源文件和与之关联的接口定义文件，以及控制这些活动的脚本，但不包括编译环境、编译工具、云服务平台（如果有）。
+
+“分发” 是指通过任何媒介向他人提供“贡献”或“衍生作品”的行为，以及利用“贡献”或“衍生作品”通过网络远程给用户提供服务的行为，例如：通过利用“贡献”或“衍生作品”搭建的云服务平台提供在线服务的行为。
+
+1.   授予版权许可
+
+每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、“分发”其“贡献”或“衍生作品”，不论修改与否。
+
+2.   授予专利许可
+
+每个“贡献者”根据“本许可证”授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销的情形除外）专利许可，供您使用、制造、委托制造、销售、许诺销售、进口其“贡献”或以其他方式转移其“贡献”。前述专利许可仅限于“贡献者”现在或将来拥有或控制的其“贡献”中的专利权利要求，而不包括仅因您对“贡献”的修改而将必然会侵犯到的专利权利要求。如果您或您的“关联实体”直接或间接地，就“贡献”对任何人发起专利侵权诉讼（包括在诉讼中提出反诉请求或交叉请求）或发起其他专利维权行动，则“贡献者”根据“本许可证”授予您的专利许可自您发起专利诉讼或专利维权行动之日终止。
+
+3.   无商标许可
+
+“贡献者”在“本许可证”下不提供对其商品名称、商标、服务标识或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用的情形除外。
+
+4.   分发限制
+
+您可以将您接收到的“贡献”或您的“衍生作品”以源程序形式或可执行形式重新“分发”，但必须满足下列条件：
+
+（1）您必须向接收者提供“本许可证”的副本，并保留“贡献”中的版权、商标、专利及免责声明；并且，
+
+（2）如果您“分发”您接收到的“贡献”，您必须使用“本许可证”提供该“贡献”的源代码副本；如果您 “分发”您的“衍生作品”，您必须：
+
+（i）随“衍生作品”提供使用“本许可证”“分发”的您的“衍生作品”的“对应源代码”。如果您通过下载链接提供前述“对应源代码”，则您应将下载链接地址置于“衍生作品”或其随附文档中的明显位置，有效期自该“衍生作品”“分发”之日起不少于三年，并确保接收者可以获得“对应源代码”；或者，
+
+（ii）随“衍生作品”向接收者提供一个书面要约，表明您愿意提供根据“本许可证”“分发”的您“衍生作品”的“对应源代码”。该书面要约应置于“衍生作品”中的明显位置，并确保接收者根据书面要约可获取“对应源代码”的时间从您接到该请求之日起不得超过三个月，且有效期自该“衍生作品”“分发”之日起不少于三年。
+
+5.   违约与终止
+
+如果您违反“本许可证”，任何“贡献者”有权书面通知您终止其根据“本许可证”授予您的许可。该“贡献者”授予您的许可自您接到其终止通知之日起终止。仅在如下两种情形下，即使您收到“贡献者”的通知也并不终止其授予您的许可：
+
+（1）您在接到该终止通知之前已停止所有违反行为；
+
+（2）您是首次收到该“贡献者”根据“本许可证”发出的书面终止通知，并且您在收到该通知后30天内已停止所有违反行为。
+
+只要您下游的接收者遵守“本许可证”的相关规定，即使您在“本许可证”下被授予的许可终止，不影响下游的接收者根据“本许可证”享有的权利。
+
+6.   例外
+
+如果您将“贡献”与采用GNU AFFERO GENERAL PUBLIC LICENSE Version 3（以下简称“AGPLv3”）或其后续版本的作品结合形成新的“衍生作品”，且根据“AGPLv3”或其后续版本的要求您有义务将新形成的“衍生作品”以“AGPLv3”或其后续版本进行许可的，您可以根据“AGPLv3”或其后续版本进行许可，只要您在“分发”该“衍生作品”的同时向接收者提供“本许可证”的副本，并保留“贡献”中的版权、商标、专利及免责声明。但任何“贡献者”不会因您选择“AGPLv3”或其后续版本而授予该“衍生作品”的接收者更多权利。
+
+7.   免责声明与责任限制
+
+“贡献”在提供时不带有任何明示或默示的担保。在任何情况下，“贡献者”或版权人不对任何人因使用“贡献”而引发的任何直接或间接损失承担任何责任，不论该等损失因何种原因导致或者基于何种法律理论,即使其曾被告知有该等损失的可能性。
+
+8.   语言
+
+“本许可证”以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何不一致，以中文版为准。
+
+条款结束
+
+如何将木兰公共许可证，第2版，应用到您的软件
+
+如果您希望将木兰公共许可证，第2版，应用到您的软件，为了方便接收者查阅，建议您完成如下三步：
+
+1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；
+
+2， 请您在软件包的一级目录下创建以“LICENSE”为名的文件，将整个许可证文本放入该文件中；
+
+3， 请将如下声明文本放入每个源文件的头部注释中。
+
+Copyright (c) 2021 OceanBase
+OceanBase CE is licensed under Mulan PubL v2.
+You can use this software according to the terms and conditions of the Mulan PubL v2.
+You may obtain a copy of Mulan PubL v2 at:
+         http://license.coscl.org.cn/MulanPubL-2.0
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+See the Mulan PubL v2 for more details.
+Mulan Public License，Version 2
+Mulan Public License，Version 2 (Mulan PubL v2)
+
+May 2021 http://license.coscl.org.cn/MulanPubL-2.0
+
+Your reproduction, use, modification and Distribution of the Contribution shall be subject to Mulan Public License, Version 2 (this License) with following terms and conditions:
+
+0. Definition
+
+Contribution means the copyrightable work licensed by a particular Contributor under this License, including the work licensed by the initial Contributor under this License and its Derivative Work licensed by any subsequent Contributor under this License.
+
+Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.
+
+Legal Entity means the entity making a Contribution and all its Affiliates.
+
+Affiliates mmeans entities that control, are controlled by, or are under common control with the acting entity under this License, ‘control’ means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.
+
+Derivative Work means works created based on Contribution, specifically including works formed by modifying, rewriting, translating, annotating, combining or linking to all or part of Contribution (including dynamic linking or static linking). Works which only communicate with Contribution through inter-process communication or system call, are independent works, rather than Derivative Work.
+
+Corresponding Source Code means all the source code needed to generate, install, and (for an executable work) run the object code including the interface definition files associated with source files for the work, and scripts to control those activities, excluding of compilation environment and compilation tools, cloud services platform (if any).
+
+Distribute (or Distribution) means the act of making the Contribution or Derivative Work available to others through any medium, and using the Contribution or Derivative Work to provide online services to users, such as the act of providing online services through a cloud service platform built using Contributions or Derivative Works.
+
+1. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or Distribute its Contribution or Derivative Work, with modification or not.
+
+2. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to use, make, have made, sell, offer for sale, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, excluding of any patent claims solely be infringed by your modification. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that any Contribution infringes patents, then any patent license granted to you under this License for the Contribution shall terminate as of the date such litigation or activity is filed or taken.
+
+3. No Trademark License
+
+No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in Section 4.
+
+4. Distribution Restriction
+
+You may Distribute the Contribution you received or your Derivative Work, whether in source or executable forms, provided that you meet the following conditions:
+
+1) You must provide recipients with a copy of this License and retain copyright, trademark, patent and disclaimer statements in the Contribution; and,
+
+2) If you Distribute the Contribution you received, you must provide copies of the Contribution’s source code under this License;
+
+If you Distribute your Derivative Work, you have to:
+
+(i) accompanying the Derivative work, provide recipients with Corresponding Source Code of your Derivative Work under this License. If you provide the Corresponding Source Code through a download link, you should place such link address prominently in the Derivative Work or its accompanying documents, and be valid no less than three years from your Distribution of the particular Derivative Work, and ensure that the recipients can acquire the Corresponding Source Code through the link; or,
+
+(ii) accompanying the Derivative Work, provide recipients with a written offer indicating your willingness to provide the Corresponding Source Code of the Derivative Work licensed under this License. Such written offer shall be placed prominently in the Derivative Work or its accompanying documents. Without reasonable excuse, the recipient shall be able to acquire the Corresponding Source code of the Derivative work for no more than three months from your receipt of a valid request, and be valid no less than three years from your Distribution of the particular Derivative Work.
+
+5. Breach and Termination
+
+If you breach this License, any Contributor has the right to notify you in writing to terminate its license granted to you under this License. The license granted to you by such Contributor terminates upon your receipt of such notice of termination. Notwithstanding the foregoing, your license will not be terminated even if you receive a notice of termination from Contributor, provided that:
+
+1) you have cured all the breaches prior to receiving such notice of termination; or,
+
+2) it’s your first time to receive a notice of termination from such Contributor pursuant to this License, and you have cured all the breaches within 30 days of receipt of such notice.
+
+Termination of your license under this License shall not affect the downstream recipient's rights under this License, provided that the downstream recipient complies with this License.
+
+6. Exceptions
+
+If you combine Contribution or your Derivative Work with a work licensed under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 (hereinafter referred to as “AGPLv3”) or its subsequent versions, and according to the AGPLv3 or its subsequent versions, you have an obligation to make the combined work to be licensed under the corresponding license, you can license such combined work under the license, provided that when you Distribute the combined work, you also provide a copy of this License to the recipients, and retain copyright, trademarks, patents, and disclaimer statements in the Contribution. No Contributor will grant additional rights to the recipients of the combined work for your license under AGPLv3 or its subsequent versions.
+
+7. Disclaimer of Warranty and Limitation of liability
+
+CONTRIBUTION ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE CONTRIBUTION, NO MATTER HOW IT’S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+8. Language
+
+THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.
+
+END OF THE TERMS AND CONDITIONS
+
+How to apply the Mulan Public License，Version 2 (Mulan PubL v2), to your software
+
+To apply the Mulan Public License，Version 2 to your work, for easy identification by recipients, you are suggested to complete following three steps:
+
+Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;
+Create a file named “LICENSE” which contains the whole context of this License in the first directory of your software package;
+Attach the statement to the appropriate annotated syntax at the beginning of each source file.
+
+Copyright (c) 2021 OceanBase
+OceanBase CE is licensed under Mulan PubL v2.
+You can use this software according to the terms and conditions of the Mulan PubL v2.
+You may obtain a copy of Mulan PubL v2 at:
+         http://license.coscl.org.cn/MulanPubL-2.0
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+See the Mulan PubL v2 for more details.

README.md

+# OceanBase Migration Serivce LogProxy
+
+OceanBase增量日志代理服务，是 [OMS](https://www.oceanbase.com/product/oms) 的一部分。基于 [liboblog](https://github.com/oceanbase/oceanbase), 以服务的形式，提供实时增量链路接入和管理能力，方便应用接入OceanBase增量日志；能够解决网络隔离的情况下，订阅增量日志的需求；并提供多种链路接入方式：
+ - Client
+ - Canal
+ - More...
+
+## Quick start
+### Compile
+Install CMake 3.2 or above.
+```shell
+mkdir buildir && cd buildir && cmake .. && make
+```
+
+### Play with it
+```shell
+# run server
+./logproxy -f ./conf/conf.json
+# run demo client
+./demo_client -h127.0.0.1 -P2983 
+```
+
+## Documentation
+- [Compile](./docs/manual.md#编译)
+- [Run](./docs/manual.md#运行)
+- [Configuration](./docs/manual.md#配置)
+
+## Licencing
+OceanBase Database is under MulanPubL - 2.0 license. You can freely copy and use the source code. When you modify or distribute the source code, please obey the MulanPubL - 2.0 license.
+
+## Contributing
+Contributions are warmly welcomed and greatly appreciated. Here are a few ways you can contribute:
+- Raise us an [issue](https://github.com/oceanbase/oblogproxy/issues).
+- Submit Pull Requests. 
+
+## Support
+In case you have any problems when using OceanBase Database, welcome reach out for help:
+- [GitHub Issue](https://github.com/oceanbase/oblogproxy/issues)
+- [Official Website](https://open.oceanbase.com/)

build_local.sh

+#!/usr/bin/env bash
+
+mkdir -p bin && mvn clean package -Dmaven.test.skip=true && cp server/target/logproxy-jar-with-dependencies.jar ./bin/logproxy.jar && cp client/target/logproxy-client.jar ./bin/logproxy-client.jar && cp ./server/script/* ./bin && cp ./server/script/run.sh .

cmake/gflags.cmake

+INCLUDE(ExternalProject)
+
+if (POLICY CMP0097)
+    CMAKE_POLICY(SET CMP0097 NEW)
+endif ()
+
+SET(GFLAGS_SOURCES_DIR ${THIRD_PARTY_PATH}/gflags)
+SET(GFLAGS_INSTALL_DIR ${THIRD_PARTY_PATH}/install/gflags)
+SET(GFLAGS_INCLUDE_DIR "${GFLAGS_INSTALL_DIR}/include" CACHE PATH "gflags include directory." FORCE)
+set(GFLAGS_LIBRARIES "${GFLAGS_INSTALL_DIR}/lib/libgflags.a" CACHE FILEPATH "GFLAGS_LIBRARIES" FORCE)
+set(BUILD_COMMAND $(MAKE) --silent)
+set(INSTALL_COMMAND $(MAKE) install)
+
+INCLUDE_DIRECTORIES(${GFLAGS_INCLUDE_DIR})
+
+ExternalProject_Add(
+        extern_gflags
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        GIT_REPOSITORY "https://github.com/gflags/gflags.git"
+        GIT_TAG "v2.2.2"
+        GIT_SUBMODULES ""
+        GIT_SUBMODULES_RECURSE "false"
+        PREFIX ${GFLAGS_SOURCES_DIR}
+        BUILD_COMMAND ${BUILD_COMMAND}
+        INSTALL_COMMAND ${INSTALL_COMMAND}
+        UPDATE_COMMAND ""
+        CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+        -DBUILD_STATIC_LIBS=ON
+        -DCMAKE_INSTALL_PREFIX=${GFLAGS_INSTALL_DIR}
+        -DCMAKE_INSTALL_LIBDIR=${GFLAGS_INSTALL_DIR}/lib
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+        -DGFLAGS_BUILD_TESTING=OFF
+        -DGFLAGS_BUILD_PACKAGING=OFF
+        -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+        ${EXTERNAL_OPTIONAL_ARGS}
+        CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${GFLAGS_INSTALL_DIR}
+        -DCMAKE_INSTALL_LIBDIR:PATH=${GFLAGS_INSTALL_DIR}/lib
+        -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+        -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+)
+
+ADD_LIBRARY(gflags STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET gflags PROPERTY IMPORTED_LOCATION ${GFLAGS_LIBRARIES})
+ADD_DEPENDENCIES(gflags extern_gflags)
+
+message(gflag: ${GFLAGS_INCLUDE_DIR}, ${GFLAGS_LIBRARIES})

cmake/glog.cmake

+INCLUDE(ExternalProject)
+
+SET(GLOG_SOURCES_DIR ${THIRD_PARTY_PATH}/glog)
+SET(GLOG_INSTALL_DIR ${THIRD_PARTY_PATH}/install/glog)
+SET(GLOG_INCLUDE_DIR "${GLOG_INSTALL_DIR}/include" CACHE PATH "glog include directory." FORCE)
+SET(GLOG_LIBRARIES "${GLOG_INSTALL_DIR}/lib/libglog.a" CACHE FILEPATH "glog library." FORCE)
+
+INCLUDE_DIRECTORIES(${GLOG_INCLUDE_DIR})
+
+set(prefix_path "${THIRD_PARTY_PATH}/install/gflags")
+
+SET(gflags_BUILD_STATIC_LIBS ON)
+
+ExternalProject_Add(
+        extern_glog
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        DEPENDS gflags
+        GIT_REPOSITORY "https://github.com/google/glog.git"
+        GIT_TAG "v0.4.0"
+        PREFIX ${GLOG_SOURCES_DIR}
+        UPDATE_COMMAND ""
+        CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+        -DCMAKE_INSTALL_PREFIX=${GLOG_INSTALL_DIR}
+        -DCMAKE_INSTALL_LIBDIR=${GLOG_INSTALL_DIR}/lib
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+        -DWITH_GFLAGS=ON
+        -Dgflags_DIR=${GFLAGS_INSTALL_DIR}/lib/cmake/gflags
+        -DBUILD_TESTING=OFF
+        -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+        -DCMAKE_PREFIX_PATH=${prefix_path}
+        ${EXTERNAL_OPTIONAL_ARGS}
+        CMAKE_CACHE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${GLOG_INSTALL_DIR}
+        -DCMAKE_INSTALL_LIBDIR:PATH=${GLOG_INSTALL_DIR}/lib
+        -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+        -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+)
+
+ADD_DEPENDENCIES(extern_glog gflags)
+ADD_LIBRARY(glog STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET glog PROPERTY IMPORTED_LOCATION ${GLOG_LIBRARIES})
+ADD_DEPENDENCIES(glog extern_glog)
+LINK_LIBRARIES(glog gflags)
\ No newline at end of file

cmake/gtest.cmake

+INCLUDE(ExternalProject)
+
+SET(GTEST_SOURCES_DIR ${THIRD_PARTY_PATH}/gtest)
+SET(GTEST_INSTALL_DIR ${THIRD_PARTY_PATH}/install/gtest)
+SET(GTEST_INCLUDE_DIR "${GTEST_INSTALL_DIR}/include" CACHE PATH "gtest include directory." FORCE)
+SET(GTEST_LIBRARIES "${GTEST_INSTALL_DIR}/lib/libgtest.a" CACHE FILEPATH "gtest library." FORCE)
+
+INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIR})
+
+set(prefix_path "${THIRD_PARTY_PATH}/install/gflags")
+
+SET(gflags_BUILD_STATIC_LIBS ON)
+
+ExternalProject_Add(
+        extern_gtest
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        DEPENDS gflags
+        GIT_REPOSITORY "https://github.com/google/googletest.git"
+        GIT_TAG "master"
+        PREFIX ${GTEST_SOURCES_DIR}
+        UPDATE_COMMAND ""
+        CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+        -DCMAKE_INSTALL_PREFIX=${GTEST_INSTALL_DIR}
+        -DCMAKE_INSTALL_LIBDIR=${GTEST_INSTALL_DIR}/lib
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+        -DBUILD_GMOCK=OFF
+        -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+        -DCMAKE_PREFIX_PATH=${prefix_path}
+        ${EXTERNAL_OPTIONAL_ARGS}
+)
+
+ADD_LIBRARY(gtest STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET gtest PROPERTY IMPORTED_LOCATION ${GTEST_LIBRARIES})
+ADD_DEPENDENCIES(gtest extern_gtest)
\ No newline at end of file

cmake/jsoncpp.cmake

+INCLUDE(ExternalProject)
+
+SET(JSONCPP_SOURCES_DIR ${THIRD_PARTY_PATH}/jsoncpp)
+SET(JSONCPP_INSTALL_DIR ${THIRD_PARTY_PATH}/install/jsoncpp)
+SET(JSONCPP_INCLUDE_DIR "${JSONCPP_INSTALL_DIR}/include" CACHE PATH "jsoncpp include directory." FORCE)
+SET(JSONCPP_LIBRARIES "${JSONCPP_INSTALL_DIR}/lib/libjsoncpp.a" CACHE FILEPATH "jsoncpp library." FORCE)
+
+INCLUDE_DIRECTORIES(${JSONCPP_INCLUDE_DIR})
+
+set(prefix_path "${THIRD_PARTY_PATH}/install/jsoncpp")
+
+ExternalProject_Add(
+        extern_jsoncpp
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        GIT_REPOSITORY "https://github.com/open-source-parsers/jsoncpp.git"
+        GIT_TAG "1.9.0"
+        PREFIX ${JSONCPP_SOURCES_DIR}
+        UPDATE_COMMAND ""
+        CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+        -DCMAKE_INSTALL_PREFIX=${JSONCPP_INSTALL_DIR}
+        -DCMAKE_INSTALL_LIBDIR=${JSONCPP_INSTALL_DIR}/lib
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+        -DJSONCPP_WITH_TESTS=OFF
+        -DJSONCPP_WITH_POST_BUILD_UNITTEST=OFF
+        -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+        -DCMAKE_PREFIX_PATH=${prefix_path}
+        ${EXTERNAL_OPTIONAL_ARGS}
+)
+
+ADD_LIBRARY(jsoncpp STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET jsoncpp PROPERTY IMPORTED_LOCATION ${JSONCPP_LIBRARIES})
+ADD_DEPENDENCIES(jsoncpp extern_jsoncpp)
\ No newline at end of file

cmake/libevent.cmake

+INCLUDE(ExternalProject)
+
+SET(MODULE_NAME libevent)
+SET(LIBEVENT_SOURCES_DIR ${THIRD_PARTY_PATH}/${MODULE_NAME})
+SET(LIBEVENT_INSTALL_DIR ${THIRD_PARTY_PATH}/install/${MODULE_NAME})
+SET(LIBEVENT_INCLUDE_DIR "${LIBEVENT_INSTALL_DIR}/include" CACHE PATH "libevent include directory." FORCE)
+SET(LIBEVENT_LIBRARIES "${LIBEVENT_INSTALL_DIR}/lib/libevent.a" CACHE FILEPATH "libevent library." FORCE)
+
+INCLUDE_DIRECTORIES(${LIBEVENT_INCLUDE_DIR})
+
+set(prefix_path "${LIBEVENT_INSTALL_DIR}")
+
+ExternalProject_Add(
+        extern_libevent
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        GIT_REPOSITORY "https://github.com/libevent/libevent"
+        GIT_TAG "release-2.1.12-stable"
+        PREFIX ${LIBEVENT_SOURCES_DIR}
+        UPDATE_COMMAND ""
+        CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}
+        -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+        -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+        -DCMAKE_INSTALL_PREFIX=${LIBEVENT_INSTALL_DIR}
+        -DCMAKE_INSTALL_LIBDIR=${LIBEVENT_INSTALL_DIR}/lib
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+		-DEVENT__DISABLE_OPENSSL=ON
+		-DEVENT__DISABLE_DEBUG_MODE=ON
+		-DEVENT__DISABLE_BENCHMARK=ON
+		-DEVENT__DISABLE_REGRESS=ON
+		-DEVENT__DISABLE_SAMPLES=ON
+		-DEVENT__FORCE_KQUEUE_CHECK=ON
+		-DEVENT__LIBRARY_TYPE=STATIC
+        -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+        -DCMAKE_PREFIX_PATH=${prefix_path}
+        ${EXTERNAL_OPTIONAL_ARGS}
+)
+
+ADD_LIBRARY(${MODULE_NAME} STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET ${MODULE_NAME} PROPERTY IMPORTED_LOCATION ${LIBEVENT_LIBRARIES})
+ADD_DEPENDENCIES(${MODULE_NAME} extern_libevent)

cmake/lz4.cmake

+INCLUDE(ExternalProject)
+
+SET(LZ4_SOURCES_DIR ${THIRD_PARTY_PATH}/lz4)
+SET(LZ4_INSTALL_DIR ${THIRD_PARTY_PATH}/install/lz4)
+SET(LZ4_INCLUDE_DIR "${LZ4_INSTALL_DIR}/lib" CACHE PATH "lz4 include directory." FORCE)
+SET(LZ4_LIBRARIES "${LZ4_INSTALL_DIR}/lib/liblz4.a" CACHE FILEPATH "lz4 library." FORCE)
+
+INCLUDE_DIRECTORIES(${LZ4_INCLUDE_DIR})
+
+set(prefix_path "${THIRD_PARTY_PATH}/install/lz4")
+
+ExternalProject_Add(
+        extern_lz4
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        GIT_REPOSITORY "https://github.com/lz4/lz4.git"
+        GIT_TAG "v1.9.3"
+        PREFIX ${LZ4_SOURCES_DIR}
+        BUILD_IN_SOURCE ON
+        UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ""
+        BUILD_COMMAND $(MAKE) -j${NUM_OF_PROCESSOR} liblz4.a
+        INSTALL_COMMAND mkdir -p ${LZ4_INSTALL_DIR} COMMAND cp -r ${LZ4_SOURCES_DIR}/src/extern_lz4/lib ${LZ4_INSTALL_DIR}/
+        ${EXTERNAL_OPTIONAL_ARGS}
+)
+
+ADD_LIBRARY(lz4 STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET lz4 PROPERTY IMPORTED_LOCATION ${LZ4_LIBRARIES})
+ADD_DEPENDENCIES(lz4 extern_lz4)
\ No newline at end of file

cmake/oblogmsg.cmake

+INCLUDE(ExternalProject)
+
+if (POLICY CMP0097)
+    cmake_policy(SET CMP0097 NEW)
+endif ()
+
+SET(OBLOGMSG_SOURCES_DIR ${THIRD_PARTY_PATH}/oblogmsg)
+SET(OBLOGMSG_DOWNLOAD_DIR "${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg")
+SET(OBLOGMSG_INSTALL_DIR ${THIRD_PARTY_PATH}/install/oblogmsg)
+SET(OBLOGMSG_INCLUDE_DIR "${OBLOGMSG_INSTALL_DIR}/include" CACHE PATH "oblogmsg include directory." FORCE)
+
+SET(OBLOGMSG_LIB_DIR "${OBLOGMSG_INSTALL_DIR}/lib/" CACHE FILEPATH "oblogmsg library directory." FORCE)
+if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    SET(OBLOGMSG_LIBRARIES "liboblogmsg.dylib" CACHE FILEPATH "oblogmsg library." FORCE)
+else ()
+    SET(OBLOGMSG_LIBRARIES "liboblogmsg.so" CACHE FILEPATH "oblogmsg library." FORCE)
+endif ()
+
+ExternalProject_Add(
+        extern_oblogmsg
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        GIT_REPOSITORY "git@gitlab.alibaba-inc.com:oceanbase-ce-publish/oblogmsg.git"
+        GIT_TAG "master"
+        GIT_SUBMODULES ""
+        GIT_SUBMODULES_RECURSE "false"
+        PREFIX ${OBLOGMSG_SOURCES_DIR}
+        BUILD_IN_SOURCE 1
+        UPDATE_COMMAND ""
+        CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+        -DCMAKE_BUILD_TYPE=Debug
+        -DCMAKE_PREFIX_PATH=${prefix_path}
+        -DTEST=OFF
+        -DUSE_CXX11_ABI=${USE_CXX11_ABI}
+        INSTALL_COMMAND mkdir -p ${OBLOGMSG_INSTALL_DIR}/lib ${OBLOGMSG_INSTALL_DIR}/include COMMAND cp -r ${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg/src/${OBLOGMSG_LIBRARIES} ${OBLOGMSG_INSTALL_DIR}/lib/ COMMAND cp -r ${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg/include ${OBLOGMSG_INSTALL_DIR}/ COMMAND cp -r ${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg/src/${OBLOGMSG_LIBRARIES} ${LIBRARY_OUTPUT_PATH}/
+)
+
+ADD_LIBRARY(oblogmsg STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET oblogmsg PROPERTY IMPORTED_LOCATION ${OBLOGMSG_LIBRARIES})
+ADD_DEPENDENCIES(oblogmsg extern_oblogmsg)

cmake/oblogmsg_internal.cmake

+INCLUDE(ExternalProject)
+
+if (POLICY CMP0097)
+    cmake_policy(SET CMP0097 NEW)
+endif ()
+
+SET(OBLOGMSG_SOURCES_DIR ${THIRD_PARTY_PATH}/oblogmsg)
+SET(OBLOGMSG_DOWNLOAD_DIR "${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg")
+SET(OBLOGMSG_INSTALL_DIR ${THIRD_PARTY_PATH}/install/oblogmsg)
+SET(OBLOGMSG_INCLUDE_DIR "${OBLOGMSG_INSTALL_DIR}/include" CACHE PATH "oblogmsg include directory." FORCE)
+
+message("INTERNAL: ${INTERNAL}")
+SET(OBLOGMSG_LIB_DIR "${OBLOGMSG_INSTALL_DIR}/lib/" CACHE FILEPATH "oblogmsg library directory." FORCE)
+if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    SET(OBLOGMSG_LIBRARIES "libdrcmsg.dylib" CACHE FILEPATH "oblogmsg library." FORCE)
+else ()
+    SET(OBLOGMSG_LIBRARIES "libdrcmsg.so" CACHE FILEPATH "oblogmsg library." FORCE)
+endif ()
+
+ExternalProject_Add(
+        extern_oblogmsg
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        GIT_REPOSITORY "http://gitlab.alibaba-inc.com/fanzhongyang.fzy/LogMessage.git"
+        GIT_TAG "enterprise"
+        GIT_SUBMODULES ""
+        GIT_SUBMODULES_RECURSE "false"
+        PREFIX ${OBLOGMSG_SOURCES_DIR}
+        BUILD_IN_SOURCE 1
+        UPDATE_COMMAND ""
+        CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+        -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+        -DCMAKE_BUILD_TYPE=Debug
+        -DCMAKE_PREFIX_PATH=${prefix_path}
+        -DTEST=OFF
+        -DAS_DRCMSG_SHARED=ON
+        -DUSE_CXX11_ABI=${USE_CXX11_ABI}
+        INSTALL_COMMAND mkdir -p ${OBLOGMSG_INSTALL_DIR}/lib ${OBLOGMSG_INSTALL_DIR}/include COMMAND cp -r ${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg/src/${OBLOGMSG_LIBRARIES} ${OBLOGMSG_INSTALL_DIR}/lib/ COMMAND cp -r ${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg/include ${OBLOGMSG_INSTALL_DIR}/ COMMAND cp -r ${OBLOGMSG_SOURCES_DIR}/src/extern_oblogmsg/src/${OBLOGMSG_LIBRARIES} ${LIBRARY_OUTPUT_PATH}/
+)
+
+ADD_LIBRARY(oblogmsg STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET oblogmsg PROPERTY IMPORTED_LOCATION ${OBLOGMSG_LIBRARIES})
+ADD_DEPENDENCIES(oblogmsg extern_oblogmsg)

cmake/protobuf.cmake

+INCLUDE(ExternalProject)
+# Always invoke `FIND_PACKAGE(Protobuf)` for importing function protobuf_generate_cpp
+
+FIND_PACKAGE(Protobuf QUIET)
+macro(UNSET_VAR VAR_NAME)
+    UNSET(${VAR_NAME} CACHE)
+    UNSET(${VAR_NAME})
+endmacro()
+
+UNSET_VAR(PROTOBUF_INCLUDE_DIR)
+UNSET_VAR(PROTOBUF_FOUND)
+UNSET_VAR(PROTOBUF_PROTOC_EXECUTABLE)
+UNSET_VAR(PROTOBUF_PROTOC_LIBRARY)
+UNSET_VAR(PROTOBUF_LITE_LIBRARY)
+UNSET_VAR(PROTOBUF_LIBRARY)
+UNSET_VAR(PROTOBUF_INCLUDE_DIR)
+UNSET_VAR(Protobuf_PROTOC_EXECUTABLE)
+
+if (POLICY CMP0097)
+    cmake_policy(SET CMP0097 NEW)
+endif ()
+
+# Print and set the protobuf library information,
+# finish this cmake process and exit from this file.
+macro(PROMPT_PROTOBUF_LIB)
+    SET(protobuf_DEPS ${ARGN})
+
+    MESSAGE(STATUS "Protobuf protoc executable: ${PROTOBUF_PROTOC_EXECUTABLE}")
+    MESSAGE(STATUS "Protobuf-lite library: ${PROTOBUF_LITE_LIBRARY}")
+    MESSAGE(STATUS "Protobuf library: ${PROTOBUF_LIBRARY}")
+    MESSAGE(STATUS "Protoc library: ${PROTOBUF_PROTOC_LIBRARY}")
+    MESSAGE(STATUS "Protobuf version: ${PROTOBUF_VERSION}")
+    INCLUDE_DIRECTORIES(${PROTOBUF_INCLUDE_DIR})
+
+    # Assuming that all the protobuf libraries are of the same type.
+    IF (${PROTOBUF_LIBRARY} MATCHES ${CMAKE_STATIC_LIBRARY_SUFFIX})
+        SET(protobuf_LIBTYPE STATIC)
+    ELSEIF (${PROTOBUF_LIBRARY} MATCHES "${CMAKE_SHARED_LIBRARY_SUFFIX}$")
+        SET(protobuf_LIBTYPE SHARED)
+    ELSE ()
+        MESSAGE(FATAL_ERROR "Unknown library type: ${PROTOBUF_LIBRARY}")
+    ENDIF ()
+
+    ADD_LIBRARY(protobuf ${protobuf_LIBTYPE} IMPORTED GLOBAL)
+    SET_PROPERTY(TARGET protobuf PROPERTY IMPORTED_LOCATION ${PROTOBUF_LIBRARY})
+
+    ADD_LIBRARY(protobuf_lite ${protobuf_LIBTYPE} IMPORTED GLOBAL)
+    SET_PROPERTY(TARGET protobuf_lite PROPERTY IMPORTED_LOCATION ${PROTOBUF_LITE_LIBRARY})
+
+    ADD_LIBRARY(libprotoc ${protobuf_LIBTYPE} IMPORTED GLOBAL)
+    SET_PROPERTY(TARGET libprotoc PROPERTY IMPORTED_LOCATION ${PROTOC_LIBRARY})
+
+    ADD_EXECUTABLE(protoc IMPORTED GLOBAL)
+    SET_PROPERTY(TARGET protoc PROPERTY IMPORTED_LOCATION ${PROTOBUF_PROTOC_EXECUTABLE})
+    SET(Protobuf_PROTOC_EXECUTABLE ${PROTOBUF_PROTOC_EXECUTABLE})
+
+    FOREACH (dep ${protobuf_DEPS})
+        ADD_DEPENDENCIES(protobuf ${dep})
+        ADD_DEPENDENCIES(protobuf_lite ${dep})
+        ADD_DEPENDENCIES(libprotoc ${dep})
+        ADD_DEPENDENCIES(protoc ${dep})
+    ENDFOREACH ()
+
+    RETURN()
+endmacro()
+
+macro(SET_PROTOBUF_VERSION)
+    EXEC_PROGRAM(${PROTOBUF_PROTOC_EXECUTABLE} ARGS --version OUTPUT_VARIABLE PROTOBUF_VERSION)
+    STRING(REGEX MATCH "[0-9]+.[0-9]+" PROTOBUF_VERSION "${PROTOBUF_VERSION}")
+endmacro()
+
+FUNCTION(build_protobuf TARGET_NAME BUILD_FOR_HOST)
+    STRING(REPLACE "extern_" "" TARGET_DIR_NAME "${TARGET_NAME}")
+    SET(PROTOBUF_SOURCES_DIR ${THIRD_PARTY_PATH}/${TARGET_DIR_NAME})
+    SET(PROTOBUF_INSTALL_DIR ${THIRD_PARTY_PATH}/install/${TARGET_DIR_NAME})
+
+    SET(${TARGET_NAME}_INCLUDE_DIR "${PROTOBUF_INSTALL_DIR}/include" PARENT_SCOPE)
+    SET(PROTOBUF_INCLUDE_DIR "${PROTOBUF_INSTALL_DIR}/include" PARENT_SCOPE)
+    SET(${TARGET_NAME}_LITE_LIBRARY
+            "${PROTOBUF_INSTALL_DIR}/lib/libprotobuf-lite${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            PARENT_SCOPE)
+    SET(${TARGET_NAME}_LIBRARY
+            "${PROTOBUF_INSTALL_DIR}/lib/libprotobuf${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            PARENT_SCOPE)
+    SET(${TARGET_NAME}_PROTOC_LIBRARY
+            "${PROTOBUF_INSTALL_DIR}/lib/libprotoc${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            PARENT_SCOPE)
+    SET(${TARGET_NAME}_PROTOC_EXECUTABLE
+            "${PROTOBUF_INSTALL_DIR}/bin/protoc${CMAKE_EXECUTABLE_SUFFIX}"
+            PARENT_SCOPE)
+
+    SET(OPTIONAL_CACHE_ARGS "")
+    SET(OPTIONAL_ARGS "")
+    IF (BUILD_FOR_HOST)
+        SET(OPTIONAL_ARGS "-Dprotobuf_WITH_ZLIB=OFF")
+    ELSE ()
+        SET(OPTIONAL_ARGS
+                "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+                "-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}"
+                "-DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}"
+                "-DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}"
+                "-DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}"
+                "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
+                "-DCMAKE_CXX_FLAGS_RELEASE=${CMAKE_CXX_FLAGS_RELEASE}"
+                "-DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG}"
+                "-Dprotobuf_WITH_ZLIB=OFF"
+                #                "-DZLIB_ROOT:FILEPATH=${ZLIB_ROOT}"
+                ${EXTERNAL_OPTIONAL_ARGS})
+    ENDIF ()
+
+    SET(PROTOBUF_REPO "https://github.com/protocolbuffers/protobuf.git")
+    SET(PROTOBUF_TAG "v3.6.0")
+
+    ExternalProject_Add(
+            ${TARGET_NAME}
+            ${EXTERNAL_PROJECT_LOG_ARGS}
+            PREFIX ${PROTOBUF_SOURCES_DIR}
+            UPDATE_COMMAND ""
+            #            DEPENDS         zlib
+            GIT_REPOSITORY ${PROTOBUF_REPO}
+            GIT_TAG ${PROTOBUF_TAG}
+            GIT_SUBMODULES ""
+            GIT_SUBMODULES_RECURSE "false"
+            CONFIGURE_COMMAND
+            ${CMAKE_COMMAND} ${PROTOBUF_SOURCES_DIR}/src/${TARGET_NAME}/cmake
+            ${OPTIONAL_ARGS}
+            -Dprotobuf_BUILD_TESTS=OFF
+            -DCMAKE_SKIP_RPATH=ON
+            -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+            -DCMAKE_BUILD_TYPE=${THIRD_PARTY_BUILD_TYPE}
+            -DCMAKE_INSTALL_PREFIX=${PROTOBUF_INSTALL_DIR}
+            -DCMAKE_INSTALL_LIBDIR=lib
+            -DBUILD_SHARED_LIBS=OFF
+            -Dprotobuf_MSVC_STATIC_RUNTIME=${MSVC_STATIC_CRT}
+            CMAKE_CACHE_ARGS
+            -DCMAKE_INSTALL_PREFIX:PATH=${PROTOBUF_INSTALL_DIR}
+            -DCMAKE_BUILD_TYPE:STRING=${THIRD_PARTY_BUILD_TYPE}
+            -DCMAKE_VERBOSE_MAKEFILE:BOOL=OFF
+            -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
+            ${OPTIONAL_CACHE_ARGS}
+    )
+ENDFUNCTION()
+
+SET(PROTOBUF_VERSION 3.6.0)
+
+build_protobuf(extern_protobuf FALSE)
+
+SET(PROTOBUF_INCLUDE_DIR ${extern_protobuf_INCLUDE_DIR}
+        CACHE PATH "protobuf include directory." FORCE)
+SET(PROTOBUF_LITE_LIBRARY ${extern_protobuf_LITE_LIBRARY}
+        CACHE FILEPATH "protobuf lite library." FORCE)
+SET(PROTOBUF_LIBRARY ${extern_protobuf_LIBRARY}
+        CACHE FILEPATH "protobuf library." FORCE)
+SET(PROTOBUF_LIBRARIES ${extern_protobuf_LIBRARY}
+        CACHE FILEPATH "protobuf library." FORCE)
+SET(PROTOBUF_PROTOC_LIBRARY ${extern_protobuf_PROTOC_LIBRARY}
+        CACHE FILEPATH "protoc library." FORCE)
+
+SET(PROTOBUF_PROTOC_EXECUTABLE ${extern_protobuf_PROTOC_EXECUTABLE}
+        CACHE FILEPATH "protobuf executable." FORCE)
+PROMPT_PROTOBUF_LIB(extern_protobuf)

cmake/rocksdb.cmake

+INCLUDE(ExternalProject)
+
+SET(ROCKSDB_SOURCES_DIR ${THIRD_PARTY_PATH}/rocksdb)
+SET(ROCKSDB_INSTALL_DIR ${THIRD_PARTY_PATH}/install/rocksdb)
+SET(ROCKSDB_INCLUDE_DIR "${ROCKSDB_INSTALL_DIR}/include" CACHE PATH "rocksdb include directory." FORCE)
+SET(ROCKSDB_LIBRARIES "${ROCKSDB_INSTALL_DIR}/lib/librocksdb.a" CACHE FILEPATH "rocksdb library." FORCE)
+INCLUDE_DIRECTORIES(${ROCKSDB_INCLUDE_DIR})
+
+FILE(WRITE ${ROCKSDB_SOURCES_DIR}/src/build.sh
+        "PORTABLE=1 make -j${NUM_OF_PROCESSOR} static_lib"
+        )
+
+ExternalProject_Add(
+        extern_rocksdb
+        ${EXTERNAL_PROJECT_LOG_ARGS}
+        DEPENDS gflags zlib snappy bz2
+        PREFIX ${ROCKSDB_SOURCES_DIR}
+        GIT_REPOSITORY "https://github.com/facebook/rocksdb.git"
+        GIT_TAG "v6.3.6"
+        UPDATE_COMMAND ""
+        CONFIGURE_COMMAND ""
+        BUILD_IN_SOURCE 1
+        BUILD_COMMAND mv ../build.sh . COMMAND sh build.sh
+        INSTALL_COMMAND mkdir -p ${ROCKSDB_INSTALL_DIR}/lib COMMAND cp -r include ${ROCKSDB_INSTALL_DIR}/ COMMAND cp librocksdb.a ${ROCKSDB_LIBRARIES}
+)
+
+ADD_DEPENDENCIES(extern_rocksdb lz4 gflags)
+ADD_LIBRARY(rocksdb STATIC IMPORTED GLOBAL)
+SET_PROPERTY(TARGET rocksdb PROPERTY IMPORTED_LOCATION ${ROCKSDB_LIBRARIES})
+ADD_DEPENDENCIES(rocksdb extern_rocksdb)
+LINK_LIBRARIES(rocksdb gflags lz4)

common/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>com.oceanbase.clogproxy</groupId>
+        <artifactId>clogproxy</artifactId>
+        <version>1.0.1-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>common</artifactId>
+
+    <dependencies>
+        <!-- common language -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.protobuf</groupId>
+            <artifactId>protobuf-java</artifactId>
+        </dependency>
+
+        <!-- net -->
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-all</artifactId>
+        </dependency>
+    </dependencies>
+
+</project>
\ No newline at end of file

common/src/main/java/com/oceanbase/clogproxy/common/config/ShareConf.java

+package com.oceanbase.clogproxy.common.config;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-08-19
+ */
+public class ShareConf {
+    public static boolean AUTH_PASSWORD_HASH = true;
+}

common/src/main/java/com/oceanbase/clogproxy/common/packet/CompressType.java

+package com.oceanbase.clogproxy.common.packet;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-06-16
+ */
+public enum CompressType {
+    /**
+     * no compress
+     */
+    NONE(0),
+
+    /**
+     * lz4 compress
+     */
+    LZ4(1);
+
+    private int code;
+
+    CompressType(int code) {
+        this.code = code;
+    }
+
+    public static CompressType codeOf(int code) {
+        for (CompressType v : values()) {
+            if (v.code == code) {
+                return v;
+            }
+        }
+        return null;
+    }
+
+    public int code() {
+        return code;
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/packet/HeaderType.java

+package com.oceanbase.clogproxy.common.packet;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-06-15
+ */
+public enum HeaderType {
+    /**
+     * error response
+     */
+    ERROR_RESPONSE(-1),
+
+    /**
+     * client request handshake
+     */
+    HANDSHAKE_REQUEST_CLIENT(1),
+
+    /**
+     * response to client handshake
+     */
+    HANDSHAKE_RESPONSE_CLIENT(2),
+
+    /**
+     * logreader request handshake
+     */
+    HANDSHAKE_REQUEST_LOGREADER(3),
+
+    /**
+     * logreader response handshake
+     */
+    HANDSHAKE_RESPONSE_LOGREADER(4),
+
+    /**
+     * logreader data stream
+     */
+    DATA_LOGREADER(5),
+
+    /**
+     * client data stream
+     */
+    DATA_CLIENT(6),
+
+    /**
+     * status info of server runtime
+     */
+    STATUS(7),
+
+    /**
+     * status info of LogReader
+     */
+    STATUS_LOGREADER(8),
+    ;
+
+    private final int code;
+
+    HeaderType(int code) {
+        this.code = code;
+    }
+
+    public static HeaderType codeOf(int code) {
+        for (HeaderType t : values()) {
+            if (t.code == code) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    public int code() {
+        return code;
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/packet/LogType.java

+package com.oceanbase.clogproxy.common.packet;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * <p>
+ * </p>
+ * <p> Date: 2020-05-07 Time: 11:14</p>
+ *
+ * @author jiyong.jy
+ */
+public enum LogType {
+
+    /**
+     * LogProxy OceanBase LogReader
+     */
+    OCEANBASE(0),
+
+    /**
+     * DRC store
+     */
+    OMS_STORE(1);
+
+    private final int code;
+
+    private static final Map<Integer, LogType> CODE_TYPES = new HashMap<>(values().length);
+
+    static {
+        for (LogType logCaptureType : values()) {
+            CODE_TYPES.put(logCaptureType.code, logCaptureType);
+        }
+    }
+
+    LogType(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return this.code;
+    }
+
+    public static LogType fromString(String string) {
+        if (string == null) {
+            throw new NullPointerException("logTypeString is null");
+        }
+        return valueOf(string.toUpperCase());
+    }
+
+    public static LogType fromCode(int code) {
+        if (CODE_TYPES.containsKey(code)) {
+            return CODE_TYPES.get(code);
+        }
+        return null;
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/packet/ProtocolVersion.java

+package com.oceanbase.clogproxy.common.packet;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-06-16
+ */
+public enum ProtocolVersion {
+    /**
+     * v0 version
+     */
+    V0(0),
+    V1(1);
+
+    private final int code;
+
+    ProtocolVersion(int code) {
+        this.code = code;
+    }
+
+    public static ProtocolVersion codeOf(int code) {
+        for (ProtocolVersion v : values()) {
+            if (v.code == code) {
+                return v;
+            }
+        }
+        return null;
+    }
+
+    public int code() {
+        return code;
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/util/CryptoUtil.java

+package com.oceanbase.clogproxy.common.util;
+
+import org.apache.commons.codec.digest.DigestUtils;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.GCMParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-07-14
+ */
+public class CryptoUtil {
+
+    private static final String KEY = "LogProxy123*";
+
+    private static final int AES_KEY_SIZE = 256;
+    private static final int GCM_TAG_LENGTH = 16;
+
+    public static Encryptor newEncryptor(String key) {
+        return new Encryptor(key);
+    }
+
+    public static Encryptor newEncryptor() {
+        return new Encryptor(KEY);
+    }
+
+    public static class Encryptor {
+        private Cipher cipher = null;   // not thread-safe
+        private byte[] key = new byte[AES_KEY_SIZE / 16];
+        private byte[] iv = new byte[12];
+
+        private Encryptor(String cipherKey) {
+            try {
+                cipher = Cipher.getInstance("AES/GCM/NoPadding");
+                byte[] cipherBytes = cipherKey.getBytes();
+                System.arraycopy(cipherBytes, 0, key, 0, Math.min(key.length, cipherBytes.length));
+                System.arraycopy(cipherBytes, 0, iv, 0, Math.min(iv.length, cipherBytes.length));
+
+            } catch (NoSuchAlgorithmException | NoSuchPaddingException e) {
+                System.out.println("failed to init AES key generator, exit!!! : " + e);
+                System.exit(-1);
+            }
+        }
+
+        public byte[] encrypt(String text) {
+            SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
+            GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
+
+            try {
+                cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmParameterSpec);
+                return cipher.doFinal(text.getBytes());
+            } catch (InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
+                System.out.println("failed to encrypt AES 256 GCM: " + e);
+                return null;
+            }
+        }
+
+        public String decrypt(byte[] cipherText) {
+            SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
+            GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
+            try {
+                cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmParameterSpec);
+                byte[] decryptedText = cipher.doFinal(cipherText);
+                return new String(decryptedText);
+            } catch (InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
+                System.out.println("failed to decrypt AES 256 GCM: " + e);
+                return "";
+            }
+        }
+    }
+
+    public static byte[] sha1(byte[] bytes) {
+        return DigestUtils.sha1(bytes);
+    }
+
+    public static byte[] sha1(String text) {
+        return DigestUtils.sha1(text);
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/util/Decoder.java

+package com.oceanbase.clogproxy.common.util;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
+
+/**
+ * <p>
+ * </p>
+ * <p> Date: 2020-04-20 Time: 21:54</p>
+ *
+ * @author jiyong.jy
+ */
+public class Decoder {
+
+    public static String decodeStringInt(ByteBuf buffer) {
+        if (buffer.readableBytes() < Integer.BYTES) {
+            return null;
+        }
+        buffer.markReaderIndex();
+        int length = buffer.readInt();
+        if (buffer.readableBytes() < length) {
+            buffer.resetReaderIndex();
+            return null;
+        }
+        byte[] bytes = new byte[length];
+        buffer.readBytes(bytes);
+        String str = new String(bytes);
+        if (str.isEmpty()) {
+            throw new RuntimeException("decode string is null or empty");
+        }
+        return str;
+    }
+
+    public static String decodeStringByte(ByteBuf buffer) {
+        if (buffer.readableBytes() < Byte.BYTES) {
+            return null;
+        }
+        buffer.markReaderIndex();
+        short length = buffer.readByte();
+        if (buffer.readableBytes() < length) {
+            buffer.resetReaderIndex();
+            return null;
+        }
+        byte[] bytes = new byte[length];
+        buffer.readBytes(bytes);
+        String str = new String(bytes);
+        if (str.isEmpty()) {
+            throw new RuntimeException("decode string is null or empty");
+        }
+        return str;
+    }
+
+    public static ByteBuf encodeStringInt(String string) {
+        if (string == null || string.length() == 0) {
+            throw new RuntimeException("encode string is null or empty");
+        }
+        ByteBuf byteBuf = PooledByteBufAllocator.DEFAULT.buffer(4 + string.length());
+        byteBuf.writeInt(string.length());
+        byteBuf.writeBytes(string.getBytes());
+        return byteBuf;
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/util/Hex.java

+package com.oceanbase.clogproxy.common.util;
+
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
+import org.apache.commons.codec.DecoderException;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-07-02
+ */
+public final class Hex {
+    public static String dump(byte[] array) {
+        return dump(array, 0, array.length);
+    }
+
+    public static String dump(byte[] bytes, int offset, int length) {
+        return ByteBufUtil.prettyHexDump(Unpooled.wrappedBuffer(bytes, offset, length));
+    }
+
+    public static String str(byte[] bytes) {
+        return org.apache.commons.codec.binary.Hex.encodeHexString(bytes, false);
+    }
+
+    public static byte[] toBytes(String hexstr) {
+        try {
+            return org.apache.commons.codec.binary.Hex.decodeHex(hexstr);
+        } catch (DecoderException e) {
+            return null;
+        }
+    }
+}
\ No newline at end of file

common/src/main/java/com/oceanbase/clogproxy/common/util/NetworkUtil.java

+package com.oceanbase.clogproxy.common.util;
+
+import java.net.Inet4Address;
+import java.net.InetAddress;
+import java.net.InterfaceAddress;
+import java.net.NetworkInterface;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.util.Enumeration;
+
+import io.netty.channel.Channel;
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * <p>
+ * </p>
+ * <p> Date: 2020-05-01 Time: 11:33</p>
+ *
+ * @author jiyong.jy
+ */
+public class NetworkUtil {
+
+    private static String IP;
+
+    static {
+        try {
+            for (Enumeration<NetworkInterface> e = NetworkInterface.getNetworkInterfaces(); e.hasMoreElements(); ) {
+                NetworkInterface item = e.nextElement();
+                for (InterfaceAddress address : item.getInterfaceAddresses()) {
+                    if (item.isLoopback() || !item.isUp()) {
+                        continue;
+                    }
+                    if (address.getAddress() instanceof Inet4Address) {
+                        Inet4Address inet4Address = (Inet4Address) address.getAddress();
+                        IP = inet4Address.getHostAddress();
+                        break;
+                    }
+                }
+            }
+            if (IP.isEmpty()) {
+                IP = InetAddress.getLocalHost().getHostAddress();
+            }
+        } catch (SocketException | UnknownHostException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * get local ip
+     *
+     * @return local ip
+     */
+    public static String getLocalIp() {
+        return IP;
+    }
+
+    /**
+     * Parse the remote address of the channel.
+     */
+    public static String parseRemoteAddress(final Channel channel) {
+        if (null == channel) {
+            return StringUtils.EMPTY;
+        }
+        final SocketAddress remote = channel.remoteAddress();
+        return doParse(remote != null ? remote.toString().trim() : StringUtils.EMPTY);
+    }
+
+    /**
+     * <ol>
+     * <li>if an address starts with a '/', skip it.
+     * <li>if an address contains a '/', substring it.
+     * </ol>
+     */
+    private static String doParse(String addr) {
+        if (StringUtils.isBlank(addr)) {
+            return StringUtils.EMPTY;
+        }
+        if (addr.charAt(0) == '/') {
+            return addr.substring(1);
+        } else {
+            int len = addr.length();
+            for (int i = 1; i < len; ++i) {
+                if (addr.charAt(i) == '/') {
+                    return addr.substring(i + 1);
+                }
+            }
+            return addr;
+        }
+    }
+
+}

common/src/main/java/com/oceanbase/clogproxy/common/util/Password.java

+package com.oceanbase.clogproxy.common.util;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-07-22
+ */
+public class Password {
+    private String value;
+
+    public void set(String value) {
+        this.value = value;
+    }
+
+    public String get() {
+        return value;
+    }
+
+    @Override
+    public String toString() {
+        return "******";
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/util/TaskExecutor.java

+package com.oceanbase.clogproxy.common.util;
+
+import com.google.common.collect.Maps;
+
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.Future;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-07-17
+ * <p>
+ * Handle all async task or background thread, wrapping all Thread related action.
+ * This benefits us to change Thread Schedule Framework, maybe Coroutine in the future.
+ */
+public class TaskExecutor {
+
+    private static class Singleton {
+        private static final TaskExecutor INSTANCE = new TaskExecutor();
+    }
+
+    public static TaskExecutor instance() {
+        return TaskExecutor.Singleton.INSTANCE;
+    }
+
+    private TaskExecutor() { }
+
+    public static class Task<T> {
+        protected Future<T> future;
+        protected Failure failure;
+
+        public T get() {
+            try {
+                return future.get();
+            } catch (InterruptedException | ExecutionException e) {
+                if (failure != null) {
+                    failure.onError(e);
+                }
+                return null;
+            }
+        }
+
+        public void join() {
+            get();
+        }
+    }
+
+    public static class BackgroundTask extends Task<Void> {
+
+        public void join() {
+            try {
+                future.get();
+            } catch (InterruptedException | ExecutionException e) {
+                if (failure != null) {
+                    failure.onError(e);
+                }
+            }
+        }
+    }
+
+    public interface Failure {
+        void onError(Exception e);
+    }
+
+    private ExecutorService asyncTasks = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
+        60L, TimeUnit.SECONDS, new SynchronousQueue<>(), (ThreadFactory) Thread::new);
+
+    private ExecutorService bgTasks = new ThreadPoolExecutor(0, Integer.MAX_VALUE,
+        60L, TimeUnit.SECONDS, new SynchronousQueue<>(), (ThreadFactory) Thread::new);
+
+    private Map<String, ConcurrentTask> concurrentTasks = Maps.newConcurrentMap();
+
+    public <T> Task<T> async(Callable<T> callable) {
+        return async(callable, null);
+    }
+
+    public <T> Task<T> async(Callable<T> callable, Failure failure) {
+        Task<T> task = new Task<>();
+        task.future = asyncTasks.submit(callable);
+        task.failure = failure;
+        return task;
+    }
+
+    public BackgroundTask background(Callable<Void> callable) {
+        return background(callable, null);
+    }
+
+    public BackgroundTask background(Callable<Void> callable, Failure failure) {
+        BackgroundTask task = new BackgroundTask();
+        task.future = bgTasks.submit(callable);
+        task.failure = failure;
+        return task;
+    }
+
+    public static class ConcurrentTask {
+        private ExecutorService concurrentTasks;
+
+        public ConcurrentTask(int parallelism) {
+            // Never exceed actual CPU core count for init count, or got an Exception
+            concurrentTasks = new ForkJoinPool(Math.min(parallelism,
+                Runtime.getRuntime().availableProcessors()),
+                ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true);
+        }
+
+        public <T> Future<T> concurrent(Callable<T> callable) {
+            return concurrentTasks.submit(callable);
+        }
+    }
+
+    public ConcurrentTask refConcurrent(String name, int parallelism) {
+        ConcurrentTask task = concurrentTasks.get(name);
+        if (task != null) {
+            return task;
+        }
+        task = new ConcurrentTask(parallelism);
+        concurrentTasks.put(name, task);
+        return task;
+    }
+
+    public int getAsyncTaskCount() {
+        return ((ThreadPoolExecutor) asyncTasks).getActiveCount();
+    }
+
+    public int getBgTaskCount() {
+        return ((ThreadPoolExecutor) bgTasks).getActiveCount();
+    }
+
+    public int getConcurrentTaskCount() {
+        int count = 0;
+        for (ConcurrentTask t : concurrentTasks.values()) {
+            count += ((ForkJoinPool) t.concurrentTasks).getActiveThreadCount();
+        }
+        return count;
+    }
+}

common/src/main/java/com/oceanbase/clogproxy/common/util/TypeTrait.java

+package com.oceanbase.clogproxy.common.util;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.lang.reflect.Field;
+
+/**
+ * @author Fankux(yuqi.fy)
+ * @since 2020-06-13
+ */
+public class TypeTrait {
+    public static boolean isNumber(Object obj) {
+        return (obj instanceof Byte) || (obj instanceof Short) ||
+                (obj instanceof Integer) || (obj instanceof Long);
+    }
+
+    public static boolean isNumber(Field field) {
+        String typeName = field.getGenericType().getTypeName();
+        return typeName.equals("byte") || typeName.equals("java.lang.Byte") ||
+                typeName.equals("short") || typeName.equals("java.lang.Short") ||
+                typeName.equals("int") || typeName.equals("java.lang.Integer") ||
+                typeName.equals("long") || typeName.equals("java.lang.Long");
+    }
+
+    public static boolean isReal(Object obj) {
+        return (obj instanceof Float) || (obj instanceof Double);
+    }
+
+    public static boolean isReal(Field field) {
+        String typeName = field.getGenericType().getTypeName();
+        return typeName.equals("float") || typeName.equals("java.lang.Float") ||
+                typeName.equals("double") || typeName.equals("java.lang.Double");
+    }
+
+    public static boolean isBool(Object obj) {
+        return obj instanceof Boolean;
+    }
+
+    public static boolean isBool(Field field) {
+        String typeName = field.getGenericType().getTypeName();
+        return typeName.equals("boolean") || typeName.equals("java.lang.Boolean");
+    }
+
+    public static boolean isString(Object obj) {
+        return (obj instanceof Character) || (obj instanceof String);
+    }
+
+    public static boolean isString(Field field) {
+        String typeName = field.getGenericType().getTypeName();
+        return typeName.equals("char") || typeName.equals("java.lang.Character") ||
+                typeName.equals("java.lang.String");
+    }
+
+    public static boolean isSameLooseType(Object object, Field field) {
+        return (isNumber(object) && isNumber(field)) ||
+                (isReal(object) && isReal(field)) ||
+                (isBool(object) && isBool(field)) ||
+                (isString(object) && isString(field));
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T fromString(String value, Class<?> clazz) {
+        if (clazz == Byte.class || clazz == byte.class) {
+            return (T) Byte.valueOf(value);
+        } else if (clazz == Short.class || clazz == short.class) {
+            return (T) Short.valueOf(value);
+        } else if (clazz == Integer.class || clazz == int.class) {
+            return (T) Integer.valueOf(value);
+        } else if (clazz == Long.class || clazz == long.class) {
+            return (T) Long.valueOf(value);
+        } else if (clazz == Float.class || clazz == float.class) {
+            return (T) Float.valueOf(value);
+        } else if (clazz == Double.class || clazz == double.class) {
+            return (T) Double.valueOf(value);
+        } else if (clazz == Boolean.class || clazz == boolean.class) {
+            return (T) (Boolean) (!StringUtils.isEmpty(value) && Boolean.parseBoolean(value));
+        } else if (clazz == Character.class || clazz == char.class) {
+            if (StringUtils.isNotEmpty(value)) {
+                return (T) (Character) value.charAt(0);
+            }
+        } else if (clazz == String.class) {
+            return (T) value;
+        }
+        return null;
+    }
+}

common/src/test/resources/logback-test.xml

+<?xml version="1.0"?>
+<configuration>
+    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>[%d{yyy-MM-dd HH:mm:ss.SSS}][%p][%t][%c{0}:%line] %m%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="console"/>
+    </root>
+</configuration>
\ No newline at end of file

conf/conf.json

+{
+  "service_port": 2983,
+  "encode_threadpool_size": 8,
+  "encode_queue_size": 20000,
+  "max_packet_bytes": 8388608,
+  "record_queue_size": 1024,
+  "read_timeout_us": 2000000,
+  "read_fail_interval_us": 1000000,
+  "read_wait_num": 20000,
+  "send_timeout_us": 2000000,
+  "send_fail_interval_us": 1000000,
+  "command_timeout_s": 10,
+  "log_quota_size_mb": 5120,
+  "log_quota_day": 30,
+  "log_gc_interval_s": 43200,
+  "oblogreader_path_retain_hour": 168,
+  "oblogreader_lease_s": 300,
+  "oblogreader_path": "./run",
+  "allow_all_tenant": true,
+  "auth_user": true,
+  "auth_use_rs": false,
+  "auth_allow_sys_user": true,
+  "ob_sys_username": "",
+  "ob_sys_password": "",
+  "counter_interval_s": 2,
+  "metric_interval_s": 120,
+  "debug": false,
+  "verbose": false,
+  "verbose_packet": false,
+  "readonly": false,
+  "count_record": false,
+  "channel_type": "plain",
+  "tls_ca_cert_file": "",
+  "tls_cert_file": "",
+  "tls_key_file": "",
+  "tls_verify_peer": true,
+  "liboblog_tls": false,
+  "liboblog_tls_cert_path": ""
+}

demo/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>com.oceanbase.clogproxy</groupId>
+        <artifactId>clogproxy</artifactId>
+        <version>1.0.1-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>demo</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.oceanbase.clogproxy</groupId>
+            <artifactId>client</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-cli</artifactId>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>logproxy-demo</finalName>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-deploy-plugin</artifactId>
+                <version>2.8.2</version>
+                <configuration>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
\ No newline at end of file

demo/src/main/java/com/oceanbase/clogproxy/demo/Demo.java

+package com.oceanbase.clogproxy.demo;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.Lists;
+import com.oceanbase.clogproxy.client.ErrorCode;
+import com.oceanbase.clogproxy.client.LogProxyClient;
+import com.oceanbase.clogproxy.client.LogProxyClientException;
+import com.oceanbase.clogproxy.client.RecordListener;
+import com.oceanbase.clogproxy.client.config.ClientConf;
+import com.oceanbase.clogproxy.client.config.ObReaderConfig;
+import com.oceanbase.oms.record.Field;
+import com.oceanbase.oms.record.RecordType;
+import com.oceanbase.oms.record.Struct;
+import com.oceanbase.oms.record.oms.OmsIndexSchema;
+import com.oceanbase.oms.record.oms.OmsRecord;
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.DefaultParser;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * <p> Date: 2020/6/8 </p>
+ *
+ * @author Fankux(yuqi.fy)
+ */
+public class Demo {
+    private static final Logger logger = LoggerFactory.getLogger(Demo.class);
+
+    public static void main(String[] args) {
+        Options options = new Options();
+        options.addOption("i", "instanceId", true, "cluster Id");
+        options.addOption("l", "instanceUrl", true, "cluster Url");
+        options.addOption("h", "host", true, "host address");
+        options.addOption("P", "port", true, "host port");
+        options.addOption("u", "username", true, "username to connect");
+        options.addOption("p", "password", true, "password to connect");
+        options.addOption("c", "checkpoint", true, "checkpoint to start(UNIX timestamp)");
+        options.addOption("t", "tableWhiteList", true, "table whilte list to filter");
+        options.addOption("e", "properties", true, "extra K-V properties");
+
+        String address = "";
+        int port = 0;
+        ObReaderConfig config = new ObReaderConfig();
+
+        CommandLineParser parser = new DefaultParser();
+        try {
+            CommandLine cmd = parser.parse(options, args);
+            for (Option opt : cmd.getOptions()) {
+                switch (opt.getOpt()) {
+                    case "i":
+                        config.setInstanceId(opt.getValue());
+                        break;
+                    case "l":
+                        config.setInstanceUrl(opt.getValue());
+                        break;
+                    case "h":
+                        address = opt.getValue();
+                        break;
+                    case "P":
+                        port = Integer.parseInt(opt.getValue());
+                        break;
+                    case "u":
+                        config.setUsername(opt.getValue());
+                        break;
+                    case "p":
+                        config.setPassword(opt.getValue());
+                        break;
+                    case "c":
+                        config.setStartTimestamp(Long.parseLong(opt.getValue()));
+                        break;
+                    case "t":
+                        config.setTableWhiteList(opt.getValue());
+                        break;
+                    case "e":
+//                        config.setExtraConfigs();
+                        break;
+                    default:
+                        for (Option option : options.getOptions()) {
+                            System.out.printf("-%s,--%s\t\t\t%s%n", option.getOpt(), option.getLongOpt(), option.getDescription());
+                        }
+                        return;
+                }
+            }
+        } catch (ParseException e) {
+            logger.error("failed to parse command line: ", e);
+            return;
+        }
+        if (StringUtils.isEmpty(address) || port == 0) {
+            logger.error("failed to initiate caused by empty address or not port specified");
+            return;
+        }
+
+        Joiner joiner = Joiner.on(',');
+
+        logger.info("conf: {}", config.toString());
+        ClientConf.USER_DEFINED_CLIENTID = "LogProxyClientDemo";
+        ClientConf.IGNORE_UNKNOWN_RECORD_TYPE = true;
+        LogProxyClient logProxyClient = new LogProxyClient(address, port, config);
+        logProxyClient.addListener(new RecordListener() {
+            @Override
+            public void notify(OmsRecord record) {
+                if (record.getRecordType() == RecordType.HEARTBEAT) {
+                    logger.info("HEARTBEAT: {}:{}:{}", record.meta().getDbTypeRaw(), record.meta().getTimestamp(), record.meta().getCheckpoint());
+                    return;
+                }
+                if (record.getRecordType() == RecordType.INSERT) {
+                    List<String> colums = Optional.ofNullable(record.getPostStruct().fields()).orElse(Lists.newArrayList()).
+                        stream().map(field -> '`' + field.name() + '`').collect(Collectors.toList());
+                    List<Object> values = Optional.ofNullable(record.getPostStruct().values()).orElse(Lists.newArrayList()).
+                        stream().map(o -> '\'' + o.toString() + '\'').collect(Collectors.toList());
+                    assert (colums.size() != values.size());
+
+                    String insertSql = String.format("INSERT INTO `%s`.`%s`(%s) VALUES (%s)",
+                        record.meta().getDatabase(), record.meta().getTable(), joiner.join(colums), joiner.join(values));
+                    logger.info(insertSql);
+                    return;
+                }
+
+                if (record.getRecordType() == RecordType.DELETE) {
+                    OmsIndexSchema uniqueSchema = record.getPostStruct().schema().chosenUidIndex();
+                    if (uniqueSchema == null) {
+                        throw new LogProxyClientException(ErrorCode.E_PARSE, "None Unique Key record: " + record.toString());
+                    }
+
+                    List<String> keyNames = uniqueSchema.getIndexFields().stream().map(Field::name).collect(Collectors.toList());
+                    List<String> keyValues = uniqueSchema.getIndexFields().stream().map(f ->
+                        record.getPostStruct().get(f).toString()).collect(Collectors.toList());
+                    assert (keyNames.size() != keyValues.size());
+                    StringBuilder deleteSql = new StringBuilder(String.format("DELETE FROM `%s`.`%s` WHERE ",
+                        record.meta().getDatabase(), record.meta().getTable()));
+                    for (int i = 0; i < keyNames.size(); ++i) {
+                        deleteSql.append("`").append(keyNames.get(i)).append("`='").append(keyValues.get(i)).append('\'');
+                        if (i != keyNames.size() - 1) {
+                            deleteSql.append(" AND ");
+                        }
+                    }
+                    logger.info(deleteSql.toString());
+                }
+
+                if (record.getRecordType() == RecordType.UPDATE) {
+                    StringBuilder sb = new StringBuilder(String.format("UPDATE `%s`.`%s` SET ", record.meta().getDatabase(),
+                        record.meta().getTable()));
+                    List<Field> fields = record.getPostStruct().fields();
+                    for (int i = 1; i < fields.size(); i += 1) {
+                        sb.append("`").append(fields.get(i).name()).append("`='").
+                            append(record.getPostStruct().get(fields.get(i))).append('\'');
+                        if (i != fields.size() - 1) {
+                            sb.append(", ");
+                        }
+                    }
+
+                    sb.append(" WHERE ");
+
+                    OmsIndexSchema uniqueSchema = record.getPostStruct().schema().chosenUidIndex();
+                    if (uniqueSchema == null) {
+                        throw new LogProxyClientException(ErrorCode.E_PARSE, "None Unique Key record: " + record.toString());
+                    }
+                    List<String> keyNames = uniqueSchema.getIndexFields().stream().map(Field::name).collect(Collectors.toList());
+                    List<String> keyValues = uniqueSchema.getIndexFields().stream().map(f ->
+                        record.getPostStruct().get(f).toString()).collect(Collectors.toList());
+                    assert (keyNames.size() != keyValues.size());
+                    StringBuilder whereSql = new StringBuilder();
+                    for (int i = 0; i < keyNames.size(); ++i) {
+                        whereSql.append("`").append(keyNames.get(i)).append("`").append("=").append("'").append(keyValues.get(i)).append("'");
+                        if (i != keyNames.size() - 1) {
+                            whereSql.append(" AND ");
+                        }
+                        logger.info(whereSql.toString());
+                    }
+                    sb.append(whereSql);
+
+                    logger.info(sb.toString());
+                }
+
+                if (record.getRecordType() == RecordType.DDL) {
+                    logger.info(record.toString());
+                }
+            }
+
+            @Override
+            public void onException(LogProxyClientException e) {
+                logger.error("LogProxy Client exception occured: ", e);
+                if (e.needStop()) {
+                    logProxyClient.stop();
+                }
+            }
+        });
+
+        logProxyClient.addStatusListener(status -> logger.info("Runtime Status: {}", status.toString().replace("\n", ", ")));
+
+        logProxyClient.start();
+        logProxyClient.join();
+    }
+
+    static String getFieldValue(Struct struct, Field field) {
+        return struct.get(field).toString();
+    }
+}