deltacloud-core 0.5.0 → 1.0.0

data/lib/deltacloud/{base_driver → drivers}/base_driver.rb

@@ -14,14 +14,53 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-require 'deltacloud/base_driver/exceptions'
-
 module Deltacloud
 
   class BaseDriver
 
     include ExceptionHandler
 
+    STATE_MACHINE_OPTS = {
+      :all_states => [:start, :pending, :running, :stopping, :stopped, :finish],
+      :all_actions => [:create, :reboot, :stop, :start, :destroy]
+    } unless defined?(STATE_MACHINE_OPTS)
+
+    def self.driver_name
+      name.split('::').last.gsub('Driver', '').downcase
+    end
+
+    def self.features
+      @features ||= {}
+    end
+
+    def self.features_for(entity)
+      features.inject([]) do |result, item|
+        result << item[entity] if item.has_key? entity
+        result
+      end
+    end
+
+    def self.feature(collection, feature_name)
+      return if has_feature?(collection, feature_name)
+      constraints[collection] ||= {}
+      constraints[collection][feature_name] ||= {}
+      constraints[collection][feature_name].merge!(yield) if block_given?
+      features[collection] ||= []
+      features[collection] << feature_name
+    end
+
+    def self.constraints(opts={})
+      if opts[:collection] and opts[:feature]
+        return [] unless @constraints.has_key? opts[:collection]
+        return @constraints[opts[:collection]][opts[:feature]]
+      end
+      @constraints ||= {}
+    end
+
+    def self.has_feature?(collection, feature_name)
+      features.has_key?(collection) and features[collection].include?(feature_name)
+    end
+
     def name
       self.class.name.split('::').last.gsub('Driver', '').downcase
     end
@@ -37,11 +76,12 @@ module Deltacloud
       hw_profile = ::Deltacloud::HardwareProfile.new( name, &block )
       @hardware_profiles << hw_profile
       hw_params = hw_profile.params
-      unless hw_params.empty?
-        feature :instances, :hardware_profiles do
-          decl.operation(:create) { add_params(hw_params) }
-        end
-      end
+      # FIXME: Features
+      #unless hw_params.empty?
+      #  feature :instances, :hardware_profiles do
+      #    decl.operation(:create) { add_params(hw_params) }
+      #  end
+      #end
     end
 
     def self.hardware_profiles
@@ -55,6 +95,7 @@ module Deltacloud
     end
 
     def hardware_profile(credentials, name)
+      name = name[:id] if name.kind_of? Hash
       hardware_profiles(credentials, :id => name).first
     end
 
@@ -90,7 +131,7 @@ module Deltacloud
     end
 
     def self.define_instance_states(&block)
-      machine = ::Deltacloud::StateMachine.new(&block)
+      machine = ::Deltacloud::StateMachine.new(STATE_MACHINE_OPTS, &block)
       @instance_state_machine = machine
     end
 
@@ -114,6 +155,11 @@ module Deltacloud
       actions
     end
 
+    def has_capability?(method)
+      method = (RUBY_VERSION =~ /^1\.9/) ? method : method.to_s
+      (self.class.instance_methods - self.class.superclass.instance_methods).include? method
+    end
+
     ## Capabilities
     # The rabbit dsl supports declaring a capability that is required
     # in the backend driver for the call to succeed. A driver can
@@ -197,16 +243,8 @@ module Deltacloud
       firewalls(credentials, opts).first if has_capability?(:firewalls)
     end
 
-    MEMBER_SHOW_METHODS =
-      [ :realm, :image, :instance, :storage_volume, :bucket, :blob, :key, :firewall ]
-
-    def has_capability?(capability)
-      if MEMBER_SHOW_METHODS.include?(capability.to_sym)
-        has_capability?(capability.to_s.pluralize)
-      else
-        respond_to?(capability)
-      end
-    end
+    MEMBER_SHOW_METHODS = [ :realm, :image, :instance, :storage_volume, :bucket, :blob,
+                            :key, :firewall ] unless defined?(MEMBER_SHOW_METHODS)
 
     def filter_on(collection, attribute, opts)
       return collection if opts.nil?

data/lib/deltacloud/drivers/condor/condor_driver.rb

@@ -14,9 +14,6 @@
 # under the License.
 #
 
-require 'deltacloud/base_driver'
-
-
 class Instance
   def self.convert_condor_state(state_id)
     case state_id
@@ -44,10 +41,6 @@ module Deltacloud
         feature :instances, :user_data
         feature :instances, :authentication_password
 
-        def supported_collections
-          DEFAULT_COLLECTIONS - [ :storage_volumes, :storage_snapshots ]
-        end
-
         CONDOR_MAPPER_DIR = ENV['CONDOR_MAPPER_DIR'] || '/var/tmp'
 
         def hardware_profiles(credentials, opts={})
@@ -175,7 +168,7 @@ module Deltacloud
           pending.to( :running )        .automatically
           pending.to( :finish )         .on(:destroy)
           running.to( :running )        .on( :reboot )
-          running.to( :shutting_down )  .on( :destroy )
+          running.to( :stopping )       .on( :destroy )
           pending.to( :finish )         .automatically
         end
 

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

@@ -14,9 +14,10 @@
 # under the License.
 #
 
-require 'deltacloud/base_driver'
 require 'aws'
 
+require_relative '../../runner'
+
 class Instance
   attr_accessor :keyname
   attr_accessor :authn_error
@@ -29,19 +30,17 @@ end
 
 module Deltacloud
   module Drivers
-    module EC2
-      class EC2Driver < Deltacloud::BaseDriver
-
-        def supported_collections
-
-          DEFAULT_COLLECTIONS + [ :keys, :buckets, :load_balancers, :addresses, :firewalls ]
-        end
+    module Ec2
+      class Ec2Driver < Deltacloud::BaseDriver
 
         feature :instances, :user_data
         feature :instances, :authentication_key
         feature :instances, :firewalls
         feature :instances, :instance_count
+        feature :instances, :metrics
         feature :images, :owner_id
+        feature :images, :image_name
+        feature :images, :image_description
         feature :buckets, :bucket_location
         feature :instances, :attach_snapshot
 
@@ -49,7 +48,7 @@ module Deltacloud
 
         define_hardware_profile('t1.micro') do
           cpu                1
-          memory             0.63 * 1024
+          memory             613
           storage            160
           architecture       ['i386','x86_64']
         end
@@ -58,7 +57,14 @@ module Deltacloud
           cpu                1
           memory             1.7 * 1024
           storage            160
-          architecture       'i386'
+          architecture       ['i386', 'x86_64']
+        end
+
+        define_hardware_profile('m1.medium') do
+          cpu                 2
+          memory              3.75 * 1024
+          storage             410
+          architecture        ['i386', 'x86_64']
         end
 
         define_hardware_profile('m1.large') do
@@ -79,7 +85,7 @@ module Deltacloud
           cpu                5
           memory             1.7 * 1024
           storage            350
-          architecture       'i386'
+          architecture       ['i386', 'x86_64']
         end
 
         define_hardware_profile('c1.xlarge') do
@@ -118,7 +124,8 @@ module Deltacloud
           stopped.to( :running )        .on( :start )
           running.to( :running )        .on( :reboot )
           running.to( :stopping )       .on( :stop )
-          shutting_down.to( :stopped )  .automatically
+          stopping.to(:stopped)         .automatically
+          stopping.to(:finish)          .automatically
           stopped.to( :finish )         .automatically
         end
 
@@ -132,10 +139,11 @@ module Deltacloud
           ec2 = new_client(credentials)
           img_arr = []
           opts ||= {}
+          profiles = hardware_profiles(nil)
           if opts[:id]
             safely do
               img_arr = ec2.describe_images([opts[:id]]).collect do |image|
-                convert_image(image)
+                convert_image(image, profiles)
               end
             end
             return img_arr
@@ -143,7 +151,7 @@ module Deltacloud
           owner_id = opts[:owner_id] || default_image_owner
           safely do
             img_arr = ec2.describe_images_by_owner([owner_id], default_image_type).collect do |image|
-              convert_image(image)
+              convert_image(image, profiles)
             end
           end
           img_arr = filter_on( img_arr, :architecture, opts )
@@ -152,12 +160,19 @@ module Deltacloud
 
         def realms(credentials, opts={})
           ec2 = new_client(credentials)
-          zone_id = opts ? opts[:id] : nil
+          realms = []
           safely do
-            return ec2.describe_availability_zones(zone_id).collect do |realm|
-              convert_realm(realm)
+            if opts[:id] and !opts[:id].empty?
+              ec2.describe_availability_zones([opts[:id]]).collect do |realm|
+                realms << convert_realm(realm) unless realm.empty?
+              end
+            else
+              ec2.describe_availability_zones.collect do |realm|
+                realms << convert_realm(realm) unless realm.empty?
+              end
             end
           end
+          realms
         end
 
         def create_image(credentials, opts={})
@@ -183,6 +198,7 @@ module Deltacloud
           inst_arr = []
           safely do
             ec2_inst = ec2.describe_instances([opts[:id]]).first
+            raise "Instance #{opts[:id]} NotFound" if ec2_inst.nil?
             instance = convert_instance(ec2_inst)
             return nil unless instance
             if ec2_inst[:aws_platform] == 'windows'
@@ -215,6 +231,9 @@ module Deltacloud
           if opts[:user_data]
             instance_options[:user_data] = Base64::decode64(opts[:user_data])
           end
+          if opts[:metrics] and !opts[:metrics].empty?
+            instance_options[:monitoring_enabled] = true
+          end
           instance_options[:key_name] = opts[:keyname] if opts[:keyname]
           instance_options[:availability_zone] = opts[:realm_id] if opts[:realm_id]
           instance_options[:instance_type] = opts[:hwp_id] if opts[:hwp_id] && opts[:hwp_id].length > 0
@@ -249,7 +268,7 @@ module Deltacloud
             :username => 'root', # Default for EC2 Linux instances
           }
           param[:port] = opts[:port] || '22'
-          param[:ip] = target.public_addresses
+          param[:ip] = opts[:ip] || target.public_addresses.first.address
           param[:private_key] = (opts[:private_key].length > 1) ? opts[:private_key] : nil
           safely do
             Deltacloud::Runner.execute(opts[:cmd], param)
@@ -276,11 +295,41 @@ module Deltacloud
 
         alias :stop_instance :destroy_instance
 
+        def metrics(credentials, opts={})
+          cw = new_client(credentials, :mon)
+          metrics_arr = []
+          cw.list_metrics( :namespace => 'AWS/EC2' ).each do |metric|
+            if metrics_arr.any? { |m| m.id == metric[:value] }
+              i = metrics_arr.index { |m| m.id == metric[:value] }
+              metrics_arr[i] = metrics_arr[i].add_property(metric[:measure_name])
+            else
+              metrics_arr << convert_metric(metric)
+            end
+          end
+          metrics_arr.reject! { |m| m.unknown? }
+          filter_on(metrics_arr, :id, opts)
+        end
+
+        def metric(credentials, opts={})
+          cw = new_client(credentials, :mon)
+          m = metrics(credentials, :id => opts[:id])
+          return [] if m.empty?
+          m = m.first
+          # Get statistics from last 1 hour
+          start_time = (Time.now - 3600).utc.iso8601.to_s
+          end_time = Time.now.utc.iso8601.to_s
+          m.properties.each do |p|
+            p.values = cw.get_metric_statistics(p.name,  ['Minimum', 'Maximum', 'Average'],
+                        start_time, end_time, metric_unit_for(p.name), { m.entity => opts[:id]})
+          end
+          m
+        end
+
         def keys(credentials, opts={})
           ec2 = new_client(credentials)
           opts ||= {}
           safely do
-            ec2.describe_key_pairs(opts[:id] || nil).collect do |key|
+            ec2.describe_key_pairs(opts[:id] ? [opts[:id]] : nil).collect do |key|
               convert_key(key)
             end
           end
@@ -335,6 +384,7 @@ module Deltacloud
 
         def destroy_load_balancer(credentials, id)
           ec2 = new_client( credentials, :elb )
+          return 'InvalidLoadBalancer' if load_balancer(credentials, :id => id).nil?
           safely do
             ec2.delete_load_balancer(id)
           end
@@ -361,7 +411,7 @@ module Deltacloud
           safely do
             s3_client = new_client(credentials, :s3)
             unless (opts[:id].nil?)
-              bucket = s3_client.bucket(opts[:id])
+              bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts[:id])
               buckets << convert_bucket(bucket)
             else
               bucket_list = s3_client.buckets
@@ -399,7 +449,7 @@ module Deltacloud
           s3_client = new_client(credentials, :s3)
           blobs = []
           safely do
-            s3_bucket = s3_client.bucket(opts['bucket'])
+            s3_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts['bucket'])
             if(opts[:id])
               blobs << convert_object(s3_bucket.key(opts[:id], true))
             else
@@ -456,7 +506,8 @@ module Deltacloud
           s3_client = new_client(credentials, :s3)
           blob_meta = {}
           safely do
-            the_blob = s3_client.bucket(opts['bucket']).key(opts[:id], true)
+            the_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts['bucket'])
+            the_blob = the_bucket.key(opts[:id], true)
             blob_meta = the_blob.meta_headers
           end
         end
@@ -465,13 +516,15 @@ module Deltacloud
           s3_client = new_client(credentials, :s3)
           meta_hash = BlobHelper::rename_metadata_headers(opts['meta_hash'], '')
           safely do
-            the_blob = s3_client.bucket(opts['bucket']).key(opts[:id])
+            the_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, opts['bucket'])
+            the_blob = the_bucket.key(opts[:id])
             the_blob.save_meta(meta_hash)
           end
         end
 
         def blob_data(credentials, bucket_id, blob_id, opts={})
           s3_client = new_client(credentials, :s3)
+          bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, bucket_id)
           safely do
             s3_client.interface.get(bucket_id, blob_id) do |chunk|
               yield chunk
@@ -704,7 +757,7 @@ module Deltacloud
         def providers(credentials, opts={})
           ec2 = new_client(credentials)
           providers = ec2.describe_regions.map{|r| Provider.new( {:id=>r, :name=>r,
-           :url=>"#{ENV['API_HOST']}:#{ENV['API_PORT']}#{settings.root_url}\;provider=#{r}" }) }
+           :url=>"#{ENV['API_HOST']}:#{ENV['API_PORT']}#{Deltacloud[ENV['API_FRONTEND'] || :deltacloud].root_url}\;provider=#{r}" }) }
         end
 
         def configured_providers
@@ -712,23 +765,30 @@ module Deltacloud
         end
 
         def valid_credentials?(credentials)
-          retval = true
           begin
-            realms(credentials)
-          rescue
-            retval = false
+            realms(credentials) && true
+          rescue => e
+            if e.class.name =~ /AuthFailure/
+              retval = false
+            else
+              safely { raise e }
+            end
           end
-          retval
         end
 
         private
-        def new_client(credentials, type = :ec2)
+        def new_client(credentials, type = :ec2, endpoint = nil)
           klass = case type
                     when :elb then Aws::Elb
                     when :ec2 then Aws::Ec2
                     when :s3 then Aws::S3
+                    when :mon then Aws::Mon
                   end
-          klass.new(credentials.user, credentials.password, {:server => endpoint_for_service(type), :connection_mode => :per_thread})
+          klass.new(credentials.user, credentials.password, {
+            :server => endpoint || endpoint_for_service(type),
+            :connection_mode => :per_thread,
+            :logger => ENV['RACK_ENV'] == 'test' ? Logger.new('/dev/null') : Logger.new(STDOUT)
+          })
         end
 
         def default_image_owner
@@ -746,6 +806,16 @@ module Deltacloud
           Deltacloud::Drivers::driver_config[:ec2][:entrypoints][service.to_s][endpoint] || endpoint
         end
 
+        def get_bucket_with_endpoint(s3_client, credentials, s3_bucket_name)
+            s3_bucket = s3_client.bucket(s3_bucket_name)
+            endpoint_for_bucket = Deltacloud::Drivers::driver_config[:ec2][:entrypoints]["s3"]["#{s3_bucket.location}"]
+            if (s3_client.interface.params[:server] != endpoint_for_bucket)
+              s3_client = new_client(credentials, :s3, endpoint_for_bucket)
+              s3_bucket = s3_client.bucket(s3_bucket_name)
+            end
+            [s3_bucket, s3_client]
+        end
+
         def convert_bucket(s3_bucket)
           #get blob list:
           blob_list = []
@@ -781,7 +851,7 @@ module Deltacloud
           )
         end
 
-        def convert_image(image)
+        def convert_image(image, profiles)
           # There is not support for 'name' for now
           Image.new(
             :id => image[:aws_id],
@@ -789,6 +859,7 @@ module Deltacloud
             :description => image[:aws_description] || image[:aws_location],
             :owner_id => image[:aws_owner],
             :architecture => image[:aws_architecture],
+            :hardware_profiles => image_profiles(image, profiles),
             :state => image[:aws_state]
           )
         end
@@ -852,8 +923,16 @@ module Deltacloud
           )
         end
 
+        def image_profiles(image, profiles)
+          profiles = filter_hardware_profiles(profiles, :architecture => image[:aws_architecture])
+          if image[:aws_root_device_type] != 'ebs'
+            profiles.reject { |p| p.name == 't1.micro' }
+          else
+            profiles
+          end
+        end
+
         def convert_load_balancer(credentials, loadbalancer)
-          puts loadbalancer.inspect
           realms = []
           balancer_realms = loadbalancer[:availability_zones].each do |zone|
             realms << realm(credentials, zone)
@@ -951,6 +1030,24 @@ module Deltacloud
                       }  )
         end
 
+        def metric_unit_for(name)
+          case name
+            when /Bytes/ then 'Bytes'
+            when /Ops/ then 'Count'
+            when /Count/ then 'Count'
+            when /Utilization/ then 'Percent'
+            when /Network/ then 'Bytes'
+            else 'None'
+          end
+        end
+
+        def convert_metric(metric)
+          Metric.new(
+            :id => metric[:value],
+            :entity => metric[:name] || :unknown
+          ).add_property(metric[:measure_name])
+        end
+
         def convert_state(ec2_state)
           case ec2_state
             when "terminated"
@@ -971,6 +1068,18 @@ module Deltacloud
             status 401
           end
 
+          on /(NotFound|InvalidInstanceID|InvalidAMIID|InvalidLoadBalancer|LoadBalancerNotFound)/ do
+            status 404
+          end
+
+          on /Bad Request.*elasticloadbalancing/ do
+            status 404
+          end
+
+          on /Invalid availability zone/ do
+            status 404
+          end
+
           on /Error/ do
             status 502
           end