meshchat 0.8.0 → 0.10.0

data/lib/meshchat/network/message/emote.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class Emote < Chat
+      end
+    end
+  end
+end

data/lib/meshchat/network/message/factory.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class Factory
+        # The left side of this map is all the
+        # lowercase un-underscored variant of
+        # the constant name
+        #
+        # e.g.: NODE_LIST == 'nodelist'
+        TYPES = {
+          CHAT           => Chat,
+          EMOTE          => Emote,
+          WHISPER        => Whisper,
+          DISCONNECT     => Disconnect,
+          PING           => Ping,
+          PING_REPLY     => PingReply,
+          NODE_LIST      => NodeList,
+          NODE_LIST_DIFF => NodeListDiff,
+          NODE_LIST_HASH => NodeListHash
+        }.freeze
+
+        # the message dispatcher that is responsible for
+        # dispatching messages across either network
+        attr_accessor :_dispatcher
+        attr_accessor :_common_parameters
+
+        def initialize(dispatcher)
+          @_dispatcher        = dispatcher
+          @_common_parameters = {
+            message_dispatcher: _dispatcher,
+            message_factory:    self
+          }
+        end
+
+        # If data contains the payload key, we are receiving the message.
+        # If data does not caine the payload key, we are buliding the message
+        # to send
+        def create(type = '', data: {})
+          return Debug.message_type_not_found(type + 'not found') if type.blank?
+          data = data.deep_symbolize_keys
+
+          parameters = parameters_for(data)
+          klass = TYPES[type]
+          raise Errors::MessageTypeNotRecognized unless klass
+          klass.new(parameters)
+        end
+
+        def parameters_for(data)
+          if is_receiving?(data)
+            receiving_parameters_for(data)
+          else
+            sending_parameters_for(data)
+          end
+        end
+
+        def is_receiving?(data)
+          data[:payload].present?
+        end
+
+        # ensures a payload exists, as well as assigns the
+        # message dispatcher and message factory
+        def receiving_parameters_for(data)
+          { payload: data[:payload] }.merge(_common_parameters)
+        end
+
+        def sending_parameters_for(data)
+          data.merge(
+            message: data[:message],
+            sender: {
+              'alias'    => APP_CONFIG.user['alias'],
+              'location' => APP_CONFIG.user.location,
+              'uid'      => APP_CONFIG.user['uid']
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/message/node_list.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class NodeList < Base
+        def message
+          @message ||= Node.as_json
+        end
+
+        def handle
+          respond
+          nil
+        end
+
+        # only need to respond if this server has node entries that the
+        # sender of this message doesn't have
+        def respond
+          received_list = message
+          we_only_have, they_only_have = Node.diff(received_list)
+
+          Display.debug('node_list#respond: me: ' + we_only_have.to_s)
+          Display.debug('node_list#respond: they: ' + they_only_have.to_s)
+
+          if they_only_have.present?
+            they_only_have.each do |n|
+              Node.from_json(n).save!
+            end
+          end
+
+          uid = payload['sender']['uid']
+
+          if we_only_have.present?
+            respond_with_what_we_have(we_only_have, they_only_have, uid)
+          else
+            respond_with_confirmation_of_in_sync(uid)
+          end
+        end
+
+        def respond_with_confirmation_of_in_sync(uid)
+          Display.debug 'node lists are in sync'
+          nlh_message = _message_factory.create(NODE_LIST_HASH)
+          # lists are in sync, confirm with hash
+          _message_dispatcher.send_message(uid: uid, message: nlh_message)
+        end
+
+        def respond_with_what_we_have(we_only_have, they_only_have, uid)
+          Display.debug 'we have nodes that they do not'
+
+          we_only_have_message = _message_factory.create(
+            NODE_LIST_DIFF,
+            data: { message: we_only_have })
+
+          they_only_have_message = _message_factory.create(
+            NODE_LIST_DIFF,
+            data: { message: they_only_have })
+
+          # give the sender our list
+          _message_dispatcher.send_message(
+            uid: uid,
+            message: we_only_have_message
+          )
+
+          # give people we know about
+          # (but the sender of the Node List may not know about)
+          # our node list diff
+          Node.online.each do |node|
+            _message_dispatcher.send_message(
+              node: node,
+              message: they_only_have_message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/message/node_list_diff.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class NodeListDiff < Base
+        def handle
+          entries_we_do_not_have = message
+
+          entries_we_do_not_have.each do |entry_as_json|
+            # this will silently fail if there is a duplicate
+            # or if this is an invalid entry
+            Node.from_json(entry_as_json).save
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/message/node_list_hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class NodeListHash < Base
+        def message
+          @_message ||= Node.as_sha512
+        end
+
+        # node list hash is received
+        # @return [NilClass] no output for this message type
+        def handle
+          respond
+          nil
+        end
+
+        def respond
+          if message != Node.as_sha512
+            Display.debug 'node list hashes do not match'
+
+            _message_dispatcher.send_message(
+              uid: payload['sender']['uid'],
+              message: NodeList.new(message: Node.as_json)
+            )
+          else
+            Display.debug 'node list hash matches'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/message/ping.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class Ping < Base
+        def display
+          # we'll never display our own ping to someone else...
+          # or shouldn't.... or there should be different output
+          # TODO: display is a bad method name
+          name = payload['sender']['alias']
+          location = payload['sender']['location']
+
+          "#{name}@#{location} pinged you."
+        end
+
+        def handle
+          respond
+          display
+        end
+
+        def respond
+          reply = _message_factory.create(PING_REPLY)
+          _message_dispatcher.send_message(
+            uid: payload['sender']['uid'],
+            message: reply
+          )
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/message/ping_reply.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class PingReply < Base
+        def display
+          'ping successful' if APP_CONFIG.user.debug?
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/message/whisper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class Whisper < Base
+        attr_accessor :_to
+
+        def initialize(
+          message:            nil,
+          sender:             {},
+          payload:            {},
+          to:                 '',
+          message_dispatcher: nil,
+          message_factory:    nil)
+
+          super(
+            message:            message,
+            sender:             sender,
+            payload:            payload,
+            message_dispatcher: message_dispatcher,
+            message_factory:    message_factory)
+
+          @_to = to
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/remote.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Remote
+      extend ActiveSupport::Autoload
+      eager_autoload do
+        autoload :Connection
+        autoload :RelayPool
+        autoload :Relay
+      end
+    end
+  end
+end

data/lib/meshchat/network/remote/connection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Remote
+      class Connection
+        attr_reader :_message_factory, :_message_dispatcher
+        attr_reader :_relay_pool
+
+        def initialize(dispatcher, message_factory)
+          @_message_factory = message_factory
+          @_message_dispatcher = dispatcher
+          @_relay_pool = RelayPool.new(dispatcher)
+        end
+
+        def send_message(node, encrypted_message)
+          payload = payload_for(node.uid, encrypted_message)
+          _relay_pool.send_payload(payload)
+        end
+
+        # @param [String] to - the uid of the person we are sending to
+        # @param [String] message - the encrypted message
+        def payload_for(to, encrypted_message)
+          { to: to, message: encrypted_message }
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/remote/relay.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+require 'action_cable_client'
+
+module Meshchat
+  module Network
+    module Remote
+      class Relay
+        # This channel is determine by the server, see
+        # https://github.com/NullVoxPopuli/mesh-relay/blob/master/app/channels/mesh_relay_channel.rb
+        CHANNEL = 'MeshRelayChannel'
+
+        attr_reader :_url, :_client, :_request_processor
+        attr_accessor :_connected
+        delegate :perform, to: :_client
+
+        def initialize(url, message_dispatcher, connected: nil)
+          @_url = url
+          @_request_processor = Incoming::RequestProcessor.new(
+            network: NETWORK_RELAY,
+            location: url,
+            message_dispatcher: message_dispatcher)
+
+          setup(connected: connected)
+        end
+
+        def setup(connected: nil)
+          path = "#{_url}?uid=#{APP_CONFIG.user['uid']}"
+          @_client = ActionCableClient.new(path, CHANNEL)
+
+          # don't output anything upon connecting
+          _client.connected {
+            self._connected = true
+          }
+
+          # If there are errors, report them!
+          _client.errored do |message|
+            process_error(message)
+          end
+
+          _client.subscribed do
+            connected.call if connected
+          end
+
+          # forward the encrypted messages to our RequestProcessor
+          # so that they can be decrypted
+          _client.received do |message|
+            process_message(message)
+          end
+
+          _client.disconnected do
+            self._connected = false
+          end
+
+          _client
+        end
+
+        def connected?
+          _connected
+        end
+
+        # example messages:
+        # {"identifier"=>"{\"channel\":\"MeshRelayChannel\"}", "message"=>{"message"=>"hi"}}
+        # {"identifier"=>"{\"channel\":\"MeshRelayChannel\"}", "message"=>{"error"=>"hi"}}
+        # {"identifier"=>"{\"channel\":\"MeshRelayChannel\"}", "type"=>"confirm_subscription"}
+        # {"identifier"=>"{\"channel\":\"MeshRelayChannel\"}", "message"=>{"error"=>"Member with UID user2 could not be found"}}
+        def process_message(message)
+          Debug.received_message_from_relay(message, _url)
+
+          _, type, message = message.values_at('identifier', 'type', 'message')
+
+          # do we want to do anything here?
+          return if type == 'confirm_subscription'
+          # are there any other types of websocket messages?
+          return unless message
+
+          if message['message']
+            chat_message_received(message)
+          elsif message['error']
+            error_message_received(message)
+          end
+        end
+
+        # TODO: what does an error message look like?
+        # TODO: what are situations in which we receive an error message?
+        def process_error(message)
+          Display.alert(message)
+        end
+
+        def chat_message_received(message)
+          _request_processor.process(message)
+        rescue => e
+          ap e.message
+          puts e.backtrace
+        end
+
+        def error_message_received(message)
+          Display.info message['error']
+          if message['status'] == 404
+            # mark the node as offline via relay
+            # TODO: find the intended node.
+            #       if on_local_network is true, send to http_client
+            # Display.info "#{node.alias_name} has ventured offline"
+            # Debug.person_not_online(node, message, e)
+          end
+        end
+      end
+    end
+  end
+end