worked on callbacks, dineros node concept

build.gradle

@@ -27,6 +27,14 @@ repositories {
         name 'gitlab-maven'
         url 'https://git-st.inf.tu-dresden.de/api/v4/groups/jastadd/-/packages/maven'
     }
+    maven {
+        name 'rosjava-maven'
+        url "https://git-st.inf.tu-dresden.de/api/v4/projects/1106/packages/maven"
+    }
+    maven {
+        name 'rosjava-msg-maven'
+        url 'https://git-st.inf.tu-dresden.de/api/v4/projects/1108/packages/maven'
+    }
 }
 
 configurations {
@@ -56,8 +64,7 @@ dependencies {
     api group: 'fr.lip6.pnml', name: 'fr.lip6.pnml.framework.utils', version: '2.2.12'
     implementation group: 'org.apache.ws.commons.axiom', name: 'axiom-api', version: '1.2.22'
     implementation group: 'org.apache.ws.commons.axiom', name: 'axiom-impl', version: '1.2.22'
-    implementation group: 'com.thaiopensourc' +
-            'e', name: 'jing', version: '20091111'
+    implementation group: 'com.thaiopensource', name: 'jing', version: '20091111'
     implementation 'org.jetbrains:annotations:19.0.0'
     // https://mvnrepository.com/artifact/xalan/xalan
     implementation group: 'xalan', name: 'xalan', version: '2.7.2'
@@ -71,8 +78,31 @@ dependencies {
     jastadd2 "org.jastadd:jastadd:2.3.4"
     relast group: 'org.jastadd', name: 'relast', version: "${relast_version}"
     ecore files("libs/ecore2relast-0.1.jar")
- //   relast files("libs/relast.jar")
 
+    // ros java
+    compile 'org.ros.rosjava_core:rosjava:0.3.9'
+
+    // ros java subpackages
+    implementation 'org.ros.rosjava_core:apache_xmlrpc_server:0.3.8'
+    implementation 'org.ros.rosjava_core:apache_xmlrpc_common:0.3.8'
+    implementation 'org.ros.rosjava_core:apache_xmlrpc_client:0.3.8'
+    implementation 'org.ros.rosjava_core:rosjava_helpers:0.3.8'
+    implementation 'org.ros.rosjava_bootstrap:message_generation:0.3.3'
+
+    // ros java dependencies
+    implementation("com.google.guava:guava:31.0.1-jre")
+    implementation group: 'org.jboss.netty', name: 'netty', version: '3.2.10.Final'
+    implementation group: 'commons-codec', name: 'commons-codec', version: '1.15'
+    implementation group: 'commons-pool', name: 'commons-pool', version: '1.6'
+    implementation group: 'commons-httpclient', name: 'commons-httpclient', version: '3.1'
+    implementation group: 'org.apache.ws.commons.util', name: 'ws-commons-util', version: '1.0.2'
+    implementation group: 'dnsjava', name: 'dnsjava', version: '2.1.1'
+
+    // ros java messages
+    compile fileTree(include: ['std_msgs-0.5.11.jar'], dir: './libs')
+    compile fileTree(include: ['rosgraph_msgs-1.10.12.jar'], dir: './libs')
+
+    // testing
     testImplementation('org.junit.jupiter:junit-jupiter:5.8.2')
 
 }

src/main/jastadd/engine/balloonMarking/BalloonExecution.jadd

@@ -2,7 +2,12 @@ aspect BalloonExecution {
 
     public Optional<BalloonMarking> BalloonMarking.fireTransition(Transition transition, BalloonCallbackStorage callbackStorage, boolean requireFlush) {
 
-        if(enabledBalloonTransitions().isEmpty()) return Optional.empty();
+        if(!transition.asInputSignalTransition().getStaticTransitionInformation().isDefaultTransitionInformation()) return Optional.empty();
+
+        // synchronize marking modification to prevent concurrent modifications
+        synchronized(this){
+
+            if(!this.isBalloonEnabled(transition)) return Optional.empty();
 
             List<BalloonToken> inToken=new ArrayList<>();
 
@@ -33,6 +38,7 @@ aspect BalloonExecution {
                 // flush the entire marking tree
                 this.flushTreeCache();
             }
+        }
 
         return Optional.of(this);
     }
@@ -45,6 +51,14 @@ aspect BalloonExecution {
         return null;
     }
 
+    public Optional<BalloonMarking> BalloonMarking.fireTopicPublisherTransition(java.util.Random random, Transition transition, BalloonCallbackStorage callbackStorage, boolean requireFlush) {
+        return null;
+    }
+
+    public Optional<BalloonMarking> BalloonMarking.fireServiceServerTransition(java.util.Random random, Transition transition, BalloonCallbackStorage callbackStorage, boolean requireFlush) {
+        return null;
+    }
+
     public BalloonCallbackStorage PetriNet.initializeCallbackStorage() {
 
         BalloonCallbackStorage storage = new BalloonCallbackStorage();

src/main/java/de/tudresden/inf/st/pnml/engine/Main.java

@@ -14,7 +14,7 @@ public class Main {
 
     public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
 
-        String pnmlPath = "../pnml-relast-nets/src/main/resources/balloonTestNets/balloon-correct-2.pnml";
+        String pnmlPath = "../pnml-relast-nets/src/main/resources/balloonTestNets/balloon-correct-3.pnml";
         PetriNet petriNet = PnmlParser.parsePnml(pnmlPath).get(0);
 
         BalloonMarking bm = petriNet.initializeBalloonMarking();

src/main/java/de/tudresden/inf/st/pnml/engine/execution/TransitionCallback.java

@@ -4,6 +4,7 @@ import de.tudresden.inf.st.pnml.jastadd.model.BalloonToken;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public abstract class TransitionCallback {
@@ -12,6 +13,13 @@ public abstract class TransitionCallback {
 
     private String id;
     private int priority;
+    private List<String> params = new ArrayList<>();
+
+    public TransitionCallback(String id, int priority, List<String> params) {
+        this.id = id;
+        this.priority = priority;
+        this.params.addAll(params);
+    }
 
     public TransitionCallback(String id, int priority) {
         this.id = id;

src/main/java/de/tudresden/inf/st/pnml/engine/ros/DiNeRosDefaultNode.java

+package de.tudresden.inf.st.pnml.engine.ros;
+
+import de.tudresden.inf.st.pnml.jastadd.model.PetriNet;
+
+public class DiNeRosDefaultNode extends DiNeRosNode{
+
+    public DiNeRosDefaultNode(String nodeName, PetriNet petriNet) {
+        super(nodeName, petriNet);
+    }
+}

src/main/java/de/tudresden/inf/st/pnml/engine/ros/DiNeRosNode.java

+package de.tudresden.inf.st.pnml.engine.ros;
+
+import de.tudresden.inf.st.pnml.base.constants.PnmlConstants;
+import de.tudresden.inf.st.pnml.engine.transform.TopicTransformer;
+import de.tudresden.inf.st.pnml.jastadd.model.BalloonCallbackStorage;
+import de.tudresden.inf.st.pnml.jastadd.model.BalloonMarking;
+import de.tudresden.inf.st.pnml.jastadd.model.PetriNet;
+import de.tudresden.inf.st.pnml.jastadd.model.Transition;
+import org.ros.namespace.GraphName;
+import org.ros.node.AbstractNodeMain;
+import org.ros.node.ConnectedNode;
+import org.ros.node.topic.Subscriber;
+import org.xml.sax.SAXException;
+import std_msgs.String;
+
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public abstract class DiNeRosNode extends AbstractNodeMain {
+
+    public final java.lang.String nodeName;
+    public final PetriNet petriNet;
+    private BalloonMarking marking;
+    private BalloonCallbackStorage callbackStorage;
+    private final Map<java.lang.String, DiNeRosSubscriber> dinerosSubscribers = new HashMap<>();
+
+    public DiNeRosNode(java.lang.String nodeName, PetriNet petriNet){
+        this.nodeName = nodeName;
+        this.petriNet = petriNet;
+        try {
+            marking = petriNet.initializeBalloonMarking();
+            callbackStorage = petriNet.initializeCallbackStorage();
+        } catch (IOException | SAXException | ParserConfigurationException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public GraphName getDefaultNodeName() {
+        return GraphName.of(nodeName);
+    }
+
+    @Override
+    public void onStart(final ConnectedNode connectedNode) {
+
+        int inCount = 0;
+
+        for(Transition t : petriNet.allTransitions()){
+            if(t.asInputSignalTransition().getStaticTransitionInformation().getType().equals(PnmlConstants.TOPIC_SUBSCRIBER)
+                    || t.asInputSignalTransition().getStaticTransitionInformation().getType().equals(PnmlConstants.TRANSITION_TYPE_TOPIC_LIMITED_OUT)
+                    || t.asInputSignalTransition().getStaticTransitionInformation().getType().equals(PnmlConstants.TRANSITION_TYPE_TOPIC_UNLIMITED_OUT)){
+
+                Subscriber<String> subscriber = connectedNode.newSubscriber(t.asInputSignalTransition()
+                        .getStaticTransitionInformation().asTopicTransitionInformation().getTopic(), std_msgs.String._TYPE);
+
+                int finalInCount = inCount;
+                subscriber.addMessageListener(message -> {
+
+                    List<java.lang.String> addedElementIds = new ArrayList<>();
+                    TopicTransformer.includeSubscriberInstance(petriNet, t.asInputSignalTransition()
+                            .getStaticTransitionInformation().getSubNet(), java.lang.String.valueOf(finalInCount), addedElementIds);
+
+                    for (Map.Entry<java.lang.String, DiNeRosSubscriber> entry : dinerosSubscribers.entrySet()) {
+                        if(entry.getKey().equals(t.asInputSignalTransition().getStaticTransitionInformation().getSubNet())){
+                            entry.getValue().execute(marking, callbackStorage, petriNet, t.asInputSignalTransition().getStaticTransitionInformation().getSubNet());
+                            TopicTransformer.removeSubscriberInstance(petriNet, addedElementIds);
+                            break;
+                        }
+                    }
+                });
+
+                inCount++;
+            }
+        }
+
+    }
+
+    public Map<java.lang.String, DiNeRosSubscriber> getDinerosSubscribers() {
+        return dinerosSubscribers;
+    }
+}

src/main/java/de/tudresden/inf/st/pnml/engine/ros/DiNeRosSubscriber.java

+package de.tudresden.inf.st.pnml.engine.ros;
+
+import de.tudresden.inf.st.pnml.jastadd.model.BalloonCallbackStorage;
+import de.tudresden.inf.st.pnml.jastadd.model.BalloonMarking;
+import de.tudresden.inf.st.pnml.jastadd.model.PetriNet;
+
+public interface DiNeRosSubscriber {
+
+    public boolean execute(BalloonMarking balloonMarking, BalloonCallbackStorage balloonCallbackStorage, PetriNet petriNet, String subnet);
+}

src/main/java/de/tudresden/inf/st/pnml/engine/ros/RosCommunicationUtil.java

+package de.tudresden.inf.st.pnml.engine.ros;
+
+import de.tudresden.inf.st.pnml.jastadd.model.BalloonMarking;
+import de.tudresden.inf.st.pnml.jastadd.model.PetriNet;
+import de.tudresden.inf.st.pnml.jastadd.model.Transition;
+import org.ros.node.ConnectedNode;
+import org.ros.node.topic.Publisher;
+import org.ros.node.topic.Subscriber;
+import std_msgs.String;
+
+import java.nio.charset.StandardCharsets;
+import java.util.function.BiConsumer;
+
+import org.ros.message.MessageListener;
+
+public class RosCommunicationUtil {
+
+    public static boolean publish(java.lang.String topic, byte[] msgContent, ConnectedNode node){
+
+        System.out.println("Publishing new message to " + topic);
+        Publisher<std_msgs.String> pub = node.newPublisher(topic, std_msgs.String._TYPE);
+
+        if(pub == null){
+            while(true){
+                if(node != null){
+                    break;
+                }
+            }
+
+            std_msgs.String msg = pub.newMessage();
+            java.lang.String s = new java.lang.String(msgContent, StandardCharsets.UTF_8);
+            msg.setData(s);
+            pub.publish(msg);
+
+            return true;
+        }
+        return false;
+    }
+
+    public static Subscriber listen(java.lang.String topic, ConnectedNode node, Transition t, PetriNet pn, BalloonMarking bm){
+
+        Subscriber<String> subscriber = node.newSubscriber(topic, std_msgs.String._TYPE);
+  //      subscriber.addMessageListener(message -> callback.accept(topic, message.getData().getBytes()));
+
+        subscriber.addMessageListener(message -> {
+
+
+
+        });
+
+        return subscriber;
+
+    }
+}

src/main/java/de/tudresden/inf/st/pnml/engine/transform/ServiceTransformer.java

+package de.tudresden.inf.st.pnml.engine.transform;
+
+public class ServiceTransformer {
+}

src/main/java/de/tudresden/inf/st/pnml/engine/transform/TopicTransformer.java

+package de.tudresden.inf.st.pnml.engine.transform;
+
+import de.tudresden.inf.st.pnml.base.constants.PnmlConstants;
+import de.tudresden.inf.st.pnml.jastadd.model.*;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TopicTransformer {
+
+    public static PetriNet includeSubscriberInstance(PetriNet petriNet, String subnet, String suffix, List<String> addedElementIds){
+
+        Page topPage = petriNet.getPage(0);
+
+        // Elements
+        for (Place p : getPlacesBySubnet(petriNet, subnet)) {
+
+            OutputSignalPlace copy = getOutputSignalPlace();
+            copy.setId(p.getId() + "-" + suffix);
+            copy.setToolspecificList(p.getToolspecificList().treeCopy());
+            copy.getName().setText(p.getName().getText());
+            copy.setNodeGraphics(p.getNodeGraphics().treeCopy());
+
+            // copy initial marking of places
+            PTMarking m = new PTMarking();
+            m.setText(p.getInitialMarking().getText());
+
+            PlaceInformation pi = new PlaceInformation();
+            pi.setSubNet(p.asOutputSignalPlace().getStaticPlaceInformation().getSubNet() + "-" + suffix);
+            pi.setLocation(p.asOutputSignalPlace().getStaticPlaceInformation().getLocation());
+            pi.setInstance(p.asOutputSignalPlace().getStaticPlaceInformation().getInstance());
+            pi.setType(p.asOutputSignalPlace().getStaticPlaceInformation().getType());
+
+            copy.setMutualPlaceInformation(pi);
+
+            topPage.addObject(copy);
+            addedElementIds.add(copy.getId());
+        }
+
+        petriNet.flushTreeCache();
+
+        for (Transition t : getTransitionsBySubnet(petriNet, subnet)) {
+            InputSignalTransition copy = getInputSignalTransition();
+            copy.setId(t.getId() + "-" + suffix);
+            copy.getName().setText(t.getName().getText());
+            copy.setMutualInputSignalBindingList(t.asInputSignalTransition().getMutualInputSignalBindingList().treeCopy());
+            copy.getName().setText(t.getName().getText());
+            copy.setToolspecificList(t.getToolspecificList().treeCopy());
+            copy.setNodeGraphics(t.getNodeGraphics().treeCopy());
+
+            TransitionInformation ti = new DefaultTransitionInformation();
+            ti.setType(t.asInputSignalTransition().getStaticTransitionInformation().getType());
+            ti.setSubNet(t.asInputSignalTransition().getStaticTransitionInformation().getSubNet() + "-" + suffix);
+            ti.setLocation(t.asInputSignalTransition().getStaticTransitionInformation().getLocation());
+            ti.setInstance(t.asInputSignalTransition().getStaticTransitionInformation().getInstance());
+            copy.setMutualTransitionInformation(ti);
+
+            topPage.addObject(copy);
+            addedElementIds.add(copy.getId());
+        }
+
+        petriNet.flushTreeCache();
+
+        // Arcs
+        for (Arc a : getInnerAndBorderSubnetArcs(petriNet, subnet)) {
+
+            Arc newArc = a.treeCopy();
+
+            String sourceId = a.getSource().getId() + "-" + suffix;
+            newArc.setSource((Node) getPnObjectByID(petriNet, sourceId));
+
+            String targetId = a.getTarget().getId() + "-" + suffix;
+
+            if(a.getTarget().isTransitionNode()){
+                if(!a.getTarget().asTransitionNode().asTransition().asInputSignalTransition().getStaticTransitionInformation().getSubNet().equals(subnet)){
+                    targetId = a.getTarget().getId();
+                }
+            }
+
+            if(a.getTarget().isPlaceNode()){
+                if(!a.getTarget().asPlaceNode().asPlace().asOutputSignalPlace().getStaticPlaceInformation().getSubNet().equals(subnet)){
+                    targetId = a.getTarget().getId();
+                }
+            }
+
+            newArc.setTarget((Node) getPnObjectByID(petriNet, targetId));
+            newArc.setId(sourceId + "-to-" + targetId);
+
+            topPage.addObject(newArc);
+            addedElementIds.add(newArc.getId());
+        }
+
+        // TODO: references
+
+        petriNet.flushTreeCache();
+
+        return petriNet;
+    }
+
+    public static PetriNet removeSubscriberInstance(PetriNet petriNet, List<String> addedElementIds){
+
+        for(String id : addedElementIds){
+            getPnObjectByID(petriNet, id).removeSelf();
+        }
+
+        petriNet.flushTreeCache();
+        return petriNet;
+    }
+
+    private static Set<Arc> getInnerAndBorderSubnetArcs(PetriNet petriNet, String subnet) {
+
+        Set<Arc> arcs = new HashSet<>();
+
+        for (Arc a : petriNet.allArcs()) {
+
+            if(a.getTarget().isTransitionNode() && a.getSource().isPlaceNode()){
+
+                if(a.getSource().asPlaceNode().asPlace().asOutputSignalPlace().getStaticPlaceInformation().getSubNet().equals(subnet)){
+                    arcs.add(a);
+                }
+
+            } else {
+                if(a.getSource().asTransitionNode().asTransition().asInputSignalTransition().getStaticTransitionInformation().getSubNet().equals(subnet)){
+                    arcs.add(a);
+                }
+            }
+        }
+
+        return arcs;
+    }
+
+    private static InputSignalTransition getInputSignalTransition(){
+
+        PetriNet templateNet = PnmlParser.parsePnml(System.getProperty("user.dir") + "/src/main/resources/elements/InputSignalTransition.pnml").get(0);
+
+        for(Transition t : templateNet.allTransitions()){
+            if(t.getId().equals("InputSignalTransition")){
+                return t.asInputSignalTransition();
+            }
+        }
+
+        return null;
+    }
+
+    private static OutputSignalPlace getOutputSignalPlace(){
+
+        PetriNet templateNet = PnmlParser.parsePnml(System.getProperty("user.dir") + "/src/main/resources/elements/OutputSignalPlace.pnml").get(0);
+
+        for(Place p : templateNet.allPlaces()){
+            if(p.getId().equals("OutputSignalPlace")){
+                return p.asOutputSignalPlace();
+            }
+        }
+
+        return null;
+    }
+
+    private static PnObject getPnObjectByID(PetriNet petriNet, String Id) {
+
+        for (PnObject po : petriNet.allObjects()) {
+            if (po.getId().equals(Id)) {
+                return po;
+            }
+        }
+
+        return null;
+    }
+
+    private static Set<Place> getPlacesBySubnet(PetriNet petriNet, String subnet) {
+
+        Set<Place> places = new HashSet<>();
+
+        for (Place p : petriNet.allPlaces()) {
+            if (p.asOutputSignalPlace().getStaticPlaceInformation().getSubNet().equals(subnet)) {
+                places.add(p);
+            }
+        }
+
+        return places;
+    }
+
+    private static Set<Transition> getTransitionsBySubnet(PetriNet petriNet, String subnet) {
+
+        Set<Transition> transitions = new HashSet<>();
+
+        for (Transition t : petriNet.allTransitions()) {
+            if (t.asInputSignalTransition().getStaticTransitionInformation().getSubNet().equals(subnet)) {
+                transitions.add(t);
+            }
+        }
+
+        return transitions;
+    }
+
+    private static Set<RefPlace> getRefPlaceBySubnet(PetriNet petriNet, String subnet) {
+
+        Set<RefPlace> places = new HashSet<>();
+
+        for (RefPlace rp : petriNet.allRefPlaces()) {
+            if (rp.getSubNet().equals(subnet)) {
+                places.add(rp);
+            }
+        }
+
+        return places;
+    }
+
+    private static Set<RefTransition> getRefTransitionBySubnet(PetriNet petriNet, String subnet) {
+
+        Set<RefTransition> transitions = new HashSet<>();
+
+        for (RefTransition rt : petriNet.allRefTransitions()) {
+            if (rt.getSubNet().equals(subnet)) {
+                transitions.add(rt);
+            }
+        }
+
+        return transitions;
+    }
+}

src/main/resources/elements/InputSignalTransition.pnml

+<pnml xmlns="http://www.pnml.org/version-2009/grammar/pnml">
+    <net id="TopicPublisherTemplate" type ="http://www.pnml.org/version-2009/grammar/ptnet">
+        <name>
+            <text>InputSignalTransitionNet</text>
+        </name>
+        <page id="InputSignalTransitionPage">
+            <transition id="InputSignalTransition">
+                <toolspecific tool="de.tudresden.inf.st.pnml.distributedPN" version="0.1">
+                    <location>none</location>
+                    <subnet>none</subnet>
+                    <type>discreteTransitionType</type>
+                    <inputsignalbindings>
+                    </inputsignalbindings>
+                    <inputsignalclause></inputsignalclause>
+                </toolspecific>
+                <name>
+                    <text>ServiceClientOutputTransition</text>
+                    <graphics>
+                        <offset x="0" y="0" />
+                    </graphics>
+                </name>
+                <graphics>
+                    <position x="0" y="0"/>
+                </graphics>
+            </transition>
+
+        </page>
+    </net>
+</pnml>
\ No newline at end of file

src/main/resources/elements/OutputSignalPlace.pnml

+<pnml xmlns="http://www.pnml.org/version-2009/grammar/pnml">
+    <net id="TopicPublisherTemplate" type ="http://www.pnml.org/version-2009/grammar/ptnet">
+        <name>
+            <text>OutputSignalPlaceNet</text>
+        </name>
+        <page id="OutputSignalPlacePage">
+            <place id="OutputSignalPlace">
+                <toolspecific tool="de.tudresden.inf.st.pnml.distributedPN" version="0.1">
+                    <location>none</location>
+                    <subnet>none</subnet>
+                    <type>discretePlaceType</type>
+                    <outputsignalbindings>
+                    </outputsignalbindings>
+                </toolspecific>
+                <name>
+                    <text>ServiceTogglePlace</text>
+                    <graphics>
+                        <offset x="0" y="0" />
+                    </graphics>
+                </name>
+                <initialMarking>
+                    <text>0</text>
+                </initialMarking>
+                <graphics>
+                    <position x="0" y="0"/>
+                </graphics>
+            </place>
+        </page>
+    </net>
+</pnml>
\ No newline at end of file