epi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65b6f4c3b4d118849bb76a9bb617296e7abfc0d0
+  data.tar.gz: 01905d5290fbadfe2ab466a0c6d593c88a3b0a7d
+SHA512:
+  metadata.gz: a17b31c2de560b44ff2cc927eaaaee9a987bb828ea526367d8fd57da134f651ca5a99e3c91e7f9b22db80383e3272835bf1a4bc569368741bc74ee95a98ffd6e
+  data.tar.gz: f1c1de71a10027df1c70c137716034eec7a462f729383f81552e4f7132844956bd3a15e20b240d430cff8f6e941b6a0cb5f5da0a11a72f1cc21c1acd59a114df

data/bin/epi

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../../lib', __FILE__)
+$: << lib unless $:.include? lib
+require 'epi'
+require 'eventmachine'
+if $0 == __FILE__
+  EventMachine.run do
+    %w[INT TERM].each do |s|
+      Signal.trap(s) do
+        puts " #{s} => bye for now!"
+        EventMachine.stop
+      end
+    end
+    Epi::Cli.run ARGV
+  end
+end

data/lib/epi.rb

@@ -0,0 +1,52 @@
+require 'pathname'
+require 'logger'
+require 'shellwords'
+
+require 'epi/core_ext'
+require 'epi/exceptions'
+require 'epi/version'
+require 'epi/cli'
+require 'epi/server'
+require 'epi/data'
+require 'epi/process_status'
+require 'epi/running_process'
+require 'epi/job'
+require 'epi/jobs'
+require 'epi/configuration_file'
+require 'epi/job_description'
+require 'epi/launch'
+
+module Epi
+  ROOT = Pathname File.expand_path('../..', __FILE__)
+
+  class << self
+
+    def logger
+      @logger ||= make_logger
+    end
+
+    def logger=(value)
+      @logger = Logger === value ? value : make_logger(value)
+    end
+
+    def root?
+      @is_root = `whoami`.chomp == 'root' if @is_root.nil?
+      @is_root
+    end
+
+    private
+
+    def make_logger(target = nil)
+      Logger.new(target || ENV['EPI_LOG'] || STDOUT).tap do |logger|
+        logger.level = Logger::Severity::WARN
+        level = ENV['EPI_LOG_LEVEL']
+        if level
+          level = level.upcase
+          logger.level = Logger::Severity.const_get(level) if Logger::Severity.const_defined? level
+        end
+      end
+    end
+
+  end
+
+end

data/lib/epi/cli.rb

@@ -0,0 +1,22 @@
+require_relative 'cli/command'
+
+module Epi
+  module Cli
+
+    class << self
+
+      def run(args)
+        command = args.shift
+        begin
+          Command.run command, args
+        rescue Exceptions::Fatal => error
+          STDERR << error.message
+          STDERR << "\n"
+          EventMachine.stop_event_loop
+        end
+      end
+
+    end
+
+  end
+end

data/lib/epi/cli/command.rb

@@ -0,0 +1,27 @@
+module Epi
+  module Cli
+    unless defined? Command
+
+      class Command
+
+        def self.run(command, args)
+          const_name = command.camelize.to_sym
+          if Commands.const_defined? const_name
+            klass = Commands.const_get const_name
+            return klass.new(args).run if Class === klass && klass < self
+          end
+          raise Exceptions::Fatal, 'Unknown command'
+        end
+
+        attr_reader :args
+
+        def initialize(args)
+          @args = args
+        end
+
+      end
+
+      Dir[File.expand_path '../commands/*.rb', __FILE__].each { |f| require f }
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Epi
+  module Cli
+    module Commands
+      class Config < Command
+
+        def run
+          case args.shift
+            when 'add' then add
+            else raise Exceptions::Fatal, 'Unknown config command, use [ add ]'
+          end
+        end
+
+        private
+
+        def add
+          raise Exceptions::Fatal, 'No path given' unless args.first
+          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
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Epi
+  module Cli
+    module Commands
+      class Job < Command
+
+        def run
+          id = args.shift
+          raise Exceptions::Fatal, 'No job ID given' if id.nil? || id.empty?
+          instruction = args.join(' ').strip
+          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}
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Epi
+  module Cli
+    module Commands
+      class Server < Command
+
+        def run
+          process = Epi::Server.process
+          raise Exceptions::Fatal, 'You need root privileges to manage this server' if
+              process && process.was_alive? && process.root? && !Epi.root?
+          case args.first
+            when nil, 'start' then startup
+            when 'run' then run_server
+            when 'stop' then shutdown
+            else raise Exceptions::Fatal, 'Unknown server command, use [ start | stop | restart ]'
+          end
+        end
+
+        private
+
+        def startup
+          Epi::Server.ensure_running
+          puts 'Server is running'
+        end
+
+        def shutdown
+          Epi::Server.shutdown
+          puts 'Server has shut down'
+        end
+
+        def run_server
+          Epi::Server.run
+          puts 'Server is running'
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Epi
+  module Cli
+    module Commands
+      class Status < Command
+
+        def run
+          Epi::Server.send :status
+        end
+
+      end
+    end
+  end
+end

data/lib/epi/configuration_file.rb

@@ -0,0 +1,56 @@
+require 'forwardable'
+require 'pathname'
+require 'digest'
+
+module Epi
+  class ConfigurationFile
+    extend Forwardable
+    include Exceptions
+
+    attr_reader :path, :job_descriptions
+
+    delegate [:exist?, :binread] => :path
+
+    def initialize(path)
+      @job_descriptions = {}
+      @path = Pathname path
+    end
+
+    def logger
+      Epi.logger
+    end
+
+    def read
+      return unless exist? && changed?
+      logger.info "Reading configuration file #{path}"
+      data = binread
+      begin
+        instance_eval data, path.to_s
+        @last_digest = Digest::MD5.digest(data)
+      rescue => error
+        raise InvalidConfigurationFile.new("Unhandled exception of type #{error.class.name}", error)
+      end
+    end
+
+    def changed?
+      Digest::MD5.digest(binread) != @last_digest
+    end
+
+    def job(id_and_name, &block)
+      raise InvalidConfigurationFile, 'Improper use of "job"' unless
+          Hash === id_and_name &&
+          id_and_name.count == 1 &&
+          Symbol === id_and_name.keys.first &&
+          String === id_and_name.values.first &&
+          block.respond_to?(:call) &&
+          block.respond_to?(:arity) &&
+          block.arity >= 1
+      id, name = id_and_name.first
+      id = id.to_s
+      job_description = @job_descriptions[id] ||= JobDescription.new(id)
+      job_description.name = name
+      job_description.reconfigure &block
+    end
+
+  end
+end

data/lib/epi/core_ext.rb

@@ -0,0 +1 @@
+require_relative 'core_ext/inflector'

data/lib/epi/core_ext/inflector.rb

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

data/lib/epi/data.rb

@@ -0,0 +1,152 @@
+require 'pathname'
+require 'bson'
+require 'forwardable'
+
+module Epi
+  class Data
+    include Exceptions
+
+    ROOT_HOME = '/etc/epi'
+
+    class << self
+      extend Forwardable
+
+      delegate [:[], :[]=, :read, :write, :root?, :save, :reload, :home] => :default_instance
+
+      %w[server_pid].each do |property|
+        define_method(property) { read property }
+        define_method(property + '=') { |value| write property, value }
+      end
+
+      def configuration_paths
+        self['configuration_paths'] ||= []
+      end
+
+      def jobs
+        self['jobs'] ||= {}
+      end
+
+      def jobs=(value)
+        self['jobs'] = value
+      end
+
+      # Get the default data storage instance
+      # @return [self]
+      def default_instance
+        @default_instance ||= new(detect_home_dir)
+      end
+
+      # Remove the default instance. Useful if the home path changes.
+      def reset!
+        @default_instance = nil
+      end
+
+      private
+
+      # Try to guess the Epi home directory, by first looking at the
+      # `EPI_HOME` environment variable, then '/etc/epi', then '~/.epi'
+      # @return [String]
+      def detect_home_dir
+        custom_home_dir || root_home_dir || user_home_dir
+      end
+
+      # The home directory specified in the environment
+      # @return [String|NilClass]
+      def custom_home_dir
+        ENV['EPI_HOME']
+      end
+
+      # The root home directory, if it exists or can be created
+      # @return [String|NilClass]
+      def root_home_dir
+        (Epi.root? || Dir.exist?(ROOT_HOME)) && ROOT_HOME
+      end
+
+      # The user's home directory
+      # @return [String]
+      def user_home_dir
+        "#{ENV['HOME'] || '~'}/.epi"
+      end
+
+    end
+
+    attr_reader :home
+
+    # @param home [String] The directory in which all working files should be stored.
+    def initialize(home)
+      @home = Pathname home
+      prepare_home!
+    end
+
+    # Read a file as UTF-8
+    # @param file_name [String] Name of the file to read
+    # @return [String|NilClass] Contents of the file, or `nil` if the file doesn't exist.
+    def read(file_name)
+      path = home + file_name
+      path.exist? ? path.read : nil
+    end
+
+    # Write a file as UTF-8
+    # @param file_name [String] Name of the file to write
+    # @param data [Object] Data to be written to the file, or `nil` if the file should be deleted.
+    def write(file_name, data)
+      path = home + file_name
+      if data.nil?
+        path.delete if path.exist?
+        nil
+      else
+        data = data.to_s
+        path.parent.mkpath
+        path.write data
+        path.chmod 0644
+        data.length
+      end
+    end
+
+    def data_file
+      @data_file ||= home + 'data.bson'
+    end
+
+    # Force reload of data from disk
+    def reload
+      @hash = nil
+    end
+
+    # Save data to disk
+    def save
+      data_file.binwrite hash.to_bson
+      data_file.chmod 0644
+    end
+
+    def hash
+      @hash ||= data_file.exist? ? Hash.from_bson(StringIO.new data_file.binread) : {}
+    end
+
+    # Returns true if using root data at /etc/epi, or false if using user data
+    # is at ~/.epi
+    # @return [TrueClass|FalseClass]
+    def root?
+      @is_root
+    end
+
+    def [](key)
+      hash[key.to_s]
+    end
+
+    def []=(key, value)
+      hash[key.to_s] = value
+    end
+
+    private
+
+    # Ensures the home directory exists and is readable
+    # @raise [Fatal]
+    def prepare_home!
+      @is_root = @home.to_s == ROOT_HOME
+      home.mkpath
+      raise Fatal, 'We need write and execute permissions for ' << home.to_s unless
+          home.exist? && home.readable? && home.executable?
+    end
+
+  end
+end