kiel 0.2 → 0.4

data/lib/kiel.rb

@@ -12,6 +12,8 @@ require 'kiel/cloud/aws'
 # If one step fails, all subsequent installation steps might fail too. But when one step succeeds, that step can be
 # used as base for all subsequence steps. 
 #
+# Currently there are two different ways to access the AWS API: RightAWS and the aws-sdk gem.
+#
 # License::   Distributes under the MIT license
 
 module Kiel

data/lib/kiel/cloud/aws.rb

@@ -1,13 +1,15 @@
 require 'digest/sha1'
+require 'kiel/cloud/aws_base'
 
 module Kiel
     module Cloud
-        INSTANCE_STARTUP_TIMEOUT    = 120
-        RECOGNIZED_OPTIONS = [ :region, :credentials, :instance, :start_options ]
-        
         # Implements the connection to the Amazon Web Services (AWS). The current implementation works for one 
         # configured region. The default server is a small EC2 instance.
         class AWS
+            include AWSBase
+            
+            RECOGNIZED_OPTIONS = [ :region, :credentials, :instance, :start_options ]
+        
             # The contructor takes the following configuration options:
             #
             # :region:: A string naming the region to be used. If no region is given, the default region is used.
@@ -41,6 +43,7 @@ module Kiel
                 end
             end
 
+            # Finds all images where the given tags apply
             def all_images_by_tags tags
                 images = @ec2.images.with_owner('self').tagged( tags.first.first )
     
@@ -52,13 +55,6 @@ module Kiel
                 images
             end    
 
-            def image_by_tags tags
-                images = all_images_by_tags tags
-                
-                raise "#{images.size} are tagged with the given tags: #{tags.inspect}" if images.size > 1 
-                images.size == 1 ? images.first : nil 
-            end
-            
             def wait_for_ec2 instance
                 puts "waiting for EC2 instance to start."
                 sleep_count = INSTANCE_STARTUP_TIMEOUT
@@ -83,7 +79,7 @@ module Kiel
                 puts ''
             end
 
-            private :image_by_tags, :wait_for_ec2, :wait_for_image
+            private :wait_for_ec2, :wait_for_image
             
             # starts a server instance in the cloud, returning a handle to that instance.
             # the image is either named by an image id +:id => 'image_id'+ or by a set of tags that match for
@@ -118,7 +114,7 @@ module Kiel
                 
                     puts "waiting 2 minutes before starting to take the image..."
                     sleep 120
-                    puts "creating images..."
+                    puts "creating image..."
     
                     image = @ec2.images.create( 
                         :instance_id => instance.id,
@@ -144,19 +140,14 @@ module Kiel
                 end                    
             end
 
-            # returns true, if an image with the given tags exists
-            def exists? tags
-                raise ArgumentError, "AWS.exists? with empty tags" if tags.empty?
-                
-                image_by_tags tags 
-            end
-            
+            # the public dns name of the given instance
             def dns_name instance
                 instance.dns_name
             end
             
-            # deletes the given image
-            def delete_image image_name
+            # deletes the given images by tags. For now this function is used just for cleanup during tests.
+            def delete_image tags
+                all_images_by_tags( tags ).each { | image | image.deregister } 
             end
         end
     end

data/lib/kiel/cloud/aws_base.rb

@@ -0,0 +1,23 @@
+module Kiel
+    module Cloud
+        module AWSBase
+            INSTANCE_STARTUP_TIMEOUT    = 120
+
+            def image_by_tags tags
+                images = all_images_by_tags tags
+
+                raise "#{images.size} are tagged with the given tags: #{tags.inspect}" if images.size > 1 
+                images.size == 1 ? images.first : nil 
+            end
+    
+            private :image_by_tags
+
+            # returns true, if an image with the given tags exists
+            def exists? tags
+                raise ArgumentError, "AWS.exists? with empty tags" if tags.empty?
+                
+                image_by_tags tags 
+            end
+        end
+    end
+end

data/lib/kiel/cloud/right_aws.rb

@@ -0,0 +1,158 @@
+require 'kiel/cloud/aws_base'
+
+module Kiel
+     module Cloud
+        # Implements the connection to the Amazon Web Services (AWS) using the Right-AWS gem.
+        class RightAWS
+            include AWSBase
+            
+            RECOGNIZED_OPTIONS = [ :region, :credentials, :instance, :start_options ]
+
+            # The contructor takes the following configuration options:
+            #
+            # :region:: A string naming the region to be used. If no region is given, North America is used by default.
+            #
+            # :credentials:: A hash containing the fields 'access_key_id' and 'secret_access_key' with the credential
+            #                information to your amazon account.
+            #
+            # :instance:: An instance of the AWS::EC2. If that instance is given, no +credentials:+ should be given.
+            #             Kiel::Cloud::AWS will instead use this instance.     
+            #
+            # :start_options:: Possible options are :key_name and :security_groups to set the
+            #                  name of the used ssh key and a security group, where ssh is enabled.
+            def initialize options = {}
+                require 'right_aws'
+
+                options.each_key do | key |
+                    raise ArgumentError, "unrecognized option \'#{key}\'" unless RECOGNIZED_OPTIONS.include? key
+                end
+                                    
+                @ec2 = options[ :instance ]
+                @start_options = options[ :start_options ] || {}
+                
+                if @ec2 
+                    puts "\'credentials\' ignored as an instance was given too" if options.key? :credentials
+                else
+                    raise ArgumentError, 'no credentials given' unless options.key? :credentials
+                    credentials = options[ :credentials ]
+                    
+                    raise ArgumentError, 'no :access_key_id given within credentials' unless credentials.key? :access_key_id
+                    raise ArgumentError, 'no :secret_access_key given within credentials' unless credentials.key? :secret_access_key         
+
+                    params = options.key?( :region ) ? { region: options[ :region ] } : {} 
+                    @ec2 = RightAws::Ec2.new credentials[ :access_key_id ], credentials[ :secret_access_key ], params
+                end
+            end
+                    
+            # Finds all images where the given tags apply
+            def all_images_by_tags tags
+                images = @ec2.describe_images_by_owner 'self'
+
+                images = images.select do | image |
+                    image_tags = image[ :tags ]
+                    image_tags.merge( tags ) == image_tags 
+                end
+                
+                images
+            end
+
+            def wait_for_ec2 instance
+                puts "waiting for EC2 instance to start."
+                sleep 10 # added to reduce the likelihood of getting an "The instance ID 'i-xxxxxx' does not exist" message 
+                sleep_count = INSTANCE_STARTUP_TIMEOUT
+                while @ec2.describe_instances( [ instance[ :aws_instance_id ] ] )[ 0 ][ :aws_state ] == 'pending' and sleep_count != 0 do 
+                    sleep 1
+                    sleep_count = sleep_count - 1
+                end
+            end
+
+            def wait_for_image image
+                image_state = 'pending'                              
+                while image_state == 'pending' do
+                    begin 
+                        image_state = @ec2.describe_images_by_owner( 'self' ).detect{ | desc | desc[ :aws_id ] == image }
+                        image_state = image_state[ :aws_state ]
+                    rescue => e
+                        puts "err: #{e.inspect}"
+                    end     
+                       
+                    sleep 1
+                    STDOUT.write '.'
+                end
+                puts ''
+            end
+
+            private :wait_for_ec2, :wait_for_image
+
+            # starts a server instance in the cloud, returning a handle to that instance.
+            # the image is either named by an image id +:id => 'image_id'+ or by a set of tags that match for
+            # just one image +:tags => { 'image_type' => 'application', 'base' => '34' }+
+            def start_instance image_name
+                options = @start_options.merge( if image_name.key?( :id )
+                    { image_id: image_name[ :id ] }
+                else
+                    tags  = image_name[ :tags ]
+                    image = image_by_tags tags
+                    raise RuntimeError, "no image with tags: \'#{tags}\' found to start an instance" unless image
+                    
+                    { image_id: image[ :aws_id ] }
+                end )
+                
+                instance = @ec2.launch_instances( 
+                    options[ :image_id ], image_id: options[ :image_id ], key_name: options[ :key_name ], group_names: options[ :security_groups ] )
+                instance = instance[ 0 ]
+                                
+                begin
+                    wait_for_ec2 instance
+                    puts "ec2 instance \'#{dns_name instance}\' started."
+                rescue 
+                    stop_instance instance
+                    raise
+                end 
+                
+                instance
+            end
+            
+            # store the given +instance+ and add the hash of +tags+ to the image. 
+            def store_image instance, tags
+                begin
+                    puts "waiting 2 minutes before starting to take the image..."
+                    sleep 120
+                    puts "creating image..."
+
+                    image = @ec2.create_image( 
+                        instance[ :aws_instance_id ],
+                        :no_reboot => true,
+                        :description => "automaticaly created #{tags[ 'image_type' ]} image",
+                        :name => "#{tags[ 'image_type' ]} #{Digest::SHA1.hexdigest tags.inspect}" )
+                       
+                    puts "waiting for image to get ready..."
+                    wait_for_image image
+
+                    puts "image was created, adding tags..."
+                    @ec2.create_tags( image, tags )
+                    puts "tags added."
+                ensure
+                    stop_instance instance
+                end
+            end
+
+            # stops the given instance.
+            def stop_instance instance
+                @ec2.terminate_instances( [ instance[ :aws_instance_id ] ] )
+            end
+
+            # the public dns name of the given instance
+            def dns_name instance
+                @ec2.describe_instances( [ instance[ :aws_instance_id ] ] )[ 0 ][ :dns_name ]
+            end
+            
+            # deletes the given images by tags. For now this function is used just for cleanup during tests.
+            def delete_image tags
+                all_images_by_tags( tags ).each do | image | 
+                    @ec2.deregister_image image[ :aws_id ]
+                end     
+            end
+        end
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kiel
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.4'
   prerelease: 
 platform: ruby
 authors:
@@ -9,10 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-10 00:00:00.000000000 Z
+date: 2012-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name:
+  - rake
   - aws-sdk
   - capistrano
   requirement: !ruby/object:Gem::Requirement
@@ -32,15 +33,17 @@ dependencies:
 description: ! "Kiel automates the process of creating rake tasks to produce Amazon
   Machine Images (AMI). The basic idea behind Kiel\nis that an AMI can be best produced
   by installing software step by step on a defined base and by having all that \nsteps
-  under source code control. On the way from a base image to the final AMI, produces
-  a new AMI with every step.\n"
+  under source code control. On the way from a base image to the final AMI, Kiel produces
+  a new AMI with every step\nand thus has some save points to start with.\n"
 email: gemmaster@robitzki.de
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/kiel/cloud/aws.rb
+- lib/kiel/cloud/aws_base.rb
 - lib/kiel/cloud/mock.rb
+- lib/kiel/cloud/right_aws.rb
 - lib/kiel/scm/git.rb
 - lib/kiel/scm/mock.rb
 - lib/kiel/setup/capistrano.rb
@@ -62,7 +65,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2182922364464276395
+      hash: 2193310327288113027
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: