cloud-maker 0.2.1 → 0.3.0

data/bin/cloud-maker

@@ -43,7 +43,7 @@ class CloudMakerCLI < Thor
     puts
 
     if yes?("Are you sure you wish to terminate this instance?".red + " (y/n)")
-      cloud_maker = CloudMaker::Ec2.new(
+      cloud_maker = CloudMaker::EC2.new(
         :aws_access_key_id => options.aws_access_key_id,
         :aws_secret_access_key => options.aws_secret_access_key
       )
@@ -64,7 +64,7 @@ class CloudMakerCLI < Thor
     :default => ENV['AWS_SECRET_ACCESS_KEY'],
     :required => true
   def info(aws_instance_id)
-    cloud_maker = CloudMaker::Ec2.new(
+    cloud_maker = CloudMaker::EC2.new(
       :aws_access_key_id => options.aws_access_key_id,
       :aws_secret_access_key => options.aws_secret_access_key
     )
@@ -111,16 +111,17 @@ class CloudMakerCLI < Thor
     print_config_hash(config.to_hash)
 
     if options.yes || yes?("Launch a new EC2 instance with the options above? (y/n)")
-      cloud_maker = CloudMaker::Ec2.new(
+      cloud_maker = CloudMaker::EC2.new(
         :aws_access_key_id => options.aws_access_key_id,
-        :aws_secret_access_key => options.aws_secret_access_key
+        :aws_secret_access_key => options.aws_secret_access_key,
+        :region => config['region']
       )
 
       instance = cloud_maker.launch(config)
       puts
-      say "Successfully launched new EC2 instance: ".green + instance[:aws_instance_id].magenta
+      say "Successfully launched new EC2 instance: ".green + instance.id.magenta
       puts
-      print_colored_hash(instance)
+      print_colored_hash(CloudMaker::EC2.instance_to_hash(instance))
     else
       say "Launch aborted!".red
     end

data/lib/cloud-maker.rb

@@ -2,7 +2,7 @@ require 'yaml'
 require 'thor'
 require 'colorize'
 require 'deep_merge'
-require 'right_aws'
+require 'aws-sdk'
 
 require 'cloud_maker/config'
 require 'cloud_maker/ec2'

data/lib/cloud_maker/config.rb

@@ -70,7 +70,7 @@ module CloudMaker
     # extra_options   - Options that describe the config as opposed to being part
     #                   of the config.
     #   'config_path' - The path the config was loaded from. Used for archival purposes.
-    #   'import_ec2'  - CloudMaker::Ec2 defines properties it relies on, if this value
+    #   'import_ec2'  - CloudMaker::EC2 defines properties it relies on, if this value
     #                   is true then we pull those property definitions in.
     #
     # Returns a CloudMaker object
@@ -83,7 +83,7 @@ module CloudMaker
       self.imports = extract_imports!(cloud_config)
       self.cloud_config = cloud_config
 
-      self.import(self.class.new(Ec2::CLOUD_MAKER_CONFIG)) if (extra_options['import_ec2'])
+      self.import(self.class.new(EC2::CLOUD_MAKER_CONFIG)) if (extra_options['import_ec2'])
       self.imports.reverse.each do |import_path|
         self.import(self.class.from_yaml(import_path))
       end

data/lib/cloud_maker/ec2.rb

@@ -1,15 +1,15 @@
 require 'right_aws'
 
 module CloudMaker
-  class Ec2
+  class EC2
     # Public: Gets/Sets the AWS access key.
     attr_accessor :aws_secret_access_key
     # Public: Gets/Sets the AWS secret.
     attr_accessor :aws_access_key_id
-    # Internal: Gets/Sets the RightAws::Ec2 instance.
+    # Internal: Gets/Sets the AWS::EC2 instance.
     attr_accessor :ec2
 
-    # Public: A CloudMaker::Config hash that describes the config properties Ec2 relies on.
+    # Public: A CloudMaker::Config hash that describes the config properties EC2 relies on.
     CLOUD_MAKER_CONFIG = {
       'cloud-maker' => {
         'ami' => {
@@ -42,7 +42,7 @@ module CloudMaker
     # Public: The name of the tag that will be used to find the name of an s3 bucket for archiving/information retrieval
     BUCKET_TAG = 's3_archive_bucket'
 
-    # Public: Creates a new Ec2 instance
+    # Public: Creates a new EC2 instance
     #
     # cloud_maker_config - A CloudMaker::Config object describing the instance
     #                      to be managed.
@@ -50,7 +50,7 @@ module CloudMaker
     #                      :aws_access_key_id     - (required) The AWS access key
     #                      :aws_secret_access_key - (required) The AWS secret
     #
-    # Returns a new CloudMaker::Ec2 instance
+    # Returns a new CloudMaker::EC2 instance
     # Raises RuntimeError if any of the required options are not specified
     def initialize(options)
       required_keys = [:aws_access_key_id, :aws_secret_access_key]
@@ -61,80 +61,123 @@ module CloudMaker
       self.aws_access_key_id = options[:aws_access_key_id]
       self.aws_secret_access_key = options[:aws_secret_access_key]
 
-      self.ec2 = RightAws::Ec2.new(self.aws_access_key_id, self.aws_secret_access_key)
+      self.ec2 = AWS::EC2.new(:access_key_id => self.aws_access_key_id, :secret_access_key => self.aws_secret_access_key)
     end
 
     # Public: Fetch archived information about an instance
     #
     # Returns a hash of information about the instance as it was launched
     def info(instance_id)
-      bucket = self.ec2.describe_tags(:filters => {'resource-id' => instance_id, 'key' => BUCKET_TAG}).first[:value]
+      instance = find_instance(instance_id)
+      bucket = instance.tags[BUCKET_TAG]
+
       archiver = S3Archiver.new(
         :instance_id => instance_id,
         :aws_access_key_id => self.aws_access_key_id,
         :aws_secret_access_key => self.aws_secret_access_key,
         :bucket_name => bucket
       )
+
       archiver.load_archive
     end
 
     # Public: Terminates the specified EC2 instance.
     #
-    # Returns a RightAws supplied Hash describing the terminated instance.
+    # Returns nothing.
     def terminate(instance_id)
-      self.ec2.terminate_instances([instance_id])
+      find_instance(instance_id).terminate
     end
 
     # Public: Launches a new EC2 instance, associates any specified elastic IPS
     # with it, adds any specified tags, and archives the launch details to S3.
     #
-    # Returns a RightAws supplied Hash describing the launched instance.
+    # Returns an AWS::EC2 object for the launched instance.
     def launch(cloud_maker_config)
       user_data = cloud_maker_config.to_user_data
 
-      instance = ec2.launch_instances(cloud_maker_config['ami'],
-        :group_names => cloud_maker_config['security_group'],
+      if !cloud_maker_config['availability_zone'].nil? && !cloud_maker_config['availability_zone'].empty?
+        region = find_region(cloud_maker_config['availability_zone'])
+      else
+        region = ec2 # .instances.create will just put things in the default region
+      end
+
+      instance = region.instances.create(
+        :image_id => cloud_maker_config['ami'],
+        :security_groups => cloud_maker_config['security_group'],
         :instance_type => cloud_maker_config['instance_type'],
         :key_name => cloud_maker_config['key_pair'],
         :availability_zone => cloud_maker_config['availability_zone'],
         :user_data => user_data
-      ).first
-
-      instance_id = instance[:aws_instance_id]
-
-      ec2.create_tags(instance_id, cloud_maker_config["tags"]) if cloud_maker_config["tags"]
-
-      if (cloud_maker_config["elastic_ip"])
-        #we can't associate IPs while the state is pending
-        while instance[:aws_state] == 'pending'
-          #this is going to hammer EC2 a bit, it might be necessary to add some delay in here
-          instance = ec2.describe_instances([instance_id]).first
-        end
-
-        ec2.associate_address(instance_id, :public_ip => cloud_maker_config["elastic_ip"])
-      end
+      )
 
-      begin
-        instance = ec2.describe_instances([instance_id]).first # So we get updated tag/ip info
-      rescue RightAws::AwsError => e
-        tries ||= 0
-        tries += 1
-        if tries <= 5
-          sleep 2**tries
-        else
-          raise e
-        end
-      end
+      instance.tags.set(cloud_maker_config["tags"]) if cloud_maker_config["tags"]
+      instance.associate_elastic_ip(cloud_maker_config["elastic_ip"]) if cloud_maker_config["elastic_ip"]
 
       archiver = S3Archiver.new(
-        :instance_id => instance_id,
+        :instance_id => instance.id,
         :aws_access_key_id => self.aws_access_key_id,
         :aws_secret_access_key => self.aws_secret_access_key,
         :bucket_name => cloud_maker_config["tags"][BUCKET_TAG]
       )
-      archiver.store_archive(cloud_maker_config, instance)
+      archiver.store_archive(cloud_maker_config, self.class.instance_to_hash(instance))
 
       instance
     end
+
+    # Internal: Find the instance object for an instance ID regardless of what
+    # region the instance is in. It looks in the default region (us-east-1) first
+    # and then looks in all regions if it's not there.
+    #
+    # Returns nil or an AWS::EC2::Instance
+    def find_instance(instance_id)
+      # Check the default region first
+      return ec2.instances[instance_id] if ec2.instances[instance_id].exists?
+
+      # If we don't find it there look in every region
+      instance = nil
+      ec2.regions.each do |region|
+        if region.instances[instance_id].exists?
+          instance = region.instances[instance_id]
+          break
+        end
+      end
+
+      instance
+    end
+
+
+    # Internal: Find the region object for a given availability zone. Currently works
+    # based on amazon naming conventions and will break if they change.
+    #
+    # Returns an AWS::EC2::Region
+    # Raises a RuntimeError if the region doesn't exist
+    def find_region(availability_zone)
+      region_name = availability_zone.gsub(/(\d)\w$/, '\1')
+      if ec2.regions[region_name].exists?
+        ec2.regions[region_name]
+      else
+        raise RuntimeError.new("The region #{region_name} doesn't exist - region name generated from availability_zone: #{availability_zone}.")
+      end
+    end
+
+    class << self
+      # Public: Generates a hash of properties from an AWS::EC2 instance
+      #
+      # Returns a hash of properties for the instance.
+      def instance_to_hash(instance)
+        {
+          :instance_id => instance.id,
+          :ami => instance.image_id,
+          :api_termination_disabled => instance.api_termination_disabled?,
+          :dns_name => instance.dns_name,
+          :ip_address => instance.ip_address,
+          :private_ip_address => instance.private_ip_address,
+          :key_name => instance.key_name,
+          :owner_id => instance.owner_id,
+          :status => instance.status
+        }
+      end
+    end
+
   end
 end

data/lib/cloud_maker/s3_archiver.rb

@@ -7,7 +7,7 @@ module CloudMaker
     attr_accessor :aws_access_key_id
     # Public: Gets/Sets the EC2 instance ID string.
     attr_accessor :instance_id
-    # Internal: Gets/Sets the RightAws::S3::Bucket used for storing/loading archives.
+    # Internal: Gets/Sets the bucket object used for storing/loading archives.
     attr_accessor :bucket
 
     # Public: All archive keys will be prefixed with KEY_PREFIX/
@@ -37,22 +37,26 @@ module CloudMaker
       self.aws_access_key_id = options[:aws_access_key_id]
       self.aws_secret_access_key = options[:aws_secret_access_key]
 
-      s3 = RightAws::S3.new(self.aws_access_key_id, self.aws_secret_access_key)
-      self.bucket = s3.bucket(options[:bucket_name])
+      self.bucket = AWS::S3.new(
+        :access_key_id => self.aws_access_key_id,
+        :secret_access_key => self.aws_secret_access_key
+      ).buckets[options[:bucket_name]]
+
+      raise RuntimeError.new("The S3 bucket #{options[:bucket_name]} does not exist.") unless self.bucket.exists?
     end
 
     # Public: Generates an archive with all information relevant to an instance
     # launch and stores it to S3.
     #
     # cloud_maker_config - The CloudMaker::Config the instance was launched with
-    # instance           - A Hash describing the properties of the launched instance
+    # properties         - A Hash describing the properties of the launched instance
     #
     # Returns nothing.
-    def store_archive(cloud_maker_config, instance)
+    def store_archive(cloud_maker_config, properties)
       userdata = cloud_maker_config.to_user_data
-      self.bucket.put(self.user_data_key, userdata)
-      self.bucket.put(self.instance_yaml_key, instance.to_yaml)
-      self.bucket.put(self.cloud_config_yaml_key, cloud_maker_config.to_hash.to_yaml)
+      self.bucket.objects.create(self.user_data_key, :data => userdata)
+      self.bucket.objects.create(self.instance_yaml_key, :data => properties.to_yaml)
+      self.bucket.objects.create(self.cloud_config_yaml_key, :data => cloud_maker_config.to_hash.to_yaml)
       true
     end
 
@@ -61,9 +65,9 @@ module CloudMaker
     # Returns the content of the archive.
     def load_archive
       {
-        :user_data => self.bucket.get(self.user_data_key),
-        :cloud_config => YAML::load(self.bucket.get(self.cloud_config_yaml_key)),
-        :instance => YAML::load(self.bucket.get(self.instance_yaml_key))
+        :user_data => self.bucket.objects[self.user_data_key].read,
+        :cloud_config => YAML::load(self.bucket.objects[self.cloud_config_yaml_key].read),
+        :instance => YAML::load(self.bucket.objects[self.instance_yaml_key].read)
       }
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cloud-maker
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-09 00:00:00.000000000 Z
+date: 2012-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -45,13 +45,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.15'
 - !ruby/object:Gem::Dependency
-  name: right_aws
+  name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -59,7 +59,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: deep_merge
   requirement: !ruby/object:Gem::Requirement