uc 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f34804e8f79d78729380eeab1d954bee634792ad
-  data.tar.gz: 327501a9ea5089ea852ab3f1907485f48422cc22
+  metadata.gz: 59c522f2247a747ec300e7cafbd827b7700f18be
+  data.tar.gz: 7303d81d3893d08bed3de0856835014df3882efe
 SHA512:
-  metadata.gz: bdea49006e4b025300bd0cb94e7577b5b40f492bf536252ee77f051505b208ad6a1151e30a125713d00a7f8d2d984ec5bbd02cd4d43489236c20e523c9d75ae2
-  data.tar.gz: 49f24b6ce3d7017db4d2a5822a1b3b63f0310ce28d6ef148e49f40b55b8911c520b83fe1978b6b8b48400e1f3e9f4088a0da0fe47681d55061a82cd0b8a5b4d1
+  metadata.gz: 7bda91add1413b1fa20739eaf23b975d45920e8dd8739fce7d2d7de97db8ba1b18d9762337ced2c796203882d2a188e29dececa291e93d1ef2df7e9a31489f03
+  data.tar.gz: e9764c28553b46752e4d1c0689ca93a5aed0e601c0c7d3e38a531d434ee3159e66fa12c690ebb3b8bcf41cb18960d35e8b37caaededa8898c99c525b2f1f6bc1

data/bin/uc

@@ -8,7 +8,10 @@ require 'optparse'
 require 'uc/error'
 require 'uc/version'
 require 'uc/server'
+require 'uc/logger'
+require 'uc/lock'
 
+logger = ::Uc::Logger.logger
 options = {}
 options[:rails_env] = "production"
 
@@ -38,6 +41,11 @@ opts_parser = OptionParser.new do |opts|
       exit
     end
 
+    opts.on("--debug", "Show debug messages") do
+      logger.level = ::Logger::DEBUG
+      ENV["UC_DEBUG"] = "true"
+    end
+
     opts.on_tail("-h", "--help", "Show this message") do 
       puts opts
       exit
@@ -46,8 +54,9 @@ end
 
 begin
   opts_parser.parse!(ARGV)
-
   app_dir = options[:app_dir] || Dir.pwd
+  lock = ::Uc::Lock.new(app_dir)
+  lock.acquire
   server = ::Uc::Server.new(app_dir, rails_env: options[:rails_env])
   command = ARGV.shift
 
@@ -55,14 +64,14 @@ begin
   when "start", "stop", "restart", "status"
     server.send command.to_sym
   when "rr", "rolling-restart"
-    server.rolling_restart ARGV.shift
+    server.rolling_restart
   when nil
-    puts "ERROR No command specified",""
+    logger.error "No command specified"
     puts opts_parser
     abort
   end
 
 rescue OptionParser::InvalidOption, OptionParser::MissingArgument, ::Uc::Error => e
-  puts "ERROR #{e.message}"
+  logger.error "#{e.message}"
   abort
 end

data/lib/uc/lock.rb

@@ -0,0 +1,18 @@
+require 'uc/error'
+module Uc
+  class Lock
+
+    attr_reader :app_dir
+    def initialize(app_dir)
+      @app_dir = app_dir
+    end
+
+    def acquire
+      Dir.chdir app_dir do
+        lock_acquired = File.new("tmp/.uc.lock", "a+").flock( File::LOCK_NB | File::LOCK_EX )
+        raise ::Uc::Error,"another uc process is already running"  if not lock_acquired
+      end
+    end
+
+  end
+end

data/lib/uc/logger.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'uc/mq_logger'
 module Uc
   module Logger
    
@@ -6,16 +7,26 @@ module Uc
       @logger ||= begin
         logger = ::Logger.new(STDOUT)
         logger.formatter = proc do |severity, datetime, progname, msg|
-          "#{msg}\n"
+          if severity == "INFO"
+            "#{msg}\n"
+          else
+            "#{severity} #{msg}\n"
+          end
         end
         logger.level = ::Logger::INFO
         logger
       end
-    end 
+    end
 
     def logger
       ::Uc::Logger.logger
     end
 
+    def mq_log(msg)
+      return if not respond_to? :queue_name
+      @mq_logger ||= ::Uc::MqLogger.new(queue_name)
+      @mq_logger.log msg 
+    end 
+
   end
 end

data/lib/uc/mq_logger.rb

@@ -0,0 +1,22 @@
+module Uc
+  class MqLogger
+
+    attr_reader :queue_name
+
+    def initialize(queue_name)
+      @queue_name = queue_name
+    end
+
+    def mq
+      @mq ||= ::Uc::Mqueue.new(queue_name)
+    end
+
+    def log(msg)
+      @writer ||= mq.nb_writer
+      @writer.send msg
+    rescue Errno::ENOENT, Errno::EAGAIN, Errno::EACCES, Errno::EMSGSIZE => e
+      puts "#{e.class} #{e.message}"
+    end
+
+  end
+end

data/lib/uc/mqueue.rb

@@ -1,66 +1,84 @@
 require 'posix_mq'
-require 'uc/logger'
 module Uc
   class Mqueue
-    include ::Uc::Logger
  
-    attr_reader :name 
+    attr_reader :name, :max_msg, :msg_size
 
-    def initialize(name)
+    def initialize(name, max_msg: 10, msg_size: 100)
       @name = name
+      @max_msg = max_msg
+      @msg_size = msg_size
     end
 
-    def setup
-      attr = ::POSIX_MQ::Attr.new(0,100,100)       # o_readonly, maxmsg, msgsize
-      puts name
+    def create
       ::POSIX_MQ.new("/#{name}", :rw, 0700, attr)
-      make_empty
     end
 
-    def reader
-      @reader ||= ::POSIX_MQ.new("/#{name}", :r)
+    def recreate
+      destroy
+      create
     end
 
-    def nb_reader
-      mq = ::POSIX_MQ.new("/#{name}", :r)
-      mq.nonblock = true
-      return mq
+    def destroy
+      ::POSIX_MQ.unlink("/#{name}")
+    rescue
+      return false
     end
 
-    def writer
-      POSIX_MQ.new("/#{name}", IO::WRONLY)
+    def attr
+      ::POSIX_MQ::Attr.new(0,max_msg,msg_size)
+    end
+  
+    def new_mq(io_mode, nonblock, &block)
+      mq = ::POSIX_MQ.new("/#{name}", io_mode)
+      mq.nonblock = true if nonblock
+      return mq if not block_given?
+       
+      begin
+          yield mq
+      ensure
+          mq.close if mq
+      end
     end
 
-    def nb_writer
-      writer = POSIX_MQ.new("/#{name}", IO::WRONLY)
-      writer.nonblock = true
-      return writer
+    def reader(&block)
+      new_mq(:r, false, &block)
     end
 
-    def watch(loglevel: :info, msg: "success", err_msg: "error", &block)
-      setup
-      make_empty
-      yield
-      wait_for_fin(msg, err_msg, loglevel)
+    def nb_reader(&block)
+      new_mq(:r, true, &block)
+    end
+
+    def writer(&block)
+      new_mq(IO::WRONLY, false, &block)
     end
 
-    def wait_for_fin(msg, err_msg, loglevel)
+    def nb_writer(&block)
+      new_mq(IO::WRONLY, true, &block)
+    end
+
+    def wait(event, timeout, output: false)
+      event = event.to_s
       message = ""
-      timeout = 30
-      while message != "fin"
-        reader.receive(message, timeout)
-        logger.send(loglevel, message) if message != "fin"
+      reader do |r|
+        while message != event do
+          r.receive(message, timeout)
+          puts "> #{message}" if output
+        end
       end
-      logger.info msg
-    rescue Errno::ETIMEDOUT
-      logger.info "#{timeout}s timeout reached while waiting for message"
-      raise ::Uc::Error, err_msg
+      return message
+    end
+
+    def watch(event, timeout: 30, recreate: true, &block)
+      self.recreate if recreate 
+      clear
+      yield
+      wait(event, timeout, output: true)
     end
 
-    def make_empty
-      mq = nb_reader
-      while true do
-        mq.receive
+    def clear
+      nb_reader do |mq|
+        loop { mq.receive }
       end
     rescue Errno::EAGAIN
       return

data/lib/uc/server.rb

@@ -1,11 +1,12 @@
 require 'uc/logger'
 require 'uc/shell_helper'
 require 'uc/mqueue'
-require 'uc/unicorn'
-require 'uc/unicorn_config'
+require 'uc/unicorn/api'
+require 'uc/unicorn/config'
 require 'uc/error'
 
 module Uc
+
   class Server
 
     include ::Uc::ShellHelper
@@ -15,9 +16,9 @@ module Uc
     attr_reader :rails_env
 
     def initialize(app_dir, rails_env: "production")
-      @uconfig = ::Uc::UnicornConfig.new(app_dir)
+      @uconfig = ::Uc::Unicorn::Config.new(app_dir)
       @rails_env = rails_env
-      load_env
+      @uconfig.load_env
     end
 
     def app_env(&block)
@@ -48,21 +49,6 @@ module Uc
       end
     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 status
       status = ( server_running? ? "Running pid #{pid}" : "Stopped")  
       puts status
@@ -73,20 +59,44 @@ module Uc
       start
     end
 
-    def rolling_restart(queue = nil)
+    def rolling_restart
       app_env
       if not server_running?
         start
         return
       end
-      queue ||= get_queue_name
-      raise ::Uc::Error, "argument missing mq name"  if (queue.nil? || queue.empty?)
-      mq = ::Uc::Mqueue.new(queue)
-      mq.watch err_msg: "server may not have restarted successfully" do
-        Process.kill("USR2", pid)
+      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"
+      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}"
     end
 
+
     def process_running?(pid)
       return false if pid <= 0
       Process.getpgid pid
@@ -99,25 +109,15 @@ module Uc
       process_running? pid
     end
 
-    def get_queue_name
-      Dir.chdir uconfig.app_dir do
-        return ::Uc::Unicorn.get_queue_name
-      end
-    end
-
-    def read_pid
-      uconfig.read_pid
-    end
-
     def pid
-      @pid ||= read_pid
+      uconfig.pid
     end
 
-    def load_env
-      env_file = "#{uconfig.app_dir}/config/uc_env.rb"
-      File.readable? env_file and
-        load "#{uconfig.app_dir}/config/uc_env.rb"
-    rescue LoadError
+    def queue_name
+      @queue_name ||= Dir.chdir uconfig.app_dir do
+        api = ::Uc::Unicorn::Api.new
+        api.queue_name
+      end
     end
 
   end

data/lib/uc/unicorn/api.rb

@@ -0,0 +1,60 @@
+require 'uc/unicorn/rolling_restart'
+require 'uc/unicorn/prestart'
+require 'securerandom'
+
+module Uc; module Unicorn
+ 
+  class Api
+
+    attr_reader :run_id
+
+    def initialize
+      @run_id = SecureRandom.hex(3)
+    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
+    end
+
+
+    def prestart(server, worker, **kwargs)
+      prestart = ::Uc::Unicorn::Prestart.new(server, worker, queue_name, **kwargs)
+      prestart.run_id = @run_id
+      prestart.run
+    end
+
+    def clean_env
+      ENV.delete "BUNDLE_BIN_PATH"
+      ENV.delete "RUBYLIB"
+      ENV.delete "RUBYOPT"
+      ENV.delete "GEM_HOME"
+      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"  
+    end
+
+  end
+
+end; end

data/lib/uc/{unicorn_config.rb → unicorn/config.rb}

@@ -1,7 +1,7 @@
 require 'pathname'
 require 'uc/logger'
-module Uc
-  class UnicornConfig
+module Uc; module Unicorn
+  class Config
 
     include ::Uc::Logger  
 
@@ -43,6 +43,10 @@ module Uc
       return -1
     end
 
+    def pid
+      @pid ||= read_pid
+    end
+
     def check_dirs
       logger.debug "Using app_dir => #{app_dir}"
       raise ::Uc::Error, %{app_dir not readable} if not path_readable? app_dir
@@ -57,6 +61,12 @@ module Uc
       @dirs_checked
     end
 
+    def load_env
+      env_file = rpath "config/uc_env.rb"
+      File.readable? env_file and
+        load env_file
+    rescue LoadError
+    end
 
     private 
 
@@ -66,14 +76,11 @@ module Uc
       "#{app_dir}/#{path}"
     end
 
-    def rpathname(path)
-      Pathname.new(rpath(path))
-    end
-  
     def path_readable?(path_str)
       path = Pathname.new(path_str)
       path.readable?
     end
 
+
   end
-end
+end; end

data/lib/uc/unicorn/prestart.rb

@@ -0,0 +1,83 @@
+require 'uc/logger'
+require 'uc/mqueue'
+
+module Uc; module Unicorn;
+  class Prestart
+
+    include ::Uc::Logger
+
+    attr_reader :server, :worker, :queue_name, :url
+    attr_accessor :run_id
+
+    def initialize(server, worker, queue_name, url: "/", run_id: nil)
+      @server = server
+      @worker = worker
+      @url = url
+      @queue_name = queue_name
+      @run_id = run_id
+    end
+
+    def app
+      @app ||= server.instance_variable_get("@app")
+    end
+
+    def run
+      response = app.call(rack_request)
+      body = response[2]
+      body.close
+      end_prestart
+    rescue => e
+      logger.warn "pre start failed for worker : #{e.message}"
+    end
+
+
+    private
+
+    def worker_id
+      worker.nr + 1
+    end
+
+    def rack_request
+      Rack::MockRequest.env_for("http://127.0.0.1/#{url}")
+    end
+
+    def last_worker?
+      (worker.nr + 1) == server.worker_processes
+    end 
+
+    def end_prestart
+      if last_worker?
+        logger.debug "[ps] no_event #{worker_id}"
+        return
+      end
+      logger.debug "[ps] start #{worker_id}"
+      send_prestart_end
+      mq_log "prestart end worker #{worker_id}"
+      logger.debug "[ps] end #{worker_id}"
+    end
+
+    def send_prestart_end
+      mq.create
+      mq.clear
+      mq.nb_writer do |writer|
+        writer.send prestart_end_event
+      end
+    rescue Errno::ENOENT, Errno::EAGAIN, Errno::EACCES => e
+      logger.warn "prestart failed for worker #{worker.nr + 1}: #{e.class}"
+    end
+
+    def prestart_end_event
+      run_id ? "prestart_end_#{run_id}" : "prestart_end" 
+    end
+
+    def mq
+      @mq ||= ::Uc::Mqueue.new(prestart_queue_name, max_msg: 10, msg_size: 30)
+    end
+
+    def prestart_queue_name
+      "#{queue_name}_prestart_#{worker.nr}"
+    end
+
+  end
+end; end
+

data/lib/uc/unicorn/rolling_restart.rb

@@ -0,0 +1,87 @@
+require 'uc/mqueue'
+require 'uc/logger'
+module Uc; module Unicorn
+  class RollingRestart
+
+    include ::Uc::Logger
+    attr_reader :server, :worker, :queue_name, :prestart_wait, :sleep_secs
+    attr_accessor :run_id
+
+    def initialize(server, worker, queue_name, prestart_wait: nil, sleep_secs: 0.1)
+      @server = server
+      @worker = worker
+      @queue_name = queue_name
+      @prestart_wait = prestart_wait
+      @sleep_secs = sleep_secs
+    end
+
+    def run
+      return if not (server && worker)
+      return if not restart?
+
+      destroy_prestart_queues
+      wait_for_prestart_end_event
+      sleep sleep_secs if not first_worker?
+      kill_old_worker
+    end
+
+    private
+
+    def prestart_mq
+      @prestart_mq ||= ::Uc::Mqueue.new(prestart_queue, max_msg: 10, msg_size: 30)
+    end
+
+    def destroy_prestart_queues
+      return if not first_worker?
+      (0..server.worker_processes).each do |i|
+        mq = ::Uc::Mqueue.new("#{queue_name}_prestart_#{i}")
+        mq.destroy
+      end
+    end
+ 
+    def prestart_queue
+      first_worker? ? nil : "#{queue_name}_prestart_#{worker.nr - 1}"
+    end
+
+    def wait_for_prestart_end_event
+      return if not prestart_wait
+      if not prestart_queue
+        logger.debug "[rr] no ps wait for #{worker.nr + 1}"
+        return
+      end
+      begin
+        prestart_mq.create
+        msg = prestart_mq.wait( prestart_end_event, prestart_wait)
+        logger.debug "[rr] ps end event #{prestart_end_event} for #{ worker.nr + 1}"
+      rescue => e
+        logger.info "#{e.class} #{e.message}"
+      end
+    end
+
+    def kill_old_worker
+      sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
+      Process.kill(sig, File.read(old_pid).to_i)
+      mq_log "starting worker #{worker.nr + 1}"
+      mq_log "fin" if sig == :QUIT
+    rescue Errno::ENOENT, Errno::ESRCH, Errno::EAGAIN, Errno::EACCES => e
+      logger.error "rolling restart #{e.class} #{e.message}"
+    end
+
+    def prestart_end_event
+      run_id ? "prestart_end_#{run_id}" : "prestart_end"
+    end
+
+    def restart?
+      old_pid != server.pid
+    end
+
+    def first_worker?
+      worker.nr == 0
+    end
+    
+    def old_pid
+      "#{server.config[:pid]}.oldbin"
+    end
+  
+  end
+end; end

data/lib/uc/version.rb

@@ -1,3 +1,3 @@
 module Uc
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: uc
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Neeraj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-19 00:00:00.000000000 Z
+date: 2014-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,12 +68,16 @@ files:
 - bin/uc
 - lib/uc.rb
 - lib/uc/error.rb
+- lib/uc/lock.rb
 - lib/uc/logger.rb
+- lib/uc/mq_logger.rb
 - lib/uc/mqueue.rb
 - lib/uc/server.rb
 - lib/uc/shell_helper.rb
-- lib/uc/unicorn.rb
-- lib/uc/unicorn_config.rb
+- lib/uc/unicorn/api.rb
+- lib/uc/unicorn/config.rb
+- lib/uc/unicorn/prestart.rb
+- lib/uc/unicorn/rolling_restart.rb
 - lib/uc/version.rb
 - uc.gemspec
 homepage: ''

data/lib/uc/unicorn.rb

@@ -1,70 +0,0 @@
-require 'uc/mqueue'
-module Uc
-  module Unicorn
-
-    def self.queue_file
-      "config/unicorn_mq"
-    end
-
-    def self.rolling_restart(server, worker, queue_name: nil, sleep_secs: 1)
-      queue_name ||= get_queue_name
-      old_pid = "#{server.config[:pid]}.oldbin"
-      if old_pid != server.pid
-        sleep sleep_secs
-        begin
-          sig = (worker.nr + 1) >= server.worker_processes ? :QUIT : :TTOU
-          Process.kill(sig, File.read(old_pid).to_i)
-
-          mq = ::Uc::Mqueue.new(queue_name)
-          writer = mq.nb_writer
-          writer.send("started worker #{worker.nr + 1}")
-          if sig == :QUIT
-            writer.send("fin")
-          end
-        rescue Errno::ENOENT, Errno::ESRCH, Errno::EAGAIN => e
-        end
-     end
-    end
-
-    def self.clean_env
-      ENV.delete "BUNDLE_BIN_PATH"
-      ENV.delete "RUBYLIB"
-      ENV.delete "RUBYOPT"
-      ENV.delete "GEM_HOME"
-      ENV.delete "GEM_PATH"
-    end
-
-
-    def self.get_queue_name
-      queue_name = queue_name_from_file
-      queue_name ||= "unicorn_#{Process.uid}"
-      return queue_name
-    end
-
-    def self.queue_name_from_file
-      queue_file = Pathname.new self.queue_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 self.pre_start(server, worker, url: "/")
-      app = server.instance_variable_get("@app")
-      response = app.call(rack_request(url))
-      body = response[2]
-      body.close
-    rescue => e
-      puts "WARN: pre start url failed : #{e.message}"
-    end
-
-    private
-
-    def self.rack_request(url)
-      Rack::MockRequest.env_for("http://127.0.0.1/#{url}")
-    end
-
-  end
-end