uc 0.0.7 → 0.0.8

data/lib/uc/server.rb

@@ -1,57 +1,49 @@
 require 'uc/logger'
 require 'uc/shell_helper'
-require 'uc/mqueue'
-require 'uc/unicorn/api'
+require 'uc/config'
+require 'uc/status'
 require 'uc/unicorn/config'
+require 'uc/unicorn/paths'
 require 'uc/error'
+require 'uc/paths'
 
 module Uc
-
   class Server
 
     include ::Uc::ShellHelper
     include ::Uc::Logger
 
-    attr_reader :uconfig
-    attr_reader :rails_env
+    attr_reader :paths, :rails_env, :app_dir
 
-    def initialize(app_dir, rails_env: "production")
-      @uconfig = ::Uc::Unicorn::Config.new(app_dir)
+    def initialize(app_dir, rails_env: "production", debug: false)
+      @app_dir = app_dir
       @rails_env = rails_env
-      @uconfig.load_env
-    end
-
-    def app_env(&block)
-      uconfig.dirs_checked? || uconfig.check_dirs
-      yield if block
+      @debug = debug
     end
 
     def start 
-      app_env do
-        if server_running?
-          logger.info "unicorn already running pid #{pid}"
-          return
-        end
-
-        cmd %{unicorn -c #{uconfig.config_path} -D -E #{rails_env} }, return_output: false,
+      init_once
+      if server_status.running?
+        puts server_status
+        return
+      end
+      event_stream.watch_in_background :fin do
+        cmd %{unicorn -c #{uconfig.path} -D -E #{rails_env} }, return_output: false,
           error_msg: "error starting unicorn"
       end
     end
 
     def stop
-      app_env do
-        if not server_running?
-          puts "unicorn not running"
-          return
-        end
-
-        kill(pid, 30)
+      init_once
+      if server_status.stopped?
+        logger.info "unicorn not running"
+        return
       end
+      kill(server_status.pid, 30)
     end
 
     def status
-      status = ( server_running? ? "Running pid #{pid}" : "Stopped")  
-      puts status
+      puts server_status
     end
 
     def restart
@@ -60,65 +52,62 @@ module Uc
     end
 
     def rolling_restart
-      app_env
-      if not server_running?
+      init_once
+      uconfig.generate_once
+      if not server_status.running?
         start
         return
       end
-      mq = ::Uc::Mqueue.new(queue_name)
-      begin
-        mq.watch :fin do
-          Process.kill("USR2", pid)
-        end
-      rescue Errno::EACCES
-        raise ::Uc::Error, "unable to setup message queue"
-      rescue Errno::ENOENT
-        raise ::Uc::Error, "message queue deleted"
-      rescue Errno::ETIMEDOUT
-        raise ::Uc::Error, "timeout reached while waiting for server to restart"
+      event_stream.watch :fin do
+        Process.kill("USR2", server_status.pid)
+      end
+    end
+
+    def print_config
+      init_once
+      config.to_h.each do |k,v| 
+        v = %{ "#{v}" } if not v.is_a? Numeric
+        puts "#{k} #{v}" 
       end
     end
 
     private
 
-    def kill(pid, timeout)
-      Process.kill(:TERM, pid)
-      logger.debug "TERM signal sent to #{pid}"
-      (1..timeout).each do
-        if not process_running? pid
-          logger.info "Stopped #{pid}"
-          return
-        end
-        sleep 1
-      end
-      Process.kill(9, pid)
-      sleep 1
-      logger.info "Killed #{pid}"
+    def server_status
+      @server_status ||= ::Uc::Status.new(unicorn_paths)
     end
 
+    def paths
+      @paths ||= ::Uc::Paths.new(app_dir)
+    end
 
-    def process_running?(pid)
-      return false if pid <= 0
-      Process.getpgid pid
-      return true
-    rescue Errno::ESRCH
-        return false
+    def config
+      @config ||= ::Uc::Config.new(app_dir)
     end
 
-    def server_running?
-      process_running? pid
+    def unicorn_paths
+      @unicorn_paths ||= ::Uc::Unicorn::Paths.new(config.app_dir)
     end
 
-    def pid
-      uconfig.pid
+    def uconfig
+      @uconfig ||= ::Uc::Unicorn::Config.new(config.to_h, unicorn_paths)
     end
 
-    def queue_name
-      @queue_name ||= Dir.chdir uconfig.app_dir do
-        api = ::Uc::Unicorn::Api.new
-        api.queue_name
-      end
+    def lock
+      @lock ||= ::Uc::Lock.new(app_dir)
+    end
+
+    def init
+      paths.validate_required
+      lock.acquire
+      ::Uc::Logger.event_queue = config.event_queue_name
+      config.load_env
+      event_stream.debug_output = true if @debug
+    end
+
+    def init_once
+      @init_once ||= init
     end
 
-  end
+  end   
 end

data/lib/uc/shell_helper.rb

@@ -2,7 +2,7 @@ module Uc
   module ShellHelper
 
     def cmd(command, error_msg: nil, return_output: false)
-      puts "Running #{command}"
+      puts "#{"Running".bold.green} #{command}"
       if return_output
         output = `#{command}`
       else
@@ -15,5 +15,29 @@ module Uc
       return output
     end 
 
+    def kill(pid, timeout)
+      Process.kill(:TERM, pid)
+      logger.debug "TERM signal sent to #{pid}"
+      (1..timeout).each do
+        if not process_running? pid
+          logger.info "Stopped #{pid}"
+          return
+        end
+        sleep 1
+      end
+      Process.kill(9, pid)
+      sleep 1
+      logger.info "Killed #{pid}"
+    end
+
+    def process_running?(pid)
+      return false if pid <= 0
+      Process.getpgid pid
+      return true
+    rescue Errno::ESRCH
+        return false
+    end
+
+
   end 
 end

data/lib/uc/status.rb

@@ -0,0 +1,49 @@
+require 'uc/shell_helper'
+
+module Uc
+  class Status
+
+    include ::Uc::ShellHelper
+
+    attr_reader :paths
+    attr_accessor :use_pid
+
+    def initialize(unicorn_paths)
+      @paths =  unicorn_paths
+    end
+
+    def running?
+      return process_running? pid if use_pid
+      not ex_lock_available?
+    end
+
+    def pid
+      @pid ||= read_pid
+    end
+
+    def stopped?
+      not running?
+    end
+
+    def to_s
+      status = ( running? ? "Running pid #{pid}" : "Stopped")
+    end
+
+    private
+
+    def ex_lock_available?
+      File.open( paths.lock_file, 'a+') do |f|
+        ex_lock = f.flock(File::LOCK_EX|File::LOCK_NB)
+      end
+    end
+
+    def read_pid
+      pid = (File.read paths.pid_file).to_i
+      pid == 0 ? -1 : pid
+    rescue
+      return -1
+    end
+
+
+  end
+end

data/lib/uc/templates/unicorn.erb

@@ -0,0 +1,58 @@
+require 'uc/unicorn/api'
+uc = ::Uc::Unicorn::Api.new("<%= config.fetch :event_queue %>")
+worker_processes <%= config.fetch :instances %>
+working_directory "<%= paths.app_dir %>"
+timeout <%= config.fetch :timeout %>
+listen "<%= paths.socket %>" , :backlog => <%= config.fetch :queue_size %>
+pid "<%= paths.pid_file %>"
+stdout_path "<%= paths.stdout_log %>"
+stderr_path "<%= paths.stderr_log %>"
+
+ready_wait = <%= config.fetch :ready_wait %>
+
+preload_app true
+
+GC.respond_to?(:copy_on_write_friendly=) and
+  GC.copy_on_write_friendly = true
+
+check_client_connection false
+
+before_fork do |server, worker|
+
+  uc.init(server)
+
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.connection.disconnect!
+
+  if defined?(Resque)
+    Resque.redis.quit
+    Rails.logger.info('Disconnected from Redis')
+  end
+
+  uc.wait_for_worker_ready(server, worker, ready_wait: ready_wait)
+  uc.gradual_shutdown(server, worker)
+  sleep 0.3
+end
+
+after_fork do |server, worker|
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+    
+  uc.prestart server, worker, url: "<%= config.fetch :prestart_url %>"
+  uc.send_worker_ready server, worker, ready_wait: ready_wait
+  uc.end_run worker
+end
+
+before_exec do |server|
+  uc.clean_env
+  uc.load_env
+end
+
+if respond_to? :on_exec_fail
+  uc = uc
+  on_exec_fail do |server|
+    puts "runnign asdadad"
+    uc.on_exec_fail
+    puts "lol"
+  end
+end

data/lib/uc/unicorn/api.rb

@@ -1,30 +1,71 @@
-require 'uc/unicorn/rolling_restart'
+require 'uc/config'
+require 'uc/unicorn/init'
+require 'uc/unicorn/gradual_shutdown'
 require 'uc/unicorn/prestart'
+require 'uc/unicorn/ready_event'
+require 'uc/unicorn/ready_wait'
 require 'securerandom'
+require 'uc/logger'
 
 module Uc; module Unicorn
  
   class Api
 
     attr_reader :run_id
+    attr_accessor :queue_name
 
-    def initialize
+    def initialize(event_queue)
+      @queue_name = event_queue
       @run_id = SecureRandom.hex(3)
+      ::Uc::Logger.event_queue = queue_name
     end
-
-    def rolling_restart(server, worker, **kwargs)
-      rolling_restart = ::Uc::Unicorn::RollingRestart.new(server, worker, queue_name, **kwargs)
-      rolling_restart.run_id = @run_id
-      rolling_restart.run
+    
+    def init(server)
+      @init ||= ::Uc::Unicorn::Init.new(server)
+      @init.run_once
     end
 
+    def gradual_shutdown(server, worker)
+      gradual_shutdown = ::Uc::Unicorn::GradualShutdown.new(server, worker)
+      gradual_shutdown.run
+    end
 
     def prestart(server, worker, **kwargs)
-      prestart = ::Uc::Unicorn::Prestart.new(server, worker, queue_name, **kwargs)
-      prestart.run_id = @run_id
+      prestart = ::Uc::Unicorn::Prestart.new(server, worker, **kwargs)
       prestart.run
     end
 
+    def send_worker_ready(server, worker, **kwargs)
+      ready_event = ::Uc::Unicorn::ReadyEvent.new(server, worker, **kwargs)
+      ready_event.run_id = run_id
+      ready_event.run
+    end
+
+    def wait_for_worker_ready(server, worker, **kwargs)
+      ready_event_wait = ::Uc::Unicorn::ReadyWait.new(server, worker, **kwargs)
+      ready_event_wait.run_id = run_id
+      ready_event_wait.run
+    end
+
+    def acquire_shared_lock(lock_file)
+      shared_lock = ::Uc::Unicorn::Lock.new(lock_file)
+      shared_lock.acquire
+    end
+
+    def shared_env
+      @shared_env ||= {}
+    end
+
+    def end_run(worker)
+      @init.end_run(worker)
+    end
+
+    def on_exec_fail
+      event_stream = ::Uc::Logger.event_stream
+      event_stream.close_connections
+      event_stream.fatal "re-exec failed"
+    end
+
     def clean_env
       ENV.delete "BUNDLE_BIN_PATH"
       ENV.delete "RUBYLIB"
@@ -33,26 +74,9 @@ module Uc; module Unicorn
       ENV.delete "GEM_PATH"
     end
 
-    def queue_name
-      @queue_name ||= begin
-        queue_name_from_file || "unicorn_#{Process.uid}"
-      end
-    end
-
-    private 
-
-    def queue_name_from_file
-      queue_file = Pathname.new queue_name_file
-      queue_name = nil
-      if queue_file.readable?
-        queue_name = File.read(queue_file).chomp
-        queue_name = (queue_name.empty? ? nil : queue_name)
-      end
-      return queue_name
-    end
-
-    def queue_name_file
-      "config/unicorn_mq"  
+    def load_env
+      config = ::Uc::Config.new(Dir.pwd)
+      config.load_env
     end
 
   end

data/lib/uc/unicorn/config.rb

@@ -1,86 +1,46 @@
-require 'pathname'
 require 'uc/logger'
-module Uc; module Unicorn
-  class Config
+require 'uc/error'
+require 'erb'
 
-    include ::Uc::Logger  
+module Uc
+  module Unicorn
 
-    attr_reader :app_dir
+    class Config
 
-    def initialize(app_dir)
-      @app_dir = app_dir
-    end
-
-    def config_path
-      rpath "config/unicorn.rb"
-    end
-
-
-    def stdout_log
-      rpath "log/unicorn.stdout.log"
-    end
-
-    def stderr_log
-      rpath "log/unicorn.stderr.log"
-    end
-
-    def socket_file
-      rpath "tmp/sockets/unicorn.sock"
-    end
-
-    def pid_file
-      rpath "tmp/pids/unicorn.pid"
-    end
+      include ::Uc::Logger  
 
-    def rack_path
-      rpath "config.ru"
-    end
-
-    def read_pid
-      pid = (File.read pid_file).to_i
-      pid == 0 ? -1 : pid
-    rescue
-      return -1
-    end
+      attr_reader :paths, :config
 
-    def pid
-      @pid ||= read_pid
-    end
+      def initialize(config_hash, paths)
+        @config = config_hash
+        @paths = paths
+      end
 
-    def check_dirs
-      logger.debug "Using app_dir => #{app_dir}"
-      raise ::Uc::Error, %{app_dir not readable} if not path_readable? app_dir
-      Dir.chdir app_dir do
-        raise ::Uc::Error, %{no config.ru found in app_dir} if not path_readable? rack_path
-        raise ::Uc::Error, %{no unicorn config found %} if not path_readable? config_path
+      def path
+        generate_once
+        paths.unicorn_config
       end
-      @dirs_checked = true
-    end
-  
-    def dirs_checked?
-      @dirs_checked
-    end
 
-    def load_env
-      env_file = rpath "config/uc_env.rb"
-      File.readable? env_file and
-        load env_file
-    rescue LoadError
-    end
+      def generate_config_file
+        erb = ERB.new(File.read(paths.unicorn_template))
+        binding = Kernel.binding
+        File.open(paths.unicorn_config, 'w') do |f|
+          f.write erb.result(binding)
+        end 
+        return true
+      rescue => e
+        logger.debug e.message
+        raise ::Uc::Error, "unable to generate unicorn config"
+      end
 
-    private 
+      def generate_once
+        return if @config_generated
+        generate_config_file
+        @config_generated = true
+      end
 
-    def rpath(path)
-      path = Pathname.new(path)
-      raise "absolute path specified: #{path}" if path.absolute?
-      "#{app_dir}/#{path}"
-    end
 
-    def path_readable?(path_str)
-      path = Pathname.new(path_str)
-      path.readable?
     end
 
-
-  end
-end; end
+  end 
+end

data/lib/uc/unicorn/gradual_shutdown.rb

@@ -0,0 +1,57 @@
+require 'uc/logger'
+require 'uc/unicorn/helper'
+
+module Uc
+  module Unicorn
+  
+    class GradualShutdown
+
+      include ::Uc::Logger
+      include ::Uc::Unicorn::Helper
+
+      attr_reader :server, :worker
+
+      def initialize(server, worker)
+        @server = server
+        @worker = worker
+      end
+
+      def run
+        return if not (server && worker)
+        return if not restart?
+        shutdown_old_master 
+      end
+
+      def shutdown_old_master
+        event_stream.debug "stopping old worker #{id}"
+        if send_signal
+          event_stream.debug "stopped old worker #{id}"
+        end
+      end
+
+      def sig
+        (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
+      end
+
+      def send_signal
+        Process.kill(sig, File.read(old_pid).to_i)
+        return true
+      rescue => e
+        log_kill_error e
+        return false
+      end
+
+      def log_kill_error(e)
+        stderr.info "error sending kill signal #{id}| #{e.class} #{e.message}"
+        event_stream.warn "error while stopping worker #{worker.nr + 1}, #{e.class}"
+      end
+
+      def id
+        @id ||= (worker.nr + 1)
+      end
+
+    end
+
+  end
+end
+

data/lib/uc/unicorn/helper.rb

@@ -0,0 +1,25 @@
+module Uc
+  module Unicorn
+    module Helper
+
+      def restart?
+        (File.readable? old_pid) && (server.pid != old_pid)
+      end
+
+      def first_worker?
+        worker.nr == 0
+      end
+          
+      def last_worker?
+        (worker.nr + 1) == server.worker_processes
+      end
+ 
+      def old_pid
+        "#{server.config[:pid]}.oldbin"
+      end
+
+
+    end
+  end
+end
+

data/lib/uc/unicorn/init.rb

@@ -0,0 +1,58 @@
+require 'uc/unicorn/helper'
+require 'uc/error'
+require 'uc/logger'
+
+module Uc
+  module Unicorn
+    class Init
+
+      include ::Uc::Logger
+      include ::Uc::Unicorn::Helper
+
+      attr_accessor :server, :worker
+
+      def initialize(server)
+        @server = server
+      end
+
+      def event_type
+        @event_type ||= (restart? ? "restart" : "start")
+      end
+
+      def lock_file
+        @lock_file ||= "tmp/unicorn.lock"
+      end
+
+      def run
+        event_stream.debug "event_type #{event_type}"
+        acquired = acquire_lock
+        if not acquired
+          error_msg = "unable to acquire shared lock (unicorn)"
+          event_stream.fatal error_msg
+          raise ::Uc::Error, error_msg
+        end
+      end
+
+      def acquire_lock
+        lock_acquired = File.new(lock_file, "a+").flock(File::LOCK_SH | File::LOCK_NB )
+       rescue => e
+        stderr.error "#{e.class} #{e.message}\n #{e.backtrace.join("\n")}"
+        return false
+      end
+
+      def run_once
+       return if @ran_once
+       @ran_once = true
+       run
+      end
+
+      def end_run(worker)
+        @worker = worker
+        if last_worker?
+          event_stream.pub :fin, "server #{event_type}" 
+        end
+      end
+
+    end
+  end
+end