evesync 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acd82817da3db48b0d5f142a1a5764f50617e9e56abd55d9ecb20cd92cca0aaf
-  data.tar.gz: 3dc586adc166118cda1961d6489914cb2193319642ab6c2fde7897db17f9a0a4
+  metadata.gz: 32546fdd2bf3681b09b5d76b29a9afe2559f726f328274b8d0cccbe26a6cbc46
+  data.tar.gz: b9e529c9972c92dcc3035ef8028600c6ecfe30004dd704dc01c0f45eb8728cce
 SHA512:
-  metadata.gz: 4b6b3ab34063bd3f57ac41b2859983f999bc1cdab2a31b7a7da69b750ab564c8e7637c56250a4eca24aa958ae9b578730d2aa8cbffbb2a2acf6112bbd18cbaae
-  data.tar.gz: 13897826a7bb2aee1e25f17a811c66483268e6a2f78e68a0797bc07ae74d33420c450a1ceb0134180858a72fcb656cc2b67ccad94b65a7471b11bbb5953f1d07
+  metadata.gz: 0d467ccd88887d72c85056c0097838cb9e11416e07d1ab2b3b616642a0984cef50c1a60cf0f3595c9c4e6aa806f4bd48fc2581aea56fe374c6f5a1bb669ceb38
+  data.tar.gz: 836b9e00da567d26161402c41146b37166d60627e536b0e4a26c6e154ee54fc21f2ed439ee09b0e9280b25be7663119229eab09eb98a2e2ef2e9c18ead41e8b8

data/Rakefile

@@ -56,17 +56,20 @@ end
 
 ## Docker related targets
 
-task :docker do
-  sh 'docker-compose build'
-end
+namespace :docker do
 
-task :up do
-  sh 'docker-compose up -d'
-end
+  task :build do
+    sh 'docker-compose build'
+  end
 
-task :down do
-  sh 'docker-compose stop || docker-compose kill ||:'
-  sh 'docker-compose rm --force ||:'
+  task :up do
+    sh 'docker-compose up -d node-1 node-2'
+  end
+
+  task :down do
+    sh 'docker-compose stop || docker-compose kill ||:'
+    sh 'docker-compose rm --force ||:'
+  end
 end
 
 namespace :rhel do

data/bin/evedatad

@@ -1,34 +1,12 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby -*-
 
-require 'evesync/ipc/server'
-require 'evesync/log'
+require 'evesync/service'
 require 'evesync/database'
 
-Evesync::Log.info('Database daemon starting...')
-
-database = Evesync::Database.new
-
-# Creating an IPC server to accept data
-data_server = Evesync::IPC::Server.new(
-  port: :evedatad,
-  proxy: database
-).start
-
-Signal.trap('TERM') do
-  data_server.stop
-  exit(0)
+evedata = Evesync::Service.new(:evedatad) do |config|
+  config.proxy = Evesync::Database.new
+  # zip db if needed, save backup
 end
 
-Evesync::Log.info('Database daemon started!')
-
-begin
-  loop do
-    sleep 3600 # FIXME: 1 hour, rewrite better
-    # zip db if needed, save backup
-  end
-rescue SignalException => e
-  data_server.stop
-  Evesync::Log.warn("Database daemon received signal: #{e.signm}(#{e.signo})")
-  exit(0)
-end
+evedata.start

data/bin/evehand

@@ -1,36 +1,12 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby -*-
 
-require 'evesync/log'
-require 'evesync/ipc/server'
+require 'evesync/service'
 require 'evesync/handler'
 
-Evesync::Log.info('Handle daemon starting...')
-
-all_handler = Evesync::Handler.new
-
-handler_server = Evesync::IPC::Server.new(
-  port: :evehand,
-  proxy: all_handler,
-  ip: '*' # accept remote requests
-).start
-
-Evesync::Log.info('Handle daemon started!')
-
-# Signal handling
-
-Signal.trap('TERM') do
-  handler_server.stop
-  exit(0)
+evehand = Evesync::Service.new(:evehand) do |config|
+  config.proxy = Evesync::Handler.new
+  config.ip = '*'
 end
 
-begin
-  loop do
-    sleep 3600 # FIXME: 1 hour, rewrite better
-    # FIXME: know what to do
-  end
-rescue SignalException => e
-  handler_server.stop
-  Evesync::Log.warn("Received signal: #{e.signm}(#{e.signo})")
-  exit(0)
-end
+evehand.start

data/bin/evemond

@@ -1,42 +1,18 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby -*-
 
-require 'evesync/log'
-require 'evesync/ipc/server'
+require 'evesync/service'
 require 'evesync/trigger'
 require 'evesync/watcher'
 
-Evesync::Log.info 'Monitoring daemon starting...'
-
 queue = Queue.new
 trigger = Evesync::Trigger.new(queue)
 watcher = Evesync::Watcher.new(queue)
 
-[trigger, watcher].each(&:start)
-
-evesync_server = Evesync::IPC::Server.new(
-  port: :evemond,
-  proxy: trigger
-).start
-
-Evesync::Log.info 'Monitoring daemon started!'
-
-# Signal handling
-
-Signal.trap('SIGINT') do
-  [watcher, trigger].each(&:stop)
-  evesync_server.stop
-  exit(0)
+evemon = Evesync::Service.new(:evemond) do |config|
+  config.proxy = trigger
+  config.at_start = lambda { [trigger, watcher].each(&:start) }
+  config.at_exit  = lambda { [trigger, watcher].each(&:stop)  }
 end
 
-begin
-  loop do
-    sleep 100
-    # FIXME: know what to do
-  end
-rescue SignalException => e
-  watcher.stop
-  evesync_server.stop
-  Evesync::Log.warn("Monitoring daemon received signal: #{e.signm}(#{e.signo})")
-  exit(0)
-end
+evemon.start

data/bin/evesync

@@ -14,28 +14,24 @@ require 'evesync/config'
 require 'evesync/sync'
 require 'evesync/ipc/client'
 
-DB_TAG = 'db'
-FILES_TAG = 'files'
+DB_TAG    = 'db'.freeze
+FILES_TAG = 'files'.freeze
 
-opts = {}
+opts     = {}
 $program = File.basename($0)
-#Evesync::Log.level = :warn
-Evesync::Log.simple = true
 
 def kill_by_pid(daemon)
   begin
-    Process.kill('TERM', File.read("/var/run/evesync/#{daemon}.pid").to_i)
-  rescue Errno::ESRCH
+    puts "Killing #{daemon}..."
+    pid = File.read("/var/run/evesync/#{daemon}.pid").to_i
+    Process.kill('INT', pid)
+  rescue Errno::ESRCH, Errno::ENOENT
     puts("#{daemon} already killed")
   end
 end
 
 def spawn_daemon(daemon)
-  pid = spawn(daemon,
-        :err => "/var/log/evesync/#{daemon}.log",
-        :out=>:err)
-  File.write("/var/run/evesync/#{daemon}.pid", pid)
-  pid
+  system(daemon)
 end
 
 OptionParser.new do |parser|
@@ -84,8 +80,6 @@ OptionParser.new do |parser|
 
   # TODO: refactor
   parser.on('-r', '--run', 'Start daemons') do
-    FileUtils.mkdir_p '/var/log/evesync'
-    FileUtils.mkdir_p '/var/run/evesync'
     spawn_daemon 'evedatad'
     spawn_daemon 'evemond'
     spawn_daemon 'evehand'
@@ -99,10 +93,8 @@ OptionParser.new do |parser|
       kill_by_pid 'evesyncd'
       kill_by_pid 'evedatad'
     rescue StandardError => e
-      puts("Error: #{e}")
-      puts('Something went wrong while killing processes. Do it yourself!')
-    ensure
-      FileUtils.rm_f Dir.glob('/var/run/evesync/*.pid')
+      puts("(!) Error: #{e} (!)")
+      puts('Something went wrong while killing processes...')
     end
   end
 end.parse!

data/bin/evesyncd

@@ -1,44 +1,17 @@
 #!/usr/bin/env ruby
 # -*- mode: ruby -*-
 
-require 'evesync/log'
+require 'evesync/service'
 require 'evesync/sync'
-require 'evesync/config'
-require 'evesync/ipc/server'
-
-# Exiting if `auto_discover = false'
-unless Evesync::Config['auto_discover']
-  Evesync::Log.info('Synchronizing not required')
-  exit(0)
-end
-
-Evesync::Log.info('Synchronizing daemon starting...')
 
 sync = Evesync::Sync.new
 
-sync_server = Evesync::IPC::Server.new(
-  port: :evesyncd,
-  proxy: sync
-).start
-
-Signal.trap('TERM') do
-  sync_server.stop
-  exit(0)
+evesync = Evesync::Service.new(:evesyncd) do |config|
+  config.proxy = sync
+  config.at_start = sync.method(:discover)
+  config.interval = 15 # TODO: read from config
 end
 
-Evesync::Log.info('Synchronizing daemon started!')
-
-few_seconds = Evesync::Config['discover_timeout'].to_i
-
-sync.discover                   # discovering nodes
-sleep 3                         # giving 3 seconds to complete
-
-begin
-  loop do
-    sync.synchronize            # updating this node
-    sleep few_seconds           # ... in some interval
-  end
-rescue SignalException
-  sync_server.stop
-  exit(0)
+evesync.start do
+  sync.synchronize
 end

data/bin/start

@@ -1,16 +1,5 @@
 #!/usr/bin/env bash
-trap 'echo Exiting; \
-	pkill evedatad; \
-	pkill evemond; \
-	pkill evehand; \
-	pkill evesyncd
-	exit 1' 2
-evedatad &
-evemond &
-evehand &
-sleep 3s
-evesyncd &
-
-while true; do
-    sleep 1000
-done
+evedatad
+evemond
+evehand
+evesyncd

data/lib/evesync.rb

@@ -1,3 +1,3 @@
 module Evesync
-  VERSION = '1.0.7'.freeze
+  VERSION = '1.0.8'.freeze
 end

data/lib/evesync/constants.rb

@@ -9,7 +9,7 @@ module Evesync
     DB_PATH       = '/var/lib/evesync/db/'.freeze
     DB_FILES_PATH = '/var/lib/evesync/files/'.freeze
 
-    DEFAULT_LOGLEVEL = 'info'.freeze
+    DEFAULT_LOGLEVEL = :info
 
     DISCOVER_TIMEOUT = 3600
     WATCH_INTERVAL   = 2

data/lib/evesync/discover.rb

@@ -1,6 +1,9 @@
 require 'evesync/ipc/client'
 require 'evesync/log'
 require 'evesync/config'
+require 'evesync/os'
+
+require 'json'
 
 module Evesync
 
@@ -35,14 +38,14 @@ module Evesync
     # Sending UDP message on broadcast
     # Discovering our nodes
 
-    def send_discovery_message(ip = '<broadcast>', message = DISCOVERY_REQ)
+    def send_discovery_message(ip='<broadcast>', message=DISCOVERY_REQ)
       udp_sock = UDPSocket.new
-      if ip == '<broadcast>'
+      if is_broadcast(ip)
         udp_sock.setsockopt(
           Socket::SOL_SOCKET, Socket::SO_BROADCAST, true
         )
       end
-      udp_sock.send(message, 0, ip, @port)
+      udp_sock.send(to_discover_msg(message: message), 0, ip, @port)
       udp_sock.close
     end
 
@@ -54,17 +57,18 @@ module Evesync
 
     def listen_discovery
       loop do
-        data, recvdata = @listen_sock.recvfrom(1024)
+        datajson, recvdata = @listen_sock.recvfrom(1024)
         node_ip = recvdata[-1]
 
         next if Utils.local_ip?(node_ip)
 
-        if [DISCOVERY_REQ, DISCOVERY_ANS].include? data
+        data = from_discover_msg(datajson)
+        if fine_node?(data)
           # Push new node_ip to trigger
           @evesync.add_remote_node(node_ip)
         end
 
-        case data
+        case data['message']
         when DISCOVERY_REQ
           Log.info("Discover host request got: #{node_ip}")
           send_discovery_message(node_ip, DISCOVERY_ANS)
@@ -73,5 +77,29 @@ module Evesync
         end
       end
     end
+
+    def to_discover_msg(msg)
+      {
+        evesync: {
+          message: msg,
+          os: EVESYNC_OS,
+        }
+      }.to_json.freeze
+    end
+
+    def from_discover_msg(data)
+      JSON.parse(data)['evesync'] # TODO: catch error
+    end
+
+    def is_broadcast(ip)
+      ip == '<broadcast>'
+    end
+
+    def fine_node?(data)
+      [
+        [DISCOVERY_ANS, DISCOVERY_REQ].include?(data['message']),
+        data['os'] == EVESYNC_OS,
+      ].all?
+    end
   end
 end

data/lib/evesync/ipc/server.rb

@@ -48,7 +48,7 @@ module Evesync
       end
 
       def stop
-        DRb.thread.exit
+        DRb.stop_service
         self
       end
     end

data/lib/evesync/log.rb

@@ -1,62 +1,105 @@
-require 'logger'
 require 'evesync/config'
 require 'evesync/constants'
 
+require 'syslog'
+require 'logger'
+require 'fileutils'
 
 module Evesync
 
-  # This module is responsible for logging
+  # Logging via syslog
   module Log
     # Supported levels for logging
-    LEVELS = %i[debug info warn error fatal].freeze
+    LEVELS = %i[debug info notice warn error fatal]
+    def LEVELS.less(a, b)
+      (self.index(a) <=> self.index(b) or -1) >= 0
+    end
+
+    # Default engine for logging, one of (:io, :syslog)
+    DEFAULT_ENGINE = :io
+
+    # Log level mapping for syslog
+    SYSLOG = {
+      :debug  => Syslog::LOG_DEBUG,
+      :info   => Syslog::LOG_INFO,
+      :notice => Syslog::LOG_NOTICE,
+      :warn   => Syslog::LOG_WARNING,
+      :error  => Syslog::LOG_ERR,
+      :fatal  => Syslog::LOG_CRIT,
+      #:alert => Syslog::LOG_ALERT,
+      #:emerg => Syslog::LOG_EMERG,
+    }
+
+    SYSLOG_OPTIONS = [
+      Syslog::LOG_PID,
+      Syslog::LOG_NOWAIT,
+      Syslog::LOG_CONS,
+      Syslog::LOG_PERROR,
+    ].inject(&:|)
+
+    SYSLOG_FACILITY = [
+      Syslog::LOG_DAEMON,
+      Syslog::LOG_LOCAL5,
+    ].inject(&:|)
 
+    # Public methods available via Log.method
     class << self
-      def method_missing(m, *args)
-        # Unlisted methods are not allowed
-        raise NoMethodError unless LEVELS.include?(m)
 
-        check_logger
-        @logger.send(m, to_string(*args))
-        nil
-      end
+      LEVELS.each do |level|
+        define_method(level) do |*args|
+          check_logger
+          return unless LEVELS.less(level.to_sym, @level.to_sym)
 
-      def check_logger
-        init_logger unless @logger
+          case @engine
+          when :syslog
+            @logger.log(SYSLOG[level], to_string(*args))
+          when :io
+            @logger.send(level, to_string(*args))
+          end
+
+          nil           # prevent from being able to access the object
+        end
       end
 
       def level=(lvl)
         check_logger
-        if lvl.is_a?(Symbol) or lvl.is_a?(String)
-          @logger.level =
-            begin
-              Logger.const_get(lvl.to_s.upcase)
-            rescue NameError
-              Logger::DEBUG
-            end
-        end
+        raise "Unknown level #{lvl}" unless LEVELS.include? lvl
+        @level = lvl
       end
 
       def level
-        check_logger
-        @logger.level
+        @level
       end
 
-      def simple=(bool)
+      def check_logger
         init_logger unless @logger
-        if bool
-          @logger.formatter = proc do |_sev, _dt, _prog, msg|
-            "#{msg}\n"
-          end
-        end
       end
 
+      def engine=(engine)
+        raise UnsupportedLogEngine.new(engine) \
+          unless [:syslog, :io].member? engine
+        @engine = engine
+      end
+
+      # Using syslog implementation
       def init_logger
-        @logger = Logger.new(STDERR)
-        @logger.formatter = proc do |sev, dtime, _prog, msg|
-          time = dtime.strftime('%Y-%m-%d %H:%M:%S')
-          prog = File.basename($PROGRAM_NAME)
-          "[#{time}] #{prog.ljust(8)} #{sev.ljust(5)}: #{msg}\n"
+        @engine ||= DEFAULT_ENGINE
+        prog = File.basename($PROGRAM_NAME)
+
+        case @engine
+        when :syslog
+          @logger = Syslog.open(prog, SYSLOG_OPTIONS, SYSLOG_FACILITY)
+
+        when :io
+          FileUtils.mkdir_p '/var/log/evesync/'
+          @logger = Logger.new("/var/log/evesync/#{prog}.log")
+          @logger.formatter = proc do |sev, dtime, _prog, msg|
+            time = dtime.strftime('%Y-%m-%d %H:%M:%S')
+            "[#{time}] #{prog.ljust(8)} #{sev.ljust(5)}: #{msg}\n"
+          end
         end
+
+        @level  = Config[:loglevel] || :info
       end
 
       def to_string(*args)

data/lib/evesync/os/linux.rb

@@ -2,8 +2,13 @@ text = File.new('/etc/os-release').read
 
 if text =~ /^ID.*(rhel|centos|fedora)/
   require 'evesync/os/linux/rhel'
+  EVESYNC_OS = 'rhel'.freeze
 elsif text =~ /ID.*arch/
   require 'evesync/os/linux/arch'
+  EVESYNC_OS = 'arch'.freeze
 elsif text =~ /ID.*debian/
   require 'evesync/os/linux/deb'
+  EVESYNC_OS = 'deb'.freeze
+else
+  EVESYNC_OS = 'not implemented'
 end

data/lib/evesync/service.rb

@@ -0,0 +1,104 @@
+require 'evesync/log'
+require 'evesync/ipc/server'
+
+require 'fileutils'
+
+module Evesync
+  # Class for creating daemons which are DRb servers with
+  # proxy object to accept requests.
+  #
+  # Traps signals to exit.
+  #
+  # Example:
+  #  d = Evesync::Service.new(:mydaemond) do |config|
+  #    config.proxy = SomeProxyObject.new
+  #  end
+  #
+  #  d.start
+  #
+  class Service
+    def initialize(name)
+      @factory = ServiceFactory.new
+      @factory.name = name unless name.nil?
+      yield @factory
+    end
+
+    def start
+      daemonize
+
+      Log.info("#{@factory.name} daemon starting...")
+
+      @ipc_server = IPC::Server.new(
+        port: @factory.port,
+        proxy: @factory.proxy,
+        ip: @factory.ip,
+      ).start
+
+      Signal.trap('TERM') do
+        @ipc_server.stop
+        exit 0
+      end
+
+      Log.info("#{@factory.name} daemon started!")
+
+      @factory.at_start.call if @factory.at_start.respond_to? :call
+
+      loop do
+        sleep @factory.interval
+        yield if block_given?
+      end
+
+    rescue SignalException => e
+      Log.warn("#{@factory.name} daemon received signal: " \
+               "#{e.signm}(#{e.signo})")
+      exit 0
+
+    # rubocop:disable Lint/RescueException
+    rescue Exception => crit
+      Log.fatal(crit)
+      crit.backtrace.each { |line| Log.fatal(line) }
+      exit 1
+
+    # rubocop:enable Lint/RescueException
+    ensure
+      @factory.at_exit.call if @factory.at_exit.respond_to? :call
+      @ipc_server.stop
+    end
+
+    def daemonize
+      Process.daemon
+      Process.setproctitle(@factory.name.to_s) \
+        if Process.respond_to? :setproctitle
+      $0 = @factory.name.to_s
+      FileUtils.mkdir_p @factory.pids
+      File.open("#{@factory.pids}/#{@factory.name}.pid", 'w') do |f|
+        f.puts(Process.pid)
+      end
+    end
+  end
+
+  class ServiceFactory
+    attr_accessor :name, :proxy, :at_start, :at_exit
+    attr_writer   :interval, :port, :ip, :logs, :pids
+
+    def logs
+      @logs || '/var/log/evesync/'
+    end
+
+    def pids
+      @pids || '/var/run/evesync/'
+    end
+
+    def port
+      @port || name.to_sym
+    end
+
+    def ip
+      @ip || 'localhost'
+    end
+
+    def interval
+      @interval || 3600
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: evesync
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.0.8
 platform: ruby
 authors:
 - Kiselev Valentine
@@ -163,6 +163,7 @@ files:
 - lib/evesync/os/linux/rhel/package_manager.rb
 - lib/evesync/os/linux/rhel/package_watcher.rb
 - lib/evesync/os/linux/rhel/rpm.rb
+- lib/evesync/service.rb
 - lib/evesync/sync.rb
 - lib/evesync/trigger.rb
 - lib/evesync/trigger/base.rb