Merge pull request #1589 from fengzeroz/v2.6

version: 2.6.1

.github/workflows/check.yml

@@ -40,7 +40,7 @@ jobs:
 
   ut:
     runs-on: ubuntu-20.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.6
 
 
     steps:
@@ -75,7 +75,7 @@ jobs:
 
   ft:
     runs-on: ubuntu-20.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.6
 
     steps:
       - uses: actions/checkout@v2
@@ -108,12 +108,13 @@ jobs:
 
   pyft:
     runs-on: ubuntu-20.04
-    container: ghcr.io/neugates/build:x86_64-main
+    container: ghcr.io/neugates/build:x86_64-v2.6
 
     steps:
       - uses: actions/checkout@v2
         with:
           submodules: recursive
+          fetch-depth: 0
       
       - name: compile
         run: |
@@ -122,11 +123,25 @@ jobs:
           cmake .. -DCMAKE_TOOLCHAIN_FILE=../cmake/x86_64-linux-gnu.cmake
           make -j4
 
+      - name: get neuron current branch
+        shell: bash
+        run: |
+          if [ '${{ github.event_name }}' == 'push' ]; then
+            branch=${{ github.ref_name }}
+          elif [ '${{ github.event_name }}' == 'pull_request' ]; then
+            branch=${{ github.event.pull_request.base.ref }}
+          elif [ '${{ github.event_name }}' == 'release' ]; then
+            branch=${{ github.event.release.target_commitish }}
+          fi
+          echo "BRANCH=$branch" >> $GITHUB_ENV
+          echo "neuron current branch is $branch"
+
       - name: fetch neu-ft
         uses: actions/checkout@v2
         with:
             repository: neugates/neu-ft
             path: neu-ft
+            ref: ${{ env.BRANCH }}
 
       - name: function test
         run: |

.github/workflows/ci.yml

@@ -8,9 +8,9 @@ on:
       - published
 
 env:
-  VERSION: 2.6.0
-  UI_VERSION: 2.5.0
-  BRANCH: main
+  VERSION: 2.6.1
+  UI_VERSION: 2.6.1
+  BRANCH: v2.6
 
 jobs:
   cross-build:
@@ -21,10 +21,10 @@ jobs:
           - [aarch64-linux-gnu, aarch64, arm64]
           - [arm-linux-gnueabihf, armv4, armhf]
           - [x86_64-linux-gnu, x86_64, amd64]
-    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-main
+    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-v2.6
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: recursive
 
@@ -54,7 +54,7 @@ jobs:
 
       - uses: actions/upload-artifact@v3
         with:
-          name: neuron-sdk-${{ matrix.arch[2] }}
+          name: neuron-sdk
           path: |
             neuron-sdk-*.tar.gz
 
@@ -64,10 +64,10 @@ jobs:
       matrix:
         arch:
           - [x86_64-linux-gnu, x86_64, amd64]
-    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-main
+    container: ghcr.io/neugates/build:${{ matrix.arch[1] }}-v2.6
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: recursive
 
@@ -85,15 +85,14 @@ jobs:
 
       - uses: actions/upload-artifact@v3
         with:
-          name: neuron-sdk-debug-${{ matrix.arch[2] }}
+          name: neuron-sdk
           path: |
             neuron-sdk-debug-*.tar.gz
-
-  create_daily_release:
-    runs-on: ubuntu-20.04
+  
+  create_update_daily_release:
+    runs-on: ubuntu-latest
     if: github.event_name == 'push'
     needs: [cross-build, build-debug-sdk]
-
     steps:
       - name: delete old daily-pre-release
         uses: dev-drprasad/delete-tag-and-release@v0.2.1
@@ -103,159 +102,17 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: create daily-pre-release
-        id: create_release
-        uses: actions/create-release@v1
+      - uses: actions/download-artifact@v3
+        with:
+          name: neuron-sdk
+      
+      - uses: softprops/action-gh-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
+          name: Daily Release(${{ env.BRANCH }})
           tag_name: ${{ env.BRANCH }}-daily
-          release_name: Daily Release(${{ env.BRANCH }})
           draft: false
           prerelease: true
-
-      - shell: bash
-        run: |
-          echo "${{ steps.create_release.outputs.upload_url }}" > release_url.txt
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: release_url
-          path: release_url.txt
-        
-  upload_daily_release_asset:
-    runs-on: ubuntu-20.04
-    if: github.event_name == 'push'
-    needs: create_daily_release
-    strategy:
-      matrix:
-        arch: [arm64, armhf, amd64]
-        type: [neuron-sdk]
-        package: [tar.gz]
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-
-      - uses: actions/download-artifact@v2
-        with:
-          name: release_url
-
-      - id: release_url
-        run: |
-          value=`cat release_url.txt`
-          echo "name=$value" >> $GITHUB_OUTPUT
-
-      - uses: actions/download-artifact@v2
-        with:
-          name: ${{ matrix.type }}-${{ matrix.arch }}
-      
-      - id: package
-        run: echo "name=${{ matrix.type }}-${{ env.VERSION }}-${{ matrix.arch }}.${{ matrix.package }}" >> $GITHUB_OUTPUT
-
-      - name: upload daily release asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1.0.2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.release_url.outputs.name }}
-          asset_path: ./${{ steps.package.outputs.name }}
-          asset_name: ${{ matrix.type }}-${{ env.VERSION }}-daily-linux-${{ matrix.arch }}.${{ matrix.package }}
-          asset_content_type: application/octet-stream
-
-  upload_daily_release_debug_asset:
-    runs-on: ubuntu-20.04
-    if: github.event_name == 'push'
-    needs: create_daily_release
-    strategy:
-      matrix:
-        arch: [amd64]
-        type: [neuron-sdk-debug]
-        package: [tar.gz]
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-
-      - uses: actions/download-artifact@v2
-        with:
-          name: release_url
-
-      - id: release_url
-        run: |
-          value=`cat release_url.txt`
-          echo "name=$value" >> $GITHUB_OUTPUT
-
-      - uses: actions/download-artifact@v2
-        with:
-          name: ${{ matrix.type }}-${{ matrix.arch }}
-      
-      - id: package
-        run: echo "name=${{ matrix.type }}-${{ env.VERSION }}-${{ matrix.arch }}.${{ matrix.package }}" >> $GITHUB_OUTPUT
-
-      - name: upload daily release asset
-        id: upload-release-asset
-        uses: actions/upload-release-asset@v1.0.2
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.release_url.outputs.name }}
-          asset_path: ./${{ steps.package.outputs.name }}
-          asset_name: ${{ matrix.type }}-${{ env.VERSION }}-daily-linux-${{ matrix.arch }}.${{ matrix.package }}
-          asset_content_type: application/octet-stream
-
-  clean:
-    runs-on: ubuntu-20.04
-    needs: [upload_daily_release_asset, upload_daily_release_debug_asset]
-    steps:
-      - uses: geekyeggo/delete-artifact@v1
-        with:
-          name: release_url
-  
-  release:
-    runs-on: ubuntu-20.04
-    if: github.event_name == 'release'
-    needs: cross-build
-    strategy:
-      matrix:
-        arch: [arm64, armhf, amd64]
-        type: [neuron-sdk]
-        package: [tar.gz]
-
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-
-      - uses: actions/download-artifact@v2
-        with:
-          name: ${{ matrix.type }}-${{ matrix.arch }}
-      
-      - id: package
-        run: echo "name=${{ matrix.type }}-${{ env.VERSION }}-${{ matrix.arch }}.${{ matrix.package }}" >> $GITHUB_OUTPUT
-
-      - name: gen packages sha256
-        run: sudo bash -c "echo $(sha256sum ./${{ steps.package.outputs.name }} | awk '{print $1}') > ./${{ steps.package.outputs.name }}.sha256"
-
-      - uses: actions/upload-release-asset@v1
-        if: github.event_name == 'release'
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        with:
-          upload_url: ${{ github.event.release.upload_url }}
-          asset_path: ./${{ steps.package.outputs.name}}.sha256
-          asset_name: ${{ matrix.type }}-${{ env.VERSION }}-linux-${{ matrix.arch }}.${{ matrix.package }}.sha256
-          asset_content_type: application/octet-stream
-
-      - uses: actions/upload-release-asset@v1
-        if: github.event_name == 'release'
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        with:
-          upload_url: ${{ github.event.release.upload_url }}
-          asset_path: ./${{ steps.package.outputs.name}}
-          asset_name: ${{ matrix.type }}-${{ env.VERSION }}-linux-${{ matrix.arch }}.${{ matrix.package }}
-          asset_content_type: application/octet-stream
+          files: |
+            neuron-sdk-*

CMakeLists.txt

@@ -129,6 +129,7 @@ set(NEURON_SOURCES
     plugins/restful/handle.c
     plugins/restful/log_handle.c
     plugins/restful/file_handle.c
+    plugins/restful/metric_handle.c
     plugins/restful/normal_handle.c
     plugins/restful/rw_handle.c
     plugins/restful/adapter_handle.c

cmake/aarch64-linux-gnu.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX aarch64-linux-gnu)
 set(CMAKE_SYSTEM_PROCESSOR aarch64)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.6/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/arm-linux-gnueabi.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX arm-linux-gnueabi)
 set(CMAKE_SYSTEM_PROCESSOR armv5tejl)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.6/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/arm-linux-gnueabihf.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX arm-linux-gnueabihf)
 set(CMAKE_SYSTEM_PROCESSOR armv7l)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.6/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

cmake/x86_64-linux-gnu.cmake

@@ -1,7 +1,7 @@
 set(CMAKE_SYSTEM_NAME Linux)
 set(COMPILER_PREFIX x86_64-linux-gnu)
 set(CMAKE_SYSTEM_PROCESSOR x86_64)
-set(LIBRARY_DIR /home/neuron/main/libs)
+set(LIBRARY_DIR /home/neuron/v2.6/libs)
 
 set(CMAKE_C_COMPILER ${COMPILER_PREFIX}-gcc)
 set(CMAKE_CXX_COMPILER ${COMPILER_PREFIX}-g++)

dev.conf

@@ -4,10 +4,12 @@ file perms = 666
 
 [formats]
 
-stdout_format = "%d [%V] [%c] %f:%L %m%n"
-file_format = "%d [%V] %f:%L %m%n"
+stdout_format = "%d:%ms [%V] [%c] %f:%L %m%n"
+file_format = "%d:%ms [%V] %f:%L %m%n"
+syslog = "%d:%ms %H neuron[%p]: [%V] [%c] %f:%L %m%n"
 
 [rules]
 
 *.*     "./logs/%c.log", 50MB * 1 ~ "./logs/%c.#2s.log"; file_format
 *.*    	>stdout; stdout_format
+*.*     $remote_syslog; syslog

ft/metrics_test.robot

@@ -5,8 +5,8 @@ Resource            resource/api.resource
 Resource            resource/common.resource
 Resource            resource/error.resource
 
-Suite Setup         Start Neuronx
-Suite Teardown      Stop Neuronx
+Suite Setup         Metrics Test Setup
+Suite Teardown      Metrics Test Teardown
 
 
 *** Test Cases ***
@@ -30,4 +30,14 @@ Check node state, it should return success
     ${nlines}=    Get metrics lines
     ${parameter_lines}=    Get parameter lines    ${nlines}
 
-    Check node state    ${parameter_lines}
+    Check node state    ${parameter_lines}
+
+*** Keywords ***
+Metrics Test Setup
+    Start Neuronx
+    ${res}=         Add Node    monitor           ${PLUGIN_MONITOR}
+    Check Response Status       ${res}            200
+
+Metrics Test Teardown
+    Del Node        monitor
+    Stop Neuronx

ft/modbus_rtu_test.robot

@@ -193,5 +193,5 @@ Modbus Test Teardown
     Terminate All Processes    kill=false
 
 Start Modbus-RTU Simulator
-    ${handle} =	Start Process    ${MODBUS_TCP_SERVER_SIMULATOR}	rtu	60503   cwd=build/simulator
+    ${handle} =	Start Process    ${MODBUS_TCP_SERVER_SIMULATOR}	rtu	60503  ip_v4   cwd=build/simulator
     [Return]	${handle}

ft/node_test.robot

@@ -93,18 +93,6 @@ Update node name to the same, it should fail as name conflicts
 	Check Response Status    ${res}    409
 	Check Error Code         ${res}    ${NEU_ERR_NODE_EXIST}
 
-Update monitor node, it should fail
-	${res} =    Update Node    monitor        monitor-new
-
-	Check Response Status    ${res}    400
-	Check Error Code         ${res}    ${NEU_ERR_NODE_NOT_ALLOW_UPDATE}
-
-Update node name to monitor, it should fail
-	${res} =    Update Node    modbus-node    monitor
-
-	Check Response Status    ${res}    409
-	Check Error Code         ${res}    ${NEU_ERR_NODE_EXIST}
-
 Update driver node name, it should success
 	${res} =    Update Node    modbus-node    modbus-node-new
 	Check Response Status    ${res}    200

ft/resource/api.resource

@@ -258,8 +258,9 @@ Add Template Group
   [RETURN]            ${res}[0]
 
 Put Template Group
-  [Arguments]         ${tmpl}                 ${group}            ${interval}
-  PUT                 /api/v2/template/group  {"template": "${tmpl}", "group": "${group}", "interval": ${interval}}
+  [Arguments]         ${tmpl}                 ${group}            &{updates}
+  ${data} =           Evaluate                json.dumps({"template": "${tmpl}", "group": "${group}", **$updates})     json
+  PUT                 /api/v2/template/group  ${data}
   ${res} =            Object  response body
   [RETURN]            ${res}[0]
 

ft/resource/common.resource

@@ -18,6 +18,7 @@ ${test_data_dir}     ft/data
 
 
 ${PLUGIN_MODBUS_TCP}	Modbus TCP
+${PLUGIN_MONITOR}	Monitor
 ${PLUGIN_MQTT}    MQTT
 
 ${MQTT_CMD_NONE}                             

ft/resource/error.resource

@@ -95,3 +95,5 @@ ${NEU_ERR_PLUGIN_NOT_FOUND}                     3014
 ${NEU_ERR_PLUGIN_DEVICE_NOT_RESPONSE}           3015
 ${NEU_ERR_PLUGIN_NOT_SUPPORT_TEMPLATE}          3016
 ${NEU_ERR_PLUGIN_NOT_SUPPORT_WRITE_TAGS}        3017
+
+${NEU_ERR_MQTT_SUBSCRIBE_FAILURE}               4010

ft/resource/simulator.resource

@@ -8,7 +8,7 @@ ${OPCUA_SERVER_SIMULATOR}         ./opcua_simulator
 
 *** Keywords ***
 Start Modbus Simulator
-	${handle} =	Start Process    ${MODBUS_TCP_SERVER_SIMULATOR}	tcp	60502   cwd=build/simulator
+	${handle} =	Start Process    ${MODBUS_TCP_SERVER_SIMULATOR}	tcp	60502  ip_v4   cwd=build/simulator
 	[Return]	${handle}
 
 Start Simulator Arg

ft/subscribe_test.robot

@@ -45,6 +45,14 @@ North APP subscribe multiple nonexistent groups, it should fail.
 	Check Response Status           ${res}      404
 	Check Error Code                ${res}      ${NEU_ERR_GROUP_NOT_EXIST}
 
+North MQTT APP subscribe with empty topic, it should fail.
+	${g1} =     Evaluate            {"driver": "modbus-node", "group": "group1", "params":{"topic":""}}
+
+	${res}=     Subscribe Groups    mqtt        ${g1}
+
+	Check Response Status           ${res}      200
+	Check Error Code                ${res}      ${NEU_ERR_MQTT_SUBSCRIBE_FAILURE}
+
 North APP subscribe multiple groups, it should return success
 	Add Group   modbus-node         group1      1000
 	Add Group   modbus-node         group2      1000

ft/template.robot

@@ -496,7 +496,7 @@ Get groups from existent template having one group, it should success.
 
 
 Update group interval when template does not exist, it should fail.
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${1000}
     Check Response Status         ${res}                404
     Check Error Code              ${res}                ${NEU_ERR_TEMPLATE_NOT_FOUND}
 
@@ -508,7 +508,7 @@ Update group using too long template name in request, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_long_str}                 ${g_group1}[name]     ${2000}
+    ${res} =                      Put Template Group    ${g_long_str}                 ${g_group1}[name]     interval=${2000}
     Check Response Status         ${res}                400
     Check Error Code              ${res}                ${NEU_ERR_TEMPLATE_NAME_TOO_LONG}
 
@@ -520,7 +520,7 @@ Update group using too long group name in request, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_long_str}         ${2000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_long_str}         interval=${2000}
     Check Response Status         ${res}                400
     Check Error Code              ${res}                ${NEU_ERR_GROUP_NAME_TOO_LONG}
 
@@ -532,7 +532,7 @@ Update group interval when group does not exist, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${1000}
     Check Response Status         ${res}                404
     Check Error Code              ${res}                ${NEU_ERR_GROUP_NOT_EXIST}
 
@@ -544,7 +544,7 @@ Update group interval to invalid value, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${10}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${10}
     Check Response Status         ${res}                400
     Check Error Code              ${res}                ${NEU_ERR_GROUP_PARAMETER_INVALID}
 
@@ -556,7 +556,7 @@ Update group interval, it should success.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${1000}
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
@@ -568,6 +568,93 @@ Update group interval, it should success.
     [Teardown]                    Del Template          ${g_template}
 
 
+Update group with empty new name, it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=${EMPTY}
+    Check Response Status         ${res}                400
+    Check Error Code              ${res}                ${NEU_ERR_BODY_IS_WRONG}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group with too long new name, it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=${g_long_str}
+    Check Response Status         ${res}                400
+    Check Error Code              ${res}                ${NEU_ERR_GROUP_NAME_TOO_LONG}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group name to conflicting group name, it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Add Template Group    ${g_template}                 grp                   ${1000}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp
+    Check Response Status         ${res}                409
+    Check Error Code              ${res}                ${NEU_ERR_GROUP_EXIST}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group name, it should success.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Get Template Groups   ${g_template}
+    Check Response Status         ${res}                200
+    Should Have Only One Group    ${res}[groups]        grp                           ${g_group1}[interval]
+    Group Tag Count Should Be     ${res}[groups][0]     2
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group with at least name or interval, otherwise it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]
+    Check Response Status         ${res}                400
+    Check Error Code              ${res}                ${NEU_ERR_BODY_IS_WRONG}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group name and interval, it should success.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp      interval=${1000}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Get Template Groups   ${g_template}
+    Check Response Status         ${res}                200
+    Should Have Only One Group    ${res}[groups]        grp                           ${1000}
+    Group Tag Count Should Be     ${res}[groups][0]     2
+
+    [Teardown]                    Del Template          ${g_template}
+
+
 Delete group from nonexistent template, it should fail.
     ${res} =                      Del Template Group    ${g_template}                 ${g_group1}[name]
     Check Response Status         ${res}                404
@@ -642,7 +729,7 @@ Template groups should be persisted.
     Should Have Only One Group    ${res}[groups]        ${g_group1}[name]             ${g_group1}[interval]
     Group Tag Count Should Be     ${res}[groups][0]     0
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp      interval=${1000}
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
@@ -650,10 +737,10 @@ Template groups should be persisted.
 
     ${res} =                      Get Template Groups   ${g_template}
     Check Response Status         ${res}                200
-    Should Have Only One Group    ${res}[groups]        ${g_group1}[name]             ${1000}
+    Should Have Only One Group    ${res}[groups]        grp                           ${1000}
     Group Tag Count Should Be     ${res}[groups][0]     0
 
-    ${res} =                      Del Template Group    ${g_template}                 ${g_group1}[name]
+    ${res} =                      Del Template Group    ${g_template}                 grp
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 

include/neuron/adapter.h

@@ -24,8 +24,11 @@
 extern "C" {
 #endif
 
+#include <pthread.h>
 #include <stdint.h>
 
+#include "json/neu_json_rw.h"
+
 #include "define.h"
 #include "metrics.h"
 #include "tag.h"
@@ -34,11 +37,11 @@ extern "C" {
 typedef struct {
     neu_node_running_state_e running;
     neu_node_link_state_e    link;
+    char                     log_level[NEU_LOG_LEVEL_LEN];
 } neu_node_state_t;
 
 typedef enum neu_reqresp_type {
     NEU_RESP_ERROR,
-    NEU_REQ_UPDATE_LICENSE,
 
     NEU_REQ_READ_GROUP,
     NEU_RESP_READ_GROUP,
@@ -144,8 +147,7 @@ typedef enum neu_reqresp_type {
 } neu_reqresp_type_e;
 
 static const char *neu_reqresp_type_string_t[] = {
-    [NEU_RESP_ERROR]         = "NEU_RESP_ERROR",
-    [NEU_REQ_UPDATE_LICENSE] = "NEU_REQ_UPDATE_LICENSE",
+    [NEU_RESP_ERROR] = "NEU_RESP_ERROR",
 
     [NEU_REQ_READ_GROUP]  = "NEU_REQ_READ_GROUP",
     [NEU_RESP_READ_GROUP] = "NEU_RESP_READ_GROUP",
@@ -260,6 +262,7 @@ typedef struct neu_reqresp_head {
     void *             ctx;
     char               sender[NEU_NODE_NAME_LEN];
     char               receiver[NEU_NODE_NAME_LEN];
+    uint32_t           len;
 } neu_reqresp_head_t;
 
 typedef struct neu_resp_error {
@@ -391,6 +394,30 @@ typedef struct {
     neu_datatag_t *tags;
 } neu_req_add_tag_t, neu_req_update_tag_t;
 
+static inline void neu_req_add_tag_fini(neu_req_add_tag_t *req)
+{
+    for (uint16_t i = 0; i < req->n_tag; i++) {
+        neu_tag_fini(&req->tags[i]);
+    }
+    free(req->tags);
+}
+
+static inline int neu_req_add_tag_copy(neu_req_add_tag_t *dst,
+                                       neu_req_add_tag_t *src)
+{
+    strcpy(dst->driver, src->driver);
+    strcpy(dst->group, src->group);
+    dst->tags = (neu_datatag_t *) calloc(src->n_tag, sizeof(src->tags[0]));
+    if (NULL == dst->tags) {
+        return -1;
+    }
+    dst->n_tag = src->n_tag;
+    for (uint16_t i = 0; i < src->n_tag; i++) {
+        neu_tag_copy(&dst->tags[i], &src->tags[i]);
+    }
+    return 0;
+}
+
 typedef struct {
     uint16_t index;
     int      error;
@@ -403,6 +430,36 @@ typedef struct neu_req_del_tag {
     char **  tags;
 } neu_req_del_tag_t;
 
+static inline void neu_req_del_tag_fini(neu_req_del_tag_t *req)
+{
+    for (uint16_t i = 0; i < req->n_tag; i++) {
+        free(req->tags[i]);
+    }
+    free(req->tags);
+}
+
+static inline int neu_req_del_tag_copy(neu_req_del_tag_t *dst,
+                                       neu_req_del_tag_t *src)
+{
+    strcpy(dst->driver, src->driver);
+    strcpy(dst->group, src->group);
+    dst->tags = (char **) calloc(src->n_tag, sizeof(src->tags[0]));
+    if (NULL == dst->tags) {
+        return -1;
+    }
+    dst->n_tag = src->n_tag;
+    for (uint16_t i = 0; i < src->n_tag; ++i) {
+        dst->tags[i] = strdup(src->tags[i]);
+        if (NULL == dst->tags[i]) {
+            while (i-- > 0) {
+                free(dst->tags[i]);
+            }
+            free(dst->tags);
+        }
+    }
+    return 0;
+}
+
 typedef struct neu_req_get_tag {
     char driver[NEU_NODE_NAME_LEN];
     char group[NEU_GROUP_NAME_LEN];
@@ -414,10 +471,11 @@ typedef struct neu_resp_get_tag {
 } neu_resp_get_tag_t;
 
 typedef struct {
-    char  app[NEU_NODE_NAME_LEN];
-    char  driver[NEU_NODE_NAME_LEN];
-    char  group[NEU_GROUP_NAME_LEN];
-    char *params;
+    char     app[NEU_NODE_NAME_LEN];
+    char     driver[NEU_NODE_NAME_LEN];
+    char     group[NEU_GROUP_NAME_LEN];
+    uint16_t port;
+    char *   params;
 } neu_req_subscribe_t;
 
 typedef struct {
@@ -427,9 +485,10 @@ typedef struct {
 } neu_req_unsubscribe_t;
 
 typedef struct {
-    char *driver;
-    char *group;
-    char *params;
+    char *   driver;
+    char *   group;
+    uint16_t port;
+    char *   params;
 } neu_req_subscribe_group_info_t;
 
 typedef struct {
@@ -491,6 +550,19 @@ typedef struct neu_req_node_setting {
     char *setting;
 } neu_req_node_setting_t;
 
+static inline void neu_req_node_setting_fini(neu_req_node_setting_t *req)
+{
+    free(req->setting);
+}
+
+static inline int neu_req_node_setting_copy(neu_req_node_setting_t *dst,
+                                            neu_req_node_setting_t *src)
+{
+    strcpy(dst->node, src->node);
+    dst->setting = strdup(src->setting);
+    return dst->setting ? 0 : -1;
+}
+
 typedef struct neu_req_get_node_setting {
     char node[NEU_NODE_NAME_LEN];
 } neu_req_get_node_setting_t;
@@ -612,7 +684,14 @@ typedef struct {
     char     tmpl[NEU_TEMPLATE_NAME_LEN];
     char     group[NEU_GROUP_NAME_LEN];
     uint32_t interval;
-} neu_req_add_template_group_t, neu_req_update_template_group_t;
+} neu_req_add_template_group_t;
+
+typedef struct {
+    char     tmpl[NEU_TEMPLATE_NAME_LEN];
+    char     group[NEU_GROUP_NAME_LEN];
+    char     new_name[NEU_GROUP_NAME_LEN];
+    uint32_t interval;
+} neu_req_update_template_group_t;
 
 typedef struct {
     char tmpl[NEU_TEMPLATE_NAME_LEN];
@@ -687,9 +766,6 @@ static inline void neu_req_inst_templates_fini(neu_req_inst_templates_t *req)
     free(req->insts);
 }
 
-typedef struct neu_req_update_license {
-} neu_req_update_license_t;
-
 typedef struct neu_req_read_group {
     char driver[NEU_NODE_NAME_LEN];
     char group[NEU_GROUP_NAME_LEN];
@@ -713,6 +789,12 @@ typedef struct neu_resp_tag_value_meta {
     neu_tag_meta_t metas[NEU_TAG_META_SIZE];
 } neu_resp_tag_value_meta_t;
 
+static inline UT_icd *neu_resp_tag_value_meta_icd()
+{
+    static UT_icd icd = { sizeof(neu_resp_tag_value_meta_t), NULL, NULL, NULL };
+    return &icd;
+}
+
 typedef struct neu_req_write_tags {
     char driver[NEU_NODE_NAME_LEN];
     char group[NEU_GROUP_NAME_LEN];
@@ -722,19 +804,155 @@ typedef struct neu_req_write_tags {
 } neu_req_write_tags_t;
 
 typedef struct {
-    char                       driver[NEU_NODE_NAME_LEN];
-    char                       group[NEU_GROUP_NAME_LEN];
-    uint16_t                   n_tag;
-    neu_resp_tag_value_meta_t *tags;
+    char driver[NEU_NODE_NAME_LEN];
+    char group[NEU_GROUP_NAME_LEN];
+
+    UT_array *tags; // neu_resp_tag_value_meta_t
 } neu_resp_read_group_t;
 
+static inline void neu_resp_read_free(neu_resp_read_group_t *resp)
+{
+    utarray_foreach(resp->tags, neu_resp_tag_value_meta_t *, tag_value)
+    {
+        if (tag_value->value.type == NEU_TYPE_PTR) {
+            free(tag_value->value.value.ptr.ptr);
+        }
+    }
+    utarray_free(resp->tags);
+}
+
 typedef struct {
-    char                      driver[NEU_NODE_NAME_LEN];
-    char                      group[NEU_GROUP_NAME_LEN];
-    uint16_t                  n_tag;
-    neu_resp_tag_value_meta_t tags[];
+    uint16_t        index;
+    pthread_mutex_t mtx;
+} neu_reqresp_trans_data_ctx_t;
+
+typedef struct {
+    char driver[NEU_NODE_NAME_LEN];
+    char group[NEU_GROUP_NAME_LEN];
+
+    neu_reqresp_trans_data_ctx_t *ctx;
+    UT_array *                    tags; // neu_resp_tag_value_meta_t
 } neu_reqresp_trans_data_t;
 
+static inline void neu_trans_data_free(neu_reqresp_trans_data_t *data)
+{
+    pthread_mutex_lock(&data->ctx->mtx);
+    if (data->ctx->index > 0) {
+        data->ctx->index -= 1;
+    }
+
+    if (data->ctx->index == 0) {
+        utarray_foreach(data->tags, neu_resp_tag_value_meta_t *, tag_value)
+        {
+            if (tag_value->value.type == NEU_TYPE_PTR) {
+                free(tag_value->value.value.ptr.ptr);
+            }
+        }
+        utarray_free(data->tags);
+        pthread_mutex_unlock(&data->ctx->mtx);
+        pthread_mutex_destroy(&data->ctx->mtx);
+        free(data->ctx);
+    } else {
+        pthread_mutex_unlock(&data->ctx->mtx);
+    }
+}
+
+static inline void neu_tag_value_to_json(neu_resp_tag_value_meta_t *tag_value,
+                                         neu_json_read_resp_tag_t * tag_json)
+{
+    tag_json->name  = tag_value->tag;
+    tag_json->error = 0;
+
+    for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
+        if (strlen(tag_value->metas[k].name) > 0) {
+            tag_json->n_meta++;
+        } else {
+            break;
+        }
+    }
+    if (tag_json->n_meta > 0) {
+        tag_json->metas = (neu_json_tag_meta_t *) calloc(
+            tag_json->n_meta, sizeof(neu_json_tag_meta_t));
+    }
+    neu_json_metas_to_json(tag_value->metas, NEU_TAG_META_SIZE, tag_json);
+
+    switch (tag_value->value.type) {
+    case NEU_TYPE_ERROR:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.i32;
+        tag_json->error         = tag_value->value.value.i32;
+        break;
+    case NEU_TYPE_UINT8:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.u8;
+        break;
+    case NEU_TYPE_INT8:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.i8;
+        break;
+    case NEU_TYPE_INT16:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.i16;
+        break;
+    case NEU_TYPE_INT32:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.i32;
+        break;
+    case NEU_TYPE_INT64:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.i64;
+        break;
+    case NEU_TYPE_WORD:
+    case NEU_TYPE_UINT16:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.u16;
+        break;
+    case NEU_TYPE_DWORD:
+    case NEU_TYPE_UINT32:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.u32;
+        break;
+    case NEU_TYPE_LWORD:
+    case NEU_TYPE_UINT64:
+        tag_json->t             = NEU_JSON_INT;
+        tag_json->value.val_int = tag_value->value.value.u64;
+        break;
+    case NEU_TYPE_FLOAT:
+        tag_json->t               = NEU_JSON_FLOAT;
+        tag_json->value.val_float = tag_value->value.value.f32;
+        tag_json->precision       = tag_value->value.precision;
+        break;
+    case NEU_TYPE_DOUBLE:
+        tag_json->t                = NEU_JSON_DOUBLE;
+        tag_json->value.val_double = tag_value->value.value.d64;
+        tag_json->precision        = tag_value->value.precision;
+        break;
+    case NEU_TYPE_BOOL:
+        tag_json->t              = NEU_JSON_BOOL;
+        tag_json->value.val_bool = tag_value->value.value.boolean;
+        break;
+    case NEU_TYPE_BIT:
+        tag_json->t             = NEU_JSON_BIT;
+        tag_json->value.val_bit = tag_value->value.value.u8;
+        break;
+    case NEU_TYPE_STRING:
+        tag_json->t             = NEU_JSON_STR;
+        tag_json->value.val_str = tag_value->value.value.str;
+        break;
+    case NEU_TYPE_PTR:
+        tag_json->t             = NEU_JSON_STR;
+        tag_json->value.val_str = (char *) tag_value->value.value.ptr.ptr;
+        break;
+    case NEU_TYPE_BYTES:
+        tag_json->t                      = NEU_JSON_BYTES;
+        tag_json->value.val_bytes.length = tag_value->value.value.bytes.length;
+        tag_json->value.val_bytes.bytes  = tag_value->value.value.bytes.bytes;
+        break;
+    default:
+        break;
+    }
+}
+
 typedef struct {
     char node[NEU_NODE_NAME_LEN];
 } neu_reqresp_node_deleted_t;
@@ -827,9 +1045,11 @@ typedef struct {
 
 typedef struct neu_req_update_log_level {
     char node[NEU_NODE_NAME_LEN];
+    char log_level[NEU_LOG_LEVEL_LEN];
 } neu_req_update_log_level_t;
 
-void *neu_msg_gen(neu_reqresp_head_t *header, void *data);
+void  neu_msg_gen(neu_reqresp_head_t *header, void *data);
+void *neu_trans_data_gen(neu_reqresp_head_t *header, void *data);
 
 inline static void neu_msg_exchange(neu_reqresp_head_t *header)
 {
@@ -861,6 +1081,8 @@ typedef struct adapter_callbacks {
     int (*command)(neu_adapter_t *adapter, neu_reqresp_head_t head, void *data);
     int (*response)(neu_adapter_t *adapter, neu_reqresp_head_t *head,
                     void *data);
+    int (*responseto)(neu_adapter_t *adapter, neu_reqresp_head_t *head,
+                      void *data, struct sockaddr_in dst);
     neu_adapter_register_metric_cb_t register_metric;
     neu_adapter_update_metric_cb_t   update_metric;
 

include/neuron/connection/neu_connection.h

@@ -298,4 +298,7 @@ int neu_conn_wait_msg(neu_conn_t *conn, void *context, uint16_t n_byte,
 int neu_conn_tcp_server_wait_msg(neu_conn_t *conn, int fd, void *context,
                                  uint16_t n_byte, neu_conn_process_msg fn);
 
+int is_ipv4(const char *ip);
+int is_ipv6(const char *ip);
+
 #endif

include/neuron/define.h

@@ -37,15 +37,23 @@
 #define NEU_TAG_FLOAG_PRECISION_MAX 17
 #define NEU_USER_PASSWORD_MIN_LEN 4
 #define NEU_USER_PASSWORD_MAX_LEN 16
-#define NEU_LOG_LEVEL_LEN 9
+#define NEU_LOG_LEVEL_LEN 12
 #define NEU_FILE_PATH_LEN 128
+#define NEU_MSG_MAX_SIZE 2048
 
 #define NEU_TAG_META_LENGTH 20
 #define NEU_TAG_META_SIZE 3
 
+#define NEU_LOG_LEVEL_DEBUG "debug"
+#define NEU_LOG_LEVEL_INFO "info"
+#define NEU_LOG_LEVEL_NOTICE "notice"
+#define NEU_LOG_LEVEL_WARN "warn"
+#define NEU_LOG_LEVEL_ERROR "error"
+#define NEU_LOG_LEVEL_FATAL "fatal"
+
 extern int  default_log_level;
 extern bool disable_jwt;
-extern char host_port[24];
+extern char host_port[32];
 
 typedef enum neu_plugin_kind {
     NEU_PLUGIN_KIND_STATIC = 0,
@@ -72,4 +80,9 @@ typedef enum {
     NEU_NODE_RUNNING_STATE_STOPPED = 4,
 } neu_node_running_state_e;
 
+typedef enum {
+    NEU_TAG_CACHE_TYPE_INTERVAL = 0,
+    NEU_TAG_CACHE_TYPE_NEVER,
+} neu_tag_cache_type_e;
+
 #endif

include/neuron/persist/persist.h

@@ -383,10 +383,12 @@ int neu_persister_store_template_group(const char *              tmpl_name,
 /**
  * Update template group.
  * @param tmpl_name                 template name.
+ * @param group_name                group name.
  * @param group_info                group info to persist.
  * @return 0 on success, non-zero otherwise
  */
 int neu_persister_update_template_group(const char *              tmpl_name,
+                                        const char *              group_name,
                                         neu_persist_group_info_t *group_info);
 
 /**

include/neuron/plugin.h

@@ -46,6 +46,7 @@ typedef struct neu_plugin_common {
     char                       name[NEU_NODE_NAME_LEN];
 
     neu_node_link_state_e link_state;
+    char                  log_level[NEU_LOG_LEVEL_LEN];
 
     zlog_category_t *log;
 } neu_plugin_common_t;
@@ -116,6 +117,7 @@ typedef struct neu_plugin_module {
     bool                          single;
     const char *                  single_name;
     neu_event_timer_type_e        timer_type;
+    neu_tag_cache_type_e          cache_type;
 } neu_plugin_module_t;
 
 inline static neu_plugin_common_t *

neuron.json

@@ -1,5 +1,7 @@
 {
 	"ip": "0.0.0.0",
 	"port": 7000,
-	"disable_auth": 0
-}
+	"disable_auth": 0,
+	"syslog_host": "",
+	"syslog_port": 541
+}

persistence/0050_2.6.0_virtual_license.sql

@@ -0,0 +1,24 @@
+/**
+* NEURON IIoT System for Industry 4.0
+* Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 3 of the License, or (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this program; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+**/
+BEGIN;
+
+CREATE TABLE
+  IF NOT EXISTS virtual_license (license TEXT NOT NULL);
+
+COMMIT;

plugins/ekuiper/json_rw.c

@@ -25,111 +25,6 @@
 #include "json_rw.h"
 #include "plugin_ekuiper.h"
 
-int wrap_tag_data(neu_json_read_resp_tag_t * json_tag,
-                  neu_resp_tag_value_meta_t *tag_value)
-{
-    if (NULL == json_tag || NULL == tag_value) {
-        return -1;
-    }
-
-    for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
-        if (strlen(tag_value->metas[k].name) > 0) {
-            json_tag->n_meta++;
-        } else {
-            break;
-        }
-    }
-
-    if (json_tag->n_meta > 0) {
-        json_tag->metas = (neu_json_tag_meta_t *) calloc(
-            json_tag->n_meta, sizeof(neu_json_tag_meta_t));
-        if (json_tag->metas == NULL) {
-            return -1;
-        }
-    }
-
-    neu_json_metas_to_json(tag_value->metas, NEU_TAG_META_SIZE, json_tag);
-
-    json_tag->name  = tag_value->tag;
-    json_tag->error = NEU_ERR_SUCCESS;
-
-    switch (tag_value->value.type) {
-    case NEU_TYPE_INT8:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.i8;
-        break;
-    case NEU_TYPE_UINT8:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.u8;
-        break;
-    case NEU_TYPE_INT16:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.i16;
-        break;
-    case NEU_TYPE_WORD:
-    case NEU_TYPE_UINT16:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.u16;
-        break;
-    case NEU_TYPE_INT32:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.i32;
-        break;
-    case NEU_TYPE_DWORD:
-    case NEU_TYPE_UINT32:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.u32;
-        break;
-    case NEU_TYPE_INT64:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.i64;
-        break;
-    case NEU_TYPE_LWORD:
-    case NEU_TYPE_UINT64:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.u64;
-        break;
-    case NEU_TYPE_FLOAT:
-        json_tag->t               = NEU_JSON_FLOAT;
-        json_tag->value.val_float = tag_value->value.value.f32;
-        break;
-    case NEU_TYPE_DOUBLE:
-        json_tag->t                = NEU_JSON_DOUBLE;
-        json_tag->value.val_double = tag_value->value.value.d64;
-        break;
-    case NEU_TYPE_BIT:
-        json_tag->t             = NEU_JSON_BIT;
-        json_tag->value.val_bit = tag_value->value.value.u8;
-        break;
-    case NEU_TYPE_BOOL:
-        json_tag->t              = NEU_JSON_BOOL;
-        json_tag->value.val_bool = tag_value->value.value.boolean;
-        break;
-    case NEU_TYPE_STRING:
-        json_tag->t             = NEU_JSON_STR;
-        json_tag->value.val_str = tag_value->value.value.str;
-        break;
-    case NEU_TYPE_PTR:
-        json_tag->t             = NEU_JSON_STR;
-        json_tag->value.val_str = (char *) tag_value->value.value.ptr.ptr;
-        break;
-    case NEU_TYPE_ERROR:
-        json_tag->t             = NEU_JSON_INT;
-        json_tag->value.val_int = tag_value->value.value.i32;
-        json_tag->error         = tag_value->value.value.i32;
-        break;
-    case NEU_TYPE_BYTES:
-        json_tag->t                      = NEU_JSON_BYTES;
-        json_tag->value.val_bytes.length = tag_value->value.value.bytes.length;
-        json_tag->value.val_bytes.bytes  = tag_value->value.value.bytes.bytes;
-        break;
-    default:
-        break;
-    }
-
-    return 0;
-}
-
 int json_encode_read_resp_header(void *json_object, void *param)
 {
     int                      ret    = 0;
@@ -186,18 +81,17 @@ int json_encode_read_resp_tags(void *json_object, void *param)
         return -1;
     }
 
-    for (int i = 0; i < trans_data->n_tag; i++) {
+    utarray_foreach(trans_data->tags, neu_resp_tag_value_meta_t *, tag_value)
+    {
         neu_json_read_resp_tag_t json_tag = { 0 };
 
-        if (0 != wrap_tag_data(&json_tag, &trans_data->tags[i])) {
-            continue; // ignore
-        }
+        neu_tag_value_to_json(tag_value, &json_tag);
 
         neu_json_elem_t tag_elem = {
             .name      = json_tag.name,
             .t         = json_tag.t,
             .v         = json_tag.value,
-            .precision = trans_data->tags[i].value.precision,
+            .precision = tag_value->value.precision,
         };
 
         if (json_tag.n_meta > 0) {
@@ -231,22 +125,24 @@ int json_encode_read_resp_tags(void *json_object, void *param)
         }
     }
 
-    neu_json_elem_t resp_elems[] = { {
-                                         .name         = "values",
-                                         .t            = NEU_JSON_OBJECT,
-                                         .v.val_object = values_object,
-                                     },
-                                     {
-                                         .name         = "errors",
-                                         .t            = NEU_JSON_OBJECT,
-                                         .v.val_object = errors_object,
+    neu_json_elem_t resp_elems[] = {
+        {
+            .name         = "values",
+            .t            = NEU_JSON_OBJECT,
+            .v.val_object = values_object,
+        },
+        {
+            .name         = "errors",
+            .t            = NEU_JSON_OBJECT,
+            .v.val_object = errors_object,
 
-                                     },
-                                     {
-                                         .name         = "metas",
-                                         .t            = NEU_JSON_OBJECT,
-                                         .v.val_object = metas_object,
-                                     } };
+        },
+        {
+            .name         = "metas",
+            .t            = NEU_JSON_OBJECT,
+            .v.val_object = metas_object,
+        },
+    };
     // steals `values_object` and `errors_object`
     ret = neu_json_encode_field(json_object, resp_elems,
                                 NEU_JSON_ELEM_SIZE(resp_elems));

plugins/ekuiper/plugin_ekuiper.c

@@ -308,11 +308,6 @@ static int ekuiper_plugin_request(neu_plugin_t *      plugin,
         } else {
             send_data(plugin, trans_data);
         }
-        for (int i = 0; i < trans_data->n_tag; i++) {
-            if (trans_data->tags[i].value.type == NEU_TYPE_PTR) {
-                free(trans_data->tags[i].value.value.ptr.ptr);
-            }
-        }
         break;
     }
     case NEU_REQ_UPDATE_NODE: {
@@ -329,8 +324,6 @@ static int ekuiper_plugin_request(neu_plugin_t *      plugin,
     }
     case NEU_REQ_UNSUBSCRIBE_GROUP:
         break;
-    case NEU_REQ_UPDATE_LICENSE:
-        break;
     default:
         plog_warn(plugin, "unsupported request type: %d", header->type);
         break;

plugins/modbus/modbus-rtu.json

@@ -305,10 +305,6 @@
 		"description_zh": "服务端模式中填写本地 IP，客户端模式中填写目标设备 IP",
 		"attribute": "required",
 		"type": "string",
-		"valid": {
-			"regex": "/^((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)$/",
-			"length": 30
-		},
 		"condition": {
 			"field": "link",
 			"value": 1

plugins/modbus/modbus-tcp.json

@@ -46,27 +46,6 @@
 		}
 	],
 	"group_interval": 1000,
-	"transport_mode": {
-		"name": "Transport Mode",
-		"name_zh": "传输模式",
-		"description": "TCP transfer or UDP transfer",
-		"description_zh": "TCP 传输或 UDP 传输",
-		"attribute": "required",
-		"type": "map",
-		"default": 0,
-		"valid": {
-			"map": [
-				{
-					"key": "TCP",
-					"value": 0
-				},
-				{
-					"key": "UDP",
-					"value": 1
-				}
-			]
-		}
-	},
 	"connection_mode": {
 		"name": "Connection Mode",
 		"name_zh": "连接模式",
@@ -86,10 +65,6 @@
 					"value": 1
 				}
 			]
-		},
-		"condition": {
-			"field": "transport_mode",
-			"value": 0
 		}
 	},
 	"max_retries": {
@@ -137,11 +112,7 @@
 		"description": "Local IP in server mode, remote device IP in client mode",
 		"description_zh": "服务端模式中填写本地 IP，客户端模式中填写目标设备 IP",
 		"attribute": "required",
-		"type": "string",
-		"valid": {
-			"regex": "/^((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)$/",
-			"length": 30
-		}
+		"type": "string"		
 	},
 	"port": {
 		"name": "Port",

plugins/modbus/modbus_point.c

@@ -168,7 +168,8 @@ int modbus_tag_to_point(const neu_datatag_t *tag, modbus_point_t *point)
             point->area == MODBUS_AREA_INPUT) {
             ret = NEU_ERR_TAG_TYPE_NOT_SUPPORT;
         } else {
-            if (point->option.bytes.length > 128) {
+            if (point->option.bytes.length > 128 ||
+                point->option.bytes.length % 2 == 1) {
                 return NEU_ERR_TAG_ADDRESS_FORMAT_INVALID;
             }
             point->n_register =

plugins/modbus/modbus_req.c

@@ -106,7 +106,7 @@ int modbus_send_msg(void *ctx, uint16_t n_byte, uint8_t *bytes)
 
     plog_send_protocol(plugin, bytes, n_byte);
 
-    if (plugin->is_server && plugin->protocol == MODBUS_PROTOCOL_TCP) {
+    if (plugin->is_server) {
         ret = neu_conn_tcp_server_send(plugin->conn, plugin->client_fd, bytes,
                                        n_byte);
     } else {
@@ -152,8 +152,10 @@ int modbus_group_timer(neu_plugin_t *plugin, neu_plugin_group_t *group,
         {
             modbus_point_t *p   = calloc(1, sizeof(modbus_point_t));
             int             ret = modbus_tag_to_point(tag, p);
-            assert(ret == 0);
-
+            if (ret != NEU_ERR_SUCCESS) {
+                plog_error(plugin, "invalid tag: %s, address: %s", tag->name,
+                           tag->address);
+            }
             utarray_push_back(gd->tags, &p);
         }
 
@@ -679,7 +681,12 @@ static int process_protocol_buf(neu_plugin_t *plugin, uint8_t slave_id,
             }
         }
     } else if (plugin->protocol == MODBUS_PROTOCOL_RTU) {
-        ret = neu_conn_recv(plugin->conn, recv_buf, response_size);
+        if (plugin->is_server) {
+            ret = neu_conn_tcp_server_recv(plugin->conn, plugin->client_fd,
+                                           recv_buf, response_size);
+        } else {
+            ret = neu_conn_recv(plugin->conn, recv_buf, response_size);
+        }
 
         if (ret == 0 || ret == -1) {
             free(recv_buf);

plugins/modbus/modbus_tcp.c

@@ -154,14 +154,13 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
                              .v.val_str = NULL };
     neu_json_elem_t  interval  = { .name = "interval", .t = NEU_JSON_INT };
     neu_json_elem_t  mode  = { .name = "connection_mode", .t = NEU_JSON_INT };
-    neu_json_elem_t  tmode = { .name = "transport_mode", .t = NEU_JSON_INT };
     neu_conn_param_t param = { 0 };
     neu_json_elem_t  max_retries = { .name = "max_retries", .t = NEU_JSON_INT };
     neu_json_elem_t  retry_interval = { .name = "retry_interval",
                                        .t    = NEU_JSON_INT };
 
-    ret = neu_parse_param((char *) config, &err_param, 6, &port, &host, &mode,
-                          &timeout, &interval, &tmode);
+    ret = neu_parse_param((char *) config, &err_param, 5, &port, &host, &mode,
+                          &timeout, &interval);
 
     if (ret != 0) {
         plog_error(plugin, "config: %s, decode error: %s", config, err_param);
@@ -192,33 +191,24 @@ static int driver_config(neu_plugin_t *plugin, const char *config)
     plugin->max_retries    = max_retries.v.val_int;
     plugin->retry_interval = retry_interval.v.val_int;
 
-    if (tmode.v.val_int == 1) {
-        param.type                = NEU_CONN_UDP;
-        param.params.udp.timeout  = 3000;
-        param.params.udp.src_ip   = "0.0.0.0";
-        param.params.udp.src_port = 0;
-        param.params.udp.dst_ip   = host.v.val_str;
-        param.params.udp.dst_port = port.v.val_int;
-        plugin->is_server         = false;
-    } else {
-        if (mode.v.val_int == 1) {
-            param.type                           = NEU_CONN_TCP_SERVER;
-            param.params.tcp_server.ip           = host.v.val_str;
-            param.params.tcp_server.port         = port.v.val_int;
-            param.params.tcp_server.start_listen = modbus_tcp_server_listen;
-            param.params.tcp_server.stop_listen  = modbus_tcp_server_stop;
-            param.params.tcp_server.timeout      = timeout.v.val_int;
-            param.params.tcp_server.max_link     = 1;
-            plugin->is_server                    = true;
-        }
-        if (mode.v.val_int == 0) {
-            param.type                      = NEU_CONN_TCP_CLIENT;
-            param.params.tcp_client.ip      = host.v.val_str;
-            param.params.tcp_client.port    = port.v.val_int;
-            param.params.tcp_client.timeout = timeout.v.val_int;
-            plugin->is_server               = false;
-        }
+    if (mode.v.val_int == 1) {
+        param.type                           = NEU_CONN_TCP_SERVER;
+        param.params.tcp_server.ip           = host.v.val_str;
+        param.params.tcp_server.port         = port.v.val_int;
+        param.params.tcp_server.start_listen = modbus_tcp_server_listen;
+        param.params.tcp_server.stop_listen  = modbus_tcp_server_stop;
+        param.params.tcp_server.timeout      = timeout.v.val_int;
+        param.params.tcp_server.max_link     = 1;
+        plugin->is_server                    = true;
     }
+    if (mode.v.val_int == 0) {
+        param.type                      = NEU_CONN_TCP_CLIENT;
+        param.params.tcp_client.ip      = host.v.val_str;
+        param.params.tcp_client.port    = port.v.val_int;
+        param.params.tcp_client.timeout = timeout.v.val_int;
+        plugin->is_server               = false;
+    }
+
     plog_notice(plugin,
                 "config: host: %s, port: %" PRId64 ", mode: %" PRId64 "",
                 host.v.val_str, port.v.val_int, mode.v.val_int);

plugins/monitor/CMakeLists.txt

@@ -6,7 +6,6 @@ file(COPY ${CMAKE_SOURCE_DIR}/plugins/monitor/monitor.json DESTINATION ${CMAKE_B
 set(src
     monitor.c
     monitor_config.c
-    metric_handle.c
     mqtt_handle.c
 )
 

plugins/monitor/monitor.c

@@ -23,7 +23,6 @@
 
 #include "errcodes.h"
 #include "event/event.h"
-#include "metric_handle.h"
 #include "monitor.h"
 #include "mqtt_handle.h"
 #include "utils/http_handler.h"
@@ -48,59 +47,6 @@ static void disconnect_cb(void *data)
                 neu_plugin_module.module_name);
 }
 
-static nng_http_server *server_init()
-{
-    nng_url *        url    = NULL;
-    nng_http_server *server = NULL;
-
-    nlog_notice("monitor bind url: %s", host_port);
-
-    int ret = nng_url_parse(&url, host_port);
-    if (0 != ret) {
-        return NULL;
-    }
-
-    ret = nng_http_server_hold(&server, url);
-    if (0 != ret) {
-        nlog_error("monitor server bind error: %d", ret);
-    }
-
-    nng_url_free(url);
-    return server;
-}
-
-static struct neu_http_handler api_handlers[] = {
-    {
-        .method        = NEU_HTTP_METHOD_GET,
-        .type          = NEU_HTTP_HANDLER_FUNCTION,
-        .url           = "/api/v2/metrics",
-        .value.handler = handle_get_metric,
-    },
-};
-
-static int add_handlers(nng_http_server *server)
-{
-    struct neu_http_handler cors = {
-        .method        = NEU_HTTP_METHOD_OPTIONS,
-        .type          = NEU_HTTP_HANDLER_FUNCTION,
-        .value.handler = neu_http_handle_cors,
-    };
-
-    for (size_t i = 0; i < sizeof(api_handlers) / sizeof(api_handlers[0]);
-         ++i) {
-        if (0 != neu_http_add_handler(server, &api_handlers[0])) {
-            return -1;
-        }
-
-        cors.url = api_handlers[i].url;
-        if (0 != neu_http_add_handler(server, &cors)) {
-            return -1;
-        }
-    }
-
-    return 0;
-}
-
 static int config_mqtt_client(neu_plugin_t *plugin, neu_mqtt_client_t *client,
                               const monitor_config_t *config)
 {
@@ -253,26 +199,6 @@ static neu_plugin_t *monitor_plugin_open(void)
 
     neu_plugin_common_init(&plugin->common);
 
-    if (0 != pthread_mutex_init(&plugin->mutex, NULL)) {
-        free(plugin);
-        return NULL;
-    }
-
-    plugin->api_server = server_init();
-    if (NULL == plugin->api_server) {
-        nlog_error("fail to create monitor server");
-        free(plugin);
-        return NULL;
-    }
-
-    if (0 != add_handlers(plugin->api_server) ||
-        0 != nng_http_server_start(plugin->api_server)) {
-        nlog_error("fail to start monitor server");
-        nng_http_server_release(plugin->api_server);
-        free(plugin);
-        return NULL;
-    }
-
     g_monitor_plugin_ = plugin;
     return plugin;
 }
@@ -281,9 +207,6 @@ static int monitor_plugin_close(neu_plugin_t *plugin)
 {
     int rv = 0;
 
-    nng_http_server_stop(plugin->api_server);
-    nng_http_server_release(plugin->api_server);
-    pthread_mutex_destroy(&plugin->mutex);
     plog_notice(plugin, "Success to free plugin: %s",
                 neu_plugin_module.module_name);
     free(plugin);
@@ -409,8 +332,6 @@ static int monitor_plugin_request(neu_plugin_t *      plugin,
         handle_events(plugin, header->type, data);
         break;
     }
-    case NEU_REQ_UPDATE_LICENSE:
-        break;
     default:
         nlog_warn("recv unsupported msg: %s",
                   neu_reqresp_type_string(header->type));
@@ -493,7 +414,7 @@ const neu_plugin_module_t neu_plugin_module = {
     .kind            = NEU_PLUGIN_KIND_SYSTEM,
     .type            = NEU_NA_TYPE_APP,
     .display         = true,
-    .single          = true,
+    .single          = false,
     .single_name     = "monitor",
 };
 

plugins/monitor/monitor.h

@@ -33,11 +33,9 @@
 
 struct neu_plugin {
     neu_plugin_common_t common;
-    pthread_mutex_t     mutex;
     bool                started;
     neu_events_t *      events;
     neu_event_timer_t * heartbeat_timer;
-    nng_http_server *   api_server;
     monitor_config_t *  config;
     neu_mqtt_client_t * mqtt_client;
 };

plugins/monitor/mqtt_handle.c

@@ -140,8 +140,8 @@ static char *generate_event_json(neu_plugin_t *plugin, neu_reqresp_type_e event,
             update_grp->interval >= NEU_GROUP_INTERVAL_LIMIT;
         json_req.update_grp.interval = update_grp->interval;
         *topic_p                     = plugin->config->group_update_topic;
-        neu_json_encode_by_fn(&json_req, neu_json_encode_add_group_config_req,
-                              &json_str);
+        neu_json_encode_by_fn(
+            &json_req, neu_json_encode_update_group_config_req, &json_str);
         break;
     }
     case NEU_REQ_ADD_TAG_EVENT:
@@ -322,20 +322,12 @@ int handle_events(neu_plugin_t *plugin, neu_reqresp_type_e event, void *data)
 
 end:
     if (NEU_REQ_NODE_SETTING_EVENT == event) {
-        free(((neu_req_node_setting_t *) data)->setting);
+        neu_req_node_setting_fini(data);
     } else if (NEU_REQ_ADD_TAG_EVENT == event ||
                NEU_REQ_UPDATE_TAG_EVENT == event) {
-        neu_req_add_tag_t *add_tag = data;
-        for (uint16_t i = 0; i < add_tag->n_tag; i++) {
-            neu_tag_fini(&add_tag->tags[i]);
-        }
-        free(add_tag->tags);
+        neu_req_add_tag_fini(data);
     } else if (NEU_REQ_DEL_TAG_EVENT == event) {
-        neu_req_del_tag_t *del_tag = data;
-        for (uint16_t i = 0; i < del_tag->n_tag; i++) {
-            free(del_tag->tags[i]);
-        }
-        free(del_tag->tags);
+        neu_req_del_tag_fini(data);
     }
     return rv;
 }

plugins/mqtt/mqtt_handle.c

@@ -27,117 +27,25 @@
 #include "mqtt_handle.h"
 #include "mqtt_plugin.h"
 
-static int tag_values_to_json(neu_resp_tag_value_meta_t *tags, uint16_t len,
-                              neu_json_read_resp_t *json)
+static int tag_values_to_json(UT_array *tags, neu_json_read_resp_t *json)
 {
-    if (0 == len) {
+    int index = 0;
+
+    if (0 == utarray_len(tags)) {
         return 0;
     }
 
-    json->n_tag = len;
+    json->n_tag = utarray_len(tags);
     json->tags  = (neu_json_read_resp_tag_t *) calloc(
         json->n_tag, sizeof(neu_json_read_resp_tag_t));
     if (NULL == json->tags) {
         return -1;
     }
 
-    for (int i = 0; i < json->n_tag; i++) {
-        neu_resp_tag_value_meta_t *tag  = &tags[i];
-        neu_type_e                 type = tag->value.type;
-        json->tags[i].name              = tag->tag;
-        json->tags[i].error             = NEU_ERR_SUCCESS;
-
-        for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
-            if (strlen(tag->metas[k].name) > 0) {
-                json->tags[i].n_meta++;
-            } else {
-                break;
-            }
-        }
-
-        if (json->tags[i].n_meta > 0) {
-            json->tags[i].metas = (neu_json_tag_meta_t *) calloc(
-                json->tags[i].n_meta, sizeof(neu_json_tag_meta_t));
-        }
-
-        neu_json_metas_to_json(tag->metas, NEU_TAG_META_SIZE, &json->tags[i]);
-
-        switch (type) {
-        case NEU_TYPE_ERROR:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.i32;
-            json->tags[i].error         = tag->value.value.i32;
-            break;
-        case NEU_TYPE_UINT8:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.u8;
-            break;
-        case NEU_TYPE_INT8:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.i8;
-            break;
-        case NEU_TYPE_INT16:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.i16;
-            break;
-        case NEU_TYPE_INT32:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.i32;
-            break;
-        case NEU_TYPE_INT64:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.i64;
-            break;
-        case NEU_TYPE_WORD:
-        case NEU_TYPE_UINT16:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.u16;
-            break;
-        case NEU_TYPE_DWORD:
-        case NEU_TYPE_UINT32:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.u32;
-            break;
-        case NEU_TYPE_LWORD:
-        case NEU_TYPE_UINT64:
-            json->tags[i].t             = NEU_JSON_INT;
-            json->tags[i].value.val_int = tag->value.value.u64;
-            break;
-        case NEU_TYPE_FLOAT:
-            json->tags[i].t               = NEU_JSON_FLOAT;
-            json->tags[i].value.val_float = tag->value.value.f32;
-            json->tags[i].precision       = tag->value.precision;
-            break;
-        case NEU_TYPE_DOUBLE:
-            json->tags[i].t                = NEU_JSON_DOUBLE;
-            json->tags[i].value.val_double = tag->value.value.d64;
-            json->tags[i].precision        = tag->value.precision;
-            break;
-        case NEU_TYPE_BOOL:
-            json->tags[i].t              = NEU_JSON_BOOL;
-            json->tags[i].value.val_bool = tag->value.value.boolean;
-            break;
-        case NEU_TYPE_BIT:
-            json->tags[i].t             = NEU_JSON_BIT;
-            json->tags[i].value.val_bit = tag->value.value.u8;
-            break;
-        case NEU_TYPE_STRING:
-            json->tags[i].t             = NEU_JSON_STR;
-            json->tags[i].value.val_str = tag->value.value.str;
-            break;
-        case NEU_TYPE_PTR:
-            json->tags[i].t             = NEU_JSON_STR;
-            json->tags[i].value.val_str = (char *) tag->value.value.ptr.ptr;
-            break;
-        case NEU_TYPE_BYTES:
-            json->tags[i].t = NEU_JSON_BYTES;
-            json->tags[i].value.val_bytes.length =
-                tag->value.value.bytes.length;
-            json->tags[i].value.val_bytes.bytes = tag->value.value.bytes.bytes;
-            break;
-        default:
-            break;
-        }
+    utarray_foreach(tags, neu_resp_tag_value_meta_t *, tag_value)
+    {
+        neu_tag_value_to_json(tag_value, &json->tags[index]);
+        index += 1;
     }
 
     return 0;
@@ -147,15 +55,13 @@ static char *generate_upload_json(neu_plugin_t *            plugin,
                                   neu_reqresp_trans_data_t *data,
                                   mqtt_upload_format_e      format)
 {
-    neu_resp_tag_value_meta_t *tags     = data->tags;
-    uint16_t                   len      = data->n_tag;
-    char *                     json_str = NULL;
-    neu_json_read_periodic_t   header   = { .group     = (char *) data->group,
+    char *                   json_str = NULL;
+    neu_json_read_periodic_t header   = { .group     = (char *) data->group,
                                         .node      = (char *) data->driver,
                                         .timestamp = global_timestamp };
-    neu_json_read_resp_t       json     = { 0 };
+    neu_json_read_resp_t     json     = { 0 };
 
-    if (0 != tag_values_to_json(tags, len, &json)) {
+    if (0 != tag_values_to_json(data->tags, &json)) {
         plog_error(plugin, "tag_values_to_json fail");
         return NULL;
     }
@@ -188,12 +94,12 @@ static char *generate_read_resp_json(neu_plugin_t *         plugin,
                                      neu_json_mqtt_t *      mqtt,
                                      neu_resp_read_group_t *data)
 {
-    neu_resp_tag_value_meta_t *tags     = data->tags;
-    uint16_t                   len      = data->n_tag;
-    char *                     json_str = NULL;
-    neu_json_read_resp_t       json     = { 0 };
+    // neu_resp_tag_value_meta_t *tags     = data->tags;
+    // uint16_t                   len      = data->n_tag;
+    char *               json_str = NULL;
+    neu_json_read_resp_t json     = { 0 };
 
-    if (0 != tag_values_to_json(tags, len, &json)) {
+    if (0 != tag_values_to_json(data->tags, &json)) {
         plog_error(plugin, "tag_values_to_json fail");
         return NULL;
     }

plugins/mqtt/mqtt_plugin.c

@@ -354,14 +354,6 @@ static int mqtt_plugin_request(neu_plugin_t *plugin, neu_reqresp_head_t *head,
         break;
     case NEU_REQRESP_TRANS_DATA: {
         error = handle_trans_data(plugin, data);
-
-        neu_reqresp_trans_data_t *t_data = (neu_reqresp_trans_data_t *) data;
-        for (int i = 0; i < t_data->n_tag; i++) {
-            if (t_data->tags[i].value.type == NEU_TYPE_PTR) {
-                free(t_data->tags[i].value.value.ptr.ptr);
-            }
-        }
-
         break;
     }
     case NEU_REQ_SUBSCRIBE_GROUP:
@@ -382,8 +374,6 @@ static int mqtt_plugin_request(neu_plugin_t *plugin, neu_reqresp_head_t *head,
     case NEU_REQRESP_NODE_DELETED:
         error = handle_del_driver(plugin, data);
         break;
-    case NEU_REQ_UPDATE_LICENSE:
-        break;
     default:
         error = NEU_ERR_MQTT_FAILURE;
         break;

plugins/mqtt/mqtt_plugin.h

@@ -134,7 +134,7 @@ static inline void route_tbl_update_driver(route_entry_t **tbl,
     {
         if (0 == strcmp(e->key.driver, driver)) {
             HASH_DEL(*tbl, e);
-            strcpy(e->key.driver, new_name);
+            strncpy(e->key.driver, new_name, sizeof(e->key.driver));
             HASH_ADD(hh, *tbl, key, sizeof(e->key), e);
         }
     }
@@ -147,7 +147,7 @@ static inline void route_tbl_update_group(route_entry_t **tbl,
     route_entry_t *e = route_tbl_get(tbl, driver, group);
     if (e) {
         HASH_DEL(*tbl, e);
-        strcpy(e->key.group, new_name);
+        strncpy(e->key.group, new_name, sizeof(e->key.group));
         HASH_ADD(hh, *tbl, key, sizeof(e->key), e);
     }
 }

plugins/restful/adapter_handle.c

@@ -330,9 +330,10 @@ void handle_get_node_state_resp(nng_aio *aio, neu_resp_get_node_state_t *state)
     neu_json_get_node_state_resp_t res    = { 0 };
     char *                         result = NULL;
 
-    res.link    = state->state.link;
-    res.running = state->state.running;
-    res.rtt     = state->rtt;
+    res.link      = state->state.link;
+    res.running   = state->state.running;
+    res.rtt       = state->rtt;
+    res.log_level = state->state.log_level;
 
     neu_json_encode_by_fn(&res, neu_json_encode_get_node_state_resp, &result);
 
@@ -357,6 +358,7 @@ void handle_get_nodes_state_resp(nng_aio *                   aio,
         states_res.nodes[index].running = state->state.running;
         states_res.nodes[index].link    = state->state.link;
         states_res.nodes[index].rtt     = state->rtt;
+        states_res.nodes[index].log_level = state->state.log_level;
     }
 
     neu_json_encode_by_fn(&states_res, neu_json_encode_get_nodes_state_resp,

plugins/restful/global_config_handle.c

@@ -103,7 +103,10 @@ static int add_setting(context_t *ctx, neu_json_node_setting_req_t *data);
 
 static inline bool is_static_node(const char *name, const char *plugin)
 {
-    return 0 == strcmp("monitor", name) && 0 == strcmp("Monitor", plugin);
+    (void) name;
+    (void) plugin;
+    return false;
+    // return 0 == strcmp("monitor", name) && 0 == strcmp("Monitor", plugin);
 }
 
 static context_t *context_new(nng_aio *aio, bool get)

plugins/restful/handle.c

@@ -30,6 +30,7 @@
 #include "global_config_handle.h"
 #include "group_config_handle.h"
 #include "log_handle.h"
+#include "metric_handle.h"
 #include "ndriver_handle.h"
 #include "normal_handle.h"
 #include "plugin_handle.h"
@@ -143,6 +144,9 @@ static struct neu_http_handler cors_handler[] = {
     {
         .url = "/api/v2/ndriver/tag",
     },
+    {
+        .url = "/api/v2/metrics",
+    },
 };
 
 static struct neu_http_handler rest_handlers[] = {
@@ -502,6 +506,12 @@ static struct neu_http_handler rest_handlers[] = {
         .url           = "/api/v2/ndriver/tag",
         .value.handler = handle_get_ndriver_tags,
     },
+    {
+        .method        = NEU_HTTP_METHOD_GET,
+        .type          = NEU_HTTP_HANDLER_FUNCTION,
+        .url           = "/api/v2/metrics",
+        .value.handler = handle_get_metric,
+    },
 };
 
 void neu_rest_handler(const struct neu_http_handler **handlers, uint32_t *size)

plugins/restful/log_handle.c

@@ -118,20 +118,57 @@ void handle_log_level(nng_aio *aio)
             neu_req_update_log_level_t cmd    = { 0 };
             zlog_category_t *          ct = zlog_get_category(req->node_name);
             zlog_category_t *          neuron = zlog_get_category("neuron");
+            int                        log_level;
+            static int                 log_level_neuron = 60;
 
-            ret = zlog_level_switch(ct, ZLOG_LEVEL_DEBUG);
+            if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_DEBUG)) {
+                log_level = ZLOG_LEVEL_DEBUG;
+                strcpy(cmd.log_level, NEU_LOG_LEVEL_DEBUG);
+            } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_INFO)) {
+                log_level = ZLOG_LEVEL_INFO;
+                strcpy(cmd.log_level, NEU_LOG_LEVEL_INFO);
+            } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_NOTICE)) {
+                log_level = ZLOG_LEVEL_NOTICE;
+                strcpy(cmd.log_level, NEU_LOG_LEVEL_NOTICE);
+            } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_WARN)) {
+                log_level = ZLOG_LEVEL_WARN;
+                strcpy(cmd.log_level, NEU_LOG_LEVEL_WARN);
+            } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_ERROR)) {
+                log_level = ZLOG_LEVEL_ERROR;
+                strcpy(cmd.log_level, NEU_LOG_LEVEL_ERROR);
+            } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_FATAL)) {
+                log_level = ZLOG_LEVEL_FATAL;
+                strcpy(cmd.log_level, NEU_LOG_LEVEL_FATAL);
+            } else {
+                strcpy(cmd.log_level, "unknow");
+                nlog_error(
+                    "Failed to modify log_level of the node, node_name:%s, ",
+                    req->node_name);
+                NEU_JSON_RESPONSE_ERROR(NEU_ERR_PARAM_IS_WRONG, {
+                    neu_http_response(aio, error_code.error, result_error);
+                });
+                goto end;
+            }
+
+            ret = zlog_level_switch(ct, log_level);
             if (ret != 0) {
-                nlog_error("Modify node log level fail, node_name:%s, "
-                           "ret: %d,",
-                           req->node_name, ret);
+                nlog_error(
+                    "Failed to modify log_level of the node, node_name:%s, "
+                    "ret: %d,",
+                    req->node_name, ret);
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, {
                     neu_http_response(aio, error_code.error, result_error);
                 });
             }
 
-            ret = zlog_level_switch(neuron, ZLOG_LEVEL_DEBUG);
+            if (log_level > log_level_neuron) {
+                log_level_neuron = log_level;
+            }
+
+            ret = zlog_level_switch(neuron, log_level_neuron);
             if (ret != 0) {
-                nlog_error("Modify neuron log level fail, ret: %d", ret);
+                nlog_error("Failed to modify log_level of the node, ret: %d",
+                           ret);
                 NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, {
                     neu_http_response(aio, error_code.error, result_error);
                 });
@@ -147,6 +184,7 @@ void handle_log_level(nng_aio *aio)
                     neu_http_response(aio, NEU_ERR_IS_BUSY, result_error);
                 });
             }
+        end:;
         })
 }
 

plugins/restful/metric_handle.c

@@ -1,6 +1,6 @@
 /**
  * NEURON IIoT System for Industry 4.0
- * Copyright (C) 2020-2022 EMQ Technologies Co., Ltd All rights reserved.
+ * Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -22,12 +22,11 @@
 #include "define.h"
 #include "metrics.h"
 #include "utils/asprintf.h"
+#include "utils/http.h"
+#include "utils/http_handler.h"
 #include "utils/log.h"
 
 #include "metric_handle.h"
-#include "monitor.h"
-#include "utils/http.h"
-#include "utils/http_handler.h"
 
 // clang-format off
 #define METRIC_GLOBAL_TMPL                                                       \
@@ -298,19 +297,18 @@ static void gen_node_metrics(const neu_metrics_t *metrics, struct context *ctx)
 
 void handle_get_metric(nng_aio *aio)
 {
-    int           status = NNG_HTTP_STATUS_OK;
-    char *        result = NULL;
-    size_t        len    = 0;
-    FILE *        stream = NULL;
-    neu_plugin_t *plugin = neu_monitor_get_plugin();
+    int    status = NNG_HTTP_STATUS_OK;
+    char * result = NULL;
+    size_t len    = 0;
+    FILE * stream = NULL;
 
     neu_metrics_category_e cat           = NEU_METRICS_CATEGORY_ALL;
     size_t                 cat_param_len = 0;
     const char *cat_param = neu_http_get_param(aio, "category", &cat_param_len);
     if (NULL != cat_param &&
         !parse_metrics_catgory(cat_param, cat_param_len, &cat)) {
-        plog_error(plugin, "invalid metrics category: %.*s",
-                   (int) cat_param_len, cat_param);
+        nlog_error("invalid metrics category: %.*s", (int) cat_param_len,
+                   cat_param);
         status = NNG_HTTP_STATUS_BAD_REQUEST;
         goto end;
     }

plugins/restful/metric_handle.h

@@ -1,6 +1,6 @@
 /**
  * NEURON IIoT System for Industry 4.0
- * Copyright (C) 2020-2022 EMQ Technologies Co., Ltd All rights reserved.
+ * Copyright (C) 2020-2023 EMQ Technologies Co., Ltd All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,8 +17,8 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  **/
 
-#ifndef NEU_PLUGIN_MONITOR_METRIC_H
-#define NEU_PLUGIN_MONITOR_METRIC_H
+#ifndef NEU_PLUGIN_REST_METRIC_H
+#define NEU_PLUGIN_REST_METRIC_H
 
 #include <nng/nng.h>
 

plugins/restful/rest.c

@@ -240,8 +240,6 @@ static int dashb_plugin_request(neu_plugin_t *      plugin,
         handle_get_ndriver_tags_resp(header->ctx,
                                      (neu_resp_get_ndriver_tags_t *) data);
         break;
-    case NEU_REQ_UPDATE_LICENSE:
-        break;
     default:
         nlog_fatal("recv unhandle msg: %s",
                    neu_reqresp_type_string(header->type));

plugins/restful/rw_handle.c

@@ -79,6 +79,10 @@ void handle_write(nng_aio *aio)
                 return;
             }
 
+            nng_http_req *nng_req = nng_aio_get_input(aio, 0);
+            nlog_notice("<%p> req %s %s", aio, nng_http_req_get_method(nng_req),
+                        nng_http_req_get_uri(nng_req));
+
             header.ctx  = aio;
             header.type = NEU_REQ_WRITE_TAG;
 
@@ -144,6 +148,9 @@ void handle_write_tags(nng_aio *aio)
                 }
             }
 
+            nng_http_req *nng_req = nng_aio_get_input(aio, 0);
+            nlog_notice("<%p> req %s %s", aio, nng_http_req_get_method(nng_req),
+                        nng_http_req_get_uri(nng_req));
             header.ctx  = aio;
             header.type = NEU_REQ_WRITE_TAGS;
 
@@ -200,116 +207,19 @@ void handle_read_resp(nng_aio *aio, neu_resp_read_group_t *resp)
 {
     neu_json_read_resp_t api_res = { 0 };
     char *               result  = NULL;
+    int                  index   = 0;
 
-    api_res.n_tag = resp->n_tag;
+    api_res.n_tag = utarray_len(resp->tags);
     api_res.tags  = calloc(api_res.n_tag, sizeof(neu_json_read_resp_tag_t));
 
-    for (int i = 0; i < resp->n_tag; i++) {
-        neu_resp_tag_value_meta_t *tag = &resp->tags[i];
-
-        api_res.tags[i].name  = resp->tags[i].tag;
-        api_res.tags[i].error = NEU_ERR_SUCCESS;
-
-        for (int k = 0; k < NEU_TAG_META_SIZE; k++) {
-            if (strlen(tag->metas[k].name) > 0) {
-                api_res.tags[i].n_meta++;
-            } else {
-                break;
-            }
-        }
-
-        if (api_res.tags[i].n_meta > 0) {
-            api_res.tags[i].metas = (neu_json_tag_meta_t *) calloc(
-                api_res.tags[i].n_meta, sizeof(neu_json_tag_meta_t));
-        }
-
-        neu_json_metas_to_json(tag->metas, NEU_TAG_META_SIZE, &api_res.tags[i]);
-
-        switch (resp->tags[i].value.type) {
-        case NEU_TYPE_INT8:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.i8;
-            break;
-        case NEU_TYPE_UINT8:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.u8;
-            break;
-        case NEU_TYPE_INT16:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.i16;
-            break;
-        case NEU_TYPE_WORD:
-        case NEU_TYPE_UINT16:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.u16;
-            break;
-        case NEU_TYPE_INT32:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.i32;
-            break;
-        case NEU_TYPE_DWORD:
-        case NEU_TYPE_UINT32:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.u32;
-            break;
-        case NEU_TYPE_INT64:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.i64;
-            break;
-        case NEU_TYPE_LWORD:
-        case NEU_TYPE_UINT64:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.u64;
-            break;
-        case NEU_TYPE_FLOAT:
-            api_res.tags[i].t               = NEU_JSON_FLOAT;
-            api_res.tags[i].value.val_float = resp->tags[i].value.value.f32;
-            api_res.tags[i].precision       = resp->tags[i].value.precision;
-            break;
-        case NEU_TYPE_DOUBLE:
-            api_res.tags[i].t                = NEU_JSON_DOUBLE;
-            api_res.tags[i].value.val_double = resp->tags[i].value.value.d64;
-            api_res.tags[i].precision        = resp->tags[i].value.precision;
-            break;
-        case NEU_TYPE_BIT:
-            api_res.tags[i].t             = NEU_JSON_BIT;
-            api_res.tags[i].value.val_bit = resp->tags[i].value.value.u8;
-            break;
-        case NEU_TYPE_BOOL:
-            api_res.tags[i].t              = NEU_JSON_BOOL;
-            api_res.tags[i].value.val_bool = resp->tags[i].value.value.boolean;
-            break;
-        case NEU_TYPE_STRING:
-            api_res.tags[i].t             = NEU_JSON_STR;
-            api_res.tags[i].value.val_str = resp->tags[i].value.value.str;
-            break;
-        case NEU_TYPE_BYTES:
-            api_res.tags[i].t = NEU_JSON_BYTES;
-            api_res.tags[i].value.val_bytes.length =
-                resp->tags[i].value.value.bytes.length;
-            api_res.tags[i].value.val_bytes.bytes =
-                resp->tags[i].value.value.bytes.bytes;
-            break;
-        case NEU_TYPE_ERROR:
-            api_res.tags[i].t             = NEU_JSON_INT;
-            api_res.tags[i].value.val_int = resp->tags[i].value.value.i32;
-            api_res.tags[i].error         = resp->tags[i].value.value.i32;
-            break;
-        case NEU_TYPE_PTR:
-            api_res.tags[i].t = NEU_JSON_STR;
-            api_res.tags[i].value.val_str =
-                (char *) resp->tags[i].value.value.ptr.ptr;
-            break;
-        default:
-            break;
-        }
+    utarray_foreach(resp->tags, neu_resp_tag_value_meta_t *, tag_value)
+    {
+        neu_tag_value_to_json(tag_value, &api_res.tags[index]);
+        index += 1;
     }
 
     neu_json_encode_by_fn(&api_res, neu_json_encode_read_resp, &result);
-    for (int i = 0; i < resp->n_tag; i++) {
-        if (resp->tags[i].value.type == NEU_TYPE_PTR) {
-            free(resp->tags[i].value.value.ptr.ptr);
-        }
+    for (int i = 0; i < api_res.n_tag; i++) {
         if (api_res.tags[i].n_meta > 0) {
             free(api_res.tags[i].metas);
         }
@@ -317,5 +227,4 @@ void handle_read_resp(nng_aio *aio, neu_resp_read_group_t *resp)
     neu_http_ok(aio, result);
     free(api_res.tags);
     free(result);
-    free(resp->tags);
 }

plugins/restful/template_handle.c

@@ -338,8 +338,8 @@ void handle_get_templates_resp(nng_aio *aio, neu_resp_get_templates_t *resp)
 }
 
 static inline int
-send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
-                            neu_json_template_mod_group_req_t *req)
+send_template_add_group_req(nng_aio *                          aio,
+                            neu_json_template_add_group_req_t *req)
 {
     neu_plugin_t *plugin = neu_rest_get_plugin();
 
@@ -358,7 +358,7 @@ send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
 
     neu_reqresp_head_t header = {
         .ctx  = aio,
-        .type = type,
+        .type = NEU_REQ_ADD_TEMPLATE_GROUP,
     };
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
@@ -368,13 +368,12 @@ send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
     return 0;
 }
 
-static inline void process_mod_template_group(nng_aio *          aio,
-                                              neu_reqresp_type_e type)
+void handle_add_template_group(nng_aio *aio)
 {
     NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
-        aio, neu_json_template_mod_group_req_t,
-        neu_json_decode_template_mod_group_req, {
-            int ret = send_template_mod_group_req(aio, type, req);
+        aio, neu_json_template_add_group_req_t,
+        neu_json_decode_template_add_group_req, {
+            int ret = send_template_add_group_req(aio, req);
             if (ret != 0) {
                 NEU_JSON_RESPONSE_ERROR(
                     ret, { neu_http_response(aio, ret, result_error); });
@@ -382,14 +381,71 @@ static inline void process_mod_template_group(nng_aio *          aio,
         })
 }
 
-void handle_add_template_group(nng_aio *aio)
+static inline int
+send_template_update_group_req(nng_aio *                             aio,
+                               neu_json_template_update_group_req_t *req)
 {
-    process_mod_template_group(aio, NEU_REQ_ADD_TEMPLATE_GROUP);
+    neu_plugin_t *plugin = neu_rest_get_plugin();
+
+    if (strlen(req->tmpl) >= NEU_TEMPLATE_NAME_LEN) {
+        return NEU_ERR_TEMPLATE_NAME_TOO_LONG;
+    } else if (strlen(req->group) >= NEU_GROUP_NAME_LEN) {
+        return NEU_ERR_GROUP_NAME_TOO_LONG;
+    } else if (req->set_interval &&
+               (req->interval < NEU_GROUP_INTERVAL_LIMIT ||
+                req->interval > UINT32_MAX)) {
+        return NEU_ERR_GROUP_PARAMETER_INVALID;
+    }
+
+    // for backward compatibility,
+    // `new_name` or `interval` (inclusive) should be provided
+    if (!req->new_name && !req->set_interval) {
+        return NEU_ERR_BODY_IS_WRONG;
+    }
+
+    neu_req_update_template_group_t cmd = { 0 };
+
+    if (req->new_name) {
+        // if `new_name` is provided, then it should be valid
+        int len = strlen(req->new_name);
+        if (0 == len) {
+            return NEU_ERR_BODY_IS_WRONG;
+        } else if (len >= NEU_GROUP_NAME_LEN) {
+            return NEU_ERR_GROUP_NAME_TOO_LONG;
+        }
+        strcpy(cmd.new_name, req->new_name);
+    } else {
+        // if `new_name` is omitted, then keep the group name
+        strcpy(cmd.new_name, req->group);
+    }
+
+    strcpy(cmd.tmpl, req->tmpl);
+    strcpy(cmd.group, req->group);
+    cmd.interval = req->interval;
+
+    neu_reqresp_head_t header = {
+        .ctx  = aio,
+        .type = NEU_REQ_UPDATE_TEMPLATE_GROUP,
+    };
+
+    if (0 != neu_plugin_op(plugin, header, &cmd)) {
+        return NEU_ERR_IS_BUSY;
+    }
+
+    return 0;
 }
 
 void handle_update_template_group(nng_aio *aio)
 {
-    process_mod_template_group(aio, NEU_REQ_UPDATE_TEMPLATE_GROUP);
+    NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
+        aio, neu_json_template_update_group_req_t,
+        neu_json_decode_template_update_group_req, {
+            int ret = send_template_update_group_req(aio, req);
+            if (ret != 0) {
+                NEU_JSON_RESPONSE_ERROR(
+                    ret, { neu_http_response(aio, ret, result_error); });
+            }
+        })
 }
 
 static inline int

simulator/modbus_simulator.c

@@ -99,8 +99,8 @@ static void sig_handler(int sig)
 
 int main(int argc, char *argv[])
 {
-    if (argc != 3) {
-        printf("./modbus_simulator rtu/tcp port\n");
+    if (argc != 4) {
+        printf("./modbus_simulator rtu/tcp port ip_v4/ip_v6\n");
         return -1;
     }
 
@@ -119,13 +119,23 @@ int main(int argc, char *argv[])
         return -1;
     }
 
+    bool mode_ipv6 = false;
+    if (strncmp(argv[3], "ip_v6", strlen("ip_v6")) == 0) {
+        mode_ipv6 = true;
+    } else if (strncmp(argv[3], "ip_v4", strlen("ip_v4")) == 0) {
+        mode_ipv6 = false;
+    } else {
+        printf("./modbus_simulator rtu/tcp port ip_v4/ip_v6\n");
+        return -1;
+    }
+
     zlog_init("./config/dev.conf");
     neuron = zlog_get_category("neuron");
 
     neu_conn_param_t param = {
         .log                            = neuron,
         .type                           = NEU_CONN_TCP_SERVER,
-        .params.tcp_server.ip           = "0.0.0.0",
+        .params.tcp_server.ip           = mode_ipv6 ? "::" : "0.0.0.0",
         .params.tcp_server.port         = (uint16_t) port,
         .params.tcp_server.timeout      = 0,
         .params.tcp_server.max_link     = 10,

src/adapter/adapter.c

@@ -27,10 +27,6 @@
 #include <sys/time.h>
 #include <unistd.h>
 
-#include <nng/nng.h>
-#include <nng/protocol/pair1/pair.h>
-#include <nng/supplemental/util/platform.h>
-
 #include "utils/log.h"
 
 #include "adapter.h"
@@ -41,11 +37,16 @@
 #include "plugin.h"
 #include "storage.h"
 
+static int adapter_trans_data(enum neu_event_io_type type, int fd,
+                              void *usr_data);
 static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data);
 static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
                            void *data);
 static int adapter_response(neu_adapter_t *adapter, neu_reqresp_head_t *header,
                             void *data);
+static int adapter_responseto(neu_adapter_t *     adapter,
+                              neu_reqresp_head_t *header, void *data,
+                              struct sockaddr_in dst);
 static int adapter_register_metric(neu_adapter_t *adapter, const char *name,
                                    const char *help, neu_metric_type_e type,
                                    uint64_t init);
@@ -56,11 +57,11 @@ inline static void reply(neu_adapter_t *adapter, neu_reqresp_head_t *header,
                          void *data);
 inline static void notify_monitor(neu_adapter_t *    adapter,
                                   neu_reqresp_type_e event, void *data);
-static int         level_check(void *usr_data);
 
 static const adapter_callbacks_t callback_funs = {
     .command         = adapter_command,
     .response        = adapter_response,
+    .responseto      = adapter_responseto,
     .register_metric = adapter_register_metric,
     .update_metric   = adapter_update_metric,
 };
@@ -92,25 +93,6 @@ static __thread int create_adapter_error = 0;
     REGISTER_METRIC(adapter, NEU_METRIC_SEND_MSG_ERRORS_TOTAL, 0); \
     REGISTER_METRIC(adapter, NEU_METRIC_RECV_MSGS_TOTAL, 0);
 
-static inline void start_log_level_timer(neu_adapter_t *adapter)
-{
-    neu_event_timer_param_t timer_level = {
-        .second      = 30,
-        .millisecond = 0,
-        .cb          = level_check,
-        .usr_data    = adapter,
-        .type        = NEU_EVENT_TIMER_BLOCK,
-    };
-
-    adapter->timer_lev = neu_event_add_timer(adapter->events, timer_level);
-}
-
-static inline void stop_log_level_timer(neu_adapter_t *adapter)
-{
-    neu_event_del_timer(adapter->events, adapter->timer_lev);
-    adapter->timer_lev = NULL;
-}
-
 int neu_adapter_error()
 {
     return create_adapter_error;
@@ -138,24 +120,41 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
         break;
     }
 
+    adapter->control_fd =
+        socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+    if (adapter->control_fd <= 0) {
+        free(adapter);
+        return NULL;
+    }
+    adapter->trans_data_fd =
+        socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+    if (adapter->trans_data_fd <= 0) {
+        close(adapter->control_fd);
+        free(adapter);
+        return NULL;
+    }
+
     adapter->name                    = strdup(info->name);
     adapter->events                  = neu_event_new();
     adapter->state                   = NEU_NODE_RUNNING_STATE_INIT;
     adapter->handle                  = info->handle;
     adapter->cb_funs.command         = callback_funs.command;
     adapter->cb_funs.response        = callback_funs.response;
+    adapter->cb_funs.responseto      = callback_funs.responseto;
     adapter->cb_funs.register_metric = callback_funs.register_metric;
     adapter->cb_funs.update_metric   = callback_funs.update_metric;
     adapter->module                  = info->module;
+    adapter->timestamp_lev           = 0;
+    adapter->trans_data_port         = 0;
 
-    adapter->timestamp_lev = 0;
-
-    rv = nng_pair1_open(&adapter->sock);
+    struct sockaddr_in remote = {
+        .sin_family      = AF_INET,
+        .sin_port        = htons(7788),
+        .sin_addr.s_addr = inet_addr("127.0.0.1"),
+    };
+    rv = connect(adapter->control_fd, (struct sockaddr *) &remote,
+                 sizeof(struct sockaddr_in));
     assert(rv == 0);
-    nng_socket_set_int(adapter->sock, NNG_OPT_RECVBUF, 8192);
-    nng_socket_set_int(adapter->sock, NNG_OPT_SENDBUF, 8192);
-    nng_socket_set_ms(adapter->sock, NNG_OPT_SENDTIMEO, 1000);
-    nng_socket_get_int(adapter->sock, NNG_OPT_RECVFD, &adapter->recv_fd);
 
     switch (info->module->type) {
     case NEU_NA_TYPE_DRIVER:
@@ -165,12 +164,34 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
         neu_adapter_driver_init((neu_adapter_driver_t *) adapter);
         break;
     case NEU_NA_TYPE_NDRIVER:
-    case NEU_NA_TYPE_APP:
+    case NEU_NA_TYPE_APP: {
+        while (true) {
+            uint16_t           port  = neu_manager_get_port();
+            struct sockaddr_in local = {
+                .sin_family      = AF_INET,
+                .sin_port        = htons(port),
+                .sin_addr.s_addr = inet_addr("127.0.0.1"),
+            };
+            if (bind(adapter->trans_data_fd, (struct sockaddr *) &local,
+                     sizeof(struct sockaddr_in)) == 0) {
+                adapter->trans_data_port = port;
+                break;
+            }
+        }
+
+        param.usr_data = (void *) adapter;
+        param.cb       = adapter_trans_data;
+        param.fd       = adapter->trans_data_fd;
+
+        adapter->trans_data_io = neu_event_add_io(adapter->events, param);
+
         if (adapter->module->display) {
             REGISTER_APP_METRICS(adapter);
         }
+
         break;
     }
+    }
 
     adapter->plugin = adapter->module->intf_funs->open();
     assert(adapter->plugin != NULL);
@@ -200,17 +221,11 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
         adapter_load_group_and_tag((neu_adapter_driver_t *) adapter);
     }
 
-    param.fd       = adapter->recv_fd;
+    param.fd       = adapter->control_fd;
     param.usr_data = (void *) adapter;
     param.cb       = adapter_loop;
 
-    adapter->nng_io = neu_event_add_io(adapter->events, param);
-    rv = nng_dial(adapter->sock, neu_manager_get_url(), &adapter->dialer, 0);
-    assert(rv == 0);
-
-    start_log_level_timer(adapter);
-
-    nlog_notice("Success to create adapter: %s", adapter->name);
+    adapter->control_io = neu_event_add_io(adapter->events, param);
 
     adapter_storage_state(adapter->name, adapter->state);
 
@@ -220,9 +235,10 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
 
         if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
             neu_adapter_driver_destroy((neu_adapter_driver_t *) adapter);
+        } else {
+            neu_event_del_io(adapter->events, adapter->trans_data_io);
         }
-        stop_log_level_timer(adapter);
-        neu_event_del_io(adapter->events, adapter->nng_io);
+        neu_event_del_io(adapter->events, adapter->control_io);
 
         neu_adapter_destroy(adapter);
         return NULL;
@@ -232,6 +248,11 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load)
     }
 }
 
+uint16_t neu_adapter_trans_data_port(neu_adapter_t *adapter)
+{
+    return adapter->trans_data_port;
+}
+
 int neu_adapter_rename(neu_adapter_t *adapter, const char *new_name)
 {
     char *name     = strdup(new_name);
@@ -247,7 +268,6 @@ int neu_adapter_rename(neu_adapter_t *adapter, const char *new_name)
         return NEU_ERR_EINTERNAL;
     }
 
-    stop_log_level_timer(adapter);
     if (NEU_NA_TYPE_DRIVER == adapter->module->type) {
         neu_adapter_driver_stop_group_timer((neu_adapter_driver_t *) adapter);
     }
@@ -269,7 +289,6 @@ int neu_adapter_rename(neu_adapter_t *adapter, const char *new_name)
     strcpy(common->name, adapter->name);
     zlog_level_switch(common->log, default_log_level);
 
-    start_log_level_timer(adapter);
     if (NEU_NA_TYPE_DRIVER == adapter->module->type) {
         neu_adapter_driver_start_group_timer((neu_adapter_driver_t *) adapter);
     }
@@ -282,18 +301,24 @@ int neu_adapter_rename(neu_adapter_t *adapter, const char *new_name)
 
 void neu_adapter_init(neu_adapter_t *adapter, neu_node_running_state_e state)
 {
-    neu_reqresp_head_t  header   = { .type = NEU_REQ_NODE_INIT };
-    neu_req_node_init_t init     = { 0 };
-    nng_msg *           init_msg = NULL;
+    memset(adapter->buf, 0, sizeof(adapter->buf));
+    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->buf;
+    neu_req_node_init_t init   = { 0 };
 
-    strcpy(header.sender, adapter->name);
-    strcpy(header.receiver, "manager");
+    header->type = NEU_REQ_NODE_INIT;
 
+    strcpy(header->sender, adapter->name);
+    strcpy(header->receiver, "manager");
     strcpy(init.node, adapter->name);
     init.state = state;
-    init_msg   = neu_msg_gen(&header, &init);
 
-    nng_sendmsg(adapter->sock, init_msg, 0);
+    neu_msg_gen(header, &init);
+
+    int ret = send(adapter->control_fd, header, header->len, 0);
+    if (ret != (int) header->len) {
+        nlog_error("%s failed to send init msg to manager, ret: %d, errno: %d",
+                   adapter->name, ret, errno);
+    }
 }
 
 neu_node_type_e neu_adapter_get_type(neu_adapter_t *adapter)
@@ -301,6 +326,11 @@ neu_node_type_e neu_adapter_get_type(neu_adapter_t *adapter)
     return adapter->module->type;
 }
 
+neu_tag_cache_type_e neu_adapter_get_tag_cache_type(neu_adapter_t *adapter)
+{
+    return adapter->module->cache_type;
+}
+
 static int adapter_register_metric(neu_adapter_t *adapter, const char *name,
                                    const char *help, neu_metric_type_e type,
                                    uint64_t init)
@@ -376,21 +406,24 @@ static void adapter_reset_metrics(neu_adapter_t *adapter)
 static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
                            void *data)
 {
-    int      ret = 0;
-    nng_msg *msg = NULL;
+    int     ret                   = 0;
+    uint8_t buf[NEU_MSG_MAX_SIZE] = { 0 };
 
-    strcpy(header.sender, adapter->name);
-    switch (header.type) {
+    neu_reqresp_head_t *pheader = (neu_reqresp_head_t *) buf;
+    *pheader                    = header;
+
+    strcpy(pheader->sender, adapter->name);
+    switch (pheader->type) {
     case NEU_REQ_READ_GROUP:
     case NEU_REQ_WRITE_TAGS:
     case NEU_REQ_WRITE_TAG: {
         neu_req_read_group_t *cmd = (neu_req_read_group_t *) data;
-        strcpy(header.receiver, cmd->driver);
+        strcpy(pheader->receiver, cmd->driver);
         break;
     }
     case NEU_REQ_DEL_NODE: {
         neu_req_del_node_t *cmd = (neu_req_del_node_t *) data;
-        strcpy(header.receiver, cmd->node);
+        strcpy(pheader->receiver, cmd->node);
         break;
     }
     case NEU_REQ_UPDATE_GROUP:
@@ -398,7 +431,7 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
     case NEU_REQ_DEL_GROUP:
     case NEU_REQ_ADD_GROUP: {
         neu_req_add_group_t *cmd = (neu_req_add_group_t *) data;
-        strcpy(header.receiver, cmd->driver);
+        strcpy(pheader->receiver, cmd->driver);
         break;
     }
     case NEU_REQ_GET_TAG:
@@ -406,7 +439,7 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
     case NEU_REQ_DEL_TAG:
     case NEU_REQ_ADD_TAG: {
         neu_req_add_tag_t *cmd = (neu_req_add_tag_t *) data;
-        strcpy(header.receiver, cmd->driver);
+        strcpy(pheader->receiver, cmd->driver);
         break;
     }
     case NEU_REQ_UPDATE_NODE:
@@ -415,97 +448,181 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header,
     case NEU_REQ_GET_NODE_SETTING:
     case NEU_REQ_NODE_SETTING: {
         neu_req_node_setting_t *cmd = (neu_req_node_setting_t *) data;
-        strcpy(header.receiver, cmd->node);
+        strcpy(pheader->receiver, cmd->node);
         break;
     }
     case NEU_REQ_GET_DRIVER_GROUP:
     case NEU_REQ_GET_SUB_DRIVER_TAGS: {
-        strcpy(header.receiver, "manager");
+        strcpy(pheader->receiver, "manager");
         break;
     }
     case NEU_REQRESP_NODE_DELETED: {
         neu_reqresp_node_deleted_t *cmd = (neu_reqresp_node_deleted_t *) data;
-        strcpy(header.receiver, cmd->node);
+        strcpy(pheader->receiver, cmd->node);
         break;
     }
     case NEU_REQ_UPDATE_NDRIVER_TAG_PARAM:
     case NEU_REQ_UPDATE_NDRIVER_TAG_INFO:
     case NEU_REQ_GET_NDRIVER_TAGS: {
         neu_req_get_ndriver_tags_t *cmd = (neu_req_get_ndriver_tags_t *) data;
-        strcpy(header.receiver, cmd->ndriver);
+        strcpy(pheader->receiver, cmd->ndriver);
         break;
     }
     case NEU_REQ_UPDATE_LOG_LEVEL: {
         neu_req_update_log_level_t *cmd = (neu_req_update_log_level_t *) data;
-        strcpy(header.receiver, cmd->node);
+        strcpy(pheader->receiver, cmd->node);
         break;
     }
     default:
         break;
     }
 
-    msg = neu_msg_gen(&header, data);
+    neu_msg_gen(pheader, data);
 
-    ret = nng_sendmsg(adapter->sock, msg, 0);
-    if (ret != 0) {
-        nng_msg_free(msg);
+    ret = send(adapter->control_fd, pheader, pheader->len, 0);
+    if (ret != (int) pheader->len) {
+        nlog_error(
+            "adapter: %s send %d command %s failed, ret: %d-%d, errno: %s(%d)",
+            adapter->name, adapter->control_fd,
+            neu_reqresp_type_string(pheader->type), ret, pheader->len,
+            strerror(errno), errno);
+        return -1;
+    } else {
+        return 0;
     }
-
-    return ret;
 }
 
 static int adapter_response(neu_adapter_t *adapter, neu_reqresp_head_t *header,
                             void *data)
 {
-    switch (header->type) {
-    case NEU_REQRESP_TRANS_DATA:
-        strcpy(header->sender, adapter->name);
-        break;
-    default:
-        neu_msg_exchange(header);
-        break;
-    }
+    assert(header->type != NEU_REQRESP_TRANS_DATA);
+    neu_msg_exchange(header);
 
-    nng_msg *msg = neu_msg_gen(header, data);
-    int      ret = nng_sendmsg(adapter->sock, msg, 0);
-    if (ret != 0) {
-        nng_msg_free(msg);
+    neu_msg_gen(header, data);
+    int ret = send(adapter->control_fd, header, header->len, 0);
+    if (ret <= 0) {
+        nlog_error("adapter: %s send response %s failed, ret: %d, errno: %d",
+                   adapter->name, neu_reqresp_type_string(header->type), ret,
+                   errno);
     }
 
     return ret;
 }
 
-static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
+static int adapter_responseto(neu_adapter_t *     adapter,
+                              neu_reqresp_head_t *header, void *data,
+                              struct sockaddr_in dst)
 {
-    neu_adapter_t *     adapter = (neu_adapter_t *) usr_data;
-    nng_msg *           msg     = NULL;
-    neu_reqresp_head_t *header  = NULL;
+    assert(header->type == NEU_REQRESP_TRANS_DATA);
+    strcpy(header->sender, adapter->name);
 
+    neu_msg_gen(header, data);
+    int ret = sendto(adapter->control_fd, header, header->len, 0,
+                     (struct sockaddr *) &dst, sizeof(dst));
+    if (ret <= 0) {
+        nlog_error("adapter: %s send responseto %s failed, ret: %d, errno: %d",
+                   adapter->name, neu_reqresp_type_string(header->type), ret,
+                   errno);
+    }
+
+    return ret;
+}
+
+static int adapter_trans_data(enum neu_event_io_type type, int fd,
+                              void *usr_data)
+{
+    neu_adapter_t *adapter = (neu_adapter_t *) usr_data;
     if (type != NEU_EVENT_IO_READ) {
         nlog_warn("adapter: %s recv close, exit loop, fd: %d", adapter->name,
                   fd);
         return 0;
     }
 
-    nng_recvmsg(adapter->sock, &msg, 0);
-    header = (neu_reqresp_head_t *) nng_msg_body(msg);
-    nlog_info("adapter(%s) recv msg from: %s, type: %s", adapter->name,
-              header->sender, neu_reqresp_type_string(header->type));
+    memset(adapter->recv_buf, 0, sizeof(adapter->recv_buf));
+    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->recv_buf;
+
+    int rv = recv(adapter->trans_data_fd, adapter->recv_buf,
+                  sizeof(adapter->recv_buf), 0);
+    if (rv <= 0) {
+        nlog_warn("adapter: %s recv trans data failed, ret: %d, errno: %s(%d)",
+                  adapter->name, rv, strerror(errno), errno);
+        return 0;
+    }
+
+    nlog_debug("adapter(%s) recv msg from: %s %p, type: %s", adapter->name,
+               header->sender, header->ctx,
+               neu_reqresp_type_string(header->type));
+
+    if (header->type != NEU_REQRESP_TRANS_DATA &&
+        header->type != NEU_RESP_ERROR) {
+        nlog_warn("adapter: %s recv msg type error, type: %s", adapter->name,
+                  neu_reqresp_type_string(header->type));
+        return 0;
+    }
+
+    adapter->module->intf_funs->request(
+        adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+    if (header->type == NEU_REQRESP_TRANS_DATA) {
+        neu_trans_data_free((neu_reqresp_trans_data_t *) &header[1]);
+    }
+    return 0;
+}
+
+static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
+{
+    neu_adapter_t *adapter = (neu_adapter_t *) usr_data;
+    if (type != NEU_EVENT_IO_READ) {
+        nlog_warn("adapter: %s recv close, exit loop, fd: %d", adapter->name,
+                  fd);
+        return 0;
+    }
+
+    memset(adapter->recv_buf, 0, sizeof(adapter->recv_buf));
+    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->recv_buf;
+
+    int rv = recv(adapter->control_fd, adapter->recv_buf,
+                  sizeof(adapter->recv_buf), 0);
+    if (rv <= 0) {
+        nlog_warn("adapter: %s recv failed, ret: %d, errno: %s(%d)",
+                  adapter->name, rv, strerror(errno), errno);
+        return 0;
+    }
+
+    nlog_info("adapter(%s) recv msg from: %s %p, type: %s", adapter->name,
+              header->sender, header->ctx,
+              neu_reqresp_type_string(header->type));
 
     switch (header->type) {
+    case NEU_REQ_SUBSCRIBE_GROUP: {
+        neu_req_subscribe_t *cmd = (neu_req_subscribe_t *) &header[1];
+        if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
+            neu_adapter_driver_subscribe((neu_adapter_driver_t *) adapter, cmd);
+        } else {
+            adapter->module->intf_funs->request(
+                adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+        }
+        break;
+    }
+    case NEU_REQ_UNSUBSCRIBE_GROUP: {
+        neu_req_unsubscribe_t *cmd = (neu_req_unsubscribe_t *) &header[1];
+        if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
+            neu_adapter_driver_unsubscribe((neu_adapter_driver_t *) adapter,
+                                           cmd);
+        } else {
+            adapter->module->intf_funs->request(
+                adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+        }
+        break;
+    }
+    case NEU_REQ_UPDATE_SUBSCRIBE_GROUP:
     case NEU_RESP_GET_DRIVER_GROUP:
     case NEU_REQRESP_NODE_DELETED:
     case NEU_RESP_GET_SUB_DRIVER_TAGS:
-    case NEU_REQ_UPDATE_LICENSE:
     case NEU_REQ_UPDATE_NODE:
     case NEU_RESP_GET_NODE_STATE:
     case NEU_RESP_GET_NODES_STATE:
     case NEU_RESP_GET_NODE_SETTING:
     case NEU_REQ_UPDATE_GROUP:
-    case NEU_REQ_SUBSCRIBE_GROUP:
-    case NEU_REQ_UPDATE_SUBSCRIBE_GROUP:
-    case NEU_REQ_UNSUBSCRIBE_GROUP:
-    case NEU_RESP_READ_GROUP:
     case NEU_RESP_GET_SUBSCRIBE_GROUP:
     case NEU_RESP_ADD_TAG:
     case NEU_RESP_ADD_TEMPLATE_TAG:
@@ -521,7 +638,6 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_RESP_GET_NDRIVER_TAGS:
     case NEU_RESP_GET_GROUP:
     case NEU_RESP_ERROR:
-    case NEU_REQRESP_TRANS_DATA:
     case NEU_REQRESP_NODES_STATE:
     case NEU_REQ_ADD_NODE_EVENT:
     case NEU_REQ_DEL_NODE_EVENT:
@@ -536,6 +652,11 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         adapter->module->intf_funs->request(
             adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
         break;
+    case NEU_RESP_READ_GROUP:
+        adapter->module->intf_funs->request(
+            adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
+        neu_resp_read_free((neu_resp_read_group_t *) &header[1]);
+        break;
     case NEU_REQ_READ_GROUP: {
         neu_resp_error_t error = { 0 };
 
@@ -555,8 +676,8 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_resp_error_t error = { 0 };
 
         if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
-            void *msg_dump = calloc(nng_msg_len(msg), 1);
-            memcpy(msg_dump, header, nng_msg_len(msg));
+            void *msg_dump = calloc(header->len, 1);
+            memcpy(msg_dump, header, header->len);
             neu_adapter_driver_write_tag((neu_adapter_driver_t *) adapter,
                                          msg_dump);
         } else {
@@ -577,8 +698,8 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_msg_exchange(header);
             reply(adapter, header, &error);
         } else {
-            void *msg_dump = calloc(nng_msg_len(msg), 1);
-            memcpy(msg_dump, header, nng_msg_len(msg));
+            void *msg_dump = calloc(header->len, 1);
+            memcpy(msg_dump, header, header->len);
             neu_adapter_driver_write_tags((neu_adapter_driver_t *) adapter,
                                           msg_dump);
         }
@@ -915,7 +1036,6 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
     }
     case NEU_REQ_NODE_UNINIT: {
         neu_req_node_uninit_t *cmd = (neu_req_node_uninit_t *) &header[1];
-        nng_msg *              uninit_msg                  = NULL;
         char                   name[NEU_NODE_NAME_LEN]     = { 0 };
         char                   receiver[NEU_NODE_NAME_LEN] = { 0 };
 
@@ -925,15 +1045,18 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_msg_exchange(header);
         strcpy(header->sender, adapter->name);
         strcpy(cmd->node, adapter->name);
-        uninit_msg = neu_msg_gen(header, cmd);
+
+        neu_msg_gen(header, cmd);
 
         strcpy(name, adapter->name);
         strcpy(receiver, header->receiver);
-        if (nng_sendmsg(adapter->sock, uninit_msg, 0) == 0) {
-            nlog_notice("%s send uninit msg to %s", name, receiver);
+
+        int ret = send(adapter->control_fd, header, header->len, 0);
+        if (ret != (int) header->len) {
+            nlog_error("%s %d send uninit msg to %s error: %s(%d)", name,
+                       adapter->control_fd, receiver, strerror(errno), errno);
         } else {
-            nng_msg_free(uninit_msg);
-            nlog_error("%s send uninit msg to %s failed", name, receiver);
+            nlog_notice("%s send uninit msg to %s failed", name, receiver);
         }
         break;
     }
@@ -1002,10 +1125,6 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_REQ_UPDATE_LOG_LEVEL: {
         neu_resp_error_t error = { 0 };
 
-        struct timeval tv = { 0 };
-        gettimeofday(&tv, NULL);
-        adapter->timestamp_lev = tv.tv_sec;
-
         neu_msg_exchange(header);
         header->type = NEU_RESP_ERROR;
         reply(adapter, header, &error);
@@ -1014,18 +1133,20 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
     }
 
     default:
+        nlog_warn("adapter: %s recv msg type error, type: %s", adapter->name,
+                  neu_reqresp_type_string(header->type));
         assert(false);
         break;
     }
-    nng_msg_free(msg);
 
     return 0;
 }
 
 void neu_adapter_destroy(neu_adapter_t *adapter)
 {
-    nng_dialer_close(adapter->dialer);
-    nng_close(adapter->sock);
+    nlog_notice("adapter %s destroy", adapter->name);
+    close(adapter->control_fd);
+    close(adapter->trans_data_fd);
 
     adapter->module->intf_funs->close(adapter->plugin);
 
@@ -1064,14 +1185,12 @@ int neu_adapter_uninit(neu_adapter_t *adapter)
     }
     adapter->module->intf_funs->uninit(adapter->plugin);
 
-    neu_event_del_io(adapter->events, adapter->nng_io);
+    neu_event_del_io(adapter->events, adapter->control_io);
 
     if (adapter->module->type == NEU_NA_TYPE_DRIVER) {
         neu_adapter_driver_destroy((neu_adapter_driver_t *) adapter);
     }
 
-    stop_log_level_timer(adapter);
-
     nlog_notice("Stop the adapter(%s)", adapter->name);
     return 0;
 }
@@ -1187,6 +1306,7 @@ neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter)
 
     state.link    = common->link_state;
     state.running = adapter->state;
+    strcpy(state.log_level, common->log_level);
 
     return state;
 }
@@ -1327,67 +1447,44 @@ void neu_adapter_del_group_metrics(neu_adapter_t *adapter,
 inline static void reply(neu_adapter_t *adapter, neu_reqresp_head_t *header,
                          void *data)
 {
-    nng_msg *msg = neu_msg_gen(header, data);
+    neu_msg_gen(header, data);
 
-    int ret = nng_sendmsg(adapter->sock, msg, 0);
-    if (ret != 0) {
-        nng_msg_free(msg);
-        nlog_warn("%s reply %s to %s, error: %s", header->sender,
+    int ret = send(adapter->control_fd, header, header->len, 0);
+    if (ret <= 0) {
+        nlog_warn("%s reply %s to %s, error: %s(%d)", header->sender,
                   neu_reqresp_type_string(header->type), header->receiver,
-                  nng_strerror(ret));
+                  strerror(errno), errno);
     }
 }
 
 inline static void notify_monitor(neu_adapter_t *    adapter,
                                   neu_reqresp_type_e event, void *data)
 {
-    neu_reqresp_head_t header = {
-        .receiver = "monitor",
-        .type     = event,
-    };
+    memset(adapter->buf, 0, sizeof(adapter->buf));
+    neu_reqresp_head_t *header = (neu_reqresp_head_t *) adapter->buf;
 
-    strncpy(header.sender, adapter->name, NEU_NODE_NAME_LEN);
+    strcpy(header->receiver, "manager");
+    strncpy(header->sender, adapter->name, NEU_NODE_NAME_LEN);
+    header->type = event;
 
-    nng_msg *msg = neu_msg_gen(&header, data);
+    neu_msg_gen(header, data);
 
-    int ret = nng_sendmsg(adapter->sock, msg, 0);
-    if (ret != 0) {
-        nng_msg_free(msg);
-        nlog_warn("notify %s of %s, error: %s", header.receiver,
-                  neu_reqresp_type_string(header.type), nng_strerror(ret));
+    int ret = send(adapter->control_fd, header, header->len, 0);
+    if (ret <= 0) {
+        nlog_warn("notify %s of %s, error: %s(%d)", header->receiver,
+                  neu_reqresp_type_string(header->type), strerror(errno),
+                  errno);
     }
 }
 
-static int level_check(void *usr_data)
+void neu_msg_gen(neu_reqresp_head_t *header, void *data)
 {
-    neu_adapter_t *adapter = (neu_adapter_t *) usr_data;
-
-    if (0 != adapter->timestamp_lev) {
-        struct timeval   tv      = { 0 };
-        int64_t          diff    = 0;
-        int64_t          delay_s = 600;
-        zlog_category_t *ct      = zlog_get_category(adapter->name);
-
-        gettimeofday(&tv, NULL);
-        diff = tv.tv_sec - adapter->timestamp_lev;
-        if (delay_s <= diff) {
-            int ret = zlog_level_switch(ct, default_log_level);
-            if (0 != ret) {
-                nlog_error("Modify default log level fail, ret:%d", ret);
-            }
-        }
-    }
-
-    return 0;
-}
-
-void *neu_msg_gen(neu_reqresp_head_t *header, void *data)
-{
-    nng_msg *msg       = NULL;
-    void *   body      = NULL;
-    size_t   data_size = 0;
+    size_t data_size = 0;
 
     switch (header->type) {
+    case NEU_REQRESP_TRANS_DATA:
+        data_size = sizeof(neu_reqresp_trans_data_t);
+        break;
     case NEU_REQ_NODE_INIT:
     case NEU_REQ_NODE_UNINIT:
     case NEU_RESP_NODE_UNINIT:
@@ -1588,15 +1685,6 @@ void *neu_msg_gen(neu_reqresp_head_t *header, void *data)
     case NEU_RESP_READ_GROUP:
         data_size = sizeof(neu_resp_read_group_t);
         break;
-    case NEU_REQRESP_TRANS_DATA: {
-        neu_reqresp_trans_data_t *trans = (neu_reqresp_trans_data_t *) data;
-        data_size                       = sizeof(neu_reqresp_trans_data_t) +
-            trans->n_tag * sizeof(neu_resp_tag_value_meta_t);
-        break;
-    }
-    case NEU_REQ_UPDATE_LICENSE:
-        data_size = sizeof(neu_req_update_license_t);
-        break;
     case NEU_REQRESP_NODE_DELETED:
         data_size = sizeof(neu_reqresp_node_deleted_t);
         break;
@@ -1633,9 +1721,7 @@ void *neu_msg_gen(neu_reqresp_head_t *header, void *data)
         break;
     }
 
-    nng_msg_alloc(&msg, sizeof(neu_reqresp_head_t) + data_size);
-    body = nng_msg_body(msg);
-    memcpy(body, header, sizeof(neu_reqresp_head_t));
-    memcpy((uint8_t *) body + sizeof(neu_reqresp_head_t), data, data_size);
-    return msg;
+    assert(NEU_MSG_MAX_SIZE >= sizeof(neu_reqresp_head_t) + data_size);
+    memcpy((uint8_t *) &header[1], data, data_size);
+    header->len = sizeof(neu_reqresp_head_t) + data_size;
 }

src/adapter/adapter_internal.h

@@ -20,10 +20,7 @@
 #ifndef ADAPTER_INTERNAL_H
 #define ADAPTER_INTERNAL_H
 
-#include <nng/nng.h>
-#include <nng/protocol/pair1/pair.h>
-#include <nng/supplemental/util/platform.h>
-
+#include "define.h"
 #include "event/event.h"
 #include "plugin.h"
 
@@ -36,18 +33,26 @@ struct neu_adapter {
 
     neu_node_running_state_e state;
 
+    char log_level[NEU_LOG_LEVEL_LEN];
+
     adapter_callbacks_t cb_funs;
 
     void *               handle;
     neu_plugin_module_t *module;
     neu_plugin_t *       plugin;
 
-    nng_socket sock;
-    nng_dialer dialer;
+    uint8_t buf[NEU_MSG_MAX_SIZE];
+    uint8_t recv_buf[NEU_MSG_MAX_SIZE];
 
-    neu_events_t *  events;
-    neu_event_io_t *nng_io;
-    int             recv_fd;
+    neu_event_io_t *control_io;
+    neu_event_io_t *trans_data_io;
+
+    int control_fd;
+    int trans_data_fd;
+
+    uint16_t trans_data_port;
+
+    neu_events_t *events;
 
     neu_event_timer_t *timer_lev;
     int64_t            timestamp_lev;
@@ -66,6 +71,8 @@ typedef struct adapter_msg_handler {
 int  neu_adapter_error();
 void neu_adapter_set_error(int error);
 
+uint16_t neu_adapter_trans_data_port(neu_adapter_t *adapter);
+
 neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load);
 void neu_adapter_init(neu_adapter_t *adapter, neu_node_running_state_e state);
 
@@ -75,7 +82,8 @@ int neu_adapter_start(neu_adapter_t *adapter);
 int neu_adapter_start_single(neu_adapter_t *adapter);
 int neu_adapter_stop(neu_adapter_t *adapter);
 
-neu_node_type_e neu_adapter_get_type(neu_adapter_t *adapter);
+neu_node_type_e      neu_adapter_get_type(neu_adapter_t *adapter);
+neu_tag_cache_type_e neu_adapter_get_tag_cache_type(neu_adapter_t *adapter);
 
 int  neu_adapter_uninit(neu_adapter_t *adapter);
 void neu_adapter_destroy(neu_adapter_t *adapter);

src/adapter/driver/cache.c

@@ -19,11 +19,9 @@
 
 #include <assert.h>
 #include <math.h>
+#include <pthread.h>
 #include <string.h>
 
-#include <nng/nng.h>
-#include <nng/supplemental/util/platform.h>
-
 #include "utils/uthash.h"
 
 #include "define.h"
@@ -49,7 +47,7 @@ struct elem {
 };
 
 struct neu_driver_cache {
-    nng_mtx *mtx;
+    pthread_mutex_t mtx;
 
     struct elem *table;
 };
@@ -71,7 +69,7 @@ neu_driver_cache_t *neu_driver_cache_new()
 {
     neu_driver_cache_t *cache = calloc(1, sizeof(neu_driver_cache_t));
 
-    nng_mtx_alloc(&cache->mtx);
+    pthread_mutex_init(&cache->mtx, NULL);
 
     return cache;
 }
@@ -81,7 +79,7 @@ void neu_driver_cache_destroy(neu_driver_cache_t *cache)
     struct elem *elem = NULL;
     struct elem *tmp  = NULL;
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_ITER(hh, cache->table, elem, tmp)
     {
         HASH_DEL(cache->table, elem);
@@ -93,9 +91,9 @@ void neu_driver_cache_destroy(neu_driver_cache_t *cache)
         }
         free(elem);
     }
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 
-    nng_mtx_free(cache->mtx);
+    pthread_mutex_destroy(&cache->mtx);
 
     free(cache);
 }
@@ -112,7 +110,7 @@ void neu_driver_cache_add(neu_driver_cache_t *cache, const char *group,
     struct elem *elem = NULL;
     tkey_t       key  = to_key(group, tag);
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
 
     if (elem == NULL) {
@@ -128,7 +126,7 @@ void neu_driver_cache_add(neu_driver_cache_t *cache, const char *group,
     elem->changed   = false;
     elem->value     = value;
 
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 }
 
 void neu_driver_cache_update_change(neu_driver_cache_t *cache,
@@ -140,7 +138,7 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
     struct elem *elem = NULL;
     tkey_t       key  = to_key(group, tag);
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
     if (elem != NULL) {
         elem->timestamp = timestamp;
@@ -242,7 +240,7 @@ void neu_driver_cache_update_change(neu_driver_cache_t *cache,
         }
     }
 
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 }
 
 void neu_driver_cache_update(neu_driver_cache_t *cache, const char *group,
@@ -262,7 +260,7 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
     int          ret  = -1;
     tkey_t       key  = to_key(group, tag);
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
 
     if (elem != NULL) {
@@ -321,8 +319,7 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
         }
 
         for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (elem->metas[i].name != NULL &&
-                strlen(elem->metas[i].name) > 0) {
+            if (strlen(elem->metas[i].name) > 0) {
                 memcpy(&value->metas[i], &elem->metas[i],
                        sizeof(neu_tag_meta_t));
             }
@@ -331,7 +328,7 @@ int neu_driver_cache_meta_get(neu_driver_cache_t *cache, const char *group,
         ret = 0;
     }
 
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 
     return ret;
 }
@@ -345,7 +342,7 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
     int          ret  = -1;
     tkey_t       key  = to_key(group, tag);
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
 
     if (elem != NULL && elem->changed) {
@@ -404,8 +401,7 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
         }
 
         for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (elem->metas[i].name != NULL &&
-                strlen(elem->metas[i].name) > 0) {
+            if (strlen(elem->metas[i].name) > 0) {
                 memcpy(&value->metas[i], &elem->metas[i],
                        sizeof(neu_tag_meta_t));
             }
@@ -417,7 +413,7 @@ int neu_driver_cache_meta_get_changed(neu_driver_cache_t *cache,
         ret = 0;
     }
 
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 
     return ret;
 }
@@ -429,7 +425,7 @@ int neu_driver_cache_get(neu_driver_cache_t *cache, const char *group,
     int          ret  = -1;
     tkey_t       key  = to_key(group, tag);
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
 
     if (elem != NULL) {
@@ -485,8 +481,7 @@ int neu_driver_cache_get(neu_driver_cache_t *cache, const char *group,
         }
 
         for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (elem->metas[i].name != NULL &&
-                strlen(elem->metas[i].name) > 0) {
+            if (strlen(elem->metas[i].name) > 0) {
                 memcpy(&value->metas[i], &elem->metas[i],
                        sizeof(neu_tag_meta_t));
             }
@@ -495,7 +490,7 @@ int neu_driver_cache_get(neu_driver_cache_t *cache, const char *group,
         ret = 0;
     }
 
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 
     return ret;
 }
@@ -508,7 +503,7 @@ int neu_driver_cache_get_changed(neu_driver_cache_t *cache, const char *group,
     int          ret  = -1;
     tkey_t       key  = to_key(group, tag);
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
 
     if (elem != NULL && elem->changed) {
@@ -563,8 +558,7 @@ int neu_driver_cache_get_changed(neu_driver_cache_t *cache, const char *group,
         }
 
         for (int i = 0; i < NEU_TAG_META_SIZE; i++) {
-            if (elem->metas[i].name != NULL &&
-                strlen(elem->metas[i].name) > 0) {
+            if (strlen(elem->metas[i].name) > 0) {
                 memcpy(&value->metas[i], &elem->metas[i],
                        sizeof(neu_tag_meta_t));
             }
@@ -576,7 +570,7 @@ int neu_driver_cache_get_changed(neu_driver_cache_t *cache, const char *group,
         ret = 0;
     }
 
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 
     return ret;
 }
@@ -587,7 +581,7 @@ void neu_driver_cache_del(neu_driver_cache_t *cache, const char *group,
     struct elem *elem = NULL;
     tkey_t       key  = to_key(group, tag);
 
-    nng_mtx_lock(cache->mtx);
+    pthread_mutex_lock(&cache->mtx);
     HASH_FIND(hh, cache->table, &key, sizeof(tkey_t), elem);
 
     if (elem != NULL) {
@@ -601,5 +595,5 @@ void neu_driver_cache_del(neu_driver_cache_t *cache, const char *group,
         free(elem);
     }
 
-    nng_mtx_unlock(cache->mtx);
+    pthread_mutex_unlock(&cache->mtx);
 }

src/adapter/driver/driver.c

@@ -22,9 +22,6 @@
 #include <pthread.h>
 #include <stdlib.h>
 
-#include <nng/nng.h>
-#include <nng/supplemental/util/platform.h>
-
 #include "event/event.h"
 #include "utils/log.h"
 #include "utils/utextend.h"
@@ -46,6 +43,11 @@ typedef struct to_be_write_tag {
     void *         req;
 } to_be_write_tag_t;
 
+typedef struct {
+    char               app[NEU_NODE_NAME_LEN];
+    struct sockaddr_in addr;
+} sub_app_t;
+
 typedef struct group {
     char *name;
 
@@ -59,6 +61,9 @@ typedef struct group {
     neu_event_timer_t *read;
     neu_event_timer_t *write;
 
+    UT_array *      apps; // sub_app_t array
+    pthread_mutex_t apps_mtx;
+
     neu_plugin_group_t    grp;
     neu_adapter_driver_t *driver;
 
@@ -79,11 +84,12 @@ static int  report_callback(void *usr_data);
 static int  read_callback(void *usr_data);
 static int  write_callback(void *usr_data);
 static void read_group(int64_t timestamp, int64_t timeout,
+                       neu_tag_cache_type_e cache_type,
                        neu_driver_cache_t *cache, const char *group,
-                       UT_array *tags, neu_resp_tag_value_meta_t *datas);
-static int  read_report_group(int64_t timestamp, int64_t timeout,
+                       UT_array *tags, UT_array *tag_values);
+static void read_report_group(int64_t timestamp, int64_t timeout,
                               neu_driver_cache_t *cache, const char *group,
-                              UT_array *tags, neu_resp_tag_value_meta_t *datas);
+                              UT_array *tags, UT_array *tag_values);
 static void update(neu_adapter_t *adapter, const char *group, const char *tag,
                    neu_dvalue_t value);
 static void update_im(neu_adapter_t *adapter, const char *group,
@@ -103,6 +109,8 @@ static void write_response(neu_adapter_t *adapter, void *r, neu_error error)
 
     req->type = NEU_RESP_ERROR;
 
+    nlog_notice("write tag response <%p>", req->ctx);
+
     adapter->cb_funs.response(adapter, req, &nerror);
     free(req);
 }
@@ -161,8 +169,9 @@ static void update_im(neu_adapter_t *adapter, const char *group,
                       const char *tag, neu_dvalue_t value,
                       neu_tag_meta_t *metas, int n_meta)
 {
-    neu_adapter_driver_t *driver = (neu_adapter_driver_t *) adapter;
-    neu_reqresp_head_t    header = { 0 };
+    neu_adapter_driver_t *  driver    = (neu_adapter_driver_t *) adapter;
+    static __thread uint8_t buf[1024] = { 0 };
+    neu_reqresp_head_t *    header    = (neu_reqresp_head_t *) buf;
 
     if (tag == NULL || value.type == NEU_TYPE_ERROR) {
         nlog_warn("update_im tag is null or value is error %d",
@@ -198,20 +207,47 @@ static void update_im(neu_adapter_t *adapter, const char *group,
               driver->adapter.name, group, tag, neu_type_string(value.type),
               global_timestamp);
 
-    header.type                    = NEU_REQRESP_TRANS_DATA;
-    neu_reqresp_trans_data_t *data = calloc(
-        1,
-        sizeof(neu_reqresp_trans_data_t) + sizeof(neu_resp_tag_value_meta_t));
+    memset(buf, 0, sizeof(buf));
+    header->type = NEU_REQRESP_TRANS_DATA;
+    neu_reqresp_trans_data_t *data =
+        calloc(1, sizeof(neu_reqresp_trans_data_t));
 
     strcpy(data->driver, driver->adapter.name);
     strcpy(data->group, group);
+    utarray_new(data->tags, neu_resp_tag_value_meta_icd());
 
-    data->n_tag =
-        read_report_group(global_timestamp, 0, driver->cache, group, tags,
-                          (neu_resp_tag_value_meta_t *) &data[1]);
+    read_report_group(global_timestamp, 0, driver->cache, group, tags,
+                      data->tags);
 
-    if (data->n_tag > 0) {
-        driver->adapter.cb_funs.response(&driver->adapter, &header, data);
+    if (utarray_len(data->tags) > 0) {
+        group_t *find = NULL;
+        HASH_FIND_STR(driver->groups, group, find);
+        if (find != NULL) {
+            pthread_mutex_lock(&find->apps_mtx);
+
+            data->ctx        = calloc(1, sizeof(neu_reqresp_trans_data_ctx_t));
+            data->ctx->index = utarray_len(find->apps);
+            if (data->ctx->index > 0) {
+                pthread_mutex_init(&data->ctx->mtx, NULL);
+
+                utarray_foreach(find->apps, sub_app_t *, app)
+                {
+                    if (driver->adapter.cb_funs.responseto(
+                            &driver->adapter, header, data, app->addr) <= 0) {
+                        neu_trans_data_free(data);
+                    }
+                }
+            } else {
+                utarray_free(data->tags);
+                free(data->ctx);
+            }
+
+            pthread_mutex_unlock(&find->apps_mtx);
+        } else {
+            utarray_free(data->tags);
+        }
+    } else {
+        utarray_free(data->tags);
     }
 
     utarray_free(tags);
@@ -289,6 +325,7 @@ int neu_adapter_driver_uninit(neu_adapter_driver_t *driver)
 
         utarray_free(el->static_tags);
         utarray_free(el->wt_tags);
+        utarray_free(el->apps);
         neu_group_destroy(el->group);
         free(el);
     }
@@ -310,12 +347,20 @@ void neu_adapter_driver_start_group_timer(neu_adapter_driver_t *driver)
             .type        = NEU_EVENT_TIMER_NOBLOCK,
         };
 
-        param.cb   = report_callback;
-        el->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
-
         param.type = driver->adapter.module->timer_type;
         param.cb   = read_callback;
         el->read   = neu_event_add_timer(driver->driver_events, param);
+
+        struct timespec t1 = {
+            .tv_sec  = 0,
+            .tv_nsec = 1000 * 1000 * 20,
+        };
+        struct timespec t2 = { 0 };
+        nanosleep(&t1, &t2);
+
+        param.type = NEU_EVENT_TIMER_NOBLOCK;
+        param.cb   = report_callback;
+        el->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
     }
 }
 
@@ -348,23 +393,23 @@ void neu_adapter_driver_read_group(neu_adapter_driver_t *driver,
     neu_group_t *         group = g->group;
     UT_array *            tags  = neu_group_get_read_tag(group);
 
-    resp.n_tag = utarray_len(tags);
-    resp.tags =
-        calloc(1, utarray_len(tags) * sizeof(neu_resp_tag_value_meta_t));
+    utarray_new(resp.tags, neu_resp_tag_value_meta_icd());
 
     if (driver->adapter.state != NEU_NODE_RUNNING_STATE_RUNNING) {
         utarray_foreach(tags, neu_datatag_t *, tag)
         {
-            int index = utarray_eltidx(tags, tag);
-            strcpy(resp.tags[index].tag, tag->name);
-            resp.tags[index].value.type      = NEU_TYPE_ERROR;
-            resp.tags[index].value.value.i32 = NEU_ERR_PLUGIN_NOT_RUNNING;
-        }
+            neu_resp_tag_value_meta_t tag_value = { 0 };
+            strcpy(tag_value.tag, tag->name);
+            tag_value.value.type      = NEU_TYPE_ERROR;
+            tag_value.value.value.i32 = NEU_ERR_PLUGIN_NOT_RUNNING;
 
+            utarray_push_back(resp.tags, &tag_value);
+        }
     } else {
         read_group(global_timestamp,
                    neu_group_get_interval(group) *
                        NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
+                   neu_adapter_get_tag_cache_type(&driver->adapter),
                    driver->cache, cmd->group, tags, resp.tags);
     }
 
@@ -411,7 +456,7 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
         switch (tag->option.value32.endian) {
         case NEU_DATATAG_ENDIAN_LB32:
             neu_ntohs_p((uint16_t *) value->value.bytes.bytes);
-            neu_ntohs_p((uint16_t *) value->value.bytes.bytes + 2);
+            neu_ntohs_p((uint16_t *) (value->value.bytes.bytes + 2));
             break;
         case NEU_DATATAG_ENDIAN_BB32:
             value->value.u32 = htonl(value->value.u32);
@@ -419,7 +464,7 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
         case NEU_DATATAG_ENDIAN_BL32:
             value->value.u32 = htonl(value->value.u32);
             neu_ntohs_p((uint16_t *) value->value.bytes.bytes);
-            neu_ntohs_p((uint16_t *) value->value.bytes.bytes + 2);
+            neu_ntohs_p((uint16_t *) (value->value.bytes.bytes + 2));
             break;
         case NEU_DATATAG_ENDIAN_LL32:
         default:
@@ -435,7 +480,7 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
         switch (tag->option.value32.endian) {
         case NEU_DATATAG_ENDIAN_LB32:
             neu_ntohs_p((uint16_t *) value->value.bytes.bytes);
-            neu_ntohs_p((uint16_t *) value->value.bytes.bytes + 2);
+            neu_ntohs_p((uint16_t *) (value->value.bytes.bytes + 2));
             break;
         case NEU_DATATAG_ENDIAN_BB32:
             value->value.u32 = htonl(value->value.u32);
@@ -443,7 +488,7 @@ static void fix_value(neu_datatag_t *tag, neu_type_e value_type,
         case NEU_DATATAG_ENDIAN_BL32:
             value->value.u32 = htonl(value->value.u32);
             neu_ntohs_p((uint16_t *) value->value.bytes.bytes);
-            neu_ntohs_p((uint16_t *) value->value.bytes.bytes + 2);
+            neu_ntohs_p((uint16_t *) (value->value.bytes.bytes + 2));
             break;
         case NEU_DATATAG_ENDIAN_LL32:
         default:
@@ -672,9 +717,10 @@ void neu_adapter_driver_write_tag(neu_adapter_driver_t *driver,
 int neu_adapter_driver_add_group(neu_adapter_driver_t *driver, const char *name,
                                  uint32_t interval)
 {
-    UT_icd   icd  = { sizeof(to_be_write_tag_t), NULL, NULL, NULL };
-    group_t *find = NULL;
-    int      ret  = NEU_ERR_GROUP_EXIST;
+    UT_icd   icd     = { sizeof(to_be_write_tag_t), NULL, NULL, NULL };
+    UT_icd   sub_icd = { sizeof(sub_app_t), NULL, NULL, NULL };
+    group_t *find    = NULL;
+    int      ret     = NEU_ERR_GROUP_EXIST;
 
     HASH_FIND_STR(driver->groups, name, find);
     if (find == NULL) {
@@ -688,8 +734,10 @@ int neu_adapter_driver_add_group(neu_adapter_driver_t *driver, const char *name,
         };
 
         pthread_mutex_init(&find->wt_mtx, NULL);
+        pthread_mutex_init(&find->apps_mtx, NULL);
 
         utarray_new(find->wt_tags, &icd);
+        utarray_new(find->apps, &sub_icd);
 
         find->driver         = driver;
         find->name           = strdup(name);
@@ -698,14 +746,23 @@ int neu_adapter_driver_add_group(neu_adapter_driver_t *driver, const char *name,
         neu_group_split_static_tags(find->group, &find->static_tags,
                                     &find->grp.tags);
 
+        param.type = driver->adapter.module->timer_type;
+        param.cb   = read_callback;
+        find->read = neu_event_add_timer(driver->driver_events, param);
+
+        struct timespec t1 = {
+            .tv_sec  = 0,
+            .tv_nsec = 1000 * 1000 * 20,
+        };
+        struct timespec t2 = { 0 };
+        nanosleep(&t1, &t2);
+
+        param.type   = NEU_EVENT_TIMER_NOBLOCK;
         param.cb     = report_callback;
         find->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
-        param.type   = driver->adapter.module->timer_type;
-        param.cb     = read_callback;
-        find->read   = neu_event_add_timer(driver->driver_events, param);
 
         param.second      = 0;
-        param.millisecond = 100;
+        param.millisecond = 3;
         param.cb          = write_callback;
         find->write       = neu_event_add_timer(driver->driver_events, param);
 
@@ -775,6 +832,7 @@ int neu_adapter_driver_update_group(neu_adapter_driver_t *driver,
             find->grp.group_name = new_name_cp2;
             neu_adapter_metric_update_group_name((neu_adapter_t *) driver, name,
                                                  new_name);
+            find->timestamp = global_timestamp; // trigger group_change
             HASH_ADD_STR(driver->groups, name, find);
         } else {
             free(new_name_cp1);
@@ -793,11 +851,21 @@ int neu_adapter_driver_update_group(neu_adapter_driver_t *driver,
     neu_group_set_interval(find->group, interval);
 
     // restore the timers
+
+    param.type = driver->adapter.module->timer_type;
+    param.cb   = read_callback;
+    find->read = neu_event_add_timer(driver->driver_events, param);
+
+    struct timespec t1 = {
+        .tv_sec  = 0,
+        .tv_nsec = 1000 * 1000 * 20,
+    };
+    struct timespec t2 = { 0 };
+    nanosleep(&t1, &t2);
+
+    param.type   = NEU_EVENT_TIMER_NOBLOCK;
     param.cb     = report_callback;
     find->report = neu_adapter_add_timer((neu_adapter_t *) driver, param);
-    param.type   = driver->adapter.module->timer_type;
-    param.cb     = read_callback;
-    find->read   = neu_event_add_timer(driver->driver_events, param);
 
     return ret;
 }
@@ -845,13 +913,19 @@ int neu_adapter_driver_del_group(neu_adapter_driver_t *driver, const char *name)
             }
         }
 
+        driver->tag_cnt -= neu_group_tag_size(find->group);
+        driver->adapter.cb_funs.update_metric(
+            &driver->adapter, NEU_METRIC_TAGS_TOTAL, driver->tag_cnt, NULL);
+
         utarray_free(find->static_tags);
         utarray_free(find->grp.tags);
         utarray_free(find->wt_tags);
+        utarray_free(find->apps);
         neu_group_destroy(find->group);
+        pthread_mutex_destroy(&find->wt_mtx);
+        pthread_mutex_destroy(&find->apps_mtx);
         free(find);
 
-        pthread_mutex_destroy(&find->wt_mtx);
         neu_adapter_del_group_metrics(&driver->adapter, name);
         ret = NEU_ERR_SUCCESS;
     }
@@ -982,6 +1056,8 @@ int neu_adapter_driver_add_tag(neu_adapter_driver_t *driver, const char *group,
     group_t *find = NULL;
 
     neu_datatag_parse_addr_option(tag, &tag->option);
+    driver->adapter.module->intf_funs->driver.validate_tag(
+        driver->adapter.plugin, tag);
 
     HASH_FIND_STR(driver->groups, group, find);
     if (find == NULL) {
@@ -1168,34 +1244,59 @@ UT_array *neu_adapter_driver_get_ptag(neu_adapter_driver_t *driver,
 
 static int report_callback(void *usr_data)
 {
-    group_t *                group  = (group_t *) usr_data;
-    neu_reqresp_head_t       header = { 0 };
-    neu_node_running_state_e state  = group->driver->adapter.state;
+    group_t *                group     = (group_t *) usr_data;
+    static __thread uint8_t  buf[1024] = { 0 };
+    neu_reqresp_head_t *     header    = (neu_reqresp_head_t *) buf;
+    neu_node_running_state_e state     = group->driver->adapter.state;
     if (state != NEU_NODE_RUNNING_STATE_RUNNING) {
         return 0;
     }
 
-    header.type = NEU_REQRESP_TRANS_DATA;
+    memset(buf, 0, sizeof(buf));
+    header->type = NEU_REQRESP_TRANS_DATA;
 
     UT_array *tags =
         neu_adapter_driver_get_read_tag(group->driver, group->name);
 
     neu_reqresp_trans_data_t *data =
-        calloc(1,
-               sizeof(neu_reqresp_trans_data_t) +
-                   utarray_len(tags) * sizeof(neu_resp_tag_value_meta_t));
+        calloc(1, sizeof(neu_reqresp_trans_data_t));
 
     strcpy(data->driver, group->driver->adapter.name);
     strcpy(data->group, group->name);
-    data->n_tag = read_report_group(global_timestamp,
-                                    neu_group_get_interval(group->group) *
-                                        NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
-                                    group->driver->cache, group->name, tags,
-                                    (neu_resp_tag_value_meta_t *) &data[1]);
+    utarray_new(data->tags, neu_resp_tag_value_meta_icd());
 
-    if (data->n_tag > 0) {
-        group->driver->adapter.cb_funs.response(&group->driver->adapter,
-                                                &header, data);
+    read_report_group(global_timestamp,
+                      neu_group_get_interval(group->group) *
+                          NEU_DRIVER_TAG_CACHE_EXPIRE_TIME,
+                      group->driver->cache, group->name, tags, data->tags);
+
+    nlog_info("report group: %s, all tags: %d, report tags: %d", group->name,
+              utarray_len(tags), utarray_len(data->tags));
+    if (utarray_len(data->tags) > 0) {
+        pthread_mutex_lock(&group->apps_mtx);
+
+        data->ctx        = calloc(1, sizeof(neu_reqresp_trans_data_ctx_t));
+        data->ctx->index = utarray_len(group->apps);
+
+        if (data->ctx->index > 0) {
+            pthread_mutex_init(&data->ctx->mtx, NULL);
+
+            utarray_foreach(group->apps, sub_app_t *, app)
+            {
+                if (group->driver->adapter.cb_funs.responseto(
+                        &group->driver->adapter, header, data, app->addr) <=
+                    0) {
+                    neu_trans_data_free(data);
+                }
+            }
+        } else {
+            utarray_free(data->tags);
+            free(data->ctx);
+        }
+
+        pthread_mutex_unlock(&group->apps_mtx);
+    } else {
+        utarray_free(data->tags);
     }
     utarray_free(tags);
     free(data);
@@ -1316,7 +1417,7 @@ static int read_callback(void *usr_data)
                               group_change);
     }
 
-    if (group->grp.tags != NULL) {
+    if (group->grp.tags != NULL && utarray_len(group->grp.tags) > 0) {
         int64_t spend = global_timestamp;
 
         group->driver->adapter.module->intf_funs->driver.group_timer(
@@ -1333,39 +1434,40 @@ static int read_callback(void *usr_data)
     return 0;
 }
 
-static int read_report_group(int64_t timestamp, int64_t timeout,
-                             neu_driver_cache_t *cache, const char *group,
-                             UT_array *tags, neu_resp_tag_value_meta_t *datas)
+static void read_report_group(int64_t timestamp, int64_t timeout,
+                              neu_driver_cache_t *cache, const char *group,
+                              UT_array *tags, UT_array *tag_values)
 {
-    int index = 0;
-
     utarray_foreach(tags, neu_datatag_t *, tag)
     {
-        neu_driver_cache_value_t value = { 0 };
+        neu_driver_cache_value_t  value     = { 0 };
+        neu_resp_tag_value_meta_t tag_value = { 0 };
 
         if (neu_tag_attribute_test(tag, NEU_ATTRIBUTE_SUBSCRIBE)) {
             if (neu_driver_cache_meta_get_changed(cache, group, tag->name,
-                                                  &value, datas[index].metas,
+                                                  &value, tag_value.metas,
                                                   NEU_TAG_META_SIZE) != 0) {
                 nlog_info("tag: %s not changed", tag->name);
                 continue;
             }
         } else {
             if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                          datas[index].metas,
+                                          tag_value.metas,
                                           NEU_TAG_META_SIZE) != 0) {
-                strcpy(datas[index].tag, tag->name);
-                datas[index].value.type      = NEU_TYPE_ERROR;
-                datas[index].value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
-                index += 1;
+                strcpy(tag_value.tag, tag->name);
+                tag_value.value.type      = NEU_TYPE_ERROR;
+                tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
+
+                utarray_push_back(tag_values, &tag_value);
                 continue;
             }
         }
-        strcpy(datas[index].tag, tag->name);
+        strcpy(tag_value.tag, tag->name);
 
         if (value.value.type == NEU_TYPE_ERROR) {
-            datas[index].value = value.value;
-            index += 1;
+            tag_value.value = value.value;
+
+            utarray_push_back(tag_values, &tag_value);
             continue;
         }
 
@@ -1427,94 +1529,96 @@ static int read_report_group(int64_t timestamp, int64_t timeout,
 
         if (!neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) &&
             (timestamp - value.timestamp) > timeout && timeout > 0) {
-            datas[index].value.type      = NEU_TYPE_ERROR;
-            datas[index].value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;
+            tag_value.value.type      = NEU_TYPE_ERROR;
+            tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;
         } else {
             if (value.value.type == NEU_TYPE_PTR) {
-                datas[index].value.type = NEU_TYPE_PTR;
-                datas[index].value.value.ptr.length =
-                    value.value.value.ptr.length;
-                datas[index].value.value.ptr.type = value.value.value.ptr.type;
-                datas[index].value.value.ptr.ptr  = value.value.value.ptr.ptr;
+                tag_value.value.type             = NEU_TYPE_PTR;
+                tag_value.value.value.ptr.length = value.value.value.ptr.length;
+                tag_value.value.value.ptr.type   = value.value.value.ptr.type;
+                tag_value.value.value.ptr.ptr    = value.value.value.ptr.ptr;
             } else {
-                datas[index].value = value.value;
+                tag_value.value = value.value;
             }
             if (tag->decimal != 0) {
-                datas[index].value.type = NEU_TYPE_DOUBLE;
+                tag_value.value.type = NEU_TYPE_DOUBLE;
                 switch (tag->type) {
                 case NEU_TYPE_INT8:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i8 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i8 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT8:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u8 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u8 * tag->decimal;
                     break;
                 case NEU_TYPE_INT16:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i16 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i16 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT16:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u16 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u16 * tag->decimal;
                     break;
                 case NEU_TYPE_INT32:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i32 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i32 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT32:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u32 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u32 * tag->decimal;
                     break;
                 case NEU_TYPE_INT64:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i64 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i64 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT64:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u64 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u64 * tag->decimal;
                     break;
                 case NEU_TYPE_FLOAT:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.f32 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.f32 * tag->decimal;
                     break;
                 case NEU_TYPE_DOUBLE:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.d64 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.d64 * tag->decimal;
                     break;
                 default:
-                    datas[index].value.type = tag->type;
+                    tag_value.value.type = tag->type;
                     break;
                 }
             }
         }
-        index += 1;
-    }
 
-    return index;
+        utarray_push_back(tag_values, &tag_value);
+    }
 }
 
 static void read_group(int64_t timestamp, int64_t timeout,
+                       neu_tag_cache_type_e cache_type,
                        neu_driver_cache_t *cache, const char *group,
-                       UT_array *tags, neu_resp_tag_value_meta_t *datas)
+                       UT_array *tags, UT_array *tag_values)
 {
     utarray_foreach(tags, neu_datatag_t *, tag)
     {
-        neu_driver_cache_value_t value = { 0 };
-        int                      index = utarray_eltidx(tags, tag);
+        neu_resp_tag_value_meta_t tag_value = { 0 };
+        neu_driver_cache_value_t  value     = { 0 };
 
-        strcpy(datas[index].tag, tag->name);
+        strcpy(tag_value.tag, tag->name);
 
         if (neu_driver_cache_meta_get(cache, group, tag->name, &value,
-                                      datas[index].metas,
+                                      tag_value.metas,
                                       NEU_TAG_META_SIZE) != 0) {
-            datas[index].value.type      = NEU_TYPE_ERROR;
-            datas[index].value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
+            tag_value.value.type      = NEU_TYPE_ERROR;
+            tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_NOT_READY;
+
+            utarray_push_back(tag_values, &tag_value);
             continue;
         }
 
         if (value.value.type == NEU_TYPE_ERROR) {
-            datas[index].value = value.value;
+            tag_value.value = value.value;
+            utarray_push_back(tag_values, &tag_value);
             continue;
         }
 
@@ -1574,69 +1678,70 @@ static void read_group(int64_t timestamp, int64_t timeout,
             break;
         }
 
-        if (!neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) &&
+        if (cache_type != NEU_TAG_CACHE_TYPE_NEVER &&
+            !neu_tag_attribute_test(tag, NEU_ATTRIBUTE_STATIC) &&
             (timestamp - value.timestamp) > timeout) {
-            datas[index].value.type      = NEU_TYPE_ERROR;
-            datas[index].value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;
+            tag_value.value.type      = NEU_TYPE_ERROR;
+            tag_value.value.value.i32 = NEU_ERR_PLUGIN_TAG_VALUE_EXPIRED;
         } else {
             if (value.value.type == NEU_TYPE_PTR) {
-                datas[index].value.type = NEU_TYPE_PTR;
-                datas[index].value.value.ptr.length =
-                    value.value.value.ptr.length;
-                datas[index].value.value.ptr.type = value.value.value.ptr.type;
-                datas[index].value.value.ptr.ptr  = value.value.value.ptr.ptr;
+                tag_value.value.type             = NEU_TYPE_PTR;
+                tag_value.value.value.ptr.length = value.value.value.ptr.length;
+                tag_value.value.value.ptr.type   = value.value.value.ptr.type;
+                tag_value.value.value.ptr.ptr    = value.value.value.ptr.ptr;
             } else {
-                datas[index].value = value.value;
+                tag_value.value = value.value;
             }
             if (tag->decimal != 0) {
-                datas[index].value.type = NEU_TYPE_DOUBLE;
+                tag_value.value.type = NEU_TYPE_DOUBLE;
                 switch (tag->type) {
                 case NEU_TYPE_INT8:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i8 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i8 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT8:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u8 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u8 * tag->decimal;
                     break;
                 case NEU_TYPE_INT16:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i16 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i16 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT16:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u16 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u16 * tag->decimal;
                     break;
                 case NEU_TYPE_INT32:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i32 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i32 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT32:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u32 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u32 * tag->decimal;
                     break;
                 case NEU_TYPE_INT64:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.i64 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.i64 * tag->decimal;
                     break;
                 case NEU_TYPE_UINT64:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.u64 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.u64 * tag->decimal;
                     break;
                 case NEU_TYPE_FLOAT:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.f32 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.f32 * tag->decimal;
                     break;
                 case NEU_TYPE_DOUBLE:
-                    datas[index].value.value.d64 =
-                        (double) datas[index].value.value.d64 * tag->decimal;
+                    tag_value.value.value.d64 =
+                        (double) tag_value.value.value.d64 * tag->decimal;
                     break;
                 default:
-                    datas[index].value.type = tag->type;
+                    tag_value.value.type = tag->type;
                     break;
                 }
             }
         }
+        utarray_push_back(tag_values, &tag_value);
     }
 }
 
@@ -1646,3 +1751,60 @@ static void store_write_tag(group_t *group, to_be_write_tag_t *tag)
     utarray_push_back(group->wt_tags, tag);
     pthread_mutex_unlock(&group->wt_mtx);
 }
+
+void neu_adapter_driver_subscribe(neu_adapter_driver_t *driver,
+                                  neu_req_subscribe_t * req)
+{
+    sub_app_t sub_app = { 0 };
+    group_t * find    = NULL;
+
+    HASH_FIND_STR(driver->groups, req->group, find);
+    if (find == NULL) {
+        nlog_warn("%s sub group: %s not exist", driver->adapter.name,
+                  req->group);
+        return;
+    }
+
+    pthread_mutex_lock(&find->apps_mtx);
+    utarray_foreach(find->apps, sub_app_t *, app)
+    {
+        if (strcmp(app->app, req->app) == 0) {
+            nlog_warn("%s sub group: %s app: %s already exist",
+                      driver->adapter.name, req->group, req->app);
+            pthread_mutex_unlock(&find->apps_mtx);
+            return;
+        }
+    }
+
+    strcpy(sub_app.app, req->app);
+    sub_app.addr.sin_family      = AF_INET;
+    sub_app.addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+    sub_app.addr.sin_port        = htons(req->port);
+
+    utarray_push_back(find->apps, &sub_app);
+    pthread_mutex_unlock(&find->apps_mtx);
+}
+
+void neu_adapter_driver_unsubscribe(neu_adapter_driver_t * driver,
+                                    neu_req_unsubscribe_t *req)
+{
+    group_t *find = NULL;
+
+    HASH_FIND_STR(driver->groups, req->group, find);
+    if (find == NULL) {
+        nlog_warn("%s unsub group: %s not exist", driver->adapter.name,
+                  req->group);
+        return;
+    }
+
+    pthread_mutex_lock(&find->apps_mtx);
+    utarray_foreach(find->apps, sub_app_t *, app)
+    {
+        if (strcmp(app->app, req->app) == 0) {
+            utarray_erase(find->apps, utarray_eltidx(find->apps, app), 1);
+            pthread_mutex_unlock(&find->apps_mtx);
+            return;
+        }
+    }
+    pthread_mutex_unlock(&find->apps_mtx);
+}

src/adapter/driver/driver_internal.h

@@ -79,4 +79,9 @@ void      neu_adapter_driver_get_value_tag(neu_adapter_driver_t *driver,
                                            const char *group, UT_array **tags);
 UT_array *neu_adapter_driver_get_read_tag(neu_adapter_driver_t *driver,
                                           const char *          group);
+
+void neu_adapter_driver_subscribe(neu_adapter_driver_t *driver,
+                                  neu_req_subscribe_t * req);
+void neu_adapter_driver_unsubscribe(neu_adapter_driver_t * driver,
+                                    neu_req_unsubscribe_t *req);
 #endif

src/adapter/storage.c

@@ -54,8 +54,8 @@ void adapter_storage_update_group(const char *node, const char *group,
 
     int rv = neu_persister_update_group(node, group, &info);
     if (0 != rv) {
-        nlog_error("fail update adapter:%s group:%s, interval: %u", node, group,
-                   interval);
+        nlog_error("fail update adapter:%s group:%s, new_name:%s interval: %u",
+                   node, group, new_name, interval);
     }
 }
 

src/argparse.c

@@ -78,6 +78,8 @@ const char *usage_text =
 "    --config_file <PATH> startup parameter configuration file\n"
 "    --config_dir <DIR>   directory from which neuron reads configuration\n"
 "    --plugin_dir <DIR>   directory from which neuron loads plugin lib files\n"
+"    --syslog_host <HOST> syslog server host to which neuron will send logs\n"
+"    --syslog_port <PORT> syslog server port (default 541 if not provided)\n"
 "\n";
 // clang-format on
 
@@ -225,6 +227,25 @@ static inline int load_env(neu_cli_args_t *args, char **log_level_out,
             }
             *plugin_dir_out = strdup(plugin_dir);
         }
+
+        char *syslog_host = getenv(NEU_ENV_SYSLOG_HOST);
+        if (NULL != syslog_host) {
+            if (NULL != args->syslog_host) {
+                free(args->syslog_host);
+            }
+            args->syslog_host = strdup(syslog_host);
+        }
+
+        char *syslog_port = getenv(NEU_ENV_SYSLOG_PORT);
+        if (NULL != syslog_port) {
+            int port = atoi(syslog_port);
+            if (port < 1 || 65535 < port) {
+                printf("neuron %s setting invalid!\n", NEU_ENV_SYSLOG_PORT);
+                ret = -1;
+                break;
+            }
+            args->syslog_port = port;
+        }
     } while (0);
 
     return ret;
@@ -262,9 +283,13 @@ static inline int load_config_file(int argc, char *argv[],
     int   fd          = -1;
     void *root        = NULL;
 
-    neu_json_elem_t elems[] = { { .name = "disable_auth", .t = NEU_JSON_INT },
-                                { .name = "ip", .t = NEU_JSON_STR },
-                                { .name = "port", .t = NEU_JSON_INT } };
+    neu_json_elem_t elems[] = {
+        { .name = "disable_auth", .t = NEU_JSON_INT },
+        { .name = "ip", .t = NEU_JSON_STR },
+        { .name = "port", .t = NEU_JSON_INT },
+        { .name = "syslog_host", .t = NEU_JSON_STR },
+        { .name = "syslog_port", .t = NEU_JSON_INT },
+    };
 
     resolve_config_file_path(argc, argv, long_options, opts, &config_file);
 
@@ -298,7 +323,8 @@ static inline int load_config_file(int argc, char *argv[],
             break;
         }
 
-        if (neu_json_decode_by_json(root, 3, elems) == 0) {
+        if (neu_json_decode_by_json(root, NEU_JSON_ELEM_SIZE(elems), elems) ==
+            0) {
             if (elems[0].v.val_int == 1) {
                 args->disable_auth = true;
             } else if (elems[0].v.val_int == 0) {
@@ -325,6 +351,24 @@ static inline int load_config_file(int argc, char *argv[],
                 break;
             }
 
+            if (elems[3].v.val_str != NULL) {
+                if (strlen(elems[3].v.val_str) > 0) {
+                    args->syslog_host = strdup(elems[3].v.val_str);
+                }
+            } else {
+                printf("config file %s syslog_host setting error!\n",
+                       config_file);
+                break;
+            }
+
+            if (0 < elems[4].v.val_int && elems[4].v.val_int < 65536) {
+                args->syslog_port = elems[4].v.val_int;
+            } else {
+                printf("config file %s syslog_port setting invalid!\n",
+                       config_file);
+                break;
+            }
+
             ret = 0;
         } else {
             printf("config file %s elems error! must had ip, port and "
@@ -350,6 +394,10 @@ static inline int load_config_file(int argc, char *argv[],
         free(elems[1].v.val_str);
     }
 
+    if (elems[3].v.val_str != NULL) {
+        free(elems[3].v.val_str);
+    }
+
     return ret;
 }
 
@@ -374,6 +422,8 @@ void neu_cli_args_init(neu_cli_args_t *args, int argc, char *argv[])
         { "config_dir", required_argument, NULL, 'c' },
         { "plugin_dir", required_argument, NULL, 'p' },
         { "stop", no_argument, NULL, 's' },
+        { "syslog_host", required_argument, NULL, 'S' },
+        { "syslog_port", required_argument, NULL, 'P' },
         { NULL, 0, NULL, 0 },
     };
 
@@ -451,6 +501,22 @@ void neu_cli_args_init(neu_cli_args_t *args, int argc, char *argv[])
             }
             plugin_dir = strdup(optarg);
             break;
+        case 'P': {
+            int syslog_port = atoi(optarg);
+            if (syslog_port < 1 || 65535 < syslog_port) {
+                fprintf(stderr, "%s: option '--syslog_port' invalid : `%s`\n",
+                        argv[0], optarg);
+                goto quit;
+            }
+            args->syslog_port = syslog_port;
+            break;
+        }
+        case 'S':
+            if (args->syslog_host) {
+                free(args->syslog_host);
+            }
+            args->syslog_host = strdup(optarg);
+            break;
         case '?':
         default:
             usage();
@@ -525,5 +591,6 @@ void neu_cli_args_fini(neu_cli_args_t *args)
         free(args->config_dir);
         free(args->plugin_dir);
         free(args->ip);
+        free(args->syslog_host);
     }
 }

src/argparse.h

@@ -33,6 +33,8 @@
 #define NEU_ENV_DISABLE_AUTH "NEURON_DISABLE_AUTH"
 #define NEU_ENV_CONFIG_DIR "NEURON_CONFIG_DIR"
 #define NEU_ENV_PLUGIN_DIR "NEURON_PLUGIN_DIR"
+#define NEU_ENV_SYSLOG_HOST "NEURON_SYSLOG_HOST"
+#define NEU_ENV_SYSLOG_PORT "NEURON_SYSLOG_PORT"
 
 #define NEURON_CONFIG_FNAME "./config/neuron.json"
 
@@ -41,6 +43,7 @@ extern "C" {
 #endif
 
 #include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 
 extern const char *g_config_dir;
@@ -49,16 +52,18 @@ extern const char *g_plugin_dir;
 /** Neuron command line arguments.
  */
 typedef struct {
-    bool   daemonized; // flag indicating whether to run as daemon process
-    bool   dev_log;    // logging for development
-    size_t restart;    // restart policy
-    bool   disable_auth;
-    char * log_init_file;
-    char * config_dir;
-    char * plugin_dir;
-    bool   stop;
-    char * ip;
-    int    port;
+    bool     daemonized; // flag indicating whether to run as daemon process
+    bool     dev_log;    // logging for development
+    size_t   restart;    // restart policy
+    bool     disable_auth;
+    char *   log_init_file;
+    char *   config_dir;
+    char *   plugin_dir;
+    bool     stop;
+    char *   ip;
+    int      port;
+    char *   syslog_host;
+    uint16_t syslog_port;
 } neu_cli_args_t;
 
 /** Parse command line arguments.

src/base/neu_plugin_common.c

@@ -31,6 +31,7 @@ void neu_plugin_common_init(neu_plugin_common_t *common)
 {
     common->magic      = NEU_PLUGIN_MAGIC_NUMBER;
     common->link_state = NEU_NODE_LINK_STATE_DISCONNECTED;
+    strcpy(common->log_level, NEU_LOG_LEVEL_NOTICE);
 }
 
 bool neu_plugin_common_check(neu_plugin_t *plugin)

src/base/template.c

@@ -145,8 +145,8 @@ int neu_template_del_group(neu_template_t *tmpl, const char *group)
     return 0;
 }
 
-int neu_template_update_group(neu_template_t *tmpl, const char *group,
-                              uint32_t interval)
+int neu_template_update_group_interval(neu_template_t *tmpl, const char *group,
+                                       uint32_t interval)
 {
     group_entry_t *ent = NULL;
     HASH_FIND(hh, tmpl->groups, group, strlen(group), ent);
@@ -157,6 +157,31 @@ int neu_template_update_group(neu_template_t *tmpl, const char *group,
     return neu_group_update(ent->group, interval);
 }
 
+int neu_template_update_group_name(neu_template_t *tmpl, const char *group,
+                                   const char *new_name)
+{
+    if (0 == strcmp(group, new_name)) {
+        return 0;
+    }
+
+    if (NULL != neu_template_get_group(tmpl, new_name)) {
+        return NEU_ERR_GROUP_EXIST;
+    }
+
+    group_entry_t *ent = NULL;
+    HASH_FIND(hh, tmpl->groups, group, strlen(group), ent);
+    if (NULL == ent) {
+        return NEU_ERR_GROUP_NOT_EXIST;
+    }
+
+    HASH_DEL(tmpl->groups, ent);
+    int rv   = neu_group_set_name(ent->group, new_name);
+    new_name = neu_group_get_name(ent->group);
+    HASH_ADD_KEYPTR(hh, tmpl->groups, new_name, strlen(new_name), ent);
+
+    return rv;
+}
+
 size_t neu_template_group_num(const neu_template_t *tmpl)
 {
     return HASH_COUNT(tmpl->groups);

src/base/template.h

@@ -51,8 +51,10 @@ neu_group_t *neu_template_get_group(const neu_template_t *tmpl,
 int neu_template_add_group(neu_template_t *tmpl, const char *group,
                            uint32_t interval);
 int neu_template_del_group(neu_template_t *tmpl, const char *group);
-int neu_template_update_group(neu_template_t *tmpl, const char *group,
-                              uint32_t interval);
+int neu_template_update_group_interval(neu_template_t *tmpl, const char *group,
+                                       uint32_t interval);
+int neu_template_update_group_name(neu_template_t *tmpl, const char *group,
+                                   const char *new_name);
 
 // Iterate through groups in the template and apply `cb` each.
 // NOTE: `cb` must not alter the group name or delete the group.

src/connection/connection.c

@@ -348,7 +348,7 @@ ssize_t neu_conn_send(neu_conn_t *conn, uint8_t *buf, ssize_t len)
                 }
             } else {
                 if (rc == -1 && errno == EAGAIN) {
-                    if (retry > 50) {
+                    if (retry > 5) {
                         zlog_error(conn->param.log,
                                    "conn fd: %d, send buf len: %zd, ret: %zd, "
                                    "errno: %s(%d)",
@@ -677,15 +677,34 @@ static void conn_tcp_server_listen(neu_conn_t *conn)
 {
     if (conn->param.type == NEU_CONN_TCP_SERVER &&
         conn->tcp_server.is_listen == false) {
-        int fd  = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
-        int ret = 0;
-        struct sockaddr_in local = {
-            .sin_family      = AF_INET,
-            .sin_port        = htons(conn->param.params.tcp_server.port),
-            .sin_addr.s_addr = inet_addr(conn->param.params.tcp_server.ip),
-        };
+        int fd = -1, ret = 0;
+
+        if (is_ipv4(conn->param.params.tcp_server.ip)) {
+            struct sockaddr_in local = {
+                .sin_family      = AF_INET,
+                .sin_port        = htons(conn->param.params.tcp_server.port),
+                .sin_addr.s_addr = inet_addr(conn->param.params.tcp_server.ip),
+            };
+
+            fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
+
+            ret = bind(fd, (struct sockaddr *) &local, sizeof(local));
+        } else if (is_ipv6(conn->param.params.tcp_server.ip)) {
+            struct sockaddr_in6 local = { 0 };
+            local.sin6_family         = AF_INET6;
+            local.sin6_port = htons(conn->param.params.tcp_server.port);
+            inet_pton(AF_INET6, conn->param.params.tcp_server.ip,
+                      &local.sin6_addr);
+
+            fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
+
+            ret = bind(fd, (struct sockaddr *) &local, sizeof(local));
+        } else {
+            zlog_error(conn->param.log, "invalid ip: %s",
+                       conn->param.params.tcp_server.ip);
+            return;
+        }
 
-        ret = bind(fd, (struct sockaddr *) &local, sizeof(local));
         if (ret != 0) {
             close(fd);
             zlog_error(conn->param.log, "tcp bind %s:%d fail, errno: %s",
@@ -756,20 +775,46 @@ static void conn_connect(neu_conn_t *conn)
                     (conn->param.params.tcp_client.timeout % 1000) * 1000,
             };
 
-            fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+            if (is_ipv4(conn->param.params.tcp_client.ip)) {
+                fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+            } else {
+                fd = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
+            }
+
             setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
             setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
         } else {
-            fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
+            if (is_ipv4(conn->param.params.tcp_client.ip)) {
+                fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
+            } else {
+                fd = socket(AF_INET6, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
+            }
+        }
+
+        if (is_ipv4(conn->param.params.tcp_client.ip)) {
+            struct sockaddr_in remote = {
+                .sin_family      = AF_INET,
+                .sin_port        = htons(conn->param.params.tcp_client.port),
+                .sin_addr.s_addr = inet_addr(conn->param.params.tcp_client.ip),
+            };
+
+            ret = connect(fd, (struct sockaddr *) &remote,
+                          sizeof(struct sockaddr_in));
+        } else if (is_ipv6(conn->param.params.tcp_client.ip)) {
+            struct sockaddr_in6 remote_ip6 = { 0 };
+            remote_ip6.sin6_family         = AF_INET6;
+            remote_ip6.sin6_port = htons(conn->param.params.tcp_client.port);
+            inet_pton(AF_INET6, conn->param.params.tcp_client.ip,
+                      &remote_ip6.sin6_addr);
+
+            ret = connect(fd, (struct sockaddr *) &remote_ip6,
+                          sizeof(remote_ip6));
+        } else {
+            zlog_error(conn->param.log, "invalid ip: %s",
+                       conn->param.params.tcp_server.ip);
+            return;
         }
-        struct sockaddr_in remote = {
-            .sin_family      = AF_INET,
-            .sin_port        = htons(conn->param.params.tcp_client.port),
-            .sin_addr.s_addr = inet_addr(conn->param.params.tcp_client.ip),
-        };
 
-        ret = connect(fd, (struct sockaddr *) &remote,
-                      sizeof(struct sockaddr_in));
         if (ret != 0 && errno != EINPROGRESS) {
             close(fd);
             zlog_error(conn->param.log, "connect %s:%d error: %s(%d)",
@@ -794,22 +839,50 @@ static void conn_connect(neu_conn_t *conn)
                 .tv_usec = (conn->param.params.udp.timeout % 1000) * 1000,
             };
 
-            fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+            if (is_ipv4(conn->param.params.udp.dst_ip)) {
+                fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+            } else {
+                fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
+            }
+
             setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
             setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
         } else {
-            fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+            if (is_ipv4(conn->param.params.udp.dst_ip)) {
+                fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+            } else {
+                fd = socket(AF_INET6, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+            }
         }
+
         int so_broadcast = 1;
         setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &so_broadcast,
                    sizeof(so_broadcast));
-        struct sockaddr_in local = {
-            .sin_family      = AF_INET,
-            .sin_port        = htons(conn->param.params.udp.src_port),
-            .sin_addr.s_addr = inet_addr(conn->param.params.udp.src_ip),
-        };
 
-        ret = bind(fd, (struct sockaddr *) &local, sizeof(struct sockaddr_in));
+        if (is_ipv4(conn->param.params.udp.src_ip)) {
+            struct sockaddr_in local = {
+                .sin_family      = AF_INET,
+                .sin_port        = htons(conn->param.params.udp.src_port),
+                .sin_addr.s_addr = inet_addr(conn->param.params.udp.src_ip),
+            };
+
+            ret = bind(fd, (struct sockaddr *) &local,
+                       sizeof(struct sockaddr_in));
+        } else if (is_ipv6(conn->param.params.udp.src_ip)) {
+            struct sockaddr_in6 local = { 0 };
+            local.sin6_family         = AF_INET6;
+            local.sin6_port           = htons(conn->param.params.udp.src_port);
+            inet_pton(AF_INET6, conn->param.params.udp.src_ip,
+                      &local.sin6_addr);
+
+            ret = bind(fd, (struct sockaddr *) &local,
+                       sizeof(struct sockaddr_in6));
+        } else {
+            zlog_error(conn->param.log, "invalid ip: %s",
+                       conn->param.params.tcp_server.ip);
+            return;
+        }
+
         if (ret != 0) {
             close(fd);
             zlog_error(conn->param.log, "bind %s:%d error: %s(%d)",
@@ -819,13 +892,29 @@ static void conn_connect(neu_conn_t *conn)
             return;
         }
 
-        struct sockaddr_in remote = {
-            .sin_family      = AF_INET,
-            .sin_port        = htons(conn->param.params.udp.dst_port),
-            .sin_addr.s_addr = inet_addr(conn->param.params.udp.dst_ip),
-        };
-        ret = connect(fd, (struct sockaddr *) &remote,
-                      sizeof(struct sockaddr_in));
+        if (is_ipv4(conn->param.params.udp.dst_ip)) {
+            struct sockaddr_in remote = {
+                .sin_family      = AF_INET,
+                .sin_port        = htons(conn->param.params.udp.dst_port),
+                .sin_addr.s_addr = inet_addr(conn->param.params.udp.dst_ip),
+            };
+            ret = connect(fd, (struct sockaddr *) &remote,
+                          sizeof(struct sockaddr_in));
+        } else if (is_ipv6(conn->param.params.udp.dst_ip)) {
+            struct sockaddr_in6 remote = { 0 };
+            remote.sin6_family         = AF_INET6;
+            remote.sin6_port           = htons(conn->param.params.udp.dst_port);
+            inet_pton(AF_INET6, conn->param.params.udp.dst_ip,
+                      &remote.sin6_addr);
+
+            ret = connect(fd, (struct sockaddr *) &remote,
+                          sizeof(struct sockaddr_in6));
+        } else {
+            zlog_error(conn->param.log, "invalid ip: %s",
+                       conn->param.params.tcp_server.ip);
+            return;
+        }
+
         if (ret != 0 && errno != EINPROGRESS) {
             close(fd);
             zlog_error(conn->param.log, "connect %s:%d error: %s(%d)",
@@ -849,22 +938,53 @@ static void conn_connect(neu_conn_t *conn)
                 .tv_usec = (conn->param.params.udpto.timeout % 1000) * 1000,
             };
 
-            fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+            if (is_ipv4(conn->param.params.udpto.src_ip)) {
+                fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+            } else {
+                fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
+            }
             setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
             setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
         } else {
-            fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+            if (is_ipv4(conn->param.params.udpto.src_ip)) {
+                fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+            } else {
+                fd = socket(AF_INET6, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+            }
         }
         int so_broadcast = 1;
         setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &so_broadcast,
                    sizeof(so_broadcast));
-        struct sockaddr_in local = {
-            .sin_family      = AF_INET,
-            .sin_port        = htons(conn->param.params.udpto.src_port),
-            .sin_addr.s_addr = inet_addr(conn->param.params.udpto.src_ip),
-        };
 
-        ret = bind(fd, (struct sockaddr *) &local, sizeof(struct sockaddr_in));
+        if (is_ipv4(conn->param.params.udpto.src_ip)) {
+            fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+
+            struct sockaddr_in local = {
+                .sin_family      = AF_INET,
+                .sin_port        = htons(conn->param.params.udpto.src_port),
+                .sin_addr.s_addr = inet_addr(conn->param.params.udpto.src_ip),
+            };
+
+            ret = bind(fd, (struct sockaddr *) &local,
+                       sizeof(struct sockaddr_in));
+        } else if (is_ipv6(conn->param.params.udp.dst_ip)) {
+            fd = socket(AF_INET6, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+
+            struct sockaddr_in6 local = { 0 };
+            local.sin6_family         = AF_INET6;
+            local.sin6_port = htons(conn->param.params.udpto.src_port);
+
+            inet_pton(AF_INET6, conn->param.params.udpto.src_ip,
+                      &local.sin6_addr);
+
+            ret = bind(fd, (struct sockaddr *) &local,
+                       sizeof(struct sockaddr_in6));
+        } else {
+            zlog_error(conn->param.log, "invalid ip: %s",
+                       conn->param.params.tcp_server.ip);
+            return;
+        }
+
         if (ret != 0) {
             close(fd);
             zlog_error(conn->param.log, "bind %s:%d error: %s(%d)",
@@ -1175,15 +1295,13 @@ int neu_conn_stream_tcp_server_consume(neu_conn_t *conn, int fd, void *context,
             } else if (used == -1) {
                 neu_conn_tcp_server_close_client(conn, fd);
                 break;
+            } else {
+                conn->offset -= used;
+                memmove(conn->buf, conn->buf + used, conn->offset);
+                neu_protocol_unpack_buf_init(&protocol_buf, conn->buf,
+                                             conn->offset);
             }
         }
-        if (conn->offset != 0) {
-            conn->offset -= neu_protocol_unpack_buf_used_size(&protocol_buf);
-            memmove(conn->buf,
-                    conn->buf +
-                        neu_protocol_unpack_buf_used_size(&protocol_buf),
-                    conn->offset);
-        }
     }
     return ret;
 }
@@ -1256,3 +1374,15 @@ int neu_conn_tcp_server_wait_msg(neu_conn_t *conn, int fd, void *context,
 
     return ret;
 }
+
+int is_ipv4(const char *ip)
+{
+    struct sockaddr_in sa;
+    return inet_pton(AF_INET, ip, &(sa.sin_addr)) != 0;
+}
+
+int is_ipv6(const char *ip)
+{
+    struct sockaddr_in6 sa;
+    return inet_pton(AF_INET6, ip, &(sa.sin6_addr)) != 0;
+}

src/connection/mqtt_client.c

@@ -23,6 +23,8 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <arpa/inet.h>
+
 #define NNG_SUPP_TLS 1
 #define NNG_SUPP_SQLITE 1
 #include <nng/mqtt/mqtt_client.h>
@@ -1045,7 +1047,10 @@ int neu_mqtt_client_set_tls(neu_mqtt_client_t *client, bool enabled,
         client->tls_cfg = cfg;
     }
 
-    if (0 != (rv = nng_tls_config_server_name(client->tls_cfg, client->host))) {
+    // validate server name and enable SNI only when host is not an IP address
+    struct sockaddr_in sa;
+    if (0 == inet_pton(AF_INET, client->host, &sa.sin_addr) &&
+        0 != (rv = nng_tls_config_server_name(client->tls_cfg, client->host))) {
         log(error, "nng_tls_config_server_name fail: %s", nng_strerror(rv));
         rv = -1;
         goto end;

src/core/manager.c

@@ -16,13 +16,13 @@
  * along with this program; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  **/
+#include <errno.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/time.h>
 #include <unistd.h>
 
-#include <nng/nng.h>
-#include <nng/protocol/pair1/pair.h>
-#include <nng/supplemental/util/platform.h>
+#include <arpa/inet.h>
 
 #include "event/event.h"
 #include "persist/persist.h"
@@ -45,26 +45,32 @@
 // definition for adapter names
 #define DEFAULT_DASHBOARD_ADAPTER_NAME DEFAULT_DASHBOARD_PLUGIN_NAME
 
-static const char *const url = "inproc://neu_manager";
-
 static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data);
-static int manager_level_check(void *usr_data);
-inline static void     reply(neu_manager_t *manager, neu_reqresp_head_t *header,
-                             void *data);
-inline static nng_msg *trans_data_dup(nng_msg *msg);
-inline static void     trans_data_free(nng_msg *msg);
-typedef nng_msg *(*msg_dup)(nng_msg *msg);
-inline static void forward_msg_dup(neu_manager_t *manager, nng_msg *msg,
-                                   nng_pipe pipe, msg_dup dup);
-inline static void forward_msg(neu_manager_t *manager, nng_msg *msg,
-                               const char *node);
-inline static void notify_monitor(neu_manager_t *    manager,
-                                  neu_reqresp_type_e event, void *data);
+
+inline static void reply(neu_manager_t *manager, neu_reqresp_head_t *header,
+                         void *data);
+inline static void forward_msg(neu_manager_t *     manager,
+                               neu_reqresp_head_t *header, const char *node);
+
+// inline static nng_msg *trans_data_dup(nng_msg *msg);
+// inline static void     trans_data_free(nng_msg *msg);
+// typedef nng_msg *(*msg_dup)(nng_msg *msg);
+// inline static void forward_msg_dup(neu_manager_t *manager, nng_msg *msg,
+// nng_pipe pipe, msg_dup dup);
+
+inline static void notify_monitors(neu_manager_t *    manager,
+                                   neu_reqresp_type_e event, void *data);
 static void start_static_adapter(neu_manager_t *manager, const char *name);
 static int  update_timestamp(void *usr_data);
 static void start_single_adapter(neu_manager_t *manager, const char *name,
                                  const char *plugin_name, bool display);
 
+uint16_t neu_manager_get_port()
+{
+    static uint16_t port = 10000;
+    return port++;
+}
+
 neu_manager_t *neu_manager_create()
 {
     int                  rv      = 0;
@@ -81,29 +87,26 @@ neu_manager_t *neu_manager_create()
         .type        = NEU_EVENT_TIMER_NOBLOCK,
     };
 
-    neu_event_timer_param_t timer_level = {
-        .second      = 60,
-        .millisecond = 0,
-        .cb          = manager_level_check,
-        .type        = NEU_EVENT_TIMER_BLOCK,
-    };
-
     manager->events            = neu_event_new();
     manager->plugin_manager    = neu_plugin_manager_create();
     manager->node_manager      = neu_node_manager_create();
     manager->subscribe_manager = neu_subscribe_manager_create();
     manager->template_manager  = neu_template_manager_create();
 
-    rv = nng_pair1_open_poly(&manager->socket);
+    manager->server_fd =
+        socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP);
+    assert(manager->server_fd > 0);
+
+    struct sockaddr_in local = {
+        .sin_family      = AF_INET,
+        .sin_port        = htons(7788),
+        .sin_addr.s_addr = inet_addr("127.0.0.1"),
+    };
+    rv = bind(manager->server_fd, (struct sockaddr *) &local,
+              sizeof(struct sockaddr_in));
     assert(rv == 0);
 
-    rv = nng_listen(manager->socket, url, NULL, 0);
-    assert(rv == 0);
-
-    nng_socket_set_int(manager->socket, NNG_OPT_RECVBUF, 8192);
-    nng_socket_set_int(manager->socket, NNG_OPT_SENDBUF, 8292);
-    nng_socket_set_ms(manager->socket, NNG_OPT_SENDTIMEO, 1000);
-    nng_socket_get_int(manager->socket, NNG_OPT_RECVFD, &param.fd);
+    param.fd      = manager->server_fd;
     manager->loop = neu_event_add_io(manager->events, param);
 
     manager->timestamp_lev_manager = 0;
@@ -136,9 +139,6 @@ neu_manager_t *neu_manager_create()
 
     manager_load_subscribe(manager);
 
-    timer_level.usr_data = (void *) manager;
-    manager->timer_lev   = neu_event_add_timer(manager->events, timer_level);
-
     timestamp_timer_param.usr_data = (void *) manager;
     manager->timer_timestamp =
         neu_event_add_timer(manager->events, timestamp_timer_param);
@@ -149,25 +149,29 @@ neu_manager_t *neu_manager_create()
 
 void neu_manager_destroy(neu_manager_t *manager)
 {
-    neu_reqresp_head_t  header     = { .type = NEU_REQ_NODE_UNINIT };
-    neu_req_node_init_t uninit     = { 0 };
-    nng_msg *           uninit_msg = NULL;
-    UT_array *pipes = neu_node_manager_get_pipes_all(manager->node_manager);
+    memset(manager->buf, 0, sizeof(manager->buf));
+    neu_reqresp_head_t *header = (neu_reqresp_head_t *) manager->buf;
+    neu_req_node_init_t uninit = { 0 };
+
+    UT_array *addrs = neu_node_manager_get_addrs_all(manager->node_manager);
 
     neu_event_del_timer(manager->events, manager->timer_lev);
     neu_event_del_timer(manager->events, manager->timer_timestamp);
-    strcpy(header.sender, "manager");
-    utarray_foreach(pipes, nng_pipe *, pipe)
-    {
-        uninit_msg = neu_msg_gen(&header, &uninit);
-        nng_msg_set_pipe(uninit_msg, *pipe);
 
-        if (nng_sendmsg(manager->socket, uninit_msg, 0) != 0) {
-            nng_msg_free(uninit_msg);
-            nlog_warn("manager -> %d uninit msg send fail", (*pipe).id);
+    header->type = NEU_REQ_NODE_UNINIT;
+    strcpy(header->sender, "manager");
+
+    utarray_foreach(addrs, struct sockaddr_in *, addr)
+    {
+        neu_msg_gen(header, &uninit);
+        if (sendto(manager->server_fd, manager->buf, header->len, 0,
+                   (struct sockaddr *) addr,
+                   sizeof(struct sockaddr_in)) != (int) header->len) {
+            nlog_error("manager -> %s uninit msg send fail",
+                       inet_ntoa((*addr).sin_addr));
         }
     }
-    utarray_free(pipes);
+    utarray_free(addrs);
 
     while (1) {
         usleep(1000 * 100);
@@ -181,7 +185,7 @@ void neu_manager_destroy(neu_manager_t *manager)
     neu_plugin_manager_destroy(manager->plugin_manager);
     neu_template_manager_destroy(manager->template_manager);
 
-    nng_close(manager->socket);
+    close(manager->server_fd);
     neu_event_del_io(manager->events, manager->loop);
     neu_event_close(manager->events);
 
@@ -189,92 +193,41 @@ void neu_manager_destroy(neu_manager_t *manager)
     nlog_notice("manager exit");
 }
 
-const char *neu_manager_get_url()
-{
-    return url;
-}
-
-static int manager_level_check(void *usr_data)
-{
-    neu_manager_t *manager = (neu_manager_t *) usr_data;
-
-    if (0 != manager->timestamp_lev_manager) {
-        struct timeval   tv      = { 0 };
-        int64_t          diff    = { 0 };
-        int64_t          delay_s = 600;
-        zlog_category_t *neuron  = zlog_get_category("neuron");
-
-        gettimeofday(&tv, NULL);
-        diff = tv.tv_sec - manager->timestamp_lev_manager;
-        if (delay_s <= diff) {
-            int ret = zlog_level_switch(neuron, default_log_level);
-            if (0 != ret) {
-                nlog_error("Modify default log level fail, ret:%d", ret);
-            }
-        }
-    }
-
-    return 0;
-}
-
 static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 {
-    neu_manager_t *     manager = (neu_manager_t *) usr_data;
-    int                 rv      = 0;
-    nng_msg *           msg     = NULL;
-    neu_reqresp_head_t *header  = NULL;
+    int                 rv       = 0;
+    neu_manager_t *     manager  = (neu_manager_t *) usr_data;
+    socklen_t           addr_len = sizeof(struct sockaddr_in);
+    struct sockaddr_in  src_addr = { 0 };
+    neu_reqresp_head_t *header   = NULL;
 
     if (type == NEU_EVENT_IO_CLOSED || type == NEU_EVENT_IO_HUP) {
         nlog_warn("manager socket(%d) recv closed or hup %d.", fd, type);
         return 0;
     }
 
-    rv = nng_recvmsg(manager->socket, &msg, NNG_FLAG_NONBLOCK);
-    if (rv != 0) {
-        nlog_warn("manager recv msg error: %d", rv);
+    memset(manager->recv_buf, 0, sizeof(manager->recv_buf));
+    rv = recvfrom(manager->server_fd, manager->recv_buf,
+                  sizeof(manager->recv_buf), 0, (struct sockaddr *) &src_addr,
+                  &addr_len);
+    if (rv == -1) {
+        nlog_warn("manager recv msg error: %s(%d)", strerror(errno), errno);
         return 0;
     }
 
-    header = (neu_reqresp_head_t *) nng_msg_body(msg);
+    header = (neu_reqresp_head_t *) manager->recv_buf;
 
     nlog_info("manager recv msg from: %s to %s, type: %s", header->sender,
               header->receiver, neu_reqresp_type_string(header->type));
     switch (header->type) {
-    case NEU_REQRESP_TRANS_DATA: {
-        neu_reqresp_trans_data_t *cmd = (neu_reqresp_trans_data_t *) &header[1];
-        UT_array *apps = neu_subscribe_manager_find(manager->subscribe_manager,
-                                                    cmd->driver, cmd->group);
-        if (apps != NULL) {
-            utarray_foreach(apps, neu_app_subscribe_t *, app)
-            {
-                forward_msg_dup(manager, msg, app->pipe, trans_data_dup);
-                nlog_debug("forward trans data to pipe: %d", app->pipe.id);
-            }
-            utarray_free(apps);
-        }
-
-        trans_data_free(msg);
-        break;
-    }
-    case NEU_REQ_UPDATE_LICENSE: {
-        UT_array *pipes = neu_node_manager_get_pipes_all(manager->node_manager);
-
-        utarray_foreach(pipes, nng_pipe *, pipe)
-        {
-            forward_msg_dup(manager, msg, *pipe, NULL);
-            nlog_notice("forward license update to pipe: %d", pipe->id);
-        }
-        utarray_free(pipes);
-
-        break;
-    }
     case NEU_REQ_NODE_INIT: {
         neu_req_node_init_t *init = (neu_req_node_init_t *) &header[1];
-        nng_pipe             pipe = nng_msg_get_pipe(msg);
 
         if (0 !=
-            neu_node_manager_update(manager->node_manager, init->node, pipe)) {
-            nlog_warn("bind node %s to pipe(%d) fail", init->node, pipe.id);
+            neu_node_manager_update(manager->node_manager, init->node,
+                                    src_addr)) {
+            nlog_warn("bind node %s to src addr(%d) fail", init->node,
+                      ntohs(src_addr.sin_port));
             break;
         }
 
@@ -288,7 +241,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             }
         }
 
-        nlog_notice("bind node %s to pipe(%d)", init->node, pipe.id);
+        nlog_notice("bind node %s to src addr(%d)", init->node,
+                    ntohs(src_addr.sin_port));
         break;
     }
     case NEU_REQ_ADD_PLUGIN: {
@@ -441,15 +395,11 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             (neu_req_update_template_group_t *) &header[1];
         neu_resp_error_t e = { 0 };
 
-        if (cmd->interval < NEU_GROUP_INTERVAL_LIMIT) {
-            e.error = NEU_ERR_GROUP_PARAMETER_INVALID;
-        } else {
-            e.error = neu_manager_update_template_group(manager, cmd);
-        }
+        e.error = neu_manager_update_template_group(manager, cmd);
 
         if (e.error == NEU_ERR_SUCCESS) {
             manager_storage_update_template_group(cmd->tmpl, cmd->group,
-                                                  cmd->interval);
+                                                  cmd->new_name, cmd->interval);
         }
 
         neu_msg_exchange(header);
@@ -592,7 +542,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         if (error == NEU_ERR_SUCCESS) {
             manager_storage_add_node(manager, cmd->node);
-            notify_monitor(manager, NEU_REQ_ADD_NODE_EVENT, cmd);
+            notify_monitors(manager, NEU_REQ_ADD_NODE_EVENT, cmd);
         }
 
         header->type = NEU_RESP_ERROR;
@@ -604,12 +554,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         neu_req_update_node_t *cmd = (neu_req_update_node_t *) &header[1];
         neu_resp_error_t       e   = { 0 };
 
-        if (0 == strcmp("monitor", cmd->node)) {
-            e.error = NEU_ERR_NODE_NOT_ALLOW_UPDATE;
-        } else if (0 == strcmp("monitor", cmd->new_name)) {
-            e.error = NEU_ERR_NODE_EXIST;
-        } else if (NULL ==
-                   neu_node_manager_find(manager->node_manager, cmd->node)) {
+        if (NULL == neu_node_manager_find(manager->node_manager, cmd->node)) {
             e.error = NEU_ERR_NODE_NOT_EXIST;
         } else if (NULL !=
                    neu_node_manager_find(manager->node_manager,
@@ -620,7 +565,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         if (0 == e.error) {
             header->type = NEU_REQ_NODE_RENAME;
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
         } else {
             header->type = NEU_RESP_ERROR;
             neu_msg_exchange(header);
@@ -660,8 +605,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
                                             cmd->node);
         }
         header->type = NEU_REQ_NODE_UNINIT;
-        forward_msg(manager, msg, header->receiver);
-        notify_monitor(manager, NEU_REQ_DEL_NODE_EVENT, cmd);
+        forward_msg(manager, header, header->receiver);
+        notify_monitors(manager, NEU_REQ_DEL_NODE_EVENT, cmd);
         if (neu_adapter_get_type(adapter) == NEU_NA_TYPE_DRIVER) {
             UT_array *apps = neu_subscribe_manager_find_by_driver(
                 manager->subscribe_manager, cmd->node);
@@ -705,14 +650,17 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
     case NEU_REQ_SUBSCRIBE_GROUP: {
-        neu_req_subscribe_t *cmd   = (neu_req_subscribe_t *) &header[1];
-        neu_resp_error_t     error = { 0 };
+        neu_req_subscribe_t *cmd      = (neu_req_subscribe_t *) &header[1];
+        neu_resp_error_t     error    = { 0 };
+        uint16_t             app_port = 0;
 
         error.error = neu_manager_subscribe(manager, cmd->app, cmd->driver,
-                                            cmd->group, cmd->params);
+                                            cmd->group, cmd->params, &app_port);
 
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, msg, cmd->app);
+            cmd->port = app_port;
+            forward_msg(manager, header, cmd->app);
+            forward_msg(manager, header, cmd->driver);
             manager_storage_subscribe(manager, cmd->app, cmd->driver,
                                       cmd->group, cmd->params);
         } else {
@@ -732,14 +680,16 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         for (uint16_t i = 0; i < cmd->n_group; ++i) {
             neu_req_subscribe_group_info_t *info = &cmd->groups[i];
 
-            error.error = neu_manager_subscribe(manager, cmd->app, info->driver,
-                                                info->group, info->params);
+            error.error =
+                neu_manager_subscribe(manager, cmd->app, info->driver,
+                                      info->group, info->params, &info->port);
             if (0 != error.error) {
                 break;
             }
 
-            error.error = neu_manager_send_subscribe(
-                manager, cmd->app, info->driver, info->group, info->params);
+            error.error = neu_manager_send_subscribe(manager, cmd->app,
+                                                     info->driver, info->group,
+                                                     info->port, info->params);
             if (0 != error.error) {
                 break;
             }
@@ -762,7 +712,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             manager, cmd->app, cmd->driver, cmd->group, cmd->params);
 
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, msg, cmd->app);
+            forward_msg(manager, header, cmd->app);
             manager_storage_update_subscribe(manager, cmd->app, cmd->driver,
                                              cmd->group, cmd->params);
         } else {
@@ -782,7 +732,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_manager_unsubscribe(manager, cmd->app, cmd->driver, cmd->group);
 
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, msg, cmd->app);
+            forward_msg(manager, header, cmd->app);
+            forward_msg(manager, header, cmd->driver);
             manager_storage_unsubscribe(manager, cmd->app, cmd->driver,
                                         cmd->group);
         }
@@ -859,12 +810,13 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
 
         break;
     }
+
     case NEU_REQ_GET_GROUP:
     case NEU_REQ_GET_NODE_SETTING:
+    case NEU_REQ_GET_NODE_STATE:
     case NEU_REQ_READ_GROUP:
     case NEU_REQ_WRITE_TAG:
     case NEU_REQ_WRITE_TAGS:
-    case NEU_REQ_GET_NODE_STATE:
     case NEU_REQ_GET_TAG:
     case NEU_REQ_GET_NDRIVER_TAGS:
     case NEU_REQ_NODE_CTL:
@@ -876,7 +828,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_msg_exchange(header);
             reply(manager, header, &e);
         } else {
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
         }
 
         break;
@@ -897,7 +849,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
                 utarray_foreach(apps, neu_app_subscribe_t *, app)
                 {
                     header->type = NEU_REQ_UPDATE_NODE;
-                    forward_msg(manager, msg, app->app_name);
+                    forward_msg(manager, header, app->app_name);
                 }
 
                 utarray_free(apps);
@@ -924,7 +876,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
                 utarray_foreach(apps, neu_app_subscribe_t *, app)
                 {
                     header->type = NEU_REQ_UPDATE_GROUP;
-                    forward_msg(manager, msg, app->app_name);
+                    forward_msg(manager, header, app->app_name);
                 }
 
                 utarray_free(apps);
@@ -940,16 +892,14 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_REQ_ADD_NODE_EVENT:
     case NEU_REQ_DEL_NODE_EVENT:
     case NEU_REQ_NODE_CTL_EVENT:
+    case NEU_REQ_NODE_SETTING_EVENT:
     case NEU_REQ_ADD_GROUP_EVENT:
     case NEU_REQ_DEL_GROUP_EVENT:
     case NEU_REQ_UPDATE_GROUP_EVENT:
     case NEU_REQ_ADD_TAG_EVENT:
     case NEU_REQ_DEL_TAG_EVENT:
     case NEU_REQ_UPDATE_TAG_EVENT: {
-        if (neu_node_manager_find(manager->node_manager, header->receiver)) {
-            forward_msg(manager, msg, header->receiver);
-        }
-
+        notify_monitors(manager, header->type, &header[1]);
         break;
     }
 
@@ -964,7 +914,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             e.error = NEU_ERR_GROUP_NOT_ALLOW;
         } else {
             header->type = NEU_REQ_UPDATE_DRIVER_GROUP;
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
         }
 
         if (e.error) {
@@ -986,7 +936,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_msg_exchange(header);
             reply(manager, header, &e);
         } else {
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
             neu_subscribe_manager_remove(manager->subscribe_manager,
                                          cmd->driver, cmd->group);
         }
@@ -1006,7 +956,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             }
             free(cmd->tags);
         } else {
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
         }
 
         break;
@@ -1026,13 +976,12 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             }
             free(cmd->tags);
         } else {
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
         }
 
         break;
     }
-    case NEU_REQ_NODE_SETTING:
-    case NEU_REQ_NODE_SETTING_EVENT: {
+    case NEU_REQ_NODE_SETTING: {
         neu_req_node_setting_t *cmd = (neu_req_node_setting_t *) &header[1];
 
         if (neu_node_manager_find(manager->node_manager, header->receiver) ==
@@ -1043,7 +992,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             reply(manager, header, &e);
             free(cmd->setting);
         } else {
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
         }
         break;
     }
@@ -1060,7 +1009,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_RESP_GET_NODE_STATE:
     case NEU_RESP_ERROR:
     case NEU_RESP_READ_GROUP:
-        forward_msg(manager, msg, header->receiver);
+        forward_msg(manager, header, header->receiver);
         break;
 
     case NEU_REQ_ADD_NDRIVER_MAP: {
@@ -1070,7 +1019,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         error.error = neu_manager_add_ndriver_map(manager, cmd->ndriver,
                                                   cmd->driver, cmd->group);
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, msg, cmd->ndriver);
+            forward_msg(manager, header, cmd->ndriver);
             manager_storage_add_ndriver_map(manager, cmd->ndriver, cmd->driver,
                                             cmd->group);
         }
@@ -1087,7 +1036,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         error.error = neu_manager_del_ndriver_map(manager, cmd->ndriver,
                                                   cmd->driver, cmd->group);
         if (error.error == NEU_ERR_SUCCESS) {
-            forward_msg(manager, msg, cmd->ndriver);
+            forward_msg(manager, header, cmd->ndriver);
             manager_storage_del_ndriver_map(manager, cmd->ndriver, cmd->driver,
                                             cmd->group);
         }
@@ -1121,7 +1070,7 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
     case NEU_REQ_UPDATE_NDRIVER_TAG_INFO: {
         if (NULL !=
             neu_node_manager_find(manager->node_manager, header->receiver)) {
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
             break;
         }
 
@@ -1147,11 +1096,14 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             neu_msg_exchange(header);
             reply(manager, header, &e);
         } else {
-            struct timeval tv = { 0 };
-            gettimeofday(&tv, NULL);
-            manager->timestamp_lev_manager = tv.tv_sec;
+            neu_req_update_log_level_t *cmd =
+                (neu_req_update_log_level_t *) &header[1];
+            neu_adapter_t *adapter_log =
+                neu_node_manager_find(manager->node_manager, header->receiver);
+            strcpy(neu_plugin_to_plugin_common(adapter_log->plugin)->log_level,
+                   cmd->log_level);
 
-            forward_msg(manager, msg, header->receiver);
+            forward_msg(manager, header, header->receiver);
         }
 
         break;
@@ -1160,96 +1112,115 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
         break;
     }
 
-    nng_msg_free(msg);
     return 0;
 }
 
-inline static void forward_msg_dup(neu_manager_t *manager, nng_msg *msg,
-                                   nng_pipe pipe, msg_dup dup)
+inline static void forward_msg(neu_manager_t *     manager,
+                               neu_reqresp_head_t *header, const char *node)
 {
-    nng_msg *out_msg;
+    struct sockaddr_in addr =
+        neu_node_manager_get_addr(manager->node_manager, node);
 
-    nng_msg_dup(&out_msg, msg);
-    if (dup != NULL) {
-        out_msg = dup(out_msg);
-    }
-    nng_msg_set_pipe(out_msg, pipe);
-    if (nng_sendmsg(manager->socket, out_msg, 0) == 0) {
-        nlog_info("forward msg to pipe %d", pipe.id);
+    int ret = sendto(manager->server_fd, header, header->len, 0,
+                     (struct sockaddr *) &addr, sizeof(addr));
+    if (ret != (int) header->len) {
+        nlog_warn("forward msg %s to node (%s)%d fail",
+                  neu_reqresp_type_string(header->type), node,
+                  ntohs(addr.sin_port));
     } else {
-        nlog_warn("forward msg to pipe %d fail", pipe.id);
-        nng_msg_free(out_msg);
+        nlog_info("forward msg %s to %s", neu_reqresp_type_string(header->type),
+                  node);
     }
 }
 
-inline static nng_msg *trans_data_dup(nng_msg *msg)
-{
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) nng_msg_body(msg);
-    assert(header->type == NEU_REQRESP_TRANS_DATA);
-    neu_reqresp_trans_data_t *cmd = (neu_reqresp_trans_data_t *) &header[1];
+struct notify_monitor_ctx {
+    neu_manager_t *    manager;
+    neu_reqresp_type_e event;
+    void *             data;
+};
 
-    for (int i = 0; i < cmd->n_tag; i++) {
-        if (cmd->tags[i].value.type == NEU_TYPE_PTR) {
-            uint8_t *ptr = calloc(cmd->tags[i].value.value.ptr.length, 1);
-            cmd->tags[i].value.value.ptr.ptr = ptr;
+static int notify_monitor(const char *name, struct sockaddr_in addr, void *arg)
+{
+    struct notify_monitor_ctx *ctx     = arg;
+    void *                     data    = NULL;
+    neu_req_node_setting_t     setting = { 0 };
+    neu_req_add_tag_t          mod_tag = { 0 };
+    neu_req_del_tag_t          del_tag = { 0 };
+
+    // monitor not ready, ignore
+    if (0 == addr.sin_port) {
+        return 0;
+    }
+
+    // copy message data
+    switch (ctx->event) {
+    case NEU_REQ_NODE_SETTING_EVENT: {
+        if (0 != neu_req_node_setting_copy(&setting, ctx->data)) {
+            return -1;
         }
+        data = &setting;
+        break;
     }
-
-    return msg;
-}
-
-inline static void trans_data_free(nng_msg *msg)
-{
-    neu_reqresp_head_t *header = (neu_reqresp_head_t *) nng_msg_body(msg);
-    assert(header->type == NEU_REQRESP_TRANS_DATA);
-    neu_reqresp_trans_data_t *cmd = (neu_reqresp_trans_data_t *) &header[1];
-
-    for (int i = 0; i < cmd->n_tag; i++) {
-        if (cmd->tags[i].value.type == NEU_TYPE_PTR) {
-            free(cmd->tags[i].value.value.ptr.ptr);
+    case NEU_REQ_ADD_TAG_EVENT:
+    case NEU_REQ_UPDATE_TAG_EVENT: {
+        if (0 != neu_req_add_tag_copy(&mod_tag, ctx->data)) {
+            return -1;
         }
+        data = &mod_tag;
+        break;
     }
+    case NEU_REQ_DEL_TAG_EVENT: {
+        if (0 != neu_req_del_tag_copy(&del_tag, ctx->data)) {
+            return -1;
+        }
+        data = &del_tag;
+        break;
+    }
+    default:
+        data = ctx->data;
+    }
+
+    // message header
+    memset(ctx->manager->buf, 0, sizeof(ctx->manager->buf));
+    neu_reqresp_head_t *header = (neu_reqresp_head_t *) ctx->manager->buf;
+
+    strcpy(header->sender, "manager");
+    strcpy(header->receiver, name);
+    header->type = ctx->event;
+
+    // send message
+    neu_msg_gen(header, data);
+
+    int ret = sendto(ctx->manager->server_fd, header, header->len, 0,
+                     (struct sockaddr *) &addr, sizeof(addr));
+    if (ret <= 0) {
+        nlog_warn("notify %s of %s, error: %s(%d)", header->receiver,
+                  neu_reqresp_type_string(header->type), strerror(errno),
+                  errno);
+    }
+
+    return 0;
 }
 
-inline static void forward_msg(neu_manager_t *manager, nng_msg *msg,
-                               const char *node)
+inline static void notify_monitors(neu_manager_t *    manager,
+                                   neu_reqresp_type_e event, void *data)
 {
-    nng_msg *out_msg;
-    nng_pipe pipe = neu_node_manager_get_pipe(manager->node_manager, node);
-
-    nng_msg_dup(&out_msg, msg);
-    nng_msg_set_pipe(out_msg, pipe);
-    if (nng_sendmsg(manager->socket, out_msg, 0) == 0) {
-        nlog_info("forward msg to %s", node);
-    } else {
-        nlog_warn("forward msg to pipe (%s)%d fail", node, pipe.id);
-        nng_msg_free(out_msg);
-    }
-}
-
-inline static void notify_monitor(neu_manager_t *    manager,
-                                  neu_reqresp_type_e event, void *data)
-{
-    nng_pipe pipe = neu_node_manager_get_pipe(manager->node_manager, "monitor");
-    if (0 == pipe.id) {
-        nlog_error("no monitor node");
-        return;
-    }
-
-    neu_reqresp_head_t header = {
-        .sender   = "manager",
-        .receiver = "monitor",
-        .type     = event,
+    struct notify_monitor_ctx ctx = {
+        .manager = manager,
+        .event   = event,
+        .data    = data,
     };
 
-    nng_msg *msg = neu_msg_gen(&header, data);
-    nng_msg_set_pipe(msg, pipe);
+    neu_node_manager_for_each_monitor(manager->node_manager, notify_monitor,
+                                      &ctx);
 
-    int ret = nng_sendmsg(manager->socket, msg, 0);
-    if (ret != 0) {
-        nng_msg_free(msg);
-        nlog_warn("notify %s of %s, error: %s", header.receiver,
-                  neu_reqresp_type_string(header.type), nng_strerror(ret));
+    if (NEU_REQ_NODE_SETTING_EVENT == event) {
+        neu_req_node_setting_fini(data);
+    } else if (NEU_REQ_ADD_TAG_EVENT == event ||
+               NEU_REQ_UPDATE_TAG_EVENT == event) {
+        neu_req_add_tag_fini(data);
+    } else if (NEU_REQ_DEL_TAG_EVENT == event) {
+        neu_req_del_tag_fini(data);
     }
 }
 
@@ -1302,17 +1273,20 @@ static void start_single_adapter(neu_manager_t *manager, const char *name,
 inline static void reply(neu_manager_t *manager, neu_reqresp_head_t *header,
                          void *data)
 {
-    nng_msg *msg = neu_msg_gen(header, data);
-    nng_pipe pipe =
-        neu_node_manager_get_pipe(manager->node_manager, header->receiver);
+    neu_msg_gen(header, data);
+    struct sockaddr_in addr =
+        neu_node_manager_get_addr(manager->node_manager, header->receiver);
 
-    nng_msg_set_pipe(msg, pipe);
-    int ret = nng_sendmsg(manager->socket, msg, 0);
+    int ret = sendto(manager->server_fd, header, header->len, 0,
+                     (struct sockaddr *) &addr, sizeof(addr));
 
-    if (ret != 0) {
-        nng_msg_free(msg);
+    if (ret != (int) header->len) {
         nlog_warn("reply %s to %s, error: %d",
                   neu_reqresp_type_string(header->type), header->receiver, ret);
+    } else {
+        nlog_notice("reply %s to %s(%d) %p",
+                    neu_reqresp_type_string(header->type), header->receiver,
+                    ntohs(addr.sin_port), header->ctx);
     }
 }
 

src/core/manager.h

@@ -29,6 +29,6 @@
 neu_manager_t *neu_manager_create();
 void           neu_manager_destroy(neu_manager_t *manager);
 
-const char *neu_manager_get_url(void);
+uint16_t neu_manager_get_port();
 
 #endif

src/core/manager_internal.c

@@ -19,6 +19,7 @@
 #include <dlfcn.h>
 
 #include "utils/log.h"
+#include "json/neu_json_param.h"
 
 #include "adapter.h"
 #include "errcodes.h"
@@ -332,7 +333,21 @@ int neu_manager_update_template_group(neu_manager_t *                  manager,
         return NEU_ERR_TEMPLATE_NOT_FOUND;
     }
 
-    return neu_template_update_group(tmpl, req->group, req->interval);
+    int rv = 0;
+
+    if (strlen(req->new_name) > 0 && 0 != strcmp(req->group, req->new_name)) {
+        rv = neu_template_update_group_name(tmpl, req->group, req->new_name);
+        if (0 != rv) {
+            return rv;
+        }
+    }
+
+    if (req->interval >= NEU_GROUP_INTERVAL_LIMIT) {
+        rv = neu_template_update_group_interval(tmpl, req->new_name,
+                                                req->interval);
+    }
+
+    return rv;
 }
 
 int neu_manager_del_template_group(neu_manager_t *               manager,
@@ -646,9 +661,9 @@ static inline int manager_subscribe(neu_manager_t *manager, const char *app,
                                     const char *driver, const char *group,
                                     const char *params)
 {
-    int            ret  = NEU_ERR_SUCCESS;
-    nng_pipe       pipe = { 0 };
-    neu_adapter_t *adapter =
+    int                ret  = NEU_ERR_SUCCESS;
+    struct sockaddr_in addr = { 0 };
+    neu_adapter_t *    adapter =
         neu_node_manager_find(manager->node_manager, driver);
 
     if (adapter == NULL) {
@@ -661,16 +676,16 @@ static inline int manager_subscribe(neu_manager_t *manager, const char *app,
         return ret;
     }
 
-    pipe = neu_node_manager_get_pipe(manager->node_manager, app);
+    addr = neu_node_manager_get_addr(manager->node_manager, app);
     return neu_subscribe_manager_sub(manager->subscribe_manager, driver, app,
-                                     group, params, pipe);
+                                     group, params, addr);
 }
 
 int neu_manager_subscribe(neu_manager_t *manager, const char *app,
                           const char *driver, const char *group,
-                          const char *params)
+                          const char *params, uint16_t *app_port)
 {
-    if (0 == strcmp(app, "monitor")) {
+    if (neu_node_manager_is_monitor(manager->node_manager, app)) {
         // filter out monitor node
         return NEU_ERR_NODE_NOT_ALLOW_SUBSCRIBE;
     }
@@ -681,6 +696,21 @@ int neu_manager_subscribe(neu_manager_t *manager, const char *app,
         return NEU_ERR_NODE_NOT_EXIST;
     }
 
+    *app_port = neu_adapter_trans_data_port(adapter);
+
+    // guard against empty mqtt topic parameter
+    // this is not an elegant solution due to the current architecture
+    if (params && 0 == strcmp(adapter->module->module_name, "MQTT")) {
+        neu_json_elem_t elem = { .name = "topic", .t = NEU_JSON_STR };
+        neu_json_decode((char *) params, 1, &elem);
+        neu_parse_param(params, NULL, 1, &elem);
+        if (elem.v.val_str && 0 == strlen(elem.v.val_str)) {
+            free(elem.v.val_str);
+            return NEU_ERR_MQTT_SUBSCRIBE_FAILURE;
+        }
+        free(elem.v.val_str);
+    }
+
     if (NEU_NA_TYPE_APP != neu_adapter_get_type(adapter)) {
         return NEU_ERR_NODE_NOT_ALLOW_SUBSCRIBE;
     }
@@ -698,35 +728,53 @@ int neu_manager_update_subscribe(neu_manager_t *manager, const char *app,
 
 int neu_manager_send_subscribe(neu_manager_t *manager, const char *app,
                                const char *driver, const char *group,
-                               const char *params)
+                               uint16_t app_port, const char *params)
 {
-    neu_reqresp_head_t header = { 0 };
-    header.type               = NEU_REQ_SUBSCRIBE_GROUP;
-    strcpy(header.sender, "manager");
-    strcpy(header.receiver, app);
+    memset(manager->buf, 0, sizeof(manager->buf));
+    neu_reqresp_head_t *header = (neu_reqresp_head_t *) manager->buf;
+    header->type               = NEU_REQ_SUBSCRIBE_GROUP;
+    strcpy(header->sender, "manager");
+    strcpy(header->receiver, app);
 
     neu_req_subscribe_t cmd = { 0 };
     strcpy(cmd.app, app);
     strcpy(cmd.driver, driver);
     strcpy(cmd.group, group);
+    cmd.port = app_port;
 
     if (params && NULL == (cmd.params = strdup(params))) {
         return NEU_ERR_EINTERNAL;
     }
 
-    nng_msg *out_msg;
-    nng_pipe pipe = neu_node_manager_get_pipe(manager->node_manager, app);
+    struct sockaddr_in addr =
+        neu_node_manager_get_addr(manager->node_manager, app);
 
-    out_msg = neu_msg_gen(&header, &cmd);
-    nng_msg_set_pipe(out_msg, pipe);
+    neu_msg_gen(header, &cmd);
 
-    if (nng_sendmsg(manager->socket, out_msg, 0) == 0) {
-        nlog_notice("send %s to %s", neu_reqresp_type_string(header.type), app);
-    } else {
-        nlog_warn("send %s to %s failed", neu_reqresp_type_string(header.type),
-                  app);
+    int ret = sendto(manager->server_fd, header, header->len, 0,
+                     (struct sockaddr *) &addr, sizeof(addr));
+    if (ret != (int) header->len) {
+        nlog_warn("send %s to %s app failed",
+                  neu_reqresp_type_string(header->type), app);
         free(cmd.params);
-        nng_msg_free(out_msg);
+    } else {
+        nlog_notice("send %s to %s app", neu_reqresp_type_string(header->type),
+                    app);
+    }
+
+    strcpy(header->receiver, driver);
+    addr = neu_node_manager_get_addr(manager->node_manager, driver);
+
+    neu_msg_gen(header, &cmd);
+
+    ret = sendto(manager->server_fd, header, header->len, 0,
+                 (struct sockaddr *) &addr, sizeof(addr));
+    if (ret != (int) header->len) {
+        nlog_warn("send %s to %s driver failed",
+                  neu_reqresp_type_string(header->type), app);
+    } else {
+        nlog_notice("send %s to %s driver",
+                    neu_reqresp_type_string(header->type), app);
     }
 
     return 0;

src/core/manager_internal.h

@@ -20,9 +20,6 @@
 #ifndef _NEU_MANAGER_INTERNAL_H_
 #define _NEU_MANAGER_INTERNAL_H_
 
-#include <nng/nng.h>
-#include <nng/supplemental/util/platform.h>
-
 #include "event/event.h"
 #include "persist/persist.h"
 
@@ -32,7 +29,9 @@
 #include "template_manager.h"
 
 typedef struct neu_manager {
-    nng_socket      socket;
+    int             server_fd;
+    uint8_t         buf[NEU_MSG_MAX_SIZE];
+    uint8_t         recv_buf[NEU_MSG_MAX_SIZE];
     neu_events_t *  events;
     neu_event_io_t *loop;
 
@@ -102,13 +101,13 @@ UT_array *neu_manager_get_driver_group(neu_manager_t *manager);
 
 int       neu_manager_subscribe(neu_manager_t *manager, const char *app,
                                 const char *driver, const char *group,
-                                const char *params);
+                                const char *params, uint16_t *app_port);
 int       neu_manager_update_subscribe(neu_manager_t *manager, const char *app,
                                        const char *driver, const char *group,
                                        const char *params);
 int       neu_manager_send_subscribe(neu_manager_t *manager, const char *app,
                                      const char *driver, const char *group,
-                                     const char *params);
+                                     uint16_t app_port, const char *params);
 int       neu_manager_unsubscribe(neu_manager_t *manager, const char *app,
                                   const char *driver, const char *group);
 UT_array *neu_manager_get_sub_group(neu_manager_t *manager, const char *app);

src/core/node_manager.c

@@ -28,24 +28,29 @@
 typedef struct node_entity {
     char *name;
 
-    neu_adapter_t *adapter;
-    bool           is_static;
-    bool           display;
-    bool           single;
-    nng_pipe       pipe;
+    neu_adapter_t *    adapter;
+    bool               is_static;
+    bool               display;
+    bool               single;
+    bool               is_monitor;
+    struct sockaddr_in addr;
 
     UT_hash_handle hh;
-
 } node_entity_t;
 
 struct neu_node_manager {
     node_entity_t *nodes;
+    UT_array *     monitors;
 };
 
 neu_node_manager_t *neu_node_manager_create()
 {
     neu_node_manager_t *node_manager = calloc(1, sizeof(neu_node_manager_t));
 
+    if (node_manager) {
+        utarray_new(node_manager->monitors, &ut_ptr_icd);
+    }
+
     return node_manager;
 }
 
@@ -60,6 +65,7 @@ void neu_node_manager_destroy(neu_node_manager_t *mgr)
         free(el);
     }
 
+    utarray_free(mgr->monitors);
     free(mgr);
 }
 
@@ -70,9 +76,15 @@ int neu_node_manager_add(neu_node_manager_t *mgr, neu_adapter_t *adapter)
     node->adapter = adapter;
     node->name    = strdup(adapter->name);
     node->display = true;
+    node->is_monitor =
+        (0 == strcmp(node->adapter->module->module_name, "Monitor"));
 
     HASH_ADD_STR(mgr->nodes, name, node);
 
+    if (node->is_monitor) {
+        utarray_push_back(mgr->monitors, &node);
+    }
+
     return 0;
 }
 
@@ -129,7 +141,7 @@ int neu_node_manager_update_name(neu_node_manager_t *mgr, const char *node_name,
 }
 
 int neu_node_manager_update(neu_node_manager_t *mgr, const char *name,
-                            nng_pipe pipe)
+                            struct sockaddr_in addr)
 {
     node_entity_t *node = NULL;
 
@@ -137,7 +149,7 @@ int neu_node_manager_update(neu_node_manager_t *mgr, const char *name,
     if (NULL == node) {
         return -1;
     }
-    node->pipe = pipe;
+    node->addr = addr;
 
     return 0;
 }
@@ -149,6 +161,10 @@ void neu_node_manager_del(neu_node_manager_t *mgr, const char *name)
     HASH_FIND_STR(mgr->nodes, name, node);
     if (node != NULL) {
         HASH_DEL(mgr->nodes, node);
+        if (node->is_monitor) {
+            utarray_erase(mgr->monitors, utarray_eltidx(mgr->monitors, node),
+                          1);
+        }
         free(node->name);
         free(node);
     }
@@ -165,7 +181,7 @@ bool neu_node_manager_exist_uninit(neu_node_manager_t *mgr)
 
     HASH_ITER(hh, mgr->nodes, el, tmp)
     {
-        if (el->pipe.id == 0) {
+        if (el->addr.sin_port == 0) {
             return true;
         }
     }
@@ -303,55 +319,82 @@ bool neu_node_manager_is_driver(neu_node_manager_t *mgr, const char *name)
     return false;
 }
 
-UT_array *neu_node_manager_get_pipes(neu_node_manager_t *mgr, int type)
+UT_array *neu_node_manager_get_addrs(neu_node_manager_t *mgr, int type)
 {
-    UT_icd         icd   = { sizeof(nng_pipe), NULL, NULL, NULL };
-    UT_array *     pipes = NULL;
+    UT_icd         icd   = { sizeof(struct sockaddr_in), NULL, NULL, NULL };
+    UT_array *     addrs = NULL;
     node_entity_t *el = NULL, *tmp = NULL;
 
-    utarray_new(pipes, &icd);
+    utarray_new(addrs, &icd);
 
     HASH_ITER(hh, mgr->nodes, el, tmp)
     {
         if (!el->is_static) {
             if (el->adapter->module->type & type) {
-                nng_pipe pipe = el->pipe;
-                utarray_push_back(pipes, &pipe);
+                struct sockaddr_in addr = el->addr;
+                utarray_push_back(addrs, &addr);
             }
         }
     }
 
-    return pipes;
+    return addrs;
 }
 
-UT_array *neu_node_manager_get_pipes_all(neu_node_manager_t *mgr)
+UT_array *neu_node_manager_get_addrs_all(neu_node_manager_t *mgr)
 {
-    UT_icd         icd   = { sizeof(nng_pipe), NULL, NULL, NULL };
-    UT_array *     pipes = NULL;
+    UT_icd         icd   = { sizeof(struct sockaddr_in), NULL, NULL, NULL };
+    UT_array *     addrs = NULL;
     node_entity_t *el = NULL, *tmp = NULL;
 
-    utarray_new(pipes, &icd);
+    utarray_new(addrs, &icd);
 
     HASH_ITER(hh, mgr->nodes, el, tmp)
     {
-        nng_pipe pipe = el->pipe;
-        utarray_push_back(pipes, &pipe);
+        struct sockaddr_in addr = el->addr;
+        utarray_push_back(addrs, &addr);
     }
 
-    return pipes;
+    return addrs;
 }
 
-nng_pipe neu_node_manager_get_pipe(neu_node_manager_t *mgr, const char *name)
+struct sockaddr_in neu_node_manager_get_addr(neu_node_manager_t *mgr,
+                                             const char *        name)
 {
-    nng_pipe       pipe = { 0 };
-    node_entity_t *node = NULL;
+    struct sockaddr_in addr = { 0 };
+    node_entity_t *    node = NULL;
 
     HASH_FIND_STR(mgr->nodes, name, node);
     if (node != NULL) {
-        pipe = node->pipe;
+        addr = node->addr;
     }
 
-    return pipe;
+    return addr;
+}
+
+bool neu_node_manager_is_monitor(neu_node_manager_t *mgr, const char *name)
+{
+    node_entity_t *node = NULL;
+    HASH_FIND_STR(mgr->nodes, name, node);
+    return node ? node->is_monitor : false;
+}
+
+int neu_node_manager_for_each_monitor(neu_node_manager_t *mgr,
+                                      int (*cb)(const char *       name,
+                                                struct sockaddr_in addr,
+                                                void *             data),
+                                      void *data)
+{
+    int rv = 0;
+
+    utarray_foreach(mgr->monitors, node_entity_t **, node)
+    {
+        rv = cb((*node)->name, (*node)->addr, data);
+        if (0 != rv) {
+            break;
+        }
+    }
+
+    return rv;
 }
 
 UT_array *neu_node_manager_get_state(neu_node_manager_t *mgr)
@@ -371,6 +414,8 @@ UT_array *neu_node_manager_get_state(neu_node_manager_t *mgr)
             state.state.running = el->adapter->state;
             state.state.link =
                 neu_plugin_to_plugin_common(el->adapter->plugin)->link_state;
+            strcpy(state.state.log_level,
+                   neu_plugin_to_plugin_common(el->adapter->plugin)->log_level);
             neu_metric_entry_t *e = NULL;
             if (NULL != el->adapter->metrics) {
                 HASH_FIND_STR(el->adapter->metrics->entries,
@@ -383,4 +428,4 @@ UT_array *neu_node_manager_get_state(neu_node_manager_t *mgr)
     }
 
     return states;
-}
+}

src/core/node_manager.h

@@ -20,7 +20,7 @@
 #ifndef _NEU_NODE_MANAGER_H_
 #define _NEU_NODE_MANAGER_H_
 
-#include <nng/nng.h>
+#include <arpa/inet.h>
 
 #include "define.h"
 #include "utils/utextend.h"
@@ -40,7 +40,7 @@ int neu_node_manager_add_single(neu_node_manager_t *mgr, neu_adapter_t *adapter,
 int neu_node_manager_update_name(neu_node_manager_t *mgr, const char *node_name,
                                  const char *new_node_name);
 int neu_node_manager_update(neu_node_manager_t *mgr, const char *name,
-                            nng_pipe pipe);
+                            struct sockaddr_in addr);
 bool     neu_node_manager_exist_uninit(neu_node_manager_t *mgr);
 void     neu_node_manager_del(neu_node_manager_t *mgr, const char *name);
 uint16_t neu_node_manager_size(neu_node_manager_t *mgr);
@@ -57,10 +57,16 @@ neu_adapter_t *neu_node_manager_find(neu_node_manager_t *mgr, const char *name);
 bool neu_node_manager_is_single(neu_node_manager_t *mgr, const char *name);
 bool neu_node_manager_is_driver(neu_node_manager_t *mgr, const char *name);
 
-// nng_pipe array
-UT_array *neu_node_manager_get_pipes(neu_node_manager_t *mgr, int type);
-UT_array *neu_node_manager_get_pipes_all(neu_node_manager_t *mgr);
-nng_pipe  neu_node_manager_get_pipe(neu_node_manager_t *mgr, const char *name);
+// addr array
+UT_array *neu_node_manager_get_addrs(neu_node_manager_t *mgr, int type);
+UT_array *neu_node_manager_get_addrs_all(neu_node_manager_t *mgr);
+struct sockaddr_in neu_node_manager_get_addr(neu_node_manager_t *mgr,
+                                             const char *        name);
+
+bool neu_node_manager_is_monitor(neu_node_manager_t *mgr, const char *name);
+int  neu_node_manager_for_each_monitor(
+     neu_node_manager_t *mgr,
+     int (*)(const char *name, struct sockaddr_in addr, void *data), void *data);
 
 // neu_nodes_state_t array
 UT_array *neu_node_manager_get_state(neu_node_manager_t *mgr);

src/core/storage.c

@@ -234,17 +234,19 @@ void manager_storage_add_template_group(const char *tmpl, const char *group,
 }
 
 void manager_storage_update_template_group(const char *tmpl, const char *group,
-                                           uint32_t interval)
+                                           const char *new_name,
+                                           uint32_t    interval)
 {
     neu_persist_group_info_t info = {
-        .name     = (char *) group,
+        .name     = (char *) new_name,
         .interval = interval,
     };
 
-    int rv = neu_persister_update_template_group(tmpl, &info);
+    int rv = neu_persister_update_template_group(tmpl, group, &info);
     if (0 != rv) {
-        nlog_error("update template:%s grp:%s, interval:%" PRIu32 " fail", tmpl,
-                   group, interval);
+        nlog_error("update template:%s group:%s, new_name:%s interval:%" PRIu32
+                   " fail",
+                   tmpl, group, new_name, interval);
     }
 }
 
@@ -403,17 +405,18 @@ int manager_load_subscribe(neu_manager_t *manager)
         } else {
             utarray_foreach(sub_infos, neu_persist_subscription_info_t *, info)
             {
-                rv = neu_manager_subscribe(manager, node->node,
+                uint16_t app_port = 0;
+                rv                = neu_manager_subscribe(manager, node->node,
                                            info->driver_name, info->group_name,
-                                           info->params);
+                                           info->params, &app_port);
                 const char *ok_or_err = (0 == rv) ? "success" : "fail";
                 nlog_notice("%s load subscription app:%s driver:%s grp:%s",
                             ok_or_err, node->node, info->driver_name,
                             info->group_name);
                 if (0 == rv) {
-                    neu_manager_send_subscribe(manager, node->node,
-                                               info->driver_name,
-                                               info->group_name, info->params);
+                    neu_manager_send_subscribe(
+                        manager, node->node, info->driver_name,
+                        info->group_name, app_port, info->params);
                 }
             }
 

src/core/storage.h

@@ -55,7 +55,8 @@ void manager_storage_clear_templates(neu_manager_t *manager);
 void manager_storage_add_template_group(const char *tmpl, const char *group,
                                         uint32_t interval);
 void manager_storage_update_template_group(const char *tmpl, const char *group,
-                                           uint32_t interval);
+                                           const char *new_name,
+                                           uint32_t    interval);
 void manager_storage_del_template_group(const char *tmpl, const char *group);
 void manager_storage_add_template_tag(const char *tmpl, const char *group,
                                       const neu_datatag_t *tag);

src/core/subscribe.c

@@ -175,7 +175,7 @@ void neu_subscribe_manager_unsub_all(neu_subscribe_mgr_t *mgr, const char *app)
 
 int neu_subscribe_manager_sub(neu_subscribe_mgr_t *mgr, const char *driver,
                               const char *app, const char *group,
-                              const char *params, nng_pipe pipe)
+                              const char *params, struct sockaddr_in addr)
 {
     sub_elem_t *        find    = NULL;
     sub_elem_key_t      key     = { 0 };
@@ -184,7 +184,7 @@ int neu_subscribe_manager_sub(neu_subscribe_mgr_t *mgr, const char *driver,
     strncpy(key.driver, driver, sizeof(key.driver));
     strncpy(key.group, group, sizeof(key.group));
     strncpy(app_sub.app_name, app, sizeof(app_sub.app_name));
-    app_sub.pipe = pipe;
+    app_sub.addr = addr;
 
     if (params && NULL == (app_sub.params = strdup(params))) {
         return NEU_ERR_EINTERNAL;
@@ -304,7 +304,7 @@ int neu_subscribe_manager_update_app_name(neu_subscribe_mgr_t *mgr,
         utarray_foreach(el->apps, neu_app_subscribe_t *, sub_app)
         {
             if (strcmp(app, sub_app->app_name) == 0) {
-                strcpy(sub_app->app_name, new_name);
+                strncpy(sub_app->app_name, new_name, sizeof(sub_app->app_name));
             }
         }
     }
@@ -322,7 +322,7 @@ int neu_subscribe_manager_update_driver_name(neu_subscribe_mgr_t *mgr,
     {
         if (strcmp(driver, el->key.driver) == 0) {
             HASH_DEL(mgr->ss, el);
-            strcpy(el->key.driver, new_name);
+            strncpy(el->key.driver, new_name, sizeof(el->key.driver));
             HASH_ADD(hh, mgr->ss, key, sizeof(sub_elem_key_t), el);
         }
     }
@@ -348,7 +348,7 @@ int neu_subscribe_manager_update_group_name(neu_subscribe_mgr_t *mgr,
     }
 
     HASH_DEL(mgr->ss, find);
-    strcpy(find->key.group, new_name);
+    strncpy(find->key.group, new_name, sizeof(find->key.group));
     HASH_ADD(hh, mgr->ss, key, sizeof(sub_elem_key_t), find);
 
     return 0;

src/core/subscribe.h

@@ -20,7 +20,7 @@
 #ifndef _NEU_SUBSCRIBE_H_
 #define _NEU_SUBSCRIBE_H_
 
-#include <nng/nng.h>
+#include <netinet/in.h>
 
 #include "define.h"
 #include "utils/utextend.h"
@@ -28,9 +28,10 @@
 typedef struct neu_subscribe_mgr neu_subscribe_mgr_t;
 
 typedef struct neu_app_subscribe {
-    char     app_name[NEU_NODE_NAME_LEN];
-    char *   params;
-    nng_pipe pipe;
+    char  app_name[NEU_NODE_NAME_LEN];
+    char *params;
+
+    struct sockaddr_in addr;
 } neu_app_subscribe_t;
 
 static inline void neu_app_subscribe_fini(neu_app_subscribe_t *app_sub)
@@ -52,7 +53,7 @@ UT_array *neu_subscribe_manager_get_ndriver_maps(neu_subscribe_mgr_t *mgr,
 void neu_subscribe_manager_unsub_all(neu_subscribe_mgr_t *mgr, const char *app);
 int  neu_subscribe_manager_sub(neu_subscribe_mgr_t *mgr, const char *driver,
                                const char *app, const char *group,
-                               const char *params, nng_pipe pipe);
+                               const char *params, struct sockaddr_in addr);
 int  neu_subscribe_manager_unsub(neu_subscribe_mgr_t *mgr, const char *driver,
                                  const char *app, const char *group);
 void neu_subscribe_manager_remove(neu_subscribe_mgr_t *mgr, const char *driver,

src/daemon.c

@@ -35,7 +35,7 @@
 
 #include "daemon.h"
 
-#define STOP_TIMEOUT 20000
+#define STOP_TIMEOUT 10000
 #define STOP_TICK 2000
 
 void daemonize()
@@ -205,6 +205,10 @@ int neuron_stop()
     if (0 == kill((pid_t)(-gid), SIGINT)) {
         if (neuron_wait_exit(STOP_TIMEOUT) == 0) {
             ret = 0;
+        } else {
+            if (0 == kill((pid_t)(-gid), SIGKILL)) {
+                ret = 0;
+            }
         }
     } else {
         nlog_error("cannot kill gpid:%ld reason: %s\n", (long) gid,

src/event/event_linux.c

@@ -26,9 +26,6 @@
 #include <string.h>
 #include <unistd.h>
 
-#include <nng/nng.h>
-#include <nng/supplemental/util/platform.h>
-
 #include "event/event.h"
 #include "utils/log.h"
 
@@ -38,43 +35,72 @@
 
 struct neu_event_timer {
     int                    fd;
-    void *                 event_data;
+    struct event_data *    event_data;
     struct itimerspec      value;
     neu_event_timer_type_e type;
-
-    nng_mtx *mtx;
-    bool     stop;
+    pthread_mutex_t        mtx;
+    bool                   stop;
 };
 
 struct neu_event_io {
-    int   fd;
-    void *event_data;
+    int                fd;
+    struct event_data *event_data;
 };
-
 struct event_data {
     enum {
-        TIMER,
-        IO,
+        TIMER = 0,
+        IO    = 1,
     } type;
     union {
         neu_event_io_callback    io;
         neu_event_timer_callback timer;
     } callback;
     union {
-        struct neu_event_io *   io;
-        struct neu_event_timer *timer;
+        neu_event_io_t    io;
+        neu_event_timer_t timer;
     } ctx;
 
     void *usr_data;
     int   fd;
+    int   index;
+    bool  use;
 };
 
 struct neu_events {
     int       epoll_fd;
     pthread_t thread;
     bool      stop;
+
+    pthread_mutex_t   mtx;
+    int               n_event;
+    struct event_data event_datas[256];
 };
 
+static int get_free_event(neu_events_t *events)
+{
+    int ret = -1;
+    pthread_mutex_lock(&events->mtx);
+    for (int i = 0; i < 256; i++) {
+        if (events->event_datas[i].use == false) {
+            events->event_datas[i].use   = true;
+            events->event_datas[i].index = i;
+            ret                          = i;
+            break;
+        }
+    }
+
+    pthread_mutex_unlock(&events->mtx);
+    return ret;
+}
+
+static void free_event(neu_events_t *events, int index)
+{
+    pthread_mutex_lock(&events->mtx);
+    events->event_datas[index].use   = false;
+    events->event_datas[index].index = 0;
+    pthread_mutex_unlock(&events->mtx);
+}
+
 static void *event_loop(void *arg)
 {
     neu_events_t *events   = (neu_events_t *) arg;
@@ -103,28 +129,27 @@ static void *event_loop(void *arg)
 
         switch (data->type) {
         case TIMER:
+            pthread_mutex_lock(&data->ctx.timer.mtx);
             if ((event.events & EPOLLIN) == EPOLLIN) {
                 uint64_t t;
 
                 ssize_t size = read(data->fd, &t, sizeof(t));
                 (void) size;
 
-                if (!data->ctx.timer->stop) {
-                    if (data->ctx.timer->type == NEU_EVENT_TIMER_BLOCK) {
-                        nng_mtx_lock(data->ctx.timer->mtx);
+                if (!data->ctx.timer.stop) {
+                    if (data->ctx.timer.type == NEU_EVENT_TIMER_BLOCK) {
                         epoll_ctl(epoll_fd, EPOLL_CTL_DEL, data->fd, NULL);
                         ret = data->callback.timer(data->usr_data);
-                        timerfd_settime(data->fd, 0, &data->ctx.timer->value,
+                        timerfd_settime(data->fd, 0, &data->ctx.timer.value,
                                         NULL);
                         epoll_ctl(epoll_fd, EPOLL_CTL_ADD, data->fd, &event);
-                        nng_mtx_unlock(data->ctx.timer->mtx);
                     } else {
-                        nng_mtx_lock(data->ctx.timer->mtx);
                         ret = data->callback.timer(data->usr_data);
-                        nng_mtx_unlock(data->ctx.timer->mtx);
                     }
                 }
             }
+
+            pthread_mutex_unlock(&data->ctx.timer.mtx);
             break;
         case IO:
             if ((event.events & EPOLLHUP) == EPOLLHUP) {
@@ -156,6 +181,8 @@ neu_events_t *neu_event_new(void)
 
     events->epoll_fd = epoll_create(1);
     events->stop     = false;
+    events->n_event  = 0;
+    pthread_mutex_init(&events->mtx, NULL);
 
     pthread_create(&events->thread, NULL, event_loop, events);
 
@@ -168,6 +195,7 @@ int neu_event_close(neu_events_t *events)
     close(events->epoll_fd);
 
     pthread_join(events->thread, NULL);
+    pthread_mutex_destroy(&events->mtx);
 
     free(events);
     return 0;
@@ -184,24 +212,30 @@ neu_event_timer_t *neu_event_add_timer(neu_events_t *          events,
         .it_interval.tv_sec  = timer.second,
         .it_interval.tv_nsec = timer.millisecond * 1000 * 1000,
     };
-    struct event_data *data      = calloc(1, sizeof(struct event_data));
-    struct epoll_event event     = { .events = EPOLLIN, .data.ptr = data };
-    neu_event_timer_t *timer_ctx = calloc(1, sizeof(neu_event_timer_t));
+    int index = get_free_event(events);
+    assert(index >= 0);
+
+    neu_event_timer_t *timer_ctx = &events->event_datas[index].ctx.timer;
+    timer_ctx->event_data        = &events->event_datas[index];
+
+    struct epoll_event event = {
+        .events   = EPOLLIN,
+        .data.ptr = timer_ctx->event_data,
+    };
 
     timerfd_settime(timer_fd, 0, &value, NULL);
 
-    data->type           = TIMER;
-    data->fd             = timer_fd;
-    data->usr_data       = timer.usr_data;
-    data->callback.timer = timer.cb;
-    data->ctx.timer      = timer_ctx;
+    timer_ctx->event_data->type           = TIMER;
+    timer_ctx->event_data->fd             = timer_fd;
+    timer_ctx->event_data->usr_data       = timer.usr_data;
+    timer_ctx->event_data->callback.timer = timer.cb;
+    timer_ctx->event_data->ctx.timer = events->event_datas[index].ctx.timer;
 
-    timer_ctx->value      = value;
-    timer_ctx->fd         = timer_fd;
-    timer_ctx->event_data = data;
-    timer_ctx->stop       = false;
-    timer_ctx->type       = timer.type;
-    nng_mtx_alloc(&timer_ctx->mtx);
+    timer_ctx->value = value;
+    timer_ctx->fd    = timer_fd;
+    timer_ctx->type  = timer.type;
+    timer_ctx->stop  = false;
+    pthread_mutex_init(&timer_ctx->mtx, NULL);
 
     ret = epoll_ctl(events->epoll_fd, EPOLL_CTL_ADD, timer_fd, &event);
 
@@ -221,34 +255,35 @@ int neu_event_del_timer(neu_events_t *events, neu_event_timer_t *timer)
                 events->epoll_fd);
 
     timer->stop = true;
-    nng_mtx_lock(timer->mtx);
-    close(timer->fd);
     epoll_ctl(events->epoll_fd, EPOLL_CTL_DEL, timer->fd, NULL);
-    free(timer->event_data);
-    nng_mtx_unlock(timer->mtx);
 
-    nng_mtx_free(timer->mtx);
-    free(timer);
+    pthread_mutex_lock(&timer->mtx);
+    close(timer->fd);
+    pthread_mutex_unlock(&timer->mtx);
+
+    pthread_mutex_destroy(&timer->mtx);
+    free_event(events, timer->event_data->index);
     return 0;
 }
 
 neu_event_io_t *neu_event_add_io(neu_events_t *events, neu_event_io_param_t io)
 {
-    int                ret    = 0;
-    neu_event_io_t *   io_ctx = calloc(1, sizeof(neu_event_io_t));
-    struct event_data *data   = calloc(1, sizeof(struct event_data));
-    struct epoll_event event  = { .events =
-                                     EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP,
-                                 .data.ptr = data };
+    int             ret      = 0;
+    int             index    = get_free_event(events);
+    neu_event_io_t *io_ctx   = &events->event_datas[index].ctx.io;
+    io_ctx->event_data       = &events->event_datas[index];
+    struct epoll_event event = {
+        .events   = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP,
+        .data.ptr = io_ctx->event_data,
+    };
 
-    data->type        = IO;
-    data->fd          = io.fd;
-    data->usr_data    = io.usr_data;
-    data->callback.io = io.cb;
-    data->ctx.io      = io_ctx;
+    io_ctx->event_data->type        = IO;
+    io_ctx->event_data->fd          = io.fd;
+    io_ctx->event_data->usr_data    = io.usr_data;
+    io_ctx->event_data->callback.io = io.cb;
+    io_ctx->event_data->ctx.io      = events->event_datas[index].ctx.io;
 
-    io_ctx->fd         = io.fd;
-    io_ctx->event_data = data;
+    io_ctx->fd = io.fd;
 
     ret = epoll_ctl(events->epoll_fd, EPOLL_CTL_ADD, io.fd, &event);
 
@@ -260,19 +295,14 @@ neu_event_io_t *neu_event_add_io(neu_events_t *events, neu_event_io_param_t io)
 
 int neu_event_del_io(neu_events_t *events, neu_event_io_t *io)
 {
-    struct event_data *data = (struct event_data *) io->event_data;
+    if (io == NULL) {
+        return 0;
+    }
+
     zlog_notice(neuron, "del io: %d from epoll: %d", io->fd, events->epoll_fd);
 
     epoll_ctl(events->epoll_fd, EPOLL_CTL_DEL, io->fd, NULL);
-    switch (data->type) {
-    case TIMER:
-        free(data->ctx.timer);
-        break;
-    case IO:
-        free(data->ctx.io);
-        break;
-    }
-    free(data);
+    free_event(events, io->event_data->index);
 
     return 0;
 }

src/main.c

@@ -17,8 +17,13 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  **/
 
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <netinet/in.h>
 #include <signal.h>
 #include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
@@ -35,10 +40,15 @@ static neu_manager_t *g_manager         = NULL;
 zlog_category_t *     neuron            = NULL;
 bool                  disable_jwt       = false;
 int                   default_log_level = ZLOG_LEVEL_NOTICE;
-char                  host_port[24]     = { 0 };
+char                  host_port[32]     = { 0 };
 
 int64_t global_timestamp = 0;
 
+struct {
+    struct sockaddr_in addr;
+    int                fd;
+} g_remote_syslog_ctx;
+
 static void sig_handler(int sig)
 {
     nlog_warn("recv sig: %d", sig);
@@ -52,6 +62,40 @@ static void sig_handler(int sig)
     exit(-1);
 }
 
+static int remote_syslog(zlog_msg_t *msg)
+{
+    sendto(g_remote_syslog_ctx.fd, msg->buf, msg->len, 0,
+           (const struct sockaddr *) &g_remote_syslog_ctx.addr,
+           sizeof(g_remote_syslog_ctx.addr));
+    return 0;
+}
+
+static int config_remote_syslog(const char *host, uint16_t port)
+{
+    g_remote_syslog_ctx.fd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (g_remote_syslog_ctx.fd < 0) {
+        return -1;
+    }
+
+    g_remote_syslog_ctx.addr.sin_family      = AF_INET;
+    g_remote_syslog_ctx.addr.sin_port        = htons(port);
+    g_remote_syslog_ctx.addr.sin_addr.s_addr = inet_addr(host);
+
+    if (0 == inet_pton(AF_INET, host, &g_remote_syslog_ctx.addr.sin_addr)) {
+        // not an valid ip address, try resolve as host name
+        struct hostent *he = gethostbyname(host);
+        if (NULL == he) {
+            return -1;
+        }
+
+        memcpy(&g_remote_syslog_ctx.addr.sin_addr, he->h_addr_list[0],
+               he->h_length);
+    }
+
+    zlog_set_record("remote_syslog", remote_syslog);
+    return 0;
+}
+
 static int neuron_run(const neu_cli_args_t *args)
 {
     struct rlimit rl = { 0 };
@@ -107,8 +151,14 @@ int main(int argc, char *argv[])
     }
 
     zlog_init(args.log_init_file);
-    neuron = zlog_get_category("neuron");
 
+    if (args.syslog_host && strlen(args.syslog_host) > 0 &&
+        0 != config_remote_syslog(args.syslog_host, args.syslog_port)) {
+        nlog_fatal("neuron setup remote syslog fail, exit.");
+        goto main_end;
+    }
+
+    neuron = zlog_get_category("neuron");
     zlog_level_switch(neuron, default_log_level);
 
     if (neuron_already_running()) {

src/parser/neu_json_group_config.h

@@ -135,9 +135,10 @@ int  neu_json_decode_unsubscribe_req(char *                       buf,
 void neu_json_decode_unsubscribe_req_free(neu_json_unsubscribe_req_t *req);
 
 typedef struct {
-    char *driver;
-    char *group;
-    char *params;
+    char *   driver;
+    char *   group;
+    uint16_t port;
+    char *   params;
 } neu_json_subscribe_groups_info_t;
 
 typedef struct {

src/parser/neu_json_log.c

@@ -43,9 +43,13 @@ int neu_json_decode_update_log_level_req(
     }
 
     neu_json_elem_t req_elems[] = { {
-        .name = "node",
-        .t    = NEU_JSON_STR,
-    } };
+                                        .name = "node",
+                                        .t    = NEU_JSON_STR,
+                                    },
+                                    {
+                                        .name = "level",
+                                        .t    = NEU_JSON_STR,
+                                    } };
 
     ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
                                   req_elems);
@@ -54,6 +58,7 @@ int neu_json_decode_update_log_level_req(
     }
 
     req->node_name = req_elems[0].v.val_str;
+    req->log_level = req_elems[1].v.val_str;
 
     *result = req;
     goto decode_exit;
@@ -71,9 +76,15 @@ decode_exit:
 void neu_json_decode_update_log_level_req_free(
     neu_json_update_log_level_req_t *req)
 {
-    free(req->node_name);
-
-    free(req);
+    if (req->node_name != NULL) {
+        free(req->node_name);
+    }
+    if (req->log_level != NULL) {
+        free(req->log_level);
+    }
+    if (req != NULL) {
+        free(req);
+    }
 }
 
 int neu_json_encode_get_log_resp(void *json_object, void *param)

src/parser/neu_json_log.h

@@ -35,6 +35,7 @@ typedef char *neu_json_get_log_resp_row_t;
 
 typedef struct {
     char *node_name;
+    char *log_level;
 } neu_json_update_log_level_req_t;
 
 typedef struct {

src/parser/neu_json_node.c

@@ -184,6 +184,11 @@ int neu_json_encode_get_node_state_resp(void *json_object, void *param)
                                          .name      = "rtt",
                                          .t         = NEU_JSON_INT,
                                          .v.val_int = resp->rtt,
+                                     },
+                                     {
+                                         .name      = "log_level",
+                                         .t         = NEU_JSON_STR,
+                                         .v.val_str = resp->log_level,
                                      } };
     ret = neu_json_encode_field(json_object, resp_elems,
                                 NEU_JSON_ELEM_SIZE(resp_elems));
@@ -200,28 +205,31 @@ int neu_json_encode_get_nodes_state_resp(void *json_object, void *param)
     void *                      node_array = neu_json_array();
     neu_json_get_nodes_state_t *p_node     = resp->nodes;
     for (int i = 0; i < resp->n_node; i++) {
-        neu_json_elem_t node_elems[] = {
-            {
-                .name      = "node",
-                .t         = NEU_JSON_STR,
-                .v.val_str = p_node->name,
-            },
-            {
-                .name      = "running",
-                .t         = NEU_JSON_INT,
-                .v.val_int = p_node->running,
-            },
-            {
-                .name      = "link",
-                .t         = NEU_JSON_INT,
-                .v.val_int = p_node->link,
-            },
-            {
-                .name      = "rtt",
-                .t         = NEU_JSON_INT,
-                .v.val_int = p_node->rtt,
-            },
-        };
+        neu_json_elem_t node_elems[] = { {
+                                             .name      = "node",
+                                             .t         = NEU_JSON_STR,
+                                             .v.val_str = p_node->name,
+                                         },
+                                         {
+                                             .name      = "running",
+                                             .t         = NEU_JSON_INT,
+                                             .v.val_int = p_node->running,
+                                         },
+                                         {
+                                             .name      = "link",
+                                             .t         = NEU_JSON_INT,
+                                             .v.val_int = p_node->link,
+                                         },
+                                         {
+                                             .name      = "rtt",
+                                             .t         = NEU_JSON_INT,
+                                             .v.val_int = p_node->rtt,
+                                         },
+                                         {
+                                             .name      = "log_level",
+                                             .t         = NEU_JSON_STR,
+                                             .v.val_str = p_node->log_level,
+                                         } };
         node_array = neu_json_encode_array(node_array, node_elems,
                                            NEU_JSON_ELEM_SIZE(node_elems));
         p_node++;

src/parser/neu_json_node.h

@@ -25,6 +25,7 @@
 #ifndef _NEU_JSON_API_NEU_JSON_NODE_H_
 #define _NEU_JSON_API_NEU_JSON_NODE_H_
 
+#include "define.h"
 #include "json/json.h"
 
 #ifdef __cplusplus
@@ -52,6 +53,7 @@ typedef struct {
     int64_t running;
     int64_t link;
     int64_t rtt;
+    char *  log_level;
 } neu_json_get_node_state_resp_t;
 
 int neu_json_encode_get_node_state_resp(void *json_object, void *param);
@@ -61,6 +63,7 @@ typedef struct {
     int64_t running;
     int64_t link;
     int64_t rtt;
+    char *  log_level;
 } neu_json_get_nodes_state_t;
 
 typedef struct {

src/parser/neu_json_template.c

@@ -378,10 +378,10 @@ int neu_json_encode_get_templates_resp(void *json_obj, void *param)
                                  NEU_JSON_ELEM_SIZE(req_elems));
 }
 
-int neu_json_encode_template_mod_group_req(void *json_obj, void *param)
+int neu_json_encode_template_add_group_req(void *json_obj, void *param)
 {
     int                                ret = 0;
-    neu_json_template_mod_group_req_t *req = param;
+    neu_json_template_add_group_req_t *req = param;
 
     neu_json_elem_t req_elems[] = { {
                                         .name      = "template",
@@ -404,12 +404,12 @@ int neu_json_encode_template_mod_group_req(void *json_obj, void *param)
     return ret;
 }
 
-int neu_json_decode_template_mod_group_req(
-    char *buf, neu_json_template_mod_group_req_t **result)
+int neu_json_decode_template_add_group_req(
+    char *buf, neu_json_template_add_group_req_t **result)
 {
     int                                ret      = 0;
     void *                             json_obj = NULL;
-    neu_json_template_mod_group_req_t *req      = NULL;
+    neu_json_template_add_group_req_t *req      = NULL;
 
     json_obj = neu_json_decode_new(buf);
     if (NULL == json_obj) {
@@ -449,13 +449,13 @@ int neu_json_decode_template_mod_group_req(
     return 0;
 
 decode_fail:
-    neu_json_decode_template_mod_group_req_free(req);
+    neu_json_decode_template_add_group_req_free(req);
     neu_json_decode_free(json_obj);
     return -1;
 }
 
-void neu_json_decode_template_mod_group_req_free(
-    neu_json_template_mod_group_req_t *req)
+void neu_json_decode_template_add_group_req_free(
+    neu_json_template_add_group_req_t *req)
 {
     if (req) {
         free(req->tmpl);
@@ -464,6 +464,79 @@ void neu_json_decode_template_mod_group_req_free(
     }
 }
 
+int neu_json_decode_template_update_group_req(
+    char *buf, neu_json_template_update_group_req_t **result)
+{
+    int ret = 0;
+
+    neu_json_template_update_group_req_t *req = calloc(1, sizeof(*req));
+    if (req == NULL) {
+        return -1;
+    }
+
+    void *json_obj = neu_json_decode_new(buf);
+    if (NULL == json_obj) {
+        free(req);
+        return -1;
+    }
+
+    neu_json_elem_t req_elems[] = {
+        {
+            .name = "template",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name = "group",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name      = "new_name",
+            .t         = NEU_JSON_STR,
+            .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+        },
+    };
+    ret       = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
+                                  req_elems);
+    req->tmpl = req_elems[0].v.val_str;
+    req->group    = req_elems[1].v.val_str;
+    req->new_name = req_elems[2].v.val_str;
+    if (0 != ret) {
+        goto error;
+    }
+
+    json_t *json_interval = json_object_get(json_obj, "interval");
+    if (NULL != json_interval) {
+        if (!json_is_integer(json_interval)) {
+            nlog_error("decode interval is not integer");
+            goto error;
+        }
+        req->set_interval = true;
+        req->interval     = json_integer_value(json_interval);
+    } else if (NULL == req->new_name) {
+        // at least one of `new_name` or `interval` should be provided
+        goto error;
+    }
+
+    *result = req;
+    neu_json_decode_free(json_obj);
+    return 0;
+
+error:
+    neu_json_decode_template_update_group_req_free(req);
+    neu_json_decode_free(json_obj);
+    return -1;
+}
+
+void neu_json_decode_template_update_group_req_free(
+    neu_json_template_update_group_req_t *req)
+{
+    free(req->tmpl);
+    free(req->group);
+    free(req->new_name);
+
+    free(req);
+}
+
 int neu_json_encode_template_del_group_req(void *json_object, void *param)
 {
     int                                ret = 0;

src/parser/neu_json_template.h

@@ -81,13 +81,26 @@ typedef struct {
     char *  tmpl;
     char *  group;
     int64_t interval;
-} neu_json_template_mod_group_req_t;
+} neu_json_template_add_group_req_t;
 
-int neu_json_encode_template_mod_group_req(void *json_obj, void *param);
-int neu_json_decode_template_mod_group_req(
-    char *buf, neu_json_template_mod_group_req_t **result);
-void neu_json_decode_template_mod_group_req_free(
-    neu_json_template_mod_group_req_t *req);
+int neu_json_encode_template_add_group_req(void *json_obj, void *param);
+int neu_json_decode_template_add_group_req(
+    char *buf, neu_json_template_add_group_req_t **result);
+void neu_json_decode_template_add_group_req_free(
+    neu_json_template_add_group_req_t *req);
+
+typedef struct {
+    char *  tmpl;
+    char *  group;
+    char *  new_name;
+    bool    set_interval;
+    int64_t interval;
+} neu_json_template_update_group_req_t;
+
+int neu_json_decode_template_update_group_req(
+    char *buf, neu_json_template_update_group_req_t **result);
+void neu_json_decode_template_update_group_req_free(
+    neu_json_template_update_group_req_t *req);
 
 typedef struct {
     char *tmpl;

src/persist/persist.c

@@ -600,21 +600,12 @@ void neu_persister_destroy()
 int neu_persister_store_node(neu_persist_node_info_t *info)
 {
     int rv = 0;
-    if (strcmp(info->plugin_name, "Monitor") == 0) {
-        rv = execute_sql(
-            global_db,
-            "INSERT OR IGNORE INTO nodes (name, type, state, plugin_name) "
-            "VALUES (%Q, %i, %i, %Q)",
-            info->name, info->type, info->state, info->plugin_name);
-    } else {
-        rv =
-            execute_sql(global_db,
-                        "INSERT INTO nodes (name, type, state, plugin_name) "
-                        "VALUES (%Q, %i, %i, %Q)",
-                        info->name, info->type, info->state, info->plugin_name);
-        if (0 == rv) {
-            node_count_add(1);
-        }
+    rv     = execute_sql(global_db,
+                     "INSERT INTO nodes (name, type, state, plugin_name) "
+                     "VALUES (%Q, %i, %i, %Q)",
+                     info->name, info->type, info->state, info->plugin_name);
+    if (0 == rv) {
+        node_count_add(1);
     }
     return rv;
 }
@@ -1487,12 +1478,32 @@ int neu_persister_store_template_group(const char *              tmpl_name,
 }
 
 int neu_persister_update_template_group(const char *              tmpl_name,
+                                        const char *              group_name,
                                         neu_persist_group_info_t *group_info)
 {
-    return execute_sql(
-        global_db,
-        "UPDATE template_groups SET interval=%i WHERE tmpl_name=%Q AND name=%Q",
-        group_info->interval, tmpl_name, group_info->name);
+    int  ret             = -1;
+    bool update_name     = (0 != strcmp(group_name, group_info->name));
+    bool update_interval = (NEU_GROUP_INTERVAL_LIMIT <= group_info->interval);
+
+    if (update_name && update_interval) {
+        ret = execute_sql(global_db,
+                          "UPDATE template_groups SET name=%Q, interval=%i "
+                          "WHERE tmpl_name=%Q AND name=%Q",
+                          group_info->name, group_info->interval, tmpl_name,
+                          group_name);
+    } else if (update_name) {
+        ret = execute_sql(global_db,
+                          "UPDATE template_groups SET name=%Q "
+                          "WHERE tmpl_name=%Q AND name=%Q",
+                          group_info->name, tmpl_name, group_name);
+    } else if (update_interval) {
+        ret = execute_sql(global_db,
+                          "UPDATE template_groups SET interval=%i "
+                          "WHERE tmpl_name=%Q AND name=%Q",
+                          group_info->interval, tmpl_name, group_name);
+    }
+
+    return ret;
 }
 
 int neu_persister_load_template_groups(const char *tmpl_name,

src/utils/async_queue.c

@@ -17,11 +17,9 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 config_ **/
 
+#include <pthread.h>
 #include <stdlib.h>
 
-#include <nng/nng.h>
-#include <nng/supplemental/util/platform.h>
-
 #include "utils/async_queue.h"
 #include "utils/utextend.h"
 
@@ -39,7 +37,7 @@ struct neu_async_queue {
     neu_async_queue_expire expire_fn;
     neu_async_queue_free   free_fn;
 
-    nng_mtx *mtx;
+    pthread_mutex_t mtx;
 
     uint16_t max;
 
@@ -59,7 +57,7 @@ neu_async_queue_t *neu_async_queue_new(neu_async_queue_key    key_fn,
 
     q->max = max_size;
 
-    nng_mtx_alloc(&q->mtx);
+    pthread_mutex_init(&q->mtx, NULL);
 
     return q;
 }
@@ -68,16 +66,16 @@ void neu_async_queue_destroy(neu_async_queue_t *q)
 {
     element *elt = NULL, *tmp = NULL;
 
-    nng_mtx_lock(q->mtx);
+    pthread_mutex_lock(&q->mtx);
     DL_FOREACH_SAFE(q->list, elt, tmp)
     {
         q->free_fn(elt->data);
         DL_DELETE(q->list, elt);
         free(elt);
     }
-    nng_mtx_unlock(q->mtx);
+    pthread_mutex_unlock(&q->mtx);
 
-    nng_mtx_free(q->mtx);
+    pthread_mutex_destroy(&q->mtx);
     free(q);
 }
 
@@ -86,7 +84,7 @@ void neu_async_queue_push(neu_async_queue_t *q, void *elem)
     element *elt   = NULL;
     int      count = 0;
 
-    nng_mtx_lock(q->mtx);
+    pthread_mutex_lock(&q->mtx);
     DL_COUNT(q->list, elt, count);
 
     if (count == q->max && count > 0) {
@@ -102,7 +100,7 @@ void neu_async_queue_push(neu_async_queue_t *q, void *elem)
 
     DL_APPEND(q->list, elt);
 
-    nng_mtx_unlock(q->mtx);
+    pthread_mutex_unlock(&q->mtx);
 }
 
 int neu_async_queue_pop(neu_async_queue_t *q, uint64_t key, void **elem)
@@ -110,7 +108,7 @@ int neu_async_queue_pop(neu_async_queue_t *q, uint64_t key, void **elem)
     element *elt = NULL, *tmp = NULL;
     int      ret = -1;
 
-    nng_mtx_lock(q->mtx);
+    pthread_mutex_lock(&q->mtx);
     DL_FOREACH_SAFE(q->list, elt, tmp)
     {
         if (elt->key == key) {
@@ -127,7 +125,7 @@ int neu_async_queue_pop(neu_async_queue_t *q, uint64_t key, void **elem)
             }
         }
     }
-    nng_mtx_unlock(q->mtx);
+    pthread_mutex_unlock(&q->mtx);
 
     return ret;
 }
@@ -137,7 +135,7 @@ void neu_async_queue_remove(neu_async_queue_t *q, neu_async_queue_filter filter,
 {
     element *el = NULL, *tmp = NULL;
 
-    nng_mtx_lock(q->mtx);
+    pthread_mutex_lock(&q->mtx);
     DL_FOREACH_SAFE(q->list, el, tmp)
     {
         if (filter(filter_elem, el->data)) {
@@ -146,19 +144,19 @@ void neu_async_queue_remove(neu_async_queue_t *q, neu_async_queue_filter filter,
             free(el);
         }
     }
-    nng_mtx_unlock(q->mtx);
+    pthread_mutex_unlock(&q->mtx);
 }
 
 void neu_async_queue_clean(neu_async_queue_t *q)
 {
     element *el = NULL, *tmp = NULL;
 
-    nng_mtx_lock(q->mtx);
+    pthread_mutex_lock(&q->mtx);
     DL_FOREACH_SAFE(q->list, el, tmp)
     {
         DL_DELETE(q->list, el);
         q->free_fn(el->data);
         free(el);
     }
-    nng_mtx_unlock(q->mtx);
+    pthread_mutex_unlock(&q->mtx);
 }

src/utils/http.c

@@ -51,7 +51,7 @@ static int response(nng_aio *aio, char *content, enum nng_http_status status)
     nng_http_res_set_status(res, status);
 
     nng_http_req *nng_req = nng_aio_get_input(aio, 0);
-    nlog_notice("%s %s [%d]", nng_http_req_get_method(nng_req),
+    nlog_notice("<%p> %s %s [%d]", aio, nng_http_req_get_method(nng_req),
                 nng_http_req_get_uri(nng_req), status);
 
     nng_aio_set_output(aio, 0, res);

src/utils/log.c

@@ -27,11 +27,10 @@
 
 static UT_array *collect_logs(const char *dir, const char *node)
 {
-    DIR *          dirp                         = NULL;
-    struct dirent *dent                         = NULL;
-    UT_array *     files                        = NULL;
-    char           flag[NEU_NODE_NAME_LEN + 2]  = { 0 };
-    char           flag_[NEU_NODE_NAME_LEN + 2] = { 0 };
+    DIR *          dirp                        = NULL;
+    struct dirent *dent                        = NULL;
+    UT_array *     files                       = NULL;
+    char           flag[NEU_NODE_NAME_LEN + 2] = { 0 };
 
     if ((dirp = opendir(dir)) == NULL) {
         nlog_error("fail open dir: %s", dir);
@@ -40,11 +39,9 @@ static UT_array *collect_logs(const char *dir, const char *node)
 
     utarray_new(files, &ut_str_icd);
     snprintf(flag, sizeof(flag), "%s.", node);
-    snprintf(flag_, sizeof(flag_), "%s_", node);
 
     while (NULL != (dent = readdir(dirp))) {
-        if (strstr(dent->d_name, flag) != NULL ||
-            strstr(dent->d_name, flag_) != NULL) {
+        if (strstr(dent->d_name, flag) != NULL) {
             char *file = dent->d_name;
             utarray_push_back(files, &file);
         }

version

@@ -1 +1 @@
-2.6.0-dev
+2.6.1

zlog.conf

@@ -4,8 +4,10 @@ file perms = 666
 
 [formats]
 
-simple = "%d [%V] %f:%L %m%n"
+simple = "%d:%ms [%V] %f:%L %m%n"
+syslog = "%d:%ms %H neuron[%p]: [%V] [%c] %f:%L %m%n"
 
 [rules]
 
 *.*     "./logs/%c.log", 50MB * 1 ~ "./logs/%c.#2s.log"; simple
+*.*     $remote_syslog; syslog