Merge remote-tracking branch 'ce/master'

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

@@ -31,6 +31,7 @@
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.context.request.async.AsyncRequestTimeoutException;
 import org.springframework.web.context.request.async.DeferredResult;
+import org.thingsboard.common.util.DonAsynchron;
 import org.thingsboard.server.cluster.TbClusterService;
 import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.Dashboard;
@@ -839,18 +840,14 @@ protected MediaType parseMediaType(String contentType) {
     }
 
     protected <T> DeferredResult<T> wrapFuture(ListenableFuture<T> future) {
-        final DeferredResult<T> deferredResult = new DeferredResult<>();
-        Futures.addCallback(future, new FutureCallback<>() {
-            @Override
-            public void onSuccess(T result) {
-                deferredResult.setResult(result);
-            }
+        DeferredResult<T> deferredResult = new DeferredResult<>(); // Timeout of spring.mvc.async.request-timeout is used
+        DonAsynchron.withCallback(future, deferredResult::setResult, deferredResult::setErrorResult);
+        return deferredResult;
+    }
 
-            @Override
-            public void onFailure(Throwable t) {
-                deferredResult.setErrorResult(t);
-            }
-        }, MoreExecutors.directExecutor());
+    protected <T> DeferredResult<T> wrapFuture(ListenableFuture<T> future, long timeoutMs) {
+        DeferredResult<T> deferredResult = new DeferredResult<>(timeoutMs);
+        DonAsynchron.withCallback(future, deferredResult::setResult, deferredResult::setErrorResult);
         return deferredResult;
     }
 

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

@@ -630,4 +630,22 @@ public PageData<CloudEvent> getCloudEvents(
             throw handleException(e);
         }
     }
+
+    @ApiOperation(value = "Is edge upgrade enabled (isEdgeUpgradeAvailable)",
+            notes = "Returns 'true' if upgrade available for connected edge, 'false' - otherwise.")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN')")
+    @RequestMapping(value = "/edge/{edgeId}/upgrade/available", method = RequestMethod.GET)
+    @ResponseBody
+    public boolean isEdgeUpgradeAvailable(
+            @ApiParam(value = EDGE_ID_PARAM_DESCRIPTION, required = true)
+            @PathVariable("edgeId") String strEdgeId) throws Exception {
+        if (isEdgesEnabled() && edgeUpgradeServiceOpt.isPresent()) {
+            EdgeId edgeId = new EdgeId(toUUID(strEdgeId));
+            edgeId = checkNotNull(edgeId);
+            Edge edge = checkEdgeId(edgeId, Operation.READ);
+            return edgeUpgradeServiceOpt.get().isUpgradeAvailable(edge.getTenantId(), edge.getId());
+        } else {
+            throw new ThingsboardException("Edges support disabled", ThingsboardErrorCode.GENERAL);
+        }
+    }
 }

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

@@ -21,6 +21,7 @@
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.security.access.prepost.PreAuthorize;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -83,6 +84,8 @@ public class EntitiesVersionControlController extends BaseController {
 
     private final EntitiesVersionControlService versionControlService;
 
+    @Value("${queue.vc.request-timeout:180000}")
+    private int vcRequestTimeout;
 
     @ApiOperation(value = "Save entities version (saveEntitiesVersion)", notes = "" +
             "Creates a new version of entities (or a single entity) by request.\n" +
@@ -515,4 +518,9 @@ public DeferredResult<List<BranchInfo>> listBranches() throws Exception {
         }, MoreExecutors.directExecutor()));
     }
 
+    @Override
+    protected <T> DeferredResult<T> wrapFuture(ListenableFuture<T> future) {
+        return wrapFuture(future, vcRequestTimeout);
+    }
+
 }

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

@@ -35,6 +35,7 @@
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.settings.UserSettings;
 import org.thingsboard.server.common.data.settings.UserSettingsType;
+import org.thingsboard.server.common.data.tenant.profile.DefaultTenantProfileConfiguration;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.security.model.UserPrincipal;
@@ -130,6 +131,10 @@ public SystemParams getSystemParams() throws ThingsboardException {
         }
         systemParams.setUserSettings(userSettingsNode);
         systemParams.setMaxDatapointsLimit(maxDatapointsLimit);
+        if (!currentUser.isSystemAdmin()) {
+            DefaultTenantProfileConfiguration tenantProfileConfiguration = tenantProfileCache.get(tenantId).getDefaultProfileConfiguration();
+            systemParams.setMaxResourceSize(tenantProfileConfiguration.getMaxResourceSize());
+        }
         return systemParams;
     }
 

application/src/main/java/org/thingsboard/server/service/edge/instructions/DefaultEdgeUpgradeInstructionsService.java

@@ -21,8 +21,13 @@
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.EdgeUpgradeInfo;
 import org.thingsboard.server.common.data.edge.EdgeInstructions;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.kv.AttributeKvEntry;
+import org.thingsboard.server.dao.attributes.AttributesService;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.install.InstallScripts;
 
@@ -32,6 +37,7 @@
 import java.nio.file.Paths;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 
 @Service
 @Slf4j
@@ -47,6 +53,7 @@ public class DefaultEdgeUpgradeInstructionsService implements EdgeUpgradeInstruc
     private static final String UPGRADE_DIR = "upgrade";
 
     private final InstallScripts installScripts;
+    private final AttributesService attributesService;
 
     @Value("${app.version:unknown}")
     @Setter
@@ -74,13 +81,41 @@ public void updateInstructionMap(Map<String, EdgeUpgradeInfo> map) {
         }
     }
 
+    @Override
+    public boolean isUpgradeAvailable(TenantId tenantId, EdgeId edgeId) throws Exception {
+        Optional<AttributeKvEntry> attributeKvEntryOpt = attributesService.find(tenantId, edgeId, DataConstants.SERVER_SCOPE, DataConstants.EDGE_VERSION_ATTR_KEY).get();
+        if (attributeKvEntryOpt.isPresent()) {
+            String edgeVersionFormatted = convertEdgeVersionToDocsFormat(attributeKvEntryOpt.get().getValueAsString());
+            return isVersionGreaterOrEqualsThan(edgeVersionFormatted, "3.6.0") && !isVersionGreaterOrEqualsThan(edgeVersionFormatted, appVersion);
+        }
+        return false;
+    }
+
+    private boolean isVersionGreaterOrEqualsThan(String version1, String version2) {
+        String[] v1 = version1.split("\\.");
+        String[] v2 = version2.split("\\.");
+
+        int length = Math.max(v1.length, v2.length);
+        for (int i = 0; i < length; i++) {
+            int num1 = i < v1.length ? Integer.parseInt(v1[i]) : 0;
+            int num2 = i < v2.length ? Integer.parseInt(v2[i]) : 0;
+
+            if (num1 < num2) {
+                return false;
+            } else if (num1 > num2) {
+                return true;
+            }
+        }
+        return true;
+    }
+
     private EdgeInstructions getDockerUpgradeInstructions(String tbVersion, String currentEdgeVersion) {
         EdgeUpgradeInfo edgeUpgradeInfo = upgradeVersionHashMap.get(currentEdgeVersion);
         if (edgeUpgradeInfo == null || edgeUpgradeInfo.getNextEdgeVersion() == null || tbVersion.equals(currentEdgeVersion)) {
             return new EdgeInstructions("Edge upgrade instruction for " + currentEdgeVersion + "EDGE is not available.");
         }
         StringBuilder result = new StringBuilder(readFile(resolveFile("docker", "upgrade_preparing.md")));
-        while (edgeUpgradeInfo.getNextEdgeVersion() != null || !tbVersion.equals(currentEdgeVersion)) {
+        while (edgeUpgradeInfo.getNextEdgeVersion() != null && !tbVersion.equals(currentEdgeVersion)) {
             String edgeVersion = edgeUpgradeInfo.getNextEdgeVersion();
             String dockerUpgradeInstructions = readFile(resolveFile("docker", "instructions.md"));
             if (edgeUpgradeInfo.isRequiresUpdateDb()) {
@@ -109,7 +144,7 @@ private EdgeInstructions getLinuxUpgradeInstructions(String tbVersion, String cu
         String upgrade_preparing = readFile(resolveFile("upgrade_preparing.md"));
         upgrade_preparing = upgrade_preparing.replace("${OS}", os.equals("centos") ? "RHEL/CentOS 7/8" : "Ubuntu");
         StringBuilder result = new StringBuilder(upgrade_preparing);
-        while (edgeUpgradeInfo.getNextEdgeVersion() != null || !tbVersion.equals(currentEdgeVersion)) {
+        while (edgeUpgradeInfo.getNextEdgeVersion() != null && !tbVersion.equals(currentEdgeVersion)) {
             String edgeVersion = edgeUpgradeInfo.getNextEdgeVersion();
             String linuxUpgradeInstructions = readFile(resolveFile(os, "instructions.md"));
             if (edgeUpgradeInfo.isRequiresUpdateDb()) {

application/src/main/java/org/thingsboard/server/service/edge/instructions/EdgeUpgradeInstructionsService.java

@@ -17,6 +17,8 @@
 
 import org.thingsboard.server.common.data.EdgeUpgradeInfo;
 import org.thingsboard.server.common.data.edge.EdgeInstructions;
+import org.thingsboard.server.common.data.id.EdgeId;
+import org.thingsboard.server.common.data.id.TenantId;
 
 import java.util.Map;
 
@@ -27,4 +29,6 @@ public interface EdgeUpgradeInstructionsService {
     void updateInstructionMap(Map<String, EdgeUpgradeInfo> upgradeVersions);
 
     void setAppVersion(String version);
+
+    boolean isUpgradeAvailable(TenantId tenantId, EdgeId edgeId) throws Exception;
 }

application/src/main/java/org/thingsboard/server/service/edge/rpc/EdgeGrpcSession.java

@@ -822,7 +822,7 @@ private ConnectResponseMsg processConnect(ConnectRequestMsg request) {
     }
 
     private void processSaveEdgeVersionAsAttribute(String edgeVersion) {
-        AttributeKvEntry attributeKvEntry = new BaseAttributeKvEntry(new StringDataEntry("edgeVersion", edgeVersion), System.currentTimeMillis());
+        AttributeKvEntry attributeKvEntry = new BaseAttributeKvEntry(new StringDataEntry(DataConstants.EDGE_VERSION_ATTR_KEY, edgeVersion), System.currentTimeMillis());
         ctx.getAttributesService().save(this.tenantId, this.edge.getId(), DataConstants.SERVER_SCOPE, attributeKvEntry);
     }
 

application/src/main/java/org/thingsboard/server/service/executors/VersionControlExecutor.java

@@ -0,0 +1,32 @@
+/**
+ * Copyright © 2016-2023 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.executors;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.thingsboard.common.util.AbstractListeningExecutor;
+
+@Component
+public class VersionControlExecutor extends AbstractListeningExecutor {
+
+    @Value("${vc.thread_pool_size:6}")
+    private int threadPoolSize;
+
+    @Override
+    protected int getThreadPollSize() {
+        return threadPoolSize;
+    }
+}

application/src/main/java/org/thingsboard/server/service/notification/DefaultNotificationSchedulerService.java

@@ -21,6 +21,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Service;
+import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.rule.engine.api.NotificationCenter;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.NotificationRequestId;
@@ -35,36 +36,38 @@
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.dao.notification.NotificationRequestService;
-import org.thingsboard.server.queue.scheduler.SchedulerComponent;
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.executors.NotificationExecutorService;
 import org.thingsboard.server.service.partition.AbstractPartitionBasedService;
 
 import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 
 @TbCoreComponent
 @Service
 @RequiredArgsConstructor
 @Slf4j
-@SuppressWarnings("UnstableApiUsage")
 public class DefaultNotificationSchedulerService extends AbstractPartitionBasedService<NotificationRequestId> implements NotificationSchedulerService {
 
     private final NotificationCenter notificationCenter;
     private final NotificationRequestService notificationRequestService;
-    private final SchedulerComponent scheduler;
     private final NotificationExecutorService notificationExecutor;
+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(ThingsBoardThreadFactory.forName("notification-scheduler"));
 
     private final Map<NotificationRequestId, ScheduledRequestMetadata> scheduledNotificationRequests = new ConcurrentHashMap<>();
 
+    @Override
     @PostConstruct
     public void init() {
         super.init();
@@ -166,6 +169,13 @@ protected String getSchedulerExecutorName() {
         return "notifications-scheduler";
     }
 
+    @Override
+    @PreDestroy
+    public void stop() {
+        super.stop();
+        scheduler.shutdownNow();
+    }
+
     @Data
     private static class ScheduledRequestMetadata {
         private final TenantId tenantId;

application/src/main/java/org/thingsboard/server/service/sync/ie/exporting/impl/NotificationTargetExportService.java

@@ -43,6 +43,9 @@ protected void setRelatedEntities(EntitiesExportCtx<?> ctx, NotificationTarget n
                     CustomerUsersFilter customerUsersFilter = (CustomerUsersFilter) usersFilter;
                     customerUsersFilter.setCustomerId(getExternalIdOrElseInternal(ctx, new CustomerId(customerUsersFilter.getCustomerId())).getId());
                     break;
+                case USER_LIST:
+                    // users list stays as is and is replaced with current user id on import (due to user entities not being supported by VC)
+                    break;
             }
         }
     }

application/src/main/java/org/thingsboard/server/service/sync/ie/exporting/impl/ResourceExportService.java

@@ -18,16 +18,24 @@
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.TbResource;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.TbResourceId;
 import org.thingsboard.server.common.data.sync.ie.EntityExportData;
 import org.thingsboard.server.queue.util.TbCoreComponent;
+import org.thingsboard.server.service.sync.vc.data.EntitiesExportCtx;
 
 import java.util.Set;
 
 @Service
 @TbCoreComponent
 public class ResourceExportService extends BaseEntityExportService<TbResourceId, TbResource, EntityExportData<TbResource>> {
 
+    @Override
+    protected void setAdditionalExportData(EntitiesExportCtx<?> ctx, TbResource resource, EntityExportData<TbResource> exportData) throws ThingsboardException {
+        super.setAdditionalExportData(ctx, resource, exportData);
+        resource.setPreview(null); // will be generated on import
+    }
+
     @Override
     public Set<EntityType> getSupportedEntityTypes() {
         return Set.of(EntityType.TB_RESOURCE);

application/src/main/java/org/thingsboard/server/service/sync/ie/importing/impl/NotificationTargetImportService.java

@@ -41,7 +41,7 @@
 import org.thingsboard.server.queue.util.TbCoreComponent;
 import org.thingsboard.server.service.sync.vc.data.EntitiesImportCtx;
 
-import java.util.stream.Collectors;
+import java.util.List;
 
 @Service
 @TbCoreComponent
@@ -66,10 +66,7 @@ protected NotificationTarget prepare(EntitiesImportCtx ctx, NotificationTarget n
                     break;
                 case USER_LIST:
                     UserListFilter userListFilter = (UserListFilter) usersFilter;
-                    userListFilter.setUsersIds(userListFilter.getUsersIds().stream()
-                            .map(UserId::new).map(idProvider::getInternalId)
-                            .map(UUIDBased::getId).collect(Collectors.toList())
-                    );
+                    userListFilter.setUsersIds(List.of(ctx.getUser().getUuidId())); // user entities are not supported by VC; replacing with current user id
                     break;
                 case TENANT_ADMINISTRATORS:
                     if (CollectionUtils.isNotEmpty(((TenantAdministratorsFilter) usersFilter).getTenantsIds()) ||