procodile 1.0.10 → 1.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc9014711e488092ae55249f9fcda8dbb2fb9cc1
-  data.tar.gz: 9181ab265781b1b39a20524705eab6b6c31117e9
+  metadata.gz: 90d57673d57a817411b10a60ebbaa04b8222f644
+  data.tar.gz: a928bbe14abe7ad22dee7e98763ef42d12abffb3
 SHA512:
-  metadata.gz: 4b12e1eb9fb33548ea5b01d757a73cf377a024cc6e5a0877168fe1240e359c29f569a9b7fcc888c1d8d20008dcdad54497292b79471db1d5efc44b848b2f48a6
-  data.tar.gz: 135e12b6084a9cddad8736913bec02ab0dd591728f212340e60e7f83302887dc80551adc09b19cf220306ebde3e742f8b6fc6669cc7794228f84d1f0a39546c7
+  metadata.gz: 227c83421e688d37e8fc544959ead123ca7c1abb5e0f00c465525a7298225a4b3af000eba4b1041ee57ffbba1cb91a7e7332457e35def291697b01dd510436a0
+  data.tar.gz: ce6efd84d43fc76f094ef4f8788c7848d3992548f12493ea529aa0321ec0819c5e9d752a02451227ac57833542e435173aa574136f33beb2a40743cc2b12af55

data/bin/procodile

@@ -1,26 +1,12 @@
 #!/usr/bin/env ruby
 
-require 'yaml'
-global_config_path = ENV['PROCODILE_CONFIG'] || "/etc/procodile"
-if File.exist?(global_config_path)
-  global_config = YAML.load_file(global_config_path)
-else
-  global_config = {}
-end
-
-if global_config['user'] && ENV['USER'] != global_config['user']
-  if global_config['user_reexec']
-    $stderr.puts "\e[31mProcodile must be run as #{global_config['user']}. Re-executing as #{global_config['user']}...\e[0m"
-    exec "sudo -u #{global_config['user']} -- #{$0} #{ARGV.join(' ')}"
-  else
-    $stderr.puts "\e[31mError: Procodile must be run as #{global_config['user']}\e[0m"
-    exit 1
-  end
-end
+trap("INT") { puts ; exit 1 }
 
 $:.unshift(File.expand_path('../../lib', __FILE__))
+
 require 'optparse'
 require 'fileutils'
+require 'yaml'
 require 'procodile'
 require 'procodile/version'
 require 'procodile/error'
@@ -46,7 +32,7 @@ begin
     end
 
     opts.on("--procfile PATH", "The path to the Procfile (defaults to: Procfile)") do |path|
-      options[:procfile_path] = path
+      options[:procfile] = path
     end
 
     if cli.class.commands[command.to_sym] && option_block = cli.class.commands[command.to_sym][:options]
@@ -58,11 +44,90 @@ rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
   exit 1
 end
 
+root = nil
+procfile = nil
+global_config = {}
+if options[:root] && options[:procfile]
+  # root and profile provided on the command line
+  root = options[:root]
+  procfile = options[:procfile]
+elsif options[:root] && options[:procfile].nil?
+  # root provided on the command line but no procfile
+  root = options[:root]
+  procfile = nil
+elsif options[:root].nil? && options[:procfile]
+  # no root provided but a procfile is provided
+  procfile = File.expand_path(options[:procfile])
+  root = File.dirname(procfile)
+else
+  # we don't really know what to do in this situation, if there's a global config
+  # file we can use that
+  global_config_path = ENV['PROCODILE_CONFIG'] || "/etc/procodile"
+  if File.exist?(global_config_path)
+    global_config = YAML.load_file(global_config_path)
+    if global_config.is_a?(Array)
+      puts "There are multiple applications configured in #{global_config_path}"
+      if File.file?("Procfile")
+        puts "\e[45;37mChoose an appplication or press ENTER to use the current directory:\e[0m"
+      else
+        puts "\e[45;37mChoose an application:\e[0m"
+      end
+      global_config.each_with_index do |app, i|
+        col = i % 3
+        print "#{(i+1)}) #{app['name']}"[0,28].ljust(col != 2 ? 30 : 0, ' ')
+        if col == 2 || i == global_config.size - 1
+          puts
+        end
+      end
+      app_id = STDIN.gets.to_i
+      if app_id == 0
+        if File.file?('Procfile')
+          puts "Skipping application selection... using current directory"
+          global_config = {}
+        else
+          exit 1
+        end
+      elsif app = global_config[app_id - 1]
+        puts "\e[35mYou selected #{app['name']}\e[0m"
+        global_config = app
+      else
+        puts "Invalid app number"
+        exit 1
+      end
+    end
+  end
+end
+
+if global_config['user'] && ENV['USER'] != global_config['user']
+  if global_config['user_reexec']
+    $stderr.puts "\e[31mProcodile must be run as #{global_config['user']}. Re-executing as #{global_config['user']}...\e[0m"
+    exec "sudo -u #{global_config['user']} -- #{$0} #{ARGV.join(' ')}"
+  else
+    $stderr.puts "\e[31mError: Procodile must be run as #{global_config['user']}\e[0m"
+    exit 1
+  end
+end
+
+if global_config['root'] && global_config['procfile']
+  # the global config specifies a root and a procfile
+  root = global_config['root']
+  procfile = File.expand_path(global_config['procfile'], root)
+elsif global_config['root'] && global_config['procfile'].nil?
+  root = global_config['root']
+  procfile = nil # assume from the root
+elsif global_config['root'].nil? && global_config['procfile']
+  procfile = global_config['procfile']
+  root = File.dirname(procfile)
+else
+  root ||= FileUtils.pwd
+  procfile ||= nil
+end
+
 begin
   if command != 'help'
-    cli.config = Procodile::Config.new(options[:root] ? File.expand_path(options[:root]) : global_config['root'] || FileUtils.pwd, options[:environment], options[:procfile_path])
+    cli.config = Procodile::Config.new(root, options[:environment], procfile)
   end
-  cli.run(command)
+  cli.dispatch(command)
 rescue Procodile::Error => e
   $stderr.puts "Error: #{e.message}".color(31)
   exit 1

data/lib/procodile.rb

@@ -1,4 +1,13 @@
 module Procodile
+
+  def self.root
+    File.expand_path('../../', __FILE__)
+  end
+
+  def self.bin_path
+    File.join(root, 'bin', 'procodile')
+  end
+
 end
 
 class String

data/lib/procodile/cli.rb

@@ -34,7 +34,7 @@ module Procodile
       @options = {}
     end
 
-    def run(command)
+    def dispatch(command)
       if self.class.commands.keys.include?(command.to_sym)
         public_send(command)
       else
@@ -54,7 +54,7 @@ module Procodile
 
       puts "The following commands are supported:"
       puts
-      self.class.commands.each do |method, options|
+      self.class.commands.sort_by { |k,v| k.to_s }.each do |method, options|
         puts "  \e[34m#{method.to_s.ljust(18, ' ')}\e[0m #{options[:description]}"
       end
       puts
@@ -104,6 +104,13 @@ module Procodile
         cli.options[:proxy] = true
       end
 
+      opts.on("--ports PROCESSES", "Choose ports to allocate to processes") do |processes|
+        cli.options[:port_allocations] = processes.split(/\,/).each_with_object({}) do |line, hash|
+          process, port = line.split(':')
+          hash[process] = port.to_i
+        end
+      end
+
       opts.on("-d", "--dev", "Run in development mode") do
         cli.options[:development] = true
         cli.options[:respawn] = false
@@ -130,7 +137,7 @@ module Procodile
           raise Error, "Cannot enable the proxy when the supervisor is running"
         end
 
-        instances = ControlClient.run(@config.sock_path, 'start_processes', :processes => process_names_from_cli_option, :tag => @options[:tag])
+        instances = ControlClient.run(@config.sock_path, 'start_processes', :processes => process_names_from_cli_option, :tag => @options[:tag], :port_allocations => @options[:port_allocations])
         if instances.empty?
           puts "No processes to start."
         else
@@ -145,7 +152,7 @@ module Procodile
         if @options[:start_supervisor] == false
           raise Error, "Supervisor is not running and cannot be started because --no-supervisor is set"
         else
-          start_supervisor do |supervisor|
+          self.class.start_supervisor(@config, @options) do |supervisor|
             unless @options[:start_processes] == false
               supervisor.start_processes(process_names_from_cli_option, :tag => @options[:tag])
             end
@@ -332,7 +339,6 @@ module Procodile
     #
     # Kill
     #
-
     desc "Forcefully kill all known processes"
     command def kill
       Dir[File.join(@config.pid_root, '*.pid')].each do |pid_path|
@@ -347,6 +353,69 @@ module Procodile
       end
     end
 
+    #
+    # Run a command with a procodile environment
+    #
+    desc "Run a command within the environment"
+    command def run
+      desired_command = ARGV.drop(1).join(' ')
+      exec(@config.environment_variables, desired_command)
+    end
+
+    #
+    # Run the configured console command
+    #
+    desc "Open a console within the environment"
+    command def console
+      if cmd = @config.console_command
+        environment = @config.environment_variables
+        exec(environment, cmd)
+      else
+        raise Error, "No console command has been configured in the Procfile"
+      end
+    end
+
+    #
+    # Open up the procodile log if it exists
+    #
+    desc "Open a console within the environment"
+    options do |opts, cli|
+      opts.on("-f", "Wait for additional data and display it straight away") do
+        cli.options[:wait] = true
+      end
+
+      opts.on("-n LINES", "The number of previous lines to return") do |lines|
+        cli.options[:lines] = lines.to_i
+      end
+
+      opts.on("-p PROCESS", "--process PROCESS", "Show the log for a given process (rather than procodile)") do |process|
+        cli.options[:process] = process
+      end
+
+    end
+    command def log
+      opts = []
+      opts << "-f" if options[:wait]
+      opts << "-n #{options[:lines]}" if options[:lines]
+
+      if options[:process]
+        if process = @config.processes[options[:process]]
+          log_path = process.log_path
+        else
+          raise Error, "Invalid process name '#{options[:process]}'"
+        end
+      else
+        log_path = @config.log_path
+      end
+      puts opts
+      if File.exist?(log_path)
+        exec("tail #{opts.join(' ')} #{log_path}")
+      else
+        raise Error, "No file found at #{log_path}"
+      end
+    end
+
+
     private
 
     def supervisor_running?
@@ -360,18 +429,14 @@ module Procodile
     end
 
     def current_pid
-      if File.exist?(pid_path)
-        pid_file = File.read(pid_path).strip
+      if File.exist?(@config.supervisor_pid_path)
+        pid_file = File.read(@config.supervisor_pid_path).strip
         pid_file.length > 0 ? pid_file.to_i : nil
       else
         nil
       end
     end
 
-    def pid_path
-      File.join(@config.pid_root, 'procodile.pid')
-    end
-
     def process_names_from_cli_option
       if @options[:processes]
         processes = @options[:processes].split(',')
@@ -390,38 +455,38 @@ module Procodile
       end
     end
 
-    def start_supervisor(&after_start)
+    def self.start_supervisor(config, options = {}, &after_start)
       run_options = {}
-      run_options[:respawn] = @options[:respawn]
-      run_options[:stop_when_none] = @options[:stop_when_none]
-      run_options[:proxy] = @options[:proxy]
-
-      processes = process_names_from_cli_option
-
-      if @options[:clean]
-        FileUtils.rm_rf(Dir[File.join(@config.pid_root, '*')])
+      run_options[:respawn] = options[:respawn]
+      run_options[:stop_when_none] = options[:stop_when_none]
+      run_options[:proxy] = options[:proxy]
+      run_options[:force_single_log] = options[:foreground]
+      run_options[:port_allocations] = options[:port_allocations]
+
+      if options[:clean]
+        FileUtils.rm_rf(Dir[File.join(config.pid_root, '*')])
         puts "Emptied PID directory"
       end
 
-      if !Dir[File.join(@config.pid_root, "*")].empty?
-        raise Error, "The PID directory (#{@config.pid_root}) is not empty. Cannot start unless things are clean."
+      if !Dir[File.join(config.pid_root, "*")].empty?
+        raise Error, "The PID directory (#{config.pid_root}) is not empty. Cannot start unless things are clean."
       end
 
-      $0="[procodile] #{@config.app_name} (#{@config.root})"
-      if @options[:foreground]
-        File.open(pid_path, 'w') { |f| f.write(::Process.pid) }
-        Supervisor.new(@config, run_options).start(&after_start)
+      $0="[procodile] #{config.app_name} (#{config.root})"
+      if options[:foreground]
+        File.open(config.supervisor_pid_path, 'w') { |f| f.write(::Process.pid) }
+        Supervisor.new(config, run_options).start(&after_start)
       else
-        FileUtils.rm_f(File.join(@config.pid_root, "*.pid"))
+        FileUtils.rm_f(File.join(config.pid_root, "*.pid"))
         pid = fork do
-          STDOUT.reopen(@config.log_path, 'a')
+          STDOUT.reopen(config.log_path, 'a')
           STDOUT.sync = true
-          STDERR.reopen(@config.log_path, 'a')
+          STDERR.reopen(config.log_path, 'a')
           STDERR.sync = true
-          Supervisor.new(@config, run_options).start(&after_start)
+          Supervisor.new(config, run_options).start(&after_start)
         end
         ::Process.detach(pid)
-        File.open(pid_path, 'w') { |f| f.write(pid) }
+        File.open(config.supervisor_pid_path, 'w') { |f| f.write(pid) }
         puts "Started Procodile supervisor with PID #{pid}"
       end
     end

data/lib/procodile/config.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'fileutils'
 require 'procodile/error'
 require 'procodile/process'
 
@@ -10,11 +11,11 @@ module Procodile
     attr_reader :root
     attr_reader :environment
 
-    def initialize(root, environment, procfile = nil)
+    def initialize(root, environment = nil, procfile = nil)
       @root = root
       @environment = environment || 'production'
       @procfile_path = procfile
-      unless File.exist?(procfile_path)
+      unless File.file?(procfile_path)
         raise Error, "Procfile not found at #{procfile_path}"
       end
       FileUtils.mkdir_p(pid_root)
@@ -62,16 +63,20 @@ module Procodile
       @app_name ||= fetch(local_options['app_name']) || fetch(options['app_name']) || 'Procodile'
     end
 
+    def console_command
+      fetch(local_options['console_command']) || fetch(options['console_command'])
+    end
+
     def processes
       @processes ||= {}
     end
 
     def process_list
-      @process_list ||= YAML.load_file(procfile_path) || {}
+      @process_list ||= load_process_list_from_file
     end
 
     def options
-      @options ||= File.exist?(options_path) ? YAML.load_file(options_path) : {}
+      @options ||= load_options_from_file
     end
 
     def process_options
@@ -79,7 +84,7 @@ module Procodile
     end
 
     def local_options
-      @local_options ||= File.exist?(local_options_path) ? YAML.load_file(local_options_path) : {}
+      @local_options ||= load_local_options_from_file
     end
 
     def local_process_options
@@ -98,6 +103,10 @@ module Procodile
       @pid_root ||= File.expand_path(fetch(local_options['pid_root']) || fetch(options['pid_root']) || 'pids', @root)
     end
 
+    def supervisor_pid_path
+      File.join(pid_root, 'procodile.pid')
+    end
+
     def log_path
       log_path = fetch(local_options['log_path']) || fetch(options['log_path'])
       if log_path
@@ -121,8 +130,6 @@ module Procodile
       File.join(pid_root, 'procodile.sock')
     end
 
-    private
-
     def procfile_path
       @procfile_path || File.join(@root, 'Procfile')
     end
@@ -135,6 +142,8 @@ module Procodile
       procfile_path + ".local"
     end
 
+    private
+
     def create_process(name, command, log_color)
       process = Process.new(self, name, command, options_for_process(name))
       process.log_color = log_color
@@ -161,5 +170,17 @@ module Procodile
       end
     end
 
+    def load_process_list_from_file
+      YAML.load_file(procfile_path)
+    end
+
+    def load_options_from_file
+      File.exist?(options_path) ? YAML.load_file(options_path) : {}
+    end
+
+    def load_local_options_from_file
+      File.exist?(local_options_path) ? YAML.load_file(local_options_path) : {}
+    end
+
   end
 end

data/lib/procodile/control_session.rb

@@ -25,6 +25,13 @@ module Procodile
     end
 
     def start_processes(options)
+      if options['port_allocations']
+        if @supervisor.run_options[:port_allocations]
+          @supervisor.run_options[:port_allocations].merge!(options['port_allocations'])
+        else
+          @supervisor.run_options[:port_allocations] = options['port_allocations']
+        end
+      end
       instances = @supervisor.start_processes(options['processes'], :tag => options['tag'])
       "200 " + instances.map(&:to_hash).to_json
     end

data/lib/procodile/instance.rb

@@ -100,12 +100,23 @@ module Procodile
         Procodile.log(@process.log_color, description, "Already running with PID #{@pid}")
         nil
       else
+        if @supervisor.run_options[:port_allocations] && chosen_port = @supervisor.run_options[:port_allocations][@process.name]
+          if chosen_port == 0
+            allocate_port
+          else
+            @port = chosen_port
+            Procodile.log(@process.log_color, description, "Assigned #{chosen_port} to process")
+          end
+        elsif @process.proxy? && @supervisor.tcp_proxy
+          # Allocate a port randomly if a proxy is needed
+          allocate_port
+        end
 
-        if @process.proxy? && @supervisor.tcp_proxy
+        if (@supervisor.run_options[:allocate_ports] && @supervisor.run_options[:allocate_ports].include?(@process.name)) || (@process.proxy? && @supervisor.tcp_proxy)
           allocate_port
         end
 
-        if self.process.log_path
+        if self.process.log_path && @supervisor.run_options[:force_single_log] != true
           log_destination = File.open(self.process.log_path, 'a')
           io = nil
         else
@@ -115,13 +126,15 @@ module Procodile
         end
         @tag = @supervisor.tag.dup if @supervisor.tag
         Dir.chdir(@process.config.root)
-        @pid = ::Process.spawn(environment_variables, @process.command, :out => log_destination, :err => log_destination, :pgroup => true)
+        without_rbenv do
+          @pid = ::Process.spawn(environment_variables, @process.command, :out => log_destination, :err => log_destination, :pgroup => true)
+        end
         log_destination.close
         File.open(pid_file_path, 'w') { |f| f.write(@pid.to_s + "\n") }
         @supervisor.add_instance(self, io)
         ::Process.detach(@pid)
         Procodile.log(@process.log_color, description, "Started with PID #{@pid}" + (@tag ? " (tagged with #{@tag})" : ''))
-        if self.process.log_path
+        if self.process.log_path && io.nil?
           Procodile.log(@process.log_color, description, "Logging to #{self.process.log_path}")
         end
         @started_at = Time.now
@@ -315,18 +328,59 @@ module Procodile
     # Find a port number for this instance to listen on. We just check that nothing is already listening on it.
     # The process is expected to take it straight away if it wants it.
     #
-    def allocate_port
+    def allocate_port(max_attempts = 10)
+      attempts = 0
       until @port
+        attempts += 1
         possible_port = rand(10000) + 20000
-        begin
-          server = TCPServer.new('127.0.0.1', possible_port)
-          server.close
+        if self.port_available?(possible_port)
+          Procodile.log(@process.log_color, description, "Allocated port as #{possible_port}")
           return @port = possible_port
-        rescue
-          # Nah.
+        elsif attempts >= max_attempts
+          raise Procodile::Error, "Couldn't allocate port for #{instance.name}"
         end
       end
     end
 
+    #
+    # Is the given port available?
+    #
+    def port_available?(port)
+      case @process.network_protocol
+      when 'tcp'
+        server = TCPServer.new('127.0.0.1', port)
+        server.close
+        true
+      when 'udp'
+        server = UDPSocket.new
+        server.bind('127.0.0.1', port)
+        server.close
+        true
+      else
+        raise Procodile::Error, "Invalid network_protocol '#{@process.network_protocol}'"
+      end
+    rescue Errno::EADDRINUSE => e
+      false
+    end
+
+    #
+    # If procodile is executed through rbenv it will pollute our environment which means that
+    # any spawned processes will be invoked with procodile's ruby rather than the ruby that
+    # the application wishes to use
+    #
+    def without_rbenv(&block)
+      previous_environment = ENV.select { |k,v| k =~ /\A(RBENV\_)/ }
+      if previous_environment.size > 0
+        previous_environment.each { |key, value| ENV[key] = nil }
+        previous_environment['PATH'] = ENV['PATH']
+        ENV['PATH'] = ENV['PATH'].split(':').select { |p| !(p =~ /\.rbenv\/versions/) }.join(':')
+      end
+      yield
+    ensure
+      previous_environment.each do |key, value|
+        ENV[key] = value
+      end
+    end
+
   end
 end

data/lib/procodile/process.rb

@@ -12,11 +12,10 @@ module Procodile
     attr_accessor :log_color
     attr_accessor :removed
 
-    def initialize(config, name, command, environment, options = {})
+    def initialize(config, name, command, options = {})
       @config = config
       @name = name
       @command = command
-      @environment = environment
       @options = options
       @log_color = 0
       @instance_index = 0
@@ -132,6 +131,12 @@ module Procodile
       proxy? ? @options['proxy_address'] || '127.0.0.1' : nil
     end
 
+    #
+    # Return the network protocol for this process
+    #
+    def network_protocol
+      @options['network_protocol'] || 'tcp'
+    end
 
     #
     # Generate an array of new instances for this process (based on its quantity)
@@ -166,5 +171,16 @@ module Procodile
       }
     end
 
+    #
+    # Is the given quantity suitable for this process?
+    #
+    def correct_quantity?(quantity)
+      if self.restart_mode == 'start-term'
+        quantity >= self.quantity
+      else
+        self.quantity == quantity
+      end
+    end
+
   end
 end

data/lib/procodile/signal_handler.rb

@@ -36,6 +36,7 @@ module Procodile
 
     def handle
       if signal = self.class.queue.shift
+        Procodile.log nil, 'system', "Supervisor received #{signal} signal"
         if @handlers[signal]
           @handlers[signal].each(&:call)
         end

data/lib/procodile/status_cli_output.rb

@@ -59,10 +59,10 @@ module Procodile
             print "|| => ".color(process['log_color']) + instance['description'].to_s.ljust(17, ' ').color(process['log_color'])
             print instance['status'].ljust(10, ' ')
             print "   " + formatted_timestamp(instance['started_at']).ljust(10, ' ')
-            print "   " + instance['pid'].to_s.ljust(6, ' ')
-            print "   " + instance['respawns'].to_s.ljust(4, ' ')
-            print "   " + (instance['port'] || "-").to_s.ljust(6, ' ')
-            print "   " + (instance['tag'] || "-").to_s
+            print "   pid:" + instance['pid'].to_s.ljust(6, ' ')
+            print "   respawns:" + instance['respawns'].to_s.ljust(4, ' ')
+            print "   port:" + (instance['port'] || "-").to_s.ljust(6, ' ')
+            print "   tag:" + (instance['tag'] || "-").to_s
             puts
           end
         end

data/lib/procodile/supervisor.rb

@@ -9,6 +9,7 @@ module Procodile
     attr_reader :started_at
     attr_reader :tag
     attr_reader :tcp_proxy
+    attr_reader :run_options
 
     def initialize(config, run_options = {})
       @config = config
@@ -19,7 +20,7 @@ module Procodile
       @signal_handler.register('TERM') { stop_supervisor }
       @signal_handler.register('INT') { stop(:stop_supervisor => true) }
       @signal_handler.register('USR1') { restart }
-      @signal_handler.register('USR2') { status }
+      @signal_handler.register('USR2') { }
       @signal_handler.register('HUP') { reload_config }
     end
 
@@ -41,6 +42,15 @@ module Procodile
       watch_for_output
       @started_at = Time.now
       after_start.call(self) if block_given?
+      supervise!
+    rescue => e
+      Procodile.log nil, "system", "Error: #{e.class} (#{e.message})"
+      e.backtrace.each { |bt| Procodile.log nil, "system", "=> #{bt})" }
+      stop(:stop_supervisor => true)
+      supervise!
+    end
+
+    def supervise!
       loop { supervise; sleep 3 }
     end
 
@@ -130,7 +140,7 @@ module Procodile
 
       if @run_options[:stop_when_none]
         # If the processes go away, we can stop the supervisor now
-        if @processes.all? { |_,instances| instances.size == 0 }
+        if @processes.all? { |_,instances| instances.reject(&:failed?).size == 0 }
           Procodile.log nil, "system", "All processes have stopped"
           stop_supervisor
         end
@@ -170,7 +180,7 @@ module Procodile
     def messages
       messages = []
       processes.each do |process, process_instances|
-        if process.quantity != process_instances.size
+        unless process.correct_quantity?(process_instances.size)
           messages << {:type => :incorrect_quantity, :process => process.name, :current => process_instances.size, :desired => process.quantity}
         end
         for instance in process_instances

data/lib/procodile/version.rb

@@ -1,3 +1,3 @@
 module Procodile
-  VERSION = '1.0.10'
+  VERSION = '1.0.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: procodile
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.0.11
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2017-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json