ruby_nos 0.0.1

data/lib/ruby_nos/aliasing.rb

@@ -0,0 +1,15 @@
+module Aliasing
+
+  module ClassMethods
+    def attr_alias(new_attr, original)
+      alias_method(new_attr, original) if method_defined? original
+      new_writer = "#{new_attr}="
+      original_writer = "#{original}="
+      alias_method(new_writer, original_writer) if method_defined? original_writer
+    end
+  end
+
+  def self.included klass
+    klass.extend ClassMethods
+  end
+end

data/lib/ruby_nos/cloud.rb

@@ -0,0 +1,80 @@
+module RubyNos
+  class Cloud
+    include Initializable
+    attr_accessor :uuid, :current_agent, :list
+
+    def uuid
+      @uuid ||= RubyNos.cloud_uuid
+    end
+
+    def list
+      @list ||= List.new
+    end
+
+    def update agent_info
+      if agent_info.is_a?(Hash)
+        self.current_agent = build_remote_agent(agent_info)
+      else
+        self.current_agent = agent_info
+      end
+
+      if list.is_on_the_list?(self.current_agent.uuid)
+        update_actual_info
+      else
+        RubyNos.logger.send(:info, "Added agent #{self.current_agent.uuid}")
+        list.add(self.current_agent)
+      end
+    end
+
+    private
+
+    def build_remote_agent agent_info
+      agent = RemoteAgent.new(uuid: agent_info[:agent_uuid], timestamp: (agent_info[:timestamp] || timestamp_for_list))
+      info = agent_info[:info]
+      agent.endpoints = process_endpoints(info[:endpoints]) if (info && info[:endpoints])
+      agent
+    end
+
+    def timestamp_for_list
+      Formatter.timestamp
+    end
+
+    def update_actual_info
+      if correct_timestamp? && !same_info?
+        prepare_agent
+        list.update(self.current_agent.uuid, self.current_agent)
+      end
+    end
+
+    def remote_agent_on_the_list
+      list.info_for(self.current_agent.uuid)
+    end
+
+    def prepare_agent
+      if self.current_agent.endpoints == []
+        self.current_agent.endpoints = remote_agent_on_the_list.endpoints if remote_agent_on_the_list.endpoints
+      end
+      if self.current_agent.rest_api == nil
+        self.current_agent.rest_api = remote_agent_on_the_list.rest_api if remote_agent_on_the_list.rest_api
+      end
+    end
+
+    def correct_timestamp?
+      timestamp = current_agent.timestamp
+      ((timestamp_for_list - RubyNos.keep_alive_time) < timestamp) && (timestamp <= timestamp_for_list)
+    end
+
+    def same_info?
+      remote_agent_on_the_list.same_endpoints?(self.current_agent) && remote_agent_on_the_list.same_api?(self.current_agent) && remote_agent_on_the_list.same_timestamp?(self.current_agent)
+    end
+
+    def process_endpoints endpoints
+      [].tap do |endpoints_info|
+        endpoints.each do |endpoint|
+          e_info = endpoint.split(",")
+          endpoints_info << Endpoint.new({type: e_info[0], port: e_info[1], host: e_info[2]})
+        end
+      end
+    end
+  end
+end

data/lib/ruby_nos/endpoint.rb

@@ -0,0 +1,43 @@
+module RubyNos
+  class Endpoint
+    include Initializable
+    include Aliasing
+
+    attr_accessor :path, :port, :sticky, :type, :priority, :host
+    ALLOWED_TYPES = ["PUBLIC", "HEALTHCHECK", "INTERNAL", "MSNOS_HTTP", "UDP", "HTTP", "PUB", "HCK", "INT", "MHT"]
+
+    attr_alias :pa, :path
+    attr_alias :po, :port
+    attr_alias :st, :sticky
+    attr_alias :ty, :type
+    attr_alias :xp, :priority
+    attr_alias :ho, :host
+
+    def type= type
+      if ALLOWED_TYPES.include?(type)
+        @type = type
+      else
+        raise ArgumentError
+      end
+    end
+
+    def priority
+      @priority ||= 0
+    end
+
+    def sticky
+      @sticky ||= 0
+    end
+
+    def to_hash
+      {
+          pa: self.path,
+          po: self.port,
+          st: self.sticky,
+          ty: self.type,
+          xp: self.priority,
+          ho: self.host
+      }
+    end
+  end
+end

data/lib/ruby_nos/formatter.rb

@@ -0,0 +1,25 @@
+require "json"
+
+module RubyNos
+  class Formatter
+    def convert_to_uuid string_uuid
+      string_uuid.match(/(\h{8})(\h{4})(\h{4})(\h{4})(\h{12})/).captures.join("-")
+    end
+
+    def uuid_format? uuid
+      !!uuid.match(/\h{8}-\h{4}-\h{4}-\h{4}-\h{12}/)
+    end
+
+    def uuid_to_string uuid
+      uuid.gsub("-", "")
+    end
+
+    def parse_message message
+      JSON.parse(message, {symbolize_names: true})
+    end
+
+    def self.timestamp
+      (Time.now.to_f*1000).to_i
+    end
+  end
+end

data/lib/ruby_nos/list.rb

@@ -0,0 +1,34 @@
+module RubyNos
+  class List
+    include Initializable
+    attr_accessor :list
+
+    def list
+      @list ||= []
+    end
+
+    def add element
+      list << {element.uuid => element}
+    end
+    
+    def update uuid, new_element
+      list.select{|e| e[uuid]}.first[uuid] = new_element
+    end
+      
+    def eliminate uuid
+      list.delete_if{|e| e.keys.first == uuid}
+    end
+
+    def info_for uuid
+      list.select{|e| e[uuid]}.first[uuid]
+    end
+
+    def list_of_keys
+      list.map{|e| e.keys}.flatten
+    end
+
+    def is_on_the_list? uuid
+      list_of_keys.include?(uuid)
+    end
+  end
+end

data/lib/ruby_nos/message.rb

@@ -0,0 +1,47 @@
+require "securerandom"
+require "initializable"
+
+module RubyNos
+  class Message
+    include Aliasing
+
+    include Initializable
+    attr_accessor :version, :from, :type, :to, :hops, :reliable, :data, :id, :signature, :timestamp
+    attr_alias :v,  :version
+    attr_alias :fr, :from
+    attr_alias :ty, :type
+    attr_alias :hp, :hops
+    attr_alias :rx, :reliable
+    attr_alias :dt, :data
+    attr_alias :sg, :signature
+    attr_alias :ts, :timestamp
+
+    def to_hash
+      {
+          v:  self.version  || "1.0",
+          ty: self.type,
+          fr: self.from,
+          to: self.to,
+          hp: self.hops     || RubyNos.hops,
+          ts: self.timestamp || generate_miliseconds_timestamp,
+          rx: self.reliable || 0,
+          dt: self.data
+      }.delete_if{|key, value| value==nil  || value == {}}
+    end
+
+    def serialize
+      message = to_hash
+      message.merge!({sg: signature_generator.generate_signature(message.to_s)})
+    end
+
+    private
+
+    def generate_miliseconds_timestamp
+      Formatter.timestamp
+    end
+
+    def signature_generator
+      @signature_generator ||= SignatureGenerator.new
+    end
+  end
+end

data/lib/ruby_nos/processor.rb

@@ -0,0 +1,133 @@
+module RubyNos
+  class Processor
+
+    attr_accessor :agent, :current_message
+
+    def initialize agent
+      @agent = agent
+    end
+
+    def formatter
+      @formatter ||= Formatter.new
+    end
+
+    def signature_generator
+      @signature_generator ||= SignatureGenerator.new
+    end
+
+    def process_message received_message
+      formatted_message = formatter.parse_message(received_message)
+      self.current_message = Message.new(formatted_message)
+
+      unless sender_uuid == agent.uuid || !correct_signature?(formatted_message)
+        RubyNos.logger.send(:info, "#{self.current_message.type} arrives")
+        if agent_receptor? || cloud_receptor?
+          processor = message_processor.fetch(current_message.type, nil)
+          processor.call if processor
+        end
+      end
+    end
+
+    private
+
+    def message_processor
+      {
+          "PIN" => lambda {process_pin_message},
+          "PON" => lambda {process_pon_message},
+          "PRS" => lambda {process_presence_message},
+          "DSC" => lambda {process_discovery_message},
+          "ENQ" => lambda {process_enquiry_message},
+          "QNE" => lambda {process_enquiry_answer_message}
+      }
+    end
+
+    def sender_uuid
+      get_uuid(self.current_message.from)
+    end
+
+    def receptor_uuid
+      get_uuid(self.current_message.to)
+    end
+
+    def received_api
+      RestApi.new({name: self.current_message.data[:name]}).tap do |api|
+        if self.current_message.data[:apis]
+          self.current_message.data[:apis].each do |endpoint|
+            api.add_endpoint(endpoint)
+          end
+        end
+      end
+    end
+
+    def correct_signature? received_message
+      if received_message[:sg]
+        signature = received_message.delete(:sg)
+        signature_generator.valid_signature?(received_message.to_s, signature)
+      else
+        true
+      end
+    end
+
+    def process_pin_message
+      update_cloud
+      send_response "PON"
+    end
+
+    def process_pon_message
+      update_cloud
+    end
+
+    def process_presence_message
+      if self.current_message.data[:present] == 0
+        agent.cloud.list.eliminate(sender_uuid)
+      else
+        update_cloud
+      end
+    end
+
+    def process_discovery_message
+      unless agent.cloud.list.is_on_the_list?(sender_uuid)
+        update_cloud
+      end
+      send_response "PRS"
+    end
+
+    def process_enquiry_message
+      update_cloud
+      send_response "QNE"
+    end
+
+    def process_enquiry_answer_message
+      agent.cloud.update(RemoteAgent.new({uuid: sender_uuid, timestamp: self.current_message.timestamp, rest_api: received_api}))
+    end
+
+    def update_cloud
+      agent.cloud.update({agent_uuid: sender_uuid, info: self.current_message.data, timestamp: self.current_message.timestamp}) unless agent.cloud.uuid == sender_uuid
+    end
+
+    def agent_receptor?
+      agent.uuid == receptor_uuid
+    end
+
+    def cloud_receptor?
+      agent.cloud.uuid == receptor_uuid
+    end
+
+    def get_uuid uuid_param
+      if uuid_param.start_with?("AGT:", "CLD:")
+        uuid = formatter.convert_to_uuid(uuid_param[4..-1])
+        if formatter.uuid_format?(uuid)
+          uuid
+        else
+          raise(ArgumentError, 'Argument format is incorrect')
+        end
+      else
+        raise(ArgumentError, 'Argument format is incorrect')
+      end
+    end
+
+    def send_response type
+      agent.send_message({type: type})
+    end
+  end
+end

data/lib/ruby_nos/remote_agent.rb

@@ -0,0 +1,41 @@
+module RubyNos
+  class RemoteAgent
+    include Initializable
+    attr_accessor :uuid, :rest_api, :endpoints, :timestamp
+
+    def endpoints
+      @endpoints ||= []
+    end
+
+    def add_endpoint *args
+      endpoints << Endpoint.new(*args)
+    end
+
+    def endpoints_collection
+      endpoints.map{|e| e.to_hash}
+    end
+
+    def same_endpoints? another_agent
+      endpoints_collection == another_agent.endpoints_collection
+    end
+
+    def same_api? another_agent
+      if rest_api && another_agent.rest_api
+        rest_api.to_hash == another_agent.rest_api.to_hash
+      else
+        false
+      end
+    end
+
+    def same_timestamp? another_agent
+      timestamp == another_agent.timestamp
+    end
+
+    def to_hash
+      {
+          uuid: uuid,
+          timestamp: Time.at(timestamp/1000)
+      }
+    end
+  end
+end

data/lib/ruby_nos/rest_api.rb

@@ -0,0 +1,23 @@
+module RubyNos
+  class RestApi
+    include Initializable
+    attr_accessor :name, :endpoints, :port, :host
+
+    def endpoints
+      @endpoints ||= []
+    end
+
+    def add_endpoint args
+      args.merge!({port: port}) unless (args[:port] || args[:po] )
+      args.merge!({host: host}) unless (args[:host] || args[:ho] )
+      endpoints << Endpoint.new(args)
+    end
+
+    def to_hash
+      {
+          name: self.name,
+          apis: endpoints.map{|e| e.to_hash}
+      }
+    end
+  end
+end