judo 0.3.1 → 0.3.2

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

data/bin/judo

@@ -35,7 +35,7 @@ Usage: judo launch [options] SERVER ...
        judo animate [options] SNAPSHOT SERVER    ## create a new server from a snapshot
        judo erase [options] SNAPSHOT           ## erase an old snapshot
 
-       judo swapip [options] SERVER SERVER     ## swap elastic IP's on the two servers
+       judo swap [options] SERVER SERVER     ## swap elastic IP's and names on the two servers
 
        judo info [options] [SERVER ...]
        judo console [options] [SERVER ...] ## shows AWS console output
@@ -124,13 +124,18 @@ begin
     when "start" then find_servers(judo, ARGV)        { |s| s.start(options) }
     when "restart" then find_servers(judo, ARGV)      { |s| s.restart(options) }
     when "stop" then find_servers(judo, ARGV)         { |s| s.stop(options) }
-    when "create" then mk_servers(judo, ARGV)         { |s| s.create(options) }
-    when "launch" then mk_servers(judo, ARGV)         { |s| s.create(options); s.start(options) }
+    when "create" then mk_servers(judo, options, ARGV)
+    when "launch" then mk_servers(judo, options, ARGV)         { |s| s.start(options) }
     when "snapshots" then do_snapshots(judo, ARGV)
-    when "swapip" then
+    when "rename" then
+      raise JudoError, "usage: judo rename SERVER SERVER" unless ARGV.size == 2
+      old,new = ARGV
+      server = find_servers(judo, [old]).first
+      server.rename(new)
+    when "swap" then
       servers = find_servers(judo, ARGV)
       raise JudoError, "usage: judo swapip SERVER SERVER" unless servers.size == 2
-      servers[0].swapip(servers[1])
+      servers[0].swap(servers[1])
     when "erase" then
       raise JudoError, "usage: judo erase SNAPSHOT" unless ARGV.size == 1
       snapshot_name = ARGV.shift
@@ -150,7 +155,7 @@ begin
       raise JudoError, "You must specify a new server name" unless new_server
       snapshot = judo.snapshots.detect { |s| s.name == snapshot_name }
       raise JudoError, "No such snapshot #{snapshot_name}" unless snapshot
-      snapshot.animate(new_server,options[:version])
+      snapshot.animate(new_server).start(options)
     when "destroy" then
       raise JudoError, "You must specify what servers to destroy" if ARGV.empty?
       find_either(judo, ARGV) do |i|

data/lib/judo.rb

@@ -6,6 +6,7 @@ require 'fileutils'
 require 'yaml'
 require 'json'
 require 'pp'
+require 'tempfile'
 
 raise "Judo Currently Requires Ruby 1.8.7" unless RUBY_VERSION == "1.8.7"
 

data/lib/judo/base.rb

@@ -152,12 +152,22 @@ module Judo
     end
 
     def servers
-      @servers ||= servers_state.map { |name,data| Judo::Server.new(self, name, data["group"].first) }
+      @servers ||= servers_state.map { |id,data| Judo::Server.new(self, id, data["group"].first) }
     end
 
-    def new_server(name, group)
-      s = Judo::Server.new(self, name, group)
+    def new_server_id
+      rand(2**32).to_s(36)
+    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.name}.#{index}"
+    end
+
+    def create_server(name, group, options)
+      s = Judo::Server.new(self, new_server_id, group)
       servers << s
+      s.create(name, options)
       s
     end
 
@@ -217,6 +227,19 @@ module Judo
       @group_version ||= sdb.get_attributes(base_domain, "group_versions")[:attributes]
     end
 
+    def set_keypair(key_name, material)
+      s3_put("#{key_name}.pem", material)
+      update "key_name" => key_name
+    end
+
+    def key_name
+      get("key_name")
+    end
+
+    def key_material
+      s3_get("#{key_name}.pem")
+    end
+
     def ip_to_judo(ip)
       servers.detect { |s| s.elastic_ip == ip }
     end
@@ -267,8 +290,14 @@ module Judo
       @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 || (raise JudoError, "no S3 bucket name specified")
+      (@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
@@ -295,12 +324,25 @@ module Judo
     end
 
     def set_db_version(new_version)
-      @db_version = new_version
-      sdb.put_attributes(base_domain, "judo", { "dbversion" => new_version }, :replace)
+      update "dbversion" => new_version
     end
 
     def get_db_version
-      @db_version ||= (sdb.get_attributes(base_domain, "judo")[:attributes]["dbversion"] || []).first.to_i
+      get("dbversion").to_i
+    end
+
+    def get(key)
+      state[key] && [state[key]].flatten.first
+    end
+
+    ## i'm copy pasting code from server - this needs to be its own module
+    def update(attrs)
+      sdb.put_attributes(base_domain, "judo", attrs, :replace)
+      state.merge! attrs
+    end
+
+    def state
+      @state ||= sdb.get_attributes(base_domain, "judo")[:attributes]
     end
 
     def check_version
@@ -311,15 +353,14 @@ module Judo
     end
 
     def setup
-      ## no need to setup bucket
-
       @repo ||= "." ## use cwd as default repo dir
 
       setup_sdb
+      setup_keypair
+      setup_bucket
       setup_security_group
       setup_judo_config
       setup_repo
-      get_group("default").compile
     end
 
     def setup_sdb
@@ -345,9 +386,13 @@ module Judo
       raise JudoError, "You must specify a repo dir" unless repo
       task("writing .judo/config.yml") do
         Dir.chdir(repo) do
-          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)
+          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
         end
       end
@@ -360,14 +405,34 @@ module Judo
       end
       task("Setting up default group") do
         Dir.chdir(repo) do
-          system "mkdir -p default/keypairs"
+          File.open("default/config.json","w") { |f| f.write default_config }
+        end
+        get_group("default").compile
+      end
+    end
 
-          @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]
+    def keypair_file(&blk)
+      Tempfile.open("judo_pem") do |file|
+        file.write key_material
+        file.flush
+        blk.call(file.path)
+      end
+    end
 
-          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 }
+    def setup_bucket
+      if name = get("bucket_name")
+        puts "Bucket #{name} already set"
+      else
+        set_bucket_name(bucket_name)
+      end
+    end
+
+    def setup_keypair
+      unless key_name
+        task("Generating an ssl keyapir") 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)
         end
       end
     end
@@ -375,7 +440,6 @@ module Judo
     def default_config
         <<DEFAULT
 {
-  "key_name":"#{@keypair}",
   "instance_type":"m1.small",
   "ami32":"ami-bb709dd2", // public ubuntu 9.10 ami - 32 bit
   "ami64":"ami-55739e3c", // public ubuntu 9.10 ami - 64 bit

data/lib/judo/commandline_helpers.rb

@@ -29,7 +29,8 @@ module JudoCommandLineHelpers
     groups.each { |group| judo_yield(group, blk) if blk }
   end
 
-  def mk_servers(judo, args, &blk)
+  ## I dont like the way this is working anymore - needs refactor
+  def mk_servers(judo, options, args, &blk)
     servers = args.map do |arg|
       name,group = split(arg)
       group ||= judo.group
@@ -37,9 +38,9 @@ module JudoCommandLineHelpers
       if name =~ /^\+(\d+)/
         count = $1.to_i
         raise JudoError, "You can batch-create between 1 and 5 servers" if count < 1 or count > 5
-        (1..count).map { judo.new_server(nil, group) }
+        (1..count).map { judo.create_server( judo.mk_server_name(group), group, options) }
       else
-        judo.new_server(name, group)
+        judo.create_server(name, group, options)
       end
     end
     servers.flatten.each { |s| judo_yield(s, blk) if blk }
@@ -150,6 +151,7 @@ module JudoCommandLineHelpers
 
   def do_info(judo, server)
     puts "[ #{server} ]"
+    printf "    %-24s: %s\n", "ID", server.id
     printf "    %-24s: %s\n", "Group", server.group.name
     printf "    %-24s: %s\n", "Note", server.note if server.note
     printf "    %-24s: %s\n", "Animated From", server.clone if server.clone

data/lib/judo/group.rb

@@ -16,12 +16,12 @@ module Judo
       @build_config ||= all_configs.reverse.inject({}) { |sum,conf| sum.merge(conf) }
     end
 
-    def server_names
-      @server_names ||= (@base.groups_config[@name] || [])
+    def server_ids
+      @server_ids ||= (@base.groups_config[@name] || [])
     end
 
     def servers
-      @base.servers.select { |s| server_names.include?(s.name) }
+      @base.servers.select { |s| server_ids.include?(s.name) }
     end
 
     def load_config
@@ -123,10 +123,6 @@ module Judo
       files
     end
 
-    def keypair_file
-      extract_file(:keypair, config["key_name"] + ".pem" , {}).first
-    end
-
     def attachments(c = config)
       extract(c, {})
     end
@@ -169,7 +165,7 @@ module Judo
     end
 
     def delete_server(server)
-      sdb.delete_attributes(@base.base_domain, "groups", name => server.name)
+      sdb.delete_attributes(@base.base_domain, "groups", name => server.id)
     end
 
     def to_s

data/lib/judo/server.rb

@@ -1,14 +1,14 @@
 module Judo
   class Server
-    attr_accessor :name, :group_name
+    attr_accessor :id,:group_name
 
-    def initialize(base, name, group, version = nil)
+    def initialize(base, id, group, version = nil)
       @base = base
-      @name = name
+      @id = id
       @group_name = group
     end
 
-    def create(options)
+    def create(name, options)
       raise JudoError, "no group specified" unless group_name
 
       options[:virgin] = true if options[:virgin].nil?
@@ -18,23 +18,21 @@ module Judo
       data       = options[:data]        ## instance specific data passed in JUDO_DATA
       ip         = options[:elastic_ip]  ## if the ip was allocated beforehand
       virgin     = options[:virgin]      ## should the server init?
+      clone      = options[:clone]       ## if it was cloned from a snapshot
 
       version = options[:version]
       version ||= group.version
 
-      if @name.nil?
-        index = @base.servers.map { |s| (s.name =~ /^#{s.group.name}.(\d*)$/); $1.to_i }.sort.last.to_i + 1
-        @name = "#{group.name}.#{index}"
-      end
-
-      raise JudoError, "there is already a server named #{name}" if @base.servers.detect { |s| s.name == @name and s != self}
+      raise JudoError, "there is already a server named #{name}" if @base.servers.detect { |s| s.name == name and s != self}
+      raise JudoError, "there is already a server with id #{id}" if @base.servers.detect { |s| s.id == id and s != self}
 
       task("Creating server #{name}") do
         update "name" => name,         "group" => group_name,
                "note" => note,         "virgin" => virgin,
                "secret" => new_secret, "version" => version,
-               "data" => data,         "elastic_ip" => ip
-        @base.sdb.put_attributes(@base.base_domain, "groups", group_name => name)
+               "data" => data,         "elastic_ip" => ip,
+               "clone" => clone,       "created_at" => Time.now.to_i
+        @base.sdb.put_attributes(@base.base_domain, "groups", group_name => id)
       end
 
       allocate_disk(snapshots)
@@ -48,17 +46,33 @@ module Judo
     end
 
     def fetch_state
-      @base.sdb.get_attributes(@base.server_domain, name)[:attributes]
+      @base.sdb.get_attributes(@base.server_domain, id)[:attributes]
     end
 
     def state
-      @base.servers_state[name] ||= fetch_state
+      @base.servers_state[id] ||= fetch_state
     end
 
     def get(key)
       state[key] && [state[key]].flatten.first
     end
 
+    def created_at
+      Time.at(get("created_at").to_i)
+    end
+
+    def started_at
+      Time.at(get("started_at").to_i)
+    end
+
+    def stopped_at
+      Time.at(get("stopped_at").to_i)
+    end
+
+    def name
+      get "name"
+    end
+
     def data
       get "data"
     end
@@ -128,28 +142,28 @@ module Judo
     end
 
     def update(attrs)
-      @base.sdb.put_attributes(@base.server_domain, name, attrs, :replace)
+      @base.sdb.put_attributes(@base.server_domain, id, attrs, :replace)
       state.merge! attrs
     end
 
     def add(key, value)
-      @base.sdb.put_attributes(@base.server_domain, name, { key => value })
+      @base.sdb.put_attributes(@base.server_domain, id, { key => value })
       (state[key] ||= []) << value
     end
 
     def remove(key, value = nil)
       if value
-        @base.sdb.delete_attributes(@base.server_domain, name, key => value)
+        @base.sdb.delete_attributes(@base.server_domain, id, key => value)
         state[key] - [value]
       else
-        @base.sdb.delete_attributes(@base.server_domain, name, [ key ])
+        @base.sdb.delete_attributes(@base.server_domain, id, [ key ])
         state.delete(key)
       end
     end
 
     def delete
       group.delete_server(self) if group
-      @base.sdb.delete_attributes(@base.server_domain, name)
+      @base.sdb.delete_attributes(@base.server_domain, id)
     end
 
 ######## end simple DB access  #######
@@ -339,7 +353,7 @@ module Judo
       result = @base.ec2.launch_instances(ami,
         :instance_type => instance_type,
         :availability_zone => config["availability_zone"],
-        :key_name => config["key_name"],
+        :key_name => @base.key_name,
         :group_ids => security_groups,
         :user_data => ud).first
       update "instance_id" => result[:aws_instance_id], "virgin" => false, "started_at" => Time.now.to_i
@@ -474,8 +488,9 @@ module Judo
 
     def connect_ssh
       wait_for_ssh
-      system "chmod 600 #{group.keypair_file}"
-      system "ssh -i #{group.keypair_file} #{config["user"]}@#{hostname}"
+      @base.keypair_file do |file|
+        system "ssh -i #{file} #{config["user"]}@#{hostname}"
+      end
     end
 
     def ec2_instance_type
@@ -488,7 +503,7 @@ module Judo
 
     def reload
       @base.reload_ec2_instances
-      @base.servers_state.delete(name)
+      @base.servers_state.delete(id)
     end
 
     def user_data(judo_boot = nil)
@@ -497,7 +512,8 @@ module Judo
 
 export DEBIAN_FRONTEND="noninteractive"
 export DEBIAN_PRIORITY="critical"
-export JUDO_ID='#{name}'
+export JUDO_ID='#{id}'
+export JUDO_NAME='#{name}'
 export JUDO_DOMAIN='#{@base.domain}'
 export JUDO_BOOT='#{judo_boot}'
 export JUDO_DATA='#{data}'
@@ -532,13 +548,22 @@ USER_DATA
     end
 
     def snapshot(name)
-      snap = @base.new_snapshot(name, self.name)
+      snap = @base.new_snapshot(name, id)
       snap.create
+      snap
+    end
+
+    def rename(newname)
+      raise JudoError, "Already a server with that name"  if @base.servers.detect { |s| s.name == newname }
+      task("Renaming to #{newname}") do
+        update "name" => newname
+      end
     end
 
-    def swapip(other)
+    def swap(other)
       ip1 = elastic_ip
       ip2 = other.elastic_ip
+
       raise JudoError, "Server must have an elastic IP to swap" unless ip1 and ip2
 
       task("Swapping Ip Addresses") do
@@ -551,6 +576,13 @@ USER_DATA
         update "elastic_ip" => ip2
         other.update "elastic_ip" => ip1
       end
+
+      task("Swapping Names") do
+        name1 = name
+        name2 = other.name
+        update "name" => name2
+        other.update "name" => name1
+      end
     end
 
     def <=>(s)

data/lib/judo/snapshot.rb

@@ -1,25 +1,29 @@
 module Judo
-  ### sdb 
-  ### name { 
-  ###   "version"    => [ server.version ], 
+  ### sdb
+  ### name {
+  ###   "version"    => [ server.version ],
   ###   "devs"       => [ "/dev/sde1:snap-abc123", "/dev/sde2:snap-abc456" ],
-  ###   "server"     => server.name
+  ###   "server"     => server.id
   ###   "group"      => server.group.name
   ###   "virgin"     => server.virgin
   ###   "note"       => server.note
   ###   "data"       => server.data
   ###   "created_at" => unixtime
   class Snapshot
-    attr_accessor :name, :server_name
+    attr_accessor :name, :server_id
 
-    def initialize(base, name, server_name)
+    def initialize(base, name, server_id)
       @base = base
       @name = name
-      @server_name = server_name
+      @server_id = server_id
+    end
+
+    def server_name
+      server.name rescue '(deleted)'
     end
 
     def server
-      @server ||= @base.servers.detect { |s| s.name == @server_name }
+      @server ||= @base.servers.detect { |s| s.id == server_id }
     end
 
     def fetch_state
@@ -35,7 +39,7 @@ module Judo
     end
 
     def created_at
-      Time.at(get("time").to_i)
+      Time.at(get("created_at").to_i)
     end
 
     def version
@@ -65,13 +69,13 @@ module Judo
         devs = server.volumes.map do |dev,vol|
           "#{dev}:#{@base.ec2.create_snapshot(vol)[:aws_id]}"
         end
-        @base.sdb.put_attributes(@base.snapshot_domain, name, { 
-          "version" => server.version, 
-          "virgin" => server.virgin?, 
-          "note" => server.note, 
-          "data" => server.data, 
-          "devs" => devs, 
-          "server" => server.name, 
+        @base.sdb.put_attributes(@base.snapshot_domain, name, {
+          "version" => server.version,
+          "virgin" => server.virgin?,
+          "note" => server.note,
+          "data" => server.data,
+          "devs" => devs,
+          "server" => server.id,
           "group" => server.group.name,
           "created_at" => Time.now.to_i.to_s
         }, :replace)
@@ -79,17 +83,14 @@ module Judo
       end
     end
 
-    def animate(new_server, version = self.version)
+    def animate(new_server)
       raise JudoError, "cannot animate, snapshotting not complete" unless completed?
-      server = @base.new_server(new_server, group_name)
-      server.create( :version => version, :snapshots => devs, :virgin => virgin, :note => note, :data => data )
-      server.update "clone" => name ##, "secret" => rand(2 ** 128).to_s(36)  ## cant change this till kuzushi knows about a post-clone operation
-      server
+      @base.create_server(new_server, group_name, :version => version, :snapshots => devs, :virgin => virgin, :note => note, :data => data , :clone => name)
     end
 
     def delete
       @base.sdb.delete_attributes(@base.snapshot_domain, name)
-      server.remove "snapshots", name
+      server.remove("snapshots", name) if server
     end
 
     def get(key)

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 1
-  version: 0.3.1
+  - 2
+  version: 0.3.2
 platform: ruby
 authors: 
 - Orion Henry
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-20 00:00:00 -04:00
+date: 2010-05-21 00:00:00 -04:00
 default_executable: judo
 dependencies: 
 - !ruby/object:Gem::Dependency