rudy 0.2

data/lib/rudy.rb

@@ -0,0 +1,102 @@
+
+require 'right_aws'
+require 'stringio'
+require 'ostruct'
+require 'yaml'
+
+require 'storable'
+
+require 'rudy/aws'
+require 'rudy/scm/svn'
+require 'rudy/utils'
+require 'rudy/command/base'
+
+# Autoload Command and MetaData classes
+begin
+  Dir.glob(File.join(RUDY_LIB, 'rudy', 'command', "*.rb")).each do |path|
+    require path
+  end
+  Dir.glob(File.join(RUDY_LIB, 'rudy', 'metadata', "*.rb")).each do |path|
+    require path
+  end
+rescue LoadError => ex
+  puts "Error: #{ex.message}"
+  exit 1
+end
+
+module Rudy #:nodoc:
+  RUDY_DOMAIN = ENV['RUDY_DOMAIN'] || "rudy_state"
+  RUDY_DELIM = ENV['RUDY_DELIM'] || '-'
+  DEFAULT_REGION = ENV['EC2_DEFAULT_REGION'] || 'us-east-1'
+  DEFAULT_ZONE = ENV['EC2_DEFAULT_ZONE'] || 'us-east-1b'
+  
+  module VERSION #:nodoc:
+    MAJOR = 0.freeze unless defined? MAJOR
+    MINOR = 2.freeze unless defined? MINOR
+    TINY  = 0.freeze unless defined? TINY
+    def self.to_s
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    def self.to_f
+      self.to_s.to_f
+    end
+  end
+end
+
+
+
+# Capture STDOUT or STDERR to prevent it from being printed. 
+#
+#    capture(:stdout) do
+#      ...
+#    end
+#
+def capture(stream)
+  raise "We can only capture STDOUT or STDERR" unless stream == :stdout || stream == :stderr
+  
+  # I'm using this to trap the annoying right_aws "peer certificate" warning.
+  # TODO: discover source of annoying right_aws warning and give it a hiding.
+  begin
+    stream = stream.to_s
+    eval "$#{stream} = StringIO.new"
+    yield
+    result = eval("$#{stream}").read
+  ensure
+    eval("$#{stream} = #{stream.upcase}")
+  end
+
+  result
+end
+
+def you_are_sure?
+  print "Are you sure? "
+  STDIN.gets =~ /^y|yes|ya$/i
+end
+def sh(command, chdir=false)
+  prevdir = Dir.pwd
+  Dir.chdir chdir if chdir
+  puts command if @verbose > 0
+  system(command)
+  Dir.chdir prevdir if chdir
+end
+
+# TODO: Net::SSH
+def ssh(host, keypair, user, command, chdir=false, verbose=false)
+  cmd = "ssh -q -i #{keypair} #{user}@#{host} '"
+  cmd += "cd #{chdir} && " if chdir
+  cmd += " #{command}'"
+  puts cmd if verbose
+  system(cmd)
+end
+
+
+def scp(host, keypair, user, local_path, remote_path, verbose=false)
+  cmd = "scp -i #{keypair} #{local_path} #{user}@#{host}:#{remote_path}"
+  puts cmd if verbose
+  system(cmd)
+end
+
+
+
+
+

data/lib/rudy/aws.rb

@@ -0,0 +1,65 @@
+
+
+
+
+module Rudy
+  module AWS
+        
+    module ObjectBase
+      attr_accessor :aws
+      def initialize(aws_connection)
+        @aws = aws_connection
+      end
+    end
+  
+    class EC2
+      @@logger = StringIO.new
+
+      attr_reader :instances
+      attr_reader :images
+      attr_reader :addresses
+      attr_reader :groups
+      attr_reader :volumes
+      attr_reader :aws
+
+      def initialize(access_key, secret_key)
+        @aws = RightAws::Ec2.new(access_key, secret_key, {:logger => Logger.new(@@logger)})
+        @instances = Rudy::AWS::EC2::Instances.new(@aws)
+        @images = Rudy::AWS::EC2::Images.new(@aws)
+        @groups = Rudy::AWS::EC2::Groups.new(@aws)
+        @addresses = Rudy::AWS::EC2::Addresses.new(@aws)
+        @volumes = Rudy::AWS::EC2::Volumes.new(@aws)
+      end
+    
+    end
+  
+    class S3
+      @@logger = StringIO.new
+
+      attr_reader :aws
+
+      def initialize(access_key, secret_key)
+        @aws = RightAws::S3.new(access_key, secret_key, {:logger => Logger.new(@@logger)})
+      end
+    end
+    
+    class SimpleDB
+      @@logger = StringIO.new
+    
+      attr_reader :domains
+      attr_reader :aws
+    
+      def initialize(access_key, secret_key)
+        @aws = RightAws::SdbInterface.new(access_key, secret_key, {:logger => Logger.new(@@logger)})
+        @domains = Rudy::AWS::SimpleDB::Domains.new(@aws)
+      end
+
+    end
+    
+    require 'rudy/aws/simpledb'
+    require 'rudy/aws/ec2'
+    require 'rudy/aws/s3'
+    
+  end
+  
+end

data/lib/rudy/aws/ec2.rb

@@ -0,0 +1,197 @@
+
+module Rudy::AWS
+  
+  class EC2
+    class Images
+      include Rudy::AWS::ObjectBase
+      
+      # Returns an array of hashes:
+      # {:aws_architecture=>"i386", :aws_owner=>"105148267242", :aws_id=>"ami-6fe40dd5", 
+      #  :aws_image_type=>"machine", :aws_location=>"bucket-name/your-image.manifest.xml", 
+      #  :aws_kernel_id=>"aki-a71cf9ce", :aws_state=>"available", :aws_ramdisk_id=>"ari-a51cf9cc", 
+      #  :aws_is_public=>false}
+      def list
+        @aws.describe_images_by_owner('self') || []
+      end
+      
+    end
+    class Volumes
+      include Rudy::AWS::ObjectBase
+      
+      def list
+        list = @aws.describe_volumes() || []
+        list.select { |v| v[:aws_status] != "deleting" }
+      end
+      
+      def attach(inst_id, vol_id, device)
+        @aws.attach_volume(vol_id, inst_id, device)
+      end
+      
+      def create(zone, size, snapshot=nil)
+        @aws.create_volume(snapshot, size, zone)
+      end
+      
+      def exists?(id)
+        list.each do |v|
+          return true if v[:aws_id] === id
+        end
+        false
+      end
+      
+    end
+    
+    class Instances
+      include Rudy::AWS::ObjectBase
+      
+      def destroy(*list)
+        begin
+          @aws.terminate_instances(list.flatten)
+        rescue RightAws::AwsError => ex
+          raise UnknownInstance.new
+        end
+      end
+      
+      def attached_volume?(id, device)
+        list = volumes(id)
+        list.each do |v|
+          return true if v[:aws_device] == device
+        end
+        false
+      end
+      
+      def volumes(id)
+        list = @aws.describe_volumes() || []
+        list.select { |v| v[:aws_status] != "deleting" && v[:aws_instance_id] === id }
+      end
+      
+      def create(ami, group, keypair_name, user_data, zone)
+        @aws.run_instances(ami, 1, 1, [group], keypair_name, user_data, 'public', nil, nil, nil, zone)
+      end
+      
+      # Creates a list of running instance IDs which are in a security group
+      # that matches +filter+. 
+      # Returns a hash. The keys are instance IDs and the values are a hash
+      # of attributes associated to that instance. 
+      def list(filter='.')
+        filter = filter.to_s.downcase.tr('_|-', '.') # treat dashes, underscores as one
+        # Returns an array of hashes with the following keys:
+        # :aws_image_id, :aws_reason, :aws_state_code, :aws_owner, :aws_instance_id, :aws_reservation_id 
+        # :aws_state, :dns_name, :ssh_key_name, :aws_groups, :private_dns_name, :aws_instance_type, 
+        # :aws_launch_time, :aws_availability_zone :aws_kernel_id, :aws_ramdisk_id
+        instances = @aws.describe_instances || []
+        running_instances = {}
+        instances.each do |inst|
+          if inst[:aws_state] != "terminated" && (inst[:aws_groups].to_s =~ /#{filter}/)
+            running_instances[inst[:aws_instance_id]] = inst
+          end
+        end
+        running_instances
+      end
+      
+      def get(inst_id)
+        instance = {}
+        list.each_pair do |id, hash|
+          next unless inst_id == id
+          instance = hash
+        end
+        instance
+      end
+      
+      def running?(inst_id)
+        inst = get(inst_id)
+        (inst && inst[:aws_state] == "running")
+      end
+      
+      def pending?(inst_id)
+        inst = get(inst_id)
+        (inst && inst[:aws_state] == "pending")
+      end
+    end
+    
+    class Groups
+      include Rudy::AWS::ObjectBase
+    
+      
+      # +list+ is a list of security groups to look for. If it's empty, all groups
+      # associated to the account will be returned.
+      # right_aws returns an array of hashes
+      # :aws_group_name  => "default-1",
+      # :aws_owner       => "000000000888",
+      # :aws_description => "Default allowing SSH, HTTP, and HTTPS ingress",
+      # :aws_perms       => [{:owner => "000000000888", :group => "default"},
+      #        {:owner => "000000000888", :group => "default-1"},
+      #        {:to_port => "-1",  :protocol => "icmp", :from_port => "-1",  :cidr_ips => "0.0.0.0/0"}]
+      #                     ]
+      def list(list=[])
+        glist = @aws.describe_security_groups(list) || []
+
+      end
+      
+      # Create a new EC2 security group
+      # Returns true/false whether successful
+      def create(name, desc='')
+        @aws.create_security_group(name, desc)
+      end
+      
+      # Delete an EC2 security group
+      # Returns true/false whether successful
+      def destroy(name)
+        @aws.delete_security_group(name)
+      end
+      
+      # Modify an EC2 security group
+      # Returns true/false whether successful
+      def modify(name, from_port, to_port, protocol='tcp', ipa='0.0.0.0/0')
+        @aws.authorize_security_group_IP_ingress(name, from_port, to_port, protocol, ipa)
+      end
+      
+      
+      # Does the security group +name+ exist?
+      def exists?(name)
+        begin
+          g = list([name.to_s])
+          
+        rescue RightAws::AwsError => ex
+          # Ignore (it raises an exception when the list contains an unknown group name)
+        ensure
+          g ||= []
+        end
+        
+        !g.empty?
+      end
+      
+    end
+    
+    class Addresses
+      include Rudy::AWS::ObjectBase
+      
+      # Returns and array of hashes:
+      # [{:instance_id=>"i-d630cbbf", :public_ip=>"75.101.1.140"},
+      #  {:instance_id=>nil, :public_ip=>"75.101.1.141"}]
+      def list
+        @aws.describe_addresses || []
+      end
+      
+      
+      # Associate an elastic IP to an instance
+      def associate(instance, address)
+        @aws.associate_address(instance, address)
+      end
+      
+      def valid?(address)
+        list.each do |a|
+          return true if a[:public_ip] == address
+        end
+        false
+      end
+      
+      def associated?(address)
+        list.each do |a|
+          return true if a[:public_ip] == address && a[:instance_id]
+        end
+        false
+      end
+    end
+  end
+  
+end

data/lib/rudy/aws/s3.rb

@@ -0,0 +1,3 @@
+
+module Rudy::AWS
+end

data/lib/rudy/aws/simpledb.rb

@@ -0,0 +1,48 @@
+
+
+
+module Rudy::AWS
+
+  
+  class SimpleDB
+    class Domains 
+      include Rudy::AWS::ObjectBase
+      
+      def create(name)
+        @aws.create_domain(name)
+      end
+      
+      def destroy(name)
+        @aws.delete_domain(name)
+      end
+    
+      def list
+        @aws.list_domains
+      end
+    end
+    
+    def destroy(domain, item, attributes={})
+      @aws.delete_attributes(domain, item, attributes)
+    end
+    
+    def store(domain, item, attributes={}, replace=false)
+      @aws.put_attributes(domain, item, attributes, replace)
+    end
+    
+    def query(domain, query=nil, max=nil)
+      @aws.query(domain, query, max)
+    end
+    
+    def query_with_attributes(domain, query, max=nil)
+      items = {}
+      query(domain, query)[:items].each do |item|
+        items[item] = get_attributes(domain, item)[:attributes]
+      end
+      items
+    end
+    
+    def get_attributes(domain, item, attribute=nil)
+      @aws.get_attributes(domain, item, attribute)
+    end
+  end
+end

data/lib/rudy/command/addresses.rb

@@ -0,0 +1,41 @@
+
+
+
+module Rudy
+  module Command
+    class Addresses < Rudy::Command::Base
+      
+      def associate_address(address)
+        raise "You did not supply an instance ID" unless instance
+        inst = @ec2.instances.get(instance)
+        raise "Instance #{inst[:aws_instance_id]} is not running!" unless inst
+        
+        raise "You have not supplied an IP addresses" unless address
+        raise "That's not an elastic IP you own!" unless @ec2.addresses.valid?(address)
+        raise "#{address} is already associated!" if @ec2.addresses.associated?(address)
+        
+        puts "Associating #{address} to #{inst[:aws_groups]}: #{inst[:dns_name]}"
+        @ec2.addresses.associate(inst[:aws_instance_id], address)
+        puts "Done!"
+        puts
+        
+        print_addresses
+      end
+      
+      def print_addresses
+        puts "Elastic IP mappings:"
+        @ec2.addresses.list.each do |address|
+          print "IP: #{address[:public_ip]} "
+          if address[:instance_id]
+            inst = @ec2.instances.get(address[:instance_id])
+            puts "%s: %s %s" % [inst[:aws_groups], inst[:aws_instance_id], inst[:dns_name]]
+          end
+        end
+        puts
+      end
+      
+      
+    end
+  end
+end
+