judo 0.2.4 → 0.3.0

data/README.markdown

@@ -64,7 +64,7 @@ default group will look something like this.
     $ cat default/config.json
     {
         "key_name":"judo14",
-        "instance_size":"m1.small",
+        "instance_type":"m1.small",
         "ami32":"ami-bb709dd2", // public ubuntu 9.10 ami - 32 bit
         "ami64":"ami-55739e3c", // public ubuntu 9.10 ami - 64 bit
         "user":"ubuntu",
@@ -72,7 +72,7 @@ default group will look something like this.
         "availability_zone":"us-east-1d"
     }
 
-Any changes you make to these files does not stick until you've committed them.
+Any changes you make to these files do not stick until you've committed them.
 To commit a group do the following.
 
     $ judo commit :default
@@ -96,7 +96,7 @@ You can stop all the servers in the :default group with:
 
 You could also have typed:
 
-  $ judo stop my_server_1 my_server_2
+    $ judo stop my_server_1 my_server_2
 
 ##  COMMANDS
 
@@ -126,7 +126,7 @@ Creates N new servers where N is an integer.  These servers have generic names
 (group.N).  Note: servers with generic names AND no external resources (like
 EBS Volumes or Elastic IPs) will be destroyed when stopped.
 
-  $ judo destroy NAME
+    $ judo destroy NAME
 
 Destroy the named server.  De-allocates any elastic IP's and destroys the EBS
 volumes.
@@ -208,7 +208,7 @@ A memcached server:
         "elastic_ip" : true,
         // only need 1 package
         "packages" : "memcached",
-        "instance_size" : "m1.xlarge",
+        "instance_type" : "m1.xlarge",
         "files" : [
           { "file"     : "/etc/memcached.conf",
             "template" : "memcached.conf.erb" },
@@ -239,7 +239,7 @@ A redis server with a 2 disk xfs raid 0:
         // dont repeat yourself - import the basic config
         "import" : "default",
         "elastic_ip" : true,
-        "instance_size" : "m2.xlarge",
+        "instance_type" : "m2.xlarge",
         "local_packages" : { "package" : "redis-server_1.2.5-1", "source" : "http://http.us.debian.org/debian/pool/main/r/redis/" },
         "volumes" : [{ "device" : "/dev/sde1",
                        "media"  : "ebs",
@@ -274,26 +274,26 @@ default config.  The system is expecting a registered keypair in this case
 named "keypair123" with a "keypair123.pem" file located in a subfolder named
 "keypairs".
 
-    "instance_size":"m1.small",
+    "instance_type":"m1.small",
 
 Specify the instance size for the server type here. See:
 http://aws.amazon.com/ec2/instance-types/
 
-  "ami32":"ami-bb709dd2",
-  "ami64":"ami-55739e3c",
-  "user":"ubuntu",
+    "ami32":"ami-bb709dd2",
+    "ami64":"ami-55739e3c",
+    "user":"ubuntu",
 
 This is where you specify the AMI's to use.  The defaults (above) are the
 ubuntu 9.10 public AMI's.  The "user" value is which user has the keypair
 bound to it for ssh'ing into the server.
 
-  "security_group":"judo",
+    "security_group":"judo",
 
 What security group to launch the server in.  A judo group is created for you
 which only has port 22 access.  Manually create new security groups as needed
 and name them here.
 
-  "availability_zone":"us-east-1d"
+    "availability_zone":"us-east-1d"
 
 What zone to launch the server in.
 
@@ -309,7 +309,9 @@ This command is very import and allows you inherit the configurations and files
 from other groups.  If you wanted to make a group called 'mysql' that was
 exactly like the default group except it installed the mysql package and ran on
 a m2.4xlarge instance type you could specify it like this:
-	{ "import : "default", "packages" : [ "mysql" ], "instance_size" : "m2.4xlarge" }
+	
+    { "import : "default", "packages" : [ "mysql" ], "instance_type" : "m2.4xlarge" }
+
 and save yourself a lot of typing.  You could further subclass by making a new
 group and importing this config.
 
@@ -493,7 +495,7 @@ was run on this specific server boot check the first line of kuzushi.log.
     ubuntu:~$ sudo head -n 1 /var/log/kuzushi.log
 
 
-== Meta
+## Meta
 
 Created by Orion Henry and Adam Wiggins. Forked from the gem 'sumo'.
 

data/TODO

@@ -1,23 +1,21 @@
 ### NEEDED for new gem launch
 
 ### [ ] ubuntu 10.04
-### [ ] allocate elastic_ip first
 ### [ ] snapshot percent complete in do_snapshots()
 ### [ ] judo swap (x) (y) -> swaps elastic IP's and name
 ### [ ] snapshots/init/virgin
 ### [ ] bind kuzushi gem version version
 ### [ ] should be able to do ALL actions except commit without the repo!
 ###     [ ] ssh - put pem into s3
-### [ ] store s3 bucket in config
-### [ ] store things in s3 by sha1sum
-### [ ] ebs backed root disk
-### [ ] clone from ebs snapshot on start
-### [ ] implement start/stop
+###     [ ] store s3 bucket in config
+### [ ] saw a timeout on volume allocation - make sure we build in re-tries - need to allocate the server all together as much as possible
+### [ ] round robin or specified availability_zone
 
+### MAYBE
+### [ ] store things in s3 by sha1sum
+### [ ] ebs backed root disk + start/stop
 ### [ ] implement auto security_group creation and setup (6 hrs)
-
-### [ ] 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
+### [ ] fix ruby 1.8.6 - test 1.9.1
 
 ### [ ] two phase delete (1 hr)
 ### [-] refactor availability_zone (2 hrs)

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.3.0

data/bin/judo

@@ -63,14 +63,29 @@ banner
   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( '-D', '--data DATA', 'Specify an instance specific string to be used during boot on create or launch' ) do |data|
+    options[:data] = data
+  end
+  opts.on( '-t', '--type TYPE', 'Specify an instance type different from the config on server start' ) do |type|
+    options[:instance_type] = type
+  end
+  opts.on( '-B', '--boot BOOT', 'Instance specific string (like --data) but for this boot only' ) do |data|
+    options[:boot] = data
+  end
+  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( '-s', '--secret KEY', 'Specify the AWS access secret key' ) do |key|
-    options[:access_key] = key
+    options[:access_secret] = key
   end
   opts.on( '-b', '--bucket BUCKET', 'Specify the AWS S3 bucket to use' ) do |bucket|
     options[:bucket] = bucket
@@ -106,11 +121,11 @@ begin
     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(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 "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 }
+    when "launch" then mk_servers(judo, ARGV)         { |s| s.create(options); s.start(options) }
     when "snapshots" then do_snapshots(judo, ARGV)
     when "swapip" then
       servers = find_servers(judo, ARGV)

data/lib/judo/base.rb

@@ -33,6 +33,7 @@ module Judo
       @bucket_name   = options[:bucket]
       @access_id     = options[:access_id]
       @access_secret = options[:access_secret]
+      @domain        = options[:domain]
     end
 
     def volumes
@@ -60,8 +61,24 @@ module Judo
       end
     end
 
-    def self.domain
-      "judo_config"
+    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 = find_judo_dir(pwd))
@@ -72,6 +89,7 @@ module Judo
         :judo_dir      => dir,
         :group         => group_config ? File.basename(File.dirname(group_config)) : nil,
         :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'])
@@ -80,7 +98,8 @@ module Judo
       {
         :access_id     => ENV['AWS_ACCESS_KEY_ID'],
         :access_secret => ENV['AWS_SECRET_ACCESS_KEY'],
-        :bucket        => ENV['JUDO_BUCKET']
+        :bucket        => ENV['JUDO_BUCKET'],
+        :domain        => ENV['JUDO_DOMAIN'],
       }.delete_if { |key,value| value.nil? }
     end
 
@@ -102,7 +121,7 @@ module Judo
 
     def fetch_snapshots_state
       s = {}
-      sdb.select("select * from #{Judo::Snapshot.domain}")[:items].each do |group|
+      sdb.select("select * from `#{snapshot_domain}`")[:items].each do |group|
         group.each do |key,val|
           s[key] = val
         end
@@ -112,7 +131,7 @@ module Judo
 
     def fetch_servers_state
       s = {}
-      sdb.select("select * from #{Judo::Server.domain}")[:items].each do |group|
+      sdb.select("select * from `#{server_domain}`")[:items].each do |group|
         group.each do |key,val|
           s[key] = val
         end
@@ -191,11 +210,11 @@ module Judo
     end
 
     def groups_config
-      @groups_config ||= sdb.get_attributes("judo_config", "groups")[:attributes]
+      @groups_config ||= sdb.get_attributes(base_domain, "groups")[:attributes]
     end
 
     def group_versions
-      @group_version ||= sdb.get_attributes("judo_config", "group_versions")[:attributes]
+      @group_version ||= sdb.get_attributes(base_domain, "group_versions")[:attributes]
     end
 
     def ip_to_judo(ip)
@@ -215,15 +234,23 @@ module Judo
     end
 
     def s3_url(k)
-      Aws::S3Generator::Key.new(bucket, k).get
+      Aws::S3Generator::Key.new(bucket, s3_key(k)).get
     end
 
     def s3_get(k)
-      bucket.get(k)
+      bucket.get( s3_key(k))
     end
 
     def s3_put(k, file)
-      bucket.put(k, file)
+      bucket.put( s3_key(k), file)
+    end
+
+    def s3_key(k)
+      if @domain
+        "#{@domain}/#{k}"
+      else
+        k
+      end
     end
 
     def repo
@@ -252,14 +279,14 @@ module Judo
       case get_db_version
         when 0
           task("Upgrading Judo: Creating Snapshots SDB Domain") do
-            sdb.create_domain(Judo::Server.domain)
-            sdb.create_domain(Judo::Snapshot.domain)
-            sdb.create_domain(Judo::Snapshot.domain)
+            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(Judo::Snapshot.domain)
+            sdb.create_domain(snapshot_domain)
             set_db_version(2)
           end
         else
@@ -269,15 +296,18 @@ module Judo
 
     def set_db_version(new_version)
       @db_version = new_version
-      sdb.put_attributes("judo_config", "judo", { "dbversion" => new_version }, :replace)
+      sdb.put_attributes(base_domain, "judo", { "dbversion" => new_version }, :replace)
     end
 
     def get_db_version
-      @db_version ||= sdb.get_attributes("judo_config", "judo")[:attributes]["dbversion"].first.to_i
+      @db_version ||= (sdb.get_attributes(base_domain, "judo")[:attributes]["dbversion"] || []).first.to_i
     end
 
     def check_version
-      upgrade_db if get_db_version != db_version
+        upgrade_db if get_db_version != db_version
+      rescue Aws::AwsError => e
+        setup_sdb
+        upgrade_db
     end
 
     def setup
@@ -294,7 +324,7 @@ module Judo
 
     def setup_sdb
       task("Trying to connect to SimpleDB") do
-        sdb.create_domain(Judo::Base.domain)
+        sdb.create_domain(base_domain)
       end
     end
 
@@ -316,7 +346,7 @@ module Judo
       task("writing .judo/config.yml") do
         Dir.chdir(repo) do
           system "mkdir .judo"
-          File.open(".judo/config.yml","w") do |f| 
+          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
@@ -346,7 +376,7 @@ module Judo
         <<DEFAULT
 {
   "key_name":"#{@keypair}",
-  "instance_size":"m1.small",
+  "instance_type":"m1.small",
   "ami32":"ami-bb709dd2", // public ubuntu 9.10 ami - 32 bit
   "ami64":"ami-55739e3c", // public ubuntu 9.10 ami - 64 bit
   "user":"ubuntu",

data/lib/judo/group.rb

@@ -31,7 +31,7 @@ module Judo
     end
 
     def set_version
-      @base.sdb.put_attributes("judo_config", "group_versions", { name => version }, :replace)
+      @base.sdb.put_attributes(@base.base_domain, "group_versions", { name => version }, :replace)
     end
 
     def compile
@@ -137,7 +137,7 @@ module Judo
 
     def parent
       @parent ||= @base.groups.detect { |p| p.name == raw_config["import"] }
-      raise JudoError, "Parent group #{raw_config["import"]} must be commited" if raw_config["import"] and @parent.nil?
+      (@parent ||= Judo::Group.new(@base, raw_config["import"], 0 )) if raw_config["import"]  ## make a mock incase the parent was never committed
       @parent
     end
 
@@ -145,8 +145,8 @@ module Judo
       servers.each { |s| s.destroy }
       @base.task("Destring #{self}") do
         @base.groups.delete(self)
-        @base.sdb.delete_attributes("judo_config", "groups", [ name ])
-        @base.sdb.delete_attributes("judo_config", "group_versions", [ name ])
+        @base.sdb.delete_attributes(@base.base_domain, "groups", [ name ])
+        @base.sdb.delete_attributes(@base.base_domain, "group_versions", [ name ])
       end
     end
 
@@ -169,7 +169,7 @@ module Judo
     end
 
     def delete_server(server)
-      sdb.delete_attributes("judo_config", "groups", name => server.name)
+      sdb.delete_attributes(@base.base_domain, "groups", name => server.name)
     end
 
     def to_s

data/lib/judo/server.rb

@@ -1,6 +1,6 @@
 module Judo
   class Server
-    attr_accessor :name
+    attr_accessor :name, :group_name
 
     def initialize(base, name, group, version = nil)
       @base = base
@@ -9,10 +9,12 @@ module Judo
     end
 
     def create(options)
-      raise JudoError, "no group specified" unless @group_name
+      raise JudoError, "no group specified" unless group_name
 
-      snapshots = options[:snapshots]
-      note = options[:note]
+      snapshots  = options[:snapshots]
+      note       = options[:note]  ## a user defined note field
+      data       = options[:data]  ## instance specific data passed in JUDO_DATA
+      ip         = options[:elastic_ip]      ## if the ip was allocated beforehand
 
       version = options[:version]
       version ||= group.version
@@ -25,8 +27,11 @@ 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, "note" => note, "virgin" => true, "secret" => rand(2 ** 128).to_s(36), "version" => version
-        @base.sdb.put_attributes("judo_config", "groups", @group_name => name)
+        update "name" => name,         "group" => group_name,
+               "note" => note,         "virgin" => true,
+               "secret" => new_secret, "version" => version,
+               "data" => data,         "elastic_ip" => ip
+        @base.sdb.put_attributes(@base.base_domain, "groups", group_name => name)
       end
 
       allocate_disk(snapshots)
@@ -36,11 +41,11 @@ module Judo
     end
 
     def group
-      @group ||= @base.groups.detect { |g| g.name == @group_name }
+      @group ||= @base.groups.detect { |g| g.name == group_name }
     end
 
     def fetch_state
-      @base.sdb.get_attributes(self.class.domain, name)[:attributes]
+      @base.sdb.get_attributes(@base.server_domain, name)[:attributes]
     end
 
     def state
@@ -51,6 +56,10 @@ module Judo
       state[key] && [state[key]].flatten.first
     end
 
+    def data
+      get "data"
+    end
+
     def instance_id
       get "instance_id"
     end
@@ -60,10 +69,10 @@ module Judo
     end
 
     def size_desc
-      if not running? or ec2_instance_type == instance_size
-        instance_size
+      if not running? or ec2_instance_type == instance_type
+        instance_type
       else
-        "#{ec2_instance_type}/#{instance_size}"
+        "#{ec2_instance_type}/#{instance_type}"
       end
     end
 
@@ -119,39 +128,36 @@ module Judo
       Hash[ (state["volumes"] || []).map { |a| a.split(":") } ]
     end
 
-    def self.domain
-      "judo_servers"
-    end
-
     def update(attrs)
-      @base.sdb.put_attributes(self.class.domain, name, attrs, :replace)
+      @base.sdb.put_attributes(@base.server_domain, name, attrs, :replace)
       state.merge! attrs
     end
 
     def add(key, value)
-      @base.sdb.put_attributes(self.class.domain, name, { key => value })
+      @base.sdb.put_attributes(@base.server_domain, name, { key => value })
       (state[key] ||= []) << value
     end
 
     def remove(key, value = nil)
       if value
-        @base.sdb.delete_attributes(self.class.domain, name, key => value)
+        @base.sdb.delete_attributes(@base.server_domain, name, key => value)
         state[key] - [value]
       else
-        @base.sdb.delete_attributes(self.class.domain, name, [ key ])
+        @base.sdb.delete_attributes(@base.server_domain, name, [ key ])
         state.delete(key)
       end
     end
 
     def delete
       group.delete_server(self) if group
-      @base.sdb.delete_attributes(self.class.domain, name)
+      @base.sdb.delete_attributes(@base.server_domain, name)
     end
 
 ######## end simple DB access  #######
 
-    def instance_size
-      config["instance_size"]
+    def instance_type
+     ## need instance_size to be backward compatible - needed for configs made before v 0.3.0
+     get("instance_type") || config["instance_type"] || config["instance_size"]
     end
 
     def config
@@ -159,7 +165,7 @@ module Judo
     end
 
     def to_s
-      "#{name}:#{@group_name}"
+      "#{name}:#{group_name}"
     end
 
     def allocate_disk(snapshots)
@@ -275,18 +281,22 @@ module Judo
       ["pending", "running", "shutting_down", "degraded"].include?(ec2_state)
     end
 
-    def start(new_version = nil)
+    def start(options = {})
+      new_version = options[:version]
+      set_instance_type(options[:instance_type]) if options[:instance_type]
+
       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("Updating server version")      { update_version(options[:version]) } if options[:version]
+      task("Starting server #{name}")      { launch_ec2(options[:boot]) }
       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(force = false)
-      stop(force) if running?
+    def restart(options = {})
+      stop(options) if running?
       start
     end
 
@@ -310,7 +320,8 @@ module Judo
       end
     end
 
-    def stop(force = false)
+    def stop(options = {})
+      force = options[:force]
       invalid "not running" unless running?
       ## EC2 terminate_isntaces
       task("Terminating instance") { @base.ec2.terminate_instances([ instance_id ]) }
@@ -319,14 +330,14 @@ module Judo
       remove "instance_id"
     end
 
-    def launch_ec2
+    def launch_ec2(boot = nil)
 #      validate
 
       ## EC2 launch_instances
-      ud = user_data
+      ud = user_data(boot)
       debug(ud)
       result = @base.ec2.launch_instances(ami,
-        :instance_type => config["instance_size"],
+        :instance_type => instance_type,
         :availability_zone => config["availability_zone"],
         :key_name => config["key_name"],
         :group_ids => security_groups,
@@ -353,7 +364,7 @@ module Judo
     end
 
     def ia32?
-      ["m1.small", "c1.medium"].include?(instance_size)
+      ["m1.small", "c1.medium"].include?(instance_type)
     end
 
     def ia64?
@@ -480,13 +491,15 @@ module Judo
       @base.servers_state.delete(name)
     end
 
-    def user_data
+    def user_data(judo_boot = nil)
       <<USER_DATA
 #!/bin/sh
 
 export DEBIAN_FRONTEND="noninteractive"
 export DEBIAN_PRIORITY="critical"
 export JUDO_ID='#{name}'
+export JUDO_BOOT='#{judo_boot}'
+export JUDO_DATA='#{data}'
 export SECRET='#{secret}'
 apt-get update
 apt-get install ruby rubygems ruby-dev irb libopenssl-ruby libreadline-ruby -y
@@ -527,7 +540,7 @@ USER_DATA
       ip2 = other.elastic_ip
       raise JudoError, "Server must have an elastic IP to swap" unless ip1 and ip2
 
-      task("Swapping Ip Addresses") do 
+      task("Swapping Ip Addresses") do
         @base.ec2.disassociate_address(ip1)
         @base.ec2.disassociate_address(ip2)
 
@@ -543,5 +556,9 @@ USER_DATA
       [group.name, name] <=> [s.group.name, s.name]
     end
 
+    def new_secret
+      rand(2 ** 128).to_s(36)
+    end
+
   end
 end

data/lib/judo/snapshot.rb

@@ -17,7 +17,7 @@ module Judo
     end
 
     def fetch_state
-      @base.sdb.get_attributes(self.class.domain, name)[:attributes]
+      @base.sdb.get_attributes(@base.snapshot_domain, name)[:attributes]
     end
 
     def state
@@ -43,7 +43,7 @@ module Judo
         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)
+        @base.sdb.put_attributes(@base.snapshot_domain, name, { "version" => server.version, "devs" => devs, "server" => server.name, "group" => server.group.name }, :replace)
         server.add "snapshots", name
       end
     end
@@ -56,7 +56,7 @@ module Judo
     end
 
     def delete
-      @base.sdb.delete_attributes(self.class.domain, name)
+      @base.sdb.delete_attributes(@base.snapshot_domain, name)
       server.remove "snapshots", name
     end
 
@@ -98,7 +98,7 @@ module Judo
     end
 
     def fetch_state
-      @base.sdb.get_attributes(self.class.domain, name)[:attributes]
+      @base.sdb.get_attributes(@base.snapshot_domain, name)[:attributes]
     end
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 4
-  version: 0.2.4
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Orion Henry
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-17 00:00:00 -04:00
+date: 2010-05-18 00:00:00 -04:00
 default_executable: judo
 dependencies: 
 - !ruby/object:Gem::Dependency