judo 0.0.9 → 0.1.0

data/Rakefile

@@ -10,8 +10,7 @@ Jeweler::Tasks.new do |s|
 	s.rubyforge_project = "judo"
 	s.files = FileList["[A-Z]*", "{bin,lib,spec}/**/*"]
 	s.executables = %w(judo)
-	s.add_dependency "aws",  [">= 2.3.1"]
-	s.add_dependency "thor", [">= 0.13.4"]
+	s.add_dependency "aws",  [">= 2.3.5"]
 	s.add_dependency "json"
 end
 

data/VERSION

@@ -1 +1 @@
-0.0.9
+0.1.0

data/bin/judo

@@ -1,217 +1,107 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../lib/all'
-
-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 "dump", "start one or more servers"
-	def dump
-		require 'pp'
-      pp Judo::Config.sdb.select("SELECT * FROM judo_servers")[:items]
-      pp Judo::Config.sdb.select("SELECT * FROM judo_config")[:items]
-	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 = get_current
-		if name =~ /^[+](\d*)/
-			n = $1.to_i
-			abort "woah nelly - that's too many - 5 or less pls" if n > 5
-			abort "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}:#{Judo::Config.ec2.describe_volumes([vol_id])}"
-#			end
-		end
-	end
-
-	desc "list [NAMES]", "list all servers"
-	def list(*names)
-		if group = Judo::Group.current
-			printf "  SERVER IN GROUP #{group.name}\n"
-			servers(*names) do |s|
-				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"
-			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
-		end
-	end
-
-	desc "console [NAMES]", "get console output for server or first available"
-	def console(*names)
-		servers(*names) do |server|
-			puts server.console_output
-		end
-	end
-
-	desc "init", "create a new judo repository in the current directory"
-	def init
-		Judo::Setup.new.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
-		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
-	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
-		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
-	end
-
-	desc "commit", "push configs and files to couchdb"
-	def commit
-		get_current.compile
-  end
+require 'optparse'
+require File.dirname(__FILE__) + '/../lib/judo'
+require File.dirname(__FILE__) + '/../lib/judo/commandline_helpers'
+
+include JudoCommandLineHelpers
+
+defaults = Judo::Base.default_options(Dir.pwd)
+
+options = {}
+
+action = ARGV.shift
+
+ARGV.unshift "-h" unless action
+
+optparse = OptionParser.new do|opts|
+  opts.banner = <<banner
+Usage: judo launch [options] SERVER ...
+       judo create [options] SERVER ...
+       judo destroy [options] SERVER ...
+
+       # SERVER can be formatted as NAME or NAME:GROUP or +N or +N:GROUP
+       # where N is the number of servers to create or launch
+       # 'launch' only differs from 'create' in that it immediately starts the server
+
+       judo start [options] [SERVER ...]
+       judo stop [options] [SERVER ...]
+       judo restart [options] [SERVER ...]
+
+       judo commit [options] GROUP
+
+       judo info [options] [SERVER ...]
+       judo console [options] [SERVER ...] ## shows AWS console output
+       judo ssh [options] [SERVER ...]     ## ssh's into the server
+
+       # SERVER can be formatted as NAME or NAME:GROUP
+       # or :GROUP to indicate the whole group.
+       # If no servers are listed all servers are assumed.
+
+       judo list [options]    ## lists all servers
+       judo groups [options]  ## lists all groups
 
-	no_tasks do
-		def servers(*names, &block)
-			group = get_current
-			good_servers = group.servers.select { |s| names.empty? or names.include?(s.name) }
-			bad_names = (names - good_servers.map(&:name))
-			abort "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 get_current
-			Judo::Group.current || abort("This command must be run on a group - change into a group folder directory (such as 'default')")
-		end
-
-		def volume_id_to_judo(volume)
-			Judo::Server.all.detect { |s| s.volumes.invert[volume] }
-		end
-
-		def ip_to_judo(ip)
-			Judo::Server.all.detect { |s| s.elastic_ip == ip }
-		end
-
-		def instance_id_to_judo(instance_id)
-			Judo::Server.all.detect { |s| s.instance_id and s.instance_id == instance_id }
-		end
-	end
+       judo volumes [options] ## shows all EBS volumes and what they are attached to
+       judo ips [options]     ## shows all elastic ips and what they are attached to
+
+banner
+
+  # start stop create destroy launch restart info console
+  # list volumes ips
+
+  opts.on( '-c', '--config DIR', 'Specify the location of the config dir' ) do |dir|
+    defaults[:judo_dir] = dir
+    defaults.merge(Judo::Base.default_options(Dir.pwd, dir))
+  end
+  opts.on( '-r', '--repo DIR', 'Specify the location of the repo dir' ) do |dir|
+    options[:repo] = dir
+  end
+  opts.on( '-a', '--accessid ID', 'Specify the AWS access ID' ) do |id|
+    options[:access_id] = id
+  end
+  opts.on( '-s', '--secret KEY', 'Specify the AWS access secret key' ) do |key|
+    options[:access_key] = key
+  end
+  opts.on( '-b', '--bucket BUCKET', 'Specify the AWS S3 bucket to use' ) do |bucket|
+    options[:bucket] = bucket
+  end
+  opts.on( '-g', '--group GROUP', 'Specify the default group of the repo dir' ) do |group|
+    options[:group] = group
+  end
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    exit
+  end
 end
 
-CLI.start
+optparse.parse!
+
+judo = Judo::Base.new(defaults.merge(options))
+
+begin
+  case action
+    when "ips" then do_ips(judo)
+    when "volumes" then do_volumes(judo)
+    when "list" then do_list(judo, ARGV)
+    when "groups" then do_groups(judo)
+    when "info" then find_servers(judo, ARGV)         { |s| do_info(judo, s) }
+    when "console" then find_servers(judo, ARGV)      { |s| puts server.console_output }
+    when "commit" then find_groups(judo, ARGV)        { |g| g.compile }
+    when "ssh" then find_servers(judo, ARGV)          { |s| s.connect_ssh }
+    when "start" then find_servers(judo, ARGV)        { |s| s.start }
+    when "restart" then find_servers(judo, ARGV)      { |s| s.restart }
+    when "stop" then find_servers(judo, ARGV)         { |s| s.stop }
+    when "create" then mk_servers(judo, ARGV)         { |s| s.create }
+    when "launch" then mk_servers(judo, ARGV)         { |s| s.create; s.start }
+    when "destroy" then
+      raise JudoError, "You must specify what servers to destroy" if ARGV.empty?
+      find_either(judo, ARGV) do |i|
+        i.destroy
+      end
+    else
+      raise JudoError, "No such action #{action}"
+  end
+rescue JudoError => e
+  puts "Error: #{e.message}"
+  exit 1
+end

data/lib/judo.rb

@@ -0,0 +1,18 @@
+require 'yaml'
+require 'socket'
+require 'fileutils'
+
+require 'rubygems'
+require 'right_aws'
+require 'json'
+require 'pp'
+
+class JudoError < RuntimeError ; end
+class JudoInvalid < RuntimeError ; end
+
+require File.dirname(__FILE__) + '/judo/base'
+require File.dirname(__FILE__) + '/judo/config'
+require File.dirname(__FILE__) + '/judo/group'
+require File.dirname(__FILE__) + '/judo/server'
+require File.dirname(__FILE__) + '/judo/setup'
+

data/lib/judo/base.rb

@@ -0,0 +1,199 @@
+module Judo
+  class Base
+    attr_accessor :judo_dir, :repo, :group
+
+    def initialize(options)
+      @judo_dir      = options[:judo_dir]
+      @repo          = options[:repo]
+      @group         = options[:group]
+      @bucket_name   = options[:bucket]
+      @access_id     = options[:access_id]
+      @access_secret = options[:access_secret]
+    end
+
+    def volumes
+      @volumes ||= ec2.describe_volumes.map do |v|
+        {
+          :id          => v[:aws_id],
+          :size        => v[:aws_size],
+          :status      => v[:aws_status],
+          :device      => v[:aws_device],
+          :instance_id => v[:aws_instance_id],
+          :attached_to => instance_id_to_judo(v[:aws_instance_id]),
+          :assigned_to => servers.detect { |s| s.volumes.invert[v[:aws_id]] }
+        }
+      end
+    end
+
+    def ips
+      @ips ||= ec2.describe_addresses.map do |ip|
+        {
+          :ip          => ip[:public_ip],
+          :instance_id => ip[:instance_id],
+          :attached_to => instance_id_to_judo(ip[:instance_id]),
+          :assigned_to => ip_to_judo(ip[:public_ip])
+        }
+      end
+    end
+
+    def self.default_options(pwd, dir = find_judo_dir(pwd))
+      config = YAML.load File.read("#{dir}/config.yml")
+      repo_dir = config["repo"] || File.dirname(dir)
+      group_config = Dir["#{repo_dir}/*/config.json"].detect { |d| File.dirname(d) == pwd }
+      {
+        :judo_dir      => dir,
+        :group         => group_config ? File.basename(File.dirname(group_config)) : nil,
+        :repo          => repo_dir,
+        :bucket        => config["s3_bucket"],
+        :access_id     => config["access_id"],
+        :access_secret => config["access_secret"]
+      }.delete_if { |key,value| value.nil? }
+    rescue Object => e
+      puts e.inspect
+      {}
+    end
+
+    def self.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 sdb
+      @sdb ||= Aws::SdbInterface.new(access_id, access_secret, :logger => Logger.new(nil))
+    end
+
+    def fetch_servers_state
+      s = {}
+      sdb.select("select * from #{Judo::Server.domain}")[:items].each do |group|
+        group.each do |key,val|
+          s[key] = val
+        end
+      end
+      s
+    end
+
+    def servers_state
+      @servers_state ||= fetch_servers_state
+    end
+
+    def servers
+      @servers ||= servers_state.map { |name,data| Judo::Server.new(self, name, data["group"].first) }
+    end
+
+    def new_server(name, group)
+      s = Judo::Server.new(self, name, group)
+      servers << s
+      s
+    end
+    
+    def get_group(name)
+      group = groups.detect { |g| g.to_s == name }
+      group ||= Judo::Group.new(self, name, 0)
+      group
+    end
+
+    def 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 groups
+      @groups ||= group_versions.map { |name,ver| Judo::Group.new(self, name, ver.first.to_i ) }
+    end
+
+    def reload_ec2_instances
+      @ec2_instance = nil
+    end
+
+    def ec2_instances
+      @ec2_instance ||= ec2.describe_instances
+    end
+
+    def ec2
+      @ec2 ||= Aws::Ec2.new(access_id, access_secret, :logger => Logger.new(nil))
+    end
+
+    def groups_config
+      @groups_config ||= sdb.get_attributes("judo_config", "groups")[:attributes]
+    end
+
+    def group_versions
+      @group_version ||= sdb.get_attributes("judo_config", "group_versions")[:attributes]
+    end
+
+    def ip_to_judo(ip)
+      servers.detect { |s| s.elastic_ip == ip }
+    end
+
+    def instance_id_to_judo(instance_id)
+      servers.detect { |s| s.instance_id and s.instance_id == instance_id }
+    end
+
+    def s3
+      @s3 ||= Aws::S3.new(access_id, access_secret, :logger => Logger.new(nil))
+    end
+
+    def bucket
+      @bucket ||= s3.bucket(bucket_name)
+    end
+
+    def s3_url(k)
+      Aws::S3Generator::Key.new(bucket, k).get
+    end
+
+    def s3_get(k)
+      bucket.get(k)
+    end
+
+    def s3_put(k, file)
+      bucket.put(k, file)
+    end
+
+    def repo
+      raise JudoError, "no repo dir specified" unless @repo
+      raise JudoError, "repo dir not found" unless File.exists?(@repo)
+      @repo
+    end
+
+    def access_id
+      @access_id || (raise JudoError, "no AWS Access ID specified")
+    end
+
+    def access_secret
+      @access_secret || (raise JudoError, "no AWS Secret Key specified")
+    end
+
+    def bucket_name
+      @bucket_name || (raise JudoError, "no S3 bucket name specified")
+    end
+
+    def db_version
+      1
+    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 check_version
+      ## FIXME - call this somewhere
+      raise JduoError, "judo db is newer than the current gem - upgrade judo and try again" if get_db_version > db_version
+    end
+
+  end
+end