Merge remote-tracking branch 'ce/develop/3.4' into docker-compose-zookeeper-upgrade-3.8.0

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

@@ -484,29 +484,25 @@ public class EntitiesVersionControlController extends BaseController {
             MARKDOWN_CODE_BLOCK_END)
     @GetMapping("/branches")
     public DeferredResult<List<BranchInfo>> listBranches() throws Exception {
-        try {
-            accessControlService.checkPermission(getCurrentUser(), Resource.VERSION_CONTROL, Operation.READ);
-            final TenantId tenantId = getTenantId();
-            ListenableFuture<List<BranchInfo>> branches = versionControlService.listBranches(tenantId);
-            return wrapFuture(Futures.transform(branches, remoteBranches -> {
-                List<BranchInfo> infos = new ArrayList<>();
-                BranchInfo defaultBranch;
-                String defaultBranchName = versionControlService.getVersionControlSettings(tenantId).getDefaultBranch();
-                if (StringUtils.isNotEmpty(defaultBranchName)) {
-                    defaultBranch = new BranchInfo(defaultBranchName, true);
-                } else {
-                    defaultBranch = remoteBranches.stream().filter(BranchInfo::isDefault).findFirst().orElse(null);
-                }
-                if (defaultBranch != null) {
-                    infos.add(defaultBranch);
-                }
-                infos.addAll(remoteBranches.stream().filter(b -> !b.equals(defaultBranch))
-                        .map(b -> new BranchInfo(b.getName(), false)).collect(Collectors.toList()));
-                return infos;
-            }, MoreExecutors.directExecutor()));
-        } catch (Exception e) {
-            throw handleException(e);
-        }
+        accessControlService.checkPermission(getCurrentUser(), Resource.VERSION_CONTROL, Operation.READ);
+        final TenantId tenantId = getTenantId();
+        ListenableFuture<List<BranchInfo>> branches = versionControlService.listBranches(tenantId);
+        return wrapFuture(Futures.transform(branches, remoteBranches -> {
+            List<BranchInfo> infos = new ArrayList<>();
+            BranchInfo defaultBranch;
+            String defaultBranchName = versionControlService.getVersionControlSettings(tenantId).getDefaultBranch();
+            if (StringUtils.isNotEmpty(defaultBranchName)) {
+                defaultBranch = new BranchInfo(defaultBranchName, true);
+            } else {
+                defaultBranch = remoteBranches.stream().filter(BranchInfo::isDefault).findFirst().orElse(null);
+            }
+            if (defaultBranch != null) {
+                infos.add(defaultBranch);
+            }
+            infos.addAll(remoteBranches.stream().filter(b -> !b.equals(defaultBranch))
+                    .map(b -> new BranchInfo(b.getName(), false)).collect(Collectors.toList()));
+            return infos;
+        }, MoreExecutors.directExecutor()));
     }
 
 }

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

@@ -25,6 +25,7 @@ import com.google.common.util.concurrent.SettableFuture;
 import lombok.extern.slf4j.Slf4j;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.cluster.TbClusterService;
 import org.thingsboard.server.common.data.Device;
@@ -101,6 +102,7 @@ public class DefaultEdgeRequestsService implements EdgeRequestsService {
     @Autowired
     private DeviceService deviceService;
 
+    @Lazy
     @Autowired
     private TbEntityViewService entityViewService;
 

application/src/main/java/org/thingsboard/server/service/entitiy/AbstractTbEntityService.java

@@ -65,6 +65,7 @@ import org.thingsboard.server.dao.widget.WidgetsBundleService;
 import org.thingsboard.server.service.action.EntityActionService;
 import org.thingsboard.server.service.edge.EdgeNotificationService;
 import org.thingsboard.server.service.executors.DbCallbackExecutorService;
+import org.thingsboard.server.service.security.model.SecurityUser;
 import org.thingsboard.server.service.sync.vc.EntitiesVersionControlService;
 import org.thingsboard.server.service.install.InstallScripts;
 import org.thingsboard.server.service.ota.OtaPackageStateService;
@@ -78,6 +79,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.UUID;
 import java.util.stream.Collectors;
 
 @Slf4j
@@ -128,8 +130,8 @@ public abstract class AbstractTbEntityService {
     @Autowired
     protected DashboardService dashboardService;
 
-    @Autowired
-    protected EntitiesVersionControlService vcService;
+    @Autowired(required = false)
+    private EntitiesVersionControlService vcService;
     @Autowired
     protected EntityViewService entityViewService;
     @Lazy
@@ -249,4 +251,13 @@ public abstract class AbstractTbEntityService {
         }
         return result;
     }
+
+    protected ListenableFuture<UUID> autoCommit(SecurityUser user, EntityId entityId) throws Exception {
+        if (vcService != null) {
+            return vcService.autoCommit(user, entityId);
+        } else {
+            // We do not support auto-commit for rule engine
+            return Futures.immediateFailedFuture(new RuntimeException("Operation not supported!"));
+        }
+    }
 }

application/src/main/java/org/thingsboard/server/service/entitiy/asset/DefaultTbAssetService.java

@@ -47,7 +47,7 @@ public class DefaultTbAssetService extends AbstractTbEntityService implements Tb
         TenantId tenantId = asset.getTenantId();
         try {
             Asset savedAsset = checkNotNull(assetService.saveAsset(asset));
-            vcService.autoCommit(user, savedAsset.getId());
+            autoCommit(user, savedAsset.getId());
             notificationEntityService.notifyCreateOrUpdateEntity(tenantId, savedAsset.getId(), savedAsset, savedAsset.getCustomerId(), actionType, user);
             return savedAsset;
         } catch (Exception e) {

application/src/main/java/org/thingsboard/server/service/entitiy/customer/DefaultTbCustomerService.java

@@ -42,7 +42,7 @@ public class DefaultTbCustomerService extends AbstractTbEntityService implements
         TenantId tenantId = customer.getTenantId();
         try {
             Customer savedCustomer = checkNotNull(customerService.saveCustomer(customer));
-            vcService.autoCommit(user, savedCustomer.getId());
+            autoCommit(user, savedCustomer.getId());
             notificationEntityService.notifyCreateOrUpdateEntity(tenantId, savedCustomer.getId(), savedCustomer, null, actionType, user);
             return savedCustomer;
         } catch (Exception e) {

application/src/main/java/org/thingsboard/server/service/entitiy/dashboard/DefaultTbDashboardService.java

@@ -48,7 +48,7 @@ public class DefaultTbDashboardService extends AbstractTbEntityService implement
         TenantId tenantId = dashboard.getTenantId();
         try {
             Dashboard savedDashboard = checkNotNull(dashboardService.saveDashboard(dashboard));
-            vcService.autoCommit(user, savedDashboard.getId());
+            autoCommit(user, savedDashboard.getId());
             notificationEntityService.notifyCreateOrUpdateEntity(tenantId, savedDashboard.getId(), savedDashboard,
                     null, actionType, user);
             return savedDashboard;

application/src/main/java/org/thingsboard/server/service/entitiy/device/DefaultTbDeviceService.java

@@ -54,7 +54,7 @@ public class DefaultTbDeviceService extends AbstractTbEntityService implements T
         ActionType actionType = device.getId() == null ? ActionType.ADDED : ActionType.UPDATED;
         try {
             Device savedDevice = checkNotNull(deviceService.saveDeviceWithAccessToken(device, accessToken));
-            vcService.autoCommit(user, savedDevice.getId());
+            autoCommit(user, savedDevice.getId());
             notificationEntityService.notifyCreateOrUpdateDevice(tenantId, savedDevice.getId(), savedDevice.getCustomerId(),
                     savedDevice, oldDevice, actionType, user);
 

application/src/main/java/org/thingsboard/server/service/entitiy/deviceProfile/DefaultTbDeviceProfileService.java

@@ -54,7 +54,7 @@ public class DefaultTbDeviceProfileService extends AbstractTbEntityService imple
                 }
             }
             DeviceProfile savedDeviceProfile = checkNotNull(deviceProfileService.saveDeviceProfile(deviceProfile));
-            vcService.autoCommit(user, savedDeviceProfile.getId());
+            autoCommit(user, savedDeviceProfile.getId());
             tbClusterService.onDeviceProfileChange(savedDeviceProfile, null);
             tbClusterService.broadcastEntityStateChangeEvent(tenantId, savedDeviceProfile.getId(),
                     actionType.equals(ActionType.ADDED) ? ComponentLifecycleEvent.CREATED : ComponentLifecycleEvent.UPDATED);

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

@@ -25,6 +25,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.stereotype.Service;
@@ -162,6 +163,7 @@ public class DefaultSystemDataLoaderService implements SystemDataLoaderService {
     @Getter
     private boolean persistActivityToTelemetry;
 
+    @Lazy
     @Autowired
     private QueueService queueService;
 

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

@@ -21,6 +21,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections.CollectionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.EntitySubtype;
@@ -121,6 +122,7 @@ public class SqlDatabaseUpgradeService implements DatabaseEntitiesUpgradeService
     @Autowired
     private ApiUsageStateService apiUsageStateService;
 
+    @Lazy
     @Autowired
     private QueueService queueService;
 

application/src/main/java/org/thingsboard/server/service/install/update/DefaultDataUpdateService.java

@@ -22,6 +22,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Service;
 import org.thingsboard.common.util.JacksonUtil;
@@ -117,6 +118,7 @@ public class DefaultDataUpdateService implements DataUpdateService {
     @Autowired
     private TenantProfileService tenantProfileService;
 
+    @Lazy
     @Autowired
     private QueueService queueService;
 

application/src/main/java/org/thingsboard/server/service/sync/vc/DefaultEntitiesVersionControlService.java

@@ -357,6 +357,7 @@ public class DefaultEntitiesVersionControlService implements EntitiesVersionCont
         return EntityImportSettings.builder()
                 .updateRelations(config.isLoadRelations())
                 .saveAttributes(config.isLoadAttributes())
+                .saveCredentials(config.isLoadCredentials())
                 .findExistingByName(config.isFindExistingEntityByName())
                 .build();
     }

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

@@ -18,6 +18,7 @@ package org.thingsboard.server.dao.device;
 import lombok.extern.slf4j.Slf4j;
 import org.hibernate.exception.ConstraintViolationException;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.event.TransactionalEventListener;
 import org.thingsboard.server.common.data.Device;
@@ -69,6 +70,7 @@ public class DeviceProfileServiceImpl extends AbstractCachedEntityService<Device
     @Autowired
     private DataValidator<DeviceProfile> deviceProfileValidator;
 
+    @Lazy
     @Autowired
     private QueueService queueService;
 

dao/src/main/java/org/thingsboard/server/dao/queue/BaseQueueService.java

@@ -19,6 +19,7 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.hibernate.exception.ConstraintViolationException;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.TenantProfile;
 import org.thingsboard.server.common.data.id.QueueId;
@@ -43,6 +44,7 @@ public class BaseQueueService extends AbstractEntityService implements QueueServ
     @Autowired
     private QueueDao queueDao;
 
+    @Lazy
     @Autowired
     private TbTenantProfileCache tenantProfileCache;
 

dao/src/main/java/org/thingsboard/server/dao/service/validator/DeviceProfileDataValidator.java

@@ -90,8 +90,8 @@ public class DeviceProfileDataValidator extends DataValidator<DeviceProfile> {
     private DeviceDao deviceDao;
     @Autowired
     private TenantService tenantService;
-    @Autowired
     @Lazy
+    @Autowired
     private QueueService queueService;
     @Autowired
     private OtaPackageService otaPackageService;

dao/src/main/java/org/thingsboard/server/dao/sqlts/AbstractChunkedAggregationTimeseriesDao.java

@@ -26,6 +26,7 @@ import org.springframework.data.domain.Sort;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.Aggregation;
+import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
 import org.thingsboard.server.common.data.kv.DeleteTsKvQuery;
 import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
@@ -122,14 +123,17 @@ public abstract class AbstractChunkedAggregationTimeseriesDao extends AbstractSq
         if (query.getAggregation() == Aggregation.NONE) {
             return findAllAsyncWithLimit(entityId, query);
         } else {
-            long stepTs = query.getStartTs();
             List<ListenableFuture<Optional<TsKvEntry>>> futures = new ArrayList<>();
-            while (stepTs < query.getEndTs()) {
-                long startTs = stepTs;
-                long endTs = stepTs + query.getInterval();
+            long endPeriod = query.getEndTs();
+            long startPeriod = query.getStartTs();
+            long step = query.getInterval();
+            while (startPeriod <= endPeriod) {
+                long startTs = startPeriod;
+                long endTs = Math.min(startPeriod + step, endPeriod + 1);
                 long ts = startTs + (endTs - startTs) / 2;
-                futures.add(findAndAggregateAsync(entityId, query.getKey(), startTs, endTs, ts, query.getAggregation()));
-                stepTs = endTs;
+                ListenableFuture<Optional<TsKvEntry>> aggregateTsKvEntry = findAndAggregateAsync(entityId, query.getKey(), startTs, endTs, ts,  query.getAggregation());
+                futures.add(aggregateTsKvEntry);
+                startPeriod = endTs;
             }
             return getTskvEntriesFuture(Futures.allAsList(futures));
         }
@@ -148,7 +152,7 @@ public abstract class AbstractChunkedAggregationTimeseriesDao extends AbstractSq
         return Futures.immediateFuture(DaoUtil.convertDataList(tsKvEntities));
     }
 
-    private ListenableFuture<Optional<TsKvEntry>> findAndAggregateAsync(EntityId entityId, String key, long startTs, long endTs, long ts, Aggregation aggregation) {
+    ListenableFuture<Optional<TsKvEntry>> findAndAggregateAsync(EntityId entityId, String key, long startTs, long endTs, long ts, Aggregation aggregation) {
         List<CompletableFuture<TsKvEntity>> entitiesFutures = new ArrayList<>();
         switchAggregation(entityId, key, startTs, endTs, aggregation, entitiesFutures);
         return Futures.transform(setFutures(entitiesFutures), entity -> {

dao/src/main/java/org/thingsboard/server/dao/sqlts/AbstractSqlTimeseriesDao.java

@@ -91,7 +91,7 @@ public abstract class AbstractSqlTimeseriesDao extends BaseAbstractSqlTimeseries
                 .stream()
                 .map(query -> findAllAsync(tenantId, entityId, query))
                 .collect(Collectors.toList());
-        return Futures.transform(Futures.allAsList(futures), new Function<List<List<TsKvEntry>>, List<TsKvEntry>>() {
+        return Futures.transform(Futures.allAsList(futures), new Function<>() {
             @Nullable
             @Override
             public List<TsKvEntry> apply(@Nullable List<List<TsKvEntry>> results) {

dao/src/main/java/org/thingsboard/server/dao/sqlts/AggregationTimeseriesDao.java

@@ -26,4 +26,4 @@ import java.util.List;
 public interface AggregationTimeseriesDao {
 
     ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, ReadTsKvQuery query);
-}
+}

dao/src/main/java/org/thingsboard/server/dao/sqlts/BaseAbstractSqlTimeseriesDao.java

@@ -21,6 +21,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import lombok.extern.slf4j.Slf4j;
 import org.hibernate.exception.ConstraintViolationException;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionary;
 import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionaryCompositeKey;
@@ -39,9 +40,7 @@ import java.util.stream.Collectors;
 public abstract class BaseAbstractSqlTimeseriesDao extends JpaAbstractDaoListeningExecutorService {
 
     private final ConcurrentMap<String, Integer> tsKvDictionaryMap = new ConcurrentHashMap<>();
-
     protected static final ReentrantLock tsCreationLock = new ReentrantLock();
-
     @Autowired
     protected TsKvDictionaryRepository dictionaryRepository;
 
@@ -61,7 +60,7 @@ public abstract class BaseAbstractSqlTimeseriesDao extends JpaAbstractDaoListeni
                             TsKvDictionary saved = dictionaryRepository.save(tsKvDictionary);
                             tsKvDictionaryMap.put(saved.getKey(), saved.getKeyId());
                             keyId = saved.getKeyId();
-                        } catch (ConstraintViolationException e) {
+                        } catch (DataIntegrityViolationException | ConstraintViolationException e) {
                             tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
                             TsKvDictionary dictionary = tsKvDictionaryOptional.orElseThrow(() -> new RuntimeException("Failed to get TsKvDictionary entity from DB!"));
                             tsKvDictionaryMap.put(dictionary.getKey(), dictionary.getKeyId());
@@ -96,4 +95,5 @@ public abstract class BaseAbstractSqlTimeseriesDao extends JpaAbstractDaoListeni
             }
         }, service);
     }
+
 }

dao/src/main/java/org/thingsboard/server/dao/tenant/TenantServiceImpl.java

@@ -107,6 +107,7 @@ public class TenantServiceImpl extends AbstractCachedEntityService<TenantCacheKe
     @Autowired
     private DataValidator<Tenant> tenantValidator;
 
+    @Lazy
     @Autowired
     private QueueService queueService;
 

dao/src/main/java/org/thingsboard/server/dao/timeseries/CassandraBaseTimeseriesDao.java

@@ -141,7 +141,7 @@ public class CassandraBaseTimeseriesDao extends AbstractCassandraBaseTimeseriesD
     @Override
     public ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, List<ReadTsKvQuery> queries) {
         List<ListenableFuture<List<TsKvEntry>>> futures = queries.stream().map(query -> findAllAsync(tenantId, entityId, query)).collect(Collectors.toList());
-        return Futures.transform(Futures.allAsList(futures), new Function<List<List<TsKvEntry>>, List<TsKvEntry>>() {
+        return Futures.transform(Futures.allAsList(futures), new Function<>() {
             @Nullable
             @Override
             public List<TsKvEntry> apply(@Nullable List<List<TsKvEntry>> results) {
@@ -270,18 +270,20 @@ public class CassandraBaseTimeseriesDao extends AbstractCassandraBaseTimeseriesD
         if (query.getAggregation() == Aggregation.NONE) {
             return findAllAsyncWithLimit(tenantId, entityId, query);
         } else {
+            long startPeriod = query.getStartTs();
+            long endPeriod = query.getEndTs();
             long step = Math.max(query.getInterval(), MIN_AGGREGATION_STEP_MS);
-            long stepTs = query.getStartTs();
             List<ListenableFuture<Optional<TsKvEntry>>> futures = new ArrayList<>();
-            while (stepTs < query.getEndTs()) {
-                long startTs = stepTs;
-                long endTs = stepTs + step;
-                ReadTsKvQuery subQuery = new BaseReadTsKvQuery(query.getKey(), startTs, endTs, step, 1, query.getAggregation(), query.getOrder());
+            while (startPeriod <= endPeriod) {
+                long startTs = startPeriod;
+                long endTs = Math.min(startPeriod + step, endPeriod + 1);
+                long ts = endTs - startTs;
+                ReadTsKvQuery subQuery = new BaseReadTsKvQuery(query.getKey(), startTs, endTs, ts, 1, query.getAggregation(), query.getOrder());
                 futures.add(findAndAggregateAsync(tenantId, entityId, subQuery, toPartitionTs(startTs), toPartitionTs(endTs)));
-                stepTs = endTs;
+                startPeriod = endTs;
             }
             ListenableFuture<List<Optional<TsKvEntry>>> future = Futures.allAsList(futures);
-            return Futures.transform(future, new Function<List<Optional<TsKvEntry>>, List<TsKvEntry>>() {
+            return Futures.transform(future, new Function<>() {
                 @Nullable
                 @Override
                 public List<TsKvEntry> apply(@Nullable List<Optional<TsKvEntry>> input) {

dao/src/main/java/org/thingsboard/server/dao/util/AbstractBufferedRateExecutor.java

@@ -116,8 +116,13 @@ public abstract class AbstractBufferedRateExecutor<T extends AsyncTask, F extend
         F result = wrap(task, settableFuture);
 
         boolean perTenantLimitReached = false;
-        var tenantProfileConfiguration = tenantProfileCache.get(task.getTenantId()).getDefaultProfileConfiguration();
-        if (StringUtils.isNotEmpty(tenantProfileConfiguration.getCassandraQueryTenantRateLimitsConfiguration())) {
+
+        var tenantProfileConfiguration =
+                (task.getTenantId() != null && !TenantId.SYS_TENANT_ID.equals(task.getTenantId()))
+                        ? tenantProfileCache.get(task.getTenantId()).getDefaultProfileConfiguration()
+                        : null;
+        if (tenantProfileConfiguration != null &&
+                StringUtils.isNotEmpty(tenantProfileConfiguration.getCassandraQueryTenantRateLimitsConfiguration())) {
             if (task.getTenantId() == null) {
                 log.info("Invalid task received: {}", task);
             } else if (!task.getTenantId().isNullUid()) {

dao/src/test/java/org/thingsboard/server/dao/service/timeseries/BaseTimeseriesServiceTest.java

@@ -184,6 +184,140 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
         Assert.assertEquals(toTsEntry(TS - 1, stringKvEntry), entries.get(2));
     }
 
+    @Test
+    public void testFindByQuery_whenPeriodEqualsOneMilisecondPeriod() throws Exception {
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
+        saveEntries(deviceId, TS - 1L);
+        saveEntries(deviceId, TS);
+        saveEntries(deviceId, TS + 1L);
+
+        List<ReadTsKvQuery> queries = List.of(new BaseReadTsKvQuery(LONG_KEY, TS, TS, 1, 1, Aggregation.COUNT, DESC_ORDER));
+
+        List<TsKvEntry> entries = tsService.findAll(tenantId, deviceId, queries).get();
+        Assert.assertEquals(1, entries.size());
+        Assert.assertEquals(toTsEntry(TS, new LongDataEntry(LONG_KEY, 1L)), entries.get(0));
+
+        EntityView entityView = saveAndCreateEntityView(deviceId, List.of(LONG_KEY));
+
+        entries = tsService.findAll(tenantId, entityView.getId(), queries).get();
+        Assert.assertEquals(1, entries.size());
+        Assert.assertEquals(toTsEntry(TS, new LongDataEntry(LONG_KEY, 1L)), entries.get(0));
+    }
+
+    @Test
+    public void testFindByQuery_whenPeriodEqualsInterval() throws Exception {
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
+        saveEntries(deviceId, TS - 1L);
+        for (long i = TS; i <= TS + 100L; i += 10L) {
+            saveEntries(deviceId, i);
+        }
+        saveEntries(deviceId, TS + 100L + 1L);
+
+        List<ReadTsKvQuery> queries = List.of(new BaseReadTsKvQuery(LONG_KEY, TS, TS + 100, 101, 1, Aggregation.COUNT, DESC_ORDER));
+
+        List<TsKvEntry> entries = tsService.findAll(tenantId, deviceId, queries).get();
+        Assert.assertEquals(1, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 50, new LongDataEntry(LONG_KEY, 11L)), entries.get(0));
+
+        EntityView entityView = saveAndCreateEntityView(deviceId, List.of(LONG_KEY));
+
+        entries = tsService.findAll(tenantId, entityView.getId(), queries).get();
+        Assert.assertEquals(1, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 50, new LongDataEntry(LONG_KEY, 11L)), entries.get(0));
+    }
+
+    @Test
+    public void testFindByQuery_whenPeriodHaveTwoIntervalWithEqualsLength() throws Exception {
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
+        saveEntries(deviceId, TS - 1L);
+        for (long i = TS; i <= TS + 100000L; i += 10000L) {
+            saveEntries(deviceId, i);
+        }
+        saveEntries(deviceId, TS + 100000L + 1L);
+
+        List<ReadTsKvQuery> queries = List.of(new BaseReadTsKvQuery(LONG_KEY, TS, TS + 99999, 50000, 1, Aggregation.COUNT, DESC_ORDER));
+
+        List<TsKvEntry> entries = tsService.findAll(tenantId, deviceId, queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 75000, new LongDataEntry(LONG_KEY, 5L)), entries.get(1));
+
+        EntityView entityView = saveAndCreateEntityView(deviceId, List.of(LONG_KEY));
+
+        entries = tsService.findAll(tenantId, entityView.getId(), queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 75000, new LongDataEntry(LONG_KEY, 5L)), entries.get(1));
+    }
+
+    @Test
+    public void testFindByQuery_whenPeriodHaveTwoInterval_whereSecondShorterThanFirst() throws Exception {
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
+        saveEntries(deviceId, TS - 1L);
+        for (long i = TS; i <= TS + 80000L; i += 10000L) {
+            saveEntries(deviceId, i);
+        }
+        saveEntries(deviceId, TS + 80000L + 1L);
+
+        List<ReadTsKvQuery> queries = List.of(new BaseReadTsKvQuery(LONG_KEY, TS, TS + 80000, 50000, 1, Aggregation.COUNT, DESC_ORDER));
+
+        List<TsKvEntry> entries = tsService.findAll(tenantId, deviceId, queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 65000, new LongDataEntry(LONG_KEY, 4L)), entries.get(1));
+
+        EntityView entityView = saveAndCreateEntityView(deviceId, List.of(LONG_KEY));
+
+        entries = tsService.findAll(tenantId, entityView.getId(), queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 65000, new LongDataEntry(LONG_KEY, 4L)), entries.get(1));
+    }
+
+    @Test
+    public void testFindByQuery_whenPeriodHaveTwoIntervalWithEqualsLength_whereNotAllEntriesInRange() throws Exception {
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
+        for (long i = TS - 1L; i <= TS + 100000L + 1L; i += 10000) {
+            saveEntries(deviceId, i);
+        }
+
+        List<ReadTsKvQuery> queries = List.of(new BaseReadTsKvQuery(LONG_KEY, TS, TS + 99999, 50000, 1, Aggregation.COUNT, DESC_ORDER));
+
+        List<TsKvEntry> entries = tsService.findAll(tenantId, deviceId, queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 75000, new LongDataEntry(LONG_KEY, 5L)), entries.get(1));
+
+        EntityView entityView = saveAndCreateEntityView(deviceId, List.of(LONG_KEY));
+
+        entries = tsService.findAll(tenantId, entityView.getId(), queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 75000, new LongDataEntry(LONG_KEY, 5L)), entries.get(1));
+    }
+
+    @Test
+    public void testFindByQuery_whenPeriodHaveTwoInterval_whereSecondShorterThanFirst_andNotAllEntriesInRange() throws Exception {
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
+        for (long i = TS - 1L; i <= TS + 100000L + 1L; i += 10000L) {
+            saveEntries(deviceId, i);
+        }
+
+        List<ReadTsKvQuery> queries = List.of(new BaseReadTsKvQuery(LONG_KEY, TS, TS + 80000, 50000, 1, Aggregation.COUNT, DESC_ORDER));
+
+        List<TsKvEntry> entries = tsService.findAll(tenantId, deviceId, queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 65000, new LongDataEntry(LONG_KEY, 3L)), entries.get(1));
+
+        EntityView entityView = saveAndCreateEntityView(deviceId, List.of(LONG_KEY));
+
+        entries = tsService.findAll(tenantId, entityView.getId(), queries).get();
+        Assert.assertEquals(2, entries.size());
+        Assert.assertEquals(toTsEntry(TS + 25000, new LongDataEntry(LONG_KEY, 5L)), entries.get(0));
+        Assert.assertEquals(toTsEntry(TS + 65000, new LongDataEntry(LONG_KEY, 3L)), entries.get(1));
+    }
+
     @Test
     public void testFindByQueryDescOrder() throws Exception {
         DeviceId deviceId = new DeviceId(Uuids.timeBased());

dao/src/test/java/org/thingsboard/server/dao/sqlts/AbstractChunkedAggregationTimeseriesDaoTest.java

@@ -0,0 +1,156 @@
+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.sqlts;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
+import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.BDDMockito.willCallRealMethod;
+import static org.mockito.BDDMockito.willReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.thingsboard.server.common.data.id.TenantId.SYS_TENANT_ID;
+import static org.thingsboard.server.common.data.kv.Aggregation.COUNT;
+
+public class AbstractChunkedAggregationTimeseriesDaoTest {
+
+    final int LIMIT = 1;
+    final String TEMP = "temp";
+    final String DESC = "DESC";
+    AbstractChunkedAggregationTimeseriesDao tsDao;
+
+    @Before
+    public void setUp() throws Exception {
+        tsDao = spy(AbstractChunkedAggregationTimeseriesDao.class);
+        ListenableFuture<Optional<TsKvEntry>> optionalListenableFuture = Futures.immediateFuture(Optional.of(mock(TsKvEntry.class)));
+        willReturn(optionalListenableFuture).given(tsDao).findAndAggregateAsync(any(), anyString(), anyLong(), anyLong(), anyLong(), any());
+        willReturn(Futures.immediateFuture(mock(TsKvEntry.class))).given(tsDao).getTskvEntriesFuture(any());
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenLastIntervalShorterThanOthersAndEqualsEndTs() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 1, 3000, 2000, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQueryFirst = new BaseReadTsKvQuery(TEMP, 1, 2001, 1001, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQuerySecond = new BaseReadTsKvQuery(TEMP, 2001, 3001, 2501, LIMIT, COUNT, DESC);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(2)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQueryFirst.getKey(), 1, 2001, getTsForReadTsKvQuery(1, 2001), COUNT);
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQuerySecond.getKey(), 2001, 3000 + 1, getTsForReadTsKvQuery(2001, 3001), COUNT);
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenIntervalEqualsPeriod() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 1, 3000, 3000, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQueryFirst = new BaseReadTsKvQuery(TEMP, 1, 3001, 1501, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        assertThat(tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query)).isNotNull();
+        verify(tsDao, times(1)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQueryFirst.getKey(), 1, 3000 + 1, getTsForReadTsKvQuery(1, 3001), COUNT);
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenIntervalEqualsPeriodMinusOne() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 1, 3000, 2999, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQueryFirst = new BaseReadTsKvQuery(TEMP, 1, 3000, 1500, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQuerySecond = new BaseReadTsKvQuery(TEMP, 3000, 3001, 3000, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(2)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQueryFirst.getKey(), 1, 3000, getTsForReadTsKvQuery(1, 3000), COUNT);
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQuerySecond.getKey(), 3000, 3001, getTsForReadTsKvQuery(3000, 3001), COUNT);
+
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenIntervalEqualsPeriodPlusOne() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 1, 3000, 3001, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQueryFirst = new BaseReadTsKvQuery(TEMP, 1, 3001, 1501, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(1)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQueryFirst.getKey(), 1, 3001, getTsForReadTsKvQuery(1, 3001), COUNT);
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenIntervalEqualsOneMillisecondAndStartTsIsZero() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 0, 0, 1, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQueryFirst = new BaseReadTsKvQuery(TEMP, 0, 1, 0, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(1)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQueryFirst.getKey(), 0, 1, getTsForReadTsKvQuery(0, 1), COUNT);
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenIntervalEqualsOneMillisecondAndStartTsIsOne() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 1, 1, 1, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQuery = new BaseReadTsKvQuery(TEMP, 1, 2, 1, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(1)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQuery.getKey(), 1, 2, getTsForReadTsKvQuery(1, 2), COUNT);
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenIntervalEqualsOneMillisecondAndStartTsIsIntegerMax() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, Integer.MAX_VALUE, Integer.MAX_VALUE, 1, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQueryFirst = new BaseReadTsKvQuery(TEMP, Integer.MAX_VALUE, Integer.MAX_VALUE + 1L, Integer.MAX_VALUE, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(1)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQueryFirst.getKey(), Integer.MAX_VALUE, 1L + Integer.MAX_VALUE, getTsForReadTsKvQuery(Integer.MAX_VALUE, 1L + Integer.MAX_VALUE), COUNT);
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenIntervalEqualsBigNumber() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 1, 3000, Integer.MAX_VALUE, LIMIT, COUNT, DESC);
+        ReadTsKvQuery subQueryFirst = new BaseReadTsKvQuery(TEMP, 1, 3001, 1501, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(1)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, subQueryFirst.getKey(), 1, 3001, getTsForReadTsKvQuery(1, 3001), COUNT);
+    }
+
+    @Test
+    public void givenIntervalNotMultiplePeriod_whenAggregateCount_thenCountIntervalEqualsPeriodSize() {
+        ReadTsKvQuery query = new BaseReadTsKvQuery(TEMP, 1, 3000, 3, LIMIT, COUNT, DESC);
+        willCallRealMethod().given(tsDao).findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        tsDao.findAllAsync(SYS_TENANT_ID, SYS_TENANT_ID, query);
+        verify(tsDao, times(1000)).findAndAggregateAsync(any(), any(), anyLong(), anyLong(), anyLong(), any());
+        for (long i = 1; i <= 3000; i += 3) {
+            ReadTsKvQuery querySub = new BaseReadTsKvQuery(TEMP, i, i + 3, i + (i + 3 - i) / 2, LIMIT, COUNT, DESC);
+            verify(tsDao, times(1)).findAndAggregateAsync(SYS_TENANT_ID, querySub.getKey(), i, i + 3, getTsForReadTsKvQuery(i, i + 3), COUNT);
+        }
+    }
+
+    long getTsForReadTsKvQuery(long startTs, long endTs) {
+        return startTs + (endTs - startTs) / 2L;
+    }
+
+}

docker/docker-compose.cassandra.volumes.yml

@@ -0,0 +1,27 @@
+#
+# Copyright © 2016-2022 The Thingsboard Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+version: '2.2'
+
+services:
+  cassandra:
+    volumes:
+      - cassandra-volume:/var/lib/cassandra
+
+volumes:
+  cassandra-volume:
+    external: true
+    name: ${CASSANDRA_DATA_VOLUME}

docker/docker-compose.hybrid.yml

@@ -29,7 +29,7 @@ services:
       - ./tb-node/postgres:/var/lib/postgresql/data
   cassandra:
     restart: always
-    image: "cassandra:3.11.3"
+    image: "cassandra:4.0.4"
     ports:
       - "9042"
     volumes:

msa/black-box-tests/README.md

@@ -26,5 +26,9 @@ As result, in REPOSITORY column, next images should be present:
 
         mvn clean install -DblackBoxTests.skip=false -DblackBoxTests.redisCluster=true
 
+- Run the black box tests in the [msa/black-box-tests](../black-box-tests) directory in Hybrid mode (postgres + cassandra):
+
+        mvn clean install -DblackBoxTests.skip=false -DblackBoxTests.hybridMode=true
+
 
 

msa/black-box-tests/src/test/java/org/thingsboard/server/msa/ContainerTestSuite.java

@@ -27,6 +27,9 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.UUID;
 
 import static org.hamcrest.CoreMatchers.containsString;
@@ -40,6 +43,7 @@ import static org.junit.Assert.fail;
 @Slf4j
 public class ContainerTestSuite {
     final static boolean IS_REDIS_CLUSTER = Boolean.parseBoolean(System.getProperty("blackBoxTests.redisCluster"));
+    final static boolean IS_HYBRID_MODE = Boolean.parseBoolean(System.getProperty("blackBoxTests.hybridMode"));
     private static final String SOURCE_DIR = "./../../docker/";
     private static final String TB_CORE_LOG_REGEXP = ".*Starting polling for events.*";
     private static final String TRANSPORTS_LOG_REGEXP = ".*Going to recalculate partitions.*";
@@ -53,6 +57,7 @@ public class ContainerTestSuite {
     public static DockerComposeContainer getTestContainer() {
         if (testContainer == null) {
             log.info("System property of blackBoxTests.redisCluster is {}", IS_REDIS_CLUSTER);
+            log.info("System property of blackBoxTests.hybridMode is {}", IS_HYBRID_MODE);
             boolean skipTailChildContainers = Boolean.valueOf(System.getProperty("blackBoxTests.skipTailChildContainers"));
             try {
                 final String targetDir = FileUtils.getTempDirectoryPath() + "/" + "ContainerTestSuite-" + UUID.randomUUID() + "/";
@@ -61,7 +66,7 @@ public class ContainerTestSuite {
                 replaceInFile(targetDir + "docker-compose.yml", "    container_name: \"${LOAD_BALANCER_NAME}\"", "", "container_name");
 
                 class DockerComposeContainerImpl<SELF extends DockerComposeContainer<SELF>> extends DockerComposeContainer<SELF> {
-                    public DockerComposeContainerImpl(File... composeFiles) {
+                    public DockerComposeContainerImpl(List<File> composeFiles) {
                         super(composeFiles);
                     }
 
@@ -72,10 +77,11 @@ public class ContainerTestSuite {
                     }
                 }
 
-                testContainer = new DockerComposeContainerImpl<>(
-                        new File(targetDir + "docker-compose.yml"),
+                List<File> composeFiles = new ArrayList<>(Arrays.asList(new File(targetDir + "docker-compose.yml"),
                         new File(targetDir + "docker-compose.volumes.yml"),
-                        new File(targetDir + "docker-compose.postgres.yml"),
+                        IS_HYBRID_MODE
+                                ? new File(targetDir + "docker-compose.hybrid.yml")
+                                : new File(targetDir + "docker-compose.postgres.yml"),
                         new File(targetDir + "docker-compose.postgres.volumes.yml"),
                         new File(targetDir + "docker-compose.kafka.yml"),
                         IS_REDIS_CLUSTER
@@ -83,8 +89,13 @@ public class ContainerTestSuite {
                                 : new File("./../../docker/docker-compose.redis.yml"),
                         IS_REDIS_CLUSTER
                                 ? new File("./../../docker/docker-compose.redis-cluster.volumes.yml")
-                                : new File("./../../docker/docker-compose.redis.volumes.yml")
-                        )
+                                : new File("./../../docker/docker-compose.redis.volumes.yml")));
+
+                if (IS_HYBRID_MODE) {
+                    composeFiles.add(new File(targetDir + "docker-compose.cassandra.volumes.yml"));
+                }
+
+                testContainer = new DockerComposeContainerImpl<>(composeFiles)
                         .withPull(false)
                         .withLocalCompose(true)
                         .withTailChildContainers(!skipTailChildContainers)

msa/black-box-tests/src/test/java/org/thingsboard/server/msa/ThingsBoardDbInstaller.java

@@ -21,10 +21,7 @@ import org.junit.rules.ExternalResource;
 import org.testcontainers.utility.Base58;
 
 import java.io.File;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -32,7 +29,10 @@ import java.util.stream.IntStream;
 public class ThingsBoardDbInstaller extends ExternalResource {
 
     final static boolean IS_REDIS_CLUSTER = Boolean.parseBoolean(System.getProperty("blackBoxTests.redisCluster"));
+    final static boolean IS_HYBRID_MODE = Boolean.parseBoolean(System.getProperty("blackBoxTests.hybridMode"));
     private final static String POSTGRES_DATA_VOLUME = "tb-postgres-test-data-volume";
+
+    private final static String CASSANDRA_DATA_VOLUME = "tb-cassandra-test-data-volume";
     private final static String REDIS_DATA_VOLUME = "tb-redis-data-volume";
     private final static String REDIS_CLUSTER_DATA_VOLUME = "tb-redis-cluster-data-volume";
     private final static String TB_LOG_VOLUME = "tb-log-test-volume";
@@ -46,6 +46,7 @@ public class ThingsBoardDbInstaller extends ExternalResource {
     private final DockerComposeExecutor dockerCompose;
 
     private final String postgresDataVolume;
+    private final String cassandraDataVolume;
 
     private final String redisDataVolume;
     private final String redisClusterDataVolume;
@@ -60,10 +61,13 @@ public class ThingsBoardDbInstaller extends ExternalResource {
 
     public ThingsBoardDbInstaller() {
         log.info("System property of blackBoxTests.redisCluster is {}", IS_REDIS_CLUSTER);
-        List<File> composeFiles = Arrays.asList(
+        log.info("System property of blackBoxTests.hybridMode is {}", IS_HYBRID_MODE);
+        List<File> composeFiles = new ArrayList<>(Arrays.asList(
                 new File("./../../docker/docker-compose.yml"),
                 new File("./../../docker/docker-compose.volumes.yml"),
-                new File("./../../docker/docker-compose.postgres.yml"),
+                IS_HYBRID_MODE
+                       ? new File("./../../docker/docker-compose.hybrid.yml")
+                       : new File("./../../docker/docker-compose.postgres.yml"),
                 new File("./../../docker/docker-compose.postgres.volumes.yml"),
                 IS_REDIS_CLUSTER
                         ? new File("./../../docker/docker-compose.redis-cluster.yml")
@@ -71,12 +75,16 @@ public class ThingsBoardDbInstaller extends ExternalResource {
                 IS_REDIS_CLUSTER
                         ? new File("./../../docker/docker-compose.redis-cluster.volumes.yml")
                         : new File("./../../docker/docker-compose.redis.volumes.yml")
-        );
+        ));
+        if (IS_HYBRID_MODE) {
+            composeFiles.add(new File("./../../docker/docker-compose.cassandra.volumes.yml"));
+        }
 
         String identifier = Base58.randomString(6).toLowerCase();
         String project = identifier + Base58.randomString(6).toLowerCase();
 
         postgresDataVolume = project + "_" + POSTGRES_DATA_VOLUME;
+        cassandraDataVolume = project + "_" + CASSANDRA_DATA_VOLUME;
         redisDataVolume = project + "_" + REDIS_DATA_VOLUME;
         redisClusterDataVolume = project + "_" + REDIS_CLUSTER_DATA_VOLUME;
         tbLogVolume = project + "_" + TB_LOG_VOLUME;
@@ -91,6 +99,9 @@ public class ThingsBoardDbInstaller extends ExternalResource {
 
         env = new HashMap<>();
         env.put("POSTGRES_DATA_VOLUME", postgresDataVolume);
+        if (IS_HYBRID_MODE) {
+            env.put("CASSANDRA_DATA_VOLUME", cassandraDataVolume);
+        }
         env.put("TB_LOG_VOLUME", tbLogVolume);
         env.put("TB_COAP_TRANSPORT_LOG_VOLUME", tbCoapTransportLogVolume);
         env.put("TB_LWM2M_TRANSPORT_LOG_VOLUME", tbLwm2mTransportLogVolume);
@@ -119,6 +130,11 @@ public class ThingsBoardDbInstaller extends ExternalResource {
             dockerCompose.withCommand("volume create " + postgresDataVolume);
             dockerCompose.invokeDocker();
 
+            if (IS_HYBRID_MODE) {
+                dockerCompose.withCommand("volume create " + cassandraDataVolume);
+                dockerCompose.invokeDocker();
+            }
+
             dockerCompose.withCommand("volume create " + tbLogVolume);
             dockerCompose.invokeDocker();
 
@@ -140,20 +156,23 @@ public class ThingsBoardDbInstaller extends ExternalResource {
             dockerCompose.withCommand("volume create " + tbVcExecutorLogVolume);
             dockerCompose.invokeDocker();
 
-            String redisService = "";
+            String additionalServices = "";
+            if (IS_HYBRID_MODE) {
+                additionalServices += " cassandra";
+            }
             if (IS_REDIS_CLUSTER) {
                 for (int i = 0; i < 6; i++) {
-                    redisService = redisService + " redis-node-" + i;
+                    additionalServices = additionalServices + " redis-node-" + i;
                     dockerCompose.withCommand("volume create " + redisClusterDataVolume + '-' + i);
                     dockerCompose.invokeDocker();
                 }
             } else {
-                redisService = "redis";
+                additionalServices += " redis";
                 dockerCompose.withCommand("volume create " + redisDataVolume);
                 dockerCompose.invokeDocker();
             }
 
-            dockerCompose.withCommand("up -d postgres " + redisService);
+            dockerCompose.withCommand("up -d postgres" + additionalServices);
             dockerCompose.invokeCompose();
 
             dockerCompose.withCommand("run --no-deps --rm -e INSTALL_TB=true -e LOAD_DEMO=true tb-core1");

msa/js-executor/api/jsInvokeMessageProcessor.js

@@ -144,7 +144,7 @@ JsInvokeMessageProcessor.prototype.processInvokeRequest = function (requestId, r
                 },
                 (err) => {
                     var errorCode;
-                    if (err.message.includes('Script execution timed out')) {
+                    if (err && isString(err.message) && err.message.includes('Script execution timed out')) {
                         errorCode = TIMEOUT_ERROR;
                     } else {
                         errorCode = RUNTIME_ERROR;
@@ -321,4 +321,8 @@ function deleteMinUsedScript() {
     this.scriptMap.delete(prevScriptId);
 }
 
+function isString(value) {
+    return typeof value === 'string';
+}
+
 module.exports = JsInvokeMessageProcessor;

ui-ngx/src/app/modules/home/components/entity/add-entity-dialog.component.html

@@ -15,7 +15,7 @@
     limitations under the License.
 
 -->
-<form (ngSubmit)="add()" style="min-width: 400px;" [ngStyle]="entitiesTableConfig.addDialogStyle">
+<form (ngSubmit)="add()" style="min-width: 400px; width: 700px;" [ngStyle]="entitiesTableConfig.addDialogStyle">
   <mat-toolbar color="primary">
     <h2 translate>{{ translations.add }}</h2>
     <span fxFlex></span>

ui-ngx/src/app/modules/home/components/profile/tenant-profile.component.html

@@ -48,7 +48,7 @@
 <div class="mat-padding" fxLayout="column">
   <form [formGroup]="entityForm">
     <fieldset [disabled]="(isLoading$ | async) || !isEdit">
-      <mat-form-field class="mat-block">
+      <mat-form-field class="mat-block" appearance="fill">
         <mat-label translate>tenant-profile.name</mat-label>
         <input matInput formControlName="name" required/>
         <mat-error *ngIf="entityForm.get('name').hasError('required')">
@@ -99,7 +99,7 @@
           </mat-expansion-panel>
         </mat-accordion>
       </div>
-      <mat-form-field class="mat-block">
+      <mat-form-field class="mat-block" appearance="fill">
         <mat-label translate>tenant-profile.description</mat-label>
         <textarea matInput formControlName="description" rows="2"></textarea>
       </mat-form-field>

ui-ngx/src/app/modules/home/components/profile/tenant-profile.component.scss

@@ -14,6 +14,10 @@
  * limitations under the License.
  */
 :host ::ng-deep {
+  .mat-form-field-infix {
+    width: 100% !important;
+  }
+
   .mat-checkbox{
     &.hinted-checkbox {
       .mat-checkbox-inner-container {

ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.html

@@ -16,387 +16,511 @@
 
 -->
 <section [formGroup]="defaultTenantProfileConfigurationFormGroup" fxLayout="column">
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-devices</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxDevices"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDevices').hasError('required')">
-      {{ 'tenant-profile.maximum-devices-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDevices').hasError('min')">
-      {{ 'tenant-profile.maximum-devices-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-assets</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxAssets"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxAssets').hasError('required')">
-      {{ 'tenant-profile.maximum-assets-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxAssets').hasError('min')">
-      {{ 'tenant-profile.maximum-assets-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-customers</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxCustomers"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCustomers').hasError('required')">
-      {{ 'tenant-profile.maximum-customers-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCustomers').hasError('min')">
-      {{ 'tenant-profile.maximum-customers-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-users</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxUsers"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxUsers').hasError('required')">
-      {{ 'tenant-profile.maximum-users-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxUsers').hasError('min')">
-      {{ 'tenant-profile.maximum-users-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-dashboards</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxDashboards"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDashboards').hasError('required')">
-      {{ 'tenant-profile.maximum-dashboards-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDashboards').hasError('min')">
-      {{ 'tenant-profile.maximum-dashboards-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-rule-chains</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxRuleChains"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleChains').hasError('required')">
-      {{ 'tenant-profile.maximum-rule-chains-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleChains').hasError('min')">
-      {{ 'tenant-profile.maximum-rule-chains-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-resources-sum-data-size</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxResourcesInBytes"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxResourcesInBytes').hasError('required')">
-      {{ 'tenant-profile.maximum-resources-sum-data-size-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxResourcesInBytes').hasError('min')">
-      {{ 'tenant-profile.maximum-resources-sum-data-size-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.maximum-ota-packages-sum-data-size</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxOtaPackagesInBytes"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxOtaPackagesInBytes').hasError('required')">
-      {{ 'tenant-profile.maximum-ota-packages-sum-data-size-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxOtaPackagesInBytes').hasError('min')">
-      {{ 'tenant-profile.maximum-ota-packages-sum-data-size-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-transport-messages</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxTransportMessages"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportMessages').hasError('required')">
-      {{ 'tenant-profile.max-transport-messages-range' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportMessages').hasError('min')">
-      {{ 'tenant-profile.max-transport-messages-required' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-transport-data-points</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxTransportDataPoints"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportDataPoints').hasError('required')">
-      {{ 'tenant-profile.max-transport-data-points-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportDataPoints').hasError('min')">
-      {{ 'tenant-profile.max-transport-data-points-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-r-e-executions</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxREExecutions"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxREExecutions').hasError('required')">
-      {{ 'tenant-profile.max-r-e-executions-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxREExecutions').hasError('min')">
-      {{ 'tenant-profile.max-r-e-executions-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-j-s-executions</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxJSExecutions"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxJSExecutions').hasError('required')">
-      {{ 'tenant-profile.max-j-s-executions-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxJSExecutions').hasError('min')">
-      {{ 'tenant-profile.max-j-s-executions-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-d-p-storage-days</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxDPStorageDays"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDPStorageDays').hasError('required')">
-      {{ 'tenant-profile.max-d-p-storage-days-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDPStorageDays').hasError('min')">
-      {{ 'tenant-profile.max-d-p-storage-days-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.default-storage-ttl-days</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="defaultStorageTtlDays"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('defaultStorageTtlDays').hasError('required')">
-      {{ 'tenant-profile.default-storage-ttl-days-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('defaultStorageTtlDays').hasError('min')">
-      {{ 'tenant-profile.default-storage-ttl-days-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.alarms-ttl-days</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="alarmsTtlDays"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('alarmsTtlDays').hasError('required')">
-      {{ 'tenant-profile.alarms-ttl-days-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('alarmsTtlDays').hasError('min')">
-      {{ 'tenant-profile.alarms-ttl-days-days-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.rpc-ttl-days</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="rpcTtlDays"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('rpcTtlDays').hasError('required')">
-      {{ 'tenant-profile.rpc-ttl-days-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('rpcTtlDays').hasError('min')">
-      {{ 'tenant-profile.rpc-ttl-days-days-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-rule-node-executions-per-message</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxRuleNodeExecutionsPerMessage"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleNodeExecutionsPerMessage').hasError('required')">
-      {{ 'tenant-profile.max-rule-node-executions-per-message-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleNodeExecutionsPerMessage').hasError('min')">
-      {{ 'tenant-profile.max-rule-node-executions-per-message-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-emails</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxEmails"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxEmails').hasError('required')">
-      {{ 'tenant-profile.max-emails-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxEmails').hasError('min')">
-      {{ 'tenant-profile.max-emails-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-sms</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxSms"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxSms').hasError('required')">
-      {{ 'tenant-profile.max-sms-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxSms').hasError('min')">
-      {{ 'tenant-profile.max-sms-range' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.max-created-alarms</mat-label>
-    <input matInput required min="0" step="1"
-           formControlName="maxCreatedAlarms"
-           type="number">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCreatedAlarms').hasError('required')">
-      {{ 'tenant-profile.max-created-alarms-required' | translate}}
-    </mat-error>
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCreatedAlarms').hasError('min')">
-      {{ 'tenant-profile.max-created-alarms-range' | translate}}
-    </mat-error>
-  </mat-form-field>
+  <fieldset class="fields-group">
+    <legend class="group-title">
+      {{ 'tenant-profile.entities' | translate }} <span translate>tenant-profile.unlimited</span>
+    </legend>
+    <div class="fields-element" fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.maximum-devices</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxDevices"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDevices').hasError('required')">
+          {{ 'tenant-profile.maximum-devices-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDevices').hasError('min')">
+          {{ 'tenant-profile.maximum-devices-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.maximum-dashboards</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxDashboards"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDashboards').hasError('required')">
+          {{ 'tenant-profile.maximum-dashboards-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDashboards').hasError('min')">
+          {{ 'tenant-profile.maximum-dashboards-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.maximum-assets</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxAssets"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxAssets').hasError('required')">
+          {{ 'tenant-profile.maximum-assets-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxAssets').hasError('min')">
+          {{ 'tenant-profile.maximum-assets-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.maximum-users</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxUsers"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxUsers').hasError('required')">
+          {{ 'tenant-profile.maximum-users-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxUsers').hasError('min')">
+          {{ 'tenant-profile.maximum-users-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <mat-expansion-panel class="configuration-panel">
+      <mat-expansion-panel-header>
+        <mat-panel-description fxLayoutAlign="end" translate>
+          tenant-profile.advanced-settings
+        </mat-panel-description>
+      </mat-expansion-panel-header>
+      <ng-template matExpansionPanelContent>
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.maximum-customers</mat-label>
+            <input matInput required min="0" step="1"
+                   formControlName="maxCustomers"
+                   type="number">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCustomers').hasError('required')">
+              {{ 'tenant-profile.maximum-customers-required' | translate}}
+            </mat-error>
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCustomers').hasError('min')">
+              {{ 'tenant-profile.maximum-customers-range' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.maximum-rule-chains</mat-label>
+            <input matInput required min="0" step="1"
+                   formControlName="maxRuleChains"
+                   type="number">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleChains').hasError('required')">
+              {{ 'tenant-profile.maximum-rule-chains-required' | translate}}
+            </mat-error>
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleChains').hasError('min')">
+              {{ 'tenant-profile.maximum-rule-chains-range' | translate}}
+            </mat-error>
+          </mat-form-field>
+        </div>
+      </ng-template>
+    </mat-expansion-panel>
+  </fieldset>
 
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.transport-tenant-msg-rate-limit</mat-label>
-    <input matInput formControlName="transportTenantMsgRateLimit">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportTenantMsgRateLimit').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.transport-tenant-telemetry-msg-rate-limit</mat-label>
-    <input matInput formControlName="transportTenantTelemetryMsgRateLimit">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportTenantTelemetryMsgRateLimit').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.transport-tenant-telemetry-data-points-rate-limit</mat-label>
-    <input matInput formControlName="transportTenantTelemetryDataPointsRateLimit">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportTenantTelemetryDataPointsRateLimit').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.transport-device-msg-rate-limit</mat-label>
-    <input matInput formControlName="transportDeviceMsgRateLimit">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportDeviceMsgRateLimit').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.transport-device-telemetry-msg-rate-limit</mat-label>
-    <input matInput formControlName="transportDeviceTelemetryMsgRateLimit">
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.transport-device-telemetry-data-points-rate-limit</mat-label>
-    <input matInput formControlName="transportDeviceTelemetryDataPointsRateLimit">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportDeviceTelemetryDataPointsRateLimit').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.tenant-rest-limits</mat-label>
-    <input matInput
-           formControlName="tenantServerRestLimitsConfiguration"
-           type="text">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('tenantServerRestLimitsConfiguration').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.customer-rest-limits</mat-label>
-    <input matInput
-           formControlName="customerServerRestLimitsConfiguration"
-           type="text">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('customerServerRestLimitsConfiguration').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-sessions-per-tenant</mat-label>
-    <input matInput type="number" formControlName="maxWsSessionsPerTenant">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerTenant').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-sessions-per-customer</mat-label>
-    <input matInput type="number" formControlName="maxWsSessionsPerCustomer">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerCustomer').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-sessions-per-regular-user</mat-label>
-    <input matInput type="number" formControlName="maxWsSessionsPerRegularUser">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerRegularUser').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-sessions-per-public-user</mat-label>
-    <input matInput type="number" formControlName="maxWsSessionsPerPublicUser">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerPublicUser').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-queue-per-session</mat-label>
-    <input matInput type="number" formControlName="wsMsgQueueLimitPerSession">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('wsMsgQueueLimitPerSession').hasError('min')">
-      {{ 'tenant-profile.too-small-value-one' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-tenant</mat-label>
-    <input matInput type="number" formControlName="maxWsSubscriptionsPerTenant">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerTenant').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-customer</mat-label>
-    <input matInput type="number" formControlName="maxWsSubscriptionsPerCustomer">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerCustomer').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-regular-user</mat-label>
-    <input matInput type="number" formControlName="maxWsSubscriptionsPerRegularUser">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerRegularUser').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-public-user</mat-label>
-    <input matInput type="number" formControlName="maxWsSubscriptionsPerPublicUser">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerPublicUser').hasError('min')">
-      {{ 'tenant-profile.too-small-value-zero' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.ws-limit-updates-per-session</mat-label>
-    <input matInput type="text" formControlName="wsUpdatesPerSessionRateLimit">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('wsUpdatesPerSessionRateLimit').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.cassandra-tenant-limits-configuration</mat-label>
-    <input matInput type="text" formControlName="cassandraQueryTenantRateLimitsConfiguration">
-    <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('cassandraQueryTenantRateLimitsConfiguration').hasError('pattern')">
-      {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.tenant-entity-export-rate-limit</mat-label>
-    <input matInput formControlName="tenantEntityExportRateLimit">
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>tenant-profile.tenant-entity-import-rate-limit</mat-label>
-    <input matInput formControlName="tenantEntityImportRateLimit">
-  </mat-form-field>
+  <fieldset class="fields-group">
+    <legend class="group-title">
+      {{ 'tenant-profile.rule-engine' | translate }} <span translate>tenant-profile.unlimited</span>
+    </legend>
+    <div class="fields-element" fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.max-r-e-executions</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxREExecutions"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxREExecutions').hasError('required')">
+          {{ 'tenant-profile.max-r-e-executions-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxREExecutions').hasError('min')">
+          {{ 'tenant-profile.max-r-e-executions-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.max-transport-messages</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxTransportMessages"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportMessages').hasError('required')">
+          {{ 'tenant-profile.max-transport-messages-range' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportMessages').hasError('min')">
+          {{ 'tenant-profile.max-transport-messages-required' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <mat-expansion-panel class="configuration-panel">
+      <mat-expansion-panel-header>
+        <mat-panel-description fxLayoutAlign="end" translate>
+          tenant-profile.advanced-settings
+        </mat-panel-description>
+      </mat-expansion-panel-header>
+      <ng-template matExpansionPanelContent>
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.max-j-s-executions</mat-label>
+            <input matInput required min="0" step="1"
+                   formControlName="maxJSExecutions"
+                   type="number">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxJSExecutions').hasError('required')">
+              {{ 'tenant-profile.max-j-s-executions-required' | translate}}
+            </mat-error>
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxJSExecutions').hasError('min')">
+              {{ 'tenant-profile.max-j-s-executions-range' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.max-transport-data-points</mat-label>
+            <input matInput required min="0" step="1"
+                   formControlName="maxTransportDataPoints"
+                   type="number">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportDataPoints').hasError('required')">
+              {{ 'tenant-profile.max-transport-data-points-required' | translate}}
+            </mat-error>
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxTransportDataPoints').hasError('min')">
+              {{ 'tenant-profile.max-transport-data-points-range' | translate}}
+            </mat-error>
+          </mat-form-field>
+        </div>
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.max-rule-node-executions-per-message</mat-label>
+            <input matInput required min="0" step="1"
+                   formControlName="maxRuleNodeExecutionsPerMessage"
+                   type="number">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleNodeExecutionsPerMessage').hasError('required')">
+              {{ 'tenant-profile.max-rule-node-executions-per-message-required' | translate}}
+            </mat-error>
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxRuleNodeExecutionsPerMessage').hasError('min')">
+              {{ 'tenant-profile.max-rule-node-executions-per-message-range' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <div fxFlex></div>
+        </div>
+      </ng-template>
+    </mat-expansion-panel>
+  </fieldset>
+
+  <fieldset class="fields-group">
+    <legend class="group-title">
+      {{ 'tenant-profile.time-to-live' | translate }} <span translate>tenant-profile.unlimited</span>
+    </legend>
+    <div class="fields-element" fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.max-d-p-storage-days</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxDPStorageDays"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDPStorageDays').hasError('required')">
+          {{ 'tenant-profile.max-d-p-storage-days-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxDPStorageDays').hasError('min')">
+          {{ 'tenant-profile.max-d-p-storage-days-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.alarms-ttl-days</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="alarmsTtlDays"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('alarmsTtlDays').hasError('required')">
+          {{ 'tenant-profile.alarms-ttl-days-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('alarmsTtlDays').hasError('min')">
+          {{ 'tenant-profile.alarms-ttl-days-days-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.default-storage-ttl-days</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="defaultStorageTtlDays"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('defaultStorageTtlDays').hasError('required')">
+          {{ 'tenant-profile.default-storage-ttl-days-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('defaultStorageTtlDays').hasError('min')">
+          {{ 'tenant-profile.default-storage-ttl-days-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.rpc-ttl-days</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="rpcTtlDays"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('rpcTtlDays').hasError('required')">
+          {{ 'tenant-profile.rpc-ttl-days-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('rpcTtlDays').hasError('min')">
+          {{ 'tenant-profile.rpc-ttl-days-days-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+  </fieldset>
+
+  <fieldset class="fields-group">
+    <legend class="group-title">
+      {{ 'tenant-profile.alarms-and-notifications' | translate }} <span translate>tenant-profile.unlimited</span>
+    </legend>
+    <div class="fields-element" fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.max-emails</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxEmails"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxEmails').hasError('required')">
+          {{ 'tenant-profile.max-emails-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxEmails').hasError('min')">
+          {{ 'tenant-profile.max-emails-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.max-created-alarms</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxCreatedAlarms"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCreatedAlarms').hasError('required')">
+          {{ 'tenant-profile.max-created-alarms-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxCreatedAlarms').hasError('min')">
+          {{ 'tenant-profile.max-created-alarms-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.max-sms</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxSms"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxSms').hasError('required')">
+          {{ 'tenant-profile.max-sms-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxSms').hasError('min')">
+          {{ 'tenant-profile.max-sms-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <div fxFlex></div>
+  </div>
+  </fieldset>
+
+  <fieldset class="fields-group">
+    <legend class="group-title">
+      {{ 'tenant-profile.ota-files-in-bytes' | translate }} <span translate>tenant-profile.unlimited</span>
+    </legend>
+    <div class="fields-element" fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.maximum-resources-sum-data-size</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxResourcesInBytes"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxResourcesInBytes').hasError('required')">
+          {{ 'tenant-profile.maximum-resources-sum-data-size-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxResourcesInBytes').hasError('min')">
+          {{ 'tenant-profile.maximum-resources-sum-data-size-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.maximum-ota-packages-sum-data-size</mat-label>
+        <input matInput required min="0" step="1"
+               formControlName="maxOtaPackagesInBytes"
+               type="number">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxOtaPackagesInBytes').hasError('required')">
+          {{ 'tenant-profile.maximum-ota-packages-sum-data-size-required' | translate}}
+        </mat-error>
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxOtaPackagesInBytes').hasError('min')">
+          {{ 'tenant-profile.maximum-ota-packages-sum-data-size-range' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+  </fieldset>
+
+  <fieldset class="fields-group">
+    <legend class="group-title">
+      {{ 'tenant-profile.ws-title' | translate }} <span translate>tenant-profile.unlimited</span>
+    </legend>
+    <div class="fields-element" fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.ws-limit-max-sessions-per-tenant</mat-label>
+        <input matInput type="number" formControlName="maxWsSessionsPerTenant">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerTenant').hasError('min')">
+          {{ 'tenant-profile.too-small-value-zero' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-tenant</mat-label>
+        <input matInput type="number" formControlName="maxWsSubscriptionsPerTenant">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerTenant').hasError('min')">
+          {{ 'tenant-profile.too-small-value-zero' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.ws-limit-max-sessions-per-customer</mat-label>
+        <input matInput type="number" formControlName="maxWsSessionsPerCustomer">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerCustomer').hasError('min')">
+          {{ 'tenant-profile.too-small-value-zero' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block" appearance="fill">
+        <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-customer</mat-label>
+        <input matInput type="number" formControlName="maxWsSubscriptionsPerCustomer">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerCustomer').hasError('min')">
+          {{ 'tenant-profile.too-small-value-zero' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <mat-expansion-panel class="configuration-panel">
+      <mat-expansion-panel-header>
+        <mat-panel-description fxLayoutAlign="end" translate>
+          tenant-profile.advanced-settings
+        </mat-panel-description>
+      </mat-expansion-panel-header>
+      <ng-template matExpansionPanelContent>
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.ws-limit-max-sessions-per-public-user</mat-label>
+            <input matInput type="number" formControlName="maxWsSessionsPerPublicUser">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerPublicUser').hasError('min')">
+              {{ 'tenant-profile.too-small-value-zero' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-public-user</mat-label>
+            <input matInput type="number" formControlName="maxWsSubscriptionsPerPublicUser">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerPublicUser').hasError('min')">
+              {{ 'tenant-profile.too-small-value-zero' | translate}}
+            </mat-error>
+          </mat-form-field>
+        </div>
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.ws-limit-max-sessions-per-regular-user</mat-label>
+            <input matInput type="number" formControlName="maxWsSessionsPerRegularUser">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSessionsPerRegularUser').hasError('min')">
+              {{ 'tenant-profile.too-small-value-zero' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.ws-limit-max-subscriptions-per-regular-user</mat-label>
+            <input matInput type="number" formControlName="maxWsSubscriptionsPerRegularUser">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('maxWsSubscriptionsPerRegularUser').hasError('min')">
+              {{ 'tenant-profile.too-small-value-zero' | translate}}
+            </mat-error>
+          </mat-form-field>
+        </div>
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block" appearance="fill">
+            <mat-label translate>tenant-profile.ws-limit-queue-per-session</mat-label>
+            <input matInput type="number" formControlName="wsMsgQueueLimitPerSession">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('wsMsgQueueLimitPerSession').hasError('min')">
+              {{ 'tenant-profile.too-small-value-one' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <div fxFlex></div>
+        </div>
+      </ng-template>
+    </mat-expansion-panel>
+  </fieldset>
+
+  <fieldset class="fields-group">
+    <legend class="group-title">Rate limits</legend>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block">
+        <mat-label translate>tenant-profile.transport-tenant-msg-rate-limit</mat-label>
+        <input matInput formControlName="transportTenantMsgRateLimit">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportTenantMsgRateLimit').hasError('pattern')">
+          {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block">
+        <mat-label translate>tenant-profile.transport-device-msg-rate-limit</mat-label>
+        <input matInput formControlName="transportDeviceMsgRateLimit">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportDeviceMsgRateLimit').hasError('pattern')">
+          {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+      <mat-form-field fxFlex class="mat-block">
+        <mat-label translate>tenant-profile.transport-tenant-telemetry-msg-rate-limit</mat-label>
+        <input matInput formControlName="transportTenantTelemetryMsgRateLimit">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportTenantTelemetryMsgRateLimit').hasError('pattern')">
+          {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+        </mat-error>
+      </mat-form-field>
+      <mat-form-field fxFlex class="mat-block">
+        <mat-label translate>tenant-profile.transport-device-telemetry-msg-rate-limit</mat-label>
+        <input matInput formControlName="transportDeviceTelemetryMsgRateLimit">
+        <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportTenantTelemetryMsgRateLimit').hasError('pattern')">
+          {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+        </mat-error>
+      </mat-form-field>
+    </div>
+    <mat-expansion-panel class="configuration-panel">
+      <mat-expansion-panel-header>
+        <mat-panel-description fxLayoutAlign="end" translate>
+          tenant-profile.advanced-settings
+        </mat-panel-description>
+      </mat-expansion-panel-header>
+      <ng-template matExpansionPanelContent>
+        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.transport-tenant-telemetry-data-points-rate-limit</mat-label>
+            <input matInput formControlName="transportTenantTelemetryDataPointsRateLimit">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportTenantTelemetryDataPointsRateLimit').hasError('pattern')">
+              {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.transport-device-telemetry-data-points-rate-limit</mat-label>
+            <input matInput formControlName="transportDeviceTelemetryDataPointsRateLimit">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('transportDeviceTelemetryDataPointsRateLimit').hasError('pattern')">
+              {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+            </mat-error>
+          </mat-form-field>
+        </div>
+        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.tenant-rest-limits</mat-label>
+            <input matInput
+                   formControlName="tenantServerRestLimitsConfiguration"
+                   type="text">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('tenantServerRestLimitsConfiguration').hasError('pattern')">
+              {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.customer-rest-limits</mat-label>
+            <input matInput
+                   formControlName="customerServerRestLimitsConfiguration"
+                   type="text">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('customerServerRestLimitsConfiguration').hasError('pattern')">
+              {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+            </mat-error>
+          </mat-form-field>
+        </div>
+        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.tenant-entity-export-rate-limit</mat-label>
+            <input matInput formControlName="tenantEntityExportRateLimit">
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.tenant-entity-import-rate-limit</mat-label>
+            <input matInput formControlName="tenantEntityImportRateLimit">
+          </mat-form-field>
+        </div>
+        <div fxFlex fxLayout="row"  fxLayout.xs="column" fxLayoutGap.gt-xs="16px">
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.ws-limit-updates-per-session</mat-label>
+            <input matInput type="text" formControlName="wsUpdatesPerSessionRateLimit">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('wsUpdatesPerSessionRateLimit').hasError('pattern')">
+              {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+            </mat-error>
+          </mat-form-field>
+          <mat-form-field fxFlex class="mat-block">
+            <mat-label translate>tenant-profile.cassandra-tenant-limits-configuration</mat-label>
+            <input matInput type="text" formControlName="cassandraQueryTenantRateLimitsConfiguration">
+            <mat-error *ngIf="defaultTenantProfileConfigurationFormGroup.get('cassandraQueryTenantRateLimitsConfiguration').hasError('pattern')">
+              {{ 'tenant-profile.incorrect-pattern-for-rate-limits' | translate}}
+            </mat-error>
+          </mat-form-field>
+        </div>
+      </ng-template>
+    </mat-expansion-panel>
+  </fieldset>
 </section>

ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.scss

@@ -0,0 +1,55 @@
+/**
+ * Copyright © 2016-2022 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+:host {
+  .fields-element {
+    padding-top: 15px;
+  }
+
+  .group-title > span {
+    color: rgba(0, 0, 0, 0.54);
+  }
+
+  ::ng-deep {
+    .mat-expansion-panel {
+      &.configuration-panel {
+        box-shadow: none;
+
+        .mat-expansion-panel-header {
+          padding: 0;
+
+          &:hover {
+            background: none !important;
+          }
+
+          .mat-expansion-indicator {
+            padding: 2px;
+          }
+        }
+
+        > .mat-expansion-panel-content {
+          > .mat-expansion-panel-body {
+            padding: 0;
+          }
+        }
+
+        .mat-expansion-panel-header-description {
+          align-items: center;
+        }
+      }
+    }
+  }
+}

ui-ngx/src/app/modules/home/components/profile/tenant/default-tenant-profile-configuration.component.ts

@@ -25,7 +25,7 @@ import { isDefinedAndNotNull } from '@core/utils';
 @Component({
   selector: 'tb-default-tenant-profile-configuration',
   templateUrl: './default-tenant-profile-configuration.component.html',
-  styleUrls: [],
+  styleUrls: ['./default-tenant-profile-configuration.component.scss'],
   providers: [{
     provide: NG_VALUE_ACCESSOR,
     useExisting: forwardRef(() => DefaultTenantProfileConfigurationComponent),
@@ -35,7 +35,7 @@ import { isDefinedAndNotNull } from '@core/utils';
 export class DefaultTenantProfileConfigurationComponent implements ControlValueAccessor, OnInit {
 
   defaultTenantProfileConfigurationFormGroup: FormGroup;
-  rateLimitsPattern = '^(((\\d+):(\\d+)),)*((\\d+):(\\d+))$';
+  rateLimitsPattern = '([1-9]\\d*:[1-9]\\d*)(,[1-9]\\d*:[1-9]\\d*)*';
 
   private requiredValue: boolean;
   get required(): boolean {

ui-ngx/src/app/modules/home/components/queue/queue-form.component.html

@@ -17,7 +17,7 @@
 -->
 
 <form [formGroup]="queueFormGroup" fxLayout="column">
-  <mat-form-field class="mat-block">
+  <mat-form-field class="mat-block" appearance="fill">
     <mat-label translate>admin.queue-name</mat-label>
     <input matInput formControlName="name" required>
     <mat-error *ngIf="queueFormGroup.get('name').hasError('required')">
@@ -27,151 +27,181 @@
       {{ 'queue.name-unique' | translate }}
     </mat-error>
   </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>queue.poll-interval</mat-label>
-    <input type="number" matInput formControlName="pollInterval" required>
-    <mat-error *ngIf="queueFormGroup.get('pollInterval').hasError('required')">
-      {{ 'queue.poll-interval-required' | translate }}
-    </mat-error>
-    <mat-error *ngIf="queueFormGroup.get('pollInterval').hasError('min') &&
-               !queueFormGroup.get('pollInterval').hasError('required')">
-      {{ 'queue.poll-interval-min-value' | translate }}
-    </mat-error>
-  </mat-form-field>
-  <mat-form-field class="mat-block">
-    <mat-label translate>queue.partitions</mat-label>
-    <input type="number" matInput formControlName="partitions" required>
-    <mat-error *ngIf="queueFormGroup.get('partitions').hasError('required')">
-      {{ 'queue.partitions-required' | translate }}
-    </mat-error>
-    <mat-error *ngIf="queueFormGroup.get('partitions').hasError('min') &&
-               !queueFormGroup.get('partitions').hasError('required')">
-      {{ 'queue.partitions-min-value' | translate }}
-    </mat-error>
-  </mat-form-field>
-  <mat-checkbox class="hinted-checkbox" formControlName="consumerPerPartition">
-    <div>{{ 'queue.consumer-per-partition' | translate }}</div>
-    <div class="tb-hint">{{'queue.consumer-per-partition-hint' | translate}}</div>
-  </mat-checkbox>
-  <mat-form-field class="mat-block">
-    <mat-label translate>queue.processing-timeout</mat-label>
-    <input type="number" matInput formControlName="packProcessingTimeout" required>
-    <mat-error *ngIf="queueFormGroup.get('packProcessingTimeout').hasError('required')">
-      {{ 'queue.pack-processing-timeout-required' | translate }}
-    </mat-error>
-    <mat-error *ngIf="queueFormGroup.get('packProcessingTimeout').hasError('min') &&
-               !queueFormGroup.get('packProcessingTimeout').hasError('required')">
-      {{ 'queue.pack-processing-timeout-min-value' | translate }}
-    </mat-error>
-  </mat-form-field>
   <mat-accordion class="queue-strategy" [multi]="true">
-    <mat-expansion-panel [expanded]="false">
+    <mat-expansion-panel [expanded]="true">
       <mat-expansion-panel-header>
-        <mat-panel-title translate>
-          queue.submit-strategy
+        <mat-panel-title class="panel-title" translate>
+          queue.submit-settings
         </mat-panel-title>
       </mat-expansion-panel-header>
       <ng-template matExpansionPanelContent>
-        <div formGroupName="submitStrategy">
-          <mat-form-field class="mat-block">
-            <mat-label translate>queue.submit-strategy</mat-label>
-            <mat-select formControlName="type" required>
-              <mat-option *ngFor="let strategy of submitStrategies" [value]="strategy">
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap="16px" formGroupName="submitStrategy" style="padding-bottom: 15px;">
+          <div fxFlex>
+            <label class="group-label" translate>queue.submit-strategy</label>
+            <mat-radio-group fxFlex fxLayout="column" fxLayoutGap="15px" formControlName="type" required>
+              <mat-radio-button *ngFor="let strategy of submitStrategies" [value]="strategy">
                 {{ queueSubmitStrategyTypesMap.get(queueSubmitStrategyTypes[strategy]).label | translate }}
-              </mat-option>
-            </mat-select>
-            <mat-error *ngIf="queueFormGroup.get('submitStrategy.type').hasError('required')">
-              {{ 'queue.submit-strategy-type-required' | translate }}
-            </mat-error>
-          </mat-form-field>
-          <mat-form-field class="mat-block" *ngIf="hideBatchSize">
-            <mat-label translate>queue.batch-size</mat-label>
-            <input type="number" matInput formControlName="batchSize" required>
-            <mat-error *ngIf="queueFormGroup.get('submitStrategy.batchSize').hasError('required')">
-              {{ 'queue.batch-size-required' | translate }}
-            </mat-error>
-            <mat-error *ngIf="queueFormGroup.get('submitStrategy.batchSize').hasError('min') &&
-                 !queueFormGroup.get('submitStrategy.batchSize').hasError('required')">
-              {{ 'queue.batch-size-min-value' | translate }}
-            </mat-error>
-          </mat-form-field>
+                <mat-icon
+                  class="hint-icon"
+                  matTooltip="{{ queueSubmitStrategyTypesMap.get(queueSubmitStrategyTypes[strategy]).hint | translate }}"
+                  svgIcon="mdi:information-outline">
+                </mat-icon>
+              </mat-radio-button>
+            </mat-radio-group>
+          </div>
+          <div fxFlex *ngIf="hideBatchSize">
+            <label class="group-label" translate>queue.grouping-parameter</label>
+            <mat-form-field class="mat-block">
+              <mat-label translate>queue.batch-size</mat-label>
+              <input type="number" matInput formControlName="batchSize" required>
+              <mat-error *ngIf="queueFormGroup.get('submitStrategy.batchSize').hasError('required')">
+                {{ 'queue.batch-size-required' | translate }}
+              </mat-error>
+              <mat-error *ngIf="queueFormGroup.get('submitStrategy.batchSize').hasError('min') &&
+                   !queueFormGroup.get('submitStrategy.batchSize').hasError('required')">
+                {{ 'queue.batch-size-min-value' | translate }}
+              </mat-error>
+            </mat-form-field>
+          </div>
         </div>
       </ng-template>
     </mat-expansion-panel>
-    <mat-expansion-panel [expanded]="false">
+    <mat-expansion-panel [expanded]="true">
       <mat-expansion-panel-header>
-        <mat-panel-title translate>
-          queue.processing-strategy
+        <mat-panel-title class="panel-title" translate>
+          queue.processing-settings
         </mat-panel-title>
       </mat-expansion-panel-header>
       <ng-template matExpansionPanelContent>
-        <div formGroupName="processingStrategy">
-          <mat-form-field class="mat-block">
-            <mat-label translate>queue.processing-strategy</mat-label>
-            <mat-select formControlName="type" required>
-              <mat-option *ngFor="let strategy of processingStrategies" [value]="strategy">
-                {{ queueProcessingStrategyTypesMap.get(queueProcessingStrategyTypes[strategy]).label | translate }}
-              </mat-option>
-            </mat-select>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.type').hasError('required')">
-              {{ 'queue.processing-strategy-type-required' | translate }}
-            </mat-error>
-          </mat-form-field>
-          <mat-form-field class="mat-block">
-            <mat-label translate>queue.retries</mat-label>
-            <input type="number" matInput formControlName="retries" required>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.retries').hasError('required')">
-              {{ 'queue.retries-required' | translate }}
-            </mat-error>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.retries').hasError('min') &&
+        <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap="16px" formGroupName="processingStrategy" style="padding-bottom: 15px;">
+          <div fxFlex>
+            <label class="group-label" translate>queue.processing-strategy</label>
+              <mat-radio-group fxFlex fxLayout="column" fxLayoutGap="15px" formControlName="type" required>
+                <mat-radio-button *ngFor="let strategy of processingStrategies" [value]="strategy">
+                  {{ queueProcessingStrategyTypesMap.get(queueProcessingStrategyTypes[strategy]).label | translate }}
+                  <mat-icon
+                    class="hint-icon"
+                    matTooltip="{{ queueProcessingStrategyTypesMap.get(queueProcessingStrategyTypes[strategy]).hint | translate }}"
+                    svgIcon="mdi:information-outline">
+                  </mat-icon>
+                </mat-radio-button>
+              </mat-radio-group>
+          </div>
+          <div fxFlex>
+            <label class="group-label" translate>queue.retries-settings</label>
+            <mat-form-field class="mat-block">
+              <mat-label translate>queue.retries</mat-label>
+              <input type="number" matInput formControlName="retries" required>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.retries').hasError('required')">
+                {{ 'queue.retries-required' | translate }}
+              </mat-error>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.retries').hasError('min') &&
                  !queueFormGroup.get('processingStrategy.retries').hasError('required')">
-              {{ 'queue.retries-min-value' | translate }}
-            </mat-error>
-          </mat-form-field>
-          <mat-form-field class="mat-block">
-            <mat-label translate>queue.failure-percentage</mat-label>
-            <input type="number" matInput formControlName="failurePercentage" required>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.failurePercentage').hasError('required')">
-              {{ 'queue.failure-percentage-required' | translate }}
-            </mat-error>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.failurePercentage').hasError('min') &&
+                {{ 'queue.retries-min-value' | translate }}
+              </mat-error>
+            </mat-form-field>
+            <mat-form-field class="mat-block">
+              <mat-label translate>queue.failure-percentage</mat-label>
+              <input type="number" matInput formControlName="failurePercentage" required>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.failurePercentage').hasError('required')">
+                {{ 'queue.failure-percentage-required' | translate }}
+              </mat-error>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.failurePercentage').hasError('min') &&
                  !queueFormGroup.get('processingStrategy.failurePercentage').hasError('required') &&
                  !queueFormGroup.get('processingStrategy.failurePercentage').hasError('max')">
-              {{ 'queue.failure-percentage-min-value' | translate }}
-            </mat-error>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.failurePercentage').hasError('max') &&
+                {{ 'queue.failure-percentage-min-value' | translate }}
+              </mat-error>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.failurePercentage').hasError('max') &&
                  !queueFormGroup.get('processingStrategy.failurePercentage').hasError('required') &&
                  !queueFormGroup.get('processingStrategy.failurePercentage').hasError('min')">
-              {{ 'queue.failure-percentage-max-value' | translate }}
-            </mat-error>
-          </mat-form-field>
-          <mat-form-field class="mat-block">
-            <mat-label translate>queue.pause-between-retries</mat-label>
-            <input type="number" matInput formControlName="pauseBetweenRetries" required>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.pauseBetweenRetries').hasError('required')">
-              {{ 'queue.pause-between-retries-required' | translate }}
-            </mat-error>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.pauseBetweenRetries').hasError('min') &&
+                {{ 'queue.failure-percentage-max-value' | translate }}
+              </mat-error>
+            </mat-form-field>
+            <mat-form-field class="mat-block">
+              <mat-label translate>queue.pause-between-retries</mat-label>
+              <input type="number" matInput formControlName="pauseBetweenRetries" required>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.pauseBetweenRetries').hasError('required')">
+                {{ 'queue.pause-between-retries-required' | translate }}
+              </mat-error>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.pauseBetweenRetries').hasError('min') &&
                  !queueFormGroup.get('processingStrategy.pauseBetweenRetries').hasError('required')">
-              {{ 'queue.pause-between-retries-min-value' | translate }}
-            </mat-error>
-          </mat-form-field>
-          <mat-form-field class="mat-block">
-            <mat-label translate>queue.max-pause-between-retries</mat-label>
-            <input type="number" matInput formControlName="maxPauseBetweenRetries" required>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.maxPauseBetweenRetries').hasError('required')">
-              {{ 'queue.max-pause-between-retries-required' | translate }}
-            </mat-error>
-            <mat-error *ngIf="queueFormGroup.get('processingStrategy.maxPauseBetweenRetries').hasError('min') &&
+                {{ 'queue.pause-between-retries-min-value' | translate }}
+              </mat-error>
+            </mat-form-field>
+            <mat-form-field class="mat-block">
+              <mat-label translate>queue.max-pause-between-retries</mat-label>
+              <input type="number" matInput formControlName="maxPauseBetweenRetries" required>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.maxPauseBetweenRetries').hasError('required')">
+                {{ 'queue.max-pause-between-retries-required' | translate }}
+              </mat-error>
+              <mat-error *ngIf="queueFormGroup.get('processingStrategy.maxPauseBetweenRetries').hasError('min') &&
                  !queueFormGroup.get('processingStrategy.maxPauseBetweenRetries').hasError('required')">
-              {{ 'queue.max-pause-between-retries-min-value' | translate }}
-            </mat-error>
-          </mat-form-field>
+                {{ 'queue.max-pause-between-retries-min-value' | translate }}
+              </mat-error>
+            </mat-form-field>
+          </div>
+        </div>
+      </ng-template>
+    </mat-expansion-panel>
+    <mat-expansion-panel [expanded]="true">
+      <mat-expansion-panel-header>
+        <mat-panel-title class="panel-title" translate>
+          queue.polling-settings
+        </mat-panel-title>
+      </mat-expansion-panel-header>
+      <ng-template matExpansionPanelContent>
+        <div fxFlex fxLayout="column" fxLayoutGap="10px" style="padding-bottom: 15px;">
+          <div fxFlex>
+            <label class="group-label" translate>queue.batch-processing</label>
+            <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap="10px">
+              <mat-form-field fxFlex class="mat-block">
+                <mat-label translate>queue.poll-interval</mat-label>
+                <input type="number" matInput formControlName="pollInterval" required>
+                <mat-error *ngIf="queueFormGroup.get('pollInterval').hasError('required')">
+                  {{ 'queue.poll-interval-required' | translate }}
+                </mat-error>
+                <mat-error *ngIf="queueFormGroup.get('pollInterval').hasError('min') &&
+                 !queueFormGroup.get('pollInterval').hasError('required')">
+                  {{ 'queue.poll-interval-min-value' | translate }}
+                </mat-error>
+              </mat-form-field>
+              <mat-form-field fxFlex class="mat-block">
+                <mat-label translate>queue.partitions</mat-label>
+                <input type="number" matInput formControlName="partitions" required>
+                <mat-error *ngIf="queueFormGroup.get('partitions').hasError('required')">
+                  {{ 'queue.partitions-required' | translate }}
+                </mat-error>
+                <mat-error *ngIf="queueFormGroup.get('partitions').hasError('min') &&
+                 !queueFormGroup.get('partitions').hasError('required')">
+                  {{ 'queue.partitions-min-value' | translate }}
+                </mat-error>
+              </mat-form-field>
+            </div>
+          </div>
+          <div fxFlex>
+            <label class="group-label" translate>queue.immediate-processing</label>
+            <div fxFlex fxLayout="row" fxLayout.xs="column" fxLayoutGap="10px">
+              <mat-checkbox fxFlex fxFlexAlign.gt-xs="center" formControlName="consumerPerPartition">
+                {{ 'queue.consumer-per-partition' | translate }}
+              </mat-checkbox>
+              <mat-form-field fxFlex class="mat-block">
+                <mat-label translate>queue.processing-timeout</mat-label>
+                <input type="number" matInput formControlName="packProcessingTimeout" required>
+                <mat-error *ngIf="queueFormGroup.get('packProcessingTimeout').hasError('required')">
+                  {{ 'queue.pack-processing-timeout-required' | translate }}
+                </mat-error>
+                <mat-error *ngIf="queueFormGroup.get('packProcessingTimeout').hasError('min') &&
+                 !queueFormGroup.get('packProcessingTimeout').hasError('required')">
+                  {{ 'queue.pack-processing-timeout-min-value' | translate }}
+                </mat-error>
+              </mat-form-field>
+            </div>
+          </div>
         </div>
       </ng-template>
     </mat-expansion-panel>
   </mat-accordion>
-  <mat-form-field class="mat-block" formGroupName="additionalInfo">
+  <mat-form-field class="mat-block" formGroupName="additionalInfo" appearance="fill">
     <mat-label translate>queue.description</mat-label>
     <textarea matInput formControlName="description" rows="2"></textarea>
     <mat-hint translate>queue.description-hint</mat-hint>

ui-ngx/src/app/modules/home/components/queue/queue-form.component.scss

@@ -13,16 +13,38 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-:host ::ng-deep {
+:host {
   .queue-strategy {
     padding-bottom: 16px;
 
-    .mat-expansion-panel-header {
-      height: 50px;
+    .group-label {
+      display: block;
+      padding-bottom: 10px;
     }
 
-    .mat-expansion-panel-body {
-      padding-bottom: 0 !important;
+    .panel-title {
+      font-weight: 500;
+    }
+
+    .hint-icon {
+      width: 15px;
+      height: 15px;
+      vertical-align: top;
+    }
+  }
+
+  ::ng-deep {
+    .mat-form-field-infix {
+      width: 100% !important;
+    }
+    .queue-strategy {
+      .mat-expansion-panel-header {
+        height: 50px;
+      }
+
+      .mat-expansion-panel-body {
+        padding-bottom: 0 !important;
+      }
     }
   }
 }

ui-ngx/src/assets/locale/locale.constant-en_US.json

@@ -2959,18 +2959,25 @@
         "add" : "Add queue",
         "details": "Queue details",
         "topic": "Topic",
-        "submit-strategy": "Submit Strategy",
-        "processing-strategy": "Processing Strategy",
+        "submit-settings": "Submit settings",
+        "submit-strategy": "Strategy type *",
+        "grouping-parameter": "Grouping parameter",
+        "processing-settings": "Retries processing settings",
+        "processing-strategy": "Processing type *",
+        "retries-settings": "Retries settings",
+        "polling-settings": "Polling settings",
+        "batch-processing": "Batch processing",
         "poll-interval": "Poll interval",
         "partitions": "Partitions",
-        "consumer-per-partition": "Consumer per partition",
+        "immediate-processing": "Immediate processing",
+        "consumer-per-partition": "Send message poll for each consumer",
         "consumer-per-partition-hint": "Enable separate consumer(s) per each partition",
-        "processing-timeout": "Processing timeout, ms",
+        "processing-timeout": "Processing within, ms",
         "batch-size": "Batch size",
-        "retries": "Retries (0 - unlimited)",
-        "failure-percentage": "Failure Percentage",
-        "pause-between-retries": "Pause between retries",
-        "max-pause-between-retries": "Maximal pause between retries",
+        "retries": "Number of retries (0 – unlimited)",
+        "failure-percentage": "Percentage of failure messages for skipping retries",
+        "pause-between-retries": "Retry within, sec",
+        "max-pause-between-retries": "Additional retry within, sec",
         "delete": "Delete queue",
         "copyId": "Copy queue Id",
         "idCopiedMessage": "Queue Id has been copied to clipboard",
@@ -3085,93 +3092,101 @@
         "export-failed-error": "Unable to export tenant profile: {{error}}",
         "tenant-profile-file": "Tenant profile file",
         "invalid-tenant-profile-file-error": "Unable to import tenant profile: Invalid tenant profile data structure.",
-        "maximum-devices": "Maximum number of devices (0 - unlimited)",
-        "maximum-devices-required": "Maximum number of devices is required.",
-        "maximum-devices-range": "Minimum number of devices can't be negative",
-        "maximum-assets": "Maximum number of assets (0 - unlimited)",
-        "maximum-assets-required": "Maximum number of assets is required.",
-        "maximum-assets-range": "Maximum number of assets can't be negative",
-        "maximum-customers": "Maximum number of customers (0 - unlimited)",
-        "maximum-customers-required": "Maximum number of customers is required.",
-        "maximum-customers-range": "Maximum number of customers can't be negative",
-        "maximum-users": "Maximum number of users (0 - unlimited)",
-        "maximum-users-required": "Maximum number of users is required.",
-        "maximum-users-range": "Maximum number of users can't be negative",
-        "maximum-dashboards": "Maximum number of dashboards (0 - unlimited)",
-        "maximum-dashboards-required": "Maximum number of dashboards is required.",
-        "maximum-dashboards-range": "Maximum number of dashboards can't be negative",
-        "maximum-rule-chains": "Maximum number of rule chains (0 - unlimited)",
-        "maximum-rule-chains-required": "Maximum number of rule chains is required.",
-        "maximum-rule-chains-range": "Maximum number of rule chains can't be negative",
-        "maximum-resources-sum-data-size": "Maximum sum of resource files size in bytes (0 - unlimited)",
-        "maximum-resources-sum-data-size-required": "Maximum sum of resource files size is required.",
-        "maximum-resources-sum-data-size-range": "Maximum sum of resource files size can`t be negative",
-        "maximum-ota-packages-sum-data-size": "Maximum sum of ota package files size in bytes (0 - unlimited)",
-        "maximum-ota-package-sum-data-size-required": "Maximum sum of ota package files size is required.",
-        "maximum-ota-package-sum-data-size-range": "Maximum sum of ota package files size can`t be negative",
-        "transport-tenant-msg-rate-limit": "Transport tenant messages rate limit.",
-        "transport-tenant-telemetry-msg-rate-limit": "Transport tenant telemetry messages rate limit.",
-        "transport-tenant-telemetry-data-points-rate-limit": "Transport tenant telemetry data points rate limit.",
-        "transport-device-msg-rate-limit": "Transport device messages rate limit.",
-        "transport-device-telemetry-msg-rate-limit": "Transport device telemetry messages rate limit.",
-        "transport-device-telemetry-data-points-rate-limit": "Transport device telemetry data points rate limit.",
-        "tenant-entity-export-rate-limit": "Entity version creation rate limit",
-        "tenant-entity-import-rate-limit": "Entity version load rate limit",
-        "max-transport-messages": "Maximum number of transport messages (0 - unlimited)",
-        "max-transport-messages-required": "Maximum number of transport messages is required.",
-        "max-transport-messages-range": "Maximum number of transport messages can't be negative",
-        "max-transport-data-points": "Maximum number of transport data points (0 - unlimited)",
-        "max-transport-data-points-required": "Maximum number of transport data points is required.",
-        "max-transport-data-points-range": "Maximum number of transport data points can't be negative",
-        "max-r-e-executions": "Maximum number of Rule Engine executions (0 - unlimited)",
-        "max-r-e-executions-required": "Maximum number of Rule Engine executions is required.",
-        "max-r-e-executions-range": "Maximum number of Rule Engine executions can't be negative",
-        "max-j-s-executions": "Maximum number of JavaScript executions (0 - unlimited)",
-        "max-j-s-executions-required": "Maximum number of JavaScript executions is required.",
-        "max-j-s-executions-range": "Maximum number of JavaScript executions can't be negative",
-        "max-d-p-storage-days": "Maximum number of data points storage days (0 - unlimited)",
-        "max-d-p-storage-days-required": "Maximum number of data points storage days is required.",
-        "max-d-p-storage-days-range": "Maximum number of data points storage days can't be negative",
-        "default-storage-ttl-days": "Default storage TTL days (0 - unlimited)",
-        "default-storage-ttl-days-required": "Default storage TTL days is required.",
-        "default-storage-ttl-days-range": "Default storage TTL days can't be negative",
-        "alarms-ttl-days": "Alarms TTL days (0 - unlimited)",
+        "advanced-settings": "Advanced settings",
+        "entities": "Entities",
+        "rule-engine": "Rule Engine",
+        "time-to-live": "Time-to-live",
+        "alarms-and-notifications": "Alarms and notifications",
+        "ota-files-in-bytes": "OTA files in bytes",
+        "ws-title": "WS",
+        "unlimited": "(0 - unlimited)",
+        "maximum-devices": "Devices maximum number",
+        "maximum-devices-required": "Devices maximum number is required.",
+        "maximum-devices-range": "Devices maximum number can't be negative",
+        "maximum-assets": "Assets maximum number",
+        "maximum-assets-required": "Assets maximum number is required.",
+        "maximum-assets-range": "Assets maximum number can't be negative",
+        "maximum-customers": "Customers maximum number",
+        "maximum-customers-required": "Customers maximum number is required.",
+        "maximum-customers-range": "Customers maximum number can't be negative",
+        "maximum-users": "Users maximum number",
+        "maximum-users-required": "Users maximum number is required.",
+        "maximum-users-range": "Users maximum number can't be negative",
+        "maximum-dashboards": "Dashboards maximum number",
+        "maximum-dashboards-required": "Dashboards maximum number is required.",
+        "maximum-dashboards-range": "Dashboards maximum number can't be negative",
+        "maximum-rule-chains": "Rule chains maximum number",
+        "maximum-rule-chains-required": "Rule chains maximum number is required.",
+        "maximum-rule-chains-range": "Rule chains maximum number can't be negative",
+        "maximum-resources-sum-data-size": "Resource files sum size",
+        "maximum-resources-sum-data-size-required": "Resource files sum size is required.",
+        "maximum-resources-sum-data-size-range": "Resource files sum size can`t be negative",
+        "maximum-ota-packages-sum-data-size": "OTA package files sum size",
+        "maximum-ota-package-sum-data-size-required": "OTA package files sum size is required.",
+        "maximum-ota-package-sum-data-size-range": "OTA package files sum size can`t be negative",
+        "transport-tenant-msg-rate-limit": "Transport tenant messages",
+        "transport-tenant-telemetry-msg-rate-limit": "Transport tenant telemetry messages",
+        "transport-tenant-telemetry-data-points-rate-limit": "Transport tenant telemetry data points",
+        "transport-device-msg-rate-limit": "Transport device messages",
+        "transport-device-telemetry-msg-rate-limit": "Transport device telemetry messages",
+        "transport-device-telemetry-data-points-rate-limit": "Transport device telemetry data points",
+        "tenant-entity-export-rate-limit": "Entity version creation",
+        "tenant-entity-import-rate-limit": "Entity version load",
+        "max-transport-messages": "Transport messages maximum number",
+        "max-transport-messages-required": "Transport messages maximum number is required.",
+        "max-transport-messages-range": "Transport messages maximum number can't be negative",
+        "max-transport-data-points": "Transport data points maximum number ",
+        "max-transport-data-points-required": "Transport data points maximum number  is required.",
+        "max-transport-data-points-range": "Transport data points maximum number  can't be negative",
+        "max-r-e-executions": "Rule Engine executions maximum number",
+        "max-r-e-executions-required": "Rule Engine executions maximum number is required.",
+        "max-r-e-executions-range": "Rule Engine executions maximum number can't be negative",
+        "max-j-s-executions": "JavaScript executions maximum number ",
+        "max-j-s-executions-required": "JavaScript executions maximum number  is required.",
+        "max-j-s-executions-range": "JavaScript executions maximum number  can't be negative",
+        "max-d-p-storage-days": "Data points storage days maximum number",
+        "max-d-p-storage-days-required": "Data points storage days maximum number is required.",
+        "max-d-p-storage-days-range": "Data points storage days maximum number can't be negative",
+        "default-storage-ttl-days": "Storage TTL days by default",
+        "default-storage-ttl-days-required": "Storage TTL days by default is required.",
+        "default-storage-ttl-days-range": "Storage TTL days by default can't be negative",
+        "alarms-ttl-days": "Alarms TTL days",
         "alarms-ttl-days-required": "Alarms TTL days required",
         "alarms-ttl-days-days-range": "Alarms TTL days can't be negative",
-        "rpc-ttl-days": "RPC TTL days (0 - unlimited)",
+        "rpc-ttl-days": "RPC TTL days",
         "rpc-ttl-days-required": "RPC TTL days required",
         "rpc-ttl-days-days-range": "RPC TTL days can't be negative",
-        "max-rule-node-executions-per-message": "Maximum number of rule node executions per message (0 - unlimited)",
-        "max-rule-node-executions-per-message-required": "Maximum number of rule node executions per message is required.",
-        "max-rule-node-executions-per-message-range": "Maximum number of rule node executions per message can't be negative",
-        "max-emails": "Maximum number of emails sent (0 - unlimited)",
-        "max-emails-required": "Maximum number of emails sent is required.",
-        "max-emails-range": "Maximum number of emails sent can't be negative",
-        "max-sms": "Maximum number of SMS sent (0 - unlimited)",
-        "max-sms-required": "Maximum number of SMS sent is required.",
-        "max-sms-range": "Maximum number of SMS sent can't be negative",
-        "max-created-alarms": "Maximum number of alarms created (0 - unlimited)",
-        "max-created-alarms-required": "Maximum number of alarms created is required.",
-        "max-created-alarms-range": "Maximum number of alarms created can't be negative",
+        "max-rule-node-executions-per-message": "Rule node per message executions maximum number",
+        "max-rule-node-executions-per-message-required": "MRule node per message executions maximum number is required.",
+        "max-rule-node-executions-per-message-range": "Rule node per message executions maximum number can't be negative",
+        "max-emails": "Emails sent maximum number",
+        "max-emails-required": "Emails sent maximum number is required.",
+        "max-emails-range": "Emails sent maximum number can't be negative",
+        "max-sms": "SMS sent maximum number",
+        "max-sms-required": "SMS sent maximum number is required.",
+        "max-sms-range": "SMS sent maximum number can't be negative",
+        "max-created-alarms": "Alarms created maximum number",
+        "max-created-alarms-required": "Alarms created maximum number is required.",
+        "max-created-alarms-range": "Alarms created maximum number be negative",
         "no-queue": "No Queue configured",
         "add-queue": "Add Queue",
         "queues-with-count": "Queues ({{count}})",
-        "tenant-rest-limits": "Rate limit for REST requests for tenant",
-        "customer-rest-limits": "Rate limit for REST requests for customer",
+        "tenant-rest-limits": "REST requests for tenant",
+        "customer-rest-limits": "REST requests for customer",
         "incorrect-pattern-for-rate-limits": "The format is comma separated pairs of capacity and period (in seconds) with a colon between, e.g. 100:1,2000:60",
         "too-small-value-zero": "The value must be bigger than 0",
         "too-small-value-one": "The value must be bigger than 1",
-        "cassandra-tenant-limits-configuration": "Cassandra query rate limit for tenant",
-        "ws-limit-max-sessions-per-tenant": "Maximum number of WS sessions per tenant",
-        "ws-limit-max-sessions-per-customer": "Maximum number of WS sessions per customer",
-        "ws-limit-max-sessions-per-regular-user": "Maximum number of WS sessions per regular user",
-        "ws-limit-max-sessions-per-public-user": "Maximum number of WS sessions per public user",
-        "ws-limit-queue-per-session": "Maximum size of WS message queue per session",
-        "ws-limit-max-subscriptions-per-tenant": "Maximum number of WS subscriptions per tenant",
-        "ws-limit-max-subscriptions-per-customer": "Maximum number of WS subscriptions per customer",
-        "ws-limit-max-subscriptions-per-regular-user": "Maximum number of WS subscriptions per regular user",
-        "ws-limit-max-subscriptions-per-public-user": "Maximum number of WS subscriptions per public user",
-        "ws-limit-updates-per-session": "Rate limit for WS updates per session"
+        "cassandra-tenant-limits-configuration": "Cassandra query for tenant",
+        "ws-limit-max-sessions-per-tenant": "Sessions per tenant maximum number",
+        "ws-limit-max-sessions-per-customer": "Sessions per customer maximum number",
+        "ws-limit-max-sessions-per-regular-user": "Sessions per regular user maximum number",
+        "ws-limit-max-sessions-per-public-user": "Sessions per public user maximum number",
+        "ws-limit-queue-per-session": "Message queue per session maximum size",
+        "ws-limit-max-subscriptions-per-tenant": "Subscriptions per tenant maximum number",
+        "ws-limit-max-subscriptions-per-customer": "Subscriptions per customer maximum number",
+        "ws-limit-max-subscriptions-per-regular-user": "Subscriptions per regular user maximum number",
+        "ws-limit-max-subscriptions-per-public-user": "Subscriptions per public user maximum number",
+        "ws-limit-updates-per-session": "WS updates per session"
     },
     "timeinterval": {
         "seconds-interval": "{ seconds, plural, 1 {1 second} other {# seconds} }",