judo 0.0.1

data/README.rdoc

@@ -0,0 +1,90 @@
+= Tired of wrestling with server provisioning?  Sumo!
+
+Want to launch and manage persistent utility servers on EC2?  ec2-run-instances got you down?  Try this:
+
+    $ sumo create mybox
+    Created server mybox
+    $ sumo list
+    mybox          i-8a3d05e2  m1.small   ami-1515f67c
+    $ sumo launch mybox
+    ---> Launch server mybox...   done (1.9s)
+    ---> Acquire hostname...      ec2-75-101-254-61.compute-1.amazonaws.com (34.0s)
+    ---> Wait for ssh...          done (3.1s)
+
+    Logging you in via ssh.  Type 'exit' or Ctrl-D to return to your local system.
+    ------------------------------------------------------------------------------
+    ...
+    root@domU-12-31-39-04-31-37:~# 
+
+== Setup
+
+Dependencies:
+
+    $ sudo gem install thor aws right_aws
+
+Then create ~/.sumo/config.yml containing:
+
+    ---
+    access_id: <your amazon access key id>
+    access_secret: <your amazon secret access key>
+
+You'll need Bacon and Mocha if you want to run the specs, and Jewler if you want to create gems.
+
+== Usage
+
+Create a named persistent server:
+
+    $ sumo create mybox
+    Created server mybox
+
+See config vars on the server record:
+
+    $ sumo info mybox
+    mybox:
+       availability_zone:"us-east-1d"
+       ami32:"ami-1515f67c"
+       user:"ubuntu"
+       key_name:"sumo"
+       ami64:"ami-ab15f6c2"
+       user_data:""
+       security_group:"sumo"
+       instance_size:"m1.small"
+
+Set config vars before launch:
+
+    $ sumo set mybox --instance-size c1.medium
+
+Create a static IP address and/or volumes:
+
+    $ sumo attach_ip mybox
+    $ sumo attach_volume mbox 50 /dev/sdh1
+
+Launch an instance of the server:
+
+    $ sumo launch mybox
+    ---> Launch server mybox...
+
+You may want to spin down the server if it's not in use:
+
+    $ sumo stop mybox
+
+...and bring it up again later:
+
+    $ sumo start mybox
+
+== Some details you might want to know
+
+Sumo creates its own keypair named sumo, which is stored in ~/.ssh/keypair.pem.  Amazon doesn't let you upload your own ssh public key, which is lame, so this is the best option for making the launch-and-connect process a single step.
+
+It will also create an Amazon security group called sumo, so that it can lower the firewall for services you configure via cookbook roles.
+
+== Meta
+
+Created by Adam Wiggins and Orion Henry
+
+Patches contributed by Blake Mizerany, Jesse Newland, Gert Goet, and Tim Lossen
+
+Released under the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+http://github.com/adamwiggins/sumo
+

data/Rakefile

@@ -0,0 +1,27 @@
+require 'jeweler'
+
+Jeweler::Tasks.new do |s|
+	s.name = "judo"
+	s.description = "A no-hassle way to launch one-off EC2 instances from the command line"
+	s.summary = s.description
+	s.author = "Orion Henry"
+	s.email = "orion@heroku.com"
+	s.homepage = "http://github.com/orionz/judo"
+	s.rubyforge_project = "judo"
+	s.files = FileList["[A-Z]*", "{bin,lib,spec}/**/*"]
+	s.executables = %w(judo)
+	s.add_dependency "uuidtools"
+	s.add_dependency "aws"
+	s.add_dependency "thor"
+	s.add_dependency "json"
+end
+
+Jeweler::RubyforgeTasks.new
+
+desc 'Run specs'
+task :spec do
+	sh 'bacon -s spec/*_spec.rb'
+end
+
+task :default => :spec
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/judo

@@ -0,0 +1,212 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/all'
+
+#Sumo::Config.connect
+
+require 'thor'
+
+class CLI < Thor
+	desc "start [NAMES]", "start one or more servers"
+	def start(*names)
+		servers(*names) do |server|
+			server.start
+		end
+	end
+
+	desc "ssh [NAMES]", "ssh to a specified server or first available"
+	def ssh(*names)
+		servers(*names) do |server|
+			server.reload
+			server.wait_for_ssh
+			server.connect_ssh
+		end
+	end
+
+	desc "launch NAME", "create and start a persistent server"
+	def launch(name)
+		create(name, true)
+	end
+
+	desc "create NAME", "create a persistent server"
+	def create(name, start = false)
+		group = Sumo::Group.current
+		if name =~ /^[+](\d*)/
+			n = $1.to_i
+			fail "woah nelly - that's too many - 5 or less pls" if n > 5
+			fail "woah nelly - that's not enough" if n < 1
+			top_counter = group.servers.map { |s| (s.name =~ /^#{s.group}.(\d*)$/); $1.to_i }.sort.last.to_i
+			n.times do |i|
+				top_counter += 1
+				server = group.create_server "#{group}.#{top_counter}"
+				server.allocate_resources
+				server.start if start
+			end
+		else
+			server = group.create_server name
+			server.allocate_resources
+			server.start if start
+		end
+	end
+
+	desc "restart NAME", "restart a running server"
+	def restart(*names)
+		servers(*names) do |server|
+			server.restart
+		end
+	end
+
+	desc "stop [NAMES]", "stop a persistent server"
+	def stop(*names)
+		servers(*names) do |server|
+			server.stop
+			server.destroy if server.generic?
+		end
+	end
+
+	desc "destroy NAMES", "destroy a persistent server"
+	def destroy(*names)
+		raise "Must specify names of servers to destroy" if names.empty?
+		servers(*names) do |server|
+			server.destroy
+		end
+	end
+
+	desc "info [NAMES]", "show server config"
+	def info(*names)
+		servers(*names) do |server|
+			require 'pp'
+			puts "#{server}"
+			if server.ec2_instance and not server.ec2_instance.empty?
+				puts "\t[ EC2 ]"
+				[:aws_instance_id, :ssh_key_name, :aws_availability_zone, :aws_state, :aws_image_id, :dns_name, :aws_instance_type, :private_dns_name, :aws_launch_time, :aws_groups ].each do |k|
+					printf "\t %-24s: %s\n",k, server.ec2_instance[k]
+				end
+			end
+			puts "\t[ VOLUMES ]"
+			server.ec2_volumes.each do |v|
+				printf "\t %-13s %-10s %-10s %4d  %-10s %-8s\n",
+				v[:aws_id],
+				v[:aws_status],
+				v[:zone],
+				v[:aws_size],
+				v[:aws_attachment_status],
+				v[:aws_device]
+			end
+#			pp ({ :name => server.name , :group => server.group, :volumes => server.volumes, :hostname => server.hostname })
+#			pp server.volumes.inspect
+#			puts server.state.inspect
+				## EC2 describe_volumes
+#				puts "	#{dev.to_s}:#{Sumo::Config.ec2.describe_volumes([vol_id])}"
+#			end
+		end
+	end
+
+	desc "list [NAMES]", "list all servers"
+	def list(*names)
+		if group = Sumo::Group.current
+			servers(*names) do |s|
+				printf "%-18s %-11s %-11s %-13s %-10s %-10s %s\n", s.name, s.state["instance_id"], s.instance_size, s.ami, s.ec2_state, "#{s.volumes.keys.size} volumes", s.ip
+			end
+		else
+			printf "  SERVER GROUPS\n"
+			Sumo::Group.all.each do |g|
+				printf "%-18s %s servers\n", g.name, g.servers.size
+			end
+#			printf "  UNGROUPED SERVERS\n"
+#			servers.each do |s|
+#				printf "%-18s %-11s %-11s %-13s %-10s %-10s %s\n", s.name, s.state["instance_id"], s.state["security_group"], s.ami, s.ec2_state, "#{s.volumes.keys.size} volumes", s.ip
+#			end
+		else
+		end
+	end
+
+	desc "console [NAMES]", "get console output for server or first available"
+	def console(*names)
+		servers(*names) do |server|
+			if server.running?
+				puts "Not running: #{server.name}"
+			else
+				puts server.console_output if server.running?
+			end
+		end
+	end
+
+	desc "init", "create a new sumo repository in the current directory"
+	def init
+		Sumo::Config.init
+	end
+
+	desc "volumes", "list all volumes"
+	def volumes
+		format = "%13s %6s %12s  %-10s %-16s %-16s\n"
+		printf format, "AWS_ID", "SIZE", "AWS_STATUS", "AWS_DEVICE", "ATTACHED TO", "CONFIGURED FOR"
+		printf "%s\n", ("-" * 80)
+		### EC2 describe_volumes
+		Sumo::Config.ec2.describe_volumes.map do |volume|
+			[ volume[:aws_id], volume[:aws_size], volume[:aws_status], volume[:aws_device] || "", instance_id_to_sumo(volume[:aws_instance_id]) || volume[:aws_instance_id] || "", volume_id_to_sumo(volume[:aws_id]) ]
+		end.sort { |a,b| [ a[5].to_s, a[3].to_s ] <=> [ b[5].to_s, b[3].to_s ] }.each do |d|
+			printf format, *d
+		end
+	end
+
+	desc "ips", "list all ips"
+	def ips
+		format = "%15s %20s %20s\n"
+		printf format, "IP", "ATTACHED TO", "CONFIGURED FOR"
+		printf "%s\n", ("-"*57)
+		## EC2 describe_addresses
+		Sumo::Config.ec2.describe_addresses.map do |ip|
+			[ ip[:public_ip], instance_id_to_sumo(ip[:instance_id]) || ip[:instance_id], ip_to_sumo(ip[:public_ip]) ]
+		end.sort { |a,b| a[2].to_s <=> b[2].to_s }.each do |d|
+			printf format, *d
+		end
+	end
+
+	desc "commit", "push configs and files to couchdb"
+	def commit
+#		group = Sumo::Config.group
+		Sumo::Server.commit
+  end
+
+	no_tasks do
+		def servers(*names, &block)
+			group = Sumo::Group.current
+			good_servers = group.servers.select { |s| names.empty? or names.include?(s.name) }
+			bad_names = (names - good_servers.map(&:name))
+			fail "bad server name: #{bad_names.join(', ')}" unless bad_names.empty?
+			good_servers.each do |server|
+				begin
+					block.call(server)
+				rescue Object => e
+					puts "Error on #{server.name}: #{e.message}"
+				end
+			end
+		end
+
+		def task(msg, &block)
+			printf "---> %-24s ", "#{msg}..."
+			start = Time.now
+			result = block.call || 'done'
+			result = "done" unless result.is_a? String
+			finish = Time.now
+			time = sprintf("%0.1f", finish - start)
+			puts "#{result} (#{time}s)"
+			result
+		end
+
+		def volume_id_to_sumo(volume)
+			Sumo::Server.all.detect { |s| s.volumes.invert[volume] }
+		end
+
+		def ip_to_sumo(ip)
+			Sumo::Server.all.detect { |s| s.state["elastic_ip"] == ip }
+		end
+
+		def instance_id_to_sumo(instance_id)
+			Sumo::Server.all.detect { |s| s.state["instance_id"] and s.state["instance_id"] == instance_id }
+		end
+	end
+end
+
+CLI.start

data/lib/all.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'aws'
+require 'right_aws'
+require 'sdb/active_sdb' ##
+require 'yaml'
+require 'socket'
+require 'json'
+require 'couchrest'  ##
+require 'fileutils'
+
+require 'fog'
+require 'fog/aws/s3'
+
+require File.dirname(__FILE__) + '/config'
+require File.dirname(__FILE__) + '/group'
+require File.dirname(__FILE__) + '/server'
+require File.dirname(__FILE__) + '/couchrest_hacks'

data/lib/config.rb

@@ -0,0 +1,233 @@
+module Judo
+	module Config
+		extend self
+
+		## FIXME - maybe write these to defaults.json and dont have them hidden here in the code...
+		def defaults
+			defaults_file = "#{judo_dir}/defaults.json"
+			unless File.exists? defaults_file
+				File.open(defaults_file, "w") { |f| f.write(default_config.to_json) }
+			end
+			JSON.parse File.read(defaults_file)
+		end
+
+		def default_config
+			{
+				:key_name => "judo",
+				:instance_size => "m1.small",
+				:ami32 => "ami-bb709dd2",  ## public ubuntu 9.10 ami - 32 bit
+				:ami64 => "ami-55739e3c",  ## public ubuntu 9.10 ami - 64 bit
+				:user => "ubuntu",
+				:security_group => { "name" => "judo", "public_ports" => ["22"] },
+				:availability_zone => "us-east-1d"  ## FIXME -- this should be state not config -- what if they differ - how to set?
+			}
+		end
+
+#		def merged_config(name)
+#			stack = load_config_stack(name)
+#			stack.reverse.inject({}) { |sum,conf| sum.merge(conf) }
+#		end
+
+#		def load_config_stack(name, all = [])
+#			return (all << defaults) if name.nil?
+#			conf = read_config(name)
+#			load_config_stack(conf["import"], all << conf)
+#		end
+
+		def repo_dir
+			judo_config["repo"] || File.dirname(judo_dir)
+		end
+
+#		def group_dirs
+#			Dir["#{repo_dir}/*/config.json"].map { |d| File.dirname(d) }
+#		end
+
+#		def group_dir(name)
+#			group_dirs.select { |d| File.basename(d) == name }
+#		end
+
+#		def groups
+#			group_dirs.map { |g| File.basename(g) }
+#		end
+
+#		def group
+#			File.basename(group_dirs.detect { |d| Dir.pwd == d or Dir.pwd =~ /^#{d}\// }) rescue nil
+#		end
+
+#		def read_config(name)
+#			begin
+#				JSON.parse(File.read("#{group_dir(name)}/config.json"))
+#			rescue Errno::ENOENT
+#				{}
+#			end
+#		end
+
+		def access_id
+			judo_config["access_id"] || ENV["AWS_ACCESS_KEY_ID"] || (raise "please define access_id in #{judo_config_file} or in the env as AWS_ACCESS_KEY_ID")
+		end
+	
+		def access_secret
+			judo_config["access_secret"] || ENV["AWS_SECRET_ACCESS_KEY"] || (raise "please define access_secet in #{judo_config_file} or in the env as AWS_SECRET_ACCESS_KEY")
+		end
+		
+		def ec2
+			@ec2 ||= Aws::Ec2.new(access_id, access_secret, :logger => Logger.new(nil))
+		end
+
+### REMOVE
+		def couchdb
+			@couchdb ||= CouchRest.database!(couch_url)
+		end
+
+		def couch_url
+			judo_config["couch_url"] || "http://127.0.0.1:5984/judo"
+		end
+
+## FIXME
+		def keypair_file
+			judo_config["keypair_file"] || "#{judo_dir}/keypair.pem"
+		end
+
+#		def connect
+#			@@con = Aws::ActiveSdb.establish_connection(Config.access_id, Config.access_secret, :logger => Logger.new(nil))
+#			one_time_setup unless setup?
+#		end
+
+## FIXME
+		def one_time_setup
+			puts "ONE TIME SETUP"
+			Sumo::Server.create_domain
+		end
+
+#		def setup?
+#			Sumo::Server.connection.list_domains[:domains].include? Sumo::Server.domain
+#		end
+		
+## FIXME
+		def create_keypair
+			## EC2 create_key_pair
+			material = ec2.create_key_pair("judo")[:aws_material]
+			File.open(keypair_file, 'w') { |f| f.write material }
+			File.chmod 0600, keypair_file
+		end
+
+		## FIXME - this seems... lame
+		def create_security_group
+			## EC2 create_security_group
+			ec2.create_security_group('judo', 'Sumo')
+			## EC2 authorize_security_group
+			ec2.authorize_security_group_IP_ingress("judo", 22, 22,'tcp','0.0.0.0/0')
+		rescue Aws::AwsError
+		end
+
+		def judo_config
+			@config ||= read_judo_config
+		end
+
+		def judo_config_file
+			"#{judo_dir}/config.yml"
+		end
+
+		def judo_dir
+			@judo_dir ||= find_judo_dir(Dir.pwd) || abort("fatal: Not a judo repository (or any of the parent directories): .judo\nrun commands from the judo repository or type 'judo init' to setup the current directory as a new judo repository")
+		end
+
+		def find_judo_dir(check)
+			if check == "/"
+				if File.exists?("#{ENV['HOME']}/.judo")
+					"#{ENV['HOME']}/.judo"
+				else
+					nil
+				end
+			else
+				File.exists?(check + "/.judo") ? check + "/.judo" : find_judo_dir(File.dirname(check))
+			end
+		end
+
+		def read_judo_config
+			YAML.load File.read(judo_config_file)
+		rescue Errno::ENOENT
+			{}
+		end
+
+		def sdb
+			@sdb = Aws::SdbInterface.new(access_id, access_secret, :logger => Logger.new(nil))
+		end
+
+		def s3
+#			@s3 ||= RightAws::S3.new(access_id, access_secret, :logger => Logger.new(nil))
+#			@s3 ||= Aws::S3.new(access_id, access_secret)
+      @s3 = Fog::AWS::S3.new( :aws_access_key_id => access_id, :aws_secret_access_key => access_secret)
+		end
+
+		def s3_url(k)
+			s3.get_object_url(judo_config["s3_bucket"], k,Time.now.to_i + 100_000_000)
+		end
+
+		def s3_put(k, file)
+			s3.put_object(judo_config["s3_bucket"], k, file)
+		end
+
+		def collect(keys, prompt, &blk)
+			k = keys.detect do |k| 
+				printf "Looking in your environment for #{k}..."
+				printf "found!" if ENV[k]
+				printf "\n"
+				ENV[k] 
+			end
+			value = ENV[k]
+			retries = 3
+			begin
+				unless value
+					printf "#{prompt}: "
+					value = STDIN.readline
+				end
+				blk.call(value) if blk
+				value
+			rescue *[Interrupt, EOFError]
+				puts "\nGoodbye!"
+				exit(0)
+			rescue Object => e
+				fail "too many retries" if retries == 0
+				puts "There was an error: #{e.class}:#{e.message}"
+				puts "Try again or hit CTRL-C"
+				value = nil
+				retries -= 1
+				retry
+			end
+				
+		end
+				
+		def init
+			### sooooo ugly
+			require 'pp'
+			fail "you are already inside a judo repository" if find_judo_dir(Dir.pwd)
+			fail "./.git not found - judo configurations must be kept in a git repo.  type 'git init' to setup the git repo." unless File.exists? "./.git"
+			aws_id =     collect(['AWS_ACCESS_KEY_ID', 'AMAZON_ACCESS_KEY_ID'],          "Please enter your AWS access key")
+			aws_secret = collect(['AWS_SECRET_ACCESS_KEY', 'AMAZON_SECRET_ACCESS_KEY'],  "Please enter your AWS secret key") do |aws_secret|
+				puts "Trying to connect to SimpleDB with #{aws_id}:#{aws_secret}"
+				@sdb = Aws::SdbInterface.new(aws_id, aws_secret, :logger => Logger.new(nil))
+				@sdb.create_domain("judo_servers")
+				@sdb.create_domain("judo_config")
+			end
+
+			puts "setting up an s3 bucket"
+			s3_bucket = ENV['SUMO_S3_BUCKET'] || "judo_#{rand(2**128).to_s(16)}"
+   		Fog::AWS::S3.new( :aws_access_key_id => aws_id, :aws_secret_access_key => aws_secret).put_bucket(s3_bucket)
+
+			puts "setting up an .judo/config.yml"
+			system "mkdir .judo"
+			File.open(".judo/config.yml","w") { |f| f.write({ "access_id" => aws_id, "access_secret" => aws_secret, "s3_bucket" => s3_bucket }.to_yaml) }
+
+			puts "Setting up default config and keypair"
+			system "mkdir default"
+			keypair = "judo_#{rand(2**64).to_s(16)}"
+			@ec2 = Aws::Ec2.new(access_id, access_secret, :logger => Logger.new(nil))
+			material = @ec2.create_key_pair(keypair)[:aws_material]
+			File.open("default/#{keypair}.pem", 'w') { |f| f.write material }
+			File.chmod 0600, "default/#{keypair}.pem"
+			File.open("default/config.json","w") { |f| f.write default_config.merge({ "keypair" => keypair }) }
+			puts "congratulations! - you're ready to go!"
+		end
+	end
+end

data/lib/group.rb

@@ -0,0 +1,166 @@
+module Judo
+	class Group
+		attr_accessor :name, :dir
+
+    def self.dirs
+      Dir["#{Judo::Config.repo_dir}/*/config.json"].map { |d| File.dirname(d) }
+    end
+
+		def self.all
+			@@all ||= (dirs.map { |d| new(d) } << Group.new(Judo::Config.judo_dir, "default"))
+		end
+
+		def self.find(name)
+			all.detect { |d| d.name == name }
+		end
+
+		def self.[](name)
+			find(name)
+		end
+
+    def self.current
+      all.detect { |d| Dir.pwd == d.dir or Dir.pwd =~ /^#{d.dir}\// } || find("default")
+    end
+
+		def initialize(dir, name = File.basename(dir))
+			@name = name
+			@dir = dir
+		end
+
+		def create_server(server_name)
+      abort("Server needs a name") if server_name.nil?
+#     abort("Already a server named #{server_name}") if Judo::Server.find_by_name(attrs[:name])  ## FIXME
+#     Judo::Config.read_config(attrs[:group]) ## make sure the config is valid  ## FIXME
+
+      server = Judo::Server.new server_name, self
+      server.task("Creating server #{server_name}") do
+      	server.update "name" => server_name, "group" => name, "virgin" => true, "secret" => rand(2 ** 128).to_s(36)
+				Judo::Config.sdb.put_attributes("judo_config", "groups", name => server_name)
+			end
+			server
+		end
+		
+		def config
+			@config ||= self.class.load_all(self)
+		end
+	
+		def server_names
+			Judo::Config.sdb.get_attributes("judo_config", "groups", @name)[:attributes][@name] || []
+		end
+
+		def servers
+			server_names.map { |n| Judo::Server.new(n, self) }
+		end
+
+		def compile
+			tmpdir = "/tmp/kuzushi/#{name}"
+			FileUtils.rm_rf(tmpdir)
+			FileUtils.mkdir_p(tmpdir)
+			Dir.chdir(tmpdir) do |d|
+				attachments.each do |to,from|
+					FileUtils.mkdir_p(File.dirname(to))
+					FileUtils.cp(from,to)
+				end
+				File.open("config.json", "w") { |f| f.write(config.to_json) }
+				Dir.chdir("..") do
+					system "tar czvf #{tar_file} #{name}"
+					puts "Uploading to s3..."
+					Judo::Config.s3_put(tar_file, File.new(tar_file))
+				end
+			end
+		end
+
+		def tar_file
+			"#{name}.tar.gz"
+		end
+
+		def s3_url 
+			@url = Judo::Config.s3_url(tar_file)
+		end
+
+		def cp_file
+			FileUtil.mkdir_p(tmpdir)
+		end
+
+		def parent
+			self.class.find(config["import"])
+		end
+
+		def extract_file(type, name, files)
+			path = "#{dir}/#{type}s/#{name}"
+      found = Dir[path]
+			if not found.empty?
+				found.each { |f| files["#{type}s/#{File.basename(f)}"] = f }
+			elsif parent
+				parent.extract_file(type, name, files)
+			else
+				raise "Cannot find file #{name} of type #{type}"
+			end
+		end
+
+		def extract(config, files)
+			config.each do |key,value|
+				[value].flatten.each do |v|   ### cover "packages" : ["a","b"], "packages" : "a", "packages":[{ "file" : "foo.pkg"}]
+					extract(v, files) if v.is_a? Hash
+					case key
+						when *[ "init", "before", "after" ]
+							extract_file(:script, v, files) unless v =~ /^#!/
+						when "local_packages"
+							extract_file(:package, "#{v}*", files)
+						when "template"
+							extract_file(:template, v, files)
+						when "source"
+							extract_file(:file, v, files) unless config["template"]
+						when "file"
+							extract_file(:file, File.basename(v), files) unless config["template"] or config["source"]
+					end
+				end
+			end
+			files
+		end
+
+		def keypair_file
+			(attachments.select { |a| File.basename(config["keypair"]) }) || fail("no keypair_file specified")
+		end
+
+		def attachments
+			extract(config, {})
+		end
+
+		def self.load_all(group, configs = [])
+      return configs.reverse.inject(Judo::Config.defaults) { |sum,conf| sum.merge(conf) } unless group
+			raw_config = group.read_config
+			load_all(find(raw_config["import"]), configs << raw_config)
+		end
+
+		def config_file
+				return "#{dir}/defaults.json" if name == "default"
+        "#{dir}/config.json"
+		end
+
+    def read_config
+      begin
+        JSON.parse(File.read(config_file))
+      rescue Errno::ENOENT
+        {}
+      end
+    end
+
+		def delete_server(server)
+			sdb.delete_attributes("judo_config", "groups", name => server.name)
+		end
+
+		def default?
+			false
+		end
+
+		def to_s
+			name
+		end
+
+		def sdb
+			Judo::Config.sdb
+		end
+	end
+end
+

data/lib/server.rb

@@ -0,0 +1,462 @@
+### NEEDED for new gem launch
+
+### 32 hrs to go - 12:00am Feb 26th - expected completion Mar 2
+### [ ] judo init (2 hrs)
+### [ ] implement real default config - remove special case code (3 hrs)
+### [ ] complete slug compile - load into s3 (4 hrs)
+### [ ] refactor availability_zone (2 hrs)
+### [ ] refactor keypair.pem setup (3 hrs)
+### [ ] implement auto security_group creation and setup (6 hrs)
+### [ ] version in the db - require upgrade of gem if db version ahead (1 hr)
+### [ ] write some examples - simple postgres/redis/couchdb server (5hrs)
+### [ ] two phase delete (1 hr)
+### [ ] write new README (4 hrs)
+### [ ] realase new gem! (1 hr)
+
+### [ ] user a logger service (1 hr)
+### [ ] write 4 simple specs (1 hr)
+
+### Do Later
+### [ ] use amazon's new conditional write tools so we never have problems from concurrent updates
+### [ ] is thor really what we want to use here?
+### [ ] need to be able to pin a config to a version of kuzushi - gem updates can/will break a lot of things
+### [ ] I want a "judo monitor" command that will make start servers if they go down, and poke a listed port to make sure a service is listening, would be cool if it also detects wrong ami, wrong secuirity group, missing/extra volumes, missing/extra elastic_ip - might not want to force a reboot quite yet in these cases
+### [ ] Implement "judo snapshot [NAME]" to take a snapshot of the ebs's blocks
+### [ ] ruby 1.9.1 support
+### [ ] find a good way to set the hostname or prompt to :name
+### [ ] remove fog/s3 dependancy
+### [ ] enforce template files end in .erb to make room for other possible templates as defined by the extensions
+### [ ] zerigo integration for automatic DNS setup
+### [ ] How cool would it be if this was all reimplemented in eventmachine and could start lots of boxes in parallel?  Would need to evented AWS api calls... Never seen a library to do that - would have to write our own... "Fog Machine?"
+
+module Judo
+	class Server
+		attr_accessor :name, :group
+
+		def initialize(name, group)
+			@name = name
+			@group = group
+		end
+
+### Getting things in and out of SimpleDB - would be nice if it were a plugin so we could use another store if need db (couchdb/mongo/sql)
+
+		def self.migrate
+			require 'pp'
+			x = {}
+			Judo::Config.sdb.delete_domain("judo_servers")
+			Judo::Config.sdb.create_domain("judo_servers")
+			Judo::Config.sdb.delete_domain("judo_config")
+			Judo::Config.sdb.create_domain("judo_config")
+			Judo::Config.sdb.select("SELECT * FROM sumo_server").items.each do |chunk|
+				chunk.each do |uid,item|
+					name = item["name"] || "missing_#{rand(2**32).to_s(36)}"
+					group = (item["group"] || "default")
+					data = {
+						"group" => (item["group"] || "default" ), "name" => name,
+						"secret" => item["secret"], "elastic_ip" => item["elastic_ip"],
+						"volumes" => (item["volumes_flat"] || JSON.parse(item["volumes_json"] || "[]").map { |k,v| "#{k}:#{v}" }),
+						"instance_id" => item["instance_id"], "virgin" => item["virgin"]
+					}.delete_if { |k,v| v == [] or v == nil or v == [nil] }
+					pp data
+					Judo::Config.sdb.put_attributes("judo_servers", name, data, :replace)
+					Judo::Config.sdb.put_attributes("judo_config", "groups", group => name)
+				end
+			end
+			"ok"
+		end
+
+		def domain
+			"judo_servers"
+		end
+
+		def sdb
+			Judo::Config.sdb
+		end
+
+		def fetch_state
+			Judo::Config.sdb.get_attributes(domain, name)[:attributes]
+		end
+
+		def super_state
+			@@state ||= {}
+		end
+
+		def state
+			super_state[name] ||= fetch_state
+		end
+
+		def get(key)
+			state[key] && [state[key]].flatten.first
+		end
+
+		def instance_id
+			get "instance_id"
+		end
+
+		def elastic_ip
+			get "elastic_ip"
+		end
+
+		def virgin?
+			get("virgin").to_s == "true"  ## I'm going to set it to true and it will come back from the db as "true" -> could be "false" or false or nil also
+		end
+
+		def secret
+			get "secret"
+		end
+
+		def volumes
+			Hash[ (state["volumes"] || []).map { |a| a.split(":") } ]
+		end
+
+		def update(attrs)
+			sdb.put_attributes(domain, name, attrs, :replace)
+			state.merge! attrs
+		end
+
+		def add(key, value)
+			sdb.put_attributes(domain, name, { key => value })
+			(state[key] ||= []) << value
+		end
+
+		def remove(key, value = nil)
+			if value
+				sdb.delete_attributes(domain, name, key => value)
+				state[key] - [value]
+			else
+				sdb.delete_attributes(domain, name, [ key ])
+				state.delete(key)
+			end
+		end
+
+		def delete
+			group.delete_server(self)
+			sdb.delete_attributes(domain, name)
+		end
+
+######## end simple DB access  #######
+
+		def instance_size
+			config["instance_size"]
+		end
+
+		def config
+			group.config
+		end
+
+		def to_s
+			"#{group}:#{name}"
+		end
+
+		def allocate_resources
+			if config["volumes"]
+				config["volumes"].each do |volume_config|
+					device = volume_config["device"]
+					if volume_config["media"] == "ebs"
+						size = volume_config["size"]
+						if not volumes[device]
+							task("Creating EC2 Volume #{device} #{size}") do
+								### EC2 create_volume
+								volume_id = Judo::Config.ec2.create_volume(nil, size, config["availability_zone"])[:aws_id]
+								add_volume(volume_id, device)
+							end
+						else
+							puts "Volume #{device} already exists."
+						end
+					else
+						puts "device #{device || volume_config["mount"]} is not of media type 'ebs', skipping..."
+					end
+				end
+			end
+
+			begin
+				if config["elastic_ip"] and not elastic_ip
+					### EC2 allocate_address
+					task("Adding an elastic ip") do 
+						ip = Judo::Config.ec2.allocate_address
+						add_ip(ip)
+					end
+				end
+			rescue Aws::AwsError => e
+				if e.message =~ /AddressLimitExceeded/
+					abort "Failed to allocate ip address: Limit Exceeded"
+				else
+					raise
+				end
+			end
+		end
+
+		def task(msg, &block)
+			self.class.task(msg, &block)
+		end
+
+		def self.task(msg, &block)
+			printf "---> %-24s ", "#{msg}..."
+			STDOUT.flush
+			start = Time.now
+			result = block.call
+			result = "done" unless result.is_a? String
+			finish = Time.now
+			time = sprintf("%0.1f", finish - start)
+			puts "#{result} (#{time}s)"
+			result
+		end
+
+		def has_ip?
+			!!elastic_ip
+		end
+
+		def has_volumes?
+			not volumes.empty?
+		end
+
+		def ec2_volumes
+			return [] if volumes.empty?
+			Judo::Config.ec2.describe_volumes( volumes.values )
+		end
+
+		def remove_ip
+			Judo::Config.ec2.release_address(elastic_ip) rescue nil
+			remove "elastic_ip"
+		end
+
+		def destroy
+			stop if running?
+			### EC2 release_address
+			task("Deleting Elastic Ip") { remove_ip } if has_ip?
+			volumes.each { |dev,v| remove_volume(v,dev) }
+			task("Destroying server #{name}") { delete }
+		end
+
+		def ec2_state
+			ec2_instance[:aws_state] rescue "offline"
+		end
+
+		def ec2_instance
+			### EC2 describe_instances
+			@@ec2_list ||= Config.ec2.describe_instances
+			@@ec2_list.detect { |e| e[:aws_instance_id] == instance_id } or {}
+		end
+
+		def running?
+			## other options are "terminated" and "nil"
+			["pending", "running", "shutting_down", "degraded"].include?(ec2_state)
+		end
+
+		def start
+			abort "Already running" if running?
+			task("Starting server #{name}")      { launch_ec2 }
+			task("Acquire hostname")             { wait_for_hostname }
+			task("Wait for ssh")                 { wait_for_ssh }
+			task("Attaching ip")                 { attach_ip } if elastic_ip
+			task("Attaching volumes")            { attach_volumes } if has_volumes?
+		end
+
+		def restart
+			stop if running?
+			start
+		end
+
+		def generic_name?
+			name =~ /^#{group}[.]\d*$/
+		end
+
+		def generic?
+			volumes.empty? and not has_ip? and generic_name?
+		end
+
+		def stop
+			abort "not running" unless running?
+			## EC2 terminate_isntaces
+			task("Terminating instance") { Config.ec2.terminate_instances([ instance_id ]) }
+			task("Wait for volumes to detach") { wait_for_volumes_detached } if volumes.size > 0
+			remove "instance_id" 
+		end
+
+		def launch_ec2
+			validate
+
+			## EC2 launch_instances
+			result = Config.ec2.launch_instances(ami,
+				:instance_type => config["instance_size"],
+				:availability_zone => config["availability_zone"],
+				:key_name => config["key_name"],
+				:group_ids => [config["security_group"]],
+				:user_data => user_data).first
+
+			update "instance_id" => result[:aws_instance_id], "virgin" => false
+#			remove "virgin"
+		end
+
+		def console_output
+			### EC2 get_console_output
+			Config.ec2.get_console_output(instance_id)[:aws_output]
+		end
+
+		def ami
+			ia32? ? config["ami32"] : config["ami64"]
+		end
+
+		def ia32?
+			["m1.small", "c1.medium"].include?(instance_size)
+		end
+
+		def ia64?
+			not ia32?
+		end
+
+		def hostname
+			ec2_instance[:dns_name] == "" ? nil : ec2_instance[:dns_name]
+		end
+
+		def wait_for_hostname
+			loop do
+				reload
+				return hostname if hostname
+				sleep 1
+			end
+		end
+
+		def wait_for_volumes_detached
+			loop do
+				break if ec2_volumes.reject { |v| v[:aws_status] == "available" }.empty?
+				sleep 2
+			end
+		end
+
+		def wait_for_termination
+			loop do
+				reload
+				break if ec2_instance[:aws_state] == "terminated"
+				sleep 1
+			end
+		end
+
+		def wait_for_ssh
+			abort "not running" unless running?
+			loop do
+				begin
+					Timeout::timeout(4) do
+						TCPSocket.new(hostname, 22)
+						return
+					end
+				rescue SocketError, Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+				end
+			end
+		end
+
+		def add_ip(public_ip)
+			update "elastic_ip" => public_ip
+			attach_ip
+		end
+
+		def attach_ip
+			return unless running? and elastic_ip
+			### EC2 associate_address
+			Config.ec2.associate_address(instance_id, elastic_ip)
+		end
+		
+		def dns_name
+			return nil unless elastic_ip
+			`dig +short -x #{elastic_ip}`.strip
+		end
+
+		def attach_volumes
+			return unless running?
+			volumes.each do |device,volume_id|
+				### EC2 attach_volume
+				Config.ec2.attach_volume(volume_id, instance_id, device)
+			end
+		end
+
+		def remove_volume(volume_id, device)
+			task("Deleting #{device} #{volume_id}") do
+				### EC2 delete_volume
+				Judo::Config.ec2.delete_volume(volume_id)
+				remove "volumes", "#{device}:#{volume_id}"
+			end
+		end
+
+		def add_volume(volume_id, device)
+			abort("Server already has a volume on that device") if volumes[device]
+
+			add "volumes", "#{device}:#{volume_id}"
+
+			Config.ec2.attach_volume(volume_id, instance_id, device) if running?
+
+			volume_id
+		end
+
+		def connect_ssh
+			abort "not running" unless running?
+			system "ssh -i #{group.keypair_file} #{config["user"]}@#{hostname}"
+		end
+		
+		def self.commit
+			Config.group_dirs.each do |group_dir|
+				group = File.basename(group_dir)
+				next if Config.group and Config.group != group
+				puts "commiting #{group}"
+				doc = Config.couchdb.get(group) rescue {}
+				config = Config.read_config(group)
+				config['_id'] = group
+				config['_rev'] = doc['_rev'] if doc.has_key?('_rev')
+				response = Config.couchdb.save_doc(config)
+				doc = Config.couchdb.get(response['id'])
+
+				# walk subdirs and save as _attachments
+				['files', 'templates', 'packages', 'scripts'].each { |subdir|
+					Dir["#{group_dir}/#{subdir}/*"].each do |f|
+						puts "storing attachment #{f}"
+						doc.put_attachment("#{subdir}/#{File.basename(f)}", File.read(f))
+					end
+				}
+			end
+		end
+
+		def ip
+			hostname || config["state_ip"]
+		end
+
+		def reload
+			@@ec2_list = nil
+			super_state.delete(name)
+		end
+
+		def user_data
+			<<USER_DATA
+#!/bin/sh
+
+export DEBIAN_FRONTEND="noninteractive"
+export DEBIAN_PRIORITY="critical"
+export SECRET='#{secret}'
+apt-get update
+apt-get install ruby rubygems ruby-dev irb libopenssl-ruby libreadline-ruby -y
+gem install kuzushi --no-rdoc --no-ri
+GEM_BIN=`ruby -r rubygems -e "puts Gem.bindir"`
+$GEM_BIN/kuzushi #{virgin? && "init" || "start"} #{url}
+USER_DATA
+		end
+
+		def url
+			"#{Judo::Config.couch_url}/#{group}"
+		end
+
+		def validate
+			### EC2 create_security_group
+			Judo::Config.create_security_group
+
+			### EC2 desctibe_key_pairs
+			k = Judo::Config.ec2.describe_key_pairs.detect { |kp| kp[:aws_key_name] == config["key_name"] }
+
+			if k.nil?
+				if config["key_name"] == "judo"
+					Judo::Config.create_keypair
+				else
+					raise "cannot use key_pair #{config["key_name"]} b/c it does not exist"
+				end
+			end
+		end
+		
+	end
+end

data/spec/base.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../lib/all'
+
+require 'bacon'
+require 'mocha/standalone'
+require 'mocha/object'
+
+class Bacon::Context
+	include Mocha::API
+
+	def initialize(name, &block)
+		@name = name
+		@before, @after = [
+			[lambda { mocha_setup }],
+			[lambda { mocha_verify ; mocha_teardown }]
+		]
+		@block = block
+	end
+
+	def xit(desc, &bk)
+	end
+end

data/spec/server_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/base'
+
+describe Judo::Server do
+	before do
+	end
+	
+	it "creates a new server" do
+	end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: judo
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Orion Henry
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-02 00:00:00 -08:00
+default_executable: judo
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: aws
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: thor
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A no-hassle way to launch one-off EC2 instances from the command line
+email: orion@heroku.com
+executables: 
+- judo
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/judo
+- lib/all.rb
+- lib/config.rb
+- lib/group.rb
+- lib/server.rb
+- spec/base.rb
+- spec/server_spec.rb
+has_rdoc: true
+homepage: http://github.com/orionz/judo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: judo
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A no-hassle way to launch one-off EC2 instances from the command line
+test_files: 
+- spec/base.rb
+- spec/server_spec.rb