evesync 1.0.2

data/lib/evesync/discover.rb

@@ -0,0 +1,77 @@
+require 'evesync/ipc/client'
+require 'evesync/log'
+require 'evesync/config'
+
+module Evesync
+
+  ##
+  # Discover other nodes
+  # Handles discovering messages sending and receiving
+  #
+  # = Example
+  #
+  #   disc = Discover.new
+  #   disc.send_discovery_message
+  #   ...
+  #   disc.stop
+
+  class Discover
+    DISCOVERY_REQ = 'EVESYNC'.freeze
+    DISCOVERY_ANS = 'DISCOVERED'.freeze
+
+    def initialize
+      # Starting thread that sends and accepts UDP-packages.
+      # This is how a node can say that it's online
+      @evesync = IPC::Client.new(
+        port: :evemond
+      )
+      @port = Config[:evesyncd]['broadcast_port']
+      @listen_sock = UDPSocket.new
+      @listen_sock.bind('0.0.0.0', @port)
+      @listen_thread = Thread.new { listen_discovery }
+    end
+
+    ##
+    # Sending UDP message on broadcast
+    # Discovering our nodes
+
+    def send_discovery_message(ip = '<broadcast>', message = DISCOVERY_REQ)
+      udp_sock = UDPSocket.new
+      if ip == '<broadcast>'
+        udp_sock.setsockopt(
+          Socket::SOL_SOCKET, Socket::SO_BROADCAST, true
+        )
+      end
+      udp_sock.send(message, 0, ip, @port)
+      udp_sock.close
+    end
+
+    def stop
+      @listen_thread.exit
+    end
+
+    private
+
+    def listen_discovery
+      loop do
+        data, recvdata = @listen_sock.recvfrom(1024)
+        node_ip = recvdata[-1]
+
+        next if Utils.local_ip?(node_ip)
+
+        if [DISCOVERY_REQ, DISCOVERY_ANS].include? data
+          # Push new node_ip to trigger
+          @evesync.add_remote_node(node_ip)
+        end
+
+        case data
+        when DISCOVERY_REQ
+          Log.info("Discover host request got: #{node_ip}")
+          send_discovery_message(node_ip, DISCOVERY_ANS)
+        when DISCOVERY_ANS
+          Log.info("Discover host response got: #{node_ip}")
+        end
+      end
+    end
+  end
+end

data/lib/evesync/err.rb

@@ -0,0 +1,25 @@
+# TODO: move to a err directory
+module Evesync
+  module Err
+
+    # Base Evesync error class.
+    # Using it as a base for all Evesync exceptions.
+    #
+    # = Example:
+    #  class MyError < Evesync::Err::Base
+    #    def initialize(message, *args)
+    #      super(message)
+    #      ...
+    #    end
+    #    ...
+    #  end
+    class Base < RuntimeError
+      def initialize(message)
+        super(message)
+      end
+    end
+
+    class SaveError < Base
+    end
+  end
+end

data/lib/evesync/handler/file.rb

@@ -0,0 +1,28 @@
+require 'evesync/ipc/data/file'
+
+module Evesync
+  class Handler
+    class File
+      def handle(file)
+        Log.debug("Handler File handling started...")
+        content = file.content
+        name = file.name
+        Log.debug("Handler File writing received content to #{name}")
+
+        if file.action == IPC::Data::File::Action::DELETE
+          ::File.delete(name)
+        else # TODO: handle move_to and move_from
+          # TODO: handle exceptions or throw them
+          # Writing content
+          ::File.write(name, content)
+          # Changing mode
+          ::File.chmod(name, file.mode)
+        end
+
+        # Returning all fine!
+        Log.debug("Handler File handling done!")
+        true
+      end
+    end
+  end
+end

data/lib/evesync/handler/package.rb

@@ -0,0 +1,30 @@
+require 'evesync/log'
+require 'evesync/os'
+
+module Evesync
+  class Handler
+    class Package
+      def handle(message)
+        Log.debug('Handler Package handling started...')
+
+        args = [message.name, message.version]
+
+        case message.command
+        when /install/
+          OS::PackageManager.install(*args)
+        when /remove/
+          OS::PackageManager.remove(*args)
+        when /update/
+          OS::PackageManager.update(*args)
+        when /downgrade/
+          OS::PackageManager.downgrade(*args)
+        else
+          Log.warn("Handler Package command unknown: #{message.command}")
+          return false
+        end
+        Log.debug('Handler Package handling done!')
+        true
+      end
+    end
+  end
+end

data/lib/evesync/handler.rb

@@ -0,0 +1,89 @@
+require 'evesync/log'
+require 'evesync/handler/package'
+require 'evesync/handler/file'
+require 'evesync/ipc/client'
+
+module Evesync
+
+  # Handles package changes, sent via Package class and queue
+  # Sends messages to evedatad and available evehands.
+  #
+  # [See]
+  #     - *Evesync::Trigger::File*
+  #     - *Evesync::Trigger::Package*
+  #
+  # [Handlers available:]
+  #   - *Evesync::Handler::Package*
+  #   - *Evesync::Handler::File*
+  #
+  # = Example:
+  #
+  #   handler = Evesync::Handler.new(queue)
+  #   Evesync::IPC::Server.new(
+  #     :proxy => handler,
+  #     ...
+  #   )
+  #
+  # = Example call:
+  #
+  #   Evesync::IPC::Client.new(
+  #     :port => :evehand
+  #   ).handle(IPC::Data::Package.new(
+  #     :name => 'tree',
+  #     :version => '0.0.1',
+  #     :command => :install
+  #   )
+  #
+  # = TODO:
+  #
+  #   * Make anoter daemon\Thread to search for available
+  #     evehands daemons
+  #   * Delegate +handle+ to another daemon if not found
+  class Handler
+    def initialize
+      @package_handler = Handler::Package.new
+      @files_handler = Handler::File.new
+      @monitor = IPC::Client.new(
+        port: :evemond
+      )
+      @database = IPC::Client.new(
+        port: :evedatad
+      )
+      Log.debug('Handler initialization done!')
+    end
+
+    def handle(message)
+      Log.info "Handler triggered with: #{message}"
+
+      handler = if message.is_a? IPC::Data::Package
+                  @package_handler
+                elsif message.is_a? IPC::Data::File
+                  @files_handler
+                else
+                  Log.error('Handler: unknown message type')
+                  nil
+                end
+      return unless handler
+
+      @monitor.ignore(message)
+
+      # TODO: add PackageManagerLock exception
+      # FIXME: package manger may be locked
+      # Add sleep and ones again try if PackageManagerLock
+      # exception is cought
+      handler.handle(message) || @monitor.unignore(message)
+      @database.save(message)
+
+      true
+    end
+
+    # For syncing and other remove db access
+    def events
+      @database.events
+    end
+
+    def messages(*args)
+      @database.messages(*args)
+    end
+  end
+end

data/lib/evesync/ipc/client.rb

@@ -0,0 +1,37 @@
+require 'drb/drb'
+require 'evesync/log'
+require 'evesync/ipc/ipc'
+
+module  Evesync
+  module IPC
+    class Client
+      include IPC
+
+      attr_reader :ip, :uri
+
+      def initialize(params)
+        check_params_provided(params, [:port])
+        port = get_port(params)
+        @ip = params[:ip] || 'localhost' # TODO: check ip
+        @uri = "druby://#{@ip}:#{port}"
+        # to remote calls for unmarshallable objects
+        DRb.start_service
+      end
+
+      # TODO: add callbacks
+      def method_missing(method, *args, &block)
+        Log.debug("RPC Client calling '#{method}' on #{@uri}")
+        # FIXME: don't send +start+ and +stop+ and +initialize+
+        begin
+          service = DRbObject.new_with_uri(@uri)
+          res = service.send(method, *args, &block)
+          Log.debug("RPC Client method '#{method}' handled on #{@uri}")
+          res
+        rescue StandardError
+          Log.warn("RPC Client ERROR: no connection")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/evesync/ipc/data/file.rb

@@ -0,0 +1,64 @@
+require 'evesync/ipc/data/hashable'
+require 'evesync/ntp'
+
+module Evesync
+  module IPC
+    module Data
+      class File
+        include Hashable
+        extend Unhashable
+
+        module Action
+          MODIFY = :modify # File was modified
+          DELETE = :delete # File was deleted
+          MOVED_TO = :moved_to # File was renamed
+          CREATE = :create # File was created
+        end
+
+        attr_reader :name, :mode, :action, :timestamp
+
+        def initialize(params)
+          @name = params[:name].freeze
+          @mode = params[:mode].freeze
+          @action = parse_action(params[:action]).freeze
+          @timestamp = params[:timestamp] || NTP.timestamp
+          @content = params[:content] || IO.read(@name).freeze if ::File.exist? @name
+        end
+
+        def ==(other)
+          (@name == other.name) &&
+            (@action == other.action) &&
+            (@mode == other.mode)
+          # timestamps may differ
+          # conten comparing may cost too much
+        end
+
+        #  The content of a file for remote call. Sends as
+        #  a plain text(?), no extra calls between machines.
+        #
+        # = TODO
+        #  * Think about binary data
+        #  * Encoding information
+        #  * Large file sending
+        attr_reader :content
+
+        private
+
+        def parse_action(action)
+          case action.to_s
+          when /modify/i
+            result = Action::MODIFY
+          when /delete/i
+            result = Action::DELETE
+          when /moved_to/i
+            result = Action::MOVED_TO
+          when /create/i
+            result = Action::CREATE
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/evesync/ipc/data/hashable.rb

@@ -0,0 +1,74 @@
+require 'evesync/log'
+require 'json'
+
+module Evesync
+  module IPC
+    module Data
+      # The class, that includes it must implement method
+      # *initialize(params)*
+      # This is a MUST BE requirement
+      #
+      module Hashable
+        def to_hash
+          hash = {}
+          instance_variables.each do |var|
+            value = instance_variable_get(var)
+
+            if value.respond_to? :to_hash
+              # FIXME: if it wasn't implemented it'll be an error
+              # for a complex type
+              hash[var] = value.to_hash
+              hash[var]['type'] = value.class.to_s
+            else
+              hash[var] = value
+            end
+            hash['type'] = self.class.to_s
+          end
+          Log.debug("IPC Data message hash created: #{hash}")
+          hash
+        end
+      end
+
+      module Unhashable
+        def from_hash(hash)
+          Log.debug("IPC Data message hash parsing: #{hash}")
+          params = {}
+          hash.each do |key, value|
+            next unless key =~ /^@/
+
+            if value.is_a? Hash
+              # FIXME: code dumplication ipc_data.rb:31
+              begin
+                cl = Object.const_get value['type']
+              rescue NameError => e
+                Log.fatal("IPC Data Unsupported type: #{hash['type']}")
+                raise e
+              end
+
+              unless cl.respond_to? :from_hash
+                err_msg = "IPC Data ERROR Class #{cl} must implement `self.from_hash'"
+                Log.fatal(err_msg)
+                raise err_msg
+              end
+
+              complex_value = cl.from_hash value
+              params[key.sub('@', '').to_sym] = complex_value
+            else
+              params[key.sub('@', '').to_sym] = value
+            end
+          end
+
+          begin
+            # If the `type' is imported it will be used
+            cl = Object.const_get hash['type']
+          rescue TypeError, NameError
+            # Or the base class will be the type
+            cl = self
+          end
+
+          cl.new(params)
+        end
+      end
+    end
+  end
+end

data/lib/evesync/ipc/data/ignore.rb

@@ -0,0 +1,22 @@
+require 'evesync/ipc/data/hashable'
+
+module Evesync
+  module IPC
+    module Data
+      class Ignore
+        include Hashable
+        extend Unhashable
+
+        attr_reader :subject
+
+        def initialize(params)
+          @subject = params[:subject]
+        end
+
+        def to_s
+          "Ignoring: #{@subject}"
+        end
+      end
+    end
+  end
+end

data/lib/evesync/ipc/data/package.rb

@@ -0,0 +1,58 @@
+require 'evesync/ipc/data/hashable'
+
+module Evesync
+  module IPC
+    module Data
+      class Package
+        include Data::Hashable
+        extend Data::Unhashable
+
+        module Command
+          INSTALL   = :install
+          UPDATE    = :update
+          DOWNGRADE = :downgrade
+          REMOVE    = :remove
+          UNKNOWN   = :unknown
+        end
+
+        attr_reader :name, :version, :command, :timestamp
+
+        def initialize(params)
+          @name = params[:name].freeze
+          @version = params[:version].freeze
+          @command = parse_command(params[:command]).freeze
+          @timestamp = params[:timestamp] || NTP.timestamp
+        end
+
+        def ==(pkg)
+          (pkg.name == @name) &&
+            (pkg.version == @version) &&
+            (pkg.command == @command)
+        end
+
+        def to_s
+          "Package(#{@command.upcase}: #{name}-#{@version})"
+        end
+
+        private
+
+        def parse_command(command)
+          cmd = case command
+                when /^inst\w+$/
+                  Command::INSTALL
+                when /^(remove\w*|delete\w*)$/
+                  Command::REMOVE
+                when /^(update\w*|upgrade\w*)$/
+                  Command::UPDATE
+                when /^downgrade\w*$/
+                  Command::DOWNGRADE
+                else
+                  Command::UNKNOWN
+                end
+
+          cmd.to_s
+        end
+      end
+    end
+  end
+end

data/lib/evesync/ipc/data/utils.rb

@@ -0,0 +1,14 @@
+Dir[File.dirname(__FILE__) + '/*.rb'].each do |file|
+  require file unless file.include?(__FILE__)
+end
+
+module Evesync
+  module IPC
+    module Data
+      def self.from_json(json)
+        hash = JSON.parse(json)
+        Class.new.extend(Unhashable).from_hash(hash)
+      end
+    end
+  end
+end

data/lib/evesync/ipc/data.rb

@@ -0,0 +1,50 @@
+require 'drb/drb'
+
+# TODO: add custom exceptions for IPCData
+module Evesync
+  module IPCData
+    def self.pack(message)
+      unless message.respond_to? :to_hash
+        err_msg = "IPC ERROR Instance #{message} must implement `to_hash'"
+        Log.fatal(err_msg)
+        raise err_msg
+      end
+
+      hash = message.to_hash
+
+      hash.to_json
+    end
+
+    def self.unpack(message)
+      unless message.is_a? String
+        raise "IPC ERROR message #{message} must be of type String"
+      end
+
+      begin
+        hash = JSON.parse(message)
+      rescue JSON::ParseError => e
+        Log.fatal("IPC ERROR Unable to parse message #{message}")
+        raise e
+      end
+
+      begin
+        Log.debug("IPC Accepted basic hash #{hash}")
+        cl = Object.const_get hash['type']
+      rescue NameError => e
+        # FIXME: just sent JSON, this event will be delegated
+        # to another daemon (maybe) with fields:
+        # redirect_to_port: <port number>
+        Log.fatal("Unsupported basic type #{hash['type']}")
+        raise e
+      end
+
+      unless cl.respond_to? :from_hash
+        err_msg = "IPC ERROR Class #{cl} must implement `self.from_hash'"
+        Log.fatal(err_msg)
+        raise err_msg
+      end
+
+      cl.from_hash hash
+    end
+  end
+end

data/lib/evesync/ipc/ipc.rb

@@ -0,0 +1,42 @@
+require 'evesync/config'
+
+module Evesync
+  #
+  # Constants and helpful functions for Evesync::IPC module.
+  #
+  module IPC
+    $SAFE = 1 # 'no eval' rule
+
+    private
+
+    # Checks if params have the provided keys
+    #
+    # [*Raise*] RuntimeError if params don't include on of the
+    #             keys
+    def check_params_provided(params, keys)
+      keys.each do |param|
+        raise ":#{param} missed" unless
+          params.key?(param)
+      end
+    end
+
+    # Maps symbols like :evemond, :evehand to appropriate
+    # port number.
+    #
+    # [*Return*] Port number, if it's in (49152..65535)
+    #             or one of daemons' name
+    def get_port(params)
+      port = params[:port]
+      if port.is_a? Symbol
+        Config[port.to_s]['port']
+      else
+        port_i = port.to_i
+        unless (port_i < 65_535) && (port_i > 49_152)
+          raise RuntimeError.call('Port MUST be in (49152..65535)')
+        end
+
+        port
+      end
+    end
+  end
+end

data/lib/evesync/ipc/server.rb

@@ -0,0 +1,56 @@
+require 'drb/drb'
+require 'evesync/log'
+require 'evesync/ipc/ipc'
+
+module Evesync
+  module IPC
+
+    ##
+    # Server is a DRb object, using +:port+ and +:proxy+
+    # object to handle requests.
+    #
+    # = Params
+    #
+    # [*:proxy*] all methods go to this object
+    # [*:port*]  defines which port which port connect to
+    #
+    # = Example:
+    #
+    #   # Setup the server
+    #   server = Evesync::IPC::Server(
+    #     :port => '8089',
+    #     :proxy => SomeHandler.new
+    #   )
+    #   ...
+    #   server.start # now it starts recieving requests
+    #   ...
+    #   server.stop # main thread exits
+    #
+    # TODO:
+    #   * Handle blocks
+
+    class Server
+      include IPC
+
+      attr_reader :uri
+
+      def initialize(params)
+        check_params_provided(params, %i[port proxy])
+        port = get_port params
+        ip = params[:ip] || 'localhost'
+        @uri = "druby://#{ip}:#{port}"
+        @proxy = params[:proxy]
+      end
+
+      def start
+        DRb.start_service(@uri, @proxy)
+        self
+      end
+
+      def stop
+        DRb.thread.exit
+        self
+      end
+    end
+  end
+end