Merge pull request #4465 from thingsboard/feature/firmware

Feature/firmware

application/src/main/data/upgrade/3.2.2/schema_update.sql

@@ -31,7 +31,7 @@ CREATE TABLE IF NOT EXISTS edge (
     tenant_id uuid,
     CONSTRAINT edge_name_unq_key UNIQUE (tenant_id, name),
     CONSTRAINT edge_routing_key_unq_key UNIQUE (routing_key)
-);
+    );
 
 CREATE TABLE IF NOT EXISTS edge_event (
     id uuid NOT NULL CONSTRAINT edge_event_pkey PRIMARY KEY,
@@ -44,4 +44,57 @@ CREATE TABLE IF NOT EXISTS edge_event (
     body varchar(10000000),
     tenant_id uuid,
     ts bigint NOT NULL
+    );
+
+CREATE TABLE IF NOT EXISTS resource (
+    id uuid NOT NULL CONSTRAINT resource_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid NOT NULL,
+    title varchar(255) NOT NULL,
+    resource_type varchar(32) NOT NULL,
+    resource_key varchar(255) NOT NULL,
+    search_text varchar(255),
+    file_name varchar(255) NOT NULL,
+    data varchar,
+    CONSTRAINT resource_unq_key UNIQUE (tenant_id, resource_type, resource_key)
+);
+
+CREATE TABLE IF NOT EXISTS firmware (
+    id uuid NOT NULL CONSTRAINT firmware_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid NOT NULL,
+    title varchar(255) NOT NULL,
+    version varchar(255) NOT NULL,
+    file_name varchar(255),
+    content_type varchar(255),
+    checksum_algorithm varchar(32),
+    checksum varchar(1020),
+    data bytea,
+    data_size bigint,
+    additional_info varchar,
+    search_text varchar(255),
+    CONSTRAINT firmware_tenant_title_version_unq_key UNIQUE (tenant_id, title, version)
 );
+
+ALTER TABLE device_profile
+    ADD COLUMN IF NOT EXISTS firmware_id uuid;
+
+ALTER TABLE device
+    ADD COLUMN IF NOT EXISTS firmware_id uuid;
+
+DO $$
+    BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'fk_firmware_device_profile') THEN
+            ALTER TABLE device_profile
+                ADD CONSTRAINT fk_firmware_device_profile
+                    FOREIGN KEY (firmware_id) REFERENCES firmware(id);
+        END IF;
+
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'fk_firmware_device') THEN
+            ALTER TABLE device
+                ADD CONSTRAINT fk_firmware_device
+                    FOREIGN KEY (firmware_id) REFERENCES firmware(id);
+        END IF;
+    END;
+$$;
+

application/src/main/java/org/thingsboard/server/controller/BaseController.java

@@ -24,6 +24,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.MediaType;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.web.bind.annotation.ExceptionHandler;
@@ -38,6 +39,8 @@ import org.thingsboard.server.common.data.EdgeUtils;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityViewInfo;
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.common.data.FirmwareInfo;
 import org.thingsboard.server.common.data.HasName;
 import org.thingsboard.server.common.data.HasTenantId;
 import org.thingsboard.server.common.data.TbResourceInfo;
@@ -67,6 +70,7 @@ import org.thingsboard.server.common.data.id.EdgeId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
 import org.thingsboard.server.common.data.id.EntityViewId;
+import org.thingsboard.server.common.data.id.FirmwareId;
 import org.thingsboard.server.common.data.id.TbResourceId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.RuleNodeId;
@@ -106,6 +110,7 @@ import org.thingsboard.server.dao.edge.EdgeService;
 import org.thingsboard.server.dao.entityview.EntityViewService;
 import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.exception.IncorrectParameterException;
+import org.thingsboard.server.dao.firmware.FirmwareService;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.oauth2.OAuth2ConfigTemplateService;
 import org.thingsboard.server.dao.oauth2.OAuth2Service;
@@ -123,6 +128,7 @@ import org.thingsboard.server.queue.discovery.PartitionService;
 import org.thingsboard.server.queue.provider.TbQueueProducerProvider;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.component.ComponentDiscoveryService;
+import org.thingsboard.server.service.firmware.FirmwareStateService;
 import org.thingsboard.server.service.edge.EdgeNotificationService;
 import org.thingsboard.server.service.edge.rpc.EdgeGrpcService;
 import org.thingsboard.server.service.edge.rpc.init.SyncEdgeService;
@@ -245,6 +251,12 @@ public abstract class BaseController {
     @Autowired
     protected TbResourceService resourceService;
 
+    @Autowired
+    protected FirmwareService firmwareService;
+
+    @Autowired
+    protected FirmwareStateService firmwareStateService;
+
     @Autowired
     protected TbQueueProducerProvider producerProvider;
 
@@ -501,6 +513,9 @@ public abstract class BaseController {
                 case TB_RESOURCE:
                     checkResourceId(new TbResourceId(entityId.getId()), operation);
                     return;
+                case FIRMWARE:
+                    checkFirmwareId(new FirmwareId(entityId.getId()), operation);
+                    return;
                 default:
                     throw new IllegalArgumentException("Unsupported entity type: " + entityId.getEntityType());
             }
@@ -756,6 +771,30 @@ public abstract class BaseController {
         }
     }
 
+    Firmware checkFirmwareId(FirmwareId firmwareId, Operation operation) throws ThingsboardException {
+        try {
+            validateId(firmwareId, "Incorrect firmwareId " + firmwareId);
+            Firmware firmware = firmwareService.findFirmwareById(getCurrentUser().getTenantId(), firmwareId);
+            checkNotNull(firmware);
+            accessControlService.checkPermission(getCurrentUser(), Resource.FIRMWARE, operation, firmwareId, firmware);
+            return firmware;
+        } catch (Exception e) {
+            throw handleException(e, false);
+        }
+    }
+
+    FirmwareInfo checkFirmwareInfoId(FirmwareId firmwareId, Operation operation) throws ThingsboardException {
+        try {
+            validateId(firmwareId, "Incorrect firmwareId " + firmwareId);
+            FirmwareInfo firmwareInfo = firmwareService.findFirmwareInfoById(getCurrentUser().getTenantId(), firmwareId);
+            checkNotNull(firmwareInfo);
+            accessControlService.checkPermission(getCurrentUser(), Resource.FIRMWARE, operation, firmwareId, firmwareInfo);
+            return firmwareInfo;
+        } catch (Exception e) {
+            throw handleException(e, false);
+        }
+    }
+
     @SuppressWarnings("unchecked")
     protected <I extends EntityId> I emptyId(EntityType entityType) {
         return (I) EntityIdFactory.getByTypeAndUuid(entityType, ModelConstants.NULL_UUID);
@@ -1082,4 +1121,11 @@ public abstract class BaseController {
         }
     }
 
+    protected MediaType parseMediaType(String contentType) {
+        try {
+            return MediaType.parseMediaType(contentType);
+        } catch (Exception e) {
+            return MediaType.APPLICATION_OCTET_STREAM;
+        }
+    }
 }

application/src/main/java/org/thingsboard/server/controller/DeviceController.java

@@ -75,6 +75,7 @@ import javax.annotation.Nullable;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 import static org.thingsboard.server.controller.EdgeController.EDGE_ID;
@@ -124,15 +125,22 @@ public class DeviceController extends BaseController {
 
             checkEntity(device.getId(), device, Resource.DEVICE);
 
+            boolean created = device.getId() == null;
+            Device oldDevice;
+            if (!created) {
+                oldDevice = deviceService.findDeviceById(getTenantId(), device.getId());
+            } else {
+                oldDevice = null;
+            }
+
             Device savedDevice = checkNotNull(deviceService.saveDeviceWithAccessToken(device, accessToken));
 
             tbClusterService.onDeviceChange(savedDevice, null);
             tbClusterService.pushMsgToCore(new DeviceNameOrTypeUpdateMsg(savedDevice.getTenantId(),
                     savedDevice.getId(), savedDevice.getName(), savedDevice.getType()), null);
-            tbClusterService.onEntityStateChange(savedDevice.getTenantId(), savedDevice.getId(),
+            tbClusterService.onEntityStateChange(savedDevice.getTenantId(), savedDevice.getId(), created ? ComponentLifecycleEvent.CREATED : ComponentLifecycleEvent.UPDATED);
-                    device.getId() == null ? ComponentLifecycleEvent.CREATED : ComponentLifecycleEvent.UPDATED);
 
-            if (device.getId() != null) {
+            if (!created) {
                 sendEntityNotificationMsg(savedDevice.getTenantId(), savedDevice.getId(), EdgeEventActionType.UPDATED);
             }
 
@@ -145,12 +153,17 @@ public class DeviceController extends BaseController {
             } else {
                 deviceStateService.onDeviceUpdated(savedDevice);
             }
+
+            firmwareStateService.update(savedDevice, oldDevice);
+
             return savedDevice;
-        } catch (Exception e) {
+        } catch (
+                Exception e) {
             logEntityAction(emptyId(EntityType.DEVICE), device,
                     null, device.getId() == null ? ActionType.ADDED : ActionType.UPDATED, e);
             throw handleException(e);
         }
+
     }
 
     @PreAuthorize("hasAuthority('TENANT_ADMIN')")

application/src/main/java/org/thingsboard/server/controller/DeviceProfileController.java

@@ -44,6 +44,7 @@ import org.thingsboard.server.service.security.permission.Operation;
 import org.thingsboard.server.service.security.permission.Resource;
 
 import java.util.List;
+import java.util.Objects;
 import java.util.UUID;
 
 @RestController
@@ -144,6 +145,15 @@ public class DeviceProfileController extends BaseController {
 
             checkEntity(deviceProfile.getId(), deviceProfile, Resource.DEVICE_PROFILE);
 
+            boolean isFirmwareChanged = false;
+
+            if (!created) {
+                DeviceProfile oldDeviceProfile = deviceProfileService.findDeviceProfileById(getTenantId(), deviceProfile.getId());
+                if (!Objects.equals(deviceProfile.getFirmwareId(), oldDeviceProfile.getFirmwareId())) {
+                    isFirmwareChanged = true;
+                }
+            }
+
             DeviceProfile savedDeviceProfile = checkNotNull(deviceProfileService.saveDeviceProfile(deviceProfile));
 
             tbClusterService.onDeviceProfileChange(savedDeviceProfile, null);
@@ -154,9 +164,11 @@ public class DeviceProfileController extends BaseController {
                     null,
                     created ? ActionType.ADDED : ActionType.UPDATED, null);
 
+            if (isFirmwareChanged) {
+                firmwareStateService.update(savedDeviceProfile);
+            }
             sendEntityNotificationMsg(getTenantId(), savedDeviceProfile.getId(),
                     deviceProfile.getId() == null ? EdgeEventActionType.ADDED : EdgeEventActionType.UPDATED);
-
             return savedDeviceProfile;
         } catch (Exception e) {
             logEntityAction(emptyId(EntityType.DEVICE_PROFILE), deviceProfile,

application/src/main/java/org/thingsboard/server/controller/FirmwareController.java

@@ -0,0 +1,197 @@
+/**
+ * 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.controller;
+
+import com.google.common.hash.Hashing;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.common.data.FirmwareInfo;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.FirmwareId;
+import org.thingsboard.server.common.data.page.PageData;
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.security.permission.Operation;
+import org.thingsboard.server.service.security.permission.Resource;
+
+import java.nio.ByteBuffer;
+
+@Slf4j
+@RestController
+@TbCoreComponent
+@RequestMapping("/api")
+public class FirmwareController extends BaseController {
+
+    public static final String FIRMWARE_ID = "firmwareId";
+
+    @PreAuthorize("hasAnyAuthority( 'TENANT_ADMIN')")
+    @RequestMapping(value = "/firmware/{firmwareId}/download", method = RequestMethod.GET)
+    @ResponseBody
+    public ResponseEntity<org.springframework.core.io.Resource> downloadFirmware(@PathVariable(FIRMWARE_ID) String strFirmwareId) throws ThingsboardException {
+        checkParameter(FIRMWARE_ID, strFirmwareId);
+        try {
+            FirmwareId firmwareId = new FirmwareId(toUUID(strFirmwareId));
+            Firmware firmware = checkFirmwareId(firmwareId, Operation.READ);
+
+            ByteArrayResource resource = new ByteArrayResource(firmware.getData().array());
+            return ResponseEntity.ok()
+                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + firmware.getFileName())
+                    .header("x-filename", firmware.getFileName())
+                    .contentLength(resource.contentLength())
+                    .contentType(parseMediaType(firmware.getContentType()))
+                    .body(resource);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/firmware/info/{firmwareId}", method = RequestMethod.GET)
+    @ResponseBody
+    public FirmwareInfo getFirmwareInfoById(@PathVariable(FIRMWARE_ID) String strFirmwareId) throws ThingsboardException {
+        checkParameter(FIRMWARE_ID, strFirmwareId);
+        try {
+            FirmwareId firmwareId = new FirmwareId(toUUID(strFirmwareId));
+            return checkFirmwareInfoId(firmwareId, Operation.READ);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/firmware/{firmwareId}", method = RequestMethod.GET)
+    @ResponseBody
+    public Firmware getFirmwareById(@PathVariable(FIRMWARE_ID) String strFirmwareId) throws ThingsboardException {
+        checkParameter(FIRMWARE_ID, strFirmwareId);
+        try {
+            FirmwareId firmwareId = new FirmwareId(toUUID(strFirmwareId));
+            return checkFirmwareId(firmwareId, Operation.READ);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/firmware", method = RequestMethod.POST)
+    @ResponseBody
+    public FirmwareInfo saveFirmwareInfo(@RequestBody FirmwareInfo firmwareInfo) throws ThingsboardException {
+        firmwareInfo.setTenantId(getTenantId());
+        checkEntity(firmwareInfo.getId(), firmwareInfo, Resource.FIRMWARE);
+        try {
+            return firmwareService.saveFirmwareInfo(firmwareInfo);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/firmware/{firmwareId}", method = RequestMethod.POST)
+    @ResponseBody
+    public Firmware saveFirmwareData(@PathVariable(FIRMWARE_ID) String strFirmwareId,
+                                     @RequestParam(required = false) String checksum,
+                                     @RequestParam(required = false) String checksumAlgorithm,
+                                     @RequestBody MultipartFile file) throws ThingsboardException {
+        checkParameter(FIRMWARE_ID, strFirmwareId);
+        try {
+            FirmwareId firmwareId = new FirmwareId(toUUID(strFirmwareId));
+            FirmwareInfo info = checkFirmwareInfoId(firmwareId, Operation.READ);
+
+            Firmware firmware = new Firmware(firmwareId);
+            firmware.setCreatedTime(info.getCreatedTime());
+            firmware.setTenantId(getTenantId());
+            firmware.setTitle(info.getTitle());
+            firmware.setVersion(info.getVersion());
+            firmware.setAdditionalInfo(info.getAdditionalInfo());
+
+            byte[] data = file.getBytes();
+            if (StringUtils.isEmpty(checksumAlgorithm)) {
+                checksumAlgorithm = "sha256";
+                checksum = Hashing.sha256().hashBytes(data).toString();
+            }
+
+            firmware.setChecksumAlgorithm(checksumAlgorithm);
+            firmware.setChecksum(checksum);
+            firmware.setFileName(file.getOriginalFilename());
+            firmware.setContentType(file.getContentType());
+            firmware.setData(ByteBuffer.wrap(data));
+            firmware.setDataSize((long) data.length);
+            return firmwareService.saveFirmware(firmware);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/firmwares", method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<FirmwareInfo> getFirmwares(@RequestParam int pageSize,
+                                               @RequestParam int page,
+                                               @RequestParam(required = false) String textSearch,
+                                               @RequestParam(required = false) String sortProperty,
+                                               @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        try {
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            return checkNotNull(firmwareService.findTenantFirmwaresByTenantId(getTenantId(), pageLink));
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/firmwares/{hasData}", method = RequestMethod.GET)
+    @ResponseBody
+    public PageData<FirmwareInfo> getFirmwares(@PathVariable("hasData") boolean hasData,
+                                               @RequestParam int pageSize,
+                                               @RequestParam int page,
+                                               @RequestParam(required = false) String textSearch,
+                                               @RequestParam(required = false) String sortProperty,
+                                               @RequestParam(required = false) String sortOrder) throws ThingsboardException {
+        try {
+            PageLink pageLink = createPageLink(pageSize, page, textSearch, sortProperty, sortOrder);
+            return checkNotNull(firmwareService.findTenantFirmwaresByTenantIdAndHasData(getTenantId(), hasData, pageLink));
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/firmware/{firmwareId}", method = RequestMethod.DELETE)
+    @ResponseBody
+    public void deleteResource(@PathVariable("firmwareId") String strFirmwareId) throws ThingsboardException {
+        checkParameter(FIRMWARE_ID, strFirmwareId);
+        try {
+            FirmwareId firmwareId = new FirmwareId(toUUID(strFirmwareId));
+            checkFirmwareInfoId(firmwareId, Operation.DELETE);
+            firmwareService.deleteFirmware(getTenantId(), firmwareId);
+        } catch (Exception e) {
+            throw handleException(e);
+        }
+    }
+
+}

application/src/main/java/org/thingsboard/server/controller/TbResourceController.java

@@ -166,7 +166,7 @@ public class TbResourceController extends BaseController {
     @RequestMapping(value = "/resource/{resourceId}", method = RequestMethod.DELETE)
     @ResponseBody
     public void deleteResource(@PathVariable("resourceId") String strResourceId) throws ThingsboardException {
-        checkParameter("resourceId", strResourceId);
+        checkParameter(RESOURCE_ID, strResourceId);
         try {
             TbResourceId resourceId = new TbResourceId(toUUID(strResourceId));
             TbResource tbResource = checkResourceId(resourceId, Operation.DELETE);

application/src/main/java/org/thingsboard/server/install/ThingsboardInstallService.java

@@ -232,7 +232,6 @@ public class ThingsboardInstallService {
                 systemDataLoaderService.createAdminSettings();
                 systemDataLoaderService.loadSystemWidgets();
                 systemDataLoaderService.createOAuth2Templates();
-                systemDataLoaderService.loadSystemLwm2mResources();
 //                systemDataLoaderService.loadSystemPlugins();
 //                systemDataLoaderService.loadSystemRules();
 

application/src/main/java/org/thingsboard/server/service/firmware/DefaultFirmwareStateService.java

@@ -0,0 +1,260 @@
+/**
+ * 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.service.firmware;
+
+import com.google.common.util.concurrent.FutureCallback;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.thingsboard.rule.engine.api.RuleEngineTelemetryService;
+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.Firmware;
+import org.thingsboard.server.common.data.FirmwareInfo;
+import org.thingsboard.server.common.data.id.DeviceId;
+import org.thingsboard.server.common.data.id.FirmwareId;
+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.BasicTsKvEntry;
+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.data.page.PageData;
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.msg.queue.TbCallback;
+import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
+import org.thingsboard.server.dao.device.DeviceProfileService;
+import org.thingsboard.server.dao.device.DeviceService;
+import org.thingsboard.server.dao.firmware.FirmwareService;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
+import org.thingsboard.server.queue.TbQueueProducer;
+import org.thingsboard.server.queue.common.TbProtoQueueMsg;
+import org.thingsboard.server.queue.provider.TbCoreQueueFactory;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+import static org.thingsboard.server.common.data.DataConstants.FIRMWARE_CHECKSUM;
+import static org.thingsboard.server.common.data.DataConstants.FIRMWARE_CHECKSUM_ALGORITHM;
+import static org.thingsboard.server.common.data.DataConstants.FIRMWARE_SIZE;
+import static org.thingsboard.server.common.data.DataConstants.FIRMWARE_TITLE;
+import static org.thingsboard.server.common.data.DataConstants.FIRMWARE_VERSION;
+
+@Slf4j
+@Service
+@TbCoreComponent
+public class DefaultFirmwareStateService implements FirmwareStateService {
+
+    private final FirmwareService firmwareService;
+    private final DeviceService deviceService;
+    private final DeviceProfileService deviceProfileService;
+    private final RuleEngineTelemetryService telemetryService;
+    private final TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> fwStateMsgProducer;
+
+    public DefaultFirmwareStateService(FirmwareService firmwareService,
+                                       DeviceService deviceService,
+                                       DeviceProfileService deviceProfileService,
+                                       RuleEngineTelemetryService telemetryService,
+                                       TbCoreQueueFactory coreQueueFactory) {
+        this.firmwareService = firmwareService;
+        this.deviceService = deviceService;
+        this.deviceProfileService = deviceProfileService;
+        this.telemetryService = telemetryService;
+        this.fwStateMsgProducer = coreQueueFactory.createToFirmwareStateServiceMsgProducer();
+    }
+
+    @Override
+    public void update(Device device, Device oldDevice) {
+        FirmwareId newFirmwareId = device.getFirmwareId();
+        if (newFirmwareId == null) {
+            DeviceProfile newDeviceProfile = deviceProfileService.findDeviceProfileById(device.getTenantId(), device.getDeviceProfileId());
+            newFirmwareId = newDeviceProfile.getFirmwareId();
+        }
+        if (oldDevice != null) {
+            if (newFirmwareId != null) {
+                FirmwareId oldFirmwareId = oldDevice.getFirmwareId();
+                if (oldFirmwareId == null) {
+                    DeviceProfile oldDeviceProfile = deviceProfileService.findDeviceProfileById(oldDevice.getTenantId(), oldDevice.getDeviceProfileId());
+                    oldFirmwareId = oldDeviceProfile.getFirmwareId();
+                }
+                if (!newFirmwareId.equals(oldFirmwareId)) {
+                    // Device was updated and new firmware is different from previous firmware.
+                    send(device.getTenantId(), device.getId(), newFirmwareId, System.currentTimeMillis());
+                }
+            } else {
+                // Device was updated and new firmware is not set.
+                remove(device);
+            }
+        } else if (newFirmwareId != null) {
+            // Device was created and firmware is defined.
+            send(device.getTenantId(), device.getId(), newFirmwareId, System.currentTimeMillis());
+        }
+    }
+
+    @Override
+    public void update(DeviceProfile deviceProfile) {
+        TenantId tenantId = deviceProfile.getTenantId();
+
+        Consumer<Device> updateConsumer;
+        if (deviceProfile.getFirmwareId() != null) {
+            long ts = System.currentTimeMillis();
+            updateConsumer = d -> send(d.getTenantId(), d.getId(), deviceProfile.getFirmwareId(), ts);
+        } else {
+            updateConsumer = this::remove;
+        }
+
+        PageLink pageLink = new PageLink(100);
+        PageData<Device> pageData;
+        do {
+            pageData = deviceService.findDevicesByTenantIdAndTypeAndEmptyFirmware(tenantId, deviceProfile.getName(), pageLink);
+
+            pageData.getData().forEach(updateConsumer);
+
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+    }
+
+    @Override
+    public boolean process(ToFirmwareStateServiceMsg msg) {
+        boolean isSuccess = false;
+        FirmwareId targetFirmwareId = new FirmwareId(new UUID(msg.getFirmwareIdMSB(), msg.getFirmwareIdLSB()));
+        DeviceId deviceId = new DeviceId(new UUID(msg.getDeviceIdMSB(), msg.getDeviceIdLSB()));
+        TenantId tenantId = new TenantId(new UUID(msg.getTenantIdMSB(), msg.getTenantIdLSB()));
+        long ts = msg.getTs();
+
+        Device device = deviceService.findDeviceById(tenantId, deviceId);
+        if (device == null) {
+            log.warn("[{}] [{}] Device was removed during firmware update msg was queued!", tenantId, deviceId);
+        } else {
+            FirmwareId currentFirmwareId = device.getFirmwareId();
+
+            if (currentFirmwareId == null) {
+                currentFirmwareId = deviceProfileService.findDeviceProfileById(tenantId, device.getDeviceProfileId()).getFirmwareId();
+            }
+
+            if (targetFirmwareId.equals(currentFirmwareId)) {
+                update(device, firmwareService.findFirmwareById(device.getTenantId(), targetFirmwareId), ts);
+                isSuccess = true;
+            } else {
+                log.warn("[{}] [{}] Can`t update firmware for the device, target firmwareId: [{}], current firmwareId: [{}]!", tenantId, deviceId, targetFirmwareId, currentFirmwareId);
+            }
+        }
+        return isSuccess;
+    }
+
+    private void send(TenantId tenantId, DeviceId deviceId, FirmwareId firmwareId, long ts) {
+        ToFirmwareStateServiceMsg msg = ToFirmwareStateServiceMsg.newBuilder()
+                .setTenantIdMSB(tenantId.getId().getMostSignificantBits())
+                .setTenantIdLSB(tenantId.getId().getLeastSignificantBits())
+                .setDeviceIdMSB(deviceId.getId().getMostSignificantBits())
+                .setDeviceIdLSB(deviceId.getId().getLeastSignificantBits())
+                .setFirmwareIdMSB(firmwareId.getId().getMostSignificantBits())
+                .setFirmwareIdLSB(firmwareId.getId().getLeastSignificantBits())
+                .setTs(ts)
+                .build();
+
+        FirmwareInfo firmware = firmwareService.findFirmwareInfoById(tenantId, firmwareId);
+        if (firmware == null) {
+            log.warn("[{}] Failed to send firmware update because firmware was already deleted", firmwareId);
+            return;
+        }
+
+        TopicPartitionInfo tpi = new TopicPartitionInfo(fwStateMsgProducer.getDefaultTopic(), null, null, false);
+        fwStateMsgProducer.send(tpi, new TbProtoQueueMsg<>(UUID.randomUUID(), msg), null);
+
+        List<TsKvEntry> telemetry = new ArrayList<>();
+        telemetry.add(new BasicTsKvEntry(ts, new StringDataEntry(DataConstants.TARGET_FIRMWARE_TITLE, firmware.getTitle())));
+        telemetry.add(new BasicTsKvEntry(ts, new StringDataEntry(DataConstants.TARGET_FIRMWARE_VERSION, firmware.getVersion())));
+        telemetry.add(new BasicTsKvEntry(ts, new StringDataEntry(DataConstants.FIRMWARE_STATE, FirmwareUpdateStatus.QUEUED.name())));
+
+        telemetryService.saveAndNotify(tenantId, deviceId, telemetry, new FutureCallback<>() {
+            @Override
+            public void onSuccess(@Nullable Void tmp) {
+                log.trace("[{}] Success save firmware status!", deviceId);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                log.error("[{}] Failed to save firmware status!", deviceId, t);
+            }
+        });
+    }
+
+
+    private void update(Device device, FirmwareInfo firmware, long ts) {
+        TenantId tenantId = device.getTenantId();
+        DeviceId deviceId = device.getId();
+
+        BasicTsKvEntry status = new BasicTsKvEntry(System.currentTimeMillis(), new StringDataEntry(DataConstants.FIRMWARE_STATE, FirmwareUpdateStatus.INITIATED.name()));
+
+        telemetryService.saveAndNotify(tenantId, deviceId, Collections.singletonList(status), new FutureCallback<>() {
+            @Override
+            public void onSuccess(@Nullable Void tmp) {
+                log.trace("[{}] Success save telemetry with target firmware for device!", deviceId);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                log.error("[{}] Failed to save telemetry with target firmware for device!", deviceId, t);
+            }
+        });
+
+        List<AttributeKvEntry> attributes = new ArrayList<>();
+
+        attributes.add(new BaseAttributeKvEntry(ts, new StringDataEntry(DataConstants.FIRMWARE_TITLE, firmware.getTitle())));
+        attributes.add(new BaseAttributeKvEntry(ts, new StringDataEntry(DataConstants.FIRMWARE_VERSION, firmware.getVersion())));
+
+        attributes.add(new BaseAttributeKvEntry(ts, new LongDataEntry(FIRMWARE_SIZE, firmware.getDataSize())));
+        attributes.add(new BaseAttributeKvEntry(ts, new StringDataEntry(DataConstants.FIRMWARE_CHECKSUM_ALGORITHM, firmware.getChecksumAlgorithm())));
+        attributes.add(new BaseAttributeKvEntry(ts, new StringDataEntry(DataConstants.FIRMWARE_CHECKSUM, firmware.getChecksum())));
+        telemetryService.saveAndNotify(tenantId, deviceId, DataConstants.SHARED_SCOPE, attributes, new FutureCallback<>() {
+            @Override
+            public void onSuccess(@Nullable Void tmp) {
+                log.trace("[{}] Success save attributes with target firmware!", deviceId);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                log.error("[{}] Failed to save attributes with target firmware!", deviceId, t);
+            }
+        });
+    }
+
+    private void remove(Device device) {
+        telemetryService.deleteAndNotify(device.getTenantId(), device.getId(), DataConstants.SHARED_SCOPE,
+                Arrays.asList(FIRMWARE_TITLE, FIRMWARE_VERSION, FIRMWARE_SIZE, FIRMWARE_CHECKSUM_ALGORITHM, FIRMWARE_CHECKSUM),
+                new FutureCallback<>() {
+                    @Override
+                    public void onSuccess(@Nullable Void tmp) {
+                        log.trace("[{}] Success remove target firmware attributes!", device.getId());
+                    }
+
+                    @Override
+                    public void onFailure(Throwable t) {
+                        log.error("[{}] Failed to remove target firmware attributes!", device.getId(), t);
+                    }
+                });
+    }
+}

application/src/main/java/org/thingsboard/server/service/firmware/FirmwareStateService.java

@@ -0,0 +1,30 @@
+/**
+ * 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.service.firmware;
+
+import org.thingsboard.server.common.data.Device;
+import org.thingsboard.server.common.data.DeviceProfile;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
+
+public interface FirmwareStateService {
+
+    void update(Device device, Device oldDevice);
+
+    void update(DeviceProfile deviceProfile);
+
+    boolean process(ToFirmwareStateServiceMsg msg);
+
+}

application/src/main/java/org/thingsboard/server/service/firmware/FirmwareUpdateStatus.java

@@ -0,0 +1,20 @@
+/**
+ * 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.service.firmware;
+
+public enum FirmwareUpdateStatus {
+    QUEUED, INITIATED, DOWNLOADING, DOWNLOADED, VERIFIED, UPDATING, UPDATED, FAILED
+}

application/src/main/java/org/thingsboard/server/service/install/DefaultSystemDataLoaderService.java

@@ -444,11 +444,6 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService {
         installScripts.loadSystemWidgets();
     }
 
-    @Override
-    public void loadSystemLwm2mResources() throws Exception {
-        installScripts.loadSystemLwm2mResources();
-    }
-
     private User createUser(Authority authority,
                             TenantId tenantId,
                             CustomerId customerId,

application/src/main/java/org/thingsboard/server/service/install/InstallScripts.java

@@ -22,8 +22,6 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;
 import org.thingsboard.server.common.data.Dashboard;
-import org.thingsboard.server.common.data.ResourceType;
-import org.thingsboard.server.common.data.TbResource;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -33,7 +31,6 @@ import org.thingsboard.server.common.data.rule.RuleChainMetaData;
 import org.thingsboard.server.common.data.widget.WidgetTypeDetails;
 import org.thingsboard.server.common.data.widget.WidgetsBundle;
 import org.thingsboard.server.dao.dashboard.DashboardService;
-import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.oauth2.OAuth2ConfigTemplateService;
 import org.thingsboard.server.dao.resource.ResourceService;
 import org.thingsboard.server.dao.rule.RuleChainService;
@@ -45,7 +42,6 @@ import java.nio.file.DirectoryStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
-import java.util.Base64;
 import java.util.Optional;
 
 import static org.thingsboard.server.service.install.DatabaseHelper.objectMapper;
@@ -210,29 +206,6 @@ public class InstallScripts {
         }
     }
 
-    public void loadSystemLwm2mResources() throws Exception {
-        Path modelsDir = Paths.get(getDataDir(), MODELS_DIR);
-        if (Files.isDirectory(modelsDir)) {
-            try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(modelsDir, path -> path.toString().endsWith(XML_EXT))) {
-                dirStream.forEach(
-                        path -> {
-                            try {
-                                byte[] fileBytes = Files.readAllBytes(path);
-                                TbResource resource = new TbResource();
-                                resource.setFileName(path.getFileName().toString());
-                                resource.setTenantId(TenantId.SYS_TENANT_ID);
-                                resource.setResourceType(ResourceType.LWM2M_MODEL);
-                                resource.setData(Base64.getEncoder().encodeToString(fileBytes));
-                                resourceService.saveResource(resource);
-                            } catch (Exception e) {
-                                throw new DataValidationException(String.format("Could not parse the XML of objectModel with name %s", path.toString()));
-                            }
-                        }
-                );
-            }
-        }
-    }
-
     public void loadDashboards(TenantId tenantId, CustomerId customerId) throws Exception {
         Path dashboardsDir = Paths.get(getDataDir(), JSON_DIR, DEMO_DIR, DASHBOARDS_DIR);
         try (DirectoryStream<Path> dirStream = Files.newDirectoryStream(dashboardsDir, path -> path.toString().endsWith(JSON_EXT))) {

application/src/main/java/org/thingsboard/server/service/install/SqlDatabaseUpgradeService.java

@@ -450,37 +450,19 @@ public class SqlDatabaseUpgradeService implements DatabaseEntitiesUpgradeService
                 try (Connection conn = DriverManager.getConnection(dbUrl, dbUserName, dbPassword)) {
                     log.info("Updating schema ...");
                     try {
-                        conn.createStatement().execute("CREATE TABLE IF NOT EXISTS resource ( " +
+                        conn.createStatement().execute("ALTER TABLE rule_chain ADD COLUMN type varchar(255) DEFAULT 'CORE'"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
-                                "id uuid NOT NULL CONSTRAINT resource_pkey PRIMARY KEY, " +
+                    } catch (Exception ignored) {
-                                "created_time bigint NOT NULL, " +
-                                "tenant_id uuid NOT NULL, " +
-                                "title varchar(255) NOT NULL, " +
-                                "resource_type varchar(32) NOT NULL, " +
-                                "resource_key varchar(255) NOT NULL, " +
-                                "search_text varchar(255), " +
-                                "file_name varchar(255) NOT NULL, " +
-                                "data varchar, " +
-                                "CONSTRAINT resource_unq_key UNIQUE (tenant_id, resource_type, resource_key)" +
-                                ");");
-
-                        conn.createStatement().execute("UPDATE tb_schema_settings SET schema_version = 3003000;");
-                        installScripts.loadSystemLwm2mResources();
-
-                        schemaUpdateFile = Paths.get(installScripts.getDataDir(), "upgrade", "3.2.2", SCHEMA_UPDATE_SQL);
-                        loadSql(schemaUpdateFile, conn);
-                        try {
-                            conn.createStatement().execute("ALTER TABLE rule_chain ADD COLUMN type varchar(255) DEFAULT 'CORE'"); //NOSONAR, ignoring because method used to execute thingsboard database upgrade script
-                        } catch (Exception ignored) {}
-
-                        log.info("Load Edge TTL functions ...");
-                        schemaUpdateFile = Paths.get(installScripts.getDataDir(), "upgrade", "3.2.2", "schema_update_ttl.sql");
-                        loadSql(schemaUpdateFile, conn);
-                        log.info("Edge TTL functions successfully loaded!");
-
-                    } catch (Exception e) {
-                        log.error("Failed updating schema!!!", e);
                     }
+                    schemaUpdateFile = Paths.get(installScripts.getDataDir(), "upgrade", "3.2.2", SCHEMA_UPDATE_SQL);
+                    loadSql(schemaUpdateFile, conn);
+                    log.info("Load Edge TTL functions ...");
+                    schemaUpdateFile = Paths.get(installScripts.getDataDir(), "upgrade", "3.2.2", "schema_update_ttl.sql");
+                    loadSql(schemaUpdateFile, conn);
+                    log.info("Edge TTL functions successfully loaded!");
+                    conn.createStatement().execute("UPDATE tb_schema_settings SET schema_version = 3003000;");
                     log.info("Schema updated.");
+                } catch (Exception e) {
+                    log.error("Failed updating schema!!!", e);
                 }
                 break;
             default:

application/src/main/java/org/thingsboard/server/service/install/SystemDataLoaderService.java

@@ -33,6 +33,4 @@ public interface SystemDataLoaderService {
 
     void deleteSystemWidgetBundle(String bundleAlias) throws Exception;
 
-    void loadSystemLwm2mResources() throws Exception;
-
 }

application/src/main/java/org/thingsboard/server/service/queue/DefaultTbCoreConsumerService.java

@@ -24,6 +24,7 @@ import org.springframework.context.event.EventListener;
 import org.springframework.core.annotation.Order;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
+import org.thingsboard.common.util.JacksonUtil;
 import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.rule.engine.api.RpcError;
 import org.thingsboard.server.actors.ActorSystemContext;
@@ -35,7 +36,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.common.stats.StatsFactory;
 import org.thingsboard.server.common.transport.util.DataDecodingEncodingService;
-import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceStateServiceMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.EdgeNotificationMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.FromDeviceRPCResponseProto;
@@ -49,6 +50,7 @@ import org.thingsboard.server.gen.transport.TransportProtos.TbSubscriptionCloseP
 import org.thingsboard.server.gen.transport.TransportProtos.TbTimeSeriesUpdateProto;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToUsageStatsServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportToDeviceActorMsg;
 import org.thingsboard.server.queue.TbQueueConsumer;
@@ -58,8 +60,8 @@ import org.thingsboard.server.queue.provider.TbCoreQueueFactory;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
 import org.thingsboard.server.service.edge.EdgeNotificationService;
+import org.thingsboard.server.service.firmware.FirmwareStateService;
 import org.thingsboard.server.service.profile.TbDeviceProfileCache;
-import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
 import org.thingsboard.server.service.queue.processing.AbstractConsumerService;
 import org.thingsboard.server.service.rpc.FromDeviceRpcResponse;
 import org.thingsboard.server.service.rpc.TbCoreDeviceRpcService;
@@ -97,6 +99,11 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
     @Value("${queue.core.stats.enabled:false}")
     private boolean statsEnabled;
 
+    @Value("${queue.core.firmware.pack-interval-ms:60000}")
+    private long firmwarePackInterval;
+    @Value("${queue.core.firmware.pack-size:100}")
+    private int firmwarePackSize;
+
     private final TbQueueConsumer<TbProtoQueueMsg<ToCoreMsg>> mainConsumer;
     private final DeviceStateService stateService;
     private final TbApiUsageStateService statsService;
@@ -104,11 +111,15 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
     private final SubscriptionManagerService subscriptionManagerService;
     private final TbCoreDeviceRpcService tbCoreDeviceRpcService;
     private final EdgeNotificationService edgeNotificationService;
+    private final FirmwareStateService firmwareStateService;
     private final TbCoreConsumerStats stats;
     protected final TbQueueConsumer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> usageStatsConsumer;
+    private final TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> firmwareStatesConsumer;
 
     protected volatile ExecutorService usageStatsExecutor;
 
+    private volatile ExecutorService firmwareStatesExecutor;
+
     public DefaultTbCoreConsumerService(TbCoreQueueFactory tbCoreQueueFactory,
                                         ActorSystemContext actorContext,
                                         DeviceStateService stateService,
@@ -121,10 +132,12 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
                                         TbApiUsageStateService statsService,
                                         TbTenantProfileCache tenantProfileCache,
                                         TbApiUsageStateService apiUsageStateService,
-                                        EdgeNotificationService edgeNotificationService) {
+                                        EdgeNotificationService edgeNotificationService,
+                                        FirmwareStateService firmwareStateService) {
         super(actorContext, encodingService, tenantProfileCache, deviceProfileCache, apiUsageStateService, tbCoreQueueFactory.createToCoreNotificationsMsgConsumer());
         this.mainConsumer = tbCoreQueueFactory.createToCoreMsgConsumer();
         this.usageStatsConsumer = tbCoreQueueFactory.createToUsageStatsServiceMsgConsumer();
+        this.firmwareStatesConsumer = tbCoreQueueFactory.createToFirmwareStateServiceMsgConsumer();
         this.stateService = stateService;
         this.localSubscriptionService = localSubscriptionService;
         this.subscriptionManagerService = subscriptionManagerService;
@@ -132,12 +145,14 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         this.edgeNotificationService = edgeNotificationService;
         this.stats = new TbCoreConsumerStats(statsFactory);
         this.statsService = statsService;
+        this.firmwareStateService = firmwareStateService;
     }
 
     @PostConstruct
     public void init() {
         super.init("tb-core-consumer", "tb-core-notifications-consumer");
-        this.usageStatsExecutor = Executors.newCachedThreadPool(ThingsBoardThreadFactory.forName("tb-core-usage-stats-consumer"));
+        this.usageStatsExecutor = Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-core-usage-stats-consumer"));
+        this.firmwareStatesExecutor = Executors.newSingleThreadExecutor(ThingsBoardThreadFactory.forName("tb-core-firmware-notifications-consumer"));
     }
 
     @PreDestroy
@@ -146,6 +161,9 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         if (usageStatsExecutor != null) {
             usageStatsExecutor.shutdownNow();
         }
+        if (firmwareStatesExecutor != null) {
+            firmwareStatesExecutor.shutdownNow();
+        }
     }
 
     @EventListener(ApplicationReadyEvent.class)
@@ -153,6 +171,7 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
     public void onApplicationEvent(ApplicationReadyEvent event) {
         super.onApplicationEvent(event);
         launchUsageStatsConsumer();
+        launchFirmwareUpdateNotificationConsumer();
     }
 
     @Override
@@ -167,6 +186,7 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
                             .map(tpi -> tpi.newByTopic(usageStatsConsumer.getTopic()))
                             .collect(Collectors.toSet()));
         }
+        this.firmwareStatesConsumer.subscribe();
     }
 
     @Override
@@ -336,10 +356,59 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         });
     }
 
+    private void launchFirmwareUpdateNotificationConsumer() {
+        long maxProcessingTimeoutPerRecord = firmwarePackInterval / firmwarePackSize;
+        firmwareStatesExecutor.submit(() -> {
+            while (!stopped) {
+                try {
+                    List<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> msgs = firmwareStatesConsumer.poll(getNotificationPollDuration());
+                    if (msgs.isEmpty()) {
+                        continue;
+                    }
+                    long timeToSleep = maxProcessingTimeoutPerRecord;
+                    for (TbProtoQueueMsg<ToFirmwareStateServiceMsg> msg : msgs) {
+                        try {
+                            long startTime = System.currentTimeMillis();
+                            boolean isSuccessUpdate = handleFirmwareUpdates(msg);
+                            long endTime = System.currentTimeMillis();
+                            long spentTime = endTime - startTime;
+                            timeToSleep = timeToSleep - spentTime;
+                            if (isSuccessUpdate) {
+                                if (timeToSleep > 0) {
+                                    log.debug("Spent time per record is: [{}]!", spentTime);
+                                    Thread.sleep(timeToSleep);
+                                    timeToSleep = 0;
+                                }
+                                timeToSleep += maxProcessingTimeoutPerRecord;
+                            }
+                        } catch (Throwable e) {
+                            log.warn("Failed to process firmware update msg: {}", msg, e);
+                        }
+                    }
+                    firmwareStatesConsumer.commit();
+                } catch (Exception e) {
+                    if (!stopped) {
+                        log.warn("Failed to obtain usage stats from queue.", e);
+                        try {
+                            Thread.sleep(getNotificationPollDuration());
+                        } catch (InterruptedException e2) {
+                            log.trace("Failed to wait until the server has capacity to handle new firmware updates", e2);
+                        }
+                    }
+                }
+            }
+            log.info("TB Firmware States Consumer stopped.");
+        });
+    }
+
     private void handleUsageStats(TbProtoQueueMsg<ToUsageStatsServiceMsg> msg, TbCallback callback) {
         statsService.process(msg, callback);
     }
 
+    private boolean handleFirmwareUpdates(TbProtoQueueMsg<ToFirmwareStateServiceMsg> msg) {
+        return firmwareStateService.process(msg.getValue());
+    }
+
     private void forwardToCoreRpcService(FromDeviceRPCResponseProto proto, TbCallback callback) {
         RpcError error = proto.getError() > 0 ? RpcError.values()[proto.getError()] : null;
         FromDeviceRpcResponse response = new FromDeviceRpcResponse(new UUID(proto.getRequestIdMSB(), proto.getRequestIdLSB())
@@ -448,6 +517,9 @@ public class DefaultTbCoreConsumerService extends AbstractConsumerService<ToCore
         if (usageStatsConsumer != null) {
             usageStatsConsumer.unsubscribe();
         }
+        if (firmwareStatesConsumer != null) {
+            firmwareStatesConsumer.unsubscribe();
+        }
     }
 
 }

application/src/main/java/org/thingsboard/server/service/resource/TbResourceService.java

@@ -31,7 +31,7 @@ public interface TbResourceService {
 
     TbResource saveResource(TbResource resource) throws ThingsboardException;
 
-    TbResource getResource(TenantId tenantId, ResourceType resourceType, String resourceId);
+    TbResource getResource(TenantId tenantId, ResourceType resourceType, String resourceKey);
 
     TbResource findResourceById(TenantId tenantId, TbResourceId resourceId);
 

application/src/main/java/org/thingsboard/server/service/security/permission/Resource.java

@@ -38,6 +38,7 @@ public enum Resource {
     DEVICE_PROFILE(EntityType.DEVICE_PROFILE),
     API_USAGE_STATE(EntityType.API_USAGE_STATE),
     TB_RESOURCE(EntityType.TB_RESOURCE),
+    FIRMWARE(EntityType.FIRMWARE),
     EDGE(EntityType.EDGE);
 
     private final EntityType entityType;

application/src/main/java/org/thingsboard/server/service/security/permission/TenantAdminPermissions.java

@@ -42,6 +42,7 @@ public class TenantAdminPermissions extends AbstractPermissions {
         put(Resource.DEVICE_PROFILE, tenantEntityPermissionChecker);
         put(Resource.API_USAGE_STATE, tenantEntityPermissionChecker);
         put(Resource.TB_RESOURCE, tbResourcePermissionChecker);
+        put(Resource.FIRMWARE, tenantEntityPermissionChecker);
         put(Resource.EDGE, tenantEntityPermissionChecker);
     }
 

application/src/main/java/org/thingsboard/server/service/transport/DefaultTransportApiService.java

@@ -23,16 +23,19 @@ import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.protobuf.ByteString;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.cache.CacheManager;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.cache.firmware.FirmwareCacheWriter;
 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.EntityType;
-import org.thingsboard.server.common.data.TbResource;
+import org.thingsboard.server.common.data.Firmware;
 import org.thingsboard.server.common.data.ResourceType;
+import org.thingsboard.server.common.data.TbResource;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.device.credentials.BasicMqttCredentials;
 import org.thingsboard.server.common.data.device.credentials.ProvisionDeviceCredentialsData;
@@ -40,6 +43,7 @@ import org.thingsboard.server.common.data.device.profile.ProvisionDeviceProfileC
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.FirmwareId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.security.DeviceCredentials;
@@ -55,6 +59,7 @@ import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.device.provision.ProvisionFailedException;
 import org.thingsboard.server.dao.device.provision.ProvisionRequest;
 import org.thingsboard.server.dao.device.provision.ProvisionResponse;
+import org.thingsboard.server.dao.firmware.FirmwareService;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.resource.ResourceService;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
@@ -66,7 +71,6 @@ import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFro
 import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetResourceRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceRequestMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.ProvisionResponseStatus;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
@@ -79,6 +83,7 @@ import org.thingsboard.server.service.apiusage.TbApiUsageStateService;
 import org.thingsboard.server.service.executors.DbCallbackExecutorService;
 import org.thingsboard.server.service.profile.TbDeviceProfileCache;
 import org.thingsboard.server.service.queue.TbClusterService;
+import org.thingsboard.server.service.resource.TbResourceService;
 import org.thingsboard.server.service.state.DeviceStateService;
 
 import java.util.Optional;
@@ -109,7 +114,9 @@ public class DefaultTransportApiService implements TransportApiService {
     private final TbClusterService tbClusterService;
     private final DataDecodingEncodingService dataDecodingEncodingService;
     private final DeviceProvisionService deviceProvisionService;
-    private final ResourceService resourceService;
+    private final TbResourceService resourceService;
+    private final FirmwareService firmwareService;
+    private final FirmwareCacheWriter firmwareCacheWriter;
 
     private final ConcurrentMap<String, ReentrantLock> deviceCreationLocks = new ConcurrentHashMap<>();
 
@@ -118,7 +125,7 @@ public class DefaultTransportApiService implements TransportApiService {
                                       RelationService relationService, DeviceCredentialsService deviceCredentialsService,
                                       DeviceStateService deviceStateService, DbCallbackExecutorService dbCallbackExecutorService,
                                       TbClusterService tbClusterService, DataDecodingEncodingService dataDecodingEncodingService,
-                                      DeviceProvisionService deviceProvisionService, ResourceService resourceService) {
+                                      DeviceProvisionService deviceProvisionService, TbResourceService resourceService, FirmwareService firmwareService, FirmwareCacheWriter firmwareCacheWriter) {
         this.deviceProfileCache = deviceProfileCache;
         this.tenantProfileCache = tenantProfileCache;
         this.apiUsageStateService = apiUsageStateService;
@@ -131,6 +138,8 @@ public class DefaultTransportApiService implements TransportApiService {
         this.dataDecodingEncodingService = dataDecodingEncodingService;
         this.deviceProvisionService = deviceProvisionService;
         this.resourceService = resourceService;
+        this.firmwareService = firmwareService;
+        this.firmwareCacheWriter = firmwareCacheWriter;
     }
 
     @Override
@@ -167,6 +176,9 @@ public class DefaultTransportApiService implements TransportApiService {
         } else if (transportApiRequestMsg.hasResourceRequestMsg()) {
             return Futures.transform(handle(transportApiRequestMsg.getResourceRequestMsg()),
                     value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
+        } else if (transportApiRequestMsg.hasFirmwareRequestMsg()) {
+            return Futures.transform(handle(transportApiRequestMsg.getFirmwareRequestMsg()),
+                    value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
         }
         return Futures.transform(getEmptyTransportApiResponseFuture(),
                 value -> new TbProtoQueueMsg<>(tbProtoQueueMsg.getKey(), value, tbProtoQueueMsg.getHeaders()), MoreExecutors.directExecutor());
@@ -314,14 +326,14 @@ public class DefaultTransportApiService implements TransportApiService {
         } catch (ProvisionFailedException e) {
             return Futures.immediateFuture(getTransportApiResponseMsg(
                     new DeviceCredentials(),
-                    TransportProtos.ProvisionResponseStatus.valueOf(e.getMessage())));
+                    TransportProtos.ResponseStatus.valueOf(e.getMessage())));
         }
-        return Futures.transform(provisionResponseFuture, provisionResponse -> getTransportApiResponseMsg(provisionResponse.getDeviceCredentials(), TransportProtos.ProvisionResponseStatus.SUCCESS),
+        return Futures.transform(provisionResponseFuture, provisionResponse -> getTransportApiResponseMsg(provisionResponse.getDeviceCredentials(), TransportProtos.ResponseStatus.SUCCESS),
                 dbCallbackExecutorService);
     }
 
-    private TransportApiResponseMsg getTransportApiResponseMsg(DeviceCredentials deviceCredentials, TransportProtos.ProvisionResponseStatus status) {
+    private TransportApiResponseMsg getTransportApiResponseMsg(DeviceCredentials deviceCredentials, TransportProtos.ResponseStatus status) {
-        if (!status.equals(ProvisionResponseStatus.SUCCESS)) {
+        if (!status.equals(TransportProtos.ResponseStatus.SUCCESS)) {
             return TransportApiResponseMsg.newBuilder().setProvisionDeviceResponseMsg(TransportProtos.ProvisionDeviceResponseMsg.newBuilder().setStatus(status).build()).build();
         }
         TransportProtos.ProvisionDeviceResponseMsg.Builder provisionResponse = TransportProtos.ProvisionDeviceResponseMsg.newBuilder()
@@ -441,6 +453,48 @@ public class DefaultTransportApiService implements TransportApiService {
         }
     }
 
+    private ListenableFuture<TransportApiResponseMsg> handle(TransportProtos.GetFirmwareRequestMsg requestMsg) {
+        TenantId tenantId = new TenantId(new UUID(requestMsg.getTenantIdMSB(), requestMsg.getTenantIdLSB()));
+        DeviceId deviceId = new DeviceId(new UUID(requestMsg.getDeviceIdMSB(), requestMsg.getDeviceIdLSB()));
+        Device device = deviceService.findDeviceById(tenantId, deviceId);
+
+        if (device == null) {
+            return getEmptyTransportApiResponseFuture();
+        }
+
+        FirmwareId firmwareId = device.getFirmwareId();
+
+        if (firmwareId == null) {
+            firmwareId = deviceProfileCache.find(device.getDeviceProfileId()).getFirmwareId();
+        }
+
+        TransportProtos.GetFirmwareResponseMsg.Builder builder = TransportProtos.GetFirmwareResponseMsg.newBuilder();
+
+        if (firmwareId == null) {
+            builder.setResponseStatus(TransportProtos.ResponseStatus.NOT_FOUND);
+        } else {
+            Firmware firmware = firmwareService.findFirmwareById(tenantId, firmwareId);
+
+            if (firmware == null) {
+                builder.setResponseStatus(TransportProtos.ResponseStatus.NOT_FOUND);
+            } else {
+                builder.setResponseStatus(TransportProtos.ResponseStatus.SUCCESS);
+                builder.setFirmwareIdMSB(firmwareId.getId().getMostSignificantBits());
+                builder.setFirmwareIdLSB(firmwareId.getId().getLeastSignificantBits());
+                builder.setTitle(firmware.getTitle());
+                builder.setVersion(firmware.getVersion());
+                builder.setFileName(firmware.getFileName());
+                builder.setContentType(firmware.getContentType());
+                firmwareCacheWriter.put(firmwareId.toString(), firmware.getData().array());
+            }
+        }
+
+        return Futures.immediateFuture(
+                TransportApiResponseMsg.newBuilder()
+                        .setFirmwareResponseMsg(builder.build())
+                        .build());
+    }
+
     private ListenableFuture<TransportApiResponseMsg> handleRegistration(TransportProtos.LwM2MRegistrationRequestMsg msg) {
         TenantId tenantId = new TenantId(UUID.fromString(msg.getTenantId()));
         String deviceName = msg.getEndpoint();

application/src/main/resources/thingsboard.yml

@@ -371,6 +371,9 @@ caffeine:
     tokensOutdatageTime:
       timeToLiveInMinutes: 20000
       maxSize: 10000
+    firmwares:
+      timeToLiveInMinutes: 1440
+      maxSize: 100
     edges:
       timeToLiveInMinutes: 1440
       maxSize: 0
@@ -446,6 +449,9 @@ spring.resources.chain:
     content:
       enabled: "true"
 
+spring.servlet.multipart.max-file-size: "50MB"
+spring.servlet.multipart.max-request-size: "50MB"
+
 spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation: "true"
 spring.jpa.properties.hibernate.order_by.default_null_ordering: "last"
 
@@ -738,6 +744,10 @@ queue:
       sasl.mechanism: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_MECHANISM:PLAIN}"
       sasl.config: "${TB_QUEUE_KAFKA_CONFLUENT_SASL_JAAS_CONFIG:org.apache.kafka.common.security.plain.PlainLoginModule required username=\"CLUSTER_API_KEY\" password=\"CLUSTER_API_SECRET\";}"
       security.protocol: "${TB_QUEUE_KAFKA_CONFLUENT_SECURITY_PROTOCOL:SASL_SSL}"
+    consumer-properties-per-topic:
+      tb_firmware:
+        - key: max.poll.records
+          value: 10
     other:
     topic-properties:
       rule-engine: "${TB_QUEUE_KAFKA_RE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;min.insync.replicas:1}"
@@ -745,6 +755,7 @@ queue:
       transport-api: "${TB_QUEUE_KAFKA_TA_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;min.insync.replicas:1}"
       notifications: "${TB_QUEUE_KAFKA_NOTIFICATIONS_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:1;min.insync.replicas:1}"
       js-executor: "${TB_QUEUE_KAFKA_JE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:104857600;partitions:100;min.insync.replicas:1}"
+      fw-updates: "${TB_QUEUE_KAFKA_FW_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000;partitions:10;min.insync.replicas:1}"
     consumer-stats:
       enabled: "${TB_QUEUE_KAFKA_CONSUMER_STATS_ENABLED:true}"
       print-interval-ms: "${TB_QUEUE_KAFKA_CONSUMER_STATS_MIN_PRINT_INTERVAL_MS:60000}"
@@ -815,6 +826,10 @@ queue:
     poll-interval: "${TB_QUEUE_CORE_POLL_INTERVAL_MS:25}"
     partitions: "${TB_QUEUE_CORE_PARTITIONS:10}"
     pack-processing-timeout: "${TB_QUEUE_CORE_PACK_PROCESSING_TIMEOUT_MS:2000}"
+    firmware:
+      topic: "${TB_QUEUE_CORE_FW_TOPIC:tb_firmware}"
+      pack-interval-ms: "${TB_QUEUE_CORE_FW_PACK_INTERVAL_MS:60000}"
+      pack-size: "${TB_QUEUE_CORE_FW_PACK_SIZE:100}"
     usage-stats-topic: "${TB_QUEUE_US_TOPIC:tb_usage_stats}"
     stats:
       enabled: "${TB_QUEUE_CORE_STATS_ENABLED:true}"

application/src/test/java/org/thingsboard/server/controller/BaseFirmwareControllerTest.java

@@ -0,0 +1,302 @@
+/**
+ * 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.controller;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.test.web.servlet.request.MockMultipartHttpServletRequestBuilder;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
+import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.common.data.FirmwareInfo;
+import org.thingsboard.server.common.data.Tenant;
+import org.thingsboard.server.common.data.User;
+import org.thingsboard.server.common.data.page.PageData;
+import org.thingsboard.server.common.data.page.PageLink;
+import org.thingsboard.server.common.data.security.Authority;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+public abstract class BaseFirmwareControllerTest extends AbstractControllerTest {
+
+    private IdComparator<FirmwareInfo> idComparator = new IdComparator<>();
+
+    public static final String TITLE = "My firmware";
+    private static final String FILE_NAME = "filename.txt";
+    private static final String VERSION = "v1.0";
+    private static final String CONTENT_TYPE = "text/plain";
+    private static final String CHECKSUM_ALGORITHM = "sha256";
+    private static final String CHECKSUM = "4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a";
+    private static final ByteBuffer DATA = ByteBuffer.wrap(new byte[]{1});
+
+    private Tenant savedTenant;
+    private User tenantAdmin;
+
+    @Before
+    public void beforeTest() throws Exception {
+        loginSysAdmin();
+
+        Tenant tenant = new Tenant();
+        tenant.setTitle("My tenant");
+        savedTenant = doPost("/api/tenant", tenant, Tenant.class);
+        Assert.assertNotNull(savedTenant);
+
+        tenantAdmin = new User();
+        tenantAdmin.setAuthority(Authority.TENANT_ADMIN);
+        tenantAdmin.setTenantId(savedTenant.getId());
+        tenantAdmin.setEmail("tenant2@thingsboard.org");
+        tenantAdmin.setFirstName("Joe");
+        tenantAdmin.setLastName("Downs");
+
+        tenantAdmin = createUserAndLogin(tenantAdmin, "testPassword1");
+    }
+
+    @After
+    public void afterTest() throws Exception {
+        loginSysAdmin();
+
+        doDelete("/api/tenant/" + savedTenant.getId().getId().toString())
+                .andExpect(status().isOk());
+    }
+
+    @Test
+    public void testSaveFirmware() throws Exception {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+
+        FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+        Assert.assertNotNull(savedFirmwareInfo);
+        Assert.assertNotNull(savedFirmwareInfo.getId());
+        Assert.assertTrue(savedFirmwareInfo.getCreatedTime() > 0);
+        Assert.assertEquals(savedTenant.getId(), savedFirmwareInfo.getTenantId());
+        Assert.assertEquals(firmwareInfo.getTitle(), savedFirmwareInfo.getTitle());
+        Assert.assertEquals(firmwareInfo.getVersion(), savedFirmwareInfo.getVersion());
+
+        savedFirmwareInfo.setAdditionalInfo(JacksonUtil.newObjectNode());
+
+        save(savedFirmwareInfo);
+
+        FirmwareInfo foundFirmwareInfo = doGet("/api/firmware/info/" + savedFirmwareInfo.getId().getId().toString(), FirmwareInfo.class);
+        Assert.assertEquals(foundFirmwareInfo.getTitle(), savedFirmwareInfo.getTitle());
+    }
+
+    @Test
+    public void testSaveFirmwareData() throws Exception {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+
+        FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+        Assert.assertNotNull(savedFirmwareInfo);
+        Assert.assertNotNull(savedFirmwareInfo.getId());
+        Assert.assertTrue(savedFirmwareInfo.getCreatedTime() > 0);
+        Assert.assertEquals(savedTenant.getId(), savedFirmwareInfo.getTenantId());
+        Assert.assertEquals(firmwareInfo.getTitle(), savedFirmwareInfo.getTitle());
+        Assert.assertEquals(firmwareInfo.getVersion(), savedFirmwareInfo.getVersion());
+
+        savedFirmwareInfo.setAdditionalInfo(JacksonUtil.newObjectNode());
+
+        save(savedFirmwareInfo);
+
+        FirmwareInfo foundFirmwareInfo = doGet("/api/firmware/info/" + savedFirmwareInfo.getId().getId().toString(), FirmwareInfo.class);
+        Assert.assertEquals(foundFirmwareInfo.getTitle(), savedFirmwareInfo.getTitle());
+
+        MockMultipartFile testData = new MockMultipartFile("file", FILE_NAME, CONTENT_TYPE, DATA.array());
+
+        Firmware savedFirmware = savaData("/api/firmware/" + savedFirmwareInfo.getId().getId().toString() + "?checksum={checksum}&checksumAlgorithm={checksumAlgorithm}", testData, CHECKSUM, CHECKSUM_ALGORITHM);
+
+        Assert.assertEquals(FILE_NAME, savedFirmware.getFileName());
+        Assert.assertEquals(CONTENT_TYPE, savedFirmware.getContentType());
+    }
+
+    @Test
+    public void testUpdateFirmwareFromDifferentTenant() throws Exception {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+
+        FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+        loginDifferentTenant();
+        doPost("/api/firmware", savedFirmwareInfo, FirmwareInfo.class, status().isForbidden());
+        deleteDifferentTenant();
+    }
+
+    @Test
+    public void testFindFirmwareInfoById() throws Exception {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+
+        FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+        FirmwareInfo foundFirmware = doGet("/api/firmware/info/" + savedFirmwareInfo.getId().getId().toString(), FirmwareInfo.class);
+        Assert.assertNotNull(foundFirmware);
+        Assert.assertEquals(savedFirmwareInfo, foundFirmware);
+    }
+
+    @Test
+    public void testFindFirmwareById() throws Exception {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+
+        FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+        MockMultipartFile testData = new MockMultipartFile("file", FILE_NAME, CONTENT_TYPE, DATA.array());
+
+        Firmware savedFirmware = savaData("/api/firmware/" + savedFirmwareInfo.getId().getId().toString() + "?checksum={checksum}&checksumAlgorithm={checksumAlgorithm}", testData, CHECKSUM, CHECKSUM_ALGORITHM);
+
+        Firmware foundFirmware = doGet("/api/firmware/" + savedFirmwareInfo.getId().getId().toString(), Firmware.class);
+        Assert.assertNotNull(foundFirmware);
+        Assert.assertEquals(savedFirmware, foundFirmware);
+    }
+
+    @Test
+    public void testDeleteFirmware() throws Exception {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+
+        FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+        doDelete("/api/firmware/" + savedFirmwareInfo.getId().getId().toString())
+                .andExpect(status().isOk());
+
+        doGet("/api/firmware/info/" + savedFirmwareInfo.getId().getId().toString())
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    public void testFindTenantFirmwares() throws Exception {
+        List<FirmwareInfo> firmwares = new ArrayList<>();
+        for (int i = 0; i < 165; i++) {
+            FirmwareInfo firmwareInfo = new FirmwareInfo();
+            firmwareInfo.setTitle(TITLE);
+            firmwareInfo.setVersion(VERSION + i);
+
+            FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+            if (i > 100) {
+                MockMultipartFile testData = new MockMultipartFile("file", FILE_NAME, CONTENT_TYPE, DATA.array());
+
+                Firmware savedFirmware = savaData("/api/firmware/" + savedFirmwareInfo.getId().getId().toString() + "?checksum={checksum}&checksumAlgorithm={checksumAlgorithm}", testData, CHECKSUM, CHECKSUM_ALGORITHM);
+                firmwares.add(new FirmwareInfo(savedFirmware));
+            } else {
+                firmwares.add(savedFirmwareInfo);
+            }
+        }
+
+        List<FirmwareInfo> loadedFirmwares = new ArrayList<>();
+        PageLink pageLink = new PageLink(24);
+        PageData<FirmwareInfo> pageData;
+        do {
+            pageData = doGetTypedWithPageLink("/api/firmwares?",
+                    new TypeReference<>() {
+                    }, pageLink);
+            loadedFirmwares.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(firmwares, idComparator);
+        Collections.sort(loadedFirmwares, idComparator);
+
+        Assert.assertEquals(firmwares, loadedFirmwares);
+    }
+
+    @Test
+    public void testFindTenantFirmwaresByHasData() throws Exception {
+        List<FirmwareInfo> firmwaresWithData = new ArrayList<>();
+        List<FirmwareInfo> firmwaresWithoutData = new ArrayList<>();
+
+        for (int i = 0; i < 165; i++) {
+            FirmwareInfo firmwareInfo = new FirmwareInfo();
+            firmwareInfo.setTitle(TITLE);
+            firmwareInfo.setVersion(VERSION + i);
+
+            FirmwareInfo savedFirmwareInfo = save(firmwareInfo);
+
+            if (i > 100) {
+                MockMultipartFile testData = new MockMultipartFile("file", FILE_NAME, CONTENT_TYPE, DATA.array());
+
+                Firmware savedFirmware = savaData("/api/firmware/" + savedFirmwareInfo.getId().getId().toString() + "?checksum={checksum}&checksumAlgorithm={checksumAlgorithm}", testData, CHECKSUM, CHECKSUM_ALGORITHM);
+                firmwaresWithData.add(new FirmwareInfo(savedFirmware));
+            } else {
+                firmwaresWithoutData.add(savedFirmwareInfo);
+            }
+        }
+
+        List<FirmwareInfo> loadedFirmwaresWithData = new ArrayList<>();
+        PageLink pageLink = new PageLink(24);
+        PageData<FirmwareInfo> pageData;
+        do {
+            pageData = doGetTypedWithPageLink("/api/firmwares/true?",
+                    new TypeReference<>() {
+                    }, pageLink);
+            loadedFirmwaresWithData.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        List<FirmwareInfo> loadedFirmwaresWithoutData = new ArrayList<>();
+        pageLink = new PageLink(24);
+        do {
+            pageData = doGetTypedWithPageLink("/api/firmwares/false?",
+                    new TypeReference<>() {
+                    }, pageLink);
+            loadedFirmwaresWithoutData.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(firmwaresWithData, idComparator);
+        Collections.sort(firmwaresWithoutData, idComparator);
+        Collections.sort(loadedFirmwaresWithData, idComparator);
+        Collections.sort(loadedFirmwaresWithoutData, idComparator);
+
+        Assert.assertEquals(firmwaresWithData, loadedFirmwaresWithData);
+        Assert.assertEquals(firmwaresWithoutData, loadedFirmwaresWithoutData);
+    }
+
+
+    private FirmwareInfo save(FirmwareInfo firmwareInfo) throws Exception {
+        return doPost("/api/firmware", firmwareInfo, FirmwareInfo.class);
+    }
+
+    protected Firmware savaData(String urlTemplate, MockMultipartFile content, String... params) throws Exception {
+        MockMultipartHttpServletRequestBuilder postRequest = MockMvcRequestBuilders.multipart(urlTemplate, params);
+        postRequest.file(content);
+        setJwtToken(postRequest);
+        return readResponse(mockMvc.perform(postRequest).andExpect(status().isOk()), Firmware.class);
+    }
+
+}

application/src/test/java/org/thingsboard/server/controller/sql/FirmwareControllerSqlTest.java

@@ -0,0 +1,23 @@
+/**
+ * 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.controller.sql;
+
+import org.thingsboard.server.controller.BaseFirmwareControllerTest;
+import org.thingsboard.server.dao.service.DaoSqlTest;
+
+@DaoSqlTest
+public class FirmwareControllerSqlTest extends BaseFirmwareControllerTest {
+}

common/cache/src/main/java/org/thingsboard/server/cache/firmware/AbstractRedisFirmwareCache.java

@@ -0,0 +1,33 @@
+/**
+ * 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.cache.firmware;
+
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+
+import static org.thingsboard.server.common.data.CacheConstants.FIRMWARE_CACHE;
+
+public abstract class AbstractRedisFirmwareCache {
+
+    protected final RedisConnectionFactory redisConnectionFactory;
+
+    protected AbstractRedisFirmwareCache(RedisConnectionFactory redisConnectionFactory) {
+        this.redisConnectionFactory = redisConnectionFactory;
+    }
+
+    protected byte[] toFirmwareCacheKey(String key) {
+        return String.format("%s::%s", FIRMWARE_CACHE, key).getBytes();
+    }
+}

common/cache/src/main/java/org/thingsboard/server/cache/firmware/CaffeineFirmwareCacheReader.java

@@ -0,0 +1,60 @@
+/**
+ * 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.cache.firmware;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.cache.CacheManager;
+import org.springframework.stereotype.Service;
+
+import static org.thingsboard.server.common.data.CacheConstants.FIRMWARE_CACHE;
+
+@Service
+@ConditionalOnExpression("(('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true') || '${service.type:null}'=='tb-transport') && ('${cache.type:null}'=='caffeine' || '${cache.type:null}'=='null')")
+public class CaffeineFirmwareCacheReader implements FirmwareCacheReader {
+
+    private final CacheManager cacheManager;
+
+    public CaffeineFirmwareCacheReader(CacheManager cacheManager) {
+        this.cacheManager = cacheManager;
+    }
+
+    @Override
+    public byte[] get(String key) {
+        return get(key, 0, 0);
+    }
+
+    @Override
+    public byte[] get(String key, int chunkSize, int chunk) {
+        byte[] data = cacheManager.getCache(FIRMWARE_CACHE).get(key, byte[].class);
+
+        if (chunkSize < 1) {
+            return data;
+        }
+
+        if (data != null && data.length > 0) {
+            int startIndex = chunkSize * chunk;
+
+            int size = Math.min(data.length - startIndex, chunkSize);
+
+            if (startIndex < data.length && size > 0) {
+                byte[] result = new byte[size];
+                System.arraycopy(data, startIndex, result, 0, size);
+                return result;
+            }
+        }
+        return new byte[0];
+    }
+}

common/cache/src/main/java/org/thingsboard/server/cache/firmware/CaffeineFirmwareCacheWriter.java

@@ -0,0 +1,38 @@
+/**
+ * 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.cache.firmware;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.cache.CacheManager;
+import org.springframework.stereotype.Service;
+
+import static org.thingsboard.server.common.data.CacheConstants.FIRMWARE_CACHE;
+
+@Service
+@ConditionalOnExpression("('${service.type:null}'=='monolith' || '${service.type:null}'=='tb-core') && ('${cache.type:null}'=='caffeine' || '${cache.type:null}'=='null')")
+public class CaffeineFirmwareCacheWriter implements FirmwareCacheWriter {
+
+    private final CacheManager cacheManager;
+
+    public CaffeineFirmwareCacheWriter(CacheManager cacheManager) {
+        this.cacheManager = cacheManager;
+    }
+
+    @Override
+    public void put(String key, byte[] value) {
+        cacheManager.getCache(FIRMWARE_CACHE).putIfAbsent(key, value);
+    }
+}

common/cache/src/main/java/org/thingsboard/server/cache/firmware/FirmwareCacheReader.java

@@ -0,0 +1,22 @@
+/**
+ * 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.cache.firmware;
+
+public interface FirmwareCacheReader {
+    byte[] get(String key);
+
+    byte[] get(String key, int chunkSize, int chunk);
+}

common/cache/src/main/java/org/thingsboard/server/cache/firmware/FirmwareCacheWriter.java

@@ -0,0 +1,20 @@
+/**
+ * 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.cache.firmware;
+
+public interface FirmwareCacheWriter {
+    void put(String key, byte[] value);
+}

common/cache/src/main/java/org/thingsboard/server/cache/firmware/RedisFirmwareCacheReader.java

@@ -0,0 +1,49 @@
+/**
+ * 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.cache.firmware;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.stereotype.Service;
+
+@Service
+@ConditionalOnExpression("(('${service.type:null}'=='monolith' && '${transport.api_enabled:true}'=='true') || '${service.type:null}'=='tb-transport') && '${cache.type:null}'=='redis'")
+public class RedisFirmwareCacheReader extends AbstractRedisFirmwareCache implements FirmwareCacheReader {
+
+    public RedisFirmwareCacheReader(RedisConnectionFactory redisConnectionFactory) {
+        super(redisConnectionFactory);
+    }
+
+    @Override
+    public byte[] get(String key) {
+        return get(key, 0, 0);
+    }
+
+    @Override
+    public byte[] get(String key, int chunkSize, int chunk) {
+        try (RedisConnection connection = redisConnectionFactory.getConnection()) {
+            if (chunkSize == 0) {
+                return connection.get(toFirmwareCacheKey(key));
+            }
+
+            int startIndex = chunkSize * chunk;
+            int endIndex = startIndex + chunkSize - 1;
+            return connection.getRange(toFirmwareCacheKey(key), startIndex, endIndex);
+        }
+    }
+
+}

common/cache/src/main/java/org/thingsboard/server/cache/firmware/RedisFirmwareCacheWriter.java

@@ -0,0 +1,38 @@
+/**
+ * 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.cache.firmware;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.stereotype.Service;
+
+@Service
+@ConditionalOnExpression("('${service.type:null}'=='monolith' || '${service.type:null}'=='tb-core') && '${cache.type:null}'=='redis'")
+public class RedisFirmwareCacheWriter extends AbstractRedisFirmwareCache implements FirmwareCacheWriter {
+
+    public RedisFirmwareCacheWriter(RedisConnectionFactory redisConnectionFactory) {
+        super(redisConnectionFactory);
+    }
+
+    @Override
+    public void put(String key, byte[] value) {
+        try (RedisConnection connection = redisConnectionFactory.getConnection()) {
+            connection.set(toFirmwareCacheKey(key), value);
+        }
+    }
+
+}

common/dao-api/src/main/java/org/thingsboard/server/dao/device/DeviceService.java

@@ -61,6 +61,8 @@ public interface DeviceService {
 
     PageData<Device> findDevicesByTenantIdAndType(TenantId tenantId, String type, PageLink pageLink);
 
+    PageData<Device> findDevicesByTenantIdAndTypeAndEmptyFirmware(TenantId tenantId, String type, PageLink pageLink);
+
     PageData<DeviceInfo> findDeviceInfosByTenantIdAndType(TenantId tenantId, String type, PageLink pageLink);
 
     PageData<DeviceInfo> findDeviceInfosByTenantIdAndDeviceProfileId(TenantId tenantId, DeviceProfileId deviceProfileId, PageLink pageLink);

common/dao-api/src/main/java/org/thingsboard/server/dao/firmware/FirmwareService.java

@@ -0,0 +1,42 @@
+/**
+ * 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.dao.firmware;
+
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.common.data.FirmwareInfo;
+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;
+
+public interface FirmwareService {
+
+    FirmwareInfo saveFirmwareInfo(FirmwareInfo firmwareInfo);
+
+    Firmware saveFirmware(Firmware firmware);
+
+    Firmware findFirmwareById(TenantId tenantId, FirmwareId firmwareId);
+
+    FirmwareInfo findFirmwareInfoById(TenantId tenantId, FirmwareId firmwareId);
+
+    PageData<FirmwareInfo> findTenantFirmwaresByTenantId(TenantId tenantId, PageLink pageLink);
+
+    PageData<FirmwareInfo> findTenantFirmwaresByTenantIdAndHasData(TenantId tenantId, boolean hasData, PageLink pageLink);
+
+    void deleteFirmware(TenantId tenantId, FirmwareId firmwareId);
+
+    void deleteFirmwaresByTenantId(TenantId tenantId);
+}

common/data/src/main/java/org/thingsboard/server/common/data/CacheConstants.java

@@ -29,4 +29,5 @@ public class CacheConstants {
     public static final String DEVICE_PROFILE_CACHE = "deviceProfiles";
     public static final String ATTRIBUTES_CACHE = "attributes";
     public static final String TOKEN_OUTDATAGE_TIME_CACHE = "tokensOutdatageTime";
+    public static final String FIRMWARE_CACHE = "firmwares";
 }

common/data/src/main/java/org/thingsboard/server/common/data/DataConstants.java

@@ -93,6 +93,21 @@ public class DataConstants {
     public static final String USERNAME = "username";
     public static final String PASSWORD = "password";
 
+    //firmware
+    //telemetry
+    public static final String CURRENT_FIRMWARE_TITLE = "cur_fw_title";
+    public static final String CURRENT_FIRMWARE_VERSION = "cur_fw_version";
+    public static final String TARGET_FIRMWARE_TITLE = "target_fw_title";
+    public static final String TARGET_FIRMWARE_VERSION = "target_fw_version";
+    public static final String FIRMWARE_STATE = "fw_state";
+
+    //attributes
+    //telemetry
+    public static final String FIRMWARE_TITLE = "fw_title";
+    public static final String FIRMWARE_VERSION = "fw_version";
+    public static final String FIRMWARE_SIZE = "fw_size";
+    public static final String FIRMWARE_CHECKSUM = "fw_checksum";
+    public static final String FIRMWARE_CHECKSUM_ALGORITHM = "fw_checksum_algorithm";
     public static final String EDGE_MSG_SOURCE = "edge";
     public static final String MSG_SOURCE_KEY = "source";
 }

common/data/src/main/java/org/thingsboard/server/common/data/Device.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.data.device.data.DeviceData;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.FirmwareId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.validation.NoXss;
 
@@ -48,6 +49,8 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
     @JsonIgnore
     private byte[] deviceDataBytes;
 
+    private FirmwareId firmwareId;
+
     public Device() {
         super();
     }
@@ -65,6 +68,7 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
         this.label = device.getLabel();
         this.deviceProfileId = device.getDeviceProfileId();
         this.setDeviceData(device.getDeviceData());
+        this.firmwareId = device.getFirmwareId();
     }
 
     public Device updateDevice(Device device) {
@@ -159,6 +163,14 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
         return getName();
     }
 
+    public FirmwareId getFirmwareId() {
+        return firmwareId;
+    }
+
+    public void setFirmwareId(FirmwareId firmwareId) {
+        this.firmwareId = firmwareId;
+    }
+
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder();
@@ -175,6 +187,8 @@ public class Device extends SearchTextBasedWithAdditionalInfo<DeviceId> implemen
         builder.append(", deviceProfileId=");
         builder.append(deviceProfileId);
         builder.append(", deviceData=");
+        builder.append(firmwareId);
+        builder.append(", firmwareId=");
         builder.append(deviceData);
         builder.append(", additionalInfo=");
         builder.append(getAdditionalInfo());

common/data/src/main/java/org/thingsboard/server/common/data/DeviceProfile.java

@@ -22,6 +22,7 @@ import lombok.EqualsAndHashCode;
 import lombok.extern.slf4j.Slf4j;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.FirmwareId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.validation.NoXss;
@@ -56,6 +57,8 @@ public class DeviceProfile extends SearchTextBased<DeviceProfileId> implements H
     @NoXss
     private String provisionDeviceKey;
 
+    private FirmwareId firmwareId;
+
     public DeviceProfile() {
         super();
     }

common/data/src/main/java/org/thingsboard/server/common/data/EntityType.java

@@ -19,5 +19,5 @@ package org.thingsboard.server.common.data;
  * @author Andrew Shvayka
  */
 public enum EntityType {
-    TENANT, CUSTOMER, USER, DASHBOARD, ASSET, DEVICE, ALARM, RULE_CHAIN, RULE_NODE, ENTITY_VIEW, WIDGETS_BUNDLE, WIDGET_TYPE, TENANT_PROFILE, DEVICE_PROFILE, API_USAGE_STATE, TB_RESOURCE, EDGE;
+    TENANT, CUSTOMER, USER, DASHBOARD, ASSET, DEVICE, ALARM, RULE_CHAIN, RULE_NODE, ENTITY_VIEW, WIDGETS_BUNDLE, WIDGET_TYPE, TENANT_PROFILE, DEVICE_PROFILE, API_USAGE_STATE, TB_RESOURCE, FIRMWARE, EDGE;
 }

common/data/src/main/java/org/thingsboard/server/common/data/Firmware.java

@@ -0,0 +1,44 @@
+/**
+ * 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;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.id.FirmwareId;
+
+import java.nio.ByteBuffer;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class Firmware extends FirmwareInfo {
+
+    private static final long serialVersionUID = 3091601761339422546L;
+
+    private transient ByteBuffer data;
+
+    public Firmware() {
+        super();
+    }
+
+    public Firmware(FirmwareId id) {
+        super(id);
+    }
+
+    public Firmware(Firmware firmware) {
+        super(firmware);
+        this.data = firmware.getData();
+    }
+}

common/data/src/main/java/org/thingsboard/server/common/data/FirmwareInfo.java

@@ -0,0 +1,67 @@
+/**
+ * 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;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.extern.slf4j.Slf4j;
+import org.thingsboard.server.common.data.id.FirmwareId;
+import org.thingsboard.server.common.data.id.TenantId;
+
+@Slf4j
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class FirmwareInfo extends SearchTextBasedWithAdditionalInfo<FirmwareId> implements HasTenantId {
+
+    private static final long serialVersionUID = 3168391583570815419L;
+
+    private TenantId tenantId;
+    private String title;
+    private String version;
+    private boolean hasData;
+    private String fileName;
+    private String contentType;
+    private String checksumAlgorithm;
+    private String checksum;
+    private Long dataSize;
+
+
+    public FirmwareInfo() {
+        super();
+    }
+
+    public FirmwareInfo(FirmwareId id) {
+        super(id);
+    }
+
+    public FirmwareInfo(FirmwareInfo firmwareInfo) {
+        super(firmwareInfo);
+        this.tenantId = firmwareInfo.getTenantId();
+        this.title = firmwareInfo.getTitle();
+        this.version = firmwareInfo.getVersion();
+        this.hasData = firmwareInfo.isHasData();
+        this.fileName = firmwareInfo.getFileName();
+        this.contentType = firmwareInfo.getContentType();
+        this.checksumAlgorithm = firmwareInfo.getChecksumAlgorithm();
+        this.checksum = firmwareInfo.getChecksum();
+        this.dataSize = firmwareInfo.getDataSize();
+    }
+
+    @Override
+    public String getSearchText() {
+        return title;
+    }
+}

common/data/src/main/java/org/thingsboard/server/common/data/TbResourceInfo.java

@@ -27,6 +27,8 @@ import org.thingsboard.server.common.data.validation.NoXss;
 @EqualsAndHashCode(callSuper = true)
 public class TbResourceInfo extends SearchTextBased<TbResourceId> implements HasTenantId {
 
+    private static final long serialVersionUID = 7282664529021651736L;
+
     private TenantId tenantId;
     @NoXss
     private String title;

common/data/src/main/java/org/thingsboard/server/common/data/device/profile/MqttTopics.java

@@ -30,6 +30,9 @@ public class MqttTopics {
     private static final String CLAIM = "/claim";
     private static final String SUB_TOPIC = "+";
     private static final String PROVISION = "/provision";
+    private static final String FIRMWARE = "/fw";
+    private static final String CHUNK = "/chunk/";
+    private static final String ERROR = "/error";
 
     private static final String ATTRIBUTES_RESPONSE = ATTRIBUTES + RESPONSE;
     private static final String ATTRIBUTES_REQUEST = ATTRIBUTES + REQUEST;
@@ -69,6 +72,13 @@ public class MqttTopics {
     public static final String GATEWAY_ATTRIBUTES_REQUEST_TOPIC = BASE_GATEWAY_API_TOPIC + ATTRIBUTES_REQUEST;
     public static final String GATEWAY_ATTRIBUTES_RESPONSE_TOPIC = BASE_GATEWAY_API_TOPIC + ATTRIBUTES_RESPONSE;
 
+    // v2 topics
+    public static final String BASE_DEVICE_API_TOPIC_V2 = "v2";
+
+    public static final String DEVICE_FIRMWARE_RESPONSE_TOPIC_PREFIX = BASE_DEVICE_API_TOPIC_V2 + FIRMWARE + RESPONSE + "/";
+    public static final String DEVICE_FIRMWARE_RESPONSES_TOPIC = DEVICE_FIRMWARE_RESPONSE_TOPIC_PREFIX + SUB_TOPIC + CHUNK + SUB_TOPIC;
+    public static final String DEVICE_FIRMWARE_ERROR_TOPIC = BASE_DEVICE_API_TOPIC_V2 + FIRMWARE + ERROR;
+
     private MqttTopics() {
     }
 }

common/data/src/main/java/org/thingsboard/server/common/data/id/EntityIdFactory.java

@@ -71,6 +71,8 @@ public class EntityIdFactory {
                 return new ApiUsageStateId(uuid);
             case TB_RESOURCE:
                 return new TbResourceId(uuid);
+            case FIRMWARE:
+                return new FirmwareId(uuid);
             case EDGE:
                 return new EdgeId(uuid);
         }

common/data/src/main/java/org/thingsboard/server/common/data/id/FirmwareId.java

@@ -0,0 +1,44 @@
+/**
+ * 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.id;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.thingsboard.server.common.data.EntityType;
+
+import java.util.UUID;
+
+public class FirmwareId extends UUIDBased implements EntityId {
+
+    private static final long serialVersionUID = 1L;
+
+    @JsonCreator
+    public FirmwareId(@JsonProperty("id") UUID id) {
+        super(id);
+    }
+
+    public static FirmwareId fromString(String firmwareId) {
+        return new FirmwareId(UUID.fromString(firmwareId));
+    }
+
+    @JsonIgnore
+    @Override
+    public EntityType getEntityType() {
+        return EntityType.FIRMWARE;
+    }
+
+}

common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaConsumerStatsService.java

@@ -69,7 +69,7 @@ public class TbKafkaConsumerStatsService {
         this.adminClient = AdminClient.create(kafkaSettings.toAdminProps());
         this.statsPrintScheduler = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("kafka-consumer-stats"));
 
-        Properties consumerProps = kafkaSettings.toConsumerProps();
+        Properties consumerProps = kafkaSettings.toConsumerProps(null);
         consumerProps.put(ConsumerConfig.CLIENT_ID_CONFIG, "consumer-stats-loader-client");
         consumerProps.put(ConsumerConfig.GROUP_ID_CONFIG, "consumer-stats-loader-client-group");
         this.consumer = new KafkaConsumer<>(consumerProps);

common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaConsumerTemplate.java

@@ -50,7 +50,7 @@ public class TbKafkaConsumerTemplate<T extends TbQueueMsg> extends AbstractTbQue
                                     String clientId, String groupId, String topic,
                                     TbQueueAdmin admin, TbKafkaConsumerStatsService statsService) {
         super(topic);
-        Properties props = settings.toConsumerProps();
+        Properties props = settings.toConsumerProps(topic);
         props.put(ConsumerConfig.CLIENT_ID_CONFIG, clientId);
         if (groupId != null) {
             props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);

common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaSettings.java

@@ -31,7 +31,9 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.stereotype.Component;
 
+import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Properties;
 
 /**
@@ -95,6 +97,9 @@ public class TbKafkaSettings {
     @Setter
     private List<TbKafkaProperty> other;
 
+    @Setter
+    private Map<String, List<TbKafkaProperty>> consumerPropertiesPerTopic = Collections.emptyMap();
+
     public Properties toAdminProps() {
         Properties props = toProps();
         props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
@@ -103,7 +108,7 @@ public class TbKafkaSettings {
         return props;
     }
 
-    public Properties toConsumerProps() {
+    public Properties toConsumerProps(String topic) {
         Properties props = toProps();
         props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
         props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPollRecords);
@@ -113,6 +118,10 @@ public class TbKafkaSettings {
 
         props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
         props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, ByteArrayDeserializer.class);
+
+        consumerPropertiesPerTopic
+                .getOrDefault(topic, Collections.emptyList())
+                .forEach(kv -> props.put(kv.getKey(), kv.getValue()));
         return props;
     }
 

common/queue/src/main/java/org/thingsboard/server/queue/kafka/TbKafkaTopicConfigs.java

@@ -19,6 +19,7 @@ import lombok.Getter;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.StringUtils;
 
 import javax.annotation.PostConstruct;
 import java.util.HashMap;
@@ -37,6 +38,8 @@ public class TbKafkaTopicConfigs {
     private String notificationsProperties;
     @Value("${queue.kafka.topic-properties.js-executor}")
     private String jsExecutorProperties;
+    @Value("${queue.kafka.topic-properties.fw-updates:}")
+    private String fwUpdatesProperties;
 
     @Getter
     private Map<String, String> coreConfigs;
@@ -48,6 +51,8 @@ public class TbKafkaTopicConfigs {
     private Map<String, String> notificationsConfigs;
     @Getter
     private Map<String, String> jsExecutorConfigs;
+    @Getter
+    private Map<String, String> fwUpdatesConfigs;
 
     @PostConstruct
     private void init() {
@@ -56,15 +61,18 @@ public class TbKafkaTopicConfigs {
         transportApiConfigs = getConfigs(transportApiProperties);
         notificationsConfigs = getConfigs(notificationsProperties);
         jsExecutorConfigs = getConfigs(jsExecutorProperties);
+        fwUpdatesConfigs = getConfigs(fwUpdatesProperties);
     }
 
     private Map<String, String> getConfigs(String properties) {
         Map<String, String> configs = new HashMap<>();
-        for (String property : properties.split(";")) {
+        if (StringUtils.isNotEmpty(properties)) {
-            int delimiterPosition = property.indexOf(":");
+            for (String property : properties.split(";")) {
-            String key = property.substring(0, delimiterPosition);
+                int delimiterPosition = property.indexOf(":");
-            String value = property.substring(delimiterPosition + 1);
+                String key = property.substring(0, delimiterPosition);
-            configs.put(key, value);
+                String value = property.substring(delimiterPosition + 1);
+                configs.put(key, value);
+            }
         }
         return configs;
     }

common/queue/src/main/java/org/thingsboard/server/queue/provider/AwsSqsMonolithQueueFactory.java

@@ -186,6 +186,17 @@ public class AwsSqsMonolithQueueFactory implements TbCoreQueueFactory, TbRuleEng
                 msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbAwsSqsConsumerTemplate<>(transportApiAdmin, sqsSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbAwsSqsProducerTemplate<>(coreAdmin, sqsSettings, coreSettings.getFirmwareTopic());
+    }
+
     @PreDestroy
     private void destroy() {
         if (coreAdmin != null) {

common/queue/src/main/java/org/thingsboard/server/queue/provider/AwsSqsTbCoreQueueFactory.java

@@ -21,12 +21,13 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos;
-import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToUsageStatsServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.TransportApiResponseMsg;
 import org.thingsboard.server.queue.TbQueueAdmin;
@@ -165,14 +166,25 @@ public class AwsSqsTbCoreQueueFactory implements TbCoreQueueFactory {
     }
 
     @Override
-    public TbQueueProducer<TbProtoQueueMsg<TransportProtos.ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
+    public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new TbAwsSqsProducerTemplate<>(coreAdmin, sqsSettings, coreSettings.getUsageStatsTopic());
     }
 
     @Override
-    public TbQueueConsumer<TbProtoQueueMsg<TransportProtos.ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgConsumer() {
+    public TbQueueConsumer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgConsumer() {
         return new TbAwsSqsConsumerTemplate<>(transportApiAdmin, sqsSettings, coreSettings.getUsageStatsTopic(),
-                msg -> new TbProtoQueueMsg<>(msg.getKey(), TransportProtos.ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbAwsSqsConsumerTemplate<>(transportApiAdmin, sqsSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbAwsSqsProducerTemplate<>(coreAdmin, sqsSettings, coreSettings.getFirmwareTopic());
     }
 
     @PreDestroy

common/queue/src/main/java/org/thingsboard/server/queue/provider/InMemoryMonolithQueueFactory.java

@@ -130,6 +130,16 @@ public class InMemoryMonolithQueueFactory implements TbCoreQueueFactory, TbRuleE
         return new InMemoryTbQueueConsumer<>(coreSettings.getUsageStatsTopic());
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<TransportProtos.ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new InMemoryTbQueueConsumer<>(coreSettings.getFirmwareTopic());
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<TransportProtos.ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new InMemoryTbQueueProducer<>(coreSettings.getFirmwareTopic());
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<TransportProtos.ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new InMemoryTbQueueProducer<>(coreSettings.getUsageStatsTopic());

common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaMonolithQueueFactory.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
@@ -73,6 +74,7 @@ public class KafkaMonolithQueueFactory implements TbCoreQueueFactory, TbRuleEngi
     private final TbQueueAdmin jsExecutorAdmin;
     private final TbQueueAdmin transportApiAdmin;
     private final TbQueueAdmin notificationAdmin;
+    private final TbQueueAdmin fwUpdatesAdmin;
 
     public KafkaMonolithQueueFactory(PartitionService partitionService, TbKafkaSettings kafkaSettings,
                                      TbServiceInfoProvider serviceInfoProvider,
@@ -98,6 +100,7 @@ public class KafkaMonolithQueueFactory implements TbCoreQueueFactory, TbRuleEngi
         this.jsExecutorAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getJsExecutorConfigs());
         this.transportApiAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getTransportApiConfigs());
         this.notificationAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getNotificationsConfigs());
+        this.fwUpdatesAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getFwUpdatesConfigs());
     }
 
     @Override
@@ -273,6 +276,29 @@ public class KafkaMonolithQueueFactory implements TbCoreQueueFactory, TbRuleEngi
         return consumerBuilder.build();
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        TbKafkaConsumerTemplate.TbKafkaConsumerTemplateBuilder<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> consumerBuilder = TbKafkaConsumerTemplate.builder();
+        consumerBuilder.settings(kafkaSettings);
+        consumerBuilder.topic(coreSettings.getFirmwareTopic());
+        consumerBuilder.clientId("monolith-fw-consumer-" + serviceInfoProvider.getServiceId());
+        consumerBuilder.groupId("monolith-fw-consumer");
+        consumerBuilder.decoder(msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+        consumerBuilder.admin(fwUpdatesAdmin);
+        consumerBuilder.statsService(consumerStatsService);
+        return consumerBuilder.build();
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        TbKafkaProducerTemplate.TbKafkaProducerTemplateBuilder<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> requestBuilder = TbKafkaProducerTemplate.builder();
+        requestBuilder.settings(kafkaSettings);
+        requestBuilder.clientId("monolith-fw-producer-" + serviceInfoProvider.getServiceId());
+        requestBuilder.defaultTopic(coreSettings.getFirmwareTopic());
+        requestBuilder.admin(fwUpdatesAdmin);
+        return requestBuilder.build();
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         TbKafkaProducerTemplate.TbKafkaProducerTemplateBuilder<TbProtoQueueMsg<ToUsageStatsServiceMsg>> requestBuilder = TbKafkaProducerTemplate.builder();

common/queue/src/main/java/org/thingsboard/server/queue/provider/KafkaTbCoreQueueFactory.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
@@ -70,6 +71,7 @@ public class KafkaTbCoreQueueFactory implements TbCoreQueueFactory {
     private final TbQueueAdmin jsExecutorAdmin;
     private final TbQueueAdmin transportApiAdmin;
     private final TbQueueAdmin notificationAdmin;
+    private final TbQueueAdmin fwUpdatesAdmin;
 
     public KafkaTbCoreQueueFactory(PartitionService partitionService, TbKafkaSettings kafkaSettings,
                                    TbServiceInfoProvider serviceInfoProvider,
@@ -93,6 +95,7 @@ public class KafkaTbCoreQueueFactory implements TbCoreQueueFactory {
         this.jsExecutorAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getJsExecutorConfigs());
         this.transportApiAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getTransportApiConfigs());
         this.notificationAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getNotificationsConfigs());
+        this.fwUpdatesAdmin = new TbKafkaAdmin(kafkaSettings, kafkaTopicConfigs.getFwUpdatesConfigs());
     }
 
     @Override
@@ -241,6 +244,29 @@ public class KafkaTbCoreQueueFactory implements TbCoreQueueFactory {
         return consumerBuilder.build();
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        TbKafkaConsumerTemplate.TbKafkaConsumerTemplateBuilder<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> consumerBuilder = TbKafkaConsumerTemplate.builder();
+        consumerBuilder.settings(kafkaSettings);
+        consumerBuilder.topic(coreSettings.getFirmwareTopic());
+        consumerBuilder.clientId("tb-core-fw-consumer-" + serviceInfoProvider.getServiceId());
+        consumerBuilder.groupId("tb-core-fw-consumer");
+        consumerBuilder.decoder(msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+        consumerBuilder.admin(fwUpdatesAdmin);
+        consumerBuilder.statsService(consumerStatsService);
+        return consumerBuilder.build();
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        TbKafkaProducerTemplate.TbKafkaProducerTemplateBuilder<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> requestBuilder = TbKafkaProducerTemplate.builder();
+        requestBuilder.settings(kafkaSettings);
+        requestBuilder.clientId("tb-core-fw-producer-" + serviceInfoProvider.getServiceId());
+        requestBuilder.defaultTopic(coreSettings.getFirmwareTopic());
+        requestBuilder.admin(fwUpdatesAdmin);
+        return requestBuilder.build();
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         TbKafkaProducerTemplate.TbKafkaProducerTemplateBuilder<TbProtoQueueMsg<ToUsageStatsServiceMsg>> requestBuilder = TbKafkaProducerTemplate.builder();

common/queue/src/main/java/org/thingsboard/server/queue/provider/PubSubMonolithQueueFactory.java

@@ -22,6 +22,7 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos.RemoteJsRequest;
 import org.thingsboard.server.gen.js.JsInvokeProtos.RemoteJsResponse;
+import org.thingsboard.server.gen.transport.TransportProtos.*;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
@@ -190,6 +191,17 @@ public class PubSubMonolithQueueFactory implements TbCoreQueueFactory, TbRuleEng
                 msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbPubSubConsumerTemplate<>(coreAdmin, pubSubSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbPubSubProducerTemplate<>(coreAdmin, pubSubSettings, coreSettings.getFirmwareTopic());
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new TbPubSubProducerTemplate<>(coreAdmin, pubSubSettings, coreSettings.getUsageStatsTopic());

common/queue/src/main/java/org/thingsboard/server/queue/provider/PubSubTbCoreQueueFactory.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
@@ -164,6 +165,17 @@ public class PubSubTbCoreQueueFactory implements TbCoreQueueFactory {
                 msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbPubSubConsumerTemplate<>(coreAdmin, pubSubSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbPubSubProducerTemplate<>(coreAdmin, pubSubSettings, coreSettings.getFirmwareTopic());
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new TbPubSubProducerTemplate<>(coreAdmin, pubSubSettings, coreSettings.getUsageStatsTopic());

common/queue/src/main/java/org/thingsboard/server/queue/provider/RabbitMqMonolithQueueFactory.java

@@ -24,6 +24,7 @@ import org.thingsboard.server.gen.js.JsInvokeProtos.RemoteJsRequest;
 import org.thingsboard.server.gen.js.JsInvokeProtos.RemoteJsResponse;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
@@ -188,6 +189,17 @@ public class RabbitMqMonolithQueueFactory implements TbCoreQueueFactory, TbRuleE
                 msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbRabbitMqConsumerTemplate<>(coreAdmin, rabbitMqSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbRabbitMqProducerTemplate<>(coreAdmin, rabbitMqSettings, coreSettings.getFirmwareTopic());
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new TbRabbitMqProducerTemplate<>(coreAdmin, rabbitMqSettings, coreSettings.getUsageStatsTopic());

common/queue/src/main/java/org/thingsboard/server/queue/provider/RabbitMqTbCoreQueueFactory.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
@@ -170,6 +171,17 @@ public class RabbitMqTbCoreQueueFactory implements TbCoreQueueFactory {
                 msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbRabbitMqConsumerTemplate<>(coreAdmin, rabbitMqSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbRabbitMqProducerTemplate<>(coreAdmin, rabbitMqSettings, coreSettings.getFirmwareTopic());
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new TbRabbitMqProducerTemplate<>(coreAdmin, rabbitMqSettings, coreSettings.getUsageStatsTopic());

common/queue/src/main/java/org/thingsboard/server/queue/provider/ServiceBusMonolithQueueFactory.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
@@ -187,6 +188,17 @@ public class ServiceBusMonolithQueueFactory implements TbCoreQueueFactory, TbRul
                 msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbServiceBusConsumerTemplate<>(coreAdmin, serviceBusSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbServiceBusProducerTemplate<>(coreAdmin, serviceBusSettings, coreSettings.getFirmwareTopic());
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new TbServiceBusProducerTemplate<>(coreAdmin, serviceBusSettings, coreSettings.getUsageStatsTopic());

common/queue/src/main/java/org/thingsboard/server/queue/provider/ServiceBusTbCoreQueueFactory.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.gen.js.JsInvokeProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToTransportMsg;
@@ -170,6 +171,17 @@ public class ServiceBusTbCoreQueueFactory implements TbCoreQueueFactory {
                 msg -> new TbProtoQueueMsg<>(msg.getKey(), ToUsageStatsServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
     }
 
+    @Override
+    public TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer() {
+        return new TbServiceBusConsumerTemplate<>(coreAdmin, serviceBusSettings, coreSettings.getFirmwareTopic(),
+                msg -> new TbProtoQueueMsg<>(msg.getKey(), ToFirmwareStateServiceMsg.parseFrom(msg.getData()), msg.getHeaders()));
+    }
+
+    @Override
+    public TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer() {
+        return new TbServiceBusProducerTemplate<>(coreAdmin, serviceBusSettings, coreSettings.getFirmwareTopic());
+    }
+
     @Override
     public TbQueueProducer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgProducer() {
         return new TbServiceBusProducerTemplate<>(coreAdmin, serviceBusSettings, coreSettings.getUsageStatsTopic());

common/queue/src/main/java/org/thingsboard/server/queue/provider/TbCoreQueueFactory.java

@@ -16,6 +16,7 @@
 package org.thingsboard.server.queue.provider;
 
 import org.thingsboard.server.gen.js.JsInvokeProtos;
+import org.thingsboard.server.gen.transport.TransportProtos.ToFirmwareStateServiceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToCoreNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToRuleEngineMsg;
@@ -85,6 +86,20 @@ public interface TbCoreQueueFactory extends TbUsageStatsClientQueueFactory {
      */
     TbQueueConsumer<TbProtoQueueMsg<ToUsageStatsServiceMsg>> createToUsageStatsServiceMsgConsumer();
 
+    /**
+     * Used to consume messages about firmware update notifications by TB Core Service
+     *
+     * @return
+     */
+    TbQueueConsumer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgConsumer();
+
+    /**
+     * Used to consume messages about firmware update notifications by TB Core Service
+     *
+     * @return
+     */
+    TbQueueProducer<TbProtoQueueMsg<ToFirmwareStateServiceMsg>> createToFirmwareStateServiceMsgProducer();
+
     /**
      * Used to consume high priority messages by TB Core Service
      *

common/queue/src/main/java/org/thingsboard/server/queue/settings/TbQueueCoreSettings.java

@@ -26,6 +26,9 @@ public class TbQueueCoreSettings {
     @Value("${queue.core.topic}")
     private String topic;
 
+    @Value("${queue.core.firmware.topic:tb_firmware}")
+    private String firmwareTopic;
+
     @Value("${queue.core.usage-stats-topic:tb_usage_stats}")
     private String usageStatsTopic;
 

common/queue/src/main/proto/queue.proto

@@ -340,17 +340,35 @@ message ProvisionDeviceCredentialsMsg {
 }
 
 message ProvisionDeviceResponseMsg {
-  ProvisionResponseStatus status = 1;
+  ResponseStatus status = 1;
   CredentialsType credentialsType = 2;
   string credentialsValue = 3;
 }
 
-enum ProvisionResponseStatus {
+enum ResponseStatus {
   UNKNOWN = 0;
   SUCCESS = 1;
   NOT_FOUND = 2;
   FAILURE = 3;
 }
+
+message GetFirmwareRequestMsg {
+  int64 deviceIdMSB = 1;
+  int64 deviceIdLSB = 2;
+  int64 tenantIdMSB = 3;
+  int64 tenantIdLSB = 4;
+}
+
+message GetFirmwareResponseMsg {
+  ResponseStatus responseStatus = 1;
+  int64 firmwareIdMSB = 2;
+  int64 firmwareIdLSB = 3;
+  string title = 4;
+  string version = 5;
+  string contentType = 6;
+  string fileName = 7;
+}
+
 //Used to report session state to tb-Service and persist this state in the cache on the tb-Service level.
 message SubscriptionInfoProto {
   int64 lastActivityTime = 1;
@@ -571,6 +589,7 @@ message TransportApiRequestMsg {
   ProvisionDeviceRequestMsg provisionDeviceRequestMsg = 7;
   ValidateDeviceLwM2MCredentialsRequestMsg validateDeviceLwM2MCredentialsRequestMsg = 8;
   GetResourceRequestMsg resourceRequestMsg = 9;
+  GetFirmwareRequestMsg firmwareRequestMsg = 10;
 }
 
 /* Response from ThingsBoard Core Service to Transport Service */
@@ -581,6 +600,7 @@ message TransportApiResponseMsg {
   ProvisionDeviceResponseMsg provisionDeviceResponseMsg = 4;
   LwM2MResponseMsg lwM2MResponseMsg = 6;
   GetResourceResponseMsg resourceResponseMsg = 7;
+  GetFirmwareResponseMsg firmwareResponseMsg = 8;
 }
 
 /* Messages that are handled by ThingsBoard Core Service */
@@ -645,3 +665,13 @@ message ToUsageStatsServiceMsg {
   int64 customerIdMSB = 6;
   int64 customerIdLSB = 7;
 }
+
+message ToFirmwareStateServiceMsg {
+  int64 ts = 1;
+  int64 tenantIdMSB = 2;
+  int64 tenantIdLSB = 3;
+  int64 deviceIdMSB = 4;
+  int64 deviceIdLSB = 5;
+  int64 firmwareIdMSB = 6;
+  int64 firmwareIdLSB = 7;
+}

common/transport/coap/src/main/java/org/thingsboard/server/transport/coap/CoapTransportResource.java

@@ -407,7 +407,7 @@ public class CoapTransportResource extends AbstractCoapTransportResource {
         @Override
         public void onSuccess(TransportProtos.ProvisionDeviceResponseMsg msg) {
             CoAP.ResponseCode responseCode = CoAP.ResponseCode.CREATED;
-            if (!msg.getStatus().equals(TransportProtos.ProvisionResponseStatus.SUCCESS)) {
+            if (!msg.getStatus().equals(TransportProtos.ResponseStatus.SUCCESS)) {
                 responseCode = CoAP.ResponseCode.BAD_REQUEST;
             }
             if (payloadType.equals(TransportPayloadType.JSON)) {

common/transport/http/src/main/java/org/thingsboard/server/transport/http/DeviceApiController.java

@@ -20,7 +20,10 @@ import com.google.gson.JsonParser;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -41,7 +44,6 @@ 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.AttributeUpdateNotificationMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.DeviceInfoProto;
 import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceResponseMsg;
@@ -53,7 +55,6 @@ import org.thingsboard.server.gen.transport.TransportProtos.ToDeviceRpcRequestMs
 import org.thingsboard.server.gen.transport.TransportProtos.ToDeviceRpcResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToServerRpcRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ToServerRpcResponseMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceCredentialsResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateDeviceTokenRequestMsg;
 
 import javax.servlet.http.HttpServletRequest;
@@ -204,6 +205,25 @@ public class DeviceApiController {
         return responseWriter;
     }
 
+    @RequestMapping(value = "/{deviceToken}/firmware", method = RequestMethod.GET)
+    public DeferredResult<ResponseEntity> getFirmware(@PathVariable("deviceToken") String deviceToken,
+                                                      @RequestParam(value = "title") String title,
+                                                      @RequestParam(value = "version") String version,
+                                                      @RequestParam(value = "chunkSize", required = false, defaultValue = "0") int chunkSize,
+                                                      @RequestParam(value = "chunk", required = false, defaultValue = "0") int chunk) {
+        DeferredResult<ResponseEntity> responseWriter = new DeferredResult<>();
+        transportContext.getTransportService().process(DeviceTransportType.DEFAULT, ValidateDeviceTokenRequestMsg.newBuilder().setToken(deviceToken).build(),
+                new DeviceAuthCallback(transportContext, responseWriter, sessionInfo -> {
+                    TransportProtos.GetFirmwareRequestMsg requestMsg = TransportProtos.GetFirmwareRequestMsg.newBuilder()
+                            .setTenantIdMSB(sessionInfo.getTenantIdMSB())
+                            .setTenantIdLSB(sessionInfo.getTenantIdLSB())
+                            .setDeviceIdMSB(sessionInfo.getDeviceIdMSB())
+                            .setDeviceIdLSB(sessionInfo.getDeviceIdLSB()).build();
+                    transportContext.getTransportService().process(sessionInfo, requestMsg, new GetFirmwareCallback(responseWriter, title, version, chunkSize, chunk));
+                }));
+        return responseWriter;
+    }
+
     @RequestMapping(value = "/provision", method = RequestMethod.POST)
     public DeferredResult<ResponseEntity> provisionDevice(@RequestBody String json, HttpServletRequest httpRequest) {
         DeferredResult<ResponseEntity> responseWriter = new DeferredResult<>();
@@ -258,6 +278,47 @@ public class DeviceApiController {
         }
     }
 
+    private class GetFirmwareCallback implements TransportServiceCallback<TransportProtos.GetFirmwareResponseMsg> {
+        private final DeferredResult<ResponseEntity> responseWriter;
+        private final String title;
+        private final String version;
+        private final int chuckSize;
+        private final int chuck;
+
+        GetFirmwareCallback(DeferredResult<ResponseEntity> responseWriter, String title, String version, int chuckSize, int chuck) {
+            this.responseWriter = responseWriter;
+            this.title = title;
+            this.version = version;
+            this.chuckSize = chuckSize;
+            this.chuck = chuck;
+        }
+
+        @Override
+        public void onSuccess(TransportProtos.GetFirmwareResponseMsg firmwareResponseMsg) {
+            if (!TransportProtos.ResponseStatus.SUCCESS.equals(firmwareResponseMsg.getResponseStatus())) {
+                responseWriter.setResult(new ResponseEntity<>(HttpStatus.NOT_FOUND));
+            } else if (title.equals(firmwareResponseMsg.getTitle()) && version.equals(firmwareResponseMsg.getVersion())) {
+                String firmwareId = new UUID(firmwareResponseMsg.getFirmwareIdMSB(), firmwareResponseMsg.getFirmwareIdLSB()).toString();
+                ByteArrayResource resource = new ByteArrayResource(transportContext.getFirmwareCacheReader().get(firmwareId, chuckSize, chuck));
+                ResponseEntity<ByteArrayResource> response = ResponseEntity.ok()
+                        .header(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + firmwareResponseMsg.getFileName())
+                        .header("x-filename", firmwareResponseMsg.getFileName())
+                        .contentLength(resource.contentLength())
+                        .contentType(parseMediaType(firmwareResponseMsg.getContentType()))
+                        .body(resource);
+                responseWriter.setResult(response);
+            } else {
+                responseWriter.setResult(new ResponseEntity<>(HttpStatus.BAD_REQUEST));
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            log.warn("Failed to process request", e);
+            responseWriter.setResult(new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR));
+        }
+    }
+
     private static class SessionCloseOnErrorCallback implements TransportServiceCallback<Void> {
         private final TransportService transportService;
         private final SessionInfoProto sessionInfo;
@@ -338,4 +399,12 @@ public class DeviceApiController {
                 .build(), TransportServiceCallback.EMPTY);
     }
 
+    private static MediaType parseMediaType(String contentType) {
+        try {
+            return MediaType.parseMediaType(contentType);
+        } catch (Exception e) {
+            return MediaType.APPLICATION_OCTET_STREAM;
+        }
+    }
+
 }

common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/store/TbLwM2mRedisSecurityStore.java

@@ -29,7 +29,6 @@ import redis.clients.jedis.ScanResult;
 import java.util.Collection;
 import java.util.LinkedList;
 
-@Service
 public class TbLwM2mRedisSecurityStore implements EditableSecurityStore {
     private static final String SEC_EP = "SEC#EP#";
 

common/transport/mqtt/src/main/java/org/thingsboard/server/transport/mqtt/MqttTransportHandler.java

@@ -40,12 +40,14 @@ import io.netty.util.ReferenceCountUtil;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.GenericFutureListener;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.thingsboard.server.common.data.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.TransportPayloadType;
 import org.thingsboard.server.common.data.device.profile.MqttTopics;
+import org.thingsboard.server.common.data.id.FirmwareId;
 import org.thingsboard.server.common.msg.EncryptionUtil;
 import org.thingsboard.server.common.msg.tools.TbRateLimitsException;
 import org.thingsboard.server.common.transport.SessionMsgListener;
@@ -69,10 +71,10 @@ import org.thingsboard.server.transport.mqtt.session.MqttTopicMatcher;
 import org.thingsboard.server.common.transport.util.SslUtil;
 
 import javax.net.ssl.SSLPeerUnverifiedException;
-import java.security.cert.Certificate;
-import java.security.cert.X509Certificate;
 import java.io.IOException;
 import java.net.InetSocketAddress;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -80,7 +82,10 @@ import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.TimeUnit;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
+import static com.amazonaws.util.StringUtils.UTF8;
 import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_ACCEPTED;
 import static io.netty.handler.codec.mqtt.MqttConnectReturnCode.CONNECTION_REFUSED_NOT_AUTHORIZED;
 import static io.netty.handler.codec.mqtt.MqttMessageType.CONNACK;
@@ -99,6 +104,10 @@ import static io.netty.handler.codec.mqtt.MqttQoS.FAILURE;
 @Slf4j
 public class MqttTransportHandler extends ChannelInboundHandlerAdapter implements GenericFutureListener<Future<? super Void>>, SessionMsgListener {
 
+    private static final Pattern FW_PATTERN = Pattern.compile("v2/fw/request/(?<requestId>\\d+)/chunk/(?<chunk>\\d+)");
+
+    private static final String PAYLOAD_TOO_LARGE = "PAYLOAD_TOO_LARGE";
+
     private static final MqttQoS MAX_SUPPORTED_QOS_LVL = AT_LEAST_ONCE;
 
     private final UUID sessionId;
@@ -112,6 +121,9 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
     private volatile InetSocketAddress address;
     private volatile GatewaySessionHandler gatewaySessionHandler;
 
+    private final ConcurrentHashMap<String, String> fwSessions;
+    private final ConcurrentHashMap<String, Integer> fwChunkSizes;
+
     MqttTransportHandler(MqttTransportContext context, SslHandler sslHandler) {
         this.sessionId = UUID.randomUUID();
         this.context = context;
@@ -120,6 +132,8 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
         this.sslHandler = sslHandler;
         this.mqttQoSMap = new ConcurrentHashMap<>();
         this.deviceSessionCtx = new DeviceSessionCtx(sessionId, mqttQoSMap, context);
+        this.fwSessions = new ConcurrentHashMap<>();
+        this.fwChunkSizes = new ConcurrentHashMap<>();
     }
 
     @Override
@@ -280,6 +294,7 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
 
     private void processDevicePublish(ChannelHandlerContext ctx, MqttPublishMessage mqttMsg, String topicName, int msgId) {
         try {
+            Matcher fwMatcher;
             MqttTransportAdaptor payloadAdaptor = deviceSessionCtx.getPayloadAdaptor();
             if (deviceSessionCtx.isDeviceAttributesTopic(topicName)) {
                 TransportProtos.PostAttributeMsg postAttributeMsg = payloadAdaptor.convertToPostAttributes(deviceSessionCtx, mqttMsg);
@@ -299,6 +314,38 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
             } else if (topicName.equals(MqttTopics.DEVICE_CLAIM_TOPIC)) {
                 TransportProtos.ClaimDeviceMsg claimDeviceMsg = payloadAdaptor.convertToClaimDevice(deviceSessionCtx, mqttMsg);
                 transportService.process(deviceSessionCtx.getSessionInfo(), claimDeviceMsg, getPubAckCallback(ctx, msgId, claimDeviceMsg));
+            } else if ((fwMatcher = FW_PATTERN.matcher(topicName)).find()) {
+                String payload = mqttMsg.content().toString(UTF8);
+                int chunkSize = StringUtils.isNotEmpty(payload) ? Integer.parseInt(payload) : 0;
+                String requestId = fwMatcher.group("requestId");
+                int chunk = Integer.parseInt(fwMatcher.group("chunk"));
+
+                if (chunkSize > 0) {
+                    this.fwChunkSizes.put(requestId, chunkSize);
+                } else {
+                    chunkSize = fwChunkSizes.getOrDefault(requestId, 0);
+                }
+
+                if (chunkSize > context.getMaxPayloadSize()) {
+                    sendFirmwareError(ctx, PAYLOAD_TOO_LARGE);
+                    return;
+                }
+
+                String firmwareId = fwSessions.get(requestId);
+
+                if (firmwareId != null) {
+                    sendFirmware(ctx, mqttMsg.variableHeader().packetId(), firmwareId, requestId, chunkSize, chunk);
+                } else {
+                    TransportProtos.SessionInfoProto sessionInfo = deviceSessionCtx.getSessionInfo();
+                    TransportProtos.GetFirmwareRequestMsg getFirmwareRequestMsg = TransportProtos.GetFirmwareRequestMsg.newBuilder()
+                            .setDeviceIdMSB(sessionInfo.getDeviceIdMSB())
+                            .setDeviceIdLSB(sessionInfo.getDeviceIdLSB())
+                            .setTenantIdMSB(sessionInfo.getTenantIdMSB())
+                            .setTenantIdLSB(sessionInfo.getTenantIdLSB())
+                            .build();
+                    transportService.process(deviceSessionCtx.getSessionInfo(), getFirmwareRequestMsg,
+                            new FirmwareCallback(ctx, mqttMsg.variableHeader().packetId(), getFirmwareRequestMsg, requestId, chunkSize, chunk));
+                }
             } else {
                 transportService.reportActivity(deviceSessionCtx.getSessionInfo());
                 ack(ctx, msgId);
@@ -366,6 +413,65 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
         }
     }
 
+    private class FirmwareCallback implements TransportServiceCallback<TransportProtos.GetFirmwareResponseMsg> {
+        private final ChannelHandlerContext ctx;
+        private final int msgId;
+        private final TransportProtos.GetFirmwareRequestMsg msg;
+        private final String requestId;
+        private final int chunkSize;
+        private final int chunk;
+
+        FirmwareCallback(ChannelHandlerContext ctx, int msgId, TransportProtos.GetFirmwareRequestMsg msg, String requestId, int chunkSize, int chunk) {
+            this.ctx = ctx;
+            this.msgId = msgId;
+            this.msg = msg;
+            this.requestId = requestId;
+            this.chunkSize = chunkSize;
+            this.chunk = chunk;
+        }
+
+        @Override
+        public void onSuccess(TransportProtos.GetFirmwareResponseMsg response) {
+            if (TransportProtos.ResponseStatus.SUCCESS.equals(response.getResponseStatus())) {
+                FirmwareId firmwareId = new FirmwareId(new UUID(response.getFirmwareIdMSB(), response.getFirmwareIdLSB()));
+                fwSessions.put(requestId, firmwareId.toString());
+                sendFirmware(ctx, msgId, firmwareId.toString(), requestId, chunkSize, chunk);
+            } else {
+                sendFirmwareError(ctx, response.getResponseStatus().toString());
+            }
+        }
+
+        @Override
+        public void onError(Throwable e) {
+            log.trace("[{}] Failed to get firmware: {}", sessionId, msg, e);
+            processDisconnect(ctx);
+        }
+    }
+
+    private void sendFirmware(ChannelHandlerContext ctx, int msgId, String firmwareId, String requestId, int chunkSize, int chunk) {
+        log.trace("[{}] Send firmware [{}] to device!", sessionId, firmwareId);
+        ack(ctx, msgId);
+        try {
+            byte[] firmwareChunk = context.getFirmwareCacheReader().get(firmwareId, chunkSize, chunk);
+            deviceSessionCtx.getPayloadAdaptor()
+                    .convertToPublish(deviceSessionCtx, firmwareChunk, requestId, chunk)
+                    .ifPresent(deviceSessionCtx.getChannel()::writeAndFlush);
+            if (firmwareChunk != null && chunkSize != firmwareChunk.length) {
+                scheduler.schedule(() -> processDisconnect(ctx), 60, TimeUnit.SECONDS);
+            }
+        } catch (Exception e) {
+            log.trace("[{}] Failed to send firmware response!", sessionId, e);
+        }
+    }
+
+    private void sendFirmwareError(ChannelHandlerContext ctx, String error) {
+        log.warn("[{}] {}", sessionId, error);
+        deviceSessionCtx.getChannel().writeAndFlush(deviceSessionCtx
+                .getPayloadAdaptor()
+                .createMqttPublishMsg(deviceSessionCtx, MqttTopics.DEVICE_FIRMWARE_ERROR_TOPIC, error.getBytes()));
+        processDisconnect(ctx);
+    }
+
     private void processSubscribe(ChannelHandlerContext ctx, MqttSubscribeMessage mqttMsg) {
         if (!checkConnected(ctx, mqttMsg)) {
             return;
@@ -396,6 +502,8 @@ public class MqttTransportHandler extends ChannelInboundHandlerAdapter implement
                     case MqttTopics.GATEWAY_RPC_TOPIC:
                     case MqttTopics.GATEWAY_ATTRIBUTES_RESPONSE_TOPIC:
                     case MqttTopics.DEVICE_PROVISION_RESPONSE_TOPIC:
+                    case MqttTopics.DEVICE_FIRMWARE_RESPONSES_TOPIC:
+                    case MqttTopics.DEVICE_FIRMWARE_ERROR_TOPIC:
                         registerSubQoS(topic, grantedQoSList, reqQoS);
                         break;
                     default:

common/transport/mqtt/src/main/java/org/thingsboard/server/transport/mqtt/adaptors/JsonMqttAdaptor.java

@@ -21,8 +21,6 @@ import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
 import com.google.gson.JsonSyntaxException;
 import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufAllocator;
-import io.netty.buffer.UnpooledByteBufAllocator;
 import io.netty.handler.codec.mqtt.MqttFixedHeader;
 import io.netty.handler.codec.mqtt.MqttMessage;
 import io.netty.handler.codec.mqtt.MqttMessageType;
@@ -31,10 +29,10 @@ import io.netty.handler.codec.mqtt.MqttPublishVariableHeader;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;
+import org.thingsboard.server.common.data.device.profile.MqttTopics;
 import org.thingsboard.server.common.transport.adaptor.AdaptorException;
 import org.thingsboard.server.common.transport.adaptor.JsonConverter;
 import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.common.data.device.profile.MqttTopics;
 import org.thingsboard.server.transport.mqtt.session.MqttDeviceAwareSessionContext;
 
 import java.nio.charset.Charset;
@@ -55,7 +53,6 @@ public class JsonMqttAdaptor implements MqttTransportAdaptor {
     protected static final Charset UTF8 = StandardCharsets.UTF_8;
 
     private static final Gson GSON = new Gson();
-    private static final ByteBufAllocator ALLOCATOR = new UnpooledByteBufAllocator(false);
 
     @Override
     public TransportProtos.PostTelemetryMsg convertToPostTelemetry(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
@@ -153,6 +150,11 @@ public class JsonMqttAdaptor implements MqttTransportAdaptor {
         return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_PROVISION_RESPONSE_TOPIC, JsonConverter.toJson(provisionResponse)));
     }
 
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, byte[] firmwareChunk, String requestId, int chunk) {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_FIRMWARE_RESPONSE_TOPIC_PREFIX + requestId + "/chunk/" + chunk, firmwareChunk));
+    }
+
     public static JsonElement validateJsonPayload(UUID sessionId, ByteBuf payloadData) throws AdaptorException {
         String payload = validatePayload(sessionId, payloadData, false);
         try {

common/transport/mqtt/src/main/java/org/thingsboard/server/transport/mqtt/adaptors/MqttTransportAdaptor.java

@@ -15,8 +15,14 @@
  */
 package org.thingsboard.server.transport.mqtt.adaptors;
 
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.mqtt.MqttFixedHeader;
 import io.netty.handler.codec.mqtt.MqttMessage;
+import io.netty.handler.codec.mqtt.MqttMessageType;
 import io.netty.handler.codec.mqtt.MqttPublishMessage;
+import io.netty.handler.codec.mqtt.MqttPublishVariableHeader;
 import org.thingsboard.server.common.transport.adaptor.AdaptorException;
 import org.thingsboard.server.gen.transport.TransportProtos.AttributeUpdateNotificationMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ClaimDeviceMsg;
@@ -39,6 +45,8 @@ import java.util.Optional;
  */
 public interface MqttTransportAdaptor {
 
+    ByteBufAllocator ALLOCATOR = new UnpooledByteBufAllocator(false);
+
     PostTelemetryMsg convertToPostTelemetry(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException;
 
     PostAttributeMsg convertToPostAttributes(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException;
@@ -69,4 +77,14 @@ public interface MqttTransportAdaptor {
 
     Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, ProvisionDeviceResponseMsg provisionResponse) throws AdaptorException;
 
+    Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, byte[] firmwareChunk, String requestId, int chunk) throws AdaptorException;
+
+    default MqttPublishMessage createMqttPublishMsg(MqttDeviceAwareSessionContext ctx, String topic, byte[] payloadInBytes) {
+        MqttFixedHeader mqttFixedHeader =
+                new MqttFixedHeader(MqttMessageType.PUBLISH, false, ctx.getQoSForTopic(topic), false, 0);
+        MqttPublishVariableHeader header = new MqttPublishVariableHeader(topic, ctx.nextMsgId());
+        ByteBuf payload = ALLOCATOR.buffer();
+        payload.writeBytes(payloadInBytes);
+        return new MqttPublishMessage(mqttFixedHeader, header, payload);
+    }
 }

common/transport/mqtt/src/main/java/org/thingsboard/server/transport/mqtt/adaptors/ProtoMqttAdaptor.java

@@ -22,13 +22,8 @@ import com.google.protobuf.DynamicMessage;
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.google.protobuf.util.JsonFormat;
 import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufAllocator;
-import io.netty.buffer.UnpooledByteBufAllocator;
-import io.netty.handler.codec.mqtt.MqttFixedHeader;
 import io.netty.handler.codec.mqtt.MqttMessage;
-import io.netty.handler.codec.mqtt.MqttMessageType;
 import io.netty.handler.codec.mqtt.MqttPublishMessage;
-import io.netty.handler.codec.mqtt.MqttPublishVariableHeader;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import org.springframework.util.StringUtils;
@@ -47,8 +42,6 @@ import java.util.Optional;
 @Slf4j
 public class ProtoMqttAdaptor implements MqttTransportAdaptor {
 
-    private static final ByteBufAllocator ALLOCATOR = new UnpooledByteBufAllocator(false);
-
     @Override
     public TransportProtos.PostTelemetryMsg convertToPostTelemetry(MqttDeviceAwareSessionContext ctx, MqttPublishMessage inbound) throws AdaptorException {
         DeviceSessionCtx deviceSessionCtx = (DeviceSessionCtx) ctx;
@@ -149,7 +142,6 @@ public class ProtoMqttAdaptor implements MqttTransportAdaptor {
         }
     }
 
-
     @Override
     public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, TransportProtos.ToDeviceRpcRequestMsg rpcRequest) throws AdaptorException {
         DeviceSessionCtx deviceSessionCtx = (DeviceSessionCtx) ctx;
@@ -172,6 +164,11 @@ public class ProtoMqttAdaptor implements MqttTransportAdaptor {
         return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_PROVISION_RESPONSE_TOPIC, provisionResponse.toByteArray()));
     }
 
+    @Override
+    public Optional<MqttMessage> convertToPublish(MqttDeviceAwareSessionContext ctx, byte[] firmwareChunk, String requestId, int chunk) throws AdaptorException {
+        return Optional.of(createMqttPublishMsg(ctx, MqttTopics.DEVICE_FIRMWARE_RESPONSE_TOPIC_PREFIX + requestId + "/" + chunk, firmwareChunk));
+    }
+
     @Override
     public Optional<MqttMessage> convertToGatewayPublish(MqttDeviceAwareSessionContext ctx, String deviceName, TransportProtos.GetAttributeResponseMsg responseMsg) throws AdaptorException {
         if (!StringUtils.isEmpty(responseMsg.getError())) {
@@ -210,15 +207,6 @@ public class ProtoMqttAdaptor implements MqttTransportAdaptor {
         return bytes;
     }
 
-    private MqttPublishMessage createMqttPublishMsg(MqttDeviceAwareSessionContext ctx, String topic, byte[] payloadBytes) {
-        MqttFixedHeader mqttFixedHeader =
-                new MqttFixedHeader(MqttMessageType.PUBLISH, false, ctx.getQoSForTopic(topic), false, 0);
-        MqttPublishVariableHeader header = new MqttPublishVariableHeader(topic, ctx.nextMsgId());
-        ByteBuf payload = ALLOCATOR.buffer();
-        payload.writeBytes(payloadBytes);
-        return new MqttPublishMessage(mqttFixedHeader, header, payload);
-    }
-
     private int getRequestId(String topicName, String topic) {
         return Integer.parseInt(topicName.substring(topic.length()));
     }

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/TransportContext.java

@@ -20,10 +20,9 @@ import lombok.Data;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
+import org.thingsboard.server.cache.firmware.FirmwareCacheReader;
 import org.thingsboard.server.queue.discovery.TbServiceInfoProvider;
 import org.thingsboard.server.queue.scheduler.SchedulerComponent;
-import org.thingsboard.server.queue.util.TbTransportComponent;
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
@@ -51,6 +50,11 @@ public abstract class TransportContext {
     @Getter
     private ExecutorService executor;
 
+
+    @Getter
+    @Autowired
+    private FirmwareCacheReader firmwareCacheReader;
+
     @PostConstruct
     public void init() {
         executor = Executors.newWorkStealingPool(50);

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/TransportService.java

@@ -24,6 +24,8 @@ import org.thingsboard.server.gen.transport.TransportProtos.ClaimDeviceMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetAttributeRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetEntityProfileResponseMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetFirmwareRequestMsg;
+import org.thingsboard.server.gen.transport.TransportProtos.GetFirmwareResponseMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetOrCreateDeviceFromGatewayRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetResourceRequestMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.GetResourceResponseMsg;
@@ -98,6 +100,8 @@ public interface TransportService {
 
     void process(SessionInfoProto sessionInfo, ClaimDeviceMsg msg, TransportServiceCallback<Void> callback);
 
+    void process(SessionInfoProto sessionInfoProto, GetFirmwareRequestMsg msg, TransportServiceCallback<GetFirmwareResponseMsg> callback);
+
     SessionMetaData registerAsyncSession(SessionInfoProto sessionInfo, SessionMsgListener listener);
 
     SessionMetaData registerSyncSession(SessionInfoProto sessionInfo, SessionMsgListener listener, long timeout);

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/adaptor/JsonConverter.java

@@ -44,7 +44,7 @@ import org.thingsboard.server.gen.transport.TransportProtos.KeyValueType;
 import org.thingsboard.server.gen.transport.TransportProtos.PostAttributeMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.PostTelemetryMsg;
 import org.thingsboard.server.gen.transport.TransportProtos.ProvisionDeviceResponseMsg;
-import org.thingsboard.server.gen.transport.TransportProtos.ProvisionResponseStatus;
+import org.thingsboard.server.gen.transport.TransportProtos.ResponseStatus;
 import org.thingsboard.server.gen.transport.TransportProtos.TsKvListProto;
 import org.thingsboard.server.gen.transport.TransportProtos.TsKvProto;
 import org.thingsboard.server.gen.transport.TransportProtos.ValidateBasicMqttCredRequestMsg;
@@ -427,12 +427,12 @@ public class JsonConverter {
 
     private static JsonObject toJson(ProvisionDeviceResponseMsg payload, boolean toGateway, int requestId) {
         JsonObject result = new JsonObject();
-        if (payload.getStatus() == TransportProtos.ProvisionResponseStatus.NOT_FOUND) {
+        if (payload.getStatus() == ResponseStatus.NOT_FOUND) {
             result.addProperty("errorMsg", "Provision data was not found!");
-            result.addProperty("status", ProvisionResponseStatus.NOT_FOUND.name());
+            result.addProperty("status", ResponseStatus.NOT_FOUND.name());
-        } else if (payload.getStatus() == TransportProtos.ProvisionResponseStatus.FAILURE) {
+        } else if (payload.getStatus() == TransportProtos.ResponseStatus.FAILURE) {
             result.addProperty("errorMsg", "Failed to provision device!");
-            result.addProperty("status", ProvisionResponseStatus.FAILURE.name());
+            result.addProperty("status", ResponseStatus.FAILURE.name());
         } else {
             if (toGateway) {
                 result.addProperty("id", requestId);
@@ -449,7 +449,7 @@ public class JsonConverter {
                     break;
             }
             result.addProperty("credentialsType", payload.getCredentialsType().name());
-            result.addProperty("status", ProvisionResponseStatus.SUCCESS.name());
+            result.addProperty("status", ResponseStatus.SUCCESS.name());
         }
         return result;
     }

common/transport/transport-api/src/main/java/org/thingsboard/server/common/transport/service/DefaultTransportService.java

@@ -380,7 +380,6 @@ public class DefaultTransportService implements TransportService {
         AsyncCallbackTemplate.withCallback(response, callback::onSuccess, callback::onError, transportCallbackExecutor);
     }
 
-
     @Override
     public void process(TransportProtos.SessionInfoProto sessionInfo, TransportProtos.SubscriptionInfoProto msg, TransportServiceCallback<Void> callback) {
         if (log.isTraceEnabled()) {
@@ -533,6 +532,19 @@ public class DefaultTransportService implements TransportService {
         }
     }
 
+    @Override
+    public void process(TransportProtos.SessionInfoProto sessionInfo, TransportProtos.GetFirmwareRequestMsg msg, TransportServiceCallback<TransportProtos.GetFirmwareResponseMsg> callback) {
+        if (checkLimits(sessionInfo, msg, callback)) {
+            TbProtoQueueMsg<TransportProtos.TransportApiRequestMsg> protoMsg =
+                    new TbProtoQueueMsg<>(UUID.randomUUID(), TransportProtos.TransportApiRequestMsg.newBuilder().setFirmwareRequestMsg(msg).build());
+
+            AsyncCallbackTemplate.withCallback(transportApiRequestTemplate.send(protoMsg), response -> {
+                TransportProtos.GetFirmwareResponseMsg firmwareResponseMsg = response.getValue().getFirmwareResponseMsg();
+                callback.onSuccess(firmwareResponseMsg);
+            }, callback::onError, transportCallbackExecutor);
+        }
+    }
+
     @Override
     public SessionMetaData reportActivity(TransportProtos.SessionInfoProto sessionInfo) {
         return reportActivityInternal(sessionInfo);
@@ -612,11 +624,11 @@ public class DefaultTransportService implements TransportService {
         sessions.remove(toSessionId(sessionInfo));
     }
 
-    private boolean checkLimits(TransportProtos.SessionInfoProto sessionInfo, Object msg, TransportServiceCallback<Void> callback) {
+    private boolean checkLimits(TransportProtos.SessionInfoProto sessionInfo, Object msg, TransportServiceCallback<?> callback) {
         return checkLimits(sessionInfo, msg, callback, 0);
     }
 
-    private boolean checkLimits(TransportProtos.SessionInfoProto sessionInfo, Object msg, TransportServiceCallback<Void> callback, int dataPoints) {
+    private boolean checkLimits(TransportProtos.SessionInfoProto sessionInfo, Object msg, TransportServiceCallback<?> callback, int dataPoints) {
         if (log.isTraceEnabled()) {
             log.trace("[{}] Processing msg: {}", toSessionId(sessionInfo), msg);
         }

dao/src/main/java/org/thingsboard/server/dao/device/DeviceDao.java

@@ -81,6 +81,8 @@ public interface DeviceDao extends Dao<Device>, TenantEntityDao {
      */
     PageData<Device> findDevicesByTenantIdAndType(UUID tenantId, String type, PageLink pageLink);
 
+    PageData<Device> findDevicesByTenantIdAndTypeAndEmptyFirmware(UUID tenantId, String type, PageLink pageLink);
+
     /**
      * Find device infos by tenantId, type and page link.
      *

dao/src/main/java/org/thingsboard/server/dao/device/DeviceProfileServiceImpl.java

@@ -42,6 +42,7 @@ import org.thingsboard.server.common.data.DeviceProfileInfo;
 import org.thingsboard.server.common.data.DeviceProfileProvisionType;
 import org.thingsboard.server.common.data.DeviceProfileType;
 import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.Firmware;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.device.profile.CoapDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.device.profile.CoapDeviceTypeConfiguration;
@@ -61,6 +62,7 @@ import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.dao.entity.AbstractEntityService;
 import org.thingsboard.server.dao.exception.DataValidationException;
+import org.thingsboard.server.dao.firmware.FirmwareService;
 import org.thingsboard.server.dao.service.DataValidator;
 import org.thingsboard.server.dao.service.PaginatedRemover;
 import org.thingsboard.server.dao.service.Validator;
@@ -111,6 +113,9 @@ public class DeviceProfileServiceImpl extends AbstractEntityService implements D
     @Autowired
     private CacheManager cacheManager;
 
+    @Autowired
+    private FirmwareService firmwareService;
+
     private final Lock findOrCreateLock = new ReentrantLock();
 
     @Cacheable(cacheNames = DEVICE_PROFILE_CACHE, key = "{#deviceProfileId.id}")
@@ -395,6 +400,15 @@ public class DeviceProfileServiceImpl extends AbstractEntityService implements D
                         }
                     }
 
+                    if (deviceProfile.getFirmwareId() != null) {
+                        Firmware firmware = firmwareService.findFirmwareById(tenantId, deviceProfile.getFirmwareId());
+                        if (firmware == null) {
+                            throw new DataValidationException("Can't assign non-existent firmware!");
+                        }
+                        if (firmware.getData() == null) {
+                            throw new DataValidationException("Can't assign firmware with empty data!");
+                        }
+                    }
                 }
 
                 @Override

dao/src/main/java/org/thingsboard/server/dao/device/DeviceServiceImpl.java

@@ -39,6 +39,7 @@ import org.thingsboard.server.common.data.DeviceProfile;
 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;
@@ -72,6 +73,7 @@ import org.thingsboard.server.dao.device.provision.ProvisionResponseStatus;
 import org.thingsboard.server.dao.entity.AbstractEntityService;
 import org.thingsboard.server.dao.event.EventService;
 import org.thingsboard.server.dao.exception.DataValidationException;
+import org.thingsboard.server.dao.firmware.FirmwareService;
 import org.thingsboard.server.dao.service.DataValidator;
 import org.thingsboard.server.dao.service.PaginatedRemover;
 import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
@@ -131,6 +133,9 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
     @Lazy
     private TbTenantProfileCache tenantProfileCache;
 
+    @Autowired
+    private FirmwareService firmwareService;
+
     @Override
     public DeviceInfo findDeviceInfoById(TenantId tenantId, DeviceId deviceId) {
         log.trace("Executing findDeviceInfoById [{}]", deviceId);
@@ -349,6 +354,15 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
         return deviceDao.findDevicesByTenantIdAndType(tenantId.getId(), type, pageLink);
     }
 
+    @Override
+    public PageData<Device> findDevicesByTenantIdAndTypeAndEmptyFirmware(TenantId tenantId, String type, PageLink pageLink) {
+        log.trace("Executing findDevicesByTenantIdAndType, tenantId [{}], type [{}], pageLink [{}]", tenantId, type, pageLink);
+        validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
+        validateString(type, "Incorrect type " + type);
+        validatePageLink(pageLink);
+        return deviceDao.findDevicesByTenantIdAndTypeAndEmptyFirmware(tenantId.getId(), type, pageLink);
+    }
+
     @Override
     public PageData<DeviceInfo> findDeviceInfosByTenantIdAndType(TenantId tenantId, String type, PageLink pageLink) {
         log.trace("Executing findDeviceInfosByTenantIdAndType, tenantId [{}], type [{}], pageLink [{}]", tenantId, type, pageLink);
@@ -663,6 +677,16 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                             throw new DataValidationException("Can't assign device to customer from different tenant!");
                         }
                     }
+
+                    if (device.getFirmwareId() != null) {
+                        Firmware firmware = firmwareService.findFirmwareById(tenantId, device.getFirmwareId());
+                        if (firmware == null) {
+                            throw new DataValidationException("Can't assign non-existent firmware!");
+                        }
+                        if (firmware.getData() == null) {
+                            throw new DataValidationException("Can't assign firmware with empty data!");
+                        }
+                    }
                 }
             };
 

dao/src/main/java/org/thingsboard/server/dao/firmware/BaseFirmwareService.java

@@ -0,0 +1,319 @@
+/**
+ * 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.dao.firmware;
+
+import com.google.common.hash.HashFunction;
+import com.google.common.hash.Hashing;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.hibernate.exception.ConstraintViolationException;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.common.data.FirmwareInfo;
+import org.thingsboard.server.common.data.Tenant;
+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.dao.exception.DataValidationException;
+import org.thingsboard.server.dao.service.DataValidator;
+import org.thingsboard.server.dao.service.PaginatedRemover;
+import org.thingsboard.server.dao.tenant.TenantDao;
+
+import java.nio.ByteBuffer;
+import java.util.Collections;
+import java.util.Optional;
+
+import static org.thingsboard.server.common.data.CacheConstants.FIRMWARE_CACHE;
+import static org.thingsboard.server.dao.service.Validator.validateId;
+import static org.thingsboard.server.dao.service.Validator.validatePageLink;
+
+@Service
+@Slf4j
+public class BaseFirmwareService implements FirmwareService {
+    public static final String INCORRECT_FIRMWARE_ID = "Incorrect firmwareId ";
+    public static final String INCORRECT_TENANT_ID = "Incorrect tenantId ";
+
+    private final TenantDao tenantDao;
+    private final FirmwareDao firmwareDao;
+    private final FirmwareInfoDao firmwareInfoDao;
+    private final CacheManager cacheManager;
+
+    public BaseFirmwareService(TenantDao tenantDao, FirmwareDao firmwareDao, FirmwareInfoDao firmwareInfoDao, CacheManager cacheManager) {
+        this.tenantDao = tenantDao;
+        this.firmwareDao = firmwareDao;
+        this.firmwareInfoDao = firmwareInfoDao;
+        this.cacheManager = cacheManager;
+    }
+
+    @Override
+    public FirmwareInfo saveFirmwareInfo(FirmwareInfo firmwareInfo) {
+        log.trace("Executing saveFirmwareInfo [{}]", firmwareInfo);
+        firmwareInfoValidator.validate(firmwareInfo, FirmwareInfo::getTenantId);
+        try {
+            FirmwareId firmwareId = firmwareInfo.getId();
+            if (firmwareId != null) {
+                cacheManager.getCache(FIRMWARE_CACHE).evict(firmwareId.toString());
+            }
+            return firmwareInfoDao.save(firmwareInfo.getTenantId(), firmwareInfo);
+        } catch (Exception t) {
+            ConstraintViolationException e = extractConstraintViolationException(t).orElse(null);
+            if (e != null && e.getConstraintName() != null && e.getConstraintName().equalsIgnoreCase("firmware_tenant_title_version_unq_key")) {
+                throw new DataValidationException("Firmware with such title and version already exists!");
+            } else {
+                throw t;
+            }
+        }
+    }
+
+    @Override
+    public Firmware saveFirmware(Firmware firmware) {
+        log.trace("Executing saveFirmware [{}]", firmware);
+        firmwareValidator.validate(firmware, FirmwareInfo::getTenantId);
+        try {
+            FirmwareId firmwareId = firmware.getId();
+            if (firmwareId != null) {
+                cacheManager.getCache(FIRMWARE_CACHE).evict(firmwareId.toString());
+            }
+            return firmwareDao.save(firmware.getTenantId(), firmware);
+        } catch (Exception t) {
+            ConstraintViolationException e = extractConstraintViolationException(t).orElse(null);
+            if (e != null && e.getConstraintName() != null && e.getConstraintName().equalsIgnoreCase("firmware_tenant_title_version_unq_key")) {
+                throw new DataValidationException("Firmware with such title and version already exists!");
+            } else {
+                throw t;
+            }
+        }
+    }
+
+    @Override
+    public Firmware findFirmwareById(TenantId tenantId, FirmwareId firmwareId) {
+        log.trace("Executing findFirmwareById [{}]", firmwareId);
+        validateId(firmwareId, INCORRECT_FIRMWARE_ID + firmwareId);
+        return firmwareDao.findById(tenantId, firmwareId.getId());
+    }
+
+    @Override
+    public FirmwareInfo findFirmwareInfoById(TenantId tenantId, FirmwareId firmwareId) {
+        log.trace("Executing findFirmwareInfoById [{}]", firmwareId);
+        validateId(firmwareId, INCORRECT_FIRMWARE_ID + firmwareId);
+        return firmwareInfoDao.findById(tenantId, firmwareId.getId());
+    }
+
+    @Override
+    public PageData<FirmwareInfo> findTenantFirmwaresByTenantId(TenantId tenantId, PageLink pageLink) {
+        log.trace("Executing findTenantFirmwaresByTenantId, tenantId [{}], pageLink [{}]", tenantId, pageLink);
+        validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
+        validatePageLink(pageLink);
+        return firmwareInfoDao.findFirmwareInfoByTenantId(tenantId, pageLink);
+    }
+
+    @Override
+    public PageData<FirmwareInfo> findTenantFirmwaresByTenantIdAndHasData(TenantId tenantId, boolean hasData, PageLink pageLink) {
+        log.trace("Executing findTenantFirmwaresByTenantIdAndHasData, tenantId [{}], hasData [{}] pageLink [{}]", tenantId, hasData, pageLink);
+        validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
+        validatePageLink(pageLink);
+        return firmwareInfoDao.findFirmwareInfoByTenantIdAndHasData(tenantId, hasData, pageLink);
+    }
+
+    @Override
+    public void deleteFirmware(TenantId tenantId, FirmwareId firmwareId) {
+        log.trace("Executing deleteFirmware [{}]", firmwareId);
+        validateId(firmwareId, INCORRECT_FIRMWARE_ID + firmwareId);
+        try {
+            Cache cache = cacheManager.getCache(FIRMWARE_CACHE);
+            cache.evict(Collections.singletonList(firmwareId));
+            firmwareDao.removeById(tenantId, firmwareId.getId());
+        } catch (Exception t) {
+            ConstraintViolationException e = extractConstraintViolationException(t).orElse(null);
+            if (e != null && e.getConstraintName() != null && e.getConstraintName().equalsIgnoreCase("fk_firmware_device")) {
+                throw new DataValidationException("The firmware referenced by the devices cannot be deleted!");
+            } else if (e != null && e.getConstraintName() != null && e.getConstraintName().equalsIgnoreCase("fk_firmware_device_profile")) {
+                throw new DataValidationException("The firmware referenced by the device profile cannot be deleted!");
+            } else {
+                throw t;
+            }
+        }
+    }
+
+    @Override
+    public void deleteFirmwaresByTenantId(TenantId tenantId) {
+        log.trace("Executing deleteFirmwaresByTenantId, tenantId [{}]", tenantId);
+        validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
+        tenantFirmwareRemover.removeEntities(tenantId, tenantId);
+    }
+
+    private DataValidator<FirmwareInfo> firmwareInfoValidator = new DataValidator<>() {
+
+        @Override
+        protected void validateDataImpl(TenantId tenantId, FirmwareInfo firmware) {
+            if (firmware.getTenantId() == null) {
+                throw new DataValidationException("Firmware should be assigned to tenant!");
+            } else {
+                Tenant tenant = tenantDao.findById(firmware.getTenantId(), firmware.getTenantId().getId());
+                if (tenant == null) {
+                    throw new DataValidationException("Firmware is referencing to non-existent tenant!");
+                }
+            }
+
+            if (StringUtils.isEmpty(firmware.getTitle())) {
+                throw new DataValidationException("Firmware title should be specified!");
+            }
+
+            if (StringUtils.isEmpty(firmware.getVersion())) {
+                throw new DataValidationException("Firmware version should be specified!");
+            }
+        }
+
+        @Override
+        protected void validateUpdate(TenantId tenantId, FirmwareInfo firmware) {
+            FirmwareInfo firmwareOld = firmwareInfoDao.findById(tenantId, firmware.getUuidId());
+
+            BaseFirmwareService.validateUpdate(firmware, firmwareOld);
+        }
+    };
+
+    private DataValidator<Firmware> firmwareValidator = new DataValidator<>() {
+
+        @Override
+        protected void validateDataImpl(TenantId tenantId, Firmware firmware) {
+            if (firmware.getTenantId() == null) {
+                throw new DataValidationException("Firmware should be assigned to tenant!");
+            } else {
+                Tenant tenant = tenantDao.findById(firmware.getTenantId(), firmware.getTenantId().getId());
+                if (tenant == null) {
+                    throw new DataValidationException("Firmware is referencing to non-existent tenant!");
+                }
+            }
+
+            if (StringUtils.isEmpty(firmware.getTitle())) {
+                throw new DataValidationException("Firmware title should be specified!");
+            }
+
+            if (StringUtils.isEmpty(firmware.getVersion())) {
+                throw new DataValidationException("Firmware version should be specified!");
+            }
+
+            if (StringUtils.isEmpty(firmware.getFileName())) {
+                throw new DataValidationException("Firmware file name should be specified!");
+            }
+
+            if (StringUtils.isEmpty(firmware.getContentType())) {
+                throw new DataValidationException("Firmware content type should be specified!");
+            }
+
+            ByteBuffer data = firmware.getData();
+            if (data == null || !data.hasArray() || data.array().length == 0) {
+                throw new DataValidationException("Firmware data should be specified!");
+            }
+
+            if (StringUtils.isEmpty(firmware.getChecksumAlgorithm())) {
+                throw new DataValidationException("Firmware checksum algorithm should be specified!");
+            }
+            if (StringUtils.isEmpty(firmware.getChecksum())) {
+                throw new DataValidationException("Firmware checksum should be specified!");
+            }
+
+            HashFunction hashFunction;
+            switch (firmware.getChecksumAlgorithm()) {
+                case "sha256":
+                    hashFunction = Hashing.sha256();
+                    break;
+                case "md5":
+                    hashFunction = Hashing.md5();
+                    break;
+                case "crc32":
+                    hashFunction = Hashing.crc32();
+                    break;
+                default:
+                    throw new DataValidationException("Unknown checksum algorithm!");
+            }
+
+            String currentChecksum = hashFunction.hashBytes(data.array()).toString();
+
+            if (!currentChecksum.equals(firmware.getChecksum())) {
+                throw new DataValidationException("Wrong firmware file!");
+            }
+        }
+
+        @Override
+        protected void validateUpdate(TenantId tenantId, Firmware firmware) {
+            Firmware firmwareOld = firmwareDao.findById(tenantId, firmware.getUuidId());
+
+            BaseFirmwareService.validateUpdate(firmware, firmwareOld);
+
+            if (firmwareOld.getData() != null && !firmwareOld.getData().equals(firmware.getData())) {
+                throw new DataValidationException("Updating firmware data is prohibited!");
+            }
+        }
+    };
+
+    private static void validateUpdate(FirmwareInfo firmware, FirmwareInfo firmwareOld) {
+        if (!firmwareOld.getTitle().equals(firmware.getTitle())) {
+            throw new DataValidationException("Updating firmware title is prohibited!");
+        }
+
+        if (!firmwareOld.getVersion().equals(firmware.getVersion())) {
+            throw new DataValidationException("Updating firmware version is prohibited!");
+        }
+
+        if (firmwareOld.getFileName() != null && !firmwareOld.getFileName().equals(firmware.getFileName())) {
+            throw new DataValidationException("Updating firmware file name is prohibited!");
+        }
+
+        if (firmwareOld.getContentType() != null && !firmwareOld.getContentType().equals(firmware.getContentType())) {
+            throw new DataValidationException("Updating firmware content type is prohibited!");
+        }
+
+        if (firmwareOld.getChecksumAlgorithm() != null && !firmwareOld.getChecksumAlgorithm().equals(firmware.getChecksumAlgorithm())) {
+            throw new DataValidationException("Updating firmware content type is prohibited!");
+        }
+
+        if (firmwareOld.getChecksum() != null && !firmwareOld.getChecksum().equals(firmware.getChecksum())) {
+            throw new DataValidationException("Updating firmware content type is prohibited!");
+        }
+
+        if (firmwareOld.getDataSize() != null && !firmwareOld.getDataSize().equals(firmware.getDataSize())) {
+            throw new DataValidationException("Updating firmware data size is prohibited!");
+        }
+    }
+
+    private PaginatedRemover<TenantId, FirmwareInfo> tenantFirmwareRemover =
+            new PaginatedRemover<>() {
+
+                @Override
+                protected PageData<FirmwareInfo> findEntities(TenantId tenantId, TenantId id, PageLink pageLink) {
+                    return firmwareInfoDao.findFirmwareInfoByTenantId(id, pageLink);
+                }
+
+                @Override
+                protected void removeEntity(TenantId tenantId, FirmwareInfo entity) {
+                    deleteFirmware(tenantId, entity.getId());
+                }
+            };
+
+    protected Optional<ConstraintViolationException> extractConstraintViolationException(Exception t) {
+        if (t instanceof ConstraintViolationException) {
+            return Optional.of((ConstraintViolationException) t);
+        } else if (t.getCause() instanceof ConstraintViolationException) {
+            return Optional.of((ConstraintViolationException) (t.getCause()));
+        } else {
+            return Optional.empty();
+        }
+    }
+}

dao/src/main/java/org/thingsboard/server/dao/firmware/FirmwareDao.java

@@ -0,0 +1,23 @@
+/**
+ * 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.dao.firmware;
+
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.dao.Dao;
+
+public interface FirmwareDao extends Dao<Firmware> {
+
+}

dao/src/main/java/org/thingsboard/server/dao/firmware/FirmwareInfoDao.java

@@ -0,0 +1,32 @@
+/**
+ * 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.dao.firmware;
+
+import org.thingsboard.server.common.data.FirmwareInfo;
+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.dao.Dao;
+
+import java.util.UUID;
+
+public interface FirmwareInfoDao extends Dao<FirmwareInfo> {
+
+    PageData<FirmwareInfo> findFirmwareInfoByTenantId(TenantId tenantId, PageLink pageLink);
+
+    PageData<FirmwareInfo> findFirmwareInfoByTenantIdAndHasData(TenantId tenantId, boolean hasData, PageLink pageLink);
+
+}

dao/src/main/java/org/thingsboard/server/dao/model/ModelConstants.java

@@ -153,6 +153,7 @@ public class ModelConstants {
     public static final String DEVICE_ADDITIONAL_INFO_PROPERTY = ADDITIONAL_INFO_PROPERTY;
     public static final String DEVICE_DEVICE_PROFILE_ID_PROPERTY = "device_profile_id";
     public static final String DEVICE_DEVICE_DATA_PROPERTY = "device_data";
+    public static final String DEVICE_FIRMWARE_ID_PROPERTY = "firmware_id";
 
     public static final String DEVICE_BY_TENANT_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME = "device_by_tenant_and_search_text";
     public static final String DEVICE_BY_TENANT_BY_TYPE_AND_SEARCH_TEXT_COLUMN_FAMILY_NAME = "device_by_tenant_by_type_and_search_text";
@@ -176,6 +177,7 @@ public class ModelConstants {
     public static final String DEVICE_PROFILE_DEFAULT_RULE_CHAIN_ID_PROPERTY = "default_rule_chain_id";
     public static final String DEVICE_PROFILE_DEFAULT_QUEUE_NAME_PROPERTY = "default_queue_name";
     public static final String DEVICE_PROFILE_PROVISION_DEVICE_KEY = "provision_device_key";
+    public static final String DEVICE_PROFILE_FIRMWARE_ID_PROPERTY = "firmware_id";
 
     /**
      * Cassandra entityView constants.
@@ -469,6 +471,22 @@ public class ModelConstants {
     public static final String RESOURCE_FILE_NAME_COLUMN = "file_name";
     public static final String RESOURCE_DATA_COLUMN = "data";
 
+    /**
+     * Firmware constants.
+     */
+    public static final String FIRMWARE_TABLE_NAME = "firmware";
+    public static final String FIRMWARE_TENANT_ID_COLUMN = TENANT_ID_COLUMN;
+    public static final String FIRMWARE_TITLE_COLUMN = TITLE_PROPERTY;
+    public static final String FIRMWARE_VERSION_COLUMN = "version";
+    public static final String FIRMWARE_FILE_NAME_COLUMN = "file_name";
+    public static final String FIRMWARE_CONTENT_TYPE_COLUMN = "content_type";
+    public static final String FIRMWARE_CHECKSUM_ALGORITHM_COLUMN = "checksum_algorithm";
+    public static final String FIRMWARE_CHECKSUM_COLUMN = "checksum";
+    public static final String FIRMWARE_DATA_COLUMN = "data";
+    public static final String FIRMWARE_DATA_SIZE_COLUMN = "data_size";
+    public static final String FIRMWARE_ADDITIONAL_INFO_COLUMN = ADDITIONAL_INFO_PROPERTY;
+    public static final String FIRMWARE_HAS_DATA_PROPERTY = "has_data";
+
     /**
      * Edge constants.
      */

dao/src/main/java/org/thingsboard/server/dao/model/sql/AbstractDeviceEntity.java

@@ -27,6 +27,7 @@ import org.thingsboard.server.common.data.device.data.DeviceData;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.DeviceId;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.FirmwareId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.model.BaseSqlEntity;
 import org.thingsboard.server.dao.model.ModelConstants;
@@ -73,6 +74,9 @@ public abstract class AbstractDeviceEntity<T extends Device> extends BaseSqlEnti
     @Column(name = ModelConstants.DEVICE_DEVICE_PROFILE_ID_PROPERTY, columnDefinition = "uuid")
     private UUID deviceProfileId;
 
+    @Column(name = ModelConstants.DEVICE_FIRMWARE_ID_PROPERTY, columnDefinition = "uuid")
+    private UUID firmwareId;
+
     @Type(type = "jsonb")
     @Column(name = ModelConstants.DEVICE_DEVICE_DATA_PROPERTY, columnDefinition = "jsonb")
     private JsonNode deviceData;
@@ -95,6 +99,9 @@ public abstract class AbstractDeviceEntity<T extends Device> extends BaseSqlEnti
         if (device.getDeviceProfileId() != null) {
             this.deviceProfileId = device.getDeviceProfileId().getId();
         }
+        if (device.getFirmwareId() != null) {
+            this.firmwareId = device.getFirmwareId().getId();
+        }
         this.deviceData = JacksonUtil.convertValue(device.getDeviceData(), ObjectNode.class);
         this.name = device.getName();
         this.type = device.getType();
@@ -114,6 +121,7 @@ public abstract class AbstractDeviceEntity<T extends Device> extends BaseSqlEnti
         this.label = deviceEntity.getLabel();
         this.searchText = deviceEntity.getSearchText();
         this.additionalInfo = deviceEntity.getAdditionalInfo();
+        this.firmwareId = deviceEntity.getFirmwareId();
     }
 
     @Override
@@ -138,6 +146,9 @@ public abstract class AbstractDeviceEntity<T extends Device> extends BaseSqlEnti
         if (deviceProfileId != null) {
             device.setDeviceProfileId(new DeviceProfileId(deviceProfileId));
         }
+        if (firmwareId != null) {
+            device.setFirmwareId(new FirmwareId(firmwareId));
+        }
         device.setDeviceData(JacksonUtil.convertValue(deviceData, DeviceData.class));
         device.setName(name);
         device.setType(type);

dao/src/main/java/org/thingsboard/server/dao/model/sql/DeviceProfileEntity.java

@@ -27,6 +27,7 @@ import org.thingsboard.server.common.data.DeviceProfileProvisionType;
 import org.thingsboard.server.common.data.DeviceTransportType;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
 import org.thingsboard.server.common.data.id.DeviceProfileId;
+import org.thingsboard.server.common.data.id.FirmwareId;
 import org.thingsboard.server.common.data.id.RuleChainId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.model.BaseSqlEntity;
@@ -89,6 +90,9 @@ public final class DeviceProfileEntity extends BaseSqlEntity<DeviceProfile> impl
     @Column(name=ModelConstants.DEVICE_PROFILE_PROVISION_DEVICE_KEY)
     private String provisionDeviceKey;
 
+    @Column(name=ModelConstants.DEVICE_PROFILE_FIRMWARE_ID_PROPERTY)
+    private UUID firmwareId;
+
     public DeviceProfileEntity() {
         super();
     }
@@ -113,6 +117,9 @@ public final class DeviceProfileEntity extends BaseSqlEntity<DeviceProfile> impl
         }
         this.defaultQueueName = deviceProfile.getDefaultQueueName();
         this.provisionDeviceKey = deviceProfile.getProvisionDeviceKey();
+        if (deviceProfile.getFirmwareId() != null) {
+            this.firmwareId = deviceProfile.getFirmwareId().getId();
+        }
     }
 
     @Override
@@ -148,6 +155,11 @@ public final class DeviceProfileEntity extends BaseSqlEntity<DeviceProfile> impl
         }
         deviceProfile.setDefaultQueueName(defaultQueueName);
         deviceProfile.setProvisionDeviceKey(provisionDeviceKey);
+
+        if (firmwareId != null) {
+            deviceProfile.setFirmwareId(new FirmwareId(firmwareId));
+        }
+
         return deviceProfile;
     }
 }

dao/src/main/java/org/thingsboard/server/dao/model/sql/FirmwareEntity.java

@@ -0,0 +1,138 @@
+/**
+ * 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.dao.model.sql;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.hibernate.annotations.Type;
+import org.hibernate.annotations.TypeDef;
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.common.data.id.FirmwareId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.dao.model.BaseSqlEntity;
+import org.thingsboard.server.dao.model.ModelConstants;
+import org.thingsboard.server.dao.model.SearchTextEntity;
+import org.thingsboard.server.dao.util.mapping.JsonStringType;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import java.nio.ByteBuffer;
+import java.util.UUID;
+
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_CHECKSUM_ALGORITHM_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_CHECKSUM_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_CONTENT_TYPE_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_DATA_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_DATA_SIZE_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_FILE_NAME_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_TABLE_NAME;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_TENANT_ID_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_TITLE_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_VERSION_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.SEARCH_TEXT_PROPERTY;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Entity
+@TypeDef(name = "json", typeClass = JsonStringType.class)
+@Table(name = FIRMWARE_TABLE_NAME)
+public class FirmwareEntity extends BaseSqlEntity<Firmware> implements SearchTextEntity<Firmware> {
+
+    @Column(name = FIRMWARE_TENANT_ID_COLUMN)
+    private UUID tenantId;
+
+    @Column(name = FIRMWARE_TITLE_COLUMN)
+    private String title;
+
+    @Column(name = FIRMWARE_VERSION_COLUMN)
+    private String version;
+
+    @Column(name = FIRMWARE_FILE_NAME_COLUMN)
+    private String fileName;
+
+    @Column(name = FIRMWARE_CONTENT_TYPE_COLUMN)
+    private String contentType;
+
+    @Column(name = FIRMWARE_CHECKSUM_ALGORITHM_COLUMN)
+    private String checksumAlgorithm;
+
+    @Column(name = FIRMWARE_CHECKSUM_COLUMN)
+    private String checksum;
+
+    @Column(name = FIRMWARE_DATA_COLUMN, columnDefinition = "BINARY")
+    private byte[] data;
+
+    @Column(name = FIRMWARE_DATA_SIZE_COLUMN)
+    private Long dataSize;
+
+    @Type(type = "json")
+    @Column(name = ModelConstants.FIRMWARE_ADDITIONAL_INFO_COLUMN)
+    private JsonNode additionalInfo;
+
+    @Column(name = SEARCH_TEXT_PROPERTY)
+    private String searchText;
+
+    public FirmwareEntity() {
+        super();
+    }
+
+    public FirmwareEntity(Firmware firmware) {
+        this.createdTime = firmware.getCreatedTime();
+        this.setUuid(firmware.getUuidId());
+        this.tenantId = firmware.getTenantId().getId();
+        this.title = firmware.getTitle();
+        this.version = firmware.getVersion();
+        this.fileName = firmware.getFileName();
+        this.contentType = firmware.getContentType();
+        this.checksumAlgorithm = firmware.getChecksumAlgorithm();
+        this.checksum = firmware.getChecksum();
+        this.data = firmware.getData().array();
+        this.dataSize = firmware.getDataSize();
+        this.additionalInfo = firmware.getAdditionalInfo();
+    }
+
+    @Override
+    public String getSearchTextSource() {
+        return title;
+    }
+
+    @Override
+    public void setSearchText(String searchText) {
+        this.searchText = searchText;
+    }
+
+    @Override
+    public Firmware toData() {
+        Firmware firmware = new Firmware(new FirmwareId(id));
+        firmware.setCreatedTime(createdTime);
+        firmware.setTenantId(new TenantId(tenantId));
+        firmware.setTitle(title);
+        firmware.setVersion(version);
+        firmware.setFileName(fileName);
+        firmware.setContentType(contentType);
+        firmware.setChecksumAlgorithm(checksumAlgorithm);
+        firmware.setChecksum(checksum);
+        firmware.setDataSize(dataSize);
+        if (data != null) {
+            firmware.setData(ByteBuffer.wrap(data));
+            firmware.setHasData(true);
+        }
+        firmware.setAdditionalInfo(additionalInfo);
+        return firmware;
+    }
+}

dao/src/main/java/org/thingsboard/server/dao/model/sql/FirmwareInfoEntity.java

@@ -0,0 +1,153 @@
+/**
+ * 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.dao.model.sql;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.hibernate.annotations.Type;
+import org.hibernate.annotations.TypeDef;
+import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.common.data.FirmwareInfo;
+import org.thingsboard.server.common.data.id.FirmwareId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.dao.model.BaseSqlEntity;
+import org.thingsboard.server.dao.model.ModelConstants;
+import org.thingsboard.server.dao.model.SearchTextEntity;
+import org.thingsboard.server.dao.util.mapping.JsonStringType;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+import javax.persistence.Transient;
+import java.util.UUID;
+
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_CHECKSUM_ALGORITHM_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_CHECKSUM_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_CONTENT_TYPE_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_DATA_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_DATA_SIZE_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_FILE_NAME_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_HAS_DATA_PROPERTY;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_TABLE_NAME;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_TENANT_ID_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_TITLE_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.FIRMWARE_VERSION_COLUMN;
+import static org.thingsboard.server.dao.model.ModelConstants.SEARCH_TEXT_PROPERTY;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@Entity
+@TypeDef(name = "json", typeClass = JsonStringType.class)
+@Table(name = FIRMWARE_TABLE_NAME)
+public class FirmwareInfoEntity extends BaseSqlEntity<FirmwareInfo> implements SearchTextEntity<FirmwareInfo> {
+
+    @Column(name = FIRMWARE_TENANT_ID_COLUMN)
+    private UUID tenantId;
+
+    @Column(name = FIRMWARE_TITLE_COLUMN)
+    private String title;
+
+    @Column(name = FIRMWARE_VERSION_COLUMN)
+    private String version;
+
+    @Column(name = FIRMWARE_FILE_NAME_COLUMN)
+    private String fileName;
+
+    @Column(name = FIRMWARE_CONTENT_TYPE_COLUMN)
+    private String contentType;
+
+    @Column(name = FIRMWARE_CHECKSUM_ALGORITHM_COLUMN)
+    private String checksumAlgorithm;
+
+    @Column(name = FIRMWARE_CHECKSUM_COLUMN)
+    private String checksum;
+
+    @Column(name = FIRMWARE_DATA_SIZE_COLUMN)
+    private Long dataSize;
+
+    @Type(type = "json")
+    @Column(name = ModelConstants.FIRMWARE_ADDITIONAL_INFO_COLUMN)
+    private JsonNode additionalInfo;
+
+    @Column(name = SEARCH_TEXT_PROPERTY)
+    private String searchText;
+
+    @Transient
+    private boolean hasData;
+
+    public FirmwareInfoEntity() {
+        super();
+    }
+
+    public FirmwareInfoEntity(FirmwareInfo firmware) {
+        this.createdTime = firmware.getCreatedTime();
+        this.setUuid(firmware.getUuidId());
+        this.tenantId = firmware.getTenantId().getId();
+        this.title = firmware.getTitle();
+        this.version = firmware.getVersion();
+        this.fileName = firmware.getFileName();
+        this.contentType = firmware.getContentType();
+        this.checksumAlgorithm = firmware.getChecksumAlgorithm();
+        this.checksum = firmware.getChecksum();
+        this.dataSize = firmware.getDataSize();
+        this.additionalInfo = firmware.getAdditionalInfo();
+    }
+
+    public FirmwareInfoEntity(UUID id, long createdTime, UUID tenantId, String title, String version,
+                              String fileName, String contentType, String checksumAlgorithm, String checksum, Long dataSize,
+                              Object additionalInfo, boolean hasData) {
+        this.id = id;
+        this.createdTime = createdTime;
+        this.tenantId = tenantId;
+        this.title = title;
+        this.version = version;
+        this.fileName = fileName;
+        this.contentType = contentType;
+        this.checksumAlgorithm = checksumAlgorithm;
+        this.checksum = checksum;
+        this.dataSize = dataSize;
+        this.hasData = hasData;
+        this.additionalInfo = JacksonUtil.convertValue(additionalInfo, JsonNode.class);
+    }
+
+    @Override
+    public String getSearchTextSource() {
+        return title;
+    }
+
+    @Override
+    public void setSearchText(String searchText) {
+        this.searchText = searchText;
+    }
+
+    @Override
+    public FirmwareInfo toData() {
+        FirmwareInfo firmware = new FirmwareInfo(new FirmwareId(id));
+        firmware.setCreatedTime(createdTime);
+        firmware.setTenantId(new TenantId(tenantId));
+        firmware.setTitle(title);
+        firmware.setVersion(version);
+        firmware.setFileName(fileName);
+        firmware.setContentType(contentType);
+        firmware.setChecksumAlgorithm(checksumAlgorithm);
+        firmware.setChecksum(checksum);
+        firmware.setDataSize(dataSize);
+        firmware.setAdditionalInfo(additionalInfo);
+        firmware.setHasData(hasData);
+        return firmware;
+    }
+}

dao/src/main/java/org/thingsboard/server/dao/sql/device/DeviceRepository.java

@@ -94,6 +94,15 @@ public interface DeviceRepository extends PagingAndSortingRepository<DeviceEntit
                                              @Param("textSearch") String textSearch,
                                              Pageable pageable);
 
+    @Query("SELECT d FROM DeviceEntity d WHERE d.tenantId = :tenantId " +
+            "AND d.type = :type " +
+            "AND d.firmwareId = null " +
+            "AND LOWER(d.searchText) LIKE LOWER(CONCAT(:textSearch, '%'))")
+    Page<DeviceEntity> findByTenantIdAndTypeAndFirmwareIdIsNull(@Param("tenantId") UUID tenantId,
+                                             @Param("type") String type,
+                                             @Param("textSearch") String textSearch,
+                                             Pageable pageable);
+
     @Query("SELECT new org.thingsboard.server.dao.model.sql.DeviceInfoEntity(d, c.title, c.additionalInfo, p.name) " +
             "FROM DeviceEntity d " +
             "LEFT JOIN CustomerEntity c on c.id = d.customerId " +

dao/src/main/java/org/thingsboard/server/dao/sql/device/JpaDeviceDao.java

@@ -149,6 +149,16 @@ public class JpaDeviceDao extends JpaAbstractSearchTextDao<DeviceEntity, Device>
                         DaoUtil.toPageable(pageLink)));
     }
 
+    @Override
+    public PageData<Device> findDevicesByTenantIdAndTypeAndEmptyFirmware(UUID tenantId, String type, PageLink pageLink) {
+        return DaoUtil.toPageData(
+                deviceRepository.findByTenantIdAndTypeAndFirmwareIdIsNull(
+                        tenantId,
+                        type,
+                        Objects.toString(pageLink.getTextSearch(), ""),
+                        DaoUtil.toPageable(pageLink)));
+    }
+
     @Override
     public PageData<DeviceInfo> findDeviceInfosByTenantIdAndType(UUID tenantId, String type, PageLink pageLink) {
         return DaoUtil.toPageData(

dao/src/main/java/org/thingsboard/server/dao/sql/firmware/FirmwareInfoRepository.java

@@ -0,0 +1,46 @@
+/**
+ * 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.dao.sql.firmware;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.query.Param;
+import org.thingsboard.server.dao.model.sql.FirmwareInfoEntity;
+
+import java.util.UUID;
+
+public interface FirmwareInfoRepository extends CrudRepository<FirmwareInfoEntity, UUID> {
+    @Query("SELECT new FirmwareInfoEntity(f.id, f.createdTime, f.tenantId, f.title, f.version, f.fileName, f.contentType, f.checksumAlgorithm, f.checksum, f.dataSize, f.additionalInfo, f.data IS NOT NULL) FROM FirmwareEntity f WHERE " +
+            "f.tenantId = :tenantId " +
+            "AND LOWER(f.searchText) LIKE LOWER(CONCAT(:searchText, '%'))")
+    Page<FirmwareInfoEntity> findAllByTenantId(@Param("tenantId") UUID tenantId,
+                                               @Param("searchText") String searchText,
+                                               Pageable pageable);
+
+    @Query("SELECT new FirmwareInfoEntity(f.id, f.createdTime, f.tenantId, f.title, f.version, f.fileName, f.contentType, f.checksumAlgorithm, f.checksum, f.dataSize, f.additionalInfo, f.data IS NOT NULL) FROM FirmwareEntity f WHERE " +
+            "f.tenantId = :tenantId " +
+            "AND ((f.data IS NOT NULL AND :hasData = true) OR (f.data IS NULL AND :hasData = false ))" +
+            "AND LOWER(f.searchText) LIKE LOWER(CONCAT(:searchText, '%'))")
+    Page<FirmwareInfoEntity> findAllByTenantIdAndHasData(@Param("tenantId") UUID tenantId,
+                                                         @Param("hasData") boolean hasData,
+                                                         @Param("searchText") String searchText,
+                                                         Pageable pageable);
+
+    @Query("SELECT new FirmwareInfoEntity(f.id, f.createdTime, f.tenantId, f.title, f.version, f.fileName, f.contentType, f.checksumAlgorithm, f.checksum, f.dataSize, f.additionalInfo, f.data IS NOT NULL) FROM FirmwareEntity f WHERE f.id = :id")
+    FirmwareInfoEntity findFirmwareInfoById(@Param("id") UUID id);
+}

dao/src/main/java/org/thingsboard/server/dao/sql/firmware/FirmwareRepository.java

@@ -0,0 +1,24 @@
+/**
+ * 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.dao.sql.firmware;
+
+import org.springframework.data.repository.CrudRepository;
+import org.thingsboard.server.dao.model.sql.FirmwareEntity;
+
+import java.util.UUID;
+
+public interface FirmwareRepository extends CrudRepository<FirmwareEntity, UUID> {
+}

dao/src/main/java/org/thingsboard/server/dao/sql/firmware/JpaFirmwareDao.java

@@ -0,0 +1,46 @@
+/**
+ * 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.dao.sql.firmware;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.Firmware;
+import org.thingsboard.server.dao.firmware.FirmwareDao;
+import org.thingsboard.server.dao.model.sql.FirmwareEntity;
+import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
+
+import java.util.UUID;
+
+@Slf4j
+@Component
+public class JpaFirmwareDao extends JpaAbstractSearchTextDao<FirmwareEntity, Firmware> implements FirmwareDao {
+
+    @Autowired
+    private FirmwareRepository firmwareRepository;
+
+    @Override
+    protected Class<FirmwareEntity> getEntityClass() {
+        return FirmwareEntity.class;
+    }
+
+    @Override
+    protected CrudRepository<FirmwareEntity, UUID> getCrudRepository() {
+        return firmwareRepository;
+    }
+
+}

dao/src/main/java/org/thingsboard/server/dao/sql/firmware/JpaFirmwareInfoDao.java

@@ -0,0 +1,84 @@
+/**
+ * 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.dao.sql.firmware;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.FirmwareInfo;
+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.dao.DaoUtil;
+import org.thingsboard.server.dao.firmware.FirmwareInfoDao;
+import org.thingsboard.server.dao.model.sql.FirmwareInfoEntity;
+import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
+
+import java.util.Objects;
+import java.util.UUID;
+
+@Slf4j
+@Component
+public class JpaFirmwareInfoDao extends JpaAbstractSearchTextDao<FirmwareInfoEntity, FirmwareInfo> implements FirmwareInfoDao {
+
+    @Autowired
+    private FirmwareInfoRepository firmwareInfoRepository;
+
+    @Override
+    protected Class<FirmwareInfoEntity> getEntityClass() {
+        return FirmwareInfoEntity.class;
+    }
+
+    @Override
+    protected CrudRepository<FirmwareInfoEntity, UUID> getCrudRepository() {
+        return firmwareInfoRepository;
+    }
+
+    @Override
+    public FirmwareInfo findById(TenantId tenantId, UUID id) {
+        return DaoUtil.getData(firmwareInfoRepository.findFirmwareInfoById(id));
+    }
+
+    @Override
+    public FirmwareInfo save(TenantId tenantId, FirmwareInfo firmwareInfo) {
+        FirmwareInfo savedFirmware = super.save(tenantId, firmwareInfo);
+        if (firmwareInfo.getId() == null) {
+            return savedFirmware;
+        } else {
+            return findById(tenantId, savedFirmware.getId().getId());
+        }
+    }
+
+    @Override
+    public PageData<FirmwareInfo> findFirmwareInfoByTenantId(TenantId tenantId, PageLink pageLink) {
+        return DaoUtil.toPageData(firmwareInfoRepository
+                .findAllByTenantId(
+                        tenantId.getId(),
+                        Objects.toString(pageLink.getTextSearch(), ""),
+                        DaoUtil.toPageable(pageLink)));
+    }
+
+    @Override
+    public PageData<FirmwareInfo> findFirmwareInfoByTenantIdAndHasData(TenantId tenantId, boolean hasData, PageLink pageLink) {
+        return DaoUtil.toPageData(firmwareInfoRepository
+                .findAllByTenantIdAndHasData(
+                        tenantId.getId(),
+                        hasData,
+                        Objects.toString(pageLink.getTextSearch(), ""),
+                        DaoUtil.toPageable(pageLink)));
+    }
+}

dao/src/main/java/org/thingsboard/server/dao/sql/resource/TbResourceRepository.java

@@ -48,8 +48,6 @@ public interface TbResourceRepository extends CrudRepository<TbResourceEntity, U
             @Param("searchText") String search,
             Pageable pageable);
 
-    void removeAllByTenantId(UUID tenantId);
-
     @Query("SELECT tr FROM TbResourceEntity tr " +
             "WHERE tr.resourceType = :resourceType " +
             "AND LOWER(tr.searchText) LIKE LOWER(CONCAT('%', :searchText, '%')) " +

dao/src/main/resources/sql/schema-entities-hsql.sql

@@ -158,6 +158,23 @@ CREATE TABLE IF NOT EXISTS rule_node_state (
     CONSTRAINT fk_rule_node_state_node_id FOREIGN KEY (rule_node_id) REFERENCES rule_node(id) ON DELETE CASCADE
 );
 
+CREATE TABLE IF NOT EXISTS firmware (
+    id uuid NOT NULL CONSTRAINT firmware_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid NOT NULL,
+    title varchar(255) NOT NULL,
+    version varchar(255) NOT NULL,
+    file_name varchar(255),
+    content_type varchar(255),
+    checksum_algorithm varchar(32),
+    checksum varchar(1020),
+    data binary,
+    data_size bigint,
+    additional_info varchar,
+    search_text varchar(255),
+    CONSTRAINT firmware_tenant_title_version_unq_key UNIQUE (tenant_id, title, version)
+);
+
 CREATE TABLE IF NOT EXISTS device_profile (
     id uuid NOT NULL CONSTRAINT device_profile_pkey PRIMARY KEY,
     created_time bigint NOT NULL,
@@ -170,12 +187,14 @@ CREATE TABLE IF NOT EXISTS device_profile (
     search_text varchar(255),
     is_default boolean,
     tenant_id uuid,
+    firmware_id uuid,
     default_rule_chain_id uuid,
     default_queue_name varchar(255),
     provision_device_key varchar,
     CONSTRAINT device_profile_name_unq_key UNIQUE (tenant_id, name),
     CONSTRAINT device_provision_key_unq_key UNIQUE (provision_device_key),
-    CONSTRAINT fk_default_rule_chain_device_profile FOREIGN KEY (default_rule_chain_id) REFERENCES rule_chain(id)
+    CONSTRAINT fk_default_rule_chain_device_profile FOREIGN KEY (default_rule_chain_id) REFERENCES rule_chain(id),
+    CONSTRAINT fk_firmware_device_profile FOREIGN KEY (firmware_id) REFERENCES firmware(id)
 );
 
 CREATE TABLE IF NOT EXISTS device (
@@ -190,8 +209,10 @@ CREATE TABLE IF NOT EXISTS device (
     label varchar(255),
     search_text varchar(255),
     tenant_id uuid,
+    firmware_id uuid,
     CONSTRAINT device_name_unq_key UNIQUE (tenant_id, name),
-    CONSTRAINT fk_device_profile FOREIGN KEY (device_profile_id) REFERENCES device_profile(id)
+    CONSTRAINT fk_device_profile FOREIGN KEY (device_profile_id) REFERENCES device_profile(id),
+    CONSTRAINT fk_firmware_device FOREIGN KEY (firmware_id) REFERENCES firmware(id)
 );
 
 CREATE TABLE IF NOT EXISTS device_credentials (

dao/src/main/resources/sql/schema-entities.sql

@@ -25,7 +25,7 @@ CREATE OR REPLACE PROCEDURE insert_tb_schema_settings()
 $$
 BEGIN
     IF (SELECT COUNT(*) FROM tb_schema_settings) = 0 THEN
-        INSERT INTO tb_schema_settings (schema_version) VALUES (3002000);
+        INSERT INTO tb_schema_settings (schema_version) VALUES (3003000);
     END IF;
 END;
 $$;
@@ -176,6 +176,23 @@ CREATE TABLE IF NOT EXISTS rule_node_state (
     CONSTRAINT fk_rule_node_state_node_id FOREIGN KEY (rule_node_id) REFERENCES rule_node(id) ON DELETE CASCADE
 );
 
+CREATE TABLE IF NOT EXISTS firmware (
+    id uuid NOT NULL CONSTRAINT firmware_pkey PRIMARY KEY,
+    created_time bigint NOT NULL,
+    tenant_id uuid NOT NULL,
+    title varchar(255) NOT NULL,
+    version varchar(255) NOT NULL,
+    file_name varchar(255),
+    content_type varchar(255),
+    checksum_algorithm varchar(32),
+    checksum varchar(1020),
+    data bytea,
+    data_size bigint,
+    additional_info varchar,
+    search_text varchar(255),
+    CONSTRAINT firmware_tenant_title_version_unq_key UNIQUE (tenant_id, title, version)
+);
+
 CREATE TABLE IF NOT EXISTS device_profile (
     id uuid NOT NULL CONSTRAINT device_profile_pkey PRIMARY KEY,
     created_time bigint NOT NULL,
@@ -188,12 +205,14 @@ CREATE TABLE IF NOT EXISTS device_profile (
     search_text varchar(255),
     is_default boolean,
     tenant_id uuid,
+    firmware_id uuid,
     default_rule_chain_id uuid,
     default_queue_name varchar(255),
     provision_device_key varchar,
     CONSTRAINT device_profile_name_unq_key UNIQUE (tenant_id, name),
     CONSTRAINT device_provision_key_unq_key UNIQUE (provision_device_key),
-    CONSTRAINT fk_default_rule_chain_device_profile FOREIGN KEY (default_rule_chain_id) REFERENCES rule_chain(id)
+    CONSTRAINT fk_default_rule_chain_device_profile FOREIGN KEY (default_rule_chain_id) REFERENCES rule_chain(id),
+    CONSTRAINT fk_firmware_device_profile FOREIGN KEY (firmware_id) REFERENCES firmware(id)
 );
 
 CREATE TABLE IF NOT EXISTS device (
@@ -208,8 +227,10 @@ CREATE TABLE IF NOT EXISTS device (
     label varchar(255),
     search_text varchar(255),
     tenant_id uuid,
+    firmware_id uuid,
     CONSTRAINT device_name_unq_key UNIQUE (tenant_id, name),
-    CONSTRAINT fk_device_profile FOREIGN KEY (device_profile_id) REFERENCES device_profile(id)
+    CONSTRAINT fk_device_profile FOREIGN KEY (device_profile_id) REFERENCES device_profile(id),
+    CONSTRAINT fk_firmware_device FOREIGN KEY (firmware_id) REFERENCES firmware(id)
 );
 
 CREATE TABLE IF NOT EXISTS device_credentials (

dao/src/test/java/org/thingsboard/server/dao/SqlDaoServiceTestSuite.java

@@ -28,6 +28,7 @@ import java.util.Arrays;
         "org.thingsboard.server.dao.service.attributes.sql.*SqlTest",
         "org.thingsboard.server.dao.service.event.sql.*SqlTest",
         "org.thingsboard.server.dao.service.timeseries.sql.*SqlTest"
+
 })
 public class SqlDaoServiceTestSuite {
 

dao/src/test/java/org/thingsboard/server/dao/service/AbstractServiceTest.java

@@ -54,6 +54,7 @@ import org.thingsboard.server.dao.edge.EdgeService;
 import org.thingsboard.server.dao.entity.EntityService;
 import org.thingsboard.server.dao.entityview.EntityViewService;
 import org.thingsboard.server.dao.event.EventService;
+import org.thingsboard.server.dao.firmware.FirmwareService;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.resource.ResourceService;
 import org.thingsboard.server.dao.rule.RuleChainService;
@@ -157,6 +158,10 @@ public abstract class AbstractServiceTest {
     @Autowired
     protected ResourceService resourceService;
 
+
+    @Autowired
+    protected FirmwareService firmwareService;
+
     public class IdComparator<D extends HasId> implements Comparator<D> {
         @Override
         public int compare(D o1, D o2) {
@@ -203,7 +208,7 @@ public abstract class AbstractServiceTest {
 
     @Bean
     public AuditLogLevelFilter auditLogLevelFilter() {
-        Map<String,String> mask = new HashMap<>();
+        Map<String, String> mask = new HashMap<>();
         for (EntityType entityType : EntityType.values()) {
             mask.put(entityType.name().toLowerCase(), AuditLogLevelMask.RW.name());
         }

dao/src/test/java/org/thingsboard/server/dao/service/BaseDeviceProfileServiceTest.java

@@ -27,19 +27,19 @@ import org.junit.Test;
 import org.thingsboard.server.common.data.Device;
 import org.thingsboard.server.common.data.DeviceProfile;
 import org.thingsboard.server.common.data.DeviceProfileInfo;
-import org.thingsboard.server.common.data.DeviceProfileType;
 import org.thingsboard.server.common.data.DeviceTransportType;
+import org.thingsboard.server.common.data.Firmware;
 import org.thingsboard.server.common.data.Tenant;
 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.dao.exception.DataValidationException;
 
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
 
@@ -82,18 +82,49 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
         Assert.assertEquals(savedDeviceProfile.getName(), foundDeviceProfile.getName());
     }
 
+    @Test
+    public void testSaveDeviceProfileWithFirmware() {
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
+        DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
+        Assert.assertNotNull(savedDeviceProfile);
+        Assert.assertNotNull(savedDeviceProfile.getId());
+        Assert.assertTrue(savedDeviceProfile.getCreatedTime() > 0);
+        Assert.assertEquals(deviceProfile.getName(), savedDeviceProfile.getName());
+        Assert.assertEquals(deviceProfile.getDescription(), savedDeviceProfile.getDescription());
+        Assert.assertEquals(deviceProfile.getProfileData(), savedDeviceProfile.getProfileData());
+        Assert.assertEquals(deviceProfile.isDefault(), savedDeviceProfile.isDefault());
+        Assert.assertEquals(deviceProfile.getDefaultRuleChainId(), savedDeviceProfile.getDefaultRuleChainId());
+
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle("my firmware");
+        firmware.setVersion("v1.0");
+        firmware.setFileName("test.txt");
+        firmware.setContentType("text/plain");
+        firmware.setChecksumAlgorithm("sha256");
+        firmware.setChecksum("4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a");
+        firmware.setData(ByteBuffer.wrap(new byte[]{1}));
+        Firmware savedFirmware = firmwareService.saveFirmware(firmware);
+
+        deviceProfile.setFirmwareId(savedFirmware.getId());
+
+        deviceProfileService.saveDeviceProfile(savedDeviceProfile);
+        DeviceProfile foundDeviceProfile = deviceProfileService.findDeviceProfileById(tenantId, savedDeviceProfile.getId());
+        Assert.assertEquals(savedDeviceProfile.getName(), foundDeviceProfile.getName());
+    }
+
     @Test
     public void testFindDeviceProfileById() {
-        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
         DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
         DeviceProfile foundDeviceProfile = deviceProfileService.findDeviceProfileById(tenantId, savedDeviceProfile.getId());
         Assert.assertNotNull(foundDeviceProfile);
         Assert.assertEquals(savedDeviceProfile, foundDeviceProfile);
-   }
+    }
 
     @Test
     public void testFindDeviceProfileInfoById() {
-        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
         DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
         DeviceProfileInfo foundDeviceProfileInfo = deviceProfileService.findDeviceProfileInfoById(tenantId, savedDeviceProfile.getId());
         Assert.assertNotNull(foundDeviceProfileInfo);
@@ -124,7 +155,7 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
         ListeningExecutorService testExecutor = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(100));
         try {
             List<ListenableFuture<DeviceProfile>> futures = new ArrayList<>();
-            for (int i = 0; i < 50; i ++) {
+            for (int i = 0; i < 50; i++) {
                 futures.add(testExecutor.submit(() -> deviceProfileService.findOrCreateDeviceProfile(tenantId, "Device Profile 1")));
                 futures.add(testExecutor.submit(() -> deviceProfileService.findOrCreateDeviceProfile(tenantId, "Device Profile 2")));
             }
@@ -138,8 +169,8 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
 
     @Test
     public void testSetDefaultDeviceProfile() {
-        DeviceProfile deviceProfile1 = this.createDeviceProfile(tenantId,"Device Profile 1");
+        DeviceProfile deviceProfile1 = this.createDeviceProfile(tenantId, "Device Profile 1");
-        DeviceProfile deviceProfile2 = this.createDeviceProfile(tenantId,"Device Profile 2");
+        DeviceProfile deviceProfile2 = this.createDeviceProfile(tenantId, "Device Profile 2");
 
         DeviceProfile savedDeviceProfile1 = deviceProfileService.saveDeviceProfile(deviceProfile1);
         DeviceProfile savedDeviceProfile2 = deviceProfileService.saveDeviceProfile(deviceProfile2);
@@ -165,16 +196,16 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
 
     @Test(expected = DataValidationException.class)
     public void testSaveDeviceProfileWithSameName() {
-        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
         deviceProfileService.saveDeviceProfile(deviceProfile);
-        DeviceProfile deviceProfile2 = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile2 = this.createDeviceProfile(tenantId, "Device Profile");
         deviceProfileService.saveDeviceProfile(deviceProfile2);
     }
 
     @Ignore
     @Test(expected = DataValidationException.class)
     public void testChangeDeviceProfileTypeWithExistingDevices() {
-        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
         DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
         Device device = new Device();
         device.setTenantId(tenantId);
@@ -189,7 +220,7 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
 
     @Test(expected = DataValidationException.class)
     public void testChangeDeviceProfileTransportTypeWithExistingDevices() {
-        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
         DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
         Device device = new Device();
         device.setTenantId(tenantId);
@@ -203,7 +234,7 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
 
     @Test(expected = DataValidationException.class)
     public void testDeleteDeviceProfileWithExistingDevice() {
-        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
         DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
         Device device = new Device();
         device.setTenantId(tenantId);
@@ -216,7 +247,7 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
 
     @Test
     public void testDeleteDeviceProfile() {
-        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile");
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
         DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
         deviceProfileService.deleteDeviceProfile(tenantId, savedDeviceProfile.getId());
         DeviceProfile foundDeviceProfile = deviceProfileService.findDeviceProfileById(tenantId, savedDeviceProfile.getId());
@@ -233,8 +264,8 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
         Assert.assertEquals(1, pageData.getTotalElements());
         deviceProfiles.addAll(pageData.getData());
 
-        for (int i=0;i<28;i++) {
+        for (int i = 0; i < 28; i++) {
-            DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile"+i);
+            DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile" + i);
             deviceProfiles.add(deviceProfileService.saveDeviceProfile(deviceProfile));
         }
 
@@ -275,8 +306,8 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
         Assert.assertEquals(1, deviceProfilePageData.getTotalElements());
         deviceProfiles.addAll(deviceProfilePageData.getData());
 
-        for (int i=0;i<28;i++) {
+        for (int i = 0; i < 28; i++) {
-            DeviceProfile deviceProfile = this.createDeviceProfile(tenantId,"Device Profile"+i);
+            DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile" + i);
             deviceProfiles.add(deviceProfileService.saveDeviceProfile(deviceProfile));
         }
 
@@ -297,7 +328,7 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
 
         List<DeviceProfileInfo> deviceProfileInfos = deviceProfiles.stream()
                 .map(deviceProfile -> new DeviceProfileInfo(deviceProfile.getId(),
-                deviceProfile.getName(), deviceProfile.getType(), deviceProfile.getTransportType())).collect(Collectors.toList());
+                        deviceProfile.getName(), deviceProfile.getType(), deviceProfile.getTransportType())).collect(Collectors.toList());
 
         Assert.assertEquals(deviceProfileInfos, loadedDeviceProfileInfos);
 
@@ -312,4 +343,5 @@ public class BaseDeviceProfileServiceTest extends AbstractServiceTest {
         Assert.assertFalse(pageData.hasNext());
         Assert.assertEquals(1, pageData.getTotalElements());
     }
+
 }

dao/src/test/java/org/thingsboard/server/dao/service/BaseDeviceServiceTest.java

@@ -25,6 +25,7 @@ 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.EntitySubtype;
+import org.thingsboard.server.common.data.Firmware;
 import org.thingsboard.server.common.data.Tenant;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.id.CustomerId;
@@ -36,6 +37,7 @@ import org.thingsboard.server.common.data.security.DeviceCredentialsType;
 import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration;
 import org.thingsboard.server.dao.exception.DataValidationException;
 
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -154,6 +156,49 @@ public abstract class BaseDeviceServiceTest extends AbstractServiceTest {
         return foundDevice;
     }
 
+    @Test
+    public void testSaveDeviceWithFirmware() {
+        Device device = new Device();
+        device.setTenantId(tenantId);
+        device.setName("My device");
+        device.setType("default");
+        Device savedDevice = deviceService.saveDevice(device);
+
+        Assert.assertNotNull(savedDevice);
+        Assert.assertNotNull(savedDevice.getId());
+        Assert.assertTrue(savedDevice.getCreatedTime() > 0);
+        Assert.assertEquals(device.getTenantId(), savedDevice.getTenantId());
+        Assert.assertNotNull(savedDevice.getCustomerId());
+        Assert.assertEquals(NULL_UUID, savedDevice.getCustomerId().getId());
+        Assert.assertEquals(device.getName(), savedDevice.getName());
+
+        DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(tenantId, savedDevice.getId());
+        Assert.assertNotNull(deviceCredentials);
+        Assert.assertNotNull(deviceCredentials.getId());
+        Assert.assertEquals(savedDevice.getId(), deviceCredentials.getDeviceId());
+        Assert.assertEquals(DeviceCredentialsType.ACCESS_TOKEN, deviceCredentials.getCredentialsType());
+        Assert.assertNotNull(deviceCredentials.getCredentialsId());
+        Assert.assertEquals(20, deviceCredentials.getCredentialsId().length());
+
+
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle("my firmware");
+        firmware.setVersion("v1.0");
+        firmware.setFileName("test.txt");
+        firmware.setContentType("text/plain");
+        firmware.setChecksumAlgorithm("sha256");
+        firmware.setChecksum("4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a");
+        firmware.setData(ByteBuffer.wrap(new byte[]{1}));
+        Firmware savedFirmware = firmwareService.saveFirmware(firmware);
+
+        savedDevice.setFirmwareId(savedFirmware.getId());
+
+        deviceService.saveDevice(savedDevice);
+        Device foundDevice = deviceService.findDeviceById(tenantId, savedDevice.getId());
+        Assert.assertEquals(foundDevice.getName(), savedDevice.getName());
+    }
+    
     @Test(expected = DataValidationException.class)
     public void testSaveDeviceWithEmptyName() {
         Device device = new Device();

dao/src/test/java/org/thingsboard/server/dao/service/BaseFirmwareServiceTest.java

@@ -0,0 +1,488 @@
+/**
+ * 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.dao.service;
+
+import com.datastax.oss.driver.api.core.uuid.Uuids;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+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.Firmware;
+import org.thingsboard.server.common.data.FirmwareInfo;
+import org.thingsboard.server.common.data.Tenant;
+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.dao.exception.DataValidationException;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public abstract class BaseFirmwareServiceTest extends AbstractServiceTest {
+
+    public static final String TITLE = "My firmware";
+    private static final String FILE_NAME = "filename.txt";
+    private static final String VERSION = "v1.0";
+    private static final String CONTENT_TYPE = "text/plain";
+    private static final String CHECKSUM_ALGORITHM = "sha256";
+    private static final String CHECKSUM = "4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a";
+    private static final ByteBuffer DATA = ByteBuffer.wrap(new byte[]{1});
+
+    private IdComparator<FirmwareInfo> idComparator = new IdComparator<>();
+
+    private TenantId tenantId;
+
+    @Before
+    public void before() {
+        Tenant tenant = new Tenant();
+        tenant.setTitle("My tenant");
+        Tenant savedTenant = tenantService.saveTenant(tenant);
+        Assert.assertNotNull(savedTenant);
+        tenantId = savedTenant.getId();
+    }
+
+    @After
+    public void after() {
+        tenantService.deleteTenant(tenantId);
+    }
+
+    @Test
+    public void testSaveFirmware() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        Firmware savedFirmware = firmwareService.saveFirmware(firmware);
+
+        Assert.assertNotNull(savedFirmware);
+        Assert.assertNotNull(savedFirmware.getId());
+        Assert.assertTrue(savedFirmware.getCreatedTime() > 0);
+        Assert.assertEquals(firmware.getTenantId(), savedFirmware.getTenantId());
+        Assert.assertEquals(firmware.getTitle(), savedFirmware.getTitle());
+        Assert.assertEquals(firmware.getFileName(), savedFirmware.getFileName());
+        Assert.assertEquals(firmware.getContentType(), savedFirmware.getContentType());
+        Assert.assertEquals(firmware.getData(), savedFirmware.getData());
+
+        savedFirmware.setAdditionalInfo(JacksonUtil.newObjectNode());
+        firmwareService.saveFirmware(savedFirmware);
+
+        Firmware foundFirmware = firmwareService.findFirmwareById(tenantId, savedFirmware.getId());
+        Assert.assertEquals(foundFirmware.getTitle(), savedFirmware.getTitle());
+
+        firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+    }
+
+    @Test
+    public void testSaveFirmwareInfoAndUpdateWithData() {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTenantId(tenantId);
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+        FirmwareInfo savedFirmwareInfo = firmwareService.saveFirmwareInfo(firmwareInfo);
+
+        Assert.assertNotNull(savedFirmwareInfo);
+        Assert.assertNotNull(savedFirmwareInfo.getId());
+        Assert.assertTrue(savedFirmwareInfo.getCreatedTime() > 0);
+        Assert.assertEquals(firmwareInfo.getTenantId(), savedFirmwareInfo.getTenantId());
+        Assert.assertEquals(firmwareInfo.getTitle(), savedFirmwareInfo.getTitle());
+
+        Firmware firmware = new Firmware(savedFirmwareInfo.getId());
+        firmware.setCreatedTime(firmwareInfo.getCreatedTime());
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+
+        firmwareService.saveFirmware(firmware);
+
+        savedFirmwareInfo = firmwareService.findFirmwareInfoById(tenantId, savedFirmwareInfo.getId());
+        savedFirmwareInfo.setAdditionalInfo(JacksonUtil.newObjectNode());
+        firmwareService.saveFirmwareInfo(savedFirmwareInfo);
+
+        Firmware foundFirmware = firmwareService.findFirmwareById(tenantId, firmware.getId());
+        firmware.setAdditionalInfo(JacksonUtil.newObjectNode());
+
+        Assert.assertEquals(foundFirmware.getTitle(), firmware.getTitle());
+        Assert.assertTrue(foundFirmware.isHasData());
+
+        firmwareService.deleteFirmware(tenantId, savedFirmwareInfo.getId());
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithEmptyTenant() {
+        Firmware firmware = new Firmware();
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        firmwareService.saveFirmware(firmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithEmptyTitle() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        firmwareService.saveFirmware(firmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithEmptyFileName() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        firmwareService.saveFirmware(firmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithEmptyContentType() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        firmwareService.saveFirmware(firmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithEmptyData() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmwareService.saveFirmware(firmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithInvalidTenant() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(new TenantId(Uuids.timeBased()));
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        firmwareService.saveFirmware(firmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithEmptyChecksum() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(new TenantId(Uuids.timeBased()));
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setData(DATA);
+        firmwareService.saveFirmware(firmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareInfoWithExistingTitleAndVersion() {
+        FirmwareInfo firmwareInfo = new FirmwareInfo();
+        firmwareInfo.setTenantId(tenantId);
+        firmwareInfo.setTitle(TITLE);
+        firmwareInfo.setVersion(VERSION);
+        firmwareService.saveFirmwareInfo(firmwareInfo);
+
+        FirmwareInfo newFirmwareInfo = new FirmwareInfo();
+        newFirmwareInfo.setTenantId(tenantId);
+        newFirmwareInfo.setTitle(TITLE);
+        newFirmwareInfo.setVersion(VERSION);
+        firmwareService.saveFirmwareInfo(newFirmwareInfo);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testSaveFirmwareWithExistingTitleAndVersion() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        firmwareService.saveFirmware(firmware);
+
+        Firmware newFirmware = new Firmware();
+        newFirmware.setTenantId(tenantId);
+        newFirmware.setTitle(TITLE);
+        newFirmware.setVersion(VERSION);
+        newFirmware.setFileName(FILE_NAME);
+        newFirmware.setContentType(CONTENT_TYPE);
+        newFirmware.setData(DATA);
+        firmwareService.saveFirmware(newFirmware);
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testDeleteFirmwareWithReferenceByDevice() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        Firmware savedFirmware = firmwareService.saveFirmware(firmware);
+
+        Device device = new Device();
+        device.setTenantId(tenantId);
+        device.setName("My device");
+        device.setType("default");
+        device.setFirmwareId(savedFirmware.getId());
+        Device savedDevice = deviceService.saveDevice(device);
+
+        try {
+            firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+        } finally {
+            deviceService.deleteDevice(tenantId, savedDevice.getId());
+            firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+        }
+    }
+
+    @Test(expected = DataValidationException.class)
+    public void testDeleteFirmwareWithReferenceByDeviceProfile() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        Firmware savedFirmware = firmwareService.saveFirmware(firmware);
+
+        DeviceProfile deviceProfile = this.createDeviceProfile(tenantId, "Device Profile");
+        deviceProfile.setFirmwareId(savedFirmware.getId());
+        DeviceProfile savedDeviceProfile = deviceProfileService.saveDeviceProfile(deviceProfile);
+
+        try {
+            firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+        } finally {
+            deviceProfileService.deleteDeviceProfile(tenantId, savedDeviceProfile.getId());
+            firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+        }
+    }
+
+    @Test
+    public void testFindFirmwareById() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        Firmware savedFirmware = firmwareService.saveFirmware(firmware);
+
+        Firmware foundFirmware = firmwareService.findFirmwareById(tenantId, savedFirmware.getId());
+        Assert.assertNotNull(foundFirmware);
+        Assert.assertEquals(savedFirmware, foundFirmware);
+        firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+    }
+
+    @Test
+    public void testFindFirmwareInfoById() {
+        FirmwareInfo firmware = new FirmwareInfo();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        FirmwareInfo savedFirmware = firmwareService.saveFirmwareInfo(firmware);
+
+        FirmwareInfo foundFirmware = firmwareService.findFirmwareInfoById(tenantId, savedFirmware.getId());
+        Assert.assertNotNull(foundFirmware);
+        Assert.assertEquals(savedFirmware, foundFirmware);
+        firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+    }
+
+    @Test
+    public void testDeleteFirmware() {
+        Firmware firmware = new Firmware();
+        firmware.setTenantId(tenantId);
+        firmware.setTitle(TITLE);
+        firmware.setVersion(VERSION);
+        firmware.setFileName(FILE_NAME);
+        firmware.setContentType(CONTENT_TYPE);
+        firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+        firmware.setChecksum(CHECKSUM);
+        firmware.setData(DATA);
+        Firmware savedFirmware = firmwareService.saveFirmware(firmware);
+
+        Firmware foundFirmware = firmwareService.findFirmwareById(tenantId, savedFirmware.getId());
+        Assert.assertNotNull(foundFirmware);
+        firmwareService.deleteFirmware(tenantId, savedFirmware.getId());
+        foundFirmware = firmwareService.findFirmwareById(tenantId, savedFirmware.getId());
+        Assert.assertNull(foundFirmware);
+    }
+
+    @Test
+    public void testFindTenantFirmwaresByTenantId() {
+        List<FirmwareInfo> firmwares = new ArrayList<>();
+        for (int i = 0; i < 165; i++) {
+            Firmware firmware = new Firmware();
+            firmware.setTenantId(tenantId);
+            firmware.setTitle(TITLE);
+            firmware.setVersion(VERSION + i);
+            firmware.setFileName(FILE_NAME);
+            firmware.setContentType(CONTENT_TYPE);
+            firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+            firmware.setChecksum(CHECKSUM);
+            firmware.setData(DATA);
+
+            FirmwareInfo info = new FirmwareInfo(firmwareService.saveFirmware(firmware));
+            info.setHasData(true);
+            firmwares.add(info);
+        }
+
+        List<FirmwareInfo> loadedFirmwares = new ArrayList<>();
+        PageLink pageLink = new PageLink(16);
+        PageData<FirmwareInfo> pageData;
+        do {
+            pageData = firmwareService.findTenantFirmwaresByTenantId(tenantId, pageLink);
+            loadedFirmwares.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(firmwares, idComparator);
+        Collections.sort(loadedFirmwares, idComparator);
+
+        Assert.assertEquals(firmwares, loadedFirmwares);
+
+        firmwareService.deleteFirmwaresByTenantId(tenantId);
+
+        pageLink = new PageLink(31);
+        pageData = firmwareService.findTenantFirmwaresByTenantId(tenantId, pageLink);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertTrue(pageData.getData().isEmpty());
+    }
+
+    @Test
+    public void testFindTenantFirmwaresByTenantIdAndHasData() {
+        List<FirmwareInfo> firmwares = new ArrayList<>();
+        for (int i = 0; i < 165; i++) {
+            FirmwareInfo firmwareInfo = new FirmwareInfo();
+            firmwareInfo.setTenantId(tenantId);
+            firmwareInfo.setTitle(TITLE);
+            firmwareInfo.setVersion(VERSION + i);
+            firmwareInfo.setFileName(FILE_NAME);
+            firmwareInfo.setContentType(CONTENT_TYPE);
+            firmwareInfo.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+            firmwareInfo.setChecksum(CHECKSUM);
+            firmwareInfo.setDataSize((long) DATA.array().length);
+            firmwares.add(firmwareService.saveFirmwareInfo(firmwareInfo));
+        }
+
+        List<FirmwareInfo> loadedFirmwares = new ArrayList<>();
+        PageLink pageLink = new PageLink(16);
+        PageData<FirmwareInfo> pageData;
+        do {
+            pageData = firmwareService.findTenantFirmwaresByTenantIdAndHasData(tenantId, false, pageLink);
+            loadedFirmwares.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(firmwares, idComparator);
+        Collections.sort(loadedFirmwares, idComparator);
+
+        Assert.assertEquals(firmwares, loadedFirmwares);
+
+        firmwares.forEach(f -> {
+            Firmware firmware = new Firmware(f.getId());
+            firmware.setCreatedTime(f.getCreatedTime());
+            firmware.setTenantId(f.getTenantId());
+            firmware.setTitle(f.getTitle());
+            firmware.setVersion(f.getVersion());
+            firmware.setFileName(FILE_NAME);
+            firmware.setContentType(CONTENT_TYPE);
+            firmware.setChecksumAlgorithm(CHECKSUM_ALGORITHM);
+            firmware.setChecksum(CHECKSUM);
+            firmware.setData(DATA);
+            firmware.setDataSize((long) DATA.array().length);
+            firmwareService.saveFirmware(firmware);
+            f.setHasData(true);
+        });
+
+        loadedFirmwares = new ArrayList<>();
+        pageLink = new PageLink(16);
+        do {
+            pageData = firmwareService.findTenantFirmwaresByTenantIdAndHasData(tenantId, true, pageLink);
+            loadedFirmwares.addAll(pageData.getData());
+            if (pageData.hasNext()) {
+                pageLink = pageLink.nextPageLink();
+            }
+        } while (pageData.hasNext());
+
+        Collections.sort(firmwares, idComparator);
+        Collections.sort(loadedFirmwares, idComparator);
+
+        Assert.assertEquals(firmwares, loadedFirmwares);
+
+        firmwareService.deleteFirmwaresByTenantId(tenantId);
+
+        pageLink = new PageLink(31);
+        pageData = firmwareService.findTenantFirmwaresByTenantId(tenantId, pageLink);
+        Assert.assertFalse(pageData.hasNext());
+        Assert.assertTrue(pageData.getData().isEmpty());
+    }
+
+}

dao/src/test/java/org/thingsboard/server/dao/service/sql/FirmwareServiceSqlTest.java

@@ -0,0 +1,23 @@
+/**
+ * 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.dao.service.sql;
+
+import org.thingsboard.server.dao.service.BaseFirmwareServiceTest;
+import org.thingsboard.server.dao.service.DaoSqlTest;
+
+@DaoSqlTest
+public class FirmwareServiceSqlTest extends BaseFirmwareServiceTest {
+}

dao/src/test/resources/application-test.properties

@@ -36,9 +36,13 @@ caffeine.specs.tenantProfiles.maxSize=100000
 caffeine.specs.deviceProfiles.timeToLiveInMinutes=1440
 caffeine.specs.deviceProfiles.maxSize=100000
 
+caffeine.specs.firmwares.timeToLiveInMinutes=1440
+caffeine.specs.firmwares.maxSize=100000
+
 caffeine.specs.edges.timeToLiveInMinutes=1440
 caffeine.specs.edges.maxSize=100000
 
+
 redis.connection.host=localhost
 redis.connection.port=6379
 redis.connection.db=0

dao/src/test/resources/sql/hsql/drop-all-tables.sql

@@ -29,6 +29,7 @@ DROP TABLE IF EXISTS oauth2_client_registration_info;
 DROP TABLE IF EXISTS oauth2_client_registration_template;
 DROP TABLE IF EXISTS api_usage_state;
 DROP TABLE IF EXISTS resource;
+DROP TABLE IF EXISTS firmware;
 DROP TABLE IF EXISTS edge;
 DROP TABLE IF EXISTS edge_event;
 DROP FUNCTION IF EXISTS to_uuid;

dao/src/test/resources/sql/psql/drop-all-tables.sql

@@ -30,5 +30,6 @@ DROP TABLE IF EXISTS oauth2_client_registration_info;
 DROP TABLE IF EXISTS oauth2_client_registration_template;
 DROP TABLE IF EXISTS api_usage_state;
 DROP TABLE IF EXISTS resource;
+DROP TABLE IF EXISTS firmware;
 DROP TABLE IF EXISTS edge;
 DROP TABLE IF EXISTS edge_event;