judo 0.0.1 → 0.0.3

data/README.rdoc

@@ -1,82 +1,4 @@
-= 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.
+= Judo
 
 == Meta
 
@@ -86,5 +8,5 @@ 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
+http://github.com/orionz/judo
 

data/Rakefile

@@ -2,7 +2,7 @@ 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.description = "The gentile way to manage and control ec2 instances"
 	s.summary = s.description
 	s.author = "Orion Henry"
 	s.email = "orion@heroku.com"
@@ -14,6 +14,7 @@ Jeweler::Tasks.new do |s|
 	s.add_dependency "aws"
 	s.add_dependency "thor"
 	s.add_dependency "json"
+	s.add_dependency "fog"
 end
 
 Jeweler::RubyforgeTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.3

data/bin/judo

@@ -2,8 +2,6 @@
 
 require File.dirname(__FILE__) + '/../lib/all'
 
-#Sumo::Config.connect
-
 require 'thor'
 
 class CLI < Thor
@@ -30,7 +28,7 @@ class CLI < Thor
 
 	desc "create NAME", "create a persistent server"
 	def create(name, start = false)
-		group = Sumo::Group.current
+		group = Judo::Group.current
 		if name =~ /^[+](\d*)/
 			n = $1.to_i
 			fail "woah nelly - that's too many - 5 or less pls" if n > 5
@@ -97,27 +95,28 @@ class CLI < Thor
 #			pp server.volumes.inspect
 #			puts server.state.inspect
 				## EC2 describe_volumes
-#				puts "	#{dev.to_s}:#{Sumo::Config.ec2.describe_volumes([vol_id])}"
+#				puts "	#{dev.to_s}:#{Judo::Config.ec2.describe_volumes([vol_id])}"
 #			end
 		end
 	end
 
 	desc "list [NAMES]", "list all servers"
 	def list(*names)
-		if group = Sumo::Group.current
+		if group = Judo::Group.current
+			printf "  SERVER IN GROUP #{group.name}\n"
 			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
+				printf "%-18s %-4s %-11s %-11s %-13s %-10s %-10s %s\n", s.name, s.version_desc, 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|
+			Judo::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
+#		else
 		end
 	end
 
@@ -132,9 +131,9 @@ class CLI < Thor
 		end
 	end
 
-	desc "init", "create a new sumo repository in the current directory"
+	desc "init", "create a new judo repository in the current directory"
 	def init
-		Sumo::Config.init
+		Judo::Setup.new.init
 	end
 
 	desc "volumes", "list all volumes"
@@ -143,8 +142,8 @@ class CLI < Thor
 		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]) ]
+		Judo::Config.ec2.describe_volumes.map do |volume|
+			[ volume[:aws_id], volume[:aws_size], volume[:aws_status], volume[:aws_device] || "", instance_id_to_judo(volume[:aws_instance_id]) || volume[:aws_instance_id] || "", volume_id_to_judo(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
@@ -156,8 +155,8 @@ class CLI < Thor
 		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]) ]
+		Judo::Config.ec2.describe_addresses.map do |ip|
+			[ ip[:public_ip], instance_id_to_judo(ip[:instance_id]) || ip[:instance_id], ip_to_judo(ip[:public_ip]) ]
 		end.sort { |a,b| a[2].to_s <=> b[2].to_s }.each do |d|
 			printf format, *d
 		end
@@ -165,13 +164,12 @@ class CLI < Thor
 
 	desc "commit", "push configs and files to couchdb"
 	def commit
-#		group = Sumo::Config.group
-		Sumo::Server.commit
+		Judo::Group.current.compile
   end
 
 	no_tasks do
 		def servers(*names, &block)
-			group = Sumo::Group.current
+			group = Judo::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?
@@ -195,16 +193,16 @@ class CLI < Thor
 			result
 		end
 
-		def volume_id_to_sumo(volume)
-			Sumo::Server.all.detect { |s| s.volumes.invert[volume] }
+		def volume_id_to_judo(volume)
+			Judo::Server.all.detect { |s| s.volumes.invert[volume] }
 		end
 
-		def ip_to_sumo(ip)
-			Sumo::Server.all.detect { |s| s.state["elastic_ip"] == ip }
+		def ip_to_judo(ip)
+			Judo::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 }
+		def instance_id_to_judo(instance_id)
+			Judo::Server.all.detect { |s| s.state["instance_id"] and s.state["instance_id"] == instance_id }
 		end
 	end
 end

data/lib/all.rb

@@ -1,11 +1,9 @@
 require 'rubygems'
 require 'aws'
 require 'right_aws'
-require 'sdb/active_sdb' ##
 require 'yaml'
 require 'socket'
 require 'json'
-require 'couchrest'  ##
 require 'fileutils'
 
 require 'fog'
@@ -14,4 +12,4 @@ 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'
+require File.dirname(__FILE__) + '/setup'

data/lib/config.rb

@@ -2,123 +2,49 @@ 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)
+		def method_missing?(method)
 		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?
-			}
+		def db_version
+			1
 		end
 
-#		def merged_config(name)
-#			stack = load_config_stack(name)
-#			stack.reverse.inject({}) { |sum,conf| sum.merge(conf) }
-#		end
+		def get_db_version
+      version = @sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"]
+			version and version.first.to_i or db_version
+		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 check_version
+			fail "judo db is newer than the current gem - upgrade judo and try again" if get_db_version > db_version
+		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")
+			judo_config["access_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")
+			judo_config["access_secret"]
 		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"
+		def get_ec2(aws_id, aws_key)
+			Aws::Ec2.new(aws_id, aws_key, :logger => Logger.new(nil))
 		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
+		def ec2
+			@ec2 ||= get_ec2(access_id, access_secret)
 		end
 
-#		def setup?
-#			Sumo::Server.connection.list_domains[:domains].include? Sumo::Server.domain
+#		def create_security_group
+#			## EC2 create_security_group
+#			ec2.create_security_group('judo', 'Judo')
+#			## EC2 authorize_security_group
+#			ec2.authorize_security_group_IP_ingress("judo", 22, 22,'tcp','0.0.0.0/0')
+#		rescue Aws::AwsError
 #		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
@@ -150,14 +76,19 @@ module Judo
 			{}
 		end
 
+		def get_sdb(aws_id, aws_key)
+			puts "GET SDB #{aws_id} #{aws_key}"
+			Aws::SdbInterface.new(aws_id, aws_key, :logger => Logger.new(nil))
+		end
+
 		def sdb
-			@sdb = Aws::SdbInterface.new(access_id, access_secret, :logger => Logger.new(nil))
+			@sdb ||= get_sdb(access_id, access_secret)
+			@version_ok ||= check_version
+			@sdb
 		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)
+      @s3 ||= Fog::AWS::S3.new( :aws_access_key_id => access_id, :aws_secret_access_key => access_secret)
 		end
 
 		def s3_url(k)
@@ -167,67 +98,5 @@ module Judo
 		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

@@ -2,12 +2,12 @@ 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.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"))
+			@@all ||= (dirs.map { |d| new(d) })
 		end
 
 		def self.find(name)
@@ -18,9 +18,9 @@ module Judo
 			find(name)
 		end
 
-    def self.current
-      all.detect { |d| Dir.pwd == d.dir or Dir.pwd =~ /^#{d.dir}\// } || find("default")
-    end
+		def self.current
+			all.detect { |d| Dir.pwd == d.dir or Dir.pwd =~ /^#{d.dir}\// }
+		end
 
 		def initialize(dir, name = File.basename(dir))
 			@name = name
@@ -28,13 +28,13 @@ module Judo
 		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
+			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)
+			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
@@ -45,15 +45,27 @@ module Judo
 		end
 	
 		def server_names
-			Judo::Config.sdb.get_attributes("judo_config", "groups", @name)[:attributes][@name] || []
+			Judo::Config.sdb.get_attributes("judo_config", "groups")[:attributes][@name] || []
 		end
 
 		def servers
 			server_names.map { |n| Judo::Server.new(n, self) }
 		end
 
+		def version
+			@version ||= (Judo::Config.sdb.get_attributes("judo_config", "group_versions")[:attributes][@name] || ["0"]).first.to_i
+			@version ||= (Judo::Config.sdb.get_attributes("judo_config", "group_versions")[:attributes][@name] || ["0"]).first.to_i
+		end
+
+		def set_version(new_version)
+			@version = new_version
+			Judo::Config.sdb.put_attributes("judo_config", "group_versions", { name => new_version }, :replace)
+		end
+
 		def compile
 			tmpdir = "/tmp/kuzushi/#{name}"
+			set_version(version + 1)
+			puts "Compiling version #{version}"
 			FileUtils.rm_rf(tmpdir)
 			FileUtils.mkdir_p(tmpdir)
 			Dir.chdir(tmpdir) do |d|
@@ -71,7 +83,7 @@ module Judo
 		end
 
 		def tar_file
-			"#{name}.tar.gz"
+			"#{name}.#{version}.tar.gz"  ## FIXME needs to incorprate #{config version} "#{name}.#{version}.tar.gz"
 		end
 
 		def s3_url 
@@ -88,7 +100,7 @@ module Judo
 
 		def extract_file(type, name, files)
 			path = "#{dir}/#{type}s/#{name}"
-      found = Dir[path]
+			found = Dir[path]
 			if not found.empty?
 				found.each { |f| files["#{type}s/#{File.basename(f)}"] = f }
 			elsif parent
@@ -128,32 +140,27 @@ module Judo
 		end
 
 		def self.load_all(group, configs = [])
-      return configs.reverse.inject(Judo::Config.defaults) { |sum,conf| sum.merge(conf) } unless group
+			return configs.reverse.inject({}) { |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"
+			"#{dir}/config.json"
 		end
 
-    def read_config
-      begin
-        JSON.parse(File.read(config_file))
-      rescue Errno::ENOENT
-        {}
-      end
-    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

data/lib/server.rb

@@ -1,20 +1,28 @@
 ### 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)
+### [X] judo init (2 hrs)
+### [X] implement real default config - remove special case code (3 hrs)
+### [X] refactor keypair.pem setup (3 hrs)
+### [X] version in the db - require upgrade of gem if db version ahead (1 hr)
+### [X] implement multiple security groups (1 hr)
+### [-] complete slug compile - load into s3 (4 hrs)
+###     [X] compile and put in s3
+###     [X] attach and increment version number
+###     [X] list version number on "judo list"
+###     [ ] update kuzushi to pull down a compiled tar.gz
+###     [ ] error if version is blank
+### [ ] two phase delete (1 hr)
+### [-] refactor availability_zone (2 hrs)
+###     [ ] pick availability zone from config "X":"Y" or  "X":["Y","Z"]
+###     [ ] assign to state on creation ( could delay till volume creation )
 ### [ ] 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)
+### [ ] write specs (5 hr)
 
 ### Do Later
 ### [ ] use amazon's new conditional write tools so we never have problems from concurrent updates
@@ -97,6 +105,18 @@ module Judo
 			get "elastic_ip"
 		end
 
+		def version_desc
+			if version.to_i == group.version.to_i
+				"v#{version}"
+			else
+				"v#{version}/#{group.version}"
+			end
+		end
+
+		def version
+			get "version"
+		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
@@ -274,20 +294,24 @@ module Judo
 		end
 
 		def launch_ec2
-			validate
+#			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"]],
+				:group_ids => security_groups,
 				:user_data => user_data).first
 
-			update "instance_id" => result[:aws_instance_id], "virgin" => false
+			update "instance_id" => result[:aws_instance_id], "virgin" => false, "version" => group.version
 #			remove "virgin"
 		end
 
+		def security_groups
+			[ config["security_group"] ].flatten
+		end
+
 		def console_output
 			### EC2 get_console_output
 			Config.ec2.get_console_output(instance_id)[:aws_output]
@@ -439,7 +463,7 @@ USER_DATA
 		end
 
 		def url
-			"#{Judo::Config.couch_url}/#{group}"
+			group.s3_url
 		end
 
 		def validate

data/lib/setup.rb

@@ -0,0 +1,115 @@
+module Judo
+	class Setup
+		def default_config
+				<<DEFAULT
+{
+	"key_name":"#{@keypair}",
+	"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":"judo",
+	"availability_zone":"us-east-1d"
+}
+DEFAULT
+		end
+
+		def getenv(key)
+			printf "Looking in your environment for #{key}..."
+			printf "found!" if ENV[key]
+			printf "\n"
+			ENV[key]
+		end
+
+		def request(query, default = "")
+			printf "#{query} ['#{default}']: "
+			input = STDIN.readline.strip
+			input.empty? and default or input 
+		end
+
+		def failure(msg)
+			puts msg
+			exit 1
+		end
+
+		def check_setup
+			failure "you are already inside a judo repository" if Judo::Config.find_judo_dir(Dir.pwd)
+			failure "./.git not found - judo configurations must be kept in a git repo.  type 'git init' to setup the git repo." unless File.exists? "./.git"
+		end
+
+		def init
+			check_setup
+			@aws_access_id  ||= getenv('AWS_ACCESS_KEY_ID')
+			@aws_access_id  ||= getenv('AWS_ACCESS_KEY_ID')
+			@aws_secret_key ||= getenv('AWS_SECRET_ACCESS_KEY')
+			@aws_secret_key ||= getenv('AMAZON_SECRET_ACCESS_KEY')
+			@s3_bucket      ||= getenv('JUDO_S3_BUCKET')
+			@s3_bucket      ||= "judo_#{rand(2**64).to_s(36)}"
+			begin
+				@aws_access_id  = request("Please enter your AWS access key",  @aws_access_id)
+				@aws_secret_key = request("Please enter your AWS secret key" , @aws_secret_key)
+				@s3_bucket      = request("Please enter an S3 bucket to use",  @s3_bucket)
+
+				setup_default_server_group
+				setup_default_security_group
+				setup_bucket
+				setup_db
+				setup_judo_config
+
+			rescue *[Interrupt, EOFError]
+				puts "\nGoodbye!"
+				exit(0)
+			rescue Object => e
+				puts "There was an error: #{e.class}:#{e.message}"
+				puts "Try again or hit CTRL-C"
+				retry
+			end
+		end
+
+		def setup_db
+			puts "Trying to connect to SimpleDB with #{@aws_access_id}"
+			sdb.create_domain("judo_servers")
+			sdb.create_domain("judo_config")
+      olddb = sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"]
+			failure "There is an existing judo database of a newer version - upgrade judo and try again" if olddb and olddb.first.to_i > Judo::Config.db_version
+			sdb.put_attributes("judo_config", "judo", { "dbversion" => Judo::Config.db_version }, :replace)
+		end
+
+		def setup_default_security_group
+			ec2.create_security_group('judo', 'Judo')
+			ec2.authorize_security_group_IP_ingress("judo", 22, 22,'tcp','0.0.0.0/0')
+		end
+
+		def setup_bucket
+			puts "setting up an s3 bucket"
+   		Fog::AWS::S3.new(:aws_access_key_id => @aws_access_id, :aws_secret_access_key => @aws_secret_key).put_bucket(@s3_bucket)
+		end
+
+		def setup_default_server_group
+			puts "Setting up default group and keypair"
+			system "mkdir -p default/keypairs"
+
+			@keypair = "judo#{ec2.describe_key_pairs.map { |k| k[:aws_key_name] }.map { |k| k =~ /^judo(\d*)/; $1.to_i }.sort.last.to_i + 1}"
+			material = ec2.create_key_pair(@keypair)[:aws_material]
+
+			File.open("default/keypairs/#{@keypair}.pem", 'w') { |f| f.write material }
+			File.chmod 0600, "default/keypairs/#{@keypair}.pem"
+			File.open("default/config.json","w") { |f| f.write default_config }
+		end
+
+		def setup_judo_config
+			puts "setting up an .judo/config.yml"
+			system "mkdir .judo"
+			File.open(".judo/config.yml","w") { |f| f.write({ "access_id" => @aws_access_id, "access_secret" => @aws_secret_key, "s3_bucket" => @s3_bucket }.to_yaml) }
+		end
+
+		def ec2
+			@ec2 ||= Judo::Config.get_ec2(@aws_access_id, @aws_secret_key)
+		end
+
+		def sdb
+			@sdb ||= Judo::Config.get_sdb(@aws_access_id, @aws_secret_key)
+		end
+
+	end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: judo
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Orion Henry
@@ -9,50 +14,70 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-02 00:00:00 -08:00
+date: 2010-03-03 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 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: aws
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: thor
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: json
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: fog
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
-description: A no-hassle way to launch one-off EC2 instances from the command line
+  type: :runtime
+  version_requirements: *id005
+description: The gentile way to manage and control ec2 instances
 email: orion@heroku.com
 executables: 
 - judo
@@ -69,6 +94,7 @@ files:
 - lib/config.rb
 - lib/group.rb
 - lib/server.rb
+- lib/setup.rb
 - spec/base.rb
 - spec/server_spec.rb
 has_rdoc: true
@@ -84,21 +110,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: judo
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: A no-hassle way to launch one-off EC2 instances from the command line
+summary: The gentile way to manage and control ec2 instances
 test_files: 
 - spec/base.rb
 - spec/server_spec.rb