procman 1.1.2 → 1.2.0

data/Procfile

@@ -1,19 +1,24 @@
-process :unicorn do
-  start do
-    puts "ENV: #{environment}"
-  end
-  stop    {}
-  restart {}
-end
+process :example_worker do
 
-process :worker do
-  start   {}
-  stop    {}
-  restart {}
-end
+  # Only action this process in production on a specific host
+  # constraint :environment => 'production', :host => 'app01.myapp.com'
 
-process :cron do
-  start   {}
-  stop    {}
-  restart {}
+  # Only action this process in development
+  constraint :environment => 'development'
+  
+  # Define the action to be carried out when this process should start
+  start do
+    
+  end
+  
+  # Define the action to be carried out when this process should stop
+  stop do
+    
+  end
+  
+  # Define the action to be carried out when this process should restart
+  restart do
+    
+  end
+  
 end

data/Procfile.template

@@ -0,0 +1,24 @@
+process :example_worker do
+
+  # Only action this process in production on a specific host
+  # constraint :environment => 'production', :host => 'app01.myapp.com'
+
+  # Only action this process in development
+  # constraint :environment => 'development'
+  
+  # Define the action to be carried out when this process should start
+  start do
+    
+  end
+  
+  # Define the action to be carried out when this process should stop
+  stop do
+    
+  end
+  
+  # Define the action to be carried out when this process should restart
+  restart do
+    
+  end
+  
+end

data/README.md

@@ -10,6 +10,28 @@ your application as a whole.
 The `Procfile` is a Ruby file which you can use to define how to manipulate
 your processes.
 
+## Setting up
+
+If you're using Bundler (you should be) and wish to use procman, just include it within
+your Gemfile and run `bundle` to install it. 
+
+```ruby
+gem 'procman'
+```
+
+Once installed, you can execute commands as shown below but you should prefix `bundle exec`
+to the start of the command.
+
+## Creating your initial Procfile
+
+The command line tool allows you to create an example `Procfile` with a simple command. This
+will create a `Procfile` in the root of the directory you are currently within. You can then
+open this template and make changes as appropriate for your applications.
+
+```bash
+$ procman init
+```
+
 ## Example Procfile
 
 Your Procfile can contain multiple types of process and each process should define
@@ -22,11 +44,11 @@ powered by our Ruby backgrounding system, rbg.
 process :unicorn do
 
   start do
-    system("umask 002 && bundle exec unicorn_rails -E production -c config/unicorn.rb -D")
+    system("umask 002 && bundle exec unicorn_rails -E #{environment} -c #{root}/config/unicorn.rb -D")
   end
   
   stop do
-    system("kill `cat tmp/pids/unicorn.production.pid`")
+    system("kill `cat #{root}/tmp/pids/unicorn.#{environment}.pid`")
   end
   
   restart { stop and start }
@@ -34,22 +56,46 @@ process :unicorn do
 end
 
 process :worker do
+
+  constraint :environment => 'production', :host => /\.production\.myapp\z/
+  constraint :environment => 'development', :host => /\.local\z/
   
   start do
-    system("bundle exec rbg start -c config/processes/worker.rb -E production")
+    system("bundle exec rbg start -c #{root}/config/processes/worker.rb -E #{environment}")
   end
   
   stop do
-    system("bundle exec rbg stop -c config/processes/worker.rb -E production")
+    system("bundle exec rbg stop -c #{root}/config/processes/worker.rb -E #{environment}")
   end
 
   restart do
-    system("bundle exec rbg reload -c config/processes/worker.rb -E production")
+    system("bundle exec rbg reload -c #{root}/config/processes/worker.rb -E #{environment}")
   end
   
 end
 ```
 
+### Specifying constraints
+
+If you only want certain processes to execute under certain environments or on specific hosts,
+you can use constraints to restrict these.
+
+You can specify any number of constraints for a process as shown below. If no constraints are defined
+for a specific process, it will always be included when your action is executed. If a constraint is
+added, the process's action will only be invoked when at least one of the constraints is matched otherwise
+it will be skipped.
+
+Constraints are configured by adding `constraint` "rules" to your process definitions. 
+
+```ruby
+# execute always in production
+constraint :environment => 'production'
+# execute on hosts where the hostname ends in .local
+constraint :host => /\.local\z/
+# execute in prodution and where the hostname is 'app01'
+constraint :environment => 'production', :host => 'app01'
+```
+
 ## Executing process commands
 
 Once you have a Procfile, you can execute commands by sending them to the `procman`
@@ -60,6 +106,24 @@ the command using `bundle exec procman`.
 * `procman stop` - stop your processes
 * `procman restart` - restart your processes
 
+In fact, you can define any actions you wish. You do not need to be constrained by start,
+stop & restart. If you executed `procman jump`, it would call the `jump` method for each
+process within your `Procfile`. There are various action names which are reserved, including:
+`name`, `options`, `environment`, `host`, `root` and `constraint`.
+
+Also, You can pass options to these methods to add extra functionality.
+
+* `-e` - allows you specify the environment which is provided as the environment variable in your methods.
+* `--processes` - allows you to specify which processes (comma separated) should be executed in the action.
+
+Some examples of how to execute these options:
+
+```bash
+$ procman start -e production
+$ procman start -e production --processes worker
+$ procman start --processes worker,unicorn
+```
+
 ## Executing on deployment
 
 You can use the included Capistrano recipe to automatically run your procman start/stop/restart
@@ -68,3 +132,5 @@ commands whenever you deploy. Just require the deploy recipes in your `Capfile`.
 ```ruby
 require 'proc_man/deploy'
 ```
+
+This requires that you are using bundler and the `procman` gem has been included in your Gemfile.

data/bin/procman

@@ -1,7 +1,29 @@
 #!/usr/bin/env ruby
 require 'proc_man'
 begin
-  ProcMan.run(ARGV[0], ARGV[1])
+  
+  # Convert command line arguments into the appropriate ruby objects
+  args = ARGV.dup
+  final_args = []
+  options = {}
+  until args.empty?
+    arg = args.shift
+    if arg =~ /\A\-/
+      options[arg.gsub(/\A\-+/, '').to_sym] = args.shift
+    else
+      final_args << arg
+    end
+  end
+  
+  command = final_args.first
+  case command
+  when 'init'
+    ProcMan.init
+  else
+    # Execute the command
+    ProcMan.run(final_args.first, options)
+  end
+  
 rescue ProcMan::Error => e
   puts "\e[31m" + e.message + "\e[0m"
   Process.exit(1)

data/lib/proc_man.rb

@@ -1,9 +1,10 @@
 require 'proc_man/process'
 require 'proc_man/procfile'
+require 'proc_man/constraint'
 
 module ProcMan
   
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
   
   class Error < StandardError; end
   
@@ -22,16 +23,18 @@ module ProcMan
       @processes ||= Array.new
     end
     
-    def run(method, environment = nil)
+    def run(method, options = {})
       load_procfile(File.expand_path('./Procfile'))
       if method.nil?
         raise Error, "Command to execute was not specified. For example, pass 'start' to start processes."
       else
         for process in self.processes
-          process.environment = environment
+          process.options = options
           if process.defined_method?(method)
-            puts "\e[33m#{method.capitalize}ing #{process.name}\e[0m"
-            process.send(method)
+            if process.execute?
+              puts "\e[33m#{method.capitalize}ing #{process.name}\e[0m"
+              process.send(method)
+            end
           else
             puts "\e[31mThe #{process.name} process does not implement a '#{method}' method\e[0m"
           end
@@ -39,5 +42,17 @@ module ProcMan
       end
     end
     
+    # Create a new Procfile template in the current directory root
+    def init
+      path = File.expand_path('./Procfile')
+      if File.file?(path)
+        raise Error, "Procfile already exists at #{path}"
+      else
+        template_path = File.expand_path('../../Procfile.template', __FILE__)
+        File.open(path, 'w') { |f| f.write(File.read(template_path)) }
+        puts "\e[32mProcfile created at #{path}"
+      end
+    end
+    
   end
 end

data/lib/proc_man/constraint.rb

@@ -0,0 +1,34 @@
+module ProcMan
+  class Constraint
+    
+    def initialize(process, conditions)
+      @process      = process
+      @conditions   = conditions
+    end
+    
+    def matches?
+      matches = 0
+      for key, value in @conditions
+        matches += 1 if compare(value, @process.send(key).to_s.downcase)
+      end
+      @conditions.size > 0 && matches == @conditions.size
+    end
+    
+    private
+    
+    def compare(condition, value)
+      value = value.to_s.downcase
+      case condition
+      when String
+        condition.to_s.downcase == value
+      when Regexp
+        !!condition.match(value)
+      when Array
+        condition.any? { |c| compare(c, value) }
+      else
+        false
+      end
+    end
+    
+  end
+end

data/lib/proc_man/deploy.rb

@@ -20,7 +20,7 @@ Capistrano::Configuration.instance(:must_exist).load do
     after :restart, "procman:restart"
     
     def procman_command(command)
-      command = "sh -c \"cd #{deploy_to} && bundle exec procman #{command} #{environment}\""
+      command = "sh -c \"cd #{deploy_to} && bundle exec procman #{command} --environment #{environment}\""
       if user = fetch(:procman_user, 'app')
         command = "sudo -u #{user} #{command}" 
       end

data/lib/proc_man/process.rb

@@ -1,24 +1,60 @@
 module ProcMan
   class Process
     
-    attr_writer :environment
+    attr_writer :options
     
-    def initialize(name, options = {})
+    # Initializes the new process by receiving it's name
+    def initialize(name)
       @name = name
+      @constraints = []
     end
     
+    # Returns the name of the process
     def name
       @name
     end
     
+    # Returns a hash of options which the user has specified
+    def options
+      @options ||= {}
+    end
+    
+    # Returns the current environment
     def environment
-      @environment || 'development'
+      self.options[:environment] || self.options[:e] || self.options[:env] || 'development'
     end
     
+    # Returns the current root directory path
     def root
       @root ||= File.expand_path('./')
     end
     
+    ## Returns the current hostname of the machine executing this action
+    def host
+      @host ||= `hostname -f`.strip
+    end
+    
+    ## Sets a constraint for this process
+    def constraint(hash = {})
+      @constraints << Constraint.new(self, hash)
+    end
+    
+    # Specifies whether or not actions for this process should be executed
+    # in the current context.
+    def execute?
+      (@constraints.empty? || @constraints.any?(&:matches?)) &&
+      (self.options[:processes].nil? || self.options[:processes].split(',').include?(self.name.to_s))
+    end
+    
+    # Specifies whether or not the provided method has been defined in the Procfile
+    # for this process.
+    def defined_method?(name)
+      instance_variable_get("@#{name}").is_a?(Proc)
+    end
+        
+    # Stores and calls different process actions for this process. If there is no
+    # block provided and we don't have a method it will return false otherwise it
+    # will store or call the action as appropriate.
     def method_missing(method, &block)
       if block_given?
         instance_variable_set("@#{method}", block)
@@ -29,9 +65,5 @@ module ProcMan
       end
     end
     
-    def defined_method?(name)
-      instance_variable_get("@#{name}").is_a?(Proc)
-    end
-        
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: procman
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -20,13 +20,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/procman
+- lib/proc_man/constraint.rb
 - lib/proc_man/deploy.rb
 - lib/proc_man/process.rb
 - lib/proc_man/procfile.rb
 - lib/proc_man.rb
 - LICENCE
 - Procfile
-- procman-1.1.1.gem
+- Procfile.template
 - procman.gemspec
 - README.md
 homepage: http://atechmedia.com