You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@streampipes.apache.org by wi...@apache.org on 2020/11/28 12:39:39 UTC

[incubator-streampipes] branch dev updated: [STREAMPIPES-252] add mqtt transport protocol support to dataset adapters

This is an automated email from the ASF dual-hosted git repository.

wiener pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/incubator-streampipes.git


The following commit(s) were added to refs/heads/dev by this push:
     new b1a7af8  [STREAMPIPES-252] add mqtt transport protocol support to dataset adapters
b1a7af8 is described below

commit b1a7af8a67dc27851984b3b8f880a4a48f038ee0
Author: Patrick Wiener <wi...@fzi.de>
AuthorDate: Sat Nov 28 13:36:18 2020 +0100

    [STREAMPIPES-252] add mqtt transport protocol support to dataset adapters
---
 .../master/management/SourcesManagement.java       |   3 +-
 .../model/connect/adapter/AdapterDescription.java  |  16 +-
 .../manager/matching/DataSetGroundingSelector.java |  95 +++++--
 ui/src/app/core-model/gen/streampipes-model.ts     | 279 ++++++++++++++++++++-
 4 files changed, 368 insertions(+), 25 deletions(-)

diff --git a/streampipes-connect-container-master/src/main/java/org/apache/streampipes/connect/container/master/management/SourcesManagement.java b/streampipes-connect-container-master/src/main/java/org/apache/streampipes/connect/container/master/management/SourcesManagement.java
index 2a033e7..38f12ad 100644
--- a/streampipes-connect-container-master/src/main/java/org/apache/streampipes/connect/container/master/management/SourcesManagement.java
+++ b/streampipes-connect-container-master/src/main/java/org/apache/streampipes/connect/container/master/management/SourcesManagement.java
@@ -159,7 +159,8 @@ public class SourcesManagement {
         if (adapterDescription instanceof AdapterSetDescription) {
             ds = ((AdapterSetDescription) adapterDescription).getDataSet();
             EventGrounding eg = new EventGrounding();
-            eg.setTransportProtocol(SupportedProtocols.kafka());
+            eg.setTransportProtocols(Arrays.asList(SupportedProtocols.kafka(), SupportedProtocols.jms(),
+                    SupportedProtocols.mqtt()));
             eg.setTransportFormats(Arrays.asList(TransportFormatGenerator.getTransportFormat()));
             ((SpDataSet) ds).setSupportedGrounding(eg);
         } else {
diff --git a/streampipes-model/src/main/java/org/apache/streampipes/model/connect/adapter/AdapterDescription.java b/streampipes-model/src/main/java/org/apache/streampipes/model/connect/adapter/AdapterDescription.java
index be693ce..6be495e 100644
--- a/streampipes-model/src/main/java/org/apache/streampipes/model/connect/adapter/AdapterDescription.java
+++ b/streampipes-model/src/main/java/org/apache/streampipes/model/connect/adapter/AdapterDescription.java
@@ -29,10 +29,7 @@ import org.apache.streampipes.model.connect.rules.TransformationRuleDescription;
 import org.apache.streampipes.model.connect.rules.schema.SchemaTransformationRuleDescription;
 import org.apache.streampipes.model.connect.rules.stream.StreamTransformationRuleDescription;
 import org.apache.streampipes.model.connect.rules.value.ValueTransformationRuleDescription;
-import org.apache.streampipes.model.grounding.EventGrounding;
-import org.apache.streampipes.model.grounding.KafkaTransportProtocol;
-import org.apache.streampipes.model.grounding.SimpleTopicDefinition;
-import org.apache.streampipes.model.grounding.TransportProtocol;
+import org.apache.streampipes.model.grounding.*;
 import org.apache.streampipes.model.shared.annotation.TsModel;
 import org.apache.streampipes.model.staticproperty.StaticProperty;
 import org.apache.streampipes.model.util.Cloner;
@@ -43,6 +40,7 @@ import javax.persistence.Entity;
 import javax.persistence.FetchType;
 import javax.persistence.OneToMany;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 @Namespaces({"sp", "https://streampipes.org/vocabulary/v1/"})
@@ -102,9 +100,13 @@ public abstract class AdapterDescription extends NamedStreamPipesEntity {
         this.category = new ArrayList<>();
 
         // TODO move to another place
-        TransportProtocol tp = new KafkaTransportProtocol();
-        tp.setTopicDefinition(new SimpleTopicDefinition("bb"));
-        this.eventGrounding.setTransportProtocol(tp);
+        TransportProtocol tpKafka = new KafkaTransportProtocol();
+        TransportProtocol tpJms = new JmsTransportProtocol();
+        TransportProtocol tpMqtt = new MqttTransportProtocol();
+        tpKafka.setTopicDefinition(new SimpleTopicDefinition("bb"));
+        tpJms.setTopicDefinition(new SimpleTopicDefinition("cc"));
+        tpMqtt.setTopicDefinition(new SimpleTopicDefinition("dd"));
+        this.eventGrounding.setTransportProtocols(Arrays.asList(tpKafka,tpJms,tpMqtt));
 //        this.eventGrounding.setTransportFormats(Arrays.asList(Formats.jsonFormat()));
 
 
diff --git a/streampipes-pipeline-management/src/main/java/org/apache/streampipes/manager/matching/DataSetGroundingSelector.java b/streampipes-pipeline-management/src/main/java/org/apache/streampipes/manager/matching/DataSetGroundingSelector.java
index c4567ff..a14bffc 100644
--- a/streampipes-pipeline-management/src/main/java/org/apache/streampipes/manager/matching/DataSetGroundingSelector.java
+++ b/streampipes-pipeline-management/src/main/java/org/apache/streampipes/manager/matching/DataSetGroundingSelector.java
@@ -19,15 +19,15 @@ package org.apache.streampipes.manager.matching;
 
 import org.apache.commons.lang.RandomStringUtils;
 import org.apache.streampipes.config.backend.BackendConfig;
+import org.apache.streampipes.config.backend.SpProtocol;
 import org.apache.streampipes.manager.util.TopicGenerator;
 import org.apache.streampipes.model.SpDataSet;
+import org.apache.streampipes.model.grounding.*;
 import org.apache.streampipes.model.message.DataSetModificationMessage;
-import org.apache.streampipes.model.grounding.EventGrounding;
-import org.apache.streampipes.model.grounding.KafkaTransportProtocol;
-import org.apache.streampipes.model.grounding.TransportFormat;
-import org.apache.streampipes.model.grounding.TransportProtocol;
 
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.UUID;
 
 public class DataSetGroundingSelector {
 
@@ -38,18 +38,85 @@ public class DataSetGroundingSelector {
   }
 
   public DataSetModificationMessage selectGrounding() {
-    // TODO grounding negotiation
-    TransportProtocol protocol = new KafkaTransportProtocol(BackendConfig.INSTANCE.getKafkaHost(),
-            BackendConfig.INSTANCE.getKafkaPort(),
-            TopicGenerator.generateRandomTopic(),
-            BackendConfig.INSTANCE.getZookeeperHost(),
-            BackendConfig.INSTANCE.getZookeeperPort());
-    TransportFormat format = spDataSet.getSupportedGrounding().getTransportFormats().get(0);
-
     EventGrounding outputGrounding = new EventGrounding();
-    outputGrounding.setTransportProtocol(protocol);
-    outputGrounding.setTransportFormats(Arrays.asList(format));
+
+    String topic = TopicGenerator.generateRandomTopic();
+    TopicDefinition topicDefinition = new SimpleTopicDefinition(topic);
+
+    SpProtocol prioritizedProtocol =
+            BackendConfig.INSTANCE.getMessagingSettings().getPrioritizedProtocols().get(0);
+
+    if (isPrioritized(prioritizedProtocol, JmsTransportProtocol.class)) {
+      outputGrounding.setTransportProtocol(makeTransportProtocol(
+              BackendConfig.INSTANCE.getJmsHost(),
+              BackendConfig.INSTANCE.getJmsPort(),
+              topicDefinition,
+              JmsTransportProtocol.class
+      ));
+    } else if (isPrioritized(prioritizedProtocol, KafkaTransportProtocol.class)){
+      outputGrounding.setTransportProtocol(makeTransportProtocol(
+              BackendConfig.INSTANCE.getKafkaHost(),
+              BackendConfig.INSTANCE.getKafkaPort(),
+              topicDefinition,
+              KafkaTransportProtocol.class
+      ));
+    } else if (isPrioritized(prioritizedProtocol, MqttTransportProtocol.class)) {
+      outputGrounding.setTransportProtocol(makeTransportProtocol(
+              BackendConfig.INSTANCE.getMqttHost(),
+              BackendConfig.INSTANCE.getMqttPort(),
+              topicDefinition,
+              MqttTransportProtocol.class
+      ));
+    }
+
+    outputGrounding.setTransportFormats(Collections
+            .singletonList(spDataSet.getSupportedGrounding().getTransportFormats().get(0)));
+
+//    // TODO grounding negotiation
+//    TransportProtocol protocol = new KafkaTransportProtocol(BackendConfig.INSTANCE.getKafkaHost(),
+//            BackendConfig.INSTANCE.getKafkaPort(),
+//            TopicGenerator.generateRandomTopic(),
+//            BackendConfig.INSTANCE.getZookeeperHost(),
+//            BackendConfig.INSTANCE.getZookeeperPort());
+//    TransportFormat format = spDataSet.getSupportedGrounding().getTransportFormats().get(0);
+//
+//    EventGrounding outputGrounding = new EventGrounding();
+//    outputGrounding.setTransportProtocol(protocol);
+//    outputGrounding.setTransportFormats(Arrays.asList(format));
 
     return new DataSetModificationMessage(outputGrounding,RandomStringUtils.randomAlphanumeric(10));
   }
+
+  public static Boolean isPrioritized(SpProtocol prioritizedProtocol,
+                                      Class<?> protocolClass) {
+    return prioritizedProtocol.getProtocolClass().equals(protocolClass.getCanonicalName());
+  }
+
+  private static <T>T makeTransportProtocol(String hostname, int port, TopicDefinition topicDefinition,
+                                            Class<?> protocolClass) {
+    T tpOut = null;
+    if (protocolClass.equals(KafkaTransportProtocol.class)) {
+      KafkaTransportProtocol tp = new KafkaTransportProtocol();
+      tp.setKafkaPort(port);
+      fillTransportProtocol(tp, hostname, topicDefinition);
+      tpOut = (T) tp;
+    } else if (protocolClass.equals(JmsTransportProtocol.class)) {
+      JmsTransportProtocol tp = new JmsTransportProtocol();
+      tp.setPort(port);
+      fillTransportProtocol(tp, hostname, topicDefinition);
+      tpOut = (T) tp;
+    } else if (protocolClass.equals(MqttTransportProtocol.class)) {
+      MqttTransportProtocol tp = new MqttTransportProtocol();
+      tp.setPort(port);
+      fillTransportProtocol(tp, hostname, topicDefinition);
+      tpOut = (T) tp;
+    }
+    return tpOut;
+  }
+
+  private static void fillTransportProtocol(TransportProtocol protocol, String hostname,
+                                            TopicDefinition topicDefinition) {
+    protocol.setBrokerHostname(hostname);
+    protocol.setTopicDefinition(topicDefinition);
+  }
 }
diff --git a/ui/src/app/core-model/gen/streampipes-model.ts b/ui/src/app/core-model/gen/streampipes-model.ts
index e9e95be..712f6d4 100644
--- a/ui/src/app/core-model/gen/streampipes-model.ts
+++ b/ui/src/app/core-model/gen/streampipes-model.ts
@@ -19,10 +19,10 @@
 /* tslint:disable */
 /* eslint-disable */
 // @ts-nocheck
-// Generated using typescript-generator version 2.24.612 on 2020-11-10 15:19:54.
+// Generated using typescript-generator version 2.24.612 on 2020-11-25 23:55:30.
 
 export class AbstractStreamPipesEntity {
-    "@class": "org.apache.streampipes.model.base.NamedStreamPipesEntity" | "org.apache.streampipes.model.connect.adapter.AdapterDescription" | "org.apache.streampipes.model.connect.adapter.AdapterSetDescription" | "org.apache.streampipes.model.connect.adapter.GenericAdapterSetDescription" | "org.apache.streampipes.model.connect.adapter.SpecificAdapterSetDescription" | "org.apache.streampipes.model.connect.adapter.AdapterStreamDescription" | "org.apache.streampipes.model.connect.adapter.G [...]
+    "@class": "org.apache.streampipes.model.base.NamedStreamPipesEntity" | "org.apache.streampipes.model.connect.adapter.AdapterDescription" | "org.apache.streampipes.model.connect.adapter.AdapterSetDescription" | "org.apache.streampipes.model.connect.adapter.GenericAdapterSetDescription" | "org.apache.streampipes.model.connect.adapter.SpecificAdapterSetDescription" | "org.apache.streampipes.model.connect.adapter.AdapterStreamDescription" | "org.apache.streampipes.model.connect.adapter.G [...]
 
     static fromData(data: AbstractStreamPipesEntity, target?: AbstractStreamPipesEntity): AbstractStreamPipesEntity {
         if (!data) {
@@ -34,8 +34,27 @@ export class AbstractStreamPipesEntity {
     }
 }
 
+export class AccessibleSensorActuatorResource {
+    connectionInfo: string;
+    connectionType: string;
+    name: string;
+    type: string;
+
+    static fromData(data: AccessibleSensorActuatorResource, target?: AccessibleSensorActuatorResource): AccessibleSensorActuatorResource {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new AccessibleSensorActuatorResource();
+        instance.name = data.name;
+        instance.type = data.type;
+        instance.connectionInfo = data.connectionInfo;
+        instance.connectionType = data.connectionType;
+        return instance;
+    }
+}
+
 export class UnnamedStreamPipesEntity extends AbstractStreamPipesEntity {
-    "@class": "org.apache.streampipes.model.base.UnnamedStreamPipesEntity" | "org.apache.streampipes.model.connect.guess.GuessSchema" | "org.apache.streampipes.model.connect.rules.TransformationRuleDescription" | "org.apache.streampipes.model.connect.rules.value.ValueTransformationRuleDescription" | "org.apache.streampipes.model.connect.rules.value.AddTimestampRuleDescription" | "org.apache.streampipes.model.connect.rules.value.AddValueTransformationRuleDescription" | "org.apache.streamp [...]
+    "@class": "org.apache.streampipes.model.base.UnnamedStreamPipesEntity" | "org.apache.streampipes.model.connect.guess.GuessSchema" | "org.apache.streampipes.model.connect.rules.TransformationRuleDescription" | "org.apache.streampipes.model.connect.rules.value.ValueTransformationRuleDescription" | "org.apache.streampipes.model.connect.rules.value.AddTimestampRuleDescription" | "org.apache.streampipes.model.connect.rules.value.AddValueTransformationRuleDescription" | "org.apache.streamp [...]
     elementId: string;
 
     static fromData(data: UnnamedStreamPipesEntity, target?: UnnamedStreamPipesEntity): UnnamedStreamPipesEntity {
@@ -596,6 +615,21 @@ export class ApplicationLink extends UnnamedStreamPipesEntity {
     }
 }
 
+export class CPU {
+    arch: string;
+    cores: number;
+
+    static fromData(data: CPU, target?: CPU): CPU {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new CPU();
+        instance.cores = data.cores;
+        instance.arch = data.arch;
+        return instance;
+    }
+}
+
 export class Category {
     _id: string;
     _rev: string;
@@ -717,6 +751,21 @@ export class CreateNestedRuleDescription extends SchemaTransformationRuleDescrip
     }
 }
 
+export class Cuda {
+    cudaDriverVersion: string;
+    cudaRuntimeVersion: string;
+
+    static fromData(data: Cuda, target?: Cuda): Cuda {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new Cuda();
+        instance.cudaDriverVersion = data.cudaDriverVersion;
+        instance.cudaRuntimeVersion = data.cudaRuntimeVersion;
+        return instance;
+    }
+}
+
 export class CustomOutputStrategy extends OutputStrategy {
     "@class": "org.apache.streampipes.model.output.CustomOutputStrategy";
     availablePropertyKeys: string[];
@@ -751,6 +800,19 @@ export class CustomTransformOutputStrategy extends OutputStrategy {
     }
 }
 
+export class DISK {
+    diskTotal: number;
+
+    static fromData(data: DISK, target?: DISK): DISK {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new DISK();
+        instance.diskTotal = data.diskTotal;
+        return instance;
+    }
+}
+
 export class DashboardEntity extends UnnamedStreamPipesEntity {
     "@class": "org.apache.streampipes.model.dashboard.DashboardEntity" | "org.apache.streampipes.model.dashboard.DashboardWidgetModel" | "org.apache.streampipes.model.dashboard.VisualizablePipeline" | "org.apache.streampipes.model.datalake.DataExplorerWidgetModel";
     _id: string;
@@ -930,6 +992,13 @@ export class InvocableStreamPipesEntity extends NamedStreamPipesEntity {
     configured: boolean;
     correspondingPipeline: string;
     correspondingUser: string;
+    deploymentRunningInstanceId: string;
+    deploymentTargetNodeHostname: string;
+    deploymentTargetNodeId: string;
+    deploymentTargetNodePort: number;
+    elementEndpointHostname: string;
+    elementEndpointPort: number;
+    elementEndpointServiceName: string;
     inputStreams: SpDataStreamUnion[];
     staticProperties: StaticPropertyUnion[];
     statusInfoSettings: ElementStatusInfoSettings;
@@ -951,6 +1020,13 @@ export class InvocableStreamPipesEntity extends NamedStreamPipesEntity {
         instance.correspondingPipeline = data.correspondingPipeline;
         instance.correspondingUser = data.correspondingUser;
         instance.streamRequirements = __getCopyArrayFn(SpDataStream.fromDataUnion)(data.streamRequirements);
+        instance.elementEndpointHostname = data.elementEndpointHostname;
+        instance.elementEndpointPort = data.elementEndpointPort;
+        instance.deploymentTargetNodeId = data.deploymentTargetNodeId;
+        instance.deploymentTargetNodeHostname = data.deploymentTargetNodeHostname;
+        instance.deploymentTargetNodePort = data.deploymentTargetNodePort;
+        instance.deploymentRunningInstanceId = data.deploymentRunningInstanceId;
+        instance.elementEndpointServiceName = data.elementEndpointServiceName;
         instance.configured = data.configured;
         instance.uncompleted = data.uncompleted;
         return instance;
@@ -1092,6 +1168,25 @@ export class DeleteRuleDescription extends SchemaTransformationRuleDescription {
     }
 }
 
+export class Docker {
+    apiVersion: string;
+    hasDocker: boolean;
+    hasNvidiaRuntime: boolean;
+    serverVersion: string;
+
+    static fromData(data: Docker, target?: Docker): Docker {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new Docker();
+        instance.hasDocker = data.hasDocker;
+        instance.hasNvidiaRuntime = data.hasNvidiaRuntime;
+        instance.serverVersion = data.serverVersion;
+        instance.apiVersion = data.apiVersion;
+        return instance;
+    }
+}
+
 export class DomainPropertyProbability extends UnnamedStreamPipesEntity {
     "@class": "org.apache.streampipes.model.connect.guess.DomainPropertyProbability";
     domainProperty: string;
@@ -1580,6 +1675,23 @@ export class Frequency extends EventStreamQualityDefinition {
     }
 }
 
+export class GPU {
+    cudaCores: number;
+    hasGPU: boolean;
+    type: string;
+
+    static fromData(data: GPU, target?: GPU): GPU {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new GPU();
+        instance.hasGPU = data.hasGPU;
+        instance.cudaCores = data.cudaCores;
+        instance.type = data.type;
+        return instance;
+    }
+}
+
 export interface GenericAdapterDescription {
     eventSchema: EventSchema;
     formatDescription: FormatDescription;
@@ -1642,6 +1754,25 @@ export class GuessSchema extends UnnamedStreamPipesEntity {
     }
 }
 
+export class HardwareResource {
+    cpu: CPU;
+    disk: DISK;
+    gpu: GPU;
+    memory: MEM;
+
+    static fromData(data: HardwareResource, target?: HardwareResource): HardwareResource {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new HardwareResource();
+        instance.cpu = CPU.fromData(data.cpu);
+        instance.memory = MEM.fromData(data.memory);
+        instance.disk = DISK.fromData(data.disk);
+        instance.gpu = GPU.fromData(data.gpu);
+        return instance;
+    }
+}
+
 export class TransportProtocol extends UnnamedStreamPipesEntity {
     "@class": "org.apache.streampipes.model.grounding.TransportProtocol" | "org.apache.streampipes.model.grounding.JmsTransportProtocol" | "org.apache.streampipes.model.grounding.KafkaTransportProtocol" | "org.apache.streampipes.model.grounding.MqttTransportProtocol";
     brokerHostname: string;
@@ -1791,6 +1922,19 @@ export class ListOutputStrategy extends OutputStrategy {
     }
 }
 
+export class MEM {
+    memTotal: number;
+
+    static fromData(data: MEM, target?: MEM): MEM {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new MEM();
+        instance.memTotal = data.memTotal;
+        return instance;
+    }
+}
+
 export class MappingProperty extends StaticProperty {
     "@class": "org.apache.streampipes.model.staticproperty.MappingProperty" | "org.apache.streampipes.model.staticproperty.MappingPropertyUnary" | "org.apache.streampipes.model.staticproperty.MappingPropertyNary";
     mapsFromOptions: string[];
@@ -1948,6 +2092,93 @@ export class MqttTransportProtocol extends TransportProtocol {
     }
 }
 
+export class Node {
+    nodeInfo: NodeInfo;
+
+    static fromData(data: Node, target?: Node): Node {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new Node();
+        instance.nodeInfo = NodeInfo.fromData(data.nodeInfo);
+        return instance;
+    }
+}
+
+export class NodeBrokerInfo {
+    host: string;
+    port: number;
+
+    static fromData(data: NodeBrokerInfo, target?: NodeBrokerInfo): NodeBrokerInfo {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new NodeBrokerInfo();
+        instance.host = data.host;
+        instance.port = data.port;
+        return instance;
+    }
+}
+
+export class NodeInfo {
+    nodeBrokerInfo: NodeBrokerInfo;
+    nodeControllerId: string;
+    nodeControllerPort: number;
+    nodeMetadata: NodeMetadata;
+    nodeResources: NodeResources;
+    supportedPipelineElementAppIds: string[];
+
+    static fromData(data: NodeInfo, target?: NodeInfo): NodeInfo {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new NodeInfo();
+        instance.nodeControllerId = data.nodeControllerId;
+        instance.nodeControllerPort = data.nodeControllerPort;
+        instance.nodeMetadata = NodeMetadata.fromData(data.nodeMetadata);
+        instance.nodeBrokerInfo = NodeBrokerInfo.fromData(data.nodeBrokerInfo);
+        instance.nodeResources = NodeResources.fromData(data.nodeResources);
+        instance.supportedPipelineElementAppIds = __getCopyArrayFn(__identity<string>())(data.supportedPipelineElementAppIds);
+        return instance;
+    }
+}
+
+export class NodeMetadata {
+    nodeAddress: string;
+    nodeLocationTags: string[];
+    nodeModel: string;
+    nodeType: string;
+
+    static fromData(data: NodeMetadata, target?: NodeMetadata): NodeMetadata {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new NodeMetadata();
+        instance.nodeAddress = data.nodeAddress;
+        instance.nodeModel = data.nodeModel;
+        instance.nodeType = data.nodeType;
+        instance.nodeLocationTags = __getCopyArrayFn(__identity<string>())(data.nodeLocationTags);
+        return instance;
+    }
+}
+
+export class NodeResources {
+    accessibleSensorActuatorResource: AccessibleSensorActuatorResource[];
+    hardwareResource: HardwareResource;
+    softwareResource: SoftwareResource;
+
+    static fromData(data: NodeResources, target?: NodeResources): NodeResources {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new NodeResources();
+        instance.hardwareResource = HardwareResource.fromData(data.hardwareResource);
+        instance.softwareResource = SoftwareResource.fromData(data.softwareResource);
+        instance.accessibleSensorActuatorResource = __getCopyArrayFn(AccessibleSensorActuatorResource.fromData)(data.accessibleSensorActuatorResource);
+        return instance;
+    }
+}
+
 export class Notification {
     additionalInformation: string;
     description: string;
@@ -2056,6 +2287,31 @@ export class PipelineCategory {
     }
 }
 
+export class PipelineElementDockerContainer extends UnnamedStreamPipesEntity {
+    "@class": "org.apache.streampipes.model.node.PipelineElementDockerContainer";
+    containerName: string;
+    containerPorts: string[];
+    envVars: string[];
+    imageURI: string;
+    labels: { [index: string]: string };
+    serviceId: string;
+
+    static fromData(data: PipelineElementDockerContainer, target?: PipelineElementDockerContainer): PipelineElementDockerContainer {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new PipelineElementDockerContainer();
+        super.fromData(data, instance);
+        instance.imageURI = data.imageURI;
+        instance.containerName = data.containerName;
+        instance.serviceId = data.serviceId;
+        instance.containerPorts = __getCopyArrayFn(__identity<string>())(data.containerPorts);
+        instance.envVars = __getCopyArrayFn(__identity<string>())(data.envVars);
+        instance.labels = __getCopyObjectFn(__identity<string>())(data.labels);
+        return instance;
+    }
+}
+
 export class PipelineElementRecommendation {
     count: number;
     description: string;
@@ -2464,6 +2720,23 @@ export class SimpleTopicDefinition extends TopicDefinition {
     }
 }
 
+export class SoftwareResource {
+    docker: Docker;
+    kernelVersion: string;
+    os: string;
+
+    static fromData(data: SoftwareResource, target?: SoftwareResource): SoftwareResource {
+        if (!data) {
+            return data;
+        }
+        const instance = target || new SoftwareResource();
+        instance.os = data.os;
+        instance.kernelVersion = data.kernelVersion;
+        instance.docker = Docker.fromData(data.docker);
+        return instance;
+    }
+}
+
 export class SpDataStream extends NamedStreamPipesEntity {
     "@class": "org.apache.streampipes.model.SpDataStream" | "org.apache.streampipes.model.SpDataSet";
     category: string[];