epi 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65b6f4c3b4d118849bb76a9bb617296e7abfc0d0
-  data.tar.gz: 01905d5290fbadfe2ab466a0c6d593c88a3b0a7d
+  metadata.gz: ff6e7a2df3b27a605072bbedff81ea4ebb5b7c1b
+  data.tar.gz: 4609bab09c0142f2206cb733d28fb22387806fa0
 SHA512:
-  metadata.gz: a17b31c2de560b44ff2cc927eaaaee9a987bb828ea526367d8fd57da134f651ca5a99e3c91e7f9b22db80383e3272835bf1a4bc569368741bc74ee95a98ffd6e
-  data.tar.gz: f1c1de71a10027df1c70c137716034eec7a462f729383f81552e4f7132844956bd3a15e20b240d430cff8f6e941b6a0cb5f5da0a11a72f1cc21c1acd59a114df
+  metadata.gz: bb50900af4312e6959956ec5a61af06f7dee51d8f509577e56eb55027c23a7a7c43e6dd2ea4ec03425e1bc0f880d9926e094667f55b0a7eb2d7b2c3ace8427bb
+  data.tar.gz: 491f3d33d0b2be9d558f159c0ac8f502a037cbea1536444c4a53ea9c77739f208ebe05507c0c895fc47e2e4b3be29401618abba1ff3ea17448b283e23c5e3608

data/bin/epi

@@ -8,7 +8,7 @@ if $0 == __FILE__
     %w[INT TERM].each do |s|
       Signal.trap(s) do
         puts " #{s} => bye for now!"
-        EventMachine.stop
+        EventMachine.stop rescue nil
       end
     end
     Epi::Cli.run ARGV

data/lib/epi/cli/command.rb

@@ -19,8 +19,15 @@ module Epi
           @args = args
         end
 
+        def need_root!
+          process = Epi::Daemon.process
+          raise Exceptions::Fatal, 'You need root privileges to manage this daemon' if
+              process && process.was_alive? && process.root? && !Epi.root?
+        end
+
       end
 
+      Dir[File.expand_path '../commands/concerns/*.rb', __FILE__].each { |f| require f }
       Dir[File.expand_path '../commands/*.rb', __FILE__].each { |f| require f }
     end
   end

data/lib/epi/cli/commands/concerns/daemon.rb

@@ -0,0 +1,33 @@
+module Epi
+  module Cli
+    module Concerns
+      module Daemon
+
+        protected
+
+        def need_daemon!
+          raise Exceptions::Fatal, 'No daemon is running' unless Epi::Daemon.running?
+        end
+
+        def need_no_daemon!
+          raise Exceptions::Fatal, 'Daemon is already running' if Epi::Daemon.running?
+        end
+
+        def shutdown(&callback)
+          Epi::Daemon.send :shutdown, &callback
+          puts 'Shutting down ...'
+        end
+
+        def resume(&callback)
+          begin
+            Timeout::timeout(5) { sleep 0.05 while Epi::Daemon.socket_path.exist? }
+          rescue Timeout::Error
+            raise Exceptions::Fatal, 'Daemon failed to stop after 5 seconds'
+          end
+          Epi::Daemon.send :start, &callback
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/cli/commands/config.rb

@@ -6,20 +6,28 @@ module Epi
         def run
           case args.shift
             when 'add' then add
-            else raise Exceptions::Fatal, 'Unknown config command, use [ add ]'
+            when 'remove' then remove
+            else raise Exceptions::Fatal, 'Unknown config command, use [ add | remove ]'
           end
         end
 
         private
 
         def add
+          Epi::Daemon.send config: {add_paths: paths}
+        end
+
+        def remove
+          Epi::Daemon.send config: {remove_paths: paths}
+        end
+
+        def paths
           raise Exceptions::Fatal, 'No path given' unless args.first
-          paths = args.map do |path|
+          @paths ||= args.map do |path|
             path = Pathname(path)
             path = Pathname('.').realpath.join(path) unless path.absolute?
             path.to_s
           end
-          Epi::Server.send config: {add_paths: paths}
         end
 
       end

data/lib/epi/cli/commands/daemon.rb

@@ -0,0 +1,14 @@
+module Epi
+  module Cli
+    module Commands
+      class Daemon < Command
+
+        def run
+          Epi::Daemon.run
+          puts 'Daemon is running'
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/cli/commands/job.rb

@@ -10,7 +10,7 @@ module Epi
           raise Exceptions::Fatal, 'No instruction given' if instruction.empty?
           raise Exceptions::Fatal, 'Invalid instruction' unless
               instruction =~ /^((\d+ )?(more|less)|\d+|pause|resume|reset|max|min|restart)$/
-          Epi::Server.send job: {id: id, instruction: instruction}
+          Epi::Daemon.send job: {id: id, instruction: instruction}
         end
 
       end

data/lib/epi/cli/commands/restart.rb

@@ -0,0 +1,16 @@
+module Epi
+  module Cli
+    module Commands
+      class Restart < Command
+        include Concerns::Daemon
+
+        def run
+          need_root!
+          need_daemon!
+          Epi::Daemon.send(:stop_all) { shutdown { resume } }
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/cli/commands/start.rb

@@ -0,0 +1,15 @@
+module Epi
+  module Cli
+    module Commands
+      class Start < Command
+        include Concerns::Daemon
+
+        def run
+          need_no_daemon!
+          Epi::Daemon.send :start
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/cli/commands/status.rb

@@ -4,10 +4,14 @@ module Epi
       class Status < Command
 
         def run
-          Epi::Server.send :status
+          if Epi::Daemon.running?
+            Epi::Daemon.send :status
+          else
+            Epi::Daemon.send(:start) { Epi::Daemon.send :status }
+          end
         end
 
       end
     end
   end
-end
+end

data/lib/epi/cli/commands/stop.rb

@@ -0,0 +1,16 @@
+module Epi
+  module Cli
+    module Commands
+      class Stop < Command
+        include Concerns::Daemon
+
+        def run
+          need_root!
+          need_daemon!
+          Epi::Daemon.send(:stop_all) { shutdown }
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/cli.rb

@@ -6,7 +6,7 @@ module Epi
     class << self
 
       def run(args)
-        command = args.shift
+        command = args.shift || 'status' # The default command
         begin
           Command.run command, args
         rescue Exceptions::Fatal => error

data/lib/epi/connection.rb

@@ -0,0 +1,7 @@
+require 'eventmachine'
+
+module Epi
+  class Connection < EventMachine::Connection
+    include EventMachine::Protocols::ObjectProtocol
+  end
+end

data/lib/epi/core_ext/inflector.rb

@@ -1,6 +1,6 @@
 class String
   def camelize
-    gsub(/(^|_)[a-z\d]/) { |m| m.upcase }
+    gsub(/(^|_)[a-z\d]/) { |m| m[-1].upcase }
   end
 end
 

data/lib/epi/daemon/receiver.rb

@@ -0,0 +1,37 @@
+require_relative '../connection'
+
+module Epi
+  module Daemon
+    class Receiver < Connection
+
+      def logger
+        Epi.logger
+      end
+
+      def receive_object(data)
+        logger.debug "Received message of type '#{data[:type]}'"
+        begin
+          Responder.run(self, data.delete(:type).to_s, data) { |result| send_object result: result }
+        rescue Exceptions::Shutdown
+          send_object result: nil
+          Daemon.shutdown
+        rescue => error
+          send_object error: {
+              class: error.class.name,
+              message: error.message,
+              backtrace: error.backtrace
+          }
+        end
+      end
+
+      def puts(text)
+        print "#{text}\n"
+      end
+
+      def print(text)
+        send_object print: text.to_s
+      end
+
+    end
+  end
+end

data/lib/epi/{server → daemon}/responder.rb

@@ -1,5 +1,5 @@
 module Epi
-  module Server
+  module Daemon
     unless defined? Responder
       class Responder
         include Exceptions
@@ -9,13 +9,17 @@ module Epi
         # @param receiver [Receiver] The receiver that is running the responder
         # @param name [String] Name of the responder to invoke, e.g. 'command'
         # @param data [Hash] Data included in the message, to be extracted onto the responder before it is run
-        def self.run(receiver, name, data)
+        def self.run(receiver, name, data, &callback)
           klass_name = name.camelize.to_sym
           klass = Responders.const_defined?(klass_name) && Responders.const_get(klass_name)
           raise Fatal, 'Unknown message type' unless Class === klass && klass < Responder
-          responder = klass.new(receiver)
+          responder = klass.new(receiver, callback)
           data.each { |key, value| responder.__send__ :"#{key}=", value }
-          responder.run
+          if responder.respond_to? :run_async
+            responder.run_async
+          else
+            yield responder.run
+          end
         end
 
         attr_reader :receiver
@@ -24,8 +28,9 @@ module Epi
           Epi.logger
         end
 
-        def initialize(receiver)
+        def initialize(receiver, callback)
           @receiver = receiver
+          @callback = callback
         end
 
         def run
@@ -36,6 +41,10 @@ module Epi
           receiver.puts text
         end
 
+        def done(result = nil)
+          @callback.call result
+        end
+
       end
 
       Dir[File.expand_path '../responders/*.rb', __FILE__].each { |f| require f }

data/lib/epi/{server → daemon}/responders/config.rb

@@ -1,9 +1,9 @@
 module Epi
-  module Server
+  module Daemon
     module Responders
       class Config < Responder
 
-        attr_accessor :add_paths
+        attr_accessor :add_paths, :remove_paths
 
         def run
           result = []
@@ -19,6 +19,18 @@ module Epi
               result << "Added config path: #{path}"
             end
           end if add_paths
+          remove_paths.each do |path|
+            path = path.to_s
+            if configs.include?(path)
+              logger.info "Removing config path: #{path}"
+              # TODO: clean up any junk the config file may have left
+              configs.delete path
+              result << "Removed config path: #{path}"
+            else
+              logger.warn "Tried to remove unknown config path: #{path}"
+              result << "Config path not loaded: #{path}"
+            end
+          end if remove_paths
           Data.save
           Jobs.beat!
           result.join ' '

data/lib/epi/{server → daemon}/responders/job.rb

@@ -1,5 +1,5 @@
 module Epi
-  module Server
+  module Daemon
     module Responders
       class Job < Responder
 
@@ -21,11 +21,11 @@ module Epi
           @job ||= Jobs[id]
         end
 
-        def set(count, validate = true)
+        def set(count)
           allowed = job.allowed_processes
-          raise Exceptions::Fatal, "Requested count #{count} is outside allowed range #{allowed}" unless !validate || allowed === count
+          raise Exceptions::Fatal, "Requested count #{count} is outside allowed range #{allowed}" unless allowed === count
           original = job.expected_count
-          raise Exceptions::Fatal, "Already running #{count} process#{count != 1 ? 'es' : ''}" unless !validate || original != count
+          raise Exceptions::Fatal, "Already running #{count} process#{count != 1 ? 'es' : ''}" unless original != count
           job.expected_count = count
           job.sync!
           "#{count < original ? 'De' : 'In'}creasing '#{job.name}' processes by #{(original - count).abs} (from #{original} to #{count})"
@@ -59,8 +59,7 @@ module Epi
         def restart
           count = job.expected_count
           raise Exceptions::Fatal, 'This job has no processes to restart' if count == 0
-          set 0, false
-          set count
+          job.restart!
           "Replacing #{count} '#{job.name}' process#{count != 1 ? 'es' : ''}"
         end
 

data/lib/epi/{server → daemon}/responders/shutdown.rb

@@ -1,5 +1,5 @@
 module Epi
-  module Server
+  module Daemon
     module Responders
       class Shutdown < Responder
 

data/lib/epi/daemon/responders/start.rb

@@ -0,0 +1,19 @@
+module Epi
+  module Daemon
+    module Responders
+
+      class Start < Responder
+
+        def run
+          count = Jobs.running_process_count
+          if count == 0
+            'Starting ...'
+          else
+            "Starting #{count} process#{count == 1 ? '' : 'es'} ..."
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/{server → daemon}/responders/status.rb

@@ -1,5 +1,7 @@
+require 'yaml'
+
 module Epi
-  module Server
+  module Daemon
     module Responders
       # noinspection RubyStringKeysInHashInspection
       class Status < Responder
@@ -14,7 +16,7 @@ module Epi
         def stats
           {
               'Running as' => `whoami`.chomp,
-              'Since' => Server.start_time.strftime('%c'),
+              'Since' => Daemon.start_time.strftime('%c'),
               'Jobs' => jobs
           }
         end

data/lib/epi/daemon/responders/stop_all.rb

@@ -0,0 +1,20 @@
+module Epi
+  module Daemon
+    module Responders
+
+      class StopAll < Responder
+
+        def run_async
+          count = Jobs.running_process_count
+          if count > 0
+            puts "Stopping #{count} process#{count == 1 ? '' : 'es'} ..."
+            Jobs.shutdown! { done }
+          else
+            done
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/daemon/sender.rb

@@ -0,0 +1,74 @@
+require_relative '../connection'
+
+module Epi
+  module Daemon
+    class Sender < Connection
+      include Exceptions
+
+      # Send a message to the Epi server
+      #
+      # @example Get Epi's status
+      #   Sender.send :status
+      #
+      # @example Add a config file
+      #   Sender.send config: {add_paths: ['config.epi']}
+      #
+      # @param what [Hash|Symbol] Either a symbol being the message type, or a hash
+      #   with a single key (a symbol) being the message type, and value (a hash) being the message.
+      def self.send(what, &callback)
+
+        raise ArgumentError, 'Expected a hash with one key (a symbol) and value (a hash)' unless
+            Symbol === what ||
+            (Hash === what && what.count == 1 && Symbol === what.keys.first && Hash === what.values.first)
+
+        data = case what
+          when Symbol then {type: what}
+          when Hash then what.values.first.merge(type: what.keys.first)
+          else nil
+        end
+
+        EventMachine.connect Daemon.socket_path.to_s, Sender, data, callback
+
+      end
+
+      def initialize(data, callback)
+        @callback = callback
+        send_object data
+      end
+
+      def receive_object(data)
+        if data[:print]
+          STDOUT << data[:print]
+          return
+        end
+
+        if data.key? :result
+          result = data[:result]
+
+          if @callback
+            @callback.call result
+          else
+            puts result unless result.nil?
+            EM.stop
+          end
+
+        elsif data[:error]
+
+          error = data[:error]
+          if error[:class] == Fatal.name
+            STDERR << error[:message]
+            STDERR << "\n"
+          else
+            STDERR << "#{error[:class]}: #{error[:message]}\n"
+            error[:backtrace].each { |x| STDERR << "\t#{x}\n" }
+          end
+
+          EM.stop
+        end
+
+        close_connection
+      end
+
+    end
+  end
+end

data/lib/epi/{server.rb → daemon.rb}

@@ -1,11 +1,11 @@
 require 'eventmachine'
 
-require_relative 'server/sender'
-require_relative 'server/receiver'
-require_relative 'server/responder'
+require_relative 'daemon/sender'
+require_relative 'daemon/receiver'
+require_relative 'daemon/responder'
 
 module Epi
-  module Server
+  module Daemon
 
     class << self
 
@@ -19,7 +19,7 @@ module Epi
         should_run_as_root = Data.root?
 
         if running? && should_run_as_root && !process.root?
-          logger.info "Server needs to run as root, but is running as #{process.user}"
+          logger.info "Daemon needs to run as root, but is running as #{process.user}"
           shutdown
         end
 
@@ -29,15 +29,15 @@ module Epi
                 'or specify EPI_HOME as a directory other than /etc/epi'
           end
 
-          logger.info 'Starting server'
-          Epi.launch [$0, 'server', 'run'],
-                         stdout: Data.home + 'server.log',
-                         stderr: Data.home + 'server_errors.log'
+          logger.info 'Starting daemon'
+          Epi.launch [$0, 'daemon'],
+                     stdout: Data.home + 'daemon.log',
+                     stderr: Data.home + 'daemon_errors.log'
 
           begin
             Timeout::timeout(5) { sleep 0.05 until socket_path.exist? }
           rescue Timeout::Error
-            raise Exceptions::Fatal, 'Server not started after 5 seconds'
+            raise Exceptions::Fatal, 'Daemon not started after 5 seconds'
           end unless socket_path.exist?
         end
       end
@@ -47,43 +47,42 @@ module Epi
       end
 
       def run
-        raise Exceptions::Fatal, 'Server already running' if running?
+        raise Exceptions::Fatal, 'Daemon already running' if running?
 
-        # Save the server PID
-        Data.server_pid = Process.pid
+        # Save the daemon PID
+        Data.daemon_pid = Process.pid
 
         # Run an initial beat
         Jobs.beat!
 
-        # Start a server
+        # Start a daemon
         EventMachine.start_unix_domain_server socket_path.to_s, Receiver
         logger.info "Listening on socket #{socket_path}"
 
-        # Make sure other users can connect to the server
+        # Make sure other users can connect to the daemon
         socket_path.chmod 0777 #TODO: make configurable
 
-        # Ensure the socket is destroyed when the server exits
+        # Ensure the socket is destroyed when the daemon exits
         EventMachine.add_shutdown_hook { socket_path.delete }
 
         @start_time = Time.now
       end
 
-      def send(*args)
+      def send(*args, &callback)
         ensure_running
-        Sender.send *args
+        Sender.send *args, &callback
       end
 
       def shutdown(process = nil)
-        process ||= self.process
-        raise Exceptions::Fatal, 'Attempted to shut down server when no server is running' unless running?
-        if process.pid == Process.pid
+        raise Exceptions::Fatal, 'Attempted to shut down daemon when no daemon is running' unless running?
+        if (process || self.process).pid == Process.pid
           EventMachine.next_tick do
             EventMachine.stop_event_loop
-            Data.server_pid = nil
-            logger.info 'Server has shut down'
+            Data.daemon_pid = nil
+            logger.info 'Daemon has shut down'
           end
         else
-          logger.info 'Server will shut down'
+          logger.info 'Daemon will shut down'
           send :shutdown
         end
       end
@@ -93,9 +92,9 @@ module Epi
       end
 
       def process
-        server_pid = Data.server_pid
-        @process = nil if @process && @process.pid != server_pid
-        @process ||= server_pid && RunningProcess.new(server_pid)
+        daemon_pid = Data.daemon_pid
+        @process = nil if @process && @process.pid != daemon_pid
+        @process ||= daemon_pid && RunningProcess.new(daemon_pid)
       end
 
     end

data/lib/epi/data.rb

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'bson'
 require 'forwardable'
 
 module Epi
@@ -13,7 +12,7 @@ module Epi
 
       delegate [:[], :[]=, :read, :write, :root?, :save, :reload, :home] => :default_instance
 
-      %w[server_pid].each do |property|
+      %w[daemon_pid].each do |property|
         define_method(property) { read property }
         define_method(property + '=') { |value| write property, value }
       end
@@ -104,7 +103,7 @@ module Epi
     end
 
     def data_file
-      @data_file ||= home + 'data.bson'
+      @data_file ||= home + 'data'
     end
 
     # Force reload of data from disk
@@ -114,12 +113,12 @@ module Epi
 
     # Save data to disk
     def save
-      data_file.binwrite hash.to_bson
+      data_file.binwrite Marshal.dump hash
       data_file.chmod 0644
     end
 
     def hash
-      @hash ||= data_file.exist? ? Hash.from_bson(StringIO.new data_file.binread) : {}
+      @hash ||= data_file.exist? ? Marshal.load(data_file.binread) : {}
     end
 
     # Returns true if using root data at /etc/epi, or false if using user data