judo 0.4.4 → 0.5.0

data/VERSION

@@ -1 +1 @@
-0.4.4
+0.5.0

data/bin/judo

@@ -2,13 +2,11 @@
 
 require 'optparse'
 require File.dirname(__FILE__) + '/../lib/judo'
-require File.dirname(__FILE__) + '/../lib/judo/commandline_helpers'
+require File.dirname(__FILE__) + '/../lib/judo/cli_helpers'
 
-include JudoCommandLineHelpers
+include Judo::CLIHelpers
 
-defaults = Judo::Base.default_options(Dir.pwd)
-
-options = {}
+options = Judo::Base.defaults
 
 ARGV.unshift "-h" if ARGV.size == 0
 
@@ -52,22 +50,15 @@ Usage: judo launch [options] SERVER ...
 
 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))
+  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_secret] = key
   end
   opts.on( '-f', '--force', 'Force a stop or restart (immediately force detach volumes)' ) do
     options[:force] = true
   end
-  opts.on( '-d', '--domain DOMAIN', 'Specify a judo domain within an AWS account' ) do |domain|
-    options[:domain] = domain
-  end
-  opts.on( '-r', '--repo DIR', 'Specify the location of the repo dir' ) do |dir|
-    options[:repo] = dir
-  end
   opts.on( '-t', '--type TYPE', 'Specify an instance type different from the config on server start' ) do |type|
     options[:instance_type] = type
   end
@@ -82,25 +73,6 @@ banner
   opts.on( '-i', '--ip IP', 'Specify an exsiting elastic_ip address on server creation' ) do |ip|
     options[:elastic_ip] = ip
   end
-  opts.on( '-a', '--accessid ID', 'Specify the AWS access ID' ) do |id|
-    options[:access_id] = id
-  end
-  opts.on( '-k', '--keypair KEY', 'Speicy the AWS keypair pem file to use or \'create\'' ) do |key|
-    if key == 'create'
-      options[:key_create] = true
-    elsif File.basename(key) =~ /(.*)[.]pem$/
-      options[:key_name] = $1
-      options[:key_material] = File.new(key).read
-    else
-      abort "Key file must be KEY_NAME.pem"
-    end
-  end
-  opts.on( '-s', '--secret KEY', 'Specify the AWS access secret key' ) do |key|
-    options[:access_secret] = key
-  end
-  opts.on( '-b', '--bucket BUCKET', 'Specify the AWS S3 bucket to use' ) do |bucket|
-    options[:bucket] = bucket
-  end
   opts.on( '-v', '--version VERSION', 'Update the servers config version on create/start/launch' ) do |version|
     options[:version] = version
   end
@@ -113,31 +85,27 @@ end
 optparse.parse!
 
 action = ARGV.shift
-judo = Judo::Base.new(defaults.merge(options))
-judo.check_version if action != "setup"
+judo = Judo::Base.new(options)
+judo.ensure_setup unless action == "generate"
 
 begin
   case action
-    when "setup" then judo.setup
-    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 "watch" then each_server(judo, ARGV)        { |s| s.ssh_command("tail -n 1000 -f /var/log/kuzushi.log") }
-    when "info" then each_server(judo, ARGV)         { |s| do_info(judo, s) }
-    when "console" then each_server(judo, ARGV)      { |s| puts s.console_output }
-    when "commit" then mk_groups(judo, ARGV)         { |g| g.compile }
-    when "ssh" then each_server(judo, ARGV)          { |s| s.connect_ssh }
-    when "start" then each_server(judo, ARGV)        { |s| s.start(options) }
-    when "restart" then each_server(judo, ARGV)      { |s| s.restart(options) }
-    when "stop" then each_server(judo, ARGV)         { |s| s.stop(options) }
-    when "create" then mk_servers(judo, options, ARGV, false)
-    when "launch" then mk_servers(judo, options, ARGV, true)
-    when "snapshots" then do_snapshots(judo, ARGV)
-    when "config" then
-      puts "Judo DB Version: #{judo.db_version}"
-      puts "Judo Key Pair:   #{judo.key_name}"
-      puts "Judo Bucket:     #{judo.bucket_name}"
+    when "generate"  then do_generate(judo, ARGV)
+	  when "commit"    then do_commit(judo, ARGV)
+    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 "snapshots" then do_snapshots(judo, ARGV)
+    when "watch"     then each_server(judo, ARGV) { |s| s.ssh_command("tail -n 1000 -f /var/log/kuzushi.log") }
+    when "info"      then each_server(judo, ARGV) { |s| do_info(judo, s) }
+    when "console"   then each_server(judo, ARGV) { |s| puts s.console_output }
+    when "ssh"       then each_server(judo, ARGV) { |s| s.connect_ssh }
+    when "start"     then each_server(judo, ARGV) { |s| s.start(options) }
+    when "restart"   then each_server(judo, ARGV) { |s| s.restart(options) }
+    when "stop"      then each_server(judo, ARGV) { |s| s.stop(options) }
+    when "create"    then mk_servers(judo, options, ARGV, false)
+    when "launch"    then mk_servers(judo, options, ARGV, true)
     when "rename" then
       raise JudoError, "usage: judo rename SERVER SERVER" unless ARGV.size == 2
       server = judo.find_server(ARGV[0]).rename(ARGV[1])

data/default/setup.sh

@@ -2,7 +2,7 @@
 
 kuzushi-setup  ## this will wait for all the volumes to attach and take care of mounting and formatting them
 
-if [ "$JUDO_FIRST_BOOT" ] ; then
+if [ "$JUDO_FIRST_BOOT" = "true" ] ; then
   ## do some setup on the first boot only
 fi
 

data/default/userdata.erb

@@ -21,8 +21,6 @@
 ##   id - this is random string that uniqily identifies the server for its lifetime
 ##   name - the name of the server
 ##   group_name - the name of group the server is in
-##   domain - this is the JUDO_DOMAIN currently running
-##   secret - this is a 128bit random string assigned to an instance at creation time - great for passwords
 ##   metadata - a hash of metadata associated with the server with --data KEY=VALUE
 ##   boot - a hash of boot options passed to the server with --boot KEY=VALUE
 ##   first_boot? - is set to true or false depending on if this is the instance's first boot
@@ -33,8 +31,6 @@ set -x
 
 export JUDO_ID='<%= id %>'
 export JUDO_NAME='<%= name %>'
-export JUDO_DOMAIN='<%= domain %>'
-export JUDO_SECRET='<%= secret %>'
 export JUDO_FIRST_BOOT='<%= first_boot? %>'
 
 hostname <%= name %>

data/lib/judo.rb

@@ -16,4 +16,4 @@ require File.dirname(__FILE__) + '/judo/base'
 require File.dirname(__FILE__) + '/judo/group'
 require File.dirname(__FILE__) + '/judo/server'
 require File.dirname(__FILE__) + '/judo/snapshot'
-
+require File.dirname(__FILE__) + '/judo/patch'

data/lib/judo/base.rb

@@ -1,17 +1,41 @@
 module Judo
   class Base
-    attr_accessor :judo_dir, :repo, :group, :domain
+    attr_accessor :group
 
-    def initialize(options = Judo::Base.default_options)
-      @judo_dir      = File.expand_path(options[:judo_dir]) if options[:judo_dir]
-      @repo          = File.expand_path(options[:repo]) if options[:repo]
-      @bucket_name   = options[:bucket]
+    def self.defaults
+      {
+        :access_id     => ENV['AWS_ACCESS_KEY_ID'],
+        :access_secret => ENV['AWS_SECRET_ACCESS_KEY']
+      }
+    end
+
+    def initialize(options)
       @access_id     = options[:access_id]
       @access_secret = options[:access_secret]
-      @domain        = options[:domain]
-      @key_name      = options[:key_name]
-      @key_material  = options[:key_material]
-      @key_create    = options[:key_create]
+    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
+      "judo_#{access_id}"
+    end
+
+    def server_domain
+      "judo_servers"
+    end
+
+    def snapshot_domain
+      "judo_snapshots"
+    end
+
+    def base_domain
+      "judo_base"
     end
 
     def find_groups(names)
@@ -20,7 +44,7 @@ module Judo
         groups.detect { |g| g.displayname == name } || (raise JudoError, "No such group #{name}")
       end
     end
-  
+
     def find_server(name)
       find_servers([name]).first
     end
@@ -41,7 +65,7 @@ module Judo
     def find_servers_by_name_or_groups(*names)
       just_servers = names.flatten.reject { |s| s =~ /^:/ }
       just_groups = names.flatten.select { |s| s =~ /^:/ }
-    
+
       [find_groups(just_groups).map { |g| g.servers } + find_servers(just_servers)].flatten
     end
 
@@ -70,59 +94,6 @@ module Judo
       end
     end
 
-    def sdb_domain(name)
-      if @domain
-        "#{@domain}_#{name}"
-      else
-        name
-      end
-    end
-
-    def server_domain
-      sdb_domain("judo_servers")
-    end
-
-    def snapshot_domain
-      sdb_domain("judo_snapshots")
-    end
-
-    def base_domain
-      sdb_domain("judo_config")
-    end
-
-    def self.default_options(pwd = Dir.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,
-        :repo          => repo_dir,
-        :domain        => (config["domain"] || ENV['JUDO_DOMAIN']),
-        :bucket        => (config["s3_bucket"] || ENV['JUDO_BUCKET']),
-        :access_id     => (config["access_id"] || ENV['AWS_ACCESS_KEY_ID']),
-        :access_secret => (config["access_secret"] || ENV['AWS_SECRET_ACCESS_KEY'])
-      }.delete_if { |key,value| value.nil? }
-    rescue Object => e
-      {
-        :access_id     => ENV['AWS_ACCESS_KEY_ID'],
-        :access_secret => ENV['AWS_SECRET_ACCESS_KEY'],
-        :bucket        => ENV['JUDO_BUCKET'],
-        :domain        => ENV['JUDO_DOMAIN'],
-      }.delete_if { |key,value| value.nil? }
-    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
@@ -167,17 +138,9 @@ module Judo
       rand(2**32).to_s(36)
     end
 
-    def default_group_dir
-        File.expand_path(File.dirname(__FILE__) + "/../../default")
-    end
-
-    def default_file(name)
-      "#{default_group_dir}/#{name}"
-    end
-
     def mk_server_name(group)
-        index = servers.map { |s| (s.name =~ /^#{s.group.name}.(\d*)$/); $1.to_i }.sort.last.to_i + 1
-        "#{group}#{index}"
+      index = servers.map { |s| (s.name =~ /^#{s.group.name}.(\d*)$/); $1.to_i }.sort.last.to_i + 1
+      "#{group}#{index}"
     end
 
     def create_server(name, group, options)
@@ -224,7 +187,7 @@ module Judo
     end
 
     def ec2_snapshots
-      @ec2_snapshots ||= ec2.describe_snapshots
+      @ec2_snapshots ||= ec2.describe_snapshots([], :owner => "self")
     end
 
     def ec2_instances
@@ -235,29 +198,10 @@ module Judo
       @ec2 ||= Aws::Ec2.new(access_id, access_secret, :logger => Logger.new(nil))
     end
 
-    def groups_config
-      @groups_config ||= sdb.get_attributes(base_domain, "groups")[:attributes]
-    end
-
     def group_versions
       @group_version ||= sdb.get_attributes(base_domain, "group_versions")[:attributes]
     end
 
-    def set_keypair(key_name, material)
-      @key_name = key_name
-      @key_material = material
-      s3_put("#{key_name}.pem", material)
-      update "key_name" => key_name
-    end
-
-    def key_name
-      @key_name ||= get("key_name")
-    end
-
-    def key_material
-      @key_material ||= s3_get("#{key_name}.pem")
-    end
-
     def ip_to_judo(ip)
       servers.detect { |s| s.elastic_ip == ip }
     end
@@ -275,78 +219,15 @@ module Judo
     end
 
     def s3_url(k)
-      Aws::S3Generator::Key.new(bucket, s3_key(k)).get
+      Aws::S3Generator::Key.new(bucket, k).get
     end
 
     def s3_get(k)
-      bucket.get( s3_key(k))
+      bucket.get(k)
     end
 
     def s3_put(k, file)
-      bucket.put( s3_key(k), file)
-    end
-
-    def s3_key(k)
-      if @domain
-        "#{@domain}/#{k}"
-      else
-        k
-      end
-    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
-
-    ## this is a little funny - does not work like the others - can specify bucket on cmdline or env - but if not takes from judo state
-    def bucket_name
-      (@bucket_name ||= get("bucket")) || (raise JudoError, "no S3 bucket name specified")
-    end
-
-    def set_bucket_name(new_name)
-      @bucket_name = new_name
-      update "bucket" => @bucket_name
-    end
-
-    def db_version
-      2
-    end
-
-    def upgrade_db
-      case get_db_version
-        when 0
-          task("Upgrading Judo: Creating Snapshots SDB Domain") do
-            sdb.create_domain(server_domain)
-            sdb.create_domain(base_domain)
-            sdb.create_domain(snapshot_domain)
-            set_db_version(2)
-          end
-        when 1
-          task("Upgrading Judo: Creating Snapshots SDB Domain") do
-            sdb.create_domain(snapshot_domain)
-            set_db_version(2)
-          end
-        else
-          raise JudoError, "judo db is newer than the current gem - upgrade judo and try again"
-      end
-    end
-
-    def set_db_version(new_version)
-      update "dbversion" => new_version
-    end
-
-    def get_db_version
-      get("dbversion").to_i
+      bucket.put(k, file)
     end
 
     def get(key)
@@ -363,113 +244,83 @@ module Judo
       @state ||= sdb.get_attributes(base_domain, "judo")[:attributes]
     end
 
-    def check_version
-        upgrade_db if get_db_version != db_version
-      rescue Aws::AwsError => e
-        setup_sdb
-        upgrade_db
+    def ensure_setup
+      ensure_init
+      ensure_db_version
     end
 
-    def setup(options = {})
-      @repo ||= "." ## use cwd as default repo dir
-
-      setup_sdb
-      setup_keypair
-      setup_bucket
-      setup_security_group
-      setup_judo_config
-      setup_repo
+    def ensure_init
+      if !has_init?
+        init_sdb
+        init_security_group
+        init_keypair
+      end
     end
 
-    def setup_sdb
-      task("Trying to connect to SimpleDB") do
-        sdb.create_domain(base_domain)
-      end
+    def has_init?
+      sdb.list_domains[:domains].include?(base_domain)
     end
 
-    def setup_security_group
-      begin
-        ec2.create_security_group('judo', 'Judo')
-        ec2.authorize_security_group_IP_ingress("judo", 22, 22,'tcp','0.0.0.0/0')
-      rescue Aws::AwsError => e
-        raise unless e.message =~ /InvalidGroup.Duplicate/
+    def init_sdb
+      task("Initializing Judo SDB") do
+        sdb.create_domain(base_domain)
       end
     end
 
-    def setup_judo_config
-      if judo_dir and File.exists?("#{judo_dir}/config.yml")
-        puts "config already exists [#{judo_dir}/config.yml]"
-        return
-      end
-      raise JudoError, "You must specify a repo dir" unless repo
-      task("writing .judo/config.yml") do
-        Dir.chdir(repo) do
-          if File.exists?(".judo/config.yml")
-            puts ".judo folder already exists"
-          else
-            system "mkdir .judo"
-            File.open(".judo/config.yml","w") do |f|
-              f.write({ "access_id" => access_id, "access_secret" => access_secret, "s3_bucket" => bucket_name }.to_yaml)
-            end
-          end
+    def init_security_group
+      task("Initializing Judo Security Group") do
+        begin
+          ec2.create_security_group('judo', 'Judo')
+          ec2.authorize_security_group_IP_ingress("judo", 22, 22,'tcp','0.0.0.0/0')
+        rescue Aws::AwsError => e
+          raise unless e.message =~ /InvalidGroup.Duplicate/
         end
       end
     end
 
-    def setup_repo
-      if File.exists?("#{repo}/default")
-        puts "default group already exists [#{repo}/default]"
-        return
-      end
-      task("Setting up default group") do
-        FileUtils.cp_r(default_group_dir, repo)
-        get_group("default").compile
+    def init_keypair
+      task("Initializing Judo Keypair") do
+        ec2.delete_key_pair("judo")
+        material = ec2.create_key_pair("judo")[:aws_material]
+        s3_put("judo.pem", material)
       end
     end
 
     def keypair_file(&blk)
-      Tempfile.open("judo_pem") do |file|
-        file.write key_material
+      Tempfile.open("judo.pem") do |file|
+        file.write(s3_get("judo.pem"))
         file.flush
         blk.call(file.path)
       end
     end
 
-    def setup_bucket
-      if name = get("bucket_name")
-        puts "Bucket #{name} already set"
-      else
-        puts "Setting bucket name #{bucket_name}"
-        set_bucket_name(bucket_name)
-      end
+    def set_db_version(new_version)
+      update "dbversion" => new_version
     end
 
-    def setup_keypair
-      if @key_name and @key_material
-        task("Setting keypair #{@key_name}") do
-          set_keypair(@key_name, @key_material)
+    def get_db_version
+      get("dbversion").to_i
+    end
+
+    def ensure_db_version
+      case get_db_version
+      when 0
+        task("Upgrading Judo SDB from version 0 to 2") do
+          sdb.create_domain(server_domain)
+          sdb.create_domain(snapshot_domain)
+          set_db_version(2)
         end
-      elsif @key_create or not key_name
-        task("Generating an ssl keypair") do
-          name = "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(name)[:aws_material]
-          set_keypair(name, material)
+      when 1
+        task("Upgrading Judo SDB from version 1 to 2") do
+          sdb.create_domain(snapshot_domain)
+          set_db_version(2)
         end
+      when 2
+        # current version
       else
-        puts "Keypair #{key_name} already set"
+        raise JudoError, "Judo SDB has higher version (#{get_db_version}) " +
+                         "than current gem (2) - please upgrade Judo"
       end
     end
-
-    def default_config
-        <<DEFAULT
-{
-  "ami32":"ami-2d4aa444", // public ubuntu 10.04 ami - 32 bit
-  "ami64":"ami-fd4aa494", // public ubuntu 10.04 ami - 64 bit
-  "user":"ubuntu",
-  "security_group":"judo",
-  "availability_zone":"us-east-1d"
-}
-DEFAULT
-    end
   end
 end