From b0ac577328213cd85de076bee66f2bc6065bbf19 Mon Sep 17 00:00:00 2001
From: aewens <aewens@tilde.center>
Date: Sat, 15 Jun 2019 19:09:03 -0400
Subject: [PATCH] Added logic describing app flow

---
 test_sock_gen.py | 111 +++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 102 insertions(+), 9 deletions(-)

diff --git a/test_sock_gen.py b/test_sock_gen.py
index e844ab6..7c352ca 100644
--- a/test_sock_gen.py
+++ b/test_sock_gen.py
@@ -1,11 +1,73 @@
 from abots.helpers import jsto, sha256, generator
 from core.parsers import parse_irc_message
 from socket import socket, timeout as sock_timeout
-from socket import AF_INET, SOCK_STREAM
+from socket import AF_INET, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR
 from ssl import wrap_socket
 from time import sleep
 from re import compile as regex
 
+"""
+
+Socket Flow:
+- Get new messages
+- Send messages to message queue
+- Repeat
+
+App Init Flow:
+- Initialize state
+- Start server(s)
+- Start their clients
+
+App Flow:
+- Get new server messages
+- Get new client messages
+- Repeat
+
+Message Queue Flow:
+- In FIFO order, get next queue entry
+- Dispatch entry to reducers queue as action
+- Repeat
+
+Reducers Flow:
+- In FIFO order, get next action
+- Send it to relevant reducer(s)
+- Change state of application if needed
+- Dispatch new state to hooks queue
+- Repeat
+
+Hooks Flow:
+- In FIFO order, get new state
+- Send it to relevant hooks(s)
+- Run side effects triggered by new state
+    - Send message(s) to socket(s)
+    - Send message(s) to logger queue
+    - Dispatch action(s) to database queue
+    - Dispatch action(s) to reducer(s)
+- Repeat
+
+Database Flow:
+- In FIFO order, get new action
+- Run action
+- Send status/result to sender
+- Repeat
+
+Logger Flow:
+- In FIFO order, get new log message
+- Determine log level
+- Log message against logger
+- Repeat
+
+ -> Servers -\                           /-> Reducer1 -\
+/             |-> Messages -> Reducers -+--> Redcuer2 --+-> State -> Listeners
+|-> Clients -/       ^           ^       \-> Reducer3 -/             |       |
+|                    |           |                                   v       v
+|                    |           |                                 Hook1   Hook2
+|                    |           |                                      \ /
+|                    |           |                                       v
+|____________________|___________|______________________________________/
+
+"""
+
 with open("settings.json", "r") as config:
     settings = jsto(config.read())
 
@@ -24,6 +86,7 @@ join = lambda chan: pack(f"JOIN {chan}")
 user = lambda name: pack(f"USER {name} - - -")
 nick = lambda name: pack(f"NICK {name}")
 iden = lambda pswd: pack(f"PRIVMSG NickServ :IDENTIFY {pswd}")
+mode = lambda target, flag: pack(f"MODE {target} {flag}")
 
 def clean(parameters, dirt=":"):
     params = parameters.partition(dirt)
@@ -32,6 +95,9 @@ def clean(parameters, dirt=":"):
 hooks = dict()
 listeners = dict()
 state = dict()
+sockets = dict()
+sockets["server"] = dict()
+sockets["clients"] = dict()
 
 channel_modes = dict()
 channel_modes["@"] = "secret"
@@ -126,17 +192,15 @@ def identify(cancel):
         return
     if meta.get("command") != "MODE": return
     if " " not in params: return
-    name, mode = clean(params).split(" ", 1)
-    if mode == "+r":
+    name, flag = clean(params).split(" ", 1)
+    if flag == "+r":
         cancel()
         subscribe_many("tilde", ["handle_332", "handle_333", "handle_353",
             "handle_366"])
+        sock.send(mode(name, "+B"))
         if "channels" not in state:
             state["channels"] = dict()
         channels = state["channels"]
-        bots = "#bots"
-        channels[bots] = dict()
-        sock.send(join(bots))
         for chan in auto:
             channels[chan] = dict()
             sock.send(join(chan))
@@ -184,9 +248,38 @@ def handle_366(cancel):
     chan = state["channels"][channel]
     print(chan)
 
-sock = wrap_socket(socket(AF_INET, SOCK_STREAM))
-sock.connect((host, port))
-subscribe_many("tilde", ["loading", "ping"])
+socket_servers = sockets["servers"]
+for server_type, servers in settings.get("servers", dict()).items():
+    if server_type not in socket_servers:
+        socket_servers[server_type] = dict()
+    socket_type_servers = socket_servers[server_type]
+    for server_name, server_info in servers.items():
+        server_full_name = "/".join([server_type, server_name])
+        server_sock = wrap_socket(socket(AF_INET, SOCK_STREAM))
+        server_sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+        server_host = server_info.get("host", "")
+        server_port = server_info.get("port", 0)
+        try:
+            server_sock.bind((server_host, server_port))
+        except (BrokenPipeError, OSError) as e:
+            continue
+        server_sock.setblocking(0)
+        server_sock.settimeout(0)
+        socket_type_server[server_name] = dict()server_sock
+        socket_type_server[server_name]["sock"] = server_sock
+        socket_type_server[server_name]["clients"] = dict()
+        server_clients = socket_type_server[server_name]["clients"]
+        for client_type, clients in server_info.get("clients", dict()).items():
+            if client_type not in server_clients:
+                server_clients[client_type] = dict()
+            socket_type_clients = server_clients[client_type]
+            for client_name, client_info in clients.items():
+                client_full_name = "/".join([client_type, client_name])
+                client_sock = wrap_socket(socket(AF_INET, SOCK_STREAM))
+                client_sock.connect((host, port))
+                socket_type_clients[client-name] = dict()
+                socket_type_clients[client-name]["sock"] = client_sock
+                #subscribe_many(client_type, ["loading", "ping"])
 
 while True:
     try: