bbrowning-deltacloud-core 0.0.1.1

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

@@ -0,0 +1,340 @@
+#
+# Copyright (C) 2009  Red Hat, Inc.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+require 'deltacloud/base_driver'
+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
+  module Drivers
+    module EC2
+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'
+  end
+
+  define_hardware_profile('m1.large') do
+    cpu                4
+    memory             7.5 * 1024
+    storage            850
+    architecture       'x86_64'
+  end
+
+  define_hardware_profile('m1.xlarge') do
+    cpu                8
+    memory             15 * 1024
+    storage            1690
+    architecture       'x86_64'
+  end
+
+  define_hardware_profile('c1.medium') do
+    cpu                5
+    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'
+  end
+
+  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'
+  end
+
+  define_hardware_profile('m2.4xlarge') do
+    cpu                26
+    memory             68.4 * 1024
+    storage            1690
+    architecture       'x86_64'
+  end
+
+  define_instance_states do
+    start.to( :pending )          .automatically
+    pending.to( :running )        .automatically
+    pending.to( :stopping )       .on( :stop )
+    pending.to( :stopped )        .automatically
+    stopped.to( :running )        .on( :start )
+    running.to( :running )        .on( :reboot )
+    running.to( :stopping )       .on( :stop )
+    shutting_down.to( :stopped )  .automatically
+    stopped.to( :finish )         .automatically
+  end
+
+  #
+  # Images
+  #
+
+  def images(credentials, opts={} )
+    ec2 = new_client(credentials)
+    img_arr = []
+    # 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)
+      end
+    end
+    img_arr = filter_on( img_arr, :architecture, opts )
+    img_arr.sort_by{|e| [e.owner_id, e.name]}
+  end
+
+  #
+  # Realms
+  #
+
+  def realms(credentials, opts=nil)
+    ec2 = new_client(credentials)
+    realms = []
+    safely do
+      ec2.describe_availability_zones.availabilityZoneInfo.item.each do |ec2_realm|
+        realms << convert_realm( ec2_realm )
+      end
+    end
+    realms
+  end
+
+  #
+  # Instances
+  #
+  def instances(credentials, opts=nil)
+    ec2 = new_client(credentials)
+    instances = []
+    safely do
+      param = opts.nil? ? nil : opts[:id]
+      ec2_instances = ec2.describe_instances.reservationSet
+      return [] unless ec2_instances
+      ec2_instances.item.each do |item|
+        item.instancesSet.item.each do |ec2_instance|
+          instances << convert_instance( ec2_instance, item.ownerId )
+        end
+      end
+    end
+    instances = filter_on( instances, :id, opts )
+    instances = filter_on( instances, :state, opts )
+    instances
+  end
+
+
+  def create_instance(credentials, image_id, opts)
+    ec2 = new_client( credentials )
+    realm_id = opts[:realm_id]
+    image = image(credentials, :id => image_id )
+    hwp = find_hardware_profile(credentials, opts[:hwp_id], image.id)
+    ec2_instances = ec2.run_instances(
+      :image_id => image.id,
+      :user_data => opts[:user_data],
+      :key_name => opts[:keyname],
+      :availability_zone => realm_id,
+      :monitoring_enabled => true,
+      :instance_type => hwp.name,
+      :disable_api_termination => false,
+      :instance_initiated_shutdown_behavior => 'terminate'
+    )
+    convert_instance( ec2_instances.instancesSet.item.first, 'pending' )
+  end
+
+  def reboot_instance(credentials, id)
+    ec2 = new_client(credentials)
+    safely do
+      ec2.reboot_instances( :instance_id => id )
+    end
+  end
+
+  def stop_instance(credentials, id)
+    ec2 = new_client(credentials)
+    safely do
+      ec2.terminate_instances( :instance_id => id )
+    end
+  end
+
+  def destroy_instance(credentials, id)
+    ec2 = new_client(credentials)
+    safely do
+      ec2.terminate_instances( :instance_id => id )
+    end
+  end
+
+  #
+  # Storage Volumes
+  #
+  def storage_volumes(credentials, opts=nil)
+    ec2 = new_client( credentials )
+    volumes = []
+    safely do
+      if (opts)
+        ec2.describe_volumes(:volume_id => opts[:id]).volumeSet.item.each do |ec2_volume|
+          volumes << convert_volume( ec2_volume )
+        end
+      else
+        ec2_volumes = ec2.describe_volumes.volumeSet
+        return [] unless ec2_volumes
+        ec2_volumes.item.each do |ec2_volume|
+          volumes << convert_volume( ec2_volume )
+        end
+      end
+    end
+    volumes
+  end
+
+  #
+  # Storage Snapshots
+  #
+
+  def storage_snapshots(credentials, opts=nil)
+    ec2 = new_client( credentials )
+    snapshots = []
+    safely do
+      if (opts)
+        ec2.describe_snapshots(:owner => 'self', :snapshot_id => opts[:id]).snapshotSet.item.each do |ec2_snapshot|
+          snapshots << convert_snapshot( ec2_snapshot )
+        end
+      else
+        ec2_snapshots = ec2.describe_snapshots(:owner => 'self').snapshotSet
+        return [] unless ec2_snapshots
+        ec2_snapshots.item.each do |ec2_snapshot|
+          snapshots << convert_snapshot( ec2_snapshot )
+        end
+      end
+    end
+    snapshots
+  end
+
+  private
+
+  def new_client(credentials)
+    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)
+    Image.new( {
+      :id=>ec2_image['imageId'],
+      :name=>ec2_image['name'] || ec2_image['imageId'],
+      :description=>ec2_image['description'] || ec2_image['imageLocation'] || '',
+      :owner_id=>ec2_image['imageOwnerId'],
+      :architecture=>ec2_image['architecture'],
+    } )
+  end
+
+  def convert_realm(ec2_realm)
+    Realm.new( {
+      :id=>ec2_realm['zoneName'],
+      :name=>ec2_realm['regionName'],
+      :limit=>ec2_realm['zoneState'].eql?('available') ? :unlimited : 0,
+      :state=>ec2_realm['zoneState'].upcase,
+    } )
+  end
+
+  def convert_instance(ec2_instance, owner_id)
+    state = ec2_instance['instanceState']['name'].upcase
+    state_key = state.downcase.underscore.to_sym
+    realm_id = ec2_instance['placement']['availabilityZone']
+    (realm_id = nil ) if ( realm_id == '' )
+    hwp_name = ec2_instance['instanceType']
+    instance = Instance.new( {
+      :id=>ec2_instance['instanceId'],
+      :name => ec2_instance['imageId'],
+      :state=>state,
+      :image_id=>ec2_instance['imageId'],
+      :owner_id=>owner_id,
+      :realm_id=>realm_id,
+      :public_addresses=>( ec2_instance['dnsName'] == '' ? [] : [ec2_instance['dnsName']] ),
+      :private_addresses=>( ec2_instance['privateDnsName'] == '' ? [] : [ec2_instance['privateDnsName']] ),
+      :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)
+    StorageVolume.new( {
+      :id=>ec2_volume['volumeId'],
+      :created=>ec2_volume['createTime'],
+      :state=>ec2_volume['status'].upcase,
+      :capacity=>ec2_volume['size'],
+      :instance_id=>ec2_volume['snapshotId'],
+      :device=>ec2_volume['attachmentSet'],
+    } )
+  end
+
+  def convert_snapshot(ec2_snapshot)
+    StorageSnapshot.new( {
+      :id=>ec2_snapshot['snapshotId'],
+      :state=>ec2_snapshot['status'].upcase,
+      :storage_volume_id=>ec2_snapshot['volumeId'],
+      :created=>ec2_snapshot['startTime'],
+    } )
+  end
+
+  def safely(&block)
+    begin
+      block.call
+    rescue AWS::AuthFailure => e
+        raise Deltacloud::AuthException.new
+    rescue Exception => e
+        puts "ERROR: #{e.message}\n#{e.backtrace.join("\n")}"
+    end
+  end
+
+end
+
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+module RightAws
+  class MockEc2
+    
+    def initialize(opts={})
+    end
+
+    def describe_images(id)
+      load_fixtures_for(:images).select { |i| i[:aws_id].eql?(id) }
+    end
+
+    def describe_images_by_owner(id)
+      load_fixtures_for(:images).select { |i| i[:aws_owner].eql?(id) }
+    end
+
+    def describe_images(opts={})
+      load_fixtures_for(:images)
+    end
+
+    def describe_availability_zones(opts={})
+      load_fixtures_for(:realms)
+    end
+
+    def describe_instances(opts={})
+      instances = load_fixtures_for(:instances)
+      instances.each_with_index do |instance, i|
+        instances[i] = update_delayed_state(instance)
+        return [instance] if opts and opts[:id] and instance[:aws_instance_id].eql?(opts[:id])
+      end
+      update_fixtures_for(:instances, instances)
+      instances
+    end
+
+    def run_instances(image_id, min_count, max_count, group_ids, key_name, user_data='', addressing_type = nil, instance_type = nil, kernel_id = nil, ramdisk_id = nil, availability_zone = nil, block_device_mappings = nil)
+
+      instances = load_fixtures_for(:instances)
+      image = load_fixtures_for(:images).select { |img| img[:aws_id].eql?(image_id) }.first
+
+      if availability_zone
+        realm = load_fixtures_for(:realms).select { |realm| realm[:zone_name].eql?(availability_zone) }.first
+      else
+        realm = load_fixtures_for(:realms).first
+      end
+
+      raise Exception unless image
+      raise Exception unless realm
+
+      instance = { }
+      instance[:aws_image_id] = image[:aws_id]
+      instance[:aws_availability_zone] = realm[:zone_name]
+      instance[:aws_instance_type] = instance_type
+      instance[:aws_owner] = user_data
+      instance[:aws_state] = 'pending'
+      instance[:aws_reason] = ''
+      instance[:dns_name] = "#{random_dns}-01-C9.usma2.compute.amazonaws.com"
+      instance[:private_dns_name] = "#{random_dns}-02-P9.usma2.compute.amazonaws.com"
+      instance[:aws_state_code] = "0"
+      instance[:aws_key_name] = "staging"
+      instance[:aws_kernel_id] = "aki-be3adfd7"
+      instance[:aws_ramdisk_id] = "ari-ce34gad7"
+      instance[:aws_groups] = ["default"]
+      instance[:aws_instance_id] = random_instance_id
+      instance[:aws_reservation_id] = "r-aabbccdd"
+      instance[:aws_launch_time] = instance_time_format
+
+      instances << instance
+
+      update_fixtures_for(:instances, instances)
+
+      return [instance]
+    end
+
+
+    def terminate_instances(id)
+      update_instance_state(id, 'stopping', '80')
+    end
+
+    def reboot_instances(id)
+      update_instance_state(id, 'pending', '0')
+    end
+
+    alias :destroy_instance :terminate_instances
+
+    def describe_snapshots(opts={})
+      load_fixtures_for(:storage_snapshot)
+    end
+
+    def describe_volumes(opts={})
+      load_fixtures_for(:storage_volume)
+    end
+
+    private
+
+    def driver_dir
+      File::expand_path(File::join(File::dirname(__FILE__), '../../../../features/support/ec2'))
+    end
+
+    def fixtures_path
+      File::expand_path(File::join(driver_dir, 'fixtures'))
+    end
+
+    def load_fixtures_for(collection)
+      YAML.load_file(File::join(fixtures_path, "#{collection}.yaml"))
+    end
+
+    def update_fixtures_for(collection, new_data)
+      File.open(File::join(fixtures_path, "#{collection}.yaml"), 'w' ) do |out|
+        YAML.dump(new_data, out)
+      end
+      return new_data
+    end
+
+    def instance_time_format
+      DateTime.now.to_s.gsub(/\+(.+)$/, '.000Z')
+    end
+
+    def random_instance_id
+      id_1 = ("%.4s" % Time.now.to_i.to_s.reverse).reverse
+      id_2 = ("%.3s" % Time.now.to_i.to_s.reverse)
+      "i-#{id_1}f#{id_2}"
+    end
+
+    def random_dns
+      "domU-#{rand(90)+10}-#{rand(90)+10}-#{rand(90)+10}-#{rand(90)+10}"
+    end
+
+    def update_delayed_state(instance)
+      time = DateTime.now - DateTime.parse(instance[:aws_launch_time])
+      hours, minutes, seconds, frac = Date.day_fraction_to_time(time)
+
+      if (minutes>(rand(2)+1) or hours>0) and instance[:aws_state].eql?('pending')
+        instance[:aws_state], instance[:aws_state_code] = 'running', '16'
+      end
+
+      if (minutes>(rand(1)+1) or hours>0) and instance[:aws_state].eql?('stopping')
+        instance[:aws_state], instance[:aws_state_code] = 'stopped', '80'
+      end
+
+      return instance
+    end
+
+    def update_instance_state(id, state, state_code)
+      instance = describe_instances(:id => id).first
+      if instance
+        instance[:aws_state], instance[:aws_state_code] = state, state_code
+        instance[:aws_launch_time] = instance_time_format
+        instances = load_fixtures_for(:instances)
+        instances.each_with_index do |inst, i|
+          instances[i] = instance if inst[:aws_instance_id].eql?(id)       
+        end
+        update_fixtures_for(:instances, instances)
+        return instance
+      else
+        raise Exception
+      end
+    end
+
+  end
+end
+
+Deltacloud::Drivers::EC2::EC2Driver.class_eval do
+  alias_method :original_new_client, :new_client
+
+  def new_client(credentials, opts={})
+    if credentials.user != 'mockuser' and credentials.password != 'mockpassword'
+      raise Deltacloud::AuthException.new
+    end
+    RightAws::MockEc2.new
+  end
+
+end