Examples with Lwm2mDeviceProfileTransportConfiguration org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration used on opensource projects

Example 26 with Lwm2mDeviceProfileTransportConfiguration

use of org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration in project thingsboard by thingsboard.

the class LwM2mClientContextImpl method doGetAndCache.

private Lwm2mDeviceProfileTransportConfiguration doGetAndCache(UUID profileId) {
    Lwm2mDeviceProfileTransportConfiguration result = profiles.get(profileId);
    if (result == null) {
        log.debug("Fetching profile [{}]", profileId);
        DeviceProfile deviceProfile = deviceProfileCache.get(new DeviceProfileId(profileId));
        if (deviceProfile != null) {
            result = profileUpdate(deviceProfile);
        } else {
            log.warn("Device profile was not found! Most probably device profile [{}] has been removed from the database.", profileId);
        }
    }
    return result;
}

Example 27 with Lwm2mDeviceProfileTransportConfiguration

use of org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration in project thingsboard by thingsboard.

the class LwM2mClientContextImpl method profileUpdate.

@Override
public Lwm2mDeviceProfileTransportConfiguration profileUpdate(DeviceProfile deviceProfile) {
    Lwm2mDeviceProfileTransportConfiguration clientProfile = LwM2MTransportUtil.toLwM2MClientProfile(deviceProfile);
    profiles.put(deviceProfile.getUuidId(), clientProfile);
    return clientProfile;
}

Example 28 with Lwm2mDeviceProfileTransportConfiguration

use of org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration in project thingsboard by thingsboard.

the class DefaultLwM2mUplinkMsgHandler method onDeviceProfileUpdate.

// TODO: review and optimize the logic to minimize number of the requests to device.
private void onDeviceProfileUpdate(List<LwM2mClient> clients, Lwm2mDeviceProfileTransportConfiguration oldProfile, DeviceProfile deviceProfile) {
    if (clientContext.profileUpdate(deviceProfile) != null) {
        TelemetryMappingConfiguration oldTelemetryParams = oldProfile.getObserveAttr();
        Set<String> attributeSetOld = oldTelemetryParams.getAttribute();
        Set<String> telemetrySetOld = oldTelemetryParams.getTelemetry();
        Set<String> observeOld = oldTelemetryParams.getObserve();
        Map<String, String> keyNameOld = oldTelemetryParams.getKeyName();
        Map<String, ObjectAttributes> attributeLwm2mOld = oldTelemetryParams.getAttributeLwm2m();
        var newProfile = clientContext.getProfile(deviceProfile.getUuidId());
        TelemetryMappingConfiguration newTelemetryParams = newProfile.getObserveAttr();
        Set<String> attributeSetNew = newTelemetryParams.getAttribute();
        Set<String> telemetrySetNew = newTelemetryParams.getTelemetry();
        Set<String> observeNew = newTelemetryParams.getObserve();
        Map<String, String> keyNameNew = newTelemetryParams.getKeyName();
        Map<String, ObjectAttributes> attributeLwm2mNew = newTelemetryParams.getAttributeLwm2m();
        Set<String> observeToAdd = diffSets(observeOld, observeNew);
        Set<String> observeToRemove = diffSets(observeNew, observeOld);
        Set<String> newObjectsToRead = new HashSet<>();
        Set<String> newObjectsToCancelRead = new HashSet<>();
        if (!attributeSetOld.equals(attributeSetNew)) {
            newObjectsToRead.addAll(diffSets(attributeSetOld, attributeSetNew));
            newObjectsToCancelRead.addAll(diffSets(attributeSetNew, attributeSetOld));
        }
        if (!telemetrySetOld.equals(telemetrySetNew)) {
            newObjectsToRead.addAll(diffSets(telemetrySetOld, telemetrySetNew));
            newObjectsToCancelRead.addAll(diffSets(telemetrySetNew, telemetrySetOld));
        }
        if (!keyNameOld.equals(keyNameNew)) {
            ParametersAnalyzeResult keyNameChange = this.getAnalyzerKeyName(keyNameOld, keyNameNew);
            newObjectsToRead.addAll(keyNameChange.getPathPostParametersAdd());
        }
        ParametersAnalyzeResult analyzerParameters = getAttributesAnalyzer(attributeLwm2mOld, attributeLwm2mNew);
        clients.forEach(client -> {
            LwM2MModelConfig modelConfig = new LwM2MModelConfig(client.getEndpoint());
            modelConfig.getToRead().addAll(diffSets(observeToAdd, newObjectsToRead));
            modelConfig.getToCancelRead().addAll(newObjectsToCancelRead);
            modelConfig.getToCancelObserve().addAll(observeToRemove);
            modelConfig.getToObserve().addAll(observeToAdd);
            Set<String> clientObjects = clientContext.getSupportedIdVerInClient(client);
            Set<String> pathToAdd = analyzerParameters.getPathPostParametersAdd().stream().filter(target -> clientObjects.contains("/" + target.split(LWM2M_SEPARATOR_PATH)[1])).collect(Collectors.toUnmodifiableSet());
            modelConfig.getAttributesToAdd().putAll(pathToAdd.stream().collect(Collectors.toMap(t -> t, attributeLwm2mNew::get)));
            Set<String> pathToRemove = analyzerParameters.getPathPostParametersDel().stream().filter(target -> clientObjects.contains("/" + target.split(LWM2M_SEPARATOR_PATH)[1])).collect(Collectors.toUnmodifiableSet());
            modelConfig.getAttributesToRemove().addAll(pathToRemove);
            modelConfigService.sendUpdates(client, modelConfig);
        });
        // update value in fwInfo
        OtherConfiguration newLwM2mSettings = newProfile.getClientLwM2mSettings();
        OtherConfiguration oldLwM2mSettings = oldProfile.getClientLwM2mSettings();
        if (!newLwM2mSettings.getFwUpdateStrategy().equals(oldLwM2mSettings.getFwUpdateStrategy()) || (StringUtils.isNotEmpty(newLwM2mSettings.getFwUpdateResource()) && !newLwM2mSettings.getFwUpdateResource().equals(oldLwM2mSettings.getFwUpdateResource()))) {
            clients.forEach(lwM2MClient -> otaService.onFirmwareStrategyUpdate(lwM2MClient, newLwM2mSettings));
        }
        if (!newLwM2mSettings.getSwUpdateStrategy().equals(oldLwM2mSettings.getSwUpdateStrategy()) || (StringUtils.isNotEmpty(newLwM2mSettings.getSwUpdateResource()) && !newLwM2mSettings.getSwUpdateResource().equals(oldLwM2mSettings.getSwUpdateResource()))) {
            clients.forEach(lwM2MClient -> otaService.onCurrentSoftwareStrategyUpdate(lwM2MClient, newLwM2mSettings));
        }
    }
}

Example 29 with Lwm2mDeviceProfileTransportConfiguration

use of org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration in project thingsboard by thingsboard.

the class LwM2MBootstrapSecurityStore method addValueToStore.

public SecurityInfo addValueToStore(TbLwM2MSecurityInfo store, String endpoint) {
    /* add value to store  from BootstrapJson */
    SecurityInfo securityInfo = null;
    if (store != null && store.getBootstrapCredentialConfig() != null && store.getSecurityMode() != null) {
        securityInfo = store.getSecurityInfo();
        this.setBootstrapConfigSecurityInfo(store);
        BootstrapConfig bsConfigNew = store.getBootstrapConfig();
        if (bsConfigNew != null) {
            try {
                boolean bootstrapServerUpdateEnable = ((Lwm2mDeviceProfileTransportConfiguration) store.getDeviceProfile().getProfileData().getTransportConfiguration()).isBootstrapServerUpdateEnable();
                if (!bootstrapServerUpdateEnable) {
                    Optional<Map.Entry<Integer, BootstrapConfig.ServerSecurity>> securities = bsConfigNew.security.entrySet().stream().filter(sec -> sec.getValue().bootstrapServer).findAny();
                    if (securities.isPresent()) {
                        bsConfigNew.security.entrySet().remove(securities.get());
                        int serverSortId = securities.get().getValue().serverId;
                        Optional<Map.Entry<Integer, BootstrapConfig.ServerConfig>> serverConfigs = bsConfigNew.servers.entrySet().stream().filter(serv -> (serv.getValue()).shortId == serverSortId).findAny();
                        if (serverConfigs.isPresent()) {
                            bsConfigNew.servers.entrySet().remove(serverConfigs.get());
                        }
                    }
                }
                for (String config : bootstrapConfigStore.getAll().keySet()) {
                    if (config.equals(endpoint)) {
                        bootstrapConfigStore.remove(config);
                    }
                }
                bootstrapConfigStore.add(endpoint, bsConfigNew);
            } catch (InvalidConfigurationException e) {
                if (e.getMessage().contains("Psk identity") && e.getMessage().contains("already used for this bootstrap server")) {
                    log.trace("Invalid Bootstrap Configuration", e);
                } else {
                    log.error("Invalid Bootstrap Configuration", e);
                }
            }
        }
    }
    return securityInfo;
}

Example 30 with Lwm2mDeviceProfileTransportConfiguration

use of org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration in project thingsboard by thingsboard.

the class DeviceProfileDataValidator method validateDataImpl.

@Override
protected void validateDataImpl(TenantId tenantId, DeviceProfile deviceProfile) {
    if (org.thingsboard.server.common.data.StringUtils.isEmpty(deviceProfile.getName())) {
        throw new DataValidationException("Device profile name should be specified!");
    }
    if (deviceProfile.getType() == null) {
        throw new DataValidationException("Device profile type should be specified!");
    }
    if (deviceProfile.getTransportType() == null) {
        throw new DataValidationException("Device profile transport type should be specified!");
    }
    if (deviceProfile.getTenantId() == null) {
        throw new DataValidationException("Device profile should be assigned to tenant!");
    } else {
        Tenant tenant = tenantDao.findById(deviceProfile.getTenantId(), deviceProfile.getTenantId().getId());
        if (tenant == null) {
            throw new DataValidationException("Device profile is referencing to non-existent tenant!");
        }
    }
    if (deviceProfile.isDefault()) {
        DeviceProfile defaultDeviceProfile = deviceProfileService.findDefaultDeviceProfile(tenantId);
        if (defaultDeviceProfile != null && !defaultDeviceProfile.getId().equals(deviceProfile.getId())) {
            throw new DataValidationException("Another default device profile is present in scope of current tenant!");
        }
    }
    if (!org.thingsboard.server.common.data.StringUtils.isEmpty(deviceProfile.getDefaultQueueName()) && queueService != null) {
        if (!queueService.getQueuesByServiceType(ServiceType.TB_RULE_ENGINE).contains(deviceProfile.getDefaultQueueName())) {
            throw new DataValidationException("Device profile is referencing to non-existent queue!");
        }
    }
    if (deviceProfile.getProvisionType() == null) {
        deviceProfile.setProvisionType(DeviceProfileProvisionType.DISABLED);
    }
    DeviceProfileTransportConfiguration transportConfiguration = deviceProfile.getProfileData().getTransportConfiguration();
    transportConfiguration.validate();
    if (transportConfiguration instanceof MqttDeviceProfileTransportConfiguration) {
        MqttDeviceProfileTransportConfiguration mqttTransportConfiguration = (MqttDeviceProfileTransportConfiguration) transportConfiguration;
        if (mqttTransportConfiguration.getTransportPayloadTypeConfiguration() instanceof ProtoTransportPayloadConfiguration) {
            ProtoTransportPayloadConfiguration protoTransportPayloadConfiguration = (ProtoTransportPayloadConfiguration) mqttTransportConfiguration.getTransportPayloadTypeConfiguration();
            validateProtoSchemas(protoTransportPayloadConfiguration);
            validateTelemetryDynamicMessageFields(protoTransportPayloadConfiguration);
            validateRpcRequestDynamicMessageFields(protoTransportPayloadConfiguration);
        }
    } else if (transportConfiguration instanceof CoapDeviceProfileTransportConfiguration) {
        CoapDeviceProfileTransportConfiguration coapDeviceProfileTransportConfiguration = (CoapDeviceProfileTransportConfiguration) transportConfiguration;
        CoapDeviceTypeConfiguration coapDeviceTypeConfiguration = coapDeviceProfileTransportConfiguration.getCoapDeviceTypeConfiguration();
        if (coapDeviceTypeConfiguration instanceof DefaultCoapDeviceTypeConfiguration) {
            DefaultCoapDeviceTypeConfiguration defaultCoapDeviceTypeConfiguration = (DefaultCoapDeviceTypeConfiguration) coapDeviceTypeConfiguration;
            TransportPayloadTypeConfiguration transportPayloadTypeConfiguration = defaultCoapDeviceTypeConfiguration.getTransportPayloadTypeConfiguration();
            if (transportPayloadTypeConfiguration instanceof ProtoTransportPayloadConfiguration) {
                ProtoTransportPayloadConfiguration protoTransportPayloadConfiguration = (ProtoTransportPayloadConfiguration) transportPayloadTypeConfiguration;
                validateProtoSchemas(protoTransportPayloadConfiguration);
                validateTelemetryDynamicMessageFields(protoTransportPayloadConfiguration);
                validateRpcRequestDynamicMessageFields(protoTransportPayloadConfiguration);
            }
        }
    } else if (transportConfiguration instanceof Lwm2mDeviceProfileTransportConfiguration) {
        List<LwM2MBootstrapServerCredential> lwM2MBootstrapServersConfigurations = ((Lwm2mDeviceProfileTransportConfiguration) transportConfiguration).getBootstrap();
        if (lwM2MBootstrapServersConfigurations != null) {
            validateLwm2mServersConfigOfBootstrapForClient(lwM2MBootstrapServersConfigurations, ((Lwm2mDeviceProfileTransportConfiguration) transportConfiguration).isBootstrapServerUpdateEnable());
            for (LwM2MBootstrapServerCredential bootstrapServerCredential : lwM2MBootstrapServersConfigurations) {
                validateLwm2mServersCredentialOfBootstrapForClient(bootstrapServerCredential);
            }
        }
    }
    List<DeviceProfileAlarm> profileAlarms = deviceProfile.getProfileData().getAlarms();
    if (!CollectionUtils.isEmpty(profileAlarms)) {
        Set<String> alarmTypes = new HashSet<>();
        for (DeviceProfileAlarm alarm : profileAlarms) {
            String alarmType = alarm.getAlarmType();
            if (StringUtils.isEmpty(alarmType)) {
                throw new DataValidationException("Alarm rule type should be specified!");
            }
            if (!alarmTypes.add(alarmType)) {
                throw new DataValidationException(String.format("Can't create device profile with the same alarm rule types: \"%s\"!", alarmType));
            }
        }
    }
    if (deviceProfile.getDefaultRuleChainId() != null) {
        RuleChain ruleChain = ruleChainService.findRuleChainById(tenantId, deviceProfile.getDefaultRuleChainId());
        if (ruleChain == null) {
            throw new DataValidationException("Can't assign non-existent rule chain!");
        }
    }
    if (deviceProfile.getDefaultDashboardId() != null) {
        DashboardInfo dashboard = dashboardService.findDashboardInfoById(tenantId, deviceProfile.getDefaultDashboardId());
        if (dashboard == null) {
            throw new DataValidationException("Can't assign non-existent dashboard!");
        }
    }
    if (deviceProfile.getFirmwareId() != null) {
        OtaPackage firmware = otaPackageService.findOtaPackageById(tenantId, deviceProfile.getFirmwareId());
        if (firmware == null) {
            throw new DataValidationException("Can't assign non-existent firmware!");
        }
        if (!firmware.getType().equals(OtaPackageType.FIRMWARE)) {
            throw new DataValidationException("Can't assign firmware with type: " + firmware.getType());
        }
        if (firmware.getData() == null && !firmware.hasUrl()) {
            throw new DataValidationException("Can't assign firmware with empty data!");
        }
        if (!firmware.getDeviceProfileId().equals(deviceProfile.getId())) {
            throw new DataValidationException("Can't assign firmware with different deviceProfile!");
        }
    }
    if (deviceProfile.getSoftwareId() != null) {
        OtaPackage software = otaPackageService.findOtaPackageById(tenantId, deviceProfile.getSoftwareId());
        if (software == null) {
            throw new DataValidationException("Can't assign non-existent software!");
        }
        if (!software.getType().equals(OtaPackageType.SOFTWARE)) {
            throw new DataValidationException("Can't assign software with type: " + software.getType());
        }
        if (software.getData() == null && !software.hasUrl()) {
            throw new DataValidationException("Can't assign software with empty data!");
        }
        if (!software.getDeviceProfileId().equals(deviceProfile.getId())) {
            throw new DataValidationException("Can't assign firmware with different deviceProfile!");
        }
    }
}