judo 0.1.0 → 0.1.4

data/TODO

@@ -0,0 +1,45 @@
+### NEEDED for new gem launch
+
+### [ ] judo snapshots
+### [ ] judo snapshot foo bar
+### [ ] judo clone foo bar2
+### [ ] snapshots/init/virgin
+### [ ] judo stop --force
+### [ ] judo swap (x) (y) -> swaps elastic IP's and name
+### [ ] judo swap_ip (x) (y) -> swaps elastic IP's and name
+
+### [ ] judo does not work with ruby 1.8.6 - :(
+### [ ] saw a timeout on volume allocation - make sure we build in re-tries - need to allocate the server all together as much as possible
+### [ ] there is a feature to allow for using that block_mapping feature - faster startup
+
+### [ ] 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)
+### [ ] bind kuzushi gem version version
+
+### [ ] should be able to do ALL actions except commit without the repo!
+### [ ] store git commit hash with commit to block a judo commit if there is newer material stored
+### [ ] remove the tarball - store files a sha hashes in the bucket - makes for faster commits if the files have not changed
+
+### [ ] use a logger service (1 hr)
+### [ ] write specs (5 hr)
+
+### Error Handling
+### [ ] no availability zone before making disks
+### [ ] security group does not exists
+
+### 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?"
+

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.4

data/bin/judo

@@ -30,6 +30,11 @@ Usage: judo launch [options] SERVER ...
 
        judo commit [options] GROUP
 
+       judo snapshot [options] SERVER SNAPSHOT ## take an ebs snapshot of a server
+       judo snapshots [options] [SERVER ...]   ## show current snapshots on servers
+       judo clone [options] SNAPSHOT SERVER    ## create a new server from a snapshot
+       judo erase [options] SNAPSHOT           ## erase an old snapshot
+
        judo info [options] [SERVER ...]
        judo console [options] [SERVER ...] ## shows AWS console output
        judo ssh [options] [SERVER ...]     ## ssh's into the server
@@ -53,6 +58,9 @@ banner
     defaults[:judo_dir] = dir
     defaults.merge(Judo::Base.default_options(Dir.pwd, dir))
   end
+  opts.on( '-f', '--force', 'Force a stop or restart (immediately force detach volumes)' ) do
+    options[:force] = true
+  end
   opts.on( '-r', '--repo DIR', 'Specify the location of the repo dir' ) do |dir|
     options[:repo] = dir
   end
@@ -68,6 +76,9 @@ banner
   opts.on( '-g', '--group GROUP', 'Specify the default group of the repo dir' ) do |group|
     options[:group] = group
   end
+  opts.on( '-v', '--version VERSION', 'Update the servers config version on create/start/launch' ) do |version|
+    options[:version] = version
+  end
   opts.on( '-h', '--help', 'Display this screen' ) do
     puts opts
     exit
@@ -77,6 +88,7 @@ end
 optparse.parse!
 
 judo = Judo::Base.new(defaults.merge(options))
+judo.check_version
 
 begin
   case action
@@ -85,14 +97,35 @@ begin
     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 "console" then find_servers(judo, ARGV)      { |s| puts s.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 "start" then find_servers(judo, ARGV)        { |s| s.start(options[:version]) }
+    when "restart" then find_servers(judo, ARGV)      { |s| s.restart(options[:force]) }
+    when "stop" then find_servers(judo, ARGV)         { |s| s.stop(options[:force]) }
+    when "create" then mk_servers(judo, ARGV)         { |s| s.create(options[:version]) }
+    when "launch" then mk_servers(judo, ARGV)         { |s| s.create(options[:version]); s.start }
+    when "snapshots" then do_snapshots(judo, ARGV)
+    when "erase" then
+      raise JudoError, "usage: judo erase SNAPSHOT" unless ARGV.size == 1
+      snapshot_name = ARGV.shift
+      judo.snapshots.select { |s| s.name == snapshot_name }.each { |s| s.destroy }
+    when "snapshot" then
+      raise JudoError, "usage: judo snapshot SERVER SNAPSHOT" unless ARGV.size == 2
+      server_name = ARGV.shift
+      snapshot_name = ARGV.shift
+      servers = find_servers(judo, [server_name])
+      raise JudoError, "You must specify a valid server to snapshot" if servers.empty?
+      raise JudoError, "You can only snapshot one server at a time" if servers.size > 1
+      servers[0].snapshot(snapshot_name)
+    when "clone" then
+      snapshot_name = ARGV.shift
+      raise JudoError, "You must specify a snapshot name" unless snapshot_name
+      new_server = ARGV.shift
+      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.clone(new_server,options[:version])
     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

@@ -7,6 +7,8 @@ require 'right_aws'
 require 'json'
 require 'pp'
 
+raise "Judo Currently Requires Ruby 1.8.7" unless RUBY_VERSION == "1.8.7"
+
 class JudoError < RuntimeError ; end
 class JudoInvalid < RuntimeError ; end
 
@@ -14,5 +16,6 @@ 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/snapshot'
 require File.dirname(__FILE__) + '/judo/setup'
 

data/lib/judo/base.rb

@@ -1,3 +1,27 @@
+
+=begin
+module Aws
+  class Ec2
+    API_VERSION       = "2009-11-30"  ## this didnt work
+    def start_instances(instance_id)
+      link = generate_request("StartInstances",  { 'InstanceId' => instance_id } )
+      request_info(link, QEc2TerminateInstancesParser.new(:logger => @logger))
+    rescue Exception
+      on_exception
+    end
+
+    def stop_instances(instance_id)
+      link = generate_request("StopInstances",  { 'InstanceId' => instance_id } )
+      puts link.inspect
+      result = request_info(link, QEc2TerminateInstancesParser.new(:logger => @logger))
+      puts result.inspect
+    rescue Exception
+      on_exception
+    end
+  end
+end
+=end
+
 module Judo
   class Base
     attr_accessor :judo_dir, :repo, :group
@@ -12,7 +36,7 @@ module Judo
     end
 
     def volumes
-      @volumes ||= ec2.describe_volumes.map do |v|
+      @volumes ||= ec2_volumes.map do |v|
         {
           :id          => v[:aws_id],
           :size        => v[:aws_size],
@@ -69,6 +93,16 @@ module Judo
       @sdb ||= Aws::SdbInterface.new(access_id, access_secret, :logger => Logger.new(nil))
     end
 
+    def fetch_snapshots_state
+      s = {}
+      sdb.select("select * from #{Judo::Snapshot.domain}")[:items].each do |group|
+        group.each do |key,val|
+          s[key] = val
+        end
+      end
+      s
+    end
+
     def fetch_servers_state
       s = {}
       sdb.select("select * from #{Judo::Server.domain}")[:items].each do |group|
@@ -79,10 +113,18 @@ module Judo
       s
     end
 
+    def snapshots_state
+      @snapshots_state ||= fetch_snapshots_state
+    end
+
     def servers_state
       @servers_state ||= fetch_servers_state
     end
 
+    def snapshots
+      @snapshots ||= snapshots_state.map { |name,data| Judo::Snapshot.new(self, name, data["server"].first) }
+    end
+
     def servers
       @servers ||= servers_state.map { |name,data| Judo::Server.new(self, name, data["group"].first) }
     end
@@ -92,9 +134,15 @@ module Judo
       servers << s
       s
     end
-    
+
+    def new_snapshot(name, server)
+      s = Judo::Snapshot.new(self, name, server)
+      snapshots << s
+      s
+    end
+
     def get_group(name)
-      group = groups.detect { |g| g.to_s == name }
+      group = groups.detect { |g| g.name == name }
       group ||= Judo::Group.new(self, name, 0)
       group
     end
@@ -119,6 +167,14 @@ module Judo
       @ec2_instance = nil
     end
 
+    def ec2_volumes
+      @ec2_volumes ||= ec2.describe_volumes
+    end
+
+    def ec2_snapshots
+      @ec2_snapshots ||= ec2.describe_snapshots
+    end
+
     def ec2_instances
       @ec2_instance ||= ec2.describe_instances
     end
@@ -182,18 +238,34 @@ module Judo
     end
 
     def db_version
-      1
+      2
+    end
+
+    def upgrade_db
+      case get_db_version
+        when 0
+          raise JudoError, "Your db appears to be unititialized.  You will need to do a judo init"
+        when 1
+          task("Upgrading Judo: Creating Snapshots SDB Domain") do
+            sdb.create_domain(Judo::Snapshot.domain)
+            set_db_version(2)
+          end
+        else
+          raise JduoError, "judo db is newer than the current gem - upgrade judo and try again"
+      end
+    end
+
+    def set_db_version(new_version)
+      @db_version = new_version
+      sdb.put_attributes("judo_config", "judo", { "dbversion" => new_version }, :replace)
     end
 
     def get_db_version
-      version = @sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"]
-      version and version.first.to_i or db_version
+      @db_version ||= sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"].first.to_i
     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
+      upgrade_db if get_db_version != db_version
     end
-
   end
 end

data/lib/judo/commandline_helpers.rb

@@ -16,7 +16,7 @@ module JudoCommandLineHelpers
   end
 
   def find_groups(judo, args, &blk)
-    raise JudoError, "No groups #{specified}" if args.empty? and judo.group.nil?
+    raise JudoError, "No groups specified" if args.empty? and judo.group.nil?
 
     args << ":#{judo.group}" if args.empty?  ## use default group if none specified
 
@@ -65,9 +65,10 @@ module JudoCommandLineHelpers
     raise JudoError, "No servers" if servers.empty?
 
     servers.each { |s| judo_yield(s,blk) if blk }
+    servers
   end
 
-  def find_server(judo, arg, use_default)
+  def find_server(judo, arg, use_default = false)
     ## this assumes names are unique no matter the group
     name,group = split(arg)
     if name != ""
@@ -118,12 +119,23 @@ module JudoCommandLineHelpers
     end
   end
 
+  def do_snapshots(judo, args)
+    servers = find_servers(judo, args)
+    printf "  SNAPSHOTS\n"
+    printf "%s\n", ("-" * 80)
+    ## FIXME - listing snapshots for deleted servers?
+    judo.snapshots.each do |snapshot|
+#      next if args and not servers.map { |s| s.name }.include?(snapshot.server_name)
+      printf "%-15s %-25s %-15s %-10s %s\n", snapshot.name, snapshot.server_name, snapshot.group_name, snapshot.version_desc, "#{snapshot.num_ec2_snapshots}v"
+    end
+  end
+
   def do_list(judo, args)
     servers = find_servers(judo, args)
     printf "  SERVERS\n"
     printf "%s\n", ("-" * 80)
     servers.sort.each do |s|
-      printf "%-18s %-12s %-7s %-11s %-11s %-13s %-10s %-10s %s\n", s.name, s.group.name, s.version_desc, s.state["instance_id"], s.size_desc, s.ami, s.ec2_state, "#{s.volumes.keys.size} volumes", s.ip
+      printf "%-32s %-12s %-7s %-11s %-11s %-10s %-3s %s\n", s.name, s.group.name, s.version_desc, s.state["instance_id"], s.size_desc, s.ec2_state, "#{s.volumes.keys.size}v", s.has_ip? ? "ip" : ""
     end
   end
 
@@ -145,7 +157,5 @@ module JudoCommandLineHelpers
       v[:aws_attachment_status],
       v[:aws_device]
     end
-    puts "\t[ CONFIG ]"
-    pp server.config
   end
 end

data/lib/judo/group.rb

@@ -2,47 +2,11 @@ module Judo
   class Group
     attr_accessor :name, :version
 
-#    def self.dirs
-#      Dir["#{@base.repor}/*/config.json"].map { |d| File.dirname(d) }
-#    end
-#
-#    def self.all
-#      @@all ||= (dirs.map { |d| new(d) })
-#    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}\// }
-#    end
-
-#    def initialize(base, dir, name = File.basename(dir))
     def initialize(base, name, version)
       @base = base
       @name = name
       @version = version
-#      @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
-##      @base.read_config(attrs[:group]) ## make sure the config is valid  ## FIXME
-#
-#      server = Judo::Server.new base, server_name, name
-#      server.task("Creating server #{server_name}") do
-#        server.update "name" => server_name, "group" => name, "virgin" => true, "secret" => rand(2 ** 128).to_s(36)
-#        @base.sdb.put_attributes("judo_config", "groups", name => server_name)
-#      end
-#      server
-#    end
+    end
 
     def config
       @config ||= load_config
@@ -60,25 +24,20 @@ module Judo
       @base.servers.select { |s| server_names.include?(s.name) }
     end
 
-#    def version
-#      @version ||= (@base.group_versions[@name] || ["0"]).first.to_i
-#    end
-
     def load_config
         JSON.load @base.s3_get(version_config_file)
       rescue Aws::AwsError
        raise JudoError, "No config stored: try 'judo commit #{to_s}'"
     end
 
-    def set_version(new_version)
-      @version = new_version
-      @base.sdb.put_attributes("judo_config", "group_versions", { name => new_version }, :replace)
+    def set_version
+      @base.sdb.put_attributes("judo_config", "group_versions", { name => version }, :replace)
     end
 
     def compile
       tmpdir = "/tmp/kuzushi/#{name}"
-      set_version(version + 1)
       puts "Compiling #{self} version #{version}"
+      @version = @version + 1
       FileUtils.rm_rf(tmpdir)
       FileUtils.mkdir_p(tmpdir)
       new_config = build_config
@@ -101,6 +60,7 @@ module Judo
           @base.s3_put(version_config_file, new_config.to_json)
         end
       end
+      set_version
     end
 
     def version_config_file
@@ -121,7 +81,6 @@ module Judo
 
     def extract_file(type, name, files)
       path = "#{dir}/#{type}s/#{name}"
-      puts "[#{name}] #{path}"
       found = Dir[path]
       if not found.empty?
         found.each { |f| files["#{type}s/#{File.basename(f)}"] = f }
@@ -147,12 +106,15 @@ module Judo
             when "local_packages"
               extract_file(:package, "#{v}_i386.deb", files)
               extract_file(:package, "#{v}_amd64.deb", files)
+            when "git"
+              ## do nothing - is a remote
             when "template"
               extract_file(:template, v, files)
             when "source"
               extract_file(:file, v, files) unless config["template"] or config["package"]
             when "file"
-              extract_file(:file, File.basename(v), files) unless config["template"] or config["source"]
+              ## this is getting messy
+              extract_file(:file, File.basename(v), files) unless config["template"] or config["source"] or config["git"]
             end
           end
         end
@@ -216,6 +178,14 @@ module Judo
     def sdb
       @base.sdb
     end
+
+    def version_desc(v)
+      if v == version
+        "v#{v}"
+      else
+        "v#{v}/#{version}"
+      end
+    end
   end
 end
 

data/lib/judo/server.rb

@@ -1,51 +1,14 @@
-### NEEDED for new gem launch
-
-### [ ] return right away.. (1 hr)
-### [ ] 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)
-### [ ] write some examples - simple postgres/redis/couchdb server (5hrs)
-### [ ] write new README (4 hrs)
-### [ ] bind kuzushi gem version version
-### [ ] realase new gem! (1 hr)
-
-### [ ] should be able to do ALL actions except commit without the repo!
-### [ ] store git commit hash with commit to block a judo commit if there is newer material stored
-### [ ] remove the tarball - store files a sha hashes in the bucket - makes for faster commits if the files have not changed
-
-### [ ] use a logger service (1 hr)
-### [ ] write specs (5 hr)
-
-### Error Handling
-### [ ] no availability zone before making disks
-### [ ] security group does not exists
-
-### 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
 
-    def initialize(base, name, group)
+    def initialize(base, name, group, version = nil)
       @base = base
       @name = name
       @group_name = group
     end
 
-    def create
+    def create(version = group.version, snapshots = nil)
       raise JudoError, "no group specified" unless @group_name
 
       if @name.nil?
@@ -56,11 +19,12 @@ module Judo
       raise JudoError, "there is already a server named #{name}" if @base.servers.detect { |s| s.name == @name and s != self}
 
       task("Creating server #{name}") do
-        update "name" => name, "group" => @group_name, "virgin" => true, "secret" => rand(2 ** 128).to_s(36)
+        update "name" => name, "group" => @group_name, "virgin" => true, "secret" => rand(2 ** 128).to_s(36), "version" => version
         @base.sdb.put_attributes("judo_config", "groups", @group_name => name)
       end
 
-      allocate_resources
+      allocate_disk(snapshots)
+      allocate_ip
 
       self
     end
@@ -98,18 +62,37 @@ module Judo
     end
 
     def version_desc
-      return "" unless running?
-      if version == group.version
-        "v#{version}"
-      else
-        "v#{version}/#{group.version}"
-      end
+      group.version_desc(version)
     end
 
     def version
       get("version").to_i
     end
 
+    def update_version(new_version)
+        update "version" => new_version
+    end
+
+    def kuzushi_action
+      if virgin?
+        if cloned?
+          "start"
+        else
+          "init"
+        end
+      else
+        "start"
+      end
+    end
+
+    def clone
+      get("clone")
+    end
+
+    def cloned?
+      !!clone
+    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
@@ -118,6 +101,10 @@ module Judo
       get "secret"
     end
 
+    def snapshots
+      base.snapshots.select { |s| s.server == self }
+    end
+
     def volumes
       Hash[ (state["volumes"] || []).map { |a| a.split(":") } ]
     end
@@ -147,7 +134,7 @@ module Judo
     end
 
     def delete
-      group.delete_server(self)
+      group.delete_server(self) if group
       @base.sdb.delete_attributes(self.class.domain, name)
     end
 
@@ -165,7 +152,24 @@ module Judo
       "#{name}:#{@group_name}"
     end
 
-    def allocate_resources
+    def allocate_disk(snapshots)
+      if snapshots
+        clone_snapshots(snapshots)
+      else
+        create_volumes
+      end
+    end
+
+    def clone_snapshots(snapshots)
+      snapshots.each do |device,snap_id| 
+        task("Creating EC2 Volume #{device} from #{snap_id}") do
+          volume_id = @base.ec2.create_volume(snap_id, nil, config["availability_zone"])[:aws_id]
+          add_volume(volume_id, device)
+        end
+      end
+    end
+
+    def create_volumes
       if config["volumes"]
         [config["volumes"]].flatten.each do |volume_config|
           device = volume_config["device"]
@@ -185,7 +189,9 @@ module Judo
           end
         end
       end
+    end
 
+    def allocate_ip
       begin
         if config["elastic_ip"] and not elastic_ip
           ### EC2 allocate_address
@@ -259,17 +265,18 @@ module Judo
       ["pending", "running", "shutting_down", "degraded"].include?(ec2_state)
     end
 
-    def start
+    def start(new_version = nil)
       invalid "Already running" if running?
       invalid "No config has been commited yet, type 'judo commit'" unless group.version > 0
+      task("Updating server version")      { update_version(new_version) } if new_version
       task("Starting server #{name}")      { launch_ec2 }
       task("Wait for server")              { wait_for_running } if elastic_ip or has_volumes?
       task("Attaching ip")                 { attach_ip } if elastic_ip
       task("Attaching volumes")            { attach_volumes } if has_volumes?
     end
 
-    def restart
-      stop if running?
+    def restart(force = false)
+      stop(force) if running?
       start
     end
 
@@ -285,10 +292,19 @@ module Judo
       raise JudoInvalid, str
     end
 
-    def stop
+    def force_detach_volumes
+      volumes.each do |device,volume_id| 
+        task("Force detaching #{volume_id}") do
+          @base.ec2.detach_volume(volume_id, instance_id, device, true)
+        end
+      end
+    end
+
+    def stop(force = false)
       invalid "not running" unless running?
       ## EC2 terminate_isntaces
       task("Terminating instance") { @base.ec2.terminate_instances([ instance_id ]) }
+      force_detach_volumes if force
       task("Wait for volumes to detach") { wait_for_volumes_detached } if volumes.size > 0
       remove "instance_id"
     end
@@ -305,8 +321,7 @@ module Judo
         :key_name => config["key_name"],
         :group_ids => security_groups,
         :user_data => ud).first
-
-      update "instance_id" => result[:aws_instance_id], "virgin" => false, "version" => group.version
+      update "instance_id" => result[:aws_instance_id], "virgin" => false
     end
 
     def debug(str)
@@ -356,10 +371,15 @@ module Judo
     end
 
     def wait_for_volumes_detached
-      ## FIXME - force if it takes too long
-      loop do
-        break if ec2_volumes.reject { |v| v[:aws_status] == "available" }.empty?
-        sleep 2
+      begin
+        Timeout::timeout(30) do
+          loop do
+            break if ec2_volumes.reject { |v| v[:aws_status] == "available" }.empty?
+            sleep 2
+          end
+        end
+      rescue Timeout::Error
+        force_detach_volumes
       end
     end
 
@@ -505,6 +525,11 @@ USER_DATA
       end
     end
 
+    def snapshot(name)
+      snap = @base.new_snapshot(name, self.name)
+      snap.create
+    end
+
     def <=>(s)
       [group.name, name] <=> [s.group.name, s.name]
     end

data/lib/judo/setup.rb

@@ -63,7 +63,8 @@ DEFAULT
 
     def setup_db
       puts "Trying to connect to SimpleDB with #{@aws_access_id}"
-      sdb.create_domain("judo_servers")
+      sdb.create_domain(Judo::Server.domain)
+      sdb.create_domain(Judo::Snapshot.domain)
       sdb.create_domain("judo_config")
       olddb = sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"]
       abort "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

data/lib/judo/snapshot.rb

@@ -0,0 +1,108 @@
+module Judo
+  class Snapshot
+    attr_accessor :name, :server_name 
+
+    def self.domain
+      "judo_snapshots"
+    end
+
+    def initialize(base, name, server_name)
+      @base = base
+      @name = name
+      @server_name = server_name
+    end
+
+    def server
+      @server ||= @base.servers.detect { |s| s.name == @server_name }
+    end
+
+    def fetch_state
+      @base.sdb.get_attributes(self.class.domain, name)[:attributes]
+    end
+
+    def state
+      @base.snapshots_state[name] ||= fetch_state
+    end
+
+    def group_name
+      get("group")
+    end
+
+    def version
+      get("version").to_i
+    end
+
+    def num_ec2_snapshots
+      devs.size
+    end
+
+    def devs
+      Hash[ (state["devs"] || []).map { |a| a.split(":") } ]
+    end
+
+    def create
+      raise JudoError,"snapshot already exists" unless state.empty?
+      raise JudoError,"server has no disks to clone: #{server.volumes}" if server.volumes.empty?
+      task("Snapshotting #{server.name}") do 
+        devs = server.volumes.map do |dev,vol|
+          "#{dev}:#{@base.ec2.create_snapshot(vol)[:aws_id]}"
+        end
+        @base.sdb.put_attributes(self.class.domain, name, { "version" => server.version, "devs" => devs, "server" => server.name, "group" => server.group.name }, :replace)
+        server.add "snapshots", name
+      end
+    end
+
+    def clone(new_server, version = self.version)
+      raise JudoError, "cannot clone, snapshotting not complete" unless completed?
+      server = @base.new_server(new_server, group_name)
+      server.create(version, devs)
+      server.update "clone" => name ##, "secret" => rand(2 ** 128).to_s(36)  ## cant change this till kuzushi knows about a post-clone operation
+    end
+
+    def delete
+      @base.sdb.delete_attributes(self.class.domain, name)
+      server.remove "snapshots", name
+    end
+
+    def get(key)
+      state[key] && [state[key]].flatten.first
+    end
+
+    def destroy
+      devs.each do |dev,snapshot_id|
+        task("Deleting #{dev} #{snapshot_id}") do
+          begin
+            @base.ec2.delete_snapshot(snapshot_id) 
+          rescue Object => e
+            puts "Error destrotying snapshot #{e.message}"
+          end
+        end
+      end
+      delete
+    end
+
+    def ec2_ids
+      devs.values
+    end
+
+    def completed?
+      not @base.ec2_snapshots.select { |s| ec2_ids.include? s[:aws_id] }.detect { |s| s[:aws_status] != "completed" }
+    end
+
+    def size(snap_id)
+      @base.ec2_snapshots.detect { |s| s[:aws_id] == snap_id }
+    end
+
+    def version_desc
+      group.version_desc(version)
+    end
+
+    def group
+      @group ||= @base.groups.detect { |g| g.name == group_name }
+    end
+
+    def fetch_state
+      @base.sdb.get_attributes(self.class.domain, name)[:attributes]
+    end
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Orion Henry
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-08 00:00:00 -04:00
+date: 2010-05-06 00:00:00 -04:00
 default_executable: judo
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,9 +51,11 @@ extensions: []
 
 extra_rdoc_files: 
 - README.markdown
+- TODO
 files: 
 - README.markdown
 - Rakefile
+- TODO
 - VERSION
 - bin/judo
 - lib/judo.rb
@@ -63,6 +65,7 @@ files:
 - lib/judo/group.rb
 - lib/judo/server.rb
 - lib/judo/setup.rb
+- lib/judo/snapshot.rb
 - spec/base.rb
 - spec/base_spec.rb
 - spec/server_spec.rb