Initial commit

src/main/java/org/example/EventClient.java

@@ -0,0 +1,56 @@
+package org.example;
+
+import java.net.URI;
+import java.util.concurrent.Future;
+
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.client.WebSocketClient;
+
+public class EventClient
+{
+    public static void main(String[] args)
+    {
+        EventClient client = new EventClient();
+        URI uri = URI.create("ws://localhost:8080/events/");
+        try
+        {
+            client.run(uri);
+        }
+        catch (Throwable t)
+        {
+            t.printStackTrace(System.err);
+        }
+    }
+
+    public void run(URI uri) throws Exception
+    {
+        WebSocketClient client = new WebSocketClient();
+
+        try
+        {
+            client.start();
+            // The socket that receives events
+            EventEndpoint socket = new EventEndpoint();
+            // Attempt Connect
+            Future<Session> fut = client.connect(socket, uri);
+            // Wait for Connect
+            Session session = fut.get();
+
+            // Send a message
+            session.getRemote().sendString("Hello");
+
+            // Send another message
+            session.getRemote().sendString("Goodbye");
+
+            // Wait for other side to close
+            socket.awaitClosure();
+
+            // Close session
+            session.close();
+        }
+        finally
+        {
+            client.stop();
+        }
+    }
+}

src/main/java/org/example/EventEndpoint.java

@@ -0,0 +1,92 @@
+package org.example;
+
+import java.io.IOException;
+import java.util.Locale;
+import java.util.concurrent.CountDownLatch;
+
+import com.google.gson.Gson;
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.StatusCode;
+import org.eclipse.jetty.websocket.api.WebSocketAdapter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class EventEndpoint extends WebSocketAdapter
+{
+    private static final Logger LOG = LoggerFactory.getLogger(EventEndpoint.class);
+    private final CountDownLatch closureLatch = new CountDownLatch(1);
+
+    private Schafkopf schafkopf;
+    @Override
+    public void onWebSocketConnect(Session sess)
+    {
+        super.onWebSocketConnect(sess);
+        LOG.debug("Endpoint connected: {}", sess);
+        System.out.println("Endpoint connected:" + sess);
+
+        schafkopf = new Schafkopf(getSession());
+        try {
+            schafkopf.initializeCardDeck();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public void onWebSocketText(String message)
+    {
+        super.onWebSocketText(message);
+        LOG.debug("Received TEXT message: {}", message);
+        System.out.println("Received TEXT message:" + message);
+
+        if (message.toLowerCase(Locale.US).contains("bye"))
+        {
+            getSession().close(StatusCode.NORMAL, "Thanks");
+        }
+
+        if (message.toLowerCase(Locale.US).contains("startsimulation"))
+        {
+            try {
+                Gson gson = new Gson();
+                String jsonData = gson.toJson("Start");
+                getRemote().sendString(jsonData);
+
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        if (message.toLowerCase(Locale.US).contains("stopsimulation"))
+        {
+            try {
+                Gson gson = new Gson();
+                String jsonData = gson.toJson("Stop");
+                getRemote().sendString(jsonData);
+
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    @Override
+    public void onWebSocketClose(int statusCode, String reason)
+    {
+        super.onWebSocketClose(statusCode, reason);
+        LOG.debug("Socket Closed: [{}] {}", statusCode, reason);
+        closureLatch.countDown();
+    }
+
+    @Override
+    public void onWebSocketError(Throwable cause)
+    {
+        super.onWebSocketError(cause);
+        cause.printStackTrace(System.err);
+    }
+
+    public void awaitClosure() throws InterruptedException
+    {
+        LOG.debug("Awaiting closure from remote");
+        closureLatch.await();
+    }
+}

src/main/java/org/example/EventEndpointCreator.java

@@ -0,0 +1,13 @@
+package org.example;
+import org.eclipse.jetty.websocket.server.JettyServerUpgradeRequest;
+import org.eclipse.jetty.websocket.server.JettyServerUpgradeResponse;
+import org.eclipse.jetty.websocket.server.JettyWebSocketCreator;
+
+public class EventEndpointCreator implements JettyWebSocketCreator
+{
+    @Override
+    public Object createWebSocket(JettyServerUpgradeRequest jettyServerUpgradeRequest, JettyServerUpgradeResponse jettyServerUpgradeResponse)
+    {
+        return new EventEndpoint();
+    }
+}

src/main/java/org/example/EventServer.java

@@ -0,0 +1,77 @@
+package org.example;
+
+import java.net.URI;
+import java.time.Duration;
+
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerInitializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class EventServer
+{
+    private static final Logger LOG = LoggerFactory.getLogger(EventServer.class);
+
+    public static void main(String[] args) throws Exception
+    {
+        EventServer server = new EventServer();
+        server.setPort(8080);
+        server.start();
+        server.join();
+    }
+
+    private final Server server;
+    private final ServerConnector connector;
+
+    public EventServer()
+    {
+        server = new Server();
+        connector = new ServerConnector(server);
+        server.addConnector(connector);
+
+        // Setup the basic application "context" for this application at "/"
+        // This is also known as the handler tree (in jetty speak)
+        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
+        context.setContextPath("/");
+        server.setHandler(context);
+
+
+        // Configure specific websocket behavior
+        JettyWebSocketServletContainerInitializer.configure(context, (servletContext, wsContainer) ->
+        {
+            // Configure default max size
+            wsContainer.setMaxTextMessageSize(65535);
+            wsContainer.setIdleTimeout(Duration.ofDays(300000));
+            // Add websockets
+            wsContainer.addMapping("/events/*", new EventEndpointCreator());
+        });
+    }
+
+    public void setPort(int port)
+    {
+        connector.setPort(port);
+    }
+
+    public void start() throws Exception
+    {
+        server.start();
+    }
+
+    public URI getURI()
+    {
+        return server.getURI();
+    }
+
+    public void stop() throws Exception
+    {
+        server.stop();
+    }
+
+    public void join() throws InterruptedException
+    {
+        LOG.info("Use Ctrl+C to stop server");
+        server.join();
+    }
+}

src/main/java/org/example/Karte.java

@@ -0,0 +1,12 @@
+package org.example;
+
+public class Karte {
+    private int id;
+    Karte(int id){
+        this.id = id;
+    }
+
+    public int getId(){
+        return this.id;
+    }
+}

src/main/java/org/example/Schafkopf.java

@@ -0,0 +1,17 @@
+package org.example;
+import org.eclipse.jetty.websocket.api.Session;
+import com.google.gson.Gson;
+import java.io.IOException;
+
+public class Schafkopf {
+    private Karte[] deck;
+    private Session session;
+    Schafkopf(Session session){
+        this.session = session;
+    }
+    public void initializeCardDeck() throws IOException {
+        Gson gson = new Gson();
+        String jsonData = gson.toJson("Initialisiere Kartendeck");
+        session.getRemote().sendString(jsonData);
+    }
+}