whiskey_disk 0.6.0 → 0.6.2

data/CHANGELOG

@@ -1,3 +1,24 @@
+0.6.2 / 2010-12-23 
+==================
+
+  * bumping version to 0.6.2
+  * Merge branch 'feature/support-domain-roles' into develop
+  * updating README to document new roles functionality
+  * even more README tweaks
+  * more README tweaks
+  * adding lib/tasks/deploy.rake example to README
+  * refreshing gemspec
+  * update multiple deployment example to use roles
+  * new wd_role command for checking membership in a role from shell scripts
+  * adding #role? method in whiskey_disk/helpers for role-based rake tasks
+  * pass domain roles along as env variables when running ssh commands
+  * domain data now includes role information when available
+  * internal representation of 'domain' is now a list of hashes
+  * refactoring of config domain normalization code
+  * adding domain examples for config specs
+  * removing unnecessary describe blocks from config spec
+  * reordering domain config spec setup data structure for readability
+
 
 0.6.0 / 2010-12-22 
 ==================
@@ -17,6 +38,10 @@
   * normalize 'domain' values pulled from config files
   * refactor config file writing in config spec
   * WD.remote? now understands arrays of 'domain' entries in the config
+
+0.5.4
+==================
+
   * Merge branch 'release/0.5.4' into develop
   * bump gemspec for 0.5.4 release
   * Version bump to 0.5.4
@@ -37,6 +62,10 @@
   * And removing unneeded spec helper
   * removing whiskey_disk config stubbing
   * introducing use_config() spec helper
+
+0.5.3
+==================
+
   * Merge branch 'release/0.5.3' into develop
   * updating gemspec for 0.5.3
   * updating Contributors section of README
@@ -47,6 +76,10 @@
   * Reworking the config to append project name overrides to the env, since everything else is dependent thereupon
   * tidying up the spec
   * Allowing a manually specified project name in the bare config hash to be used as the parent project in the absence of one specified from the 'to' env setting
+
+0.5.2
+==================
+
   * Merge branch 'release/0.5.2' into develop
   * updating gemspec for version 0.5.2
   * Bumping version to 0.5.2
@@ -61,6 +94,10 @@
   * Updating TODO list
   * Adding lightning talk info to README
   * Making shallow clones on initial setup
+
+0.5.0
+==================
+
   * Merge branch 'release/0.5.0' into develop
   * updating gemspec for 0.5.0
   * Version bump to 0.5.0
@@ -72,6 +109,10 @@
   * Reordering specs for post-setup/deployment tasks
   * Updating README for post_*_script functionality
   * TODO file updates
+
+0.4.5
+==================
+
   * Merge branch 'release/0.4.5' into develop
   * new gemspec for 0.4.5 release
   * Version bump to 0.4.5
@@ -82,25 +123,45 @@
   * refactoring update checkout methods
   * renaming conditional_clone
   * Refactoring rake task code
+
+0.4.4
+==================
+
   * Merge branch 'release/0.4.4' into develop
   * 0.4.4 gemspec
   * Version bump to 0.4.4
   * Merge branch 'feature/readme-updates' into develop
   * TODO list tweakage
   * README updates
+
+0.4.3
+==================
+
   * Merge branch 'release/0.4.3' into develop
   * updating gemspec
   * Version bump to 0.4.3
   * Updating TODO
   * Smarter setups
   * TODO updates
+
+0.4.2
+==================
+
   * Version bump to 0.4.2
   * Taking a different approach to rake task detection
+
+0.4.1
+==================
+
   * bumping gemspec
   * Version bump to 0.4.1
   * Fixing post_* hook edge case
   * More README updates
   * updating README
+
+0.4.0
+==================
+
   * updated gemspec
   * adding staleness check docs to README
   * Version bump to 0.4.0
@@ -112,6 +173,10 @@
   * Adding first pass at conditional staleness checks
   * updating TODO list
   * README note about post_* rake task dependencies
+
+0.3.1
+==================
+
   * updated gemspec
   * Version bump to 0.3.1
   * No longer require a Rakefile when --path isn't used

data/README.markdown

@@ -20,7 +20,7 @@ everything done.
   - 1 ssh connection per run -- so everything needed to do a full setup
     is done in one shot.  Everything needed to do a full deployment is done in
 one shot.  (Having 8 minute deploys failing because I was on CDMA wireless on a
-train in india where the connection won't stay up for more than 2-3 minutes is
+train in India where the connection won't stay up for more than 2-3 minutes is
 not where I want to be any more.)
 
   - Deployment configuration is specified as YAML data, not as code.
@@ -46,8 +46,8 @@ current local checkout.
     specify a config_branch and everyone can have their own local setup that just
     works.
 
-  - There's no before\_after\_before_after hooks.  You've got plenty of
-    flexibility with just a handful of rake hook points to grab onto.
+  - There's no before\_after\_before_after hooks.  You can use a well-defined rake hook and/or a 
+    bash script to run additional tasks.
  
   - You can enable "staleness checks" so that deployments only happen if
     either the main repo, or the config repo (if you're using one) has
@@ -62,6 +62,8 @@ current local checkout.
     doing them in parallel once we're happy with the stability of this (new)
     feature.
 
+  - Assign hosts to roles (e.g., "web", "db", "app") and vary the shell or rake 
+    post-setup/post-deploy actions you run based on those roles.
 
 ### Assumptions ###
 
@@ -107,6 +109,7 @@ As a rails plugin:
 Known config file settings (if you're familiar with capistrano and vlad these should seem eerily familiar):
  
     domain:              host or list of hosts on which to deploy (these are ssh connect strings)
+                         can also optionally include role information for each host
     deploy_to:           path to which to deploy main application
     repository:          git repo path for main application
     branch:              git branch to deploy from main application git repo (default: master)
@@ -151,6 +154,85 @@ For deploying to multiple hosts, the config/deploy.yml might look like:
         RAILS_ENV: 'production'
 
 
+### Specifying domains, with or without roles ###
+
+There are a number of ways to specify domains (the ssh connection strings denoting the hosts
+where your code will be deployed).  Here are just a few examples:
+
+Just a single domain:
+
+    staging:
+      domain: "foo@staging.example.com"
+
+Just a single domain, but specified as a one-item list:
+
+    qa:
+      domain: 
+      - "foo@qa.example.com"
+
+A list of multiple domains:
+
+    production:
+      domain:
+      - "foo@appserver1.example.com"
+      - "foo@appserver2.example.com"
+      - "foo@www.example.com"
+
+Using the "name" label for the domain names (if using roles, as described below, the "name" label is required,
+otherwise it's optional and superfluous):
+
+    ci:
+      domain:
+      - name: "build@ci.example.com"
+
+
+It's also possible to assign various "roles" to the domains to which you deploy.  Some common usages would be
+"www", which might need a post\_deploy task which notifies some web server software (apache, nginx, passenger, 
+unicorn, etc.) that it should refresh the contents being served; or perhaps "db", which might need some set of
+post-deployment database migrations run (and which shouldn't be run from multiple servers).
+
+The role names are simply strings and you can create whichever roles you wish.  See the section below entitled
+"Taking actions based on roles" to see how to use roles to control actions when setting up or deploying to a
+target.
+
+Roles are described in the domain: section of the configuration file.  There are, of course, a few different
+valid ways to specify roles.  Note that the domain name must now be labeled when roles are being specified
+for the domain.
+
+A single role for a domain can be specified inline:
+
+    production:
+      domain:
+      - name: "foo@appserver1.example.com"
+        roles: "web"
+
+While multiple roles for a domain must be specified as a list:
+
+    production:
+      domain:
+      - name: "foo@appserver1.example.com"
+        roles: 
+        - "web"
+        - "app"
+        - "db"
+
+But domains with roles can be specified alongside simple domains as well:
+
+    production:
+      domain:
+      - name: "bar@demo.example.com"
+      - "user@otherhost.domain.com"
+      - name: "foo@appserver1.example.com"
+        roles: 
+        - "web"
+        - "app"
+        - "db"
+
+
+All that said, it's often simpler to refrain from carving up hosts into roles.  But who's going to listen to reason?
+
+
+
 ### post\_deploy\_script and post\_setup\_script ###
 
 Whiskey\_disk provides rake task hooks (deploy:post\_setup and deploy:post\_deploy) to allow running custom
@@ -184,7 +266,98 @@ The post\_deploy\_script will be run from /var/www/www.ogtastic.com/bin/post-dep
 target system.
 
 
-### Running from the command-line ###
+### Taking actions based on roles ###
+
+#### When running rake tasks or other ruby scripts ####
+
+Whiskey\_disk includes a helper library for use in rake tasks and other ruby scripts.  In that library you'll
+find a ruby function 'role?' which returns true if you're currently being deployed to a domain with the given
+role.  For example:
+
+<code>
+    
+    require 'whiskey_disk/helpers'
+
+    namespace :deploy do
+      task :create_rails_directories do
+        if role? :www
+          puts "creating log/ and tmp/ directories"
+          Dir.chdir(RAILS_ROOT)
+          system("mkdir -p log tmp")
+        end
+      end        
+
+      task :db_migrate_if_necessary do
+				Rake::Task['db:migrate'] if role? :db
+      end
+
+      # whytf is this even necessary?  Come on.  This should be built into ts:restart.
+      task :thinking_sphinx_restart => [:environment] do
+        if role? :app
+          Rake::Task['ts:stop'].invoke rescue nil
+          Rake::Task['ts:index'].invoke
+          Rake::Task['ts:start'].invoke
+        end
+      end
+    
+      task :bounce_passenger do
+        if role? :www
+          puts "restarting Passenger web server"
+          Dir.chdir(RAILS_ROOT)
+          system("touch tmp/restart.txt")    
+        end
+      end
+
+      # etc...
+    
+      task :post_setup  => [ :create_rails_directories ]
+      task :post_deploy => [ :db_migrate_if_necessary, :thinking_sphinx_restart, :bounce_passenger ]
+    end
+</code>
+
+
+#### When working with the shell ####
+
+Installing the whiskey\_disk gem also installs another binary, called wd_role.  It's job is really simple,
+given a role, determine if we're currently in a deployment that matches that role.  If so, exit with a success
+exit status, otherwise, exit with an error exit status.  This allows programs running in the shell to conditionally
+execute code based on domain roles.  This is particularly applicable to post\_setup\_script and post\_deploy\_script
+code.
+
+Here's an off-the-cuff example of how one might use wd\_role.  We have the rockhands gem installed (obviously), and
+are in an environment where the 'app' role is active but the 'web' role is not:
+
+
+    $ wd_role web && rock || shocker
+         .-.     
+       .-.U|     
+       |U| | .-. 
+       | | |_|U| 
+       | | | | | 
+      /|     ` |
+     | |       | 
+     |         | 
+      \        / 
+      |       |  
+      |       |  
+                 
+    $ wd_role app && rock || shocker
+       .-.       
+       |U|       
+       | |   .-. 
+       | |-._|U| 
+       | | | | | 
+      /|     ` | 
+     | |       | 
+     |         | 
+              / 
+      |       |  
+      |       |  
+    
+
+
+
+### Running whiskey\_disk from the command-line ###
   
     % wd setup --to=<target>
     % wd setup --to=<project>:<target>
@@ -307,7 +480,7 @@ sounds if you're using gitosis, btw.)
 Anyway, a config repo is just a git repo.  In it are directories for every
 project whose configuration information is managed in that repo.  For example,
 there's a "larry" directory in our main config repo, because we're deploying
-the [larry project](http://github.com/rick/larry) to manage our high-level
+the [larry project](http://github.com/flogic/larry) to manage our high-level
 configuration data.
 
 Note, if you set the 'project' setting in deploy.yml, that determines the
@@ -361,15 +534,53 @@ overlaid on top of the most recent checkout of the project.  Snap.
 
  
 
-  More Examples:
+### More Examples: ###
 
-  - We are using this to manage larry.  See [http://github.com/rick/larry/blob/master/config/deploy.yml](http://github.com/rick/larry/blob/master/config/deploy.yml) and 
-    [http://github.com/rick/larry/blob/master/lib/tasks/deploy.rake](http://github.com/rick/larry/blob/master/lib/tasks/deploy.rake)
+ - We are using this to manage larry.  See [https://github.com/flogic/larry/blob/master/config/deploy-local.yml.example](https://github.com/flogic/larry/blob/master/config/deploy-local.yml.example) and [http://github.com/flogic/larry/blob/master/lib/tasks/deploy.rake](http://github.com/flogic/larry/blob/master/lib/tasks/deploy.rake)
 
- - We are using whiskey\_disk on a private project with lots of config files, but here's
-    a gist showing a bit more interesting deploy.rake file for post_setup and
-post_deploy work:  [https://gist.github.com/47e23f2980943531beeb](https://gist.github.com/47e23f2980943531beeb)
+ - Here is a sample of a lib/tasks/deploy.rake from a Rails application we deployed once upon a time:
 
+<code>
+
+    RAILS_ENV=ENV['RAILS_ENV'] if ENV['RAILS_ENV'] and '' != ENV['RAILS_ENV']
+    Rake::Task['environment'].invoke
+    
+    require 'asset_cache_sweeper'
+
+    namespace :deploy do
+      task :create_rails_directories do
+        puts "creating log/ and tmp/ directories"
+        Dir.chdir(RAILS_ROOT)
+        system("mkdir -p log tmp")
+      end
+    
+      # note that the plpgsql language needs to be installed by the db admin at initial database creation :-/
+      task :setup_postgres_for_thinking_sphinx => [ :environment ] do
+        ThinkingSphinx::PostgreSQLAdapter.new(Product).setup
+      end
+    
+      # whytf is this even necessary?  Come on.  This should be built into ts:restart.
+      task :thinking_sphinx_restart => [:environment] do
+        Rake::Task['ts:stop'].invoke rescue nil
+        Rake::Task['ts:index'].invoke
+        Rake::Task['ts:start'].invoke
+      end
+    
+      task :bounce_passenger do
+        puts "restarting Passenger web server"
+        Dir.chdir(RAILS_ROOT)
+        system("touch tmp/restart.txt")    
+      end
+    
+      task :clear_asset_cache => [:environment] do
+        STDERR.puts "Expiring cached Assets for domains [#{AssetCacheSweeper.domains.join(", ")}]"
+        AssetCacheSweeper.expire
+      end
+    
+      task :post_setup => [ :create_rails_directories, :setup_postgres_for_thinking_sphinx ]
+      task :post_deploy => [ 'db:migrate', 'ts:config', :thinking_sphinx_restart, :bounce_passenger, :clear_asset_cache ]
+    end
+</code>
 
 ### Future Directions ###
 
@@ -387,4 +598,5 @@ to see what we have in mind for the near future.
 
  - Rick Bradley (rick@rickbradley.com, github:rick)
  - Jeremy Holland (jeremy@jeremypholland.com, github:therubyneck): feature/bugfix contributions
-
+ - Kevin Barnes (@vinbarnes), Yossef Mendellsohn (cardioid) for design help and proofreading
+ - Cristi Balan (evilchelu) for feedback and proofreading

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.6.2

data/bin/wd_role

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby 
+require 'whiskey_disk/helpers'
+
+# simple command-line script to detect whether this deployment target
+# is in a specified whiskey_disk role.  sets exit status appropriately
+#
+# useful for conditionalizing shell scripting based on roles.
+
+role = ARGV.shift
+exit(1) unless role?(role)
+
+__END__
+
+( this example session presumes you `gem install rockhands` first... )
+
+$ export WD_ROLES='app:db'
+$ wd_role web && rock || shocker
+     .-.     
+   .-.U|     
+   |U| | .-. 
+   | | |_|U| 
+   | | | | | 
+  /|     ` |
+ | |       | 
+ |         | 
+  \        / 
+  |       |  
+  |       |  
+             
+$ wd_role app && rock || shocker
+   .-.       
+   |U|       
+   | |   .-. 
+   | |-._|U| 
+   | | | | | 
+  /|     ` | 
+ | |       | 
+ |         | 
+          / 
+  |       |  
+  |       |  
+

data/examples/deploy-multiple-remotes.yml

@@ -5,6 +5,18 @@ multi:
   deploy_to: "/tmp/test-deployment/"
   repository: "git@git.ogtastic.com:whiskey_disk.git"
   branch: "develop"
+roles:
+  domain:
+  - name: "ogc@hoenir.websages.com"
+    roles:
+    - web
+    - app
+  - name: "ogc@nerthus.websages.com"
+    roles: db 
+  deploy_to: "/tmp/test-deployment/"
+  repository: "git@git.ogtastic.com:whiskey_disk.git"
+  branch: "feature/support-domain-roles"
+  post_deploy_script: "/tmp/role-checker.sh"
 badmulti:
   domain:
   - "ogc@hoenir.websages.com"

data/lib/whiskey_disk.rb

@@ -109,11 +109,16 @@ class WhiskeyDisk
       (staleness_checks_enabled? and check_staleness?) ? apply_staleness_check(join_commands) : join_commands
     end
     
+    def encode_roles(roles)
+      return '' unless roles and !roles.empty?
+      "export WD_ROLES='#{roles.join(':')}'; "
+    end
+    
     def run(cmd)
       needs(:domain)
       self[:domain].each do |domain|
-        status = system('ssh', '-v', domain, "set -x; " + cmd)
-        record_result(domain, status)
+        status = system('ssh', '-v', domain[:name], "set -x; " + encode_roles(domain[:roles]) + cmd)
+        record_result(domain[:name], status)
       end
     end
     

data/lib/whiskey_disk/config.rb

@@ -103,20 +103,37 @@ class WhiskeyDisk
         override_project_name!(data)
         { project_name => data }
       end
+
+      def compact_list(list)
+        [ list ].flatten.delete_if { |d| d.nil? or d == '' }
+      end
       
       def normalize_domain(data)
+        compacted = compact_list(data)
+        return nil if compacted.empty?
+        
+        compacted.collect do |d|
+          if d.respond_to?(:keys)
+            row = { :name => (d['name'] || d[:name]) }
+            roles = compact_list(d['roles'] || d[:roles])
+            row[:roles] = roles unless roles.empty?
+            row
+          else
+            { :name => d }
+          end
+        end
+      end
+      
+      def normalize_domains(data)
         data.each_pair do |project, project_data|
           project_data.each_pair do |target, target_data|
-            if target_data['domain']
-              cleaned = [ target_data['domain'] ].flatten.delete_if { |m| m.nil? or m == '' }
-              target_data['domain'] = (cleaned.empty? ? nil : cleaned)
-            end
+            target_data['domain'] = normalize_domain(target_data['domain']) if target_data['domain']
           end
         end
       end
 
       def normalize_data(data)
-        normalize_domain(add_project_scoping(add_environment_scoping(data.clone)))
+        normalize_domains(add_project_scoping(add_environment_scoping(data.clone)))
       end
 
       def load_data

data/lib/whiskey_disk/helpers.rb

@@ -0,0 +1,6 @@
+
+# is the current deployment domain in the specified role?
+def role?(role)
+  return false unless ENV['WD_ROLES'] and ENV['WD_ROLES'] != ''
+  ENV['WD_ROLES'].split(':').include?(role.to_s)
+end

data/spec/wd_role_command_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+def run_command
+  eval File.read(File.join(File.dirname(__FILE__), *%w[.. bin wd_role]))
+end
+
+describe 'wd role command' do
+  before do
+    ENV['WD_ROLES'] = nil
+  end
+  
+  describe 'when no command-line arguments are specified' do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = []
+    end  
+    
+    it 'should fail' do
+      lambda { run_command }.should.raise(SystemExit)
+    end
+  end
+  
+  describe "when a role is specified on the command-line" do
+    before do
+      Object.send(:remove_const, :ARGV)
+      ARGV = ['app']
+    end  
+
+    it 'should fail when no WD_ROLES environment setting is present' do
+      ENV['WD_ROLES'] = nil
+      lambda { run_command }.should.raise(SystemExit)
+    end
+    
+    it 'should fail when an empty WD_ROLES environment setting is present' do
+      ENV['WD_ROLES'] = ''
+      lambda { run_command }.should.raise(SystemExit)
+    end
+    
+    it 'should fail when the WD_ROLES environment setting does not contain that role' do
+      ENV['WD_ROLES'] = 'web:nonapp:db'
+      lambda { run_command }.should.raise(SystemExit)
+    end
+    
+    it 'should succeed when the WD_ROLES environment setting contains that role' do
+      ENV['WD_ROLES'] = 'web:app:db'
+      lambda { run_command }.should.not.raise
+    end    
+  end
+end

data/spec/whiskey_disk/config_spec.rb

@@ -210,66 +210,139 @@ describe WhiskeyDisk::Config do
       before do
         write_config_file(
           'foo' => { 
-            'bar' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com', '' ]}, 
-            'baz' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
             'xyz' => { 'repository' => 'x' },
+            'eee' => { 'repository' => 'x', 'domain' => '' },
             'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
-            'eee' => { 'repository' => 'x', 'domain' => '' }
+            'baz' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
+            'bar' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com', '' ]},
+            'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
+            'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},            
+            'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
+                                                          { 'name' => 'baz@domain.com', 'roles' => '' },
+                                                          { 'name' => 'aok@domain.com', 'roles' => [] } ]},
+            'rol' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },            
+                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
+            'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
+                                                          nil, '', [], 'foo@bar.example.com',      
+                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
           },
+
           'zyx' => {
-            'def' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com', '' ]}, 
-            'hij' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
             'xyz' => { 'repository' => 'x' },
+            'eee' => { 'repository' => 'x', 'domain' => '' },
             'abc' => { 'repository' => 'x', 'domain' => 'what@example.com' },
-            'eee' => { 'repository' => 'x', 'domain' => '' }
+            'hij' => { 'repository' => 'x', 'domain' => [ 'bar@example.com', 'baz@domain.com' ]},
+            'def' => { 'repository' => 'x', 'domain' => [ 'user@example.com', nil, 'foo@domain.com', '' ]},
+            'hsh' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, { 'name' => 'baz@domain.com' } ]},
+            'mix' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com' }, 'baz@domain.com' ]},
+            'erl' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => nil }, 
+                                                          { 'name' => 'baz@domain.com', 'roles' => '' },
+                                                          { 'name' => 'aok@domain.com', 'roles' => [] } ]},
+            'rol' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },         
+                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
+            'wow' => { 'repository' => 'x', 'domain' => [ { 'name' => 'bar@example.com', 'roles' => [ 'web', 'db' ] }, 
+                                                          { 'name' => 'baz@domain.com', 'roles' => [ 'db' ] },   
+                                                          nil, '', [], 'foo@bar.example.com',      
+                                                          { 'name' => 'aok@domain.com', 'roles' => 'app' } ]},            
           }
         )
       end
     
-      describe 'and no domain has been specified' do
-        it 'should leave the domain as nil' do
-          WhiskeyDisk::Config.load_data['foo']['xyz']['domain'].should.be.nil     
-        end
-        
-        it 'should handle nil domains across all projects and targets' do
-          WhiskeyDisk::Config.load_data['zyx']['xyz']['domain'].should.be.nil     
-        end
+      it 'should leave the domain as nil when no domain is specified' do
+        WhiskeyDisk::Config.load_data['foo']['xyz']['domain'].should.be.nil     
+      end
+      
+      it 'should handle nil domains across all projects and targets' do
+        WhiskeyDisk::Config.load_data['zyx']['xyz']['domain'].should.be.nil     
       end
     
-      describe 'and a single domain has been specified' do
-        it 'should return domain as nil if the specified domain was empty' do
-          WhiskeyDisk::Config.load_data['foo']['eee']['domain'].should.be.nil       
-        end
-        
-        it 'should handle empty specified domains across all projects and targets' do
-          WhiskeyDisk::Config.load_data['zyx']['eee']['domain'].should.be.nil                 
-        end
+      it 'should return domain as nil if a single empty domain was specified' do
+        WhiskeyDisk::Config.load_data['foo']['eee']['domain'].should.be.nil       
+      end
       
-        it 'should return domain as a single list of the specified domain if the specified domain was not empty' do
-          WhiskeyDisk::Config.load_data['foo']['abc']['domain'].should == ['what@example.com']
-        end
+      it 'should handle single empty specified domains across all projects and targets' do
+        WhiskeyDisk::Config.load_data['zyx']['eee']['domain'].should.be.nil                 
+      end
+      
+      it 'should return domain as a single element list with a name if a single non-empty domain was specified' do
+        WhiskeyDisk::Config.load_data['foo']['abc']['domain'].should == [ { :name => 'what@example.com' } ]
+      end
+  
+      it 'should handle single specified domains across all projects and targets' do
+        WhiskeyDisk::Config.load_data['zyx']['abc']['domain'].should == [ { :name => 'what@example.com' } ]
+      end
     
-        it 'should handle single specified domains across all projects and targets' do
-          WhiskeyDisk::Config.load_data['zyx']['abc']['domain'].should == ['what@example.com']
-        end
+      it 'should return the list of domain name hashes when a list of domains is specified' do
+        WhiskeyDisk::Config.load_data['foo']['baz']['domain'].should == [ 
+          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' } 
+        ]
       end
     
-      describe 'and a list of domains was specified' do
-        it 'should return the list of domains' do
-          WhiskeyDisk::Config.load_data['foo']['baz']['domain'].should == [ 'bar@example.com', 'baz@domain.com' ]
-        end
+      it 'should handle lists of domains across all projects and targets' do
+        WhiskeyDisk::Config.load_data['zyx']['hij']['domain'].should == [ 
+          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' }
+         ]
+      end
       
-        it 'should handle lists of domains across all projects and targets' do
-          WhiskeyDisk::Config.load_data['zyx']['hij']['domain'].should == [ 'bar@example.com', 'baz@domain.com' ]
-        end
+      it 'should remove any blank or nil domains from a simple list of domains' do
+        WhiskeyDisk::Config.load_data['foo']['bar']['domain'].should == [
+          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }
+         ]
+      end
+  
+      it 'should handle cleaning up blanks and nils across all projects and targets' do
+        WhiskeyDisk::Config.load_data['zyx']['def']['domain'].should == [
+          { :name => 'user@example.com' }, { :name => 'foo@domain.com' }
+         ]
+      end
       
-        it 'should remove any blank or nil domains from the list' do
-          WhiskeyDisk::Config.load_data['foo']['bar']['domain'].should == ['user@example.com', 'foo@domain.com' ]
-        end
-    
-        it 'should handle cleaning up blanks and nils across all projects and targets' do
-          WhiskeyDisk::Config.load_data['zyx']['def']['domain'].should == ['user@example.com', 'foo@domain.com' ]
-        end
+      it 'should not include roles when only nil, blank or empty roles lists are specified' do
+        WhiskeyDisk::Config.load_data['foo']['erl']['domain'].should == [
+          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' }, { :name => 'aok@domain.com' }
+         ]        
+      end
+
+      it 'should handle filtering empty roles across all projects and targets ' do
+        WhiskeyDisk::Config.load_data['zyx']['erl']['domain'].should == [
+          { :name => 'bar@example.com' }, { :name => 'baz@domain.com' }, { :name => 'aok@domain.com' }
+         ]        
+      end
+      
+      it 'should include and normalize roles when specified as strings or lists' do
+        WhiskeyDisk::Config.load_data['foo']['rol']['domain'].should == [
+          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
+          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
+          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
+         ]        
+      end
+
+      it 'should handle normalizing roles across all projects and targets ' do
+        WhiskeyDisk::Config.load_data['zyx']['rol']['domain'].should == [
+          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
+          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
+          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
+         ]        
+      end
+      
+      it 'should respect empty domains among role data' do
+        WhiskeyDisk::Config.load_data['foo']['wow']['domain'].should == [
+          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
+          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
+          { :name => 'foo@bar.example.com' },
+          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
+         ]                
+      end
+      
+      it 'should handle empty domain filtering among roles across all projects and targets' do
+        WhiskeyDisk::Config.load_data['zyx']['wow']['domain'].should == [
+          { :name => 'bar@example.com', :roles => [ 'web', 'db' ] }, 
+          { :name => 'baz@domain.com',  :roles => [ 'db' ] }, 
+          { :name => 'foo@bar.example.com' },
+          { :name => 'aok@domain.com',  :roles => [ 'app' ] }
+         ]        
       end
     end
   end
@@ -278,7 +351,7 @@ describe WhiskeyDisk::Config do
     before do
       ENV['to'] = @env = 'foo:staging'
 
-      @bare_data  = { 'repository' => 'git://foo/bar.git', 'domain' => ['ogc@ogtastic.com'] }
+      @bare_data  = { 'repository' => 'git://foo/bar.git', 'domain' => [ { :name => 'ogc@ogtastic.com' } ] }
       @env_data   = { 'staging' => @bare_data }
       @proj_data  = { 'foo' => @env_data }
     end

data/spec/whiskey_disk/helpers_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib', 'whiskey_disk', 'helpers'))
+
+describe '#role?' do
+  it 'should accept a role string' do
+    lambda { role?('web') }.should.not.raise(ArgumentError)
+  end
+  
+  it 'should require a role string' do
+    lambda { role? }.should.raise(ArgumentError)
+  end
+
+  it 'should return false if the WD_ROLES environment variable is unset' do
+    ENV['WD_ROLES'] = nil
+    role?(:web).should.be.false
+  end
+
+  it 'should return false if the WD_ROLES environment variable is empty' do
+    ENV['WD_ROLES'] = ''
+    role?(:web).should.be.false
+  end
+  
+  it 'should return true if the role, as a symbol is among the roles in the WD_ROLES env variable' do
+    ENV['WD_ROLES'] = 'db:web'
+    role?(:db).should.be.true
+  end
+  
+  it 'should return true if the role, as a string is among the roles in the WD_ROLES env variable' do
+    ENV['WD_ROLES'] = 'db:web'
+    role?('db').should.be.true
+  end
+  
+  it 'should return false if the role, as a symbol is not among the roles in the WD_ROLES env variable' do
+    ENV['WD_ROLES'] = 'db:web'
+    role?(:app).should.be.false
+  end
+  
+  it 'should return false if the role, as a string is not among the roles in the WD_ROLES env variable' do
+    ENV['WD_ROLES'] = 'db:web'
+    role?('app').should.be.false
+  end
+end
+

data/spec/whiskey_disk_spec.rb

@@ -7,7 +7,9 @@ require 'rake'
 class TestOrderedExecution < WhiskeyDisk
   class << self
     def commands
-      @commands
+      result = @commands
+      @commands = []
+      result
     end
     
     def system(*args)
@@ -57,12 +59,12 @@ describe 'WhiskeyDisk' do
     end
 
     it 'should return true if the configuration includes a non-empty domain setting' do
-      @parameters['domain'] = ['smeghost']
+      @parameters['domain'] = [ { :name => 'smeghost' } ]
       WhiskeyDisk.remote?.should == true
     end
     
     it 'should return true if the configuration includes a multiple domain settings' do
-      @parameters['domain'] = ['smeghost', 'faphost']
+      @parameters['domain'] = [ { :name => 'smeghost' }, { :name => 'faphost' } ]
       WhiskeyDisk.remote?.should == true
     end
   end
@@ -527,7 +529,7 @@ describe 'WhiskeyDisk' do
   describe 'flushing changes' do
     describe 'when running remotely' do
       before do
-        WhiskeyDisk.configuration = { 'domain' => 'www.domain.com', 'deploy_to' => '/path/to/main/repo' }
+        WhiskeyDisk.configuration = { 'domain' => [ { :name => 'www.domain.com' } ], 'deploy_to' => '/path/to/main/repo' }
         WhiskeyDisk.stub!(:bundle).and_return('command string')
         WhiskeyDisk.stub!(:run)
       end
@@ -783,7 +785,7 @@ describe 'WhiskeyDisk' do
     before do
       WhiskeyDisk.reset
       @domain = 'ogc@ogtastic.com'
-      WhiskeyDisk.configuration = { 'domain' => @domain }
+      WhiskeyDisk.configuration = { 'domain' => [ { :name => @domain } ] }
       WhiskeyDisk.stub!(:system)      
     end
     
@@ -800,14 +802,27 @@ describe 'WhiskeyDisk' do
       lambda { WhiskeyDisk.run('ls') }.should.raise
     end
 
-    it 'should pass the string to ssh with verbosity enabled' do
-      WhiskeyDisk.should.receive(:system).with('ssh', '-v', @domain, "set -x; ls")
-      WhiskeyDisk.run('ls')
+    describe 'and a single domain is specified' do
+      before do
+        @domain = 'ogc@ogtastic.com'
+        WhiskeyDisk.configuration = { 'domain' => [ { :name => @domain } ] }
+      end
+      
+      it 'should pass the string to ssh with verbosity enabled' do
+        WhiskeyDisk.should.receive(:system).with('ssh', '-v', @domain, "set -x; ls")
+        WhiskeyDisk.run('ls')
+      end
+      
+      it 'should include domain role settings when the domain has roles' do
+        WhiskeyDisk.configuration = { 'domain' => [ { :name => @domain, :roles => [ 'web', 'db' ] } ] }
+        WhiskeyDisk.should.receive(:system).with('ssh', '-v', @domain, "set -x; export WD_ROLES='web:db'; ls")
+        WhiskeyDisk.run('ls')        
+      end
     end
     
     describe 'and multiple domains are specified' do
       before do
-        @domains = [ 'ogc@ogtastic.com', 'foo@example.com' ]
+        @domains = [ { :name => 'ogc@ogtastic.com' }, { :name => 'foo@example.com' } ]
       end
             
       it 'should run the command via ssh on each domain in the order specified in the configuration file' do
@@ -819,6 +834,19 @@ describe 'WhiskeyDisk' do
         ]
       end
       
+      it 'should include role settings for each domain when available' do
+        @domains = [ 
+          { :name => 'ogc@ogtastic.com', :roles => [ 'db', 'web' ] }, 
+          { :name => 'foo@example.com', :roles => [ 'app' ] } 
+        ]
+        TestOrderedExecution.configuration = { 'domain' => @domains }
+        TestOrderedExecution.run('ls')
+        TestOrderedExecution.commands.should == [
+          "ssh -v ogc@ogtastic.com set -x; export WD_ROLES='db:web'; ls", 
+          "ssh -v foo@example.com set -x; export WD_ROLES='app'; ls"
+        ]
+      end
+      
       it 'should not fail if an ssh command fails' do
         WhiskeyDisk.configuration = { 'domain' => @domains }
         WhiskeyDisk.stub!(:system).with('ssh', '-v', 'ogc@ogtastic.com', 'set -x; ls').and_return(false)

data/whiskey_disk.gemspec

@@ -5,15 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{whiskey_disk}
-  s.version = "0.6.0"
+  s.version = "0.6.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rick Bradley"]
-  s.date = %q{2010-12-22}
-  s.default_executable = %q{wd}
+  s.date = %q{2010-12-23}
   s.description = %q{Opinionated gem for doing fast git-based server deployments.}
   s.email = %q{rick@rickbradley.com}
-  s.executables = ["wd"]
+  s.executables = ["wd_role", "wd"]
   s.extra_rdoc_files = [
     "README.markdown"
   ]
@@ -26,6 +25,7 @@ Gem::Specification.new do |s|
     "VERSION",
     "WHY.txt",
     "bin/wd",
+    "bin/wd_role",
     "examples/deploy-local.yml",
     "examples/deploy-multiple-remotes.yml",
     "examples/deploy-staging.yml",
@@ -35,13 +35,16 @@ Gem::Specification.new do |s|
     "install.rb",
     "lib/whiskey_disk.rb",
     "lib/whiskey_disk/config.rb",
+    "lib/whiskey_disk/helpers.rb",
     "lib/whiskey_disk/rake.rb",
     "spec/.bacon",
     "spec/init_spec.rb",
     "spec/install_spec.rb",
     "spec/spec_helper.rb",
     "spec/wd_command_spec.rb",
+    "spec/wd_role_command_spec.rb",
     "spec/whiskey_disk/config_spec.rb",
+    "spec/whiskey_disk/helpers_spec.rb",
     "spec/whiskey_disk/rake_spec.rb",
     "spec/whiskey_disk_spec.rb",
     "tasks/deploy.rake",
@@ -56,7 +59,9 @@ Gem::Specification.new do |s|
     "spec/install_spec.rb",
     "spec/spec_helper.rb",
     "spec/wd_command_spec.rb",
+    "spec/wd_role_command_spec.rb",
     "spec/whiskey_disk/config_spec.rb",
+    "spec/whiskey_disk/helpers_spec.rb",
     "spec/whiskey_disk/rake_spec.rb",
     "spec/whiskey_disk_spec.rb"
   ]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: whiskey_disk
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: false
   segments: 
   - 0
   - 6
-  - 0
-  version: 0.6.0
+  - 2
+  version: 0.6.2
 platform: ruby
 authors: 
 - Rick Bradley
@@ -15,8 +15,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-22 00:00:00 -05:00
-default_executable: wd
+date: 2010-12-23 00:00:00 -05:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -35,6 +35,7 @@ dependencies:
 description: Opinionated gem for doing fast git-based server deployments.
 email: rick@rickbradley.com
 executables: 
+- wd_role
 - wd
 extensions: []
 
@@ -49,6 +50,7 @@ files:
 - VERSION
 - WHY.txt
 - bin/wd
+- bin/wd_role
 - examples/deploy-local.yml
 - examples/deploy-multiple-remotes.yml
 - examples/deploy-staging.yml
@@ -58,13 +60,16 @@ files:
 - install.rb
 - lib/whiskey_disk.rb
 - lib/whiskey_disk/config.rb
+- lib/whiskey_disk/helpers.rb
 - lib/whiskey_disk/rake.rb
 - spec/.bacon
 - spec/init_spec.rb
 - spec/install_spec.rb
 - spec/spec_helper.rb
 - spec/wd_command_spec.rb
+- spec/wd_role_command_spec.rb
 - spec/whiskey_disk/config_spec.rb
+- spec/whiskey_disk/helpers_spec.rb
 - spec/whiskey_disk/rake_spec.rb
 - spec/whiskey_disk_spec.rb
 - tasks/deploy.rake
@@ -108,6 +113,8 @@ test_files:
 - spec/install_spec.rb
 - spec/spec_helper.rb
 - spec/wd_command_spec.rb
+- spec/wd_role_command_spec.rb
 - spec/whiskey_disk/config_spec.rb
+- spec/whiskey_disk/helpers_spec.rb
 - spec/whiskey_disk/rake_spec.rb
 - spec/whiskey_disk_spec.rb