navy 1.0.7 → 1.1.0

data/examples/navy.conf.rb

@@ -56,229 +56,275 @@ pid "/tmp/navy.pid"
 
 # end
 
-module Jack
+# module Jack
 
-  SELF_PIPE = []
+#   SELF_PIPE = []
 
-  extend self
+#   extend self
 
-  def call(officer)
-    trap(:QUIT) { exit }
-    trap(:TERM) { exit }
+#   def call(officer)
+#     trap(:QUIT) { sleep 120; exit }
+#     trap(:TERM) { exit }
 
-    # raise "HELLO"
-    n = 0
-    loop do
-      puts "#{n} jack called (officer=#{officer.number}) pid: #{officer.officer_pid}"
-      # Jack.logger.info "#{n} jack logger (officer=#{officer.number}) pid: #{officer.officer_pid}"
-      # Navy.logger.info "START_CTX: #{START_CTX.inspect}"
-      # Navy.logger.info "Navy::Admiral::CAPTAINS: #{Navy::Admiral::CAPTAINS.inspect}"
-      # Navy.logger.info "Navy::Admiral::OFFICERS: #{Navy::Captain::OFFICERS.inspect}"
-      sleep officer.number == 0 ? 0.5 : 1
-      n += 1
-    end
-  end
+#     # raise "HELLO"
+#     n = 0
+#     loop do
+#       Navy.logger.info "#{n} jack called (officer=#{officer.number}) pid: #{officer.officer_pid}"
+#       # Jack.logger.info "#{n} jack logger (officer=#{officer.number}) pid: #{officer.officer_pid}"
+#       # Navy.logger.info "START_CTX: #{START_CTX.inspect}"
+#       # Navy.logger.info "Navy::Admiral::CAPTAINS: #{Navy::Admiral::CAPTAINS.inspect}"
+#       # Navy.logger.info "Navy::Admiral::OFFICERS: #{Navy::Captain::OFFICERS.inspect}"
+#       sleep officer.number == 0 ? 0.5 : 1
+#       n += 1
+#     end
+#   end
 
-  def logger
-    @logger ||= Logger.new('/tmp/jack.log')
-  end
+#   def logger
+#     @logger ||= Logger.new('/tmp/jack.log')
+#   end
 
-  def logger=(val)
-    @logger = val
-  end
+#   def logger=(val)
+#     @logger = val
+#   end
 
-  def readers
-    @readers ||= {}
-  end
+#   def readers
+#     @readers ||= {}
+#   end
 
-  def reader=(val)
-    @reader = val
-  end
+#   def reader=(val)
+#     @reader = val
+#   end
 
-  def writer=(val)
-    @writer = val
-  end
+#   def writer=(val)
+#     @writer = val
+#   end
 
-  def reader
-    @reader
-  end
+#   def reader
+#     @reader
+#   end
 
-  def writer
-    @writer
-  end
+#   def writer
+#     @writer
+#   end
 
-  def main_reader=(val)
-    @main_reader = val
-  end
+#   def main_reader=(val)
+#     @main_reader = val
+#   end
 
-  def main_writer=(val)
-    @main_writer = val
-  end
+#   def main_writer=(val)
+#     @main_writer = val
+#   end
 
-  def main_reader
-    @main_reader
-  end
+#   def main_reader
+#     @main_reader
+#   end
 
-  def main_writer
-    @main_writer
-  end
+#   def main_writer
+#     @main_writer
+#   end
 
-  def threads
-    @threads ||= {}
-  end
+#   def threads
+#     @threads ||= {}
+#   end
 
-  def start
-    @thread ||= Thread.new do
-      loop do
-        IO.select([ SELF_PIPE[0] ], nil, nil, 0.1) or next
-        data = SELF_PIPE[0].gets
-        next unless data
-        data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
-        pid, message = data.split(',', 2)
-        Jack.logger.info "YOUR PID WAS: #{pid}; #{message.strip}"
-        # Jack.logger.info data
-      end
-    end
-  end
+#   def start
+#     @thread ||= Thread.new do
+#       loop do
+#         IO.select([ SELF_PIPE[0] ], nil, nil, 0.1) or next
+#         data = SELF_PIPE[0].gets
+#         next unless data
+#         data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
+#         pid, message = data.split(',', 2)
+#         Jack.logger.info "YOUR PID WAS: #{pid}; #{message.strip}"
+#         # Jack.logger.info data
+#       end
+#     end
+#   end
 
-  def stop
-    if @thread
-      @thread.terminate rescue nil
-    end
-    SELF_PIPE.each { |io| io.close rescue nil }
-  end
+#   def stop
+#     if @thread
+#       @thread.terminate rescue nil
+#     end
+#     SELF_PIPE.each { |io| io.close rescue nil }
+#   end
 
-  # def main_thread(captain = nil)
-  #   @main_thread = nil if @main_thread and @main_thread.stop?
-  #   if @main_thread.nil?
-  #     # Jack.main_reader.close rescue nil
-  #     # Jack.main_writer.close rescue nil
-  #     Jack.main_reader, Jack.main_writer = IO.pipe
-  #     Jack.main_reader.sync = true
-  #     Jack.main_writer.sync = true
-  #   end
-  #   @main_thread ||= Thread.new do
-  #     readers = [Jack.main_reader]
-  #     loop do
-  #       rs, ws = IO.select(readers, [], [], 1)
-  #       (rs || []).each do |r|
-  #         data = r.gets
-  #         next unless data
-  #         data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
-  #         ps, message = data.split(",", 2)
-  #         Jack.logger.info "pid: #{ps}, message: #{message.to_s.strip}"
-  #       end
-  #     end
-  #   end
-  # end
-end
+#   # def main_thread(captain = nil)
+#   #   @main_thread = nil if @main_thread and @main_thread.stop?
+#   #   if @main_thread.nil?
+#   #     # Jack.main_reader.close rescue nil
+#   #     # Jack.main_writer.close rescue nil
+#   #     Jack.main_reader, Jack.main_writer = IO.pipe
+#   #     Jack.main_reader.sync = true
+#   #     Jack.main_writer.sync = true
+#   #   end
+#   #   @main_thread ||= Thread.new do
+#   #     readers = [Jack.main_reader]
+#   #     loop do
+#   #       rs, ws = IO.select(readers, [], [], 1)
+#   #       (rs || []).each do |r|
+#   #         data = r.gets
+#   #         next unless data
+#   #         data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
+#   #         ps, message = data.split(",", 2)
+#   #         Jack.logger.info "pid: #{ps}, message: #{message.to_s.strip}"
+#   #       end
+#   #     end
+#   #   end
+#   # end
+# end
 
 captain :jack do
 
-  stderr_path "/tmp/navy-jack-err.log"
-  # stdout_path "/tmp/navy-jack-out.log"
-
-  preload do |captain|
-    captain.logger.warn "captain=#{captain.label} preload"
-    Jack::SELF_PIPE.each { |io| io.close rescue nil }
-    # Jack::SELF_PIPE.replace(Kgio::Pipe.new)
-    Jack::SELF_PIPE.replace(IO.pipe)
-    Jack::SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC); io.sync = true }
-    Jack.logger.info "preload"
-    Jack.start
-  end
+  # stderr_path "/tmp/navy-jack-err.log"
+  # # stdout_path "/tmp/navy-jack-out.log"
+
+  # preload do |captain|
+  #   captain.logger.warn "captain=#{captain.label} preload"
+  #   Jack::SELF_PIPE.each { |io| io.close rescue nil }
+  #   # Jack::SELF_PIPE.replace(Kgio::Pipe.new)
+  #   Jack::SELF_PIPE.replace(IO.pipe)
+  #   Jack::SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC); io.sync = true }
+  #   Jack.logger.info "preload"
+  #   Jack.start
+  # end
 
-  before_fork do |captain, officer|
-    # Jack.main_thread(captain)
-    captain.logger.warn "captain=#{captain.label} before_fork"
-    officer.logger.warn "(#{captain.label}) officer=#{officer.number} before_fork"
-    # if r = Jack.readers.delete(officer.number)
-    #   r.close
-    # end
-    # Jack.readers[officer.number], Jack.writer = IO.pipe
-    # Jack.reader = Jack.readers[officer.number]
-    # Jack.reader.sync = true
-  end
+  # before_fork do |captain, officer|
+  #   # Jack.main_thread(captain)
+  #   captain.logger.warn "captain=#{captain.label} before_fork"
+  #   officer.logger.warn "(#{captain.label}) officer=#{officer.number} before_fork"
+  #   # if r = Jack.readers.delete(officer.number)
+  #   #   r.close
+  #   # end
+  #   # Jack.readers[officer.number], Jack.writer = IO.pipe
+  #   # Jack.reader = Jack.readers[officer.number]
+  #   # Jack.reader.sync = true
+  # end
 
-  after_fork do |captain, officer|
-    # Jack.reader.close # we don't read
-    # Jack.writer.sync = true
-    captain.logger.warn "captain=#{captain.label} after_fork"
-    officer.logger.warn "(#{captain.label}) officer=#{officer.number} after_fork"
-    # $stdout.reopen Jack.writer
-    # $stderr.reopen Jack.writer
-
-    reader, writer = IO.pipe
-    $stdout.reopen writer
-    $stdout.reopen writer
-
-    Thread.new do
-      until reader.eof?
-        Jack::SELF_PIPE[1].puts "%s,%s" % [ officer.officer_pid, reader.gets ]
-      end
-    end
-  end
+  # after_fork do |captain, officer|
+  #   # Jack.reader.close # we don't read
+  #   # Jack.writer.sync = true
+  #   captain.logger.warn "captain=#{captain.label} after_fork"
+  #   officer.logger.warn "(#{captain.label}) officer=#{officer.number} after_fork"
+  #   # $stdout.reopen Jack.writer
+  #   # $stderr.reopen Jack.writer
+
+  #   reader, writer = IO.pipe
+  #   $stdout.reopen writer
+  #   $stdout.reopen writer
+
+  #   Thread.new do
+  #     until reader.eof?
+  #       Jack::SELF_PIPE[1].puts "%s,%s" % [ officer.officer_pid, reader.gets ]
+  #     end
+  #   end
+  # end
 
-  after_stop do |captain, graceful|
-    Jack.stop if graceful
-  end
+  # after_stop do |captain, graceful|
+  #   Jack.stop if graceful
+  # end
 
-  post_fork do |captain, officer|
-    # Jack.writer.close # we don't write
-    # if t = Jack.threads[officer.number]
-    #   t.terminate unless t.stop?
-    # else
-    #   Jack.threads[officer.number] = Thread.new do
-    #     reader = Jack.reader
-    #     until reader.eof?
-    #       Jack::SELF_PIPE[1].puts "%s,%s" % [ officer.officer_pid, reader.gets ]
-    #     end
-    #   end
-    # end
-    # Jack.reader.lcose
-    # Thread.new do
-    #   # Jack.main_reader.close
-    #   # Jack.main_writer.close
-    #   loop do
-    #     rs, ws = IO.select([Jack.reader], [], [], 1)
-    #     (rs || []).each do |r|
-    #       data = r.gets
-    #       next unless data
-    #       data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
-    #       # ps, message = data.split(",", 2)
-    #       # color = colors[ps.split(".").first]
-    #       # info message, ps, color
-    #       # Jack.mutex.synchronize do
-    #       # Jack.logger.info "pid: #{ps}, message: #{message}"
-    #       # Jack.logger.info data.strip
-    #       # end
-    #       Jack.main_writer.puts "pidpidpid: #{officer.officer_pid}, message: #{data}"
-    #     end
-    #   end
-    # end
-    # Thread.new do
-    #   reader, writer = Jack.reader, Jack.writer
-    #   loop do
-    #     rs, ws = IO.select([reader], [], [], 1)
-    #     (rs || []).each do |r|
-    #       data = r.gets
-    #       next unless data
-    #       data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
-    #       # ps, message = data.split(",", 2)
-    #       # color = colors[ps.split(".").first]
-    #       # info message, ps, color
-    #       # Jack.mutex.synchronize do
-    #       # Jack.logger.info "pid: #{ps}, message: #{message}"
-    #       writer.write "%s,%s" [ '13', data ]
-    #       # end
-    #     end
-    #   end
-    # end
-  end
+  # post_fork do |captain, officer|
+  #   # Jack.writer.close # we don't write
+  #   # if t = Jack.threads[officer.number]
+  #   #   t.terminate unless t.stop?
+  #   # else
+  #   #   Jack.threads[officer.number] = Thread.new do
+  #   #     reader = Jack.reader
+  #   #     until reader.eof?
+  #   #       Jack::SELF_PIPE[1].puts "%s,%s" % [ officer.officer_pid, reader.gets ]
+  #   #     end
+  #   #   end
+  #   # end
+  #   # Jack.reader.lcose
+  #   # Thread.new do
+  #   #   # Jack.main_reader.close
+  #   #   # Jack.main_writer.close
+  #   #   loop do
+  #   #     rs, ws = IO.select([Jack.reader], [], [], 1)
+  #   #     (rs || []).each do |r|
+  #   #       data = r.gets
+  #   #       next unless data
+  #   #       data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
+  #   #       # ps, message = data.split(",", 2)
+  #   #       # color = colors[ps.split(".").first]
+  #   #       # info message, ps, color
+  #   #       # Jack.mutex.synchronize do
+  #   #       # Jack.logger.info "pid: #{ps}, message: #{message}"
+  #   #       # Jack.logger.info data.strip
+  #   #       # end
+  #   #       Jack.main_writer.puts "pidpidpid: #{officer.officer_pid}, message: #{data}"
+  #   #     end
+  #   #   end
+  #   # end
+  #   # Thread.new do
+  #   #   reader, writer = Jack.reader, Jack.writer
+  #   #   loop do
+  #   #     rs, ws = IO.select([reader], [], [], 1)
+  #   #     (rs || []).each do |r|
+  #   #       data = r.gets
+  #   #       next unless data
+  #   #       data.force_encoding("BINARY") if data.respond_to?(:force_encoding)
+  #   #       # ps, message = data.split(",", 2)
+  #   #       # color = colors[ps.split(".").first]
+  #   #       # info message, ps, color
+  #   #       # Jack.mutex.synchronize do
+  #   #       # Jack.logger.info "pid: #{ps}, message: #{message}"
+  #   #       writer.write "%s,%s" [ '13', data ]
+  #   #       # end
+  #   #     end
+  #   #   end
+  #   # end
+  # end
+
+  # preload do |captain|
+  #   require 'fileutils'
+  #   require 'rainbow'
+  #   Sickill::Rainbow.enabled = true
+  # end
 
   respawn_limit 15, 5
 
-  officers 4, Jack
+  patience 5
+
+  # heartbeat do |captain|
+  #   captain.logger.info "captain=#{captain.label} heartbeat".color(:red)
+  #   captain.class::OFFICERS.each do |officer_pid, officer|
+  #     # begin
+  #       name = "/tmp/ps#{officer_pid}"
+  #       system("ps -o rss= -p #{officer_pid} > #{name}")
+  #       mem_usage = (::File.read(name) rescue 0).to_s.strip.to_i
+  #       ::FileUtils.rm_f(name)
+
+  #       if mem_usage > 2000
+  #         captain.send(:kill_officer, :TERM, officer_pid)
+  #         captain.logger.info "captain=#{captain.label} officer=#{officer.number} over memory limit, sending TERM (pid: #{officer_pid}, mem: #{mem_usage} KB)".color(:yellow)
+  #       else
+
+  #       # mem_usage = `ps -o rss= -p #{officer_pid}`.to_s.strip
+  #       # mem_usage = 20
+  #       captain.logger.info "captain=#{captain.label} checking officer=#{officer.number} (pid: #{officer_pid}, mem: #{mem_usage} KB)".color(:green)
+  #     # rescue => e
+  #       # captain.logger.error "captain=#{captain.label} checking officer=#{officer.number} (pid: #{pid}) error: #{e.inspect}".color(:red)
+  #     end
+  #   end
+  # end
+
+  officers 4 do |officer|
+    trap(:QUIT) { sleep 120; exit }
+    trap(:TERM) { exit }
+
+    # raise "HELLO"
+    n = 0
+    loop do
+      Navy.logger.info "#{n} jack called (officer=#{officer.number}) pid: #{officer.officer_pid}"
+      # Jack.logger.info "#{n} jack logger (officer=#{officer.number}) pid: #{officer.officer_pid}"
+      # Navy.logger.info "START_CTX: #{START_CTX.inspect}"
+      # Navy.logger.info "Navy::Admiral::CAPTAINS: #{Navy::Admiral::CAPTAINS.inspect}"
+      # Navy.logger.info "Navy::Admiral::OFFICERS: #{Navy::Captain::OFFICERS.inspect}"
+      sleep officer.number == 0 ? 0.5 : 1
+      n += 1
+    end
+  end
   # officers 2 do |officer|
   #   trap(:QUIT) { exit }
   #   trap(:TERM) { exit }

data/lib/navy/admiral.rb

@@ -26,8 +26,11 @@ class Navy::Admiral < Navy::Rank
     Dir.pwd
   end
 
-  attr_accessor :admiral_pid, :captains, :timeout, :respawn_limit, :respawn_limit_seconds
-  attr_reader :options
+  ## callbacks ##
+  attr_accessor :before_exec
+
+  attr_accessor :admiral_pid, :captains
+  attr_reader   :options
 
   def initialize(options = {})
     self.orig_stderr = $stderr.dup
@@ -78,6 +81,7 @@ class Navy::Admiral < Navy::Rank
       when nil
         # avoid murdering workers after our master process (or the
         # machine) comes out of suspend/hibernation
+        heartbeat.call(self) if heartbeat
         if (last_check + @timeout) >= (last_check = Time.now)
           sleep_time = murder_lazy_captains
           logger.debug("would normally murder lazy captains") if $DEBUG
@@ -132,12 +136,15 @@ class Navy::Admiral < Navy::Rank
   # Terminates all captains, but does not exit admiral process
   def stop(graceful = true)
     before_stop.call(self, graceful) if before_stop
-    limit = Time.now + timeout
-    until CAPTAINS.empty? || Time.now > limit
+    limit = Time.now + patience
+    until CAPTAINS.empty? || (n = Time.now) > limit
       kill_each_captain(graceful ? :QUIT : :TERM)
       sleep(0.1)
       reap_all_captains
     end
+    if n and n > limit
+      logger.debug "admiral patience exceeded by #{n - limit} seconds (limit #{patience} seconds)" if $DEBUG
+    end
     kill_each_captain(:KILL)
     after_stop.call(self, graceful) if after_stop
   end

data/lib/navy/admiral/orders.rb

@@ -17,6 +17,9 @@ class Navy::Admiral::Orders < Navy::Orders
       admiral.logger.debug("admiral before (#{graceful ? 'graceful' : 'hard'}) stop") if $DEBUG
     end,
     captains: {},
+    heartbeat: ->(admiral) do
+      admiral.logger.debug("admiral heartbeat") if $DEBUG
+    end,
     post_fork: ->(admiral, captain) do
       admiral.logger.debug("captain=#{captain.label} post-fork") if $DEBUG
     end,

data/lib/navy/captain.rb

@@ -12,8 +12,8 @@ class Navy::Captain < Navy::Rank
   # list of signals we care about and trap in admiral.
   QUEUE_SIGS = [ :WINCH, :QUIT, :INT, :TERM, :USR1, :USR2, :HUP, :TTIN, :TTOU ]
 
-  attr_accessor :label, :captain_pid, :timeout, :officer_count, :officer_job, :respawn_limit, :respawn_limit_seconds
-  attr_reader :admiral, :options
+  attr_accessor :label, :captain_pid, :officer_count, :officer_job
+  attr_reader   :admiral, :options
 
   def initialize(admiral, label, config, options = {})
     self.orig_stderr = $stderr.dup
@@ -70,6 +70,7 @@ class Navy::Captain < Navy::Rank
         # avoid murdering workers after our master process (or the
         # machine) comes out of suspend/hibernation
         if (last_check + @timeout) >= (last_check = Time.now)
+          heartbeat.call(self) if heartbeat
           sleep_time = murder_lazy_officers
           logger.debug("would normally murder lazy officers") if $DEBUG
         else
@@ -121,12 +122,15 @@ class Navy::Captain < Navy::Rank
   # Terminates all captains, but does not exit admiral process
   def stop(graceful = true)
     before_stop.call(self, graceful) if before_stop
-    limit = Time.now + timeout
-    until OFFICERS.empty? || Time.now > limit
+    limit = Time.now + patience
+    until OFFICERS.empty? || (n = Time.now) > limit
       kill_each_officer(graceful ? :QUIT : :TERM)
       sleep(0.1)
       reap_all_officers
     end
+    if n and n > limit
+      logger.debug "captain=#{label} patience exceeded by #{n - limit} seconds (limit #{patience} seconds)" if $DEBUG
+    end
     kill_each_officer(:KILL)
     after_stop.call(self, graceful) if after_stop
   end

data/lib/navy/captain/orders.rb

@@ -13,8 +13,12 @@ class Navy::Captain::Orders < Navy::Orders
     before_stop: ->(captain, graceful) do
       captain.logger.debug("captain=#{captain.label} before (#{graceful ? 'graceful' : 'hard'}) stop") if $DEBUG
     end,
+    heartbeat: ->(captain) do
+      captain.logger.debug("captain=#{captain.label} heartbeat") if $DEBUG
+    end,
     officer_job: -> { trap(:QUIT) { exit }; trap(:TERM) { exit }; loop { sleep 1 } },
     officer_count: 0,
+    patience: 30,
     post_fork: ->(captain, officer) do
       captain.logger.debug("(#{captain.label}) officer=#{officer.number} post-fork") if $DEBUG
     end,

data/lib/navy/orders.rb

@@ -26,9 +26,10 @@ class Navy::Orders
   attr_writer :defaults
 
   self.defaults = {
-    timeout: 60,
-    logger:  Navy.logger,
-    pid:     nil
+    logger:   Navy.logger,
+    patience: 60,
+    pid:      nil,
+    timeout:  60
   }
 
   def self.inherited(base)

data/lib/navy/rank.rb

@@ -1,10 +1,28 @@
 class Navy::Rank
 
+  # orders are configuration settings
   attr_accessor :orders
 
-  attr_accessor :before_fork, :after_fork, :before_exec, :post_fork, :before_stop, :after_stop
+  ## callbacks ##
+  attr_accessor :before_fork,
+                :before_stop,
+                :after_fork,
+                :after_stop,
+                :heartbeat,
+                :post_fork
+
+  ## reexec ##
+  attr_accessor :reexec_pid
+
+  ## respawn ##
+  attr_accessor :respawn_limit, :respawn_limit_seconds
+
+  ## stderr/stdout ##
   attr_reader   :stdout_path, :stderr_path
-  attr_accessor :reexec_pid, :orig_stdout, :orig_stderr, :current_stdout, :current_stderr
+  attr_accessor :orig_stdout, :orig_stderr, :current_stdout, :current_stderr
+
+  ## timeouts ##
+  attr_accessor :patience, :timeout
 
   def logger
     (@logger ||= orders[:logger]).tap do |log|
@@ -57,8 +75,6 @@ class Navy::Rank
     redirect_io($stderr, path)
   end
 
-  attr_accessor :timeout
-
   private
 
   # unlinks a PID file at given +path+ if it contains the current PID

data/lib/navy/speak.rb

@@ -30,6 +30,10 @@ class Navy::Speak
     set_hook(:before_stop, block_given? ? block : args[0])
   end
 
+  def heartbeat(*args, &block)
+    set_hook(:heartbeat, block_given? ? block : args[0], 1)
+  end
+
   def logger(obj)
     %w(debug info warn error fatal).each do |m|
       obj.respond_to?(m) and next
@@ -39,6 +43,13 @@ class Navy::Speak
     orders.set[:logger] = obj
   end
 
+  def patience(seconds)
+    set_int(:patience, seconds, 3)
+    # POSIX says 31 days is the smallest allowed maximum timeout for select()
+    max = 30 * 60 * 60 * 24
+    orders.set[:patience] = seconds > max ? max : seconds
+  end
+
   def pid(path); set_path(:pid, path); end
 
   def post_fork(*args, &block)

data/lib/navy/version.rb

@@ -1,3 +1,3 @@
 module Navy
-  VERSION = "1.0.7"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: navy
 version: !ruby/object:Gem::Version
-  version: 1.0.7
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-06 00:00:00.000000000 Z
+date: 2012-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &70187979402440 !ruby/object:Gem::Requirement
+  requirement: &70241876400920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70187979402440
+  version_requirements: *70241876400920
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70187979401840 !ruby/object:Gem::Requirement
+  requirement: &70241876399140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70187979401840
+  version_requirements: *70241876399140
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70187979401100 !ruby/object:Gem::Requirement
+  requirement: &70241876397680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *70187979401100
+  version_requirements: *70241876397680
 - !ruby/object:Gem::Dependency
   name: kgio
-  requirement: &70187979400340 !ruby/object:Gem::Requirement
+  requirement: &70241876396780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,7 +54,7 @@ dependencies:
         version: '2.6'
   type: :runtime
   prerelease: false
-  version_requirements: *70187979400340
+  version_requirements: *70241876396780
 description: Ruby daemon inspired by Unicorn.
 email:
 - potatosaladx@gmail.com