Merge pull request #4301 from thingsboard/develop/snmp

SNMP Transport

@@ -90,6 +90,10 @@
             <artifactId>lwm2m</artifactId>
         </dependency>
         <dependency>
+            <groupId>org.thingsboard.common.transport</groupId>
+            <artifactId>snmp</artifactId>
+        </dependency>
+        <dependency>
             <groupId>org.thingsboard</groupId>
             <artifactId>dao</artifactId>
         </dependency>

@@ -25,7 +25,6 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.server.actors.ActorSystemContext;
 import org.thingsboard.server.actors.DefaultTbActorSystem;
-import org.thingsboard.server.actors.TbActorId;
 import org.thingsboard.server.actors.TbActorRef;
 import org.thingsboard.server.actors.TbActorSystem;
 import org.thingsboard.server.actors.TbActorSystemSettings;
@@ -33,14 +32,13 @@ import org.thingsboard.server.actors.app.AppActor;
 import org.thingsboard.server.actors.app.AppInitMsg;
 import org.thingsboard.server.actors.stats.StatsActor;
 import org.thingsboard.server.common.msg.queue.PartitionChangeMsg;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
 import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
 
 @Service
 @Slf4j

@@ -56,7 +56,7 @@ import org.thingsboard.server.dao.usagerecord.ApiUsageStateService;
 import org.thingsboard.server.gen.transport.TransportProtos.ToUsageStatsServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.UsageStatsKVProto;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
 import org.thingsboard.server.queue.scheduler.SchedulerComponent;

@@ -23,7 +23,7 @@ import org.thingsboard.server.common.data.id.TenantProfileId;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.gen.transport.TransportProtos.ToUsageStatsServiceMsg;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 public interface TbApiUsageStateService extends ApplicationListener<PartitionChangeEvent> {
 

@@ -55,7 +55,7 @@ import org.thingsboard.server.gen.transport.TransportProtos.ToUsageStatsServiceM
 import org.thingsboard.server.gen.transport.TransportProtos.TransportToDeviceActorMsg;
 import org.thingsboard.server.queue.TbQueueConsumer;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.queue.provider.TbCoreQueueFactory;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;

@@ -38,7 +38,7 @@ import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.queue.TbQueueConsumer;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.queue.provider.TbRuleEngineQueueFactory;
 import org.thingsboard.server.queue.settings.TbQueueRuleEngineSettings;
 import org.thingsboard.server.queue.settings.TbRuleEngineQueueConfiguration;

@@ -16,7 +16,7 @@
 package org.thingsboard.server.service.queue;
 
 import org.springframework.context.ApplicationListener;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 public interface TbCoreConsumerService extends ApplicationListener<PartitionChangeEvent> {
 

@@ -16,7 +16,7 @@
 package org.thingsboard.server.service.queue;
 
 import org.springframework.context.ApplicationListener;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 public interface TbRuleEngineConsumerService extends ApplicationListener<PartitionChangeEvent> {
 

@@ -35,7 +35,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.queue.TbQueueConsumer;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.common.transport.util.DataDecodingEncodingService;
 import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;

@@ -54,7 +54,7 @@ import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.dao.timeseries.TimeseriesService;
 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.event.PartitionChangeEvent;
 import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
 import org.thingsboard.server.queue.util.TbCoreComponent;

@@ -18,7 +18,7 @@ package org.thingsboard.server.service.state;
 import org.springframework.context.ApplicationListener;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.id.DeviceId;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 

@@ -46,7 +46,7 @@ import org.thingsboard.server.gen.transport.TransportProtos.TbSubscriptionUpdate
 import org.thingsboard.server.gen.transport.TransportProtos.TbSubscriptionUpdateValueListProto;
 import org.thingsboard.server.queue.TbQueueProducer;
 import org.thingsboard.server.queue.common.TbProtoQueueMsg;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
 import org.thingsboard.server.queue.discovery.TbServiceInfoProvider;

@@ -20,10 +20,9 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Service;
-import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.queue.discovery.ClusterTopologyChangeEvent;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.ClusterTopologyChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;

@@ -22,7 +22,7 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.AttributeKvEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.common.msg.queue.TbCallback;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 import java.util.List;
 

@@ -15,8 +15,8 @@
  */
 package org.thingsboard.server.service.subscription;
 
-import org.thingsboard.server.queue.discovery.ClusterTopologyChangeEvent;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.ClusterTopologyChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.service.telemetry.sub.AlarmSubscriptionUpdate;
 import org.thingsboard.server.service.telemetry.sub.TelemetrySubscriptionUpdate;

@@ -22,35 +22,18 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.EventListener;
-import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.ThingsBoardThreadFactory;
-import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.common.data.kv.AttributeKvEntry;
-import org.thingsboard.server.common.data.kv.BaseAttributeKvEntry;
-import org.thingsboard.server.common.data.kv.BooleanDataEntry;
-import org.thingsboard.server.common.data.kv.DoubleDataEntry;
-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.common.msg.queue.ServiceType;
-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.gen.transport.TransportProtos;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
 import org.thingsboard.server.service.queue.TbClusterService;
 import org.thingsboard.server.service.subscription.SubscriptionManagerService;
-import org.thingsboard.server.service.subscription.TbSubscriptionUtils;
 
 import javax.annotation.Nullable;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
-import java.util.Collections;
-import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;

@@ -17,8 +17,7 @@ package org.thingsboard.server.service.telemetry;
 
 import org.springframework.context.ApplicationListener;
 import org.thingsboard.rule.engine.api.RuleEngineAlarmService;
-import org.thingsboard.rule.engine.api.RuleEngineTelemetryService;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 /**
  * Created by ashvayka on 27.03.18.

@@ -16,8 +16,7 @@
 package org.thingsboard.server.service.telemetry;
 
 import org.springframework.context.ApplicationListener;
-import org.thingsboard.rule.engine.api.RuleEngineTelemetryService;
-import org.thingsboard.server.queue.discovery.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 /**
  * Created by ashvayka on 27.03.18.

@@ -31,6 +31,7 @@ import org.thingsboard.server.common.data.ApiUsageState;
 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.DeviceTransportType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.Firmware;
 import org.thingsboard.server.common.data.FirmwareInfo;
@@ -45,6 +46,8 @@ import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.FirmwareId;
 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.relation.EntityRelation;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentialsType;
@@ -64,11 +67,15 @@ import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
+import org.thingsboard.server.gen.transport.TransportProtos.GetDeviceCredentialsRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetDeviceRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetResourceRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetSnmpDevicesRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetSnmpDevicesResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiResponseMsg;
@@ -91,6 +98,7 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
 
 /**
  * Created by ashvayka on 05.10.18.
@@ -144,43 +152,43 @@ public class DefaultTransportApiService implements TransportApiService {
     @Override
     public ListenableFuture<TbProtoQueueMsg<TransportApiResponseMsg>> handle(TbProtoQueueMsg<TransportApiRequestMsg> tbProtoQueueMsg) {
         TransportApiRequestMsg transportApiRequestMsg = tbProtoQueueMsg.getValue();
+        ListenableFuture<TransportApiResponseMsg> result = null;
+
         if (transportApiRequestMsg.hasValidateTokenRequestMsg()) {
             ValidateDeviceTokenRequestMsg msg = transportApiRequestMsg.getValidateTokenRequestMsg();
-            return Futures.transform(validateCredentials(msg.getToken(), DeviceCredentialsType.ACCESS_TOKEN),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = validateCredentials(msg.getToken(), DeviceCredentialsType.ACCESS_TOKEN);
         } else if (transportApiRequestMsg.hasValidateBasicMqttCredRequestMsg()) {
             TransportProtos.ValidateBasicMqttCredRequestMsg msg = transportApiRequestMsg.getValidateBasicMqttCredRequestMsg();
-            return Futures.transform(validateCredentials(msg),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = validateCredentials(msg);
         } else if (transportApiRequestMsg.hasValidateX509CertRequestMsg()) {
             ValidateDeviceX509CertRequestMsg msg = transportApiRequestMsg.getValidateX509CertRequestMsg();
-            return Futures.transform(validateCredentials(msg.getHash(), DeviceCredentialsType.X509_CERTIFICATE),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = validateCredentials(msg.getHash(), DeviceCredentialsType.X509_CERTIFICATE);
         } else if (transportApiRequestMsg.hasGetOrCreateDeviceRequestMsg()) {
-            return Futures.transform(handle(transportApiRequestMsg.getGetOrCreateDeviceRequestMsg()),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = handle(transportApiRequestMsg.getGetOrCreateDeviceRequestMsg());
         } else if (transportApiRequestMsg.hasEntityProfileRequestMsg()) {
-            return Futures.transform(handle(transportApiRequestMsg.getEntityProfileRequestMsg()),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = handle(transportApiRequestMsg.getEntityProfileRequestMsg());
         } else if (transportApiRequestMsg.hasLwM2MRequestMsg()) {
-            return Futures.transform(handle(transportApiRequestMsg.getLwM2MRequestMsg()),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = handle(transportApiRequestMsg.getLwM2MRequestMsg());
         } else if (transportApiRequestMsg.hasValidateDeviceLwM2MCredentialsRequestMsg()) {
             ValidateDeviceLwM2MCredentialsRequestMsg msg = transportApiRequestMsg.getValidateDeviceLwM2MCredentialsRequestMsg();
-            return Futures.transform(validateCredentials(msg.getCredentialsId(), DeviceCredentialsType.LWM2M_CREDENTIALS),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = validateCredentials(msg.getCredentialsId(), DeviceCredentialsType.LWM2M_CREDENTIALS);
         } else if (transportApiRequestMsg.hasProvisionDeviceRequestMsg()) {
-            return Futures.transform(handle(transportApiRequestMsg.getProvisionDeviceRequestMsg()),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = handle(transportApiRequestMsg.getProvisionDeviceRequestMsg());
         } else if (transportApiRequestMsg.hasResourceRequestMsg()) {
-            return Futures.transform(handle(transportApiRequestMsg.getResourceRequestMsg()),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = handle(transportApiRequestMsg.getResourceRequestMsg());
+        } else if (transportApiRequestMsg.hasSnmpDevicesRequestMsg()) {
+            result = handle(transportApiRequestMsg.getSnmpDevicesRequestMsg());
+        } else if (transportApiRequestMsg.hasDeviceRequestMsg()) {
+            result = handle(transportApiRequestMsg.getDeviceRequestMsg());
+        } else if (transportApiRequestMsg.hasDeviceCredentialsRequestMsg()) {
+            result = handle(transportApiRequestMsg.getDeviceCredentialsRequestMsg());
         } else if (transportApiRequestMsg.hasFirmwareRequestMsg()) {
-            return Futures.transform(handle(transportApiRequestMsg.getFirmwareRequestMsg()),
-                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+            result = handle(transportApiRequestMsg.getFirmwareRequestMsg());
         }
-        return Futures.transform(getEmptyTransportApiResponseFuture(),
-                value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+
+        return Futures.transform(Optional.ofNullable(result).orElseGet(this::getEmptyTransportApiResponseFuture),
+                value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()),
+                MoreExecutors.directExecutor());
     }
 
     private ListenableFuture<TransportApiResponseMsg> validateCredentials(String credentialsId, DeviceCredentialsType credentialsType) {
@@ -374,6 +382,39 @@ public class DefaultTransportApiService implements TransportApiService {
         return Futures.immediateFuture(TransportApiResponseMsg.newBuilder().setEntityProfileResponseMsg(builder).build());
     }
 
+    private ListenableFuture<TransportApiResponseMsg> handle(GetDeviceRequestMsg requestMsg) {
+        DeviceId deviceId = new DeviceId(new UUID(requestMsg.getDeviceIdMSB(), requestMsg.getDeviceIdLSB()));
+        Device device = deviceService.findDeviceById(TenantId.SYS_TENANT_ID, deviceId);
+
+        TransportApiResponseMsg responseMsg;
+        if (device != null) {
+            UUID deviceProfileId = device.getDeviceProfileId().getId();
+            responseMsg = TransportApiResponseMsg.newBuilder()
+                    .setDeviceResponseMsg(TransportProtos.GetDeviceResponseMsg.newBuilder()
+                            .setDeviceProfileIdMSB(deviceProfileId.getMostSignificantBits())
+                            .setDeviceProfileIdLSB(deviceProfileId.getLeastSignificantBits())
+                            .setDeviceTransportConfiguration(ByteString.copyFrom(
+                                    dataDecodingEncodingService.encode(device.getDeviceData().getTransportConfiguration())
+                            )))
+                    .build();
+        } else {
+            responseMsg = TransportApiResponseMsg.getDefaultInstance();
+        }
+
+        return Futures.immediateFuture(responseMsg);
+    }
+
+    private ListenableFuture<TransportApiResponseMsg> handle(GetDeviceCredentialsRequestMsg requestMsg) {
+        DeviceId deviceId = new DeviceId(new UUID(requestMsg.getDeviceIdMSB(), requestMsg.getDeviceIdLSB()));
+        DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(TenantId.SYS_TENANT_ID, deviceId);
+
+        return Futures.immediateFuture(TransportApiResponseMsg.newBuilder()
+                .setDeviceCredentialsResponseMsg(TransportProtos.GetDeviceCredentialsResponseMsg.newBuilder()
+                        .setDeviceCredentialsData(ByteString.copyFrom(dataDecodingEncodingService.encode(deviceCredentials))))
+                .build());
+    }
+
+
     private ListenableFuture<TransportApiResponseMsg> handle(GetResourceRequestMsg requestMsg) {
         TenantId tenantId = new TenantId(new UUID(requestMsg.getTenantIdMSB(), requestMsg.getTenantIdLSB()));
         ResourceType resourceType = ResourceType.valueOf(requestMsg.getResourceType());
@@ -392,6 +433,22 @@ public class DefaultTransportApiService implements TransportApiService {
         return Futures.immediateFuture(TransportApiResponseMsg.newBuilder().setResourceResponseMsg(builder).build());
     }
 
+    private ListenableFuture<TransportApiResponseMsg> handle(GetSnmpDevicesRequestMsg requestMsg) {
+        PageLink pageLink = new PageLink(requestMsg.getPageSize(), requestMsg.getPage());
+        PageData<UUID> result = deviceService.findDevicesIdsByDeviceProfileTransportType(DeviceTransportType.SNMP, pageLink);
+
+        GetSnmpDevicesResponseMsg responseMsg = GetSnmpDevicesResponseMsg.newBuilder()
+                .addAllIds(result.getData().stream()
+                        .map(UUID::toString)
+                        .collect(Collectors.toList()))
+                .setHasNextPage(result.hasNext())
+                .build();
+
+        return Futures.immediateFuture(TransportApiResponseMsg.newBuilder()
+                .setSnmpDevicesResponseMsg(responseMsg)
+                .build());
+    }
+
     private ListenableFuture<TransportApiResponseMsg> getDeviceInfo(DeviceId deviceId, DeviceCredentials credentials) {
         return Futures.transform(deviceService.findDeviceByIdAsync(TenantId.SYS_TENANT_ID, deviceId), device -> {
             if (device == null) {

@@ -26,6 +26,7 @@
     </appender>
 
     <logger name="org.thingsboard.server" level="INFO" />
+    <logger name="org.thingsboard.server.transport.snmp" level="TRACE" />
 
 <!--    <logger name="org.thingsboard.server.service.queue" level="TRACE" />-->
 <!--    <logger name="org.thingsboard.server.service.transport" level="TRACE" />-->

@@ -686,6 +686,13 @@ transport:
         alias: "${LWM2M_KEYSTORE_ALIAS_BS:bootstrap}"
     # Use redis for Security and Registration stores
     redis.enabled: "${LWM2M_REDIS_ENABLED:false}"
+  snmp:
+    enabled: "${SNMP_ENABLED:true}"
+    response_processing:
+      # parallelism level for executor (workStealingPool) that is responsible for handling responses from SNMP devices
+      parallelism_level: "${SNMP_RESPONSE_PROCESSING_PARALLELISM_LEVEL:20}"
+    # to configure SNMP to work over UDP or TCP
+    underlying_protocol: "${SNMP_UNDERLYING_PROTOCOL:udp}"
 
 # Edges parameters
 edges:

@@ -19,6 +19,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceInfo;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.device.DeviceSearchQuery;
 import org.thingsboard.server.common.data.id.CustomerId;
@@ -32,6 +33,7 @@ import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 
 import java.util.List;
+import java.util.UUID;
 
 public interface DeviceService {
 
@@ -93,6 +95,8 @@ public interface DeviceService {
 
     Device saveDevice(ProvisionRequest provisionRequest, DeviceProfile profile);
 
+    PageData<UUID> findDevicesIdsByDeviceProfileTransportType(DeviceTransportType transportType, PageLink pageLink);
+
     Device assignDeviceToEdge(TenantId tenantId, DeviceId deviceId, EdgeId edgeId);
 
     Device unassignDeviceFromEdge(TenantId tenantId, DeviceId deviceId, EdgeId edgeId);

@@ -87,6 +87,10 @@
             <groupId>org.thingsboard</groupId>
             <artifactId>protobuf-dynamic</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+        </dependency>
     </dependencies>
 
     <build>

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

+/**
+ * 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.common.data;
+
+public interface TbTransportService {
+    String getName();
+}

@@ -21,6 +21,8 @@ import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import org.thingsboard.server.common.data.DeviceTransportType;
 
+import java.io.Serializable;
+
 @JsonIgnoreProperties(ignoreUnknown = true)
 @JsonTypeInfo(
         use = JsonTypeInfo.Id.NAME,
@@ -29,11 +31,14 @@ import org.thingsboard.server.common.data.DeviceTransportType;
 @JsonSubTypes({
         @JsonSubTypes.Type(value = DefaultDeviceTransportConfiguration.class, name = "DEFAULT"),
         @JsonSubTypes.Type(value = MqttDeviceTransportConfiguration.class, name = "MQTT"),
+        @JsonSubTypes.Type(value = CoapDeviceTransportConfiguration.class, name = "COAP"),
         @JsonSubTypes.Type(value = Lwm2mDeviceTransportConfiguration.class, name = "LWM2M"),
-        @JsonSubTypes.Type(value = CoapDeviceTransportConfiguration.class, name = "COAP")})
-public interface DeviceTransportConfiguration {
-
+        @JsonSubTypes.Type(value = SnmpDeviceTransportConfiguration.class, name = "SNMP")})
+public interface DeviceTransportConfiguration extends Serializable {
     @JsonIgnore
     DeviceTransportType getType();
 
+    default void validate() {
+    }
+
 }

+/**
+ * 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.common.data.device.data;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import lombok.ToString;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.transport.snmp.AuthenticationProtocol;
+import org.thingsboard.server.common.data.transport.snmp.PrivacyProtocol;
+import org.thingsboard.server.common.data.transport.snmp.SnmpProtocolVersion;
+
+import java.util.Objects;
+
+@Data
+@ToString(of = {"host", "port", "protocolVersion"})
+public class SnmpDeviceTransportConfiguration implements DeviceTransportConfiguration {
+    private String host;
+    private Integer port;
+    private SnmpProtocolVersion protocolVersion;
+
+    /*
+     * For SNMP v1 and v2c
+     * */
+    private String community;
+
+    /*
+     * For SNMP v3
+     * */
+    private String username;
+    private String securityName;
+    private String contextName;
+    private AuthenticationProtocol authenticationProtocol;
+    private String authenticationPassphrase;
+    private PrivacyProtocol privacyProtocol;
+    private String privacyPassphrase;
+    private String engineId;
+
+    @Override
+    public DeviceTransportType getType() {
+        return DeviceTransportType.SNMP;
+    }
+
+    @Override
+    public void validate() {
+        if (!isValid()) {
+            throw new IllegalArgumentException("Transport configuration is not valid");
+        }
+    }
+
+    @JsonIgnore
+    private boolean isValid() {
+        boolean isValid = StringUtils.isNotBlank(host) && port != null && protocolVersion != null;
+        if (isValid) {
+            switch (protocolVersion) {
+                case V1:
+                case V2C:
+                    isValid = StringUtils.isNotEmpty(community);
+                    break;
+                case V3:
+                    isValid = StringUtils.isNotBlank(username) && StringUtils.isNotBlank(securityName)
+                            && contextName != null && authenticationProtocol != null
+                            && StringUtils.isNotBlank(authenticationPassphrase)
+                            && privacyProtocol != null && privacyPassphrase != null && engineId != null;
+                    break;
+            }
+        }
+        return isValid;
+    }
+}

@@ -29,13 +29,18 @@ import java.io.Serializable;
         include = JsonTypeInfo.As.PROPERTY,
         property = "type")
 @JsonSubTypes({
-         @JsonSubTypes.Type(value = DefaultDeviceProfileTransportConfiguration.class, name = "DEFAULT"),
-         @JsonSubTypes.Type(value = MqttDeviceProfileTransportConfiguration.class, name = "MQTT"),
-         @JsonSubTypes.Type(value = Lwm2mDeviceProfileTransportConfiguration.class, name = "LWM2M"),
-         @JsonSubTypes.Type(value = CoapDeviceProfileTransportConfiguration.class, name = "COAP")})
+        @JsonSubTypes.Type(value = DefaultDeviceProfileTransportConfiguration.class, name = "DEFAULT"),
+        @JsonSubTypes.Type(value = MqttDeviceProfileTransportConfiguration.class, name = "MQTT"),
+        @JsonSubTypes.Type(value = Lwm2mDeviceProfileTransportConfiguration.class, name = "LWM2M"),
+        @JsonSubTypes.Type(value = CoapDeviceProfileTransportConfiguration.class, name = "COAP"),
+        @JsonSubTypes.Type(value = SnmpDeviceProfileTransportConfiguration.class, name = "SNMP")
+})
 public interface DeviceProfileTransportConfiguration extends Serializable {
 
     @JsonIgnore
     DeviceTransportType getType();
 
+    default void validate() {
+    }
+
 }

+/**
+ * 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.common.data.device.profile;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMapping;
+import org.thingsboard.server.common.data.transport.snmp.config.SnmpCommunicationConfig;
+
+import java.util.List;
+
+@Data
+public class SnmpDeviceProfileTransportConfiguration implements DeviceProfileTransportConfiguration {
+    private Integer timeoutMs;
+    private Integer retries;
+    private List<SnmpCommunicationConfig> communicationConfigs;
+
+    @Override
+    public DeviceTransportType getType() {
+        return DeviceTransportType.SNMP;
+    }
+
+    @Override
+    public void validate() {
+        if (!isValid()) {
+            throw new IllegalArgumentException("SNMP transport configuration is not valid");
+        }
+    }
+
+    @JsonIgnore
+    private boolean isValid() {
+        return timeoutMs != null && timeoutMs >= 0 && retries != null && retries >= 0
+                && communicationConfigs != null
+                && communicationConfigs.stream().allMatch(config -> config != null && config.isValid())
+                && communicationConfigs.stream().flatMap(config -> config.getAllMappings().stream()).map(SnmpMapping::getOid)
+                .distinct().count() == communicationConfigs.stream().mapToInt(config -> config.getAllMappings().size()).sum();
+    }
+}

+/**
+ * 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.common.data.transport.snmp;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+public enum AuthenticationProtocol {
+    SHA_1("1.3.6.1.6.3.10.1.1.3"),
+    SHA_224("1.3.6.1.6.3.10.1.1.4"),
+    SHA_256("1.3.6.1.6.3.10.1.1.5"),
+    SHA_384("1.3.6.1.6.3.10.1.1.6"),
+    SHA_512("1.3.6.1.6.3.10.1.1.7"),
+    MD5("1.3.6.1.6.3.10.1.1.2");
+
+    // oids taken from org.snmp4j.security.SecurityProtocol implementations
+    private final String oid;
+
+    AuthenticationProtocol(String oid) {
+        this.oid = oid;
+    }
+
+    public String getOid() {
+        return oid;
+    }
+
+    public static Optional<AuthenticationProtocol> forName(String name) {
+        return Arrays.stream(values())
+                .filter(protocol -> protocol.name().equalsIgnoreCase(name))
+                .findFirst();
+    }
+}

+/**
+ * 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.common.data.transport.snmp;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+public enum PrivacyProtocol {
+    DES("1.3.6.1.6.3.10.1.2.2"),
+    AES_128("1.3.6.1.6.3.10.1.2.4"),
+    AES_192("1.3.6.1.4.1.4976.2.2.1.1.1"),
+    AES_256("1.3.6.1.4.1.4976.2.2.1.1.2");
+
+    // oids taken from org.snmp4j.security.SecurityProtocol implementations
+    private final String oid;
+
+    PrivacyProtocol(String oid) {
+        this.oid = oid;
+    }
+
+    public String getOid() {
+        return oid;
+    }
+
+    public static Optional<PrivacyProtocol> forName(String name) {
+        return Arrays.stream(values())
+                .filter(protocol -> protocol.name().equalsIgnoreCase(name))
+                .findFirst();
+    }
+}

+/**
+ * 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.common.data.transport.snmp;
+
+public enum SnmpCommunicationSpec {
+    TELEMETRY_QUERYING,
+
+    CLIENT_ATTRIBUTES_QUERYING,
+    SHARED_ATTRIBUTES_SETTING,
+
+    TO_DEVICE_RPC_REQUEST,
+}

+/**
+ * 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.common.data.transport.snmp;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.commons.lang3.StringUtils;
+import org.thingsboard.server.common.data.kv.DataType;
+
+import java.util.regex.Pattern;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SnmpMapping {
+    private String oid;
+    private String key;
+    private DataType dataType;
+
+    private static final Pattern OID_PATTERN = Pattern.compile("^\\.?([0-2])((\\.0)|(\\.[1-9][0-9]*))*$");
+
+    @JsonIgnore
+    public boolean isValid() {
+        return StringUtils.isNotEmpty(oid) && OID_PATTERN.matcher(oid).matches() && StringUtils.isNotBlank(key);
+    }
+}

+/**
+ * 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.common.data.transport.snmp;
+
+public enum SnmpMethod {
+    GET(-96),
+    SET(-93);
+
+    // codes taken from org.snmp4j.PDU class
+    private final int code;
+
+    SnmpMethod(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+}

+/**
+ * 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.common.data.transport.snmp;
+
+public enum SnmpProtocolVersion {
+    V1(0),
+    V2C(1),
+    V3(3);
+
+    private final int code;
+
+    SnmpProtocolVersion(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return code;
+    }
+}

+/**
+ * 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.common.data.transport.snmp.config;
+
+import lombok.Data;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMapping;
+
+import java.util.List;
+
+@Data
+public abstract class MultipleMappingsSnmpCommunicationConfig implements SnmpCommunicationConfig {
+    protected List<SnmpMapping> mappings;
+
+    @Override
+    public boolean isValid() {
+        return mappings != null && !mappings.isEmpty() && mappings.stream().allMatch(mapping -> mapping != null && mapping.isValid());
+    }
+
+    @Override
+    public List<SnmpMapping> getAllMappings() {
+        return mappings;
+    }
+}

+/**
+ * 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.common.data.transport.snmp.config;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMethod;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public abstract class RepeatingQueryingSnmpCommunicationConfig extends MultipleMappingsSnmpCommunicationConfig {
+    private Long queryingFrequencyMs;
+
+    @Override
+    public SnmpMethod getMethod() {
+        return SnmpMethod.GET;
+    }
+
+    @Override
+    public boolean isValid() {
+        return queryingFrequencyMs != null && queryingFrequencyMs > 0 && super.isValid();
+    }
+}

+/**
+ * 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.common.data.transport.snmp.config;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonSubTypes.Type;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import org.thingsboard.server.common.data.transport.snmp.SnmpCommunicationSpec;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMapping;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMethod;
+import org.thingsboard.server.common.data.transport.snmp.config.impl.ClientAttributesQueryingSnmpCommunicationConfig;
+import org.thingsboard.server.common.data.transport.snmp.config.impl.SharedAttributesSettingSnmpCommunicationConfig;
+import org.thingsboard.server.common.data.transport.snmp.config.impl.TelemetryQueryingSnmpCommunicationConfig;
+
+import java.util.List;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "spec")
+@JsonSubTypes({
+        @Type(value = TelemetryQueryingSnmpCommunicationConfig.class, name = "TELEMETRY_QUERYING"),
+        @Type(value = ClientAttributesQueryingSnmpCommunicationConfig.class, name = "CLIENT_ATTRIBUTES_QUERYING"),
+        @Type(value = SharedAttributesSettingSnmpCommunicationConfig.class, name = "SHARED_ATTRIBUTES_SETTING")
+})
+public interface SnmpCommunicationConfig {
+
+    SnmpCommunicationSpec getSpec();
+
+    @JsonIgnore
+    default SnmpMethod getMethod() {
+        return null;
+    }
+
+    @JsonIgnore
+    List<SnmpMapping> getAllMappings();
+
+    @JsonIgnore
+    boolean isValid();
+
+}

+/**
+ * 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.common.data.transport.snmp.config.impl;
+
+import org.thingsboard.server.common.data.transport.snmp.SnmpCommunicationSpec;
+import org.thingsboard.server.common.data.transport.snmp.config.RepeatingQueryingSnmpCommunicationConfig;
+
+public class ClientAttributesQueryingSnmpCommunicationConfig extends RepeatingQueryingSnmpCommunicationConfig {
+
+    @Override
+    public SnmpCommunicationSpec getSpec() {
+        return SnmpCommunicationSpec.CLIENT_ATTRIBUTES_QUERYING;
+    }
+
+}

+/**
+ * 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.common.data.transport.snmp.config.impl;
+
+import org.thingsboard.server.common.data.transport.snmp.SnmpCommunicationSpec;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMethod;
+import org.thingsboard.server.common.data.transport.snmp.config.MultipleMappingsSnmpCommunicationConfig;
+
+public class SharedAttributesSettingSnmpCommunicationConfig extends MultipleMappingsSnmpCommunicationConfig {
+
+    @Override
+    public SnmpCommunicationSpec getSpec() {
+        return SnmpCommunicationSpec.SHARED_ATTRIBUTES_SETTING;
+    }
+
+    @Override
+    public SnmpMethod getMethod() {
+        return SnmpMethod.SET;
+    }
+
+}

+/**
+ * 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.common.data.transport.snmp.config.impl;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.transport.snmp.SnmpCommunicationSpec;
+import org.thingsboard.server.common.data.transport.snmp.config.RepeatingQueryingSnmpCommunicationConfig;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TelemetryQueryingSnmpCommunicationConfig extends RepeatingQueryingSnmpCommunicationConfig {
+
+    @Override
+    public SnmpCommunicationSpec getSpec() {
+        return SnmpCommunicationSpec.TELEMETRY_QUERYING;
+    }
+
+}

@@ -19,19 +19,23 @@ import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.ApplicationContext;
 import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.TbTransportService;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ServiceInfo;
 import org.thingsboard.server.queue.settings.TbQueueRuleEngineSettings;
 import org.thingsboard.server.queue.settings.TbRuleEngineQueueConfiguration;
+import org.thingsboard.server.queue.util.AfterContextReady;
 
 import javax.annotation.PostConstruct;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
@@ -56,6 +60,8 @@ public class DefaultTbServiceInfoProvider implements TbServiceInfoProvider {
 
     @Autowired(required = false)
     private TbQueueRuleEngineSettings ruleEngineSettings;
+    @Autowired
+    private ApplicationContext applicationContext;
 
     private List<ServiceType> serviceTypes;
     private ServiceInfo serviceInfo;
@@ -102,6 +108,19 @@ public class DefaultTbServiceInfoProvider implements TbServiceInfoProvider {
         serviceInfo = builder.build();
     }
 
+    @AfterContextReady
+    public void setTransports() {
+        serviceInfo = ServiceInfo.newBuilder(serviceInfo)
+                .addAllTransports(getTransportServices().stream()
+                        .map(TbTransportService::getName)
+                        .collect(Collectors.toSet()))
+                .build();
+    }
+
+    private Collection<TbTransportService> getTransportServices() {
+        return applicationContext.getBeansOfType(TbTransportService.class).values();
+    }
+
     @Override
     public ServiceInfo getServiceInfo() {
         return serviceInfo;

@@ -15,26 +15,27 @@
  */
 package org.thingsboard.server.queue.discovery;
 
-import com.google.common.hash.HashCode;
 import com.google.common.hash.HashFunction;
+import com.google.common.hash.Hasher;
 import com.google.common.hash.Hashing;
-import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.common.msg.queue.ServiceQueueKey;
 import org.thingsboard.server.common.msg.queue.ServiceQueue;
+import org.thingsboard.server.common.msg.queue.ServiceQueueKey;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ServiceInfo;
+import org.thingsboard.server.queue.discovery.event.ClusterTopologyChangeEvent;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
+import org.thingsboard.server.queue.discovery.event.ServiceListChangedEvent;
 import org.thingsboard.server.queue.settings.TbQueueRuleEngineSettings;
 
 import javax.annotation.PostConstruct;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -46,7 +47,6 @@ import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.ConcurrentNavigableMap;
 import java.util.stream.Collectors;
 
 @Service
@@ -186,6 +186,8 @@ public class HashPartitionService implements PartitionService {
                 applicationEventPublisher.publishEvent(new ClusterTopologyChangeEvent(this, changes));
             }
         }
+
+        applicationEventPublisher.publishEvent(new ServiceListChangedEvent(otherServices, currentService));
     }
 
     @Override
@@ -219,6 +221,14 @@ public class HashPartitionService implements PartitionService {
         }
     }
 
+    @Override
+    public int resolvePartitionIndex(UUID entityId, int partitions) {
+        int hash = hashFunction.newHasher()
+                .putLong(entityId.getMostSignificantBits())
+                .putLong(entityId.getLeastSignificantBits()).hash().asInt();
+        return Math.abs(hash % partitions);
+    }
+
     private Map<ServiceQueueKey, List<ServiceInfo>> getServiceKeyListMap(List<ServiceInfo> services) {
         final Map<ServiceQueueKey, List<ServiceInfo>> currentMap = new HashMap<>();
         services.forEach(serviceInfo -> {

@@ -20,9 +20,11 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.queue.discovery.event.PartitionChangeEvent;
 
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 
 /**
  * Once application is ready or cluster topology changes, this Service will produce {@link PartitionChangeEvent}
@@ -55,4 +57,6 @@ public interface PartitionService {
      * @return
      */
     TopicPartitionInfo getNotificationsTopic(ServiceType serviceType, String serviceId);
+
+    int resolvePartitionIndex(UUID entityId, int partitions);
 }

@@ -17,6 +17,7 @@ package org.thingsboard.server.queue.discovery;
 
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.ApplicationListener;
+import org.thingsboard.server.queue.discovery.event.TbApplicationEvent;
 
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;

@@ -33,12 +33,14 @@ import org.apache.zookeeper.KeeperException;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.event.ApplicationReadyEvent;
+import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.event.EventListener;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Service;
 import org.springframework.util.Assert;
 import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.queue.discovery.event.ServiceListChangedEvent;
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
@@ -77,7 +79,8 @@ public class ZkDiscoveryService implements DiscoveryService, PathChildrenCacheLi
 
     private volatile boolean stopped = true;
 
-    public ZkDiscoveryService(TbServiceInfoProvider serviceInfoProvider, PartitionService partitionService) {
+    public ZkDiscoveryService(TbServiceInfoProvider serviceInfoProvider,
+                              PartitionService partitionService) {
         this.serviceInfoProvider = serviceInfoProvider;
         this.partitionService = partitionService;
     }

@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.queue.discovery;
+package org.thingsboard.server.queue.discovery.event;
 
 import lombok.Getter;
-import org.springframework.context.ApplicationEvent;
 import org.thingsboard.server.common.msg.queue.ServiceQueueKey;
 
 import java.util.Set;

@@ -13,10 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.queue.discovery;
+package org.thingsboard.server.queue.discovery.event;
 
 import lombok.Getter;
-import org.springframework.context.ApplicationEvent;
 import org.thingsboard.server.common.msg.queue.ServiceQueueKey;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;

+/**
+ * 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.discovery.event;
+
+import lombok.Getter;
+import lombok.ToString;
+import org.thingsboard.server.gen.transport.TransportProtos.ServiceInfo;
+
+import java.util.List;
+
+@Getter
+@ToString
+public class ServiceListChangedEvent extends TbApplicationEvent {
+    private final List<ServiceInfo> otherServices;
+    private final ServiceInfo currentService;
+
+    public ServiceListChangedEvent(List<ServiceInfo> otherServices, ServiceInfo currentService) {
+        super(otherServices);
+        this.otherServices = otherServices;
+        this.currentService = currentService;
+    }
+}

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.thingsboard.server.queue.discovery;
+package org.thingsboard.server.queue.discovery.event;
 
 import lombok.Getter;
 import org.springframework.context.ApplicationEvent;

+/**
+ * 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.context.event.ContextRefreshedEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.core.annotation.AliasFor;
+import org.springframework.core.annotation.Order;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@EventListener(ContextRefreshedEvent.class)
+@Order
+public @interface AfterContextReady {
+    @AliasFor(annotation = Order.class, attribute = "value")
+    int order() default Integer.MAX_VALUE;
+}

+/**
+ * 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.context.event.ApplicationReadyEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.core.annotation.AliasFor;
+import org.springframework.core.annotation.Order;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@EventListener(ApplicationReadyEvent.class)
+@Order
+public @interface AfterStartUp {
+    @AliasFor(annotation = Order.class, attribute = "value")
+    int order() default Integer.MAX_VALUE;
+}

+/**
+ * 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.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.snmp.enabled}'=='true')")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface TbSnmpTransportComponent {
+}

@@ -34,6 +34,7 @@ message ServiceInfo {
   int64 tenantIdMSB = 3;
   int64 tenantIdLSB = 4;
   repeated QueueInfo ruleEngineQueues = 5;
+  repeated string transports = 6;
 }
 
 /**
@@ -246,6 +247,36 @@ message GetEntityProfileResponseMsg {
   bytes apiState = 3;
 }
 
+message GetDeviceRequestMsg {
+  int64 deviceIdMSB = 1;
+  int64 deviceIdLSB = 2;
+}
+
+message GetDeviceResponseMsg {
+  int64 deviceProfileIdMSB = 1;
+  int64 deviceProfileIdLSB = 2;
+  bytes deviceTransportConfiguration = 3;
+}
+
+message GetDeviceCredentialsRequestMsg {
+  int64 deviceIdMSB = 1;
+  int64 deviceIdLSB = 2;
+}
+
+message GetDeviceCredentialsResponseMsg {
+  bytes deviceCredentialsData = 1;
+}
+
+message GetSnmpDevicesRequestMsg {
+  int32 page = 1;
+  int32 pageSize = 2;
+}
+
+message GetSnmpDevicesResponseMsg {
+  repeated string ids = 1;
+  bool hasNextPage = 2;
+}
+
 message EntityUpdateMsg {
   string entityType = 1;
   bytes data = 2;
@@ -590,6 +621,9 @@ message TransportApiRequestMsg {
   ValidateDeviceLwM2MCredentialsRequestMsg validateDeviceLwM2MCredentialsRequestMsg = 8;
   GetResourceRequestMsg resourceRequestMsg = 9;
   GetFirmwareRequestMsg firmwareRequestMsg = 10;
+  GetSnmpDevicesRequestMsg snmpDevicesRequestMsg = 11;
+  GetDeviceRequestMsg deviceRequestMsg = 12;
+  GetDeviceCredentialsRequestMsg deviceCredentialsRequestMsg = 13;
 }
 
 /* Response from ThingsBoard Core Service to Transport Service */
@@ -598,9 +632,12 @@ message TransportApiResponseMsg {
   GetOrCreateDeviceFromGatewayResponseMsg getOrCreateDeviceResponseMsg = 2;
   GetEntityProfileResponseMsg entityProfileResponseMsg = 3;
   ProvisionDeviceResponseMsg provisionDeviceResponseMsg = 4;
+  GetSnmpDevicesResponseMsg snmpDevicesResponseMsg = 5;
   LwM2MResponseMsg lwM2MResponseMsg = 6;
   GetResourceResponseMsg resourceResponseMsg = 7;
   GetFirmwareResponseMsg firmwareResponseMsg = 8;
+  GetDeviceResponseMsg deviceResponseMsg = 9;
+  GetDeviceCredentialsResponseMsg deviceCredentialsResponseMsg = 10;
 }
 
 /* Messages that are handled by ThingsBoard Core Service */

@@ -21,6 +21,7 @@ import org.eclipse.californium.core.CoapServer;
 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.TbTransportService;
 import org.thingsboard.server.coapserver.CoapServerService;
 import org.thingsboard.server.transport.coap.efento.CoapEfentoTransportResource;
 
@@ -31,7 +32,7 @@ import java.net.UnknownHostException;
 @Service("CoapTransportService")
 @ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.coap.enabled}'=='true')")
 @Slf4j
-public class CoapTransportService {
+public class CoapTransportService implements TbTransportService {
 
     private static final String V1 = "v1";
     private static final String API = "api";
@@ -65,4 +66,9 @@ public class CoapTransportService {
     public void shutdown() {
         log.info("CoAP transport stopped!");
     }
+
+    @Override
+    public String getName() {
+        return "COAP";
+    }
 }

@@ -34,6 +34,7 @@ import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.context.request.async.DeferredResult;
 import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.TbTransportService;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.transport.SessionMsgListener;
 import org.thingsboard.server.common.transport.TransportContext;
@@ -70,7 +71,7 @@ import java.util.function.Consumer;
 @ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.http.enabled}'=='true')")
 @RequestMapping("/api/v1")
 @Slf4j
-public class DeviceApiController {
+public class DeviceApiController implements TbTransportService {
 
     @Autowired
     private HttpTransportContext transportContext;
@@ -407,4 +408,9 @@ public class DeviceApiController {
         }
     }
 
+    @Override
+    public String getName() {
+        return "HTTP";
+    }
+
 }

@@ -20,13 +20,14 @@ import org.eclipse.leshan.core.response.ReadResponse;
 import org.eclipse.leshan.server.registration.Registration;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.TbTransportService;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.transport.lwm2m.server.client.Lwm2mClientRpcRequest;
 
 import java.util.Collection;
 import java.util.Optional;
 
-public interface LwM2mTransportService {
+public interface LwM2mTransportService extends TbTransportService {
 
     void onRegistered(Registration registration, Collection<Observation> previousObsersations);
 

@@ -40,6 +40,7 @@ import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.transport.TransportService;
 import org.thingsboard.server.common.transport.adaptor.AdaptorException;
 import org.thingsboard.server.common.transport.service.DefaultTransportService;
@@ -1353,4 +1354,10 @@ public class LwM2mTransportServiceImpl implements LwM2mTransportService {
                 objectId != null && objectVer != null && objectVer.equals(lwM2mClient.getRegistration().getSupportedVersion(objectId)) && resourceModel.operations.isWritable() :
                 objectId != null && objectVer != null && objectVer.equals(lwM2mClient.getRegistration().getSupportedVersion(objectId)));
     }
+
+    @Override
+    public String getName() {
+        return "LWM2M";
+    }
+
 }

@@ -28,6 +28,7 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.TbTransportService;
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
@@ -38,7 +39,7 @@ import javax.annotation.PreDestroy;
 @Service("MqttTransportService")
 @ConditionalOnExpression("'${service.type:null}'=='tb-transport' || ('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true' && '${transport.mqtt.enabled}'=='true')")
 @Slf4j
-public class MqttTransportService {
+public class MqttTransportService implements TbTransportService {
 
     @Value("${transport.mqtt.bind_address}")
     private String host;
@@ -90,4 +91,9 @@ public class MqttTransportService {
         }
         log.info("MQTT transport stopped!");
     }
+
+    @Override
+    public String getName() {
+        return "MQTT";
+    }
 }

@@ -40,6 +40,7 @@
         <module>http</module>
         <module>coap</module>
         <module>lwm2m</module>
+        <module>snmp</module>
     </modules>
 
 </project>

+<!--
+
+    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.common</groupId>
+        <version>3.3.0-SNAPSHOT</version>
+        <artifactId>transport</artifactId>
+    </parent>
+
+    <groupId>org.thingsboard.common.transport</groupId>
+    <artifactId>snmp</artifactId>
+    <packaging>jar</packaging>
+
+    <name>Thingsboard SNMP Transport Common</name>
+    <url>https://thingsboard.io</url>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <main.dir>${basedir}/../../..</main.dir>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.thingsboard.common.transport</groupId>
+            <artifactId>transport-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context-support</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.snmp4j</groupId>
+            <artifactId>snmp4j</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.snmp4j</groupId>
+            <artifactId>snmp4j-agent</artifactId>
+            <version>3.3.6</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

+/**
+ * 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.snmp;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.device.data.DeviceTransportConfiguration;
+import org.thingsboard.server.common.data.device.data.SnmpDeviceTransportConfiguration;
+import org.thingsboard.server.common.data.device.profile.SnmpDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.security.DeviceCredentials;
+import org.thingsboard.server.common.data.security.DeviceCredentialsType;
+import org.thingsboard.server.common.transport.DeviceUpdatedEvent;
+import org.thingsboard.server.common.transport.TransportContext;
+import org.thingsboard.server.common.transport.TransportDeviceProfileCache;
+import org.thingsboard.server.common.transport.TransportService;
+import org.thingsboard.server.common.transport.TransportServiceCallback;
+import org.thingsboard.server.common.transport.auth.SessionInfoCreator;
+import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsResponse;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.gen.transport.TransportProtos.SessionInfoProto;
+import org.thingsboard.server.queue.util.AfterStartUp;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+import org.thingsboard.server.transport.snmp.service.ProtoTransportEntityService;
+import org.thingsboard.server.transport.snmp.service.SnmpAuthService;
+import org.thingsboard.server.transport.snmp.service.SnmpTransportBalancingService;
+import org.thingsboard.server.transport.snmp.service.SnmpTransportService;
+import org.thingsboard.server.transport.snmp.session.DeviceSessionContext;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.stream.Collectors;
+
+@TbSnmpTransportComponent
+@Component
+@Slf4j
+@RequiredArgsConstructor
+public class SnmpTransportContext extends TransportContext {
+    @Getter
+    private final SnmpTransportService snmpTransportService;
+    private final TransportDeviceProfileCache deviceProfileCache;
+    private final TransportService transportService;
+    private final ProtoTransportEntityService protoEntityService;
+    private final SnmpTransportBalancingService balancingService;
+    @Getter
+    private final SnmpAuthService snmpAuthService;
+
+    private final Map<DeviceId, DeviceSessionContext> sessions = new ConcurrentHashMap<>();
+    private Collection<DeviceId> allSnmpDevicesIds = new ConcurrentLinkedDeque<>();
+
+    @AfterStartUp(order = 2)
+    public void initDevicesSessions() {
+        log.info("Initializing SNMP devices sessions");
+        allSnmpDevicesIds = protoEntityService.getAllSnmpDevicesIds().stream()
+                .map(DeviceId::new)
+                .collect(Collectors.toList());
+        log.trace("Found all SNMP devices ids: {}", allSnmpDevicesIds);
+
+        List<DeviceId> managedDevicesIds = allSnmpDevicesIds.stream()
+                .filter(deviceId -> balancingService.isManagedByCurrentTransport(deviceId.getId()))
+                .collect(Collectors.toList());
+        log.info("SNMP devices managed by current SNMP transport: {}", managedDevicesIds);
+
+        managedDevicesIds.stream()
+                .map(protoEntityService::getDeviceById)
+                .collect(Collectors.toList())
+                .forEach(this::establishDeviceSession);
+    }
+
+    private void establishDeviceSession(Device device) {
+        if (device == null) return;
+        log.info("Establishing SNMP session for device {}", device.getId());
+
+        DeviceProfileId deviceProfileId = device.getDeviceProfileId();
+        DeviceProfile deviceProfile = deviceProfileCache.get(deviceProfileId);
+
+        DeviceCredentials credentials = protoEntityService.getDeviceCredentialsByDeviceId(device.getId());
+        if (credentials.getCredentialsType() != DeviceCredentialsType.ACCESS_TOKEN) {
+            log.warn("[{}] Expected credentials type is {} but found {}", device.getId(), DeviceCredentialsType.ACCESS_TOKEN, credentials.getCredentialsType());
+            return;
+        }
+
+        SnmpDeviceProfileTransportConfiguration profileTransportConfiguration = (SnmpDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration();
+        SnmpDeviceTransportConfiguration deviceTransportConfiguration = (SnmpDeviceTransportConfiguration) device.getDeviceData().getTransportConfiguration();
+
+        DeviceSessionContext deviceSessionContext;
+        try {
+            deviceSessionContext = new DeviceSessionContext(
+                    device, deviceProfile, credentials.getCredentialsId(),
+                    profileTransportConfiguration, deviceTransportConfiguration, this
+            );
+            registerSessionMsgListener(deviceSessionContext);
+        } catch (Exception e) {
+            log.error("Failed to establish session for SNMP device {}: {}", device.getId(), e.toString());
+            return;
+        }
+        sessions.put(device.getId(), deviceSessionContext);
+        snmpTransportService.createQueryingTasks(deviceSessionContext);
+        log.info("Established SNMP device session for device {}", device.getId());
+    }
+
+    private void updateDeviceSession(DeviceSessionContext sessionContext, Device device, DeviceProfile deviceProfile) {
+        log.info("Updating SNMP session for device {}", device.getId());
+
+        DeviceCredentials credentials = protoEntityService.getDeviceCredentialsByDeviceId(device.getId());
+        if (credentials.getCredentialsType() != DeviceCredentialsType.ACCESS_TOKEN) {
+            log.warn("[{}] Expected credentials type is {} but found {}", device.getId(), DeviceCredentialsType.ACCESS_TOKEN, credentials.getCredentialsType());
+            destroyDeviceSession(sessionContext);
+            return;
+        }
+
+        SnmpDeviceProfileTransportConfiguration newProfileTransportConfiguration = (SnmpDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration();
+        SnmpDeviceTransportConfiguration newDeviceTransportConfiguration = (SnmpDeviceTransportConfiguration) device.getDeviceData().getTransportConfiguration();
+
+        try {
+            if (!newProfileTransportConfiguration.equals(sessionContext.getProfileTransportConfiguration())) {
+                sessionContext.setProfileTransportConfiguration(newProfileTransportConfiguration);
+                sessionContext.initializeTarget(newProfileTransportConfiguration, newDeviceTransportConfiguration);
+                snmpTransportService.cancelQueryingTasks(sessionContext);
+                snmpTransportService.createQueryingTasks(sessionContext);
+            } else if (!newDeviceTransportConfiguration.equals(sessionContext.getDeviceTransportConfiguration())) {
+                sessionContext.setDeviceTransportConfiguration(newDeviceTransportConfiguration);
+                sessionContext.initializeTarget(newProfileTransportConfiguration, newDeviceTransportConfiguration);
+            } else {
+                log.trace("Configuration of the device {} was not updated", device);
+            }
+        } catch (Exception e) {
+            log.error("Failed to update session for SNMP device {}: {}", sessionContext.getDeviceId(), e.getMessage());
+            destroyDeviceSession(sessionContext);
+        }
+    }
+
+    private void destroyDeviceSession(DeviceSessionContext sessionContext) {
+        if (sessionContext == null) return;
+        log.info("Destroying SNMP device session for device {}", sessionContext.getDevice().getId());
+        sessionContext.close();
+        snmpAuthService.cleanUpSnmpAuthInfo(sessionContext);
+        transportService.deregisterSession(sessionContext.getSessionInfo());
+        snmpTransportService.cancelQueryingTasks(sessionContext);
+        sessions.remove(sessionContext.getDeviceId());
+        log.trace("Unregistered and removed session");
+    }
+
+    private void registerSessionMsgListener(DeviceSessionContext deviceSessionContext) {
+        transportService.process(DeviceTransportType.SNMP,
+                TransportProtos.ValidateDeviceTokenRequestMsg.newBuilder().setToken(deviceSessionContext.getToken()).build(),
+                new TransportServiceCallback<>() {
+                    @Override
+                    public void onSuccess(ValidateDeviceCredentialsResponse msg) {
+                        if (msg.hasDeviceInfo()) {
+                            SessionInfoProto sessionInfo = SessionInfoCreator.create(
+                                    msg, SnmpTransportContext.this, UUID.randomUUID()
+                            );
+
+                            transportService.registerAsyncSession(sessionInfo, deviceSessionContext);
+                            transportService.process(sessionInfo, TransportProtos.SubscribeToAttributeUpdatesMsg.newBuilder().build(), TransportServiceCallback.EMPTY);
+                            transportService.process(sessionInfo, TransportProtos.SubscribeToRPCMsg.newBuilder().build(), TransportServiceCallback.EMPTY);
+
+                            deviceSessionContext.setSessionInfo(sessionInfo);
+                            deviceSessionContext.setDeviceInfo(msg.getDeviceInfo());
+                        } else {
+                            log.warn("[{}] Failed to process device auth", deviceSessionContext.getDeviceId());
+                        }
+                    }
+
+                    @Override
+                    public void onError(Throwable e) {
+                        log.warn("[{}] Failed to process device auth: {}", deviceSessionContext.getDeviceId(), e);
+                    }
+                });
+    }
+
+    @EventListener(DeviceUpdatedEvent.class)
+    public void onDeviceUpdatedOrCreated(DeviceUpdatedEvent deviceUpdatedEvent) {
+        Device device = deviceUpdatedEvent.getDevice();
+        log.trace("Got creating or updating device event for device {}", device);
+        DeviceTransportType transportType = Optional.ofNullable(device.getDeviceData().getTransportConfiguration())
+                .map(DeviceTransportConfiguration::getType)
+                .orElse(null);
+        if (!allSnmpDevicesIds.contains(device.getId())) {
+            if (transportType != DeviceTransportType.SNMP) {
+                return;
+            }
+            allSnmpDevicesIds.add(device.getId());
+            if (balancingService.isManagedByCurrentTransport(device.getId().getId())) {
+                establishDeviceSession(device);
+            }
+        } else {
+            if (balancingService.isManagedByCurrentTransport(device.getId().getId())) {
+                DeviceSessionContext sessionContext = sessions.get(device.getId());
+                if (transportType == DeviceTransportType.SNMP) {
+                    if (sessionContext != null) {
+                        updateDeviceSession(sessionContext, device, deviceProfileCache.get(device.getDeviceProfileId()));
+                    } else {
+                        establishDeviceSession(device);
+                    }
+                } else {
+                    log.trace("Transport type was changed to {}", transportType);
+                    destroyDeviceSession(sessionContext);
+                }
+            }
+        }
+    }
+
+    public void onDeviceDeleted(DeviceSessionContext sessionContext) {
+        destroyDeviceSession(sessionContext);
+    }
+
+    public void onDeviceProfileUpdated(DeviceProfile deviceProfile, DeviceSessionContext sessionContext) {
+        updateDeviceSession(sessionContext, sessionContext.getDevice(), deviceProfile);
+    }
+
+    public void onSnmpTransportListChanged() {
+        log.trace("SNMP transport list changed. Updating sessions");
+        List<DeviceId> deleted = new LinkedList<>();
+        for (DeviceId deviceId : allSnmpDevicesIds) {
+            if (balancingService.isManagedByCurrentTransport(deviceId.getId())) {
+                if (!sessions.containsKey(deviceId)) {
+                    Device device = protoEntityService.getDeviceById(deviceId);
+                    if (device != null) {
+                        log.info("SNMP device {} is now managed by current transport node", deviceId);
+                        establishDeviceSession(device);
+                    } else {
+                        deleted.add(deviceId);
+                    }
+                }
+            } else {
+                Optional.ofNullable(sessions.get(deviceId))
+                        .ifPresent(sessionContext -> {
+                            log.info("SNMP session for device {} is not managed by current transport node anymore", deviceId);
+                            destroyDeviceSession(sessionContext);
+                        });
+            }
+        }
+        log.trace("Removing deleted SNMP devices: {}", deleted);
+        allSnmpDevicesIds.removeAll(deleted);
+    }
+
+
+    public Collection<DeviceSessionContext> getSessions() {
+        return sessions.values();
+    }
+
+}

+/**
+ * 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.snmp.event;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
+import org.thingsboard.server.queue.discovery.event.ServiceListChangedEvent;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+import org.thingsboard.server.transport.snmp.service.SnmpTransportBalancingService;
+
+@TbSnmpTransportComponent
+@Component
+@RequiredArgsConstructor
+public class ServiceListChangedEventListener extends TbApplicationEventListener<ServiceListChangedEvent> {
+    private final SnmpTransportBalancingService snmpTransportBalancingService;
+
+    @Override
+    protected void onTbApplicationEvent(ServiceListChangedEvent event) {
+        snmpTransportBalancingService.onServiceListChanged(event);
+    }
+}

+/**
+ * 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.snmp.event;
+
+import org.thingsboard.server.queue.discovery.event.TbApplicationEvent;
+
+public class SnmpTransportListChangedEvent extends TbApplicationEvent {
+    public SnmpTransportListChangedEvent() {
+        super(new Object());
+    }
+}

+/**
+ * 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.snmp.event;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.queue.discovery.TbApplicationEventListener;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+import org.thingsboard.server.transport.snmp.SnmpTransportContext;
+
+@TbSnmpTransportComponent
+@Component
+@RequiredArgsConstructor
+public class SnmpTransportListChangedEventListener extends TbApplicationEventListener<SnmpTransportListChangedEvent> {
+    private final SnmpTransportContext snmpTransportContext;
+
+    @Override
+    protected void onTbApplicationEvent(SnmpTransportListChangedEvent event) {
+        snmpTransportContext.onSnmpTransportListChanged();
+    }
+}

+/**
+ * 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.snmp.service;
+
+import com.google.gson.JsonObject;
+import lombok.extern.slf4j.Slf4j;
+import org.snmp4j.PDU;
+import org.snmp4j.ScopedPDU;
+import org.snmp4j.smi.Integer32;
+import org.snmp4j.smi.Null;
+import org.snmp4j.smi.OID;
+import org.snmp4j.smi.OctetString;
+import org.snmp4j.smi.Variable;
+import org.snmp4j.smi.VariableBinding;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.device.data.SnmpDeviceTransportConfiguration;
+import org.thingsboard.server.common.data.kv.DataType;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMapping;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMethod;
+import org.thingsboard.server.common.data.transport.snmp.SnmpProtocolVersion;
+import org.thingsboard.server.common.data.transport.snmp.config.SnmpCommunicationConfig;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+import org.thingsboard.server.transport.snmp.session.DeviceSessionContext;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+@TbSnmpTransportComponent
+@Service
+@Slf4j
+public class PduService {
+    public PDU createPdu(DeviceSessionContext sessionContext, SnmpCommunicationConfig communicationConfig, Map<String, String> values) {
+        PDU pdu = setUpPdu(sessionContext);
+
+        pdu.setType(communicationConfig.getMethod().getCode());
+        pdu.addAll(communicationConfig.getAllMappings().stream()
+                .filter(mapping -> values.isEmpty() || values.containsKey(mapping.getKey()))
+                .map(mapping -> Optional.ofNullable(values.get(mapping.getKey()))
+                        .map(value -> {
+                            Variable variable = toSnmpVariable(value, mapping.getDataType());
+                            return new VariableBinding(new OID(mapping.getOid()), variable);
+                        })
+                        .orElseGet(() -> new VariableBinding(new OID(mapping.getOid()))))
+                .collect(Collectors.toList()));
+
+        return pdu;
+    }
+
+    public PDU createSingleVariablePdu(DeviceSessionContext sessionContext, SnmpMethod snmpMethod, String oid, String value, DataType dataType) {
+        PDU pdu = setUpPdu(sessionContext);
+        pdu.setType(snmpMethod.getCode());
+
+        Variable variable = value == null ? Null.instance : toSnmpVariable(value, dataType);
+        pdu.add(new VariableBinding(new OID(oid), variable));
+
+        return pdu;
+    }
+
+    private Variable toSnmpVariable(String value, DataType dataType) {
+        dataType = dataType == null ? DataType.STRING : dataType;
+        Variable variable;
+        switch (dataType) {
+            case LONG:
+                try {
+                    variable = new Integer32(Integer.parseInt(value));
+                    break;
+                } catch (NumberFormatException ignored) {
+                }
+            case DOUBLE:
+            case BOOLEAN:
+            case STRING:
+            case JSON:
+            default:
+                variable = new OctetString(value);
+        }
+        return variable;
+    }
+
+    private PDU setUpPdu(DeviceSessionContext sessionContext) {
+        PDU pdu;
+        SnmpDeviceTransportConfiguration deviceTransportConfiguration = sessionContext.getDeviceTransportConfiguration();
+        SnmpProtocolVersion snmpVersion = deviceTransportConfiguration.getProtocolVersion();
+        switch (snmpVersion) {
+            case V1:
+            case V2C:
+                pdu = new PDU();
+                break;
+            case V3:
+                ScopedPDU scopedPdu = new ScopedPDU();
+                scopedPdu.setContextName(new OctetString(deviceTransportConfiguration.getContextName()));
+                scopedPdu.setContextEngineID(new OctetString(deviceTransportConfiguration.getEngineId()));
+                pdu = scopedPdu;
+                break;
+            default:
+                throw new UnsupportedOperationException("SNMP version " + snmpVersion + " is not supported");
+        }
+        return pdu;
+    }
+
+
+    public JsonObject processPdu(PDU pdu, List<SnmpMapping> responseMappings) {
+        Map<OID, String> values = processPdu(pdu);
+
+        Map<OID, SnmpMapping> mappings = new HashMap<>();
+        if (responseMappings != null) {
+            for (SnmpMapping mapping : responseMappings) {
+                OID oid = new OID(mapping.getOid());
+                mappings.put(oid, mapping);
+            }
+        }
+
+        JsonObject data = new JsonObject();
+        values.forEach((oid, value) -> {
+            log.trace("Processing variable binding: {} - {}", oid, value);
+
+            SnmpMapping mapping = mappings.get(oid);
+            if (mapping == null) {
+                log.debug("No SNMP mapping for oid {}", oid);
+                return;
+            }
+
+            processValue(mapping.getKey(), mapping.getDataType(), value, data);
+        });
+
+        return data;
+    }
+
+    public Map<OID, String> processPdu(PDU pdu) {
+        return IntStream.range(0, pdu.size())
+                .mapToObj(pdu::get)
+                .filter(Objects::nonNull)
+                .filter(variableBinding -> !(variableBinding.getVariable() instanceof Null))
+                .collect(Collectors.toMap(VariableBinding::getOid, VariableBinding::toValueString));
+    }
+
+    private void processValue(String key, DataType dataType, String value, JsonObject result) {
+        switch (dataType) {
+            case LONG:
+                result.addProperty(key, Long.parseLong(value));
+                break;
+            case BOOLEAN:
+                result.addProperty(key, Boolean.parseBoolean(value));
+                break;
+            case DOUBLE:
+                result.addProperty(key, Double.parseDouble(value));
+                break;
+            case STRING:
+            case JSON:
+            default:
+                result.addProperty(key, value);
+        }
+    }
+}

+/**
+ * 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.snmp.service;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.device.data.DeviceData;
+import org.thingsboard.server.common.data.device.data.DeviceTransportConfiguration;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.security.DeviceCredentials;
+import org.thingsboard.server.common.transport.TransportService;
+import org.thingsboard.server.common.transport.util.DataDecodingEncodingService;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@TbSnmpTransportComponent
+@Service
+@RequiredArgsConstructor
+public class ProtoTransportEntityService {
+    private final TransportService transportService;
+    private final DataDecodingEncodingService dataDecodingEncodingService;
+
+    public Device getDeviceById(DeviceId id) {
+        TransportProtos.GetDeviceResponseMsg deviceProto = transportService.getDevice(TransportProtos.GetDeviceRequestMsg.newBuilder()
+                .setDeviceIdMSB(id.getId().getMostSignificantBits())
+                .setDeviceIdLSB(id.getId().getLeastSignificantBits())
+                .build());
+
+        if (deviceProto == null) {
+            return null;
+        }
+
+        DeviceProfileId deviceProfileId = new DeviceProfileId(new UUID(
+                deviceProto.getDeviceProfileIdMSB(), deviceProto.getDeviceProfileIdLSB())
+        );
+
+        Device device = new Device();
+        device.setId(id);
+        device.setDeviceProfileId(deviceProfileId);
+
+        DeviceTransportConfiguration deviceTransportConfiguration = (DeviceTransportConfiguration) dataDecodingEncodingService.decode(
+                deviceProto.getDeviceTransportConfiguration().toByteArray()
+        ).orElseThrow(() -> new IllegalStateException("Can't find device transport configuration"));
+
+        DeviceData deviceData = new DeviceData();
+        deviceData.setTransportConfiguration(deviceTransportConfiguration);
+        device.setDeviceData(deviceData);
+
+        return device;
+    }
+
+    public DeviceCredentials getDeviceCredentialsByDeviceId(DeviceId deviceId) {
+        TransportProtos.GetDeviceCredentialsResponseMsg deviceCredentialsResponse = transportService.getDeviceCredentials(
+                TransportProtos.GetDeviceCredentialsRequestMsg.newBuilder()
+                        .setDeviceIdMSB(deviceId.getId().getMostSignificantBits())
+                        .setDeviceIdLSB(deviceId.getId().getLeastSignificantBits())
+                        .build()
+        );
+
+        return (DeviceCredentials) dataDecodingEncodingService.decode(deviceCredentialsResponse.getDeviceCredentialsData().toByteArray())
+                .orElseThrow(() -> new IllegalArgumentException("Device credentials not found"));
+    }
+
+    public List<UUID> getAllSnmpDevicesIds() {
+        List<UUID> result = new ArrayList<>();
+
+        int page = 0;
+        int pageSize = 512;
+        boolean hasNextPage = true;
+
+        while (hasNextPage) {
+            TransportProtos.GetSnmpDevicesResponseMsg responseMsg = requestSnmpDevicesIds(page, pageSize);
+            result.addAll(responseMsg.getIdsList().stream()
+                    .map(UUID::fromString)
+                    .collect(Collectors.toList()));
+            hasNextPage = responseMsg.getHasNextPage();
+            page++;
+        }
+
+        return result;
+    }
+
+    private TransportProtos.GetSnmpDevicesResponseMsg requestSnmpDevicesIds(int page, int pageSize) {
+        TransportProtos.GetSnmpDevicesRequestMsg requestMsg = TransportProtos.GetSnmpDevicesRequestMsg.newBuilder()
+                .setPage(page)
+                .setPageSize(pageSize)
+                .build();
+        return transportService.getSnmpDevicesIds(requestMsg);
+    }
+}

+/**
+ * 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.snmp.service;
+
+import lombok.RequiredArgsConstructor;
+import org.snmp4j.AbstractTarget;
+import org.snmp4j.CommunityTarget;
+import org.snmp4j.Target;
+import org.snmp4j.UserTarget;
+import org.snmp4j.security.SecurityLevel;
+import org.snmp4j.security.SecurityModel;
+import org.snmp4j.security.SecurityProtocols;
+import org.snmp4j.security.USM;
+import org.snmp4j.smi.Address;
+import org.snmp4j.smi.GenericAddress;
+import org.snmp4j.smi.OID;
+import org.snmp4j.smi.OctetString;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.device.data.SnmpDeviceTransportConfiguration;
+import org.thingsboard.server.common.data.device.profile.SnmpDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.transport.snmp.SnmpProtocolVersion;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+import org.thingsboard.server.transport.snmp.service.SnmpTransportService;
+import org.thingsboard.server.transport.snmp.session.DeviceSessionContext;
+
+import java.util.Optional;
+
+@Service
+@TbSnmpTransportComponent
+@RequiredArgsConstructor
+public class SnmpAuthService {
+    private final SnmpTransportService snmpTransportService;
+
+    @Value("${transport.snmp.underlying_protocol}")
+    private String snmpUnderlyingProtocol;
+
+    public Target setUpSnmpTarget(SnmpDeviceProfileTransportConfiguration profileTransportConfig, SnmpDeviceTransportConfiguration deviceTransportConfig) {
+        AbstractTarget target;
+
+        SnmpProtocolVersion protocolVersion = deviceTransportConfig.getProtocolVersion();
+        switch (protocolVersion) {
+            case V1:
+                CommunityTarget communityTargetV1 = new CommunityTarget();
+                communityTargetV1.setSecurityModel(SecurityModel.SECURITY_MODEL_SNMPv1);
+                communityTargetV1.setSecurityLevel(SecurityLevel.NOAUTH_NOPRIV);
+                communityTargetV1.setCommunity(new OctetString(deviceTransportConfig.getCommunity()));
+                target = communityTargetV1;
+                break;
+            case V2C:
+                CommunityTarget communityTargetV2 = new CommunityTarget();
+                communityTargetV2.setSecurityModel(SecurityModel.SECURITY_MODEL_SNMPv2c);
+                communityTargetV2.setSecurityLevel(SecurityLevel.NOAUTH_NOPRIV);
+                communityTargetV2.setCommunity(new OctetString(deviceTransportConfig.getCommunity()));
+                target = communityTargetV2;
+                break;
+            case V3:
+                OctetString username = new OctetString(deviceTransportConfig.getUsername());
+                OctetString securityName = new OctetString(deviceTransportConfig.getSecurityName());
+                OctetString engineId = new OctetString(deviceTransportConfig.getEngineId());
+
+                OID authenticationProtocol = new OID(deviceTransportConfig.getAuthenticationProtocol().getOid());
+                OID privacyProtocol = new OID(deviceTransportConfig.getPrivacyProtocol().getOid());
+                OctetString authenticationPassphrase = new OctetString(deviceTransportConfig.getAuthenticationPassphrase());
+                authenticationPassphrase = new OctetString(SecurityProtocols.getInstance().passwordToKey(authenticationProtocol, authenticationPassphrase, engineId.getValue()));
+                OctetString privacyPassphrase = new OctetString(deviceTransportConfig.getPrivacyPassphrase());
+                privacyPassphrase = new OctetString(SecurityProtocols.getInstance().passwordToKey(privacyProtocol, authenticationProtocol, privacyPassphrase, engineId.getValue()));
+
+                USM usm = snmpTransportService.getSnmp().getUSM();
+                if (usm.hasUser(engineId, securityName)) {
+                    usm.removeAllUsers(username, engineId);
+                }
+                usm.addLocalizedUser(
+                        engineId.getValue(), username,
+                        authenticationProtocol, authenticationPassphrase.getValue(),
+                        privacyProtocol, privacyPassphrase.getValue()
+                );
+
+                UserTarget userTarget = new UserTarget();
+                userTarget.setSecurityName(securityName);
+                userTarget.setAuthoritativeEngineID(engineId.getValue());
+                userTarget.setSecurityModel(SecurityModel.SECURITY_MODEL_USM);
+                userTarget.setSecurityLevel(SecurityLevel.AUTH_PRIV);
+                target = userTarget;
+                break;
+            default:
+                throw new UnsupportedOperationException("SNMP protocol version " + protocolVersion + " is not supported");
+        }
+
+        Address address = GenericAddress.parse(snmpUnderlyingProtocol + ":" + deviceTransportConfig.getHost() + "/" + deviceTransportConfig.getPort());
+        target.setAddress(Optional.ofNullable(address).orElseThrow(() -> new IllegalArgumentException("Address of the SNMP device is invalid")));
+        target.setTimeout(profileTransportConfig.getTimeoutMs());
+        target.setRetries(profileTransportConfig.getRetries());
+        target.setVersion(protocolVersion.getCode());
+
+        return target;
+    }
+
+    public void cleanUpSnmpAuthInfo(DeviceSessionContext sessionContext) {
+        SnmpDeviceTransportConfiguration deviceTransportConfiguration = sessionContext.getDeviceTransportConfiguration();
+        if (deviceTransportConfiguration.getProtocolVersion() == SnmpProtocolVersion.V3) {
+            OctetString username = new OctetString(deviceTransportConfiguration.getUsername());
+            OctetString engineId = new OctetString(deviceTransportConfiguration.getEngineId());
+            snmpTransportService.getSnmp().getUSM().removeAllUsers(username, engineId);
+        }
+    }
+
+}

+/**
+ * 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.snmp.service;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.gen.transport.TransportProtos.ServiceInfo;
+import org.thingsboard.server.queue.discovery.PartitionService;
+import org.thingsboard.server.queue.discovery.event.ServiceListChangedEvent;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+import org.thingsboard.server.transport.snmp.event.SnmpTransportListChangedEvent;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@TbSnmpTransportComponent
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class SnmpTransportBalancingService {
+    private final PartitionService partitionService;
+    private final ApplicationEventPublisher eventPublisher;
+    private final SnmpTransportService snmpTransportService;
+
+    private int snmpTransportsCount = 1;
+    private Integer currentTransportPartitionIndex = 0;
+
+    public void onServiceListChanged(ServiceListChangedEvent event) {
+        log.trace("Got service list changed event: {}", event);
+        recalculatePartitions(event.getOtherServices(), event.getCurrentService());
+    }
+
+    public boolean isManagedByCurrentTransport(UUID entityId) {
+        boolean isManaged = resolvePartitionIndexForEntity(entityId) == currentTransportPartitionIndex;
+        if (!isManaged) {
+            log.trace("Entity {} is not managed by current SNMP transport node", entityId);
+        }
+        return isManaged;
+    }
+
+    private int resolvePartitionIndexForEntity(UUID entityId) {
+        return partitionService.resolvePartitionIndex(entityId, snmpTransportsCount);
+    }
+
+    private void recalculatePartitions(List<ServiceInfo> otherServices, ServiceInfo currentService) {
+        log.info("Recalculating partitions for SNMP transports");
+        List<ServiceInfo> snmpTransports = Stream.concat(otherServices.stream(), Stream.of(currentService))
+                .filter(service -> service.getTransportsList().contains(snmpTransportService.getName()))
+                .sorted(Comparator.comparing(ServiceInfo::getServiceId))
+                .collect(Collectors.toList());
+        log.trace("Found SNMP transports: {}", snmpTransports);
+
+        int previousCurrentTransportPartitionIndex = currentTransportPartitionIndex;
+        int previousSnmpTransportsCount = snmpTransportsCount;
+
+        if (!snmpTransports.isEmpty()) {
+            for (int i = 0; i < snmpTransports.size(); i++) {
+                if (snmpTransports.get(i).equals(currentService)) {
+                    currentTransportPartitionIndex = i;
+                    break;
+                }
+            }
+            snmpTransportsCount = snmpTransports.size();
+        }
+
+        if (snmpTransportsCount != previousSnmpTransportsCount || currentTransportPartitionIndex != previousCurrentTransportPartitionIndex) {
+            log.info("SNMP transports partitions have changed: transports count = {}, current transport partition index = {}", snmpTransportsCount, currentTransportPartitionIndex);
+            eventPublisher.publishEvent(new SnmpTransportListChangedEvent());
+        } else {
+            log.info("SNMP transports partitions have not changed");
+        }
+    }
+
+}

+/**
+ * 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.snmp.service;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import lombok.Data;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.snmp4j.PDU;
+import org.snmp4j.Snmp;
+import org.snmp4j.TransportMapping;
+import org.snmp4j.event.ResponseEvent;
+import org.snmp4j.mp.MPv3;
+import org.snmp4j.security.SecurityModels;
+import org.snmp4j.security.SecurityProtocols;
+import org.snmp4j.security.USM;
+import org.snmp4j.smi.OctetString;
+import org.snmp4j.transport.DefaultTcpTransportMapping;
+import org.snmp4j.transport.DefaultUdpTransportMapping;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.thingsboard.common.util.ThingsBoardThreadFactory;
+import org.thingsboard.server.common.data.TbTransportService;
+import org.thingsboard.server.common.data.kv.DataType;
+import org.thingsboard.server.common.data.transport.snmp.SnmpCommunicationSpec;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMapping;
+import org.thingsboard.server.common.data.transport.snmp.SnmpMethod;
+import org.thingsboard.server.common.data.transport.snmp.config.RepeatingQueryingSnmpCommunicationConfig;
+import org.thingsboard.server.common.data.transport.snmp.config.SnmpCommunicationConfig;
+import org.thingsboard.server.common.transport.TransportService;
+import org.thingsboard.server.common.transport.TransportServiceCallback;
+import org.thingsboard.server.common.transport.adaptor.JsonConverter;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.queue.util.TbSnmpTransportComponent;
+import org.thingsboard.server.transport.snmp.session.DeviceSessionContext;
+
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@TbSnmpTransportComponent
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class SnmpTransportService implements TbTransportService {
+    private final TransportService transportService;
+    private final PduService pduService;
+
+    @Getter
+    private Snmp snmp;
+    private ScheduledExecutorService queryingExecutor;
+    private ExecutorService responseProcessingExecutor;
+
+    private final Map<SnmpCommunicationSpec, ResponseDataMapper> responseDataMappers = new EnumMap<>(SnmpCommunicationSpec.class);
+    private final Map<SnmpCommunicationSpec, ResponseProcessor> responseProcessors = new EnumMap<>(SnmpCommunicationSpec.class);
+
+    @Value("${transport.snmp.response_processing.parallelism_level}")
+    private Integer responseProcessingParallelismLevel;
+    @Value("${transport.snmp.underlying_protocol}")
+    private String snmpUnderlyingProtocol;
+
+    @PostConstruct
+    private void init() throws IOException {
+        queryingExecutor = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors(), ThingsBoardThreadFactory.forName("snmp-querying"));
+        responseProcessingExecutor = Executors.newWorkStealingPool(responseProcessingParallelismLevel);
+
+        initializeSnmp();
+        configureResponseDataMappers();
+        configureResponseProcessors();
+
+        log.info("SNMP transport service initialized");
+    }
+
+    private void initializeSnmp() throws IOException {
+        TransportMapping<?> transportMapping;
+        switch (snmpUnderlyingProtocol) {
+            case "udp":
+                transportMapping = new DefaultUdpTransportMapping();
+                break;
+            case "tcp":
+                transportMapping = new DefaultTcpTransportMapping();
+                break;
+            default:
+                throw new IllegalArgumentException("Underlying protocol " + snmpUnderlyingProtocol + " for SNMP is not supported");
+        }
+        snmp = new Snmp(transportMapping);
+        snmp.listen();
+
+        USM usm = new USM(SecurityProtocols.getInstance(), new OctetString(MPv3.createLocalEngineID()), 0);
+        SecurityModels.getInstance().addSecurityModel(usm);
+    }
+
+    public void createQueryingTasks(DeviceSessionContext sessionContext) {
+        List<ScheduledFuture<?>> queryingTasks = sessionContext.getProfileTransportConfiguration().getCommunicationConfigs().stream()
+                .filter(communicationConfig -> communicationConfig instanceof RepeatingQueryingSnmpCommunicationConfig)
+                .map(config -> {
+                    RepeatingQueryingSnmpCommunicationConfig repeatingCommunicationConfig = (RepeatingQueryingSnmpCommunicationConfig) config;
+                    Long queryingFrequency = repeatingCommunicationConfig.getQueryingFrequencyMs();
+
+                    return queryingExecutor.scheduleWithFixedDelay(() -> {
+                        try {
+                            if (sessionContext.isActive()) {
+                                sendRequest(sessionContext, repeatingCommunicationConfig);
+                            }
+                        } catch (Exception e) {
+                            log.error("Failed to send SNMP request for device {}: {}", sessionContext.getDeviceId(), e.toString());
+                        }
+                    }, queryingFrequency, queryingFrequency, TimeUnit.MILLISECONDS);
+                })
+                .collect(Collectors.toList());
+        sessionContext.getQueryingTasks().addAll(queryingTasks);
+    }
+
+    public void cancelQueryingTasks(DeviceSessionContext sessionContext) {
+        sessionContext.getQueryingTasks().forEach(task -> task.cancel(true));
+        sessionContext.getQueryingTasks().clear();
+    }
+
+
+    private void sendRequest(DeviceSessionContext sessionContext, SnmpCommunicationConfig communicationConfig) {
+        sendRequest(sessionContext, communicationConfig, Collections.emptyMap());
+    }
+
+    private void sendRequest(DeviceSessionContext sessionContext, SnmpCommunicationConfig communicationConfig, Map<String, String> values) {
+        PDU request = pduService.createPdu(sessionContext, communicationConfig, values);
+        RequestInfo requestInfo = new RequestInfo(communicationConfig.getSpec(), communicationConfig.getAllMappings());
+        sendRequest(sessionContext, request, requestInfo);
+    }
+
+    private void sendRequest(DeviceSessionContext sessionContext, PDU request, RequestInfo requestInfo) {
+        if (request.size() > 0) {
+            log.trace("Executing SNMP request for device {}. Variables bindings: {}", sessionContext.getDeviceId(), request.getVariableBindings());
+            try {
+                snmp.send(request, sessionContext.getTarget(), requestInfo, sessionContext);
+            } catch (IOException e) {
+                log.error("Failed to send SNMP request to device {}: {}", sessionContext.getDeviceId(), e.toString());
+            }
+        }
+    }
+
+    public void onAttributeUpdate(DeviceSessionContext sessionContext, TransportProtos.AttributeUpdateNotificationMsg attributeUpdateNotification) {
+        sessionContext.getProfileTransportConfiguration().getCommunicationConfigs().stream()
+                .filter(config -> config.getSpec() == SnmpCommunicationSpec.SHARED_ATTRIBUTES_SETTING)
+                .findFirst()
+                .ifPresent(communicationConfig -> {
+                    Map<String, String> sharedAttributes = JsonConverter.toJson(attributeUpdateNotification).entrySet().stream()
+                            .collect(Collectors.toMap(
+                                    Map.Entry::getKey,
+                                    entry -> entry.getValue().isJsonPrimitive() ? entry.getValue().getAsString() : entry.getValue().toString()
+                            ));
+                    sendRequest(sessionContext, communicationConfig, sharedAttributes);
+                });
+    }
+
+    public void onToDeviceRpcRequest(DeviceSessionContext sessionContext, TransportProtos.ToDeviceRpcRequestMsg toDeviceRpcRequestMsg) {
+        SnmpMethod snmpMethod = SnmpMethod.valueOf(toDeviceRpcRequestMsg.getMethodName());
+        JsonObject params = JsonConverter.parse(toDeviceRpcRequestMsg.getParams()).getAsJsonObject();
+
+        String oid = Optional.ofNullable(params.get("oid")).map(JsonElement::getAsString).orElse(null);
+        String value = Optional.ofNullable(params.get("value")).map(JsonElement::getAsString).orElse(null);
+        DataType dataType = Optional.ofNullable(params.get("dataType")).map(e -> DataType.valueOf(e.getAsString())).orElse(DataType.STRING);
+
+        if (oid == null || oid.isEmpty()) {
+            throw new IllegalArgumentException("OID in to-device RPC request is not specified");
+        }
+        if (value == null && snmpMethod == SnmpMethod.SET) {
+            throw new IllegalArgumentException("Value must be specified for SNMP method 'SET'");
+        }
+
+        PDU request = pduService.createSingleVariablePdu(sessionContext, snmpMethod, oid, value, dataType);
+        sendRequest(sessionContext, request, new RequestInfo(toDeviceRpcRequestMsg.getRequestId(), SnmpCommunicationSpec.TO_DEVICE_RPC_REQUEST));
+    }
+
+
+    public void processResponseEvent(DeviceSessionContext sessionContext, ResponseEvent event) {
+        ((Snmp) event.getSource()).cancel(event.getRequest(), sessionContext);
+
+        if (event.getError() != null) {
+            log.warn("SNMP response error: {}", event.getError().toString());
+            return;
+        }
+
+        PDU response = event.getResponse();
+        if (response == null) {
+            log.debug("No response from SNMP device {}, requestId: {}", sessionContext.getDeviceId(), event.getRequest().getRequestID());
+            return;
+        }
+
+        RequestInfo requestInfo = (RequestInfo) event.getUserObject();
+        responseProcessingExecutor.execute(() -> {
+            processResponse(sessionContext, response, requestInfo);
+        });
+    }
+
+    private void processResponse(DeviceSessionContext sessionContext, PDU response, RequestInfo requestInfo) {
+        ResponseProcessor responseProcessor = responseProcessors.get(requestInfo.getCommunicationSpec());
+        if (responseProcessor == null) return;
+
+        JsonObject responseData = responseDataMappers.get(requestInfo.getCommunicationSpec()).map(response, requestInfo);
+
+        if (responseData.entrySet().isEmpty()) {
+            log.debug("No values is the SNMP response for device {}. Request id: {}", sessionContext.getDeviceId(), response.getRequestID());
+            return;
+        }
+
+        responseProcessor.process(responseData, requestInfo, sessionContext);
+        reportActivity(sessionContext.getSessionInfo());
+    }
+
+    private void configureResponseDataMappers() {
+        responseDataMappers.put(SnmpCommunicationSpec.TO_DEVICE_RPC_REQUEST, (pdu, requestInfo) -> {
+            JsonObject responseData = new JsonObject();
+            pduService.processPdu(pdu).forEach((oid, value) -> {
+                responseData.addProperty(oid.toDottedString(), value);
+            });
+            return responseData;
+        });
+
+        ResponseDataMapper defaultResponseDataMapper = (pdu, requestInfo) -> {
+            return pduService.processPdu(pdu, requestInfo.getResponseMappings());
+        };
+        Arrays.stream(SnmpCommunicationSpec.values())
+                .forEach(communicationSpec -> {
+                    responseDataMappers.putIfAbsent(communicationSpec, defaultResponseDataMapper);
+                });
+    }
+
+    private void configureResponseProcessors() {
+        responseProcessors.put(SnmpCommunicationSpec.TELEMETRY_QUERYING, (responseData, requestInfo, sessionContext) -> {
+            TransportProtos.PostTelemetryMsg postTelemetryMsg = JsonConverter.convertToTelemetryProto(responseData);
+            transportService.process(sessionContext.getSessionInfo(), postTelemetryMsg, null);
+            log.debug("Posted telemetry for SNMP device {}: {}", sessionContext.getDeviceId(), responseData);
+        });
+
+        responseProcessors.put(SnmpCommunicationSpec.CLIENT_ATTRIBUTES_QUERYING, (responseData, requestInfo, sessionContext) -> {
+            TransportProtos.PostAttributeMsg postAttributesMsg = JsonConverter.convertToAttributesProto(responseData);
+            transportService.process(sessionContext.getSessionInfo(), postAttributesMsg, null);
+            log.debug("Posted attributes for SNMP device {}: {}", sessionContext.getDeviceId(), responseData);
+        });
+
+        responseProcessors.put(SnmpCommunicationSpec.TO_DEVICE_RPC_REQUEST, (responseData, requestInfo, sessionContext) -> {
+            TransportProtos.ToDeviceRpcResponseMsg rpcResponseMsg = TransportProtos.ToDeviceRpcResponseMsg.newBuilder()
+                    .setRequestId(requestInfo.getRequestId())
+                    .setPayload(JsonConverter.toJson(responseData))
+                    .build();
+            transportService.process(sessionContext.getSessionInfo(), rpcResponseMsg, null);
+            log.debug("Posted RPC response {} for device {}", responseData, sessionContext.getDeviceId());
+        });
+    }
+
+    private void reportActivity(TransportProtos.SessionInfoProto sessionInfo) {
+        transportService.process(sessionInfo, TransportProtos.SubscriptionInfoProto.newBuilder()
+                .setAttributeSubscription(true)
+                .setRpcSubscription(true)
+                .setLastActivityTime(System.currentTimeMillis())
+                .build(), TransportServiceCallback.EMPTY);
+    }
+
+
+    @Override
+    public String getName() {
+        return "SNMP";
+    }
+
+    @PreDestroy
+    public void shutdown() {
+        log.info("Stopping SNMP transport!");
+        if (queryingExecutor != null) {
+            queryingExecutor.shutdownNow();
+        }
+        if (responseProcessingExecutor != null) {
+            responseProcessingExecutor.shutdownNow();
+        }
+        if (snmp != null) {
+            try {
+                snmp.close();
+            } catch (IOException e) {
+                log.error(e.getMessage(), e);
+            }
+        }
+        log.info("SNMP transport stopped!");
+    }
+
+    @Data
+    private static class RequestInfo {
+        private Integer requestId;
+        private SnmpCommunicationSpec communicationSpec;
+        private List<SnmpMapping> responseMappings;
+
+        public RequestInfo(Integer requestId, SnmpCommunicationSpec communicationSpec) {
+            this.requestId = requestId;
+            this.communicationSpec = communicationSpec;
+        }
+
+        public RequestInfo(SnmpCommunicationSpec communicationSpec) {
+            this.communicationSpec = communicationSpec;
+        }
+
+        public RequestInfo(SnmpCommunicationSpec communicationSpec, List<SnmpMapping> responseMappings) {
+            this.communicationSpec = communicationSpec;
+            this.responseMappings = responseMappings;
+        }
+    }
+
+    private interface ResponseDataMapper {
+        JsonObject map(PDU pdu, RequestInfo requestInfo);
+    }
+
+    private interface ResponseProcessor {
+        void process(JsonObject responseData, RequestInfo requestInfo, DeviceSessionContext sessionContext);
+    }
+
+}

+/**
+ * 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.snmp.session;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.extern.slf4j.Slf4j;
+import org.snmp4j.Target;
+import org.snmp4j.event.ResponseEvent;
+import org.snmp4j.event.ResponseListener;
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.device.data.SnmpDeviceTransportConfiguration;
+import org.thingsboard.server.common.data.device.profile.SnmpDeviceProfileTransportConfiguration;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.transport.SessionMsgListener;
+import org.thingsboard.server.common.transport.session.DeviceAwareSessionContext;
+import org.thingsboard.server.gen.transport.TransportProtos;
+import org.thingsboard.server.gen.transport.TransportProtos.AttributeUpdateNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.SessionCloseNotificationProto;
+import org.thingsboard.server.gen.transport.TransportProtos.ToDeviceRpcRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToServerRpcResponseMsg;
+import org.thingsboard.server.transport.snmp.SnmpTransportContext;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Slf4j
+public class DeviceSessionContext extends DeviceAwareSessionContext implements SessionMsgListener, ResponseListener {
+    @Getter
+    private Target target;
+    private final String token;
+    @Getter
+    @Setter
+    private SnmpDeviceProfileTransportConfiguration profileTransportConfiguration;
+    @Getter
+    @Setter
+    private SnmpDeviceTransportConfiguration deviceTransportConfiguration;
+    @Getter
+    private final Device device;
+
+    private final SnmpTransportContext snmpTransportContext;
+
+    private final AtomicInteger msgIdSeq = new AtomicInteger(0);
+    @Getter
+    private boolean isActive = true;
+
+    @Getter
+    private final List<ScheduledFuture<?>> queryingTasks = new LinkedList<>();
+
+    public DeviceSessionContext(Device device, DeviceProfile deviceProfile, String token,
+                                SnmpDeviceProfileTransportConfiguration profileTransportConfiguration,
+                                SnmpDeviceTransportConfiguration deviceTransportConfiguration,
+                                SnmpTransportContext snmpTransportContext) throws Exception {
+        super(UUID.randomUUID());
+        super.setDeviceId(device.getId());
+        super.setDeviceProfile(deviceProfile);
+        this.device = device;
+
+        this.token = token;
+        this.snmpTransportContext = snmpTransportContext;
+
+        this.profileTransportConfiguration = profileTransportConfiguration;
+        this.deviceTransportConfiguration = deviceTransportConfiguration;
+
+        initializeTarget(profileTransportConfiguration, deviceTransportConfiguration);
+    }
+
+    @Override
+    public void onDeviceProfileUpdate(TransportProtos.SessionInfoProto newSessionInfo, DeviceProfile deviceProfile) {
+        super.onDeviceProfileUpdate(newSessionInfo, deviceProfile);
+        if (isActive) {
+            snmpTransportContext.onDeviceProfileUpdated(deviceProfile, this);
+        }
+    }
+
+    @Override
+    public void onDeviceDeleted(DeviceId deviceId) {
+        snmpTransportContext.onDeviceDeleted(this);
+    }
+
+    @Override
+    public void onResponse(ResponseEvent event) {
+        if (isActive) {
+            snmpTransportContext.getSnmpTransportService().processResponseEvent(this, event);
+        }
+    }
+
+    public void initializeTarget(SnmpDeviceProfileTransportConfiguration profileTransportConfig, SnmpDeviceTransportConfiguration deviceTransportConfig) throws Exception {
+        log.trace("Initializing target for SNMP session of device {}", device);
+        this.target = snmpTransportContext.getSnmpAuthService().setUpSnmpTarget(profileTransportConfig, deviceTransportConfig);
+        log.debug("SNMP target initialized: {}", target);
+    }
+
+    public void close() {
+        isActive = false;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    @Override
+    public int nextMsgId() {
+        return msgIdSeq.incrementAndGet();
+    }
+
+    @Override
+    public void onGetAttributesResponse(GetAttributeResponseMsg getAttributesResponse) {
+    }
+
+    @Override
+    public void onAttributeUpdate(AttributeUpdateNotificationMsg attributeUpdateNotification) {
+        snmpTransportContext.getSnmpTransportService().onAttributeUpdate(this, attributeUpdateNotification);
+    }
+
+    @Override
+    public void onRemoteSessionCloseCommand(SessionCloseNotificationProto sessionCloseNotification) {
+    }
+
+    @Override
+    public void onToDeviceRpcRequest(ToDeviceRpcRequestMsg toDeviceRequest) {
+       snmpTransportContext.getSnmpTransportService().onToDeviceRpcRequest(this, toDeviceRequest);
+    }
+
+    @Override
+    public void onToServerRpcResponse(ToServerRpcResponseMsg toServerResponse) {
+    }
+}

+/**
+ * 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.snmp;
+
+import org.snmp4j.CommandResponderEvent;
+import org.snmp4j.CommunityTarget;
+import org.snmp4j.PDU;
+import org.snmp4j.Snmp;
+import org.snmp4j.Target;
+import org.snmp4j.TransportMapping;
+import org.snmp4j.agent.BaseAgent;
+import org.snmp4j.agent.CommandProcessor;
+import org.snmp4j.agent.DuplicateRegistrationException;
+import org.snmp4j.agent.MOGroup;
+import org.snmp4j.agent.ManagedObject;
+import org.snmp4j.agent.mo.MOAccessImpl;
+import org.snmp4j.agent.mo.MOScalar;
+import org.snmp4j.agent.mo.snmp.RowStatus;
+import org.snmp4j.agent.mo.snmp.SnmpCommunityMIB;
+import org.snmp4j.agent.mo.snmp.SnmpNotificationMIB;
+import org.snmp4j.agent.mo.snmp.SnmpTargetMIB;
+import org.snmp4j.agent.mo.snmp.StorageType;
+import org.snmp4j.agent.mo.snmp.VacmMIB;
+import org.snmp4j.agent.security.MutableVACM;
+import org.snmp4j.mp.MPv3;
+import org.snmp4j.mp.SnmpConstants;
+import org.snmp4j.security.SecurityLevel;
+import org.snmp4j.security.SecurityModel;
+import org.snmp4j.security.USM;
+import org.snmp4j.smi.Address;
+import org.snmp4j.smi.GenericAddress;
+import org.snmp4j.smi.Integer32;
+import org.snmp4j.smi.OID;
+import org.snmp4j.smi.OctetString;
+import org.snmp4j.smi.UdpAddress;
+import org.snmp4j.smi.Variable;
+import org.snmp4j.smi.VariableBinding;
+import org.snmp4j.transport.TransportMappings;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+import java.util.Scanner;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+public class SnmpDeviceSimulatorV2 extends BaseAgent {
+
+    public static class RequestProcessor extends CommandProcessor {
+        private final Consumer<CommandResponderEvent> processor;
+
+        public RequestProcessor(Consumer<CommandResponderEvent> processor) {
+            super(new OctetString(MPv3.createLocalEngineID()));
+            this.processor = processor;
+        }
+
+        @Override
+        public void processPdu(CommandResponderEvent event) {
+            processor.accept(event);
+        }
+    }
+
+
+    private final Target target;
+    private final Address address;
+    private Snmp snmp;
+
+    private final String password;
+
+    public SnmpDeviceSimulatorV2(int port, String password) throws IOException {
+        super(new File("conf.agent"), new File("bootCounter.agent"), new RequestProcessor(event -> {
+            System.out.println("aboba");
+            ((Snmp) event.getSource()).cancel(event.getPDU(), event1 -> System.out.println("canceled"));
+        }));
+        CommunityTarget target = new CommunityTarget();
+        target.setCommunity(new OctetString(password));
+        this.address = GenericAddress.parse("udp:0.0.0.0/" + port);
+        target.setAddress(address);
+        target.setRetries(2);
+        target.setTimeout(1500);
+        target.setVersion(SnmpConstants.version2c);
+        this.target = target;
+        this.password = password;
+    }
+
+    public void start() throws IOException {
+        init();
+        addShutdownHook();
+        getServer().addContext(new OctetString("public"));
+        finishInit();
+        run();
+        sendColdStartNotification();
+        snmp = new Snmp(transportMappings[0]);
+    }
+
+    public void setUpMappings(Map<String, String> oidToResponseMappings) {
+        unregisterManagedObject(getSnmpv2MIB());
+        oidToResponseMappings.forEach((oid, response) -> {
+            registerManagedObject(new MOScalar<>(new OID(oid), MOAccessImpl.ACCESS_READ_WRITE, new OctetString(response)));
+        });
+    }
+
+    public void sendTrap(String host, int port, Map<String, String> values) throws IOException {
+        PDU pdu = new PDU();
+        pdu.addAll(values.entrySet().stream()
+                .map(entry -> new VariableBinding(new OID(entry.getKey()), new OctetString(entry.getValue())))
+                .collect(Collectors.toList()));
+        pdu.setType(PDU.TRAP);
+
+        CommunityTarget remoteTarget = (CommunityTarget) getTarget().clone();
+        remoteTarget.setAddress(new UdpAddress(host + "/" + port));
+
+        snmp.send(pdu, remoteTarget);
+    }
+
+    @Override
+    protected void registerManagedObjects() {
+    }
+
+    protected void registerManagedObject(ManagedObject mo) {
+        try {
+            server.register(mo, null);
+        } catch (DuplicateRegistrationException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    protected void unregisterManagedObject(MOGroup moGroup) {
+        moGroup.unregisterMOs(server, getContext(moGroup));
+    }
+
+    @Override
+    protected void addNotificationTargets(SnmpTargetMIB targetMIB,
+                                          SnmpNotificationMIB notificationMIB) {
+    }
+
+    @Override
+    protected void addViews(VacmMIB vacm) {
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_SNMPv2c, new OctetString(
+                        "cpublic"), new OctetString("v1v2group"),
+                StorageType.nonVolatile);
+
+        vacm.addAccess(new OctetString("v1v2group"), new OctetString("public"),
+                SecurityModel.SECURITY_MODEL_ANY, SecurityLevel.NOAUTH_NOPRIV,
+                MutableVACM.VACM_MATCH_EXACT, new OctetString("fullReadView"),
+                new OctetString("fullWriteView"), new OctetString(
+                        "fullNotifyView"), StorageType.nonVolatile);
+
+        vacm.addViewTreeFamily(new OctetString("fullReadView"), new OID("1.3"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+    }
+
+    protected void addUsmUser(USM usm) {
+    }
+
+    protected void initTransportMappings() {
+        transportMappings = new TransportMapping[]{TransportMappings.getInstance().createTransportMapping(address)};
+    }
+
+    protected void unregisterManagedObjects() {
+    }
+
+    protected void addCommunities(SnmpCommunityMIB communityMIB) {
+        Variable[] com2sec = new Variable[]{
+                new OctetString("public"),
+                new OctetString("cpublic"),
+                getAgent().getContextEngineID(),
+                new OctetString("public"),
+                new OctetString(),
+                new Integer32(StorageType.nonVolatile),
+                new Integer32(RowStatus.active)
+        };
+        SnmpCommunityMIB.SnmpCommunityEntryRow row = communityMIB.getSnmpCommunityEntry().createRow(
+                new OctetString("public2public").toSubIndex(true), com2sec);
+        communityMIB.getSnmpCommunityEntry().addRow(row);
+    }
+
+    public Target getTarget() {
+        return target;
+    }
+
+}

+/**
+ * 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.snmp;
+
+import org.snmp4j.MessageDispatcherImpl;
+import org.snmp4j.TransportMapping;
+import org.snmp4j.agent.BaseAgent;
+import org.snmp4j.agent.CommandProcessor;
+import org.snmp4j.agent.DuplicateRegistrationException;
+import org.snmp4j.agent.MOGroup;
+import org.snmp4j.agent.ManagedObject;
+import org.snmp4j.agent.mo.DefaultMOMutableRow2PC;
+import org.snmp4j.agent.mo.DefaultMOTable;
+import org.snmp4j.agent.mo.MOAccessImpl;
+import org.snmp4j.agent.mo.MOColumn;
+import org.snmp4j.agent.mo.MOMutableColumn;
+import org.snmp4j.agent.mo.MOMutableTableModel;
+import org.snmp4j.agent.mo.MOScalar;
+import org.snmp4j.agent.mo.MOTableIndex;
+import org.snmp4j.agent.mo.MOTableRow;
+import org.snmp4j.agent.mo.MOTableSubIndex;
+import org.snmp4j.agent.mo.ext.AgentppSimulationMib;
+import org.snmp4j.agent.mo.snmp.RowStatus;
+import org.snmp4j.agent.mo.snmp.SnmpCommunityMIB;
+import org.snmp4j.agent.mo.snmp.SnmpNotificationMIB;
+import org.snmp4j.agent.mo.snmp.SnmpTargetMIB;
+import org.snmp4j.agent.mo.snmp.StorageType;
+import org.snmp4j.agent.mo.snmp.TransportDomains;
+import org.snmp4j.agent.mo.snmp.VacmMIB;
+import org.snmp4j.agent.mo.snmp4j.example.Snmp4jHeartbeatMib;
+import org.snmp4j.agent.security.MutableVACM;
+import org.snmp4j.mp.MPv1;
+import org.snmp4j.mp.MPv2c;
+import org.snmp4j.mp.MPv3;
+import org.snmp4j.mp.MessageProcessingModel;
+import org.snmp4j.security.AuthHMAC192SHA256;
+import org.snmp4j.security.AuthMD5;
+import org.snmp4j.security.AuthSHA;
+import org.snmp4j.security.PrivAES128;
+import org.snmp4j.security.PrivAES192;
+import org.snmp4j.security.PrivAES256;
+import org.snmp4j.security.PrivDES;
+import org.snmp4j.security.SecurityLevel;
+import org.snmp4j.security.SecurityModel;
+import org.snmp4j.security.SecurityModels;
+import org.snmp4j.security.SecurityProtocols;
+import org.snmp4j.security.USM;
+import org.snmp4j.security.UsmUser;
+import org.snmp4j.smi.Address;
+import org.snmp4j.smi.Gauge32;
+import org.snmp4j.smi.GenericAddress;
+import org.snmp4j.smi.Integer32;
+import org.snmp4j.smi.OID;
+import org.snmp4j.smi.OctetString;
+import org.snmp4j.smi.SMIConstants;
+import org.snmp4j.smi.TcpAddress;
+import org.snmp4j.smi.TimeTicks;
+import org.snmp4j.smi.UdpAddress;
+import org.snmp4j.smi.Variable;
+import org.snmp4j.transport.DefaultTcpTransportMapping;
+import org.snmp4j.transport.TransportMappings;
+import org.snmp4j.util.ThreadPool;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * The TestAgent is a sample SNMP agent implementation of all
+ * features (MIB implementations) provided by the SNMP4J-Agent framework.
+ *
+ * Note, for snmp4s, this code is mostly a copy from snmp4j.
+ * And don't remove snmp users
+ *
+ */
+public class SnmpDeviceSimulatorV3 extends BaseAgent {
+    protected String address;
+    private Snmp4jHeartbeatMib heartbeatMIB;
+    private AgentppSimulationMib agentppSimulationMIB;
+
+    public SnmpDeviceSimulatorV3(CommandProcessor processor) throws IOException {
+        super(new File("SNMP4JTestAgentBC.cfg"), new File("SNMP4JTestAgentConfig.cfg"),
+                processor);
+        agent.setWorkerPool(ThreadPool.create("RequestPool", 4));
+    }
+
+    public void setUpMappings(Map<String, String> oidToResponseMappings) {
+        unregisterManagedObject(getSnmpv2MIB());
+        oidToResponseMappings.forEach((oid, response) -> {
+            registerManagedObject(new MOScalar<>(new OID(oid), MOAccessImpl.ACCESS_READ_WRITE, new OctetString(response)));
+        });
+    }
+    protected void registerManagedObject(ManagedObject mo) {
+        try {
+            server.register(mo, null);
+        } catch (DuplicateRegistrationException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    protected void unregisterManagedObject(MOGroup moGroup) {
+        moGroup.unregisterMOs(server, getContext(moGroup));
+    }
+
+    protected void registerManagedObjects() {
+        try {
+            server.register(createStaticIfTable(), null);
+            server.register(createStaticIfXTable(), null);
+            agentppSimulationMIB.registerMOs(server, null);
+            heartbeatMIB.registerMOs(server, null);
+        } catch (DuplicateRegistrationException ex) {
+            ex.printStackTrace();
+        }
+    }
+
+    protected void addNotificationTargets(SnmpTargetMIB targetMIB,
+                                          SnmpNotificationMIB notificationMIB) {
+        targetMIB.addDefaultTDomains();
+
+        targetMIB.addTargetAddress(new OctetString("notificationV2c"),
+                TransportDomains.transportDomainUdpIpv4,
+                new OctetString(new UdpAddress("127.0.0.1/162").getValue()),
+                200, 1,
+                new OctetString("notify"),
+                new OctetString("v2c"),
+                StorageType.permanent);
+        targetMIB.addTargetAddress(new OctetString("notificationV3"),
+                TransportDomains.transportDomainUdpIpv4,
+                new OctetString(new UdpAddress("127.0.0.1/1162").getValue()),
+                200, 1,
+                new OctetString("notify"),
+                new OctetString("v3notify"),
+                StorageType.permanent);
+        targetMIB.addTargetParams(new OctetString("v2c"),
+                MessageProcessingModel.MPv2c,
+                SecurityModel.SECURITY_MODEL_SNMPv2c,
+                new OctetString("cpublic"),
+                SecurityLevel.AUTH_PRIV,
+                StorageType.permanent);
+        targetMIB.addTargetParams(new OctetString("v3notify"),
+                MessageProcessingModel.MPv3,
+                SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("v3notify"),
+                SecurityLevel.NOAUTH_NOPRIV,
+                StorageType.permanent);
+        notificationMIB.addNotifyEntry(new OctetString("default"),
+                new OctetString("notify"),
+                SnmpNotificationMIB.SnmpNotifyTypeEnum.inform,
+                StorageType.permanent);
+    }
+    protected void addViews(VacmMIB vacm) {
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_SNMPv1,
+                new OctetString("cpublic"),
+                new OctetString("v1v2group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_SNMPv2c,
+                new OctetString("cpublic"),
+                new OctetString("v1v2group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("SHADES"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("MD5DES"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("TEST"),
+                new OctetString("v3test"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("SHA"),
+                new OctetString("v3restricted"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("SHAAES128"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("SHAAES192"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("SHAAES256"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("MD5AES128"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("MD5AES192"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("MD5AES256"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("aboba"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        //============================================//
+        // agent5-auth-priv
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("agent5"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        //===========================================//
+        // agent002
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("agent002"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+        //===========================================//
+        // user001-auth-no-priv
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("user001"),
+                new OctetString("group001"),
+                StorageType.nonVolatile);
+        //===========================================//
+
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("v3notify"),
+                new OctetString("v3group"),
+                StorageType.nonVolatile);
+
+        //===========================================//
+        // group auth no priv
+        vacm.addGroup(SecurityModel.SECURITY_MODEL_USM,
+                new OctetString("v3notify-auth"),
+                new OctetString("group001"),
+                StorageType.nonVolatile);
+        //===========================================//
+
+
+
+        // my conf
+        vacm.addAccess(new OctetString("group001"), new OctetString("public"),
+                SecurityModel.SECURITY_MODEL_USM,
+                SecurityLevel.AUTH_NOPRIV,
+                MutableVACM.VACM_MATCH_EXACT,
+                new OctetString("fullReadView"),
+                new OctetString("fullWriteView"),
+                new OctetString("fullNotifyView"),
+                StorageType.nonVolatile);
+
+        vacm.addAccess(new OctetString("v1v2group"), new OctetString("public"),
+                SecurityModel.SECURITY_MODEL_ANY,
+                SecurityLevel.NOAUTH_NOPRIV,
+                MutableVACM.VACM_MATCH_EXACT,
+                new OctetString("fullReadView"),
+                new OctetString("fullWriteView"),
+                new OctetString("fullNotifyView"),
+                StorageType.nonVolatile);
+        vacm.addAccess(new OctetString("v3group"), new OctetString(),
+                SecurityModel.SECURITY_MODEL_USM,
+                SecurityLevel.AUTH_PRIV,
+                MutableVACM.VACM_MATCH_EXACT,
+                new OctetString("fullReadView"),
+                new OctetString("fullWriteView"),
+                new OctetString("fullNotifyView"),
+                StorageType.nonVolatile);
+        vacm.addAccess(new OctetString("v3restricted"), new OctetString(),
+                SecurityModel.SECURITY_MODEL_USM,
+                SecurityLevel.NOAUTH_NOPRIV,
+                MutableVACM.VACM_MATCH_EXACT,
+                new OctetString("restrictedReadView"),
+                new OctetString("restrictedWriteView"),
+                new OctetString("restrictedNotifyView"),
+                StorageType.nonVolatile);
+        vacm.addAccess(new OctetString("v3test"), new OctetString(),
+                SecurityModel.SECURITY_MODEL_USM,
+                SecurityLevel.AUTH_PRIV,
+                MutableVACM.VACM_MATCH_EXACT,
+                new OctetString("testReadView"),
+                new OctetString("testWriteView"),
+                new OctetString("testNotifyView"),
+                StorageType.nonVolatile);
+
+        vacm.addViewTreeFamily(new OctetString("fullReadView"), new OID("1.3"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("fullWriteView"), new OID("1.3"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("fullNotifyView"), new OID("1.3"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+
+        vacm.addViewTreeFamily(new OctetString("restrictedReadView"),
+                new OID("1.3.6.1.2"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("restrictedWriteView"),
+                new OID("1.3.6.1.2.1"),
+                new OctetString(),
+                VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("restrictedNotifyView"),
+                new OID("1.3.6.1.2"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("restrictedNotifyView"),
+                new OID("1.3.6.1.6.3.1"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+
+        vacm.addViewTreeFamily(new OctetString("testReadView"),
+                new OID("1.3.6.1.2"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("testReadView"),
+                new OID("1.3.6.1.2.1.1"),
+                new OctetString(), VacmMIB.vacmViewExcluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("testWriteView"),
+                new OID("1.3.6.1.2.1"),
+                new OctetString(),
+                VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+        vacm.addViewTreeFamily(new OctetString("testNotifyView"),
+                new OID("1.3.6.1.2"),
+                new OctetString(), VacmMIB.vacmViewIncluded,
+                StorageType.nonVolatile);
+
+    }
+
+    protected void addUsmUser(USM usm) {
+        UsmUser user = new UsmUser(new OctetString("SHADES"),
+                AuthSHA.ID,
+                new OctetString("SHADESAuthPassword"),
+                PrivDES.ID,
+                new OctetString("SHADESPrivPassword"));
+//    usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        usm.addUser(user.getSecurityName(), null, user);
+        user = new UsmUser(new OctetString("TEST"),
+                AuthSHA.ID,
+                new OctetString("maplesyrup"),
+                PrivDES.ID,
+                new OctetString("maplesyrup"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("SHA"),
+                AuthSHA.ID,
+                new OctetString("SHAAuthPassword"),
+                null,
+                null);
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("SHADES"),
+                AuthSHA.ID,
+                new OctetString("SHADESAuthPassword"),
+                PrivDES.ID,
+                new OctetString("SHADESPrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("MD5DES"),
+                AuthMD5.ID,
+                new OctetString("MD5DESAuthPassword"),
+                PrivDES.ID,
+                new OctetString("MD5DESPrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("SHAAES128"),
+                AuthSHA.ID,
+                new OctetString("SHAAES128AuthPassword"),
+                PrivAES128.ID,
+                new OctetString("SHAAES128PrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("SHAAES192"),
+                AuthSHA.ID,
+                new OctetString("SHAAES192AuthPassword"),
+                PrivAES192.ID,
+                new OctetString("SHAAES192PrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("SHAAES256"),
+                AuthSHA.ID,
+                new OctetString("SHAAES256AuthPassword"),
+                PrivAES256.ID,
+                new OctetString("SHAAES256PrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+
+        user = new UsmUser(new OctetString("MD5AES128"),
+                AuthMD5.ID,
+                new OctetString("MD5AES128AuthPassword"),
+                PrivAES128.ID,
+                new OctetString("MD5AES128PrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("MD5AES192"),
+                AuthHMAC192SHA256.ID,
+                new OctetString("MD5AES192AuthPassword"),
+                PrivAES192.ID,
+                new OctetString("MD5AES192PrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        //==============================================================
+        user = new UsmUser(new OctetString("MD5AES256"),
+                AuthMD5.ID,
+                new OctetString("MD5AES256AuthPassword"),
+                PrivAES256.ID,
+                new OctetString("MD5AES256PrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        user = new UsmUser(new OctetString("MD5AES256"),
+                AuthMD5.ID,
+                new OctetString("MD5AES256AuthPassword"),
+                PrivAES256.ID,
+                new OctetString("MD5AES256PrivPassword"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+
+        OctetString securityName = new OctetString("aboba");
+        OctetString authenticationPassphrase = new OctetString("abobaaboba");
+        OctetString privacyPassphrase = new OctetString("abobaaboba");
+        OID authenticationProtocol = AuthSHA.ID;
+        OID privacyProtocol = PrivDES.ID; // FIXME: to config
+        user = new UsmUser(securityName, authenticationProtocol, authenticationPassphrase, privacyProtocol, privacyPassphrase);
+        usm.addUser(user);
+
+        //===============================================================//
+        user = new UsmUser(new OctetString("agent5"),
+                AuthSHA.ID,
+                new OctetString("authpass"),
+                PrivDES.ID,
+                new OctetString("privpass"));
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        //===============================================================//
+        // user001
+        user = new UsmUser(new OctetString("user001"),
+                AuthSHA.ID,
+                new OctetString("authpass"),
+                null, null);
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        //===============================================================//
+        // user002
+        user = new UsmUser(new OctetString("user001"),
+                null,
+                null,
+                null, null);
+        usm.addUser(user.getSecurityName(), usm.getLocalEngineID(), user);
+        //===============================================================//
+
+        user = new UsmUser(new OctetString("v3notify"),
+                null,
+                null,
+                null,
+                null);
+        usm.addUser(user.getSecurityName(), null, user);
+
+        this.usm = usm;
+    }
+
+    private static DefaultMOTable createStaticIfXTable() {
+        MOTableSubIndex[] subIndexes =
+                new MOTableSubIndex[] { new MOTableSubIndex(SMIConstants.SYNTAX_INTEGER) };
+        MOTableIndex indexDef = new MOTableIndex(subIndexes, false);
+        MOColumn[] columns = new MOColumn[19];
+        int c = 0;
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_OCTET_STRING,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifName
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifInMulticastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifInBroadcastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifOutMulticastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifOutBroadcastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCInOctets
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCInUcastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCInMulticastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCInBroadcastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCOutOctets
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCOutUcastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCOutMulticastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_COUNTER32,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifHCOutBroadcastPkts
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_INTEGER,
+                        MOAccessImpl.ACCESS_READ_WRITE);     // ifLinkUpDownTrapEnable
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_GAUGE32,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifHighSpeed
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_INTEGER,
+                        MOAccessImpl.ACCESS_READ_WRITE);     // ifPromiscuousMode
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_INTEGER,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifConnectorPresent
+        columns[c++] =
+                new MOMutableColumn(c, SMIConstants.SYNTAX_OCTET_STRING,     // ifAlias
+                        MOAccessImpl.ACCESS_READ_WRITE, null);
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_TIMETICKS,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifCounterDiscontinuityTime
+
+        DefaultMOTable ifXTable =
+                new DefaultMOTable(new OID("1.3.6.1.2.1.31.1.1.1"), indexDef, columns);
+        MOMutableTableModel model = (MOMutableTableModel) ifXTable.getModel();
+        Variable[] rowValues1 = new Variable[] {
+                new OctetString("Ethernet-0"),
+                new Integer32(1),
+                new Integer32(2),
+                new Integer32(3),
+                new Integer32(4),
+                new Integer32(5),
+                new Integer32(6),
+                new Integer32(7),
+                new Integer32(8),
+                new Integer32(9),
+                new Integer32(10),
+                new Integer32(11),
+                new Integer32(12),
+                new Integer32(13),
+                new Integer32(14),
+                new Integer32(15),
+                new Integer32(16),
+                new OctetString("My eth"),
+                new TimeTicks(1000)
+        };
+        Variable[] rowValues2 = new Variable[] {
+                new OctetString("Loopback"),
+                new Integer32(21),
+                new Integer32(22),
+                new Integer32(23),
+                new Integer32(24),
+                new Integer32(25),
+                new Integer32(26),
+                new Integer32(27),
+                new Integer32(28),
+                new Integer32(29),
+                new Integer32(30),
+                new Integer32(31),
+                new Integer32(32),
+                new Integer32(33),
+                new Integer32(34),
+                new Integer32(35),
+                new Integer32(36),
+                new OctetString("My loop"),
+                new TimeTicks(2000)
+        };
+        model.addRow(new DefaultMOMutableRow2PC(new OID("1"), rowValues1));
+        model.addRow(new DefaultMOMutableRow2PC(new OID("2"), rowValues2));
+        ifXTable.setVolatile(true);
+        return ifXTable;
+    }
+
+    private static DefaultMOTable createStaticIfTable() {
+        MOTableSubIndex[] subIndexes =
+                new MOTableSubIndex[] { new MOTableSubIndex(SMIConstants.SYNTAX_INTEGER) };
+        MOTableIndex indexDef = new MOTableIndex(subIndexes, false);
+        MOColumn[] columns = new MOColumn[8];
+        int c = 0;
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_INTEGER,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifIndex
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_OCTET_STRING,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifDescr
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_INTEGER,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifType
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_INTEGER,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifMtu
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_GAUGE32,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifSpeed
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_OCTET_STRING,
+                        MOAccessImpl.ACCESS_READ_ONLY); // ifPhysAddress
+        columns[c++] =
+                new MOMutableColumn(c, SMIConstants.SYNTAX_INTEGER,     // ifAdminStatus
+                        MOAccessImpl.ACCESS_READ_WRITE, null);
+        columns[c++] =
+                new MOColumn(c, SMIConstants.SYNTAX_INTEGER,
+                        MOAccessImpl.ACCESS_READ_ONLY);     // ifOperStatus
+
+        DefaultMOTable ifTable =
+                new DefaultMOTable(new OID("1.3.6.1.2.1.2.2.1"), indexDef, columns);
+        MOMutableTableModel model = (MOMutableTableModel) ifTable.getModel();
+        Variable[] rowValues1 = new Variable[] {
+                new Integer32(1),
+                new OctetString("eth0"),
+                new Integer32(6),
+                new Integer32(1500),
+                new Gauge32(100000000),
+                new OctetString("00:00:00:00:01"),
+                new Integer32(1),
+                new Integer32(1)
+        };
+        Variable[] rowValues2 = new Variable[] {
+                new Integer32(2),
+                new OctetString("loopback"),
+                new Integer32(24),
+                new Integer32(1500),
+                new Gauge32(10000000),
+                new OctetString("00:00:00:00:02"),
+                new Integer32(1),
+                new Integer32(1)
+        };
+        model.addRow(new DefaultMOMutableRow2PC(new OID("1"), rowValues1));
+        model.addRow(new DefaultMOMutableRow2PC(new OID("2"), rowValues2));
+        ifTable.setVolatile(true);
+        return ifTable;
+    }
+
+    private static DefaultMOTable createStaticSnmp4sTable() {
+        MOTableSubIndex[] subIndexes =
+                new MOTableSubIndex[] { new MOTableSubIndex(SMIConstants.SYNTAX_INTEGER) };
+        MOTableIndex indexDef = new MOTableIndex(subIndexes, false);
+        MOColumn[] columns = new MOColumn[8];
+        int c = 0;
+        columns[c++] = new MOColumn(c, SMIConstants.SYNTAX_NULL, MOAccessImpl.ACCESS_READ_ONLY); // testNull
+        columns[c++] = new MOColumn(c, SMIConstants.SYNTAX_INTEGER, MOAccessImpl.ACCESS_READ_ONLY); // testBoolean
+        columns[c++] = new MOColumn(c, SMIConstants.SYNTAX_INTEGER, MOAccessImpl.ACCESS_READ_ONLY); // ifType
+        columns[c++] = new MOColumn(c, SMIConstants.SYNTAX_INTEGER, MOAccessImpl.ACCESS_READ_ONLY); // ifMtu
+        columns[c++] = new MOColumn(c, SMIConstants.SYNTAX_GAUGE32, MOAccessImpl.ACCESS_READ_ONLY); // ifSpeed
+        columns[c++] = new MOColumn(c, SMIConstants.SYNTAX_OCTET_STRING, MOAccessImpl.ACCESS_READ_ONLY); //ifPhysAddress
+        columns[c++] = new MOMutableColumn(c, SMIConstants.SYNTAX_INTEGER, MOAccessImpl.ACCESS_READ_WRITE,
+                null);
+        // ifAdminStatus
+        columns[c++] = new MOColumn(c, SMIConstants.SYNTAX_INTEGER, MOAccessImpl.ACCESS_READ_ONLY);
+        // ifOperStatus
+
+        DefaultMOTable ifTable =
+                new DefaultMOTable(new OID("1.3.6.1.4.1.50000.1.1"), indexDef, columns);
+        MOMutableTableModel model = (MOMutableTableModel) ifTable.getModel();
+        Variable[] rowValues1 = new Variable[] {
+                new Integer32(1),
+                new OctetString("eth0"),
+                new Integer32(6),
+                new Integer32(1500),
+                new Gauge32(100000000),
+                new OctetString("00:00:00:00:01"),
+                new Integer32(1),
+                new Integer32(1)
+        };
+        Variable[] rowValues2 = new Variable[] {
+                new Integer32(2),
+                new OctetString("loopback"),
+                new Integer32(24),
+                new Integer32(1500),
+                new Gauge32(10000000),
+                new OctetString("00:00:00:00:02"),
+                new Integer32(1),
+                new Integer32(1)
+        };
+        model.addRow(new DefaultMOMutableRow2PC(new OID("1"), rowValues1));
+        model.addRow(new DefaultMOMutableRow2PC(new OID("2"), rowValues2));
+        ifTable.setVolatile(true);
+        return ifTable;
+    }
+
+    protected void initTransportMappings() throws IOException {
+        transportMappings = new TransportMapping[2];
+        Address addr = GenericAddress.parse(address);
+        TransportMapping tm =
+                TransportMappings.getInstance().createTransportMapping(addr);
+        transportMappings[0] = tm;
+        transportMappings[1] = new DefaultTcpTransportMapping(new TcpAddress(address));
+    }
+
+    public void start(String ip, String port) throws IOException {
+        address = ip + "/" + port;
+        //BasicConfigurator.configure();
+        init();
+        addShutdownHook();
+//        loadConfig(ImportModes.REPLACE_CREATE);
+        getServer().addContext(new OctetString("public"));
+        finishInit();
+        run();
+        sendColdStartNotification();
+    }
+
+    protected void unregisterManagedObjects() {
+        // here we should unregister those objects previously registered...
+    }
+
+    protected void addCommunities(SnmpCommunityMIB communityMIB) {
+        Variable[] com2sec = new Variable[] {
+                new OctetString("public"),              // community name
+                new OctetString("cpublic"),              // security name
+                getAgent().getContextEngineID(),        // local engine ID
+                new OctetString("public"),              // default context name
+                new OctetString(),                      // transport tag
+                new Integer32(StorageType.nonVolatile), // storage type
+                new Integer32(RowStatus.active)         // row status
+        };
+        MOTableRow row =
+                communityMIB.getSnmpCommunityEntry().createRow(
+                        new OctetString("public2public").toSubIndex(true), com2sec);
+        communityMIB.getSnmpCommunityEntry().addRow((SnmpCommunityMIB.SnmpCommunityEntryRow) row);
+//    snmpCommunityMIB.setSourceAddressFiltering(true);
+    }
+
+    protected void registerSnmpMIBs() {
+        heartbeatMIB = new Snmp4jHeartbeatMib(super.getNotificationOriginator(),
+                new OctetString(),
+                super.snmpv2MIB.getSysUpTime());
+        agentppSimulationMIB = new AgentppSimulationMib();
+        super.registerSnmpMIBs();
+    }
+
+    protected void initMessageDispatcher() {
+        this.dispatcher = new MessageDispatcherImpl();
+        this.mpv3 = new MPv3(this.agent.getContextEngineID().getValue());
+        this.usm = new USM(SecurityProtocols.getInstance(), this.agent.getContextEngineID(), this.updateEngineBoots());
+        SecurityModels.getInstance().addSecurityModel(this.usm);
+        SecurityProtocols.getInstance().addDefaultProtocols();
+        this.dispatcher.addMessageProcessingModel(new MPv1());
+        this.dispatcher.addMessageProcessingModel(new MPv2c());
+        this.dispatcher.addMessageProcessingModel(this.mpv3);
+        this.initSnmpSession();
+    }
+
+}
\ No newline at end of file

+/**
+ * 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.snmp;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Scanner;
+
+public class SnmpTestV2 {
+    public static void main(String[] args) throws IOException {
+        SnmpDeviceSimulatorV2 device = new SnmpDeviceSimulatorV2(1610, "public");
+
+        device.start();
+        device.setUpMappings(Map.of(
+                ".1.3.6.1.2.1.1.1.50", "12",
+                ".1.3.6.1.2.1.2.1.52", "56",
+                ".1.3.6.1.2.1.3.1.54", "yes",
+                ".1.3.6.1.2.1.7.1.58", ""
+        ));
+
+
+//        while (true) {
+//            new Scanner(System.in).nextLine();
+//            device.sendTrap("127.0.0.1", 1062, Map.of(".1.3.6.1.2.87.1.56", "12"));
+//            System.out.println("sent");
+//        }
+
+//        Snmp snmp = new Snmp(device.transportMappings[0]);
+//        device.snmp.addCommandResponder(event -> {
+//            System.out.println(event);
+//        });
+
+        new Scanner(System.in).nextLine();
+    }
+
+}

+/**
+ * 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.snmp;
+
+import org.snmp4j.CommandResponderEvent;
+import org.snmp4j.agent.CommandProcessor;
+import org.snmp4j.mp.MPv3;
+import org.snmp4j.smi.OctetString;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Scanner;
+
+public class SnmpTestV3 {
+    public static void main(String[] args) throws IOException {
+        SnmpDeviceSimulatorV3 device = new SnmpDeviceSimulatorV3(new CommandProcessor(new OctetString(MPv3.createLocalEngineID())) {
+            @Override
+            public void processPdu(CommandResponderEvent event) {
+                System.out.println("event: " + event);
+            }
+        });
+        device.start("0.0.0.0", "1610");
+
+        device.setUpMappings(Map.of(
+                ".1.3.6.1.2.1.1.1.50", "12",
+                ".1.3.6.1.2.1.2.1.52", "56",
+                ".1.3.6.1.2.1.3.1.54", "yes",
+                ".1.3.6.1.2.1.7.1.58", ""
+        ));
+
+        new Scanner(System.in).nextLine();
+    }
+}

+{
+  "timeoutMs": 500,
+  "retries": 0,
+  "communicationConfigs": [
+    {
+      "spec": "TELEMETRY_QUERYING",
+      "queryingFrequencyMs": 3000,
+      "mappings": [
+        {
+          "oid": ".1.3.6.1.2.1.1.1.50",
+          "key": "temperature",
+          "dataType": "LONG"
+        },
+        {
+          "oid": ".1.3.6.1.2.1.2.1.52",
+          "key": "humidity",
+          "dataType": "DOUBLE"
+        }
+      ]
+    },
+    {
+      "spec": "CLIENT_ATTRIBUTES_QUERYING",
+      "queryingFrequencyMs": 5000,
+      "mappings": [
+        {
+          "oid": ".1.3.6.1.2.1.3.1.54",
+          "key": "isCool",
+          "dataType": "STRING"
+        }
+      ]
+    },
+    {
+      "spec": "SHARED_ATTRIBUTES_SETTING",
+      "mappings": [
+        {
+          "oid": ".1.3.6.1.2.1.7.1.58",
+          "key": "shared",
+          "dataType": "STRING"
+        }
+      ]
+    }
+  ]
+}

+{
+  "address": "192.168.3.23",
+  "port": 1610,
+  "protocolVersion": "V3",
+
+  "username": "tb-user",
+  "engineId": "qwertyuioa",
+  "securityName": "tb-user",
+  "authenticationProtocol": "SHA_512",
+  "authenticationPassphrase": "sdfghjkloifgh",
+  "privacyProtocol": "DES",
+  "privacyPassphrase": "rtytguijokod"
+}
\ No newline at end of file

+{
+  "address": "127.0.0.1",
+  "port": 1610,
+  "community": "public",
+  "protocolVersion": "V2C"
+}
\ No newline at end of file

+/**
+ * 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.common.transport;
+
+import lombok.Getter;
+import org.thingsboard.server.common.data.Device;
+
+@Getter
+public class DeviceUpdatedEvent {
+    private final Device device;
+
+    public DeviceUpdatedEvent(Device device) {
+        this.device = device;
+    }
+}

@@ -17,6 +17,7 @@ package org.thingsboard.server.common.transport;
 
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.AttributeUpdateNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeResponseMsg;
@@ -49,6 +50,8 @@ public interface SessionMsgListener {
     default void onDeviceUpdate(TransportProtos.SessionInfoProto sessionInfo, Device device,
                                 Optional<DeviceProfile> deviceProfileOpt) {}
 
+    default void onDeviceDeleted(DeviceId deviceId) {}
+
     default void onResourceUpdate(Optional<TransportProtos.ResourceUpdateMsg> resourceUpdateMsgOpt) {}
 
     default void onResourceDelete(Optional<TransportProtos.ResourceDeleteMsg> resourceUpdateMsgOpt) {}

@@ -22,6 +22,10 @@ import org.thingsboard.server.common.transport.auth.ValidateDeviceCredentialsRes
 import org.thingsboard.server.common.transport.service.SessionMetaData;
 import org.thingsboard.server.gen.transport.TransportProtos.ClaimDeviceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetDeviceCredentialsRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetDeviceCredentialsResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetDeviceRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetDeviceResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetFirmwareRequestMsg;
@@ -29,6 +33,8 @@ import org.thingsboard.server.gen.transport.TransportProtos.GetFirmwareResponseM
 import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetResourceRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetResourceResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetSnmpDevicesRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetSnmpDevicesResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.LwM2MRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.LwM2MResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.PostAttributeMsg;
@@ -57,6 +63,12 @@ public interface TransportService {
 
     GetResourceResponseMsg getResource(GetResourceRequestMsg msg);
 
+    GetSnmpDevicesResponseMsg getSnmpDevicesIds(GetSnmpDevicesRequestMsg requestMsg);
+
+    GetDeviceResponseMsg getDevice(GetDeviceRequestMsg requestMsg);
+
+    GetDeviceCredentialsResponseMsg getDeviceCredentials(GetDeviceCredentialsRequestMsg requestMsg);
+
     void process(DeviceTransportType transportType, ValidateDeviceTokenRequestMsg msg,
                  TransportServiceCallback<ValidateDeviceCredentialsResponse> callback);
 

@@ -289,7 +289,7 @@ public class JsonConverter {
         return result;
     }
 
-    public static JsonElement toJson(AttributeUpdateNotificationMsg payload) {
+    public static JsonObject toJson(AttributeUpdateNotificationMsg payload) {
         JsonObject result = new JsonObject();
         if (payload.getSharedUpdatedCount() > 0) {
             payload.getSharedUpdatedList().forEach(addToObjectFromProto(result));
@@ -558,6 +558,14 @@ public class JsonConverter {
         }
     }
 
+    public static JsonElement parse(String json) {
+        return JSON_PARSER.parse(json);
+    }
+
+    public static String toJson(JsonElement element) {
+        return GSON.toJson(element);
+    }
+
     public static void setTypeCastEnabled(boolean enabled) {
         isTypeCastEnabled = enabled;
     }
@@ -599,8 +607,7 @@ public class JsonConverter {
                 .build();
     }
 
-    private static TransportProtos.ProvisionDeviceCredentialsMsg buildProvisionDeviceCredentialsMsg(String
-                                                                                                            provisionKey, String provisionSecret) {
+    private static TransportProtos.ProvisionDeviceCredentialsMsg buildProvisionDeviceCredentialsMsg(String provisionKey, String provisionSecret) {
         return TransportProtos.ProvisionDeviceCredentialsMsg.newBuilder()
                 .setProvisionDeviceKey(provisionKey)
                 .setProvisionDeviceSecret(provisionSecret)

@@ -112,8 +112,8 @@ public class DefaultTransportDeviceProfileCache implements TransportDeviceProfil
                     profile = profileOpt.get();
                     this.put(profile);
                 } else {
-                    log.warn("[{}] Can't device profile: {}", id, entityProfileMsg.getData());
-                    throw new RuntimeException("Can't device profile!");
+                    log.warn("[{}] Can't find device profile: {}", id, entityProfileMsg.getData());
+                    throw new RuntimeException("Can't find device profile!");
                 }
             } finally {
                 deviceProfileFetchLock.unlock();

@@ -23,6 +23,7 @@ import com.google.gson.JsonObject;
 import com.google.protobuf.ByteString;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.server.common.data.ApiUsageRecordKey;
@@ -50,6 +51,7 @@ import org.thingsboard.server.common.msg.tools.TbRateLimitsException;
 import org.thingsboard.server.common.stats.MessagesStats;
 import org.thingsboard.server.common.stats.StatsFactory;
 import org.thingsboard.server.common.stats.StatsType;
+import org.thingsboard.server.common.transport.DeviceUpdatedEvent;
 import org.thingsboard.server.common.transport.SessionMsgListener;
 import org.thingsboard.server.common.transport.TransportDeviceProfileCache;
 import org.thingsboard.server.common.transport.TransportResourceCache;
@@ -134,6 +136,7 @@ public class DefaultTransportService implements TransportService {
     private final TransportRateLimitService rateLimitService;
     private final DataDecodingEncodingService dataDecodingEncodingService;
     private final SchedulerComponent scheduler;
+    private final ApplicationEventPublisher eventPublisher;
     private final TransportResourceCache transportResourceCache;
 
     protected TbQueueRequestTemplate<TbProtoQueueMsg<TransportApiRequestMsg>, TbProtoQueueMsg<TransportApiResponseMsg>> transportApiRequestTemplate;
@@ -161,7 +164,8 @@ public class DefaultTransportService implements TransportService {
                                    TransportDeviceProfileCache deviceProfileCache,
                                    TransportTenantProfileCache tenantProfileCache,
                                    TbApiUsageClient apiUsageClient, TransportRateLimitService rateLimitService,
-                                   DataDecodingEncodingService dataDecodingEncodingService, SchedulerComponent scheduler, TransportResourceCache transportResourceCache) {
+                                   DataDecodingEncodingService dataDecodingEncodingService, SchedulerComponent scheduler, TransportResourceCache transportResourceCache,
+                                   ApplicationEventPublisher eventPublisher) {
         this.serviceInfoProvider = serviceInfoProvider;
         this.queueProvider = queueProvider;
         this.producerProvider = producerProvider;
@@ -174,6 +178,7 @@ public class DefaultTransportService implements TransportService {
         this.dataDecodingEncodingService = dataDecodingEncodingService;
         this.scheduler = scheduler;
         this.transportResourceCache = transportResourceCache;
+        this.eventPublisher = eventPublisher;
     }
 
     @PostConstruct
@@ -272,6 +277,58 @@ public class DefaultTransportService implements TransportService {
     }
 
     @Override
+    public TransportProtos.GetSnmpDevicesResponseMsg getSnmpDevicesIds(TransportProtos.GetSnmpDevicesRequestMsg requestMsg) {
+        TbProtoQueueMsg<TransportProtos.TransportApiRequestMsg> protoMsg = new TbProtoQueueMsg<>(
+                UUID.randomUUID(), TransportProtos.TransportApiRequestMsg.newBuilder()
+                .setSnmpDevicesRequestMsg(requestMsg)
+                .build()
+        );
+
+        try {
+            TbProtoQueueMsg<TransportApiResponseMsg> response = transportApiRequestTemplate.send(protoMsg).get();
+            return response.getValue().getSnmpDevicesResponseMsg();
+        } catch (InterruptedException | ExecutionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public TransportProtos.GetDeviceResponseMsg getDevice(TransportProtos.GetDeviceRequestMsg requestMsg) {
+        TbProtoQueueMsg<TransportApiRequestMsg> protoMsg = new TbProtoQueueMsg<>(
+                UUID.randomUUID(), TransportProtos.TransportApiRequestMsg.newBuilder()
+                .setDeviceRequestMsg(requestMsg)
+                .build()
+        );
+
+        try {
+            TransportApiResponseMsg response = transportApiRequestTemplate.send(protoMsg).get().getValue();
+            if (response.hasDeviceResponseMsg()) {
+                return response.getDeviceResponseMsg();
+            } else {
+                return null;
+            }
+        } catch (InterruptedException | ExecutionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public TransportProtos.GetDeviceCredentialsResponseMsg getDeviceCredentials(TransportProtos.GetDeviceCredentialsRequestMsg requestMsg) {
+        TbProtoQueueMsg<TransportApiRequestMsg> protoMsg = new TbProtoQueueMsg<>(
+                UUID.randomUUID(), TransportProtos.TransportApiRequestMsg.newBuilder()
+                .setDeviceCredentialsRequestMsg(requestMsg)
+                .build()
+        );
+
+        try {
+            TbProtoQueueMsg<TransportApiResponseMsg> response = transportApiRequestTemplate.send(protoMsg).get();
+            return response.getValue().getDeviceCredentialsResponseMsg();
+        } catch (InterruptedException | ExecutionException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
     public void process(DeviceTransportType transportType, TransportProtos.ValidateDeviceTokenRequestMsg msg,
                         TransportServiceCallback<ValidateDeviceCredentialsResponse> callback) {
         log.trace("Processing msg: {}", msg);
@@ -704,7 +761,10 @@ public class DefaultTransportService implements TransportService {
                     }
                 } else if (EntityType.DEVICE.equals(entityType)) {
                     Optional<Device> deviceOpt = dataDecodingEncodingService.decode(msg.getData().toByteArray());
-                    deviceOpt.ifPresent(this::onDeviceUpdate);
+                    deviceOpt.ifPresent(device -> {
+                        onDeviceUpdate(device);
+                        eventPublisher.publishEvent(new DeviceUpdatedEvent(device));
+                    });
                 }
             } else if (toSessionMsg.hasEntityDeleteMsg()) {
                 TransportProtos.EntityDeleteMsg msg = toSessionMsg.getEntityDeleteMsg();
@@ -718,6 +778,7 @@ public class DefaultTransportService implements TransportService {
                     rateLimitService.remove(new TenantId(entityUuid));
                 } else if (EntityType.DEVICE.equals(entityType)) {
                     rateLimitService.remove(new DeviceId(entityUuid));
+                    onDeviceDeleted(new DeviceId(entityUuid));
                 }
             } else if (toSessionMsg.hasResourceUpdateMsg()) {
                 TransportProtos.ResourceUpdateMsg msg = toSessionMsg.getResourceUpdateMsg();
@@ -800,6 +861,17 @@ public class DefaultTransportService implements TransportService {
         });
     }
 
+    private void onDeviceDeleted(DeviceId deviceId) {
+        sessions.forEach((id, md) -> {
+            DeviceId sessionDeviceId = new DeviceId(new UUID(md.getSessionInfo().getDeviceIdMSB(), md.getSessionInfo().getDeviceIdLSB()));
+            if (sessionDeviceId.equals(deviceId)) {
+                transportCallbackExecutor.submit(() -> {
+                    md.getListener().onDeviceDeleted(deviceId);
+                });
+            }
+        });
+    }
+
     protected UUID toSessionId(TransportProtos.SessionInfoProto sessionInfo) {
         return new UUID(sessionInfo.getSessionIdMSB(), sessionInfo.getSessionIdLSB());
     }

@@ -18,11 +18,11 @@ package org.thingsboard.server.dao.device;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceInfo;
+import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.EntitySubtype;
 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.Dao;
 import org.thingsboard.server.dao.TenantEntityDao;
 
@@ -219,6 +219,7 @@ public interface DeviceDao extends Dao<Device>, TenantEntityDao {
      */
     PageData<Device> findDevicesByTenantIdAndProfileId(UUID tenantId, UUID profileId, PageLink pageLink);
 
+    PageData<UUID> findDevicesIdsByDeviceProfileTransportType(DeviceTransportType transportType, PageLink pageLink);
 
     /**
      * Find devices by tenantId, edgeId and page link.

@@ -363,6 +363,7 @@ public class DeviceProfileServiceImpl extends AbstractEntityService implements D
                     }
 
                     DeviceProfileTransportConfiguration transportConfiguration = deviceProfile.getProfileData().getTransportConfiguration();
+                    transportConfiguration.validate();
                     if (transportConfiguration instanceof MqttDeviceProfileTransportConfiguration) {
                         MqttDeviceProfileTransportConfiguration mqttTransportConfiguration = (MqttDeviceProfileTransportConfiguration) transportConfiguration;
                         if (mqttTransportConfiguration.getTransportPayloadTypeConfiguration() instanceof ProtoTransportPayloadConfiguration) {

@@ -36,20 +36,22 @@ import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceInfo;
 import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.Firmware;
 import org.thingsboard.server.common.data.Tenant;
-import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.device.DeviceSearchQuery;
 import org.thingsboard.server.common.data.device.credentials.BasicMqttCredentials;
 import org.thingsboard.server.common.data.device.data.CoapDeviceTransportConfiguration;
 import org.thingsboard.server.common.data.device.data.DefaultDeviceConfiguration;
 import org.thingsboard.server.common.data.device.data.DefaultDeviceTransportConfiguration;
 import org.thingsboard.server.common.data.device.data.DeviceData;
+import org.thingsboard.server.common.data.device.data.DeviceTransportConfiguration;
 import org.thingsboard.server.common.data.device.data.Lwm2mDeviceTransportConfiguration;
 import org.thingsboard.server.common.data.device.data.MqttDeviceTransportConfiguration;
+import org.thingsboard.server.common.data.device.data.SnmpDeviceTransportConfiguration;
 import org.thingsboard.server.common.data.edge.Edge;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
@@ -59,7 +61,6 @@ import org.thingsboard.server.common.data.id.EntityId;
 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.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntitySearchDirection;
 import org.thingsboard.server.common.data.relation.RelationTypeGroup;
@@ -86,6 +87,7 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
+import java.util.UUID;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 
@@ -269,11 +271,14 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                 case MQTT:
                     deviceData.setTransportConfiguration(new MqttDeviceTransportConfiguration());
                     break;
+                case COAP:
+                    deviceData.setTransportConfiguration(new CoapDeviceTransportConfiguration());
+                    break;
                 case LWM2M:
                     deviceData.setTransportConfiguration(new Lwm2mDeviceTransportConfiguration());
                     break;
-                case COAP:
-                    deviceData.setTransportConfiguration(new CoapDeviceTransportConfiguration());
+                case SNMP:
+                    deviceData.setTransportConfiguration(new SnmpDeviceTransportConfiguration());
                     break;
             }
         }
@@ -573,6 +578,11 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
     }
 
     @Override
+    public PageData<UUID> findDevicesIdsByDeviceProfileTransportType(DeviceTransportType transportType, PageLink pageLink) {
+        return deviceDao.findDevicesIdsByDeviceProfileTransportType(transportType, pageLink);
+    }
+
+    @Override
     public Device assignDeviceToEdge(TenantId tenantId, DeviceId deviceId, EdgeId edgeId) {
         Device device = findDeviceById(tenantId, deviceId);
         Edge edge = edgeService.findEdgeById(tenantId, edgeId);
@@ -677,6 +687,9 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                             throw new DataValidationException("Can't assign device to customer from different tenant!");
                         }
                     }
+                    Optional.ofNullable(device.getDeviceData())
+                            .flatMap(deviceData -> Optional.ofNullable(deviceData.getTransportConfiguration()))
+                            .ifPresent(DeviceTransportConfiguration::validate);
 
                     if (device.getFirmwareId() != null) {
                         Firmware firmware = firmwareService.findFirmwareById(tenantId, device.getFirmwareId());

@@ -20,6 +20,7 @@ import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
+import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.dao.model.sql.DeviceEntity;
 import org.thingsboard.server.dao.model.sql.DeviceInfoEntity;
 
@@ -210,4 +211,9 @@ public interface DeviceRepository extends PagingAndSortingRepository<DeviceEntit
      * */
     @Query("SELECT count(*) FROM DeviceEntity d WHERE d.tenantId = :tenantId")
     Long countByTenantId(@Param("tenantId") UUID tenantId);
+
+    @Query("SELECT d.id FROM DeviceEntity d " +
+            "INNER JOIN DeviceProfileEntity p ON d.deviceProfileId = p.id " +
+            "WHERE p.transportType = :transportType")
+    Page<UUID> findIdsByDeviceProfileTransportType(@Param("transportType") DeviceTransportType transportType, Pageable pageable);
 }

@@ -23,12 +23,12 @@ import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceInfo;
+import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.EntitySubtype;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.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.DaoUtil;
 import org.thingsboard.server.dao.device.DeviceDao;
 import org.thingsboard.server.dao.model.sql.DeviceEntity;
@@ -118,6 +118,11 @@ public class JpaDeviceDao extends JpaAbstractSearchTextDao<DeviceEntity, Device>
     }
 
     @Override
+    public PageData<UUID> findDevicesIdsByDeviceProfileTransportType(DeviceTransportType transportType, PageLink pageLink) {
+        return DaoUtil.pageToPageData(deviceRepository.findIdsByDeviceProfileTransportType(transportType, DaoUtil.toPageable(pageLink)));
+    }
+
+    @Override
     public PageData<DeviceInfo> findDeviceInfosByTenantIdAndCustomerId(UUID tenantId, UUID customerId, PageLink pageLink) {
         return DaoUtil.toPageData(
                 deviceRepository.findDeviceInfosByTenantIdAndCustomerId(

@@ -9,6 +9,7 @@ MQTT_TRANSPORT_DOCKER_NAME=tb-mqtt-transport
 HTTP_TRANSPORT_DOCKER_NAME=tb-http-transport
 COAP_TRANSPORT_DOCKER_NAME=tb-coap-transport
 LWM2M_TRANSPORT_DOCKER_NAME=tb-lwm2m-transport
+SNMP_TRANSPORT_DOCKER_NAME=tb-snmp-transport
 
 TB_VERSION=latest
 

@@ -74,3 +74,8 @@ services:
       - queue-aws-sqs.env
     depends_on:
       - zookeeper
+  tb-snmp-transport:
+    env_file:
+      - queue-aws-sqs.env
+    depends_on:
+      - zookeeper

@@ -58,3 +58,6 @@ services:
   tb-lwm2m-transport:
     env_file:
       - queue-confluent.env
+  tb-snmp-transport:
+    env_file:
+      - queue-confluent.env

@@ -85,3 +85,8 @@ services:
       - queue-kafka.env
     depends_on:
       - kafka
+  tb-snmp-transport:
+    env_file:
+      - queue-kafka.env
+    depends_on:
+      - kafka

@@ -50,6 +50,9 @@ services:
   tb-mqtt-transport2:
     volumes:
       - tb-mqtt-transport-log-volume:/var/log/tb-mqtt-transport
+  tb-snmp-transport:
+    volumes:
+      - tb-snmp-transport-log-volume:/var/log/tb-snmp-transport
 
 volumes:
   postgres-db-volume:
@@ -70,3 +73,6 @@ volumes:
   tb-mqtt-transport-log-volume:
     external: true
     name: ${TB_MQTT_TRANSPORT_LOG_VOLUME}
+  tb-snmp-transport-log-volume:
+    external: true
+    name: ${TB_SNMP_TRANSPORT_LOG_VOLUME}

@@ -74,3 +74,8 @@ services:
       - queue-pubsub.env
     depends_on:
       - zookeeper
+  tb-snmp-transport:
+    env_file:
+      - queue-pubsub.env
+    depends_on:
+      - zookeeper

@@ -74,3 +74,8 @@ services:
       - queue-rabbitmq.env
     depends_on:
       - zookeeper
+  tb-snmp-transport:
+    env_file:
+      - queue-rabbitmq.env
+    depends_on:
+      - zookeeper

@@ -72,3 +72,8 @@ services:
       - queue-service-bus.env
     depends_on:
       - zookeeper
+  tb-snmp-transport:
+    env_file:
+      - queue-service-bus.env
+    depends_on:
+      - zookeeper

@@ -217,6 +217,18 @@ services:
       - ./tb-transports/lwm2m/log:/var/log/tb-lwm2m-transport
     depends_on:
       - zookeeper
+  tb-snmp-transport:
+    restart: always
+    image: "${DOCKER_REPO}/${SNMP_TRANSPORT_DOCKER_NAME}:${TB_VERSION}"
+    environment:
+      TB_SERVICE_ID: tb-snmp-transport
+    env_file:
+      - tb-snmp-transport.env
+    volumes:
+      - ./tb-transports/snmp/conf:/config
+      - ./tb-transports/snmp/log:/var/log/tb-snmp-transport
+    depends_on:
+      - zookeeper
   tb-web-ui1:
     restart: always
     image: "${DOCKER_REPO}/${WEB_UI_DOCKER_NAME}:${TB_VERSION}"

@@ -24,3 +24,5 @@ mkdir -p tb-transports/lwm2m/log && sudo chown -R 799:799 tb-transports/lwm2m/lo
 mkdir -p tb-transports/http/log && sudo chown -R 799:799 tb-transports/http/log
 
 mkdir -p tb-transports/mqtt/log && sudo chown -R 799:799 tb-transports/mqtt/log
+
+mkdir -p tb-transports/snmp/log && sudo chown -R 799:799 tb-transports/snmp/log

+ZOOKEEPER_ENABLED=true
+ZOOKEEPER_URL=zookeeper:2181