fairchild-poolparty 1.1.3

data/bin/cloud-terminate

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'Terminate the cloud of this name')    { |c| optioner.cloudname c }
+end
+
+o.loaded_clouds.each do |cloud|
+  
+  with_cloud(cloud) do
+    
+    list_of_running_instances.each do |inst|
+      puts "Shutting down #{inst.instance_id}"
+      terminate_instance!(:instance_id => inst.instance_id)
+    end
+    
+  end    
+end

data/bin/ec2-list-active

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'EC2' #rescue `gem install -y grempe-amazon-ec2`
+aws_keys = {}
+aws_keys = YAML::load( File.open('/etc/poolparty/aws_keys.yml') ) rescue 'No aws_keys.yml file.   Will try to use enviornment variables'
+
+ACCESS_KEY_ID = aws_keys[:access_key] || ENV['AMAZON_ACCESS_KEY_ID'] || ENV['AWS_ACCESS_KEY']
+SECRET_ACCESS_KEY = aws_keys[:secret_access_key] || ENV['AMAZON_SECRET_ACCESS_KEY'] || ENV['AWS_SECRET_ACCESS_KEY']
+
+if ENV['EC2_URL']
+  ec2 = EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY, :server => URI.parse(ENV['EC2_URL']).host )
+else
+  # default server is US ec2.amazonaws.com
+  ec2 = EC2::Base.new( :access_key_id => ACCESS_KEY_ID, :secret_access_key => SECRET_ACCESS_KEY )
+end
+
+response = ec2.describe_instances
+
+public_dns_names = response.reservationSet.item.first.instancesSet.item.collect do |instance|
+  p instance
+   instance.dnsName if instance.instanceState.name == 'running'
+end.compact
+
+puts public_dns_names.join("\t")

data/bin/messenger-get-current-nodes

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'Stats for cloud name')    { |c| optioner.cloudname c }
+end
+
+o.loaded_clouds.each do |cloud|
+  # @nodes = cloud.messenger_send!("get_current_nodes")
+  # @nodes = @nodes.split(" ").map {|a| a.split(/@/)[-1] }
+  puts cloud.get_current_nodes.join(" ")
+end

data/bin/pool

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+name = ARGV.select {|arg| arg if Binary.available_binaries_for("pool").include?(arg) }.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("pool").include?(arg) }
+new_args = new_args.reject {|arg| Binary.available_binaries_for("pool").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
+
+o = PoolParty::Optioner.new(new_args, {:extra_help => "\nPool actions\n#{Binary.list_binaries_for("pool")}\n\n", :abstract => true}) do |opts, optioner|  
+  opts.on('-n poolname', '--name name', 'Address this pool')    { |c| optioner.poolname c }
+end
+
+program_name = "#{File.basename($0)}-#{name}"
+program_location = File.join(Binary.binary_directory, program_name)
+
+command_line = "#{program_location}"
+
+# Run it from the command-line first
+if Binary.available_binaries_for("pool").include?(name)
+  system command_line, *ARGV
+else
+  puts "Unknown poolparty binary: #{name}"
+end

data/bin/pool-describe

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV)
+
+puts pool_describe

data/bin/pool-generate

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rubigen'
+
+if %w(-v --version).include? ARGV.first
+  require 'poolspec/version'
+  puts "#{File.basename($0)} #{Poolspec::VERSION::STRING}"
+  exit(0)
+end
+
+require 'rubigen/scripts/generate'
+source = RubiGen::PathSource.new(:application, 
+  File.join(File.dirname(__FILE__), "../generators"))
+RubiGen::Base.reset_sources
+RubiGen::Base.append_sources source
+ARGV.reject! {|a| a == "generate" }
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'poolspec')

data/bin/pool-init

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rubigen'
+
+# First, let's generate the spec
+if %w(-V --version).include? ARGV.first
+  require 'poolspec/version'
+  puts "#{File.basename($0)} #{Poolspec::VERSION::STRING}"
+  exit(0)
+end
+
+name = ARGV.first
+
+puts "Creating pool named #{name}"
+`pool generate #{name}`
+
+# Now add the keypairs for the pool based on the default pool name and cloud name
+
+@pool = load_pool(self.spec || Binary.get_existing_spec_location)
+@clouds = [@pool.cloud("#{name}_app")]
+
+@clouds.each do |cloud|  
+  with_cloud(cloud) do
+    vputs header("Creating keypair for #{name}")
+    create_keypair unless testing
+  end  
+end

data/bin/pool-list

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+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 pool name')    { |p| optioner.poolname p }
+end
+
+o.loaded_pools.each do |pool|
+  with_pool(pool) do
+    puts header("Listing pool #{name}")
+    clouds.each do |name, cloud|
+      puts subheader("Cloud: #{name} (#{cloud.keypair})")
+      with_cloud(cloud) do
+        puts header("Listing cloud #{name}")
+        puts subheader("Active instances")
+        puts list_of_running_instances.map{|a| a.to_s}.join("\n")
+        puts ""
+        if list_of_pending_instances.size > 0
+          puts subheader("Pending instances")
+          puts list_of_pending_instances.map{|a| a.to_s}.join("\n")
+        end
+      end
+    end
+  end
+end

data/bin/pool-start

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|  
+  opts.on('-p poolname', '--pool name', 'Start pool by this name')    { |p| optioner.poolname p }
+end
+
+o.loaded_pools.each do |pl|
+  
+  with_pool(pl) do
+    puts subheader("Pool: #{pl.name}")
+    
+    pool_clouds.each do |cl|
+      vputs subheader("Cloud: #{cl.name}")
+      
+      cl.launch_and_configure_master!
+      when_no_pending_instances do
+        puts open(::File.join(File.dirname(__FILE__), "..", "lib", "poolparty", "config", "postlaunchmessage.txt")).read ^ {:master_ip => cl.master.ip.chomp}
+        clear_base_directory unless testing
+      end
+    end
+  end
+  
+end

data/bin/server-become-master

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
+end
+
+load_pool(o.spec || Binary.get_existing_spec_location)
+
+include Remote
+
+@clouds = extract_cloud_from_options o
+
+@clouds.each do |cl|
+  
+  with_cloud(cl, {:testing => o.testing}) do
+    cmd = "hostname master && #{PoolParty::Remote::RemoteInstance.dependency_resolver_comand}"
+    %x[#{cmd}] unless testing
+    after_launch_master
+  end  
+  
+end

data/bin/server-build-messenger

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+root_dir = ::File.expand_path( ::File.join(::File.dirname(__FILE__), "..", "lib/erlang/messenger/ebin") )
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+end
+
+INCLUDE = "include"
+ERLC_FLAGS = "-I#{INCLUDE}"
+@version = "0.1"
+
+# erl -pa ./ebin/ -run pm_packager recompile_scripts #{@version} -run init stop -noshell
+# erlc -pa ./ebin -o ebin ./src/*.erl
+# erl -pa ./ebin -s pm_packager start -s init stop
+cmd =<<-EOE
+  cd #{root_dir}
+  rake recompile
+  rake build_boot_scripts
+EOE
+
+vputs "** Building messenger **", o
+vputs "Running command #{cmd.runnable}", o
+
+beams_not_running = %x[ps aux | grep beam | grep master | grep -v grep].empty?
+out = %x[#{cmd.runnable}] if beams_not_running

data/bin/server-butterfly

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# based on snippet from ciconia
+# http://snippets.dzone.com/posts/show/2265
+
+require 'fileutils'
+require File.dirname(__FILE__)+'/../vendor/gems/butterfly/lib/butterfly.rb'
+require 'rack'
+
+monitor_dir = ::File.join(::File.dirname(__FILE__),'..','lib/poolparty/monitors/')
+require(::File.join(monitor_dir, 'stats_monitor_adaptor.rb') )
+opts ={ :adaptor_opts => {
+           :file => ::File.join(monitor_dir, 'stats_monitor_adaptor.rb')},
+           :port => PoolParty::Default.butterfly_port
+      }
+
+app = Rack::Builder.new do
+  use Rack::ShowExceptions
+  # use Rack::Lint
+  run Butterfly::Server.new(opts)
+end
+
+# pid = fork do
+  Rack::Handler::Thin.run(app, :Port => PoolParty::Default.butterfly_port)
+# end
+# Process.detach pid

data/bin/server-clean-cert-for

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'For cloud name')    { |c| optioner.cloudname c }
+  opts.on('-f name', '--for name', 'Clear the cert for')    { |f| optioner.for f }
+end
+
+o.loaded_clouds.each do |cloud|
+  # @nodes = cloud.messenger_send!("get_current_nodes")
+  # @nodes = @nodes.split(" ").map {|a| a.split(/@/)[-1] }  
+  PoolParty::Ruberl::Base.new(cloud.master, Default.messenger_client_port).messenger_send!("clear_cert_for #{cloud.for}")
+end

data/bin/server-cloud-elections

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require "rubygems"
+require 'net/http'
+require 'json'
+require "poolparty/lite"
+
+vote_for = ARGV.shift || "none" # or pending or terminated
+schema = ::PoolParty.load_cloud_from_json(ARGV.shift)  #TODO: smarter option parser
+remote_base_name = schema.options.remote_base.split('::')[-1].camelcase
+remoter_base = PoolParty::Remote.module_eval(remote_base_name)
+require 'rubygems'; require 'ruby-debug'; debugger
+
+case vote_for
+when "expand"
+  # PoolParty.log << "Launching new instance"
+  remoter_base.send :launch_new_instance!, schema.options do |node|
+    ::PoolParty::Provision::BootStrapper.new( node[:ip], :full_keypair_path => cld.keypair.full_filepath, :cloud => schema.options )
+    ::PoolParty::Provision::DrConfigure.new( node[:ip], :full_keypair_path => cld.keypair.full_filepath, :cloud => schema.options )
+  end
+when "contract"
+  last_instance_id = %x[/usr/bin/server-list-active instance_id].split("\t").last
+  remoter_base.terminate_instance! schema.options.merge(:instance_id => last_instance_id)
+else
+  puts "Unknown action: #{vote_for}"
+end
+  

data/bin/server-ensure-provisioning

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+available_monitors = PoolParty::Monitors.available_monitors
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'Host name')    { |h| optioner.hostname h }
+  opts.on('-l', '--no-shell', 'No shell') {optioner.noshell true}
+end
+
+o.loaded_clouds.each do |cloud|
+  
+  with_cloud(cloud) do
+    
+    @nonprovisioned_nodes = list_of_running_instances.map {|a| a.name } - cloud.get_current_nodes
+    # @tp = ThreadPool.new(10)
+    @nonprovisioned_nodes.each do |node|
+      vputs "Provisioning #{node}"
+      next if node == "master"
+      # @tp.process do
+      str = returning Array.new do |s|
+        s << cloud.dependency_resolver_command
+      end.join(";")
+  
+      node_id = node.gsub(/node/, '')
+      
+      cmd = ". /etc/profile && #{str};server-provision -n #{cloud.name} -i #{node_id};#{str}"
+      running_cmd = "ps aux | grep -v grep | grep \"server-provision -n #{cloud.name} -i #{node_id};\""
+      
+      vputs "Executing #{cmd}"
+      running = %x[#{running_cmd}]
+      `#{cmd}` if running.chomp.empty?
+    end
+    # @tp.join
+  end  
+  
+end

data/bin/server-fire-cmd

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+@command = ARGV[-1] || ""
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-c command', '--command command', 'Command to run')    { |c| optioner.command c }
+end
+
+@command = o.command if o.command
+
+print %x[#{@command}].chomp

data/bin/server-get-load

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty/lite"
+Dir["#{File.dirname(__FILE__)}/../lib/poolparty/monitors/base_monitor.rb"].each {|f| require f}
+
+monitor = ARGV.pop || "cpu"
+
+begin
+  Dir["#{File.dirname(__FILE__)}/../lib/poolparty/monitors/monitors/#{monitor}_monitor.rb"].each {|f| require f}
+  
+  klass = eval("PoolParty::Monitors::#{monitor.capitalize}Monitor")
+  print (klass.send :run).to_f rescue -1.0
+rescue Exception => e
+  puts -1.0
+end

data/bin/server-list-active

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty/lite"
+
+list_type = ARGV.shift || "ip"
+
+json_file = ARGV[0] || PoolParty::Default.properties_hash_file
+raise "ERROR: no json_file given" if !json_file
+schema = PoolParty::Schema.new( ::File.read(json_file) )
+
+remoter_base = schema.options.remote_base
+
+instances = PoolParty::Remote::Ec2.describe_instances(schema.options)
+inst_array = instances.map {|inst| inst.send list_type.to_sym }
+
+print_array = 
+case list_type
+when "ip"
+  inst_array.select {|a| a =~ /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/}
+when "internal_ip"
+  inst_array.compact.map {|ip| ip.gsub(/ip-/, '').gsub(/\.ec2\.internal/, '').gsub(/-/, '.') }
+else
+  inst_array
+end
+
+print print_array.compact.join("\t")

data/bin/server-list-instances

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty/lite"
+
+status = ARGV.shift || "running" # or pending or terminated
+schema = ::PoolParty.load_cloud_from_json(ARGV.shift)  #TODO: smarter option parser
+
+remoter_base = schema.options.remote_base
+
+instances = Kernel.const_get(remoter_base.camelcase).send :describe_instances, schema.options
+
+print instances.select {|inst| inst.status == status }.join("\t")
+
+# usage:
+# server-list-instances status

data/bin/server-manage-election

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# Call server-list-active and get the neighborhood ips back
+# then call each of those at the port of butterfly and retain the json
+# From there, mash it up together and call server-handle-election
+# to handle the election process
+
+# Error codes
+# 1 -> clouds.json was not loaded
+# 2 -> server-list-active didn't run
+require "rubygems"
+require 'net/http'
+require 'json'
+require "poolparty/lite"
+
+status = ARGV.shift || "running" # or pending or terminated
+schema = ::PoolParty.load_cloud_from_json(ARGV.shift)  #TODO: smarter option parser
+
+def get_json_stats_from(ip, port)
+  Net::HTTP.start(ip, port) {|http| http.get('/stats.json') }.body rescue "{}"
+end
+ 
+ips = %x[/usr/bin/server-list-active internal_ip].split("\t")
+
+exit(2) unless ips
+
+minimum_instances = schema.options.minimum_instances
+maximum_instances = schema.options.maximum_instances
+
+if ips.size < minimum_instances
+  %x[/usr/bin/server-cloud-elections expand]
+  puts "Cloud is too small, need to expand"
+  exit(0)
+elsif ips.size > maximum_instances
+  %x[/usr/bin/server-cloud-elections contract]
+  puts "Cloud is too big, need to contract"
+  exit(0)
+end
+
+total_json_hash = {}
+ips.each do |ip|
+  node_hsh = JSON.parse(get_json_stats_from(ip, 8642))
+  total_json_hash.merge!(node_hsh) if node_hsh
+end
+
+candidates = {:expand => 0, :contract => 0, :elected_action => nil}
+candidates.each do |action, ballots|
+  total_json_hash.each do |ip, node_hsh|
+    candidates[action]+=1 if node_hsh["nominations"] && node_hsh["nominations"].include?(action.to_s)
+    candidates[:elected_action] = node_hsh["elected_action"]
+  end
+end
+
+puts total_json_hash.inspect
+puts candidates.inspect
+
+# Expand the cloud if 50+% of the votes are for expansion
+# Contract the cloud if 51+% of the votes are for contraction
+@elected_action = candidates[:elected_action] || "none"
+if (candidates[:expand] - candidates[:contract])/total_json_hash.size > 0.5
+  %x[/usr/bin/server-cloud-elections expand] unless @elected_action == "expand"
+  @elected_action = "expand"
+elsif (candidates[:contract] - candidates[:expand])/total_json_hash.size > 0.5
+  %x[/usr/bin/server-cloud-elections contract] unless @elected_action == "contract"
+  @elected_action = "contract"
+end      
+
+puts "Elected action: #{@elected_action}"

data/bin/server-monitor.ru

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rack'
+require 'rack/contrib'
+require 'json'
+require 'thin'
+require ::File.join(::File.dirname(__FILE__),'..','lib/poolparty/monitors/', 'monitor_rack.rb') 
+
+
+app = Rack::Builder.new do
+  use Rack::Reloader, 2
+  use Rack::ShowExceptions
+  use Rack::Lint
+  # use Rack::PostBodyContentTypeParser  #parses json requests to params hash
+  run Monitors::MonitorRack.new()
+end
+
+if __FILE__ == $0
+# at_exit do
+  Rack::Handler::Thin.run app, :daemonize=>true, :pid_file=>'/tmp/monitor.pid'
+  # Thin::Server.new(app, :daemonize=>true, :pid_file=>'/tmp/monitor.pid').daemonize
+# end
+else
+  run app
+end

data/bin/server-provision

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+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('-p', '--slave', 'Provision slave (default: false)')    { optioner.provision_slave true }
+  opts.on('-i num', '--id num', 'Instance num to provision')    { |i| optioner.instance_number i }
+end
+
+o.loaded_clouds.each do |cloud|
+
+  with_cloud(cloud) do
+    setup_dev
+    instance_num = instance_number.to_i if instance_number
+    
+    if instance_num
+      @instance = get_instance_by_number( instance_num )
+      instance_num == 0 ? provisioner_for(master).install(testing) : provisioner_for(@instance).install(testing)
+    else
+      if provision_slave
+        vputs "Provisioning slaves"
+        verbose ? provisioner_for(nil).install(testing) : hide_output { provisioner_for(nil).install(testing) }
+      else
+        vputs "Provisioning master"
+        verbose ? provisioner_for(master).install(testing) : hide_output { provisioner_for(master).install(testing) }
+      end
+    end
+  end
+
+end

data/bin/server-query-agent

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib", "poolparty"))
+require "socket"
+Dir["#{::File.dirname(__FILE__)}/../lib/poolparty/modules/*.rb"].each {|f| require f }
+require "poolparty/base"
+
+def query(meth, *args)
+  socket = TCPSocket.open("127.0.0.1", PoolParty::Default.agent_port)
+  out = socket.send("#{meth} #{args}", 100)
+  socket.close
+  out
+end
+
+meth = ARGV.shift
+puts query(meth, ARGV)

data/bin/server-rerun

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
+end
+
+load_pool(o.spec || Binary.get_existing_spec_location)
+
+include Remote
+
+@clouds = extract_cloud_from_options o
+
+@clouds.each do |cl|
+  
+  with_cloud(cl, {:testing => o.testing}) do
+    cmd = PoolParty::Remote::RemoteInstance.dependency_resolver_comand
+    %x[#{cmd}] unless testing
+  end  
+  
+end

data/bin/server-send-command

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+@command = ARGV[-1] || ""
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-c command', '--command command', 'Command to run')    { |c| optioner.command c }
+end
+
+@command,@args = Arr.split(" ")[0], Arr.split(" ")[1..-1]
+
+o.loaded_clouds do |cloud|
+  with_cloud(cloud, {:command => @command, :command_args => @args}) do
+    cloud.send command.to_sym, command_args
+  end  
+end

data/bin/server-show-stats

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolpartycl"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'Host name')    { |h| optioner.hostname h }
+end
+
+o.loaded_clouds.each do |cloud|
+  
+  with_cloud(cloud) do    
+    puts header("Stats")
+    puts rules_values
+  end  
+  
+end