deltacloud-core 1.1.1 → 1.1.2

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

@@ -20,6 +20,35 @@
 module Deltacloud::Drivers::Mock
 
   class MockDriver < Deltacloud::BaseDriver
+
+    def systems(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        systems = @client.load_all_cimi(:system).map{|sys| CIMI::Model::System.from_json(sys)}
+      else
+        begin
+          systems = [CIMI::Model::System.from_json(@client.load_cimi(:system, opts[:id]))]
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+      systems.map{|sys|convert_cimi_mock_urls(:system, sys ,opts[:env])}.flatten
+    end
+
+    def system_templates(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        system_templates = @client.load_all_cimi(:system_template).map{|sys_templ| CIMI::Model::SystemTemplate.from_json(sys_templ)}
+      else
+        begin
+          system_templates = [CIMI::Model::SystemTemplate.from_json(@client.load_cimi(:system_template, opts[:id]))]
+        rescue Errno::ENOENT
+          return []
+        end
+      end
+      system_templates.map{|sys_templ|convert_cimi_mock_urls(:system_template, sys_templ, opts[:env])}.flatten
+    end
+
     def networks(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
@@ -31,6 +60,48 @@ module Deltacloud::Drivers::Mock
       end
     end
 
+    def create_network(credentials, opts={})
+      check_credentials(credentials)
+      id = "#{opts[:env].send("networks_url")}/#{opts[:name]}"
+      net_hsh = { "id"=> id,
+                  "name" => opts[:name],
+                  "description" => opts[:description],
+                  "created" => Time.now,
+                  "state" => "STARTED",
+                  "networkType" => opts[:network_config].network_type,
+                  "mtu" =>  opts[:network_config].mtu,
+                  "classOfService" => opts[:network_config].class_of_service,
+
+
+                  "forwardingGroup"=> { "href" => opts[:forwarding_group].id },
+                  "operations" => [{"rel"=>"edit", "href"=> id},
+                                   {"rel"=>"delete", "href"=> id}]    }
+      network = CIMI::Model::Network.from_json(JSON.generate(net_hsh))
+
+      @client.store_cimi(:network, network)
+      network
+    end
+
+    def delete_network(credentials, id)
+      check_credentials(credentials)
+      @client.destroy_cimi(:network, id)
+    end
+
+    def start_network(credentials, id)
+      check_credentials(credentials)
+      update_object_state(id, "Network", "STARTED")
+    end
+
+    def stop_network(credentials, id)
+      check_credentials(credentials)
+      update_object_state(id, "Network", "STOPPED")
+    end
+
+    def suspend_network(credentials, id)
+      check_credentials(credentials)
+      update_object_state(id, "Network", "SUSPENDED")
+    end
+
     def network_configurations(credentials, opts={})
       check_credentials(credentials)
       if opts[:id].nil?
@@ -163,6 +234,15 @@ module Deltacloud::Drivers::Mock
       end
     end
 
+    def update_object_state(id, object, new_state)
+      klass = CIMI::Model.const_get("#{object}")
+      symbol = object.to_s.downcase.singularize.intern
+      obj = klass.from_json(@client.load_cimi(symbol, id))
+      obj.state = new_state
+      @client.store_cimi(symbol, obj)
+      obj
+    end
+
   end
 
 end

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

@@ -240,12 +240,17 @@ class OpennebulaDriver < Deltacloud::BaseDriver
     if computehash['DISK/STORAGE']
       image_id = computehash['DISK/STORAGE'].attributes['href'].split("/").last
     end
+    if computehash['INSTANCE_TYPE']
+      instance_profile = computehash['INSTANCE_TYPE'].text
+    else
+      instance_profile = 'small'
+    end
     Instance.new( {
       :id=>computehash['ID'].text,
       :owner_id=>credentials.user,
       :name=>computehash['NAME'].text,
       :image_id=>image_id,
-      :instance_profile=>InstanceProfile.new(computehash['INSTANCE_TYPE'].text||'small'),
+      :instance_profile=>InstanceProfile.new(instance_profile),
       :realm_id=>'ONE',
       :state=>VM_STATES[computehash['STATE'].text],
       :public_addresses=>network,

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

@@ -43,11 +43,25 @@ module Deltacloud
         end
 
         define_hardware_profile('default')
+
         def supported_collections(credentials)
           #get the collections as defined by 'capability' and 'respond_to?' blocks
           super_collections = super
-          super_collections = super_collections - [Sinatra::Rabbit::BucketsCollection] if regions_for(credentials, "object-store").empty?
-          super_collections = super_collections - [Sinatra::Rabbit::StorageVolumesCollection] if regions_for(credentials, "volume").empty?
+          begin
+            new_client(credentials, "compute")
+          rescue Deltacloud::Exceptions::NotImplemented
+            super_collections = super_collections - [Deltacloud::Rabbit::ImagesCollection, Deltacloud::Rabbit::InstancesCollection, Deltacloud::Rabbit::InstanceStatesCollection,Deltacloud::Rabbit::KeysCollection,Deltacloud::Rabbit::RealmsCollection, Deltacloud::Rabbit::HardwareProfilesCollection]
+          end
+          begin
+             new_client(credentials, "object-store")
+          rescue Deltacloud::Exceptions::NotImplemented #OpenStack::Exception::NotImplemented...
+             super_collections = super_collections - [Deltacloud::Rabbit::BucketsCollection]
+          end
+          begin
+              new_client(credentials, "volume")
+          rescue Deltacloud::Exceptions::NotImplemented
+              super_collections = super_collections - [Deltacloud::Rabbit::StorageVolumesCollection, Deltacloud::Rabbit::StorageSnapshotsCollection]
+          end
           super_collections
         end
 
@@ -115,44 +129,35 @@ module Deltacloud
           end
         end
 
+        def providers(credentials, opts={})
+          os = new_client(credentials, "compute", true)
+          providers = []
+          os.connection.regions_list.each_pair do |region, services|
+            resource_types = services.inject([]){|res, cur| res << cur[:service] if ["compute", "volume", "object-store"].include?(cur[:service]); res }
+            next if resource_types.empty? #nothing here deltacloud manages
+            providers << convert_provider(region)
+          end
+          providers
+        end
+
         def realms(credentials, opts={})
           os = new_client(credentials)
           realms = []
-          if opts[:id]
-            resource_types = []
-            (os.connection.regions_list[opts[:id]] || []).each do |service|
-              resource_types << service[:service] if ["compute", "volume", "object-store"].include?(service[:service])
-              realms << Realm.new( {  :id => opts[:id],
-                                    :name => opts[:id],
-                                    :state =>'AVAILABLE',
-                                    :resource_types => resource_types}) unless resource_types.empty?
-            end
-          else
-            os.connection.regions_list.each_pair do |region, services|
-              resource_types = services.inject([]){|res, cur| res << cur[:service] if ["compute", "volume", "object-store"].include?(cur[:service]); res }
-              next if resource_types.empty? #nothing here deltacloud manages
-              realms << Realm.new( {  :id => region,
-                                    :name => region,
-                                    :state =>'AVAILABLE',
-                                    :resource_types => resource_types})
-            end
+          limits = ""
+          safely do
+            lim = os.limits
+              limits << "ABSOLUTE >> Max. Instances: #{lim[:absolute][:maxTotalInstances]} Max. RAM: #{lim[:absolute][:maxTotalRAMSize]}   ||   "
+              lim[:rate].each do |rate|
+                if rate[:regex] =~ /servers/
+                  limits << "SERVERS >> Total: #{rate[:limit].first[:value]}  Remaining: #{rate[:limit].first[:remaining]} Time Unit: per #{rate[:limit].first[:unit]}"
+                end
+              end
           end
-          realms
-#          limits = ""
-#          safely do
-#            lim = os.limits
-#              limits << "ABSOLUTE >> Max. Instances: #{lim[:absolute][:maxTotalInstances]} Max. RAM: #{lim[:absolute][:maxTotalRAMSize]}   ||   "
-#              lim[:rate].each do |rate|
-#                if rate[:regex] =~ /servers/
-#                  limits << "SERVERS >> Total: #{rate[:limit].first[:value]}  Remaining: #{rate[:limit].first[:remaining]} Time Unit: per #{rate[:limit].first[:unit]}"
-#                end
-#              end
-#          end
-#          return [] if opts[:id] and opts[:id] != 'default'
-#          [ Realm.new( { :id=>'default',
-#                        :name=>'default',
-#                        :limit => limits,
-#                        :state=>'AVAILABLE' })]
+          return [] if opts[:id] and opts[:id] != 'default'
+          [ Realm.new( { :id=>'default',
+                        :name=>'default',
+                        :limit => limits,
+                        :state=>'AVAILABLE' })]
         end
 
         def instances(credentials, opts={})
@@ -178,13 +183,7 @@ module Deltacloud
         end
 
         def create_instance(credentials, image_id, opts)
-          if opts[:realm_id] && opts[:realm_id].length > 0
-            os = new_client( credentials, "compute", opts[:realm_id])
-          else
-            #choose a random realm:
-            available_realms = regions_for(credentials, "compute")
-            os = new_client(credentials, "compute", available_realms.sample.id)
-          end
+          os = new_client( credentials, "compute")
           result = nil
 #opts[:personality]: path1='server_path1'. content1='contents1', path2='server_path2', content2='contents2' etc
           params = {}
@@ -204,7 +203,7 @@ module Deltacloud
           end
           safely do
             server = os.create_server(params)
-            result = convert_from_server(server, os.connection.authuser, get_attachments(server.id, os), os.connection.region)
+            result = convert_from_server(server, os.connection.authuser, get_attachments(server.id, os))
           end
           result
         end
@@ -238,15 +237,6 @@ module Deltacloud
 
         alias_method :stop_instance, :destroy_instance
 
-        def valid_credentials?(credentials)
-          begin
-            new_client(credentials)
-          rescue
-            return false
-          end
-          true
-        end
-
         def buckets(credentials, opts={})
           os = new_client(credentials, "object-store")
           buckets = []
@@ -484,17 +474,8 @@ module Deltacloud
         end
 
 private
-
-        def region_specified?
-          api_provider.split(";").last
-        end
-
-        def regions_for(credentials, service="compute")
-          realms(credentials).select{|region| region.resource_types.include?(service)}
-        end
-
         #for v2 authentication credentials.name == "username+tenant_name"
-        def new_client(credentials, type="compute", realm_id=nil)
+        def new_client(credentials, type="compute", ignore_provider=false)
           tokens = credentials.user.split("+")
           if credentials.user.empty?
             raise AuthenticationFailure.new(Exception.new("Error: you must supply the username"))
@@ -506,12 +487,12 @@ private
           end
           #check if region specified with provider:
           provider = api_provider
-          if (realm_id || provider.include?(";"))
-            region = realm_id || provider.split(";").last
+          if (provider.include?(";"))
+            region = provider.split(";").last
             provider = provider.chomp(";#{region}")
           end
           connection_params = {:username => user_name, :api_key => credentials.password, :authtenant => tenant_name, :auth_url => provider, :service_type => type}
-          connection_params.merge!({:region => region}) if region
+          connection_params.merge!({:region => region}) if region && !ignore_provider # hack needed for 'def providers'
           safely do
             raise ValidationFailure.new(Exception.new("Error: tried to initialise Openstack connection using" +
                     " an unknown service_type: #{type}")) unless ["volume", "compute", "object-store"].include? type
@@ -548,7 +529,7 @@ private
                     })
         end
 
-        def convert_from_server(server, owner, attachments=[], region=nil)
+        def convert_from_server(server, owner, attachments=[])
           op = (server.class == Hash)? :fetch : :send
           image = server.send(op, :image)
           flavor = server.send(op, :flavor)
@@ -559,7 +540,7 @@ private
           end
           inst = Instance.new(
             :id => server.send(op, :id).to_s,
-            :realm_id => region || "n/a",
+            :realm_id => "default",
             :owner_id => owner,
             :description => server.send(op, :name),
             :name => server.send(op, :name),
@@ -667,6 +648,14 @@ private
           )
         end
 
+        def convert_provider(region)
+          Provider.new(
+            :id => region,
+            :name => region,
+            :url => [api_provider.split(';').first, region].join(';')
+          )
+        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)
@@ -705,6 +694,10 @@ private
             status 401
           end
 
+          on /No API endpoint for region/ do
+            status 501
+          end
+
           on /OpenStack::Exception::Authentication/ do
             status 401
           end

data/lib/deltacloud/drivers/rackspace/rackspace_driver.rb

@@ -181,15 +181,6 @@ class RackspaceDriver < Deltacloud::BaseDriver
     insts
   end
 
-  def valid_credentials?(credentials)
-    begin
-      new_client(credentials)
-    rescue
-      return false
-    end
-    true
-  end
-
   define_instance_states do
     start.to( :pending )          .on( :create )
     pending.to( :running )        .automatically

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

@@ -127,12 +127,17 @@ class RhevmDriver < Deltacloud::BaseDriver
     inst_arr = []
     safely do
       if opts[:id]
-        vms = client.vms(:id => opts[:id])
+        begin
+          vm = client.vm(opts[:id])
+          inst_arr << convert_instance(client, vm)
+        rescue => e
+          raise e unless e.message =~ /Resource Not Found/
+        end
       else
         vms = client.vms
-      end
-      vms.each do |vm|
-        inst_arr << convert_instance(client, vm)
+        vms.each do |vm|
+          inst_arr << convert_instance(client, vm)
+        end
       end
     end
     inst_arr = filter_on( inst_arr, :id, opts )
@@ -286,7 +291,7 @@ class RhevmDriver < Deltacloud::BaseDriver
   # UNASSIGNED, DOWN, UP, POWERING_UP, POWERED_DOWN, PAUSED, MIGRATING_FROM,
   # MIGRATING_TO, UNKNOWN, NOT_RESPONDING, WAIT_FOR_LAUNCH, REBOOT_IN_PROGRESS,
   # SAVING_STATE, RESTORING_STATE, SUSPENDED, IMAGE_ILLEGAL,
-  # IMAGE_LOCKED or POWERING_DOWN
+  # IMAGE_LOCKED, MIGRATING or POWERING_DOWN
   #
   def convert_state(state)
     unless state.respond_to?(:upcase)
@@ -295,7 +300,7 @@ class RhevmDriver < Deltacloud::BaseDriver
     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 'STOPPING' if ['POWERING_DOWN', 'MIGRATING'].include? state
     return 'STOPPED' if ['UNASSIGNED', 'DOWN', 'NOT_RESPONDING',
                          'IMAGE_ILLEGAL', 'UNKNOWN'].include? state
     return 'RUNNING' if ['UP', 'MIGRATING_TO', 'MIGRATING_FROM'].include? state

data/lib/deltacloud/drivers/terremark/terremark_driver.rb

@@ -197,14 +197,6 @@ def destroy_instance(credentials, id)
   end
 end
 
-def valid_credentials?(credentials)
-  begin
-    new_client(credentials)
-  rescue
-    return false
-  end
-  true
-end
 
 #--
 # PRIVATE METHODS:

data/lib/deltacloud/drivers/vsphere/vsphere_client.rb

@@ -97,10 +97,15 @@ module Deltacloud::Drivers::VSphere
       rootFolder = vsphere.serviceInstance.content.rootFolder
       rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter).each do |dc|
         list_datastores(dc.datastoreFolder).each do  |datastore|
-          vms += datastore.vm.collect { |vm| { :instance => vm, :datastore => datastore.name } unless vm.nil? }
-          stored_tasks(datastore, vsphere) do |task|
-            if task.info.entity.class == RbVmomi::VIM::VirtualMachine
-              vms << { :stored_instance => load_serialized_instance(datastore, task.info.key), :datastore => datastore.name }
+          if datastore.class == RbVmomi::VIM::StoragePod
+            storagepod_name = datastore.summary['name']
+            vms += datastore.childEntity.grep(RbVmomi::VIM::VirtualMachine).collect { |vm| { :instance => vm, :datastore => storagepod_name } }
+          else
+            vms += datastore.vm.collect { |vm| { :instance => vm, :datastore => datastore.name } unless vm.nil? }
+            stored_tasks(datastore, vsphere) do |task|
+              if task.info.entity.class == RbVmomi::VIM::VirtualMachine
+                vms << { :stored_instance => load_serialized_instance(datastore, task.info.key), :datastore => datastore.name }
+              end
             end
           end
         end
@@ -116,6 +121,8 @@ module Deltacloud::Drivers::VSphere
       df.childEntity.each do |object|
         if object.class.to_s == 'Folder'
           datastores += list_datastores(object)
+        elsif object.class.to_s == 'StoragePod'
+          datastores += list_datastores(object)
         else
           datastores << object
         end

data/lib/deltacloud/drivers/vsphere/vsphere_driver.rb

@@ -390,18 +390,6 @@ module Deltacloud::Drivers::Vsphere
 
     end
 
-    def valid_credentials?(credentials)
-      begin
-        RbVmomi::VIM.connect(:host => host_endpoint, :user => credentials.user, :password => credentials.password, :insecure => true) && true
-      rescue RbVmomi::Fault::InvalidLogin
-        return false
-      rescue => e
-        safely do
-          raise e
-        end
-      end
-    end
-
     #######
     private
     #######