uc 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59c522f2247a747ec300e7cafbd827b7700f18be
-  data.tar.gz: 7303d81d3893d08bed3de0856835014df3882efe
+  metadata.gz: a1136a67ca433cebf902cb4bb1eacc673e61abed
+  data.tar.gz: 77019d47d98b56c17929eff36c90fd7c8aa8a487
 SHA512:
-  metadata.gz: 7bda91add1413b1fa20739eaf23b975d45920e8dd8739fce7d2d7de97db8ba1b18d9762337ced2c796203882d2a188e29dececa291e93d1ef2df7e9a31489f03
-  data.tar.gz: e9764c28553b46752e4d1c0689ca93a5aed0e601c0c7d3e38a531d434ee3159e66fa12c690ebb3b8bcf41cb18960d35e8b37caaededa8898c99c525b2f1f6bc1
+  metadata.gz: 2f331fac3d78f17fca9267e1213d225c9b9ed0ba83ee1ea452199605a376fd02174336b4bae6cf45ace8013081f6b5b826b06c3e4ef760bc7fe7a5d9b7116cf6
+  data.tar.gz: 047df981a85aa29710c2ba2cd26e27dcc25b5c0ab716eb1d94a505b29c13801a3d16a50742921b7051a8760f4c863d6fc93b4bf2da76d9aebb02ac1442a4060c

data/bin/uc

@@ -42,8 +42,8 @@ opts_parser = OptionParser.new do |opts|
     end
 
     opts.on("--debug", "Show debug messages") do
+      options[:debug] = true
       logger.level = ::Logger::DEBUG
-      ENV["UC_DEBUG"] = "true"
     end
 
     opts.on_tail("-h", "--help", "Show this message") do 
@@ -55,13 +55,11 @@ 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])
+  server = ::Uc::Server.new(app_dir, rails_env: options[:rails_env], debug: options[:debug])
   command = ARGV.shift
 
   case command
-  when "start", "stop", "restart", "status"
+  when "start", "stop", "restart", "status", "print_config"
     server.send command.to_sym
   when "rr", "rolling-restart"
     server.rolling_restart
@@ -69,9 +67,16 @@ begin
     logger.error "No command specified"
     puts opts_parser
     abort
+  else
+    logger.error "No such command #{command}"
+    abort
   end
 
 rescue OptionParser::InvalidOption, OptionParser::MissingArgument, ::Uc::Error => e
-  logger.error "#{e.message}"
-  abort
+  if options[:debug]
+    raise e
+  else
+    logger.error "#{e.message}"
+    abort
+  end
 end

data/examples/unicorn.rb

@@ -0,0 +1,44 @@
+require 'uc/unicorn/api'
+require 'uc/unicorn/config'
+app_dir = "/path/to/app/dir"
+
+uc = ::Uc::Unicorn::Api.new
+uconfig = ::Uc::Unicorn::Config.new(app_dir)
+
+worker_processes 5
+working_directory app_dir
+timeout 30
+listen uconfig.socket_file, :backlog => 128
+pid uconfig.pid_file
+stdout_path uconfig.stdout_log
+stderr_path uconfig.stderr_log
+
+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|
+  # the following is highly recomended for Rails + "preload_app true"
+  # as there's no need for the master process to hold a connection
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.connection.disconnect!
+
+  if defined?(Resque)
+    Resque.redis.quit
+    Rails.logger.info('Disconnected from Redis')
+  end
+  uc.rolling_restart(server, worker, prestart_wait: 5)
+end
+
+after_fork do |server, worker|
+  defined?(ActiveRecord::Base) and
+    ActiveRecord::Base.establish_connection
+  uc.prestart server, worker, url: "/in"
+end
+
+before_exec do |server|
+  uc.clean_env
+end

data/lib/uc/config.rb

@@ -0,0 +1,95 @@
+require 'uc/logger'
+
+module Uc
+  class Config
+
+    include ::Uc::Logger
+
+    def initialize(app_dir, config_file = nil)
+      @config_file = config_file
+      @app_dir = app_dir
+    end
+
+    def config_file
+      @config_file ||= "#{app_dir}/config/uc.rb"
+    end
+
+    def config
+      return @config if @config
+      @config = {
+        instances: 2,
+        queue_size: 1024,
+        timeout: 30,
+        prestart_url: "/",
+        working_dir: @app_dir,
+        event_queue: "unicorn_#{Process.uid}",
+        ready_wait: 5
+      }
+      read_from_file
+      return @config
+    end
+
+    def to_h
+      config
+    end
+
+    def ready_wait(wait_timeout)
+      config[:ready_wait] = wait_timeout.to_i
+    end
+
+    def event_queue_name
+      config[:event_queue]
+    end
+
+    def instances(num_instances)
+      config[:instances] = num_instances
+    end
+
+    def backlog(queue_size)
+      config[:queue_size] = queue_size
+    end
+
+    def prestart_url(url)
+      config[:prestart_url] = url
+    end
+
+    def timeout(secs)
+      config[:timeout] = secs
+    end
+
+    def working_dir
+      config[:working_dir] = working_dir
+    end
+
+    def event_queue(event_queue)
+      config[:event_queue] = event_queue
+    end
+
+    def app_dir
+      config[:working_dir]
+    end
+
+    def env_hash
+      @env_hash ||= {}
+    end
+
+    def env(key, value)
+      env_hash[key] = value
+    end
+
+    def load_env
+      config
+      env_hash.each do |k,v|
+        ENV[k] = v
+      end
+    end
+    
+    def read_from_file
+      return if not File.readable? config_file
+      instance_eval(File.read(config_file))
+    rescue NoMethodError => e
+      logger.warn "invalid option used in config: #{e.name}"
+    end
+
+  end
+end

data/lib/uc/custom_logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+module Uc
+  class CustomLogger < ::Logger
+
+    def initialize(file)
+      super(file)
+      @level = ::Logger::INFO
+    end
+
+    def format_message(severity, timestamp, progname, msg)
+      case severity
+      when "INFO"
+        "#{msg}\n"
+      when "ERROR"
+        "#{severity.bold.red} #{msg}\n"
+      when "WARN"
+        "#{severity.downcase.bold.yellow} #{msg}\n"
+      else
+        "#{severity.downcase.bold.blue} #{msg}\n"
+      end
+    end
+
+  end
+end

data/lib/uc/event.rb

@@ -0,0 +1,4 @@
+module Uc
+  class Event < ::Struct.new(:type, :msg)
+  end
+end

data/lib/uc/event_stream.rb

@@ -0,0 +1,162 @@
+require 'uc/ext/string'
+require 'uc/mqueue'
+require 'uc/event'
+
+module Uc
+  class EventStream
+
+    attr_reader :queue_name
+    attr_accessor :debug_output
+
+    def initialize(queue_name)
+      @queue_name = queue_name
+    end
+
+    def info(msg)
+      pub :info, msg
+    end
+
+    def debug(msg)
+      pub :debug, msg
+    end
+
+    def warn(msg)
+      pub :warn, msg
+    end
+
+    def fatal(msg)
+      pub :fatal, msg
+    end
+
+    def pub(type, msg)
+      tmsg = truncate "#{type}|#{msg}"
+      writer.send tmsg
+    rescue Errno::ENOENT, Errno::EAGAIN, Errno::EACCES, Errno::EMSGSIZE => e
+      puts "#{e.class} #{e.message}"
+    end
+
+    def truncate(msg)
+      if msg.size <= mq.msg_size
+        return msg
+      else
+        msg = "#{msg[0, mq.msg_size - 3] }..."
+      end
+    end
+
+    def watch(event_type, timeout: 30, recreate: true, &block)
+      mq.recreate if recreate
+      mq.clear
+      yield
+      wait(event_type, timeout, output: true)
+    rescue => e
+      raise uc_error(e)
+    end
+
+    def watch_in_background(event_type, timeout: 30, recreate: true, &block)
+      begin
+        mq.recreate if recreate
+        mq.clear
+        t = wait_in_background(event_type, timeout, output: true, first_timeout: 50)
+        yield
+        t.join
+        raise t[:error] if t[:error]
+      rescue => e
+        raise uc_error(e)
+      ensure
+        t.kill if t
+      end
+    end
+
+    def wait(event_type, timeout, output: false, first_timeout: nil)
+      event_type = event_type.to_s
+      message = ""
+      event = ""
+      t = first_timeout || timeout
+      mq.reader do |r|
+        loop do
+          r.receive(message, t)
+          t = timeout
+          event = parse message
+          print event if output
+          break if event.type == event_type
+        end
+      end
+      puts "#{"success".green.bold} #{event.msg}"
+      true
+    end
+
+    def wait_in_background(event_type, timeout, **kwargs)
+      Thread.new do
+        begin
+          wait(event_type, timeout, **kwargs)
+        rescue => e
+          Thread.current[:error] = e
+          false
+        end
+      end
+    end
+
+    def print(event)
+      case event.type
+      when "info"
+        puts event.msg
+      when "warn"
+        puts "#{"warn".yellow.bold} #{event.msg}"
+      when "debug"
+        puts "#{"debug".blue.bold} #{event.msg}" if debug_output
+      when "fatal"
+        raise ::Uc::Error, event.msg
+      end
+    end
+
+    def close_connections
+      writer.close if writer
+      @writer = nil
+    end
+
+
+    private  
+
+    def read(timeout)
+      event = ""
+      reader do |r|
+        r.receive(event, timeout)
+        parse event
+      end
+    end
+ 
+    def parse(event_str)
+      arr = event_str.split("|",2)
+      if arr.length == 2
+        type, msg = arr[0], arr[1]
+      else
+        type, msg = "unknown", event
+      end
+      event = ::Uc::Event.new(type, msg)
+    end
+
+    def mq
+      @mq ||= ::Uc::Mqueue.new(@queue_name)
+    end
+
+    def writer
+      @writer ||= mq.nb_writer
+    end
+
+    def uc_error(e)
+      case e
+      when Errno::EACCES
+        msg = "unable to setup message queue"
+      when Errno::ENOENT
+        msg = "message queue deleted"
+      when Errno::ETIMEDOUT
+        msg = "timeout reached while waiting for server ready msg"
+      else
+        return e
+      end
+
+      return ::Uc::Error.new(msg)
+    end
+
+  end
+end

data/lib/uc/ext/string.rb

@@ -0,0 +1,29 @@
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end 
+
+  def bold
+    "\e[1m#{self}\e[0m"
+  end 
+  
+  def white
+    colorize(37)
+  end 
+
+  def green
+    colorize(32)
+  end 
+
+  def yellow
+    colorize(33)
+  end 
+
+  def red 
+    colorize(31)
+  end 
+
+  def blue
+    colorize(34)
+  end 
+end

data/lib/uc/logger.rb

@@ -1,32 +1,45 @@
 require 'logger'
-require 'uc/mq_logger'
+require 'uc/custom_logger'
+require 'uc/event_stream'
 module Uc
   module Logger
-   
+
+    class << self
+      attr_reader :event_queue
+    end
+
+    def self.event_queue=(queue_name)
+      @event_stream = nil
+      @event_queue = queue_name
+    end
+
     def self.logger
-      @logger ||= begin
-        logger = ::Logger.new(STDOUT)
-        logger.formatter = proc do |severity, datetime, progname, msg|
-          if severity == "INFO"
-            "#{msg}\n"
-          else
-            "#{severity} #{msg}\n"
-          end
-        end
-        logger.level = ::Logger::INFO
-        logger
-      end
+      @logger ||= ::Uc::CustomLogger.new(STDOUT)
+    end
+
+    def self.stderr
+      @stderr ||= ::Logger.new(STDERR)
+    end
+
+
+    def self.event_stream
+      @event_stream ||= ::Uc::EventStream.new(event_queue)
+    end
+
+    def event_stream
+      ::Uc::Logger.event_stream
     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 
+    def stderr
+      ::Uc::Logger.stderr
+    end
 
+    def event_queue
+      ::Uc::Logger.event_queue
+    end
   end
 end

data/lib/uc/mqueue.rb

@@ -4,7 +4,7 @@ module Uc
  
     attr_reader :name, :max_msg, :msg_size
 
-    def initialize(name, max_msg: 10, msg_size: 100)
+    def initialize(name, max_msg: 15, msg_size: 70)
       @name = name
       @max_msg = max_msg
       @msg_size = msg_size

data/lib/uc/paths.rb

@@ -0,0 +1,109 @@
+require 'pathname'
+require 'uc/logger'
+
+module Uc
+  class Paths
+
+    include ::Uc::Logger  
+
+    attr_reader :app_dir
+
+    def initialize(app_dir)
+      @app_dir = Pathname.new(app_dir )
+    end
+
+    def rack
+      absolute_path "config.ru"
+    end
+
+    def log_dir
+      absolute_path "log"
+    end
+
+    def tmp_dir
+      absolute_path "tmp"
+    end
+
+    def socket_dir
+      absolute_path "tmp/sockets"
+    end
+
+    def pid_dir
+      absolute_path "tmp/pids"
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    def validate_required
+      validate_required_dirs
+      verify_readable rack
+      log_and_raise_errors
+    end
+
+    private
+
+    def log_and_raise_errors
+      if not errors.empty?
+        errors.each { |e| logger.error e }
+        raise ::Uc::Error, "exiting due to missing dirs/files"
+      end
+    end
+
+    def required_dirs
+      [ app_dir, tmp_dir, log_dir, socket_dir, pid_dir ]
+    end
+
+    def validate_required_dirs
+      required_dirs.each do |d|
+        validate_dir(d)
+      end
+    end
+
+    def throw_error(type, path)
+      rel_path = rpath(path)
+      case type
+      when :not_exist
+        msg = "path doesn't exist => #{rel_path}"
+      when :not_writable
+        msg = "path not writable => #{rel_path}"
+      when :not_dir
+        msg = "path not a directory => #{rel_path}"
+      end
+      throw :error, msg
+    end
+
+    def validate_dir(dir)
+      relative_path = rpath(dir)
+      error = catch(:error) do
+        throw_error :not_exist, dir if not File.exist? dir
+        throw_error :not_writable, dir if not File.writable? dir
+        throw_error :not_dir, dir if not File.directory? dir
+      end
+      errors << error if error
+    end
+    
+    def verify_readable(path)
+      relative_path = rpath(path)
+      if not File.readable? path
+        errors << "path not readable => #{relative_path}"
+        return false
+      else
+        return true
+      end
+    end
+  
+    def absolute_path(path)
+      path = Pathname.new(path)
+      raise "absolute path specified: #{path}" if path.absolute?
+      "#{app_dir}/#{path}"
+    end
+
+    def rpath(abs_path)
+      path = Pathname.new abs_path
+      rel_path = path.relative_path_from(app_dir)
+    end
+
+  end
+end