integrated tracing

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

@@ -26,7 +26,6 @@ public class Main {
         //new Thread(() -> nodeMainExecutor.execute(server, nodeConfiguration)) {{start();}};
 
 
-
      /*   System.out.println("---- STARTING sampleService0 ----");
         new Thread(() -> nodeMainExecutor.execute(new FakeServerNode("sampleService0", "sampleServiceNode0"), nodeConfiguration)) {{start();}};
 

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

@@ -8,6 +8,7 @@ import de.tudresden.inf.st.pnml.base.data.ClauseValuesDefinition;
 import de.tudresden.inf.st.pnml.engine.event.DiNeRosEvent;
 import de.tudresden.inf.st.pnml.engine.event.DiNeRosEventTypes;
 import de.tudresden.inf.st.pnml.engine.execution.TransitionHandler;
+import de.tudresden.inf.st.pnml.engine.tracing.TracePublishing;
 import de.tudresden.inf.st.pnml.engine.transform.PetriNetInitializer;
 import de.tudresden.inf.st.pnml.engine.transform.ServiceInstanceUtil;
 import de.tudresden.inf.st.pnml.jastadd.model.*;
@@ -41,13 +42,14 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
     public final PetriNet petriNet;
     protected BalloonMarking marking;
     public BalloonCallbackStorage callbackStorage;
-    protected ConnectedNode connectedNode;
+    public ConnectedNode connectedNode;
     protected InputSignalConnector inputSignalConnector;
     private boolean stopNode = false;
 
     private final Map<DinerosPlace, Publisher<String>> dinerosPublishers = new HashMap<>();
     private final Set<java.lang.String> responsePlaces = new HashSet<>();
     private final Set<java.lang.String> activeServerInstances = new HashSet<>();
+    public Publisher<String> tracePublisher = null;
 
     public DiNeRosNode(java.lang.String nodeName, PetriNet petriNet, java.lang.String rcHost, java.lang.String gcProtocol) {
         this.nodeName = nodeName;
@@ -125,7 +127,21 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
 
         switch (event.eventType) {
             case DiNeRosEventTypes.NOTIFICATION_MARKING_CHANGE:
+                onChangeInternal(signalFilteredTransitions);
+                break;
             case DiNeRosEventTypes.NOTIFICATION_SIGNAL_CHANGE:
+
+                Boolean newVal = false;
+
+                for(SignalConnection sc : this.inputSignalConnector.getSignalConnections()){
+                    if(sc.getId().equals(event.payload)){
+                        newVal = sc.getCurrentValue();
+                    }
+                }
+
+                TracePublishing.publish(TracePublishing.TraceTypeSignalChanged,
+                        this.getDefaultNodeName()+ " " + event.payload + " " + newVal,
+                        this.connectedNode, this.tracePublisher);
                 onChangeInternal(signalFilteredTransitions);
                 break;
             case DiNeRosEventTypes.NOTIFICATION_STARTUP_ENDED:
@@ -153,6 +169,8 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
         RosCommunicationUtil.publish(topicName, bmp.getBalloonMarking(0).getValue().getBytes(),
                 this.connectedNode, getPublisherByPlaceId(placeId));
         System.out.println("[DiNeROS-Node] [" + nodeName + "] Published msg: " + bmp.getBalloonMarking(0).getValue());
+        TracePublishing.publish(TracePublishing.TraceTypeTopicSend,
+                this.nodeName + " " + topicName + "-" + placeId, this.connectedNode, this.tracePublisher);
         bmp.getBalloonMarking(0).removeSelf();
         petriNet.flushTreeCache();
         this.notify(new DiNeRosEvent(DiNeRosEventTypes.NOTIFICATION_MARKING_CHANGE));
@@ -209,6 +227,9 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
             final StringServiceRequest request = serviceClient.newMessage();
             request.setInput(bmpSource.getBalloonMarking(0).getValue());
 
+            TracePublishing.publish(TracePublishing.TraceTypeServiceClientSend,
+                    self.nodeName + " " + serviceName + "-" + placeId, self.connectedNode, self.tracePublisher);
+
             serviceClient.call(request, new ServiceResponseListener<>() {
 
                 @Override
@@ -225,6 +246,10 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
                     } else {
                         self.notify(new DiNeRosEvent(DiNeRosEventTypes.NOTIFICATION_MARKING_CHANGE));
                     }
+
+                    TracePublishing.publish(TracePublishing.TraceTypeServiceClientReceive,
+                            self.nodeName + " " + serviceName + " " + cResPlaceId, self.connectedNode, self.tracePublisher);
+
                     // serviceClient.shutdown();
                 }
 
@@ -309,6 +334,13 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
         System.out.println("Calling onChangeInternal");
 
         TransitionSelectionResult res = onChange(enabledTransitions);
+
+        if(res.isFiringSelectionSuccess()){
+            TracePublishing.publish(TracePublishing.TraceTypeTransitionFired,
+                    this.getDefaultNodeName() + " " + res.asFiringSelectionSuccess().getTransition().getId(),
+                    this.connectedNode, this.tracePublisher);
+        }
+
         getTransitionSelectionResult(res);
     }
 
@@ -331,6 +363,9 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
         System.out.println("[" + nodeName + "] Setting Default Names for Objects");
         setDefaultNames();
 
+        System.out.println("[" + nodeName + "] Initializing tracing publisher.");
+        tracePublisher = connectedNode.newPublisher("DinerosTracing", String._TYPE);
+
         System.out.println("[" + nodeName + "] Initializing servers");
         // init service servers mechanism
         // is a 1:1 mapping, because there is always just on server
@@ -412,6 +447,8 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
                                 }
 
                                 System.out.println("[" + nodeName + "] Inserting request in " + selectedInstanceInId);
+                                TracePublishing.publish(TracePublishing.TraceTypeServiceServerReceive,
+                                        this.nodeName + " " + key + " " + selectedInstanceInId, this.connectedNode, this.tracePublisher);
                                 Place instanceEntryPlace = petriNet.getPlaceById(selectedInstanceInId);
                                 marking.resolveBalloonPlace(instanceEntryPlace).addBalloonMarking(
                                         new BalloonToken(request.getInput(), System.currentTimeMillis()));
@@ -419,6 +456,8 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
 
                                 while(activeServerInstances.contains(selectedInstanceOutId)){}
                                 System.out.println("[" + nodeName + "] Instance " + selectedInstanceOutId + " is ready to return");
+                                TracePublishing.publish(TracePublishing.TraceTypeServiceServerSend,
+                                        this.nodeName + " " + key + " " + selectedInstanceOutId, this.connectedNode, this.tracePublisher);
 
                                 for(java.lang.String entry : responsePlaces){
                                     if(entry.equals(selectedInstanceOutId)){
@@ -475,6 +514,9 @@ public abstract class DiNeRosNode extends AbstractNodeMain {
                         bmp.getBalloonMarkingList().add(bt);
                         petriNet.flushTreeCache();
 
+                        TracePublishing.publish(TracePublishing.TraceTypeTopicReceive,
+                                this.nodeName + " " + key + " " + placeId, this.connectedNode, this.tracePublisher);
+
                         if(!marking.callServiceIfRequest(bmp, self)){
                             this.notify(new DiNeRosEvent(DiNeRosEventTypes.NOTIFICATION_MARKING_CHANGE));
                         }

src/main/java/de/tudresden/inf/st/pnml/engine/tracing/TraceEntry.java

+package de.tudresden.inf.st.pnml.engine.tracing;
+
+public class TraceEntry {
+
+    public String traceType;
+    public String traceValue;
+
+    public TraceEntry(String traceType, String traceValue) {
+        this.traceType = traceType;
+        this.traceValue = traceValue;
+    }
+}

src/main/java/de/tudresden/inf/st/pnml/engine/tracing/TracePublishing.java

+package de.tudresden.inf.st.pnml.engine.tracing;
+
+import de.tudresden.inf.st.pnml.engine.ros.RosCommunicationUtil;
+import org.ros.node.ConnectedNode;
+import org.ros.node.topic.Publisher;
+
+public class TracePublishing {
+
+    public static java.lang.String TraceTypeTransitionFired = "transitionFired";
+    public static java.lang.String TraceTypeSignalChanged = "signalChanged";
+    public static java.lang.String TraceTypeTopicSend = "topicSend";
+    public static java.lang.String TraceTypeTopicReceive = "topicReceive";
+    public static java.lang.String TraceTypeServiceClientSend = "serviceClientSend";
+    public static java.lang.String TraceTypeServiceClientReceive = "serviceClientReceive";
+    public static java.lang.String TraceTypeServiceServerSend = "serviceServerSend";
+    public static java.lang.String TraceTypeServiceServerReceive = "serviceServerReceive";
+
+    public static void publish(java.lang.String traceType, java.lang.String traceValue, ConnectedNode connectedNode,
+                               Publisher<std_msgs.String> publisherObj) {
+        java.lang.String msgString = traceType + "," + traceValue;
+        RosCommunicationUtil.publish("DinerosTracing", msgString.getBytes(), connectedNode, publisherObj);
+    }
+}

src/main/java/de/tudresden/inf/st/pnml/engine/tracing/TracingNode.java

+package de.tudresden.inf.st.pnml.engine.tracing;
+
+import org.ros.namespace.GraphName;
+import org.ros.node.AbstractNodeMain;
+import org.ros.node.ConnectedNode;
+import org.ros.node.topic.Subscriber;
+import std_msgs.String;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class TracingNode extends AbstractNodeMain {
+
+    @Override
+    public GraphName getDefaultNodeName() {
+        return GraphName.of("DinerosTracingNode");
+    }
+
+    @Override
+    public void onStart(final ConnectedNode connectedNode) {
+
+        File f = new File("DinerosTrace-" + System.currentTimeMillis() + ".txt");
+
+        try {
+            if (f.createNewFile()) {
+                System.out.println("[Trace] Created trace file: " + f.getName());
+            } else {
+                System.out.println("[Trace] Trace file already exists: " + f.getName());
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        Subscriber<String> subscriber = connectedNode.newSubscriber("DinerosTracing", String._TYPE);
+
+        subscriber.addMessageListener(message -> {
+            java.lang.String[] splitEntry = message.getData().split(",");
+            updateTrace(new TraceEntry(splitEntry[0], splitEntry[1]), f);
+        }, 1000);
+
+    }
+
+    private synchronized void updateTrace(TraceEntry traceEntry, File traceFile){
+
+        try {
+            FileWriter writer = new FileWriter(traceFile.getName(), true);
+            java.lang.String line = System.currentTimeMillis() + " " +
+                    traceEntry.traceType + " " + traceEntry.traceValue;
+            writer.write(line + "\n");
+            writer.close();
+            System.out.println("[Trace] " + line);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

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

@@ -105,16 +105,16 @@ public class PetriNetInitializer {
                 //inputSignalConnector.ragconnectJavaRegisterConsumer("java://localhost:00/" + signalId,
                 //  bytes -> node.notify(DiNeRosNode.NOTIFICATION_SIGNAL_CHANGE));
 
-                inputSignalConnector.ragconnectJavaRegisterConsumer(signalId, bytes -> notifyOnSignalChange(node));
+                inputSignalConnector.ragconnectJavaRegisterConsumer(signalId, bytes -> notifyOnSignalChange(node, signalId));
             } else {
                 System.out.println("Skipping unused signal: " + signalId);
             }
         }
     }
 
-    public static void notifyOnSignalChange(DiNeRosNode node){
+    public static void notifyOnSignalChange(DiNeRosNode node, String signalId){
         System.out.println("NOTIFY ON SIGNAL CHANGE");
-        node.notify(new DiNeRosEvent(DiNeRosEventTypes.NOTIFICATION_SIGNAL_CHANGE));
+        node.notify(new DiNeRosEvent(DiNeRosEventTypes.NOTIFICATION_SIGNAL_CHANGE, signalId));
     }
 
     public void init(PetriNet petriNet, String host, String protocol, InputSignalConnector isc, DiNeRosNode node){