Andrew Shvayka
3 years ago
committed by
GitHub
GitHub
34 changed files with 2018 additions and 48 deletions
@ -0,0 +1,107 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.controller; |
|||
|
|||
import com.fasterxml.jackson.databind.JsonNode; |
|||
import io.swagger.annotations.ApiOperation; |
|||
import io.swagger.annotations.ApiParam; |
|||
import io.swagger.annotations.ApiResponse; |
|||
import io.swagger.annotations.ApiResponses; |
|||
import lombok.RequiredArgsConstructor; |
|||
import lombok.extern.slf4j.Slf4j; |
|||
import org.springframework.http.HttpHeaders; |
|||
import org.springframework.http.MediaType; |
|||
import org.springframework.http.ResponseEntity; |
|||
import org.springframework.security.access.prepost.PreAuthorize; |
|||
import org.springframework.web.bind.annotation.PathVariable; |
|||
import org.springframework.web.bind.annotation.RequestMapping; |
|||
import org.springframework.web.bind.annotation.RequestMethod; |
|||
import org.springframework.web.bind.annotation.ResponseBody; |
|||
import org.springframework.web.bind.annotation.RestController; |
|||
import org.thingsboard.server.common.data.Device; |
|||
import org.thingsboard.server.common.data.exception.ThingsboardException; |
|||
import org.thingsboard.server.common.data.id.DeviceId; |
|||
import org.thingsboard.server.dao.device.DeviceConnectivityService; |
|||
import org.thingsboard.server.queue.util.TbCoreComponent; |
|||
import org.thingsboard.server.service.security.permission.Operation; |
|||
import org.thingsboard.server.service.security.system.SystemSecurityService; |
|||
|
|||
import javax.servlet.http.HttpServletRequest; |
|||
import java.io.IOException; |
|||
import java.net.URISyntaxException; |
|||
|
|||
import static org.thingsboard.server.controller.ControllerConstants.DEVICE_ID; |
|||
import static org.thingsboard.server.controller.ControllerConstants.DEVICE_ID_PARAM_DESCRIPTION; |
|||
import static org.thingsboard.server.controller.ControllerConstants.PROTOCOL; |
|||
import static org.thingsboard.server.controller.ControllerConstants.PROTOCOL_PARAM_DESCRIPTION; |
|||
import static org.thingsboard.server.controller.ControllerConstants.TENANT_OR_CUSTOMER_AUTHORITY_PARAGRAPH; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.PEM_CERT_FILE_NAME; |
|||
|
|||
@RestController |
|||
@TbCoreComponent |
|||
@RequestMapping("/api") |
|||
@RequiredArgsConstructor |
|||
@Slf4j |
|||
public class DeviceConnectivityController extends BaseController { |
|||
|
|||
private final DeviceConnectivityService deviceConnectivityService; |
|||
private final SystemSecurityService systemSecurityService; |
|||
|
|||
@ApiOperation(value = "Get commands to publish device telemetry (getDevicePublishTelemetryCommands)", |
|||
notes = "Fetch the list of commands to publish device telemetry based on device profile " + |
|||
"If the user has the authority of 'Tenant Administrator', the server checks that the device is owned by the same tenant. " + |
|||
"If the user has the authority of 'Customer User', the server checks that the device is assigned to the same customer. " + |
|||
TENANT_OR_CUSTOMER_AUTHORITY_PARAGRAPH) |
|||
@ApiResponses(value = { |
|||
@ApiResponse(code = 200, message = "OK", |
|||
examples = @io.swagger.annotations.Example( |
|||
value = { |
|||
@io.swagger.annotations.ExampleProperty( |
|||
mediaType = "application/json", |
|||
value = "{\"http\":\"curl -v -X POST http://localhost:8080/api/v1/0ySs4FTOn5WU15XLmal8/telemetry --header Content-Type:application/json --data {temperature:25}\"," + |
|||
"\"mqtt\":\"mosquitto_pub -d -q 1 -h localhost -t v1/devices/me/telemetry -i myClient1 -u myUsername1 -P myPassword -m {temperature:25}\"," + |
|||
"\"coap\":\"coap-client -m POST coap://localhost:5683/api/v1/0ySs4FTOn5WU15XLmal8/telemetry -t json -e {temperature:25}\"}")}))}) |
|||
@PreAuthorize("hasAnyAuthority('TENANT_ADMIN', 'CUSTOMER_USER')") |
|||
@RequestMapping(value = "/device-connectivity/{deviceId}", method = RequestMethod.GET) |
|||
@ResponseBody |
|||
public JsonNode getDevicePublishTelemetryCommands(@ApiParam(value = DEVICE_ID_PARAM_DESCRIPTION) |
|||
@PathVariable(DEVICE_ID) String strDeviceId, HttpServletRequest request) throws ThingsboardException, URISyntaxException { |
|||
checkParameter(DEVICE_ID, strDeviceId); |
|||
DeviceId deviceId = new DeviceId(toUUID(strDeviceId)); |
|||
Device device = checkDeviceId(deviceId, Operation.READ_CREDENTIALS); |
|||
|
|||
String baseUrl = systemSecurityService.getBaseUrl(getTenantId(), getCurrentUser().getCustomerId(), request); |
|||
return deviceConnectivityService.findDevicePublishTelemetryCommands(baseUrl, device); |
|||
} |
|||
|
|||
@ApiOperation(value = "Download server certificate using file path defined in device.connectivity properties (downloadServerCertificate)", notes = "Download server certificate.") |
|||
@RequestMapping(value = "/device-connectivity/{protocol}/certificate/download", method = RequestMethod.GET) |
|||
@ResponseBody |
|||
public ResponseEntity<org.springframework.core.io.Resource> downloadServerCertificate(@ApiParam(value = PROTOCOL_PARAM_DESCRIPTION) |
|||
@PathVariable(PROTOCOL) String protocol) throws ThingsboardException, IOException { |
|||
checkParameter(PROTOCOL, protocol); |
|||
var pemCert = |
|||
checkNotNull(deviceConnectivityService.getPemCertFile(protocol), protocol + " pem cert file is not found!"); |
|||
|
|||
return ResponseEntity.ok() |
|||
.header(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + PEM_CERT_FILE_NAME) |
|||
.header("x-filename", PEM_CERT_FILE_NAME) |
|||
.contentLength(pemCert.contentLength()) |
|||
.contentType(MediaType.APPLICATION_OCTET_STREAM) |
|||
.body(pemCert); |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,340 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.controller; |
|||
|
|||
import com.fasterxml.jackson.core.type.TypeReference; |
|||
import com.fasterxml.jackson.databind.JsonNode; |
|||
import com.google.common.util.concurrent.ListeningExecutorService; |
|||
import com.google.common.util.concurrent.MoreExecutors; |
|||
import org.junit.After; |
|||
import org.junit.Assert; |
|||
import org.junit.Before; |
|||
import org.junit.Test; |
|||
import org.mockito.AdditionalAnswers; |
|||
import org.mockito.Mockito; |
|||
import org.springframework.context.annotation.Bean; |
|||
import org.springframework.context.annotation.Primary; |
|||
import org.springframework.test.context.ContextConfiguration; |
|||
import org.springframework.test.context.TestPropertySource; |
|||
import org.thingsboard.common.util.JacksonUtil; |
|||
import org.thingsboard.common.util.ThingsBoardExecutors; |
|||
import org.thingsboard.server.common.data.Device; |
|||
import org.thingsboard.server.common.data.DeviceProfile; |
|||
import org.thingsboard.server.common.data.DeviceProfileType; |
|||
import org.thingsboard.server.common.data.DeviceTransportType; |
|||
import org.thingsboard.server.common.data.Tenant; |
|||
import org.thingsboard.server.common.data.User; |
|||
import org.thingsboard.server.common.data.device.credentials.BasicMqttCredentials; |
|||
import org.thingsboard.server.common.data.device.profile.CoapDeviceProfileTransportConfiguration; |
|||
import org.thingsboard.server.common.data.device.profile.DefaultDeviceProfileConfiguration; |
|||
import org.thingsboard.server.common.data.device.profile.DeviceProfileData; |
|||
import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration; |
|||
import org.thingsboard.server.common.data.id.DeviceProfileId; |
|||
import org.thingsboard.server.common.data.page.PageData; |
|||
import org.thingsboard.server.common.data.security.Authority; |
|||
import org.thingsboard.server.common.data.security.DeviceCredentials; |
|||
import org.thingsboard.server.common.data.security.DeviceCredentialsType; |
|||
import org.thingsboard.server.dao.device.DeviceDao; |
|||
import org.thingsboard.server.dao.service.DaoSqlTest; |
|||
|
|||
import static org.assertj.core.api.Assertions.assertThat; |
|||
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.COAP; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.COAPS; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.DOCKER; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.HTTP; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.HTTPS; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.MQTT; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.MQTTS; |
|||
|
|||
@TestPropertySource(properties = { |
|||
"device.connectivity.https.enabled=true", |
|||
"device.connectivity.mqtts.enabled=true", |
|||
"device.connectivity.coaps.enabled=true", |
|||
}) |
|||
@ContextConfiguration(classes = {DeviceConnectivityControllerTest.Config.class}) |
|||
@DaoSqlTest |
|||
public class DeviceConnectivityControllerTest extends AbstractControllerTest { |
|||
static final TypeReference<PageData<Device>> PAGE_DATA_DEVICE_TYPE_REF = new TypeReference<>() { |
|||
}; |
|||
|
|||
private static final String DEVICE_TELEMETRY_TOPIC = "v1/devices/customTopic"; |
|||
private static final String CHECK_DOCUMENTATION = "Check documentation"; |
|||
|
|||
ListeningExecutorService executor; |
|||
|
|||
private Tenant savedTenant; |
|||
private User tenantAdmin; |
|||
private DeviceProfileId mqttDeviceProfileId; |
|||
private DeviceProfileId coapDeviceProfileId; |
|||
|
|||
static class Config { |
|||
@Bean |
|||
@Primary |
|||
public DeviceDao deviceDao(DeviceDao deviceDao) { |
|||
return Mockito.mock(DeviceDao.class, AdditionalAnswers.delegatesTo(deviceDao)); |
|||
} |
|||
} |
|||
|
|||
@Before |
|||
public void beforeTest() throws Exception { |
|||
executor = MoreExecutors.listeningDecorator(ThingsBoardExecutors.newWorkStealingPool(8, getClass())); |
|||
|
|||
loginSysAdmin(); |
|||
|
|||
Tenant tenant = new Tenant(); |
|||
tenant.setTitle("My tenant"); |
|||
savedTenant = doPost("/api/tenant", tenant, Tenant.class); |
|||
Assert.assertNotNull(savedTenant); |
|||
|
|||
tenantAdmin = new User(); |
|||
tenantAdmin.setAuthority(Authority.TENANT_ADMIN); |
|||
tenantAdmin.setTenantId(savedTenant.getId()); |
|||
tenantAdmin.setEmail("tenant2@thingsboard.org"); |
|||
tenantAdmin.setFirstName("Joe"); |
|||
tenantAdmin.setLastName("Downs"); |
|||
|
|||
tenantAdmin = createUserAndLogin(tenantAdmin, "testPassword1"); |
|||
|
|||
DeviceProfile mqttProfile = new DeviceProfile(); |
|||
mqttProfile.setName("Mqtt device profile"); |
|||
mqttProfile.setType(DeviceProfileType.DEFAULT); |
|||
mqttProfile.setTransportType(DeviceTransportType.MQTT); |
|||
DeviceProfileData deviceProfileData = new DeviceProfileData(); |
|||
deviceProfileData.setConfiguration(new DefaultDeviceProfileConfiguration()); |
|||
MqttDeviceProfileTransportConfiguration transportConfiguration = new MqttDeviceProfileTransportConfiguration(); |
|||
transportConfiguration.setDeviceTelemetryTopic(DEVICE_TELEMETRY_TOPIC); |
|||
deviceProfileData.setTransportConfiguration(transportConfiguration); |
|||
mqttProfile.setProfileData(deviceProfileData); |
|||
mqttProfile.setDefault(false); |
|||
mqttProfile.setDefaultRuleChainId(null); |
|||
|
|||
mqttDeviceProfileId = doPost("/api/deviceProfile", mqttProfile, DeviceProfile.class).getId(); |
|||
|
|||
DeviceProfile coapProfile = new DeviceProfile(); |
|||
coapProfile.setName("Coap device profile"); |
|||
coapProfile.setType(DeviceProfileType.DEFAULT); |
|||
coapProfile.setTransportType(DeviceTransportType.COAP); |
|||
DeviceProfileData deviceProfileData2 = new DeviceProfileData(); |
|||
deviceProfileData2.setConfiguration(new DefaultDeviceProfileConfiguration()); |
|||
deviceProfileData2.setTransportConfiguration(new CoapDeviceProfileTransportConfiguration()); |
|||
coapProfile.setProfileData(deviceProfileData); |
|||
coapProfile.setDefault(false); |
|||
coapProfile.setDefaultRuleChainId(null); |
|||
|
|||
coapDeviceProfileId = doPost("/api/deviceProfile", coapProfile, DeviceProfile.class).getId(); |
|||
} |
|||
|
|||
@After |
|||
public void afterTest() throws Exception { |
|||
executor.shutdownNow(); |
|||
|
|||
loginSysAdmin(); |
|||
|
|||
doDelete("/api/tenant/" + savedTenant.getId().getId()) |
|||
.andExpect(status().isOk()); |
|||
} |
|||
|
|||
@Test |
|||
public void testFetchPublishTelemetryCommandsForDefaultDevice() throws Exception { |
|||
Device device = new Device(); |
|||
device.setName("My device"); |
|||
device.setType("default"); |
|||
Device savedDevice = doPost("/api/device", device, Device.class); |
|||
JsonNode commands = |
|||
doGetTyped("/api/device-connectivity/" + savedDevice.getId().getId(), new TypeReference<>() { |
|||
}); |
|||
|
|||
DeviceCredentials credentials = |
|||
doGet("/api/device/" + savedDevice.getId().getId() + "/credentials", DeviceCredentials.class); |
|||
|
|||
assertThat(commands).hasSize(3); |
|||
JsonNode httpCommands = commands.get(HTTP); |
|||
assertThat(httpCommands.get(HTTP).asText()).isEqualTo(String.format("curl -v -X POST http://localhost:8080/api/v1/%s/telemetry " + |
|||
"--header Content-Type:application/json --data \"{temperature:25}\"", |
|||
credentials.getCredentialsId())); |
|||
assertThat(httpCommands.get(HTTPS).asText()).isEqualTo(String.format("curl -v -X POST https://localhost:443/api/v1/%s/telemetry " + |
|||
"--header Content-Type:application/json --data \"{temperature:25}\"", |
|||
credentials.getCredentialsId())); |
|||
|
|||
|
|||
JsonNode mqttCommands = commands.get(MQTT); |
|||
assertThat(mqttCommands.get(MQTT).asText()).isEqualTo(String.format("mosquitto_pub -d -q 1 -h localhost -p 1883 -t v1/devices/me/telemetry " + |
|||
"-u %s -m \"{temperature:25}\"", |
|||
credentials.getCredentialsId())); |
|||
assertThat(mqttCommands.get(MQTTS).get(0).asText()).isEqualTo("curl -f -S -o tb-server-chain.pem http://localhost:80/api/device-connectivity/mqtts/certificate/download"); |
|||
assertThat(mqttCommands.get(MQTTS).get(1).asText()).isEqualTo(String.format("mosquitto_pub -d -q 1 --cafile tb-server-chain.pem -h localhost -p 8883 " + |
|||
"-t v1/devices/me/telemetry -u %s -m \"{temperature:25}\"", credentials.getCredentialsId())); |
|||
|
|||
JsonNode dockerMqttCommands = commands.get(MQTT).get(DOCKER); |
|||
assertThat(dockerMqttCommands.get(MQTT).asText()).isEqualTo(String.format("docker run --rm -it thingsboard/mosquitto-clients mosquitto_pub -d -q 1 -h localhost" + |
|||
" -p 1883 -t v1/devices/me/telemetry -u %s -m \"{temperature:25}\"", |
|||
credentials.getCredentialsId())); |
|||
assertThat(dockerMqttCommands.get(MQTTS).asText()).isEqualTo(String.format("docker run --rm -it thingsboard/mosquitto-clients " + |
|||
"/bin/sh -c \"curl -f -S -o tb-server-chain.pem http://localhost:80/api/device-connectivity/mqtts/certificate/download && " + |
|||
"mosquitto_pub -d -q 1 --cafile tb-server-chain.pem -h localhost -p 8883 -t v1/devices/me/telemetry -u %s -m \"{temperature:25}\"\"", |
|||
credentials.getCredentialsId())); |
|||
|
|||
JsonNode linuxCoapCommands = commands.get(COAP); |
|||
assertThat(linuxCoapCommands.get(COAP).asText()).isEqualTo(String.format("coap-client -m POST coap://localhost:5683/api/v1/%s/telemetry " + |
|||
"-t json -e \"{temperature:25}\"", credentials.getCredentialsId())); |
|||
assertThat(linuxCoapCommands.get(COAPS).asText()).isEqualTo(String.format("coap-client-openssl -m POST coaps://localhost:5684/api/v1/%s/telemetry" + |
|||
" -t json -e \"{temperature:25}\"", credentials.getCredentialsId())); |
|||
} |
|||
|
|||
@Test |
|||
public void testFetchPublishTelemetryCommandsForMqttDeviceWithAccessToken() throws Exception { |
|||
Device device = new Device(); |
|||
device.setName("My device"); |
|||
device.setDeviceProfileId(mqttDeviceProfileId); |
|||
|
|||
Device savedDevice = doPost("/api/device", device, Device.class); |
|||
DeviceCredentials credentials = |
|||
doGet("/api/device/" + savedDevice.getId().getId() + "/credentials", DeviceCredentials.class); |
|||
|
|||
JsonNode commands = |
|||
doGetTyped("/api/device-connectivity/" + savedDevice.getId().getId(), new TypeReference<>() { |
|||
}); |
|||
assertThat(commands).hasSize(1); |
|||
|
|||
JsonNode mqttCommands = commands.get(MQTT); |
|||
assertThat(mqttCommands.get(MQTT).asText()).isEqualTo(String.format("mosquitto_pub -d -q 1 -h localhost -p 1883 -t %s " + |
|||
"-u %s -m \"{temperature:25}\"", DEVICE_TELEMETRY_TOPIC, credentials.getCredentialsId())); |
|||
assertThat(mqttCommands.get(MQTTS).get(0).asText()).isEqualTo("curl -f -S -o tb-server-chain.pem http://localhost:80/api/device-connectivity/mqtts/certificate/download"); |
|||
assertThat(mqttCommands.get(MQTTS).get(1).asText()).isEqualTo(String.format("mosquitto_pub -d -q 1 --cafile tb-server-chain.pem -h localhost -p 8883 " + |
|||
"-t %s -u %s -m \"{temperature:25}\"", DEVICE_TELEMETRY_TOPIC, credentials.getCredentialsId())); |
|||
|
|||
JsonNode dockerMqttCommands = commands.get(MQTT).get(DOCKER); |
|||
assertThat(dockerMqttCommands.get(MQTT).asText()).isEqualTo(String.format("docker run --rm -it thingsboard/mosquitto-clients mosquitto_pub -d -q 1 -h localhost" + |
|||
" -p 1883 -t %s -u %s -m \"{temperature:25}\"", |
|||
DEVICE_TELEMETRY_TOPIC, credentials.getCredentialsId())); |
|||
assertThat(dockerMqttCommands.get(MQTTS).asText()).isEqualTo(String.format("docker run --rm -it thingsboard/mosquitto-clients " + |
|||
"/bin/sh -c \"curl -f -S -o tb-server-chain.pem http://localhost:80/api/device-connectivity/mqtts/certificate/download && " + |
|||
"mosquitto_pub -d -q 1 --cafile tb-server-chain.pem -h localhost -p 8883 -t %s -u %s -m \"{temperature:25}\"\"", |
|||
DEVICE_TELEMETRY_TOPIC, credentials.getCredentialsId())); |
|||
} |
|||
|
|||
@Test |
|||
public void testFetchPublishTelemetryCommandsForDeviceWithMqttBasicCreds() throws Exception { |
|||
Device device = new Device(); |
|||
device.setName("My device"); |
|||
device.setDeviceProfileId(mqttDeviceProfileId); |
|||
|
|||
Device savedDevice = doPost("/api/device", device, Device.class); |
|||
DeviceCredentials credentials = |
|||
doGet("/api/device/" + savedDevice.getId().getId() + "/credentials", DeviceCredentials.class); |
|||
credentials.setCredentialsId(null); |
|||
credentials.setCredentialsType(DeviceCredentialsType.MQTT_BASIC); |
|||
BasicMqttCredentials basicMqttCredentials = new BasicMqttCredentials(); |
|||
String clientId = "testClientId"; |
|||
String userName = "testUsername"; |
|||
String password = "testPassword"; |
|||
basicMqttCredentials.setClientId(clientId); |
|||
basicMqttCredentials.setUserName(userName); |
|||
basicMqttCredentials.setPassword(password); |
|||
credentials.setCredentialsValue(JacksonUtil.toString(basicMqttCredentials)); |
|||
doPost("/api/device/credentials", credentials) |
|||
.andExpect(status().isOk()); |
|||
|
|||
JsonNode commands = |
|||
doGetTyped("/api/device-connectivity/" + savedDevice.getId().getId(), new TypeReference<>() { |
|||
}); |
|||
assertThat(commands).hasSize(1); |
|||
|
|||
JsonNode mqttCommands = commands.get(MQTT); |
|||
assertThat(mqttCommands.get(MQTT).asText()).isEqualTo(String.format("mosquitto_pub -d -q 1 -h localhost -p 1883 -t %s " + |
|||
"-i %s -u %s -P %s -m \"{temperature:25}\"", DEVICE_TELEMETRY_TOPIC, clientId, userName, password)); |
|||
assertThat(mqttCommands.get(MQTTS).get(0).asText()).isEqualTo("curl -f -S -o tb-server-chain.pem http://localhost:80/api/device-connectivity/mqtts/certificate/download"); |
|||
assertThat(mqttCommands.get(MQTTS).get(1).asText()).isEqualTo(String.format("mosquitto_pub -d -q 1 --cafile tb-server-chain.pem -h localhost -p 8883 " + |
|||
"-t %s -i %s -u %s -P %s -m \"{temperature:25}\"", DEVICE_TELEMETRY_TOPIC, clientId, userName, password)); |
|||
|
|||
JsonNode dockerMqttCommands = commands.get(MQTT).get(DOCKER); |
|||
assertThat(dockerMqttCommands.get(MQTT).asText()).isEqualTo(String.format("docker run --rm -it thingsboard/mosquitto-clients mosquitto_pub -d -q 1 -h localhost" + |
|||
" -p 1883 -t %s -i %s -u %s -P %s -m \"{temperature:25}\"", |
|||
DEVICE_TELEMETRY_TOPIC, clientId, userName, password)); |
|||
assertThat(dockerMqttCommands.get(MQTTS).asText()).isEqualTo(String.format("docker run --rm -it thingsboard/mosquitto-clients " + |
|||
"/bin/sh -c \"curl -f -S -o tb-server-chain.pem http://localhost:80/api/device-connectivity/mqtts/certificate/download && " + |
|||
"mosquitto_pub -d -q 1 --cafile tb-server-chain.pem -h localhost -p 8883 -t %s -i %s -u %s -P %s -m \"{temperature:25}\"\"", |
|||
DEVICE_TELEMETRY_TOPIC, clientId, userName, password)); |
|||
} |
|||
|
|||
@Test |
|||
public void testFetchPublishTelemetryCommandsForDeviceWithX509Creds() throws Exception { |
|||
Device device = new Device(); |
|||
device.setName("My device"); |
|||
device.setDeviceProfileId(mqttDeviceProfileId); |
|||
|
|||
Device savedDevice = doPost("/api/device", device, Device.class); |
|||
DeviceCredentials credentials = |
|||
doGet("/api/device/" + savedDevice.getId().getId() + "/credentials", DeviceCredentials.class); |
|||
credentials.setCredentialsId(null); |
|||
credentials.setCredentialsType(DeviceCredentialsType.X509_CERTIFICATE); |
|||
credentials.setCredentialsValue("testValue"); |
|||
doPost("/api/device/credentials", credentials) |
|||
.andExpect(status().isOk()); |
|||
|
|||
JsonNode commands = |
|||
doGetTyped("/api/device-connectivity/" + savedDevice.getId().getId(), new TypeReference<>() { |
|||
}); |
|||
assertThat(commands).hasSize(1); |
|||
assertThat(commands.get(MQTT).get(MQTTS).asText()).isEqualTo(CHECK_DOCUMENTATION); |
|||
assertThat(commands.get(MQTT).get(DOCKER)).isNull(); |
|||
} |
|||
|
|||
@Test |
|||
public void testFetchPublishTelemetryCommandsForCoapDevice() throws Exception { |
|||
Device device = new Device(); |
|||
device.setName("My device"); |
|||
device.setDeviceProfileId(coapDeviceProfileId); |
|||
|
|||
Device savedDevice = doPost("/api/device", device, Device.class); |
|||
DeviceCredentials credentials = |
|||
doGet("/api/device/" + savedDevice.getId().getId() + "/credentials", DeviceCredentials.class); |
|||
|
|||
JsonNode commands = |
|||
doGetTyped("/api/device-connectivity/" + savedDevice.getId().getId(), new TypeReference<>() { |
|||
}); |
|||
assertThat(commands).hasSize(1); |
|||
|
|||
JsonNode linuxCommands = commands.get(COAP); |
|||
assertThat(linuxCommands.get(COAP).asText()).isEqualTo(String.format("coap-client -m POST coap://localhost:5683/api/v1/%s/telemetry -t json -e \"{temperature:25}\"", |
|||
credentials.getCredentialsId())); |
|||
assertThat(linuxCommands.get(COAPS).asText()).isEqualTo(String.format("coap-client-openssl -m POST coaps://localhost:5684/api/v1/%s/telemetry -t json -e \"{temperature:25}\"", |
|||
credentials.getCredentialsId())); |
|||
} |
|||
|
|||
@Test |
|||
public void testFetchPublishTelemetryCommandsForCoapDeviceWithX509Creds() throws Exception { |
|||
Device device = new Device(); |
|||
device.setName("My device"); |
|||
device.setDeviceProfileId(coapDeviceProfileId); |
|||
|
|||
Device savedDevice = doPost("/api/device", device, Device.class); |
|||
DeviceCredentials credentials = |
|||
doGet("/api/device/" + savedDevice.getId().getId() + "/credentials", DeviceCredentials.class); |
|||
credentials.setCredentialsId(null); |
|||
credentials.setCredentialsType(DeviceCredentialsType.X509_CERTIFICATE); |
|||
credentials.setCredentialsValue("testValue"); |
|||
doPost("/api/device/credentials", credentials) |
|||
.andExpect(status().isOk()); |
|||
|
|||
JsonNode commands = |
|||
doGetTyped("/api/device-connectivity/" + savedDevice.getId().getId(), new TypeReference<>() { |
|||
}); |
|||
assertThat(commands).hasSize(1); |
|||
assertThat(commands.get(COAP).get(COAPS).asText()).isEqualTo(CHECK_DOCUMENTATION); |
|||
} |
|||
} |
|||
@ -0,0 +1,29 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.dao.device; |
|||
|
|||
import com.fasterxml.jackson.databind.JsonNode; |
|||
import org.springframework.core.io.Resource; |
|||
import org.thingsboard.server.common.data.Device; |
|||
|
|||
import java.net.URISyntaxException; |
|||
|
|||
public interface DeviceConnectivityService { |
|||
|
|||
JsonNode findDevicePublishTelemetryCommands(String baseUrl, Device device) throws URISyntaxException; |
|||
|
|||
Resource getPemCertFile(String protocol); |
|||
} |
|||
@ -0,0 +1,34 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.dao.device; |
|||
|
|||
import lombok.Data; |
|||
import org.springframework.boot.context.properties.ConfigurationProperties; |
|||
import org.springframework.context.annotation.Configuration; |
|||
|
|||
import java.util.Map; |
|||
|
|||
@Configuration |
|||
@ConfigurationProperties(prefix = "device") |
|||
@Data |
|||
public class DeviceConnectivityConfiguration { |
|||
private Map<String, DeviceConnectivityInfo> connectivity; |
|||
|
|||
public boolean isEnabled(String protocol) { |
|||
var info = connectivity.get(protocol); |
|||
return info != null && info.isEnabled(); |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.dao.device; |
|||
|
|||
import lombok.Data; |
|||
|
|||
@Data |
|||
public class DeviceConnectivityInfo { |
|||
private boolean enabled; |
|||
private String host; |
|||
private String port; |
|||
private String pemCertFile; |
|||
} |
|||
@ -0,0 +1,268 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.dao.device; |
|||
|
|||
import com.fasterxml.jackson.databind.JsonNode; |
|||
import com.fasterxml.jackson.databind.node.ArrayNode; |
|||
import com.fasterxml.jackson.databind.node.ObjectNode; |
|||
import lombok.extern.slf4j.Slf4j; |
|||
import org.springframework.beans.factory.annotation.Autowired; |
|||
import org.springframework.core.io.ClassPathResource; |
|||
import org.springframework.core.io.Resource; |
|||
import org.springframework.stereotype.Service; |
|||
import org.thingsboard.common.util.JacksonUtil; |
|||
import org.thingsboard.server.common.data.Device; |
|||
import org.thingsboard.server.common.data.DeviceProfile; |
|||
import org.thingsboard.server.common.data.DeviceTransportType; |
|||
import org.thingsboard.server.common.data.ResourceUtils; |
|||
import org.thingsboard.server.common.data.StringUtils; |
|||
import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration; |
|||
import org.thingsboard.server.common.data.id.DeviceId; |
|||
import org.thingsboard.server.common.data.security.DeviceCredentials; |
|||
import org.thingsboard.server.common.data.security.DeviceCredentialsType; |
|||
import org.thingsboard.server.dao.util.DeviceConnectivityUtil; |
|||
|
|||
import java.net.URI; |
|||
import java.net.URISyntaxException; |
|||
import java.util.ArrayList; |
|||
import java.util.List; |
|||
import java.util.Optional; |
|||
|
|||
import static org.thingsboard.server.dao.service.Validator.validateId; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.CHECK_DOCUMENTATION; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.COAP; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.COAPS; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.DOCKER; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.HTTP; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.HTTPS; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.MQTT; |
|||
import static org.thingsboard.server.dao.util.DeviceConnectivityUtil.MQTTS; |
|||
|
|||
@Service("DeviceConnectivityDaoService") |
|||
@Slf4j |
|||
public class DeviceConnectivityServiceImpl implements DeviceConnectivityService { |
|||
|
|||
public static final String INCORRECT_TENANT_ID = "Incorrect tenantId "; |
|||
public static final String INCORRECT_DEVICE_ID = "Incorrect deviceId "; |
|||
public static final String DEFAULT_DEVICE_TELEMETRY_TOPIC = "v1/devices/me/telemetry"; |
|||
|
|||
@Autowired |
|||
private DeviceCredentialsService deviceCredentialsService; |
|||
|
|||
@Autowired |
|||
private DeviceProfileService deviceProfileService; |
|||
|
|||
@Autowired |
|||
private DeviceConnectivityConfiguration deviceConnectivityConfiguration; |
|||
|
|||
@Override |
|||
public JsonNode findDevicePublishTelemetryCommands(String baseUrl, Device device) throws URISyntaxException { |
|||
DeviceId deviceId = device.getId(); |
|||
log.trace("Executing findDevicePublishTelemetryCommands [{}]", deviceId); |
|||
validateId(deviceId, INCORRECT_DEVICE_ID + deviceId); |
|||
|
|||
DeviceCredentials creds = deviceCredentialsService.findDeviceCredentialsByDeviceId(device.getTenantId(), deviceId); |
|||
DeviceProfile deviceProfile = deviceProfileService.findDeviceProfileById(device.getTenantId(), device.getDeviceProfileId()); |
|||
DeviceTransportType transportType = deviceProfile.getTransportType(); |
|||
|
|||
ObjectNode commands = JacksonUtil.newObjectNode(); |
|||
switch (transportType) { |
|||
case DEFAULT: |
|||
Optional.ofNullable(getHttpTransportPublishCommands(baseUrl, creds)) |
|||
.ifPresent(v -> commands.set(HTTP, v)); |
|||
Optional.ofNullable(getMqttTransportPublishCommands(baseUrl, creds)) |
|||
.ifPresent(v -> commands.set(MQTT, v)); |
|||
Optional.ofNullable(getCoapTransportPublishCommands(baseUrl, creds)) |
|||
.ifPresent(v -> commands.set(COAP, v)); |
|||
break; |
|||
case MQTT: |
|||
MqttDeviceProfileTransportConfiguration transportConfiguration = |
|||
(MqttDeviceProfileTransportConfiguration) deviceProfile.getProfileData().getTransportConfiguration(); |
|||
//TODO: add sparkplug command with emulator (check SSL)
|
|||
if (transportConfiguration.isSparkplug()) { |
|||
ObjectNode sparkplug = JacksonUtil.newObjectNode(); |
|||
sparkplug.put("sparkplug", CHECK_DOCUMENTATION); |
|||
commands.set(MQTT, sparkplug); |
|||
} else { |
|||
String topicName = transportConfiguration.getDeviceTelemetryTopic(); |
|||
|
|||
Optional.ofNullable(getMqttTransportPublishCommands(baseUrl, topicName, creds)) |
|||
.ifPresent(v -> commands.set(MQTT, v)); |
|||
} |
|||
break; |
|||
case COAP: |
|||
Optional.ofNullable(getCoapTransportPublishCommands(baseUrl, creds)) |
|||
.ifPresent(v -> commands.set(COAP, v)); |
|||
break; |
|||
default: |
|||
commands.put(transportType.name(), CHECK_DOCUMENTATION); |
|||
} |
|||
return commands; |
|||
} |
|||
|
|||
@Override |
|||
public Resource getPemCertFile(String protocol) { |
|||
String certFilePath = deviceConnectivityConfiguration.getConnectivity() |
|||
.get(protocol) |
|||
.getPemCertFile(); |
|||
|
|||
if (StringUtils.isNotBlank(certFilePath) && ResourceUtils.resourceExists(this, certFilePath)) { |
|||
return new ClassPathResource(certFilePath); |
|||
} else { |
|||
return null; |
|||
} |
|||
} |
|||
|
|||
private JsonNode getHttpTransportPublishCommands(String defaultHostname, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
ObjectNode httpCommands = JacksonUtil.newObjectNode(); |
|||
Optional.ofNullable(getHttpPublishCommand(HTTP, defaultHostname, deviceCredentials)) |
|||
.ifPresent(v -> httpCommands.put(HTTP, v)); |
|||
Optional.ofNullable(getHttpPublishCommand(HTTPS, defaultHostname, deviceCredentials)) |
|||
.ifPresent(v -> httpCommands.put(HTTPS, v)); |
|||
return httpCommands.isEmpty() ? null : httpCommands; |
|||
} |
|||
|
|||
private String getHttpPublishCommand(String protocol, String baseUrl, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
DeviceConnectivityInfo properties = deviceConnectivityConfiguration.getConnectivity().get(protocol); |
|||
if (properties == null || !properties.isEnabled() || |
|||
deviceCredentials.getCredentialsType() != DeviceCredentialsType.ACCESS_TOKEN) { |
|||
return null; |
|||
} |
|||
String hostName = getHost(baseUrl, properties); |
|||
String port = properties.getPort().isEmpty() ? "" : ":" + properties.getPort(); |
|||
|
|||
return DeviceConnectivityUtil.getHttpPublishCommand(protocol, hostName, port, deviceCredentials); |
|||
} |
|||
|
|||
private JsonNode getMqttTransportPublishCommands(String baseUrl, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
return getMqttTransportPublishCommands(baseUrl, DEFAULT_DEVICE_TELEMETRY_TOPIC, deviceCredentials); |
|||
} |
|||
|
|||
private JsonNode getMqttTransportPublishCommands(String baseUrl, String topic, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
ObjectNode mqttCommands = JacksonUtil.newObjectNode(); |
|||
|
|||
if (deviceCredentials.getCredentialsType() == DeviceCredentialsType.X509_CERTIFICATE) { |
|||
mqttCommands.put(MQTTS, CHECK_DOCUMENTATION); |
|||
return mqttCommands; |
|||
} |
|||
|
|||
ObjectNode dockerMqttCommands = JacksonUtil.newObjectNode(); |
|||
|
|||
if (deviceConnectivityConfiguration.isEnabled(MQTT)) { |
|||
Optional.ofNullable(getMqttPublishCommand(baseUrl, topic, deviceCredentials)). |
|||
ifPresent(v -> mqttCommands.put(MQTT, v)); |
|||
|
|||
Optional.ofNullable(getDockerMqttPublishCommand(MQTT, baseUrl, topic, deviceCredentials)) |
|||
.ifPresent(v -> dockerMqttCommands.put(MQTT, v)); |
|||
} |
|||
|
|||
if (deviceConnectivityConfiguration.isEnabled(MQTTS)) { |
|||
List<String> mqttsPublishCommand = getMqttsPublishCommand(baseUrl, topic, deviceCredentials); |
|||
if (mqttsPublishCommand != null) { |
|||
ArrayNode arrayNode = mqttCommands.putArray(MQTTS); |
|||
mqttsPublishCommand.forEach(arrayNode::add); |
|||
} |
|||
|
|||
Optional.ofNullable(getDockerMqttPublishCommand(MQTTS, baseUrl, topic, deviceCredentials)) |
|||
.ifPresent(v -> dockerMqttCommands.put(MQTTS, v)); |
|||
} |
|||
|
|||
if (!dockerMqttCommands.isEmpty()) { |
|||
mqttCommands.set(DOCKER, dockerMqttCommands); |
|||
} |
|||
return mqttCommands.isEmpty() ? null : mqttCommands; |
|||
} |
|||
|
|||
private String getMqttPublishCommand(String baseUrl, String deviceTelemetryTopic, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
DeviceConnectivityInfo properties = deviceConnectivityConfiguration.getConnectivity().get(MQTT); |
|||
String mqttHost = getHost(baseUrl, properties); |
|||
String mqttPort = properties.getPort().isEmpty() ? null : properties.getPort(); |
|||
return DeviceConnectivityUtil.getMqttPublishCommand(MQTT, mqttHost, mqttPort, deviceTelemetryTopic, deviceCredentials); |
|||
} |
|||
|
|||
private List<String> getMqttsPublishCommand(String baseUrl, String deviceTelemetryTopic, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
DeviceConnectivityInfo properties = deviceConnectivityConfiguration.getConnectivity().get(MQTTS); |
|||
String mqttHost = getHost(baseUrl, properties); |
|||
String mqttPort = properties.getPort().isEmpty() ? null : properties.getPort(); |
|||
String pubCommand = DeviceConnectivityUtil.getMqttPublishCommand(MQTTS, mqttHost, mqttPort, deviceTelemetryTopic, deviceCredentials); |
|||
|
|||
ArrayList<String> commands = new ArrayList<>(); |
|||
if (pubCommand != null) { |
|||
commands.add(DeviceConnectivityUtil.getCurlPemCertCommand(baseUrl, MQTTS)); |
|||
commands.add(pubCommand); |
|||
return commands; |
|||
} |
|||
return null; |
|||
} |
|||
|
|||
private String getDockerMqttPublishCommand(String protocol, String baseUrl, String deviceTelemetryTopic, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
DeviceConnectivityInfo properties = deviceConnectivityConfiguration.getConnectivity().get(protocol); |
|||
String mqttHost = getHost(baseUrl, properties); |
|||
String mqttPort = properties.getPort().isEmpty() ? null : properties.getPort(); |
|||
return DeviceConnectivityUtil.getDockerMqttPublishCommand(protocol, baseUrl, mqttHost, mqttPort, deviceTelemetryTopic, deviceCredentials); |
|||
} |
|||
|
|||
private JsonNode getCoapTransportPublishCommands(String baseUrl, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
ObjectNode coapCommands = JacksonUtil.newObjectNode(); |
|||
|
|||
if (deviceCredentials.getCredentialsType() == DeviceCredentialsType.X509_CERTIFICATE) { |
|||
coapCommands.put(COAPS, CHECK_DOCUMENTATION); |
|||
return coapCommands; |
|||
} |
|||
|
|||
ObjectNode dockerCoapCommands = JacksonUtil.newObjectNode(); |
|||
|
|||
if (deviceConnectivityConfiguration.isEnabled(COAP)) { |
|||
Optional.ofNullable(getCoapPublishCommand(COAP, baseUrl, deviceCredentials)) |
|||
.ifPresent(v -> coapCommands.put(COAP, v)); |
|||
|
|||
Optional.ofNullable(getDockerCoapPublishCommand(COAP, baseUrl, deviceCredentials)) |
|||
.ifPresent(v -> dockerCoapCommands.put(COAP, v)); |
|||
} |
|||
|
|||
if (deviceConnectivityConfiguration.isEnabled(COAPS)) { |
|||
Optional.ofNullable(getCoapPublishCommand(COAPS, baseUrl, deviceCredentials)) |
|||
.ifPresent(v -> coapCommands.put(COAPS, v)); |
|||
|
|||
Optional.ofNullable(getDockerCoapPublishCommand(COAPS, baseUrl, deviceCredentials)) |
|||
.ifPresent(v -> dockerCoapCommands.put(COAPS, v)); |
|||
} |
|||
|
|||
if (!dockerCoapCommands.isEmpty()) { |
|||
coapCommands.set(DOCKER, dockerCoapCommands); |
|||
} |
|||
|
|||
return coapCommands.isEmpty() ? null : coapCommands; |
|||
} |
|||
|
|||
private String getCoapPublishCommand(String protocol, String baseUrl, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
DeviceConnectivityInfo properties = deviceConnectivityConfiguration.getConnectivity().get(protocol); |
|||
String hostName = getHost(baseUrl, properties); |
|||
String port = properties.getPort().isEmpty() ? "" : ":" + properties.getPort(); |
|||
return DeviceConnectivityUtil.getCoapPublishCommand(protocol, hostName, port, deviceCredentials); |
|||
} |
|||
|
|||
private String getDockerCoapPublishCommand(String protocol, String baseUrl, DeviceCredentials deviceCredentials) throws URISyntaxException { |
|||
DeviceConnectivityInfo properties = deviceConnectivityConfiguration.getConnectivity().get(protocol); |
|||
String host = getHost(baseUrl, properties); |
|||
String port = properties.getPort().isEmpty() ? "" : ":" + properties.getPort(); |
|||
return DeviceConnectivityUtil.getDockerCoapPublishCommand(protocol, host, port, deviceCredentials); |
|||
} |
|||
|
|||
private String getHost(String baseUrl, DeviceConnectivityInfo properties) throws URISyntaxException { |
|||
return properties.getHost().isEmpty() ? new URI(baseUrl).getHost() : properties.getHost(); |
|||
} |
|||
} |
|||
@ -0,0 +1,123 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
package org.thingsboard.server.dao.util; |
|||
|
|||
import org.thingsboard.common.util.JacksonUtil; |
|||
import org.thingsboard.server.common.data.device.credentials.BasicMqttCredentials; |
|||
import org.thingsboard.server.common.data.security.DeviceCredentials; |
|||
|
|||
public class DeviceConnectivityUtil { |
|||
|
|||
public static final String HTTP = "http"; |
|||
public static final String HTTPS = "https"; |
|||
public static final String MQTT = "mqtt"; |
|||
public static final String LINUX = "linux"; |
|||
public static final String WINDOWS = "windows"; |
|||
public static final String DOCKER = "docker"; |
|||
public static final String MQTTS = "mqtts"; |
|||
public static final String COAP = "coap"; |
|||
public static final String COAPS = "coaps"; |
|||
public static final String PEM_CERT_FILE_NAME = "tb-server-chain.pem"; |
|||
public static final String CHECK_DOCUMENTATION = "Check documentation"; |
|||
public static final String JSON_EXAMPLE_PAYLOAD = "\"{temperature:25}\""; |
|||
public static final String DOCKER_RUN = "docker run --rm -it "; |
|||
public static final String MQTT_IMAGE = "thingsboard/mosquitto-clients "; |
|||
public static final String COAP_IMAGE = "thingsboard/coap-clients "; |
|||
|
|||
public static String getHttpPublishCommand(String protocol, String host, String port, DeviceCredentials deviceCredentials) { |
|||
return String.format("curl -v -X POST %s://%s%s/api/v1/%s/telemetry --header Content-Type:application/json --data " + JSON_EXAMPLE_PAYLOAD, |
|||
protocol, host, port, deviceCredentials.getCredentialsId()); |
|||
} |
|||
|
|||
public static String getMqttPublishCommand(String protocol, String host, String port, String deviceTelemetryTopic, DeviceCredentials deviceCredentials) { |
|||
StringBuilder command = new StringBuilder("mosquitto_pub -d -q 1"); |
|||
if (MQTTS.equals(protocol)) { |
|||
command.append(" --cafile ").append(PEM_CERT_FILE_NAME); |
|||
} |
|||
command.append(" -h ").append(host).append(port == null ? "" : " -p " + port); |
|||
command.append(" -t ").append(deviceTelemetryTopic); |
|||
|
|||
switch (deviceCredentials.getCredentialsType()) { |
|||
case ACCESS_TOKEN: |
|||
command.append(" -u ").append(deviceCredentials.getCredentialsId()); |
|||
break; |
|||
case MQTT_BASIC: |
|||
BasicMqttCredentials credentials = JacksonUtil.fromString(deviceCredentials.getCredentialsValue(), |
|||
BasicMqttCredentials.class); |
|||
if (credentials != null) { |
|||
if (credentials.getClientId() != null) { |
|||
command.append(" -i ").append(credentials.getClientId()); |
|||
} |
|||
if (credentials.getUserName() != null) { |
|||
command.append(" -u ").append(credentials.getUserName()); |
|||
} |
|||
if (credentials.getPassword() != null) { |
|||
command.append(" -P ").append(credentials.getPassword()); |
|||
} |
|||
} else { |
|||
return null; |
|||
} |
|||
break; |
|||
default: |
|||
return null; |
|||
} |
|||
command.append(" -m " + JSON_EXAMPLE_PAYLOAD); |
|||
return command.toString(); |
|||
} |
|||
|
|||
public static String getDockerMqttPublishCommand(String protocol, String baseUrl, String host, String port, String deviceTelemetryTopic, DeviceCredentials deviceCredentials) { |
|||
String mqttCommand = getMqttPublishCommand(protocol, host, port, deviceTelemetryTopic, deviceCredentials); |
|||
|
|||
if (mqttCommand == null) { |
|||
return null; |
|||
} |
|||
|
|||
StringBuilder mqttDockerCommand = new StringBuilder(); |
|||
mqttDockerCommand.append(DOCKER_RUN).append(MQTT_IMAGE); |
|||
|
|||
if (MQTTS.equals(protocol)) { |
|||
mqttDockerCommand.append("/bin/sh -c \"") |
|||
.append(getCurlPemCertCommand(baseUrl, protocol)) |
|||
.append(" && ") |
|||
.append(mqttCommand) |
|||
.append("\""); |
|||
} else { |
|||
mqttDockerCommand.append(mqttCommand); |
|||
} |
|||
|
|||
return mqttDockerCommand.toString(); |
|||
} |
|||
|
|||
public static String getCurlPemCertCommand(String baseUrl, String protocol) { |
|||
return String.format("curl -f -S -o %s %s/api/device-connectivity/%s/certificate/download", PEM_CERT_FILE_NAME, baseUrl, protocol); |
|||
} |
|||
|
|||
public static String getCoapPublishCommand(String protocol, String host, String port, DeviceCredentials deviceCredentials) { |
|||
switch (deviceCredentials.getCredentialsType()) { |
|||
case ACCESS_TOKEN: |
|||
String client = COAPS.equals(protocol) ? "coap-client-openssl" : "coap-client"; |
|||
return String.format("%s -m POST %s://%s%s/api/v1/%s/telemetry -t json -e %s", |
|||
client, protocol, host, port, deviceCredentials.getCredentialsId(), JSON_EXAMPLE_PAYLOAD); |
|||
default: |
|||
return null; |
|||
} |
|||
} |
|||
|
|||
public static String getDockerCoapPublishCommand(String protocol, String host, String port, DeviceCredentials deviceCredentials) { |
|||
String coapCommand = getCoapPublishCommand(protocol, host, port, deviceCredentials); |
|||
return coapCommand != null ? String.format("%s%s%s", DOCKER_RUN, COAP_IMAGE, coapCommand) : null; |
|||
} |
|||
} |
|||
@ -0,0 +1,402 @@ |
|||
<!-- |
|||
|
|||
Copyright © 2016-2023 The Thingsboard Authors |
|||
|
|||
Licensed under the Apache License, Version 2.0 (the "License"); |
|||
you may not use this file except in compliance with the License. |
|||
You may obtain a copy of the License at |
|||
|
|||
http://www.apache.org/licenses/LICENSE-2.0 |
|||
|
|||
Unless required by applicable law or agreed to in writing, software |
|||
distributed under the License is distributed on an "AS IS" BASIS, |
|||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
See the License for the specific language governing permissions and |
|||
limitations under the License. |
|||
|
|||
--> |
|||
<mat-toolbar color="primary"> |
|||
<h2 translate>{{ dialogTitle }}</h2> |
|||
<span fxFlex></span> |
|||
<!-- <div [tb-help]="'check-connectivity'"></div>--> |
|||
<button mat-icon-button |
|||
(click)="close()" |
|||
type="button"> |
|||
<mat-icon class="material-icons">close</mat-icon> |
|||
</button> |
|||
</mat-toolbar> |
|||
<div mat-dialog-content> |
|||
<section *ngIf="loadedCommand; else loadingCommand" class="tb-form-panel no-padding no-border"> |
|||
<tb-toggle-header #transportProtocol |
|||
value="{{ selectTransportType }}" |
|||
name="TransportProtocol" |
|||
useSelectOnMdLg="false" |
|||
appearance="fill" |
|||
[fxHide]="allowTransportType.size < 2"> |
|||
<tb-toggle-option |
|||
*ngIf="allowTransportType.has(BasicTransportType.HTTP)" |
|||
[value]="BasicTransportType.HTTP"> |
|||
{{ deviceTransportTypeTranslationMap.get(BasicTransportType.HTTP) | translate }} |
|||
</tb-toggle-option> |
|||
<tb-toggle-option |
|||
*ngIf="allowTransportType.has(DeviceTransportType.MQTT)" |
|||
[value]="DeviceTransportType.MQTT"> |
|||
{{ deviceTransportTypeTranslationMap.get(DeviceTransportType.MQTT) | translate }} |
|||
</tb-toggle-option> |
|||
<tb-toggle-option |
|||
*ngIf="allowTransportType.has(DeviceTransportType.COAP)" |
|||
[value]="DeviceTransportType.COAP"> |
|||
{{ deviceTransportTypeTranslationMap.get(DeviceTransportType.COAP) | translate }} |
|||
</tb-toggle-option> |
|||
<tb-toggle-option |
|||
*ngIf="allowTransportType.has(DeviceTransportType.SNMP)" |
|||
[value]="DeviceTransportType.SNMP"> |
|||
{{ deviceTransportTypeTranslationMap.get(DeviceTransportType.SNMP) | translate }} |
|||
</tb-toggle-option> |
|||
<tb-toggle-option |
|||
*ngIf="allowTransportType.has(DeviceTransportType.LWM2M)" |
|||
[value]="DeviceTransportType.LWM2M"> |
|||
{{ deviceTransportTypeTranslationMap.get(DeviceTransportType.LWM2M) | translate }} |
|||
</tb-toggle-option> |
|||
</tb-toggle-header> |
|||
<div class="tb-form-panel no-padding no-border" [fxHide]="!allowTransportType.size"> |
|||
<ng-container [ngSwitch]="transportProtocol.value"> |
|||
<ng-template [ngSwitchCase]="BasicTransportType.HTTP"> |
|||
<div class="tb-no-data-text" translate>device.connectivity.use-following-instructions</div> |
|||
<mat-tab-group [(selectedIndex)]="httpTabIndex"> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="windows"></mat-icon> |
|||
Windows |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<div class="tb-install-instruction-text" translate>device.connectivity.install-curl-windows</div> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'HTTP', noSec: commands.http.http, |
|||
secLabel: 'HTTPs', sec: commands.http.https, |
|||
doc: {text: '', href: ''}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="macos"></mat-icon> |
|||
MacOS |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<tb-markdown usePlainMarkdown containerClass="tb-command-code" |
|||
[data]='createMarkDownCommand("brew install curl")'></tb-markdown> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'HTTP', noSec: commands.http.http, |
|||
secLabel: 'HTTPs', sec: commands.http.https, |
|||
doc: {text: '', href: ''}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="linux"></mat-icon> |
|||
Linux |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<tb-markdown usePlainMarkdown containerClass="tb-command-code" |
|||
[data]='createMarkDownCommand("sudo apt-get install curl")'></tb-markdown> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'HTTP', noSec: commands.http.http, |
|||
secLabel: 'HTTPs', sec: commands.http.https, |
|||
doc: {text: '', href: ''}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
</mat-tab-group> |
|||
</ng-template> |
|||
<ng-template [ngSwitchCase]="DeviceTransportType.MQTT"> |
|||
<div *ngIf="commands.mqtt.sparkplug; else mqttCommands" class="tb-form-panel stroked"> |
|||
<ng-container |
|||
*ngTemplateOutlet="seeDocumentation; context: |
|||
{doc: {text: 'device.connectivity.sparkplug-command', href: 'https://thingsboard.io/docs/reference/mqtt-sparkplug-api/'}}"> |
|||
</ng-container> |
|||
</div> |
|||
<ng-template #mqttCommands> |
|||
<div class="tb-no-data-text" translate>device.connectivity.use-following-instructions</div> |
|||
<mat-tab-group [(selectedIndex)]="mqttTabIndex"> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="windows"></mat-icon> |
|||
Windows |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<div class="tb-install-instruction-text"> |
|||
<ng-container *ngTemplateOutlet="seeDocumentation; context: |
|||
{doc: {text: 'device.connectivity.install-mqtt-windows', |
|||
href: 'https://thingsboard.io/docs/getting-started-guides/helloworld/?connectdevice=mqtt-windows#step-2-connect-device'}}"> |
|||
</ng-container> |
|||
</div> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'MQTT', noSec: commands.mqtt.mqtt, |
|||
secLabel: 'MQTTs', sec: commands.mqtt.mqtts, |
|||
doc: {text: 'device.connectivity.mqtts-x509-command', href: 'https://thingsboard.io/docs/user-guide/mqtt-over-ssl/'}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="macos"></mat-icon> |
|||
MacOS |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<tb-markdown usePlainMarkdown containerClass="tb-command-code" |
|||
[data]='createMarkDownCommand("brew install mosquitto-clients")'></tb-markdown> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'MQTT', noSec: commands.mqtt.mqtt, |
|||
secLabel: 'MQTTs', sec: commands.mqtt.mqtts, |
|||
doc: {text: 'device.connectivity.mqtts-x509-command', href: 'https://thingsboard.io/docs/user-guide/mqtt-over-ssl/'}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="linux"></mat-icon> |
|||
Linux |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<tb-markdown usePlainMarkdown containerClass="tb-command-code" |
|||
[data]='createMarkDownCommand("sudo apt-get install curl mosquitto-clients")'></tb-markdown> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'MQTT', noSec: commands.mqtt.mqtt, |
|||
secLabel: 'MQTTs', sec: commands.mqtt.mqtts, |
|||
doc: {text: 'device.connectivity.mqtts-x509-command', href: 'https://thingsboard.io/docs/user-guide/mqtt-over-ssl/'}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
<mat-tab *ngIf="!!commands.mqtt.docker"> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="docker"></mat-icon> |
|||
Docker |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'MQTT', noSec: commands.mqtt.docker.mqtt, |
|||
secLabel: 'MQTTs', sec: commands.mqtt.docker.mqtts, |
|||
doc: {text: 'device.connectivity.mqtts-x509-command', href: 'https://thingsboard.io/docs/user-guide/mqtt-over-ssl/'}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
</mat-tab-group> |
|||
</ng-template> |
|||
</ng-template> |
|||
<ng-template [ngSwitchCase]="DeviceTransportType.COAP"> |
|||
<div class="tb-no-data-text" translate>device.connectivity.use-following-instructions</div> |
|||
<mat-tab-group [(selectedIndex)]="coapTabIndex"> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="macos"></mat-icon> |
|||
MacOS |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked" *ngIf="commands.coap.coaps !== 'Check documentation'"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<div class="tb-install-instruction-text"> |
|||
<ng-container *ngTemplateOutlet="seeDocumentation; context: |
|||
{doc: {text: 'device.connectivity.install-coap-client', |
|||
href: 'https://thingsboard.io/docs/user-guide/ssl/coap-access-token/'}}"> |
|||
</ng-container> |
|||
</div> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'CoAP', noSec: commands.coap.coap, |
|||
secLabel: 'CoAPs', sec: commands.coap.coaps, |
|||
doc: {text: 'device.connectivity.coaps-x509-command', href: 'https://thingsboard.io/docs/user-guide/ssl/coap-x509-certificates/'}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
<mat-tab> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="linux"></mat-icon> |
|||
Linux |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<div class="tb-form-panel stroked" *ngIf="commands.coap.coaps !== 'Check documentation'"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.install-necessary-client-tools</div> |
|||
<div class="tb-install-instruction-text"> |
|||
<ng-container *ngTemplateOutlet="seeDocumentation; context: |
|||
{doc: {text: 'device.connectivity.install-coap-client', |
|||
href: 'https://thingsboard.io/docs/user-guide/ssl/coap-access-token/'}}"> |
|||
</ng-container> |
|||
</div> |
|||
</div> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'CoAP', noSec: commands.coap.coap, |
|||
secLabel: 'CoAPs', sec: commands.coap.coaps, |
|||
doc: {text: 'device.connectivity.coaps-x509-command', href: 'https://thingsboard.io/docs/user-guide/ssl/coap-x509-certificates/'}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
<mat-tab *ngIf="!!commands.coap.docker"> |
|||
<ng-template mat-tab-label> |
|||
<mat-icon class="tabs-icon" svgIcon="docker"></mat-icon> |
|||
Docker |
|||
</ng-template> |
|||
<ng-template matTabContent> |
|||
<div class="tb-form-panel no-padding no-border tb-tab-body"> |
|||
<ng-container |
|||
*ngTemplateOutlet="executeCommand; context: {cmd: { |
|||
noSecLabel: 'CoAP', noSec: commands.coap.docker.coap, |
|||
secLabel: 'CoAPs', sec: commands.coap.docker.coaps, |
|||
doc: {text: 'device.connectivity.coaps-x509-command', href: 'https://thingsboard.io/docs/user-guide/ssl/coap-x509-certificates/'}}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</mat-tab> |
|||
</mat-tab-group> |
|||
</ng-template> |
|||
<ng-template [ngSwitchCase]="DeviceTransportType.SNMP"> |
|||
<div class="tb-form-panel stroked"> |
|||
<ng-container |
|||
*ngTemplateOutlet="seeDocumentation; context: |
|||
{doc: {text: 'device.connectivity.snmp-command', href: 'https://thingsboard.io/docs/reference/snmp-api/'}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
<ng-template [ngSwitchCase]="DeviceTransportType.LWM2M"> |
|||
<div class="tb-form-panel stroked"> |
|||
<ng-container |
|||
*ngTemplateOutlet="seeDocumentation; context: |
|||
{doc: {text: 'device.connectivity.lwm2m-command', href: 'https://thingsboard.io/docs/reference/lwm2m-api/'}}"> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
</ng-container> |
|||
</div> |
|||
<div class="tb-form-panel stroked"> |
|||
<div fxFlex fxLayout="row"> |
|||
<div class="tb-form-panel-title" translate>device.state</div> |
|||
<div class="status" [ngClass]="{'inactive': !status, 'hide': status === undefined}"> |
|||
{{ (status ? 'device.active' : 'device.inactive') | translate }} |
|||
</div> |
|||
</div> |
|||
<div class="tb-form-panel-hint tb-font-14" translate>attribute.latest-telemetry</div> |
|||
<div class="tb-form-table"> |
|||
<div class="tb-form-table-header"> |
|||
<div class="tb-form-table-header-cell" fxFlex translate>device.time</div> |
|||
<div class="tb-form-table-header-cell" fxFlex translate>attribute.key</div> |
|||
<div class="tb-form-table-header-cell" fxFlex translate>attribute.value</div> |
|||
</div> |
|||
<div *ngIf="latestTelemetry.length; else noData" class="tb-form-table-body"> |
|||
<div class="tb-form-table-row" *ngFor="let telemetry of latestTelemetry"> |
|||
<div class="tb-form-table-row-cell" fxFlex>{{ telemetry.lastUpdateTs | date: 'yyyy-MM-dd HH:mm:ss' }}</div> |
|||
<div class="tb-form-table-row-cell" fxFlex>{{ telemetry.key }}</div> |
|||
<div class="tb-form-table-row-cell" fxFlex>{{ telemetry.value }}</div> |
|||
</div> |
|||
</div> |
|||
</div> |
|||
</div> |
|||
</section> |
|||
</div> |
|||
<div mat-dialog-actions class="tb-dialog-actions"> |
|||
<mat-slide-toggle fxShow="{{ showDontShowAgain }}" [(ngModel)]="notShowAgain">{{ 'action.dont-show-again' | translate}}</mat-slide-toggle> |
|||
<span fxFlex></span> |
|||
<button mat-button |
|||
[disabled]="(isLoading$ | async)" |
|||
(click)="close()">{{ closeButtonLabel | translate }}</button> |
|||
</div> |
|||
<ng-template #loadingCommand> |
|||
<div class="tb-loader"> |
|||
<mat-spinner color="accent" diameter="65" strokeWidth="4"></mat-spinner> |
|||
<span class="mat-subtitle-1 label"> |
|||
{{ 'device.connectivity.loading-check-connectivity-command' | translate }} |
|||
</span> |
|||
</div> |
|||
</ng-template> |
|||
<ng-template #noData> |
|||
<div class="tb-no-data-available"> |
|||
<div class="tb-no-data-bg"></div> |
|||
<div class="tb-no-data-text" translate>attribute.no-latest-telemetry</div> |
|||
</div> |
|||
</ng-template> |
|||
|
|||
<ng-template #executeCommand let-cmd="cmd"> |
|||
<div class="tb-form-panel stroked"> |
|||
<div fxLayout="row" fxLayoutAlign="space-between center" [fxHide]="!(cmd.noSec || cmd.sec !== 'Check documentation')"> |
|||
<div class="tb-form-panel-title" translate>device.connectivity.execute-following-command</div> |
|||
<tb-toggle-header #protocolType value="{{ cmd.noSec ? 'noSec' : 'sec'}}" name="protocolType" useSelectOnMdLg="false" |
|||
[fxShow]="cmd.noSec && cmd.sec"> |
|||
<tb-toggle-option value="noSec">{{ cmd.noSecLabel }}</tb-toggle-option> |
|||
<tb-toggle-option value="sec">{{ cmd.secLabel }}</tb-toggle-option> |
|||
</tb-toggle-header> |
|||
</div> |
|||
<ng-container [ngSwitch]="protocolType.value"> |
|||
<ng-template [ngSwitchCase]="'noSec'"> |
|||
<tb-markdown usePlainMarkdown containerClass="tb-command-code" |
|||
[data]=createMarkDownCommand(cmd.noSec)></tb-markdown> |
|||
</ng-template> |
|||
<ng-template [ngSwitchCase]="'sec'"> |
|||
<div *ngIf="cmd.sec !== 'Check documentation'; else checkDocumentation"> |
|||
<tb-markdown usePlainMarkdown containerClass="tb-command-code" |
|||
[data]=createMarkDownCommand(cmd.sec)></tb-markdown> |
|||
</div> |
|||
<ng-template #checkDocumentation> |
|||
<ng-container |
|||
*ngTemplateOutlet="seeDocumentation; context: |
|||
{doc: cmd.doc}"> |
|||
</ng-container> |
|||
</ng-template> |
|||
</ng-template> |
|||
</ng-container> |
|||
</div> |
|||
</ng-template> |
|||
|
|||
<ng-template #seeDocumentation let-doc="doc"> |
|||
<div class="tb-form-row no-border no-padding space-between"> |
|||
<div class="tb-font-14 tb-flex-1">{{ doc.text | translate }}</div> |
|||
<a mat-stroked-button color="primary" href="{{doc.href }}" target="_blank"> |
|||
<mat-icon>description</mat-icon> |
|||
{{ 'common.documentation' | translate }} |
|||
</a> |
|||
</div> |
|||
</ng-template> |
|||
@ -0,0 +1,177 @@ |
|||
/** |
|||
* Copyright © 2016-2023 The Thingsboard Authors |
|||
* |
|||
* Licensed under the Apache License, Version 2.0 (the "License"); |
|||
* you may not use this file except in compliance with the License. |
|||
* You may obtain a copy of the License at |
|||
* |
|||
* http://www.apache.org/licenses/LICENSE-2.0 |
|||
* |
|||
* Unless required by applicable law or agreed to in writing, software |
|||
* distributed under the License is distributed on an "AS IS" BASIS, |
|||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|||
* See the License for the specific language governing permissions and |
|||
* limitations under the License. |
|||
*/ |
|||
|
|||
@import "../../../../../scss/constants"; |
|||
|
|||
:host { |
|||
height: 100%; |
|||
max-height: 100vh; |
|||
display: grid; |
|||
grid-template-rows: min-content minmax(auto, 1fr) min-content; |
|||
|
|||
.tb-loader { |
|||
display: flex; |
|||
flex-direction: column; |
|||
align-items: center; |
|||
justify-content: center; |
|||
gap: 16px; |
|||
height: 300px; |
|||
max-height: 100%; |
|||
|
|||
.label { |
|||
margin-bottom: 0; |
|||
text-align: center; |
|||
} |
|||
} |
|||
|
|||
.status { |
|||
margin-left: 12px; |
|||
border-radius: 12px; |
|||
height: 24px; |
|||
line-height: 24px; |
|||
padding: 0 8px; |
|||
width: fit-content; |
|||
color: #198038; |
|||
background-color: rgba(25, 128, 56, 0.08); |
|||
font-size: 14px; |
|||
|
|||
&.inactive { |
|||
color: #d12730; |
|||
background-color: rgba(209, 39, 48, 0.08); |
|||
} |
|||
} |
|||
|
|||
.tb-hint-instruction { |
|||
border-radius: 6px; |
|||
background-color: rgba(48, 86, 128, 0.04); |
|||
padding: 6px 16px; |
|||
|
|||
.content { |
|||
vertical-align: middle; |
|||
} |
|||
} |
|||
|
|||
.tb-font-14 { |
|||
font-size: 14px; |
|||
} |
|||
|
|||
.tb-flex-1 { |
|||
flex: 1; |
|||
} |
|||
|
|||
.tb-form-table-body { |
|||
max-height: 108px; |
|||
min-height: 108px; |
|||
overflow-y: auto; |
|||
scrollbar-gutter: stable; |
|||
|
|||
.tb-form-table-row { |
|||
min-height: 38px; |
|||
} |
|||
} |
|||
|
|||
.tb-no-data-available { |
|||
.tb-no-data-bg { |
|||
min-height: 68px; |
|||
} |
|||
} |
|||
|
|||
.tb-install-instruction-text { |
|||
min-height: 42px; |
|||
} |
|||
|
|||
@media #{$mat-sm} { |
|||
width: 470px; |
|||
} |
|||
|
|||
@media #{$mat-gt-sm} { |
|||
width: 720px; |
|||
} |
|||
} |
|||
|
|||
:host-context(.mat-mdc-dialog-container) { |
|||
.tb-dialog-actions { |
|||
display: flex; |
|||
gap: 8px; |
|||
padding: 8px 16px; |
|||
} |
|||
|
|||
.mat-mdc-dialog-content { |
|||
max-height: 80vh; |
|||
padding: 16px; |
|||
} |
|||
} |
|||
|
|||
:host ::ng-deep { |
|||
.tb-markdown-view { |
|||
.tb-command-code { |
|||
.code-wrapper { |
|||
padding: 0; |
|||
pre[class*=language-] { |
|||
margin: 0; |
|||
background: #F3F6FA; |
|||
border-color: #305680; |
|||
padding-right: 38px; |
|||
overflow: scroll; |
|||
padding-bottom: 4px; |
|||
|
|||
&::-webkit-scrollbar { |
|||
width: 4px; |
|||
height: 4px; |
|||
} |
|||
} |
|||
} |
|||
button.clipboard-btn { |
|||
right: -2px; |
|||
p { |
|||
color: #305680; |
|||
} |
|||
p, div { |
|||
background-color: #F3F6FA; |
|||
} |
|||
div { |
|||
img { |
|||
display: none; |
|||
} |
|||
&:after { |
|||
content: ""; |
|||
position: initial; |
|||
display: block; |
|||
width: 18px; |
|||
height: 18px; |
|||
background: #305680; |
|||
mask-image: url(/assets/copy-code-icon.svg); |
|||
mask-repeat: no-repeat; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
.mdc-button__label > span { |
|||
.mat-icon { |
|||
vertical-align: text-bottom; |
|||
box-sizing: initial; |
|||
} |
|||
} |
|||
|
|||
.tabs-icon { |
|||
margin-right: 8px; |
|||
} |
|||
|
|||
.tb-form-panel.tb-tab-body { |
|||
padding: 16px 0 0; |
|||
} |
|||
} |
|||
@ -0,0 +1,222 @@ |
|||
///
|
|||
/// Copyright © 2016-2023 The Thingsboard Authors
|
|||
///
|
|||
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|||
/// you may not use this file except in compliance with the License.
|
|||
/// You may obtain a copy of the License at
|
|||
///
|
|||
/// http://www.apache.org/licenses/LICENSE-2.0
|
|||
///
|
|||
/// Unless required by applicable law or agreed to in writing, software
|
|||
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|||
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|||
/// See the License for the specific language governing permissions and
|
|||
/// limitations under the License.
|
|||
///
|
|||
|
|||
import { Component, Inject, NgZone, OnDestroy, OnInit } from '@angular/core'; |
|||
import { DialogComponent } from '@shared/components/dialog.component'; |
|||
import { select, Store } from '@ngrx/store'; |
|||
import { AppState } from '@core/core.state'; |
|||
import { Router } from '@angular/router'; |
|||
import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog'; |
|||
import { DeviceService } from '@core/http/device.service'; |
|||
import { |
|||
AttributeData, |
|||
AttributeScope, |
|||
AttributesSubscriptionCmd, |
|||
LatestTelemetry, |
|||
TelemetrySubscriber |
|||
} from '@shared/models/telemetry/telemetry.models'; |
|||
import { TelemetryWebsocketService } from '@core/ws/telemetry-websocket.service'; |
|||
import { EntityId } from '@shared/models/id/entity-id'; |
|||
import { EntityType } from '@shared/models/entity-type.models'; |
|||
import { selectPersistDeviceStateToTelemetry } from '@core/auth/auth.selectors'; |
|||
import { take } from 'rxjs/operators'; |
|||
import { |
|||
BasicTransportType, |
|||
DeviceTransportType, |
|||
deviceTransportTypeTranslationMap, |
|||
NetworkTransportType, |
|||
PublishTelemetryCommand |
|||
} from '@shared/models/device.models'; |
|||
import { ActionPreferencesPutUserSettings } from '@core/auth/auth.actions'; |
|||
import { coerceBooleanProperty } from '@angular/cdk/coercion'; |
|||
import { getOS } from '@core/utils'; |
|||
|
|||
export interface DeviceCheckConnectivityDialogData { |
|||
deviceId: EntityId; |
|||
afterAdd: boolean; |
|||
} |
|||
|
|||
@Component({ |
|||
selector: 'tb-device-check-connectivity-dialog', |
|||
templateUrl: './device-check-connectivity-dialog.component.html', |
|||
styleUrls: ['./device-check-connectivity-dialog.component.scss'] |
|||
}) |
|||
export class DeviceCheckConnectivityDialogComponent extends |
|||
DialogComponent<DeviceCheckConnectivityDialogComponent> implements OnInit, OnDestroy { |
|||
|
|||
loadedCommand = false; |
|||
|
|||
status: boolean; |
|||
|
|||
latestTelemetry: Array<AttributeData> = []; |
|||
|
|||
commands: PublishTelemetryCommand; |
|||
|
|||
allowTransportType = new Set<NetworkTransportType>(); |
|||
selectTransportType: NetworkTransportType; |
|||
|
|||
BasicTransportType = BasicTransportType; |
|||
DeviceTransportType = DeviceTransportType; |
|||
deviceTransportTypeTranslationMap = deviceTransportTypeTranslationMap; |
|||
|
|||
showDontShowAgain: boolean; |
|||
dialogTitle: string; |
|||
closeButtonLabel: string; |
|||
|
|||
notShowAgain = false; |
|||
|
|||
httpTabIndex = 0; |
|||
mqttTabIndex = 0; |
|||
coapTabIndex = 0; |
|||
|
|||
private telemetrySubscriber: TelemetrySubscriber; |
|||
|
|||
private currentTime = Date.now(); |
|||
|
|||
private transportTypes = [...Object.keys(BasicTransportType), ...Object.keys(DeviceTransportType)] as Array<NetworkTransportType>; |
|||
|
|||
constructor(protected store: Store<AppState>, |
|||
protected router: Router, |
|||
@Inject(MAT_DIALOG_DATA) private data: DeviceCheckConnectivityDialogData, |
|||
public dialogRef: MatDialogRef<DeviceCheckConnectivityDialogComponent>, |
|||
private deviceService: DeviceService, |
|||
private telemetryWsService: TelemetryWebsocketService, |
|||
private zone: NgZone) { |
|||
super(store, router, dialogRef); |
|||
|
|||
if (this.data.afterAdd) { |
|||
this.dialogTitle = 'device.connectivity.device-created-check-connectivity'; |
|||
this.closeButtonLabel = 'action.skip'; |
|||
this.showDontShowAgain = true; |
|||
} else { |
|||
this.dialogTitle = 'device.connectivity.check-connectivity'; |
|||
this.closeButtonLabel = 'action.close'; |
|||
this.showDontShowAgain = false; |
|||
} |
|||
} |
|||
|
|||
ngOnInit() { |
|||
this.loadCommands(); |
|||
this.subscribeToLatestTelemetry(); |
|||
} |
|||
|
|||
ngOnDestroy() { |
|||
super.ngOnDestroy(); |
|||
this.telemetrySubscriber?.complete(); |
|||
this.telemetrySubscriber?.unsubscribe(); |
|||
} |
|||
|
|||
close(): void { |
|||
if (this.notShowAgain && this.showDontShowAgain) { |
|||
this.store.dispatch(new ActionPreferencesPutUserSettings({ notDisplayConnectivityAfterAddDevice: true })); |
|||
this.dialogRef.close(null); |
|||
} else { |
|||
this.dialogRef.close(null); |
|||
} |
|||
} |
|||
|
|||
createMarkDownCommand(commands: string | string[]): string { |
|||
if (Array.isArray(commands)) { |
|||
const formatCommands: Array<string> = []; |
|||
commands.forEach(command => formatCommands.push(this.createMarkDownSingleCommand(command))); |
|||
return formatCommands.join(`\n<br />\n\n`); |
|||
} else { |
|||
return this.createMarkDownSingleCommand(commands); |
|||
} |
|||
} |
|||
|
|||
private createMarkDownSingleCommand(command: string): string { |
|||
return '```bash\n' + |
|||
command + |
|||
'{:copy-code}\n' + |
|||
'```'; |
|||
} |
|||
|
|||
private loadCommands() { |
|||
this.deviceService.getDevicePublishTelemetryCommands(this.data.deviceId.id).subscribe( |
|||
commands => { |
|||
this.commands = commands; |
|||
const commandsProtocols = Object.keys(commands); |
|||
this.transportTypes.forEach(transport => { |
|||
const findCommand = commandsProtocols.find(item => item.toUpperCase().startsWith(transport)); |
|||
if (findCommand) { |
|||
this.allowTransportType.add(transport); |
|||
} |
|||
}); |
|||
this.selectTransportType = this.allowTransportType.values().next().value; |
|||
this.selectTabIndexForUserOS(); |
|||
this.loadedCommand = true; |
|||
} |
|||
); |
|||
} |
|||
|
|||
private subscribeToLatestTelemetry() { |
|||
this.store.pipe(select(selectPersistDeviceStateToTelemetry)).pipe( |
|||
take(1) |
|||
).subscribe(persistToTelemetry => { |
|||
this.telemetrySubscriber = TelemetrySubscriber.createEntityAttributesSubscription( |
|||
this.telemetryWsService, this.data.deviceId, LatestTelemetry.LATEST_TELEMETRY, this.zone); |
|||
if (!persistToTelemetry) { |
|||
const subscriptionCommand = new AttributesSubscriptionCmd(); |
|||
subscriptionCommand.entityType = this.data.deviceId.entityType as EntityType; |
|||
subscriptionCommand.entityId = this.data.deviceId.id; |
|||
subscriptionCommand.scope = AttributeScope.SERVER_SCOPE; |
|||
subscriptionCommand.keys = 'active'; |
|||
this.telemetrySubscriber.subscriptionCommands.push(subscriptionCommand); |
|||
} |
|||
|
|||
this.telemetrySubscriber.subscribe(); |
|||
this.telemetrySubscriber.attributeData$().subscribe( |
|||
(data) => { |
|||
const telemetry = data.reduce<Array<AttributeData>>((accumulator, item) => { |
|||
if (item.key === 'active') { |
|||
this.status = coerceBooleanProperty(item.value); |
|||
} else if (item.lastUpdateTs > this.currentTime) { |
|||
accumulator.push(item); |
|||
} |
|||
return accumulator; |
|||
}, []); |
|||
this.latestTelemetry = telemetry.sort((a, b) => b.lastUpdateTs - a.lastUpdateTs); |
|||
} |
|||
); |
|||
}); |
|||
} |
|||
|
|||
private selectTabIndexForUserOS() { |
|||
const currentOS = getOS(); |
|||
switch (currentOS) { |
|||
case 'linux': |
|||
case 'android': |
|||
this.httpTabIndex = 2; |
|||
this.mqttTabIndex = 2; |
|||
this.coapTabIndex = 1; |
|||
break; |
|||
case 'macos': |
|||
case 'ios': |
|||
this.httpTabIndex = 1; |
|||
this.mqttTabIndex = 1; |
|||
break; |
|||
case 'windows': |
|||
this.httpTabIndex = 0; |
|||
this.mqttTabIndex = 0; |
|||
break; |
|||
default: |
|||
this.mqttTabIndex = this.commands.mqtt?.docker ? 3 : 0; |
|||
this.coapTabIndex = this.commands.coap?.docker ? 2 : 1; |
|||
} |
|||
} |
|||
|
|||
} |
|||
|
After Width: | Height: | Size: 1.7 KiB |
|
After Width: | Height: | Size: 3.3 KiB |
|
After Width: | Height: | Size: 607 B |
|
After Width: | Height: | Size: 214 B |
@ -0,0 +1,21 @@ |
|||
///
|
|||
/// Copyright © 2016-2023 The Thingsboard Authors
|
|||
///
|
|||
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|||
/// you may not use this file except in compliance with the License.
|
|||
/// You may obtain a copy of the License at
|
|||
///
|
|||
/// http://www.apache.org/licenses/LICENSE-2.0
|
|||
///
|
|||
/// Unless required by applicable law or agreed to in writing, software
|
|||
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|||
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|||
/// See the License for the specific language governing permissions and
|
|||
/// limitations under the License.
|
|||
///
|
|||
|
|||
type NestedKeyOf<ObjectType extends object> = |
|||
{[Key in keyof ObjectType & (string | number)]: ObjectType[Key] extends object |
|||
? `${Key}` | `${Key}.${NestedKeyOf<ObjectType[Key]> extends infer U extends string ? U : never}` |
|||
: `${Key}` |
|||
}[keyof ObjectType & (string | number)]; |
|||
Loading…
Reference in new issue