deltacloud-core 1.0.1 → 1.0.2

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

@@ -409,7 +409,7 @@ class GogridDriver < Deltacloud::BaseDriver
 
   def convert_image(gg_image, owner_id=nil)
     Image.new( {
-      :id=>gg_image['id'],
+      :id=>gg_image['id'].to_s,
       :name => "#{gg_image['friendlyName']}",
       :description=> convert_description(gg_image).to_s,
       :owner_id=>gg_image['owner']['name'].to_s,

data/lib/deltacloud/drivers/mock/mock_client.rb

@@ -19,6 +19,8 @@
 
 module Deltacloud::Drivers::Mock
 
+  require 'fileutils'
+
   class Client
     def initialize(storage_root)
       @storage_root = storage_root

data/lib/deltacloud/drivers/mock/mock_driver.rb

@@ -17,8 +17,10 @@
 require 'yaml'
 require 'base64'
 require 'etc'
+
 require_relative 'mock_client'
 require_relative 'mock_driver_cimi_methods'
+require_relative '../../runner'
 
 module Deltacloud::Drivers::Mock
 
@@ -45,7 +47,7 @@ module Deltacloud::Drivers::Mock
     end
 
     define_hardware_profile('m1-large') do
-      cpu                (1..6)
+      cpu              (1..6)
       memory           ( 7680.. 15*1024), :default => 10 * 1024
       storage          [ 850, 1024 ]
       architecture     'x86_64'
@@ -76,6 +78,7 @@ module Deltacloud::Drivers::Mock
     feature :instances, :user_name
     feature :instances, :user_data
     feature :instances, :authentication_key
+    feature :instances, :metrics
     feature :images, :user_name
     feature :images, :user_description
 
@@ -90,7 +93,7 @@ module Deltacloud::Drivers::Mock
       @client = Client.new(storage_root)
     end
 
-    def realms(credentials, opts=nil)
+    def realms(credentials, opts={})
       check_credentials( credentials )
       results = []
       safely do
@@ -100,7 +103,6 @@ module Deltacloud::Drivers::Mock
         raise "NotImplementedTest" if opts and opts[:id] == "501"
         raise "ProviderErrorTest" if opts and opts[:id] == "502"
         raise "ProviderTimeoutTest" if opts and opts[:id] == "504"
-        return REALMS if ( opts.nil? )
         results = REALMS
       end
       results = filter_on( results, :id, opts )
@@ -188,6 +190,7 @@ module Deltacloud::Drivers::Mock
       end
 
       hwp = find_hardware_profile(credentials, opts[:hwp_id], image_id)
+      hwp ||= find_hardware_profile(credentials, 'm1-small', image_id)
 
       name = opts[:name] || "i-#{Time.now.to_i}"
 
@@ -257,9 +260,8 @@ module Deltacloud::Drivers::Mock
       volumes
     end
 
-    def create_storage_volume(credentials, opts=nil)
+    def create_storage_volume(credentials, opts={})
       check_credentials(credentials)
-      opts ||= {}
       opts[:capacity] ||= "1"
       id = "Volume#{Time.now.to_i}"
       volume = {
@@ -273,13 +275,13 @@ module Deltacloud::Drivers::Mock
       StorageVolume.new(volume)
     end
 
-    def destroy_storage_volume(credentials, opts=nil)
+    def destroy_storage_volume(credentials, opts={})
       check_credentials(credentials)
       @client.destroy(:storage_volumes, opts[:id])
     end
 
     #opts: {:id=,:instance_id,:device}
-    def attach_storage_volume(credentials, opts)
+    def attach_storage_volume(credentials, opts={})
       check_credentials(credentials)
       attach_volume_instance(opts[:id], opts[:device], opts[:instance_id])
     end
@@ -319,9 +321,10 @@ module Deltacloud::Drivers::Mock
         :fingerprint => Key::generate_mock_fingerprint,
         :pem_rsa_key => Key::generate_mock_pem
       }
-
-      raise "KeyExist" if @client.load(:keys, key_hash[:id])
-      @client.store(:keys, key_hash)
+      safely do
+        raise "KeyExist" if @client.load(:keys, key_hash[:id])
+        @client.store(:keys, key_hash)
+      end
       return Key.new(key_hash)
     end
 
@@ -387,6 +390,8 @@ module Deltacloud::Drivers::Mock
     def blob_data(credentials, bucket_id, blob_id, opts = {})
       check_credentials(credentials)
       if blob = @client.load(:blobs, blob_id)
+        #give event machine a chance
+        sleep 1
         blob[:content].split('').each {|part| yield part}
       end
     end
@@ -401,12 +406,23 @@ module Deltacloud::Drivers::Mock
         :id => blob_id,
         :name => blob_id,
         :bucket => bucket_id,
-        :content_length => blob_data[:tempfile].length,
-        :content_type => blob_data[:type],
         :last_modified => Time.now,
         :user_metadata => BlobHelper::rename_metadata_headers(blob_meta, ''),
-        :content => blob_data[:tempfile].read
       }
+      if blob_data.kind_of? Hash
+        blob_data[:tempfile].rewind
+        blob.merge!({
+          :content_length => blob_data[:tempfile].length,
+          :content_type => blob_data[:type],
+          :content => blob_data[:tempfile].read
+        })
+      elsif blob_data.kind_of? String
+        blob.merge!({
+          :content_length => blob_data.size,
+          :content_type => 'text/plain',
+          :content => blob_data
+        })
+      end
       @client.store(:blobs, blob)
       Blob.new(blob)
     end
@@ -447,6 +463,54 @@ module Deltacloud::Drivers::Mock
       end
     end
 
+    #--
+    # Metrics
+    #--
+    def metrics(credentials, opts={})
+      check_credentials( credentials )
+      instances = @client.build_all(Instance)
+      instances = filter_on( instances, :id, opts )
+
+      metrics_arr = instances.collect do |instance|
+        Metric.new(
+          :id     => instance.id,
+          :entity => instance.name
+        )
+      end
+
+      # add metric names to metrics
+      metrics_arr.each do |metric|
+        @@METRIC_NAMES.each do |name|
+          metric.add_property(name)
+        end
+        metric.properties.sort! {|a,b| a.name <=> b.name}
+      end
+      metrics_arr
+    end
+
+    def metric(credentials, opts={})
+      metric = metrics(credentials, opts).first
+
+      metric.properties.each do |property|
+
+        property.values = (0..5).collect do |i|
+
+          unit = metric_unit_for(property.name)
+          average = (property.name == 'cpuUtilization') ? (rand * 1000).to_i / 10.0 : rand(1000)
+          max = (property.name == 'cpuUtilization') ? (1000 + 10 * average).to_i / 20.0 : average * (i + 1)
+          min = (property.name == 'cpuUtilization') ? (2.5 * average).to_i / 10.0 : (average / 4).to_i
+          {
+            :minimum   => min,
+            :maximum   => max,
+            :average   => average,
+            :timestamp => Time.now - i * 60,
+            :unit      => unit
+          }
+        end
+      end
+      metric
+    end
+
     def valid_credentials?(credentials)
       begin
         check_credentials(credentials)
@@ -492,6 +556,30 @@ module Deltacloud::Drivers::Mock
       StorageVolume.new(volume)
     end
 
+    def metric_unit_for(name)
+      case name
+        when /Utilization/ then 'Percent'
+        when /Byte/ then 'Bytes'
+        when /Sector/ then 'Count'
+        when /Count/ then 'Count'
+        when /Packet/ then 'Count'
+        else 'None'
+      end
+    end
+
+    # names copied from FGCP driver
+    @@METRIC_NAMES = [
+      'cpuUtilization',
+      'diskReadRequestCount',
+      'diskReadSector',
+      'diskWriteRequestCount',
+      'diskWriteSector',
+      'nicInputByte',
+      'nicInputPacket',
+      'nicOutputByte',
+      'nicOutputPacket'
+    ]
+
     exceptions do
 
       on /AuthFailure/ do

data/lib/deltacloud/drivers/opennebula/occi_client.rb

@@ -83,8 +83,8 @@ module OCCIClient
     ######################################################################
     # Retieves the pool of Virtual Machines
     ######################################################################
-    def get_vms
-      get('/compute')
+    def get_vms(verbose=false)
+      get('/compute', verbose)
     end
 
     ######################################################################
@@ -196,8 +196,8 @@ module OCCIClient
     ######################################################################
     # Retieves the pool of Images owned by the user
     ######################################################################
-    def get_images
-      get('/storage')
+    def get_images(verbose=false)
+      get('/storage', verbose)
     end
 
 
@@ -275,10 +275,16 @@ module OCCIClient
 
     private
 
-    def get(path)
+    def get(path, verbose=false)
       url = URI.parse(@endpoint+path)
+
+      params = []
+      params << "verbose=true" if verbose
+      params << "#{url.query}" if url.query
+
       path = url.path
-      path << "?#{url.query}" if url.query
+      path << "?#{params.join('&')}"
+
       req = Net::HTTP::Get.new(path)
 
       do_request(url, req)

data/lib/deltacloud/drivers/opennebula/opennebula_driver.rb

@@ -45,10 +45,10 @@ class OpennebulaDriver < Deltacloud::BaseDriver
       @hardware_profiles = REXML::Document.new(xml).root.elements.map {|d|
         elem = d.elements
         ::Deltacloud::HardwareProfile.new(elem['NAME'].text) {
-          cpu          elem['CPU']
-          memory       elem['MEMORY']
-          storage      elem['STORAGE']
-          architecture elem['ARCHITECTURE']
+          cpu          elem['CPU'].text if elem['CPU']
+          memory       elem['MEMORY'].text if elem['MEMORY']
+          storage      elem['STORAGE'].text  if elem['STORAGE']
+          architecture elem['ARCHITECTURE'].text if elem['ARCHITECTURE']
         }
       }
     end
@@ -84,13 +84,11 @@ class OpennebulaDriver < Deltacloud::BaseDriver
   def images(credentials, opts=nil)
     occi_client = new_client(credentials)
 
-    xml = treat_response(occi_client.get_images)
+    xml = treat_response(occi_client.get_images(true))
 
     # TBD Add extended info in the pool
     images = REXML::Document.new(xml).root.elements.map do |d|
-      im_id = d.attributes['href'].split("/").last
-      storage = treat_response(occi_client.get_image(im_id))
-      convert_image(storage, credentials)
+      convert_image(d, credentials)
     end
   end
 
@@ -156,13 +154,10 @@ class OpennebulaDriver < Deltacloud::BaseDriver
   def instances(credentials, opts=nil)
     occi_client = new_client(credentials)
 
-    xml = treat_response(occi_client.get_vms)
-
+    xml = treat_response(occi_client.get_vms(true))
     # TBD Add extended info in the pool
     instances = REXML::Document.new(xml).root.elements.map do |d|
-      vm_id = d.attributes['href'].split("/").last
-      computexml = treat_response(occi_client.get_vm(vm_id))
-      convert_instance(computexml, credentials)
+      convert_instance(d, credentials)
     end
 
     instances = filter_on( instances, :state, opts )
@@ -221,7 +216,7 @@ class OpennebulaDriver < Deltacloud::BaseDriver
 
 
   def convert_image(diskxml, credentials)
-    storage = REXML::Document.new(diskxml).root.elements
+    storage = REXML::Document.new(diskxml.to_s).root.elements
 
     # TBD Add Image STATE, OWNER
     Image.new( {
@@ -235,10 +230,8 @@ class OpennebulaDriver < Deltacloud::BaseDriver
     } )
   end
 
-
   def convert_instance(computexml, credentials)
-    compute = REXML::Document.new(computexml)
-    computehash = compute.root.elements
+    computehash = REXML::Document.new(computexml.to_s).root.elements
 
     network = []
     computehash.each('NIC/IP') {|ip| network<<InstanceAddress.new(ip.text, :type => :ipv4)}
@@ -247,7 +240,6 @@ class OpennebulaDriver < Deltacloud::BaseDriver
     if computehash['DISK/STORAGE']
       image_id = computehash['DISK/STORAGE'].attributes['href'].split("/").last
     end
-
     Instance.new( {
       :id=>computehash['ID'].text,
       :owner_id=>credentials.user,

data/lib/deltacloud/drivers/openstack/openstack_driver.rb

@@ -23,9 +23,11 @@ module Deltacloud
       class OpenstackDriver < Deltacloud::BaseDriver
 
         feature :instances, :user_name
+        feature :instances, :authentication_key
         feature :instances, :authentication_password
         feature :instances, :user_files
         feature :images, :user_name
+        feature :keys, :import_key
 
         define_instance_states do
           start.to( :pending )          .on( :create )
@@ -142,6 +144,9 @@ module Deltacloud
           if opts[:password] && opts[:password].length > 0
             params[:adminPass]=opts[:password]
           end
+          if opts[:keyname] && opts[:keyname].length > 0
+            params[:key_name]=opts[:keyname]
+          end
           safely do
             server = os.create_server(params)
             result = convert_from_server(server, os.connection.authuser)
@@ -285,6 +290,30 @@ module Deltacloud
           return http, request
         end
 
+        def keys(credentials, opts={})
+          os = new_client(credentials)
+          keys = []
+          safely do
+            os.keypairs.values.each{|key| keys << convert_key(key)}
+          end
+          filter_on(keys, :id, opts)
+        end
+
+        def create_key(credentials, opts={})
+          os = new_client(credentials)
+          safely do
+            params = (opts[:public_key] and opts[:public_key].length > 0)? {:name=>opts[:key_name], :public_key=> opts[:public_key]} : {:name=>opts[:key_name]}
+            convert_key(os.create_keypair(params))
+          end
+        end
+
+        def destroy_key(credentials, opts={})
+          os = new_client(credentials)
+          safely do
+            os.delete_keypair(opts[:id])
+          end
+        end
+
 private
 
         #for v2 authentication credentials.name == "username+tenant_name"
@@ -362,7 +391,8 @@ private
             :public_addresses => convert_server_addresses(server, :public),
             :private_addresses => convert_server_addresses(server, :private),
             :username => 'root',
-            :password => password
+            :password => password,
+            :keyname => server.send(op, :key_name)
           )
           inst.actions = instance_actions_for(inst.state)
           inst.create_image = 'RUNNING'.eql?(inst.state)
@@ -411,6 +441,17 @@ private
                        :user_metadata => blob_meta })
         end
 
+        def convert_key(key)
+          Key.new(
+            :id => key[:name],
+            :fingerprint => key[:fingerprint],
+            :credential_type => :key,
+            :pem_rsa_key => key[:private_key], # only available once, on create_key
+            :state => "AVAILABLE"
+          )
+        end
+
+
         #IN: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
         #OUT:{local_path=>server_path, local_path1=>server_path2 etc}
         def extract_personality(opts)
@@ -457,6 +498,10 @@ private
             status 500
           end
 
+          on /OpenStack::Exception::NotImplemented/ do
+            status 501
+          end
+
         end
 
 

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -85,8 +85,13 @@ class RhevmDriver < Deltacloud::BaseDriver
     client = new_client(credentials)
     img_arr = []
     safely do
-      if (!opts.nil? && opts[:id])
-        img_arr << convert_image(client, client.template(opts[:id]))
+      if opts[:id]
+        begin
+          img_arr << convert_image(client, client.template(opts[:id]))
+        rescue OVIRT::OvirtException => e
+          raise e unless e.message =~ /Resource Not Found/
+          img_arr = []
+        end
       else
         img_arr = client.templates.collect { |t| convert_image(client, t) }
       end
@@ -176,7 +181,7 @@ class RhevmDriver < Deltacloud::BaseDriver
         raise "Parameter name must be #{USER_NAME_MAX} characters or less" if opts[:name].length > USER_NAME_MAX
       end
       params[:name] = opts[:name]
-      params[:template] = opts[:image_id]
+      params[:template] = image_id
       params[:cluster] = opts[:realm_id] if opts[:realm_id]
       params[:hwp_id] = opts[:hwp_id] if opts[:hwp_id]
       params[:memory] = (opts[:hwp_memory].to_i * 1024 * 1024) if opts[:hwp_memory]
@@ -273,19 +278,14 @@ class RhevmDriver < Deltacloud::BaseDriver
     unless state.respond_to?(:upcase)
       raise "State #{state.inspect} is not a string"
     end
-    case state.strip.upcase
-    when 'WAIT_FOR_LAUNCH', 'REBOOT_IN_PROGRESS', 'SAVING_STATE',
-      'RESTORING_STATE', 'POWERING_UP', 'IMAGE_LOCKED', 'SAVING_STATE' then
-      'PENDING'
-    when 'POWERING_DOWN' then
-      'STOPPING'
-    when 'UNASSIGNED', 'DOWN', 'PAUSED', 'NOT_RESPONDING', 'SUSPENDED', 'IMAGE_ILLEGAL', 'UNKNOWN' then
-      'STOPPED'
-    when 'UP', 'MIGRATING_TO', 'MIGRATING_FROM'
-      'RUNNING'
-    else
-      raise "Unexpected state '#{state}'"
-    end
+    state = state.gsub('\\', '').strip.upcase
+    return 'PENDING' if ['WAIT_FOR_LAUNCH', 'REBOOT_IN_PROGRESS', 'SAVING_STATE',
+                        'RESTORING_STATE', 'POWERING_UP', 'IMAGE_LOCKED', 'SAVING_STATE'].include? state
+    return 'STOPPING' if state == 'POWERING_DOWN'
+    return 'STOPPED' if ['UNASSIGNED', 'DOWN', 'PAUSED', 'NOT_RESPONDING', 'SUSPENDED',
+                         'IMAGE_ILLEGAL', 'UNKNOWN'].include? state
+    return 'RUNNING' if ['UP', 'MIGRATING_TO', 'MIGRATING_FROM'].include? state
+    raise "Unexpected state '#{state}'"
   end
 
   def convert_volume(volume)
@@ -308,7 +308,7 @@ class RhevmDriver < Deltacloud::BaseDriver
       :owner_id => client.credentials[:username],
       :architecture => 'x86_64', # All RHEV-M VMs are x86_64
       :hardware_profiles => hardware_profiles(nil),
-      :state => img.status
+      :state => img.status.strip.upcase
     )
   end