auser-poolparty 1.0.0 → 1.1.1

data/License.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Ari Lerner
+Copyright (c) 2009 Ari Lerner
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/PostInstall.txt

@@ -1,4 +1,4 @@
-Get ready to jump in the pool, you just installed PoolParty! (Updated at 11:21 01/28/09)
+Get ready to jump in the pool, you just installed PoolParty! (Updated at 19:34 03/02/09)
 
 To get started, run the generator:
 

data/README.txt

@@ -49,7 +49,7 @@ sudo gem install auser-poolparty
 * Add queuing of tasks on the messenger
 * Add syntax checker on the manifests
 * Move in collectd support
-* Add master query
+* Remove master-slave protocol
 
 == LICENSE:
 

data/Rakefile

@@ -1,15 +1,17 @@
 require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
+require 'config/jeweler' # setup gem configuration
 
 Dir['tasks/**/*.rake'].each { |rake| load rake }
 
 desc "Clean tmp directory"
 task :clean_tmp do |t|
-  %x[rm #{File.dirname(__FILE__)}/Manifest.txt; touch #{File.dirname(__FILE__)}/Manifest.txt]
+  FileUtils.rm_rf("#{File.dirname(__FILE__)}/Manifest.txt") if ::File.exists?("#{File.dirname(__FILE__)}/Manifest.txt") 
+  FileUtils.touch("#{File.dirname(__FILE__)}/Manifest.txt")
   %w(logs tmp).each do |dir|
     FileUtils.rm_rf("#{File.dirname(__FILE__)}/#{dir}") if ::File.exists?("#{File.dirname(__FILE__)}/#{dir}")
   end
 end
+
 desc "Remove the pkg directory"
 task :clean_pkg do |t|
   %w(pkg).each do |dir|
@@ -17,9 +19,6 @@ task :clean_pkg do |t|
   end
 end
 
-desc "Generate a new manifest and a new gem"
-task :build_local_gem => [:clean_tmp, :spec, :clean_pkg, :"manifest:refresh", :package]
-
 desc "Packge with timestamp"
 task :update_timestamp do
   data = open("PostInstall.txt").read
@@ -33,37 +32,14 @@ task :update_timestamp do
   ::File.open("PostInstall.txt", "w+") {|f| f << data }
 end
 
-desc "Release to github"
-task :github_release => [:clean_tmp, :spec, :clean_pkg, :"manifest:refresh", :update_timestamp, :package] do
-  res = %x[rake debug_gem]
-  res = res.split("\n")[1..-1].join("\n")
-  ::File.open("#{GEM_NAME.downcase}.gemspec", "w+") do |f|
-    f << res
-  end
-  `mv #{::File.expand_path(::File.dirname(__FILE__))}/pkg/*.gem #{::File.expand_path(::File.dirname(__FILE__))}/pkg/poolparty.gem`
-end
-
-desc "Generate gemspec"
-task :gemspec  => [:spec, :clean_tmp, :"manifest:refresh", :build_local_gem] do |t|
-  res = %x[rake debug_gem]
-  res = res.split("\n")[1..-1].join("\n")
-  ::File.open("#{GEM_NAME.downcase}.gemspec", "w+") do |f|
-    f << res
-  end
-end
-
-desc "Generate gemspec for github"
-task :gh => [:github_release] do
-  filepath = ::File.join(::File.dirname(__FILE__), "poolparty.gemspec")
-  data = open(filepath).read
-  spec = eval("$SAFE = 3\n#{data}")
-  yml = YAML.dump spec
-  File.open(filepath, "w+") do |f|
-    f << yml
-  end
+namespace :gem do
+  task(:build).prerequisites.unshift :gemspec # Prepend the gemspec generation
+  
+  desc "Build the gem only if the specs pass"
+  task :test_then_build => [:spec, :build]
+  
+  desc "Build and install the gem only if the specs pass"
+  task :test_then_install => [:spec, :install]
 end
 
-desc "Generate github gemspec and latest gem"
-task :ghgem => [:gh] do
-  %x[sudo gem install pkg/poolparty.gem]
-end
+task :release => [:update_timestamp]

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 1
+:major: 1
+:minor: 1

data/bin/cloud

@@ -3,7 +3,8 @@ $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 require "poolparty"
 require "poolpartycl"
 
-name = ARGV.select {|arg| arg if Binary.available_binaries_for("cloud").include?(arg) }.first
+# 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
@@ -25,7 +26,7 @@ command_line = "#{program_location}"
 
 # Run it from the command-line first
 if Binary.available_binaries_for("cloud").include?(name)
-  system command_line, *ARGV
+  system command_line, *new_args
 else
   puts "Unknown poolparty binary: #{name}"
 end

data/bin/cloud-bootstrap

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+require "poolparty/provision/boot_strapper"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n cloudname', '--name name', 'Start cloud by this name')    { |c| optioner.cloudname c }
+end
+
+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.running_instance_ips
+  if nodes.empty?
+    puts "No nodes to bootstrap"
+  else
+    nodes.each do |address|
+      puts "\nBootStrapping: #{address}\n--------------------"
+      ::PoolParty::Provision::BootStrapper.new address, {:full_keypair_path => cld.keypair.full_filepath, :cloud => cld}
+    end
+  end
+end

data/bin/cloud-configure

@@ -1,17 +1,28 @@
 #!/usr/bin/env ruby
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 require "poolparty"
-require "poolpartycl"
+# require "poolpartycl"
+
 
 o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  optioner.cloudnames
-  # optioner.daemonizeable
+  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.
+  nodes = !o.unflagged_args.empty? ?  o.unflagged_args : cld.remote_instances_list.collect {|inst| inst.ip if inst.running? }.compact
+  if nodes.empty?
+    puts "No nodes to configure"
+  else
+    if o.inst_num?
+      ::PoolParty::Provision::DrConfigure.new( nodes[o.inst_num], :full_keypair_path => cld.keypair.full_filepath,  :cloud => cld )
+    else
+      nodes.each do |address|
+        puts "Configuring: #{address}"
+        ::PoolParty::Provision::DrConfigure.new( address, :full_keypair_path => cld.keypair.full_filepath,  :cloud => cld )
+      end
+    end
+  end
 end
 
-o.loaded_clouds.each do |cloud|
-  
-  with_cloud(cloud) do
-    verbose ? provisioner_for(master).configure(testing) : hide_output { provisioner_for(master).configure(testing) }
-    cleanup_storage_directory unless testing
-  end    
-end

data/bin/cloud-list

@@ -1,7 +1,6 @@
 #!/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 }
@@ -10,17 +9,15 @@ o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
   opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
 end
 
-o.loaded_clouds.each do |cloud|
+o.loaded_clouds.each do |cld|
   
-  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  
+  puts header("Listing cloud #{cld.name}")
   
+  puts subheader("Active instances")
+  puts cld.list_of_running_instances.map{|a| a.to_s}.join("\n")
+    
+  if cld.list_of_pending_instances.size > 0
+    puts subheader("Pending instances")
+    puts cld.list_of_pending_instances.map{|a| a.to_s}.join("\n")
+  end
 end

data/bin/cloud-osxcopy

@@ -7,10 +7,11 @@ 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
 
-o.loaded_clouds.each do |cloud|
+o.loaded_clouds.each do |cld|
   
-  with_cloud(cloud, {:location => @location}) do
-    Kernel.system "echo #{master.ip.chomp} | pbcopy"
-  end
+  node = cld.list_of_running_instances.first
+  ip = node.ip
+  puts "ip: #{ip}"
+  Kernel.system "echo #{ip} | pbcopy"
   
 end

data/bin/cloud-provision

@@ -1,34 +1,30 @@
 #!/usr/bin/env ruby
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 require "poolparty"
-require "poolpartycl"
+require "poolparty/provision/boot_strapper"
 
 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 }
+  opts.on('-i num', '--num i', 'Instance number')    { |i| optioner.inst_num i.to_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)
+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.remote_instances_list.collect {|inst| inst.ip if inst.running? }.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
-      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) }
+      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 )
       end
     end
-    
-    cleanup_storage_directory unless testing
   end
+end
 
-end

data/bin/cloud-setup-dev

@@ -7,19 +7,19 @@ o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
   opts.on('-n name', '--name name', 'Setup development environment for cloud named')    { |c| optioner.cloudname c }
 end
   
-o.loaded_clouds.each do |cloud|  
-  with_cloud(cloud) do
-    
-    setup_dev
-    
+o.loaded_clouds.each do |cld|
+  
+  if cld.remote_instances_list.empty?
+    puts "Your cloud is not running"
+  else
     str =<<-EOE
-    Host #{name}-master
-      User        #{user}
-      Hostname    #{master.ip}
-      IdentityFile    #{full_keypair_path}
+    Host #{cld.name}-master
+      User        #{cld.user}
+      Hostname    #{cld.remote_instances_list.first.ip}
+      IdentityFile    #{cld.keypair}
     EOE
-    
+  
     puts "Enter the following in your .ssh/config file"
     puts str
-  end  
+  end
 end

data/bin/cloud-spec

@@ -29,7 +29,8 @@ o.loaded_clouds.each do |cloud|
       case testtype
       when "launch"
       when nil
-        print_with_nice_printer("Starting live specing cloud #{name}")      
+        print_with_nice_printer("Starting live specing cloud #{name}")
+        puts "TODO:  this isn't implented yet."
         # hide_output {launch_and_configure_master!}
         print_with_nice_printer("Waiting for cloud to provision")
         

data/bin/cloud-ssh

@@ -4,11 +4,20 @@ require "poolparty"
 require "poolpartycl"
 
 o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  optioner.options( :num => 0 )
   opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
-  opts.on('-i num', '--id num', 'Instance num to ssh (default: 0)')    { |i| optioner.num i }
+  opts.on('-i num', '--id num', 'Instance num to ssh (default: 0)')    { |i| optioner.inst_num i.to_i }
 end
-load_pool(o.spec || Binary.get_existing_spec_location)
+load_pool(o.spec? ? o.spec : Binary.get_existing_spec_location)
 
 @cloud = o.loaded_clouds.first
+nodes = @cloud.list_of_running_instances
 
-@cloud.ssh_into_instance_number( o.num.to_i || 0 ) if @cloud
+puts nodes.map {|a| a.to_s}.join("\n")
+
+if !nodes.empty?
+  n = o.inst_num? ? o.inst_num : 0
+  @cloud.ssh_into( nodes[n].ip ) if @cloud
+else
+  puts "No running instances can be found"
+end

data/bin/cloud-start

@@ -1,32 +1,28 @@
 #!/usr/bin/env ruby
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 require "poolparty"
-require "poolpartycl"
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|  
-  optioner.cloudnames
-  optioner.daemonizeable
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n cloudname', '--name name', 'Start cloud by this name')    { |c| optioner.cloudname c }
 end
 
-o.loaded_clouds.each do |cloud|
-  with_cloud(cloud) do
-    setup_dev
-    vputs header("Starting cloud #{name}")
-    vputs "#{list_of_running_instances.size} running instances (#{minimum_instances} - #{maximum_instances})"
-    # if list_of_running_instances.size <= 1
-      puts "Starting the master instance"    
-      # if testing
-      #   puts("\tNot launching while in testing mode")
-      # else
-        vputs "Launching and configuring the master"
-        @cl = self
-        daemon ? daemonize {@cl.launch_and_configure_master!} : launch_and_configure_master!
-      # end
-    # end
-    when_no_pending_instances do
-      puts open(::File.join(File.dirname(__FILE__), "..", "lib", "poolparty", "config", "postlaunchmessage.txt")).read ^ {:master_ip => master.ip.chomp}
-      clear_base_directory unless testing
+o.loaded_clouds.each do |cld|
+  if cld.list_of_running_instances.size.zero?
+    puts header("Starting cloud #{cld.name}")
+    puts "#{cld.list_of_running_instances.size} running instances (#{cld.minimum_instances} - #{cld.maximum_instances})"
+    
+    cld.launch_instance! do |node|
+      ::PoolParty::Provision::BootStrapper.new(node.ip, :full_keypair_path => cld.keypair.full_filepath, :cloud => cld)
+      ::PoolParty::Provision::DrConfigure.new(node.ip,  :full_keypair_path => cld.keypair.full_filepath, :cloud => cld)
+      
+      puts <<-EOM
+        Your cloud has started. Your ip is #{node.ip}
+      EOM
     end
-  end
   
+  else
+    puts <<-EOE
+      Your cloud is already running.
+    EOE
+  end
 end

data/bin/cloud-terminate

@@ -13,7 +13,7 @@ o.loaded_clouds.each do |cloud|
     
     list_of_running_instances.each do |inst|
       puts "Shutting down #{inst.instance_id}"
-      terminate_instance!(inst.instance_id)
+      terminate_instance!(:instance_id => inst.instance_id)
     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/server-become-master

@@ -16,7 +16,7 @@ include Remote
 @clouds.each do |cl|
   
   with_cloud(cl, {:testing => o.testing}) do
-    cmd = "hostname master && #{PoolParty::Remote::RemoteInstance.puppet_runner_command}"
+    cmd = "hostname master && #{PoolParty::Remote::RemoteInstance.dependency_resolver_comand}"
     %x[#{cmd}] unless testing
     after_launch_master
   end  

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

@@ -11,5 +11,5 @@ 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, Base.messenger_client_port).messenger_send!("clear_cert_for #{cloud.for}")
+  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

@@ -20,8 +20,7 @@ o.loaded_clouds.each do |cloud|
       next if node == "master"
       # @tp.process do
       str = returning Array.new do |s|
-        s << "/usr/sbin/puppetca --clean #{node}.compute-1.internal"
-        s << "/usr/sbin/puppetca --clean #{node}.ec2.internal"
+        s << cloud.dependency_resolver_command
       end.join(";")
   
       node_id = node.gsub(/node/, '')

data/bin/server-get-load

@@ -1,18 +1,15 @@
 #!/usr/bin/env ruby
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require "poolparty"
-require "poolpartycl"
+require "poolparty/lite"
+Dir["#{File.dirname(__FILE__)}/../lib/poolparty/monitors/base_monitor.rb"].each {|f| require f}
 
-available_monitors = PoolParty::Monitors.available_monitors
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  # opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
-  opts.on('-m name', '--monitor monitor_name', "Monitor name (default: cpu) (Available monitors: #{available_monitors.join(", ")})") {|c| optioner.monitorname c}
-end
+monitor = ARGV.pop || "cpu"
 
-@monitor = o.monitorname ? o.monitorname : "cpu"
+begin
+  Dir["#{File.dirname(__FILE__)}/../lib/poolparty/monitors/monitors/#{monitor}_monitor.rb"].each {|f| require f}
   
-if PoolParty::Monitors.available_monitors.include?(@monitor.downcase.to_sym)
-  print "PoolParty::Monitors::#{@monitor.capitalize}Monitor".constantize.run.to_f
-else
-  puts "Unknown monitor"
+  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

@@ -1,18 +1,26 @@
 #!/usr/bin/env ruby
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require "poolparty"
-require "poolpartycl"
+require "poolparty/lite"
 
-o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
-  opts.on('-c name', '--class name', 'Listing for cloud class (valid args: [name|ip])')    { |t| optioner.classname t }
-  opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
-end
+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
 
-@ctype = (o.classname || "name").downcase.to_sym
+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
 
-o.loaded_clouds.each do |cloud|
-  with_cloud(cloud, {:ctype => @ctype}) do
-    print "#{list_of_running_instances.collect{|a| "#{a.send ctype}" }.join("\t")}"
-  end  
-  
-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