aws-codedeploy-agent 0.0.1

data/vendor/gems/process_manager/lib/process_manager/config.rb

@@ -0,0 +1,112 @@
+# encoding: UTF-8
+module ProcessManager
+  class Config
+
+    def self.init
+      @config = Config.new
+    end
+
+    def self.config(options = {})
+      init unless @config
+      @config.config(options)
+    end
+
+    def self.validate_config
+      init unless @config
+      @config.validate
+    end
+
+    def self.load_config
+      if File.exists?(config[:config_file]) && File.readable?(config[:config_file])
+        file_config = YAML.load(File.read(config[:config_file])).symbolize_keys
+        config.update(file_config)
+        config_loaded_callbacks.each{|c| c.call}
+      else
+        raise "The config file #{config[:config_file]} does not exist or is not readable"
+      end
+    end
+
+    def self.on_config_load(&block)
+      @@_config_callbacks ||= []
+      @@_config_callbacks << block
+      nil
+    end
+
+    def self.config_loaded_callbacks
+      @@_config_callbacks ||= []
+    end
+
+    def initialize
+      @config = {
+        :program_name => 'process_manager',
+        :max_runs_per_worker => 0, # unlimited
+        :children => 4,
+        :log_dir => '/tmp',
+        :pid_dir => '/tmp',
+        :verbose => false,
+        :wait_after_throttle_error => 60, # wait time in seconds after a we got a throttling exception from SWF
+        :wait_between_runs => 5, # wait time in seconds after a run so that we don't run into throttling exceptions
+        :wait_after_connection_problem => 5, # wait time in seconds after a connection problem as we don't want to build a fork-bomb
+        :wait_between_spawning_children => 10, # wait time in seconds after spawning a child so that we don't overhelm SWF with our requests
+        :user => nil,
+        :group => nil,
+
+        # global config file to read
+        :config_file => nil
+      }
+    end
+
+    def config(options = {})
+      @config.update(options) unless options.nil? || options.empty?
+      @config
+    end
+
+    def validate
+      errors = []
+
+      errors << "Invalid max_runs_per_worker #{config[:max_runs_per_worker].inspect}" unless config[:max_runs_per_worker].to_s.match(/\d+/) && config[:max_runs_per_worker].to_i >= 0
+      config[:max_runs_per_worker] = config[:max_runs_per_worker].to_i
+      errors << "Invalid number of children #{config[:children].inspect}" unless config[:children].to_s.match(/\d+/) && config[:children].to_i > 0
+      config[:children] = config[:children].to_i
+
+      normalize_log_and_pid_dir
+      validate_log_and_pid_dir(errors)
+      validate_user(errors)
+      errors
+    end
+
+    def validate_log_and_pid_dir(errors)
+      FileUtils.mkdir_p(ProcessManager::Config.config[:log_dir]) unless File.exists?(ProcessManager::Config.config[:log_dir])
+      FileUtils.mkdir_p(ProcessManager::Config.config[:pid_dir]) unless File.exists?(ProcessManager::Config.config[:pid_dir])
+      errors << "Please make sure the path of the log directory exists and is writable: #{config[:log_dir].inspect}" unless file_writable?(config[:log_dir]) && File.directory?(config[:log_dir])
+      errors << "Please make sure the path of the PID directory exists and is writable: #{config[:pid_dir].inspect}" unless file_writable?(config[:pid_dir]) && File.directory?(config[:pid_dir])
+      errors
+    end
+
+    def validate_user(errors)
+      if config[:user].present?
+        errors << "The system user does not exist: #{config[:user].inspect}" unless (Etc.getpwnam(config[:user]).uid rescue false)
+      end
+      errors
+    end
+
+    def normalize_log_and_pid_dir
+      if config[:pid_dir]
+        config[:pid_dir] = File.expand_path(config[:pid_dir])
+      end
+      if config[:log_dir]
+        config[:log_dir] = File.expand_path(config[:log_dir])
+      end
+    end
+
+    def file_writable?(path)
+      return false unless path.present?
+      if File.exists?(path)
+        File.writable?(path)
+      else
+        File.writable?(File.dirname(path))
+      end
+    end
+
+  end
+end

data/vendor/gems/process_manager/lib/process_manager/log.rb

@@ -0,0 +1,107 @@
+# encoding: UTF-8
+require 'logging'
+require 'logger'
+
+module ProcessManager
+  class Log
+    NORMAL_SEVERITIES = %W{debug info warn unknown}
+    ERROR_SEVERITIES = %W{error fatal}
+    SEVERITIES = NORMAL_SEVERITIES + ERROR_SEVERITIES
+
+    class << self
+      attr_accessor :logger
+    end
+
+    class Logger
+      attr_accessor :logger
+
+      # Initializes a logger that will roll log files every hour and keeps a week's worth of logs
+      # in the disk. The log layout represents,
+      # "ISO8601_format_date log_level [program_name(pid)]: actual_log_message"
+      # Note: Rolling file appender only works with regular files
+
+      def initialize(log_device)
+        @logger = Logging.logger[ProcessManager::Config.config[:program_name]]
+        @logger.add_appenders(
+          Logging.appenders.rolling_file('rolling_file_appender',
+            :filename => log_device,
+            :age => 'daily',
+            :keep => 7,
+            :layout => Logging.layouts.pattern(:pattern => '%d %-5l [%c(%p)]: %m\n')
+          )
+        )
+        if ProcessManager::Config.config[:verbose]
+          self.level = 'debug'
+        else
+          self.level = 'info'
+        end
+      end
+
+      def level=(level)
+        if level.is_a?(Fixnum)
+          @logger.level = level
+        else
+          @logger.level = ::Logger.const_get(level.to_s.upcase)
+        end
+      end
+
+      NORMAL_SEVERITIES.each do |level|
+        log_level = ::Logger.const_get(level.upcase)
+        define_method(level) do |message|
+          raise "No logger available" unless @logger
+          @logger.add(log_level, message)
+        end
+      end
+
+      ERROR_SEVERITIES.each do |level|
+        log_level = ::Logger.const_get(level.upcase)
+        define_method(level) do |message|
+          @logger.add(log_level, message)
+          ProcessManager.on_error_callbacks.each do |callback|
+            begin
+              callback.call(message)
+            rescue Exception
+              # error callbacks shouldn't break the main flow
+            end
+          end if level == 'error'
+        end
+      end
+    end
+
+    def self.[](logger_name)
+      logger_name = logger_name.to_sym
+      @logger_collection ||= {}
+      @logger_collection[logger_name] ||= ProcessManager::Log::Logger.new(log_device(logger_name))
+    end
+
+    def self.log_device(logger_name)
+      if logger_name.is_a?(String) || logger_name.is_a?(Symbol)
+        raise 'Please init ProcessManager::Log with a base log file!' unless @base_log_file
+        @base_log_file.gsub(/\.log/, ".#{logger_name.to_s.demodulize}.log")
+      else # IO?
+        logger_name
+      end
+    end
+
+    def self.init(log_device)
+      @base_log_file = log_device
+      if @logger.nil? || ((@logger.logger.logdev.dev.path != log_device) rescue true)
+        @logger = ::ProcessManager::Log::Logger.new(log_device)
+      end
+      @logger
+    end
+
+    def self.level=(level)
+      @logger.level = ::Logger.const_get(level.to_s.upcase)
+    end
+
+    (NORMAL_SEVERITIES + ERROR_SEVERITIES).each do |level|
+      singleton_class.instance_eval do
+        define_method(level) do |message|
+          raise "No logger available" unless @logger
+          @logger.send(level, message)
+        end
+      end
+    end
+  end
+end

data/vendor/gems/process_manager/lib/process_manager/master.rb

@@ -0,0 +1,322 @@
+# encoding: UTF-8
+require 'simple_pid'
+require 'fileutils'
+require 'blank'
+
+module ProcessManager
+  module Daemon
+    class Master
+
+      attr_accessor :children
+
+      def initialize
+        @children = {}
+        ProcessManager.set_program_name(description)
+        ensure_validate_configuration
+        dropped_privileges = drop_privileges
+        ProcessManager::Log.init(log_file)
+        if dropped_privileges
+          ProcessManager::Log.info("Dropped privileges to group: #{Etc.getgrgid(Process.gid).name} (gid = #{Process.gid})")
+          ProcessManager::Log.info("Dropped privileges to user: #{Etc.getpwuid(Process.uid).name} (uid = #{Process.uid})")
+        end
+        after_initialize
+      end
+
+      # please override
+      def after_initialize
+        # hook
+      end
+
+      # please override
+      def validate_ssl_config
+      end
+
+      def self.start
+        pid = fork do
+          new.start
+        end
+        Process.detach pid
+      end
+
+      def self.stop
+        new.stop
+      end
+
+      def self.restart
+        stop
+        sleep 1
+        start
+      end
+
+      def self.status
+        if pid = find_pid
+          if ProcessManager::process_running?(pid)
+            pid
+          else
+            clean_stale_pid
+            nil
+          end
+        else
+          # does not run
+          nil
+        end
+      end
+
+      def self.pid_file
+        File.join(ProcessManager::Config.config[:pid_dir], "#{ProcessManager::Config.config[:program_name]}.#{self.pid_description}.pid")
+      end
+
+      def self.pid_lock_file
+        File.join(ProcessManager::Config.config[:pid_dir], "#{ProcessManager::Config.config[:program_name]}.pid.lock")
+      end
+
+      def pid_lock_file
+        self.class.pid_lock_file
+      end
+
+      def pid_file
+        self.class.pid_file
+      end
+
+      # please override
+      def self.pid_description
+        "ProcessManager"
+      end
+
+      def pid_description
+        self.class.pid_description
+      end
+
+      def self.log_file
+        File.join(ProcessManager::Config.config[:log_dir], "#{ProcessManager::Config.config[:program_name]}.#{pid_description}.log")
+      end
+
+      def log_file
+        self.class.log_file
+      end
+
+      def drop_privileges
+
+        runas_user = ProcessManager::Config.config[:user]
+        return false if runas_user.blank?
+
+        if runas_user == Etc.getpwuid(Process.uid).name
+          return false
+        elsif Process.uid != 0
+          raise "Can't drop privileges as unprivileged user. Please run this command as a privileged user."
+        end
+
+        if runas_user.present?
+          uid = Etc.getpwnam(runas_user).uid
+          if (group = ProcessManager::Config.config[:group]) && group.present?
+            gid = Etc.getgrnam(group).gid
+          else
+            gid = Etc.getpwuid(uid).gid
+          end
+          Process.initgroups(runas_user, gid)
+          Process::GID.change_privilege(gid)
+          Process::UID.change_privilege(uid)
+          true
+        end
+        false
+      rescue Exception => e
+        $stderr.puts "Failed to drop privileges: #{e.class} - #{e.message} - #{e.backtrace.join("\n")}"
+        exit 1
+      end
+
+      def start
+        handle_pid_file
+        validate_ssl_config
+        trap_signals
+
+        spawn_children
+        puts "Started #{description} with #{ProcessManager::Config.config[:children]} children"
+        ProcessManager::Log.info("Started #{description} with #{ProcessManager::Config.config[:children]} children")
+
+        loop do
+          # master does nothing apart from replacing dead children
+          # and forwarding signals
+          sleep 1
+        end
+      end
+
+      def stop
+        if (pid = self.class.find_pid)
+          puts "Stopping #{description(pid)}"
+          ProcessManager::Log.info("Stopping #{description(pid)}")
+          begin
+            Process.kill('TERM', pid)
+          rescue Errno::ESRCH
+          end
+        else
+          puts "Nothing running that could be stopped"
+        end
+      end
+
+      def handle_pid_file       
+        @file_lock ||= File.open(pid_lock_file, File::RDWR|File::CREAT, 0644)
+        lock_aquired = @file_lock.flock(File::LOCK_EX|File::LOCK_NB)
+        
+        if lock_aquired == false
+          ProcessManager::Log.info("Could not aquire lock on #{pid_lock_file} - aborting start!")
+          self.class.abort
+        
+        elsif File.exists?(pid_file)
+          pid = self.class.find_pid
+          if ProcessManager.process_running?(pid)
+            puts "Pidfile #{pid_file} exists and process #{pid} is running - aborting start!"
+            ProcessManager::Log.info("Pidfile #{pid_file} exists and process #{pid} is running - aborting start!")
+            @file_lock.close
+            self.class.abort
+          else
+            self.class.clean_stale_pid
+          end
+        end
+        ::SimplePid.drop(pid_file)
+      end
+
+      def spawn_children
+        ProcessManager::Config.config[:children].times do |i|
+          spawn_child(i)
+          sleep ProcessManager::Config.config[:wait_between_spawning_children].to_i
+        end
+      end
+
+      # spawn a new child and pass down out PID so that it can check if we are alive
+      def spawn_child(index)
+        master_pid = $$ # need to store in order to pass down to child
+        child_pid = fork do
+          child_class.new(index, master_pid).start
+        end
+        children[index] = child_pid
+        ProcessManager::Log.info "#{description}: Spawned child #{index + 1}/#{ProcessManager::Config.config[:children]}"
+      end
+
+      def trap_signals
+        # The QUIT & INT signals triggers a graceful shutdown.
+        # The master shuts down immediately and forwards the signal to each child
+        [:INT, :QUIT, :TERM].each do |sig|
+          trap(sig) do
+            ProcessManager::Log.info "#{description}: Received #{sig} - stopping children and shutting down"
+            kill_children(sig)
+            cleanup_and_exit
+          end
+        end
+
+        trap(:CHLD) do
+          handle_chld
+        end
+      end
+
+      def cleanup_and_exit
+        SimplePid.cleanup!(pid_file)
+        @file_lock.close
+        exit
+      end
+
+      def handle_chld
+        if child = reap_child
+          ProcessManager::Log.info "#{description}: Received CHLD - cleaning dead child process"
+          cleanup_dead_child(child)
+        else
+          ProcessManager::Log.debug "#{description}: Received CHLD - ignoring as it looks like a child of a child"
+        end
+      end
+
+      def reap_child
+        dead_child = nil
+        begin
+          dead_child = Process.wait
+        rescue Errno::ECHILD
+        end
+        dead_child
+      end
+
+      def cleanup_dead_child(dead_child)
+        ProcessManager::Log.info "#{description}: been told to replace child #{dead_child.inspect}"
+        # delete given child
+        if index = children.key(dead_child)
+          children.delete(index)
+        end
+
+        # check all other children
+        children.each do |child_index, child_pid|
+          begin
+            dead_child = Process.waitpid(child_pid, Process::WNOHANG)
+            if index = children.key(dead_child)
+              children.delete(index)
+            end
+          rescue Errno::ECHILD
+          end
+        end
+
+        replace_terminated_children
+      end
+
+      # make sure we have again as many child we need
+      def replace_terminated_children
+        missing_children = ProcessManager::Config.config[:children] - children.values.size
+        if missing_children > 0
+          ProcessManager::Log.info "#{description}: not enough child processes running - missing at least #{missing_children} - respawning"
+          0.upto(ProcessManager::Config.config[:children] - 1).each do |i|
+            if children.has_key?(i)
+              ProcessManager::Log.debug "#{description}: child #{i+1}/#{ProcessManager::Config.config[:children]} is still there"
+            else
+              spawn_child(i)
+            end
+          end
+        else
+          ProcessManager::Log.debug "#{description}: no need to replace child processes"
+        end
+      end
+
+      def kill_children(sig)
+        children.each do |index, child_pid|
+          begin
+            Process.kill(sig, child_pid)
+          rescue Errno::ESRCH
+          end
+        end
+      end
+
+      def ensure_validate_configuration
+        if (errors = ProcessManager::Config.validate_config)
+          errors.each{|error| puts error}
+        end
+        cleanup_and_exit unless errors.empty?
+      end
+
+      def self.abort
+        Kernel.abort
+      end
+
+      def self.clean_stale_pid
+        puts "Pidfile #{pid_file} present but no matching process running - cleaning up"
+        ::FileUtils.rm(pid_file)
+      end
+
+      def self.find_pid
+        File.read(pid_file).chomp.to_i rescue nil
+      end
+
+      def description(pid = $$)
+        self.class.description(pid)
+      end
+
+      def child_class
+        self.class.child_class
+      end
+
+      # please override
+      def self.description(pid = $$)
+        "master #{pid}"
+      end
+
+      # please override
+      def self.child_class
+        ::ProcessManager::Daemon::Child
+      end
+
+    end
+  end
+end