meshchat 0.8.0 → 0.10.0

data/lib/meshchat/network/incoming/message_processor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Incoming
+      # decodes an encrypted message and handles it.
+      # also update's the info of the sender
+      class MessageProcessor
+        attr_reader :_network, :_location
+        attr_reader :_message_factory, :_message_dispatcher
+
+        def initialize(network: NETWORK_LOCAL, message_dispatcher: nil, location: nil)
+          @_network = network
+          @_message_dispatcher = message_dispatcher
+          @_message_factory = message_dispatcher._message_factory
+          @_location = location
+        end
+
+        # @param [String] encoded_message - the encrypted message as a string
+        def process(encoded_message)
+          request = MessageDecryptor.new(encoded_message, _message_factory)
+          message = request.message
+
+          Debug.receiving_message(message)
+
+          # show the message to the user, and update the information
+          # we have on the sender, so that we may reply to the
+          # correct location
+          update_sender_info(request._json)
+          Display.present_message message
+        end
+
+        # @param [String] encoded_message - the encrypted message as a string
+        def update_sender_info(json)
+          sender = json['sender']
+          # Note that sender['location'] should always reference
+          # the sender's local network address
+          network_location = sender['location']
+
+          # if the sender isn't currently marked as active,
+          # perform the server list exchange
+          node = Node.find_by_uid(sender['uid'])
+          raise Errors::Forbidden, 'node not found' if node.nil?
+
+          # if we are receiving a message from a node we had previously
+          # known to be offline, we need to do the node list hash dance
+          # with them to see if they know of any new members to the network
+          unless node.online?
+            node.update(on_local_network: true) if is_processing_for_local?
+            node.update(on_relay: true) if is_processing_for_relay?
+
+            nlh = _message_factory.create(Message::NODE_LIST_HASH)
+            _message_dispatcher.send_message(node: node, message: nlh)
+          end
+
+          # update the node's location/alias
+          # as they can change this info willy nilly
+          attributes = {
+            location_on_network: network_location,
+            alias_name: sender['alias']
+          }
+          attributes[:location_of_relay] = _location if is_processing_for_relay?
+          node.update(attributes)
+        end
+
+        def is_processing_for_relay?
+          _network == NETWORK_RELAY
+        end
+
+        def is_processing_for_local?
+          _network != NETWORK_RELAY
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/incoming/request_processor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Incoming
+      # all this does is pull the encrypted message out of
+      # the received request
+      class RequestProcessor
+        attr_reader :_message_processor
+
+        def initialize(network: NETWORK_LOCAL, message_dispatcher: nil, location: nil)
+          @_message_processor = MessageProcessor.new(
+            network: network,
+            message_dispatcher: message_dispatcher,
+            location: location)
+        end
+
+        # @param [String] request_body - the encrypted message as a json string
+        def process(request_body)
+          encoded_message = parse_content(request_body)
+          _message_processor.process(encoded_message)
+        end
+
+        def parse_content(content)
+          content = JSON.parse(content) if content.is_a?(String)
+          content['message']
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/local.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Local
+      extend ActiveSupport::Autoload
+      eager_autoload do
+        autoload :Server
+        autoload :Connection
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'em-http-request'
+
+module Meshchat
+  module Network
+    module Local
+      class Connection
+        attr_reader :_message_factory, :_message_dispatcher
+
+        def initialize(dispatcher, message_factory)
+          @_message_factory = message_factory
+          @_message_dispatcher = dispatcher
+
+          # async, won't prevent us from sending
+          start_server
+        end
+
+        def start_server
+          port = APP_CONFIG.user['port']
+          Display.info "listening on port #{port}"
+          EM.start_server('0.0.0.0', port,
+            Network::Local::Server, _message_dispatcher)
+        end
+
+        # @param [Node] node - the node describing the person you're sending a message to
+        # @param [JSON] encrypted_message - the message intended for the person at the location
+        # @param [Block] error_callback - what to do in case of failure
+        def send_message(node, encrypted_message, &error_callback)
+          payload = payload_for(encrypted_message)
+          create_http_request(node.location_on_network, payload, &error_callback)
+        end
+
+        def create_http_request(location, payload, &error_callback)
+          # TODO: what about https?
+          #       maybe do the regex match: /https?:\/\//
+          location = 'http://' + location unless location.include?('http://')
+          http = EventMachine::HttpRequest.new(location).post(
+            body: payload,
+            head: {
+              'Accept' => 'application/json',
+              'Content-Type' => 'application/json'
+            })
+
+          http.errback &error_callback
+          # example things available in the callback
+          # p http.response_header.status
+          # p http.response_header
+          # p http.response
+          http.callback {}
+        end
+
+        def payload_for(encrypted_message)
+          { message: encrypted_message }.to_json
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/local/server.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'evma_httpserver'
+
+module Meshchat
+  module Network
+    module Local
+      # This is created every request
+      class Server < EM::Connection
+        include EM::HttpServer
+        attr_reader :_message_dispatcher, :_request_processor
+
+        OK = 200
+        BAD_REQUEST = 400
+        NOT_AUTHORIZED = 401
+        FORBIDDEN = 403
+        SERVER_ERROR = 500
+
+        def initialize(message_dispatcher)
+          @_message_dispatcher = message_dispatcher
+          @_request_processor = Incoming::RequestProcessor.new(
+            network: NETWORK_LOCAL,
+            message_dispatcher: message_dispatcher)
+        end
+
+        def process_http_request
+          # the http request details are available via the following instance variables:
+          #   @http_protocol
+          #   @http_request_method
+          #   @http_cookie
+          #   @http_if_none_match
+          #   @http_content_type
+          #   @http_path_info
+          #   @http_request_uri
+          #   @http_query_string
+          #   @http_post_content
+          #   @http_headers
+          # view what instance variables are available thorugh the
+          # instance_variables method
+
+          process(@http_post_content)
+          build_response
+        end
+
+        def process(raw)
+          # decode, etc
+          _request_processor.process(raw)
+        rescue Errors::NotAuthorized
+          build_response NOT_AUTHORIZED
+        rescue Errors::Forbidden
+          build_response FORBIDDEN
+        rescue Errors::BadRequest
+          build_response BAD_REQUEST
+        rescue => e
+          Display.error e.message
+          Display.error e.backtrace.join("\n")
+          build_response SERVER_ERROR, e.message
+        end
+
+        def build_response(s = OK, message = '')
+          response = EM::DelegatedHttpResponse.new(self)
+          response.status = s
+          response.content_type 'text/json'
+          response.content = message
+          response.send_response
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/network/message.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      extend ActiveSupport::Autoload
+
+      # @see https://github.com/neuravion/mesh-chat/blob/master/message-types.md
+      CHAT           = 'chat'
+      EMOTE          = 'emote'
+      PING           = 'ping'
+      PING_REPLY     = 'pingreply'
+      WHISPER        = 'whisper'
+      DISCONNECT     = 'disconnect'
+
+      NODE_LIST      = 'nodelist'
+      NODE_LIST_HASH = 'nodelisthash'
+      NODE_LIST_DIFF = 'nodelistdiff'
+
+      eager_autoload do
+        autoload :Base
+        autoload :Chat
+        autoload :Emote
+        autoload :Ping
+        autoload :PingReply
+        autoload :Disconnect
+        autoload :Whisper
+        autoload :NodeList
+        autoload :NodeListDiff
+        autoload :NodeListHash
+        autoload :Factory
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      # NOTE:
+      #  #display: shows the message
+      #            should be used locally, before *sending* a message
+      #  #handle: processing logic for the message
+      #           should be used when receiving a message, and there
+      #           needs to be a response right away
+      #  #respond: where the actual logic for the response goes
+      class Base
+        attr_accessor :payload,
+          :_message, :_sender_name, :_sender_location, :_sender_uid,
+          :_time_received,
+          :_message_dispatcher, :_message_factory
+
+        # @param [String] message
+        # @param [Hash] sender
+        # @param [Hash] payload all paramaters for a received message
+        # @param [MeshChat::Network::Dispatcher] message_dispatcher optionally overrides the default payload
+        # @param [MeshChat::Message::Factory] message_factory the message factory
+        def initialize(
+          message:            '',
+          sender:             {},
+          payload:            {},
+          message_dispatcher: nil,
+          message_factory:    nil)
+
+          if payload.present?
+            @payload = payload.deep_stringify_keys
+          else
+            @_message         = message
+            @_sender_name     = sender['alias']
+            @_sender_location = sender['location']
+            @_sender_uid      = sender['uid']
+            @_time_received   = Time.now.iso8601
+          end
+
+          @_message_dispatcher = message_dispatcher
+          @_message_factory    = message_factory
+        end
+
+        def payload
+          @payload ||= {
+            'type'           => type,
+            'message'        => _message,
+            'client'         => client,
+            'client_version' => client_version,
+            'time_sent'      => _time_received,
+            'sender'         => {
+              'alias'        => _sender_name,
+              'location'     => _sender_location,
+              'uid'          => _sender_uid
+            }
+          }
+        end
+
+        def type
+          @type ||= Factory::TYPES.invert[self.class]
+        end
+
+        def message
+          _message || payload['message']
+        end
+
+        def sender
+          payload['sender']
+        end
+
+        def sender_name
+          _sender_name || sender['alias']
+        end
+
+        def sender_location
+          _sender_location || sender['location']
+        end
+
+        def sender_uid
+          _sender_uid || sender['uid']
+        end
+
+        def time_received
+          _time_received || payload['time_sent']
+        end
+
+        def time_received_as_date
+          DateTime.parse(time_received) if time_received
+        end
+
+        def client
+          APP_CONFIG[:client_name]
+        end
+
+        def client_version
+          APP_CONFIG[:client_version]
+        end
+
+        # shows the message
+        # should be used locally, before *sending* a message
+        def display
+          {
+            time:    time_received_as_date,
+            from:    sender_name,
+            message: message
+          }
+        end
+
+        # processing logic for the message
+        # should be used when receiving a message, and there
+        # needs to be a response right away.
+        # this may call display, if the response is always to be displayed
+        def handle
+          display
+        end
+
+        # Most message types aren't going to need to have an
+        # immediate response.
+        def respond
+        end
+
+        # this message should be called immediately
+        # before sending to the whomever
+        def render
+          payload.to_json
+        end
+
+        alias_method :jsonized_payload, :render
+
+        def encrypt_for(node)
+          result     = jsonized_payload
+          public_key = node.public_key
+          result     = Encryption.encrypt(result, public_key) if node.public_key
+          Base64.strict_encode64(result)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Message
+      class Disconnect < Base
+        def display
+          location = payload['sender']['location']
+          uid = payload['sender']['uid']
+          name = payload['sender']['alias']
+          node = Node.find_by_uid(uid)
+          if node
+            node.update(on_local_network: false)
+            node.update(on_relay: false)
+          end
+
+          "#{name}@#{location} has disconnected"
+        end
+      end
+    end
+  end
+end