Rfe/ric 979 distributed ping pong example (#56)

* DistributedPingPong commit

* Distributed Ping Pong testing

---------

Co-authored-by: Sandeep Pinninti <sandeep.pinninti@prod.hclpnp.com>

Author: 2 people

art-samples/DistributedPingPong/PingPongProtocol.art

@@ -0,0 +1,6 @@
+protocol PingPongProtocol{
+    in ping(`int`);
+    out ping(`int`);
+    in pong(`int`);
+    out pong(`int`);
+};

art-samples/DistributedPingPong/PingPongServer.art

@@ -0,0 +1,72 @@
+capsule PingPongServer : TCPServer {
+
+
+    [[rt::header_preface]]
+    `
+        #include <iostream>
+        using namespace std;
+
+    `
+    [[rt::impl_preface]]
+    `
+
+        #include <chrono>
+        #include <thread>
+        using namespace std;
+
+
+    `
+    
+    [[rt::decl]]
+    `
+        public:
+            bool injectPing = false;
+            virtual void init();
+    `
+    [[rt::impl]]
+    `
+             void PingPongServer::init(){
+                int ac = RTMain::argCount();
+                const char * const * av = RTMain::argStrings();
+                         
+                while( --ac > 0 ) {
+                    const char* arg = *++av;
+                    if( RTMemoryUtil::strcmp( arg, "-remotePort=", 12 ) == 0 )
+                        config.remotePort = RTMemoryUtil::atoi(*av + 12);
+                    if( RTMemoryUtil::strcmp( arg, "-port=", 6 ) == 0 )
+                            config.port = RTMemoryUtil::atoi(*av + 6);
+                    if( RTMemoryUtil::strcmp( arg, "-injectFirstPing", 16 ) == 0 )
+                        injectPing = true;
+                }
+                         
+                cout << "Incoming port: " << config.port << endl << flush;
+             }
+    `
+    service behavior port player: PingPongProtocol;
+    statemachine {
+        redefine _initial: initial -> WaitForRequest `
+        
+            CALLSUPER;
+            cout << "TCP server started!" << endl;
+
+            // Inject first signal
+            if (injectPing) {
+                cout << "Sleeping 1 second before injecting a signal ..." << endl;
+                chrono::seconds timespan(1);
+                this_thread::sleep_for(timespan);
+                cout << "Sleeping done" << endl;
+
+                RTMessage * msg = context()->newMsg();
+                int* data = new int(0);
+
+                msg->setData(data, &RTType_int);
+                msg->setSignal(PingPongProtocol::Base::rti_ping);
+                msg->setPriority(General);
+                msg->setDestination(this, &player, 0);
+                msg->internData();
+
+                context()->receive(msg, context());
+            }
+        `;
+    };
+};

art-samples/DistributedPingPong/Player.art

@@ -0,0 +1,36 @@
+capsule Player {
+    [[rt::decl]]
+    `
+        public: int count = 0;
+    `
+
+    service behavior port server~: PingPongProtocol;
+    behavior port timer : Timing;
+    statemachine {
+        state WaitForBall{
+            ping: on server.ping
+            `
+                bool b = true; // ping
+                count = *((int*) rtdata);
+                timer.informIn(RTTimespec(1, 0), &b, &RTType_bool);          
+            `;
+            pong: on server.pong
+            `
+                bool b = false; // pong
+                count = *((int*) rtdata);
+                timer.informIn(RTTimespec(1, 0), &b, &RTType_bool);
+            `;
+            timmer: on timer.timeout
+            `
+                bool isPing = *((bool*) rtdata);
+                if (isPing)
+                    server.pong(count + 1).send();
+                else
+                    server.ping(count + 1).send();
+
+            `;
+
+        };
+        initial -> WaitForBall;
+    };  
+};

art-samples/DistributedPingPong/README.md

@@ -0,0 +1,19 @@
+# pingpong-distributed
+A distributed [DevOps Code RealTime](https://www.hcl-software.com/devops-code-realtime) application consisting of two executables that send ping and pong messages back and forth. The applications communicate with each other using the library [TCP server](../TcpServer/).
+
+## Usage
+Start each application with command-line arguments specifying a local and remote port. For example:
+```
+Top.EXE -URTS_DEBUG=quit -port=15000 -remotePort=16000
+```
+
+In this case the started executable will listen for incoming messages on port 15000 and send outgoing messages to port 16000. The other application should then be started with the reversed arguments, i.e. with `-port=16000 -remotePort=15000`. It is assumed that both applications run on the same machine. If you want to run them on separate machines, edit `PingPongServer::init()` to add another command-line argument for specifying the remote hostname.
+
+Initially both applications will wait for each other to send the first event, so nothing will happen. There are several ways to make the ping pong game start:
+* pass the `-injectFirstPing` argument to one of applications. Then the first message will be injected programmatically from within the application. For example:
+```
+TOP.EXE -URTS_DEBUG=quit -port=15000 -remotePort=16000
+TOP.EXE -URTS_DEBUG=quit -port=16000 -remotePort=15000 -injectFirstPing
+```
+* inject either the "ping" or "pong" event on the "PingPongServer::player" port. You can do this from another application by using the JSON API provided by [TCP server](../TcpServer/).
+* attach to one of the applications using the Code RealTime and send the "timeout" event to the "Player::timer" port.

art-samples/DistributedPingPong/Top.art

@@ -0,0 +1,23 @@
+
+
+capsule TOP {
+
+    [[rt::impl]]
+    `
+#include <iostream>
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+    `
+    /* Ports */
+    /* Parts */
+    part player : Player;
+    part pingPongServer : PingPongServer;
+    /* Connectors */
+    connect   pingPongServer.player with player.server;
+    /* State Machine */
+    statemachine {
+        state State1;
+        initial -> State1 ;
+    };
+};

art-samples/DistributedPingPong/top.tcjs

@@ -0,0 +1,4 @@
+let tc = TCF.define(TCF.CPP_TRANSFORM);
+tc.topCapsule = 'TOP';
+tc.targetFolder = 'DistributedPingPong_target'; 
+tc.prerequisites = ['../TcpServer/tcpServerLib.tcjs'];