Feature/147 Create a separate dockerized server

frosthaven_assistant/pubspec.lock

@@ -441,6 +441,13 @@ packages:
       url: "https://pub.dev"
     source: hosted
     version: "3.2.0"
+  frosthaven_assistant_server:
+    dependency: "direct main"
+    description:
+      path: "../frosthaven_assistant_server"
+      relative: true
+    source: path
+    version: "1.0.0"
   get_it:
     dependency: "direct main"
     description:

frosthaven_assistant/pubspec.yaml

@@ -64,6 +64,8 @@ dependencies:
       url: https://github.com/google/flutter-desktop-embedding.git
       path: plugins/window_size
   format: ^1.4.0
+  frosthaven_assistant_server:
+    path: ../frosthaven_assistant_server
 
 
 

frosthaven_assistant_server/.dockerignore

@@ -0,0 +1,8 @@
+.dockerignore
+Dockerfile
+build/
+.dart_tool/
+.git/
+.github/
+.gitignore
+.packages

frosthaven_assistant_server/.gitignore

@@ -0,0 +1,15 @@
+.dart_tool/
+build/
+
+doc/api/
+
+# IntelliJ
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# Mac
+.DS_Store
+
+

frosthaven_assistant_server/Dockerfile

@@ -0,0 +1,23 @@
+# Specify the Dart SDK base image version using dart:<version> (ex: dart:2.12)
+FROM dart:stable AS build
+
+# Resolve app dependencies.
+WORKDIR /app
+COPY pubspec.* ./
+RUN dart pub get
+
+# Copy app source code and AOT compile it.
+COPY . .
+# Ensure packages are still up-to-date if anything has changed
+RUN dart pub get --offline
+RUN dart compile exe lib/main.dart -o bin/server
+
+# Build minimal serving image from AOT-compiled `/server` and required system
+# libraries and configuration files stored in `/runtime/` from the build stage.
+FROM scratch
+COPY --from=build /runtime/ /
+COPY --from=build /app/bin/server /app/bin/
+
+# Start server.
+EXPOSE 4567
+CMD ["/app/bin/server"]

frosthaven_assistant_server/README.md

@@ -0,0 +1,15 @@
+Library and simple standalone dart server for X-Haven Assistant
+I have pushed the container to Docker Hub here:
+https://hub.docker.com/r/aschneem/x-haven-server
+
+This is currently a manual process and may not be up-to-date
+
+The pull command:
+```
+docker pull aschneem/x-haven-server
+```
+
+Running the container:
+```
+docker run -p 4567:4567 aschneem/x-haven-server
+```

frosthaven_assistant_server/analysis_options.yaml

@@ -0,0 +1,30 @@
+# This file configures the static analysis results for your project (errors,
+# warnings, and lints).
+#
+# This enables the 'recommended' set of lints from `package:lints`.
+# This set helps identify many issues that may lead to problems when running
+# or consuming Dart code, and enforces writing Dart using a single, idiomatic
+# style and format.
+#
+# If you want a smaller set of lints you can change this to specify
+# 'package:lints/core.yaml'. These are just the most critical lints
+# (the recommended set includes the core lints).
+# The core lints are also what is used by pub.dev for scoring packages.
+
+include: package:lints/recommended.yaml
+
+# Uncomment the following section to specify additional rules.
+
+# linter:
+#   rules:
+#     - camel_case_types
+
+# analyzer:
+#   exclude:
+#     - path/to/excluded/files/**
+
+# For more information about the core and recommended set of lints, see
+# https://dart.dev/go/core-lints
+
+# For additional information about configuring this file, see
+# https://dart.dev/guides/language/analysis-options

frosthaven_assistant_server/lib/game_server.dart

@@ -0,0 +1,230 @@
+
+import 'dart:convert';
+import 'dart:developer';
+import 'dart:io';
+import 'dart:typed_data';
+
+class StateUpdateMessage {
+  String indexString = "";
+  String description = "";
+  String data = "";
+  int index = 0;
+}
+
+abstract class GameServer {
+
+  final int serverVersion = 190;
+
+  ServerSocket? _serverSocket;
+  ServerSocket? get serverSocket {
+    return _serverSocket;
+  }
+  set serverSocket(ServerSocket? value){
+    _serverSocket = value;
+  }
+
+  bool _serverEnabled = false;
+  bool get serverEnabled {
+    return _serverEnabled;
+  }
+  set serverEnabled(bool value){
+    _serverEnabled = value;
+  }
+
+  String _leftOverMessage = "";
+  String get leftOverMessage{
+    return _leftOverMessage;
+  }
+  set leftOverMessage(String value){
+    _leftOverMessage = value;
+  }
+
+  void resetState();
+  void undoState();
+  void redoState();
+  void updateStateFromMessage(StateUpdateMessage message, Socket client);
+
+  void setNetworkMessage(String data);
+  void send(String data);
+  String currentStateMessage(String commandDescription);
+  Future<String> getConnectToIP();
+
+  void sendPing();
+  void addClientConnection(Socket client);
+  void removeClientConnection(Socket client);
+  void removeAllClientConnections();
+  void sendToOnly(String data, Socket client);
+  void sendToOthers(String data, Socket client);
+  void sendInitResponse(Socket client);
+
+
+  StateUpdateMessage parseStateUpdateMessage(String message) {
+    List<String> messageParts1 = message.split("Description:");
+    String indexString =
+        messageParts1[0].substring("Index:".length);
+    List<String> messageParts2 =
+        messageParts1[1].split("GameState:");
+    String description = messageParts2[0];
+    String data = messageParts2[1];
+    StateUpdateMessage result =  StateUpdateMessage();
+    result.indexString = indexString;
+    result.index = int.parse(indexString);
+    result.description = description;
+    result.data = data;
+    return result;
+  }
+
+  Future<void> startServerInternal(String ip, int port) async {
+    try {
+      serverSocket = await ServerSocket.bind(ip, port);
+      serverEnabled = true;
+      final ServerSocket server = serverSocket!;
+      String connectTo = await getConnectToIP();
+      String info =
+          'Server Online: IP: $connectTo, Port: ${server.port.toString()}';
+      log(info);
+      setNetworkMessage(info);
+      resetState();
+      send(currentStateMessage(""));
+      var subscriptions = server.listen((Socket client) {
+        handleConnection(client);
+      }, onError: (e) {
+        log('Server error: $e');
+        setNetworkMessage('Server error: ${e.toString()}');
+      });
+      sendPing();
+      await subscriptions.asFuture();
+    } catch (error) {
+      log('Server error: $error');
+      setNetworkMessage('Server error: ${error.toString()}');
+    }
+  }
+
+  void stopServer(String? error) {
+    if (serverSocket != null) {
+      log('Server Offline');
+      if (error != null) {
+        setNetworkMessage(error);
+      } else {
+        setNetworkMessage('Server Offline');
+      }
+
+      serverSocket!.close().catchError((error) {
+        log(error.toString());
+        return error;
+      });
+
+      removeAllClientConnections();
+    }
+    serverEnabled = false;
+    leftOverMessage = "";
+
+    resetState();
+  }
+
+  void handleConnection(Socket client) {
+    client.setOption(SocketOption.tcpNoDelay, true);
+    client.encoding = utf8;
+
+    String info = 'Connection from'
+        ' ${client.remoteAddress.address}:${client.remotePort}';
+    log(info);
+    setNetworkMessage(info);
+
+    addClientConnection(client);
+
+    // listen for events from the client
+    try {
+      client.listen(
+        // handle data from the client
+        (Uint8List data) async {
+          String message = utf8.decode(data);
+          message = leftOverMessage + message;
+          leftOverMessage = "";
+          processMessages(message, client);
+        },
+        // handle errors
+        onError: (error) {
+          log(error.toString());
+          setNetworkMessage(error.toString());
+          if (error is SocketException &&
+              (error.osError?.errorCode == 103 ||
+                  error.osError?.errorCode == 32)) {
+            stopServer(error.toString());
+          }
+        },
+        // handle the client closing the connection
+        onDone: () {
+          if (serverEnabled) {
+            removeClientConnection(client);
+            log('Client left');
+            setNetworkMessage('Client left.');
+          }
+        },
+      );
+    } catch (error) {
+      log(error.toString());
+      setNetworkMessage(error.toString());
+    }
+  }
+
+  void processMessages(String socketMessages, Socket client){
+    List<String> messages = socketMessages.split("S3nD:");
+          //handle
+          for (var message in messages) {
+            if (message.endsWith("[EOM]")) {
+              message = message.substring(0, message.length - "[EOM]".length);
+              if (message.startsWith("Index:")) {
+                handleIndexMessage(message, client);
+              } else if (message.startsWith("init")) {
+                handleInitMessage(message, client);
+              } else if (message.startsWith("undo")) {
+                handleUndoMessage();
+              } else if (message.startsWith("redo")) {
+                handleRedoMessage();
+              } else if (message.startsWith("pong")) {
+                handlePongMessage(client);
+              } else if (message.startsWith("ping")) {
+                handlePingMessage(client);
+              }
+            } else {
+              leftOverMessage = message;
+            }
+          }
+  }
+
+  void handleIndexMessage(String message, Socket client){
+    StateUpdateMessage parsedMessage = parseStateUpdateMessage(message);
+    updateStateFromMessage(parsedMessage, client);
+  }
+
+  void handleInitMessage(String message, Socket client){
+    List<String> initMessageParts = message.split("version:");
+    int version = int.parse(initMessageParts[1]);
+    if (version != serverVersion) {
+      //version mismatch
+      setNetworkMessage("Client version mismatch. Please update.");
+      sendToOnly(
+          "Error: Server Version is $serverVersion. client version is $version. Please update your client.",
+          client);
+    } else {
+      sendInitResponse(client);
+    }
+  }
+
+  void handleUndoMessage(){
+    log('Server Receive undo command');
+    undoState();
+  }
+  void handleRedoMessage(){
+    log('Server Receive redo command');
+    redoState();
+  }
+  void handlePongMessage(Socket client){
+    log('pong from ${client.remoteAddress}');
+  }
+  void handlePingMessage(Socket client) {
+    log('ping from ${client.remoteAddress}');
+    sendToOnly("pong", client);
+  }
+}

frosthaven_assistant_server/lib/main.dart

@@ -0,0 +1,7 @@
+import 'package:frosthaven_assistant_server/standalone_server.dart';
+
+void main() async {
+  StandaloneServer server = StandaloneServer();
+  print("Starting Server");
+  await server.startServerInternal("0.0.0.0", 4567);
+}