deltacloud-core 0.4.1 → 0.5.0

data/lib/deltacloud/drivers/mock/data/instances/inst0.yml

@@ -8,11 +8,16 @@
 - :stop
 :owner_id: mockuser
 :public_addresses:
-- img1.inst0.public.com
+- !ruby/object:InstanceAddress
+  address: img1.inst0.public.com
+  address_type: :hostname
 :private_addresses:
-- img1.inst0.private.com
+- !ruby/object:InstanceAddress
+  address: img1.inst0.private.com
+  address_type: :hostname
 :create_image: true
 :image_id: img1
 :name: Mock Instance With Profile Change
 :id: inst0
 :state: RUNNING
+:storage_volumes: []

data/lib/deltacloud/drivers/mock/data/instances/inst1.yml

@@ -4,9 +4,13 @@
 :realm_id: us
 :owner_id: mockuser
 :public_addresses:
-- img3.inst1.public.com
+- !ruby/object:InstanceAddress
+  address: img1.inst1.public.com
+  address_type: :hostname
 :private_addresses:
-- img3.inst1.private.com
+- !ruby/object:InstanceAddress
+  address: img1.inst1.private.com
+  address_type: :hostname
 :create_image: true
 :image_id: img3
 :name: MockUserInstance
@@ -15,3 +19,4 @@
 :actions:
 - :reboot
 - :stop
+:storage_volumes: []

data/lib/deltacloud/drivers/mock/data/instances/inst2.yml

@@ -4,9 +4,13 @@
 :realm_id: us
 :owner_id: anotheruser
 :public_addresses:
-- img1.inst2.public.com
+- !ruby/object:InstanceAddress
+  address: img1.inst2.public.com
+  address_type: :hostname
 :private_addresses:
-- img1.inst2.private.com
+- !ruby/object:InstanceAddress
+  address: img1.inst2.private.com
+  address_type: :hostname
 :create_image: true
 :image_id: img1
 :name: AnotherInstance
@@ -15,3 +19,4 @@
 :actions:
 - :reboot
 - :stop
+:storage_volumes: []

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

@@ -91,6 +91,23 @@ module Deltacloud::Drivers::Mock
       FileUtils.rm(fname) if File::exists?(fname)
     end
 
+    def load_all_cimi(model_name)
+        model_files = Dir[File::join(cimi_dir(model_name), "*.json")]
+        model_files.map{|f| File.read(f)}
+    end
+
+    def load_cimi(model_name, id)
+        File.read(cimi_file(model_name, id))
+    end
+
+    def cimi_file(collection, id)
+      File::join(cimi_dir(collection), "#{id}.json")
+    end
+
+    def cimi_dir(collection)
+      File::join(@storage_root, "cimi", collection.to_s)
+    end
+
     private
 
     def collection_name(klass)

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

@@ -15,10 +15,11 @@
 # under the License.
 
 
-require 'deltacloud/base_driver'
 require 'yaml'
-require 'deltacloud/drivers/mock/mock_client'
 require 'base64'
+require 'etc'
+require 'deltacloud/base_driver'
+require 'deltacloud/drivers/mock/mock_client'
 
 module Deltacloud::Drivers::Mock
 
@@ -55,8 +56,8 @@ module Deltacloud::Drivers::Mock
     end
 
     define_hardware_profile('m1-large') do
-      cpu                2
-      memory           (7.5*1024 .. 15*1024), :default => 10 * 1024
+      cpu                (1..6)
+      memory           ( 7680.. 15*1024), :default => 10 * 1024
       storage          [ 850, 1024 ]
       architecture     'x86_64'
     end
@@ -90,7 +91,7 @@ module Deltacloud::Drivers::Mock
     def initialize
       if ENV["DELTACLOUD_MOCK_STORAGE"]
         storage_root = ENV["DELTACLOUD_MOCK_STORAGE"]
-      elsif ENV["USER"]
+      elsif Etc.getlogin
         storage_root = File::join("/var/tmp", "deltacloud-mock-#{ENV["USER"]}")
       else
         raise "Please set either the DELTACLOUD_MOCK_STORAGE or USER environment variable"
@@ -195,8 +196,8 @@ module Deltacloud::Drivers::Mock
         :keyname => opts[:keyname],
         :image_id=>image_id,
         :owner_id=>credentials.user,
-        :public_addresses=>["#{image_id}.#{next_id}.public.com"],
-        :private_addresses=>["#{image_id}.#{next_id}.private.com"],
+        :public_addresses=>[ InstanceAddress.new("#{image_id}.#{next_id}.public.com", :type => :hostname) ],
+        :private_addresses=>[ InstanceAddress.new("#{image_id}.#{next_id}.private.com", :type => :hostname) ],
         :instance_profile => InstanceProfile.new(hwp.name, opts),
         :realm_id=>realm_id,
         :create_image=>true,
@@ -236,7 +237,6 @@ module Deltacloud::Drivers::Mock
     #
     # Storage Volumes
     #
-
     def storage_volumes(credentials, opts=nil)
       check_credentials( credentials )
       volumes = @client.build_all(StorageVolume)
@@ -244,6 +244,36 @@ module Deltacloud::Drivers::Mock
       volumes
     end
 
+    def create_storage_volume(credentials, opts=nil)
+      check_credentials(credentials)
+      opts ||= {}
+      opts[:capacity] ||= "1"
+      volume = {
+            :id => "Volume#{Time.now.to_i}",
+            :created => Time.now.to_s,
+            :state => "AVAILABLE",
+            :capacity => opts[:capacity],
+      }
+      @client.store(:storage_volumes, volume)
+      StorageVolume.new(volume)
+    end
+
+    def destroy_storage_volume(credentials, opts=nil)
+      check_credentials(credentials)
+      @client.destroy(:storage_volumes, opts[:id])
+    end
+
+    #opts: {:id=,:instance_id,:device}
+    def attach_storage_volume(credentials, opts)
+      check_credentials(credentials)
+      attach_volume_instance(opts[:id], opts[:device], opts[:instance_id])
+    end
+
+    def detach_storage_volume(credentials, opts)
+      check_credentials(credentials)
+      detach_volume_instance(opts[:id], opts[:instance_id])
+    end
+
     #
     # Storage Snapshots
     #
@@ -410,6 +440,17 @@ module Deltacloud::Drivers::Mock
       return false
     end
 
+    def networks(credentials, opts={})
+      check_credentials(credentials)
+      if opts[:id].nil?
+        networks = @client.load_all_cimi(:network).map{|net| CIMI::Model::Network.from_json(net)}
+        networks.map{|net|convert_cimi_network(net,opts[:env])}.flatten
+      else
+        network = CIMI::Model::Network.from_json(@client.load_cimi(:network, opts[:id]))
+        convert_cimi_network(network, opts[:env])
+      end
+    end
+
     private
 
     def check_credentials(credentials)
@@ -420,6 +461,39 @@ module Deltacloud::Drivers::Mock
       end
     end
 
+    def attach_volume_instance(volume_id, device, instance_id)
+      volume = @client.load(:storage_volumes, volume_id)
+      instance = @client.load(:instances, instance_id)
+      volume[:instance_id] = instance_id
+      volume[:device] = device
+      volume[:state] = "IN-USE"
+      instance[:storage_volumes] ||= []
+      instance[:storage_volumes] << {volume_id=>device}
+      @client.store(:storage_volumes, volume)
+      @client.store(:instances, instance)
+      StorageVolume.new(volume)
+    end
+
+    def detach_volume_instance(volume_id, instance_id)
+      volume = @client.load(:storage_volumes, volume_id)
+      instance = @client.load(:instances, instance_id)
+      volume[:instance_id] = nil
+      device = volume[:device]
+      volume[:device] = nil
+      volume[:state] = "AVAILABLE"
+      instance[:storage_volumes].delete({volume_id => device}) unless instance[:storage_volumes].nil?
+      @client.store(:storage_volumes, volume)
+      @client.store(:instances, instance)
+      StorageVolume.new(volume)
+    end
+
+    def convert_cimi_network(network, context)
+      uri=context.network_url(network.name)
+      network.uri=uri
+      network.operations.each{|op| op.href=uri}
+      network
+    end
+
     exceptions do
 
       on /AuthFailure/ do

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

@@ -190,7 +190,7 @@ class OpennebulaDriver < Deltacloud::BaseDriver
 
 	networks = []
 	(computehash['NETWORK'].each do |n|
-		networks << n.attributes['ip']
+		networks << InstanceAddress.new(n.attributes['ip'])
 	end) unless computehash['NETWORK'].nil?
 
 	Instance.new( {

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

@@ -0,0 +1,47 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
+require 'deltacloud/drivers/rackspace/rackspace_driver.rb'
+module Deltacloud
+  module Drivers
+    module Openstack
+      class OpenstackDriver < Rackspace::RackspaceDriver
+
+        feature :instances, :user_name
+        feature :instances, :authentication_password
+        feature :instances, :user_files
+
+        define_instance_states do
+          start.to( :pending )          .on( :create )
+          pending.to( :running )        .automatically
+          running.to( :running )        .on( :reboot )
+          running.to( :shutting_down )  .on( :stop )
+          shutting_down.to( :stopped )  .automatically
+          stopped.to( :finish )         .automatically
+        end
+
+        def new_client(credentials)
+          safely do
+            CloudServers::Connection.new(:username => credentials.user, :api_key => credentials.password, :auth_url => api_provider)
+          end
+        end
+
+        private :new_client
+      end
+    end
+  end
+end
+

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

@@ -356,8 +356,7 @@ class RackspaceDriver < Deltacloud::BaseDriver
     return http, request
   end
 
-private
-
+  private
 
   def new_client(credentials)
     safely do
@@ -366,10 +365,11 @@ private
   end
 
   def convert_container(cf_container)
+    blob_list=cf_container.objects
     Bucket.new({ :id => cf_container.name,
                     :name => cf_container.name,
-                    :size => cf_container.count,
-                    :blob_list => cf_container.objects
+                    :size => blob_list.size,
+                    :blob_list => blob_list
                  })
   end
 
@@ -394,8 +394,8 @@ private
       :architecture => 'x86_64',
       :image_id => server.imageId.to_s,
       :instance_profile => InstanceProfile::new(server.flavorId.to_s),
-      :public_addresses => server.addresses[:public],
-      :private_addresses => server.addresses[:private],
+      :public_addresses => server.addresses[:public].collect { |ip| InstanceAddress.new(ip) },
+      :private_addresses => server.addresses[:private].collect { |ip| InstanceAddress.new(ip) },
       :username => 'root',
       :password => password ? password : nil
     )
@@ -415,8 +415,8 @@ private
       :architecture => 'x86_64',
       :image_id => server[:imageId].to_s,
       :instance_profile => InstanceProfile::new(server[:flavorId].to_s),
-      :public_addresses => server[:addresses][:public],
-      :private_addresses => server[:addresses][:private]
+      :public_addresses => server[:addresses][:public].collect { |ip| InstanceAddress.new(ip) },
+      :private_addresses => server[:addresses][:private].collect { |ip| InstanceAddress.new(ip) }
     )
     inst.create_image = 'RUNNING'.eql?(inst.state)
     inst.actions = instance_actions_for(inst.state)

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

@@ -15,7 +15,6 @@
 #
 
 require 'rubygems'
-require 'base64'
 require 'restclient'
 require 'nokogiri'
 require 'digest/md5'
@@ -45,10 +44,11 @@ module RHEVM
 
   class Client
 
-    attr_reader :credentials, :api_entrypoint
+    attr_reader :credentials, :api_entrypoint, :datacenter_id
 
-    def initialize(username, password, api_entrypoint)
+    def initialize(username, password, api_entrypoint, datacenter_id=nil)
       @credentials = { :username => username, :password => password }
+      @datacenter_id = datacenter_id
       @api_entrypoint = api_entrypoint
     end
 
@@ -59,24 +59,37 @@ module RHEVM
       headers.merge!(auth_header)
       if opts[:id]
         vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/vms/%s" % opts[:id]].get(headers)).root
+        return [] unless current_datacenter.cluster_ids.include?((vm/'cluster').first[:id])
         [ RHEVM::VM::new(self, vm)]
       else
         Client::parse_response(RHEVM::client(@api_entrypoint)["/vms"].get(headers)).xpath('/vms/vm').collect do |vm|
+          next unless current_datacenter.cluster_ids.include?((vm/'cluster').first[:id])
           RHEVM::VM::new(self, vm)
-        end
+        end.compact
       end
     end
 
     def vm_action(id, action, headers={})
       headers.merge!(auth_header)
-      headers.merge!({
-        :content_type => 'application/xml',
-        :accept => 'application/xml',
-      })
+      headers.merge!({:accept => 'application/xml'})
+      vm = vms(:id => id)
+      raise RHEVMBackendException::new("Requested VM not found in datacenter #{self.current_datacenter.id}") if vm.empty?
       if action==:delete
         RHEVM::client(@api_entrypoint)["/vms/%s" % id].delete(headers)
       else
-        xml_response = Client::parse_response(RHEVM::client(@api_entrypoint)["/vms/%s/%s" % [id, action]].post('<action/>', headers))
+        headers.merge!({ :content_type => 'application/xml' })
+        begin
+          client_response = RHEVM::client(@api_entrypoint)["/vms/%s/%s" % [id, action]].post('<action/>', headers)
+        rescue
+          if $!.is_a?(RestClient::BadRequest)
+            fault = (Nokogiri::XML($!.http_body)/'//fault/detail')
+            fault = fault.text.gsub(/\[|\]/, '') if fault
+          end
+          fault ||= $!.message
+          raise RHEVMBackendException::new(fault)
+        end
+        xml_response = Client::parse_response(client_response)
+
         return false if (xml_response/'action/status').first.text.strip.upcase!="COMPLETE"
       end
       return true
@@ -89,7 +102,11 @@ module RHEVM
       }
       headers.merge!(auth_header)
       result_xml = Nokogiri::XML(RHEVM::client(@api_entrypoint)["/"].get(headers))
-      (result_xml/'/api/system_version').first[:major].strip == major
+      if (result_xml/'api/system_version').empty?
+        (result_xml/'/api/product_info/version').first[:major].strip == major
+      else
+        (result_xml/'/api/system_version').first[:major].strip == major
+      end
     end
 
     def cluster_version?(cluster_id, major)
@@ -102,13 +119,25 @@ module RHEVM
       (result_xml/'/cluster/version').first[:major].strip == major
     end
 
+    def capability?(name)
+      headers = {
+        :content_type => 'application/xml',
+        :accept => 'application/xml'
+      }
+      headers.merge!(auth_header)
+      result_xml = Nokogiri::XML(RHEVM::client(@api_entrypoint)["/capabilities"].get(headers))
+      !(result_xml/"/capabilities/version/custom_properties/custom_property[@name='#{name}']").empty?
+    end
+
     def create_vm(template_id, opts={})
       opts ||= {}
+      templ = template(template_id)
+      raise RHEVMBackendException::new("Requested VM not found in datacenter #{self.current_datacenter.id}") unless templ
       builder = Nokogiri::XML::Builder.new do
         vm {
           name opts[:name] || "i-#{Time.now.to_i}"
           template_(:id => template_id)
-          cluster(:id => opts[:realm_id] || clusters.first.id)
+          cluster_(:id => opts[:realm_id].nil? ? templ.cluster.id : opts[:realm_id])
           type_ opts[:hwp_id] || 'desktop'
           memory opts[:hwp_memory] ? (opts[:hwp_memory].to_i*1024*1024).to_s : (512*1024*1024).to_s
           cpu {
@@ -116,15 +145,11 @@ module RHEVM
           }
           if opts[:user_data] and not opts[:user_data].empty?
             if api_version?('3') and cluster_version?((opts[:realm_id] || clusters.first.id), '3')
+              raise "Required VDSM hook 'floppyinject' not supported by RHEV-M" unless capability?(:floppyinject)
               custom_properties {
-                #
-                # FIXME: 'regexp' parameter is just a temporary workaround. This
-                # is a reported and verified bug and should be fixed in next
-                # RHEV-M release.
-                #
                 custom_property({
                   :name => "floppyinject",
-                  :value => "#{RHEVM::FILEINJECT_PATH}:#{Base64.decode64(opts[:user_data])}",
+                  :value => "#{RHEVM::FILEINJECT_PATH}:#{opts[:user_data]}",
                   :regexp => "^([^:]+):(.*)$"})
               }
             else
@@ -138,6 +163,8 @@ module RHEVM
         :content_type => 'application/xml',
         :accept => 'application/xml',
       })
+      templates = templates(:id => template_id)
+      raise RHEVMBackendException::new("Requested VM not found in datacenter #{self.current_datacenter.id}") if templates.empty?
       headers.merge!(auth_header)
       begin
         vm = RHEVM::client(@api_entrypoint)["/vms"].post(Nokogiri::XML(builder.to_xml).root.to_s, headers)
@@ -176,6 +203,8 @@ module RHEVM
         :content_type => 'application/xml',
         :accept => 'application/xml',
       })
+      tmpl = template(id)
+      raise RHEVMBackendException::new("Requested VM not found in datacenter #{self.current_datacenter.id}") unless tmpl
       headers.merge!(auth_header)
       RHEVM::client(@api_entrypoint)["/templates/%s" % id].delete(headers)
       return true
@@ -186,29 +215,20 @@ module RHEVM
         :accept => "application/xml"
       }
       headers.merge!(auth_header)
-      if opts[:id]
-        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/templates/%s" % opts[:id]].get(headers)).root
-        [ RHEVM::Template::new(self, vm)]
-      else
-        Client::parse_response(RHEVM::client(@api_entrypoint)["/templates"].get(headers)).xpath('/templates/template').collect do |vm|
-          RHEVM::Template::new(self, vm)
-        end
-      end
+      rhevm_templates = RHEVM::client(@api_entrypoint)["/templates"].get(headers)
+      Client::parse_response(rhevm_templates).xpath('/templates/template').collect do |t|
+        next unless current_datacenter.cluster_ids.include?((t/'cluster').first[:id])
+        RHEVM::Template::new(self, t)
+      end.compact
     end
 
-    def clusters(opts={})
+    def template(template_id)
       headers = {
-        :accept => "application/xml; detail=datacenters"
+        :accept => "application/xml"
       }
       headers.merge!(auth_header)
-      if opts[:id]
-        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/clusters/%s" % opts[:id]].get(headers)).root
-        [ RHEVM::Cluster::new(self, vm)]
-      else
-        Client::parse_response(RHEVM::client(@api_entrypoint)["/clusters"].get(headers)).xpath('/clusters/cluster').collect do |vm|
-          RHEVM::Cluster::new(self, vm) if has_datacenter?(vm)
-        end.compact
-      end
+      rhevm_template = RHEVM::client(@api_entrypoint)["/templates/%s" % template_id].get(headers)
+      RHEVM::Template::new(self, Client::parse_response(rhevm_template).root)
     end
 
     def datacenters(opts={})
@@ -216,16 +236,33 @@ module RHEVM
         :accept => "application/xml"
       }
       headers.merge!(auth_header)
-      if opts[:id]
-        vm = Client::parse_response(RHEVM::client(@api_entrypoint)["/datacenters/%s" % opts[:id]].get(headers)).root
-        [ RHEVM::DataCenter::new(self, vm)]
-      else
-        Client::parse_response(RHEVM::client(@api_entrypoint)["/datacenters"].get(headers)).xpath('/data_centers/data_center').collect do |vm|
-          RHEVM::DataCenter::new(self, vm)
-        end
+      rhevm_datacenters = RHEVM::client(@api_entrypoint)["/datacenters"].get(headers)
+      Client::parse_response(rhevm_datacenters).xpath('/data_centers/data_center').collect do |dc|
+        RHEVM::DataCenter::new(self, dc)
       end
     end
 
+    def clusters
+      current_datacenter.clusters
+    end
+
+    def cluster(cluster_id)
+      current_datacenter.cluster(cluster_id)
+    end
+
+    def current_datacenter
+      @current_datacenter ||= self.datacenter_id ? datacenter(self.datacenter_id) : datacenters.first
+    end
+
+    def datacenter(datacenter_id)
+      headers = {
+        :accept => "application/xml"
+      }
+      headers.merge!(auth_header)
+      rhevm_datacenter = RHEVM::client(@api_entrypoint)["/datacenters/%s" % datacenter_id].get(headers)
+      RHEVM::DataCenter::new(self, Client::parse_response(rhevm_datacenter).root)
+    end
+
     def hosts(opts={})
       headers = {
         :accept => "application/xml"
@@ -336,11 +373,11 @@ module RHEVM
       @storage = ((xml/'disks/disk/size').first.text rescue nil)
       @macs = (xml/'nics/nic/mac').collect { |mac| mac[:address] }
       @creation_time = (xml/'creation_time').text
-      @ip = ((xml/'guest_info/ip').first[:address] rescue nil)
-      unless @ip
-        @vnc = ((xml/'display/address').first.text rescue "127.0.0.1")
-        @vnc += ":#{((xml/'display/port').first.text rescue "5890")}"
-      end
+      @ip = ((xml/'guest_info/ips/ip').first[:address] rescue nil)
+      @vnc = {
+        :address => ((xml/'display/address').first.text rescue "127.0.0.1"),
+        :port => ((xml/'display/port').first.text rescue "5890")
+      } unless @ip
     end
 
   end
@@ -364,7 +401,7 @@ module RHEVM
   end
 
   class Cluster < BaseObject
-    attr_reader :description, :datacenter
+    attr_reader :description, :datacenter, :version
 
     def initialize(client, xml)
       super(client, xml[:id], xml[:href], (xml/'name').first.text)
@@ -376,7 +413,10 @@ module RHEVM
 
     def parse_xml_attributes!(xml)
       @description = ((xml/'description').first.text rescue nil)
-      @datacenter = Link::new(@client, (xml/'data_center').first[:id], (xml/'data_center').first[:href])
+      @version =((xml/'version').first[:major].strip rescue nil)
+      unless (xml/'data_center').empty?
+        @datacenter = Link::new(@client, (xml/'data_center').first[:id], (xml/'data_center').first[:href])
+      end
     end
 
   end
@@ -390,6 +430,39 @@ module RHEVM
       self
     end
 
+    def clusters
+      headers = {
+        :accept => "application/xml; detail=datacenters"
+      }
+      headers.merge!(client.auth_header)
+      clusters_list = RHEVM::client(client.api_entrypoint)["/clusters"].get(headers)
+      cluster_arr = Client::parse_response(clusters_list).xpath('/clusters/cluster')
+      clusters_arr = []
+      cluster_arr.each do |cluster|
+        cluster = RHEVM::Cluster.new(self.client, cluster)
+        clusters_arr << cluster if cluster.datacenter && cluster.datacenter.id == client.datacenter_id
+      end
+      clusters_arr
+    end
+
+    def cluster(cluster_id)
+      headers = {
+        :accept => "application/xml; detail=datacenters"
+      }
+      headers.merge!(client.auth_header)
+      cluster_xml = RHEVM::client(client.api_entrypoint)["/clusters/%s" % cluster_id].get(headers)
+      cluster = RHEVM::Cluster.new(self.client, cluster_xml)
+      if cluster.datacenter && cluster.datacenter.id == client.datacenter_id
+        cluster
+      else
+        nil
+      end
+    end
+
+    def cluster_ids
+      @cluster_ids ||= clusters.collect { |c| c.id }
+    end
+
     private
 
     def parse_xml_attributes!(xml)