epi 0.0.1

data/lib/epi/running_process.rb

@@ -0,0 +1,159 @@
+require 'time'
+
+module Epi
+  # noinspection RubyTooManyInstanceVariablesInspection
+  class RunningProcess
+
+    DEFAULT_TIMEOUT = 20
+
+    @users = {}
+
+    class << self
+
+      def user_name(uid)
+        @users[uid.to_i] ||= `id -un #{uid}`.chomp
+      end
+
+      def group_name(gid)
+        groups[gid.to_i]
+      end
+
+      private
+
+      def groups
+        @groups ||= read_groups
+      end
+
+      def read_groups
+        {}.tap do |result|
+          File.readlines('/etc/group').each do |line|
+            result[$2.to_i] = $1 if line =~ /^([^:]+):[^:]+:(-?\d+):/
+          end
+        end
+      end
+
+    end
+
+    PS_FORMAT = 'pid,%cpu,%mem,rss,vsz,lstart,uid,gid,command'
+
+    attr_reader :pid
+
+    def logger
+      Epi.logger
+    end
+
+    def initialize(pid, ps_line = nil)
+      @pid = pid
+      @ps_line = ps_line
+      @props = {}
+      reload! unless ps_line
+    end
+
+    def reload!
+      @props = {}
+      @parts = nil
+      @ps_line = `ps -p #{pid} -o #{PS_FORMAT}`.lines[1]
+    end
+
+    # Returns `true` if the process was running when this instance was created
+    def was_alive?
+      !@ps_line.nil?
+    end
+
+    # CPU usage as a percentage
+    # @return [Float]
+    def cpu_percentage
+      @cpu_percentage ||= parts[1].to_f
+    end
+
+    # Physical memory usage as a percentage
+    # @return [Float]
+    def memory_percentage
+      @memory_percentage ||= parts[2].to_f
+    end
+
+    # Physical memory usage in bytes (rounded to the nearest kilobyte)
+    # @return [Fixnum]
+    def physical_memory
+      @physical_memory ||= parts[3].to_i * 1024
+    end
+
+    # Virtual memory usage in bytes (rounded to the nearest kilobyte)
+    # @return [Fixnum]
+    def virtual_memory
+      @virtual_memory ||= parts[4].to_i * 1024
+    end
+
+    # Sum of {#physical_memory} and {#total_memory}
+    # @return [Fixnum]
+    def total_memory
+      @total_memory ||= physical_memory + virtual_memory
+    end
+
+    # Time at which the process was started
+    # @return [Time]
+    def started_at
+      @started_at ||= Time.parse parts[5..9].join ' '
+    end
+
+    # Name of the user that owns the process
+    # @return [String]
+    def user
+      @user ||= self.class.user_name parts[10]
+    end
+
+    # Name of the group that owns the process
+    # @return [String]
+    def group
+      @group ||= self.class.group_name parts[11]
+    end
+
+    # The command that was used to start the process, including its arguments
+    # @return [String]
+    def command
+      @command ||= parts[12]
+    end
+
+    # Whether the process is root-owned
+    # @return [TrueClass|FalseClass]
+    def root?
+      user == 'root'
+    end
+
+    # Kill a running process
+    # @param timeout [TrueClass|FalseClass|Numeric] `true` to kill immediately (KILL),
+    #   `false` to kill gracefully (TERM), or a number of seconds to wait between trying
+    #   both (first TERM, then KILL).
+    # @return [RunningProcess]
+    def kill(timeout = DEFAULT_TIMEOUT)
+      if timeout.is_a? Numeric
+        begin
+          logger.info "Will wait #{timeout} second#{timeout != 1 && 's'} for process to terminate gracefully"
+          Timeout::timeout(timeout) { kill false }
+        rescue Timeout::Error
+          kill true
+        end
+      else
+        signal = timeout ? 'KILL' : 'TERM'
+        logger.info "Sending #{signal} to process #{pid}"
+        Process.kill signal, pid
+        sleep 0.2 while `ps -p #{pid} > /dev/null 2>&1; echo $?`.chomp.to_i == 0
+        logger.info "Process #{pid} terminated by signal #{signal}"
+      end
+      self
+    end
+
+    def kill!
+      kill true
+    end
+
+    private
+
+    def parts
+      raise 'Tried to access details of a non-running process' unless String === @ps_line
+      @parts ||= @ps_line.strip.split(/\s+/, 13)
+    end
+
+  end
+
+end

data/lib/epi/server.rb

@@ -0,0 +1,104 @@
+require 'eventmachine'
+
+require_relative 'server/sender'
+require_relative 'server/receiver'
+require_relative 'server/responder'
+
+module Epi
+  module Server
+
+    class << self
+
+      attr_reader :start_time
+
+      def logger
+        Epi.logger
+      end
+
+      def ensure_running
+        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}"
+          shutdown
+        end
+
+        unless running?
+          if should_run_as_root && !Epi.root?
+            raise Exceptions::Fatal, 'Found root data but not running as root. Either run again as root, ' +
+                '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'
+
+          begin
+            Timeout::timeout(5) { sleep 0.05 until socket_path.exist? }
+          rescue Timeout::Error
+            raise Exceptions::Fatal, 'Server not started after 5 seconds'
+          end unless socket_path.exist?
+        end
+      end
+
+      def socket_path
+        Data.home + 'socket'
+      end
+
+      def run
+        raise Exceptions::Fatal, 'Server already running' if running?
+
+        # Save the server PID
+        Data.server_pid = Process.pid
+
+        # Run an initial beat
+        Jobs.beat!
+
+        # Start a server
+        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
+        socket_path.chmod 0777 #TODO: make configurable
+
+        # Ensure the socket is destroyed when the server exits
+        EventMachine.add_shutdown_hook { socket_path.delete }
+
+        @start_time = Time.now
+      end
+
+      def send(*args)
+        ensure_running
+        Sender.send *args
+      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
+          EventMachine.next_tick do
+            EventMachine.stop_event_loop
+            Data.server_pid = nil
+            logger.info 'Server has shut down'
+          end
+        else
+          logger.info 'Server will shut down'
+          send :shutdown
+        end
+      end
+
+      def running?
+        process && process.was_alive?
+      end
+
+      def process
+        server_pid = Data.server_pid
+        @process = nil if @process && @process.pid != server_pid
+        @process ||= server_pid && RunningProcess.new(server_pid)
+      end
+
+    end
+
+  end
+end

data/lib/epi/server/receiver.rb

@@ -0,0 +1,46 @@
+require 'eventmachine'
+require 'bson'
+
+module Epi
+  module Server
+    class Receiver < EventMachine::Connection
+
+      def logger
+        Epi.logger
+      end
+
+      def receive_data(data)
+        response = begin
+          data = Hash.from_bson StringIO.new data
+          logger.debug "Received message of type '#{data['type']}'"
+          {result: Responder.run(self, data.delete('type').to_s, data)}
+        rescue Exceptions::Shutdown
+          self.should_shut_down = true
+          {result: 'Server is shutting down'}
+        rescue => error
+          {error: {
+              class: error.class.name,
+              message: error.message,
+              backtrace: error.backtrace
+          }}
+        end
+        response[:complete] = true
+        send_data response.to_bson
+        Server.shutdown if should_shut_down
+      end
+
+      def puts(text)
+        data = {
+            result: "#{text}\n",
+            complete: false
+        }
+        send_data data.to_bson
+      end
+
+      private
+
+      attr_accessor :should_shut_down
+
+    end
+  end
+end

data/lib/epi/server/responder.rb

@@ -0,0 +1,44 @@
+module Epi
+  module Server
+    unless defined? Responder
+      class Responder
+        include Exceptions
+
+        # Runs a responder by name.
+        #
+        # @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)
+          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)
+          data.each { |key, value| responder.__send__ :"#{key}=", value }
+          responder.run
+        end
+
+        attr_reader :receiver
+
+        def logger
+          Epi.logger
+        end
+
+        def initialize(receiver)
+          @receiver = receiver
+        end
+
+        def run
+          raise NotImplementedError, "You need to define #run for class #{self.class.name}"
+        end
+
+        def puts(text)
+          receiver.puts text
+        end
+
+      end
+
+      Dir[File.expand_path '../responders/*.rb', __FILE__].each { |f| require f }
+    end
+  end
+end

data/lib/epi/server/responders/command.rb

@@ -0,0 +1,15 @@
+module Epi
+  module Server
+    module Responders
+      class Command < Responder
+
+        attr_accessor :command, :arguments
+
+        def run
+          Cli::Command.run command, arguments
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/server/responders/config.rb

@@ -0,0 +1,30 @@
+module Epi
+  module Server
+    module Responders
+      class Config < Responder
+
+        attr_accessor :add_paths
+
+        def run
+          result = []
+          configs = Data.configuration_paths
+          add_paths.each do |path|
+            path = path.to_s
+            if configs.include?(path)
+              logger.warn "Tried to re-add config path: #{path}"
+              result << "Config path already loaded: #{path}"
+            else
+              logger.info "Adding config path: #{path}"
+              configs << path
+              result << "Added config path: #{path}"
+            end
+          end if add_paths
+          Data.save
+          Jobs.beat!
+          result.join ' '
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/server/responders/job.rb

@@ -0,0 +1,70 @@
+module Epi
+  module Server
+    module Responders
+      class Job < Responder
+
+        attr_accessor :id, :instruction
+
+        def run
+          Jobs.beat!
+          raise Exceptions::Fatal, 'Unknown job ID' unless Epi::Job === job
+          case instruction
+            when /^\d+$/ then set instruction.to_i
+            when /^(\d+ )?(more|less)$/ then __send__ $2, ($1 || 1).to_i
+            else __send__ instruction
+          end
+        end
+
+        private
+
+        def job
+          @job ||= Jobs[id]
+        end
+
+        def set(count, validate = true)
+          allowed = job.allowed_processes
+          raise Exceptions::Fatal, "Requested count #{count} is outside allowed range #{allowed}" unless !validate || allowed === count
+          original = job.expected_count
+          raise Exceptions::Fatal, "Already running #{count} process#{count != 1 ? 'es' : ''}" unless !validate || original != count
+          job.expected_count = count
+          job.sync!
+          "#{count < original ? 'De' : 'In'}creasing '#{job.name}' processes by #{(original - count).abs} (from #{original} to #{count})"
+        end
+
+        def more(increase)
+          set job.expected_count + increase
+        end
+
+        def less(decrease)
+          set job.expected_count - decrease
+        end
+
+        def max
+          set job.allowed_processes.max
+        end
+
+        def min
+          set job.allowed_processes.min
+        end
+
+        def pause
+          set 0
+        end
+
+        def resume
+          set job.job_description.initial_processes
+        end
+        alias_method :reset, :resume
+
+        def restart
+          count = job.expected_count
+          raise Exceptions::Fatal, 'This job has no processes to restart' if count == 0
+          set 0, false
+          set count
+          "Replacing #{count} '#{job.name}' process#{count != 1 ? 'es' : ''}"
+        end
+
+      end
+    end
+  end
+end