deltacloud-core 0.0.1 → 0.0.2

data/Rakefile

@@ -22,8 +22,6 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/gempackagetask'
 
-
-
 desc "Run basic unit tests"
 Rake::TestTask.new("test") { |t|
   t.test_files = FileList[
@@ -37,29 +35,8 @@ Rake::TestTask.new("test") { |t|
   t.warning = false
 }
 
-begin
-  require 'cucumber'
-  require 'cucumber/rake/task'
-
-  Cucumber::Rake::Task.new(:features) do |t|
-    t.cucumber_opts = "features --format html --out tmp/cucumber.html"
-    t.rcov = false
-  end
-
-  Cucumber::Rake::Task.new(:rcov) do |t|
-    t.cucumber_opts = "features --format pretty"
-    t.rcov = true
-    t.rcov_opts << %[-o "tmp/coverage"]
-  end
-rescue LoadError
-  desc 'Cucumber rake task not available'
-  task :features do
-    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem'
-  end
-end
-
-
 load 'deltacloud-core.gemspec'
+
 Rake::GemPackageTask.new(@spec) do |pkg|
   pkg.need_tar = true
 end

data/lib/deltacloud/base_driver/features.rb

@@ -136,6 +136,21 @@ module Deltacloud
       end
     end
 
+    declare_feature :instances, :authentication_key do
+      operation :create do
+        param :keyname, :string,  :optional, nil
+        "EC2 key authentification method"
+      end
+      operation :show do
+      end
+    end
+
+    declare_feature :instances, :authentication_password do
+      operation :create do
+        param :password, :string, :optional
+      end
+    end
+
     declare_feature :instances, :hardware_profiles do
       description "Size instances according to changes to a hardware profile"
       # The parameters are filled in from the hardware profiles

data/lib/deltacloud/base_driver/mock_driver.rb

@@ -0,0 +1,37 @@
+require 'deltacloud/method_serializer'
+
+# Create 'mock' version of original driver client/gem:
+
+module Mock
+  class EC2 < AWS::EC2::Base
+
+    include MethodSerializer::Cache
+
+    def self.cached_methods
+      [
+        :describe_images,
+        :describe_availability_zones,
+        :run_instances,
+        :describe_instances,
+        :reboot_instances,
+        :terminate_instances
+      ]
+    end
+
+    MethodSerializer::Cache::wrap_methods(self, :cache_dir => File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'tests', 'ec2', 'support'))
+  end
+end
+
+
+# Replace original client with mock client
+Deltacloud::Drivers::EC2::EC2Driver.class_eval do
+  alias_method :original_new_client, :new_client
+
+  def new_client(credentials, opts={})
+    Mock::EC2.new(
+      :access_key_id => credentials.user,
+      :secret_access_key => credentials.password
+    )
+  end
+
+end

data/lib/deltacloud/drivers/ec2/ec2_driver.rb

@@ -17,11 +17,16 @@
 
 
 require 'deltacloud/base_driver'
-begin
-  require 'AWS'
-rescue LoadError
-  puts "ERROR: Please install Amazon-EC2 gem first. (gem install amazon-ec2)"
-  exit(1)
+require 'AWS'
+
+class Instance
+  attr_accessor :keyname
+  attr_accessor :authn_error
+
+  def authn_feature_failed?
+    return true unless authn_error.nil?
+  end
+
 end
 
 module Deltacloud
@@ -30,54 +35,62 @@ module Deltacloud
 class EC2Driver < Deltacloud::BaseDriver
 
   feature :instances, :user_data
+  feature :instances, :authentication_key
 
-  define_hardware_profile('m1-small') do
-    cpu              1
-    memory         1.7 * 1024
-    storage        160
-    architecture 'i386'
+  define_hardware_profile('m1.small') do
+    cpu                1
+    memory             1.7 * 1024
+    storage            160
+    architecture       'i386'
   end
 
-  define_hardware_profile('m1-large') do
+  define_hardware_profile('m1.large') do
     cpu                4
-    memory           7.5 * 1024
-    storage          850
-    architecture 'x86_64'
+    memory             7.5 * 1024
+    storage            850
+    architecture       'x86_64'
   end
 
-  define_hardware_profile('m1-xlarge') do
+  define_hardware_profile('m1.xlarge') do
     cpu                8
-    memory            15 * 1024
-    storage         1690
-    architecture 'x86_64'
+    memory             15 * 1024
+    storage            1690
+    architecture       'x86_64'
   end
 
-  define_hardware_profile('c1-medium') do
+  define_hardware_profile('c1.medium') do
     cpu                5
-    memory           1.7 * 1024
-    storage          350
-    architecture 'i386'
+    memory             1.7 * 1024
+    storage            350
+    architecture       'i386'
   end
 
-  define_hardware_profile('c1-xlarge') do
-    cpu              20
-    memory            7 * 1024
-    storage        1690
-    architecture 'x86_64'
+  define_hardware_profile('c1.xlarge') do
+    cpu                20
+    memory             7 * 1024
+    storage            1690
+    architecture       'x86_64'
   end
 
-  define_hardware_profile('m2-xlarge') do
-    cpu               6.5
-    memory           17.1 * 1024
-    storage         420
-    architecture    'x86_64'
+  define_hardware_profile('m2.xlarge') do
+    cpu                6.5
+    memory             17.1 * 1024
+    storage            420
+    architecture       'x86_64'
   end
 
-  define_hardware_profile('m2-2xlarge') do
-    cpu              13
-    memory           34.2 * 1024
-    storage         850
-    architecture    'x86_64'
+  define_hardware_profile('m2.2xlarge') do
+    cpu                13
+    memory             34.2 * 1024
+    storage            850
+    architecture       'x86_64'
+  end
+
+  define_hardware_profile('m2.4xlarge') do
+    cpu                26
+    memory             68.4 * 1024
+    storage            1690
+    architecture       'x86_64'
   end
 
   define_instance_states do
@@ -99,9 +112,14 @@ class EC2Driver < Deltacloud::BaseDriver
   def images(credentials, opts={} )
     ec2 = new_client(credentials)
     img_arr = []
-    config = { :owner_id => "amazon" }
-    config.merge!({ :owner_id => opts[:owner_id] }) if opts and opts[:owner_id]
-    config.merge!({ :image_id => opts[:id] }) if opts and opts[:id]
+    # if we know the image_id, we don't want to limit by owner_id, since this
+    # will exclude public images
+    if (opts and opts[:id])
+      config = { :image_id => opts[:id] }
+    else
+      config = { :owner_id => "amazon" }
+      config.merge!({ :owner_id => opts[:owner_id] }) if opts and opts[:owner_id]
+    end
     safely do
       ec2.describe_images(config).imagesSet.item.each do |image|
         img_arr << convert_image(image)
@@ -156,10 +174,10 @@ class EC2Driver < Deltacloud::BaseDriver
     ec2_instances = ec2.run_instances(
       :image_id => image.id,
       :user_data => opts[:user_data],
-      :key_name => opts[:key_name],
+      :key_name => opts[:keyname],
       :availability_zone => realm_id,
       :monitoring_enabled => true,
-      :instance_type => hwp.name.tr('-', '.'),
+      :instance_type => hwp.name,
       :disable_api_termination => false,
       :instance_initiated_shutdown_behavior => 'terminate'
     )
@@ -235,10 +253,12 @@ class EC2Driver < Deltacloud::BaseDriver
   private
 
   def new_client(credentials)
-    AWS::EC2::Base.new(
+    opts = {
       :access_key_id => credentials.user,
       :secret_access_key => credentials.password
-    )
+    }
+    opts[:server] = ENV['DCLOUD_EC2_URL'] if ENV['DCLOUD_EC2_URL']
+    AWS::EC2::Base.new(opts)
   end
 
   def convert_image(ec2_image)
@@ -265,8 +285,8 @@ class EC2Driver < Deltacloud::BaseDriver
     state_key = state.downcase.underscore.to_sym
     realm_id = ec2_instance['placement']['availabilityZone']
     (realm_id = nil ) if ( realm_id == '' )
-    hwp_name = ec2_instance['instanceType'].gsub( /\./, '-')
-    Instance.new( {
+    hwp_name = ec2_instance['instanceType']
+    instance = Instance.new( {
       :id=>ec2_instance['instanceId'],
       :name => ec2_instance['imageId'],
       :state=>state,
@@ -275,10 +295,12 @@ class EC2Driver < Deltacloud::BaseDriver
       :realm_id=>realm_id,
       :public_addresses=>( ec2_instance['dnsName'] == '' ? [] : [ec2_instance['dnsName']] ),
       :private_addresses=>( ec2_instance['privateDnsName'] == '' ? [] : [ec2_instance['privateDnsName']] ),
-      :flavor_id=>ec2_instance['instanceType'].gsub( /\./, '-'),
       :instance_profile =>InstanceProfile.new(hwp_name),
       :actions=>instance_actions_for( state ),
+      :keyname => ec2_instance['keyName']
     } )
+    instance.authn_error = "Key not set for instance" unless ec2_instance['keyName']
+    return instance
   end
 
   def convert_volume(ec2_volume)
@@ -307,7 +329,7 @@ class EC2Driver < Deltacloud::BaseDriver
     rescue AWS::AuthFailure => e
         raise Deltacloud::AuthException.new
     rescue Exception => e
-        puts "ERROR: #{e.message}"
+        puts "ERROR: #{e.message}\n#{e.backtrace.join("\n")}"
     end
   end
 

data/lib/deltacloud/drivers/gogrid/gogrid_driver.rb

@@ -18,12 +18,24 @@
 require 'deltacloud/base_driver'
 require 'deltacloud/drivers/gogrid/gogrid_client'
 
+class Instance
+  attr_accessor :username
+  attr_accessor :password
+  attr_accessor :authn_error
+
+  def authn_feature_failed?
+    return true unless authn_error.nil?
+  end
+end
+
 module Deltacloud
   module Drivers
     module Gogrid
 
 class GogridDriver < Deltacloud::BaseDriver
 
+  feature :instances, :authentication_password
+
   define_hardware_profile 'server' do
     cpu            2
     memory         [512, 1024, 2048, 4096, 8192]
@@ -76,30 +88,72 @@ class GogridDriver < Deltacloud::BaseDriver
     else
       server_ram = "512MB"
     end
+    client = new_client(credentials)
     name = (opts[:name] && opts[:name]!='') ? opts[:name] : get_random_instance_name
     safely do
-      convert_instance(new_client(credentials).request('grid/server/add', {
+      instance = client.request('grid/server/add', {
         'name' => name,
         'image' => image_id,
         'server.ram' => server_ram,
         'ip' => get_next_free_ip(credentials)
-      })['list'].first, credentials.user)
+      })['list'].first
+      if instance
+        login_data = get_login_data(client, instance[:id])
+        if login_data['username'] and login_data['password']
+          instance['username'] = login_data['username']
+          instance['password'] = login_data['password']
+          inst = convert_instance(instance, credentials.user)
+        else
+          inst = convert_instance(instance, credentials.user)
+          inst.authn_error = "Unable to fetch password"
+        end
+        return inst
+      else
+        return nil
+      end
     end
   end
 
+  def list_instances(credentials, id)
+    instances = []
+    safely do
+      new_client(credentials).request('grid/server/list')['list'].collect do |instance|
+        if id.nil? or instance['name'] == id
+          instances << convert_instance(instance, credentials.user)
+        end
+      end
+    end
+    instances
+  end
+
   def instances(credentials, opts=nil)
     instances = []
     if opts and opts[:id]
-      safely do
-        instance = new_client(credentials).request('grid/server/get', { 'id' => opts[:id]})['list'].first
-        instances = [convert_instance(instance, credentials.user)]
-      end
-    else
-      safely do
-        instances = new_client(credentials).request('grid/server/list')['list'].collect do |instance|
-          convert_instance(instance, credentials.user)
+      begin
+        client = new_client(credentials)
+        instance = client.request('grid/server/get', { 'name' => opts[:id] })['list'].first
+        login_data = get_login_data(client, instance['id'])
+        if login_data['username'] and login_data['password']
+          instance['username'] = login_data['username']
+          instance['password'] = login_data['password']
+          inst = convert_instance(instance, credentials.user)
+        else
+          inst = convert_instance(instance, credentials.user)
+          inst.authn_error = "Unable to fetch password"
+        end
+        instances = [inst]
+      rescue Exception => e
+        if e.message == "400 Bad Request"
+          # in the case of a VM that we just made, the grid/server/get method
+          # throws a "400 Bad Request error".  In this case we try again by
+          # getting a full listing a filtering on the id.  This could
+          # potentially take a long time, but I don't see another way to get
+          # information about a newly created instance
+          instances = list_instances(credentials, opts[:id])
         end
       end
+    else
+      instances = list_instances(credentials, nil)
     end
     instances = filter_on( instances, :state, opts )
     instances
@@ -111,15 +165,21 @@ class GogridDriver < Deltacloud::BaseDriver
     end
   end
 
+  def destroy_instance(credentials, id)
+    safely do
+      new_client(credentials).request('grid/server/delete', { 'id' => id})
+    end
+  end
+
   def stop_instance(credentials, id)
     safely do
       new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'off'})
     end
   end
 
-  def destroy_instance(credentials, id)
+  def start_instance(credentials, id)
     safely do
-      new_client(credentials).request('grid/server/delete', { 'id' => id})
+      new_client(credentials).request('grid/server/power', { 'id' => id, 'power' => 'on'})
     end
   end
 
@@ -128,7 +188,8 @@ class GogridDriver < Deltacloud::BaseDriver
     pending.to( :running )       .automatically
     running.to( :stopped )       .on( :stop )
     stopped.to( :running )       .on( :start )
-    stopped.to( :finish )        .automatically
+    running.to( :finish )       .on( :destroy )
+    stopped.to( :finish )       .on( :destroy )
   end
 
   private
@@ -137,6 +198,22 @@ class GogridDriver < Deltacloud::BaseDriver
     GoGridClient.new('https://api.gogrid.com/api', credentials.user, credentials.password)
   end
 
+  def get_login_data(client, instance_id)
+    login_data = {}
+    begin
+      client.request('support/password/list')['list'].each do |passwd|
+        next unless passwd['server']
+        if passwd['server']['id'] == instance_id
+          login_data['username'], login_data['password'] = passwd['username'], passwd['password']
+          break
+        end
+      end
+    rescue Exception => e
+      login_data[:error] = e.message
+    end
+    return login_data
+  end
+
   def convert_image(gg_image, owner_id=nil)
     Image.new( {
       :id=>gg_image['id'],
@@ -190,6 +267,10 @@ class GogridDriver < Deltacloud::BaseDriver
     prof = InstanceProfile.new("server", opts)
 
     Instance.new(
+       # note that we use 'name' as the id here, because newly created instances
+       # don't get a real ID until later on.  The name is good enough; from
+       # what I can tell, 'name' per user is unique, so it should be sufficient
+       # to uniquely identify this instance.
       :id => instance['name'],
       :owner_id => owner_id,
       :image_id => instance['image']['id'],
@@ -200,7 +281,9 @@ class GogridDriver < Deltacloud::BaseDriver
       :state => convert_server_state(instance['state']['name'], instance['id']),
       :actions => instance_actions_for(convert_server_state(instance['state']['name'], instance['id'])),
       :public_addresses => [ instance['ip']['ip'] ],
-      :private_addresses => []
+      :private_addresses => [],
+      :username => instance['username'],
+      :password => instance['password']
     )
   end