Merge remote-tracking branch 'upstream/develop/3.3' into develop/3.3-edge

@@ -30,7 +30,8 @@ import java.util.Arrays;
         "org.thingsboard.server.service.component",
         "org.thingsboard.server.service.install",
         "org.thingsboard.server.dao",
-        "org.thingsboard.server.common.stats"})
+        "org.thingsboard.server.common.stats",
+        "org.thingsboard.server.cache"})
 public class ThingsboardInstallApplication {
 
     private static final String SPRING_CONFIG_NAME_KEY = "--spring.config.name";

@@ -47,8 +47,7 @@ import org.thingsboard.server.common.data.id.EdgeId;
 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.page.TimePageLink;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.security.permission.Operation;

@@ -50,7 +50,7 @@ import org.thingsboard.server.dao.device.provision.ProvisionFailedException;
 import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 import org.thingsboard.server.dao.device.provision.ProvisionResponse;
 import org.thingsboard.server.dao.device.provision.ProvisionResponseStatus;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.queue.TbQueueCallback;

@@ -41,7 +41,7 @@ import org.thingsboard.server.dao.entityview.EntityViewService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.service.install.InstallScripts;
 
 import java.util.ArrayList;
@@ -51,7 +51,6 @@ import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 
 import static org.apache.commons.lang3.StringUtils.isBlank;
-import static org.thingsboard.server.service.install.DatabaseHelper.objectMapper;
 
 @Service
 @Profile("install")

@@ -47,7 +47,7 @@ import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.dao.entity.EntityService;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.executors.DbCallbackExecutorService;
 import org.thingsboard.server.service.security.AccessValidator;

@@ -35,7 +35,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.common.stats.StatsFactory;
 import org.thingsboard.server.common.transport.util.DataDecodingEncodingService;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceStateServiceMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.EdgeNotificationMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.FromDeviceRPCResponseProto;

@@ -49,7 +49,7 @@ import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.settings.AdminSettingsService;
 import org.thingsboard.server.dao.user.UserService;
 import org.thingsboard.server.dao.user.UserServiceImpl;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.service.security.exception.UserPasswordExpiredException;
 import org.thingsboard.server.utils.MiscUtils;
 

@@ -31,7 +31,7 @@ import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.settings.AdminSettingsService;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.queue.usagestats.TbApiUsageClient;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
 

@@ -52,7 +52,7 @@ import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
 import org.thingsboard.server.queue.discovery.PartitionService;

@@ -39,7 +39,7 @@ import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos.*;
 import org.thingsboard.server.gen.transport.TransportProtos.LocalSubscriptionServiceMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.TbSubscriptionUpdateProto;

@@ -30,7 +30,7 @@ import org.thingsboard.server.common.data.kv.KvEntry;
 import org.thingsboard.server.common.data.kv.LongDataEntry;
 import org.thingsboard.server.common.data.kv.StringDataEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.KeyValueProto;
 import org.thingsboard.server.gen.transport.TransportProtos.KeyValueType;

@@ -54,7 +54,7 @@ import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 import org.thingsboard.server.dao.device.provision.ProvisionResponse;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileRequestMsg;

@@ -643,8 +643,8 @@ transport:
         public_y: "${LWM2M_SERVER_PUBLIC_Y_BS:3fc4e61bcd8901ec27c424114c3e887ed372497f0c2cf85839b8443e76988b34}"
         private_encoded: "${LWM2M_SERVER_PRIVATE_ENCODED_BS:308193020100301306072a8648ce3d020106082a8648ce3d0301070479307702010104205ecafd90caa7be45c42e1f3f32571632b8409e6e6249d7124f4ba56fab3c8083a00a06082a8648ce3d030107a144034200045017c87a1c1768264656b3b355434b0def6edb8b9bf166a4762d9930cd730f913fc4e61bcd8901ec27c424114c3e887ed372497f0c2cf85839b8443e76988b34}"        # Only Certificate_x509:
         alias: "${LWM2M_KEYSTORE_ALIAS_BOOTSTRAP:bootstrap}"
-    # Redis
-    redis_url: "${LWM2M_REDIS_URL:''}"
+    # Use redis for Security and Registration stores
+    redis.enabled: "${LWM2M_REDIS_ENABLED:false}"
 
 # Edges parameters
 edges:

@@ -26,7 +26,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.device.profile.MqttTopics;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.mqtt.attributes.AbstractMqttAttributesIntegrationTest;
 
 import java.nio.charset.StandardCharsets;

@@ -25,7 +25,7 @@ import org.junit.Test;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.TransportPayloadType;
 import org.thingsboard.server.common.data.device.profile.MqttTopics;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.mqtt.attributes.AbstractMqttAttributesIntegrationTest;
 
 import java.nio.charset.StandardCharsets;

@@ -37,7 +37,7 @@ import org.thingsboard.server.common.transport.util.JsonUtils;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.device.provision.ProvisionResponseStatus;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
 
 import java.util.concurrent.CountDownLatch;

@@ -36,7 +36,7 @@ import org.thingsboard.server.common.msg.EncryptionUtil;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.device.provision.ProvisionResponseStatus;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.gen.transport.TransportProtos.CredentialsDataProto;
 import org.thingsboard.server.gen.transport.TransportProtos.CredentialsType;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceCredentialsMsg;
@@ -47,7 +47,6 @@ import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceTokenR
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceX509CertRequestMsg;
 import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
 
-import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 

@@ -30,7 +30,7 @@ import org.junit.Assert;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.TransportPayloadType;
 import org.thingsboard.server.common.data.device.profile.MqttTopics;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.mqtt.AbstractMqttIntegrationTest;
 
 import java.util.Arrays;

+<!--
+
+    Copyright © 2016-2021 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.0-SNAPSHOT</version>
+        <artifactId>common</artifactId>
+    </parent>
+    <groupId>org.thingsboard.common</groupId>
+    <artifactId>cache</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Thingsboard Server Common Cache</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</groupId>
+            <artifactId>data</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-redis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.github.ben-manes.caffeine</groupId>
+            <artifactId>caffeine</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</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>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+<!--            <plugin>-->
+<!--                <groupId>org.apache.maven.plugins</groupId>-->
+<!--                <artifactId>maven-source-plugin</artifactId>-->
+<!--                <executions>-->
+<!--                    <execution>-->
+<!--                        <id>attach-sources</id>-->
+<!--                        <goals>-->
+<!--                            <goal>jar</goal>-->
+<!--                        </goals>-->
+<!--                    </execution>-->
+<!--                </executions>-->
+<!--            </plugin>-->
+<!--            <plugin>-->
+<!--                <groupId>org.apache.maven.plugins</groupId>-->
+<!--                <artifactId>maven-deploy-plugin</artifactId>-->
+<!--                <configuration>-->
+<!--                    <skip>false</skip>-->
+<!--                </configuration>-->
+<!--            </plugin>-->
+        </plugins>
+    </build>
+
+</project>

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.dao.cache;
+package org.thingsboard.server.cache;
 
 import lombok.Data;
 

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.dao.cache;
+package org.thingsboard.server.cache;
 
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.RemovalCause;
@@ -26,7 +26,6 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.cache.caffeine.CaffeineCache;
-import org.springframework.cache.interceptor.KeyGenerator;
 import org.springframework.cache.support.SimpleCacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -78,14 +77,9 @@ public class CaffeineCacheConfiguration {
         return Ticker.systemTicker();
     }
 
-    @Bean
-    public KeyGenerator previousDeviceCredentialsId() {
-        return new PreviousDeviceCredentialsIdKeyGenerator();
-    }
-
     private Weigher<? super Object, ? super Object> collectionSafeWeigher() {
         return (Weigher<Object, Object>) (key, value) -> {
-            if(value instanceof Collection) {
+            if (value instanceof Collection) {
                 return ((Collection) value).size();
             }
             return 1;

@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.dao.cache;
+package org.thingsboard.server.cache;
 
 import lombok.Data;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.cache.CacheManager;
 import org.springframework.cache.annotation.EnableCaching;
-import org.springframework.cache.interceptor.KeyGenerator;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.convert.converter.ConverterRegistry;
@@ -90,11 +89,6 @@ public abstract class TBRedisCacheConfiguration {
     }
 
     @Bean
-    public KeyGenerator previousDeviceCredentialsId() {
-        return new PreviousDeviceCredentialsIdKeyGenerator();
-    }
-
-    @Bean
     public RedisTemplate<String, Object> redisTemplate() {
         RedisTemplate<String, Object> template = new RedisTemplate<>();
         template.setConnectionFactory(redisConnectionFactory());

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.dao.cache;
+package org.thingsboard.server.cache;
 
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Value;

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.dao.cache;
+package org.thingsboard.server.cache;
 
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;

@@ -42,6 +42,7 @@
         <module>transport</module>
         <module>dao-api</module>
         <module>stats</module>
+        <module>cache</module>
         <module>edge-api</module>
     </modules>
 

+/**
+ * Copyright © 2016-2021 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.queue.util;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
+public @interface TbLwM2mTransportComponent {
+}

@@ -90,7 +90,6 @@
             <groupId>org.eclipse.leshan</groupId>
             <artifactId>leshan-client-cf</artifactId>
         </dependency>
-
         <dependency>
             <groupId>org.eclipse.leshan</groupId>
             <artifactId>leshan-server-redis</artifactId>

@@ -29,7 +29,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2MBootstrapSecurityStore;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2MInMemoryBootstrapConfigStore;
 import org.thingsboard.server.transport.lwm2m.bootstrap.secure.LwM2mDefaultBootstrapSessionManager;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportContextServer;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportContextServer;
 
 import java.math.BigInteger;
 import java.security.AlgorithmParameters;
@@ -56,7 +56,7 @@ import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_ECDHE
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CBC_SHA256;
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CCM_8;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getCoapConfig;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.getCoapConfig;
 
 @Slf4j
 @Component
@@ -70,7 +70,7 @@ public class LwM2MTransportBootstrapServerConfiguration {
     private LwM2MTransportContextBootstrap contextBs;
 
     @Autowired
-    private LwM2MTransportContextServer contextS;
+    private LwM2mTransportContextServer contextS;
 
     @Autowired
     private LwM2MBootstrapSecurityStore lwM2MBootstrapSecurityStore;
@@ -94,7 +94,7 @@ public class LwM2MTransportBootstrapServerConfiguration {
         builder.setCoapConfig(getCoapConfig(bootstrapPortNoSec, bootstrapSecurePort));
 
         /** Define model provider (Create Models )*/
-        builder.setModel(new StaticModel(contextS.getCtxServer().getModelsValue()));
+        builder.setModel(new StaticModel(contextS.getLwM2MTransportConfigServer().getModelsValue()));
 
         /**  Create credentials */
         this.setServerWithCredentials(builder);
@@ -108,8 +108,8 @@ public class LwM2MTransportBootstrapServerConfiguration {
 
         /** Create and Set DTLS Config */
         DtlsConnectorConfig.Builder dtlsConfig = new DtlsConnectorConfig.Builder();
-        dtlsConfig.setRecommendedSupportedGroupsOnly(this.contextS.getCtxServer().isRecommendedSupportedGroups());
-        dtlsConfig.setRecommendedCipherSuitesOnly(this.contextS.getCtxServer().isRecommendedCiphers());
+        dtlsConfig.setRecommendedSupportedGroupsOnly(this.contextS.getLwM2MTransportConfigServer().isRecommendedSupportedGroups());
+        dtlsConfig.setRecommendedCipherSuitesOnly(this.contextS.getLwM2MTransportConfigServer().isRecommendedCiphers());
         if (this.pskMode) {
             dtlsConfig.setSupportedCipherSuites(
                     TLS_PSK_WITH_AES_128_CCM_8,
@@ -135,10 +135,10 @@ public class LwM2MTransportBootstrapServerConfiguration {
 
     private void setServerWithCredentials(LeshanBootstrapServerBuilder builder) {
         try {
-            if (this.contextS.getCtxServer().getKeyStoreValue() != null) {
-                KeyStore keyStoreServer = this.contextS.getCtxServer().getKeyStoreValue();
+            if (this.contextS.getLwM2MTransportConfigServer().getKeyStoreValue() != null) {
+                KeyStore keyStoreServer = this.contextS.getLwM2MTransportConfigServer().getKeyStoreValue();
                 if (this.setBuilderX509(builder)) {
-                    X509Certificate rootCAX509Cert = (X509Certificate) keyStoreServer.getCertificate(this.contextS.getCtxServer().getRootAlias());
+                    X509Certificate rootCAX509Cert = (X509Certificate) keyStoreServer.getCertificate(this.contextS.getLwM2MTransportConfigServer().getRootAlias());
                     if (rootCAX509Cert != null) {
                         X509Certificate[] trustedCertificates = new X509Certificate[1];
                         trustedCertificates[0] = rootCAX509Cert;
@@ -169,8 +169,8 @@ public class LwM2MTransportBootstrapServerConfiguration {
          * For idea => KeyStorePathResource == common/transport/lwm2m/src/main/resources/credentials: in LwM2MTransportContextServer: credentials/serverKeyStore.jks
          */
         try {
-            X509Certificate serverCertificate = (X509Certificate) this.contextS.getCtxServer().getKeyStoreValue().getCertificate(this.contextBs.getCtxBootStrap().getBootstrapAlias());
-            PrivateKey privateKey = (PrivateKey) this.contextS.getCtxServer().getKeyStoreValue().getKey(this.contextBs.getCtxBootStrap().getBootstrapAlias(), this.contextS.getCtxServer().getKeyStorePasswordServer() == null ? null : this.contextS.getCtxServer().getKeyStorePasswordServer().toCharArray());
+            X509Certificate serverCertificate = (X509Certificate) this.contextS.getLwM2MTransportConfigServer().getKeyStoreValue().getCertificate(this.contextBs.getCtxBootStrap().getBootstrapAlias());
+            PrivateKey privateKey = (PrivateKey) this.contextS.getLwM2MTransportConfigServer().getKeyStoreValue().getKey(this.contextBs.getCtxBootStrap().getBootstrapAlias(), this.contextS.getLwM2MTransportConfigServer().getKeyStorePasswordServer() == null ? null : this.contextS.getLwM2MTransportConfigServer().getKeyStorePasswordServer().toCharArray());
             PublicKey publicKey = serverCertificate.getPublicKey();
             if (serverCertificate != null &&
                     privateKey != null && privateKey.getEncoded().length > 0 &&

@@ -31,30 +31,24 @@ package org.thingsboard.server.transport.lwm2m.bootstrap;
  */
 
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.transport.TransportContext;
 import org.thingsboard.server.common.transport.lwm2m.LwM2MTransportConfigBootstrap;
 
-import javax.annotation.PostConstruct;
-
 
 @Slf4j
 @Component
 @ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true') || '${service.type:null}'=='monolith'")
 public class LwM2MTransportContextBootstrap extends TransportContext {
 
-    private LwM2MTransportConfigBootstrap ctxBootStrap;
-    @Autowired
-    LwM2MTransportConfigBootstrap lwM2MTransportConfigBootstarp;
+    private final LwM2MTransportConfigBootstrap lwM2MTransportConfigBootstrap;
 
-    @PostConstruct
-    public void init() {
-        this.ctxBootStrap = lwM2MTransportConfigBootstarp;
+    public LwM2MTransportContextBootstrap(LwM2MTransportConfigBootstrap ctxBootStrap) {
+        this.lwM2MTransportConfigBootstrap = ctxBootStrap;
     }
 
     public LwM2MTransportConfigBootstrap getCtxBootStrap() {
-        return this.ctxBootStrap;
+        return this.lwM2MTransportConfigBootstrap;
     }
 }

@@ -27,16 +27,15 @@ import org.eclipse.leshan.server.bootstrap.EditableBootstrapConfigStore;
 import org.eclipse.leshan.server.bootstrap.InvalidConfigurationException;
 import org.eclipse.leshan.server.security.BootstrapSecurityStore;
 import org.eclipse.leshan.server.security.SecurityInfo;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2mCredentialsSecurityInfoValidator;
 import org.thingsboard.server.transport.lwm2m.secure.ReadResultSecurityStore;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MSessionMsgListener;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportContextServer;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mSessionMsgListener;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportContextServer;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler;
 import org.thingsboard.server.transport.lwm2m.utils.TypeServer;
 
 import java.io.IOException;
@@ -45,12 +44,12 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.UUID;
 
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.BOOTSTRAP_SERVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_ERROR;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_INFO;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LWM2M_SERVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.SERVERS;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getBootstrapParametersFromThingsboard;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.BOOTSTRAP_SERVER;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LWM2M_SERVER;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.SERVERS;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.getBootstrapParametersFromThingsboard;
 
 @Slf4j
 @Service("LwM2MBootstrapSecurityStore")
@@ -59,14 +58,14 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
 
     private final EditableBootstrapConfigStore bootstrapConfigStore;
 
-    @Autowired
-    LwM2mCredentialsSecurityInfoValidator lwM2MCredentialsSecurityInfoValidator;
+    private final LwM2mCredentialsSecurityInfoValidator lwM2MCredentialsSecurityInfoValidator;
 
-    @Autowired
-    public LwM2MTransportContextServer context;
+    private final LwM2mTransportContextServer context;
 
-    public LwM2MBootstrapSecurityStore(EditableBootstrapConfigStore bootstrapConfigStore) {
+    public LwM2MBootstrapSecurityStore(EditableBootstrapConfigStore bootstrapConfigStore, LwM2mCredentialsSecurityInfoValidator lwM2MCredentialsSecurityInfoValidator, LwM2mTransportContextServer context) {
         this.bootstrapConfigStore = bootstrapConfigStore;
+        this.lwM2MCredentialsSecurityInfoValidator = lwM2MCredentialsSecurityInfoValidator;
+        this.context = context;
     }
 
     @Override
@@ -162,18 +161,18 @@ public class LwM2MBootstrapSecurityStore implements BootstrapSecurityStore {
                 LwM2MServerBootstrap profileLwm2mServer = mapper.readValue(bootstrapObject.get(LWM2M_SERVER).toString(), LwM2MServerBootstrap.class);
                 UUID sessionUUiD = UUID.randomUUID();
                 TransportProtos.SessionInfoProto sessionInfo = context.getValidateSessionInfo(store.getMsg(), sessionUUiD.getMostSignificantBits(), sessionUUiD.getLeastSignificantBits());
-                context.getTransportService().registerAsyncSession(sessionInfo, new LwM2MSessionMsgListener(null, sessionInfo));
+                context.getTransportService().registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(null, sessionInfo));
                 if (this.getValidatedSecurityMode(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap, lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer)) {
                     lwM2MBootstrapConfig.bootstrapServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.bootstrapServer, profileServerBootstrap);
                     lwM2MBootstrapConfig.lwm2mServer = new LwM2MServerBootstrap(lwM2MBootstrapConfig.lwm2mServer, profileLwm2mServer);
                     String logMsg = String.format("%s: getParametersBootstrap: %s Access connect client with bootstrap server.", LOG_LW2M_INFO, store.getEndPoint());
-                    context.sentParametersOnThingsboard(context.getTelemetryMsgObject(logMsg), LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC, sessionInfo);
+                    context.sentParametersOnThingsboard(context.getTelemetryMsgObject(logMsg), LwM2mTransportHandler.DEVICE_TELEMETRY_TOPIC, sessionInfo);
                     return lwM2MBootstrapConfig;
                 } else {
                     log.error(" [{}] Different values SecurityMode between of client and profile.", store.getEndPoint());
                     log.error("{} getParametersBootstrap: [{}] Different values SecurityMode between of client and profile.", LOG_LW2M_ERROR, store.getEndPoint());
                     String logMsg = String.format("%s: getParametersBootstrap: %s Different values SecurityMode between of client and profile.", LOG_LW2M_ERROR, store.getEndPoint());
-                    context.sentParametersOnThingsboard(context.getTelemetryMsgObject(logMsg), LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC, sessionInfo);
+                    context.sentParametersOnThingsboard(context.getTelemetryMsgObject(logMsg), LwM2mTransportHandler.DEVICE_TELEMETRY_TOPIC, sessionInfo);
                     return null;
                 }
             }

@@ -20,16 +20,14 @@ import lombok.extern.slf4j.Slf4j;
 import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.core.util.SecurityUtil;
 import org.eclipse.leshan.server.security.SecurityInfo;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
-import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceLwM2MCredentialsRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
-import org.thingsboard.server.transport.lwm2m.bootstrap.LwM2MTransportContextBootstrap;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportContextServer;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler;
+import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceLwM2MCredentialsRequestMsg;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportContextServer;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler;
 import org.thingsboard.server.transport.lwm2m.utils.TypeServer;
 
 import java.io.IOException;
@@ -45,47 +43,46 @@ import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.RP
 import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.X509;
 
 @Slf4j
-@Component("LwM2MGetSecurityInfo")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
+@Component
+@TbLwM2mTransportComponent
 public class LwM2mCredentialsSecurityInfoValidator {
 
-    @Autowired
-    public LwM2MTransportContextServer contextS;
-
-    @Autowired
-    public LwM2MTransportContextBootstrap contextBS;
+    private final LwM2mTransportContextServer contextS;
 
+    public LwM2mCredentialsSecurityInfoValidator(LwM2mTransportContextServer contextS) {
+        this.contextS = contextS;
+    }
 
     /**
      * Request to thingsboard Response from thingsboard ValidateDeviceLwM2MCredentials
-     * @param endPoint -
+     * @param endpoint -
      * @param keyValue -
      * @return ValidateDeviceCredentialsResponseMsg and SecurityInfo
      */
-    public ReadResultSecurityStore createAndValidateCredentialsSecurityInfo(String endPoint, TypeServer keyValue) {
+    public ReadResultSecurityStore createAndValidateCredentialsSecurityInfo(String endpoint, TypeServer keyValue) {
         CountDownLatch latch = new CountDownLatch(1);
         final ReadResultSecurityStore[] resultSecurityStore = new ReadResultSecurityStore[1];
-        contextS.getTransportService().process(ValidateDeviceLwM2MCredentialsRequestMsg.newBuilder().setCredentialsId(endPoint).build(),
-                new TransportServiceCallback<ValidateDeviceCredentialsResponseMsg>() {
+        contextS.getTransportService().process(ValidateDeviceLwM2MCredentialsRequestMsg.newBuilder().setCredentialsId(endpoint).build(),
+                new TransportServiceCallback<>() {
                     @Override
                     public void onSuccess(ValidateDeviceCredentialsResponseMsg msg) {
                         String credentialsBody = msg.getCredentialsBody();
-                        resultSecurityStore[0] = createSecurityInfo(endPoint, credentialsBody, keyValue);
+                        resultSecurityStore[0] = createSecurityInfo(endpoint, credentialsBody, keyValue);
                         resultSecurityStore[0].setMsg(msg);
-                        Optional<DeviceProfile> deviceProfileOpt = LwM2MTransportHandler.decode(msg.getProfileBody().toByteArray());
+                        Optional<DeviceProfile> deviceProfileOpt = LwM2mTransportHandler.decode(msg.getProfileBody().toByteArray());
                         deviceProfileOpt.ifPresent(profile -> resultSecurityStore[0].setDeviceProfile(profile));
                         latch.countDown();
                     }
 
                     @Override
                     public void onError(Throwable e) {
-                        log.trace("[{}] [{}] Failed to process credentials ", endPoint, e);
-                        resultSecurityStore[0] = createSecurityInfo(endPoint, null, null);
+                        log.trace("[{}] [{}] Failed to process credentials ", endpoint, e);
+                        resultSecurityStore[0] = createSecurityInfo(endpoint, null, null);
                         latch.countDown();
                     }
                 });
         try {
-            latch.await(contextS.getCtxServer().getTimeout(), TimeUnit.MILLISECONDS);
+            latch.await(contextS.getLwM2MTransportConfigServer().getTimeout(), TimeUnit.MILLISECONDS);
         } catch (InterruptedException e) {
             log.error("Failed to await credentials!", e);
         }
@@ -101,7 +98,7 @@ public class LwM2mCredentialsSecurityInfoValidator {
      */
     private ReadResultSecurityStore createSecurityInfo(String endPoint, String jsonStr, TypeServer keyValue) {
         ReadResultSecurityStore result = new ReadResultSecurityStore();
-        JsonObject objectMsg = LwM2MTransportHandler.validateJson(jsonStr);
+        JsonObject objectMsg = LwM2mTransportHandler.validateJson(jsonStr);
         if (objectMsg != null && !objectMsg.isJsonNull()) {
             JsonObject object = (objectMsg.has(keyValue.type) && !objectMsg.get(keyValue.type).isJsonNull()) ? objectMsg.get(keyValue.type).getAsJsonObject() : null;
             /**

@@ -31,9 +31,9 @@ import java.util.Collection;
 public class LwM2mServerListener {
 
     private final LeshanServer lhServer;
-    private final LwM2MTransportServiceImpl service;
+    private final LwM2mTransportServiceImpl service;
 
-    public LwM2mServerListener(LeshanServer lhServer, LwM2MTransportServiceImpl service) {
+    public LwM2mServerListener(LeshanServer lhServer, LwM2mTransportServiceImpl service) {
         this.lhServer = lhServer;
         this.service = service;
     }

@@ -32,11 +32,11 @@ import org.thingsboard.server.gen.transport.TransportProtos.ToTransportUpdateCre
 import java.util.Optional;
 
 @Slf4j
-public class LwM2MSessionMsgListener implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
-    private LwM2MTransportServiceImpl service;
+public class LwM2mSessionMsgListener implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
+    private LwM2mTransportServiceImpl service;
     private TransportProtos.SessionInfoProto sessionInfo;
 
-    public LwM2MSessionMsgListener(LwM2MTransportServiceImpl service, TransportProtos.SessionInfoProto sessionInfo) {
+    public LwM2mSessionMsgListener(LwM2mTransportServiceImpl service, TransportProtos.SessionInfoProto sessionInfo) {
         this.service = service;
         this.sessionInfo = sessionInfo;
     }

@@ -34,8 +34,6 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.transport.TransportContext;
 import org.thingsboard.server.common.transport.TransportService;
@@ -43,40 +41,32 @@ import org.thingsboard.server.common.transport.TransportServiceCallback;
 import org.thingsboard.server.common.transport.adaptor.AdaptorException;
 import org.thingsboard.server.common.transport.lwm2m.LwM2MTransportConfigServer;
 import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.transport.lwm2m.server.adaptors.LwM2MJsonAdaptor;
-import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
 
-import javax.annotation.PostConstruct;
-
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_TELEMETRY;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_TELEMETRY;
 
 @Slf4j
 @Component
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true') || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportContextServer extends TransportContext {
+@TbLwM2mTransportComponent
+public class LwM2mTransportContextServer extends TransportContext {
 
-    private LwM2MTransportConfigServer ctxServer;
 
-    @Autowired
-    protected LwM2MTransportConfigServer lwM2MTransportConfigServer;
+    private final LwM2MTransportConfigServer lwM2MTransportConfigServer;
 
-    @Autowired
-    private TransportService transportService;
+    private final TransportService transportService;
 
     @Getter
-    @Autowired
-    private LwM2MJsonAdaptor adaptor;
-
-    @Autowired
-    LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
+    private final LwM2MJsonAdaptor adaptor;
 
-    @PostConstruct
-    public void init() {
-        this.ctxServer = lwM2MTransportConfigServer;
+    public LwM2mTransportContextServer(LwM2MTransportConfigServer lwM2MTransportConfigServer, TransportService transportService, LwM2MJsonAdaptor adaptor) {
+        this.lwM2MTransportConfigServer = lwM2MTransportConfigServer;
+        this.transportService = transportService;
+        this.adaptor = adaptor;
     }
 
-    public LwM2MTransportConfigServer getCtxServer() {
-        return this.ctxServer;
+    public LwM2MTransportConfigServer getLwM2MTransportConfigServer() {
+        return this.lwM2MTransportConfigServer;
     }
 
     /**
@@ -86,7 +76,7 @@ public class LwM2MTransportContextServer extends TransportContext {
      * @return - dummy
      */
     private <T> TransportServiceCallback<Void> getPubAckCallbackSentAttrTelemetry(final T msg) {
-        return new TransportServiceCallback<Void>() {
+        return new TransportServiceCallback<>() {
             @Override
             public void onSuccess(Void dummy) {
                 log.trace("Success to publish msg: {}, dummy: {}", msg, dummy);
@@ -101,11 +91,11 @@ public class LwM2MTransportContextServer extends TransportContext {
 
     public void sentParametersOnThingsboard(JsonElement msg, String topicName, TransportProtos.SessionInfoProto sessionInfo) {
         try {
-            if (topicName.equals(LwM2MTransportHandler.DEVICE_ATTRIBUTES_TOPIC)) {
+            if (topicName.equals(LwM2mTransportHandler.DEVICE_ATTRIBUTES_TOPIC)) {
                 TransportProtos.PostAttributeMsg postAttributeMsg = adaptor.convertToPostAttributes(msg);
                 TransportServiceCallback call = this.getPubAckCallbackSentAttrTelemetry(postAttributeMsg);
                 transportService.process(sessionInfo, postAttributeMsg, this.getPubAckCallbackSentAttrTelemetry(call));
-            } else if (topicName.equals(LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC)) {
+            } else if (topicName.equals(LwM2mTransportHandler.DEVICE_TELEMETRY_TOPIC)) {
                 TransportProtos.PostTelemetryMsg postTelemetryMsg = adaptor.convertToPostTelemetry(msg);
                 TransportServiceCallback call = this.getPubAckCallbackSentAttrTelemetry(postTelemetryMsg);
                 transportService.process(sessionInfo, postTelemetryMsg, this.getPubAckCallbackSentAttrTelemetry(call));

@@ -36,8 +36,8 @@ import org.nustaq.serialization.FSTConfiguration;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.transport.TransportServiceCallback;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClientProfile;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientProfile;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
 
 import java.io.File;
 import java.io.IOException;
@@ -49,7 +49,7 @@ import java.util.Optional;
 @Slf4j
 //@Component("LwM2MTransportHandler")
 //@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' )|| ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportHandler {
+public class LwM2mTransportHandler {
 
     // We choose a default timeout a bit higher to the MAX_TRANSMIT_WAIT(62-93s) which is the time from starting to
     // send a Confirmable message to the time when an acknowledgement is no longer expected.
@@ -188,8 +188,8 @@ public class LwM2MTransportHandler {
         return null;
     }
 
-    public static LwM2MClientProfile getNewProfileParameters(JsonObject profilesConfigData) {
-        LwM2MClientProfile lwM2MClientProfile = new LwM2MClientProfile();
+    public static LwM2mClientProfile getNewProfileParameters(JsonObject profilesConfigData) {
+        LwM2mClientProfile lwM2MClientProfile = new LwM2mClientProfile();
         lwM2MClientProfile.setPostClientLwM2mSettings(profilesConfigData.get(CLIENT_LWM2M_SETTINGS).getAsJsonObject());
         lwM2MClientProfile.setPostKeyNameProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(KEY_NAME).getAsJsonObject());
         lwM2MClientProfile.setPostAttributeProfile(profilesConfigData.get(OBSERVE_ATTRIBUTE_TELEMETRY).getAsJsonObject().get(ATTRIBUTE).getAsJsonArray());
@@ -214,14 +214,14 @@ public class LwM2MTransportHandler {
      * "telemetry":["/1/0/1","/2/0/1","/6/0/1"],
      * "observe":["/2/0","/2/0/0","/4/0/2"]}
      */
-    public static LwM2MClientProfile getLwM2MClientProfileFromThingsboard(DeviceProfile deviceProfile) {
+    public static LwM2mClientProfile getLwM2MClientProfileFromThingsboard(DeviceProfile deviceProfile) {
         if (deviceProfile != null && ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties().size() > 0) {
             Object profile = ((Lwm2mDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration()).getProperties();
             try {
                 ObjectMapper mapper = new ObjectMapper();
                 String profileStr = mapper.writeValueAsString(profile);
                 JsonObject profileJson = (profileStr  != null) ? validateJson(profileStr) : null;
-                return (getValidateCredentialsBodyFromThingsboard(profileJson)) ? LwM2MTransportHandler.getNewProfileParameters(profileJson) : null;
+                return (getValidateCredentialsBodyFromThingsboard(profileJson)) ? LwM2mTransportHandler.getNewProfileParameters(profileJson) : null;
             } catch (IOException e) {
                 log.error("", e);
             }
@@ -244,12 +244,12 @@ public class LwM2MTransportHandler {
         return null;
     }
 
-    public static boolean getClientUpdateValueAfterConnect (LwM2MClientProfile profile) {
+    public static boolean getClientUpdateValueAfterConnect (LwM2mClientProfile profile) {
         return profile.getPostClientLwM2mSettings().getAsJsonObject().has("clientUpdateValueAfterConnect") &&
                 profile.getPostClientLwM2mSettings().getAsJsonObject().get("clientUpdateValueAfterConnect").getAsBoolean();
     }
 
-    public static boolean getClientOnlyObserveAfterConnect (LwM2MClientProfile profile) {
+    public static boolean getClientOnlyObserveAfterConnect (LwM2mClientProfile profile) {
         return profile.getPostClientLwM2mSettings().getAsJsonObject().has("clientOnlyObserveAfterConnect") &&
                 profile.getPostClientLwM2mSettings().getAsJsonObject().get("clientOnlyObserveAfterConnect").getAsBoolean();
     }
@@ -336,11 +336,11 @@ public class LwM2MTransportHandler {
         return StringUtils.join(linkedListOut, "");
     }
 
-    public static <T> TransportServiceCallback<Void> getAckCallback(LwM2MClient lwM2MClient, int requestId, String typeTopic) {
+    public static <T> TransportServiceCallback<Void> getAckCallback(LwM2mClient lwM2MClient, int requestId, String typeTopic) {
         return new TransportServiceCallback<Void>() {
             @Override
             public void onSuccess(Void dummy) {
-                log.trace("[{}] [{}] - requestId [{}] - EndPoint  , Access AckCallback", typeTopic, requestId, lwM2MClient.getEndPoint());
+                log.trace("[{}] [{}] - requestId [{}] - EndPoint  , Access AckCallback", typeTopic, requestId, lwM2MClient.getEndpoint());
             }
 
             @Override

@@ -48,9 +48,10 @@ import org.eclipse.leshan.core.util.NamedThreadFactory;
 import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.registration.Registration;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Service;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 
 import javax.annotation.PostConstruct;
@@ -63,40 +64,41 @@ import java.util.concurrent.Executors;
 
 import static org.eclipse.californium.core.coap.CoAP.ResponseCode.isSuccess;
 import static org.eclipse.leshan.core.attributes.Attribute.MINIMUM_PERIOD;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.DEFAULT_TIMEOUT;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_DISCOVER;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_OBSERVE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_READ;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_ERROR;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_INFO;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_EXECUTE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_OBSERVE_CANCEL;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_WRITE_REPLACE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.PUT_TYPE_OPER_WRITE_ATTRIBUTES;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.PUT_TYPE_OPER_WRITE_UPDATE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.RESPONSE_CHANNEL;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.DEFAULT_TIMEOUT;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.GET_TYPE_OPER_DISCOVER;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.GET_TYPE_OPER_OBSERVE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.GET_TYPE_OPER_READ;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.POST_TYPE_OPER_EXECUTE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.POST_TYPE_OPER_OBSERVE_CANCEL;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.POST_TYPE_OPER_WRITE_REPLACE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.PUT_TYPE_OPER_WRITE_ATTRIBUTES;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.PUT_TYPE_OPER_WRITE_UPDATE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.RESPONSE_CHANNEL;
 
 @Slf4j
-@Service("LwM2MTransportRequest")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportRequest {
+@Service("LwM2mTransportRequest")
+@TbLwM2mTransportComponent
+public class LwM2mTransportRequest {
     private ExecutorService executorResponse;
-    private ExecutorService executorResponseError;
+
     private LwM2mValueConverterImpl converter;
 
     @Autowired
-    LwM2MTransportServiceImpl service;
+    private LwM2mTransportServiceImpl service;
+
+    @Autowired
+    private LwM2mTransportContextServer context;
 
     @Autowired
-    public LwM2MTransportContextServer context;
+    private LwM2mClientContext lwM2mClientContext;
 
     @PostConstruct
     public void init() {
         this.converter = LwM2mValueConverterImpl.getInstance();
-        executorResponse = Executors.newFixedThreadPool(this.context.getCtxServer().getRequestPoolSize(),
+        executorResponse = Executors.newFixedThreadPool(this.context.getLwM2MTransportConfigServer().getRequestPoolSize(),
                 new NamedThreadFactory(String.format("LwM2M %s channel response", RESPONSE_CHANNEL)));
-        executorResponseError = Executors.newFixedThreadPool(this.context.getCtxServer().getRequestErrorPoolSize(),
-                new NamedThreadFactory(String.format("LwM2M %s channel response Error", RESPONSE_CHANNEL)));
     }
 
     public Collection<Registration> doGetRegistrations(LeshanServer lwServer) {
@@ -124,7 +126,7 @@ public class LwM2MTransportRequest {
         if (registration != null && resultIds.getObjectId() >= 0) {
             DownlinkRequest request = null;
             ContentFormat contentFormat = contentFormatParam != null ? ContentFormat.fromName(contentFormatParam.toUpperCase()) : null;
-            ResourceModel resource = service.context.getCtxServer().getResourceModel(registration, resultIds);
+            ResourceModel resource = service.context.getLwM2MTransportConfigServer().getResourceModel(registration, resultIds);
             timeoutInMs = timeoutInMs > 0 ? timeoutInMs : DEFAULT_TIMEOUT;
             switch (typeOper) {
                 case GET_TYPE_OPER_READ:
@@ -234,7 +236,7 @@ public class LwM2MTransportRequest {
 
     @SuppressWarnings("unchecked")
     private void sendRequest(LeshanServer lwServer, Registration registration, DownlinkRequest request, long timeoutInMs) {
-        LwM2MClient lwM2MClient = this.service.lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null);
+        LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClientWithReg(registration, null);
         lwServer.send(registration, request, timeoutInMs, (ResponseCallback<?>) response -> {
             if (!lwM2MClient.isInit()) {
                 lwM2MClient.initValue(this.service, request.getPath().toString());

@@ -22,15 +22,16 @@ import org.eclipse.leshan.core.node.codec.DefaultLwM2mNodeEncoder;
 import org.eclipse.leshan.core.util.Hex;
 import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.californium.LeshanServerBuilder;
+import org.eclipse.leshan.server.californium.registration.CaliforniumRegistrationStore;
 import org.eclipse.leshan.server.model.LwM2mModelProvider;
 import org.eclipse.leshan.server.model.VersionedModelProvider;
 import org.eclipse.leshan.server.security.DefaultAuthorizer;
+import org.eclipse.leshan.server.security.EditableSecurityStore;
 import org.eclipse.leshan.server.security.SecurityChecker;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.context.annotation.Bean;
 import org.springframework.stereotype.Component;
-import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 
 import java.math.BigInteger;
@@ -57,32 +58,35 @@ import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_ECDHE
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8;
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CBC_SHA256;
 import static org.eclipse.californium.scandium.dtls.cipher.CipherSuite.TLS_PSK_WITH_AES_128_CCM_8;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getCoapConfig;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.getCoapConfig;
 
 @Slf4j
 @Component("LwM2MTransportServerConfiguration")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportServerConfiguration {
+@TbLwM2mTransportComponent
+public class LwM2mTransportServerConfiguration {
     private PublicKey publicKey;
     private PrivateKey privateKey;
     private boolean pskMode = false;
 
     @Autowired
-    private LwM2MTransportContextServer context;
+    private LwM2mTransportContextServer context;
 
     @Autowired
-    private LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
+    private CaliforniumRegistrationStore registrationStore;
+
+    @Autowired
+    private EditableSecurityStore securityStore;
 
     @Bean
     public LeshanServer getLeshanServer() {
         log.info("Starting LwM2M transport Server... PostConstruct");
-        return this.getLhServer(this.context.getCtxServer().getServerPortNoSec(), this.context.getCtxServer().getServerPortSecurity());
+        return this.getLhServer(this.context.getLwM2MTransportConfigServer().getServerPortNoSec(), this.context.getLwM2MTransportConfigServer().getServerPortSecurity());
     }
 
     private LeshanServer getLhServer(Integer serverPortNoSec, Integer serverSecurePort) {
         LeshanServerBuilder builder = new LeshanServerBuilder();
-        builder.setLocalAddress(this.context.getCtxServer().getServerHost(), serverPortNoSec);
-        builder.setLocalSecureAddress(this.context.getCtxServer().getServerHostSecurity(), serverSecurePort);
+        builder.setLocalAddress(this.context.getLwM2MTransportConfigServer().getServerHost(), serverPortNoSec);
+        builder.setLocalSecureAddress(this.context.getLwM2MTransportConfigServer().getServerHostSecurity(), serverSecurePort);
         builder.setDecoder(new DefaultLwM2mNodeDecoder());
         /** Use a magic converter to support bad type send by the UI. */
         builder.setEncoder(new DefaultLwM2mNodeEncoder(LwM2mValueConverterImpl.getInstance()));
@@ -91,26 +95,26 @@ public class LwM2MTransportServerConfiguration {
         builder.setCoapConfig(getCoapConfig(serverPortNoSec, serverSecurePort));
 
         /** Define model provider (Create Models )*/
-        LwM2mModelProvider modelProvider = new VersionedModelProvider(this.context.getCtxServer().getModelsValue());
+        LwM2mModelProvider modelProvider = new VersionedModelProvider(this.context.getLwM2MTransportConfigServer().getModelsValue());
         builder.setObjectModelProvider(modelProvider);
 
         /**  Create credentials */
         this.setServerWithCredentials(builder);
 
         /** Set securityStore with new registrationStore */
-        builder.setSecurityStore(lwM2mInMemorySecurityStore);
+        builder.setSecurityStore(securityStore);
+        builder.setRegistrationStore(registrationStore);
 
 
         /** Create DTLS Config */
         DtlsConnectorConfig.Builder dtlsConfig = new DtlsConnectorConfig.Builder();
-        dtlsConfig.setRecommendedSupportedGroupsOnly(this.context.getCtxServer().isRecommendedSupportedGroups());
-        dtlsConfig.setRecommendedCipherSuitesOnly(this.context.getCtxServer().isRecommendedCiphers());
+        dtlsConfig.setRecommendedSupportedGroupsOnly(this.context.getLwM2MTransportConfigServer().isRecommendedSupportedGroups());
+        dtlsConfig.setRecommendedCipherSuitesOnly(this.context.getLwM2MTransportConfigServer().isRecommendedCiphers());
         if (this.pskMode) {
             dtlsConfig.setSupportedCipherSuites(
                     TLS_PSK_WITH_AES_128_CCM_8,
                     TLS_PSK_WITH_AES_128_CBC_SHA256);
-        }
-        else {
+        } else {
             dtlsConfig.setSupportedCipherSuites(
                     TLS_PSK_WITH_AES_128_CCM_8,
                     TLS_PSK_WITH_AES_128_CBC_SHA256,
@@ -118,7 +122,6 @@ public class LwM2MTransportServerConfiguration {
                     TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256);
         }
 
-
         /** Set DTLS Config */
         builder.setDtlsConfig(dtlsConfig);
 
@@ -128,9 +131,9 @@ public class LwM2MTransportServerConfiguration {
 
     private void setServerWithCredentials(LeshanServerBuilder builder) {
         try {
-            if (this.context.getCtxServer().getKeyStoreValue() != null) {
+            if (this.context.getLwM2MTransportConfigServer().getKeyStoreValue() != null) {
                 if (this.setBuilderX509(builder)) {
-                    X509Certificate rootCAX509Cert = (X509Certificate) this.context.getCtxServer().getKeyStoreValue().getCertificate(this.context.getCtxServer().getRootAlias());
+                    X509Certificate rootCAX509Cert = (X509Certificate) this.context.getLwM2MTransportConfigServer().getKeyStoreValue().getCertificate(this.context.getLwM2MTransportConfigServer().getRootAlias());
                     if (rootCAX509Cert != null) {
                         X509Certificate[] trustedCertificates = new X509Certificate[1];
                         trustedCertificates[0] = rootCAX509Cert;
@@ -140,7 +143,7 @@ public class LwM2MTransportServerConfiguration {
                         builder.setTrustedCertificates(new X509Certificate[0]);
                     }
                     /** Set securityStore with registrationStore*/
-                    builder.setAuthorizer(new DefaultAuthorizer(lwM2mInMemorySecurityStore, new SecurityChecker() {
+                    builder.setAuthorizer(new DefaultAuthorizer(securityStore, new SecurityChecker() {
                         @Override
                         protected boolean matchX509Identity(String endpoint, String receivedX509CommonName,
                                                             String expectedX509CommonName) {
@@ -169,8 +172,8 @@ public class LwM2MTransportServerConfiguration {
          * For idea => KeyStorePathResource == common/transport/lwm2m/src/main/resources/credentials: in LwM2MTransportContextServer: credentials/serverKeyStore.jks
          */
         try {
-            X509Certificate serverCertificate = (X509Certificate) this.context.getCtxServer().getKeyStoreValue().getCertificate(this.context.getCtxServer().getServerAlias());
-            PrivateKey privateKey = (PrivateKey) this.context.getCtxServer().getKeyStoreValue().getKey(this.context.getCtxServer().getServerAlias(), this.context.getCtxServer().getKeyStorePasswordServer() == null ? null : this.context.getCtxServer().getKeyStorePasswordServer().toCharArray());
+            X509Certificate serverCertificate = (X509Certificate) this.context.getLwM2MTransportConfigServer().getKeyStoreValue().getCertificate(this.context.getLwM2MTransportConfigServer().getServerAlias());
+            PrivateKey privateKey = (PrivateKey) this.context.getLwM2MTransportConfigServer().getKeyStoreValue().getKey(this.context.getLwM2MTransportConfigServer().getServerAlias(), this.context.getLwM2MTransportConfigServer().getKeyStorePasswordServer() == null ? null : this.context.getLwM2MTransportConfigServer().getKeyStorePasswordServer().toCharArray());
             PublicKey publicKey = serverCertificate.getPublicKey();
             if (serverCertificate != null &&
                     privateKey != null && privateKey.getEncoded().length > 0 &&
@@ -203,8 +206,8 @@ public class LwM2MTransportServerConfiguration {
     private void infoPramsUri(String mode) {
         log.info("Server uses [{}]: serverNoSecureURI : [{}], serverSecureURI : [{}]",
                 mode,
-                this.context.getCtxServer().getServerHost() + ":" + this.context.getCtxServer().getServerPortNoSec(),
-                this.context.getCtxServer().getServerHostSecurity() + ":" + this.context.getCtxServer().getServerPortSecurity());
+                this.context.getLwM2MTransportConfigServer().getServerHost() + ":" + this.context.getLwM2MTransportConfigServer().getServerPortNoSec(),
+                this.context.getLwM2MTransportConfigServer().getServerHostSecurity() + ":" + this.context.getLwM2MTransportConfigServer().getServerPortSecurity());
     }
 
     private boolean setServerRPK(LeshanServerBuilder builder) {
@@ -234,27 +237,27 @@ public class LwM2MTransportServerConfiguration {
         AlgorithmParameters algoParameters = AlgorithmParameters.getInstance("EC");
         algoParameters.init(new ECGenParameterSpec("secp256r1"));
         ECParameterSpec parameterSpec = algoParameters.getParameterSpec(ECParameterSpec.class);
-        if (this.context.getCtxServer().getServerPublicX() != null &&
-                !this.context.getCtxServer().getServerPublicX().isEmpty() &&
-                this.context.getCtxServer().getServerPublicY() != null &&
-                !this.context.getCtxServer().getServerPublicY().isEmpty()) {
+        if (this.context.getLwM2MTransportConfigServer().getServerPublicX() != null &&
+                !this.context.getLwM2MTransportConfigServer().getServerPublicX().isEmpty() &&
+                this.context.getLwM2MTransportConfigServer().getServerPublicY() != null &&
+                !this.context.getLwM2MTransportConfigServer().getServerPublicY().isEmpty()) {
             /** Get point values */
-            byte[] publicX = Hex.decodeHex(this.context.getCtxServer().getServerPublicX().toCharArray());
-            byte[] publicY = Hex.decodeHex(this.context.getCtxServer().getServerPublicY().toCharArray());
+            byte[] publicX = Hex.decodeHex(this.context.getLwM2MTransportConfigServer().getServerPublicX().toCharArray());
+            byte[] publicY = Hex.decodeHex(this.context.getLwM2MTransportConfigServer().getServerPublicY().toCharArray());
             /** Create key specs */
             KeySpec publicKeySpec = new ECPublicKeySpec(new ECPoint(new BigInteger(publicX), new BigInteger(publicY)),
                     parameterSpec);
             /** Get keys */
             this.publicKey = KeyFactory.getInstance("EC").generatePublic(publicKeySpec);
         }
-        if (this.context.getCtxServer().getServerPrivateEncoded() != null &&
-                !this.context.getCtxServer().getServerPrivateEncoded().isEmpty()) {
+        if (this.context.getLwM2MTransportConfigServer().getServerPrivateEncoded() != null &&
+                !this.context.getLwM2MTransportConfigServer().getServerPrivateEncoded().isEmpty()) {
             /** Get private key */
-            byte[] privateS = Hex.decodeHex(this.context.getCtxServer().getServerPrivateEncoded().toCharArray());
+            byte[] privateS = Hex.decodeHex(this.context.getLwM2MTransportConfigServer().getServerPrivateEncoded().toCharArray());
             try {
                 this.privateKey = KeyFactory.getInstance("EC").generatePrivate(new PKCS8EncodedKeySpec(privateS));
             } catch (InvalidKeySpecException ignore2) {
-                log.error("Invalid Server rpk.PrivateKey.getEncoded () [{}}]. PrivateKey has no EC algorithm", this.context.getCtxServer().getServerPrivateEncoded());
+                log.error("Invalid Server rpk.PrivateKey.getEncoded () [{}}]. PrivateKey has no EC algorithm", this.context.getLwM2MTransportConfigServer().getServerPrivateEncoded());
             }
         }
     }

@@ -18,8 +18,8 @@ package org.thingsboard.server.transport.lwm2m.server;
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.leshan.server.californium.LeshanServer;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
 import org.thingsboard.server.transport.lwm2m.secure.LWM2MGenerationPSkRPkECC;
 
 import javax.annotation.PostConstruct;
@@ -27,21 +27,21 @@ import javax.annotation.PreDestroy;
 
 @Slf4j
 @Component("LwM2MTransportServerInitializer")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportServerInitializer {
+@TbLwM2mTransportComponent
+public class LwM2mTransportServerInitializer {
 
     @Autowired
-    private LwM2MTransportServiceImpl service;
+    private LwM2mTransportServiceImpl service;
 
     @Autowired(required = false)
     private LeshanServer leshanServer;
 
     @Autowired
-    private LwM2MTransportContextServer context;
+    private LwM2mTransportContextServer context;
 
     @PostConstruct
     public void init() {
-        if (this.context.getCtxServer().getEnableGenNewKeyPskRpk()) {
+        if (this.context.getLwM2MTransportConfigServer().getEnableGenNewKeyPskRpk()) {
             new LWM2MGenerationPSkRPkECC();
         }
         this.startLhServer();

@@ -26,7 +26,7 @@ import org.thingsboard.server.gen.transport.TransportProtos;
 import java.util.Collection;
 import java.util.Optional;
 
-public interface LwM2MTransportService {
+public interface LwM2mTransportService {
 
     void onRegistered(LeshanServer lwServer, Registration registration, Collection<Observation> previousObsersations);
 

@@ -36,7 +36,6 @@ import org.eclipse.leshan.core.util.NamedThreadFactory;
 import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.registration.Registration;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
@@ -48,11 +47,12 @@ import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.AttributeUpdateNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionEvent;
 import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClientProfile;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientProfile;
 import org.thingsboard.server.transport.lwm2m.server.client.ResourceValue;
 import org.thingsboard.server.transport.lwm2m.server.client.ResultsAnalyzerParameters;
-import org.thingsboard.server.transport.lwm2m.server.secure.LwM2mInMemorySecurityStore;
 import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
 
 import javax.annotation.PostConstruct;
@@ -79,24 +79,24 @@ import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.stream.Collectors;
 
 import static org.thingsboard.server.common.transport.util.JsonUtils.getJsonObject;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.CLIENT_NOT_AUTHORIZED;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.DEVICE_ATTRIBUTES_REQUEST;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.DEVICE_ATTRIBUTES_TOPIC;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.DEVICE_TELEMETRY_TOPIC;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_OBSERVE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.GET_TYPE_OPER_READ;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_ERROR;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_INFO;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.LOG_LW2M_TELEMETRY;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_EXECUTE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.POST_TYPE_OPER_WRITE_REPLACE;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.SERVICE_CHANNEL;
-import static org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler.getAckCallback;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.CLIENT_NOT_AUTHORIZED;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.DEVICE_ATTRIBUTES_REQUEST;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.DEVICE_ATTRIBUTES_TOPIC;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.DEVICE_TELEMETRY_TOPIC;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.GET_TYPE_OPER_OBSERVE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.GET_TYPE_OPER_READ;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_ERROR;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_INFO;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.LOG_LW2M_TELEMETRY;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.POST_TYPE_OPER_EXECUTE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.POST_TYPE_OPER_WRITE_REPLACE;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.SERVICE_CHANNEL;
+import static org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler.getAckCallback;
 
 @Slf4j
-@Service("LwM2MTransportService")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' ) || ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
-public class LwM2MTransportServiceImpl implements LwM2MTransportService {
+@Service
+@TbLwM2mTransportComponent
+public class LwM2mTransportServiceImpl implements LwM2mTransportService {
 
     private ExecutorService executorRegistered;
     private ExecutorService executorUpdateRegistered;
@@ -105,27 +105,29 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
     protected final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
     protected final Lock writeLock = readWriteLock.writeLock();
 
-
     @Autowired
     private TransportService transportService;
 
     @Autowired
-    public LwM2MTransportContextServer context;
+    public LwM2mTransportContextServer context;
 
     @Autowired
-    private LwM2MTransportRequest lwM2MTransportRequest;
+    private LwM2mTransportRequest lwM2mTransportRequest;
 
     @Autowired
-    LwM2mInMemorySecurityStore lwM2mInMemorySecurityStore;
+    private LwM2mClientContext lwM2mClientContext;
+
+    @Autowired(required = false)
+    private LeshanServer leshanServer;
 
     @PostConstruct
     public void init() {
-        this.context.getScheduler().scheduleAtFixedRate(this::checkInactivityAndReportActivity, new Random().nextInt((int) context.getCtxServer().getSessionReportTimeout()), context.getCtxServer().getSessionReportTimeout(), TimeUnit.MILLISECONDS);
-        this.executorRegistered = Executors.newFixedThreadPool(this.context.getCtxServer().getRegisteredPoolSize(),
+        this.context.getScheduler().scheduleAtFixedRate(this::checkInactivityAndReportActivity, new Random().nextInt((int) context.getLwM2MTransportConfigServer().getSessionReportTimeout()), context.getLwM2MTransportConfigServer().getSessionReportTimeout(), TimeUnit.MILLISECONDS);
+        this.executorRegistered = Executors.newFixedThreadPool(this.context.getLwM2MTransportConfigServer().getRegisteredPoolSize(),
                 new NamedThreadFactory(String.format("LwM2M %s channel registered", SERVICE_CHANNEL)));
-        this.executorUpdateRegistered = Executors.newFixedThreadPool(this.context.getCtxServer().getUpdateRegisteredPoolSize(),
+        this.executorUpdateRegistered = Executors.newFixedThreadPool(this.context.getLwM2MTransportConfigServer().getUpdateRegisteredPoolSize(),
                 new NamedThreadFactory(String.format("LwM2M %s channel update registered", SERVICE_CHANNEL)));
-        this.executorUnRegistered = Executors.newFixedThreadPool(this.context.getCtxServer().getUnRegisteredPoolSize(),
+        this.executorUnRegistered = Executors.newFixedThreadPool(this.context.getLwM2MTransportConfigServer().getUnRegisteredPoolSize(),
                 new NamedThreadFactory(String.format("LwM2M %s channel un registered", SERVICE_CHANNEL)));
         this.converter = LwM2mValueConverterImpl.getInstance();
     }
@@ -149,17 +151,16 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
         executorRegistered.submit(() -> {
             try {
                 log.warn("[{}] [{{}] Client: create after Registration", registration.getEndpoint(), registration.getId());
-                LwM2MClient lwM2MClient = this.lwM2mInMemorySecurityStore.updateInSessionsLwM2MClient(lwServer, registration);
+                LwM2mClient lwM2MClient = this.lwM2mClientContext.updateInSessionsLwM2MClient(registration);
                 if (lwM2MClient != null) {
-                    lwM2MClient.setLwM2MTransportServiceImpl(this);
                     this.sentLogsToThingsboard(LOG_LW2M_INFO + ": Client  Registered", registration);
                     SessionInfoProto sessionInfo = this.getValidateSessionInfo(registration);
                     if (sessionInfo != null) {
-                        lwM2MClient.setDeviceUuid(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB()));
-                        lwM2MClient.setProfileUuid(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
+                        lwM2MClient.setDeviceId(new UUID(sessionInfo.getDeviceIdMSB(), sessionInfo.getDeviceIdLSB()));
+                        lwM2MClient.setProfileId(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
                         lwM2MClient.setDeviceName(sessionInfo.getDeviceName());
                         lwM2MClient.setDeviceProfileName(sessionInfo.getDeviceType());
-                        transportService.registerAsyncSession(sessionInfo, new LwM2MSessionMsgListener(this, sessionInfo));
+                        transportService.registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(this, sessionInfo));
                         transportService.process(sessionInfo, DefaultTransportService.getSessionEventMsg(SessionEvent.OPEN), null);
                         transportService.process(sessionInfo, TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().build(), null);
                         this.sentLogsToThingsboard(LOG_LW2M_INFO + ": Client  create after Registration", registration);
@@ -221,8 +222,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
         if (sessionInfo != null) {
             transportService.deregisterSession(sessionInfo);
             this.doCloseSession(sessionInfo);
-            lwM2mInMemorySecurityStore.delRemoveSessionAndListener(registration.getId());
-            if (lwM2mInMemorySecurityStore.getProfiles().size() > 0) {
+            lwM2mClientContext.delRemoveSessionAndListener(registration.getId());
+            if (lwM2mClientContext.getProfiles().size() > 0) {
                 this.syncSessionsAndProfiles();
             }
             log.info("Client close session: [{}] unReg [{}] name  [{}] profile ", registration.getId(), registration.getEndpoint(), sessionInfo.getDeviceType());
@@ -292,13 +293,13 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
             el.getAsJsonObject().entrySet().forEach(de -> {
                 String path = this.getPathAttributeUpdate(sessionInfo, de.getKey());
                 String value = de.getValue().getAsString();
-                LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSession(new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB())).entrySet().iterator().next().getValue();
-                LwM2MClientProfile profile = lwM2mInMemorySecurityStore.getProfile(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
-                ResourceModel resourceModel = context.getCtxServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(path));
+                LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClient(new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB()));
+                LwM2mClientProfile profile = lwM2mClientContext.getProfile(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
+                ResourceModel resourceModel = context.getLwM2MTransportConfigServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(path));
                 if (!path.isEmpty() && (this.validatePathInAttrProfile(profile, path) || this.validatePathInTelemetryProfile(profile, path))) {
                     if (resourceModel != null && resourceModel.operations.isWritable()) {
-                        lwM2MTransportRequest.sendAllRequest(lwM2MClient.getLwServer(), lwM2MClient.getRegistration(), path, POST_TYPE_OPER_WRITE_REPLACE,
-                                ContentFormat.TLV.getName(), null, value, this.context.getCtxServer().getTimeout());
+                        lwM2mTransportRequest.sendAllRequest(leshanServer, lwM2MClient.getRegistration(), path, POST_TYPE_OPER_WRITE_REPLACE,
+                                ContentFormat.TLV.getName(), null, value, this.context.getLwM2MTransportConfigServer().getTimeout());
                     } else {
                         log.error("Resource path - [{}] value - [{}] is not Writable and cannot be updated", path, value);
                         String logMsg = String.format("%s: attributeUpdate: Resource path - %s value - %s is not Writable and cannot be updated",
@@ -323,9 +324,9 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      */
     @Override
     public void onDeviceProfileUpdate(SessionInfoProto sessionInfo, DeviceProfile deviceProfile) {
-        Set<String> registrationIds = lwM2mInMemorySecurityStore.getSessions().entrySet()
+        Set<String> registrationIds = lwM2mClientContext.getLwM2mClients().entrySet()
                 .stream()
-                .filter(e -> e.getValue().getProfileUuid().equals(deviceProfile.getUuidId()))
+                .filter(e -> e.getValue().getProfileId().equals(deviceProfile.getUuidId()))
                 .map(Map.Entry::getKey).sorted().collect(Collectors.toCollection(LinkedHashSet::new));
         if (registrationIds.size() > 0) {
             this.onDeviceUpdateChangeProfile(registrationIds, deviceProfile);
@@ -339,8 +340,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      */
     @Override
     public void onDeviceUpdate(SessionInfoProto sessionInfo, Device device, Optional<DeviceProfile> deviceProfileOpt) {
-        Optional<String> registrationIdOpt = lwM2mInMemorySecurityStore.getSessions().entrySet().stream()
-                .filter(e -> device.getUuidId().equals(e.getValue().getDeviceUuid()))
+        Optional<String> registrationIdOpt = lwM2mClientContext.getLwM2mClients().entrySet().stream()
+                .filter(e -> device.getUuidId().equals(e.getValue().getDeviceId()))
                 .map(Map.Entry::getKey)
                 .findFirst();
         registrationIdOpt.ifPresent(registrationId -> this.onDeviceUpdateLwM2MClient(registrationId, device, deviceProfileOpt));
@@ -353,8 +354,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      */
     @Override
     public void doTrigger(LeshanServer lwServer, Registration registration, String path) {
-        lwM2MTransportRequest.sendAllRequest(lwServer, registration, path, POST_TYPE_OPER_EXECUTE,
-                ContentFormat.TLV.getName(), null, null, this.context.getCtxServer().getTimeout());
+        lwM2mTransportRequest.sendAllRequest(lwServer, registration, path, POST_TYPE_OPER_EXECUTE,
+                ContentFormat.TLV.getName(), null, null, this.context.getLwM2MTransportConfigServer().getTimeout());
     }
 
     /**
@@ -397,18 +398,18 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * Removes a profile if not used in sessions
      */
     private void syncSessionsAndProfiles() {
-        Map<UUID, LwM2MClientProfile> profilesClone = lwM2mInMemorySecurityStore.getProfiles().entrySet()
+        Map<UUID, LwM2mClientProfile> profilesClone = lwM2mClientContext.getProfiles().entrySet()
                 .stream()
                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
         profilesClone.forEach((k, v) -> {
-            String registrationId = lwM2mInMemorySecurityStore.getSessions().entrySet()
+            String registrationId = lwM2mClientContext.getLwM2mClients().entrySet()
                     .stream()
-                    .filter(e -> e.getValue().getProfileUuid().equals(k))
+                    .filter(e -> e.getValue().getProfileId().equals(k))
                     .findFirst()
                     .map(Map.Entry::getKey) // return the key of the matching entry if found
                     .orElse("");
             if (registrationId.isEmpty()) {
-                lwM2mInMemorySecurityStore.getProfiles().remove(k);
+                lwM2mClientContext.getProfiles().remove(k);
             }
         });
     }
@@ -458,12 +459,12 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param registration - Registration LwM2M Client
      * @param lwM2MClient  - object with All parameters off client
      */
-    private void initLwM2mFromClientValue(LeshanServer lwServer, Registration registration, LwM2MClient lwM2MClient) {
-        LwM2MClientProfile lwM2MClientProfile = lwM2mInMemorySecurityStore.getProfile(registration.getId());
+    private void initLwM2mFromClientValue(LeshanServer lwServer, Registration registration, LwM2mClient lwM2MClient) {
+        LwM2mClientProfile lwM2MClientProfile = lwM2mClientContext.getProfile(registration);
         Set<String> clientObjects = this.getAllOjectsInClient(registration);
-        if (clientObjects != null && !LwM2MTransportHandler.getClientOnlyObserveAfterConnect(lwM2MClientProfile)) {
+        if (clientObjects != null && !LwM2mTransportHandler.getClientOnlyObserveAfterConnect(lwM2MClientProfile)) {
             // #2
-            if (!LwM2MTransportHandler.getClientUpdateValueAfterConnect(lwM2MClientProfile)) {
+            if (!LwM2mTransportHandler.getClientUpdateValueAfterConnect(lwM2MClientProfile)) {
                 this.initReadAttrTelemetryObserveToClient(lwServer, registration, lwM2MClient, GET_TYPE_OPER_READ);
 
             }
@@ -471,8 +472,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
             else {
                 lwM2MClient.getPendingRequests().addAll(clientObjects);
                 clientObjects.forEach(path -> {
-                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, path, GET_TYPE_OPER_READ, ContentFormat.TLV.getName(),
-                            null, null, this.context.getCtxServer().getTimeout());
+                    lwM2mTransportRequest.sendAllRequest(lwServer, registration, path, GET_TYPE_OPER_READ, ContentFormat.TLV.getName(),
+                            null, null, this.context.getLwM2MTransportConfigServer().getTimeout());
                 });
             }
         }
@@ -517,7 +518,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param path         - resource
      */
     private void updateResourcesValue(Registration registration, LwM2mResource lwM2mResource, String path) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null);
+        LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClientWithReg(registration, null);
         lwM2MClient.updateResourceValue(path, lwM2mResource);
         Set<String> paths = new HashSet<>();
         paths.add(path);
@@ -565,8 +566,9 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param path    -
      * @return true if path isPresent in postAttributeProfile
      */
-    private boolean validatePathInAttrProfile(LwM2MClientProfile profile, String path) {
-        Set<String> attributesSet = new Gson().fromJson(profile.getPostAttributeProfile(), new TypeToken<>(){}.getType());
+    private boolean validatePathInAttrProfile(LwM2mClientProfile profile, String path) {
+        Set<String> attributesSet = new Gson().fromJson(profile.getPostAttributeProfile(), new TypeToken<>() {
+        }.getType());
         return attributesSet.stream().filter(p -> p.equals(path)).findFirst().isPresent();
     }
 
@@ -575,8 +577,9 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param path    -
      * @return true if path isPresent in postAttributeProfile
      */
-    private boolean validatePathInTelemetryProfile(LwM2MClientProfile profile, String path) {
-        Set<String> telemetriesSet = new Gson().fromJson(profile.getPostTelemetryProfile(), new TypeToken<>(){}.getType());
+    private boolean validatePathInTelemetryProfile(LwM2mClientProfile profile, String path) {
+        Set<String> telemetriesSet = new Gson().fromJson(profile.getPostTelemetryProfile(), new TypeToken<>() {
+        }.getType());
         return telemetriesSet.stream().filter(p -> p.equals(path)).findFirst().isPresent();
     }
 
@@ -588,16 +591,19 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param lwServer     -
      * @param registration -
      */
-    private void initReadAttrTelemetryObserveToClient(LeshanServer lwServer, Registration registration, LwM2MClient lwM2MClient, String typeOper) {
+    private void initReadAttrTelemetryObserveToClient(LeshanServer lwServer, Registration registration, LwM2mClient lwM2MClient, String typeOper) {
         try {
-            LwM2MClientProfile lwM2MClientProfile = lwM2mInMemorySecurityStore.getProfile(registration.getId());
+            LwM2mClientProfile lwM2MClientProfile = lwM2mClientContext.getProfile(registration);
             Set<String> clientInstances = this.getAllInstancesInClient(registration);
             Set<String> result;
             if (GET_TYPE_OPER_READ.equals(typeOper)) {
-                result = new ObjectMapper().readValue(lwM2MClientProfile.getPostAttributeProfile().getAsJsonArray().toString().getBytes(), new TypeReference<>() {});
-                result.addAll(new ObjectMapper().readValue(lwM2MClientProfile.getPostTelemetryProfile().getAsJsonArray().toString().getBytes(), new TypeReference<>() {}));
+                result = new ObjectMapper().readValue(lwM2MClientProfile.getPostAttributeProfile().getAsJsonArray().toString().getBytes(), new TypeReference<>() {
+                });
+                result.addAll(new ObjectMapper().readValue(lwM2MClientProfile.getPostTelemetryProfile().getAsJsonArray().toString().getBytes(), new TypeReference<>() {
+                }));
             } else {
-                result = new ObjectMapper().readValue(lwM2MClientProfile.getPostObserveProfile().getAsJsonArray().toString().getBytes(), new TypeReference<>() {});
+                result = new ObjectMapper().readValue(lwM2MClientProfile.getPostObserveProfile().getAsJsonArray().toString().getBytes(), new TypeReference<>() {
+                });
             }
             Set<String> pathSent = ConcurrentHashMap.newKeySet();
             result.forEach(p -> {
@@ -611,8 +617,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
             });
             lwM2MClient.getPendingRequests().addAll(pathSent);
             pathSent.forEach(target -> {
-                lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, typeOper, ContentFormat.TLV.getName(),
-                        null, null, this.context.getCtxServer().getTimeout());
+                lwM2mTransportRequest.sendAllRequest(lwServer, registration, target, typeOper, ContentFormat.TLV.getName(),
+                        null, null, this.context.getLwM2MTransportConfigServer().getTimeout());
             });
             if (GET_TYPE_OPER_OBSERVE.equals(typeOper)) {
                 lwM2MClient.initValue(this, null);
@@ -630,15 +636,15 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param device         -
      */
     private void onDeviceUpdateLwM2MClient(String registrationId, Device device, Optional<DeviceProfile> deviceProfileOpt) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSessions().get(registrationId);
+        LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClients().get(registrationId);
         lwM2MClient.setDeviceName(device.getName());
-        if (!lwM2MClient.getProfileUuid().equals(device.getDeviceProfileId().getId())) {
+        if (!lwM2MClient.getProfileId().equals(device.getDeviceProfileId().getId())) {
             Set<String> registrationIds = new HashSet<>();
             registrationIds.add(registrationId);
             deviceProfileOpt.ifPresent(deviceProfile -> this.onDeviceUpdateChangeProfile(registrationIds, deviceProfile));
         }
 
-        lwM2MClient.setProfileUuid(device.getDeviceProfileId().getId());
+        lwM2MClient.setProfileId(device.getDeviceProfileId().getId());
     }
 
     /**
@@ -693,20 +699,20 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param path
      */
     private void getParametersFromProfile(JsonObject attributes, JsonObject telemetry, Registration registration, Set<String> path) {
-        LwM2MClientProfile lwM2MClientProfile = lwM2mInMemorySecurityStore.getProfile(registration.getId());
+        LwM2mClientProfile lwM2MClientProfile = lwM2mClientContext.getProfile(registration);
         lwM2MClientProfile.getPostAttributeProfile().forEach(p -> {
-            LwM2mPath pathIds = new LwM2mPath(p.getAsString().toString());
+            LwM2mPath pathIds = new LwM2mPath(p.getAsString());
             if (pathIds.isResource()) {
                 if (path == null || path.contains(p.getAsString())) {
-                    this.addParameters(p.getAsString().toString(), attributes, registration);
+                    this.addParameters(p.getAsString(), attributes, registration);
                 }
             }
         });
         lwM2MClientProfile.getPostTelemetryProfile().forEach(p -> {
-            LwM2mPath pathIds = new LwM2mPath(p.getAsString().toString());
+            LwM2mPath pathIds = new LwM2mPath(p.getAsString());
             if (pathIds.isResource()) {
                 if (path == null || path.contains(p.getAsString())) {
-                    this.addParameters(p.getAsString().toString(), telemetry, registration);
+                    this.addParameters(p.getAsString(), telemetry, registration);
                 }
             }
         });
@@ -717,8 +723,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param registration - Registration LwM2M Client
      */
     private void addParameters(String path, JsonObject parameters, Registration registration) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getSessions().get(registration.getId());
-        JsonObject names = lwM2mInMemorySecurityStore.getProfiles().get(lwM2MClient.getProfileUuid()).getPostKeyNameProfile();
+        LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClientWithReg(registration, null);
+        JsonObject names = lwM2mClientContext.getProfiles().get(lwM2MClient.getProfileId()).getPostKeyNameProfile();
         String resName = String.valueOf(names.get(path));
         if (resName != null && !resName.isEmpty()) {
             try {
@@ -727,7 +733,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
                     parameters.addProperty(resName, resValue);
                 }
             } catch (Exception e) {
-                log.error(e.getStackTrace().toString());
+                log.error("Failed to add parameters.", e);
             }
         }
     }
@@ -736,11 +742,11 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param path - path resource
      * @return - value of Resource or null
      */
-    private String getResourceValueToString(LwM2MClient lwM2MClient, String path) {
+    private String getResourceValueToString(LwM2mClient lwM2MClient, String path) {
         LwM2mPath pathIds = new LwM2mPath(path);
         ResourceValue resourceValue = this.returnResourceValueFromLwM2MClient(lwM2MClient, pathIds);
-        return (resourceValue == null) ? null :
-                (String) this.converter.convertValue(resourceValue.getResourceValue(), this.context.getCtxServer().getResourceModelType(lwM2MClient.getRegistration(), pathIds), ResourceModel.Type.STRING, pathIds);
+        return resourceValue == null ? null :
+                this.converter.convertValue(resourceValue.getResourceValue(), this.context.getLwM2MTransportConfigServer().getResourceModelType(lwM2MClient.getRegistration(), pathIds), ResourceModel.Type.STRING, pathIds).toString();
     }
 
     /**
@@ -749,7 +755,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param pathIds -
      * @return - return value of Resource by idPath
      */
-    private ResourceValue returnResourceValueFromLwM2MClient(LwM2MClient lwM2MClient, LwM2mPath pathIds) {
+    private ResourceValue returnResourceValueFromLwM2MClient(LwM2mClient lwM2MClient, LwM2mPath pathIds) {
         ResourceValue resourceValue = null;
         if (pathIds.isResource()) {
             resourceValue = lwM2MClient.getResources().get(pathIds.toString());
@@ -790,23 +796,25 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param deviceProfile   -
      */
     private void onDeviceUpdateChangeProfile(Set<String> registrationIds, DeviceProfile deviceProfile) {
-
-        LwM2MClientProfile lwM2MClientProfileOld = lwM2mInMemorySecurityStore.getProfiles().get(deviceProfile.getUuidId());
-        if (lwM2mInMemorySecurityStore.addUpdateProfileParameters(deviceProfile)) {
-
+        LwM2mClientProfile lwM2MClientProfileOld = lwM2mClientContext.getProfiles().get(deviceProfile.getUuidId());
+        if (lwM2mClientContext.addUpdateProfileParameters(deviceProfile)) {
             // #1
             JsonArray attributeOld = lwM2MClientProfileOld.getPostAttributeProfile();
-            Set<String> attributeSetOld = new Gson().fromJson(attributeOld, new TypeToken<>(){}.getType());
+            Set<String> attributeSetOld = new Gson().fromJson(attributeOld, new TypeToken<>() {
+            }.getType());
             JsonArray telemetryOld = lwM2MClientProfileOld.getPostTelemetryProfile();
-            Set<String> telemetrySetOld = new Gson().fromJson(telemetryOld, new TypeToken<>(){}.getType());
+            Set<String> telemetrySetOld = new Gson().fromJson(telemetryOld, new TypeToken<>() {
+            }.getType());
             JsonArray observeOld = lwM2MClientProfileOld.getPostObserveProfile();
             JsonObject keyNameOld = lwM2MClientProfileOld.getPostKeyNameProfile();
 
-            LwM2MClientProfile lwM2MClientProfileNew = lwM2mInMemorySecurityStore.getProfiles().get(deviceProfile.getUuidId());
+            LwM2mClientProfile lwM2MClientProfileNew = lwM2mClientContext.getProfiles().get(deviceProfile.getUuidId());
             JsonArray attributeNew = lwM2MClientProfileNew.getPostAttributeProfile();
-            Set<String> attributeSetNew = new Gson().fromJson(attributeNew, new TypeToken<>(){}.getType());
+            Set<String> attributeSetNew = new Gson().fromJson(attributeNew, new TypeToken<>() {
+            }.getType());
             JsonArray telemetryNew = lwM2MClientProfileNew.getPostTelemetryProfile();
-            Set<String> telemetrySetNew = new Gson().fromJson(telemetryNew, new TypeToken<>(){}.getType());
+            Set<String> telemetrySetNew = new Gson().fromJson(telemetryNew, new TypeToken<>() {
+            }.getType());
             JsonArray observeNew = lwM2MClientProfileNew.getPostObserveProfile();
             JsonObject keyNameNew = lwM2MClientProfileNew.getPostKeyNameProfile();
 
@@ -814,20 +822,24 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
             ResultsAnalyzerParameters sentAttrToThingsboard = new ResultsAnalyzerParameters();
             // #3.1
             if (!attributeOld.equals(attributeNew)) {
-                ResultsAnalyzerParameters postAttributeAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(attributeOld, new TypeToken<Set<String>>(){}.getType()), attributeSetNew);
+                ResultsAnalyzerParameters postAttributeAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(attributeOld, new TypeToken<Set<String>>() {
+                }.getType()), attributeSetNew);
                 sentAttrToThingsboard.getPathPostParametersAdd().addAll(postAttributeAnalyzer.getPathPostParametersAdd());
                 sentAttrToThingsboard.getPathPostParametersDel().addAll(postAttributeAnalyzer.getPathPostParametersDel());
             }
             // #3.2
-            if (!attributeOld.equals(attributeNew)) {
-                ResultsAnalyzerParameters postTelemetryAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(telemetryOld, new TypeToken<Set<String>>(){}.getType()), telemetrySetNew);
+            if (!telemetryOld.equals(telemetryNew)) {
+                ResultsAnalyzerParameters postTelemetryAnalyzer = this.getAnalyzerParameters(new Gson().fromJson(telemetryOld, new TypeToken<Set<String>>() {
+                }.getType()), telemetrySetNew);
                 sentAttrToThingsboard.getPathPostParametersAdd().addAll(postTelemetryAnalyzer.getPathPostParametersAdd());
                 sentAttrToThingsboard.getPathPostParametersDel().addAll(postTelemetryAnalyzer.getPathPostParametersDel());
             }
             // #3.3
             if (!keyNameOld.equals(keyNameNew)) {
-                ResultsAnalyzerParameters keyNameChange = this.getAnalyzerKeyName(new Gson().fromJson(keyNameOld.toString(), new TypeToken<ConcurrentHashMap<String, String>>(){}.getType()),
-                        new Gson().fromJson(keyNameNew.toString(), new TypeToken<ConcurrentHashMap<String, String>>(){}.getType()));
+                ResultsAnalyzerParameters keyNameChange = this.getAnalyzerKeyName(new Gson().fromJson(keyNameOld.toString(), new TypeToken<ConcurrentHashMap<String, String>>() {
+                        }.getType()),
+                        new Gson().fromJson(keyNameNew.toString(), new TypeToken<ConcurrentHashMap<String, String>>() {
+                        }.getType()));
                 sentAttrToThingsboard.getPathPostParametersAdd().addAll(keyNameChange.getPathPostParametersAdd());
             }
 
@@ -835,9 +847,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
             if (sentAttrToThingsboard.getPathPostParametersAdd().size() > 0) {
                 // update value in Resources
                 registrationIds.forEach(registrationId -> {
-                    LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(null, registrationId);
-                    LeshanServer lwServer = lwM2MClient.getLwServer();
-                    Registration registration = lwM2mInMemorySecurityStore.getByRegistration(registrationId);
+                    LeshanServer lwServer = leshanServer;
+                    Registration registration = lwM2mClientContext.getRegistration(registrationId);
                     this.readResourceValueObserve(lwServer, registration, sentAttrToThingsboard.getPathPostParametersAdd(), GET_TYPE_OPER_READ);
                     // sent attr/telemetry to tingsboard for new path
                     this.updateAttrTelemetry(registration, false, sentAttrToThingsboard.getPathPostParametersAdd());
@@ -851,8 +862,10 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
 
             // #5.1
             if (!observeOld.equals(observeNew)) {
-                Set<String> observeSetOld = new Gson().fromJson(observeOld, new TypeToken<>(){}.getType());
-                Set<String> observeSetNew = new Gson().fromJson(observeNew, new TypeToken<>(){}.getType());
+                Set<String> observeSetOld = new Gson().fromJson(observeOld, new TypeToken<>() {
+                }.getType());
+                Set<String> observeSetNew = new Gson().fromJson(observeNew, new TypeToken<>() {
+                }.getType());
                 //#5.2 add
                 //  path Attr/Telemetry includes newObserve
                 attributeSetOld.addAll(telemetrySetOld);
@@ -863,9 +876,8 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
                 ResultsAnalyzerParameters postObserveAnalyzer = this.getAnalyzerParameters(sentObserveToClientOld.getPathPostParametersAdd(), sentObserveToClientNew.getPathPostParametersAdd());
                 //  sent Request observe to Client
                 registrationIds.forEach(registrationId -> {
-                    LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClient(null, registrationId);
-                    LeshanServer lwServer = lwM2MClient.getLwServer();
-                    Registration registration = lwM2mInMemorySecurityStore.getByRegistration(registrationId);
+                    LeshanServer lwServer = leshanServer;
+                    Registration registration = lwM2mClientContext.getRegistration(registrationId);
                     this.readResourceValueObserve(lwServer, registration, postObserveAnalyzer.getPathPostParametersAdd(), GET_TYPE_OPER_OBSERVE);
                     // 5.3 del
                     //  sent Request cancel observe to Client
@@ -914,11 +926,11 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
             LwM2mPath pathIds = new LwM2mPath(target);
             if (pathIds.isResource()) {
                 if (GET_TYPE_OPER_READ.equals(typeOper)) {
-                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
-                            ContentFormat.TLV.getName(), null, null, this.context.getCtxServer().getTimeout());
+                    lwM2mTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
+                            ContentFormat.TLV.getName(), null, null, this.context.getLwM2MTransportConfigServer().getTimeout());
                 } else if (GET_TYPE_OPER_OBSERVE.equals(typeOper)) {
-                    lwM2MTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
-                            null, null, null, this.context.getCtxServer().getTimeout());
+                    lwM2mTransportRequest.sendAllRequest(lwServer, registration, target, typeOper,
+                            null, null, null, this.context.getLwM2MTransportConfigServer().getTimeout());
                 }
             }
         });
@@ -935,7 +947,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
     }
 
     private void cancelObserveIsValue(LeshanServer lwServer, Registration registration, Set<String> paramAnallyzer) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null);
+        LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClientWithReg(registration, null);
         paramAnallyzer.forEach(p -> {
                     if (this.returnResourceValueFromLwM2MClient(lwM2MClient, new LwM2mPath(p)) != null) {
                         this.setCancelObservationRecourse(lwServer, registration, p);
@@ -944,10 +956,10 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
         );
     }
 
-    private void putDelayedUpdateResourcesClient(LwM2MClient lwM2MClient, Object valueOld, Object valueNew, String path) {
+    private void putDelayedUpdateResourcesClient(LwM2mClient lwM2MClient, Object valueOld, Object valueNew, String path) {
         if (valueNew != null && (valueOld == null || !valueNew.toString().equals(valueOld.toString()))) {
-            lwM2MTransportRequest.sendAllRequest(lwM2MClient.getLwServer(), lwM2MClient.getRegistration(), path, POST_TYPE_OPER_WRITE_REPLACE,
-                    ContentFormat.TLV.getName(), null, valueNew, this.context.getCtxServer().getTimeout());
+            lwM2mTransportRequest.sendAllRequest(leshanServer, lwM2MClient.getRegistration(), path, POST_TYPE_OPER_WRITE_REPLACE,
+                    ContentFormat.TLV.getName(), null, valueNew, this.context.getLwM2MTransportConfigServer().getTimeout());
         } else {
             log.error("05 delayError");
         }
@@ -982,7 +994,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @return -
      */
     private String getPathAttributeUpdateProfile(TransportProtos.SessionInfoProto sessionInfo, String name) {
-        LwM2MClientProfile profile = lwM2mInMemorySecurityStore.getProfile(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
+        LwM2mClientProfile profile = lwM2mClientContext.getProfile(new UUID(sessionInfo.getDeviceProfileIdMSB(), sessionInfo.getDeviceProfileIdLSB()));
         return profile.getPostKeyNameProfile().getAsJsonObject().entrySet().stream()
                 .filter(e -> e.getValue().getAsString().equals(name)).findFirst().map(Map.Entry::getKey)
                 .orElse("");
@@ -1002,7 +1014,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      */
     public void onGetAttributesResponse(TransportProtos.GetAttributeResponseMsg attributesResponse, TransportProtos.SessionInfoProto sessionInfo) {
         try {
-            LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClient(sessionInfo);
+            LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2MClient(sessionInfo);
             attributesResponse.getSharedAttributeListList().forEach(attr -> {
                 String path = this.getPathAttributeUpdate(sessionInfo, attr.getKv().getKey());
                 // #1.1
@@ -1027,18 +1039,18 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param lwM2MClient -
      * @return
      */
-    private SessionInfoProto getNewSessionInfoProto(LwM2MClient lwM2MClient) {
+    private SessionInfoProto getNewSessionInfoProto(LwM2mClient lwM2MClient) {
         if (lwM2MClient != null) {
             TransportProtos.ValidateDeviceCredentialsResponseMsg msg = lwM2MClient.getCredentialsResponse();
             if (msg == null || msg.getDeviceInfo() == null) {
-                log.error("[{}] [{}]", lwM2MClient.getEndPoint(), CLIENT_NOT_AUTHORIZED);
+                log.error("[{}] [{}]", lwM2MClient.getEndpoint(), CLIENT_NOT_AUTHORIZED);
                 this.closeClientSession(lwM2MClient.getRegistration());
                 return null;
             } else {
                 return SessionInfoProto.newBuilder()
                         .setNodeId(this.context.getNodeId())
-                        .setSessionIdMSB(lwM2MClient.getSessionUuid().getMostSignificantBits())
-                        .setSessionIdLSB(lwM2MClient.getSessionUuid().getLeastSignificantBits())
+                        .setSessionIdMSB(lwM2MClient.getSessionId().getMostSignificantBits())
+                        .setSessionIdLSB(lwM2MClient.getSessionId().getLeastSignificantBits())
                         .setDeviceIdMSB(msg.getDeviceInfo().getDeviceIdMSB())
                         .setDeviceIdLSB(msg.getDeviceInfo().getDeviceIdLSB())
                         .setTenantIdMSB(msg.getDeviceInfo().getTenantIdMSB())
@@ -1053,13 +1065,12 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
         return null;
     }
 
-
     /**
      * @param registration - Registration LwM2M Client
      * @return - sessionInfo after access connect client
      */
     private SessionInfoProto getValidateSessionInfo(Registration registration) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(registration, null);
+        LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClientWithReg(registration, null);
         return getNewSessionInfoProto(lwM2MClient);
     }
 
@@ -1068,7 +1079,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @return -
      */
     private SessionInfoProto getValidateSessionInfo(String registrationId) {
-        LwM2MClient lwM2MClient = lwM2mInMemorySecurityStore.getLwM2MClientWithReg(null, registrationId);
+        LwM2mClient lwM2MClient = lwM2mClientContext.getLwM2mClientWithReg(null, registrationId);
         return getNewSessionInfoProto(lwM2MClient);
     }
 
@@ -1079,12 +1090,12 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      */
     private void checkInactivity(SessionInfoProto sessionInfo) {
         if (transportService.reportActivity(sessionInfo) == null) {
-            transportService.registerAsyncSession(sessionInfo, new LwM2MSessionMsgListener(this, sessionInfo));
+            transportService.registerAsyncSession(sessionInfo, new LwM2mSessionMsgListener(this, sessionInfo));
         }
     }
 
     private void checkInactivityAndReportActivity() {
-        lwM2mInMemorySecurityStore.getSessions().forEach((key, value) -> this.checkInactivity(this.getValidateSessionInfo(key)));
+        lwM2mClientContext.getLwM2mClients().forEach((key, value) -> this.checkInactivity(this.getValidateSessionInfo(key)));
     }
 
     /**
@@ -1095,7 +1106,7 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      *
      * @param lwM2MClient - LwM2M Client
      */
-    public void putDelayedUpdateResourcesThingsboard(LwM2MClient lwM2MClient) {
+    public void putDelayedUpdateResourcesThingsboard(LwM2mClient lwM2MClient) {
         SessionInfoProto sessionInfo = this.getValidateSessionInfo(lwM2MClient.getRegistration());
         if (sessionInfo != null) {
             //#1.1 + #1.2
@@ -1119,15 +1130,16 @@ public class LwM2MTransportServiceImpl implements LwM2MTransportService {
      * @param lwM2MClient -
      * @return ArrayList  keyNames from profile attr resources shared!!!! && IsWritable
      */
-    private List<String> getNamesAttrFromProfileIsWritable(LwM2MClient lwM2MClient) {
-        LwM2MClientProfile profile = lwM2mInMemorySecurityStore.getProfile(lwM2MClient.getProfileUuid());
+    private List<String> getNamesAttrFromProfileIsWritable(LwM2mClient lwM2MClient) {
+        LwM2mClientProfile profile = lwM2mClientContext.getProfile(lwM2MClient.getProfileId());
         Set attrSet = new Gson().fromJson(profile.getPostAttributeProfile(), Set.class);
-        ConcurrentMap<String, String> keyNamesMap = new Gson().fromJson(profile.getPostKeyNameProfile().toString(), new TypeToken<ConcurrentHashMap<String, String>>(){}.getType());
+        ConcurrentMap<String, String> keyNamesMap = new Gson().fromJson(profile.getPostKeyNameProfile().toString(), new TypeToken<ConcurrentHashMap<String, String>>() {
+        }.getType());
 
         ConcurrentMap<String, String> keyNamesIsWritable = keyNamesMap.entrySet()
                 .stream()
-                .filter(e -> (attrSet.contains(e.getKey()) && context.getCtxServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(e.getKey())) != null &&
-                        context.getCtxServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(e.getKey())).operations.isWritable()))
+                .filter(e -> (attrSet.contains(e.getKey()) && context.getLwM2MTransportConfigServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(e.getKey())) != null &&
+                        context.getLwM2MTransportConfigServer().getResourceModel(lwM2MClient.getRegistration(), new LwM2mPath(e.getKey())).operations.isWritable()))
                 .collect(Collectors.toConcurrentMap(Map.Entry::getKey, Map.Entry::getValue));
 
         Set<String> namesIsWritable = ConcurrentHashMap.newKeySet();

@@ -20,13 +20,11 @@ import lombok.extern.slf4j.Slf4j;
 import org.eclipse.leshan.core.node.LwM2mMultipleResource;
 import org.eclipse.leshan.core.node.LwM2mResource;
 import org.eclipse.leshan.core.node.LwM2mSingleResource;
-import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportServiceImpl;
-import org.thingsboard.server.transport.lwm2m.utils.LwM2mValueConverterImpl;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportServiceImpl;
 
 import java.util.List;
 import java.util.Map;
@@ -36,42 +34,36 @@ import java.util.concurrent.CopyOnWriteArrayList;
 
 @Slf4j
 @Data
-public class LwM2MClient implements Cloneable {
+public class LwM2mClient implements Cloneable {
     private String deviceName;
     private String deviceProfileName;
-    private String endPoint;
+    private String endpoint;
     private String identity;
     private SecurityInfo securityInfo;
-    private UUID deviceUuid;
-    private UUID sessionUuid;
-    private UUID profileUuid;
-    private LeshanServer lwServer;
-    private LwM2MTransportServiceImpl lwM2MTransportServiceImpl;
+    private UUID deviceId;
+    private UUID sessionId;
+    private UUID profileId;
     private Registration registration;
     private ValidateDeviceCredentialsResponseMsg credentialsResponse;
-    private final Map<String, String> attributes;
     private final Map<String, ResourceValue> resources;
     private final Map<String, TransportProtos.TsKvProto> delayedRequests;
     private final List<String> pendingRequests;
     private boolean init;
-    private final LwM2mValueConverterImpl converter;
 
     public Object clone() throws CloneNotSupportedException {
         return super.clone();
     }
 
-    public LwM2MClient(String endPoint, String identity, SecurityInfo securityInfo, ValidateDeviceCredentialsResponseMsg credentialsResponse, UUID profileUuid, UUID sessionUuid) {
-        this.endPoint = endPoint;
+    public LwM2mClient(String endpoint, String identity, SecurityInfo securityInfo, ValidateDeviceCredentialsResponseMsg credentialsResponse, UUID profileId, UUID sessionId) {
+        this.endpoint = endpoint;
         this.identity = identity;
         this.securityInfo = securityInfo;
         this.credentialsResponse = credentialsResponse;
-        this.attributes = new ConcurrentHashMap<>();
         this.delayedRequests = new ConcurrentHashMap<>();
         this.pendingRequests = new CopyOnWriteArrayList<>();
         this.resources = new ConcurrentHashMap<>();
-        this.profileUuid = profileUuid;
-        this.sessionUuid = sessionUuid;
-        this.converter = LwM2mValueConverterImpl.getInstance();
+        this.profileId = profileId;
+        this.sessionId = sessionId;
         this.init = false;
     }
 
@@ -83,7 +75,7 @@ public class LwM2MClient implements Cloneable {
         }
     }
 
-    public void initValue(LwM2MTransportServiceImpl lwM2MTransportService, String path) {
+    public void initValue(LwM2mTransportServiceImpl lwM2MTransportService, String path) {
         if (path != null) {
             this.pendingRequests.remove(path);
         }
@@ -93,8 +85,8 @@ public class LwM2MClient implements Cloneable {
         }
     }
 
-    public LwM2MClient copy() {
-        return new LwM2MClient(this.endPoint, this.identity, this.securityInfo, this.credentialsResponse, this.profileUuid, this.sessionUuid);
+    public LwM2mClient copy() {
+        return new LwM2mClient(this.endpoint, this.identity, this.securityInfo, this.credentialsResponse, this.profileId, this.sessionId);
     }
 }
 

+/**
+ * Copyright © 2016-2021 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.lwm2m.server.client;
+
+import org.eclipse.leshan.server.registration.Registration;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.gen.transport.TransportProtos;
+
+import java.util.Map;
+import java.util.UUID;
+
+public interface LwM2mClientContext {
+
+    void delRemoveSessionAndListener(String registrationId);
+
+    LwM2mClient getLwM2MClient(String endPoint, String identity);
+
+    LwM2mClient getLwM2MClient(TransportProtos.SessionInfoProto sessionInfo);
+
+    LwM2mClient getLwM2mClient(UUID sessionId);
+
+    LwM2mClient getLwM2mClientWithReg(Registration registration, String registrationId);
+
+    LwM2mClient updateInSessionsLwM2MClient(Registration registration);
+
+    LwM2mClient addLwM2mClientToSession(String identity);
+
+    Registration getRegistration(String registrationId);
+
+    Map<String, LwM2mClient> getLwM2mClients();
+
+    Map<UUID, LwM2mClientProfile> getProfiles();
+
+    LwM2mClientProfile getProfile(UUID profileUuId);
+
+    LwM2mClientProfile getProfile(Registration registration);
+
+    Map<UUID, LwM2mClientProfile> setProfiles(Map<UUID, LwM2mClientProfile> profiles);
+
+    boolean addUpdateProfileParameters(DeviceProfile deviceProfile);
+}

+/**
+ * Copyright © 2016-2021 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.lwm2m.server.client;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.leshan.server.registration.Registration;
+import org.eclipse.leshan.server.security.EditableSecurityStore;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
+import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
+import org.thingsboard.server.transport.lwm2m.secure.LwM2mCredentialsSecurityInfoValidator;
+import org.thingsboard.server.transport.lwm2m.secure.ReadResultSecurityStore;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler;
+import org.thingsboard.server.transport.lwm2m.utils.TypeServer;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.NO_SEC;
+
+@Service
+@TbLwM2mTransportComponent
+public class LwM2mClientContextImpl implements LwM2mClientContext {
+    private static final boolean INFOS_ARE_COMPROMISED = false;
+
+    private final Map<String /** registrationId */, LwM2mClient> lwM2mClients = new ConcurrentHashMap<>();
+    private Map<UUID /** profileUUid */, LwM2mClientProfile> profiles = new ConcurrentHashMap<>();
+
+    private final LwM2mCredentialsSecurityInfoValidator lwM2MCredentialsSecurityInfoValidator;
+
+    private final EditableSecurityStore securityStore;
+
+    public LwM2mClientContextImpl(LwM2mCredentialsSecurityInfoValidator lwM2MCredentialsSecurityInfoValidator, EditableSecurityStore securityStore) {
+        this.lwM2MCredentialsSecurityInfoValidator = lwM2MCredentialsSecurityInfoValidator;
+        this.securityStore = securityStore;
+    }
+
+    public void delRemoveSessionAndListener(String registrationId) {
+        LwM2mClient lwM2MClient = lwM2mClients.get(registrationId);
+        if (lwM2MClient != null) {
+            securityStore.remove(lwM2MClient.getEndpoint(), INFOS_ARE_COMPROMISED);
+            lwM2mClients.remove(registrationId);
+        }
+    }
+
+    @Override
+    public LwM2mClient getLwM2MClient(String endPoint, String identity) {
+        Map.Entry<String, LwM2mClient> modelClients = endPoint != null ?
+                this.lwM2mClients.entrySet().stream().filter(model -> endPoint.equals(model.getValue().getEndpoint())).findAny().orElse(null) :
+                this.lwM2mClients.entrySet().stream().filter(model -> identity.equals(model.getValue().getIdentity())).findAny().orElse(null);
+        return modelClients != null ? modelClients.getValue() : null;
+    }
+
+    @Override
+    public LwM2mClient getLwM2MClient(TransportProtos.SessionInfoProto sessionInfo) {
+        return getLwM2mClient(new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB()));
+    }
+
+    @Override
+    public LwM2mClient getLwM2mClient(UUID sessionId) {
+        return lwM2mClients.values().stream().filter(c -> c.getSessionId().equals(sessionId)).findAny().get();
+    }
+
+    @Override
+    public LwM2mClient getLwM2mClientWithReg(Registration registration, String registrationId) {
+        LwM2mClient client = registrationId != null ?
+                this.lwM2mClients.get(registrationId) :
+                this.lwM2mClients.containsKey(registration.getId()) ?
+                        this.lwM2mClients.get(registration.getId()) :
+                        this.lwM2mClients.get(registration.getEndpoint());
+        return client != null ? client : updateInSessionsLwM2MClient(registration);
+    }
+
+    @Override
+    public LwM2mClient updateInSessionsLwM2MClient(Registration registration) {
+        if (this.lwM2mClients.get(registration.getEndpoint()) == null) {
+            addLwM2mClientToSession(registration.getEndpoint());
+        }
+        LwM2mClient lwM2MClient = lwM2mClients.get(registration.getEndpoint());
+        lwM2MClient.setRegistration(registration);
+        this.lwM2mClients.remove(registration.getEndpoint());
+        this.lwM2mClients.put(registration.getId(), lwM2MClient);
+        return lwM2MClient;
+    }
+
+    public Registration getRegistration(String registrationId) {
+        return this.lwM2mClients.get(registrationId).getRegistration();
+    }
+
+    /**
+     * Add new LwM2MClient to session
+     * @param identity-
+     * @return SecurityInfo. If error - SecurityInfoError
+     * and log:
+     * - FORBIDDEN - if there is no authorization
+     * - profileUuid - if the device does not have a profile
+     * - device - if the thingsboard does not have a device with a name equal to the identity
+     */
+    @Override
+    public LwM2mClient addLwM2mClientToSession(String identity) {
+        ReadResultSecurityStore store = lwM2MCredentialsSecurityInfoValidator.createAndValidateCredentialsSecurityInfo(identity, TypeServer.CLIENT);
+        if (store.getSecurityMode() < LwM2MSecurityMode.DEFAULT_MODE.code) {
+            UUID profileUuid = (store.getDeviceProfile() != null && addUpdateProfileParameters(store.getDeviceProfile())) ? store.getDeviceProfile().getUuidId() : null;
+            LwM2mClient client;
+            if (store.getSecurityInfo() != null && profileUuid != null) {
+                String endpoint = store.getSecurityInfo().getEndpoint();
+                client = new LwM2mClient(endpoint, store.getSecurityInfo().getIdentity(), store.getSecurityInfo(), store.getMsg(), profileUuid, UUID.randomUUID());
+                lwM2mClients.put(endpoint, client);
+            } else if (store.getSecurityMode() == NO_SEC.code && profileUuid != null) {
+                client = new LwM2mClient(identity, null, null, store.getMsg(), profileUuid, UUID.randomUUID());
+                lwM2mClients.put(identity, client);
+            } else {
+                throw new RuntimeException(String.format("Registration failed: FORBIDDEN/profileUuid/device %s , endpointId: %s  [PSK]", profileUuid, identity));
+            }
+            return client;
+        } else {
+            throw new RuntimeException(String.format("Registration failed: FORBIDDEN, endpointId: %s", identity));
+        }
+    }
+
+    @Override
+    public Map<String, LwM2mClient> getLwM2mClients() {
+        return lwM2mClients;
+    }
+
+    @Override
+    public Map<UUID, LwM2mClientProfile> getProfiles() {
+        return profiles;
+    }
+
+    @Override
+    public LwM2mClientProfile getProfile(UUID profileId) {
+        return profiles.get(profileId);
+    }
+
+    @Override
+    public LwM2mClientProfile getProfile(Registration registration) {
+        return this.getProfiles().get(getLwM2mClientWithReg(registration, null).getProfileId());
+    }
+
+    @Override
+    public Map<UUID, LwM2mClientProfile> setProfiles(Map<UUID, LwM2mClientProfile> profiles) {
+        return this.profiles = profiles;
+    }
+
+    @Override
+    public boolean addUpdateProfileParameters(DeviceProfile deviceProfile) {
+        LwM2mClientProfile lwM2MClientProfile = LwM2mTransportHandler.getLwM2MClientProfileFromThingsboard(deviceProfile);
+        if (lwM2MClientProfile != null) {
+            profiles.put(deviceProfile.getUuidId(), lwM2MClientProfile);
+            return true;
+        }
+        return false;
+    }
+}

@@ -20,7 +20,7 @@ import com.google.gson.JsonObject;
 import lombok.Data;
 
 @Data
-public class LwM2MClientProfile {
+public class LwM2mClientProfile {
     /**
      * {"clientLwM2mSettings": {
      *      clientUpdateValueAfterConnect: false;

@@ -13,30 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.transport.lwm2m.server.secure;
+package org.thingsboard.server.transport.lwm2m.server.store;
 
 import lombok.extern.slf4j.Slf4j;
 import org.eclipse.leshan.core.util.Hex;
-import org.eclipse.leshan.server.californium.LeshanServer;
 import org.eclipse.leshan.server.registration.Registration;
 import org.eclipse.leshan.server.security.InMemorySecurityStore;
 import org.eclipse.leshan.server.security.SecurityInfo;
 import org.eclipse.leshan.server.security.SecurityStoreListener;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
-import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode;
 import org.thingsboard.server.transport.lwm2m.secure.LwM2mCredentialsSecurityInfoValidator;
 import org.thingsboard.server.transport.lwm2m.secure.ReadResultSecurityStore;
-import org.thingsboard.server.transport.lwm2m.server.LwM2MTransportHandler;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClient;
-import org.thingsboard.server.transport.lwm2m.server.client.LwM2MClientProfile;
+import org.thingsboard.server.transport.lwm2m.server.LwM2mTransportHandler;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClient;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientProfile;
 import org.thingsboard.server.transport.lwm2m.utils.TypeServer;
 
 import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -49,8 +45,9 @@ import java.util.stream.Collectors;
 import static org.thingsboard.server.transport.lwm2m.secure.LwM2MSecurityMode.NO_SEC;
 
 @Slf4j
-@Service("LwM2mInMemorySecurityStore")
-@ConditionalOnExpression("('${service.type:null}'=='tb-transport' && '${transport.lwm2m.enabled:false}'=='true' )|| ('${service.type:null}'=='monolith' && '${transport.lwm2m.enabled}'=='true')")
+//@Service("LwM2mInMemorySecurityStore")
+//@TbLwM2mTransportComponent
+@Deprecated
 public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
     private static final boolean INFOS_ARE_COMPROMISED = false;
 
@@ -58,8 +55,8 @@ public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
     private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
     private final Lock readLock = readWriteLock.readLock();
     private final Lock writeLock = readWriteLock.writeLock();
-    private final Map<String /** registrationId */, LwM2MClient> sessions = new ConcurrentHashMap<>();
-    private Map<UUID /** profileUUid */, LwM2MClientProfile> profiles = new ConcurrentHashMap<>();
+    private final Map<String /** registrationId */, LwM2mClient> sessions = new ConcurrentHashMap<>();
+    private Map<UUID /** profileUUid */, LwM2mClientProfile> profiles = new ConcurrentHashMap<>();
     private SecurityStoreListener listener;
 
     @Autowired
@@ -102,7 +99,7 @@ public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
     public Collection<SecurityInfo> getAll() {
         readLock.lock();
         try {
-            return Collections.unmodifiableCollection(this.sessions.values().stream().map(LwM2MClient::getSecurityInfo).collect(Collectors.toList()));
+            return this.sessions.values().stream().map(LwM2mClient::getSecurityInfo).collect(Collectors.toUnmodifiableList());
         } finally {
             readLock.unlock();
         }
@@ -115,7 +112,7 @@ public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
     public void delRemoveSessionAndListener(String registrationId) {
         writeLock.lock();
         try {
-            LwM2MClient lwM2MClient = (sessions.get(registrationId) != null) ? sessions.get(registrationId) : null;
+            LwM2mClient lwM2MClient = (sessions.get(registrationId) != null) ? sessions.get(registrationId) : null;
             if (lwM2MClient != null) {
                 if (listener != null) {
                     listener.securityInfoRemoved(INFOS_ARE_COMPROMISED, lwM2MClient.getSecurityInfo());
@@ -132,14 +129,14 @@ public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
         this.listener = listener;
     }
 
-    public LwM2MClient getLwM2MClient(String endPoint, String identity) {
-        Map.Entry<String, LwM2MClient> modelClients = (endPoint != null) ?
-                this.sessions.entrySet().stream().filter(model -> endPoint.equals(model.getValue().getEndPoint())).findAny().orElse(null) :
+    public LwM2mClient getLwM2MClient(String endPoint, String identity) {
+        Map.Entry<String, LwM2mClient> modelClients = endPoint != null ?
+                this.sessions.entrySet().stream().filter(model -> endPoint.equals(model.getValue().getEndpoint())).findAny().orElse(null) :
                 this.sessions.entrySet().stream().filter(model -> identity.equals(model.getValue().getIdentity())).findAny().orElse(null);
-        return (modelClients != null) ? modelClients.getValue() : null;
+        return modelClients != null ? modelClients.getValue() : null;
     }
 
-    public LwM2MClient getLwM2MClientWithReg(Registration registration, String registrationId) {
+    public LwM2mClient getLwM2MClientWithReg(Registration registration, String registrationId) {
         return registrationId != null ?
                 this.sessions.get(registrationId) :
                 this.sessions.containsKey(registration.getId()) ?
@@ -147,28 +144,25 @@ public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
                         this.sessions.get(registration.getEndpoint());
     }
 
-    public LwM2MClient getLwM2MClient(TransportProtos.SessionInfoProto sessionInfo) {
+    public LwM2mClient getLwM2MClient(TransportProtos.SessionInfoProto sessionInfo) {
         return this.getSession(new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB())).entrySet().iterator().next().getValue();
-
     }
 
     /**
      * Update in sessions (LwM2MClient for key registration_Id) after starting registration LwM2MClient in LwM2MTransportServiceImpl
      * Remove from sessions LwM2MClient with key registration_Endpoint
-     * @param lwServer -
      * @param registration -
      * @return LwM2MClient after adding it to session
      */
-    public LwM2MClient updateInSessionsLwM2MClient(LeshanServer lwServer, Registration registration) {
+    public LwM2mClient updateInSessionsLwM2MClient(Registration registration) {
         writeLock.lock();
         try {
             if (this.sessions.get(registration.getEndpoint()) == null) {
                 this.addLwM2MClientToSession(registration.getEndpoint());
             }
-            LwM2MClient lwM2MClient = this.sessions.get(registration.getEndpoint());
-            lwM2MClient.setLwServer(lwServer);
+            LwM2mClient lwM2MClient = this.sessions.get(registration.getEndpoint());
             lwM2MClient.setRegistration(registration);
-            lwM2MClient.getAttributes().putAll(registration.getAdditionalRegistrationAttributes());
+//            lwM2MClient.getAttributes().putAll(registration.getAdditionalRegistrationAttributes());
             this.sessions.remove(registration.getEndpoint());
             this.sessions.put(registration.getId(), lwM2MClient);
             return lwM2MClient;
@@ -179,7 +173,7 @@ public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
 
     private String getRegistrationId(String endPoint, String identity) {
         List<String> registrationIds = (endPoint != null) ?
-                this.sessions.entrySet().stream().filter(model -> endPoint.equals(model.getValue().getEndPoint())).map(Map.Entry::getKey).collect(Collectors.toList()) :
+                this.sessions.entrySet().stream().filter(model -> endPoint.equals(model.getValue().getEndpoint())).map(Map.Entry::getKey).collect(Collectors.toList()) :
                 this.sessions.entrySet().stream().filter(model -> identity.equals(model.getValue().getIdentity())).map(Map.Entry::getKey).collect(Collectors.toList());
         return (registrationIds != null && registrationIds.size() > 0) ? registrationIds.get(0) : null;
     }
@@ -203,49 +197,51 @@ public class LwM2mInMemorySecurityStore extends InMemorySecurityStore {
             UUID profileUuid = (store.getDeviceProfile() != null && addUpdateProfileParameters(store.getDeviceProfile())) ? store.getDeviceProfile().getUuidId() : null;
             if (store.getSecurityInfo() != null && profileUuid != null) {
                 String endpoint = store.getSecurityInfo().getEndpoint();
-                sessions.put(endpoint, new LwM2MClient(endpoint, store.getSecurityInfo().getIdentity(), store.getSecurityInfo(), store.getMsg(), profileUuid, UUID.randomUUID()));
+                sessions.put(endpoint, new LwM2mClient(endpoint, store.getSecurityInfo().getIdentity(), store.getSecurityInfo(), store.getMsg(), profileUuid, UUID.randomUUID()));
             } else if (store.getSecurityMode() == NO_SEC.code && profileUuid != null) {
-                sessions.put(identity, new LwM2MClient(identity, null, null, store.getMsg(), profileUuid, UUID.randomUUID()));
+                sessions.put(identity, new LwM2mClient(identity, null, null, store.getMsg(), profileUuid, UUID.randomUUID()));
             } else {
-                    log.error("Registration failed: FORBIDDEN/profileUuid/device [{}] , endpointId: [{}]", profileUuid, identity);
-                    /**
-                     * Return Error securityInfo
-                     */
-                    byte[] preSharedKey = Hex.decodeHex("0A0B".toCharArray());
-                    SecurityInfo infoError = SecurityInfo.newPreSharedKeyInfo("error", "error_identity", preSharedKey);
-                    return infoError;
-                }
+                log.error("Registration failed: FORBIDDEN/profileUuid/device [{}] , endpointId: [{}]", profileUuid, identity);
+                /**
+                 * Return Error securityInfo
+                 */
+                byte[] preSharedKey = Hex.decodeHex("0A0B".toCharArray());
+                SecurityInfo infoError = SecurityInfo.newPreSharedKeyInfo("error", "error_identity", preSharedKey);
+                return infoError;
             }
-            return store.getSecurityInfo();
+        }
+        return store.getSecurityInfo();
     }
 
-    public Map<String, LwM2MClient> getSession(UUID sessionUuId) {
-        return this.sessions.entrySet().stream().filter(e -> e.getValue().getSessionUuid().equals(sessionUuId)).collect(Collectors.toMap(map -> map.getKey(), map -> map.getValue()));
+    public Map<String, LwM2mClient> getSession(UUID sessionUuId) {
+        return this.sessions.entrySet().stream()
+                .filter(e -> e.getValue().getSessionId().equals(sessionUuId))
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
-    public Map<String, LwM2MClient> getSessions() {
+    public Map<String, LwM2mClient> getSessions() {
         return this.sessions;
     }
 
-    public Map<UUID, LwM2MClientProfile> getProfiles() {
+    public Map<UUID, LwM2mClientProfile> getProfiles() {
         return this.profiles;
     }
 
-    public LwM2MClientProfile getProfile(UUID profileUuId) {
+    public LwM2mClientProfile getProfile(UUID profileUuId) {
         return this.profiles.get(profileUuId);
     }
 
-    public LwM2MClientProfile getProfile(String registrationId) {
-        UUID profileUUid = this.getSessions().get(registrationId).getProfileUuid();
+    public LwM2mClientProfile getProfile(String registrationId) {
+        UUID profileUUid = this.getSessions().get(registrationId).getProfileId();
         return this.getProfiles().get(profileUUid);
     }
 
-    public Map<UUID, LwM2MClientProfile> setProfiles(Map<UUID, LwM2MClientProfile> profiles) {
+    public Map<UUID, LwM2mClientProfile> setProfiles(Map<UUID, LwM2mClientProfile> profiles) {
         return this.profiles = profiles;
     }
 
     public boolean addUpdateProfileParameters(DeviceProfile deviceProfile) {
-        LwM2MClientProfile lwM2MClientProfile = LwM2MTransportHandler.getLwM2MClientProfileFromThingsboard(deviceProfile);
+        LwM2mClientProfile lwM2MClientProfile = LwM2mTransportHandler.getLwM2MClientProfileFromThingsboard(deviceProfile);
         if (lwM2MClientProfile != null) {
             profiles.put(deviceProfile.getUuidId(), lwM2MClientProfile);
             return true;

+/**
+ * Copyright © 2016-2021 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.lwm2m.server.store;
+
+import org.eclipse.californium.core.coap.Token;
+import org.eclipse.californium.core.observe.ObservationStoreException;
+import org.eclipse.californium.elements.EndpointContext;
+import org.eclipse.leshan.core.observation.Observation;
+import org.eclipse.leshan.core.util.NamedThreadFactory;
+import org.eclipse.leshan.core.util.Validate;
+import org.eclipse.leshan.server.Destroyable;
+import org.eclipse.leshan.server.Startable;
+import org.eclipse.leshan.server.Stoppable;
+import org.eclipse.leshan.server.californium.observation.ObserveUtil;
+import org.eclipse.leshan.server.californium.registration.CaliforniumRegistrationStore;
+import org.eclipse.leshan.server.redis.JedisLock;
+import org.eclipse.leshan.server.redis.RedisRegistrationStore;
+import org.eclipse.leshan.server.redis.SingleInstanceJedisLock;
+import org.eclipse.leshan.server.redis.serialization.ObservationSerDes;
+import org.eclipse.leshan.server.redis.serialization.RegistrationSerDes;
+import org.eclipse.leshan.server.registration.Deregistration;
+import org.eclipse.leshan.server.registration.ExpirationListener;
+import org.eclipse.leshan.server.registration.Registration;
+import org.eclipse.leshan.server.registration.RegistrationUpdate;
+import org.eclipse.leshan.server.registration.UpdatedRegistration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.ScanParams;
+import redis.clients.jedis.ScanResult;
+import redis.clients.jedis.Transaction;
+
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+public class TbLwM2mRedisRegistrationStore implements CaliforniumRegistrationStore, Startable, Stoppable, Destroyable {
+    /** Default time in seconds between 2 cleaning tasks (used to remove expired registration). */
+    public static final long DEFAULT_CLEAN_PERIOD = 60;
+    public static final int DEFAULT_CLEAN_LIMIT = 500;
+    /** Defaut Extra time for registration lifetime in seconds */
+    public static final long DEFAULT_GRACE_PERIOD = 0;
+
+    private static final Logger LOG = LoggerFactory.getLogger(RedisRegistrationStore.class);
+
+    // Redis key prefixes
+    private static final String REG_EP = "REG:EP:"; // (Endpoint => Registration)
+    private static final String REG_EP_REGID_IDX = "EP:REGID:"; // secondary index key (Registration ID => Endpoint)
+    private static final String REG_EP_ADDR_IDX = "EP:ADDR:"; // secondary index key (Socket Address => Endpoint)
+    private static final String LOCK_EP = "LOCK:EP:";
+    private static final byte[] OBS_TKN = "OBS:TKN:".getBytes(UTF_8);
+    private static final String OBS_TKNS_REGID_IDX = "TKNS:REGID:"; // secondary index (token list by registration)
+    private static final byte[] EXP_EP = "EXP:EP".getBytes(UTF_8); // a sorted set used for registration expiration
+    // (expiration date, Endpoint)
+
+    private final RedisConnectionFactory connectionFactory;
+
+    // Listener use to notify when a registration expires
+    private ExpirationListener expirationListener;
+
+    private final ScheduledExecutorService schedExecutor;
+    private ScheduledFuture<?> cleanerTask;
+    private boolean started = false;
+
+    private final long cleanPeriod; // in seconds
+    private final int cleanLimit; // maximum number to clean in a clean period
+    private final long gracePeriod; // in seconds
+
+    private final JedisLock lock;
+
+    public TbLwM2mRedisRegistrationStore(RedisConnectionFactory connectionFactory) {
+        this(connectionFactory, DEFAULT_CLEAN_PERIOD, DEFAULT_GRACE_PERIOD, DEFAULT_CLEAN_LIMIT); // default clean period 60s
+    }
+
+    public TbLwM2mRedisRegistrationStore(RedisConnectionFactory connectionFactory, long cleanPeriodInSec, long lifetimeGracePeriodInSec, int cleanLimit) {
+        this(connectionFactory, Executors.newScheduledThreadPool(1,
+                new NamedThreadFactory(String.format("RedisRegistrationStore Cleaner (%ds)", cleanPeriodInSec))),
+                cleanPeriodInSec, lifetimeGracePeriodInSec, cleanLimit);
+    }
+
+    public TbLwM2mRedisRegistrationStore(RedisConnectionFactory connectionFactory, ScheduledExecutorService schedExecutor, long cleanPeriodInSec,
+                                         long lifetimeGracePeriodInSec, int cleanLimit) {
+        this(connectionFactory, schedExecutor, cleanPeriodInSec, lifetimeGracePeriodInSec, cleanLimit, new SingleInstanceJedisLock());
+    }
+
+    /**
+     * @since 1.1
+     */
+    public TbLwM2mRedisRegistrationStore(RedisConnectionFactory connectionFactory, ScheduledExecutorService schedExecutor, long cleanPeriodInSec,
+                                         long lifetimeGracePeriodInSec, int cleanLimit, JedisLock redisLock) {
+        this.connectionFactory = connectionFactory;
+        this.schedExecutor = schedExecutor;
+        this.cleanPeriod = cleanPeriodInSec;
+        this.cleanLimit = cleanLimit;
+        this.gracePeriod = lifetimeGracePeriodInSec;
+        this.lock = redisLock;
+    }
+
+    /* *************** Redis Key utility function **************** */
+
+    private byte[] toKey(byte[] prefix, byte[] key) {
+        byte[] result = new byte[prefix.length + key.length];
+        System.arraycopy(prefix, 0, result, 0, prefix.length);
+        System.arraycopy(key, 0, result, prefix.length, key.length);
+        return result;
+    }
+
+    private byte[] toKey(String prefix, String registrationID) {
+        return (prefix + registrationID).getBytes();
+    }
+
+    private byte[] toLockKey(String endpoint) {
+        return toKey(LOCK_EP, endpoint);
+    }
+
+    private byte[] toLockKey(byte[] endpoint) {
+        return toKey(LOCK_EP.getBytes(UTF_8), endpoint);
+    }
+
+    /* *************** Leshan Registration API **************** */
+
+    @Override
+    public Deregistration addRegistration(Registration registration) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] lockValue = null;
+            byte[] lockKey = toLockKey(registration.getEndpoint());
+
+            try {
+                lockValue = lock.acquire(j, lockKey);
+
+                // add registration
+                byte[] k = toEndpointKey(registration.getEndpoint());
+                byte[] old = j.getSet(k, serializeReg(registration));
+
+                // add registration: secondary indexes
+                byte[] regid_idx = toRegIdKey(registration.getId());
+                j.set(regid_idx, registration.getEndpoint().getBytes(UTF_8));
+                byte[] addr_idx = toRegAddrKey(registration.getSocketAddress());
+                j.set(addr_idx, registration.getEndpoint().getBytes(UTF_8));
+
+                // Add or update expiration
+                addOrUpdateExpiration(j, registration);
+
+                if (old != null) {
+                    Registration oldRegistration = deserializeReg(old);
+                    // remove old secondary index
+                    if (!registration.getId().equals(oldRegistration.getId()))
+                        j.del(toRegIdKey(oldRegistration.getId()));
+                    if (!oldRegistration.getSocketAddress().equals(registration.getSocketAddress())) {
+                        removeAddrIndex(j, oldRegistration);
+                    }
+                    // remove old observation
+                    Collection<Observation> obsRemoved = unsafeRemoveAllObservations(j, oldRegistration.getId());
+
+                    return new Deregistration(oldRegistration, obsRemoved);
+                }
+
+                return null;
+            } finally {
+                lock.release(j, lockKey, lockValue);
+            }
+        }
+    }
+
+    @Override
+    public UpdatedRegistration updateRegistration(RegistrationUpdate update) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+
+            // Fetch the registration ep by registration ID index
+            byte[] ep = j.get(toRegIdKey(update.getRegistrationId()));
+            if (ep == null) {
+                return null;
+            }
+
+            byte[] lockValue = null;
+            byte[] lockKey = toLockKey(ep);
+            try {
+                lockValue = lock.acquire(j, lockKey);
+
+                // Fetch the registration
+                byte[] data = j.get(toEndpointKey(ep));
+                if (data == null) {
+                    return null;
+                }
+
+                Registration r = deserializeReg(data);
+
+                Registration updatedRegistration = update.update(r);
+
+                // Store the new registration
+                j.set(toEndpointKey(updatedRegistration.getEndpoint()), serializeReg(updatedRegistration));
+
+                // Add or update expiration
+                addOrUpdateExpiration(j, updatedRegistration);
+
+                // Update secondary index :
+                // If registration is already associated to this address we don't care as we only want to keep the most
+                // recent binding.
+                byte[] addr_idx = toRegAddrKey(updatedRegistration.getSocketAddress());
+                j.set(addr_idx, updatedRegistration.getEndpoint().getBytes(UTF_8));
+                if (!r.getSocketAddress().equals(updatedRegistration.getSocketAddress())) {
+                    removeAddrIndex(j, r);
+                }
+
+                return new UpdatedRegistration(r, updatedRegistration);
+
+            } finally {
+                lock.release(j, lockKey, lockValue);
+            }
+        }
+    }
+
+    @Override
+    public Registration getRegistration(String registrationId) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            return getRegistration(j, registrationId);
+        }
+    }
+
+    @Override
+    public Registration getRegistrationByEndpoint(String endpoint) {
+        Validate.notNull(endpoint);
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] data = j.get(toEndpointKey(endpoint));
+            if (data == null) {
+                return null;
+            }
+            return deserializeReg(data);
+        }
+    }
+
+    @Override
+    public Registration getRegistrationByAdress(InetSocketAddress address) {
+        Validate.notNull(address);
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] ep = j.get(toRegAddrKey(address));
+            if (ep == null) {
+                return null;
+            }
+            byte[] data = j.get(toEndpointKey(ep));
+            if (data == null) {
+                return null;
+            }
+            return deserializeReg(data);
+        }
+    }
+
+    @Override
+    public Iterator<Registration> getAllRegistrations() {
+        return new TbLwM2mRedisRegistrationStore.RedisIterator(connectionFactory, new ScanParams().match(REG_EP + "*").count(100));
+    }
+
+    protected class RedisIterator implements Iterator<Registration> {
+
+        private RedisConnectionFactory connectionFactory;
+        private ScanParams scanParams;
+
+        private String cursor;
+        private List<Registration> scanResult;
+
+        public RedisIterator(RedisConnectionFactory connectionFactory, ScanParams scanParams) {
+            this.connectionFactory = connectionFactory;
+            this.scanParams = scanParams;
+            // init scan result
+            scanNext("0");
+        }
+
+        private void scanNext(String cursor) {
+            try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+                do {
+                    ScanResult<byte[]> sr = j.scan(cursor.getBytes(), scanParams);
+
+                    this.scanResult = new ArrayList<>();
+                    if (sr.getResult() != null && !sr.getResult().isEmpty()) {
+                        for (byte[] value : j.mget(sr.getResult().toArray(new byte[][]{}))) {
+                            this.scanResult.add(deserializeReg(value));
+                        }
+                    }
+
+                    cursor = sr.getCursor();
+                } while (!"0".equals(cursor) && scanResult.isEmpty());
+
+                this.cursor = cursor;
+            }
+        }
+
+        @Override
+        public boolean hasNext() {
+            if (!scanResult.isEmpty()) {
+                return true;
+            }
+            if ("0".equals(cursor)) {
+                // no more elements to scan
+                return false;
+            }
+
+            // read more elements
+            scanNext(cursor);
+            return !scanResult.isEmpty();
+        }
+
+        @Override
+        public Registration next() {
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+            return scanResult.remove(0);
+        }
+
+        @Override
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Override
+    public Deregistration removeRegistration(String registrationId) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            return removeRegistration(j, registrationId, false);
+        }
+    }
+
+    private Deregistration removeRegistration(Jedis j, String registrationId, boolean removeOnlyIfNotAlive) {
+        // fetch the client ep by registration ID index
+        byte[] ep = j.get(toRegIdKey(registrationId));
+        if (ep == null) {
+            return null;
+        }
+
+        byte[] lockValue = null;
+        byte[] lockKey = toLockKey(ep);
+        try {
+            lockValue = lock.acquire(j, lockKey);
+
+            // fetch the client
+            byte[] data = j.get(toEndpointKey(ep));
+            if (data == null) {
+                return null;
+            }
+            Registration r = deserializeReg(data);
+
+            if (!removeOnlyIfNotAlive || !r.isAlive(gracePeriod)) {
+                long nbRemoved = j.del(toRegIdKey(r.getId()));
+                if (nbRemoved > 0) {
+                    j.del(toEndpointKey(r.getEndpoint()));
+                    Collection<Observation> obsRemoved = unsafeRemoveAllObservations(j, r.getId());
+                    removeAddrIndex(j, r);
+                    removeExpiration(j, r);
+                    return new Deregistration(r, obsRemoved);
+                }
+            }
+            return null;
+        } finally {
+            lock.release(j, lockKey, lockValue);
+        }
+    }
+
+    private void removeAddrIndex(Jedis j, Registration registration) {
+        // Watch the key to remove.
+        byte[] regAddrKey = toRegAddrKey(registration.getSocketAddress());
+        j.watch(regAddrKey);
+
+        byte[] epFromAddr = j.get(regAddrKey);
+        // Delete the key if needed.
+        if (Arrays.equals(epFromAddr, registration.getEndpoint().getBytes(UTF_8))) {
+            // Try to delete the key
+            Transaction transaction = j.multi();
+            transaction.del(regAddrKey);
+            transaction.exec();
+            // if transaction failed this is not an issue as the socket address is probably reused and we don't neeed to
+            // delete it anymore.
+        } else {
+            // the key must not be deleted.
+            j.unwatch();
+        }
+    }
+
+    private void addOrUpdateExpiration(Jedis j, Registration registration) {
+        j.zadd(EXP_EP, registration.getExpirationTimeStamp(gracePeriod), registration.getEndpoint().getBytes(UTF_8));
+    }
+
+    private void removeExpiration(Jedis j, Registration registration) {
+        j.zrem(EXP_EP, registration.getEndpoint().getBytes(UTF_8));
+    }
+
+    private byte[] toRegIdKey(String registrationId) {
+        return toKey(REG_EP_REGID_IDX, registrationId);
+    }
+
+    private byte[] toRegAddrKey(InetSocketAddress addr) {
+        return toKey(REG_EP_ADDR_IDX, addr.getAddress().toString() + ":" + addr.getPort());
+    }
+
+    private byte[] toEndpointKey(String endpoint) {
+        return toKey(REG_EP, endpoint);
+    }
+
+    private byte[] toEndpointKey(byte[] endpoint) {
+        return toKey(REG_EP.getBytes(UTF_8), endpoint);
+    }
+
+    private byte[] serializeReg(Registration registration) {
+        return RegistrationSerDes.bSerialize(registration);
+    }
+
+    private Registration deserializeReg(byte[] data) {
+        return RegistrationSerDes.deserialize(data);
+    }
+
+    /* *************** Leshan Observation API **************** */
+
+    /*
+     * The observation is not persisted here, it is done by the Californium layer (in the implementation of the
+     * org.eclipse.californium.core.observe.ObservationStore#add method)
+     */
+    @Override
+    public Collection<Observation> addObservation(String registrationId, Observation observation) {
+
+        List<Observation> removed = new ArrayList<>();
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+
+            // fetch the client ep by registration ID index
+            byte[] ep = j.get(toRegIdKey(registrationId));
+            if (ep == null) {
+                return null;
+            }
+
+            byte[] lockValue = null;
+            byte[] lockKey = toLockKey(ep);
+
+            try {
+                lockValue = lock.acquire(j, lockKey);
+
+                // cancel existing observations for the same path and registration id.
+                for (Observation obs : getObservations(j, registrationId)) {
+                    if (observation.getPath().equals(obs.getPath())
+                            && !Arrays.equals(observation.getId(), obs.getId())) {
+                        removed.add(obs);
+                        unsafeRemoveObservation(j, registrationId, obs.getId());
+                    }
+                }
+
+            } finally {
+                lock.release(j, lockKey, lockValue);
+            }
+        }
+        return removed;
+    }
+
+    @Override
+    public Observation removeObservation(String registrationId, byte[] observationId) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+
+            // fetch the client ep by registration ID index
+            byte[] ep = j.get(toRegIdKey(registrationId));
+            if (ep == null) {
+                return null;
+            }
+
+            // remove observation
+            byte[] lockValue = null;
+            byte[] lockKey = toLockKey(ep);
+            try {
+                lockValue = lock.acquire(j, lockKey);
+
+                Observation observation = build(get(new Token(observationId)));
+                if (observation != null && registrationId.equals(observation.getRegistrationId())) {
+                    unsafeRemoveObservation(j, registrationId, observationId);
+                    return observation;
+                }
+                return null;
+
+            } finally {
+                lock.release(j, lockKey, lockValue);
+            }
+        }
+    }
+
+    @Override
+    public Observation getObservation(String registrationId, byte[] observationId) {
+        return build(get(new Token(observationId)));
+    }
+
+    @Override
+    public Collection<Observation> getObservations(String registrationId) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            return getObservations(j, registrationId);
+        }
+    }
+
+    private Collection<Observation> getObservations(Jedis j, String registrationId) {
+        Collection<Observation> result = new ArrayList<>();
+        for (byte[] token : j.lrange(toKey(OBS_TKNS_REGID_IDX, registrationId), 0, -1)) {
+            byte[] obs = j.get(toKey(OBS_TKN, token));
+            if (obs != null) {
+                result.add(build(deserializeObs(obs)));
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public Collection<Observation> removeObservations(String registrationId) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            // check registration exists
+            Registration registration = getRegistration(j, registrationId);
+            if (registration == null)
+                return Collections.emptyList();
+
+            // get endpoint and create lock
+            String endpoint = registration.getEndpoint();
+            byte[] lockValue = null;
+            byte[] lockKey = toKey(LOCK_EP, endpoint);
+            try {
+                lockValue = lock.acquire(j, lockKey);
+
+                return unsafeRemoveAllObservations(j, registrationId);
+            } finally {
+                lock.release(j, lockKey, lockValue);
+            }
+        }
+    }
+
+    /* *************** Californium ObservationStore API **************** */
+
+    @Override
+    public org.eclipse.californium.core.observe.Observation putIfAbsent(Token token,
+                                                                        org.eclipse.californium.core.observe.Observation obs) throws ObservationStoreException {
+        return add(token, obs, true);
+    }
+
+    @Override
+    public org.eclipse.californium.core.observe.Observation put(Token token,
+                                                                org.eclipse.californium.core.observe.Observation obs) throws ObservationStoreException {
+        return add(token, obs, false);
+    }
+
+    private org.eclipse.californium.core.observe.Observation add(Token token,
+                                                                 org.eclipse.californium.core.observe.Observation obs, boolean ifAbsent) throws ObservationStoreException {
+        String endpoint = ObserveUtil.validateCoapObservation(obs);
+        org.eclipse.californium.core.observe.Observation previousObservation = null;
+
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] lockValue = null;
+            byte[] lockKey = toKey(LOCK_EP, endpoint);
+            try {
+                lockValue = lock.acquire(j, lockKey);
+
+                String registrationId = ObserveUtil.extractRegistrationId(obs);
+                if (!j.exists(toRegIdKey(registrationId)))
+                    throw new ObservationStoreException("no registration for this Id");
+                byte[] key = toKey(OBS_TKN, obs.getRequest().getToken().getBytes());
+                byte[] serializeObs = serializeObs(obs);
+                byte[] previousValue = null;
+                if (ifAbsent) {
+                    previousValue = j.get(key);
+                    if (previousValue == null || previousValue.length == 0) {
+                        j.set(key, serializeObs);
+                    } else {
+                        return deserializeObs(previousValue);
+                    }
+                } else {
+                    previousValue = j.getSet(key, serializeObs);
+                }
+
+                // secondary index to get the list by registrationId
+                j.lpush(toKey(OBS_TKNS_REGID_IDX, registrationId), obs.getRequest().getToken().getBytes());
+
+                // log any collisions
+                if (previousValue != null && previousValue.length != 0) {
+                    previousObservation = deserializeObs(previousValue);
+                    LOG.warn(
+                            "Token collision ? observation from request [{}] will be replaced by observation from request [{}] ",
+                            previousObservation.getRequest(), obs.getRequest());
+                }
+            } finally {
+                lock.release(j, lockKey, lockValue);
+            }
+        }
+        return previousObservation;
+    }
+
+    @Override
+    public void remove(Token token) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] tokenKey = toKey(OBS_TKN, token.getBytes());
+
+            // fetch the observation by token
+            byte[] serializedObs = j.get(tokenKey);
+            if (serializedObs == null)
+                return;
+
+            org.eclipse.californium.core.observe.Observation obs = deserializeObs(serializedObs);
+            String registrationId = ObserveUtil.extractRegistrationId(obs);
+            Registration registration = getRegistration(j, registrationId);
+            if (registration == null) {
+                LOG.warn("Unable to remove observation {}, registration {} does not exist anymore", obs.getRequest(),
+                        registrationId);
+                return;
+            }
+
+            String endpoint = registration.getEndpoint();
+            byte[] lockValue = null;
+            byte[] lockKey = toKey(LOCK_EP, endpoint);
+            try {
+                lockValue = lock.acquire(j, lockKey);
+
+                unsafeRemoveObservation(j, registrationId, token.getBytes());
+            } finally {
+                lock.release(j, lockKey, lockValue);
+            }
+        }
+
+    }
+
+    @Override
+    public org.eclipse.californium.core.observe.Observation get(Token token) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] obs = j.get(toKey(OBS_TKN, token.getBytes()));
+            if (obs == null) {
+                return null;
+            } else {
+                return deserializeObs(obs);
+            }
+        }
+    }
+
+    /* *************** Observation utility functions **************** */
+
+    private Registration getRegistration(Jedis j, String registrationId) {
+        byte[] ep = j.get(toRegIdKey(registrationId));
+        if (ep == null) {
+            return null;
+        }
+        byte[] data = j.get(toEndpointKey(ep));
+        if (data == null) {
+            return null;
+        }
+
+        return deserializeReg(data);
+    }
+
+    private void unsafeRemoveObservation(Jedis j, String registrationId, byte[] observationId) {
+        if (j.del(toKey(OBS_TKN, observationId)) > 0L) {
+            j.lrem(toKey(OBS_TKNS_REGID_IDX, registrationId), 0, observationId);
+        }
+    }
+
+    private Collection<Observation> unsafeRemoveAllObservations(Jedis j, String registrationId) {
+        Collection<Observation> removed = new ArrayList<>();
+        byte[] regIdKey = toKey(OBS_TKNS_REGID_IDX, registrationId);
+
+        // fetch all observations by token
+        for (byte[] token : j.lrange(regIdKey, 0, -1)) {
+            byte[] obs = j.get(toKey(OBS_TKN, token));
+            if (obs != null) {
+                removed.add(build(deserializeObs(obs)));
+            }
+            j.del(toKey(OBS_TKN, token));
+        }
+        j.del(regIdKey);
+
+        return removed;
+    }
+
+    @Override
+    public void setContext(Token token, EndpointContext correlationContext) {
+        // In Leshan we always set context when we send the request, so this should not be needed to implement this.
+    }
+
+    private byte[] serializeObs(org.eclipse.californium.core.observe.Observation obs) {
+        return ObservationSerDes.serialize(obs);
+    }
+
+    private org.eclipse.californium.core.observe.Observation deserializeObs(byte[] data) {
+        return ObservationSerDes.deserialize(data);
+    }
+
+    private Observation build(org.eclipse.californium.core.observe.Observation cfObs) {
+        if (cfObs == null)
+            return null;
+
+        return ObserveUtil.createLwM2mObservation(cfObs.getRequest());
+    }
+
+    /* *************** Expiration handling **************** */
+
+    /**
+     * Start regular cleanup of dead registrations.
+     */
+    @Override
+    public synchronized void start() {
+        if (!started) {
+            started = true;
+            cleanerTask = schedExecutor.scheduleAtFixedRate(new TbLwM2mRedisRegistrationStore.Cleaner(), cleanPeriod, cleanPeriod, TimeUnit.SECONDS);
+        }
+    }
+
+    /**
+     * Stop the underlying cleanup of the registrations.
+     */
+    @Override
+    public synchronized void stop() {
+        if (started) {
+            started = false;
+            if (cleanerTask != null) {
+                cleanerTask.cancel(false);
+                cleanerTask = null;
+            }
+        }
+    }
+
+    /**
+     * Destroy "cleanup" scheduler.
+     */
+    @Override
+    public synchronized void destroy() {
+        started = false;
+        schedExecutor.shutdownNow();
+        try {
+            schedExecutor.awaitTermination(5, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+            LOG.warn("Destroying RedisRegistrationStore was interrupted.", e);
+        }
+    }
+
+    private class Cleaner implements Runnable {
+
+        @Override
+        public void run() {
+
+            try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+                Set<byte[]> endpointsExpired = j.zrangeByScore(EXP_EP, Double.NEGATIVE_INFINITY,
+                        System.currentTimeMillis(), 0, cleanLimit);
+
+                for (byte[] endpoint : endpointsExpired) {
+                    Registration r = deserializeReg(j.get(toEndpointKey(endpoint)));
+                    if (!r.isAlive(gracePeriod)) {
+                        Deregistration dereg = removeRegistration(j, r.getId(), true);
+                        if (dereg != null)
+                            expirationListener.registrationExpired(dereg.getRegistration(), dereg.getObservations());
+                    }
+                }
+            } catch (Exception e) {
+                LOG.warn("Unexpected Exception while registration cleaning", e);
+            }
+        }
+    }
+
+    @Override
+    public void setExpirationListener(ExpirationListener listener) {
+        expirationListener = listener;
+    }
+
+    @Override
+    public void setExecutor(ScheduledExecutorService executor) {
+        // TODO should we reuse californium executor ?
+    }
+}

+/**
+ * Copyright © 2016-2021 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.lwm2m.server.store;
+
+import org.eclipse.leshan.server.redis.serialization.SecurityInfoSerDes;
+import org.eclipse.leshan.server.security.EditableSecurityStore;
+import org.eclipse.leshan.server.security.NonUniqueSecurityInfoException;
+import org.eclipse.leshan.server.security.SecurityInfo;
+import org.eclipse.leshan.server.security.SecurityStoreListener;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.stereotype.Service;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.ScanParams;
+import redis.clients.jedis.ScanResult;
+
+import java.util.Collection;
+import java.util.LinkedList;
+
+@Service
+public class TbLwM2mRedisSecurityStore implements EditableSecurityStore {
+    private static final String SEC_EP = "SEC#EP#";
+
+    private static final String PSKID_SEC = "PSKID#SEC";
+
+    private final RedisConnectionFactory connectionFactory;
+    private SecurityStoreListener listener;
+
+    public TbLwM2mRedisSecurityStore(RedisConnectionFactory connectionFactory) {
+        this.connectionFactory = connectionFactory;
+    }
+
+    @Override
+    public SecurityInfo getByEndpoint(String endpoint) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] data = j.get((SEC_EP + endpoint).getBytes());
+            if (data == null) {
+                return null;
+            } else {
+                return deserialize(data);
+            }
+        }
+    }
+
+    @Override
+    public SecurityInfo getByIdentity(String identity) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            String ep = j.hget(PSKID_SEC, identity);
+            if (ep == null) {
+                return null;
+            } else {
+                byte[] data = j.get((SEC_EP + ep).getBytes());
+                if (data == null) {
+                    return null;
+                } else {
+                    return deserialize(data);
+                }
+            }
+        }
+    }
+
+    @Override
+    public Collection<SecurityInfo> getAll() {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            ScanParams params = new ScanParams().match(SEC_EP + "*").count(100);
+            Collection<SecurityInfo> list = new LinkedList<>();
+            String cursor = "0";
+            do {
+                ScanResult<byte[]> res = j.scan(cursor.getBytes(), params);
+                for (byte[] key : res.getResult()) {
+                    byte[] element = j.get(key);
+                    list.add(deserialize(element));
+                }
+                cursor = res.getCursor();
+            } while (!"0".equals(cursor));
+            return list;
+        }
+    }
+
+    @Override
+    public SecurityInfo add(SecurityInfo info) throws NonUniqueSecurityInfoException {
+        byte[] data = serialize(info);
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            if (info.getIdentity() != null) {
+                // populate the secondary index (security info by PSK id)
+                String oldEndpoint = j.hget(PSKID_SEC, info.getIdentity());
+                if (oldEndpoint != null && !oldEndpoint.equals(info.getEndpoint())) {
+                    throw new NonUniqueSecurityInfoException("PSK Identity " + info.getIdentity() + " is already used");
+                }
+                j.hset(PSKID_SEC.getBytes(), info.getIdentity().getBytes(), info.getEndpoint().getBytes());
+            }
+
+            byte[] previousData = j.getSet((SEC_EP + info.getEndpoint()).getBytes(), data);
+            SecurityInfo previous = previousData == null ? null : deserialize(previousData);
+            String previousIdentity = previous == null ? null : previous.getIdentity();
+            if (previousIdentity != null && !previousIdentity.equals(info.getIdentity())) {
+                j.hdel(PSKID_SEC, previousIdentity);
+            }
+
+            return previous;
+        }
+    }
+
+    @Override
+    public SecurityInfo remove(String endpoint, boolean infosAreCompromised) {
+        try (Jedis j = (Jedis) connectionFactory.getConnection().getNativeConnection()) {
+            byte[] data = j.get((SEC_EP + endpoint).getBytes());
+
+            if (data != null) {
+                SecurityInfo info = deserialize(data);
+                if (info.getIdentity() != null) {
+                    j.hdel(PSKID_SEC.getBytes(), info.getIdentity().getBytes());
+                }
+                j.del((SEC_EP + endpoint).getBytes());
+                if (listener != null) {
+                    listener.securityInfoRemoved(infosAreCompromised, info);
+                }
+                return info;
+            }
+        }
+        return null;
+    }
+
+    private byte[] serialize(SecurityInfo secInfo) {
+        return SecurityInfoSerDes.serialize(secInfo);
+    }
+
+    private SecurityInfo deserialize(byte[] data) {
+        return SecurityInfoSerDes.deserialize(data);
+    }
+
+    @Override
+    public void setListener(SecurityStoreListener listener) {
+        this.listener = listener;
+    }
+}

+/**
+ * Copyright © 2016-2021 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.lwm2m.server.store;
+
+import org.eclipse.leshan.server.californium.registration.CaliforniumRegistrationStore;
+import org.eclipse.leshan.server.californium.registration.InMemoryRegistrationStore;
+import org.eclipse.leshan.server.security.EditableSecurityStore;
+import org.eclipse.leshan.server.security.InMemorySecurityStore;
+import org.eclipse.leshan.server.security.NonUniqueSecurityInfoException;
+import org.eclipse.leshan.server.security.SecurityInfo;
+import org.eclipse.leshan.server.security.SecurityStoreListener;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.cache.TBRedisCacheConfiguration;
+import org.thingsboard.server.queue.util.TbLwM2mTransportComponent;
+import org.thingsboard.server.transport.lwm2m.server.client.LwM2mClientContext;
+
+import java.util.Collection;
+import java.util.Optional;
+
+@Service
+@TbLwM2mTransportComponent
+public class TbLwM2mStoreConfiguration {
+
+    @Autowired(required = false)
+    private Optional<TBRedisCacheConfiguration> redisConfiguration;
+
+    @Autowired
+    @Lazy
+    private LwM2mClientContext clientContext;
+
+    @Value("${transport.lwm2m.redis.enabled:false}")
+    private boolean useRedis;
+
+    @Bean
+    private CaliforniumRegistrationStore registrationStore() {
+        return redisConfiguration.isPresent() && useRedis ?
+                new TbLwM2mRedisRegistrationStore(redisConfiguration.get().redisConnectionFactory()) : new InMemoryRegistrationStore();
+    }
+
+    @Bean
+    private EditableSecurityStore securityStore() {
+        return new TbLwM2mSecurityStoreWrapper(redisConfiguration.isPresent() && useRedis ?
+                new TbLwM2mRedisSecurityStore(redisConfiguration.get().redisConnectionFactory()) : new InMemorySecurityStore());
+    }
+
+    public class TbLwM2mSecurityStoreWrapper implements EditableSecurityStore {
+
+        private final EditableSecurityStore securityStore;
+
+        public TbLwM2mSecurityStoreWrapper(EditableSecurityStore securityStore) {
+            this.securityStore = securityStore;
+        }
+
+        @Override
+        public Collection<SecurityInfo> getAll() {
+            return securityStore.getAll();
+        }
+
+        @Override
+        public SecurityInfo add(SecurityInfo info) throws NonUniqueSecurityInfoException {
+            return securityStore.add(info);
+        }
+
+        @Override
+        public SecurityInfo remove(String endpoint, boolean infosAreCompromised) {
+            return securityStore.remove(endpoint, infosAreCompromised);
+        }
+
+        @Override
+        public void setListener(SecurityStoreListener listener) {
+            securityStore.setListener(listener);
+        }
+
+        @Override
+        public SecurityInfo getByEndpoint(String endpoint) {
+            SecurityInfo securityInfo = securityStore.getByEndpoint(endpoint);
+            if (securityInfo == null) {
+                securityInfo = clientContext.addLwM2mClientToSession(endpoint).getSecurityInfo();
+                try {
+                    if (securityInfo != null) {
+                        add(securityInfo);
+                    }
+                } catch (NonUniqueSecurityInfoException e) {
+                    e.printStackTrace();
+                }
+            }
+            return securityInfo;
+        }
+
+        @Override
+        public SecurityInfo getByIdentity(String pskIdentity) {
+            SecurityInfo securityInfo = securityStore.getByIdentity(pskIdentity);
+            if (securityInfo == null) {
+                securityInfo = clientContext.addLwM2mClientToSession(pskIdentity).getSecurityInfo();
+                try {
+                    if (securityInfo != null) {
+                        add(securityInfo);
+                    }
+                } catch (NonUniqueSecurityInfoException e) {
+                    e.printStackTrace();
+                }
+            }
+            return securityInfo;
+        }
+    }
+}

@@ -54,6 +54,10 @@
         </dependency>
         <dependency>
             <groupId>org.thingsboard.common</groupId>
+            <artifactId>cache</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common</groupId>
             <artifactId>util</artifactId>
         </dependency>
         <dependency>

@@ -20,10 +20,10 @@ import lombok.Data;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.queue.discovery.TbServiceInfoProvider;
 import org.thingsboard.server.queue.scheduler.SchedulerComponent;
+import org.thingsboard.server.queue.util.TbTransportComponent;
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
@@ -35,8 +35,6 @@ import java.util.concurrent.Executors;
  */
 @Slf4j
 @Data
-@Service
-@ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true')")
 public abstract class TransportContext {
 
     protected final ObjectMapper mapper = new ObjectMapper();

@@ -186,10 +186,6 @@ public class LwM2MTransportConfigServer {
     @Value("${transport.lwm2m.server.secure.alias:}")
     private String serverAlias;
 
-    @Getter
-    @Value("${transport.lwm2m.secure.redis_url:}")
-    private String redisUrl;
-
     @PostConstruct
     public void init() {
         modelsValue = ObjectLoader.loadDefault();

@@ -46,6 +46,10 @@
             <artifactId>javax.annotation-api</artifactId>
         </dependency>
         <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+        </dependency>
+        <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
         </dependency>

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.dao.util.mapping;
+package org.thingsboard.common.util;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;

@@ -41,6 +41,10 @@
         </dependency>
         <dependency>
             <groupId>org.thingsboard.common</groupId>
+            <artifactId>cache</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common</groupId>
             <artifactId>message</artifactId>
         </dependency>
         <dependency>

@@ -49,7 +49,7 @@ import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 import org.thingsboard.server.dao.entity.EntityService;
 import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.service.DataValidator;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.io.PrintWriter;
 import java.io.StringWriter;

@@ -16,6 +16,7 @@
 package org.thingsboard.server.dao.cache;
 
 import org.springframework.cache.interceptor.KeyGenerator;
+import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.dao.device.DeviceCredentialsService;
@@ -24,6 +25,7 @@ import java.lang.reflect.Method;
 
 import static org.thingsboard.server.common.data.CacheConstants.DEVICE_CREDENTIALS_CACHE;
 
+@Component("previousDeviceCredentialsId")
 public class PreviousDeviceCredentialsIdKeyGenerator implements KeyGenerator {
 
     private static final String NOT_VALID_DEVICE = DEVICE_CREDENTIALS_CACHE + "_notValidDeviceCredentialsId";

@@ -33,7 +33,7 @@ import org.thingsboard.server.common.msg.EncryptionUtil;
 import org.thingsboard.server.dao.entity.AbstractEntityService;
 import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.service.DataValidator;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import static org.thingsboard.server.common.data.CacheConstants.DEVICE_CREDENTIALS_CACHE;
 import static org.thingsboard.server.dao.service.Validator.validateId;

@@ -75,7 +75,7 @@ import org.thingsboard.server.dao.service.DataValidator;
 import org.thingsboard.server.dao.service.PaginatedRemover;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.dao.tenant.TenantDao;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;

@@ -31,7 +31,7 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.model.BaseSqlEntity;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.SearchTextEntity;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.dao.util.mapping.JsonBinaryType;
 import org.thingsboard.server.dao.util.mapping.JsonStringType;
 

@@ -32,7 +32,7 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.model.BaseSqlEntity;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.SearchTextEntity;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.dao.util.mapping.JsonBinaryType;
 
 import javax.persistence.Column;

@@ -27,7 +27,7 @@ import org.thingsboard.server.common.data.tenant.profile.TenantProfileData;
 import org.thingsboard.server.dao.model.BaseSqlEntity;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.SearchTextEntity;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.dao.util.mapping.JsonBinaryType;
 
 import javax.persistence.Column;

@@ -48,7 +48,7 @@ import org.thingsboard.server.dao.service.DataValidator;
 import org.thingsboard.server.dao.service.PaginatedRemover;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.dao.tenant.TenantDao;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.util.HashMap;
 import java.util.Map;

@@ -19,6 +19,7 @@ import org.hibernate.type.descriptor.WrapperOptions;
 import org.hibernate.type.descriptor.java.AbstractTypeDescriptor;
 import org.hibernate.type.descriptor.java.MutableMutabilityPlan;
 import org.hibernate.usertype.DynamicParameterizedType;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.util.Properties;
 

@@ -46,7 +46,7 @@ import org.thingsboard.server.common.data.query.EntityKeyType;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
 import org.thingsboard.server.dao.alarm.AlarmOperationResult;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.util.Arrays;
 import java.util.Collections;

@@ -854,6 +854,11 @@
             </dependency>
             <dependency>
                 <groupId>org.thingsboard.common</groupId>
+                <artifactId>cache</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.thingsboard.common</groupId>
                 <artifactId>actor</artifactId>
                 <version>${project.version}</version>
             </dependency>

@@ -23,7 +23,7 @@ import org.mockito.junit.MockitoJUnitRunner;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 @RunWith(MockitoJUnitRunner.class)
 public class TbNodeUtilsTest {

@@ -28,7 +28,7 @@ import org.thingsboard.rule.engine.api.TbNodeException;
 import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import static org.thingsboard.common.util.DonAsynchron.withCallback;
 

@@ -35,7 +35,7 @@ import org.thingsboard.server.common.data.plugin.ComponentType;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.session.SessionMsgType;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;

@@ -25,20 +25,17 @@ import org.thingsboard.rule.engine.api.TbContext;
 import org.thingsboard.rule.engine.profile.state.PersistedAlarmRuleState;
 import org.thingsboard.rule.engine.profile.state.PersistedAlarmState;
 import org.thingsboard.server.common.data.DataConstants;
-import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.alarm.Alarm;
 import org.thingsboard.server.common.data.alarm.AlarmSeverity;
 import org.thingsboard.server.common.data.alarm.AlarmStatus;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileAlarm;
-import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.query.EntityKeyType;
 import org.thingsboard.server.common.data.query.KeyFilter;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
 import org.thingsboard.server.common.msg.queue.ServiceQueue;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.util.ArrayList;
 import java.util.Comparator;

@@ -40,7 +40,7 @@ import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.session.SessionMsgType;
 import org.thingsboard.server.common.transport.adaptor.JsonConverter;
 import org.thingsboard.server.dao.sql.query.EntityKeyMapping;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.util.ArrayList;
 import java.util.HashMap;

@@ -38,7 +38,7 @@ import org.thingsboard.server.common.data.rule.RuleNodeState;
 import org.thingsboard.server.common.msg.TbMsg;
 import org.thingsboard.server.common.msg.TbMsgMetaData;
 import org.thingsboard.server.common.msg.queue.PartitionChangeMsg;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
+import org.thingsboard.common.util.JacksonUtil;
 
 import java.util.Map;
 import java.util.UUID;

@@ -16,31 +16,8 @@
 package org.thingsboard.rule.engine.profile;
 
 import lombok.Data;
-import lombok.extern.slf4j.Slf4j;
 import org.codehaus.jackson.annotate.JsonIgnoreProperties;
-import org.thingsboard.rule.engine.api.EmptyNodeConfiguration;
 import org.thingsboard.rule.engine.api.NodeConfiguration;
-import org.thingsboard.rule.engine.api.RuleEngineDeviceProfileCache;
-import org.thingsboard.rule.engine.api.RuleNode;
-import org.thingsboard.rule.engine.api.TbContext;
-import org.thingsboard.rule.engine.api.TbNode;
-import org.thingsboard.rule.engine.api.TbNodeConfiguration;
-import org.thingsboard.rule.engine.api.TbNodeException;
-import org.thingsboard.server.common.data.DataConstants;
-import org.thingsboard.server.common.data.Device;
-import org.thingsboard.server.common.data.DeviceProfile;
-import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.id.DeviceId;
-import org.thingsboard.server.common.data.id.DeviceProfileId;
-import org.thingsboard.server.common.data.plugin.ComponentType;
-import org.thingsboard.server.common.msg.TbMsg;
-import org.thingsboard.server.common.msg.TbMsgMetaData;
-import org.thingsboard.server.dao.util.mapping.JacksonUtil;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
 
 @Data
 @JsonIgnoreProperties(ignoreUnknown = true)

@@ -45,9 +45,21 @@
     </properties>
 
     <dependencies>
+<!--        <dependency>-->
+<!--            <groupId>org.thingsboard.common.transport</groupId>-->
+<!--            <artifactId>transport-api</artifactId>-->
+<!--        </dependency>-->
         <dependency>
             <groupId>org.thingsboard.common.transport</groupId>
-            <artifactId>transport-api</artifactId>
+            <artifactId>lwm2m</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common</groupId>
+            <artifactId>queue</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.thingsboard.common</groupId>
+            <artifactId>cache</artifactId>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>

@@ -26,7 +26,7 @@ import java.util.Arrays;
 @SpringBootConfiguration
 @EnableAsync
 @EnableScheduling
-@ComponentScan({"org.thingsboard.server.lwm2m", "org.thingsboard.server.common", "org.thingsboard.server.transport.lwm2m", "org.thingsboard.server.queue"})
+@ComponentScan({"org.thingsboard.server.lwm2m", "org.thingsboard.server.common", "org.thingsboard.server.transport.lwm2m", "org.thingsboard.server.queue", "org.thingsboard.server.cache"})
 public class ThingsboardLwm2mTransportApplication {
 
     private static final String SPRING_CONFIG_NAME_KEY = "--spring.config.name";

@@ -40,6 +40,83 @@ zk:
   # Name of the directory in zookeeper 'filesystem'
   zk_dir: "${ZOOKEEPER_NODES_DIR:/thingsboard}"
 
+cache:
+  # caffeine or redis
+  type: "${CACHE_TYPE:caffeine}"
+
+caffeine:
+  specs:
+    relations:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    deviceCredentials:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    devices:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    sessions:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    assets:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    entityViews:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    claimDevices:
+      timeToLiveInMinutes: 1
+      maxSize: 0
+    securitySettings:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    tenantProfiles:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+    deviceProfiles:
+      timeToLiveInMinutes: 1440
+      maxSize: 0
+
+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:}"
+  # 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}"
+
 # LWM2M server parameters
 transport:
   # Local LwM2M transport parameters
@@ -102,8 +179,8 @@ transport:
         public_y: "${LWM2M_SERVER_PUBLIC_Y_BS:3fc4e61bcd8901ec27c424114c3e887ed372497f0c2cf85839b8443e76988b34}"
         private_encoded: "${LWM2M_SERVER_PRIVATE_ENCODED_BS:308193020100301306072a8648ce3d020106082a8648ce3d0301070479307702010104205ecafd90caa7be45c42e1f3f32571632b8409e6e6249d7124f4ba56fab3c8083a00a06082a8648ce3d030107a144034200045017c87a1c1768264656b3b355434b0def6edb8b9bf166a4762d9930cd730f913fc4e61bcd8901ec27c424114c3e887ed372497f0c2cf85839b8443e76988b34}"        # Only Certificate_x509:
         alias: "${LWM2M_KEYSTORE_ALIAS_BOOTSTRAP:bootstrap}"
-    # Redis
-    redis_url: "${LWM2M_REDIS_URL:''}"
+    # Use redis for Security and Registration stores
+    redis.enabled: "${LWM2M_REDIS_ENABLED:false}"
 
   sessions:
     inactivity_timeout: "${TB_TRANSPORT_SESSIONS_INACTIVITY_TIMEOUT:300000}"

@@ -88,6 +88,9 @@
       <mat-error *ngIf="deviceCredentialsFormGroup.get('credentialsValue').hasError('required')">
         {{ 'device.lwm2m-value-required' | translate }}
       </mat-error>
+      <mat-error *ngIf="deviceCredentialsFormGroup.get('credentialsValue').hasError('jsonError')">
+        {{ 'device.lwm2m-value-json-error' | translate }}
+      </mat-error>
       <div mat-dialog-actions fxLayoutAlign="center center">
         <button mat-raised-button color="primary"
                 matTooltip="{{'device.lwm2m-value-edit-tip' | translate }}"

@@ -14,7 +14,7 @@
 /// limitations under the License.
 ///
 
-import { Component, forwardRef, Input, OnDestroy, OnInit } from '@angular/core';
+import {Component, forwardRef, Input, OnDestroy, OnInit} from '@angular/core';
 import {
   ControlValueAccessor,
   FormBuilder,
@@ -33,19 +33,19 @@ import {
   DeviceCredentials,
   DeviceCredentialsType
 } from '@shared/models/device.models';
-import { Subscription } from 'rxjs';
-import { distinctUntilChanged } from 'rxjs/operators';
-import { SecurityConfigComponent } from '@home/pages/device/lwm2m/security-config.component';
+import {Subscription} from 'rxjs';
+import {distinctUntilChanged} from 'rxjs/operators';
+import {SecurityConfigComponent} from '@home/pages/device/lwm2m/security-config.component';
 import {
   DEFAULT_END_POINT,
   DeviceCredentialsDialogLwm2mData,
   END_POINT,
   getDefaultSecurityConfig,
-  JSON_ALL_CONFIG
+  JSON_ALL_CONFIG, SecurityConfigModels, validateSecurityConfig
 } from '@home/pages/device/lwm2m/security-config.models';
-import { TranslateService } from '@ngx-translate/core';
-import { MatDialog } from '@angular/material/dialog';
-import { isDefinedAndNotNull } from '@core/utils';
+import {TranslateService} from '@ngx-translate/core';
+import {MatDialog} from '@angular/material/dialog';
+import {isDefinedAndNotNull} from '@core/utils';
 
 @Component({
   selector: 'tb-device-credentials',
@@ -196,13 +196,19 @@ export class DeviceCredentialsComponent implements ControlValueAccessor, OnInit,
         this.deviceCredentialsFormGroup.get('credentialsBasic').disable({emitEvent: false});
         break;
       case DeviceCredentialsType.X509_CERTIFICATE:
-      case DeviceCredentialsType.LWM2M_CREDENTIALS:
         this.deviceCredentialsFormGroup.get('credentialsValue').setValidators([Validators.required]);
         this.deviceCredentialsFormGroup.get('credentialsValue').updateValueAndValidity({emitEvent: false});
         this.deviceCredentialsFormGroup.get('credentialsId').setValidators([]);
         this.deviceCredentialsFormGroup.get('credentialsId').updateValueAndValidity({emitEvent: false});
         this.deviceCredentialsFormGroup.get('credentialsBasic').disable({emitEvent: false});
         break;
+      case DeviceCredentialsType.LWM2M_CREDENTIALS:
+        this.deviceCredentialsFormGroup.get('credentialsValue').setValidators([Validators.required, this.jsonValidator]);
+        this.deviceCredentialsFormGroup.get('credentialsValue').updateValueAndValidity({emitEvent: false});
+        this.deviceCredentialsFormGroup.get('credentialsId').setValidators([]);
+        this.deviceCredentialsFormGroup.get('credentialsId').updateValueAndValidity({emitEvent: false});
+        this.deviceCredentialsFormGroup.get('credentialsBasic').disable({emitEvent: false});
+        break;
       case DeviceCredentialsType.MQTT_BASIC:
         this.deviceCredentialsFormGroup.get('credentialsBasic').enable({emitEvent: false});
         this.deviceCredentialsFormGroup.get('credentialsBasic').updateValueAndValidity({emitEvent: false});
@@ -247,7 +253,11 @@ export class DeviceCredentialsComponent implements ControlValueAccessor, OnInit,
     if (credentialsValue === null || credentialsValue.length === 0) {
       credentialsValue = getDefaultSecurityConfig();
     } else {
-      credentialsValue = JSON.parse(credentialsValue);
+      try {
+        credentialsValue = JSON.parse(credentialsValue);
+      } catch (e) {
+        credentialsValue = getDefaultSecurityConfig();
+      }
     }
     const credentialsId = this.deviceCredentialsFormGroup.get('credentialsId').value || DEFAULT_END_POINT;
     this.dialog.open<SecurityConfigComponent, DeviceCredentialsDialogLwm2mData, object>(SecurityConfigComponent, {
@@ -273,4 +283,8 @@ export class DeviceCredentialsComponent implements ControlValueAccessor, OnInit,
   private isDefautLw2mResponse(response: object): boolean {
     return Object.keys(response).length === 0 || JSON.stringify(response) === '[{}]';
   }
+
+  private jsonValidator(control: FormControl) {
+    return validateSecurityConfig(control.value) ? null: {jsonError: {parsedJson: "error"}};
+  }
 }

@@ -395,21 +395,4 @@ export class Lwm2mDeviceProfileTransportConfigurationComponent implements Contro
       }
     });
   }
-
-  isPathInJson(path: string): boolean {
-    let isPath = this.findPathInJson(path, ATTRIBUTE);
-    if (!isPath) {
-      isPath = this.findPathInJson(path, TELEMETRY);
-    }
-    return !!isPath;
-  }
-
-  private findPathInJson = (path: string, side: string): string => {
-    if (this.configurationValue.observeAttr) {
-      if (this.configurationValue.observeAttr[side]) {
-        return this.configurationValue.bootstrap[side].find(
-          pathJs => pathJs === path);
-      }
-    }
-  }
 }

@@ -134,7 +134,7 @@ export class Lwm2mObjectListComponent implements ControlValueAccessor, OnInit, V
   }
 
   private add(object: ObjectLwM2M): void {
-    if (this.modelValue.indexOf(object.id) === -1) {
+    if (isDefinedAndNotNull(this.modelValue) && this.modelValue.indexOf(object.id) === -1) {
       this.modelValue.push(object.id);
       this.objectsList.push(object);
       this.lwm2mListFormGroup.get('objectsList').setValue(this.objectsList);
@@ -151,9 +151,6 @@ export class Lwm2mObjectListComponent implements ControlValueAccessor, OnInit, V
       index = this.modelValue.indexOf(object.id);
       this.modelValue.splice(index, 1);
       this.removeList.next(object);
-      if (!this.modelValue.length) {
-        this.modelValue = null;
-      }
       this.clear();
     }
   }

@@ -27,7 +27,7 @@ export const DEFAULT_ID_SERVER = 123;
 export const DEFAULT_ID_BOOTSTRAP = 111;
 export const DEFAULT_HOST_NAME = 'localhost';
 export const DEFAULT_PORT_SERVER_NO_SEC = 5685;
-export const DEFAULT_PORT_BOOTSTRAP_NO_SEC = 5686;
+export const DEFAULT_PORT_BOOTSTRAP_NO_SEC = 5687;
 export const DEFAULT_CLIENT_HOLD_OFF_TIME = 1;
 export const DEFAULT_LIFE_TIME = 300;
 export const DEFAULT_MIN_PERIOD = 1;

@@ -20,7 +20,6 @@ export const DEFAULT_END_POINT = 'default_client_lwm2m_end_point_no_sec';
 export const BOOTSTRAP_SERVERS = 'servers';
 export const BOOTSTRAP_SERVER = 'bootstrapServer';
 export const LWM2M_SERVER = 'lwm2mServer';
-export const JSON_OBSERVE = 'jsonObserve';
 export const LEN_MAX_PSK = 64;
 export const LEN_MAX_PRIVATE_KEY = 134;
 export const LEN_MAX_PUBLIC_KEY_RPK = 182;
@@ -148,4 +147,41 @@ export function getDefaultSecurityConfig(): SecurityConfigModels {
   return securityConfigModels;
 }
 
+const isSecurityConfigModels = (p: any): p is SecurityConfigModels =>
+  p.hasOwnProperty('client') &&
+    isClientSecurityConfigType(p['client']) &&
+  p.hasOwnProperty('bootstrap') &&
+    isBootstrapSecurityConfig(p['bootstrap']);
+
+const isClientSecurityConfigType = (p: any): p is ClientSecurityConfigType =>
+  p.hasOwnProperty('securityConfigClientMode') &&
+  p.hasOwnProperty('endpoint') &&
+  p.hasOwnProperty('identity') &&
+  p.hasOwnProperty('key') &&
+  p.hasOwnProperty('x509');
+
+const isBootstrapSecurityConfig = (p: any): p is BootstrapSecurityConfig =>
+  p.hasOwnProperty('bootstrapServer') &&
+    isServerSecurityConfig(p['bootstrapServer']) &&
+  p.hasOwnProperty('lwm2mServer') &&
+    isServerSecurityConfig(p['lwm2mServer']);
+
+const isServerSecurityConfig = (p: any): p is ServerSecurityConfig =>
+  p.hasOwnProperty('securityMode') &&
+  p.hasOwnProperty('clientPublicKeyOrId') &&
+  p.hasOwnProperty('clientSecretKey');
+
+export function validateSecurityConfig(config: string): boolean {
+  try {
+    const securityConfig= JSON.parse(config);
+    if (isSecurityConfigModels(securityConfig)) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (e) {
+    return false;
+  }
+}
+
 

@@ -912,6 +912,7 @@
         "lwm2m-key-required": "LwM2M Security config key is required.",
         "lwm2m-value": "LwM2M Security config",
         "lwm2m-value-required": "LwM2M Security config value is required.",
+        "lwm2m-value-json-error": "LwM2M Security config value is not json format.",
         "lwm2m-endpoint": "Client endpoint/identity",
         "lwm2m-security-info": "Security Config Info",
         "lwm2m-value-edit": "Edit Security config",