judo 0.4.4 → 0.5.0

data/lib/judo/cli_helpers.rb

@@ -0,0 +1,157 @@
+module Judo
+  module CLIHelpers
+		def default_group_dir
+      File.expand_path(File.dirname(__FILE__) + "/../../default")
+    end
+
+    def do_generate(judo, args)
+			name = args.first
+			if File.exists?(name)
+				puts "group already exists at /#{name}"
+			else
+			  FileUtils.cp_r(default_group_dir, name)
+			end
+    end
+
+    def each_server(judo, args, &blk)
+      raise JudoError, "No servers specified - use :all for all servers" if args.empty?
+      servers = judo.find_servers_by_name_or_groups_with_not(args)
+      servers.each do |server|
+        begin
+          blk.call(server)
+        rescue JudoInvalid => e
+          puts "#{server} - #{e.message}"
+        end
+      end
+    end
+
+    def mk_server_names(judo, args, &blk)
+      args.each do |arg|
+        name,group = arg.split(":")
+        raise JudoError, "You must specify a group on create and launch" unless group
+        names = if name =~ /^[12345]$/
+          (1..(name.to_i)).each do
+            blk.call(judo.mk_server_name(group), group)
+          end
+        elsif name == ""
+          blk.call(judo.mk_server_name(group), group)
+        elsif name =~ /^\d+$/
+          raise JudoError, "You can batch-create between 1 and 5 servers" if count < 1 or count > 5
+        else
+          blk.call(name, group)
+        end
+      end
+    end
+
+    def do_commit(judo, args)
+			name = args.first
+			if name =~ /:(.+)$/
+        group = judo.get_group($1)
+      else
+        raise JudoError, "Invalid group name '#{name}'"
+      end
+			group.commit
+    end
+
+    def mk_servers(judo, options, args, start)
+      mk_server_names(judo, args) do |name, group|
+        begin
+          server = judo.create_server(name, group, options)
+          server.start(options) if start
+        rescue JudoInvalid => e
+          puts "#{server} - #{e.message}"
+        end
+      end
+    end
+
+    def do_groups(judo)
+      printf "  SERVER GROUPS\n"
+      judo.groups.each do |g|
+        printf "%-18s %s servers\n", g.name, g.servers.size
+      end
+    end
+
+    def do_volumes(judo)
+      vols = judo.volumes.sort { |a,b| [ a[:assigned_to].to_s, a[:instance_id].to_s ] <=> [ b[:assigned_to].to_s, b[:instance_id].to_s ] }
+
+      format = "%13s %6s %12s  %-10s %-16s %-16s\n"
+      printf format, "AWS_ID", "SIZE", "AWS_STATUS", "AWS_DEVICE", "ATTACHED TO", "CONFIGURED FOR"
+      printf "%s\n", ("-" * 80)
+
+      vols.each do |v|
+        attached = v[:attached_to] ? v[:attached_to].name : v[:instance_id]
+        assigned = v[:assigned_to] ? v[:assigned_to].name : ""
+        printf format, v[:id], v[:size], v[:status], v[:device], attached, assigned
+      end
+    end
+
+    def do_ips(judo)
+      ips = judo.ips.sort { |a,b| a[:assigned_to].to_s <=> b[:assigned_to].to_s }
+
+      format = "%15s %20s %20s\n"
+      printf format, "IP", "ATTACHED TO", "CONFIGURED FOR"
+      printf "%s\n", ("-"*57)
+
+      ips.each do |ip|
+        attached = ip[:attached_to] ? ip[:attached_to].name : ip[:instance_id]
+        assigned = ip[:assigned_to] ? ip[:assigned_to].name : ""
+        printf format, ip[:ip], attached, assigned
+      end
+    end
+
+    def do_snapshots(judo, args)
+      printf "  SNAPSHOTS\n"
+      printf "%s\n", ("-" * 80)
+      judo.snapshots.each do |snapshot|
+        printf "%-15s %-25s %-15s %-10s %s\n", snapshot.name, snapshot.server_name, snapshot.group_name, snapshot.version_desc, "ebs:#{snapshot.ec2_ids.size}"
+      end
+    end
+
+    def do_list(judo, args)
+      printf "  SERVERS\n"
+      printf "%s\n", ("-" * 80)
+      args << ":all" if args.empty?
+      each_server(judo,args) do |s|
+        printf "%-32s %-12s %-7s %-11s %-11s %-10s %-3s %s\n", s.name, s.group.name, s.version_desc, s.get("instance_id"), s.size_desc, s.ec2_state, "ebs:#{s.volumes.keys.size}", s.has_ip? ? "ip" : ""
+      end
+    end
+
+    def sub_info(header, data, &block)
+      return if data == []
+      return if data == {}
+      return if data.nil?
+      puts "  [ #{header} ]"
+      [ data ].flatten.each do |d|
+        block.call(d)
+      end
+    end
+
+    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", "Animated From", server.clone if server.clone
+      printf "    %-24s: %s\n", "Elastic Ip", server.elastic_ip if server.elastic_ip
+      sub_info("EC2", server.ec2_instance) do |i|
+        [:aws_instance_id, :ssh_key_name, :aws_availability_zone, :aws_state, :aws_image_id, :dns_name, :aws_instance_type, :private_dns_name, :aws_launch_time, :aws_groups ].each do |k|
+          printf "    %-24s: %s\n",k, i[k]
+        end
+      end
+      sub_info("METADATA", server.metadata.keys) do |key|
+        printf("    %-24s: %s\n", key, server.metadata[key] )
+      end
+      sub_info("VOLUMES", server.ec2_volumes) do |v|
+        printf "    %-13s %-10s %-10s %4d  %-10s %-8s\n",
+        v[:aws_id],
+        v[:aws_status],
+        v[:zone],
+        v[:aws_size],
+        v[:aws_attachment_status],
+        v[:aws_device]
+      end
+      sub_info("SNAPSHOTS", server.snapshots) do |s|
+        printf "    %-10s %-15s %-8s %-5s\n", s.name, s.group_name, s.version_desc, "#{s.ec2_ids.size}v"
+      end
+    end
+  end
+end

data/lib/judo/group.rb

@@ -19,12 +19,8 @@ module Judo
       (@config ||= {})[version] ||= load_config(version)
     end
 
-    def server_ids
-      @server_ids ||= (@base.groups_config[@name] || [])
-    end
-
     def servers
-      @base.servers.select { |s| server_ids.include?(s.id) }
+      @base.servers.select { |s| s.group_name == name }
     end
 
     def load_userdata(version)
@@ -40,28 +36,32 @@ module Judo
     end
 
     def set_version
-      @base.sdb.put_attributes(@base.base_domain, "group_versions", { name => version }, :replace)
+      @base.sdb.put_attributes(@base.base_domain,
+        "group_versions", {name => version}, :replace)
+    end
+
+    def check_conf(conf)
+      if conf["import"]
+        raise JudoError, "config option 'import' no longer supported"
+      end
     end
 
-    def compile
-      raise JudoError, "Group name :all is reserved" if name == "all"
+    def commit
+      raise JudoError, "Group name all is reserved" if name == "all"
       @base.task("Compiling #{self} version #{version + 1}") do
         @version = version + 1
-        raise JudoError, "can not find group folder #{dir}" unless File.exists?(dir)
-        conf = JSON.parse(read_file('config.json'))
-        raise JudoError, "config option 'import' no longer supported" if conf["import"]
+        conf = JSON.parse(File.read("#{name}/config.json"))
+        userdata = File.read("#{name}/userdata.erb")
         tar = tar_file(@version)
-        Dir.chdir(@base.repo) do |d|
-            puts ""
-            system "tar czvf #{tar} #{name}"
-            puts "Uploading config to s3..."
-            @base.s3_put(version_config_file(@version), conf.to_json)
-            puts "Uploading userdata.erb to s3..."
-            @base.s3_put(version_userdata_file(@version), read_file('userdata.erb'))
-            puts "Uploading tar file to s3..."
-            @base.s3_put(tar, File.new(tar).read(File.stat(tar).size))
-            File.delete(tar)
-        end
+        puts ""
+        system "tar czvf #{tar} #{name}"
+        puts "Uploading config to s3..."
+        @base.s3_put(version_config_file(@version), conf.to_json)
+        puts "Uploading userdata.erb to s3..."
+        @base.s3_put(version_userdata_file(@version), userdata)
+        puts "Uploading tar file to s3..."
+        @base.s3_put(tar, File.new(tar).read(File.stat(tar).size))
+        File.delete(tar)
         set_version
       end
     end
@@ -82,37 +82,17 @@ module Judo
       @url = @base.s3_url(tar_file(version))
     end
 
-
     def destroy
-      servers.each { |s| s.destroy }
-      @base.task("Destring #{self}") do
+      @base.task("Destroying servers in group #{self}") do
+        servers.each { |s| s.destroy }
+      end
+      @base.task("Destroying group #{self}") do
         @base.groups.delete(self)
-        @base.sdb.delete_attributes(@base.base_domain, "groups", [ name ])
         @base.sdb.delete_attributes(@base.base_domain, "group_versions", [ name ])
       end
     end
 
-    def dir
-      "#{@base.repo}/#{name}/"
-    end
-
-    def default_userdata_file
-        File.expand_path(File.dirname(__FILE__) + "/../../default/userdata.erb")
-    end
-
-    def read_file(name)
-        File.read("#{dir}/#{name}")
-      rescue Errno::ENOENT
-        default = @base.default_file(name)
-        puts "File #{name} not found: using #{default} instead"
-        File.read default
-    end
-
-    def delete_server(server)
-      sdb.delete_attributes(@base.base_domain, "groups", name => server.id)
-    end
-
-    def displayname 
+    def displayname
       ":#{name}"
     end
 
@@ -120,16 +100,8 @@ module Judo
       displayname
     end
 
-    def sdb
-      @base.sdb
-    end
-
     def version_desc(v)
-      if v == version
-        "v#{v}"
-      else
-        "v#{v}/#{version}"
-      end
+      v == version ? "v#{v}" : "v#{v}/#{version}"
     end
   end
 end

data/lib/judo/patch.rb

@@ -0,0 +1,13 @@
+module Aws
+  class Ec2
+    def describe_snapshots(list=[], opts={})
+      params = {}
+      params.merge!(hash_params('SnapshotId',list.to_a))
+      params.merge!(hash_params('Owner', [opts[:owner]])) if opts[:owner]
+      link = generate_request("DescribeSnapshots", params)
+      request_cache_or_info :describe_snapshots, link,  QEc2DescribeSnapshotsParser, @@bench, list.blank?
+    rescue Exception
+      on_exception
+    end
+  end
+end

data/lib/judo/server.rb

@@ -1,38 +1,33 @@
 module Judo
   class Server
-    attr_accessor :id
+    attr_accessor :base, :id, :group_name
 
-    def initialize(base, id, group, version = nil)
+    def initialize(base, id, group_name, version = nil)
       @base = base
       @id = id
-      @group = group
-      @judo_domain = base.domain
+      @group_name = group_name
     end
 
     def create(name, options)
       raise JudoError, "group '#{group_name}' does not exists" unless group
-
-      options[:virgin] = true if options[:virgin].nil?
-
-      snapshots  = options[:snapshots]
-      metadata   = options[:metadata]
-      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
-
       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}
 
+      virgin        = !(options[:virgin] == false)
+      snapshots     = options[:snapshots]
+      metadata      = options[:metadata]
+      ip            = options[:elastic_ip]
+      clone         = options[:clone]
+      instance_type = options[:instance_type]
+      version       = options[:version] || group.version
+
       task("Creating server #{name}") do
         update("name" => name,         "group" => group_name,
                "virgin" => virgin,     "elastic_ip" => ip,
-               "secret" => new_secret, "version" => version,
-               "clone" => clone,       "created_at" => Time.now.to_i)
+               "version" => version,   "clone" => clone,
+               "instance_type" => instance_type,
+               "created_at" => Time.now.to_i)
         set_metadata(metadata) if metadata
-        @base.sdb.put_attributes(@base.base_domain, "groups", group_name => id)
       end
 
       allocate_disk(snapshots)
@@ -42,19 +37,13 @@ module Judo
     end
 
     def set_metadata(new_metadata)
-      puts new_metadata.inspect
-      clean_metadata = new_metadata.inject({}) { |buf,(k,v)| 
-        puts [ buf, k , v ].inspect
-        buf[k.to_s] = v.to_s; buf }
-      puts clean_metadata.inspect
-      keys_to_remove = clean_metadata.keys - clean_metadata.keys
-      @metadata = clean_metadata
-      update encode_metadata(clean_metadata) unless clean_metadata.empty?
-      keys_to_remove.each { |key| remove key }
-    end
-
-    def encode_metadata(data)
-      data.inject({}) { |buf,(key,value)| buf["metadata_#{key.to_s}"] = [value].to_json; buf }
+      new_metadata_json = new_metadata.to_json
+      if (new_metadata_json.size > 1000)
+        raise "metadata json too big: '#{new_metadata_json}'"
+      else
+        @metadata = new_metadata
+        update("metadata_json" => new_metadata_json)
+      end
     end
 
     def metadata
@@ -62,16 +51,12 @@ module Judo
     end
 
     def get_metadata
-      state.inject({}) do |buf,(key,value)|
-        if key =~ /^metadata_(.*)/
-          buf[$1] = JSON.load(value.first)
-        end
-        buf
-      end
+      metadata_json = get("metadata_json")
+      JSON.load(metadata_json) if metadata_json
     end
 
     def group
-      @group_obj ||= @base.groups.detect { |g| g.name == @group }
+      @group ||= @base.groups.detect { |g| g.name == @group_name }
     end
 
     def fetch_state
@@ -98,10 +83,6 @@ module Judo
       get "name"
     end
 
-    def data
-      get "data"
-    end
-
     def instance_id
       get "instance_id"
     end
@@ -138,10 +119,6 @@ module Judo
       end
     end
 
-    def note
-      get("note")
-    end
-
     def clone
       get("clone")
     end
@@ -158,10 +135,6 @@ module Judo
       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
 
-    def secret
-      get "secret"
-    end
-
     def snapshots
       @base.snapshots.select { |s| s.server == self }
     end
@@ -197,15 +170,13 @@ module Judo
     end
 
     def delete
-      group.delete_server(self) if group
       @base.sdb.delete_attributes(@base.server_domain, id)
     end
 
 ######## end simple DB access  #######
 
     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"] || "m1.small"
+     get("instance_type")
     end
 
     def config
@@ -245,7 +216,6 @@ module Judo
             size = volume_config["size"]
             if not volumes[device]
               task("Creating EC2 Volume #{device} #{size}") do
-                ### EC2 create_volume
                 volume_id = @base.ec2.create_volume(nil, size, config["availability_zone"])[:aws_id]
                 add_volume(volume_id, device)
               end
@@ -262,7 +232,6 @@ module Judo
     def allocate_ip
       begin
         if config["elastic_ip"] and not elastic_ip
-          ### EC2 allocate_address
           task("Adding an elastic ip") do
             ip = @base.ec2.allocate_address
             add_ip(ip)
@@ -313,18 +282,16 @@ module Judo
 
     def destroy
       stop if running?
-      ### EC2 release_address
       task("Deleting Elastic Ip") { remove_ip } if has_ip?
       volumes.each { |dev,v| remove_volume(v,dev) }
       task("Destroying server #{name}") { delete }
     end
 
     def ec2_state
-      ec2_instance[:aws_state] rescue "offline"
+      ec2_instance[:aws_state]
     end
 
     def ec2_instance
-      ### EC2 describe_instances
       @base.ec2_instances.detect { |e| e[:aws_instance_id] == instance_id } or {}
     end
 
@@ -334,7 +301,7 @@ module Judo
     end
 
     def start(options = {})
-      @boot= options[:boot]
+      @boot = options[:boot]
       new_version = options[:version]
       set_instance_type(options[:instance_type]) if options[:instance_type]
 
@@ -385,15 +352,12 @@ module Judo
     end
 
     def launch_ec2
-#      validate
-
-      ## EC2 launch_instances
       ud = user_data
       debug(ud)
       result = @base.ec2.launch_instances(ami,
         :instance_type => instance_type,
         :availability_zone => config["availability_zone"],
-        :key_name => @base.key_name,
+        :key_name => "judo",
         :group_ids => security_groups,
         :user_data => ud).first
       update "instance_id" => result[:aws_instance_id], "virgin" => false, "started_at" => Time.now.to_i
@@ -472,17 +436,21 @@ module Judo
       end
     end
 
+    def ssh?
+      begin
+        Timeout::timeout(2) do
+          TCPSocket.new(hostname, 22)
+          true
+        end
+      rescue SocketError, Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+        false
+      end
+    end
+
     def wait_for_ssh
       invalid "not running" unless running?
       loop do
-        begin
-          reload
-          Timeout::timeout(4) do
-            TCPSocket.new(hostname, 22)
-            return
-          end
-        rescue SocketError, Timeout::Error, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-        end
+        ssh? ? return : sleep(1)
       end
     end
 
@@ -493,7 +461,6 @@ module Judo
 
     def attach_ip
       return unless running? and elastic_ip
-      ### EC2 associate_address
       @base.ec2.associate_address(instance_id, elastic_ip)
     end
 
@@ -508,14 +475,12 @@ module Judo
     def attach_volumes
       return unless running?
       volumes.each do |device,volume_id|
-        ### EC2 attach_volume
         @base.ec2.attach_volume(volume_id, instance_id, device)
       end
     end
 
     def remove_volume(volume_id, device)
       task("Deleting #{device} #{volume_id}") do
-        ### EC2 delete_volume
         @base.ec2.delete_volume(volume_id)
         remove "volumes", "#{device}:#{volume_id}"
       end
@@ -534,14 +499,14 @@ module Judo
     def ssh_command(cmd)
       wait_for_ssh
       @base.keypair_file do |file|
-        system "ssh -i #{file} #{config["user"]}@#{hostname} '#{cmd}'"
+        system "ssh -q -i #{file} #{config["user"]}@#{hostname} '#{cmd}'"
       end
     end
 
     def connect_ssh
       wait_for_ssh
       @base.keypair_file do |file|
-        system "ssh -i #{file} #{config["user"]}@#{hostname}"
+        system "ssh -q -i #{file} #{config["user"]}@#{hostname}"
       end
     end
 
@@ -568,26 +533,6 @@ module Judo
       group.s3_url(version)
     end
 
-    def domain
-      @base.domain
-    end
-
-    def validate
-      ### EC2 create_security_group
-      @base.create_security_group
-
-      ### EC2 desctibe_key_pairs
-      k = @base.ec2.describe_key_pairs.detect { |kp| kp[:aws_key_name] == config["key_name"] }
-
-      if k.nil?
-        if config["key_name"] == "judo"
-          @base.create_keypair
-        else
-          raise "cannot use key_pair #{config["key_name"]} b/c it does not exist"
-        end
-      end
-    end
-
     def snapshot(name)
       snap = @base.new_snapshot(name, id)
       snap.create
@@ -630,14 +575,6 @@ module Judo
       [group.to_s, name.to_s] <=> [s.group.to_s, s.name.to_s]
     end
 
-    def new_secret
-      rand(2 ** 128).to_s(36)
-    end
-
-    def group_name
-      @group
-    end
-
     def boot
       @boot || {}
     end