fairchild-poolparty 1.1.5 → 1.2.12

data/History.txt

@@ -1,3 +1,6 @@
+== 1.1 2009-03-03
+  * Release 1.1 with new stable core
+
 == 1.0.0 2009-1-20
 	* Released 1.0 at CitrusByte
 	* Party

data/README.txt

@@ -13,13 +13,6 @@ pool :cloud do
  end
 end
 
-== FEATURES/PROBLEMS:
-
-* Written in Ruby and Erlang
-* Written from the ground up to be extensible with plugins
-* Easy git-style commands to communicate with your clouds
-* Much much more
-
 == SYNOPSIS:
 
 PoolParty is written with the intention of being as application-agnostic as possible. It installs only the basic 
@@ -28,6 +21,16 @@ required software to glue the cloud together on the instances as listed below.
 PoolParty is easily configuration. In fact, it makes little assumptions about your development environment and allows 
 several options on how to begin configuring the cloud.
 
+== WHAT NEXT:
+* PoolParty::Resources - learn how to use resources in your <tt>clouds.rb</tt>
+
+== FEATURES/PROBLEMS:
+
+* Written in Ruby and Erlang
+* Written from the ground up to be extensible with plugins
+* Easy git-style commands to communicate with your clouds
+* Much much more
+
 == REQUIREMENTS:
 
 Ruby
@@ -41,7 +44,7 @@ sudo gem install auser-poolparty
 
 (The MIT License)
 
-Copyright (c) 2008 Ari Lerner
+Copyright (c) 2008 Ari Lerner, CloudTeam
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -60,4 +63,5 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -51,7 +51,6 @@ end
 
 task :release => [:update_timestamp]
 
-
 # Generate documentation
 Rake::RDocTask.new do |rd|
   rd.main = "Readme.txt"

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 5
+:minor: 2
+:patch: 12
 :major: 1
-:minor: 1

data/bin/cloud

@@ -1,51 +1,48 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
-require "poolpartycl"
-
-# name = ARGV.select {|arg| arg if Binary.available_binaries_for("cloud").include?(arg) }.first
-name = ARGV.shift if Binary.available_binaries_for("cloud").include?(ARGV.first)
-# If the options include -h and they don't include a valid command, then we can just pass the 
-# original options back, but if they do contain a binary, we don't want -h getting through to 
-# these options, so we'll strip it if it's included
-DUP_ARG = ARGV.dup
-new_args = DUP_ARG.map {|arg| DUP_ARG.delete(arg) unless help_array.include?(arg) || Binary.available_binaries_for("cloud").include?(arg) }
-new_args = new_args.reject {|arg| Binary.available_binaries_for("cloud").include?(arg) }.empty? ? ARGV : (name ? (help_array.each {|arg| DUP_ARG.delete(arg)}; DUP_ARG) : DUP_ARG)
-
-# Let's make sure if no command is passed in that we show the help message
-new_args.push("-h") unless name
-
-# Binary.list_binaries_for("cloud")
-extra_help_string = <<-EOE
-
-  Cloud commands
-    cloud start       starts a single instance in your cloud.
-    cloud bootstrap   bootstraps an instance or multiple instances
-    cloud configure   configures an instance or multiple instances
-    cloud provision   combines bootstrap and configures an instance or multiple instances
-    cloud expand      expands the cloud by a single instance
-    cloud contract    contracts the cloud by a single instance
-    cloud describe    show the configuration of the current clouds.rb configuration file
-    cloud list        show a list of the current instances on the cloud
-    cloud ssh         ssh into an instance of the cloud
-    cloud terminate   terminate the cloud
+# require "poolpartycl"
+require 'git-style-binary/command'
+
+GitStyleBinary.primary do
+  @theme = :short
+  
+  version "PoolParty cloud command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string} COMMAND [ARGS]
+
+The cloud subcommands commands are:
+  \#{GitStyleBinary.pretty_known_subcommands(:short).join("  ")}
+
+See 'cloud help COMMAND' for more information on a specific command.
+EOS
+  
+  opt :debug, "Debug the output", :type => :boolean, :default => false
+  opt :spec, "Set the pool spec file", :type => String
+  opt :testing, "Set testing mode on", :type => :boolean, :default => false
+  opt :cloud_name, "Name of the working cloud", :type => String, :default => nil
+
+  before_run do |command|
+    # Setup testing/debugging
+    $TESTING = true if command[:testing]
+    $DEBUGGING = true if command[:debug]
     
-EOE
-
-o = PoolParty::Optioner.new(new_args, {
-  :extra_help => extra_help_string,
-  :abstract => true}) do |opts, optioner|  
-  opts.on('-n cloudname', '--name name', 'Address this cloud')    { |c| optioner.cloudname c }
-end
-
-program_name = "#{File.basename($0)}-#{name}"
-program_location = File.join(Binary.binary_directory, program_name)
-
-command_line = "#{program_location}"
+    @loaded_pool = load_pool( command[:spec] ? command[:spec] : Binary.get_existing_spec_location)
+    @loaded_clouds = command[:cloud_name] ? [clouds[command[:cloud_name].to_sym]] : clouds.map {|k,c| c }
+    @loaded_clouds.each do |cld|
+      cld.verbose command[:verbose]
+      cld.debugging = command[:debug]
+    end
+  end
+  
+  run do |command|
+    subcommands = GitStyleBinary.list_subcommands
+    
+    puts "Usage: cloud COMMAND [ARGS]
+    
+    The cloud subcommands commands are:
+      #{subcommands}
 
-# Run it from the command-line first
-if Binary.available_binaries_for("cloud").include?(name)
-  system command_line, *new_args
-else
-  puts "Unknown poolparty binary: #{name}"
+    See 'cloud help COMMAND' for more information on a specific command."
+  end
 end

data/bin/cloud-bootstrap

@@ -1,31 +1,41 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
-require "poolparty/provision/boot_strapper"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string}
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  opts.on('-n cloudname', '--name name', 'Start cloud by this name')    { |c| optioner.cloudname c }
-  opts.on('-i num', '--num i', 'Instance number')    { |i| optioner.inst_num i.to_i }
-end
+  Bootstrap a cloud instance
+EOS
 
-o.loaded_clouds.each do |cld|
-  # If an IP or DNS name is given, bootstrap that node, otherwise, bootstrap all running nodes.
-  # ::FileUtils.rm_rf "#{Default.tmp_path}/" unless o.testing?
+  short_desc "Bootstrap a cloud instance"
   
-  nodes = !o.unflagged_args.empty? ?  o.unflagged_args : cld.nodes(:status => "running").collect {|i| i.ip }.sort.compact
-  if nodes.empty?
-    puts "No nodes to bootstrap"
-  else
-    if o.inst_num?
-      vputs "\nBootStrapping: #{nodes[o.inst_num]}\n--------------------"
-      ::PoolParty::Provision::BootStrapper.new nodes[o.inst_num], :cloud => cld
-    else
-      nodes.each do |address|
-        vputs "\nBootStrapping: #{address}\n--------------------"      
-        ::PoolParty::Provision::BootStrapper.new address, :cloud => cld
-      end
+  opt :inst_num, "The number of the instance to run bootstrap on", :type => :int
+
+  run do |command|    
+    
+    @loaded_clouds.each do |cld|
+
+        # If an IP or DNS name is given, bootstrap that node, otherwise, bootstrap all running nodes.
+        if cld.nodes(:status => "running").empty?
+          puts "No nodes to bootstrap"
+        else
+          if command[:inst_num]
+            vputs "\nBootStrapping: #{nodes[o.inst_num]}\n--------------------"
+            ::PoolParty::Provision::BootStrapper.new cld.nodes(:status => "running")[ command[:inst_num] ], :cloud => cld
+          else
+            cld.nodes(:status => "running").each do |address|
+              cld.vputs "\nBootStrapping: #{address[:ip]}\n--------------------"      
+              ::PoolParty::Provision::BootStrapper.new address[:ip], :cloud => cld
+            end
+          end
+        end
+      
     end
+    
   end
-end
-
+end

data/bin/cloud-configure

@@ -1,43 +1,42 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
-extra_help_string = <<-EOE
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string}
 
-  Cloud configure
-  
-    Cloud configure will repackage the deployment and send it off to a 
-    remote instance from within the cloud. It then will reconfigure
-    itself and alert the rest of the cloud
-    
-EOE
+  Configure a cloud instance
+EOS
 
-o = PoolParty::Optioner.new(ARGV, {:extra_help => extra_help_string}) do |opts, optioner|
-  opts.on('-n cloudname', '--name name', 'Start cloud by this name')    { |c| optioner.cloudname c }
-  opts.on('-i num', '--num i', 'Instance number')    { |i| optioner.inst_num i.to_i }
-end
-
-o.loaded_clouds.each do |cld|
-  # If an IP or DNS name is given, bootstrap that node, otherwise, bootstrap all running nodes.
-  # ::FileUtils.rm_rf "#{Default.tmp_path}/" unless o.testing?
+  short_desc "Configure a cloud instance"
   
-  if cld.nodes(:status => "running").size < 1
-    puts header("No instances running")
-  else
-    nodes = !o.unflagged_args.empty? ?  o.unflagged_args : cld.nodes(:status => "running").collect {|i| i.ip }.sort.compact
-    if nodes.empty?
-      puts "No nodes to configure"
-    else
-      if o.inst_num?
-        vputs "Configuring #{nodes[o.inst_num]}"
-        ::PoolParty::Provision::DrConfigure.new( nodes[o.inst_num], :cloud => cld )
-      else
-        nodes.each do |address|
-          puts "Configuring: #{address}"
-          ::PoolParty::Provision::DrConfigure.new( address, :cloud => cld )
+  opt :inst_num, "The number of the instance to run bootstrap on", :type => :int
+
+  run do |command|    
+    
+    @loaded_clouds.each do |cld|
+        
+        # If an IP or DNS name is given, bootstrap that node, otherwise, bootstrap all running nodes.
+        if cld.nodes(:status => "running").empty?
+          puts "No nodes to bootstrap"
+        else
+          if command[:inst_num]
+            vputs "\nConfiguring: #{cld.nodes[o.inst_num]}\n--------------------"
+            address = cld.nodes(:status => "running")[ command[:inst_num] ]
+            ::PoolParty::Provision::DrConfigure.new( address[:ip], :cloud => cld )
+          else
+            cld.nodes(:status => "running").each do |address|
+              cld.vputs "\nConfiguring: #{address[:ip]}\n--------------------"      
+              ::PoolParty::Provision::DrConfigure.new address[:ip], :cloud => cld
+            end
+          end
         end
-      end
+      
     end
+    
   end
-end
-
+end

data/bin/cloud-console

@@ -1,12 +1,34 @@
 #!/usr/bin/env ruby
-# File: script/console
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+require "poolparty"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
-libs =  " -r irb/completion"
-# Perhaps use a console_lib to store any extra methods I may want available in the cosole
-# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
-libs <<  " -r #{File.dirname(__FILE__) + '/../lib/poolparty.rb'}"
-libs <<  " -r #{File.dirname(__FILE__) + '/../lib/poolpartycl.rb'}"
-puts "Loading PoolParty console..."
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string}
 
-exec "#{irb} #{libs} --simple-prompt"
+  Open an irb session with the clouds.rb loaded
+EOS
+
+  short_desc "Open an irb session with clouds.rb loaded"
+  
+  opt :inst_num, "The number of the instance to run bootstrap on", :type => :int
+
+  run do |command|    
+    
+    irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+    libs =  " -r irb/completion"
+    # Perhaps use a console_lib to store any extra methods I may want available in the cosole
+    # libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+    libs <<  " -r #{File.dirname(__FILE__) + '/../lib/poolparty.rb'}"
+    libs <<  " -r #{File.dirname(__FILE__) + '/../lib/poolpartycl.rb'}"
+    libs <<  " -r #{$pool_specfile}" if $pool_specfile
+    puts "Loading PoolParty console..."
+
+    exec "#{irb} #{libs} --simple-prompt"
+    
+  end
+end

data/bin/cloud-contract

@@ -1,17 +1,33 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
-require "poolpartycl"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
-end
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string}
 
-o.loaded_clouds.each do |cld|  
-  puts header("Contracting cloud #{cld.name}")
-  puts "#{cld.nodes(:status => "running").size} running instances (#{cld.minimum_instances} minimum instances)"
-  puts testing ? "Not contracting (test mode)" : "Contracting the cloud if possible"
+  contracts the cloud by a single instance
+EOS
 
-  last_instance_id = cld.nodes(:status => "running").last[:instance_id]
-  cld.remote_base.terminate_instance! cld.options.merge(:instance_id => last_instance_id)
+  short_desc "contracts the cloud by a single instance"
+
+  run do |command|    
+    @loaded_clouds.each do |cld|
+
+      puts "Contracting cloud #{cld.name}"
+      puts "#{cld.nodes(:status => "running").size} running instances (#{cld.minimum_instances} minimum instances)"
+      puts testing ? "Not contracting (test mode)" : "Contracting the cloud if possible"
+      
+      if cld.minimum_instances < cld.nodes(:status => "running").size
+        last_instance_id = cld.nodes(:status => "running").last[:instance_id]
+        cld.remote_base.terminate_instance! cld.dsl_options.merge(:instance_id => last_instance_id)
+      else
+        puts "The cloud #{cld.name} is running minimum instances (#{cld.nodes(:status => "running").size})"
+      end
+
+    end    
+  end
 end

data/bin/cloud-expand

@@ -1,26 +1,39 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
-require "poolpartycl"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  opts.on('-n name', '--name name', 'Expand the cloud on this name')    { |c| optioner.cloudname c }
-end
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string}
 
-o.loaded_clouds.each do |cld|
+  expands the cloud by a single instance
+EOS
 
-  vputs header("Expanding cloud #{cld.name}")
-  vputs "#{cld.nodes(:status => "running").size} running instances of #{cld.maximum_instances} possible instances"
-  vputs testing ? "Not expanding (test mode)" : "Expanding the cloud"
-  
-  cld.launch_instance! do |node|
-    ::PoolParty::Provision::BootStrapper.new(node.ip, :cloud => cld)
-    ::PoolParty::Provision::DrConfigure.new(node.ip,  :cloud => cld)
-    
-    puts <<-EOM
-      Your cloud has expanded. The new ip is #{node.ip}
-    EOM
+  short_desc "expands the cloud by a single instance"
+
+  run do |command|    
+    @loaded_clouds.each do |cld|
+
+        vputs "Expanding cloud #{cld.name}"
+        vputs "#{cld.nodes(:status => "running").size} running instances of #{cld.maximum_instances} possible instances"
+        vputs testing ? "Not expanding (test mode)" : "Expanding the cloud"
+        
+        if cld.maximum_instances > cld.nodes(:status => "running").size
+          cld.launch_instance!(:cloud_name => cld.name) do |node|
+            ::PoolParty::Provision::BootStrapper.new(node.ip, :cloud => cld)
+            ::PoolParty::Provision::DrConfigure.new(node.ip,  :cloud => cld)
+
+            puts <<-EOM
+              Your cloud has expanded. The new ip is #{node.ip}
+            EOM
+          end          
+        else
+          puts "The cloud #{cld.name} has too many instances already (#{cld.nodes(:status => "running").size})"
+        end
+
+    end    
   end
-  
-  
 end

data/bin/cloud-list

@@ -1,21 +1,49 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  opts.on('-f [remote|local]', '--from [remote|local]', 'Remote or local (default: local)')    { |o| optioner.location o }
-  opts.on('-r', '--remote', 'Remote listing')    { optioner.location "remote" }
-  opts.on('-l', '--local', 'Local listing')    { optioner.location "local" }
-  opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
-end
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string}
 
-o.loaded_clouds.each do |cld|
-  puts header("Listing cloud #{cld.name}")
-  puts subheader("Active instances")
-  puts cld.nodes(:status => "running").map{|a| "#{a[:instance_id]}\t#{a[:ip]}" }.join("\n")
-    
-  if cld.nodes(:status => "pending").size > 0
-    puts subheader("Pending instances")
-    puts cld.nodes(:status => "pending").map{|a| "#{a[:instance_id]}\t#{a[:ip]}" }.join("\n")
+  List the clouds and their nodes
+  e.g. show a list of the current instances on the cloud
+EOS
+
+  opt :instance_id, "Describe a specific instance", :type => String, :default => nil
+  opt :short, "show a short description rather than a long one", :default => false
+
+  short_desc "show a list of the current instances on the clouds"
+
+  run do |command|
+    @loaded_clouds.each do |cld|
+      if command[:instance_id]
+        require 'pp'
+        pp result = cld.nodes(:instance_id=>command[:instance_id])
+      else
+        if command[:short]
+          %w{running pending}.each do |status|
+            nodes = cld.nodes(:status => status)
+            if nodes.size > 0
+              puts nodes.map{|a| 
+                "%-15s [%s]: #{a[:instance_id] || a[:id]}\t#{a[:ip] ||a[:public_ip] }" % [cld.name, status] 
+              }.join("\n")
+            end
+          end
+        else
+          puts "Listing cloud #{cld.name}"
+          puts "Active instances"
+          puts cld.nodes(:status => "running").map{|a| "#{a[:instance_id] || a[:id]}\t#{a[:ip] ||a[:public_ip] }" }.join("\n")
+          
+          if cld.nodes(:status => "pending").size > 0
+            puts "Pending instances"
+            puts cld.nodes(:status => "pending").map{|a| "#{a[:instance_id] || a[:id]}\t#{a[:ip] ||a[:public_ip] }" }.join("\n")
+          end
+        end
+      end
+    end
   end
 end

data/bin/cloud-osxcopy

@@ -1,17 +1,27 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
-require "poolpartycl"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  opts.on('-n name', '--name name', 'Copy the master ip for this cloud')    { |c| optioner.cloudname c }
-end
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string} COMMAND [ARGS]
 
-o.loaded_clouds.each do |cld|
-  
-  node = cld.nodes(:status => "running").first
-  ip = node.ip
-  puts "ip: #{ip}"
-  Kernel.system "echo #{ip} | pbcopy"
-  
+  Copy the IP address of a node to the Mac OS X clipboard
+EOS
+
+  short_desc "Copy the IP address of a node to the Mac OS X clipboard"
+
+  run do |command|    
+    @loaded_clouds.each do |cld|
+      
+      node = cld.nodes(:status => "running").first
+      ip = node.ip
+      puts "ip: #{ip}"
+      Kernel.system "echo #{ip} | pbcopy"
+      
+    end    
+  end
 end

data/bin/cloud-provision

@@ -1,30 +1,45 @@
 #!/usr/bin/env ruby
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+$:.unshift(File.dirname(__FILE__) + "/../lib")
 require "poolparty"
-require "poolparty/provision/boot_strapper"
+# require "poolpartycl"
+require 'git-style-binary/command'
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  opts.on('-n cloudname', '--name name', 'Start cloud by this name')    { |c| optioner.cloudname c }
-  opts.on('-i num', '--num i', 'Instance number')    { |i| optioner.inst_num i.to_i }
-end
+GitStyleBinary.command do  
+  version "PoolParty #{$0} command"  
+  banner <<-EOS
+Usage: #{$0} #{all_options_string}
 
-o.loaded_clouds.each do |cld|
-  # If an IP or DNS name is given, bootstrap that node, otherwise, bootstrap all running nodes.
-  nodes = !o.unflagged_args.empty? ?  o.unflagged_args : cld.nodes(:status => "running").collect {|i|i.ip }.compact
-  if nodes.empty?
-    puts "No nodes to bootstrap"
-  else
-    if o.inst_num?
-      ::PoolParty::Provision::BootStrapper.new( nodes[o.inst_num], :full_keypair_path => cld.keypair.full_filepath, :cloud => cld )
-      ::PoolParty::Provision::DrConfigure.new( nodes[o.inst_num], :full_keypair_path => cld.keypair.full_filepath,  :cloud => cld )
-    else
-      nodes.each do |address|
-        puts "bootstrapping: #{address}"
-        ::PoolParty::Provision::BootStrapper.new( address, :full_keypair_path => cld.keypair.full_filepath, :cloud => cld )
-        ::PoolParty::Provision::DrConfigure.new( address, :full_keypair_path => cld.keypair.full_filepath, 
-                                                          :cloud => cld )
+  combines bootstrap and configures an instance or multiple instances
+EOS
+
+  short_desc "combines bootstrap and configures an instance or multiple instances"
+
+  run do |command|
+    @loaded_clouds.each do |cld|
+      
+      # If an IP or DNS name is given, bootstrap that node, otherwise, bootstrap all running nodes.
+      if cld.nodes.empty?
+        puts "No nodes to provision"
+      else
+        # Call before_provision callback on cloud
+        cld.call_before_provision_callbacks
+        
+        if command[:inst_num]
+          vputs "\nConfiguring: #{nodes[o.inst_num]}\n--------------------"
+          address = cld.nodes[ command[:inst_num] ]
+          ::PoolParty::Provision::BootStrapper.new( address[:ip], :cloud => cld )
+          ::PoolParty::Provision::DrConfigure.new( address[:ip], :cloud => cld )
+          cld.call_after_provision_callbacks
+        else
+          cld.nodes(:status => "running").each do |address|
+            cld.vputs "\nConfiguring: #{address[:ip]}\n--------------------"      
+            ::PoolParty::Provision::BootStrapper.new( address[:ip], :cloud => cld )
+            ::PoolParty::Provision::DrConfigure.new( address[:ip], :cloud => cld )
+            cld.call_after_provision_callbacks
+          end
+        end
       end
-    end
+      
+    end    
   end
-end
-
+end