Merge branch '20221019' into 'master'

refactor: 脚本引擎模板调整

See merge request huang/thingsboard3.3.2!139

@@ -83,6 +83,10 @@
         </dependency>
         <dependency>
             <groupId>org.thingsboard.common.transport</groupId>
+            <artifactId>tcp</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common.transport</groupId>
             <artifactId>http</artifactId>
         </dependency>
         <dependency>

@@ -28,30 +28,13 @@ import org.springframework.security.core.Authentication;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.thingsboard.server.cluster.TbClusterService;
-import org.thingsboard.server.common.data.Customer;
-import org.thingsboard.server.common.data.Dashboard;
-import org.thingsboard.server.common.data.DashboardInfo;
-import org.thingsboard.server.common.data.Device;
-import org.thingsboard.server.common.data.DeviceInfo;
-import org.thingsboard.server.common.data.DeviceProfile;
-import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.EntityView;
-import org.thingsboard.server.common.data.EntityViewInfo;
-import org.thingsboard.server.common.data.HasName;
-import org.thingsboard.server.common.data.HasTenantId;
-import org.thingsboard.server.common.data.OtaPackage;
-import org.thingsboard.server.common.data.OtaPackageInfo;
-import org.thingsboard.server.common.data.TbResource;
-import org.thingsboard.server.common.data.TbResourceInfo;
-import org.thingsboard.server.common.data.Tenant;
-import org.thingsboard.server.common.data.TenantInfo;
-import org.thingsboard.server.common.data.TenantProfile;
-import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.alarm.Alarm;
 import org.thingsboard.server.common.data.alarm.AlarmInfo;
 import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.asset.AssetInfo;
 import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.device.profile.*;
 import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.edge.EdgeEventActionType;
 import org.thingsboard.server.common.data.edge.EdgeEventType;
@@ -919,4 +902,29 @@ public abstract class BaseController {
             return MediaType.APPLICATION_OCTET_STREAM;
         }
     }
+
+    /**
+     * 构建设备配置的配置数据
+     * @param transportType            产品的通信协议
+     * @param deviceProfileData        空的设备配置数据
+     * @param transportConfiguration   传输配置
+     * @param scriptText               自定义数据协议的解析脚本
+     */
+    protected void buildDeviceProfileData(String transportType,DeviceProfileData deviceProfileData,DeviceProfileTransportConfiguration transportConfiguration,String scriptText) {
+        deviceProfileData.setConfiguration(new DefaultDeviceProfileConfiguration());
+        deviceProfileData.setProvisionConfiguration(new DisabledDeviceProfileProvisionConfiguration(null));
+
+        // 传输类型默认都是Default
+        if(transportType ==null || DeviceTransportType.DEFAULT.name().equals(transportType)){
+            deviceProfileData.setTransportConfiguration(new DefaultDeviceProfileTransportConfiguration());
+        }else if(DeviceTransportType.TCP.name().equals(transportType)){
+            YtTcpDeviceProfileTransportConfiguration tcpDeviceProfileTransportConfiguration = (YtTcpDeviceProfileTransportConfiguration) transportConfiguration;
+            String scriptId = tcpDeviceProfileTransportConfiguration.getScriptId();
+            tcpDeviceProfileTransportConfiguration.setPingText(scriptText);
+            deviceProfileData.setTransportConfiguration(tcpDeviceProfileTransportConfiguration);
+        }else{
+            deviceProfileData.setTransportConfiguration(transportConfiguration);
+        }
+
+    }
 }

@@ -59,6 +59,7 @@ public class YtAdminController extends BaseController {
   private final UserService tbUserService;
 
   @PostMapping("/tenant")
+  @Deprecated
   @PreAuthorize("@check.checkPermissions({'SYS_ADMIN','PLATFORM_ADMIN'},{'api:yt:admin:tenant:post'})")
   public ResponseEntity<TenantDTO> saveTenant(@RequestBody TenantReqDTO tenantReqDTO) {
     TenantDTO newTenant = ytTenantService.createNewTenant(tenantReqDTO);

@@ -13,10 +13,7 @@ import org.thingsboard.server.common.data.DeviceProfileProvisionType;
 import org.thingsboard.server.common.data.DeviceProfileType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.audit.ActionType;
-import org.thingsboard.server.common.data.device.profile.DefaultDeviceProfileConfiguration;
-import org.thingsboard.server.common.data.device.profile.DefaultDeviceProfileTransportConfiguration;
-import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
-import org.thingsboard.server.common.data.device.profile.DisabledDeviceProfileProvisionConfiguration;
+import org.thingsboard.server.common.data.device.profile.*;
 import org.thingsboard.server.common.data.edge.EdgeEventActionType;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
@@ -24,6 +21,7 @@ import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
+import org.thingsboard.server.common.data.rule.RuleChain;
 import org.thingsboard.server.common.data.yunteng.common.DeleteGroup;
 import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
 import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
@@ -34,6 +32,7 @@ import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
 import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
 import org.thingsboard.server.common.msg.queue.ServiceQueue;
 import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceScriptService;
 import org.thingsboard.server.dao.yunteng.service.YtDeviceProfileService;
 import org.thingsboard.server.service.security.permission.Operation;
 
@@ -51,7 +50,7 @@ import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.
 @Api(tags = {"设备配置管理"})
 public class YtDeviceProfileController extends BaseController {
     private final YtDeviceProfileService ytDeviceProfileService;
-
+    private final YtDeviceScriptService javaScriptService;
     @PostMapping()
     @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{'api:yt:deviceProfile:post','api:yt:deviceProfile:update'})")
     @ApiOperation("创建 | 编辑")
@@ -66,11 +65,14 @@ public class YtDeviceProfileController extends BaseController {
          * 2/3.处理TB业务逻辑
          * 3/3.处理业务平台的业务逻辑
          */
-
-        deviceProfileDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+        String tenantId = getCurrentUser().getCurrentTenantId();
+        deviceProfileDTO.setTenantId(tenantId);
         DeviceProfile tbDeviceProfile = buildTbDeviceProfileFromDeviceProfileDTO(deviceProfileDTO);
+
         updateTbDeviceProfile(tbDeviceProfile, created);
 
+        ytDeviceProfileService.insertOrUpdate(deviceProfileDTO);
+
         return ResponseEntity.ok(deviceProfileDTO);
     }
 
@@ -130,9 +132,7 @@ public class YtDeviceProfileController extends BaseController {
             @RequestParam(value = "transportType", required = false) String transportType,
             @RequestParam(value = ORDER_FILED, required = false) String orderBy,
             @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType) throws ThingsboardException {
-
-        PageLink pageLink = createPageLink(pageSize, page > 1 ? page - 1 : 0, name, orderBy==null ? "createdTime":orderBy, orderType == null ? OrderTypeEnum.DESC.name(): orderType.name());
-        return ytDeviceProfileService.page(pageLink, getCurrentUser().getCurrentTenantId(), transportType);
+        return ytDeviceProfileService.page(page,pageSize,orderBy,orderType, getCurrentUser().getCurrentTenantId(),name, transportType);
     }
 
     @GetMapping("/me/list")
@@ -146,11 +146,13 @@ public class YtDeviceProfileController extends BaseController {
     @ApiOperation("删除")
     @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{'api:yt:deviceProfile:delete'})")
     public void deleteDevices(@Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO) throws ThingsboardException {
-        ytDeviceProfileService.checkDeviceProfiles(getCurrentUser().getCurrentTenantId(), deleteDTO.getIds());
+        String tenantId = getCurrentUser().getCurrentTenantId();
+        ytDeviceProfileService.checkDeviceProfiles(tenantId, deleteDTO.getIds());
 
         for (String id : deleteDTO.getIds()) {
             deleteTbDeviceProfile(id);
         }
+        ytDeviceProfileService.deleteDeviceProfiles(tenantId,deleteDTO.getIds());
 
     }
 
@@ -217,33 +219,50 @@ public class YtDeviceProfileController extends BaseController {
         tbDeviceProfile.setTenantId(TenantId.fromUUID(tenantId));
         tbDeviceProfile.setDefault(deviceProfileDTO.isDefault());
 
+
+        String chainStr = deviceProfileDTO.getDefaultRuleChainId();
+        if(StringUtils.isBlank(chainStr)){
+            throw new YtDataValidationException(ErrorMessage.RULE_CHAIN_NOT_ENABLE.getMessage());
+        }
+        UUID chainId = UUID.fromString(chainStr);
+        RuleChain chain = ruleChainService.findRuleChainById(TenantId.SYS_TENANT_ID,new RuleChainId(chainId));
+        if(chain==null || !deviceProfileDTO.getTenantId().equals(chain.getTenantId().getId().toString())){
+            throw new YtDataValidationException(ErrorMessage.RULE_CHAIN_NOT_ENABLE.getMessage());
+        }
+
         // 获取当前租户的默认规则链
         if (StringUtils.isNotBlank(deviceProfileDTO.getDefaultRuleChainId())) {
-            UUID chainId = UUID.fromString(deviceProfileDTO.getDefaultRuleChainId());
             tbDeviceProfile.setDefaultRuleChainId(new RuleChainId(chainId));
         }
 
         tbDeviceProfile.setDefaultQueueName(ServiceQueue.MAIN);
         tbDeviceProfile.setProvisionType(DeviceProfileProvisionType.DISABLED);
 
-        DeviceProfileData deviceProfileData = new DeviceProfileData();
-        deviceProfileData.setConfiguration(new DefaultDeviceProfileConfiguration());
-        deviceProfileData.setProvisionConfiguration(new DisabledDeviceProfileProvisionConfiguration(null));
 
         // 传输类型默认都是Default
         String transportType = deviceProfileDTO.getTransportType();
+        String scriptText=null;
         if(transportType ==null || DeviceTransportType.DEFAULT.name().equals(transportType)){
             tbDeviceProfile.setTransportType(DeviceTransportType.DEFAULT);
-            deviceProfileData.setTransportConfiguration(new DefaultDeviceProfileTransportConfiguration());
         }else{
             tbDeviceProfile.setTransportType(DeviceTransportType.valueOf(transportType));
-            deviceProfileData.setTransportConfiguration(deviceProfileDTO.getProfileData().getTransportConfiguration());
         }
 
+        if(DeviceTransportType.TCP.name().equals(transportType)){
+            YtTcpDeviceProfileTransportConfiguration tcpDeviceProfileTransportConfiguration = (YtTcpDeviceProfileTransportConfiguration) deviceProfileDTO.getProfileData().getTransportConfiguration();
+            String scriptId = tcpDeviceProfileTransportConfiguration.getScriptId();
+            scriptText =javaScriptService.getScriptText(deviceProfileDTO.getTenantId(), scriptId);
+            deviceProfileDTO.setScriptId(scriptId);
+        }
+
+        DeviceProfileData deviceProfileData = new DeviceProfileData();
+        buildDeviceProfileData(transportType,deviceProfileData,deviceProfileDTO.getProfileData().getTransportConfiguration(),scriptText);
+
         if(deviceProfileDTO.getProfileData()!=null
                 && deviceProfileDTO.getProfileData().getAlarms() !=null){
             deviceProfileData.setAlarms(deviceProfileDTO.getProfileData().getAlarms());
         }
+
         tbDeviceProfile.setProfileData(deviceProfileData);
 
         return tbDeviceProfile;

+package org.thingsboard.server.controller.yunteng;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParser;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.rule.engine.api.ScriptEngine;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceProfileProvisionType;
+import org.thingsboard.server.common.data.DeviceProfileType;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.audit.ActionType;
+import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
+import org.thingsboard.server.common.data.edge.EdgeEventActionType;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.RuleChainId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.plugin.ComponentLifecycleEvent;
+import org.thingsboard.server.common.data.yunteng.common.DeleteGroup;
+import org.thingsboard.server.common.data.yunteng.constant.FastIotConstants;
+import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.DeleteDTO;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.common.data.yunteng.dto.YtDeviceScriptDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
+import org.thingsboard.server.common.msg.queue.ServiceQueue;
+import org.thingsboard.server.common.yunteng.script.YtScriptInvokeService;
+import org.thingsboard.server.common.yunteng.script.YtScriptType;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceProfileService;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceScriptService;
+
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.*;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("api/yt/js")
+@Api(tags = {"设备数据解析脚本管理"})
+public class YtDeviceScriptController extends BaseController {
+    private final YtDeviceScriptService scriptService;
+    private final YtDeviceProfileService ytDeviceProfileService;
+    private final YtScriptInvokeService jsEngine;
+    private static final JsonParser parser = new JsonParser();
+
+    private static final ObjectMapper objectMapper = new ObjectMapper();
+
+    @PostMapping()
+    @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{'api:yt:js:post','api:yt:js:update'})")
+    @ApiOperation("创建 | 编辑")
+    public ResponseEntity<YtDeviceScriptDTO> saveJavaScript(
+            @RequestBody YtDeviceScriptDTO scriptDTO) throws ThingsboardException {
+        String id = scriptDTO.getId();
+        boolean created = StringUtils.isBlank(id);
+        String tenantId = getCurrentUser().getCurrentTenantId();
+        scriptDTO.setTenantId(tenantId);
+        scriptService.validateFormdata(scriptDTO,created);
+        /**
+         * 业务流程
+         * 1/3.编辑时同步刷新相关的设备配置
+         * 2/3.处理TB业务逻辑
+         * 3/3.处理业务平台的业务逻辑
+         */
+        if(!created){
+            List<DeviceProfileDTO> usedProfiles =ytDeviceProfileService.findDeviceProfile(tenantId,id);
+            for(DeviceProfileDTO profile:usedProfiles){
+                DeviceProfile tbDeviceProfile = buildTbDeviceProfileFromDeviceProfileDTO(profile,scriptDTO.getTenantId(),scriptDTO.getConvertJs());
+                updateTbDeviceProfile(tbDeviceProfile);
+            }
+
+        }
+
+
+        String creator = getCurrentUser().getCurrentUserId();
+        scriptDTO.setCreator(creator);
+        scriptDTO.setUpdater(creator);
+        scriptService.insertOrUpdate(scriptDTO);
+
+        return ResponseEntity.ok(scriptDTO);
+    }
+
+    /**
+     * 更新thingsboard的设备配置信息
+     *
+     * @param deviceProfile 设备配置
+     * @throws ThingsboardException
+     */
+    private DeviceProfile updateTbDeviceProfile(DeviceProfile deviceProfile) throws ThingsboardException {
+        boolean isFirmwareChanged = false;
+        boolean isSoftwareChanged = false;
+
+        DeviceProfile oldDeviceProfile = deviceProfileService.findDeviceProfileById(getTenantId(), deviceProfile.getId());
+        if (!Objects.equals(deviceProfile.getFirmwareId(), oldDeviceProfile.getFirmwareId())) {
+            isFirmwareChanged = true;
+        }
+        if (!Objects.equals(deviceProfile.getSoftwareId(), oldDeviceProfile.getSoftwareId())) {
+            isSoftwareChanged = true;
+        }
+        if (FastIotConstants.ASSERT_DEFAULT_NAME.equals(oldDeviceProfile.getName()) && !Objects.equals(deviceProfile.getName(), oldDeviceProfile.getName())) {
+            throw new YtDataValidationException(ErrorMessage.ASSERT_DEFAULT_NAME_NO_CHANGED.getMessage());
+        }
+
+        DeviceProfile savedDeviceProfile = checkNotNull(deviceProfileService.saveDeviceProfile(deviceProfile));
+
+        tbClusterService.onDeviceProfileChange(savedDeviceProfile, null);
+        tbClusterService.broadcastEntityStateChangeEvent(deviceProfile.getTenantId(), savedDeviceProfile.getId(), ComponentLifecycleEvent.UPDATED);
+
+        logEntityAction(savedDeviceProfile.getId(), savedDeviceProfile,
+                null,ActionType.UPDATED, null);
+
+        otaPackageStateService.update(savedDeviceProfile, isFirmwareChanged, isSoftwareChanged);
+
+        sendEntityNotificationMsg(getTenantId(), savedDeviceProfile.getId(),EdgeEventActionType.UPDATED);
+        return savedDeviceProfile;
+    }
+
+    @GetMapping("{id}")
+    @ApiOperation("详情")
+//    @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{'api:yt:deviceProfile:get'})")
+    public ResponseEntity<YtDeviceScriptDTO> getDevice(@PathVariable("id") String id) throws ThingsboardException {
+        return ResponseEntity.of(scriptService.getDeviceScript(getCurrentUser().getCurrentTenantId(), id));
+    }
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @GetMapping(params = {PAGE_SIZE, PAGE})
+    @ApiOperation("分页查询")
+    public YtPageData<YtDeviceScriptDTO> pageDeviceProfile(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestParam(value = "name", required = false) String name,
+            @RequestParam(value = "transportType", required = false) String transportType,
+            @RequestParam(value = ORDER_FILED, required = false) String orderFiled,
+            @RequestParam(value = ORDER_TYPE, required = false) OrderTypeEnum orderType) throws ThingsboardException {
+
+        return scriptService.page(page, pageSize, orderFiled, orderType, getCurrentUser().getCurrentTenantId());
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @GetMapping("/me/list")
+    @ApiOperation("选项列表")
+    public ResponseEntity listDeviceProfile() throws ThingsboardException {
+        List<YtDeviceScriptDTO> results = scriptService.findDeviceScript(getCurrentUser().getCurrentTenantId());
+        return ResponseEntity.ok(results);
+    }
+
+    @DeleteMapping
+    @ApiOperation("删除")
+    @PreAuthorize("@check.checkPermissions({'TENANT_ADMIN'},{'api:yt:deviceProfile:delete'})")
+    public void deleteDevices(@Validated({DeleteGroup.class}) @RequestBody DeleteDTO deleteDTO) throws ThingsboardException {
+        scriptService.deleteScriptes(getCurrentUser().getCurrentTenantId(), deleteDTO.getIds());
+    }
+
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @PostMapping("/test")
+    @ApiOperation("测试脚本执行结果")
+    public ResponseEntity<JsonNode> test(@RequestBody JsonNode inputParams) throws ThingsboardException {
+        try {
+            String script = inputParams.get("script").asText();
+            String jsParam  = inputParams.get("params").asText();
+
+
+            String output = "";
+            String errorText = "";
+            ScriptEngine engine = null;
+            try {
+                UUID scriptId = jsEngine.eval(YtScriptType.TCP_TRANSPORT_SCRIPT, script).get();
+                ListenableFuture<String> result = Futures.transformAsync(jsEngine.invokeFunction(scriptId, jsParam),
+                        o -> {
+                            try {
+                                JsonElement json = parser.parse(o.toString());
+                                return Futures.immediateFuture(json.toString());
+                            } catch (Exception e) {
+                                return Futures.immediateFailedFuture(e);
+                            }
+                        }, MoreExecutors.directExecutor());
+
+                output =result.get(20, TimeUnit.SECONDS);
+            } catch (Exception e) {
+                errorText = e.getMessage();
+            } finally {
+                if (engine != null) {
+                    engine.destroy();
+                }
+            }
+            ObjectNode result = objectMapper.createObjectNode();
+            result.put("output", output);
+            result.put("error", errorText);
+            return ResponseEntity.ok(result);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+
+
+    }
+
+
+
+
+
+    /**
+     * 构造调用TBDeviceProfile需要的参数
+     *
+     * @param deviceProfileDTO 页面接收的参数
+     * @return 封装好的TBDeviceProfile
+     */
+    private DeviceProfile buildTbDeviceProfileFromDeviceProfileDTO(DeviceProfileDTO deviceProfileDTO,String scriptId,String scriptText) {
+        DeviceProfile tbDeviceProfile = new DeviceProfile();
+        if (StringUtils.isNotBlank(deviceProfileDTO.getId())) {
+            UUID profileId = UUID.fromString(deviceProfileDTO.getId());
+            tbDeviceProfile.setId(new DeviceProfileId(profileId));
+            tbDeviceProfile.setCreatedTime(deviceProfileDTO.getCreateTime().toInstant(ZoneOffset.of("+8")).toEpochMilli());
+        }else{
+            tbDeviceProfile.setCreatedTime(LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli());
+        }
+        tbDeviceProfile.setName(deviceProfileDTO.getName());
+        tbDeviceProfile.setImage(deviceProfileDTO.getImage());
+        tbDeviceProfile.setDescription(deviceProfileDTO.getDescription());
+        tbDeviceProfile.setType(DeviceProfileType.DEFAULT);
+        UUID tenantId = UUID.fromString(deviceProfileDTO.getTenantId());
+        tbDeviceProfile.setTenantId(TenantId.fromUUID(tenantId));
+        tbDeviceProfile.setDefault(deviceProfileDTO.isDefault());
+
+        // 获取当前租户的默认规则链
+        if (StringUtils.isNotBlank(deviceProfileDTO.getDefaultRuleChainId())) {
+            UUID chainId = UUID.fromString(deviceProfileDTO.getDefaultRuleChainId());
+            tbDeviceProfile.setDefaultRuleChainId(new RuleChainId(chainId));
+        }
+
+        tbDeviceProfile.setDefaultQueueName(ServiceQueue.MAIN);
+        tbDeviceProfile.setProvisionType(DeviceProfileProvisionType.DISABLED);
+
+
+        // 传输类型默认都是Default
+        String transportType = deviceProfileDTO.getTransportType();
+        tbDeviceProfile.setTransportType(DeviceTransportType.valueOf(transportType));
+
+
+        deviceProfileDTO.setScriptId(scriptId);
+
+        DeviceProfileData deviceProfileData = new DeviceProfileData();
+        buildDeviceProfileData(transportType,deviceProfileData,deviceProfileDTO.getProfileData().getTransportConfiguration(),scriptText);
+
+
+        tbDeviceProfile.setProfileData(deviceProfileData);
+
+        return tbDeviceProfile;
+    }
+}

@@ -176,7 +176,7 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService {
 
     @Override
     public void createSysAdmin() {
-        createUser(Authority.SYS_ADMIN, null, null, "sysadmin@thingsboard.org", "sysadmin");
+        createUser(Authority.SYS_ADMIN, null, null, "sysadmin@qq.com", "Sysadmin@123");
     }
 
     @Override

@@ -170,9 +170,9 @@ ui:
 database:
   ts_max_intervals: "${DATABASE_TS_MAX_INTERVALS:700}" # Max number of DB queries generated by single API call to fetch telemetry records
   ts:
-    type: "${DATABASE_TS_TYPE:sql}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
+    type: "${DATABASE_TS_TYPE:timescale}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
   ts_latest:
-    type: "${DATABASE_TS_LATEST_TYPE:sql}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
+    type: "${DATABASE_TS_LATEST_TYPE:timescale}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
 
 # note: timescale works only with postgreSQL database for DATABASE_ENTITIES_TYPE.
 
@@ -539,9 +539,9 @@ spring:
     database-platform: "${SPRING_JPA_DATABASE_PLATFORM:org.hibernate.dialect.PostgreSQLDialect}"
   datasource:
     driverClassName: "${SPRING_DRIVER_CLASS_NAME:org.postgresql.Driver}"
-    url: "${SPRING_DATASOURCE_URL:jdbc:postgresql://47.99.141.212:20638/thingsboard-3.3.4}"
+    url: "${SPRING_DATASOURCE_URL:jdbc:postgresql://47.99.141.212:20638/timescale-3.3.4}"
     username: "${SPRING_DATASOURCE_USERNAME:postgres}"
-    password: "${SPRING_DATASOURCE_PASSWORD:Vrr861!@waja}"
+    password: "${SPRING_DATASOURCE_PASSWORD:Xga751++nqnk}"
 #    url: "${SPRING_DATASOURCE_URL:jdbc:postgresql://101.133.234.90:28776/thingsboard-3.3.2}"
 #    username: "${SPRING_DATASOURCE_USERNAME:postgres}"
 #    password: "${SPRING_DATASOURCE_PASSWORD:Bua312!!iwcw}"
@@ -708,6 +708,59 @@ transport:
       # Skip certificate validity check for client certificates.
       skip_validity_check_for_client_cert: "${MQTT_SSL_SKIP_VALIDITY_CHECK_FOR_CLIENT_CERT:false}"
   # Local CoAP transport parameters
+  tcp:
+    # Enable/disable tcp transport protocol.
+    enabled: "${TCP_ENABLED:true}"
+    bind_address: "${TCP_BIND_ADDRESS:0.0.0.0}"
+    bind_port: "${TCP_BIND_PORT:8088}"
+    # Enable proxy protocol support. Disabled by default. If enabled, supports both v1 and v2.
+    # Useful to get the real IP address of the client in the logs and for rate limits.
+    proxy_enabled: "${TCP_PROXY_PROTOCOL_ENABLED:false}"
+    timeout: "${TCP_TIMEOUT:10000}"
+    msg_queue_size_per_device_limit: "${TCP_MSG_QUEUE_SIZE_PER_DEVICE_LIMIT:100}" # messages await in the queue before device connected state. This limit works on low level before TenantProfileLimits mechanism
+    netty:
+      leak_detector_level: "${NETTY_LEAK_DETECTOR_LVL:DISABLED}"
+      boss_group_thread_count: "${NETTY_BOSS_GROUP_THREADS:1}"
+      worker_group_thread_count: "${NETTY_WORKER_GROUP_THREADS:12}"
+      max_payload_size: "${NETTY_MAX_PAYLOAD_SIZE:65536}"
+      so_keep_alive: "${NETTY_SO_KEEPALIVE:false}"
+    # TCP SSL configuration
+    ssl:
+      # Enable/disable SSL support
+      enabled: "${TCP_SSL_ENABLED:false}"
+      # TCP SSL bind address
+      bind_address: "${TCP_SSL_BIND_ADDRESS:0.0.0.0}"
+      # TCP SSL bind port
+      bind_port: "${TCP_SSL_BIND_PORT:8888}"
+      # SSL protocol: See https://docs.oracle.com/en/java/javase/11/docs/specs/security/standard-names.html#sslcontext-algorithms
+      protocol: "${TCP_SSL_PROTOCOL:TLSv1.2}"
+      # Server SSL credentials
+      credentials:
+        # Server credentials type (PEM - pem certificate file; KEYSTORE - java keystore)
+        type:  "${TCP_SSL_CREDENTIALS_TYPE:PEM}"
+        # PEM server credentials
+        pem:
+          # Path to the server certificate file (holds server certificate or certificate chain, may include server private key)
+          cert_file: "${TCP_SSL_PEM_CERT:tcpserver.pem}"
+          # Path to the server certificate private key file. Optional by default. Required if the private key is not present in server certificate file;
+          key_file: "${TCP_SSL_PEM_KEY:tcpserver_key.pem}"
+          # Server certificate private key password (optional)
+          key_password: "${TCP_SSL_PEM_KEY_PASSWORD:server_key_password}"
+        # Keystore server credentials
+        keystore:
+          # Type of the key store
+          type: "${TCP_SSL_KEY_STORE_TYPE:JKS}"
+          # Path to the key store that holds the SSL certificate
+          store_file: "${TCP_SSL_KEY_STORE:tcpserver.jks}"
+          # Password used to access the key store
+          store_password: "${TCP_SSL_KEY_STORE_PASSWORD:server_ks_password}"
+          # Optional alias of the private key; If not set, the platform will load the first private key from the keystore;
+          key_alias: "${TCP_SSL_KEY_ALIAS:}"
+          # Optional password to access the private key. If not set, the platform will attempt to load the private keys that are not protected with the password;
+          key_password: "${TCP_SSL_KEY_PASSWORD:server_key_password}"
+      # Skip certificate validity check for client certificates.
+      skip_validity_check_for_client_cert: "${TCP_SSL_SKIP_VALIDITY_CHECK_FOR_CLIENT_CERT:false}"
+  # Local CoAP transport parameters
   coap:
     # Enable/disable coap transport protocol.
     enabled: "${COAP_ENABLED:true}"
@@ -1143,8 +1196,8 @@ file:
       staticUrl: /oss/files/**              #oss静态访问路径 只有type = local需要
       randomFileName: ${file.storage.randomFileName}
     minio:
-      minioUrl: ${MINIO_URL:https://dev.thingskit.com:9000}  #minio储存地址
-#      minioUrl: https://demo.thingskit.com:9000  #minio储存地址
+#      minioUrl: ${MINIO_URL:https://dev.thingskit.com:9000}  #minio储存地址
+      minioUrl: https://demo.thingskit.com:9000  #minio储存地址
       minioName: ${MINIO_NAME:YunTeng}                    #minio账户
       minioPass: ${MINIO_PWD:YunTeng123456}              #minio访问密码
       bucketName: yunteng                   #minio储存桶名称

@@ -43,6 +43,8 @@ public class DataConstants {
     public static final String COAP_TRANSPORT_NAME = "COAP";
     public static final String LWM2M_TRANSPORT_NAME = "LWM2M";
     public static final String MQTT_TRANSPORT_NAME = "MQTT";
+    //Thingskit function
+    public static final String TCP_TRANSPORT_NAME = "TCP";
     public static final String HTTP_TRANSPORT_NAME = "HTTP";
     public static final String SNMP_TRANSPORT_NAME = "SNMP";
 

@@ -18,6 +18,7 @@ package org.thingsboard.server.common.data;
 public enum DeviceTransportType {
     DEFAULT,
     MQTT,
+    TCP,
     COAP,
     LWM2M,
     SNMP

@@ -21,6 +21,7 @@ import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import io.swagger.annotations.ApiModel;
 import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.device.profile.YtTcpDeviceProfileTransportConfiguration;
 
 import java.io.Serializable;
 
@@ -33,6 +34,7 @@ import java.io.Serializable;
 @JsonSubTypes({
         @JsonSubTypes.Type(value = DefaultDeviceTransportConfiguration.class, name = "DEFAULT"),
         @JsonSubTypes.Type(value = MqttDeviceTransportConfiguration.class, name = "MQTT"),
+        @JsonSubTypes.Type(value = YtTcpDeviceTransportConfiguration.class, name = "TCP"),
         @JsonSubTypes.Type(value = CoapDeviceTransportConfiguration.class, name = "COAP"),
         @JsonSubTypes.Type(value = Lwm2mDeviceTransportConfiguration.class, name = "LWM2M"),
         @JsonSubTypes.Type(value = SnmpDeviceTransportConfiguration.class, name = "SNMP")})

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.device.data;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonAnySetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import org.thingsboard.server.common.data.DeviceTransportType;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Data
+public class YtTcpDeviceTransportConfiguration implements DeviceTransportConfiguration {
+
+
+    @Override
+    public DeviceTransportType getType() {
+        return DeviceTransportType.TCP;
+    }
+
+}

@@ -31,6 +31,7 @@ import java.io.Serializable;
 @JsonSubTypes({
         @JsonSubTypes.Type(value = DefaultDeviceProfileTransportConfiguration.class, name = "DEFAULT"),
         @JsonSubTypes.Type(value = MqttDeviceProfileTransportConfiguration.class, name = "MQTT"),
+        @JsonSubTypes.Type(value = YtTcpDeviceProfileTransportConfiguration.class, name = "TCP"),
         @JsonSubTypes.Type(value = Lwm2mDeviceProfileTransportConfiguration.class, name = "LWM2M"),
         @JsonSubTypes.Type(value = CoapDeviceProfileTransportConfiguration.class, name = "COAP"),
         @JsonSubTypes.Type(value = SnmpDeviceProfileTransportConfiguration.class, name = "SNMP")

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.device.profile;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.validation.NoXss;
+import org.thingsboard.server.common.data.yunteng.enums.TcpDataTypeEnum;
+
+@Data
+public class YtTcpDeviceProfileTransportConfiguration implements DeviceProfileTransportConfiguration {
+
+    @NoXss
+    private TcpDataTypeEnum dataFormat = TcpDataTypeEnum.HEX;
+    private String scriptId;
+    private String scriptText;
+    private String pingText;
+
+    @Override
+    public DeviceTransportType getType() {
+        return DeviceTransportType.TCP;
+    }
+
+
+
+
+}

@@ -49,6 +49,11 @@ public final class ModelConstants {
         "iotfs_user_organization_mapping";
     /** 设备表 */
     public static final String IOTFS_DEVICE_TABLE_NAME = "iotfs_device";
+    /** 产品信息(设备配置)扩展表 */
+    public static final String IOTFS_DEVICE_PROFILE_TABLE_NAME = "iotfs_device_profile";
+    /** 自定义数据协议解析脚本 */
+    public static final String IOTFS_DEVICE_SCRIPT_TABLE_NAME = "iotfs_java_script";
+
     /** 设备类型表 */
     public static final String IOTFS_DEVICE_TYPE_TABLE_NAME = "iotfs_device_type";
     /** 告警配置表 */

@@ -81,7 +81,9 @@ public enum ErrorMessage {
   DATA_BOARD_IS_PRIVATE(400057,"该数据看板不是公有视图"),
   MESSAGE_SEND_TOO_FAST(400058,"1分钟内请求次数过多，请休息一下！"),
   PASSWORD_INCORRECT(4010059, "密码错误!"),
-  MESSAGE_SEND_FAILED(4010059, "消息发送失败!"),
+  MESSAGE_SEND_FAILED(4010060, "消息发送失败!"),
+  PROJECT_USED_SCRIPT(400061,"产品【%s】正在使用待删除的解析脚本"),
+  RULE_CHAIN_NOT_ENABLE(400062,"规则链不是有效的！"),
   HAVE_NO_PERMISSION(500002,"没有修改权限");
   private final int code;
   private String message;

@@ -7,11 +7,15 @@ import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.DeviceProfileType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
+import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+import org.thingsboard.server.common.data.yunteng.enums.DeviceTypeEnum;
 import org.thingsboard.server.common.data.yunteng.utils.JacksonUtil;
 
 import javax.validation.Valid;
 import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
@@ -21,27 +25,38 @@ import java.util.UUID;
 
 @EqualsAndHashCode(callSuper = true)
 @Data
-public class DeviceProfileDTO extends TenantDTO {
+public class DeviceProfileDTO extends BaseDTO {
     @NotEmpty(message = "设备配置名称不能为空或者空字符串", groups = AddGroup.class)
-    @ApiModelProperty(value = "设备配置名称")
+    @ApiModelProperty(value = "产品(设备配置)名称")
     private String name;
 
     private String description;
+
     /**
-     * 转换脚本：TCP才会使用
+     * TCP协议的解析脚本ID，由后端自己回填
      */
-    private String convertJs;
+    private String scriptId;
 
+    @ApiModelProperty(value = "租户ID")
+    private String tenantId;
     @NotEmpty(message = "传输协议不能为空或者空字符串", groups = AddGroup.class)
     @ApiModelProperty(value = "传输协议", required = true)
-    @NotEmpty(message = "传输协议不能为空或者二空字符串")
     private String transportType;
+
+    private String provisionType;
+
+    @NotNull(message = "产品类型不能为空", groups = {AddGroup.class})
+    @ApiModelProperty(value = "产品类型：GATEWAY,DIRECT_CONNECTION,SENSOR", required = true)
+    private DeviceTypeEnum deviceType;
+
     /**
      * TB的设备配置文件
      */
     @Deprecated
     private String tbProfileId;
 
+
+
     @Valid
     private transient DeviceProfileData profileData;
     @ApiModelProperty(value = "关联规则链，默认关联根规则链", required = false)
@@ -76,17 +91,11 @@ public class DeviceProfileDTO extends TenantDTO {
         this.profileData = JacksonUtil.convertValue(profileData, DeviceProfileData.class);
 
     }
-
-    public DeviceProfileDTO(UUID id, String name, Long time, String description, DeviceTransportType transportType, String defaultRuleChainId,boolean isDefault,String image,DeviceProfileType type, String convertJs) {
-        setId(id.toString());
-        setCreateTime(LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneOffset.of("+8")));
+    public DeviceProfileDTO(String name, TenantId tenantId, DeviceProfileId tbProfileId, DeviceTypeEnum deviceType) {
         this.name = name;
-        this.isDefault = isDefault;
-        this.image = image;
-        this.description = description;
-        this.type = type.name();
-        this.convertJs = convertJs;
-        this.transportType = transportType.name();
-        this.defaultRuleChainId = defaultRuleChainId.toString();
+        this.tenantId =tenantId.getId().toString();
+        this.tbProfileId = tbProfileId.getId().toString();
+        this.deviceType = deviceType;
     }
+
 }

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.common.AddGroup;
+import org.thingsboard.server.common.data.yunteng.common.UpdateGroup;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class YtDeviceScriptDTO extends BaseDTO {
+    @NotEmpty(message = "解析脚本名称不能为空或者空字符串", groups = {AddGroup.class,UpdateGroup.class})
+    @ApiModelProperty(value = "解析脚本名称")
+    private String name;
+
+    /** TB的租户ID */
+    @ApiModelProperty(value = "租户ID")
+    private String tenantId;
+
+    @ApiModelProperty(value = "脚本描述")
+    private String description;
+    @NotEmpty(message = "解析脚本内容不能为空或者空字符串", groups = {AddGroup.class,UpdateGroup.class})
+    @ApiModelProperty(value = "解析脚本方法体内容")
+    private String convertJs;
+
+    @ApiModelProperty(value = "状态：0禁用 1启用")
+    @NotNull(message = "状态不能为空",groups = UpdateGroup.class)
+    private Integer status;
+
+    public YtDeviceScriptDTO() {
+    }
+}

@@ -3,9 +3,8 @@ package org.thingsboard.server.common.data.yunteng.enums;
 /**
  * 设备凭证
  */
-public enum DeviceCredentialsEnum {
-    ACCESS_TOKEN,
-    X509_CERTIFICATE,
-    MQTT_BASIC,
-    LWM2M_CREDENTIALS
+public enum TcpDataTypeEnum {
+    HEX,
+    JSON,
+    ASCII
 }

@@ -37,6 +37,7 @@
     <modules>
         <module>transport-api</module>
         <module>mqtt</module>
+        <module>tcp</module>
         <module>http</module>
         <module>coap</module>
         <module>lwm2m</module>

+<!--
+
+    Copyright © 2016-2022 The Thingsboard Authors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.thingsboard.common</groupId>
+        <version>3.3.4-SNAPSHOT</version>
+        <artifactId>transport</artifactId>
+    </parent>
+    <groupId>org.thingsboard.common.transport</groupId>
+    <artifactId>tcp</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Thingsboard TCP Transport Common</name>
+    <url>https://thingsboard.io</url>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <main.dir>${basedir}/../../..</main.dir>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.thingsboard.common.transport</groupId>
+            <artifactId>transport-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-all</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-tcnative-boringssl-static</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context-support</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>log4j-over-slf4j</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.findbugs</groupId>
+            <artifactId>jsr305</artifactId>
+            <version>3.0.1</version>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.vintage</groupId>
+            <artifactId>junit-vintage-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
+
+</project>

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp;
+
+import io.netty.handler.ssl.SslHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.msg.EncryptionUtil;
+import org.thingsboard.server.common.transport.TransportService;
+import org.thingsboard.server.common.transport.TransportServiceCallback;
+import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
+import org.thingsboard.server.common.transport.config.ssl.SslCredentials;
+import org.thingsboard.server.common.transport.config.ssl.SslCredentialsConfig;
+import org.thingsboard.server.common.transport.util.SslUtil;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Created by valerii.sosliuk on 11/6/16.
+ */
+@Slf4j
+@Component("TcpSslHandlerProvider")
+@ConditionalOnProperty(prefix = "transport.tcp.ssl", value = "enabled", havingValue = "true", matchIfMissing = false)
+public class TcpSslHandlerProvider {
+
+    @Value("${transport.tcp.ssl.protocol}")
+    private String sslProtocol;
+
+    @Autowired
+    private TransportService transportService;
+
+    @Bean
+    @ConfigurationProperties(prefix = "transport.tcp.ssl.credentials")
+    public SslCredentialsConfig tcpSslCredentials() {
+        return new SslCredentialsConfig("tcp SSL Credentials", false);
+    }
+
+    @Autowired
+    @Qualifier("tcpSslCredentials")
+    private SslCredentialsConfig tcpSslCredentialsConfig;
+
+    private SSLContext sslContext;
+
+    public SslHandler getSslHandler() {
+        if (sslContext == null) {
+            sslContext = createSslContext();
+        }
+        SSLEngine sslEngine = sslContext.createSSLEngine();
+        sslEngine.setUseClientMode(false);
+        sslEngine.setNeedClientAuth(false);
+        sslEngine.setWantClientAuth(true);
+        sslEngine.setEnabledProtocols(sslEngine.getSupportedProtocols());
+        sslEngine.setEnabledCipherSuites(sslEngine.getSupportedCipherSuites());
+        sslEngine.setEnableSessionCreation(true);
+        return new SslHandler(sslEngine);
+    }
+
+    private SSLContext createSslContext() {
+        try {
+            SslCredentials sslCredentials = this.tcpSslCredentialsConfig.getCredentials();
+            TrustManagerFactory tmFactory = sslCredentials.createTrustManagerFactory();
+            KeyManagerFactory kmf = sslCredentials.createKeyManagerFactory();
+
+            KeyManager[] km = kmf.getKeyManagers();
+            TrustManager x509wrapped = getX509TrustManager(tmFactory);
+            TrustManager[] tm = {x509wrapped};
+            if (StringUtils.isEmpty(sslProtocol)) {
+                sslProtocol = "TLS";
+            }
+            SSLContext sslContext = SSLContext.getInstance(sslProtocol);
+            sslContext.init(km, tm, null);
+            return sslContext;
+        } catch (Exception e) {
+            log.error("Unable to set up SSL context. Reason: " + e.getMessage(), e);
+            throw new RuntimeException("Failed to get SSL context", e);
+        }
+    }
+
+    private TrustManager getX509TrustManager(TrustManagerFactory tmf) throws Exception {
+        X509TrustManager x509Tm = null;
+        for (TrustManager tm : tmf.getTrustManagers()) {
+            if (tm instanceof X509TrustManager) {
+                x509Tm = (X509TrustManager) tm;
+                break;
+            }
+        }
+        return new ThingsboardTcpX509TrustManager(x509Tm, transportService);
+    }
+
+    static class ThingsboardTcpX509TrustManager implements X509TrustManager {
+
+        private final X509TrustManager trustManager;
+        private TransportService transportService;
+
+        ThingsboardTcpX509TrustManager(X509TrustManager trustManager, TransportService transportService) {
+            this.trustManager = trustManager;
+            this.transportService = transportService;
+        }
+
+        @Override
+        public X509Certificate[] getAcceptedIssuers() {
+            return trustManager.getAcceptedIssuers();
+        }
+
+        @Override
+        public void checkServerTrusted(X509Certificate[] chain,
+                                       String authType) throws CertificateException {
+            trustManager.checkServerTrusted(chain, authType);
+        }
+
+        @Override
+        public void checkClientTrusted(X509Certificate[] chain,
+                                       String authType) throws CertificateException {
+            String credentialsBody = null;
+            for (X509Certificate cert : chain) {
+                try {
+                    String strCert = SslUtil.getCertificateString(cert);
+                    String sha3Hash = EncryptionUtil.getSha3Hash(strCert);
+                    final String[] credentialsBodyHolder = new String[1];
+                    CountDownLatch latch = new CountDownLatch(1);
+                    transportService.process(DeviceTransportType.TCP, TransportProtos.ValidateDeviceX509CertRequestMsg.newBuilder().setHash(sha3Hash).build(),
+                            new TransportServiceCallback<ValidateDeviceCredentialsResponse>() {
+                                @Override
+                                public void onSuccess(ValidateDeviceCredentialsResponse msg) {
+                                    if (!StringUtils.isEmpty(msg.getCredentials())) {
+                                        credentialsBodyHolder[0] = msg.getCredentials();
+                                    }
+                                    latch.countDown();
+                                }
+
+                                @Override
+                                public void onError(Throwable e) {
+                                    log.error(e.getMessage(), e);
+                                    latch.countDown();
+                                }
+                            });
+                    latch.await(10, TimeUnit.SECONDS);
+                    if (strCert.equals(credentialsBodyHolder[0])) {
+                        credentialsBody = credentialsBodyHolder[0];
+                        break;
+                    }
+                } catch (InterruptedException | CertificateEncodingException e) {
+                    log.error(e.getMessage(), e);
+                }
+            }
+            if (credentialsBody == null) {
+                throw new CertificateException("Invalid Device Certificate");
+            }
+        }
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp;
+
+import io.netty.handler.ssl.SslHandler;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.transport.TransportContext;
+import org.thingsboard.server.transport.tcp.adaptors.JsonTcpAdaptor;
+
+import javax.annotation.PostConstruct;
+import java.net.InetSocketAddress;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Created by ashvayka on 04.10.18.
+ */
+@Slf4j
+@Component
+@ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.tcp.enabled}'=='true')")
+public class TcpTransportContext extends TransportContext {
+
+    @Getter
+    @Autowired(required = false)
+    private TcpSslHandlerProvider sslHandlerProvider;
+
+    @Getter
+    @Autowired
+    private JsonTcpAdaptor jsonTcpAdaptor;
+
+
+    @Getter
+    @Value("${transport.tcp.netty.max_payload_size}")
+    private Integer maxPayloadSize;
+
+    @Getter
+    @Value("${transport.tcp.ssl.skip_validity_check_for_client_cert:false}")
+    private boolean skipValidityCheckForClientCert;
+
+    @Getter
+    @Setter
+    private SslHandler sslHandler;
+
+    @Getter
+    @Value("${transport.tcp.msg_queue_size_per_device_limit:100}")
+    private int messageQueueSizePerDeviceLimit;
+
+    @Getter
+    @Value("${transport.tcp.timeout:10000}")
+    private long timeout;
+
+    @Getter
+    @Value("${transport.tcp.proxy_enabled:false}")
+    private boolean proxyEnabled;
+
+    private final AtomicInteger connectionsCounter = new AtomicInteger();
+
+    @PostConstruct
+    public void init() {
+        super.init();
+        transportService.createGaugeStats("openConnections", connectionsCounter);
+    }
+
+    public void channelRegistered() {
+        connectionsCounter.incrementAndGet();
+    }
+
+    public void channelUnregistered() {
+        connectionsCounter.decrementAndGet();
+    }
+
+    public boolean checkAddress(InetSocketAddress address) {
+        return rateLimitService.checkAddress(address);
+    }
+
+    public void onAuthSuccess(InetSocketAddress address) {
+        rateLimitService.onAuthSuccess(address);
+    }
+
+    public void onAuthFailure(InetSocketAddress address) {
+        rateLimitService.onAuthFailure(address);
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp;
+
+import com.google.gson.JsonParseException;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.codec.mqtt.*;
+import io.netty.handler.ssl.SslHandler;
+import io.netty.util.ReferenceCountUtil;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.thingsboard.server.common.data.*;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.OtaPackageId;
+import org.thingsboard.server.common.data.ota.OtaPackageType;
+import org.thingsboard.server.common.data.yunteng.enums.TcpDataTypeEnum;
+import org.thingsboard.server.common.msg.EncryptionUtil;
+import org.thingsboard.server.common.msg.tools.TbRateLimitsException;
+import org.thingsboard.server.common.transport.SessionMsgListener;
+import org.thingsboard.server.common.transport.TransportService;
+import org.thingsboard.server.common.transport.TransportServiceCallback;
+import org.thingsboard.server.common.transport.adaptor.AdaptorException;
+import org.thingsboard.server.common.transport.auth.SessionInfoCreator;
+import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
+import org.thingsboard.server.common.transport.util.SslUtil;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceX509CertRequestMsg;
+import org.thingsboard.server.queue.scheduler.SchedulerComponent;
+import org.thingsboard.server.transport.tcp.adaptors.TcpTransportAdaptor;
+import org.thingsboard.server.transport.tcp.session.DeviceSessionCtx;
+import org.thingsboard.server.transport.tcp.session.TCPMessage;
+import org.thingsboard.server.transport.tcp.util.ByteUtils;
+
+import javax.net.ssl.SSLPeerUnverifiedException;
+import java.net.InetSocketAddress;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static com.amazonaws.util.StringUtils.UTF8;
+import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_ACCEPTED;
+import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED;
+import static io.netty.handler.codec.mqtt.MqttMessageType.*;
+import static io.netty.handler.codec.mqtt.MqttQoS.*;
+import static org.thingsboard.server.common.transport.service.DefaultTransportService.SESSION_EVENT_MSG_CLOSED;
+import static org.thingsboard.server.common.transport.service.DefaultTransportService.SESSION_EVENT_MSG_OPEN;
+
+/**
+ * @author Andrew Shvayka
+ */
+@Slf4j
+public class TcpTransportHandler extends ChannelInboundHandlerAdapter implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
+
+    private static final Pattern FW_REQUEST_PATTERN = Pattern.compile(MqttTopics.DEVICE_FIRMWARE_REQUEST_TOPIC_PATTERN);
+    private static final Pattern SW_REQUEST_PATTERN = Pattern.compile(MqttTopics.DEVICE_SOFTWARE_REQUEST_TOPIC_PATTERN);
+
+
+    private static final String PAYLOAD_TOO_LARGE = "PAYLOAD_TOO_LARGE";
+
+    private static final MqttQoS MAX_SUPPORTED_QOS_LVL = AT_LEAST_ONCE;
+
+    private final UUID sessionId;
+    private final TcpTransportContext context;
+    private final TransportService transportService;
+    private final SchedulerComponent scheduler;
+    private final SslHandler sslHandler;
+
+
+    /**需要处理的消息队列，例如：需要下发给设备的，设备上传的。*/
+    final DeviceSessionCtx deviceSessionCtx;
+    volatile InetSocketAddress address;
+
+    private final ConcurrentHashMap<String, String> otaPackSessions;
+    private final ConcurrentHashMap<String, Integer> chunkSizes;
+    private final ConcurrentMap<Integer, TransportProtos.ToDeviceRpcRequestMsg> rpcAwaitingAck;
+
+
+
+    TcpTransportHandler(TcpTransportContext context, SslHandler sslHandler) {
+        this.sessionId = UUID.randomUUID();
+        this.context = context;
+        this.transportService = context.getTransportService();
+        this.scheduler = context.getScheduler();
+        this.sslHandler = sslHandler;
+        this.deviceSessionCtx = new DeviceSessionCtx(sessionId, context);
+        this.otaPackSessions = new ConcurrentHashMap<>();
+        this.chunkSizes = new ConcurrentHashMap<>();
+        this.rpcAwaitingAck = new ConcurrentHashMap<>();
+    }
+
+    @Override
+    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
+        super.channelRegistered(ctx);
+        context.channelRegistered();
+    }
+
+    @Override
+    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
+        super.channelUnregistered(ctx);
+        context.channelUnregistered();
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) {
+        log.trace("【{}】 Processing msg: 【{}】", sessionId, msg);
+        if (address == null) {
+            address = getAddress(ctx);
+        }
+        try {
+            if (msg instanceof ByteBuf) {
+                ByteBuf message = (ByteBuf) msg;
+
+                processTcpMsg(ctx, ByteUtils.buf2Bytes(message));
+
+            } else {
+                log.debug("【{}】 Received non tcp message: 【{}】", sessionId, msg.getClass().getSimpleName());
+                ctx.close();
+            }
+        } finally {
+            ReferenceCountUtil.safeRelease(msg);
+        }
+    }
+
+    InetSocketAddress getAddress(ChannelHandlerContext ctx) {
+        var address = ctx.channel().attr(TcpTransportService.ADDRESS).get();
+        if (address == null) {
+            log.trace("[{}] Received empty address.", ctx.channel().id());
+            InetSocketAddress remoteAddress = (InetSocketAddress) ctx.channel().remoteAddress();
+            log.trace("[{}] Going to use address: {}", ctx.channel().id(), remoteAddress);
+            return remoteAddress;
+        } else {
+            log.trace("[{}] Received address: {}", ctx.channel().id(), address);
+        }
+        return address;
+    }
+
+    void processTcpMsg(ChannelHandlerContext ctx, byte[] msg) {
+        deviceSessionCtx.setChannel(ctx);
+        if (deviceSessionCtx.getDeviceInfo()  == null || deviceSessionCtx.getDeviceProfile() == null) {
+            processConnect(ctx,  ByteUtils.getString(msg, ByteUtils.UTF_8));
+        } else {
+            enqueueRegularSessionMsg(ctx,msg);
+        }
+    }
+
+
+
+    void enqueueRegularSessionMsg(ChannelHandlerContext ctx, byte[]  msg) {
+        final int queueSize = deviceSessionCtx.getMsgQueueSize();
+        if (queueSize >= context.getMessageQueueSizePerDeviceLimit()) {
+            log.info("Closing current session because msq queue size for device {} exceed limit {} with msgQueueSize counter {} and actual queue size {}",
+                    deviceSessionCtx.getDeviceId(), context.getMessageQueueSizePerDeviceLimit(), queueSize, deviceSessionCtx.getMsgQueueSize());
+            ctx.close();
+            return;
+        }
+
+        deviceSessionCtx.addToQueue(new TCPMessage(MqttMessageType.PUBLISH,msg));
+        processMsgQueue(ctx); //Under the normal conditions the msg queue will contain 0 messages. Many messages will be processed on device connect event in separate thread pool
+    }
+
+
+
+    void processMsgQueue(ChannelHandlerContext ctx) {
+        if (!deviceSessionCtx.isConnected()) {
+            log.trace("[{}][{}] Postpone processing msg due to device is not connected. Msg queue size is {}", sessionId, deviceSessionCtx.getDeviceId(), deviceSessionCtx.getMsgQueueSize());
+            return;
+        }
+        deviceSessionCtx.tryProcessQueuedMsgs(msg -> processRegularSessionMsg(ctx, msg));
+    }
+
+    void processRegularSessionMsg(ChannelHandlerContext ctx, TCPMessage msg) {
+        switch (msg.getMessageType()) {
+            case PUBLISH:
+                processPublish(ctx, msg);
+                break;
+            case SUBSCRIBE:
+//                processSubscribe(ctx, (MqttSubscribeMessage) msg);
+                break;
+            case UNSUBSCRIBE:
+//                processUnsubscribe(ctx, (MqttUnsubscribeMessage) msg);
+                break;
+
+            case DISCONNECT:
+                ctx.close();
+                break;
+            case PUBACK:
+//                int msgId = ((MqttPubAckMessage) msg).variableHeader().messageId();
+//                TransportProtos.ToDeviceRpcRequestMsg rpcRequest = rpcAwaitingAck.remove(msgId);
+//                if (rpcRequest != null) {
+//                    transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequest, RpcStatus.DELIVERED, TransportServiceCallback.EMPTY);
+//                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    private ByteBuf toDeviceMsg(byte[] msgs){
+        return Unpooled.copiedBuffer(msgs);
+    }
+
+    private String textFromMessage(byte[] payload){
+        if(deviceSessionCtx.getPayloadType().equals(TcpDataTypeEnum.ASCII)){
+            return ByteUtils.getString(payload,ByteUtils.UTF_8);
+        }else{
+            return ByteUtils.bytesToHex(payload);
+        }
+    }
+    private void processPublish(ChannelHandlerContext ctx, TCPMessage mqttMsg) {
+        if (!checkConnected(ctx, mqttMsg)) {
+            return;
+        }
+        if(deviceSessionCtx.getPingText().equals(mqttMsg.getMessage())){
+            ctx.channel().writeAndFlush(toDeviceMsg(mqttMsg.getMessage()));
+            transportService.reportActivity(deviceSessionCtx.getSessionInfo());
+            return;
+        }
+        String dataStr = textFromMessage(mqttMsg.getMessage());
+        log.trace("[{}][{}] Processing publish msg [{}]!", sessionId, deviceSessionCtx.getDeviceId(), dataStr);
+
+        processDevicePublish(ctx, dataStr);
+    }
+
+
+    private void processDevicePublish(ChannelHandlerContext ctx, String mqttMsg) {
+        try {
+//            Matcher fwMatcher;
+            TcpTransportAdaptor payloadAdaptor = deviceSessionCtx.getPayloadAdaptor();
+            TransportProtos.PostTelemetryMsg postTelemetryMsg = payloadAdaptor.convertToPostTelemetry(deviceSessionCtx, mqttMsg);
+            transportService.process(deviceSessionCtx.getSessionInfo(), postTelemetryMsg, null);
+//            if (deviceSessionCtx.isDeviceAttributesTopic(topicName)) {
+//                TransportProtos.PostAttributeMsg postAttributeMsg = payloadAdaptor.convertToPostAttributes(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(ctx, msgId, postAttributeMsg));
+//            } else if (deviceSessionCtx.isDeviceTelemetryTopic(topicName)) {
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX)) {
+//                TransportProtos.GetAttributeRequestMsg getAttributeMsg = payloadAdaptor.convertToGetAttributes(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_ATTRIBUTES_REQUEST_TOPIC_PREFIX);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), getAttributeMsg, getPubAckCallback(ctx, msgId, getAttributeMsg));
+//                attrReqTopicType = TopicType.V1;
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_RESPONSE_TOPIC)) {
+//                TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = payloadAdaptor.convertToDeviceRpcResponse(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_RESPONSE_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(ctx, msgId, rpcResponseMsg));
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_REQUESTS_TOPIC)) {
+//                TransportProtos.ToServerRpcRequestMsg rpcRequestMsg = payloadAdaptor.convertToServerRpcRequest(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_REQUESTS_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequestMsg, getPubAckCallback(ctx, msgId, rpcRequestMsg));
+//                toServerRpcSubTopicType = TopicType.V1;
+//            } else if (topicName.equals(MqttTopics.DEVICE_CLAIM_TOPIC)) {
+//                TransportProtos.ClaimDeviceMsg claimDeviceMsg = payloadAdaptor.convertToClaimDevice(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), claimDeviceMsg, getPubAckCallback(ctx, msgId, claimDeviceMsg));
+//            } else if ((fwMatcher = FW_REQUEST_PATTERN.matcher(topicName)).find()) {
+//                getOtaPackageCallback(ctx, mqttMsg, msgId, fwMatcher, OtaPackageType.FIRMWARE);
+//            } else if ((fwMatcher = SW_REQUEST_PATTERN.matcher(topicName)).find()) {
+//                getOtaPackageCallback(ctx, mqttMsg, msgId, fwMatcher, OtaPackageType.SOFTWARE);
+//            } else if (topicName.equals(MqttTopics.DEVICE_TELEMETRY_SHORT_TOPIC)) {
+//                TransportProtos.PostTelemetryMsg postTelemetryMsg = payloadAdaptor.convertToPostTelemetry(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), postTelemetryMsg, getPubAckCallback(ctx, msgId, postTelemetryMsg));
+//            } else if (topicName.equals(MqttTopics.DEVICE_TELEMETRY_SHORT_JSON_TOPIC)) {
+//                TransportProtos.PostTelemetryMsg postTelemetryMsg = context.getJsonMqttAdaptor().convertToPostTelemetry(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), postTelemetryMsg, getPubAckCallback(ctx, msgId, postTelemetryMsg));
+//            } else if (topicName.equals(MqttTopics.DEVICE_TELEMETRY_SHORT_PROTO_TOPIC)) {
+//                TransportProtos.PostTelemetryMsg postTelemetryMsg = context.getAscallAdaptor().convertToPostTelemetry(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), postTelemetryMsg, getPubAckCallback(ctx, msgId, postTelemetryMsg));
+//            } else if (topicName.equals(MqttTopics.DEVICE_ATTRIBUTES_SHORT_TOPIC)) {
+//                TransportProtos.PostAttributeMsg postAttributeMsg = payloadAdaptor.convertToPostAttributes(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(ctx, msgId, postAttributeMsg));
+//            } else if (topicName.equals(MqttTopics.DEVICE_ATTRIBUTES_SHORT_JSON_TOPIC)) {
+//                TransportProtos.PostAttributeMsg postAttributeMsg = context.getJsonMqttAdaptor().convertToPostAttributes(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(ctx, msgId, postAttributeMsg));
+//            } else if (topicName.equals(MqttTopics.DEVICE_ATTRIBUTES_SHORT_PROTO_TOPIC)) {
+//                TransportProtos.PostAttributeMsg postAttributeMsg = context.getAscallAdaptor().convertToPostAttributes(deviceSessionCtx, mqttMsg);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), postAttributeMsg, getPubAckCallback(ctx, msgId, postAttributeMsg));
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_RESPONSE_SHORT_JSON_TOPIC)) {
+//                TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = context.getJsonMqttAdaptor().convertToDeviceRpcResponse(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_RESPONSE_SHORT_JSON_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(ctx, msgId, rpcResponseMsg));
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_RESPONSE_SHORT_PROTO_TOPIC)) {
+//                TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = context.getAscallAdaptor().convertToDeviceRpcResponse(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_RESPONSE_SHORT_PROTO_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(ctx, msgId, rpcResponseMsg));
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_RESPONSE_SHORT_TOPIC)) {
+//                TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = payloadAdaptor.convertToDeviceRpcResponse(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_RESPONSE_SHORT_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcResponseMsg, getPubAckCallback(ctx, msgId, rpcResponseMsg));
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_REQUESTS_SHORT_JSON_TOPIC)) {
+//                TransportProtos.ToServerRpcRequestMsg rpcRequestMsg = context.getJsonMqttAdaptor().convertToServerRpcRequest(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_REQUESTS_SHORT_JSON_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequestMsg, getPubAckCallback(ctx, msgId, rpcRequestMsg));
+//                toServerRpcSubTopicType = TopicType.V2_JSON;
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_REQUESTS_SHORT_PROTO_TOPIC)) {
+//                TransportProtos.ToServerRpcRequestMsg rpcRequestMsg = context.getAscallAdaptor().convertToServerRpcRequest(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_REQUESTS_SHORT_PROTO_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequestMsg, getPubAckCallback(ctx, msgId, rpcRequestMsg));
+//                toServerRpcSubTopicType = TopicType.V2_PROTO;
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_RPC_REQUESTS_SHORT_TOPIC)) {
+//                TransportProtos.ToServerRpcRequestMsg rpcRequestMsg = payloadAdaptor.convertToServerRpcRequest(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_RPC_REQUESTS_SHORT_TOPIC);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequestMsg, getPubAckCallback(ctx, msgId, rpcRequestMsg));
+//                toServerRpcSubTopicType = TopicType.V2;
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_SHORT_JSON_TOPIC_PREFIX)) {
+//                TransportProtos.GetAttributeRequestMsg getAttributeMsg = context.getJsonMqttAdaptor().convertToGetAttributes(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_ATTRIBUTES_REQUEST_SHORT_JSON_TOPIC_PREFIX);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), getAttributeMsg, getPubAckCallback(ctx, msgId, getAttributeMsg));
+//                attrReqTopicType = TopicType.V2_JSON;
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_SHORT_PROTO_TOPIC_PREFIX)) {
+//                TransportProtos.GetAttributeRequestMsg getAttributeMsg = context.getAscallAdaptor().convertToGetAttributes(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_ATTRIBUTES_REQUEST_SHORT_PROTO_TOPIC_PREFIX);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), getAttributeMsg, getPubAckCallback(ctx, msgId, getAttributeMsg));
+//                attrReqTopicType = TopicType.V2_PROTO;
+//            } else if (topicName.startsWith(MqttTopics.DEVICE_ATTRIBUTES_REQUEST_SHORT_TOPIC_PREFIX)) {
+//                TransportProtos.GetAttributeRequestMsg getAttributeMsg = payloadAdaptor.convertToGetAttributes(deviceSessionCtx, mqttMsg, MqttTopics.DEVICE_ATTRIBUTES_REQUEST_SHORT_TOPIC_PREFIX);
+//                transportService.process(deviceSessionCtx.getSessionInfo(), getAttributeMsg, getPubAckCallback(ctx, msgId, getAttributeMsg));
+//                attrReqTopicType = TopicType.V2;
+//            } else {
+//                transportService.reportActivity(deviceSessionCtx.getSessionInfo());
+//                ack(ctx, msgId);
+//            }
+        } catch (AdaptorException e) {
+            log.debug("[{}] Failed to process publish msg [{}][{}]", sessionId, mqttMsg, e);
+            ctx.close();
+        }
+    }
+
+    private void getOtaPackageCallback(ChannelHandlerContext ctx, MqttPublishMessage mqttMsg, int msgId, Matcher fwMatcher, OtaPackageType type) {
+        String payload = mqttMsg.content().toString(UTF8);
+        int chunkSize = StringUtils.isNotEmpty(payload) ? Integer.parseInt(payload) : 0;
+        String requestId = fwMatcher.group("requestId");
+        int chunk = Integer.parseInt(fwMatcher.group("chunk"));
+
+        if (chunkSize > 0) {
+            this.chunkSizes.put(requestId, chunkSize);
+        } else {
+            chunkSize = chunkSizes.getOrDefault(requestId, 0);
+        }
+
+        if (chunkSize > context.getMaxPayloadSize()) {
+            sendOtaPackageError(ctx, PAYLOAD_TOO_LARGE);
+            return;
+        }
+
+        String otaPackageId = otaPackSessions.get(requestId);
+
+        if (otaPackageId != null) {
+            sendOtaPackage(ctx, mqttMsg.variableHeader().packetId(), otaPackageId, requestId, chunkSize, chunk, type);
+        } else {
+            TransportProtos.SessionInfoProto sessionInfo = deviceSessionCtx.getSessionInfo();
+            TransportProtos.GetOtaPackageRequestMsg getOtaPackageRequestMsg = TransportProtos.GetOtaPackageRequestMsg.newBuilder()
+                    .setDeviceIdMSB(sessionInfo.getDeviceIdMSB())
+                    .setDeviceIdLSB(sessionInfo.getDeviceIdLSB())
+                    .setTenantIdMSB(sessionInfo.getTenantIdMSB())
+                    .setTenantIdLSB(sessionInfo.getTenantIdLSB())
+                    .setType(type.name())
+                    .build();
+            transportService.process(deviceSessionCtx.getSessionInfo(), getOtaPackageRequestMsg,
+                    new OtaPackageCallback(ctx, msgId, getOtaPackageRequestMsg, requestId, chunkSize, chunk));
+        }
+    }
+
+    private void ack(ChannelHandlerContext ctx, int msgId) {
+        if (msgId > 0) {
+            ctx.writeAndFlush(createMqttPubAckMsg(msgId));
+        }
+    }
+
+    private <T> TransportServiceCallback<Void> getPubAckCallback(final ChannelHandlerContext ctx, final int msgId, final T msg) {
+        return new TransportServiceCallback<>() {
+            @Override
+            public void onSuccess(Void dummy) {
+                log.trace("[{}] Published msg: {}", sessionId, msg);
+                ack(ctx, msgId);
+            }
+
+            @Override
+            public void onError(Throwable e) {
+                log.trace("[{}] Failed to publish msg: {}", sessionId, msg, e);
+                ctx.close();
+            }
+        };
+    }
+
+    private class DeviceProvisionCallback implements TransportServiceCallback<ProvisionDeviceResponseMsg> {
+        private final ChannelHandlerContext ctx;
+        private final int msgId;
+        private final TransportProtos.ProvisionDeviceRequestMsg msg;
+
+        DeviceProvisionCallback(ChannelHandlerContext ctx, int msgId, TransportProtos.ProvisionDeviceRequestMsg msg) {
+            this.ctx = ctx;
+            this.msgId = msgId;
+            this.msg = msg;
+        }
+
+        @Override
+        public void onSuccess(TransportProtos.ProvisionDeviceResponseMsg provisionResponseMsg) {
+//            log.trace("[{}] Published msg: {}", sessionId, msg);
+//            ack(ctx, msgId);
+//            try {
+//                if (deviceSessionCtx.getProvisionPayloadType().equals(TransportPayloadType.JSON)) {
+//                    deviceSessionCtx.getContext().getJsonMqttAdaptor().convertToPublish(deviceSessionCtx, provisionResponseMsg).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+//                } else {
+//                    deviceSessionCtx.getContext().getAscallAdaptor().convertToPublish(deviceSessionCtx, provisionResponseMsg).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+//                }
+//                scheduler.schedule((Callable<ChannelFuture>) ctx::close, 60, TimeUnit.SECONDS);
+//            } catch (Exception e) {
+//                log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
+//            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            log.trace("[{}] Failed to publish msg: {}", sessionId, msg, e);
+            ctx.close();
+        }
+    }
+
+    private class OtaPackageCallback implements TransportServiceCallback<TransportProtos.GetOtaPackageResponseMsg> {
+        private final ChannelHandlerContext ctx;
+        private final int msgId;
+        private final TransportProtos.GetOtaPackageRequestMsg msg;
+        private final String requestId;
+        private final int chunkSize;
+        private final int chunk;
+
+        OtaPackageCallback(ChannelHandlerContext ctx, int msgId, TransportProtos.GetOtaPackageRequestMsg msg, String requestId, int chunkSize, int chunk) {
+            this.ctx = ctx;
+            this.msgId = msgId;
+            this.msg = msg;
+            this.requestId = requestId;
+            this.chunkSize = chunkSize;
+            this.chunk = chunk;
+        }
+
+        @Override
+        public void onSuccess(TransportProtos.GetOtaPackageResponseMsg response) {
+            if (TransportProtos.ResponseStatus.SUCCESS.equals(response.getResponseStatus())) {
+                OtaPackageId firmwareId = new OtaPackageId(new UUID(response.getOtaPackageIdMSB(), response.getOtaPackageIdLSB()));
+                otaPackSessions.put(requestId, firmwareId.toString());
+                sendOtaPackage(ctx, msgId, firmwareId.toString(), requestId, chunkSize, chunk, OtaPackageType.valueOf(response.getType()));
+            } else {
+                sendOtaPackageError(ctx, response.getResponseStatus().toString());
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            log.trace("[{}] Failed to get firmware: {}", sessionId, msg, e);
+            ctx.close();
+        }
+    }
+
+    private void sendOtaPackage(ChannelHandlerContext ctx, int msgId, String firmwareId, String requestId, int chunkSize, int chunk, OtaPackageType type) {
+        log.trace("[{}] Send firmware [{}] to device!", sessionId, firmwareId);
+        ack(ctx, msgId);
+        try {
+            byte[] firmwareChunk = context.getOtaPackageDataCache().get(firmwareId, chunkSize, chunk);
+            deviceSessionCtx.getPayloadAdaptor()
+                    .convertToPublish(deviceSessionCtx, firmwareChunk, requestId, chunk, type)
+                    .ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+        } catch (Exception e) {
+            log.trace("[{}] Failed to send firmware response!", sessionId, e);
+        }
+    }
+
+    private void sendOtaPackageError(ChannelHandlerContext ctx, String error) {
+        log.warn("[{}] {}", sessionId, error);
+        deviceSessionCtx.getChannel().writeAndFlush(deviceSessionCtx
+                .getPayloadAdaptor()
+                .createMqttPublishMsg(deviceSessionCtx, MqttTopics.DEVICE_FIRMWARE_ERROR_TOPIC, error.getBytes()));
+        ctx.close();
+    }
+
+    private void processSubscribe(ChannelHandlerContext ctx, MqttSubscribeMessage mqttMsg) {
+//        if (!checkConnected(ctx, mqttMsg)) {
+//            return;
+//        }
+//        log.trace("[{}] Processing subscription [{}]!", sessionId, mqttMsg.variableHeader().messageId());
+//        List<Integer> grantedQoSList = new ArrayList<>();
+//        boolean activityReported = false;
+//        for (MqttTopicSubscription subscription : mqttMsg.payload().topicSubscriptions()) {
+//            String topic = subscription.topicName();
+//            MqttQoS reqQoS = subscription.qualityOfService();
+//            try {
+//                switch (topic) {
+//                    case MqttTopics.DEVICE_ATTRIBUTES_TOPIC: {
+//                        processAttributesSubscribe(grantedQoSList, topic, reqQoS, TopicType.V1);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_ATTRIBUTES_SHORT_TOPIC: {
+//                        processAttributesSubscribe(grantedQoSList, topic, reqQoS, TopicType.V2);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_ATTRIBUTES_SHORT_JSON_TOPIC: {
+//                        processAttributesSubscribe(grantedQoSList, topic, reqQoS, TopicType.V2_JSON);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_ATTRIBUTES_SHORT_PROTO_TOPIC: {
+//                        processAttributesSubscribe(grantedQoSList, topic, reqQoS, TopicType.V2_PROTO);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_TOPIC: {
+//                        processRpcSubscribe(grantedQoSList, topic, reqQoS, TopicType.V1);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_SHORT_TOPIC: {
+//                        processRpcSubscribe(grantedQoSList, topic, reqQoS, TopicType.V2);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_SHORT_JSON_TOPIC: {
+//                        processRpcSubscribe(grantedQoSList, topic, reqQoS, TopicType.V2_JSON);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_SHORT_PROTO_TOPIC: {
+//                        processRpcSubscribe(grantedQoSList, topic, reqQoS, TopicType.V2_PROTO);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_SHORT_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_SHORT_JSON_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_SHORT_PROTO_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_SHORT_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_SHORT_JSON_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_SHORT_PROTO_TOPIC:
+//                    case MqttTopics.GATEWAY_ATTRIBUTES_TOPIC:
+//                    case MqttTopics.GATEWAY_RPC_TOPIC:
+//                    case MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC:
+//                    case MqttTopics.DEVICE_PROVISION_RESPONSE_TOPIC:
+//                    case MqttTopics.DEVICE_FIRMWARE_RESPONSES_TOPIC:
+//                    case MqttTopics.DEVICE_FIRMWARE_ERROR_TOPIC:
+//                    case MqttTopics.DEVICE_SOFTWARE_RESPONSES_TOPIC:
+//
+//                        break;
+//                    default:
+//                        log.warn("[{}] Failed to subscribe to [{}][{}]", sessionId, topic, reqQoS);
+//                        grantedQoSList.add(FAILURE.value());
+//                        break;
+//                }
+//            } catch (Exception e) {
+//                log.warn("[{}] Failed to subscribe to [{}][{}]", sessionId, topic, reqQoS, e);
+//                grantedQoSList.add(FAILURE.value());
+//            }
+//        }
+//        if (!activityReported) {
+//            transportService.reportActivity(deviceSessionCtx.getSessionInfo());
+//        }
+//        ctx.writeAndFlush(createSubAckMessage(mqttMsg.variableHeader().messageId(), grantedQoSList));
+    }
+
+//    private void processRpcSubscribe(List<Integer> grantedQoSList, String topic, MqttQoS reqQoS, TopicType topicType) {
+//        transportService.process(deviceSessionCtx.getSessionInfo(), TransportProtos.SubscribeToRPCMsg.newBuilder().build(), null);
+//        rpcSubTopicType = topicType;
+//    }
+//
+//    private void processAttributesSubscribe(List<Integer> grantedQoSList, String topic, MqttQoS reqQoS, TopicType topicType) {
+//        transportService.process(deviceSessionCtx.getSessionInfo(), TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().build(), null);
+//        attrSubTopicType = topicType;
+//    }
+
+
+
+    private void processUnsubscribe(ChannelHandlerContext ctx, MqttUnsubscribeMessage mqttMsg) {
+//        if (!checkConnected(ctx, mqttMsg)) {
+//            return;
+//        }
+//        boolean activityReported = false;
+//        log.trace("[{}] Processing subscription [{}]!", sessionId, mqttMsg.variableHeader().messageId());
+//        for (String topicName : mqttMsg.payload().topics()) {
+//            try {
+//                switch (topicName) {
+//                    case MqttTopics.DEVICE_ATTRIBUTES_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_SHORT_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_SHORT_PROTO_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_SHORT_JSON_TOPIC: {
+//                        transportService.process(deviceSessionCtx.getSessionInfo(),
+//                                TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().setUnsubscribe(true).build(), null);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_SHORT_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_SHORT_JSON_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_REQUESTS_SUB_SHORT_PROTO_TOPIC: {
+//                        transportService.process(deviceSessionCtx.getSessionInfo(),
+//                                TransportProtos.SubscribeToRPCMsg.newBuilder().setUnsubscribe(true).build(), null);
+//                        activityReported = true;
+//                        break;
+//                    }
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_SHORT_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_SHORT_JSON_TOPIC:
+//                    case MqttTopics.DEVICE_RPC_RESPONSE_SUB_SHORT_PROTO_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_SHORT_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_SHORT_JSON_TOPIC:
+//                    case MqttTopics.DEVICE_ATTRIBUTES_RESPONSES_SHORT_PROTO_TOPIC:
+//                    case MqttTopics.GATEWAY_ATTRIBUTES_TOPIC:
+//                    case MqttTopics.GATEWAY_RPC_TOPIC:
+//                    case MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC:
+//                    case MqttTopics.DEVICE_PROVISION_RESPONSE_TOPIC:
+//                    case MqttTopics.DEVICE_FIRMWARE_RESPONSES_TOPIC:
+//                    case MqttTopics.DEVICE_FIRMWARE_ERROR_TOPIC:
+//                    case MqttTopics.DEVICE_SOFTWARE_RESPONSES_TOPIC:
+//                    case MqttTopics.DEVICE_SOFTWARE_ERROR_TOPIC: {
+//                        activityReported = true;
+//                        break;
+//                    }
+//                }
+//            } catch (Exception e) {
+//                log.debug("[{}] Failed to process unsubscription [{}] to [{}]", sessionId, mqttMsg.variableHeader().messageId(), topicName);
+//            }
+//        }
+//        if (!activityReported) {
+//            transportService.reportActivity(deviceSessionCtx.getSessionInfo());
+//        }
+//        ctx.writeAndFlush(createUnSubAckMessage(mqttMsg.variableHeader().messageId()));
+    }
+
+    private MqttMessage createUnSubAckMessage(int msgId) {
+        MqttFixedHeader mqttFixedHeader =
+                new MqttFixedHeader(UNSUBACK, false, AT_MOST_ONCE, false, 0);
+        MqttMessageIdVariableHeader mqttMessageIdVariableHeader = MqttMessageIdVariableHeader.from(msgId);
+        return new MqttMessage(mqttFixedHeader, mqttMessageIdVariableHeader);
+    }
+
+    void processConnect(ChannelHandlerContext ctx, String accessToken) {
+        log.debug("[{}][{}] Processing connect msg for client: {}!", address, sessionId, accessToken);
+
+        if (DataConstants.PROVISION.equals(accessToken) || DataConstants.PROVISION.equals(accessToken)) {
+            deviceSessionCtx.setProvisionOnly(true);
+            ctx.writeAndFlush(createTcpConnAckMsg(CONNECTION_ACCEPTED));
+        } else {
+            X509Certificate cert;
+            if (sslHandler != null && (cert = getX509Certificate()) != null) {
+//                processX509CertConnect(ctx, cert, msg);
+            } else {
+                processAuthTokenConnect(ctx, accessToken);
+            }
+        }
+    }
+
+    private void processAuthTokenConnect(ChannelHandlerContext ctx, String accessToken) {
+
+        log.debug("[{}][{}] Processing connect msg for client with user name: {}!", address, sessionId, accessToken);
+        TransportProtos.ValidateDeviceTokenRequestMsg.Builder request = TransportProtos.ValidateDeviceTokenRequestMsg.newBuilder()
+                .setToken(accessToken);
+
+        transportService.process(DeviceTransportType.TCP, request.build(),
+                new TransportServiceCallback<>() {
+                    @Override
+                    public void onSuccess(ValidateDeviceCredentialsResponse msg) {
+                        onValidateDeviceResponse(msg, ctx);
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        log.trace("[{}] Failed to process credentials: {}", address, accessToken, e);
+                        ctx.writeAndFlush(createTcpConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE));
+                        ctx.close();
+                    }
+                });
+    }
+
+    private void processX509CertConnect(ChannelHandlerContext ctx, X509Certificate cert, MqttConnectMessage connectMessage) {
+        try {
+            if (!context.isSkipValidityCheckForClientCert()) {
+                cert.checkValidity();
+            }
+            String strCert = SslUtil.getCertificateString(cert);
+            String sha3Hash = EncryptionUtil.getSha3Hash(strCert);
+            transportService.process(DeviceTransportType.MQTT, ValidateDeviceX509CertRequestMsg.newBuilder().setHash(sha3Hash).build(),
+                    new TransportServiceCallback<>() {
+                        @Override
+                        public void onSuccess(ValidateDeviceCredentialsResponse msg) {
+                            onValidateDeviceResponse(msg, ctx);
+                        }
+
+                        @Override
+                        public void onError(Throwable e) {
+                            log.trace("[{}] Failed to process credentials: {}", address, sha3Hash, e);
+                            ctx.writeAndFlush(createTcpConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE));
+                            ctx.close();
+                        }
+                    });
+        } catch (Exception e) {
+            context.onAuthFailure(address);
+            ctx.writeAndFlush(createTcpConnAckMsg(CONNECTION_REFUSED_NOT_AUTHORIZED));
+            log.trace("[{}] X509 auth failure: {}", sessionId, address, e);
+            ctx.close();
+        }
+    }
+
+    private X509Certificate getX509Certificate() {
+        try {
+            Certificate[] certChain = sslHandler.engine().getSession().getPeerCertificates();
+            if (certChain.length > 0) {
+                return (X509Certificate) certChain[0];
+            }
+        } catch (SSLPeerUnverifiedException e) {
+            log.warn(e.getMessage());
+            return null;
+        }
+        return null;
+    }
+
+    private ByteBuf createTcpConnAckMsg(MqttConnectReturnCode msg) {
+        return Unpooled.copiedBuffer(ByteUtils.hexStr2Bytes(msg.name()));
+    }
+
+    @Override
+    public void channelReadComplete(ChannelHandlerContext ctx) {
+        ctx.flush();
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        log.error("[{}] Unexpected Exception", sessionId, cause);
+        ctx.close();
+        if (cause instanceof OutOfMemoryError) {
+            log.error("Received critical error. Going to shutdown the service.");
+            System.exit(1);
+        }
+    }
+
+    private static MqttSubAckMessage createSubAckMessage(Integer msgId, List<Integer> grantedQoSList) {
+        MqttFixedHeader mqttFixedHeader =
+                new MqttFixedHeader(SUBACK, false, AT_MOST_ONCE, false, 0);
+        MqttMessageIdVariableHeader mqttMessageIdVariableHeader = MqttMessageIdVariableHeader.from(msgId);
+        MqttSubAckPayload mqttSubAckPayload = new MqttSubAckPayload(grantedQoSList);
+        return new MqttSubAckMessage(mqttFixedHeader, mqttMessageIdVariableHeader, mqttSubAckPayload);
+    }
+
+
+
+    public static MqttPubAckMessage createMqttPubAckMsg(int requestId) {
+        MqttFixedHeader mqttFixedHeader =
+                new MqttFixedHeader(PUBACK, false, AT_MOST_ONCE, false, 0);
+        MqttMessageIdVariableHeader mqttMsgIdVariableHeader =
+                MqttMessageIdVariableHeader.from(requestId);
+        return new MqttPubAckMessage(mqttFixedHeader, mqttMsgIdVariableHeader);
+    }
+
+    private boolean checkConnected(ChannelHandlerContext ctx, TCPMessage msg) {
+        if (deviceSessionCtx.isConnected()) {
+            return true;
+        } else {
+            log.info("[{}] Closing current session due to invalid msg order: {}", sessionId, msg);
+            return false;
+        }
+    }
+
+
+
+    @Override
+    public void operationComplete(Future<? super Void> future) throws Exception {
+        log.trace("[{}] Channel closed!", sessionId);
+        doDisconnect();
+    }
+
+    public void doDisconnect() {
+        if (deviceSessionCtx.isConnected()) {
+            log.debug("[{}] Client disconnected!", sessionId);
+            transportService.process(deviceSessionCtx.getSessionInfo(), SESSION_EVENT_MSG_CLOSED, null);
+            transportService.deregisterSession(deviceSessionCtx.getSessionInfo());
+            deviceSessionCtx.setDisconnected();
+        }
+        deviceSessionCtx.release();
+    }
+
+
+    private void onValidateDeviceResponse(ValidateDeviceCredentialsResponse msg, ChannelHandlerContext ctx) {
+        if (!msg.hasDeviceInfo()) {
+            context.onAuthFailure(address);
+            ctx.writeAndFlush(createTcpConnAckMsg(CONNECTION_REFUSED_NOT_AUTHORIZED));
+            ctx.close();
+        } else {
+            context.onAuthSuccess(address);
+            deviceSessionCtx.setDeviceInfo(msg.getDeviceInfo());
+            deviceSessionCtx.setDeviceProfile(msg.getDeviceProfile());
+            deviceSessionCtx.setSessionInfo(SessionInfoCreator.create(msg, context, sessionId));
+            transportService.process(deviceSessionCtx.getSessionInfo(), SESSION_EVENT_MSG_OPEN, new TransportServiceCallback<Void>() {
+                @Override
+                public void onSuccess(Void msg) {
+                    transportService.registerAsyncSession(deviceSessionCtx.getSessionInfo(), TcpTransportHandler.this);
+                    ctx.writeAndFlush(createTcpConnAckMsg(CONNECTION_ACCEPTED));
+                    deviceSessionCtx.setConnected(true);
+                    log.debug("[{}] Client connected!", sessionId);
+                    transportService.getCallbackExecutor().execute(() -> processMsgQueue(ctx)); //this callback will execute in Producer worker thread and hard or blocking work have to be submitted to the separate thread.
+                }
+
+                @Override
+                public void onError(Throwable e) {
+                    if (e instanceof TbRateLimitsException) {
+                        log.trace("[{}] Failed to submit session event: {}", sessionId, e.getMessage());
+                    } else {
+                        log.warn("[{}] Failed to submit session event", sessionId, e);
+                    }
+                    ctx.writeAndFlush(createTcpConnAckMsg(MqttConnectReturnCode.CONNECTION_REFUSED_SERVER_UNAVAILABLE));
+                    ctx.close();
+                }
+            });
+        }
+    }
+
+    @Override
+    public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg response) {
+//        log.trace("[{}] Received get attributes response", sessionId);
+//        String topicBase = attrReqTopicType.getAttributesResponseTopicBase();
+//        TcpTransportAdaptor adaptor = deviceSessionCtx.getAdaptor(attrReqTopicType);
+//        try {
+//            adaptor.convertToPublish(deviceSessionCtx, response, topicBase).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+//        } catch (Exception e) {
+//            log.trace("[{}] Failed to convert device attributes response to MQTT msg", sessionId, e);
+//        }
+    }
+
+    @Override
+    public void onAttributeUpdate(UUID sessionId, TransportProtos.AttributeUpdateNotificationMsg notification) {
+//        log.trace("[{}] Received attributes update notification to device", sessionId);
+//        String topic = attrSubTopicType.getAttributesSubTopic();
+//        TcpTransportAdaptor adaptor = deviceSessionCtx.getAdaptor(attrSubTopicType);
+//        try {
+//            adaptor.convertToPublish(deviceSessionCtx, notification, topic).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+//        } catch (Exception e) {
+//            log.trace("[{}] Failed to convert device attributes update to MQTT msg", sessionId, e);
+//        }
+    }
+
+    @Override
+    public void onRemoteSessionCloseCommand(UUID sessionId, TransportProtos.SessionCloseNotificationProto sessionCloseNotification) {
+        log.trace("[{}] Received the remote command to close the session: {}", sessionId, sessionCloseNotification.getMessage());
+        deviceSessionCtx.getChannel().close();
+    }
+
+    @Override
+    public void onToDeviceRpcRequest(UUID sessionId, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
+//        log.trace("[{}] Received RPC command to device", sessionId);
+//        String baseTopic = rpcSubTopicType.getRpcRequestTopicBase();
+//        TcpTransportAdaptor adaptor = deviceSessionCtx.getAdaptor(rpcSubTopicType);
+//        try {
+//            adaptor.convertToPublish(deviceSessionCtx, rpcRequest, baseTopic).ifPresent(payload -> {
+//                int msgId = ((MqttPublishMessage) payload).variableHeader().packetId();
+//                if (isAckExpected(payload)) {
+//                    rpcAwaitingAck.put(msgId, rpcRequest);
+//                    context.getScheduler().schedule(() -> {
+//                        TransportProtos.ToDeviceRpcRequestMsg msg = rpcAwaitingAck.remove(msgId);
+//                        if (msg != null) {
+//                            transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequest, RpcStatus.TIMEOUT, TransportServiceCallback.EMPTY);
+//                        }
+//                    }, Math.max(0, Math.min(deviceSessionCtx.getContext().getTimeout(), rpcRequest.getExpirationTime() - System.currentTimeMillis())), TimeUnit.MILLISECONDS);
+//                }
+//                var cf = publish(payload, deviceSessionCtx);
+//                cf.addListener(result -> {
+//                    if (result.cause() == null) {
+//                        if (!isAckExpected(payload)) {
+//                            transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequest, RpcStatus.DELIVERED, TransportServiceCallback.EMPTY);
+//                        } else if (rpcRequest.getPersisted()) {
+//                            transportService.process(deviceSessionCtx.getSessionInfo(), rpcRequest, RpcStatus.SENT, TransportServiceCallback.EMPTY);
+//                        }
+//                    } else {
+//                        // TODO: send error
+//                    }
+//                });
+//            });
+//        } catch (Exception e) {
+//            transportService.process(deviceSessionCtx.getSessionInfo(),
+//                    TransportProtos.ToDeviceRpcResponseMsg.newBuilder()
+//                            .setRequestId(rpcRequest.getRequestId()).setError("Failed to convert device RPC command to MQTT msg").build(), TransportServiceCallback.EMPTY);
+//            log.trace("[{}] Failed to convert device RPC command to MQTT msg", sessionId, e);
+//        }
+    }
+
+    @Override
+    public void onToServerRpcResponse(TransportProtos.ToServerRpcResponseMsg rpcResponse) {
+//        log.trace("[{}] Received RPC response from server", sessionId);
+//        String baseTopic = toServerRpcSubTopicType.getRpcResponseTopicBase();
+//        TcpTransportAdaptor adaptor = deviceSessionCtx.getAdaptor(toServerRpcSubTopicType);
+//        try {
+//            adaptor.convertToPublish(deviceSessionCtx, rpcResponse, baseTopic).ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+//        } catch (Exception e) {
+//            log.trace("[{}] Failed to convert device RPC command to MQTT msg", sessionId, e);
+//        }
+    }
+
+    private ChannelFuture publish(MqttMessage message, DeviceSessionCtx deviceSessionCtx) {
+        return deviceSessionCtx.getChannel().writeAndFlush(message);
+    }
+
+    private boolean isAckExpected(MqttMessage message) {
+        return message.fixedHeader().qosLevel().value() > 0;
+    }
+
+    @Override
+    public void onDeviceProfileUpdate(TransportProtos.SessionInfoProto sessionInfo, DeviceProfile deviceProfile) {
+        deviceSessionCtx.onDeviceProfileUpdate(sessionInfo, deviceProfile);
+    }
+
+    @Override
+    public void onDeviceUpdate(TransportProtos.SessionInfoProto sessionInfo, Device device, Optional<DeviceProfile> deviceProfileOpt) {
+        deviceSessionCtx.onDeviceUpdate(sessionInfo, device, deviceProfileOpt);
+    }
+
+    @Override
+    public void onDeviceDeleted(DeviceId deviceId) {
+        context.onAuthFailure(address);
+        ChannelHandlerContext ctx = deviceSessionCtx.getChannel();
+        ctx.close();
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp;
+
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.handler.codec.haproxy.HAProxyMessageDecoder;
+import io.netty.handler.codec.mqtt.MqttDecoder;
+import io.netty.handler.codec.mqtt.MqttEncoder;
+import io.netty.handler.codec.string.StringDecoder;
+import io.netty.handler.codec.string.StringEncoder;
+import io.netty.handler.ssl.SslHandler;
+import org.thingsboard.server.transport.tcp.limits.IpFilter;
+import org.thingsboard.server.transport.tcp.limits.ProxyIpFilter;
+
+/**
+ * @author Andrew Shvayka
+ */
+public class TcpTransportServerInitializer extends ChannelInitializer<SocketChannel> {
+
+    private final TcpTransportContext context;
+    private final boolean sslEnabled;
+
+    public TcpTransportServerInitializer(TcpTransportContext context, boolean sslEnabled) {
+        this.context = context;
+        this.sslEnabled = sslEnabled;
+    }
+
+    @Override
+    public void initChannel(SocketChannel ch) {
+        ChannelPipeline pipeline = ch.pipeline();
+        SslHandler sslHandler = null;
+        if (context.isProxyEnabled()) {
+            pipeline.addLast("proxy", new HAProxyMessageDecoder());
+            pipeline.addLast("ipFilter", new ProxyIpFilter(context));
+        } else {
+            pipeline.addLast("ipFilter", new IpFilter(context));
+        }
+        if (sslEnabled && context.getSslHandlerProvider() != null) {
+            sslHandler = context.getSslHandlerProvider().getSslHandler();
+            pipeline.addLast(sslHandler);
+        }
+//        pipeline.addLast("decoder", new StringDecoder());
+//        pipeline.addLast("encoder", new StringEncoder());
+
+        TcpTransportHandler handler = new TcpTransportHandler(context, sslHandler);
+
+        pipeline.addLast(handler);
+        ch.closeFuture().addListener(handler);
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.util.AttributeKey;
+import io.netty.util.ResourceLeakDetector;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.DataConstants;
+import org.thingsboard.server.common.data.TbTransportService;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.net.InetSocketAddress;
+
+/**
+ * @author Andrew Shvayka
+ */
+@Service("TcpTransportService")
+@ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.tcp.enabled}'=='true')")
+@Slf4j
+public class TcpTransportService implements TbTransportService {
+
+    public static AttributeKey<InetSocketAddress> ADDRESS = AttributeKey.newInstance("TCP_SRC_ADDRESS");
+
+    @Value("${transport.tcp.bind_address}")
+    private String host;
+    @Value("${transport.tcp.bind_port}")
+    private Integer port;
+
+    @Value("${transport.tcp.ssl.enabled}")
+    private boolean sslEnabled;
+
+    @Value("${transport.tcp.ssl.bind_address}")
+    private String sslHost;
+    @Value("${transport.tcp.ssl.bind_port}")
+    private Integer sslPort;
+
+    @Value("${transport.tcp.netty.leak_detector_level}")
+    private String leakDetectorLevel;
+    @Value("${transport.tcp.netty.boss_group_thread_count}")
+    private Integer bossGroupThreadCount;
+    @Value("${transport.tcp.netty.worker_group_thread_count}")
+    private Integer workerGroupThreadCount;
+    @Value("${transport.tcp.netty.so_keep_alive}")
+    private boolean keepAlive;
+
+    @Autowired
+    private TcpTransportContext context;
+
+    private Channel serverChannel;
+    private Channel sslServerChannel;
+    private EventLoopGroup bossGroup;
+    private EventLoopGroup workerGroup;
+
+    @PostConstruct
+    public void init() throws Exception {
+        log.info("Setting resource leak detector level to {}", leakDetectorLevel);
+        ResourceLeakDetector.setLevel(ResourceLeakDetector.Level.valueOf(leakDetectorLevel.toUpperCase()));
+
+        log.info("Starting TCP transport...");
+        bossGroup = new NioEventLoopGroup(bossGroupThreadCount);
+        workerGroup = new NioEventLoopGroup(workerGroupThreadCount);
+        ServerBootstrap b = new ServerBootstrap();
+        b.group(bossGroup, workerGroup)
+                .channel(NioServerSocketChannel.class)
+                .childHandler(new TcpTransportServerInitializer(context, false))
+                .childOption(ChannelOption.SO_KEEPALIVE, keepAlive);
+
+        serverChannel = b.bind(host, port).sync().channel();
+        if (sslEnabled) {
+            b = new ServerBootstrap();
+            b.group(bossGroup, workerGroup)
+                    .channel(NioServerSocketChannel.class)
+                    .childHandler(new TcpTransportServerInitializer(context, true))
+                    .childOption(ChannelOption.SO_KEEPALIVE, keepAlive);
+            sslServerChannel = b.bind(sslHost, sslPort).sync().channel();
+        }
+        log.info("TCP transport started!");
+    }
+
+    @PreDestroy
+    public void shutdown() throws InterruptedException {
+        log.info("Stopping TCP transport!");
+        try {
+            serverChannel.close().sync();
+            if (sslEnabled) {
+                sslServerChannel.close().sync();
+            }
+        } finally {
+            workerGroup.shutdownGracefully();
+            bossGroup.shutdownGracefully();
+        }
+        log.info("TCP transport stopped!");
+    }
+
+    @Override
+    public String getName() {
+        return DataConstants.TCP_TRANSPORT_NAME;
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.adaptors;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.JsonSyntaxException;
+import io.netty.buffer.ByteBuf;
+import io.netty.handler.codec.mqtt.MqttFixedHeader;
+import io.netty.handler.codec.mqtt.MqttMessage;
+import io.netty.handler.codec.mqtt.MqttPublishMessage;
+import io.netty.handler.codec.mqtt.MqttPublishVariableHeader;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.data.ota.OtaPackageType;
+import org.thingsboard.server.common.transport.adaptor.AdaptorException;
+import org.thingsboard.server.common.transport.adaptor.JsonConverter;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.common.yunteng.script.YtScriptInvokeService;
+import org.thingsboard.server.common.yunteng.script.YtScriptType;
+import org.thingsboard.server.transport.tcp.session.DeviceSessionCtx;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+
+import static org.thingsboard.server.common.data.device.profile.MqttTopics.DEVICE_SOFTWARE_FIRMWARE_RESPONSES_TOPIC_FORMAT;
+
+
+/**
+ * @author Andrew Shvayka
+ */
+@Component
+@Slf4j
+public class JsonTcpAdaptor implements TcpTransportAdaptor {
+
+    protected static final Charset UTF8 = StandardCharsets.UTF_8;
+    @Autowired
+    private YtScriptInvokeService jsEngine;
+    private static final JsonParser parser = new JsonParser();
+    @Override
+    public TransportProtos.PostTelemetryMsg convertToPostTelemetry(DeviceSessionCtx ctx, String inbound) throws AdaptorException {
+        try {
+            JsonElement payload = validatePayload(ctx, inbound, false);
+            return JsonConverter.convertToTelemetryProto(payload);
+        } catch (IllegalStateException | JsonSyntaxException ex) {
+            log.debug("Failed to decode post telemetry request", ex);
+            throw new AdaptorException(ex);
+        } catch (ExecutionException e) {
+            throw new RuntimeException(e);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public UUID getJsScriptEngineFunctionId(String scriptBody, String... argNames) throws ExecutionException, InterruptedException {
+        return jsEngine.eval(YtScriptType.TCP_TRANSPORT_SCRIPT, scriptBody, argNames).get();
+    }
+
+    @Override
+    public TransportProtos.PostAttributeMsg convertToPostAttributes(DeviceSessionCtx ctx, MqttPublishMessage inbound) throws AdaptorException {
+        String payload = validatePayload(ctx.getSessionId(), inbound.payload(), false);
+        try {
+            return JsonConverter.convertToAttributesProto(new JsonParser().parse(payload));
+        } catch (IllegalStateException | JsonSyntaxException ex) {
+            log.debug("Failed to decode post attributes request", ex);
+            throw new AdaptorException(ex);
+        }
+    }
+
+    @Override
+    public TransportProtos.ClaimDeviceMsg convertToClaimDevice(DeviceSessionCtx ctx, MqttPublishMessage inbound) throws AdaptorException {
+        String payload = validatePayload(ctx.getSessionId(), inbound.payload(), true);
+        try {
+            return JsonConverter.convertToClaimDeviceProto(ctx.getDeviceId(), payload);
+        } catch (IllegalStateException | JsonSyntaxException ex) {
+            log.debug("Failed to decode claim device request", ex);
+            throw new AdaptorException(ex);
+        }
+    }
+
+    @Override
+    public TransportProtos.ProvisionDeviceRequestMsg convertToProvisionRequestMsg(DeviceSessionCtx ctx, MqttPublishMessage inbound) throws AdaptorException {
+        String payload = validatePayload(ctx.getSessionId(), inbound.payload(), false);
+        try {
+            return JsonConverter.convertToProvisionRequestMsg(payload);
+        } catch (IllegalStateException | JsonSyntaxException ex) {
+            throw new AdaptorException(ex);
+        }
+    }
+
+    @Override
+    public TransportProtos.GetAttributeRequestMsg convertToGetAttributes(DeviceSessionCtx ctx, MqttPublishMessage inbound, String topicBase) throws AdaptorException {
+        return processGetAttributeRequestMsg(inbound, topicBase);
+    }
+
+    @Override
+    public TransportProtos.ToDeviceRpcResponseMsg convertToDeviceRpcResponse(DeviceSessionCtx ctx, MqttPublishMessage inbound, String topicBase) throws AdaptorException {
+        return processToDeviceRpcResponseMsg(inbound, topicBase);
+    }
+
+    @Override
+    public TransportProtos.ToServerRpcRequestMsg convertToServerRpcRequest(DeviceSessionCtx ctx, MqttPublishMessage inbound, String topicBase) throws AdaptorException {
+        return processToServerRpcRequestMsg(ctx, inbound, topicBase);
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, TransportProtos.GetAttributeResponseMsg responseMsg, String topicBase) throws AdaptorException {
+        return processConvertFromAttributeResponseMsg(ctx, responseMsg, topicBase);
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(DeviceSessionCtx ctx, String deviceName, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+        return processConvertFromGatewayAttributeResponseMsg(ctx, deviceName, responseMsg);
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, TransportProtos.AttributeUpdateNotificationMsg notificationMsg, String topic) {
+        return Optional.of(createMqttPublishMsg(ctx, topic, JsonConverter.toJson(notificationMsg)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(DeviceSessionCtx ctx, String deviceName, TransportProtos.AttributeUpdateNotificationMsg notificationMsg) {
+        JsonObject result = JsonConverter.getJsonObjectForGateway(deviceName, notificationMsg);
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_ATTRIBUTES_TOPIC, result));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, TransportProtos.ToDeviceRpcRequestMsg rpcRequest, String topicBase) {
+        return Optional.of(createMqttPublishMsg(ctx, topicBase + rpcRequest.getRequestId(), JsonConverter.toJson(rpcRequest, false)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToGatewayPublish(DeviceSessionCtx ctx, String deviceName, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_RPC_TOPIC, JsonConverter.toGatewayJson(deviceName, rpcRequest)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, TransportProtos.ToServerRpcResponseMsg rpcResponse, String topicBase) {
+        return Optional.of(createMqttPublishMsg(ctx, topicBase + rpcResponse.getRequestId(), JsonConverter.toJson(rpcResponse)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, TransportProtos.ProvisionDeviceResponseMsg provisionResponse) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_PROVISION_RESPONSE_TOPIC, JsonConverter.toJson(provisionResponse)));
+    }
+
+    @Override
+    public Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, byte[] firmwareChunk, String requestId, int chunk, OtaPackageType firmwareType) {
+        return Optional.of(createMqttPublishMsg(ctx, String.format(DEVICE_SOFTWARE_FIRMWARE_RESPONSES_TOPIC_FORMAT, firmwareType.getKeyPrefix(), requestId, chunk), firmwareChunk));
+    }
+
+    public static JsonElement validateJsonPayload(UUID sessionId, ByteBuf payloadData) throws AdaptorException {
+        String payload = validatePayload(sessionId, payloadData, false);
+        try {
+            return new JsonParser().parse(payload);
+        } catch (JsonSyntaxException ex) {
+            log.debug("Payload is in incorrect format: {}", payload);
+            throw new AdaptorException(ex);
+        }
+    }
+
+    private TransportProtos.GetAttributeRequestMsg processGetAttributeRequestMsg(MqttPublishMessage inbound, String topicBase) throws AdaptorException {
+        String topicName = inbound.variableHeader().topicName();
+        try {
+            TransportProtos.GetAttributeRequestMsg.Builder result = TransportProtos.GetAttributeRequestMsg.newBuilder();
+            result.setRequestId(getRequestId(topicName, topicBase));
+            String payload = inbound.payload().toString(UTF8);
+            JsonElement requestBody = new JsonParser().parse(payload);
+            Set<String> clientKeys = toStringSet(requestBody, "clientKeys");
+            Set<String> sharedKeys = toStringSet(requestBody, "sharedKeys");
+            if (clientKeys != null) {
+                result.addAllClientAttributeNames(clientKeys);
+            }
+            if (sharedKeys != null) {
+                result.addAllSharedAttributeNames(sharedKeys);
+            }
+            return result.build();
+        } catch (RuntimeException e) {
+            log.debug("Failed to decode get attributes request", e);
+            throw new AdaptorException(e);
+        }
+    }
+
+    private TransportProtos.ToDeviceRpcResponseMsg processToDeviceRpcResponseMsg(MqttPublishMessage inbound, String topicBase) throws AdaptorException {
+        String topicName = inbound.variableHeader().topicName();
+        try {
+            int requestId = getRequestId(topicName, topicBase);
+            String payload = inbound.payload().toString(UTF8);
+            return TransportProtos.ToDeviceRpcResponseMsg.newBuilder().setRequestId(requestId).setPayload(payload).build();
+        } catch (RuntimeException e) {
+            log.debug("Failed to decode rpc response", e);
+            throw new AdaptorException(e);
+        }
+    }
+
+    private TransportProtos.ToServerRpcRequestMsg processToServerRpcRequestMsg(DeviceSessionCtx ctx, MqttPublishMessage inbound, String topicBase) throws AdaptorException {
+        String topicName = inbound.variableHeader().topicName();
+        String payload = validatePayload(ctx.getSessionId(), inbound.payload(), false);
+        try {
+            int requestId = getRequestId(topicName, topicBase);
+            return JsonConverter.convertToServerRpcRequest(new JsonParser().parse(payload), requestId);
+        } catch (IllegalStateException | JsonSyntaxException ex) {
+            log.debug("Failed to decode to server rpc request", ex);
+            throw new AdaptorException(ex);
+        }
+    }
+
+    private Optional<MqttMessage> processConvertFromAttributeResponseMsg(DeviceSessionCtx ctx, TransportProtos.GetAttributeResponseMsg responseMsg, String topicBase) throws AdaptorException {
+        if (!StringUtils.isEmpty(responseMsg.getError())) {
+            throw new AdaptorException(responseMsg.getError());
+        } else {
+            int requestId = responseMsg.getRequestId();
+            if (requestId >= 0) {
+                return Optional.of(createMqttPublishMsg(ctx,
+                        topicBase + requestId,
+                        JsonConverter.toJson(responseMsg)));
+            }
+            return Optional.empty();
+        }
+    }
+
+    private Optional<MqttMessage> processConvertFromGatewayAttributeResponseMsg(DeviceSessionCtx ctx, String deviceName, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
+        if (!StringUtils.isEmpty(responseMsg.getError())) {
+            throw new AdaptorException(responseMsg.getError());
+        } else {
+            JsonObject result = JsonConverter.getJsonObjectForGateway(deviceName, responseMsg);
+            return Optional.of(createMqttPublishMsg(ctx, MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC, result));
+        }
+    }
+
+    protected MqttPublishMessage createMqttPublishMsg(DeviceSessionCtx ctx, String topic, JsonElement json) {
+        MqttFixedHeader mqttFixedHeader = null;
+//                new MqttFixedHeader(MqttMessageType.PUBLISH, false, ctx.getQoSForTopic(topic), false, 0);
+        MqttPublishVariableHeader header = new MqttPublishVariableHeader(topic, ctx.nextMsgId());
+        ByteBuf payload = ALLOCATOR.buffer();
+        payload.writeBytes(json.toString().getBytes(UTF8));
+        return new MqttPublishMessage(mqttFixedHeader, header, payload);
+    }
+
+    private Set<String> toStringSet(JsonElement requestBody, String name) {
+        JsonElement element = requestBody.getAsJsonObject().get(name);
+        if (element != null) {
+            return new HashSet<>(Arrays.asList(element.getAsString().split(",")));
+        } else {
+            return null;
+        }
+    }
+
+    private static String validatePayload(UUID sessionId, ByteBuf payloadData, boolean isEmptyPayloadAllowed) throws AdaptorException {
+        String payload = payloadData.toString(UTF8);
+        if (payload == null) {
+            log.debug("[{}] Payload is empty!", sessionId);
+            if (!isEmptyPayloadAllowed) {
+                throw new AdaptorException(new IllegalArgumentException("Payload is empty!"));
+            }
+        }
+        return payload;
+    }
+
+    private JsonElement validatePayload(DeviceSessionCtx session, String payload, boolean isEmptyPayloadAllowed) throws AdaptorException, ExecutionException, InterruptedException {
+        if (payload == null) {
+            log.debug("[{}] Payload is empty!", session.getSessionId());
+            if (!isEmptyPayloadAllowed) {
+                throw new AdaptorException(new IllegalArgumentException("Payload is empty!"));
+            }
+        }
+//        jsEngine.invokeFunction();
+//        new JsonParser().parse(payload)
+//        return payload;
+        ListenableFuture<JsonElement> result = Futures.transformAsync(jsEngine.invokeFunction(session.getScriptId(), payload),
+                o -> {
+                    try {
+                        return Futures.immediateFuture(parser.parse(o.toString()));
+                    } catch (Exception e) {
+                        return Futures.immediateFailedFuture(e);
+                    }
+                }, MoreExecutors.directExecutor());
+
+        return result.get();
+    }
+
+    private int getRequestId(String topicName, String topic) {
+        return Integer.parseInt(topicName.substring(topic.length()));
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.adaptors;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.mqtt.MqttFixedHeader;
+import io.netty.handler.codec.mqtt.MqttMessage;
+import io.netty.handler.codec.mqtt.MqttMessageType;
+import io.netty.handler.codec.mqtt.MqttPublishMessage;
+import io.netty.handler.codec.mqtt.MqttPublishVariableHeader;
+import org.thingsboard.server.common.data.ota.OtaPackageType;
+import org.thingsboard.server.common.transport.adaptor.AdaptorException;
+import org.thingsboard.server.gen.transport.TransportProtos.AttributeUpdateNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ClaimDeviceMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.PostAttributeMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.PostTelemetryMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToDeviceRpcRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToDeviceRpcResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToServerRpcRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToServerRpcResponseMsg;
+import org.thingsboard.server.transport.tcp.session.DeviceSessionCtx;
+
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * @author Andrew Shvayka
+ */
+public interface TcpTransportAdaptor {
+
+    ByteBufAllocator ALLOCATOR = new UnpooledByteBufAllocator(false);
+
+    PostTelemetryMsg convertToPostTelemetry(DeviceSessionCtx ctx, String inbound) throws AdaptorException;
+
+    UUID getJsScriptEngineFunctionId(String scriptBody, String... argNames) throws ExecutionException, InterruptedException;
+    PostAttributeMsg convertToPostAttributes(DeviceSessionCtx ctx, MqttPublishMessage inbound) throws AdaptorException;
+
+    GetAttributeRequestMsg convertToGetAttributes(DeviceSessionCtx ctx, MqttPublishMessage inbound, String topicBase) throws AdaptorException;
+
+    ToDeviceRpcResponseMsg convertToDeviceRpcResponse(DeviceSessionCtx ctx, MqttPublishMessage mqttMsg, String topicBase) throws AdaptorException;
+
+    ToServerRpcRequestMsg convertToServerRpcRequest(DeviceSessionCtx ctx, MqttPublishMessage mqttMsg, String topicBase) throws AdaptorException;
+
+    ClaimDeviceMsg convertToClaimDevice(DeviceSessionCtx ctx, MqttPublishMessage inbound) throws AdaptorException;
+
+    Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, GetAttributeResponseMsg responseMsg, String topicBase) throws AdaptorException;
+
+    Optional<MqttMessage> convertToGatewayPublish(DeviceSessionCtx ctx, String deviceName, GetAttributeResponseMsg responseMsg) throws AdaptorException;
+
+    Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, AttributeUpdateNotificationMsg notificationMsg, String topic) throws AdaptorException;
+
+    Optional<MqttMessage> convertToGatewayPublish(DeviceSessionCtx ctx, String deviceName, AttributeUpdateNotificationMsg notificationMsg) throws AdaptorException;
+
+    Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, ToDeviceRpcRequestMsg rpcRequest, String topicBase) throws AdaptorException;
+
+    Optional<MqttMessage> convertToGatewayPublish(DeviceSessionCtx ctx, String deviceName, ToDeviceRpcRequestMsg rpcRequest) throws AdaptorException;
+
+    Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, ToServerRpcResponseMsg rpcResponse, String topicBase) throws AdaptorException;
+
+    ProvisionDeviceRequestMsg convertToProvisionRequestMsg(DeviceSessionCtx ctx, MqttPublishMessage inbound) throws AdaptorException;
+
+    Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, ProvisionDeviceResponseMsg provisionResponse) throws AdaptorException;
+
+    Optional<MqttMessage> convertToPublish(DeviceSessionCtx ctx, byte[] firmwareChunk, String requestId, int chunk, OtaPackageType firmwareType) throws AdaptorException;
+
+    default MqttPublishMessage createMqttPublishMsg(DeviceSessionCtx ctx, String topic, byte[] payloadInBytes) {
+        MqttFixedHeader mqttFixedHeader =null;
+//                new MqttFixedHeader(MqttMessageType.PUBLISH, false, ctx.getQoSForTopic(topic), false, 0);
+        MqttPublishVariableHeader header = new MqttPublishVariableHeader(topic, ctx.nextMsgId());
+        ByteBuf payload = ALLOCATOR.buffer();
+        payload.writeBytes(payloadInBytes);
+        return new MqttPublishMessage(mqttFixedHeader, header, payload);
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.limits;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.ipfilter.AbstractRemoteAddressFilter;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.transport.tcp.TcpTransportContext;
+import org.thingsboard.server.transport.tcp.TcpTransportService;
+
+import java.net.InetSocketAddress;
+
+@Slf4j
+public class IpFilter extends AbstractRemoteAddressFilter<InetSocketAddress> {
+
+    private TcpTransportContext context;
+
+    public IpFilter(TcpTransportContext context) {
+        this.context = context;
+    }
+
+    @Override
+    protected boolean accept(ChannelHandlerContext ctx, InetSocketAddress remoteAddress) throws Exception {
+        log.trace("[{}] Received msg: {}", ctx.channel().id(), remoteAddress);
+        if(context.checkAddress(remoteAddress)){
+            log.trace("[{}] Setting address: {}", ctx.channel().id(), remoteAddress);
+            ctx.channel().attr(TcpTransportService.ADDRESS).set(remoteAddress);
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.limits;
+
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.codec.haproxy.HAProxyMessage;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.transport.tcp.TcpTransportContext;
+import org.thingsboard.server.transport.tcp.TcpTransportService;
+
+import java.net.InetSocketAddress;
+
+@Slf4j
+public class ProxyIpFilter extends ChannelInboundHandlerAdapter {
+
+
+    private TcpTransportContext context;
+
+    public ProxyIpFilter(TcpTransportContext context) {
+        this.context = context;
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        log.trace("[{}] Received msg: {}", ctx.channel().id(), msg);
+        if (msg instanceof HAProxyMessage) {
+            HAProxyMessage proxyMsg = (HAProxyMessage) msg;
+            if (proxyMsg.sourceAddress() != null && proxyMsg.sourcePort() > 0) {
+                InetSocketAddress address = new InetSocketAddress(proxyMsg.sourceAddress(), proxyMsg.sourcePort());
+                if (!context.checkAddress(address)) {
+                    closeChannel(ctx);
+                } else {
+                    log.trace("[{}] Setting address: {}", ctx.channel().id(), address);
+                    ctx.channel().attr(TcpTransportService.ADDRESS).set(address);
+                    // We no longer need this channel in the pipeline. Similar to HAProxyMessageDecoder
+                    ctx.pipeline().remove(this);
+                }
+            } else {
+                log.trace("Received local health-check connection message: {}", proxyMsg);
+                closeChannel(ctx);
+            }
+        }
+    }
+
+    private void closeChannel(ChannelHandlerContext ctx) {
+        while (ctx.pipeline().last() != this) {
+            ChannelHandler handler = ctx.pipeline().removeLast();
+            if (handler instanceof ChannelInboundHandlerAdapter) {
+                try {
+                    ((ChannelInboundHandlerAdapter) handler).channelUnregistered(ctx);
+                } catch (Exception e) {
+                    log.error("Failed to unregister channel: [{}]", ctx, e);
+                }
+            }
+
+        }
+        ctx.pipeline().remove(this);
+        ctx.close();
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.session;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.util.ReferenceCountUtil;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.device.profile.DeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.device.profile.YtTcpDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.yunteng.enums.TcpDataTypeEnum;
+import org.thingsboard.server.common.transport.session.DeviceAwareSessionContext;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.transport.tcp.TcpTransportContext;
+import org.thingsboard.server.transport.tcp.adaptors.TcpTransportAdaptor;
+import org.thingsboard.server.transport.tcp.util.ByteUtils;
+
+import java.util.UUID;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Consumer;
+
+/**
+ * @author Andrew Shvayka
+ */
+@Slf4j
+public class DeviceSessionCtx extends DeviceAwareSessionContext {
+
+    @Getter
+    @Setter
+    private ChannelHandlerContext channel;
+
+    @Getter
+    private final TcpTransportContext context;
+
+    private final AtomicInteger msgIdSeq = new AtomicInteger(0);
+
+    private final ConcurrentLinkedQueue<TCPMessage> msgQueue = new ConcurrentLinkedQueue<>();
+
+    @Getter
+    private final Lock msgQueueProcessorLock = new ReentrantLock();
+
+    private final AtomicInteger msgQueueSize = new AtomicInteger(0);
+
+    @Getter
+    @Setter
+    private boolean provisionOnly = false;
+
+    //    private volatile TcpTopicFilter telemetryTopicFilter = MqttTopicFilterFactory.getDefaultTelemetryFilter();
+//    private volatile TcpTopicFilter attributesTopicFilter = MqttTopicFilterFactory.getDefaultAttributesFilter();
+    @Getter
+    private volatile TcpDataTypeEnum payloadType = TcpDataTypeEnum.HEX;
+    @Getter
+    private volatile byte[] pingText ;
+    //    private volatile Descriptors.Descriptor attributesDynamicMessageDescriptor;
+//    private volatile Descriptors.Descriptor telemetryDynamicMessageDescriptor;
+//    private volatile Descriptors.Descriptor rpcResponseDynamicMessageDescriptor;
+//    private volatile DynamicMessage.Builder rpcRequestDynamicMessageBuilder;
+    private volatile TcpTransportAdaptor adaptor;
+    @Getter
+    private UUID scriptId;
+
+    public DeviceSessionCtx(UUID sessionId, TcpTransportContext context) {
+        super(sessionId);
+        this.context = context;
+        this.adaptor = context.getJsonTcpAdaptor();
+    }
+
+    public int nextMsgId() {
+        return msgIdSeq.incrementAndGet();
+    }
+
+
+    public TcpTransportAdaptor getPayloadAdaptor() {
+        return adaptor;
+    }
+
+
+
+
+    @Override
+    public void setDeviceProfile(DeviceProfile deviceProfile) {
+        super.setDeviceProfile(deviceProfile);
+        updateDeviceSessionConfiguration(deviceProfile);
+    }
+
+    @Override
+    public void onDeviceProfileUpdate(TransportProtos.SessionInfoProto sessionInfo, DeviceProfile deviceProfile) {
+        super.onDeviceProfileUpdate(sessionInfo, deviceProfile);
+        updateDeviceSessionConfiguration(deviceProfile);
+    }
+
+    private void updateDeviceSessionConfiguration(DeviceProfile deviceProfile){
+        DeviceProfileTransportConfiguration transportConfiguration = deviceProfile.getProfileData().getTransportConfiguration();
+
+        YtTcpDeviceProfileTransportConfiguration tcpConfiguration = (YtTcpDeviceProfileTransportConfiguration) transportConfiguration;
+        payloadType = tcpConfiguration.getDataFormat();
+        if (TcpDataTypeEnum.ASCII.equals(payloadType)) {
+            payloadType = TcpDataTypeEnum.ASCII;
+        } else {
+            payloadType = TcpDataTypeEnum.HEX;
+        }
+        this.pingText = ByteUtils.getBytes(tcpConfiguration.getPingText(),ByteUtils.UTF_8);
+        String scriptBody = tcpConfiguration.getScriptText();
+        try {
+            this.scriptId = this.adaptor.getJsScriptEngineFunctionId(scriptBody);
+        } catch (ExecutionException e) {
+            log.warn("设备配置【{}】的脚本【{}】解析异常",deviceProfile.getSearchText(),scriptBody);
+            throw new RuntimeException(e);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+
+
+
+
+    public void addToQueue(TCPMessage msg) {
+        msgQueueSize.incrementAndGet();
+        ReferenceCountUtil.retain(msg);
+        msgQueue.add(msg);
+    }
+
+    public void tryProcessQueuedMsgs(Consumer<TCPMessage> msgProcessor) {
+        while (!msgQueue.isEmpty()) {
+            if (msgQueueProcessorLock.tryLock()) {
+                try {
+                    TCPMessage msg;
+                    while ((msg = msgQueue.poll()) != null) {
+                        try {
+                            msgQueueSize.decrementAndGet();
+                            msgProcessor.accept(msg);
+                        } finally {
+                            ReferenceCountUtil.safeRelease(msg);
+                        }
+                    }
+                } finally {
+                    msgQueueProcessorLock.unlock();
+                }
+            } else {
+                return;
+            }
+        }
+    }
+
+    public int getMsgQueueSize() {
+        return msgQueueSize.get();
+    }
+
+    public void release() {
+        if (!msgQueue.isEmpty()) {
+            log.warn("doDisconnect for device {} but unprocessed messages {} left in the msg queue", getDeviceId(), msgQueue.size());
+            msgQueue.forEach(ReferenceCountUtil::safeRelease);
+            msgQueue.clear();
+        }
+    }
+
+
+}

+package org.thingsboard.server.transport.tcp.session;
+
+import io.netty.handler.codec.mqtt.MqttMessageType;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.ToString;
+
+import java.io.Serializable;
+
+@Data
+public class TCPMessage implements Serializable {
+    private String requestId;
+    private MqttMessageType messageType;
+
+    private byte[] message;
+    private boolean hex;
+
+    private String deviceId;
+
+    /**
+     *  TCP 消息
+     * @param sn 设备sn
+     * @param message 消息体
+     * @param hex 是否是16进制
+     */
+    public TCPMessage(MqttMessageType messageType, String deviceId, byte[] message, boolean hex){
+        this.messageType = messageType;
+        this.deviceId = deviceId;
+        this.message = message;
+        this.hex = hex;
+    }
+
+    public TCPMessage(MqttMessageType messageType,  byte[] message){
+        this.messageType = messageType;
+        this.message = message;
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.util;
+
+import lombok.Data;
+
+@Data
+public class AlwaysTrueTopicFilter implements TcpTopicFilter {
+
+    @Override
+    public boolean filter(String topic) {
+        return true;
+    }
+}

+package org.thingsboard.server.transport.tcp.util;
+
+import io.netty.buffer.ByteBuf;
+import org.apache.commons.lang3.ArrayUtils;
+
+import java.io.*;
+import java.nio.charset.Charset;
+
+/**
+ * @Description :数据类型转换工具类
+ * 二进制的最高位是符号位，0表示正，1表示负。
+ * 负数采用二进制的补码表示，10进制转为二进制得到的是源码，将源码按位取反得到的是反码，反码加1得到补码
+ *
+ *
+ * *￥￥￥【基本数据类型】￥￥￥￥￥￥￥￥￥￥￥￥
+        1/8：boolean【1 位】
+        3/8：byte   【1个字节，8 位】
+        3/8：short  【2个字节，16位】
+        4/8：int    【4个字节，32位】
+        5/8：long   【8个字节，64位】
+        6/8：float  【4个字节，32位】
+        7/8：double 【8个字节，64位】
+        8/8：chart  【2个字节，16位】
+ *
+ *
+ *
+ * *￥￥￥【位运算】￥￥￥￥￥￥￥￥￥￥￥￥
+    左移【<< n】：向左移动，左边高位舍弃，右边的低位补0，例如：2左移3位，结果为16
+    右移【>>n】：向右移动，右边的舍弃掉，左边补的值取决于原来最高位，原来是1就补1，原来是0就补0
+    无符号右移【>>>n】向右移动，右边的舍弃掉，左边补0。
+ *
+ *
+ *
+ * 1.其它地方抛出异常，交由控制层统一处理
+ * 2.服务层注意持久化的事务管理
+ * @Author: junlianglee
+ * @Date Created in 2019/12/11.
+ * @Modified by Administrator on 2019/12/11.
+ */
+public class ByteUtils {
+    public static final char[] ascii = "0123456789ABCDEF".toCharArray();
+    private static char[] HEX_VOCABLE = {'0', '1', '2', '3', '4', '5', '6', '7',
+            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+    public static final String UTF_8 = "UTF-8";
+    /**
+     * 将short整型数值转换为字节数组
+     *
+     * @param data
+     * @return
+     */
+    public static byte[] getBytes(short data) {
+        byte[] bytes = new byte[2];
+        bytes[0] = (byte) ((data & 0xff00) >> 8);//1个十六进制位匹配4个二进制位
+        bytes[1] = (byte) (data & 0xff);
+        return bytes;
+    }
+
+    /**
+     * 将字符转换为字节数组
+     *
+     * @param data
+     * @return
+     */
+    public static byte[] getBytes(char data) {
+        byte[] bytes = new byte[2];
+        bytes[0] = (byte) (data >> 8);
+        bytes[1] = (byte) (data);
+        return bytes;
+    }
+
+    /**
+     * 将布尔值转换为字节数组
+     *
+     * @param data
+     * @return
+     */
+    public static byte[] getBytes(boolean data) {
+        byte[] bytes = new byte[1];
+        bytes[0] = (byte) (data ? 1 : 0);
+        return bytes;
+    }
+
+    /**
+     * 将整型数值转换为字节数组
+     *
+     * @param data
+     * @return
+     */
+    public static byte[] getBytes(int data) {
+        byte[] bytes = new byte[4];
+        bytes[0] = (byte) ((data & 0xff000000) >> 24);
+        bytes[1] = (byte) ((data & 0xff0000) >> 16);
+        bytes[2] = (byte) ((data & 0xff00) >> 8);
+        bytes[3] = (byte) (data & 0xff);
+        return bytes;
+    }
+
+    /**
+     * 将long整型数值转换为字节数组
+     *
+     * @param data
+     * @return
+     */
+    public static byte[] getBytes(long data) {
+        byte[] bytes = new byte[8];
+        bytes[0] = (byte) ((data >> 56) & 0xff);
+        bytes[1] = (byte) ((data >> 48) & 0xff);
+        bytes[2] = (byte) ((data >> 40) & 0xff);
+        bytes[3] = (byte) ((data >> 32) & 0xff);
+        bytes[4] = (byte) ((data >> 24) & 0xff);
+        bytes[5] = (byte) ((data >> 16) & 0xff);
+        bytes[6] = (byte) ((data >> 8) & 0xff);
+        bytes[7] = (byte) (data & 0xff);
+        return bytes;
+    }
+
+    /**
+     * 将float型数值转换为字节数组
+     *
+     * @param data
+     * @return
+     */
+    public static byte[] getBytes(float data) {
+        int intBits = Float.floatToIntBits(data);
+        return getBytes(intBits);
+    }
+
+    /**
+     * 将double型数值转换为字节数组
+     *
+     * @param data
+     * @return
+     */
+    public static byte[] getBytes(double data) {
+        long intBits = Double.doubleToLongBits(data);
+        return getBytes(intBits);
+    }
+
+    /**
+     * 将字符串按照charsetName编码格式的字节数组
+     *
+     * @param data
+     *            字符串
+     * @param charsetName
+     *            编码格式
+     * @return
+     */
+    public static byte[] getBytes(String data, String charsetName) {
+        Charset charset = Charset.forName(charsetName);
+        return data.getBytes(charset);
+    }
+
+
+
+
+
+    /**
+     * 将字节数组前8字节转换为long整型数值
+     *
+     * @param bytes
+     * @return
+     */
+    public static long getLong(byte[] bytes) {
+        return (0xff00000000000000L & ((long) bytes[0] << 56)
+                | (0xff000000000000L & ((long) bytes[1] << 48))
+                | (0xff0000000000L & ((long) bytes[2] << 40))
+                | (0xff00000000L & ((long) bytes[3] << 32))
+                | (0xff000000L & ((long) bytes[4] << 24))
+                | (0xff0000L & ((long) bytes[5] << 16))
+                | (0xff00L & ((long) bytes[6] << 8))
+                | (0xffL & (long) bytes[7]));
+    }
+
+
+
+    /**
+     * 将charsetName编码格式的字节数组转换为字符串
+     *
+     * @param bytes
+     * @param charsetName
+     * @return
+     */
+    public static String getString(byte[] bytes, String charsetName) {
+        return new String(bytes, Charset.forName(charsetName));
+    }
+
+
+    public static byte[] hexStr2Bytes(String hexString) {
+        if (hexString == null || hexString.equals("")) {
+            return null;
+        }
+        // toUpperCase将字符串中的所有字符转换为大写
+        hexString = hexString.toUpperCase();
+        int length = hexString.length() / 2;// 2个16进制字符表示一个字节，所以字节数组长度是字符串长度除以2
+        // toCharArray将此字符串转换为一个新的字符数组。
+        char[] hexChars = hexString.toCharArray();
+        byte[] d = new byte[length];
+        for (int i = 0; i < length; i++) {
+            int pos = i * 2;
+            d[i] = (byte) (charToByte(hexChars[pos]) << 4
+                    | charToByte(hexChars[pos + 1]));
+        }
+        return d;
+    }
+
+    // charToByte返回在指定字符的第一个发生的字符串中的索引，即返回匹配字符
+    private static byte charToByte(char c) {
+        return (byte) "0123456789ABCDEF".indexOf(c);
+    }
+    /**
+     * 将16进制字符串转换为字节数组
+     *
+     * @param hex
+     * @return
+     */
+    public static byte[] hexToBytes(String hex) {
+        if (hex.length() % 2 != 0)
+            throw new IllegalArgumentException(
+                    "input string should be any multiple of 2!");
+        hex.toUpperCase();
+
+        byte[] byteBuffer = new byte[hex.length() / 2];
+
+        byte padding = 0x00;
+        boolean paddingTurning = false;
+        for (int i = 0; i < hex.length(); i++) {
+            if (paddingTurning) {
+                char c = hex.charAt(i);
+                int index = indexOf(hex, c);
+                padding = (byte) ((padding << 4) | index);
+                byteBuffer[i / 2] = padding;
+                padding = 0x00;
+                paddingTurning = false;
+            } else {
+                char c = hex.charAt(i);
+                int index = indexOf(hex, c);
+                padding = (byte) (padding | index);
+                paddingTurning = true;
+            }
+
+        }
+        return byteBuffer;
+    }
+
+    private static int indexOf(String input, char c) {
+        int index = ArrayUtils.indexOf(HEX_VOCABLE, c);
+
+        if (index < 0) {
+            throw new IllegalArgumentException("err input:" + input);
+        }
+        return index;
+
+    }
+    /**
+     * 字节数组转16进制字符串
+     *
+     * @param bs
+     * @return
+     */
+    public static String bytesToHex(byte[] bs) {
+        StringBuilder sb = new StringBuilder();
+        for (byte b : bs) {
+            int high = (b >> 4) & 0x0f;
+            int low = b & 0x0f;
+            sb.append(HEX_VOCABLE[high]);
+            sb.append(HEX_VOCABLE[low]);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * 字节数组取前len个字节转16进制字符串
+     *
+     * @param bs
+     * @param len
+     * @return
+     */
+    public static String bytesToHex(byte[] bs, int len) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < len; i++) {
+            byte b = bs[i];
+            int high = (b >> 4) & 0x0f;
+            int low = b & 0x0f;
+            sb.append(HEX_VOCABLE[high]);
+            sb.append(HEX_VOCABLE[low]);
+        }
+        return sb.toString();
+    }
+    /**
+     * 字节数组偏移offset长度之后的取len个字节转16进制字符串
+     *
+     * @param bs
+     * @param offset
+     * @param len
+     * @return
+     */
+    public static String bytesToHex(byte[] bs, int offset, int len) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < len; i++) {
+            byte b = bs[offset + i];
+            int high = (b >> 4) & 0x0f;
+            int low = b & 0x0f;
+            sb.append(HEX_VOCABLE[high]);
+            sb.append(HEX_VOCABLE[low]);
+        }
+        return sb.toString();
+    }
+    /**
+     * 字节数组转16进制字符串
+     *
+     * @param bs
+     * @return
+     */
+    public static String byteToHex(byte bs) {
+        StringBuilder sb = new StringBuilder();
+        int high = (bs >> 4) & 0x0f;
+        int low = bs & 0x0f;
+        sb.append(HEX_VOCABLE[high]);
+        sb.append(HEX_VOCABLE[low]);
+        return sb.toString();
+    }
+    /**
+     * 将字节数组取反
+     *
+     * @param src
+     * @return
+     */
+    public static String negate(byte[] src) {
+        if (src == null || src.length == 0) {
+            return null;
+        }
+        byte[] temp = new byte[2 * src.length];
+        for (int i = 0; i < src.length; i++) {
+            byte tmp = (byte) (0xFF ^ src[i]);
+            temp[i * 2] = (byte) ((tmp >> 4) & 0x0f);
+            temp[i * 2 + 1] = (byte) (tmp & 0x0f);
+        }
+        StringBuffer res = new StringBuffer();
+        for (int i = 0; i < temp.length; i++) {
+            res.append(ascii[temp[i]]);
+        }
+        return res.toString();
+    }
+
+
+
+    /**
+     * 数组合并
+     * @param before
+     * @param end
+     * @return
+     */
+    public static  byte[] merge(byte[]before,byte[]end){
+        byte[] result= new byte[before.length+end.length];
+        System.arraycopy(before,0,result,0,before.length);
+        System.arraycopy(end,0,result,before.length,end.length);
+        return result;
+    }
+
+    public static  byte[] subBytes(byte[]before,Integer start,Integer length){
+        byte[] result= new byte[length];
+        System.arraycopy(before,start,result,0,length);
+        return result;
+    }
+
+    /**
+     * 比较字节数组是否相同
+     *
+     * @param a
+     * @param b
+     * @return
+     */
+    public static boolean compareBytes(byte[] a, byte[] b) {
+        if (a == null || a.length == 0 || b == null || b.length == 0
+                || a.length != b.length) {
+            return false;
+        }
+        if (a.length == b.length) {
+            for (int i = 0; i < a.length; i++) {
+                if (a[i] != b[i]) {
+                    return false;
+                }
+            }
+        } else {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * 只比对指定长度byte
+     *
+     * @param a
+     * @param b
+     * @param len
+     * @return
+     */
+    public static boolean compareBytes(byte[] a, byte[] b, int len) {
+        if (a == null || a.length == 0 || b == null || b.length == 0
+                || a.length < len || b.length < len) {
+            return false;
+        }
+        for (int i = 0; i < len; i++) {
+            if (a[i] != b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 将字节数组转换为二进制字符串
+     *
+     * @param items
+     * @return
+     */
+    public static String bytesToBinaryString(byte[] items) {
+        if (items == null || items.length == 0) {
+            return null;
+        }
+        StringBuffer buf = new StringBuffer();
+        for (byte item : items) {
+            buf.append(byteToBinaryString(item));
+        }
+        return buf.toString();
+    }
+
+    /**
+     * 将字节转换为二进制字符串
+     *
+     * @param item
+     * @return
+     */
+    public static String byteToBinaryString(byte item) {
+        byte a = item;
+        StringBuffer buf = new StringBuffer();
+        for (int i = 0; i < 8; i++) {
+            buf.insert(0, a % 2);
+            a = (byte) (a >> 1);
+        }
+        return buf.toString();
+    }
+
+    /**
+     * 对数组a，b进行异或运算
+     *
+     * @param a
+     * @param b
+     * @return
+     */
+    public static byte[] xor(byte[] a, byte[] b) {
+        if (a == null || a.length == 0 || b == null || b.length == 0
+                || a.length != b.length) {
+            return null;
+        }
+        byte[] result = new byte[a.length];
+        for (int i = 0; i < a.length; i++) {
+            result[i] = (byte) (a[i] ^ b[i]);
+        }
+        return result;
+    }
+
+    /**
+     * 对数组a，b进行异或运算 运算长度len
+     *
+     * @param a
+     * @param b
+     * @param len
+     * @return
+     */
+    public static byte[] xor(byte[] a, byte[] b, int len) {
+        if (a == null || a.length == 0 || b == null || b.length == 0) {
+            return null;
+        }
+        if (a.length < len || b.length < len) {
+            return null;
+        }
+        byte[] result = new byte[len];
+        for (int i = 0; i < len; i++) {
+            result[i] = (byte) (a[i] ^ b[i]);
+        }
+        return result;
+    }
+    /**
+     * 将short整型数值转换为字节数组
+     *
+     * @param num
+     * @return
+     */
+    public static byte[] shortToBytes(int num) {
+        byte[] temp = new byte[2];
+        for (int i = 0; i < 2; i++) {
+            temp[i] = (byte) ((num >>> (8 - i * 8)) & 0xFF);
+        }
+        return temp;
+    }
+
+    /**
+     * 将字节数组转为整型
+     *
+     * @param arr
+     * @return
+     */
+    public static int bytesToShort(byte[] arr) {
+        int mask = 0xFF;
+        int temp = 0;
+        int result = 0;
+        for (int i = 0; i < 2; i++) {
+            result <<= 8;
+            temp = arr[i] & mask;
+            result |= temp;
+        }
+        return result;
+    }
+
+    /**
+     * 将整型数值转换为指定长度的字节数组
+     *
+     * @param num
+     * @return
+     */
+    public static byte[] intToBytes(int num) {
+        byte[] temp = new byte[4];
+        for (int i = 0; i < 4; i++) {
+            temp[i] = (byte) ((num >>> (24 - i * 8)) & 0xFF);
+        }
+        return temp;
+    }
+
+    /**
+     * 将整型数值转换为指定长度的字节数组
+     *
+     * @param src
+     * @param len
+     * @return
+     */
+    public static byte[] intToBytes(int src, int len) {
+        if (len < 1 || len > 4) {
+            return null;
+        }
+        byte[] temp = new byte[len];
+        for (int i = 0; i < len; i++) {
+            temp[len - 1 - i] = (byte) ((src >>> (8 * i)) & 0xFF);
+        }
+        return temp;
+    }
+
+    /**
+     * 将字节数组转换为整型数值
+     *
+     * @param arr
+     * @return
+     */
+    public static int bytesToInt(byte[] arr) {
+        int mask = 0xFF;
+        int temp = 0;
+        int result = 0;
+        for (int i = 0; i < 4; i++) {
+            result <<= 8;
+            temp = arr[i] & mask;
+            result |= temp;
+        }
+        return result;
+    }
+
+    /**
+     * 将long整型数值转换为字节数组
+     *
+     * @param num
+     * @return
+     */
+    public static byte[] longToBytes(long num) {
+        byte[] temp = new byte[8];
+        for (int i = 0; i < 8; i++) {
+            temp[i] = (byte) ((num >>> (56 - i * 8)) & 0xFF);
+        }
+        return temp;
+    }
+
+    /**
+     * 将字节数组转换为long整型数值
+     *
+     * @param arr
+     * @return
+     */
+    public static long bytesToLong(byte[] arr) {
+        int mask = 0xFF;
+        int temp = 0;
+        long result = 0;
+        int len = Math.min(8, arr.length);
+        for (int i = 0; i < len; i++) {
+            result <<= 8;
+            temp = arr[i] & mask;
+            result |= temp;
+        }
+        return result;
+    }
+
+    /**
+     * 将16进制字符转换为字节
+     *
+     * @param c
+     * @return
+     */
+    public static byte toByte(char c) {
+        byte b = (byte) "0123456789ABCDEF".indexOf(c);
+        return b;
+    }
+
+    /**
+     * 功能描述：把两个字节的字节数组转化为整型数据，高位补零，例如：<br/>
+     * 有字节数组byte[] data = new byte[]{1,2};转换后int数据的字节分布如下：<br/>
+     * 00000000 00000000 00000001 00000010,函数返回258
+     *
+     * @param lenData
+     *            需要进行转换的字节数组
+     * @return 字节数组所表示整型值的大小
+     */
+    public static int bytesToIntWhereByteLengthEquals2(byte lenData[]) {
+        if (lenData.length != 2) {
+            return -1;
+        }
+        byte fill[] = new byte[]{0, 0};
+        byte real[] = new byte[4];
+        System.arraycopy(fill, 0, real, 0, 2);
+        System.arraycopy(lenData, 0, real, 2, 2);
+        int len = byteToInt(real);
+        return len;
+
+    }
+
+    /**
+     * 功能描述：将byte数组转化为int类型的数据
+     *
+     * @param byteVal
+     *            需要转化的字节数组
+     * @return 字节数组所表示的整型数据
+     */
+    public static int byteToInt(byte[] byteVal) {
+        int result = 0;
+        for (int i = 0; i < byteVal.length; i++) {
+            int tmpVal = (byteVal[i] << (8 * (3 - i)));
+            switch (i) {
+                case 0 :
+                    tmpVal = tmpVal & 0xFF000000;
+                    break;
+                case 1 :
+                    tmpVal = tmpVal & 0x00FF0000;
+                    break;
+                case 2 :
+                    tmpVal = tmpVal & 0x0000FF00;
+                    break;
+                case 3 :
+                    tmpVal = tmpVal & 0x000000FF;
+                    break;
+            }
+
+            result = result | tmpVal;
+        }
+        return result;
+    }
+    public static byte CheckXORSum(byte[] bData) {
+        byte sum = 0x00;
+        for (int i = 0; i < bData.length; i++) {
+            sum ^= bData[i];
+        }
+        return sum;
+    }
+    /**
+     * 从offset开始 将后续长度为len的byte字节转为int
+     *
+     * @param data
+     * @param offset
+     * @param len
+     * @return
+     */
+    public static int bytesToInt(byte[] data, int offset, int len) {
+        int mask = 0xFF;
+        int temp = 0;
+        int result = 0;
+        len = Math.min(len, 4);
+        for (int i = 0; i < len; i++) {
+            result <<= 8;
+            temp = data[offset + i] & mask;
+            result |= temp;
+        }
+        return result;
+    }
+
+    /**
+     * byte字节数组中的字符串的长度
+     *
+     * @param data
+     * @return
+     */
+    public static int getBytesStringLen(byte[] data) {
+        int count = 0;
+        for (byte b : data) {
+            if (b == 0x00)
+                break;
+            count++;
+        }
+        return count;
+    }
+
+    /**
+     * 校验和
+     *
+     * @param msg
+     *            需要计算校验和的byte数组
+     * @param length
+     *            校验和位数
+     * @return 计算出的校验和数组
+     */
+    public static byte[] SumCheck(byte[] msg, int length) {
+        long mSum = 0;
+        byte[] mByte = new byte[length];
+
+        /** 逐Byte添加位数和 */
+        for (byte byteMsg : msg) {
+            long mNum = ((long) byteMsg >= 0)
+                    ? (long) byteMsg
+                    : ((long) byteMsg + 256);
+            mSum += mNum;
+        } /** end of for (byte byteMsg : msg) */
+
+        /** 位数和转化为Byte数组 */
+        for (int liv_Count = 0; liv_Count < length; liv_Count++) {
+            mByte[length - liv_Count
+                    - 1] = (byte) (mSum >> (liv_Count * 8) & 0xff);
+        } /** end of for (int liv_Count = 0; liv_Count < length; liv_Count++) */
+
+        return mByte;
+    }
+
+    /**
+     * 字节数据转十进制字符(补码-无符号)
+     *
+     * @param data
+     * @return
+     */
+    public static String getByteToStr(byte[] data) {
+        StringBuffer str = new StringBuffer();
+        for (int i = 0; i < data.length; i++) {
+            if (data[i] < 0) {
+                int tem = data[i] + 256;
+                str.append(tem + " ");
+            } else {
+                str.append(data[i] + " ");
+            }
+        }
+        return str.toString();
+    }
+
+    public static byte[]  buf2Bytes(ByteBuf in) {
+        return buf2Bytes( in, in.readableBytes()) ;
+    }
+    public static byte[]  buf2Bytes(ByteBuf in,int readable) {
+        byte[] dst = new byte[readable];
+        in.getBytes(0, dst);
+        return dst;
+    }
+
+    public static byte[] fileBytes(String pathname) throws IOException {
+        File filename = new File(pathname);
+        BufferedInputStream in = new BufferedInputStream(new FileInputStream(filename));
+        ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
+        byte[] temp = new byte[1024];
+        int size = 0;
+        while((size = in.read(temp)) != -1){
+            out.write(temp, 0, size);
+        }
+        in.close();
+        out.close();
+        byte[] content = out.toByteArray();
+        return content;
+    }
+    /**
+     * 单字节高低位互换
+     * @param src
+     * @return
+     */
+    public static int revert(int src) {
+        int lowByte = (src & 0xFF00) >> 8;
+        int highByte = (src & 0x00FF) << 8;
+        return lowByte | highByte;
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.util;
+
+import lombok.Data;
+
+@Data
+public class EqualsTopicFilter implements TcpTopicFilter {
+
+    private final String filter;
+
+    @Override
+    public boolean filter(String topic) {
+        return filter.equals(topic);
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.util;
+
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+@Slf4j
+public class MqttTopicFilterFactory {
+
+    private static final ConcurrentMap<String, TcpTopicFilter> filters = new ConcurrentHashMap<>();
+    private static final TcpTopicFilter DEFAULT_TELEMETRY_TOPIC_FILTER = toFilter(MqttTopics.DEVICE_TELEMETRY_TOPIC);
+    private static final TcpTopicFilter DEFAULT_ATTRIBUTES_TOPIC_FILTER = toFilter(MqttTopics.DEVICE_ATTRIBUTES_TOPIC);
+
+    public static TcpTopicFilter toFilter(String topicFilter) {
+        if (topicFilter == null || topicFilter.isEmpty()) {
+            throw new IllegalArgumentException("Topic filter can't be empty!");
+        }
+        return filters.computeIfAbsent(topicFilter, filter -> {
+            if (filter.equals("#")) {
+                return new AlwaysTrueTopicFilter();
+            } else if (filter.contains("+") || filter.contains("#")) {
+                String regex = filter
+                        .replace("\\", "\\\\")
+                        .replace("+", "[^/]+")
+                        .replace("/#", "($|/.*)");
+                log.debug("Converting [{}] to [{}]", filter, regex);
+                return new RegexTopicFilter(regex);
+            } else {
+                return new EqualsTopicFilter(filter);
+            }
+        });
+    }
+
+    public static TcpTopicFilter getDefaultTelemetryFilter() {
+        return DEFAULT_TELEMETRY_TOPIC_FILTER;
+    }
+
+    public static TcpTopicFilter getDefaultAttributesFilter() {
+        return DEFAULT_ATTRIBUTES_TOPIC_FILTER;
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.util;
+
+import lombok.Data;
+
+import java.util.regex.Pattern;
+
+@Data
+public class RegexTopicFilter implements TcpTopicFilter {
+
+    private final Pattern regex;
+
+    public RegexTopicFilter(String regex) {
+        this.regex = Pattern.compile(regex);
+    }
+
+    @Override
+    public boolean filter(String topic) {
+        return regex.matcher(topic).matches();
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.transport.tcp.util;
+
+public interface TcpTopicFilter {
+
+    boolean filter(String topic);
+
+}

@@ -137,6 +137,11 @@
             <groupId>org.bouncycastle</groupId>
             <artifactId>bcpkix-jdk15on</artifactId>
         </dependency>
+
+        <dependency>
+            <groupId>org.javadelight</groupId>
+            <artifactId>delight-nashorn-sandbox</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import delight.nashornsandbox.NashornSandbox;
+import delight.nashornsandbox.NashornSandboxes;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.thingsboard.common.util.ThingsBoardExecutors;
+import org.thingsboard.server.common.yunteng.script.AbstractYtScriptInvokeService;
+import org.thingsboard.server.common.yunteng.script.YtScriptExecutorService;
+import org.thingsboard.server.common.yunteng.script.YtScriptStatCallback;
+import org.thingsboard.server.queue.usagestats.TbApiUsageClient;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import javax.script.Invocable;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
+
+@Slf4j
+public abstract class AbstractNashornYtScriptInvokeService extends AbstractYtScriptInvokeService {
+
+    private NashornSandbox sandbox;
+    private ScriptEngine engine;
+    private ExecutorService monitorExecutorService;
+
+    private final AtomicInteger jsPushedMsgs = new AtomicInteger(0);
+    private final AtomicInteger jsInvokeMsgs = new AtomicInteger(0);
+    private final AtomicInteger jsEvalMsgs = new AtomicInteger(0);
+    private final AtomicInteger jsFailedMsgs = new AtomicInteger(0);
+    private final AtomicInteger jsTimeoutMsgs = new AtomicInteger(0);
+    private final FutureCallback<UUID> evalCallback = new YtScriptStatCallback<>(jsEvalMsgs, jsTimeoutMsgs, jsFailedMsgs);
+    private final FutureCallback<Object> invokeCallback = new YtScriptStatCallback<>(jsInvokeMsgs, jsTimeoutMsgs, jsFailedMsgs);
+
+    private final ReentrantLock evalLock = new ReentrantLock();
+
+    @Getter
+    private final YtScriptExecutorService jsExecutor;
+
+    @Value("${js.local.max_requests_timeout:0}")
+    private long maxRequestsTimeout;
+
+    @Value("${js.local.stats.enabled:false}")
+    private boolean statsEnabled;
+
+    public AbstractNashornYtScriptInvokeService(TbApiUsageClient apiUsageClient, YtScriptExecutorService jsExecutor) {
+        super();
+        this.jsExecutor = jsExecutor;
+    }
+
+    @Scheduled(fixedDelayString = "${js.local.stats.print_interval_ms:10000}")
+    public void printStats() {
+        if (statsEnabled) {
+            int pushedMsgs = jsPushedMsgs.getAndSet(0);
+            int invokeMsgs = jsInvokeMsgs.getAndSet(0);
+            int evalMsgs = jsEvalMsgs.getAndSet(0);
+            int failed = jsFailedMsgs.getAndSet(0);
+            int timedOut = jsTimeoutMsgs.getAndSet(0);
+            if (pushedMsgs > 0 || invokeMsgs > 0 || evalMsgs > 0 || failed > 0 || timedOut > 0) {
+                log.info("Nashorn JS Invoke Stats: pushed [{}] received [{}] invoke [{}] eval [{}] failed [{}] timedOut [{}]",
+                        pushedMsgs, invokeMsgs + evalMsgs, invokeMsgs, evalMsgs, failed, timedOut);
+            }
+        }
+    }
+
+    @PostConstruct
+    public void init() {
+        super.init(maxRequestsTimeout);
+        if (useJsSandbox()) {
+            sandbox = NashornSandboxes.create();
+            monitorExecutorService = ThingsBoardExecutors.newWorkStealingPool(getMonitorThreadPoolSize(), "nashorn-js-monitor");
+            sandbox.setExecutor(monitorExecutorService);
+            sandbox.setMaxCPUTime(getMaxCpuTime());
+            sandbox.allowNoBraces(false);
+            sandbox.allowLoadFunctions(true);
+            sandbox.setMaxPreparedStatements(30);
+        } else {
+            ScriptEngineManager factory = new ScriptEngineManager();
+            engine = factory.getEngineByName("nashorn");
+        }
+    }
+
+    @PreDestroy
+    public void stop() {
+        super.stop();
+        if (monitorExecutorService != null) {
+            monitorExecutorService.shutdownNow();
+        }
+    }
+
+    protected abstract boolean useJsSandbox();
+
+    protected abstract int getMonitorThreadPoolSize();
+
+    protected abstract long getMaxCpuTime();
+
+    @Override
+    protected ListenableFuture<UUID> doEval(UUID scriptId, String functionName, String jsScript) {
+        jsPushedMsgs.incrementAndGet();
+        ListenableFuture<UUID> result = jsExecutor.executeAsync(() -> {
+            try {
+                evalLock.lock();
+                try {
+                    if (useJsSandbox()) {
+                        sandbox.eval(jsScript);
+                    } else {
+                        engine.eval(jsScript);
+                    }
+                } finally {
+                    evalLock.unlock();
+                }
+                scriptIdToNameMap.put(scriptId, functionName);
+                return scriptId;
+            } catch (Exception e) {
+                log.debug("Failed to compile JS script: {}", e.getMessage(), e);
+                throw new ExecutionException(e);
+            }
+        });
+        if (maxRequestsTimeout > 0) {
+            result = Futures.withTimeout(result, maxRequestsTimeout, TimeUnit.MILLISECONDS, timeoutExecutorService);
+        }
+        Futures.addCallback(result, evalCallback, MoreExecutors.directExecutor());
+        return result;
+    }
+
+    @Override
+    protected ListenableFuture<Object> doInvokeFunction(UUID scriptId, String functionName, Object[] args) {
+        jsPushedMsgs.incrementAndGet();
+        ListenableFuture<Object> result = jsExecutor.executeAsync(() -> {
+            try {
+                if (useJsSandbox()) {
+                    return sandbox.getSandboxedInvocable().invokeFunction(functionName, args);
+                } else {
+                    return ((Invocable) engine).invokeFunction(functionName, args);
+                }
+            } catch (Exception e) {
+                onScriptExecutionError(scriptId, e, functionName);
+                throw new ExecutionException(e);
+            }
+        });
+
+        if (maxRequestsTimeout > 0) {
+            result = Futures.withTimeout(result, maxRequestsTimeout, TimeUnit.MILLISECONDS, timeoutExecutorService);
+        }
+        Futures.addCallback(result, invokeCallback, MoreExecutors.directExecutor());
+        return result;
+    }
+
+    protected void doRelease(UUID scriptId, String functionName) throws ScriptException {
+        if (useJsSandbox()) {
+            sandbox.eval(functionName + " = undefined;");
+        } else {
+            engine.eval(functionName + " = undefined;");
+        }
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.common.util.ThingsBoardThreadFactory;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Created by ashvayka on 26.09.18.
+ */
+@Slf4j
+public abstract class AbstractYtScriptInvokeService implements YtScriptInvokeService {
+
+
+
+    protected ScheduledExecutorService timeoutExecutorService;
+    protected Map<UUID, String> scriptIdToNameMap = new ConcurrentHashMap<>();
+    protected Map<UUID, DisableListInfo> disabledFunctions = new ConcurrentHashMap<>();
+
+
+
+    public void init(long maxRequestsTimeout) {
+        if (maxRequestsTimeout > 0) {
+            timeoutExecutorService = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("nashorn-js-timeout"));
+        }
+    }
+
+    public void stop() {
+        if (timeoutExecutorService != null) {
+            timeoutExecutorService.shutdownNow();
+        }
+    }
+
+    @Override
+    public ListenableFuture<UUID> eval(YtScriptType scriptType, String scriptBody, String... argNames) {
+            UUID scriptId = UUID.randomUUID();
+            String functionName = "invokeInternal_" + scriptId.toString().replace('-', '_');
+            String jsScript = generateJsScript(scriptType, functionName, scriptBody, argNames);
+            return doEval(scriptId, functionName, jsScript);
+    }
+
+    @Override
+    public ListenableFuture<Object> invokeFunction(UUID scriptId, Object... args) {
+            String functionName = scriptIdToNameMap.get(scriptId);
+            if (functionName == null) {
+                return Futures.immediateFailedFuture(new RuntimeException("No compiled script found for scriptId: [" + scriptId + "]!"));
+            }
+            if (!isDisabled(scriptId)) {
+                return doInvokeFunction(scriptId, functionName, args);
+            } else {
+                String message = "Script invocation is blocked due to maximum error count "
+                        + getMaxErrors() + ", scriptId " + scriptId + "!";
+                log.warn(message);
+                return Futures.immediateFailedFuture(new RuntimeException(message));
+            }
+    }
+
+    @Override
+    public ListenableFuture<Void> release(UUID scriptId) {
+        String functionName = scriptIdToNameMap.get(scriptId);
+        if (functionName != null) {
+            try {
+                scriptIdToNameMap.remove(scriptId);
+                disabledFunctions.remove(scriptId);
+                doRelease(scriptId, functionName);
+            } catch (Exception e) {
+                return Futures.immediateFailedFuture(e);
+            }
+        }
+        return Futures.immediateFuture(null);
+    }
+
+    protected abstract ListenableFuture<UUID> doEval(UUID scriptId, String functionName, String scriptBody);
+
+    protected abstract ListenableFuture<Object> doInvokeFunction(UUID scriptId, String functionName, Object[] args);
+
+    protected abstract void doRelease(UUID scriptId, String functionName) throws Exception;
+
+    protected abstract int getMaxErrors();
+
+    protected abstract long getMaxBlacklistDuration();
+
+    protected void onScriptExecutionError(UUID scriptId, Throwable t, String scriptBody) {
+        DisableListInfo disableListInfo = disabledFunctions.computeIfAbsent(scriptId, key -> new DisableListInfo());
+        log.warn("Script has exception and will increment counter {} on disabledFunctions for id {}, exception {}, cause {}, scriptBody {}",
+                disableListInfo.get(), scriptId, t, t.getCause(), scriptBody);
+        disableListInfo.incrementAndGet();
+    }
+
+    private String generateJsScript(YtScriptType scriptType, String functionName, String scriptBody, String... argNames) {
+        if (scriptType == YtScriptType.TCP_TRANSPORT_SCRIPT) {
+            return YtScriptFactory.generateRuleNodeScript(functionName, scriptBody, argNames);
+
+        }
+        throw new RuntimeException("No script factory implemented for scriptType: " + scriptType);
+    }
+
+    private boolean isDisabled(UUID scriptId) {
+        DisableListInfo errorCount = disabledFunctions.get(scriptId);
+        if (errorCount != null) {
+            if (errorCount.getExpirationTime() <= System.currentTimeMillis()) {
+                disabledFunctions.remove(scriptId);
+                return false;
+            } else {
+                return errorCount.get() >= getMaxErrors();
+            }
+        } else {
+            return false;
+        }
+    }
+
+    private class DisableListInfo {
+        private final AtomicInteger counter;
+        private long expirationTime;
+
+        private DisableListInfo() {
+            this.counter = new AtomicInteger(0);
+        }
+
+        public int get() {
+            return counter.get();
+        }
+
+        public int incrementAndGet() {
+            int result = counter.incrementAndGet();
+            expirationTime = System.currentTimeMillis() + getMaxBlacklistDuration();
+            return result;
+        }
+
+        public long getExpirationTime() {
+            return expirationTime;
+        }
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.yunteng.script.AbstractNashornYtScriptInvokeService;
+import org.thingsboard.server.common.yunteng.script.YtScriptExecutorService;
+import org.thingsboard.server.queue.usagestats.TbApiUsageClient;
+
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+@ConditionalOnProperty(prefix = "js", value = "evaluator", havingValue = "local", matchIfMissing = true)
+@Service
+public class
+NashornYtScriptInvokeService extends AbstractNashornYtScriptInvokeService {
+
+    @Value("${js.local.use_js_sandbox}")
+    private boolean useJsSandbox;
+
+    @Value("${js.local.monitor_thread_pool_size}")
+    private int monitorThreadPoolSize;
+
+    @Value("${js.local.max_cpu_time}")
+    private long maxCpuTime;
+
+    @Value("${js.local.max_errors}")
+    private int maxErrors;
+
+    @Value("${js.local.max_black_list_duration_sec:60}")
+    private int maxBlackListDurationSec;
+
+    public NashornYtScriptInvokeService(TbApiUsageClient apiUsageClient, YtScriptExecutorService jsExecutor) {
+        super(apiUsageClient, jsExecutor);
+    }
+
+    @Override
+    protected boolean useJsSandbox() {
+        return useJsSandbox;
+    }
+
+    @Override
+    protected int getMonitorThreadPoolSize() {
+        return monitorThreadPoolSize;
+    }
+
+    @Override
+    protected long getMaxCpuTime() {
+        return maxCpuTime;
+    }
+
+    @Override
+    protected int getMaxErrors() {
+        return maxErrors;
+    }
+
+    @Override
+    protected long getMaxBlacklistDuration() {
+        return TimeUnit.SECONDS.toMillis(maxBlackListDurationSec);
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.util.JsonFormat;
+import org.thingsboard.server.gen.js.JsInvokeProtos;
+import org.thingsboard.server.queue.common.TbProtoQueueMsg;
+import org.thingsboard.server.queue.kafka.TbKafkaEncoder;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Created by ashvayka on 25.09.18.
+ */
+public class RemoteJsRequestEncoder implements TbKafkaEncoder<TbProtoQueueMsg<JsInvokeProtos.RemoteJsRequest>> {
+    @Override
+    public byte[] encode(TbProtoQueueMsg<JsInvokeProtos.RemoteJsRequest> value) {
+        try {
+            return JsonFormat.printer().print(value.getValue()).getBytes(StandardCharsets.UTF_8);
+        } catch (InvalidProtocolBufferException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import com.google.protobuf.util.JsonFormat;
+import org.thingsboard.server.gen.js.JsInvokeProtos;
+import org.thingsboard.server.queue.TbQueueMsg;
+import org.thingsboard.server.queue.common.TbProtoQueueMsg;
+import org.thingsboard.server.queue.kafka.TbKafkaDecoder;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Created by ashvayka on 25.09.18.
+ */
+public class RemoteJsResponseDecoder implements TbKafkaDecoder<TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse>> {
+
+    @Override
+    public TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse> decode(TbQueueMsg msg) throws IOException {
+        JsInvokeProtos.RemoteJsResponse.Builder builder = JsInvokeProtos.RemoteJsResponse.newBuilder();
+        JsonFormat.parser().ignoringUnknownFields().merge(new String(msg.getData(), StandardCharsets.UTF_8), builder);
+        return new TbProtoQueueMsg<>(msg.getKey(), builder.build(), msg.getHeaders());
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StopWatch;
+import org.thingsboard.common.util.ThingsBoardThreadFactory;
+import org.thingsboard.server.gen.js.JsInvokeProtos;
+import org.thingsboard.server.queue.TbQueueRequestTemplate;
+import org.thingsboard.server.queue.common.TbProtoJsQueueMsg;
+import org.thingsboard.server.queue.common.TbProtoQueueMsg;
+import org.thingsboard.server.queue.usagestats.TbApiUsageClient;
+
+import javax.annotation.Nullable;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Slf4j
+@ConditionalOnExpression("'${js.evaluator:null}'=='remote' && ('${service.type:null}'=='monolith' || '${service.type:null}'=='tb-core' || '${service.type:null}'=='tb-transport')")
+@Service
+public class YtRemoteJsInvokeService extends AbstractYtScriptInvokeService {
+
+    @Value("${queue.js.max_eval_requests_timeout}")
+    private long maxEvalRequestsTimeout;
+
+    @Value("${queue.js.max_requests_timeout}")
+    private long maxRequestsTimeout;
+
+    @Getter
+    @Value("${js.remote.max_errors}")
+    private int maxErrors;
+
+    @Value("${js.remote.max_black_list_duration_sec:60}")
+    private int maxBlackListDurationSec;
+
+    @Value("${js.remote.stats.enabled:false}")
+    private boolean statsEnabled;
+
+    private final AtomicInteger queuePushedMsgs = new AtomicInteger(0);
+    private final AtomicInteger queueInvokeMsgs = new AtomicInteger(0);
+    private final AtomicInteger queueEvalMsgs = new AtomicInteger(0);
+    private final AtomicInteger queueFailedMsgs = new AtomicInteger(0);
+    private final AtomicInteger queueTimeoutMsgs = new AtomicInteger(0);
+    private final ExecutorService callbackExecutor = Executors.newFixedThreadPool(
+            Runtime.getRuntime().availableProcessors(), ThingsBoardThreadFactory.forName("js-executor-remote-callback"));
+
+    public YtRemoteJsInvokeService(TbApiUsageClient apiUsageClient) {
+        super();
+    }
+
+    @Scheduled(fixedDelayString = "${js.remote.stats.print_interval_ms}")
+    public void printStats() {
+        if (statsEnabled) {
+            int pushedMsgs = queuePushedMsgs.getAndSet(0);
+            int invokeMsgs = queueInvokeMsgs.getAndSet(0);
+            int evalMsgs = queueEvalMsgs.getAndSet(0);
+            int failed = queueFailedMsgs.getAndSet(0);
+            int timedOut = queueTimeoutMsgs.getAndSet(0);
+            if (pushedMsgs > 0 || invokeMsgs > 0 || evalMsgs > 0 || failed > 0 || timedOut > 0) {
+                log.info("Queue JS Invoke Stats: pushed [{}] received [{}] invoke [{}] eval [{}] failed [{}] timedOut [{}]",
+                        pushedMsgs, invokeMsgs + evalMsgs, invokeMsgs, evalMsgs, failed, timedOut);
+            }
+        }
+    }
+
+    @Autowired
+    private TbQueueRequestTemplate<TbProtoJsQueueMsg<JsInvokeProtos.RemoteJsRequest>, TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse>> requestTemplate;
+
+    private Map<UUID, String> scriptIdToBodysMap = new ConcurrentHashMap<>();
+
+    @PostConstruct
+    public void init() {
+        super.init(maxRequestsTimeout);
+        requestTemplate.init();
+    }
+
+    @PreDestroy
+    public void destroy() {
+        super.stop();
+        if (requestTemplate != null) {
+            requestTemplate.stop();
+        }
+    }
+
+    @Override
+    protected ListenableFuture<UUID> doEval(UUID scriptId, String functionName, String scriptBody) {
+        JsInvokeProtos.JsCompileRequest jsRequest = JsInvokeProtos.JsCompileRequest.newBuilder()
+                .setScriptIdMSB(scriptId.getMostSignificantBits())
+                .setScriptIdLSB(scriptId.getLeastSignificantBits())
+                .setFunctionName(functionName)
+                .setScriptBody(scriptBody).build();
+
+        JsInvokeProtos.RemoteJsRequest jsRequestWrapper = JsInvokeProtos.RemoteJsRequest.newBuilder()
+                .setCompileRequest(jsRequest)
+                .build();
+
+        log.trace("Post compile request for scriptId [{}]", scriptId);
+        ListenableFuture<TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse>> future = requestTemplate.send(new TbProtoJsQueueMsg<>(UUID.randomUUID(), jsRequestWrapper));
+        if (maxEvalRequestsTimeout > 0) {
+            future = Futures.withTimeout(future, maxEvalRequestsTimeout, TimeUnit.MILLISECONDS, timeoutExecutorService);
+        }
+        queuePushedMsgs.incrementAndGet();
+        Futures.addCallback(future, new FutureCallback<TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse>>() {
+            @Override
+            public void onSuccess(@Nullable TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse> result) {
+                queueEvalMsgs.incrementAndGet();
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                if (t instanceof TimeoutException || (t.getCause() != null && t.getCause() instanceof TimeoutException)) {
+                    queueTimeoutMsgs.incrementAndGet();
+                }
+                queueFailedMsgs.incrementAndGet();
+            }
+        }, callbackExecutor);
+        return Futures.transform(future, response -> {
+            JsInvokeProtos.JsCompileResponse compilationResult = response.getValue().getCompileResponse();
+            UUID compiledScriptId = new UUID(compilationResult.getScriptIdMSB(), compilationResult.getScriptIdLSB());
+            if (compilationResult.getSuccess()) {
+                scriptIdToNameMap.put(scriptId, functionName);
+                scriptIdToBodysMap.put(scriptId, scriptBody);
+                return compiledScriptId;
+            } else {
+                log.debug("[{}] Failed to compile script due to [{}]: {}", compiledScriptId, compilationResult.getErrorCode().name(), compilationResult.getErrorDetails());
+                throw new RuntimeException(compilationResult.getErrorDetails());
+            }
+        }, callbackExecutor);
+    }
+
+    @Override
+    protected ListenableFuture<Object> doInvokeFunction(UUID scriptId, String functionName, Object[] args) {
+        log.trace("doInvokeFunction js-request for uuid {} with timeout {}ms", scriptId, maxRequestsTimeout);
+        final String scriptBody = scriptIdToBodysMap.get(scriptId);
+        if (scriptBody == null) {
+            return Futures.immediateFailedFuture(new RuntimeException("No script body found for scriptId: [" + scriptId + "]!"));
+        }
+        JsInvokeProtos.JsInvokeRequest.Builder jsRequestBuilder = JsInvokeProtos.JsInvokeRequest.newBuilder()
+                .setScriptIdMSB(scriptId.getMostSignificantBits())
+                .setScriptIdLSB(scriptId.getLeastSignificantBits())
+                .setFunctionName(functionName)
+                .setTimeout((int) maxRequestsTimeout)
+                .setScriptBody(scriptBody);
+
+        for (Object arg : args) {
+            jsRequestBuilder.addArgs(arg.toString());
+        }
+
+        JsInvokeProtos.RemoteJsRequest jsRequestWrapper = JsInvokeProtos.RemoteJsRequest.newBuilder()
+                .setInvokeRequest(jsRequestBuilder.build())
+                .build();
+
+        StopWatch stopWatch = new StopWatch();
+        stopWatch.start();
+
+        ListenableFuture<TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse>> future = requestTemplate.send(new TbProtoJsQueueMsg<>(UUID.randomUUID(), jsRequestWrapper));
+        if (maxRequestsTimeout > 0) {
+            future = Futures.withTimeout(future, maxRequestsTimeout, TimeUnit.MILLISECONDS, timeoutExecutorService);
+        }
+        queuePushedMsgs.incrementAndGet();
+        Futures.addCallback(future, new FutureCallback<TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse>>() {
+            @Override
+            public void onSuccess(@Nullable TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse> result) {
+                queueInvokeMsgs.incrementAndGet();
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                onScriptExecutionError(scriptId, t, scriptBody);
+                if (t instanceof TimeoutException || (t.getCause() != null && t.getCause() instanceof TimeoutException)) {
+                    queueTimeoutMsgs.incrementAndGet();
+                }
+                queueFailedMsgs.incrementAndGet();
+            }
+        }, callbackExecutor);
+        return Futures.transform(future, response -> {
+            stopWatch.stop();
+            log.trace("doInvokeFunction js-response took {}ms for uuid {}", stopWatch.getTotalTimeMillis(), response.getKey());
+            JsInvokeProtos.JsInvokeResponse invokeResult = response.getValue().getInvokeResponse();
+            if (invokeResult.getSuccess()) {
+                return invokeResult.getResult();
+            } else {
+                final RuntimeException e = new RuntimeException(invokeResult.getErrorDetails());
+                onScriptExecutionError(scriptId, e, scriptBody);
+                log.debug("[{}] Failed to compile script due to [{}]: {}", scriptId, invokeResult.getErrorCode().name(), invokeResult.getErrorDetails());
+                throw e;
+            }
+        }, callbackExecutor);
+    }
+
+    @Override
+    protected void doRelease(UUID scriptId, String functionName) throws Exception {
+        JsInvokeProtos.JsReleaseRequest jsRequest = JsInvokeProtos.JsReleaseRequest.newBuilder()
+                .setScriptIdMSB(scriptId.getMostSignificantBits())
+                .setScriptIdLSB(scriptId.getLeastSignificantBits())
+                .setFunctionName(functionName).build();
+
+        JsInvokeProtos.RemoteJsRequest jsRequestWrapper = JsInvokeProtos.RemoteJsRequest.newBuilder()
+                .setReleaseRequest(jsRequest)
+                .build();
+
+        ListenableFuture<TbProtoQueueMsg<JsInvokeProtos.RemoteJsResponse>> future = requestTemplate.send(new TbProtoJsQueueMsg<>(UUID.randomUUID(), jsRequestWrapper));
+        if (maxRequestsTimeout > 0) {
+            future = Futures.withTimeout(future, maxRequestsTimeout, TimeUnit.MILLISECONDS, timeoutExecutorService);
+        }
+        JsInvokeProtos.RemoteJsResponse response = future.get().getValue();
+
+        JsInvokeProtos.JsReleaseResponse compilationResult = response.getReleaseResponse();
+        UUID compiledScriptId = new UUID(compilationResult.getScriptIdMSB(), compilationResult.getScriptIdLSB());
+        if (compilationResult.getSuccess()) {
+            scriptIdToBodysMap.remove(scriptId);
+        } else {
+            log.debug("[{}] Failed to release script due", compiledScriptId);
+        }
+    }
+
+    @Override
+    protected long getMaxBlacklistDuration() {
+        return TimeUnit.SECONDS.toMillis(maxBlackListDurationSec);
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.thingsboard.common.util.AbstractListeningExecutor;
+
+@Component
+public class YtScriptExecutorService extends AbstractListeningExecutor {
+
+    @Value("${actors.rule.js_thread_pool_size}")
+    private int jsExecutorThreadPoolSize;
+
+    @Override
+    protected int getThreadPollSize() {
+        return Math.max(jsExecutorThreadPoolSize, 1);
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+public class YtScriptFactory {
+
+    public static final String MSG = "params";
+
+    public static final String RULE_NODE_FUNCTION_NAME = "tcpTransportFunc";
+
+    private static final String JS_WRAPPER_PREFIX_TEMPLATE = "function %s(params) { " +
+            "    var out = new Object(); " +
+            "    return JSON.stringify(%s(params));" +
+            "    function %s(%s) {";
+    private static final String JS_WRAPPER_SUFFIX = "return out; \n }" +
+            "\n}";
+
+
+    public static String generateRuleNodeScript(String functionName, String scriptBody, String... argNames) {
+        String msgArg;
+
+        msgArg = (argNames != null && argNames.length >= 1) ? argNames[0]:MSG;
+
+        String jsWrapperPrefix = String.format(JS_WRAPPER_PREFIX_TEMPLATE
+                , functionName
+                ,RULE_NODE_FUNCTION_NAME
+                , RULE_NODE_FUNCTION_NAME, msgArg);
+        String result =  jsWrapperPrefix + scriptBody + JS_WRAPPER_SUFFIX;
+        return result;
+    }
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import java.util.List;
+
+/**
+ * Created by ashvayka on 25.09.18.
+ */
+public class YtScriptInvokeRequest {
+
+    private String scriptId;
+    private String scriptBody;
+    private List<String> args;
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import java.util.List;
+
+/**
+ * Created by ashvayka on 25.09.18.
+ */
+public class YtScriptInvokeResponse {
+
+    private String scriptId;
+    private String scriptBody;
+    private List<String> args;
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+import java.util.UUID;
+
+public interface YtScriptInvokeService {
+
+    ListenableFuture<UUID> eval(YtScriptType scriptType, String scriptBody, String... argNames);
+
+    ListenableFuture<Object> invokeFunction(UUID scriptId, Object... args);
+
+    ListenableFuture<Void> release(UUID scriptId);
+
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+import com.google.common.util.concurrent.FutureCallback;
+import lombok.AllArgsConstructor;
+
+import javax.annotation.Nullable;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@AllArgsConstructor
+public class YtScriptStatCallback<T> implements FutureCallback<T> {
+
+    private final AtomicInteger jsSuccessMsgs;
+    private final AtomicInteger jsTimeoutMsgs;
+    private final AtomicInteger jsFailedMsgs;
+
+
+    @Override
+    public void onSuccess(@Nullable T result) {
+        jsSuccessMsgs.incrementAndGet();
+    }
+
+    @Override
+    public void onFailure(Throwable t) {
+        if (t instanceof TimeoutException || (t.getCause() != null && t.getCause() instanceof TimeoutException)) {
+            jsTimeoutMsgs.incrementAndGet();
+        } else {
+            jsFailedMsgs.incrementAndGet();
+        }
+    }
+}

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.yunteng.script;
+
+public enum YtScriptType {
+    TCP_TRANSPORT_SCRIPT
+}

@@ -31,29 +31,12 @@ import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.StringUtils;
 import org.thingsboard.common.util.JacksonUtil;
-import org.thingsboard.server.common.data.Device;
-import org.thingsboard.server.common.data.DeviceInfo;
-import org.thingsboard.server.common.data.DeviceProfile;
-import org.thingsboard.server.common.data.DeviceTransportType;
-import org.thingsboard.server.common.data.EntitySubtype;
-import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.EntityView;
+import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.device.DeviceSearchQuery;
 import org.thingsboard.server.common.data.device.credentials.BasicMqttCredentials;
-import org.thingsboard.server.common.data.device.data.CoapDeviceTransportConfiguration;
-import org.thingsboard.server.common.data.device.data.DefaultDeviceConfiguration;
-import org.thingsboard.server.common.data.device.data.DefaultDeviceTransportConfiguration;
-import org.thingsboard.server.common.data.device.data.DeviceData;
-import org.thingsboard.server.common.data.device.data.Lwm2mDeviceTransportConfiguration;
-import org.thingsboard.server.common.data.device.data.MqttDeviceTransportConfiguration;
-import org.thingsboard.server.common.data.device.data.SnmpDeviceTransportConfiguration;
+import org.thingsboard.server.common.data.device.data.*;
 import org.thingsboard.server.common.data.edge.Edge;
-import org.thingsboard.server.common.data.id.CustomerId;
-import org.thingsboard.server.common.data.id.DeviceId;
-import org.thingsboard.server.common.data.id.DeviceProfileId;
-import org.thingsboard.server.common.data.id.EdgeId;
-import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.id.*;
 import org.thingsboard.server.common.data.ota.OtaPackageType;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -73,21 +56,13 @@ import org.thingsboard.server.dao.service.DataValidator;
 import org.thingsboard.server.dao.service.PaginatedRemover;
 
 import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Optional;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 
 import static org.thingsboard.server.common.data.CacheConstants.DEVICE_CACHE;
 import static org.thingsboard.server.dao.DaoUtil.toUUIDs;
-import static org.thingsboard.server.dao.service.Validator.validateId;
-import static org.thingsboard.server.dao.service.Validator.validateIds;
-import static org.thingsboard.server.dao.service.Validator.validatePageLink;
-import static org.thingsboard.server.dao.service.Validator.validateString;
+import static org.thingsboard.server.dao.service.Validator.*;
 
 @Service
 @Slf4j
@@ -288,6 +263,12 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                 case SNMP:
                     deviceData.setTransportConfiguration(new SnmpDeviceTransportConfiguration());
                     break;
+
+                //Thingskit function
+                case TCP:
+                    deviceData.setTransportConfiguration(new YtTcpDeviceTransportConfiguration());
+                    break;
+
             }
         }
         return deviceData;

@@ -19,12 +19,15 @@ import com.google.common.util.concurrent.ListenableFuture;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.TenantInfo;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.common.data.yunteng.enums.DeviceTypeEnum;
 import org.thingsboard.server.dao.asset.AssetService;
 import org.thingsboard.server.dao.customer.CustomerService;
 import org.thingsboard.server.dao.dashboard.DashboardService;
@@ -42,6 +45,7 @@ import org.thingsboard.server.dao.service.Validator;
 import org.thingsboard.server.dao.usagerecord.ApiUsageStateService;
 import org.thingsboard.server.dao.user.UserService;
 import org.thingsboard.server.dao.widget.WidgetsBundleService;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceProfileService;
 
 import static org.thingsboard.server.dao.service.Validator.validateId;
 
@@ -99,7 +103,8 @@ public class TenantServiceImpl extends AbstractEntityService implements TenantSe
 
     @Autowired
     private DataValidator<Tenant> tenantValidator;
-
+    @Autowired
+    private YtDeviceProfileService ytDeviceProfileService;
     @Override
     public Tenant findTenantById(TenantId tenantId) {
         log.trace("Executing findTenantById [{}]", tenantId);
@@ -132,8 +137,13 @@ public class TenantServiceImpl extends AbstractEntityService implements TenantSe
         tenantValidator.validate(tenant, Tenant::getId);
         Tenant savedTenant = tenantDao.save(tenant.getId(), tenant);
         if (tenant.getId() == null) {
-            deviceProfileService.createDefaultDeviceProfile(savedTenant.getId());
+
+            //Thingskit function
+            DeviceProfile deviceProfile = deviceProfileService.createDefaultDeviceProfile(savedTenant.getId());
+            DeviceProfileDTO profileDTO = new DeviceProfileDTO(deviceProfile.getName(),deviceProfile.getTenantId(),deviceProfile.getId(), DeviceTypeEnum.DIRECT_CONNECTION);
+            ytDeviceProfileService.insertOrUpdate(profileDTO);
             apiUsageStateService.createDefaultApiUsageState(savedTenant.getId(), null);
+
         }
         return savedTenant;
     }

@@ -8,12 +8,8 @@ import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.apache.ibatis.type.EnumTypeHandler;
 import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
-import org.thingsboard.server.common.data.yunteng.enums.DeviceCredentialsEnum;
-import org.thingsboard.server.common.data.yunteng.enums.DeviceState;
 import org.thingsboard.server.common.data.yunteng.enums.DeviceTypeEnum;
 
-import java.time.LocalDateTime;
-
 @Data
 @EqualsAndHashCode(callSuper = true)
 @TableName(value = ModelConstants.Table.IOTFS_DEVICE_TABLE_NAME, autoResultMap = true)

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.apache.ibatis.type.EnumTypeHandler;
+import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
+import org.thingsboard.server.common.data.yunteng.enums.DeviceTypeEnum;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName(value = ModelConstants.Table.IOTFS_DEVICE_PROFILE_TABLE_NAME, autoResultMap = true)
+public class YtDeviceProfileEntity extends TenantBaseEntity {
+    private String name;
+
+    private String scriptId;
+    private String tbProfileId;
+    @TableField(typeHandler = EnumTypeHandler.class)
+    private DeviceTypeEnum deviceType;
+    private String description;
+}

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.apache.ibatis.type.EnumTypeHandler;
+import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
+import org.thingsboard.server.common.data.yunteng.enums.DeviceTypeEnum;
+
+@Data
+@TableName(value = ModelConstants.Table.IOTFS_DEVICE_SCRIPT_TABLE_NAME, autoResultMap = true)
+@EqualsAndHashCode(callSuper = true)
+public class YtDeviceScriptEntity extends TenantBaseEntity {
+    private String name;
+    private String convertJs;
+    /**
+     * 告警状态：0：正常 1：告警
+     */
+    private Integer status;
+    private String description;
+}

@@ -2,6 +2,7 @@ package org.thingsboard.server.dao.yunteng.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
@@ -17,30 +18,33 @@ import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
 import org.thingsboard.server.common.data.yunteng.core.cache.CacheUtils;
 import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
 import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
-import org.thingsboard.server.common.data.yunteng.dto.AlarmProfileDTO;
-import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.common.data.yunteng.dto.*;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
 import org.thingsboard.server.common.data.yunteng.utils.ReflectUtils;
 import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
 import org.thingsboard.server.dao.service.Validator;
-import org.thingsboard.server.dao.yunteng.entities.Menu;
+import org.thingsboard.server.dao.yunteng.entities.*;
 import org.thingsboard.server.dao.yunteng.jpa.dao.YtJpaDeviceProfileDao;
-import org.thingsboard.server.dao.yunteng.entities.AlarmProfile;
-import org.thingsboard.server.dao.yunteng.entities.YtDevice;
 import org.thingsboard.server.dao.yunteng.mapper.AlarmProfileMapper;
 import org.thingsboard.server.dao.yunteng.mapper.DeviceMapper;
+import org.thingsboard.server.dao.yunteng.mapper.YtDeviceProfileMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
 import org.thingsboard.server.dao.yunteng.service.YtDeviceProfileService;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 @Service
 @RequiredArgsConstructor
 @Slf4j
-public class YtDeviceProfileServiceImpl implements YtDeviceProfileService {
+public class YtDeviceProfileServiceImpl extends AbstractBaseService<YtDeviceProfileMapper, YtDeviceProfileEntity>
+        implements YtDeviceProfileService {
 
   private final DeviceMapper deviceMapper;
 
   private final YtJpaDeviceProfileDao deviceProfileDao;
 
+
   @Override
   public boolean validateFormdata(DeviceProfileDTO ytDeviceProfileDTO) {
     TenantId tenantId = TenantId.fromUUID(UUID.fromString(ytDeviceProfileDTO.getTenantId()));
@@ -63,6 +67,61 @@ public class YtDeviceProfileServiceImpl implements YtDeviceProfileService {
   }
 
   @Override
+  public DeviceProfileDTO insertOrUpdate( DeviceProfileDTO deviceDTO) {
+    if (StringUtils.isBlank(deviceDTO.getId())) {
+      return insert(deviceDTO);
+    } else {
+      return update(deviceDTO);
+    }
+  }
+
+  private DeviceProfileDTO insert(DeviceProfileDTO deviceDTO) {
+
+    YtDeviceProfileEntity profile = new YtDeviceProfileEntity();
+    deviceDTO.copyToEntity(
+            profile,
+            ModelConstants.TablePropertyMapping.ACTIVE_TIME,
+            ModelConstants.TablePropertyMapping.DEVICE_STATE,
+            ModelConstants.TablePropertyMapping.CREATOR,
+            ModelConstants.TablePropertyMapping.UPDATER,
+            ModelConstants.TablePropertyMapping.CREATE_TIME,
+            ModelConstants.TablePropertyMapping.UPDATE,
+            ModelConstants.TablePropertyMapping.UPDATE_TIME);
+
+
+    baseMapper.insert(profile);
+    return profile.getDTO(DeviceProfileDTO.class);
+  }
+
+  private DeviceProfileDTO update(DeviceProfileDTO deviceDTO) {
+    YtDeviceProfileEntity device = new YtDeviceProfileEntity();
+    deviceDTO.copyToEntity(
+            device,
+            ModelConstants.TablePropertyMapping.ACTIVE_TIME,
+            ModelConstants.TablePropertyMapping.DEVICE_STATE,
+            ModelConstants.TablePropertyMapping.TB_DEVICE_ID,
+            ModelConstants.TablePropertyMapping.TENANT_CODE,
+            ModelConstants.TablePropertyMapping.CREATOR,
+            ModelConstants.TablePropertyMapping.UPDATER,
+            ModelConstants.TablePropertyMapping.CREATE_TIME,
+            ModelConstants.TablePropertyMapping.UPDATE,
+            ModelConstants.TablePropertyMapping.UPDATE_TIME);
+    baseMapper.updateById(device);
+    return device.getDTO(DeviceProfileDTO.class);
+  }
+
+  @Override
+  public void deleteDeviceProfiles(String tenantId, Set<String> ids) {
+    LambdaQueryWrapper<YtDeviceProfileEntity> queryWrapper =
+            new QueryWrapper<YtDeviceProfileEntity>()
+                    .lambda()
+                    .eq(YtDeviceProfileEntity::getTenantId, tenantId)
+                    .in(YtDeviceProfileEntity::getId, ids);
+
+    baseMapper.delete(queryWrapper);
+  }
+
+  @Override
   @Transactional
   public void checkDeviceProfiles(String tenantId, Set<String> ids) {
     // check if ids bind to device
@@ -76,28 +135,17 @@ public class YtDeviceProfileServiceImpl implements YtDeviceProfileService {
 
   @Override
   public Optional<DeviceProfileDTO> getDeviceProfile(String tenantId, String id) {
-    TenantId tenant = TenantId.fromUUID(UUID.fromString(tenantId));
-    DeviceProfile profile = deviceProfileDao.findById(tenant, UUID.fromString(id));
-    return Optional.ofNullable(profile)
-        .map(
-            entity -> {
-              DeviceProfileDTO result = ReflectUtils.getDeviceProfileDTO(entity);
-              return result;
-            });
+    return Optional.ofNullable(baseMapper.selectDetail(tenantId,id));
   }
 
   @Override
-  public YtPageData<DeviceProfileDTO> page(
-      PageLink pageLink, String tenantIdStr, String transportType) {
+  public YtPageData<DeviceProfileDTO> page(Integer page, Integer pageSize, String orderField, OrderTypeEnum orderType
+          , String tenantIdStr, String profileName, String transportType) {
 
-    TenantId tenantId = TenantId.fromUUID(UUID.fromString(tenantIdStr));
-    Validator.validatePageLink(pageLink);
-    PageData<DeviceProfileDTO> tbDatas =
-        deviceProfileDao.findDeviceProfileInfos(pageLink, tenantId, transportType);
-    YtPageData<DeviceProfileDTO> result =
-        new YtPageData<>(tbDatas.getData(), tbDatas.getTotalElements());
+    IPage<YtDeviceProfileEntity> currentPage = getCurrentPage(page,pageSize,orderField,orderType);
+    IPage<DeviceProfileDTO> result = baseMapper.getProfilePage(currentPage,tenantIdStr,profileName,transportType);
 
-    return result;
+    return getPageData(result, DeviceProfileDTO.class);
   }
 
   @Override
@@ -107,4 +155,17 @@ public class YtDeviceProfileServiceImpl implements YtDeviceProfileService {
         deviceProfileDao.findDeviceProfileByTenantId(TenantId.fromUUID(profileId));
     return results;
   }
+
+  @Override
+  public List<DeviceProfileDTO> findDeviceProfile(String tenantId, String scriptId) {
+    LambdaQueryWrapper<YtDeviceProfileEntity> queryWrapper =
+            new QueryWrapper<YtDeviceProfileEntity>()
+                    .lambda()
+                    .eq(YtDeviceProfileEntity::getTenantId, tenantId)
+                    .eq(YtDeviceProfileEntity::getScriptId, scriptId);
+    List<DeviceProfileDTO> results = baseMapper.selectList(queryWrapper).stream()
+            .map(item -> item.getDTO(DeviceProfileDTO.class))
+            .collect(Collectors.toList());
+    return results;
+  }
 }

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.thingsboard.server.common.data.yunteng.constant.ModelConstants;
+import org.thingsboard.server.common.data.yunteng.core.exception.YtDataValidationException;
+import org.thingsboard.server.common.data.yunteng.core.message.ErrorMessage;
+import org.thingsboard.server.common.data.yunteng.dto.YtDeviceScriptDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceProfileEntity;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceScriptEntity;
+import org.thingsboard.server.dao.yunteng.mapper.YtDeviceProfileMapper;
+import org.thingsboard.server.dao.yunteng.mapper.YtDeviceScriptMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.YtDeviceScriptService;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class YtDeviceScriptServiceImpl extends AbstractBaseService<YtDeviceScriptMapper, YtDeviceScriptEntity>
+        implements YtDeviceScriptService {
+
+
+  private final YtDeviceProfileMapper profileMapper;
+
+
+  @Override
+  public boolean validateFormdata(YtDeviceScriptDTO scriptDTO,boolean created) {
+    String tenantId = scriptDTO.getTenantId();
+    if (created) {
+      // 判断数据库是否已存在名字相同的设备配置
+      LambdaQueryWrapper<YtDeviceScriptEntity> queryWrapper =
+              new QueryWrapper<YtDeviceScriptEntity>()
+                      .lambda()
+                      .eq(YtDeviceScriptEntity::getTenantId, tenantId)
+                      .eq(YtDeviceScriptEntity::getName, scriptDTO.getName());
+      int results = baseMapper.selectCount(queryWrapper);
+      if (results > 0) {
+        throw new YtDataValidationException(ErrorMessage.NAME_ALREADY_EXISTS.getMessage());
+      }
+    } else {
+      LambdaQueryWrapper<YtDeviceScriptEntity> queryWrapper =
+              new QueryWrapper<YtDeviceScriptEntity>()
+                      .lambda()
+                      .eq(YtDeviceScriptEntity::getTenantId, tenantId)
+                      .and(
+                              second ->
+                                      second
+                                              .eq(YtDeviceScriptEntity::getId, scriptDTO.getId())
+                                              .or(f -> f.eq(YtDeviceScriptEntity::getName, scriptDTO.getName())));
+
+
+      List<YtDeviceScriptEntity> results = baseMapper.selectList(queryWrapper);
+      for(YtDeviceScriptEntity item:results){
+        if(item.getId().equals(scriptDTO.getId()) && !item.getTenantId().equals(scriptDTO.getTenantId())){
+          throw new YtDataValidationException(ErrorMessage.TENANT_MISMATCHING.getMessage());
+        }
+        if(!item.getId().equals(scriptDTO.getId()) && item.getName().equals(scriptDTO.getName())){
+          throw new YtDataValidationException(ErrorMessage.NAME_ALREADY_EXISTS.getMessage());
+        }
+      }
+    }
+
+    return false;
+  }
+
+  @Override
+  public String getScriptText(String tenantId, String scriptId) {
+    return null;
+  }
+
+  @Override
+  public YtDeviceScriptDTO insertOrUpdate( YtDeviceScriptDTO deviceDTO) {
+    if (StringUtils.isBlank(deviceDTO.getId())) {
+      return insert(deviceDTO);
+    } else {
+      return update(deviceDTO);
+    }
+  }
+
+  @Override
+  public void checkDeviceScriptes(String tenantId, Set<String> ids) {
+    // check if ids bind to device
+    List<YtDeviceProfileEntity> usedList =
+            profileMapper.selectList(
+                    new QueryWrapper<YtDeviceProfileEntity>().lambda().in(YtDeviceProfileEntity::getScriptId, ids));
+    if (usedList !=null &&usedList.size() > 0) {
+      List<String> names = usedList.stream()
+              .map(i -> i.getName())
+              .collect(Collectors.toList());
+      throw new YtDataValidationException(String.format(ErrorMessage.PROJECT_USED_SCRIPT.getMessage(),names));
+    }
+  }
+  @Override
+  @Transactional
+  public void deleteScriptes(String tenantId, Set<String> ids) {
+    checkDeviceScriptes(tenantId, ids);
+    LambdaQueryWrapper<YtDeviceScriptEntity> queryWrapper =
+            new QueryWrapper<YtDeviceScriptEntity>()
+                    .lambda()
+                    .eq(YtDeviceScriptEntity::getTenantId, tenantId)
+                    .in(YtDeviceScriptEntity::getId, ids);
+
+    baseMapper.delete(queryWrapper);
+
+  }
+
+  private YtDeviceScriptDTO insert(YtDeviceScriptDTO deviceDTO) {
+
+    YtDeviceScriptEntity profile = new YtDeviceScriptEntity();
+    deviceDTO.copyToEntity(
+            profile,
+            ModelConstants.TablePropertyMapping.ACTIVE_TIME,
+            ModelConstants.TablePropertyMapping.DEVICE_STATE,
+            ModelConstants.TablePropertyMapping.UPDATER,
+            ModelConstants.TablePropertyMapping.CREATE_TIME,
+            ModelConstants.TablePropertyMapping.UPDATE_TIME);
+
+    baseMapper.insert(profile);
+    return profile.getDTO(YtDeviceScriptDTO.class);
+  }
+
+  private YtDeviceScriptDTO update(YtDeviceScriptDTO deviceDTO) {
+    YtDeviceScriptEntity device = new YtDeviceScriptEntity();
+    deviceDTO.copyToEntity(
+            device,
+            ModelConstants.TablePropertyMapping.ACTIVE_TIME,
+            ModelConstants.TablePropertyMapping.DEVICE_STATE,
+            ModelConstants.TablePropertyMapping.TB_DEVICE_ID,
+            ModelConstants.TablePropertyMapping.TENANT_CODE,
+            ModelConstants.TablePropertyMapping.CREATOR,
+            ModelConstants.TablePropertyMapping.UPDATER,
+            ModelConstants.TablePropertyMapping.CREATE_TIME,
+            ModelConstants.TablePropertyMapping.UPDATE,
+            ModelConstants.TablePropertyMapping.UPDATE_TIME);
+    baseMapper.updateById(device);
+    return device.getDTO(YtDeviceScriptDTO.class);
+  }
+
+
+
+
+  @Override
+  public Optional<YtDeviceScriptDTO> getDeviceScript(String tenantId, String id) {
+    LambdaQueryWrapper<YtDeviceScriptEntity> queryWrapper =
+            new QueryWrapper<YtDeviceScriptEntity>()
+                    .lambda()
+                    .eq(YtDeviceScriptEntity::getTenantId, tenantId)
+                    .eq(YtDeviceScriptEntity::getId, id);
+    YtDeviceScriptEntity profile = baseMapper.selectOne(queryWrapper);
+    return Optional.ofNullable(profile)
+        .map(
+            entity -> {
+              YtDeviceScriptDTO result = entity.getDTO(YtDeviceScriptDTO.class);
+              return result;
+            });
+  }
+
+  @Override
+  public YtPageData<YtDeviceScriptDTO> page(Integer page, Integer pageSize, String orderField, OrderTypeEnum orderType,String tenantId) {
+    IPage<YtDeviceScriptEntity> currentPage = getCurrentPage(page,pageSize,orderField,orderType);
+
+    LambdaQueryWrapper<YtDeviceScriptEntity> queryWrapper =
+            new QueryWrapper<YtDeviceScriptEntity>()
+                    .lambda()
+                    .eq(YtDeviceScriptEntity::getTenantId, tenantId);
+
+
+
+
+    IPage<YtDeviceScriptEntity> scriptes = baseMapper.selectPage(currentPage, queryWrapper);
+    List<YtDeviceScriptDTO> records = scriptes.getRecords().stream()
+            .map(entity -> entity.getDTO(YtDeviceScriptDTO.class))
+            .collect(Collectors.toList());
+    return new YtPageData<>(records, scriptes.getTotal());
+  }
+
+  @Override
+  public List<YtDeviceScriptDTO> findDeviceScript(String tenantId) {
+    LambdaQueryWrapper<YtDeviceScriptEntity> queryWrapper =
+            new QueryWrapper<YtDeviceScriptEntity>()
+                    .lambda()
+                    .eq(YtDeviceScriptEntity::getTenantId, tenantId);
+    List<YtDeviceScriptDTO> results = baseMapper.selectList(queryWrapper).stream()
+            .map(item -> item.getDTO(YtDeviceScriptDTO.class))
+            .collect(Collectors.toList());
+    return results;
+  }
+
+
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.thingsboard.server.common.data.yunteng.dto.*;
+import org.thingsboard.server.dao.yunteng.entities.YtDevice;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceProfileEntity;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface YtDeviceProfileMapper extends BaseMapper<YtDeviceProfileEntity> {
+
+    /**
+     * 获取产品(设备配置)详情
+     * @return
+     */
+    public DeviceProfileDTO selectDetail( @Param("tenantId") String tenantId, @Param("id") String id);
+
+    public IPage<DeviceProfileDTO> getProfilePage(IPage<?> page, @Param("tenantId") String tenantId, @Param("profileName") String profileName, @Param("transportType") String transportType);
+
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceScriptEntity;
+
+@Mapper
+public interface YtDeviceScriptMapper extends BaseMapper<YtDeviceScriptEntity> {
+}

@@ -76,6 +76,33 @@ public abstract class AbstractBaseService<M extends BaseMapper<T>, T extends Bas
     }
   }
 
+  protected IPage<T> getCurrentPage(Integer page, Integer pageSize, String orderField, OrderTypeEnum orderType) {
+    if(page == null){
+      page = 1;
+    }
+    if(pageSize == null){
+      pageSize=10;
+    }
+    if(StringUtils.isEmpty(orderField)){
+      orderField = FastIotConstants.DefaultOrder.CREATE_TIME;
+    }
+    if(orderType == null){
+      orderType = OrderTypeEnum.DESC;
+    }
+
+    Page<T> pageInform = new Page<>(page, pageSize);
+
+    switch (orderType){
+      case ASC:
+        pageInform.addOrder(OrderItem.asc(orderField));
+        break;
+      default:
+        pageInform.addOrder(OrderItem.desc(orderField));
+    }
+
+    return pageInform;
+  }
+
   /**
    * 分页信息
    * @param pageNum     第几页

 package org.thingsboard.server.dao.yunteng.service;
 
+import com.baomidou.mybatisplus.core.metadata.IPage;
 import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
 import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
 
 import java.util.List;
@@ -10,13 +13,19 @@ import java.util.Set;
 
 public interface YtDeviceProfileService {
 
+    DeviceProfileDTO insertOrUpdate(DeviceProfileDTO deviceDTO);
+
+    void deleteDeviceProfiles(String tenantId, Set<String> ids);
+
     void checkDeviceProfiles(String tenantId, Set<String> ids);
 
     Optional<DeviceProfileDTO> getDeviceProfile(String tenantId, String id);
 
-    YtPageData<DeviceProfileDTO> page(PageLink pageLink, String tenantId, String transportType);
+    YtPageData<DeviceProfileDTO> page(Integer page, Integer pageSize, String orderField, OrderTypeEnum orderType
+            ,String tenantIdStr, String profileName, String transportType);
 
     List<DeviceProfileDTO> findDeviceProfile(String tenantId);
+    List<DeviceProfileDTO> findDeviceProfile(String tenantId,String scriptId);
 
 
     /**

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.yunteng.dto.YtDeviceScriptDTO;
+import org.thingsboard.server.common.data.yunteng.enums.OrderTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.YtPageData;
+import org.thingsboard.server.dao.yunteng.entities.Trigger;
+import org.thingsboard.server.dao.yunteng.entities.YtDeviceScriptEntity;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+public interface YtDeviceScriptService  extends BaseService<YtDeviceScriptEntity>{
+
+    /**
+     * 查找脚本解析的脚本内容
+     * @param tenantId
+     * @param scriptId
+     * @return
+     */
+    String getScriptText(String tenantId, String scriptId);
+
+    YtDeviceScriptDTO insertOrUpdate(YtDeviceScriptDTO deviceDTO);
+
+    void deleteScriptes(String tenantId, Set<String> ids);
+
+    void checkDeviceScriptes(String tenantId, Set<String> ids);
+
+    Optional<YtDeviceScriptDTO> getDeviceScript(String tenantId, String id);
+
+    YtPageData<YtDeviceScriptDTO> page(Integer page, Integer pageSize, String orderField, OrderTypeEnum orderType, String tenantId);
+
+    List<YtDeviceScriptDTO> findDeviceScript(String tenantId);
+
+
+    /**
+     * 验证表单数据有效性
+     * @param scriptDTO
+     * @param created
+     * @return
+     */
+    boolean validateFormdata( YtDeviceScriptDTO scriptDTO,boolean created);
+}

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="org.thingsboard.server.dao.yunteng.mapper.YtDeviceProfileMapper">
+    <resultMap type="org.thingsboard.server.common.data.yunteng.dto.DeviceProfileDTO" id="detail">
+        <result property="id" column="id"/>
+        <result property="createTime" column="create_time"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="creator" column="creator"/>
+        <result property="updater" column="updater"/>
+        <result property="name" column="name"/>
+        <result property="image" column="image"/>
+        <result property="description" column="description"/>
+        <result property="tenantId" column="tenant_id"/>
+        <result property="scriptId" column="script_id"/>
+        <result property="transportType" column="transport_type"/>
+        <result property="provisionType" column="provision_type"/>
+        <result property="deviceType" column="device_type" typeHandler="org.apache.ibatis.type.EnumTypeHandler"/>
+        <result property="tbProfileId" column="tb_profile_id"/>
+        <result property="profileData" column="profile_data" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler"/>
+        <result property="defaultQueueName" column="default_queue_name"/>
+        <result property="defaultRuleChainId" column="default_rule_chain_id"/>
+        <result property="default" column="is_default"/>
+        <result property="type" column="type"/>
+    </resultMap>
+
+
+    <sql id="basicColumns">
+        base.name,base.image,base.description,base.tenant_id,base.transport_type,base.provision_type,base.profile_data,base.default_queue_name,base.default_rule_chain_id,base.is_default,base.type
+        ,iot.id,iot.script_id,iot.device_type,iot.create_time,iot.update_time,iot.creator,iot.updater
+    </sql>
+
+    <select id="getProfilePage" resultMap="detail">
+        SELECT
+        <include refid="basicColumns"/>
+        FROM device_profile base
+        LEFT JOIN iotfs_device_profile iot ON iot.tb_profile_id = base.id::TEXT
+        <where>
+            <if test="tenantId !=null and tenantId !=''">
+                AND base.tenant_id::TEXT = #{tenantId}
+            </if>
+            <if test="profileName !=null and profileName !=''">
+                AND base.name = #{profileName}
+            </if>
+            <if test="transportType !=null and transportType !=''">
+                AND base.transport_type = #{transportType}
+            </if>
+        </where>
+    </select>
+
+
+    <select id="selectDetail" resultMap="detail">
+        SELECT
+        <include refid="basicColumns"/>,d.customer_id::TEXT AS customer_id,cus.title AS cusotomer_name
+        FROM device_profile base
+        LEFT JOIN iotfs_device_profile iot ON iot.tb_profile_id = base.id::TEXT
+        <where>
+            <if test="tenantId !=null and tenantId !=''">
+                AND iot.tenant_id = #{tenantId}
+            </if>
+            <if test="id !=null and id !=''">
+                AND base.id = #{id}
+            </if>
+        </where>
+    </select>
+</mapper>

@@ -939,6 +939,11 @@
             </dependency>
             <dependency>
                 <groupId>org.thingsboard.common.transport</groupId>
+                <artifactId>tcp</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.thingsboard.common.transport</groupId>
                 <artifactId>http</artifactId>
                 <version>${project.version}</version>
             </dependency>

@@ -41,7 +41,7 @@
         <pkg.copyInstallScripts>false</pkg.copyInstallScripts>
         <pkg.win.dist>${project.build.directory}/windows</pkg.win.dist>
         <pkg.implementationTitle>ThingsBoard MQTT Transport Service</pkg.implementationTitle>
-        <pkg.mainClass>org.thingsboard.server.mqtt.ThingsboardMqttTransportApplication</pkg.mainClass>
+        <pkg.mainClass>org.thingsboard.server.tcp.ThingsboardMqttTransportApplication</pkg.mainClass>
     </properties>
 
     <dependencies>

@@ -36,6 +36,7 @@
     <modules>
         <module>http</module>
         <module>mqtt</module>
+        <module>tcp</module>
         <module>coap</module>
         <module>lwm2m</module>
         <module>snmp</module>

+<!--
+
+    Copyright © 2016-2022 The Thingsboard Authors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.thingsboard</groupId>
+        <version>3.3.4-SNAPSHOT</version>
+        <artifactId>transport</artifactId>
+    </parent>
+    <groupId>org.thingsboard.transport</groupId>
+    <artifactId>tcp</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Thingsboard TCP Transport Service</name>
+    <url>https://thingsboard.io</url>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <main.dir>${basedir}/../..</main.dir>
+        <pkg.type>java</pkg.type>
+        <pkg.disabled>false</pkg.disabled>
+        <pkg.process-resources.phase>process-resources</pkg.process-resources.phase>
+        <pkg.package.phase>package</pkg.package.phase>
+        <pkg.name>tb-tcp-transport</pkg.name>
+        <pkg.copyInstallScripts>false</pkg.copyInstallScripts>
+        <pkg.win.dist>${project.build.directory}/windows</pkg.win.dist>
+        <pkg.implementationTitle>ThingsBoard TCP Transport Service</pkg.implementationTitle>
+        <pkg.mainClass>org.thingsboard.server.tcp.ThingsboardTcpTransportApplication</pkg.mainClass>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.thingsboard.common.transport</groupId>
+            <artifactId>tcp</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common</groupId>
+            <artifactId>queue</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.sun.winsw</groupId>
+            <artifactId>winsw</artifactId>
+            <classifier>bin</classifier>
+            <type>exe</type>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.vintage</groupId>
+            <artifactId>junit-vintage-engine</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>${pkg.name}-${project.version}</finalName>
+        <resources>
+            <resource>
+                <directory>${project.basedir}/src/main/resources</directory>
+            </resource>
+        </resources>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-resources-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.thingsboard</groupId>
+                <artifactId>gradle-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-install-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+    <repositories>
+        <repository>
+            <id>jenkins</id>
+            <name>Jenkins Repository</name>
+            <url>https://repo.jenkins-ci.org/releases</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
+</project>

+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+
+    Copyright © 2016-2022 The Thingsboard Authors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<!DOCTYPE configuration>
+<configuration>
+
+    <appender name="fileLogAppender"
+              class="ch.qos.logback.core.rolling.RollingFileAppender">
+        <file>${pkg.logFolder}/${pkg.name}.log</file>
+        <rollingPolicy
+                class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
+            <fileNamePattern>${pkg.logFolder}/${pkg.name}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
+            <maxFileSize>100MB</maxFileSize>
+            <maxHistory>30</maxHistory>
+            <totalSizeCap>3GB</totalSizeCap>
+        </rollingPolicy>
+        <encoder>
+            <pattern>%d{ISO8601} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.thingsboard.server" level="INFO" />
+
+    <logger name="com.microsoft.azure.servicebus.primitives.CoreMessageReceiver" level="OFF" />
+
+    <root level="INFO">
+        <appender-ref ref="fileLogAppender"/>
+    </root>
+
+</configuration>

+#
+# Copyright © 2016-2022 The Thingsboard Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+export JAVA_OPTS="$JAVA_OPTS -Xlog:gc*,heap*,age*,safepoint=debug:file=@pkg.logFolder@/gc.log:time,uptime,level,tags:filecount=10,filesize=10M"
+export JAVA_OPTS="$JAVA_OPTS -XX:+IgnoreUnrecognizedVMOptions -XX:+HeapDumpOnOutOfMemoryError"
+export JAVA_OPTS="$JAVA_OPTS -XX:-UseBiasedLocking -XX:+UseTLAB -XX:+ResizeTLAB -XX:+PerfDisableSharedMem -XX:+UseCondCardMark"
+export JAVA_OPTS="$JAVA_OPTS -XX:+UseG1GC -XX:MaxGCPauseMillis=500 -XX:+UseStringDeduplication -XX:+ParallelRefProcEnabled -XX:MaxTenuringThreshold=10"
+export LOG_FILENAME=${pkg.name}.out
+export LOADER_PATH=${pkg.installFolder}/conf

+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.tcp;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.SpringBootConfiguration;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+import java.util.Arrays;
+
+@SpringBootConfiguration
+@EnableAsync
+@EnableScheduling
+@ComponentScan({"org.thingsboard.server.tcp", "org.thingsboard.server.common", "org.thingsboard.server.transport.tcp", "org.thingsboard.server.queue", "org.thingsboard.server.cache"})
+public class ThingsboardTcpTransportApplication {
+
+    private static final String SPRING_CONFIG_NAME_KEY = "--spring.config.name";
+    private static final String DEFAULT_SPRING_CONFIG_PARAM = SPRING_CONFIG_NAME_KEY + "=" + "tb-tcp-transport";
+
+    public static void main(String[] args) {
+        SpringApplication.run(ThingsboardTcpTransportApplication.class, updateArguments(args));
+    }
+
+    private static String[] updateArguments(String[] args) {
+        if (Arrays.stream(args).noneMatch(arg -> arg.startsWith(SPRING_CONFIG_NAME_KEY))) {
+            String[] modifiedArgs = new String[args.length + 1];
+            System.arraycopy(args, 0, modifiedArgs, 0, args.length);
+            modifiedArgs[args.length] = DEFAULT_SPRING_CONFIG_PARAM;
+            return modifiedArgs;
+        }
+        return args;
+    }
+}

+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+
+    Copyright © 2016-2022 The Thingsboard Authors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
+<!DOCTYPE configuration>
+<configuration scan="true" scanPeriod="10 seconds">
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{ISO8601} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.thingsboard.server" level="TRACE" />
+
+    <logger name="com.microsoft.azure.servicebus.primitives.CoreMessageReceiver" level="OFF" />
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT"/>
+    </root>
+
+</configuration>
\ No newline at end of file

+#
+# Copyright © 2016-2022 The Thingsboard Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# If you enabled process metrics you should also enable 'web-environment'.
+spring.main.web-environment: "${WEB_APPLICATION_ENABLE:false}"
+# If you enabled process metrics you should set 'web-application-type' to 'servlet' value.
+spring.main.web-application-type: "${WEB_APPLICATION_TYPE:none}"
+
+server:
+  # Server bind address (has no effect if web-environment is disabled).
+  address: "${HTTP_BIND_ADDRESS:0.0.0.0}"
+  # Server bind port (has no effect if web-environment is disabled).
+  port: "${HTTP_BIND_PORT:8083}"
+
+# Zookeeper connection parameters. Used for service discovery.
+zk:
+  # Enable/disable zookeeper discovery service.
+  enabled: "${ZOOKEEPER_ENABLED:true}"
+  # Zookeeper connect string
+  url: "${ZOOKEEPER_URL:47.99.141.212:2181}"
+  # Zookeeper retry interval in milliseconds
+  retry_interval_ms: "${ZOOKEEPER_RETRY_INTERVAL_MS:3000}"
+  # Zookeeper connection timeout in milliseconds
+  connection_timeout_ms: "${ZOOKEEPER_CONNECTION_TIMEOUT_MS:3000}"
+  # Zookeeper session timeout in milliseconds
+  session_timeout_ms: "${ZOOKEEPER_SESSION_TIMEOUT_MS:3000}"
+  # Name of the directory in zookeeper 'filesystem'
+  zk_dir: "${ZOOKEEPER_NODES_DIR:/thingsboard}"
+
+cache:
+  type: "${CACHE_TYPE:redis}"
+
+redis:
+  # standalone or cluster
+  connection:
+    type: "${REDIS_CONNECTION_TYPE:standalone}"
+  standalone:
+    host: "${REDIS_HOST:localhost}"
+    port: "${REDIS_PORT:6379}"
+    useDefaultClientConfig: "${REDIS_USE_DEFAULT_CLIENT_CONFIG:true}"
+    # this value may be used only if you used not default ClientConfig
+    clientName: "${REDIS_CLIENT_NAME:standalone}"
+    # this value may be used only if you used not default ClientConfig
+    connectTimeout: "${REDIS_CLIENT_CONNECT_TIMEOUT:30000}"
+    # this value may be used only if you used not default ClientConfig
+    readTimeout: "${REDIS_CLIENT_READ_TIMEOUT:60000}"
+    # this value may be used only if you used not default ClientConfig
+    usePoolConfig: "${REDIS_CLIENT_USE_POOL_CONFIG:false}"
+  cluster:
+    # Comma-separated list of "host:port" pairs to bootstrap from.
+    nodes: "${REDIS_NODES:}"
+    # Maximum number of redirects to follow when executing commands across the cluster.
+    max-redirects: "${REDIS_MAX_REDIRECTS:12}"
+    useDefaultPoolConfig: "${REDIS_USE_DEFAULT_POOL_CONFIG:true}"
+  # db index
+  db: "${REDIS_DB:0}"
+  # db password
+  password: "${REDIS_PASSWORD:redis@6379}"
+  # pool config
+  pool_config:
+    maxTotal: "${REDIS_POOL_CONFIG_MAX_TOTAL:128}"
+    maxIdle: "${REDIS_POOL_CONFIG_MAX_IDLE:128}"
+    minIdle: "${REDIS_POOL_CONFIG_MIN_IDLE:16}"
+    testOnBorrow: "${REDIS_POOL_CONFIG_TEST_ON_BORROW:true}"
+    testOnReturn: "${REDIS_POOL_CONFIG_TEST_ON_RETURN:true}"
+    testWhileIdle: "${REDIS_POOL_CONFIG_TEST_WHILE_IDLE:true}"
+    minEvictableMs: "${REDIS_POOL_CONFIG_MIN_EVICTABLE_MS:60000}"
+    evictionRunsMs: "${REDIS_POOL_CONFIG_EVICTION_RUNS_MS:30000}"
+    maxWaitMills: "${REDIS_POOL_CONFIG_MAX_WAIT_MS:60000}"
+    numberTestsPerEvictionRun: "${REDIS_POOL_CONFIG_NUMBER_TESTS_PER_EVICTION_RUN:3}"
+    blockWhenExhausted: "${REDIS_POOL_CONFIG_BLOCK_WHEN_EXHAUSTED:true}"
+
+# TCP_ server parameters
+transport:
+  tcp:
+    bind_address: "${TCP_BIND_ADDRESS:0.0.0.0}"
+    bind_port: "${TCP_BIND_PORT:8088}"
+    # Enable proxy protocol support. Disabled by default. If enabled, supports both v1 and v2.
+    # Useful to get the real IP address of the client in the logs and for rate limits.
+    proxy_enabled: "${TCP_PROXY_PROTOCOL_ENABLED:false}"
+    timeout: "${TCP_TIMEOUT:10000}"
+    msg_queue_size_per_device_limit: "${TCP_MSG_QUEUE_SIZE_PER_DEVICE_LIMIT:100}" # messages await in the queue before device connected state. This limit works on low level before TenantProfileLimits mechanism
+    netty:
+      leak_detector_level: "${NETTY_LEAK_DETECTOR_LVL:DISABLED}"
+      boss_group_thread_count: "${NETTY_BOSS_GROUP_THREADS:1}"
+      worker_group_thread_count: "${NETTY_WORKER_GROUP_THREADS:12}"
+      max_payload_size: "${NETTY_MAX_PAYLOAD_SIZE:65536}"
+      so_keep_alive: "${NETTY_SO_KEEPALIVE:false}"
+    # TCP_ SSL configuration
+    ssl:
+      # Enable/disable SSL support
+      enabled: "${TCP_SSL_ENABLED:false}"
+      # TCP_ SSL bind address
+      bind_address: "${TCP_SSL_BIND_ADDRESS:0.0.0.0}"
+      # TCP_ SSL bind port
+      bind_port: "${TCP_SSL_BIND_PORT:8883}"
+      # SSL protocol: See https://docs.oracle.com/en/java/javase/11/docs/specs/security/standard-names.html#sslcontext-algorithms
+      protocol: "${TCP_SSL_PROTOCOL:TLSv1.2}"
+      # Server SSL credentials
+      credentials:
+        # Server credentials type (PEM - pem certificate file; KEYSTORE - java keystore)
+        type:  "${TCP_SSL_CREDENTIALS_TYPE:PEM}"
+        # PEM server credentials
+        pem:
+          # Path to the server certificate file (holds server certificate or certificate chain, may include server private key)
+          cert_file: "${TCP_SSL_PEM_CERT:tcpserver.pem}"
+          # Path to the server certificate private key file. Optional by default. Required if the private key is not present in server certificate file;
+          key_file: "${TCP_SSL_PEM_KEY:tcpserver_key.pem}"
+          # Server certificate private key password (optional)
+          key_password: "${TCP_SSL_PEM_KEY_PASSWORD:server_key_password}"
+        # Keystore server credentials
+        keystore:
+          # Type of the key store
+          type: "${TCP_SSL_KEY_STORE_TYPE:JKS}"
+          # Path to the key store that holds the SSL certificate
+          store_file: "${TCP_SSL_KEY_STORE:tcpserver.jks}"
+          # Password used to access the key store
+          store_password: "${TCP_SSL_KEY_STORE_PASSWORD:server_ks_password}"
+          # Optional alias of the private key; If not set, the platform will load the first private key from the keystore;
+          key_alias: "${TCP_SSL_KEY_ALIAS:}"
+          # Password used to access the key
+          key_password: "${TCP_SSL_KEY_PASSWORD:server_key_password}"
+      # Skip certificate validity check for client certificates.
+      skip_validity_check_for_client_cert: "${TCP_SSL_SKIP_VALIDITY_CHECK_FOR_CLIENT_CERT:false}"
+  sessions:
+    inactivity_timeout: "${TB_TRANSPORT_SESSIONS_INACTIVITY_TIMEOUT:300000}"
+    report_timeout: "${TB_TRANSPORT_SESSIONS_REPORT_TIMEOUT:3000}"
+  json:
+    # Cast String data types to Numeric if possible when processing Telemetry/Attributes JSON
+    type_cast_enabled: "${JSON_TYPE_CAST_ENABLED:true}"
+    # Maximum allowed string value length when processing Telemetry/Attributes JSON (0 value disables string value length check)
+    max_string_value_length: "${JSON_MAX_STRING_VALUE_LENGTH:0}"
+  log:
+    enabled: "${TB_TRANSPORT_LOG_ENABLED:true}"
+    max_length: "${TB_TRANSPORT_LOG_MAX_LENGTH:1024}"
+  stats:
+    enabled: "${TB_TRANSPORT_STATS_ENABLED:true}"
+    print-interval-ms: "${TB_TRANSPORT_STATS_PRINT_INTERVAL_MS:60000}"
+  client_side_rpc:
+    timeout: "${CLIENT_SIDE_RPC_TIMEOUT:60000}"
+  rate_limits:
+    # Enable or disable generic rate limits. Device and Tenant specific rate limits are controlled in Tenant Profile.
+    ip_limits_enabled: "${TB_TRANSPORT_IP_RATE_LIMITS_ENABLED:false}"
+    # Maximum number of connect attempts with invalid credentials
+    max_wrong_credentials_per_ip: "${TB_TRANSPORT_MAX_WRONG_CREDENTIALS_PER_IP:10}"
+    # Timeout to expire block IP addresses
+    ip_block_timeout: "${TB_TRANSPORT_IP_BLOCK_TIMEOUT:60000}"
+
+
+queue:
+  type: "${TB_QUEUE_TYPE:kafka}" # kafka (Apache Kafka) or aws-sqs (AWS SQS) or pubsub (PubSub) or service-bus (Azure Service Bus) or rabbitmq (RabbitMQ)
+  kafka:
+    bootstrap.servers: "${TB_KAFKA_SERVERS:47.99.141.212:9092}"
+    acks: "${TB_KAFKA_ACKS:all}"
+    retries: "${TB_KAFKA_RETRIES:1}"
+    batch.size: "${TB_KAFKA_BATCH_SIZE:16384}"
+    linger.ms: "${TB_KAFKA_LINGER_MS:1}"
+    max.request.size: "${TB_KAFKA_MAX_REQUEST_SIZE:1048576}"
+    max.in.flight.requests.per.connection: "${TB_KAFKA_MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION:5}"
+    buffer.memory: "${TB_BUFFER_MEMORY:33554432}"
+    replication_factor: "${TB_QUEUE_KAFKA_REPLICATION_FACTOR:1}"
+    use_confluent_cloud: "${TB_QUEUE_KAFKA_USE_CONFLUENT_CLOUD:false}"
+    confluent:
+      ssl.algorithm: "${TB_QUEUE_KAFKA_CONFLUENT_SSL_ALGORITHM:https}"
+      sasl.mechanism: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_MECHANISM:PLAIN}"
+      sasl.config: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";}"
+      security.protocol: "${TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL}"
+    other: # In this section you can specify custom parameters for Kafka consumer/producer and expose the env variables to configure outside
+      - key: "request.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/producer-configs.html#producerconfigs_request.timeout.ms
+        value: "${TB_QUEUE_KAFKA_REQUEST_TIMEOUT_MS:30000}" # (30 seconds)
+      - key: "session.timeout.ms" # refer to https://docs.confluent.io/platform/current/installation/configuration/consumer-configs.html#consumerconfigs_session.timeout.ms
+        value: "${TB_QUEUE_KAFKA_SESSION_TIMEOUT_MS:10000}" # (10 seconds)
+    topic-properties:
+      rule-engine: "${TB_QUEUE_KAFKA_RE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;min.insync.replicas:1}"
+      core: "${TB_QUEUE_KAFKA_CORE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;min.insync.replicas:1}"
+      transport-api: "${TB_QUEUE_KAFKA_TA_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;min.insync.replicas:1}"
+      notifications: "${TB_QUEUE_KAFKA_NOTIFICATIONS_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;min.insync.replicas:1}"
+      js-executor: "${TB_QUEUE_KAFKA_JE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:104857600;partitions:100;min.insync.replicas:1}"
+  aws_sqs:
+    use_default_credential_provider_chain: "${TB_QUEUE_AWS_SQS_USE_DEFAULT_CREDENTIAL_PROVIDER_CHAIN:false}"
+    access_key_id: "${TB_QUEUE_AWS_SQS_ACCESS_KEY_ID:YOUR_KEY}"
+    secret_access_key: "${TB_QUEUE_AWS_SQS_SECRET_ACCESS_KEY:YOUR_SECRET}"
+    region: "${TB_QUEUE_AWS_SQS_REGION:YOUR_REGION}"
+    threads_per_topic: "${TB_QUEUE_AWS_SQS_THREADS_PER_TOPIC:1}"
+    queue-properties:
+      rule-engine: "${TB_QUEUE_AWS_SQS_RE_QUEUE_PROPERTIES:VisibilityTimeout:30;MaximumMessageSize:262144;MessageRetentionPeriod:604800}"
+      core: "${TB_QUEUE_AWS_SQS_CORE_QUEUE_PROPERTIES:VisibilityTimeout:30;MaximumMessageSize:262144;MessageRetentionPeriod:604800}"
+      transport-api: "${TB_QUEUE_AWS_SQS_TA_QUEUE_PROPERTIES:VisibilityTimeout:30;MaximumMessageSize:262144;MessageRetentionPeriod:604800}"
+      notifications: "${TB_QUEUE_AWS_SQS_NOTIFICATIONS_QUEUE_PROPERTIES:VisibilityTimeout:30;MaximumMessageSize:262144;MessageRetentionPeriod:604800}"
+      js-executor: "${TB_QUEUE_AWS_SQS_JE_QUEUE_PROPERTIES:VisibilityTimeout:30;MaximumMessageSize:262144;MessageRetentionPeriod:604800}"
+      #    VisibilityTimeout in seconds;MaximumMessageSize in bytes;MessageRetentionPeriod in seconds
+  pubsub:
+    project_id: "${TB_QUEUE_PUBSUB_PROJECT_ID:YOUR_PROJECT_ID}"
+    service_account: "${TB_QUEUE_PUBSUB_SERVICE_ACCOUNT:YOUR_SERVICE_ACCOUNT}"
+    max_msg_size: "${TB_QUEUE_PUBSUB_MAX_MSG_SIZE:1048576}" #in bytes
+    max_messages: "${TB_QUEUE_PUBSUB_MAX_MESSAGES:1000}"
+    queue-properties:
+      rule-engine: "${TB_QUEUE_PUBSUB_RE_QUEUE_PROPERTIES:ackDeadlineInSec:30;messageRetentionInSec:604800}"
+      core: "${TB_QUEUE_PUBSUB_CORE_QUEUE_PROPERTIES:ackDeadlineInSec:30;messageRetentionInSec:604800}"
+      transport-api: "${TB_QUEUE_PUBSUB_TA_QUEUE_PROPERTIES:ackDeadlineInSec:30;messageRetentionInSec:604800}"
+      notifications: "${TB_QUEUE_PUBSUB_NOTIFICATIONS_QUEUE_PROPERTIES:ackDeadlineInSec:30;messageRetentionInSec:604800}"
+      js-executor: "${TB_QUEUE_PUBSUB_JE_QUEUE_PROPERTIES:ackDeadlineInSec:30;messageRetentionInSec:604800}"
+  service_bus:
+    namespace_name: "${TB_QUEUE_SERVICE_BUS_NAMESPACE_NAME:YOUR_NAMESPACE_NAME}"
+    sas_key_name: "${TB_QUEUE_SERVICE_BUS_SAS_KEY_NAME:YOUR_SAS_KEY_NAME}"
+    sas_key: "${TB_QUEUE_SERVICE_BUS_SAS_KEY:YOUR_SAS_KEY}"
+    max_messages: "${TB_QUEUE_SERVICE_BUS_MAX_MESSAGES:1000}"
+    queue-properties:
+      rule-engine: "${TB_QUEUE_SERVICE_BUS_RE_QUEUE_PROPERTIES:lockDurationInSec:30;maxSizeInMb:1024;messageTimeToLiveInSec:604800}"
+      core: "${TB_QUEUE_SERVICE_BUS_CORE_QUEUE_PROPERTIES:lockDurationInSec:30;maxSizeInMb:1024;messageTimeToLiveInSec:604800}"
+      transport-api: "${TB_QUEUE_SERVICE_BUS_TA_QUEUE_PROPERTIES:lockDurationInSec:30;maxSizeInMb:1024;messageTimeToLiveInSec:604800}"
+      notifications: "${TB_QUEUE_SERVICE_BUS_NOTIFICATIONS_QUEUE_PROPERTIES:lockDurationInSec:30;maxSizeInMb:1024;messageTimeToLiveInSec:604800}"
+      js-executor: "${TB_QUEUE_SERVICE_BUS_JE_QUEUE_PROPERTIES:lockDurationInSec:30;maxSizeInMb:1024;messageTimeToLiveInSec:604800}"
+  rabbitmq:
+    exchange_name: "${TB_QUEUE_RABBIT_MQ_EXCHANGE_NAME:}"
+    host: "${TB_QUEUE_RABBIT_MQ_HOST:localhost}"
+    port: "${TB_QUEUE_RABBIT_MQ_PORT:5672}"
+    virtual_host: "${TB_QUEUE_RABBIT_MQ_VIRTUAL_HOST:/}"
+    username: "${TB_QUEUE_RABBIT_MQ_USERNAME:YOUR_USERNAME}"
+    password: "${TB_QUEUE_RABBIT_MQ_PASSWORD:YOUR_PASSWORD}"
+    automatic_recovery_enabled: "${TB_QUEUE_RABBIT_MQ_AUTOMATIC_RECOVERY_ENABLED:false}"
+    connection_timeout: "${TB_QUEUE_RABBIT_MQ_CONNECTION_TIMEOUT:60000}"
+    handshake_timeout: "${TB_QUEUE_RABBIT_MQ_HANDSHAKE_TIMEOUT:10000}"
+    queue-properties:
+      rule-engine: "${TB_QUEUE_RABBIT_MQ_RE_QUEUE_PROPERTIES:x-max-length-bytes:1048576000;x-message-ttl:604800000}"
+      core: "${TB_QUEUE_RABBIT_MQ_CORE_QUEUE_PROPERTIES:x-max-length-bytes:1048576000;x-message-ttl:604800000}"
+      transport-api: "${TB_QUEUE_RABBIT_MQ_TA_QUEUE_PROPERTIES:x-max-length-bytes:1048576000;x-message-ttl:604800000}"
+      notifications: "${TB_QUEUE_RABBIT_MQ_NOTIFICATIONS_QUEUE_PROPERTIES:x-max-length-bytes:1048576000;x-message-ttl:604800000}"
+      js-executor: "${TB_QUEUE_RABBIT_MQ_JE_QUEUE_PROPERTIES:x-max-length-bytes:1048576000;x-message-ttl:604800000}"
+  partitions:
+    hash_function_name: "${TB_QUEUE_PARTITIONS_HASH_FUNCTION_NAME:murmur3_128}"
+    virtual_nodes_size: "${TB_QUEUE_PARTITIONS_VIRTUAL_NODES_SIZE:16}"
+  transport_api:
+    requests_topic: "${TB_QUEUE_TRANSPORT_API_REQUEST_TOPIC:tb_transport.api.requests}"
+    responses_topic: "${TB_QUEUE_TRANSPORT_API_RESPONSE_TOPIC:tb_transport.api.responses}"
+    max_pending_requests: "${TB_QUEUE_TRANSPORT_MAX_PENDING_REQUESTS:10000}"
+    max_requests_timeout: "${TB_QUEUE_TRANSPORT_MAX_REQUEST_TIMEOUT:10000}"
+    max_callback_threads: "${TB_QUEUE_TRANSPORT_MAX_CALLBACK_THREADS:100}"
+    request_poll_interval: "${TB_QUEUE_TRANSPORT_REQUEST_POLL_INTERVAL_MS:25}"
+    response_poll_interval: "${TB_QUEUE_TRANSPORT_RESPONSE_POLL_INTERVAL_MS:25}"
+  core:
+    topic: "${TB_QUEUE_CORE_TOPIC:tb_core}"
+    poll-interval: "${TB_QUEUE_CORE_POLL_INTERVAL_MS:25}"
+    partitions: "${TB_QUEUE_CORE_PARTITIONS:10}"
+    pack-processing-timeout: "${TB_QUEUE_CORE_PACK_PROCESSING_TIMEOUT_MS:60000}"
+    usage-stats-topic: "${TB_QUEUE_US_TOPIC:tb_usage_stats}"
+    stats:
+      enabled: "${TB_QUEUE_CORE_STATS_ENABLED:false}"
+      print-interval-ms: "${TB_QUEUE_CORE_STATS_PRINT_INTERVAL_MS:10000}"
+  js:
+    # JS Eval request topic
+    request_topic: "${REMOTE_JS_EVAL_REQUEST_TOPIC:js_eval.requests}"
+    # JS Eval responses topic prefix that is combined with node id
+    response_topic_prefix: "${REMOTE_JS_EVAL_RESPONSE_TOPIC:js_eval.responses}"
+    # JS Eval max pending requests
+    max_pending_requests: "${REMOTE_JS_MAX_PENDING_REQUESTS:10000}"
+    # JS Eval max request timeout
+    max_requests_timeout: "${REMOTE_JS_MAX_REQUEST_TIMEOUT:10000}"
+    # JS response poll interval
+    response_poll_interval: "${REMOTE_JS_RESPONSE_POLL_INTERVAL_MS:25}"
+  rule-engine:
+    topic: "${TB_QUEUE_RULE_ENGINE_TOPIC:tb_rule_engine}"
+    poll-interval: "${TB_QUEUE_RULE_ENGINE_POLL_INTERVAL_MS:25}"
+    pack-processing-timeout: "${TB_QUEUE_RULE_ENGINE_PACK_PROCESSING_TIMEOUT_MS:60000}"
+    stats:
+      enabled: "${TB_QUEUE_RULE_ENGINE_STATS_ENABLED:true}"
+      print-interval-ms: "${TB_QUEUE_RULE_ENGINE_STATS_PRINT_INTERVAL_MS:60000}"
+    queues:
+      - name: "${TB_QUEUE_RE_MAIN_QUEUE_NAME:Main}"
+        topic: "${TB_QUEUE_RE_MAIN_TOPIC:tb_rule_engine.main}"
+        poll-interval: "${TB_QUEUE_RE_MAIN_POLL_INTERVAL_MS:25}"
+        partitions: "${TB_QUEUE_RE_MAIN_PARTITIONS:10}"
+        pack-processing-timeout: "${TB_QUEUE_RE_MAIN_PACK_PROCESSING_TIMEOUT_MS:60000}"
+        submit-strategy:
+          type: "${TB_QUEUE_RE_MAIN_SUBMIT_STRATEGY_TYPE:BURST}" # BURST, BATCH, SEQUENTIAL_BY_ORIGINATOR, SEQUENTIAL_BY_TENANT, SEQUENTIAL
+          # For BATCH only
+          batch-size: "${TB_QUEUE_RE_MAIN_SUBMIT_STRATEGY_BATCH_SIZE:1000}" # Maximum number of messages in batch
+        processing-strategy:
+          type: "${TB_QUEUE_RE_MAIN_PROCESSING_STRATEGY_TYPE:SKIP_ALL_FAILURES}" # SKIP_ALL_FAILURES, SKIP_ALL_FAILURES_AND_TIMED_OUT, RETRY_ALL, RETRY_FAILED, RETRY_TIMED_OUT, RETRY_FAILED_AND_TIMED_OUT
+          # For RETRY_ALL, RETRY_FAILED, RETRY_TIMED_OUT, RETRY_FAILED_AND_TIMED_OUT
+          retries: "${TB_QUEUE_RE_MAIN_PROCESSING_STRATEGY_RETRIES:3}" # Number of retries, 0 is unlimited
+          failure-percentage: "${TB_QUEUE_RE_MAIN_PROCESSING_STRATEGY_FAILURE_PERCENTAGE:0}" # Skip retry if failures or timeouts are less then X percentage of messages;
+          pause-between-retries: "${TB_QUEUE_RE_MAIN_PROCESSING_STRATEGY_RETRY_PAUSE:3}"# Time in seconds to wait in consumer thread before retries;
+      - name: "${TB_QUEUE_RE_HP_QUEUE_NAME:HighPriority}"
+        topic: "${TB_QUEUE_RE_HP_TOPIC:tb_rule_engine.hp}"
+        poll-interval: "${TB_QUEUE_RE_HP_POLL_INTERVAL_MS:25}"
+        partitions: "${TB_QUEUE_RE_HP_PARTITIONS:10}"
+        pack-processing-timeout: "${TB_QUEUE_RE_HP_PACK_PROCESSING_TIMEOUT_MS:60000}"
+        submit-strategy:
+          type: "${TB_QUEUE_RE_HP_SUBMIT_STRATEGY_TYPE:BURST}" # BURST, BATCH, SEQUENTIAL_BY_ORIGINATOR, SEQUENTIAL_BY_TENANT, SEQUENTIAL
+          # For BATCH only
+          batch-size: "${TB_QUEUE_RE_HP_SUBMIT_STRATEGY_BATCH_SIZE:100}" # Maximum number of messages in batch
+        processing-strategy:
+          type: "${TB_QUEUE_RE_HP_PROCESSING_STRATEGY_TYPE:RETRY_FAILED_AND_TIMED_OUT}" # SKIP_ALL_FAILURES, SKIP_ALL_FAILURES_AND_TIMED_OUT, RETRY_ALL, RETRY_FAILED, RETRY_TIMED_OUT, RETRY_FAILED_AND_TIMED_OUT
+          # For RETRY_ALL, RETRY_FAILED, RETRY_TIMED_OUT, RETRY_FAILED_AND_TIMED_OUT
+          retries: "${TB_QUEUE_RE_HP_PROCESSING_STRATEGY_RETRIES:0}" # Number of retries, 0 is unlimited
+          failure-percentage: "${TB_QUEUE_RE_HP_PROCESSING_STRATEGY_FAILURE_PERCENTAGE:0}" # Skip retry if failures or timeouts are less then X percentage of messages;
+          pause-between-retries: "${TB_QUEUE_RE_HP_PROCESSING_STRATEGY_RETRY_PAUSE:5}"# Time in seconds to wait in consumer thread before retries;
+      - name: "${TB_QUEUE_RE_SQ_QUEUE_NAME:SequentialByOriginator}"
+        topic: "${TB_QUEUE_RE_SQ_TOPIC:tb_rule_engine.sq}"
+        poll-interval: "${TB_QUEUE_RE_SQ_POLL_INTERVAL_MS:25}"
+        partitions: "${TB_QUEUE_RE_SQ_PARTITIONS:10}"
+        pack-processing-timeout: "${TB_QUEUE_RE_SQ_PACK_PROCESSING_TIMEOUT_MS:60000}"
+        submit-strategy:
+          type: "${TB_QUEUE_RE_SQ_SUBMIT_STRATEGY_TYPE:SEQUENTIAL_BY_ORIGINATOR}" # BURST, BATCH, SEQUENTIAL_BY_ORIGINATOR, SEQUENTIAL_BY_TENANT, SEQUENTIAL
+          # For BATCH only
+          batch-size: "${TB_QUEUE_RE_SQ_SUBMIT_STRATEGY_BATCH_SIZE:100}" # Maximum number of messages in batch
+        processing-strategy:
+          type: "${TB_QUEUE_RE_SQ_PROCESSING_STRATEGY_TYPE:RETRY_FAILED_AND_TIMED_OUT}" # SKIP_ALL_FAILURES, SKIP_ALL_FAILURES_AND_TIMED_OUT, RETRY_ALL, RETRY_FAILED, RETRY_TIMED_OUT, RETRY_FAILED_AND_TIMED_OUT
+          # For RETRY_ALL, RETRY_FAILED, RETRY_TIMED_OUT, RETRY_FAILED_AND_TIMED_OUT
+          retries: "${TB_QUEUE_RE_SQ_PROCESSING_STRATEGY_RETRIES:3}" # Number of retries, 0 is unlimited
+          failure-percentage: "${TB_QUEUE_RE_SQ_PROCESSING_STRATEGY_FAILURE_PERCENTAGE:0}" # Skip retry if failures or timeouts are less then X percentage of messages;
+          pause-between-retries: "${TB_QUEUE_RE_SQ_PROCESSING_STRATEGY_RETRY_PAUSE:5}"# Time in seconds to wait in consumer thread before retries;
+  transport:
+    # For high priority notifications that require minimum latency and processing time
+    notifications_topic: "${TB_QUEUE_TRANSPORT_NOTIFICATIONS_TOPIC:tb_transport.notifications}"
+    poll_interval: "${TB_QUEUE_TRANSPORT_NOTIFICATIONS_POLL_INTERVAL_MS:25}"
+
+service:
+  type: "${TB_SERVICE_TYPE:tb-transport}"
+  # Unique id for this service (autogenerated if empty)
+  id: "${TB_SERVICE_ID:}"
+  tenant_id: "${TB_SERVICE_TENANT_ID:}" # empty or specific tenant id.
+
+metrics:
+  # Enable/disable actuator metrics.
+  enabled: "${METRICS_ENABLED:false}"
+
+management:
+  endpoints:
+    web:
+      exposure:
+        # Expose metrics endpoint (use value 'prometheus' to enable prometheus metrics).
+        include: '${METRICS_ENDPOINTS_EXPOSE:info}'

@@ -44,6 +44,7 @@ export enum DeviceProfileType {
 export enum DeviceTransportType {
   DEFAULT = 'DEFAULT',
   MQTT = 'MQTT',
+  TCP = 'TCP',
   COAP = 'COAP',
   LWM2M = 'LWM2M',
   SNMP = 'SNMP'
@@ -99,6 +100,7 @@ export const deviceTransportTypeTranslationMap = new Map<DeviceTransportType, st
   [
     [DeviceTransportType.DEFAULT, 'device-profile.transport-type-default'],
     [DeviceTransportType.MQTT, 'device-profile.transport-type-mqtt'],
+    [DeviceTransportType.TCP, 'device-profile.transport-type-tcp'],
     [DeviceTransportType.COAP, 'device-profile.transport-type-coap'],
     [DeviceTransportType.LWM2M, 'device-profile.transport-type-lwm2m'],
     [DeviceTransportType.SNMP, 'device-profile.transport-type-snmp']
@@ -118,6 +120,7 @@ export const deviceTransportTypeHintMap = new Map<DeviceTransportType, string>(
   [
     [DeviceTransportType.DEFAULT, 'device-profile.transport-type-default-hint'],
     [DeviceTransportType.MQTT, 'device-profile.transport-type-mqtt-hint'],
+    [DeviceTransportType.TCP, 'device-profile.transport-type-mqtt-hint'],
     [DeviceTransportType.COAP, 'device-profile.transport-type-coap-hint'],
     [DeviceTransportType.LWM2M, 'device-profile.transport-type-lwm2m-hint'],
     [DeviceTransportType.SNMP, 'device-profile.transport-type-snmp-hint']
@@ -202,6 +205,13 @@ export const deviceTransportTypeConfigurationInfoMap = new Map<DeviceTransportTy
       }
     ],
     [
+      DeviceTransportType.TCP,
+      {
+        hasProfileConfiguration: true,
+        hasDeviceConfiguration: false,
+      }
+    ],
+    [
       DeviceTransportType.LWM2M,
       {
         hasProfileConfiguration: true,
@@ -250,6 +260,11 @@ export interface MqttDeviceProfileTransportConfiguration {
   [key: string]: any;
 }
 
+//Thingskit function
+export interface YtTcpDeviceProfileTransportConfiguration {
+  [key: string]: any;
+}
+
 export interface CoapClientSetting {
   powerMode?: PowerMode | null;
   edrxCycle?: number;
@@ -306,6 +321,7 @@ export interface SnmpMapping {
 
 export type DeviceProfileTransportConfigurations = DefaultDeviceProfileTransportConfiguration &
                                                    MqttDeviceProfileTransportConfiguration &
+                                                   YtTcpDeviceProfileTransportConfiguration &
                                                    CoapDeviceProfileTransportConfiguration &
                                                    Lwm2mDeviceProfileTransportConfiguration &
                                                    SnmpDeviceProfileTransportConfiguration;
@@ -366,6 +382,10 @@ export function createDeviceProfileTransportConfiguration(type: DeviceTransportT
         };
         transportConfiguration = {...mqttTransportConfiguration, type: DeviceTransportType.MQTT};
         break;
+      case DeviceTransportType.TCP:
+        const tcpTransportConfiguration: YtTcpDeviceProfileTransportConfiguration = {};
+        transportConfiguration = {...tcpTransportConfiguration, type: DeviceTransportType.TCP};
+        break;
       case DeviceTransportType.COAP:
         const coapTransportConfiguration: CoapDeviceProfileTransportConfiguration = {
           coapDeviceTypeConfiguration: {
@@ -411,6 +431,10 @@ export function createDeviceTransportConfiguration(type: DeviceTransportType): D
         const mqttTransportConfiguration: MqttDeviceTransportConfiguration = {};
         transportConfiguration = {...mqttTransportConfiguration, type: DeviceTransportType.MQTT};
         break;
+      case DeviceTransportType.TCP:
+        const tcpTransportConfiguration: YtTcpDeviceTransportConfiguration = {};
+        transportConfiguration = {...tcpTransportConfiguration, type: DeviceTransportType.TCP};
+        break;
       case DeviceTransportType.COAP:
         const coapTransportConfiguration: CoapDeviceTransportConfiguration = {
           powerMode: null
@@ -600,6 +624,10 @@ export interface MqttDeviceTransportConfiguration {
   [key: string]: any;
 }
 
+export interface YtTcpDeviceTransportConfiguration {
+  [key: string]: any;
+}
+
 export interface CoapDeviceTransportConfiguration {
   powerMode?: PowerMode | null;
   edrxCycle?: number;
@@ -725,6 +753,9 @@ export const credentialTypesByTransportType = new Map<DeviceTransportType, Devic
     [DeviceTransportType.MQTT, [
       DeviceCredentialsType.ACCESS_TOKEN, DeviceCredentialsType.X509_CERTIFICATE, DeviceCredentialsType.MQTT_BASIC
     ]],
+    [DeviceTransportType.TCP, [
+      DeviceCredentialsType.ACCESS_TOKEN
+    ]],
     [DeviceTransportType.COAP, [DeviceCredentialsType.ACCESS_TOKEN, DeviceCredentialsType.X509_CERTIFICATE]],
     [DeviceTransportType.LWM2M, [DeviceCredentialsType.LWM2M_CREDENTIALS]],
     [DeviceTransportType.SNMP, [DeviceCredentialsType.ACCESS_TOKEN]]

@@ -999,6 +999,7 @@
     "transport-type-lwm2m": "LWM2M",
     "transport-type-lwm2m-hint": "LWM2M传输类型",
     "transport-type-mqtt": "MQTT",
+    "transport-type-tcp": "TCP",
     "transport-type-mqtt-hint": "启用高级MQTT传输设置",
     "transport-type-required": "传输方式必填。",
     "transport-type-snmp-hint": "指定 SNMP 传输配置",