navy 0.0.3 → 1.0.0

data/bin/navy

@@ -24,6 +24,10 @@ op = OptionParser.new("", 24, '  ') do |opts|
     ship_options[:daemonize] = !!d
   end
 
+  opts.on("-c", "--config-file FILE", "Navy-specific config file") do |f|
+    options[:config_file] = f
+  end
+
   opts.separator "Common options:"
 
   opts.on_tail("-h", "--help", "Show this message") do
@@ -40,24 +44,15 @@ op = OptionParser.new("", 24, '  ') do |opts|
 
 end
 
-# unless options[:config_file]
-#   $stderr.puts "ERROR: config file required", ''
-#   puts op.to_s.gsub(/^.*DEPRECATED.*$/s, '')
-#   exit 1
-# end
+unless options[:config_file]
+  $stderr.puts "ERROR: config file required", ''
+  puts op.to_s.gsub(/^.*DEPRECATED.*$/s, '')
+  exit 1
+end
 
 # app = Mule.builder('config', op)
 # op = nil
 
-# if $DEBUG
-#   require 'pp'
-#   pp({
-#     :mule_options => options,
-#     # :app => app,
-#     :daemonize => server_options[:daemonize],
-#   })
-# end
-
 if $DEBUG
   require 'pp'
   pp({

data/examples/navy.conf.rb

@@ -0,0 +1,73 @@
+preload do |admiral|
+  admiral.logger.warn "admiral preload"
+end
+
+before_fork do |admiral, captain|
+  admiral.logger.warn "admiral (#{captain.label}) before_fork"
+  captain.logger.warn "captain=#{captain.label} before_fork"
+end
+
+after_fork do |admiral, captain|
+  admiral.logger.warn "admiral (#{captain.label}) after_fork"
+  captain.logger.warn "captain=#{captain.label} after_fork"
+end
+
+respawn_limit 15, 5
+
+pid "/tmp/navy.pid"
+
+# stderr_path "/tmp/navy-err.log"
+# stdout_path "/tmp/navy-out.log"
+
+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"
+  end
+
+  before_fork do |captain, officer|
+    captain.logger.warn "captain=#{captain.label} before_fork"
+    officer.logger.warn "(#{captain.label}) officer=#{officer.number} before_fork"
+  end
+
+  after_fork do |captain, officer|
+    captain.logger.warn "captain=#{captain.label} after_fork"
+    officer.logger.warn "(#{captain.label}) officer=#{officer.number} after_fork"
+  end
+
+  respawn_limit 15, 5
+
+  officers 2 do |officer|
+    trap(:QUIT) { exit }
+    trap(:TERM) { exit }
+    # raise "HELLO"
+    n = 0
+    loop do
+      Navy.logger.info "#{n} jack called (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 1
+      n += 1
+    end
+  end
+
+end
+
+captain :blackbeard do
+
+  pid "/tmp/navy-blackbeard.pid"
+
+  officers 5 do
+    trap(:QUIT) { exit }; trap(:TERM) { exit }; loop { sleep 1 }
+  end
+  # officers 5 do
+  #   trap(:QUIT, :TRAP) { exit }
+
+  #   nil while true
+  # end
+
+end

data/lib/navy.rb

@@ -22,6 +22,7 @@ module Navy
   end
 end
 require 'navy/util'
+require 'navy/orders'
 require 'navy/rank'
 require 'navy/admiral'
 require 'navy/captain'

data/lib/navy/admiral.rb

@@ -2,6 +2,7 @@ class Navy::Admiral < Navy::Rank
 
   # This hash maps PIDs to Captains
   CAPTAINS = {}
+  RESPAWNS = {}
 
   SELF_PIPE = []
 
@@ -25,60 +26,22 @@ class Navy::Admiral < Navy::Rank
     Dir.pwd
   end
 
-  attr_accessor :admiral_pid
-  attr_reader :captains, :options, :timeout
+  attr_accessor :admiral_pid, :captains, :timeout, :respawn_limit, :respawn_limit_seconds
+  attr_reader :options
 
   def initialize(options = {})
-    @options = options.dup
-    @ready_pipe = @options.delete(:ready_pipe)
-    @timeout = 60
+    @options                = options.dup
+    @options[:use_defaults] = true
+    self.orders             = Navy::Admiral::Orders.new(self.class, @options)
+
     self.reexec_pid = 0
-    self.pid = "/tmp/navy.pid"
-    @captains = {
-      admin: {
-        number: 3,
-        job: ->(*args) {
-          trap(:QUIT) { exit }
-          trap(:TERM) { exit }
-          n = 0
-          loop do
-            # Navy.logger.info "#{n} admin called #{args.inspect}"
-            # 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 10
-            n += 1
-          end
-        }
-      },
-      user: {
-        number: 3,
-        job: ->(*args) {
-          trap(:QUIT) { exit }
-          trap(:TERM) { exit }
-          n = 0
-          loop do
-            # Navy.logger.info "#{n} user called #{args.inspect}"
-            # Navy.logger.info "Navy::Admiral::CAPTAINS: #{Navy::Admiral::CAPTAINS.inspect}"
-            # Navy.logger.info "Navy::Admiral::OFFICERS: #{Navy::Captain::OFFICERS.inspect}"
-            sleep 10
-            n += 1
-          end
-        }
-      }
-    }
-    self.after_fork = ->(admiral, captain) do
-      admiral.logger.info("captain=#{captain.label} spawned pid=#{$$}")
-    end
-    self.before_fork = ->(admiral, captain) do
-      admiral.logger.info("captain=#{captain.label} spawning...")
-    end
-    self.before_exec = ->(admiral) do
-      admiral.logger.info("forked child re-executing...")
-    end
+    @ready_pipe     = @options.delete(:ready_pipe)
+
+    orders.give!(self, except: [ :stderr_path, :stdout_path ])
   end
 
   def start
+    orders.give!(self, only: [ :stderr_path, :stdout_path ])
     init_self_pipe!
     QUEUE_SIGS.each do |sig|
       trap(sig) do
@@ -92,6 +55,7 @@ class Navy::Admiral < Navy::Rank
     logger.info "admiral starting"
 
     self.admiral_pid = $$
+    preload.call(self) if preload
     spawn_missing_captains
     self
   end
@@ -113,7 +77,7 @@ class Navy::Admiral < 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)
-          # sleep_time = murder_lazy_workers
+          sleep_time = murder_lazy_captains
           logger.debug("would normally murder lazy captains") if $DEBUG
         else
           sleep_time = @timeout/2.0 + 1
@@ -206,6 +170,11 @@ class Navy::Admiral < Navy::Rank
     end while true
   end
 
+  # forcibly terminate all workers that haven't checked in in timeout seconds.  The timeout is implemented using an unlinked File
+  def murder_lazy_captains
+    @timeout - 1
+  end
+
   # reexecutes the START_CTX with a new binary
   def reexec
     if reexec_pid > 0
@@ -251,10 +220,28 @@ class Navy::Admiral < Navy::Rank
   def spawn_missing_captains
     captains.each do |label, config|
       CAPTAINS.value?(label) and next
+      respawns = RESPAWNS[label]
+      if respawns
+        first_respawn = respawns.first
+        respawn_count = respawns.size
+        if respawn_count >= respawn_limit
+          if (diff = Time.now - first_respawn) < respawn_limit_seconds
+            logger.error "captain=#{label} respawn error (#{respawn_count} in #{diff} sec, limit #{respawn_limit} in #{respawn_limit_seconds} sec)"
+            @errored_captains ||= {}
+            @errored_captains[label] = captains.delete(label)
+            proc_name "admiral (error)"
+            break
+          else
+            RESPAWNS[label] = []
+          end
+        end
+      end
       captain = Navy::Captain.new(self, label, config)
       before_fork.call(self, captain) if before_fork
       if pid = fork
         CAPTAINS[pid] = captain
+        RESPAWNS[label] ||= []
+        RESPAWNS[label].push(Time.now)
       else
         after_fork.call(self, captain) if after_fork
         captain.start.join
@@ -295,4 +282,5 @@ class Navy::Admiral < Navy::Rank
     SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
   end
 
-end
+end
+require 'navy/admiral/orders'

data/lib/navy/admiral/orders.rb

@@ -0,0 +1,22 @@
+class Navy::Admiral::Orders < Navy::Orders
+
+  defaults.merge!({
+    after_fork: ->(admiral, captain) do
+      admiral.logger.info("captain=#{captain.label} spawned pid=#{$$}")
+    end,
+    before_fork: ->(admiral, captain) do
+      admiral.logger.info("captain=#{captain.label} spawning...")
+    end,
+    before_exec: ->(admiral) do
+      admiral.logger.info("forked child re-executing...")
+    end,
+    captains: {},
+    preload: ->(admiral) do
+      admiral.logger.info("admiral preloading...")
+    end,
+    respawn_limit: 100,
+    respawn_limit_seconds: 1.0
+  })
+
+end
+require 'navy/admiral/speak'

data/lib/navy/admiral/speak.rb

@@ -0,0 +1,12 @@
+class Navy::Admiral::Speak < Navy::Speak
+
+  def before_exec(*args, &block)
+    set_hook(:before_exec, block_given? ? block : args[0], 1)
+  end
+
+  def captain(label, *args, &block)
+    orders.set[:captains] ||= {}
+    orders.set[:captains][label] = block_given? ? block : args[0]
+  end
+
+end

data/lib/navy/captain.rb

@@ -2,6 +2,7 @@ class Navy::Captain < Navy::Rank
 
   # This hash maps PIDs to Officers
   OFFICERS = {}
+  RESPAWNS = {}
 
   SELF_PIPE = []
 
@@ -11,24 +12,19 @@ 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, :number
+  attr_accessor :label, :captain_pid, :timeout, :officer_count, :officer_job, :respawn_limit, :respawn_limit_seconds
   attr_reader :admiral, :options
 
-  def initialize(admiral, label, options = {})
-    @admiral, @options = admiral, options.dup
-    @label = label
-    @number = @options[:number] || 1
-    @timeout = 15
-    # self.pid = "/tmp/navy-#{label}.pid"
-    self.after_fork = ->(captain, officer) do
-      captain.logger.info("(#{captain.label}) officer=#{officer.number} spawned pid=#{$$}")
-    end
-    self.before_fork = ->(captain, officer) do
-      captain.logger.info("(#{captain.label}) officer=#{officer.number} spawning...")
-    end
-    self.before_exec = ->(captain) do
-      captain.logger.info("forked child re-executing...")
-    end
+  def initialize(admiral, label, config, options = {})
+    @options                = options.dup
+    @options[:use_defaults] = true
+    @options[:config_file]  = config
+    self.orders             = Navy::Captain::Orders.new(self.class, @options)
+    @options.merge!(orders.set)
+
+    @admiral, @label = admiral, label
+
+    orders.give!(self, except: [ :stderr_path, :stdout_path ])
   end
 
   def ==(other_label)
@@ -36,6 +32,7 @@ class Navy::Captain < Navy::Rank
   end
 
   def start
+    orders.give!(self, only: [ :stderr_path, :stdout_path ])
     init_self_pipe!
     QUEUE_SIGS.each do |sig|
       trap(sig) do
@@ -49,6 +46,7 @@ class Navy::Captain < Navy::Rank
     logger.info "captain[#{label}] starting"
 
     self.captain_pid = $$
+    preload.call(self) if preload
     spawn_missing_officers
     self
   end
@@ -64,10 +62,11 @@ class Navy::Captain < Navy::Rank
       reap_all_officers
       case SIG_QUEUE.shift
       when nil
+        # logger.info "captain[#{label}] heartbeat"
         # avoid murdering workers after our master process (or the
         # machine) comes out of suspend/hibernation
         if (last_check + @timeout) >= (last_check = Time.now)
-          # sleep_time = murder_lazy_workers
+          sleep_time = murder_lazy_officers
           logger.debug("would normally murder lazy officers") if $DEBUG
         else
           sleep_time = @timeout/2.0 + 1
@@ -96,9 +95,9 @@ class Navy::Captain < Navy::Rank
         # end
       when :TTIN
         respawn = true
-        self.number += 1
+        self.officer_count += 1
       when :TTOU
-        self.number -= 1 if self.number > 0
+        self.officer_count -= 1 if self.officer_count > 0
       when :HUP
         respawn = true
         # if config.config_file
@@ -158,14 +157,36 @@ class Navy::Captain < Navy::Rank
     end while true
   end
 
+  # forcibly terminate all workers that haven't checked in in timeout seconds.  The timeout is implemented using an unlinked File
+  def murder_lazy_officers
+    @timeout - 1
+  end
+
   def spawn_missing_officers
     n = -1
-    until (n += 1) == @number
+    until (n += 1) == @officer_count
       OFFICERS.value?(n) and next
-      officer = Navy::Officer.new(self, n, options[:job])
+      respawns = RESPAWNS[n]
+      if respawns
+        first_respawn = respawns.first
+        respawn_count = respawns.size
+        if respawn_count >= respawn_limit
+          if (diff = Time.now - first_respawn) < respawn_limit_seconds
+            logger.error "(#{label}) officer=#{n} respawn error (#{respawn_count} in #{diff} sec, limit #{respawn_limit} in #{respawn_limit_seconds} sec)"
+            @officer_count -= 1
+            proc_name "captain[#{label}] (error)"
+            break
+          else
+            RESPAWNS[n] = []
+          end
+        end
+      end
+      officer = Navy::Officer.new(self, n, officer_job)
       before_fork.call(self, officer) if before_fork
       if pid = fork
         OFFICERS[pid] = officer
+        RESPAWNS[n] ||= []
+        RESPAWNS[n].push(Time.now)
       else
         after_fork.call(self, officer) if after_fork
         officer.start
@@ -179,10 +200,10 @@ class Navy::Captain < Navy::Rank
   end
 
   def maintain_officer_count
-    (off = OFFICERS.size - @number) == 0 and return
+    (off = OFFICERS.size - @officer_count) == 0 and return
     off < 0 and return spawn_missing_officers
     OFFICERS.dup.each_pair { |opid,o|
-      o.number >= @number and kill_officer(:QUIT, opid) rescue nil
+      o.number >= @officer_count and kill_officer(:QUIT, opid) rescue nil
     }
   end
 
@@ -206,4 +227,5 @@ class Navy::Captain < Navy::Rank
     SELF_PIPE.each { |io| io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) }
   end
 
-end
+end
+require 'navy/captain/orders'

data/lib/navy/captain/orders.rb

@@ -0,0 +1,21 @@
+class Navy::Captain::Orders < Navy::Orders
+
+  defaults.merge!({
+    after_fork: ->(captain, officer) do
+      captain.logger.info("(#{captain.label}) officer=#{officer.number} spawned pid=#{$$}")
+    end,
+    before_fork: ->(captain, officer) do
+      captain.logger.info("(#{captain.label}) officer=#{officer.number} spawning...")
+    end,
+    officer_job: -> { trap(:QUIT) { exit }; trap(:TERM) { exit }; loop { sleep 1 } },
+    officer_count: 0,
+    preload: ->(captain) do
+      captain.logger.info("captain=#{captain.label} preloading...")
+    end,
+    respawn_limit: 100,
+    respawn_limit_seconds: 1.0,
+    timeout: 30
+  })
+
+end
+require 'navy/captain/speak'

data/lib/navy/captain/speak.rb

@@ -0,0 +1,8 @@
+class Navy::Captain::Speak < Navy::Speak
+
+  def officers(officer_count = 1, *args, &block)
+    orders.set[:officer_count] = officer_count
+    orders.set[:officer_job]   = block_given? ? block : args[0]
+  end
+
+end

data/lib/navy/officer.rb

@@ -1,18 +1,22 @@
 class Navy::Officer < Navy::Rank
-  attr_accessor :number
+  attr_accessor :number, :officer_pid
   attr_reader :captain, :job
   def initialize(captain, number, job)
     @captain, @number, @job = captain, number, job
-    # self.pid = "/tmp/navy-#{captain.label}-#{number}.pid"
   end
 
   def ==(other_number)
     @number == other_number
   end
 
+  def logger
+    captain.logger
+  end
+
   def start
+    self.officer_pid = $$
     proc_name "(#{captain.label}) officer[#{number}]"
-    job.call
+    (job.respond_to?(:arity) && job.arity == 0) ? job.call : job.call(self)
   rescue => e
     logger.error(e) rescue nil
     exit!

data/lib/navy/orders.rb

@@ -0,0 +1,97 @@
+class Navy::Orders
+
+  ## class_attribute :defaults ##
+  def self.defaults;  nil;        end
+  def self.defaults?; !!defaults; end
+  def self.defaults=(val)
+    singleton_class.class_eval do
+      begin
+        if method_defined?(:defaults) || private_method_defined?(:defaults)
+          remove_method(:defaults)
+        end
+      rescue NameError
+        # ignore this
+      end
+      define_method(:defaults) { val }
+    end
+
+    val
+  end
+  def defaults
+    defined?(@defaults) ? @defaults : self.class.defaults
+  end
+  def defaults?
+    !!defaults
+  end
+  attr_writer :defaults
+
+  self.defaults = {
+    timeout: 60,
+    logger:  Navy.logger,
+    pid:     nil
+  }
+
+  def self.inherited(base)
+    base.defaults = self.defaults.dup
+  end
+
+  attr_reader :rank_class
+  attr_accessor :config_file, :set
+
+  def initialize(rank_class, options = {})
+    @rank_class = rank_class
+    self.set = Hash.new(:unset)
+    self.config_file = options.delete(:config_file)
+    @use_defaults = options.delete(:use_defaults)
+
+    set.merge!(defaults) if @use_defaults
+    options.each { |key, value| salor_mouth.__send__(key, value) }
+
+    reload(false)
+  end
+
+  def reload(merge_defaults = true) #:nodoc:
+    if merge_defaults && @use_defaults
+      set.merge!(defaults) if @use_defaults
+    end
+    sailor_mouth.curse!(config_file) if config_file
+    # instance_eval(File.read(config_file), config_file) if config_file
+
+    # parse_rackup_file
+
+    # RACKUP[:set_listener] and
+    #   set[:listeners] << "#{RACKUP[:host]}:#{RACKUP[:port]}"
+
+    # # unicorn_rails creates dirs here after working_directory is bound
+    # after_reload.call if after_reload
+
+    # # working_directory binds immediately (easier error checking that way),
+    # # now ensure any paths we changed are correctly set.
+    # [ :pid, :stderr_path, :stdout_path ].each do |var|
+    #   String === (path = set[var]) or next
+    #   path = File.expand_path(path)
+    #   File.writable?(path) || File.writable?(File.dirname(path)) or \
+    #         raise ArgumentError, "directory for #{var}=#{path} not writable"
+    # end
+  end
+
+  def give!(rank, options = {})
+    only   = options[:only]   || []
+    except = options[:except] || (only.empty? ? [] : set.keys - only)
+    set.each do |key, value|
+      value == :unset and next
+      except.include?(key) and next
+      rank.__send__("#{key}=", value)
+    end
+  end
+
+  def sailor_mouth
+    @sailor_mouth ||= rank_class::Speak.new(self)
+  end
+
+  def [](key) # :nodoc:
+    set[key]
+  end
+
+end
+require 'navy/speak'

data/lib/navy/rank.rb

@@ -1,12 +1,16 @@
 class Navy::Rank
 
+  attr_accessor :orders
+
   attr_accessor :before_fork, :after_fork, :before_exec
   attr_accessor :reexec_pid
-  attr_reader :pid
 
   def logger
-    Navy.logger
+    @logger ||= orders[:logger]
   end
+  attr_writer :logger
+
+  attr_reader :options
 
   # sets the path for the PID file of the master process
   def pid=(path)
@@ -37,6 +41,14 @@ class Navy::Rank
     end
     @pid = path
   end
+  attr_reader :pid
+
+  attr_accessor :preload
+
+  def stdout_path=(path); redirect_io($stdout, path); end
+  def stderr_path=(path); redirect_io($stderr, path); end
+
+  attr_accessor :timeout
 
   private
 

data/lib/navy/speak.rb

@@ -0,0 +1,126 @@
+# cover your ears...
+class Navy::Speak
+
+  attr_reader :orders
+
+  def initialize(orders)
+    @orders = orders
+  end
+
+  def curse!(file)
+    String === file and return instance_eval(File.read(file), file)
+    instance_eval(&file)
+  end
+
+  ## sailor mouth ##
+
+  def after_fork(*args, &block)
+    set_hook(:after_fork, block_given? ? block : args[0])
+  end
+
+  def before_fork(*args, &block)
+    set_hook(:before_fork, block_given? ? block : args[0])
+  end
+
+  def logger(obj)
+    %w(debug info warn error fatal).each do |m|
+      obj.respond_to?(m) and next
+      raise ArgumentError, "logger=#{obj} does not respond to method=#{m}"
+    end
+
+    orders.set[:logger] = obj
+  end
+
+  def pid(path); set_path(:pid, path); end
+
+  def preload(*args, &block)
+    set_hook(:preload, block_given? ? block : args[0], 1)
+  end
+
+  def respawn_limit(respawns, seconds = 1.0)
+    set_int(:respawn_limit, respawns, 1)
+    orders.set[:respawn_limit_seconds] = seconds
+  end
+
+  def stderr_path(path)
+    set_path(:stderr_path, path)
+  end
+
+  def stdout_path(path)
+    set_path(:stdout_path, path)
+  end
+
+  def timeout(seconds)
+    set_int(:timeout, seconds, 3)
+    # POSIX says 31 days is the smallest allowed maximum timeout for select()
+    max = 30 * 60 * 60 * 24
+    orders.set[:timeout] = seconds > max ? max : seconds
+  end
+
+  def user(user, group = nil)
+    # raises ArgumentError on invalid user/group
+    Etc.getpwnam(user)
+    Etc.getgrnam(group) if group
+    set[:user] = [ user, group ]
+  end
+
+  def working_directory(path)
+    # just let chdir raise errors
+    path = File.expand_path(path)
+    if config_file &&
+       config_file[0] != ?/ &&
+       ! File.readable?("#{path}/#{config_file}")
+      raise ArgumentError,
+            "config_file=#{config_file} would not be accessible in" \
+            " working_directory=#{path}"
+    end
+    Dir.chdir(path)
+    Navy::Admiral::START_CTX[:cwd] = ENV["PWD"] = path
+  end
+
+  private
+
+  def set_int(var, n, min) #:nodoc:
+    Integer === n or raise ArgumentError, "not an integer: #{var}=#{n.inspect}"
+    n >= min or raise ArgumentError, "too low (< #{min}): #{var}=#{n.inspect}"
+    orders.set[var] = n
+  end
+
+  def set_path(var, path) #:nodoc:
+    case path
+    when NilClass, String
+      orders.set[var] = path
+    else
+      raise ArgumentError
+    end
+  end
+
+  def check_bool(var, bool) # :nodoc:
+    case bool
+    when true, false
+      return bool
+    end
+    raise ArgumentError, "#{var}=#{bool.inspect} not a boolean"
+  end
+
+  def set_bool(var, bool) #:nodoc:
+    orders.set[var] = check_bool(var, bool)
+  end
+
+  def set_hook(var, my_proc, req_arity = 2) #:nodoc:
+    case my_proc
+    when Proc
+      arity = my_proc.arity
+      (arity == req_arity) or \
+        raise ArgumentError,
+              "#{var}=#{my_proc.inspect} has invalid arity: " \
+              "#{arity} (need #{req_arity})"
+    when NilClass
+      my_proc = orders.defaults[var]
+    else
+      raise ArgumentError, "invalid type: #{var}=#{my_proc.inspect}"
+    end
+    orders.set[var] = my_proc
+  end
+
+end

data/lib/navy/version.rb

@@ -1,3 +1,3 @@
 module Navy
-  VERSION = "0.0.3"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: navy
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-04 00:00:00.000000000 Z
+date: 2012-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &70181829400440 !ruby/object:Gem::Requirement
+  requirement: &70259513239380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70181829400440
+  version_requirements: *70259513239380
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70181829399700 !ruby/object:Gem::Requirement
+  requirement: &70259513238660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70181829399700
+  version_requirements: *70259513238660
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70181829398740 !ruby/object:Gem::Requirement
+  requirement: &70259513237620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *70181829398740
+  version_requirements: *70259513237620
 - !ruby/object:Gem::Dependency
   name: kgio
-  requirement: &70181829398120 !ruby/object:Gem::Requirement
+  requirement: &70259513236820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,7 +54,7 @@ dependencies:
         version: '2.6'
   type: :runtime
   prerelease: false
-  version_requirements: *70181829398120
+  version_requirements: *70259513236820
 description: Ruby daemon inspired by Unicorn.
 email:
 - potatosaladx@gmail.com
@@ -69,12 +69,19 @@ files:
 - README.md
 - Rakefile
 - bin/navy
+- examples/navy.conf.rb
 - lib/navy.rb
 - lib/navy/admiral.rb
+- lib/navy/admiral/orders.rb
+- lib/navy/admiral/speak.rb
 - lib/navy/captain.rb
+- lib/navy/captain/orders.rb
+- lib/navy/captain/speak.rb
 - lib/navy/officer.rb
+- lib/navy/orders.rb
 - lib/navy/rank.rb
 - lib/navy/ship.rb
+- lib/navy/speak.rb
 - lib/navy/util.rb
 - lib/navy/version.rb
 - navy.gemspec