meshchat 0.8.0 → 0.10.0

data/lib/meshchat/message/ping.rb

@@ -1,32 +0,0 @@
-module MeshChat
-  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
-        location = payload['sender']['location']
-
-        node = Node.find_by_location(location)
-
-        MeshChat::Net::Client.send(
-          node: node,
-          message: PingReply.new
-        )
-      end
-    end
-  end
-end

data/lib/meshchat/message/ping_reply.rb

@@ -1,9 +0,0 @@
-module MeshChat
-  module Message
-    class PingReply < Base
-      def display
-        'ping successful'.freeze if Settings.debug?
-      end
-    end
-  end
-end

data/lib/meshchat/message/relay.rb

@@ -1,43 +0,0 @@
-module MeshChat
-  module Message
-    class Relay < Base
-      def initialize(
-        message: nil,
-        sender_name: nil,
-        sender_location: nil,
-        sender_uid: nil,
-        time_recieved: nil,
-        payload: nil,
-        destination: '',
-        hops: [])
-
-        # package the original message
-        message = {
-          message: message,
-          destination: destination,
-          hops: hops
-        }
-
-        super(
-          message: message,
-          sender_name: sender_name,
-          sender_location: sender_location,
-          sender_uid: sender_uid,
-          time_recieved: time_recieved,
-          payload: payload)
-      end
-
-      def display; end
-
-      def handle
-        respond
-        return
-      end
-
-      def respond
-
-      end
-
-    end
-  end
-end

data/lib/meshchat/message/whisper.rb

@@ -1,36 +0,0 @@
-module MeshChat
-  module Message
-    class Whisper < Base
-      attr_accessor :_to
-
-      def initialize(
-        message: nil,
-        sender_name: nil,
-        sender_location: nil,
-        sender_uid: nil,
-        time_recieved: nil,
-        payload: nil,
-        to: '')
-
-        super(
-          message: message,
-          sender_name: sender_name,
-          sender_location: sender_location,
-          sender_uid: sender_uid,
-          time_recieved: time_recieved,
-          payload: payload)
-
-        self._to = to
-      end
-
-      def display
-        time_sent = payload['time_sent'].to_s
-        time = Date.parse(time_sent)
-        time_recieved = time.strftime('%e/%m/%y %H:%I:%M')
-
-        to = _to.present? ? "->#{_to}" : ''
-        "#{time_recieved} #{sender_name}#{to} > #{message}"
-      end
-    end
-  end
-end

data/lib/meshchat/models/entry.rb

@@ -1,104 +0,0 @@
-module MeshChat
-  module Models
-    class Entry < ActiveRecord::Base
-      IPV4_WITH_PORT = /((?:(?:^|\.)(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])){4})(:\d*)?/
-      # http://rubular.com/r/WYT09ptct3
-      DOMAIN_WITH_PORT = /(https?:\/\/)?([\da-z\.-]+)\.?([a-z\.]{2,6})([\/\w \.-]*)*[^\/](:\d*)?/
-
-      validates :alias_name,
-                :location,
-                :public_key, presence: true
-
-      validates :uid, presence: true, uniqueness: true
-
-      # ipv4 with port
-      validates_format_of :location, with: ->(e){
-        location = e.location || ''
-        location.include?('//') || location.include?('localhost') ?
-          DOMAIN_WITH_PORT :
-          IPV4_WITH_PORT
-      }
-
-      scope :online, -> { where(online: true) }
-      scope :offline, -> { where(online: false) }
-
-      class << self
-        def sha_preimage
-          all.map(&:public_key).sort.join(',')
-        end
-
-        def as_sha512
-          digest = Digest::SHA512.new
-          digest.hexdigest sha_preimage
-        end
-
-        def as_json
-          # must also include ourselves
-          # so that we can pass our own public key
-          # to those who don't have it
-          others = all.map(&:as_json)
-          me = Settings.identity_as_json
-          others << me
-        end
-
-        def from_json(json)
-          new(
-            alias_name: json['alias'],
-            location: json['location'],
-            uid: json['uid'],
-            public_key: json['publickey']
-          )
-        end
-
-        def public_key_from_uid(uid)
-          find_by_uid(uid).try(:public_key)
-        end
-
-        # @param [Array] theirs array of hashes representing node entries
-        # @return [Array<-,+>] nodes only we have, and nodes only they have
-        def diff(theirs)
-          ours = as_json
-          we_only_have = ours - theirs
-          they_only_have = theirs - ours
-
-          [we_only_have, they_only_have]
-        end
-
-        def import_from_file(filename)
-          begin
-            f = File.read(filename)
-            hash = JSON.parse(f)
-            n = from_json(hash)
-            n.save
-            n
-          rescue => e
-            Display.alert e.message
-          end
-        end
-      end
-
-      def ==(other)
-        result = false
-
-        if other.is_a?(Hash)
-          result = as_json.values_at(*other.keys) == other.values
-        end
-
-        result || super
-      end
-
-      def as_json
-        {
-          'alias' => alias_name,
-          'location' => location,
-          'uid' => uid,
-          'publickey' => public_key
-        }
-      end
-
-      def as_info
-        "#{alias_name}@#{location}"
-      end
-    end
-  end
-end

data/lib/meshchat/net/client.rb

@@ -1,83 +0,0 @@
-module MeshChat
-  module Net
-    module Client
-      module_function
-
-      # @note Either the location, node, or uid should be present
-      #
-      # @param [String] location (Optional) location of target
-      # @param [String] uid (Optional) uid of target
-      # @param [Node] node (Optional) target
-      # @param [Message] message (Required) what to send to the target
-      def send(location: nil, uid: nil, node: nil, message: nil)
-        # verify node is valid
-        node = self.node_for(location: location, uid: uid, node: node)
-        # don't proceed if we don't have a node
-        return unless node
-
-        if Settings['uid'] == node.uid
-          Display.debug 'avoiding sending to self'
-          return
-        end
-
-        Thread.new(node, message) do |node, message|
-          begin
-            payload = Client.payload_for(node, message)
-
-            Display.debug('SENDING: ' + message.type)
-            Display.debug('SENDING: ' + message.sender.to_s)
-            Display.debug('SENDING: ' + message.message.to_s)
-
-            # TODO: this is horrible, come up with something better / abstract it
-            begin
-              Curl::Easy.http_post(node.location, payload.to_json) do |c|
-                c.headers['Accept'] = 'application/json'
-                c.headers['Content-Type'] = 'application/json'
-                if MeshChat::Settings.debug?
-                  puts message.render
-                  c.verbose = true
-                  c.on_debug do |type, data|
-                    puts data
-                  end
-                end
-              end
-            rescue => e
-              node.update(online: false)
-              Display.info "#{node.alias_name} has ventured offline"
-              Display.debug("#{message.class.name}: Issue connectiong to #{node.alias_name}@#{node.location}")
-              Display.debug(e.message)
-            end
-
-          rescue => e
-            Display.info "Public key encryption for #{node.try(:alias_name) || 'unknown'} failed"
-          end
-        end
-      end
-
-      # creates a json payload
-      def self.payload_for(node, message)
-        request = MeshChat::Net::Request.new(node, message)
-        { message: request.payload }
-      end
-
-      # private
-
-      # @return [Node]
-      def node_for(location: nil, uid: nil, node: nil)
-        unless node
-          node = Models::Entry.find_by_location(location) if location
-          node = Models::Entry.find_by_uid(uid) if uid && !node
-        end
-
-        # TODO: also check for public key?
-        # without the public key, the message is sent in cleartext. :-\
-        if !(node && node.location)
-          Display.alert "Node not found, or does not have a location. Have you imported #{location || ""}?"
-          return
-        end
-
-        node
-      end
-    end
-  end
-end

data/lib/meshchat/net/listener/errors.rb

@@ -1,11 +0,0 @@
-module MeshChat
-  module Net
-    module Listener
-      module Errors
-        class NotAuthorized < StandardError; end
-        class Forbidden < StandardError; end
-        class BadRequest < StandardError; end
-      end
-    end
-  end
-end

data/lib/meshchat/net/listener/request.rb

@@ -1,48 +0,0 @@
-module MeshChat
-  module Net
-    module Listener
-      class Request
-        attr_accessor :json, :message
-        attr_accessor :_input
-
-        def initialize(input)
-          self._input = try_decrypt(input)
-
-          begin
-            self.json = JSON.parse(_input)
-          rescue => e
-            Display.debug e.message
-            Display.debug e.backtrace.join("\n")
-            raise Errors::BadRequest.new
-          end
-          self.message = process_json
-        end
-
-        private
-
-        def try_decrypt(input)
-          begin
-            decoded = Base64.decode64(input)
-            input = Cipher.decrypt(decoded, Settings[:privatekey])
-          rescue => e
-            Display.debug e.message
-            Display.debug e.backtrace.join("\n")
-            Display.debug input
-            raise Errors::NotAuthorized.new(e.message)
-          end
-
-          input
-        end
-
-        def process_json
-          type = json['type']
-          klass = Message::TYPES[type]
-
-          raise Errors::BadRequest.new(type) unless klass
-
-          klass.new(payload: json)
-        end
-      end
-    end
-  end
-end

data/lib/meshchat/net/listener/request_processor.rb

@@ -1,50 +0,0 @@
-module MeshChat
-  module Net
-    module Listener
-      module RequestProcessor
-
-        module_function
-
-        def process(raw)
-          request = Request.new(raw)
-          message = request.message
-
-          # TODO: wrap in debug if check
-          Display.debug('RECEIVING: ' + message.type)
-          Display.debug('RECEIVING: ' + message.sender.to_s)
-          Display.debug('RECEIVING: ' + message.message.to_s)
-
-          # handle the message
-          Display.present_message message
-
-          # then update the sender info in the db
-          update_sender_info(request.json)
-        end
-
-        def update_sender_info(json)
-          sender = json['sender']
-
-          # if the sender isn't currently marked as active,
-          # perform the server list exchange
-          node = Node.find_by_uid(sender['uid'])
-          raise Errors::Forbidden.new if node.nil?
-
-          unless node.online?
-            node.update(online: true)
-            payload = Message::NodeListHash.new
-            Client.send(
-              location: sender['location'],
-              message: payload)
-          end
-
-          # update the node's location/alias
-          # as they can change this info willy nilly
-          node.update(
-            location: sender['location'],
-            alias_name: sender['alias']
-          )
-        end
-      end
-    end
-  end
-end

data/lib/meshchat/net/listener/server.rb

@@ -1,114 +0,0 @@
-require 'sinatra/base'
-require 'meshchat/net/listener/errors'
-
-module MeshChat
-  module Net
-    module Listener
-      class Server < Sinatra::Base
-        OK = 200
-        BAD_REQUEST = 400
-        NOT_AUTHORIZED = 401
-        FORBIDDEN = 403
-
-        configure :development do
-          # only shows resulting status
-          disable :logging
-          # enable :logging
-          set :bind, '0.0.0.0' #['10.10.2.29','127.0.0.1', 'localhost']
-          set :show_exceptions, :after_handler
-          set :threaded, true
-        end
-        # TODO: do we want to return an error if
-        # we can't decrypt?
-
-        def self.run!(*)
-          # any code that should be ran
-          # before sintra starts should go here
-
-          # start the server
-          super
-          # code after here will not run
-        end
-
-        get '/' do
-          process_request
-        end
-
-        post '/' do
-          process_request
-        end
-
-        def process_request
-          begin
-            # form params should override
-            # raw body
-            raw = get_message
-            process(raw)
-          rescue => e
-            Display.error e.message
-            Display.error e.backtrace.join("\n")
-            body e.message
-            status 500
-          end
-        end
-
-        def get_message
-          # if received as form data
-          return params[:message] if params[:message]
-
-          # if received as json
-          request_body = request.body.read
-          json_body = JSON.parse(request_body)
-          json_body['message']
-        end
-
-        def process(raw)
-          # decode, etc
-          begin
-            RequestProcessor.process(raw)
-          rescue Errors::NotAuthorized
-            status_of NOT_AUTHORIZED
-          rescue Errors::Forbidden
-            status_of FORBIDDEN
-          rescue Errors::BadRequest
-            status_of BAD_REQUEST
-          end
-        end
-
-        def status_of(s)
-          status s
-          Display.debug('SERVER: ' + s.inspect)
-          body ''
-        end
-
-        # Hack away our problems
-        # don't show the Sinatra has taken the stage message
-        #
-        # https://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb#L1504
-        def self.start_server(handler, server_settings, handler_name)
-          handler.run(self, server_settings) do |server|
-
-            setup_traps
-            set :running_server, server
-            set :handler_name,   handler_name
-            server.threaded = settings.threaded if server.respond_to? :threaded=
-
-            yield server if block_given?
-          end
-        end
-
-        # Hack away our problems
-        # Don't show the Sinatra quit message
-        #
-        # https://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb#L1420
-        def self.quit!
-          return unless running?
-          # Use Thin's hard #stop! if available, otherwise just #stop.
-          running_server.respond_to?(:stop!) ? running_server.stop! : running_server.stop
-          set :running_server, nil
-          set :handler_name, nil
-        end
-      end
-    end
-  end
-end