fog 1.1.2 → 1.2.0

data/lib/fog/libvirt/models/compute/servers.rb

@@ -44,7 +44,8 @@ module Fog
         end
 
         def get(uuid)
-          self.all(:uuid => uuid).first
+          vm = all(:uuid => uuid)
+          vm.first if vm
         end
 
         def bootstrap(new_attributes = {})

data/lib/fog/libvirt/models/compute/util.rb

@@ -9,7 +9,7 @@ module Fog
       # finds a value from xml
       def document path, attribute=nil
         return nil if new?
-        xml = REXML::Document.new(@xml_desc)
+        xml = REXML::Document.new(self.xml)
         attribute.nil? ? xml.elements[path].text : xml.elements[path].attributes[attribute]
       end
 
@@ -19,7 +19,6 @@ module Fog
         end
       end
 
-
     end
   end
 end

data/lib/fog/local/models/storage/file.rb

@@ -36,6 +36,13 @@ module Fog
           @directory
         end
 
+        def copy(target_directory_key, target_file_key, options={})
+          requires :directory, :key
+          connection.copy_object(directory.key, key, target_directory_key, target_file_key)
+          target_directory = connection.directories.new(:key => target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
         def destroy
           requires :directory, :key
           ::File.delete(path) if ::File.exists?(path)
@@ -50,7 +57,7 @@ module Fog
               break
             end
             pwd = Dir.pwd
-            if ::Dir.exists?(dir_path)
+            if ::File.exists?(dir_path) && ::File.directory?(dir_path)
               Dir.chdir(dir_path)
               if Dir.glob('*').empty?
                 Dir.rmdir(dir_path)

data/lib/fog/local/storage.rb

@@ -64,6 +64,14 @@ module Fog
         def path_to(partial)
           ::File.join(@local_root, partial)
         end
+
+        def copy_object(source_directory_name, source_object_name, target_directory_name, target_object_name, options={})
+          require 'fileutils'
+          source_path = path_to(::File.join(source_directory_name, source_object_name))
+          target_path = path_to(::File.join(target_directory_name, target_object_name))
+          ::FileUtils.mkdir_p(::File.dirname(source_path))
+          ::FileUtils.copy_file(source_path, target_path)
+        end
       end
 
     end

data/lib/fog/ninefold/models/storage/file.rb

@@ -28,6 +28,14 @@ module Fog
           @directory
         end
 
+        def copy(target_directory_key, target_file_key, options={})
+          target_directory = connection.directories.new(:key => target_directory_key)
+          target_directory.files.create(
+            :key => target_file_key,
+            :body => body
+          )
+        end
+
         def destroy
           requires :directory, :key
           connection.delete_namespace([directory.key, key].join('/'))

data/lib/fog/openstack.rb

@@ -79,12 +79,14 @@ module Fog
       @compute_service_name = options[:openstack_compute_service_name]
 
       req_body= {
-        'passwordCredentials'  => {
-          'username' => @openstack_username,
-          'password' => @openstack_api_key
+        'auth' => {
+          'passwordCredentials'  => {
+            'username' => @openstack_username,
+            'password' => @openstack_api_key
+          }
         }
       }
-      req_body['tenantId'] = @openstack_tenant if @openstack_tenant
+      req_body['auth']['tenantName'] = @openstack_tenant if @openstack_tenant
 
       response = connection.request({
         :expects  => [200, 204],
@@ -96,9 +98,9 @@ module Fog
       })
       body=MultiJson.decode(response.body)
      
-      if body['auth']['serviceCatalog'] and body['auth']['serviceCatalog'][@compute_service_name] and body['auth']['serviceCatalog'][@compute_service_name][0] then
-        mgmt_url = body['auth']['serviceCatalog'][@compute_service_name][0]['publicURL']
-        token = body['auth']['token']['id']
+      if svc = body['access']['serviceCatalog'].detect{|x| x['name'] == @compute_service_name}
+        mgmt_url = svc['endpoints'].detect{|x| x['publicURL']}['publicURL']
+        token = body['access']['token']['id']
         return {
           :token => token,
           :server_management_url => mgmt_url

data/lib/fog/openstack/compute.rb

@@ -186,8 +186,6 @@ module Fog
             raise Fog::Compute::OpenStack::ServiceUnavailable.new(
                     "OpenStack binding only supports version 1.1")
           end
-          # Add tenant
-          @path += @openstack_tenant if @openstack_tenant
           @port   = uri.port
           @scheme = uri.scheme
         end

data/lib/fog/ovirt.rb

@@ -0,0 +1,17 @@
+require 'fog/core'
+
+module Fog
+  module Ovirt
+
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error; end
+      class SecurityError < ServiceError; end
+      class NotFound < ServiceError; end
+    end
+
+    service(:compute, 'ovirt/compute', 'Compute')
+
+  end
+end

data/lib/fog/ovirt/compute.rb

@@ -0,0 +1,106 @@
+
+module Fog
+  module Compute
+    class Ovirt < Fog::Service
+
+      requires   :ovirt_username, :ovirt_password
+      recognizes :ovirt_url,      :ovirt_server,  :ovirt_port, :ovirt_api_path, :ovirt_datacenter
+
+      model_path 'fog/ovirt/models/compute'
+      model      :server
+      collection :servers
+      model      :template
+      collection :templates
+      model      :cluster
+      collection :clusters
+      model      :interface
+      collection :interfaces
+
+      request_path 'fog/ovirt/requests/compute'
+
+      request :vm_action
+      request :destroy_vm
+      request :create_vm
+      request :update_vm
+      request :datacenters
+      request :storage_domains
+      request :list_virtual_machines
+      request :get_virtual_machine
+      request :list_templates
+      request :get_template
+      request :list_clusters
+      request :get_cluster
+      request :add_interface
+      request :destroy_interface
+      request :update_interface
+      request :list_vm_interfaces
+      request :list_template_interfaces
+      request :list_networks
+
+      module Shared
+        # converts an OVIRT object into an hash for fog to consume.
+        def ovirt_attrs obj
+          opts = {:raw => obj}
+          obj.instance_variables.each do |v|
+            key = v.to_s.gsub("@","").to_sym
+            value = obj.instance_variable_get(v)
+            #ignore nil values
+            next if value.nil?
+
+            opts[key] = case value
+                        when OVIRT::Link
+                          value.id
+                        when Array
+                          value
+                        when Hash
+                          value
+                        else
+                          value.to_s.strip
+                        end
+          end
+          opts
+        end
+      end
+
+      class Mock
+        include Shared
+
+        def initialize(options={})
+          require 'rbovirt'
+          username = options[:ovirt_username]
+          password = options[:ovirt_password]
+          url      = options[:ovirt_url]
+        end
+
+        private
+        attr_reader :client
+        #read mocks xml
+        def read_xml(file_name)
+          file_path = File.join(File.dirname(__FILE__),"requests","compute","mock_files",file_name)
+          File.read(file_path)
+        end
+      end
+
+      class Real
+        include Shared
+
+
+        def initialize(options={})
+          require 'rbovirt'
+          username   = options[:ovirt_username]
+          password   = options[:ovirt_password]
+          server     = options[:ovirt_server]
+          port       = options[:ovirt_port]       || 8080
+          api_path   = options[:ovirt_api_path]   || '/api'
+          url        = options[:ovirt_url]        || "#{@scheme}://#{server}:#{port}#{api_path}"
+          datacenter = options[:ovirt_datacenter]
+
+          @client = OVIRT::Client.new(username, password, url, datacenter)
+        end
+
+        private
+        attr_reader :client
+      end
+    end
+  end
+end

data/lib/fog/ovirt/models/compute/cluster.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class Ovirt
+
+      class Cluster < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :raw
+
+        def networks
+          connection.list_networks(id)
+        end
+
+        def to_s
+          name
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/ovirt/models/compute/clusters.rb

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/ovirt/models/compute/cluster'
+
+module Fog
+  module Compute
+    class Ovirt
+
+      class Clusters < Fog::Collection
+
+        model Fog::Compute::Ovirt::Cluster
+
+        def all(filters = {})
+          load connection.list_clusters(filters)
+        end
+
+        def get(id)
+          new connection.get_cluster(id)
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ovirt/models/compute/interface.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class Ovirt
+
+      class Interface < Fog::Model
+        attr_accessor :raw
+        identity :id
+
+        attribute :name
+        attribute :network
+        attribute :interface
+        attribute :mac
+
+        def to_s
+          name
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/ovirt/models/compute/interfaces.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/ovirt/models/compute/interface'
+
+module Fog
+  module Compute
+    class Ovirt
+
+      class Interfaces < Fog::Collection
+
+        model Fog::Compute::Ovirt::Interface
+
+        attr_accessor :vm
+
+        def all(filters = {})
+          requires :vm
+          if vm.is_a? Fog::Compute::Ovirt::Server
+            load connection.list_vm_interfaces(vm.id)
+          elsif vm.is_a? Fog::Compute::Ovirt::Template
+            load connection.list_template_interfaces(vm.id)
+          else
+            raise 'interfaces should have vm or template'
+          end
+        end
+
+        def get(id)
+          new connection.get_interface(id)
+        end
+
+     end
+    end
+  end
+end

data/lib/fog/ovirt/models/compute/server.rb

@@ -0,0 +1,112 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Ovirt
+
+      class Server < Fog::Compute::Server
+
+        # This will be the instance uuid which is globally unique across
+        # a oVirt deployment.
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :profile
+        attribute :display
+        attribute :storage,       :aliases => 'disk_size'
+        attribute :creation_time
+        attribute :os
+        attribute :ip
+        attribute :status
+        attribute :cores,         :aliases => 'cpus'
+        attribute :memory
+        attribute :host
+        attribute :cluster
+        attribute :template
+        attribute :interfaces
+        attribute :raw
+
+        def ready?
+          !(status =~ /down/i)
+        end
+
+        def locked?
+          !!(status =~ /locked/i)
+        end
+
+        def stopped?
+          !!(status =~ /down/i)
+        end
+
+        def mac
+          interfaces.first.mac unless interfaces.empty?
+        end
+
+        def interfaces
+          attributes[:interfaces] ||= id.nil? ? [] : Fog::Compute::Ovirt::Interfaces.new(
+              :connection => connection,
+              :vm => self
+          )
+        end
+
+        def add_interface attrs
+          wait_for { stopped? } if attrs[:blocking]
+          connection.add_interface(id, attrs)
+        end
+
+        def update_interface attrs
+          wait_for { stopped? } if attrs[:blocking]
+          connection.update_interface(id, attrs)
+        end
+
+        def destroy_interface attrs
+          wait_for { stopped? } if attrs[:blocking]
+          connection.destroy_interface(id, attrs)
+        end
+
+        def start(options = {})
+          wait_for { stopped? } if options[:blocking]
+          connection.vm_action(:id =>id, :action => :start)
+          reload
+        end
+
+        def stop(options = {})
+          connection.vm_action(:id =>id, :action => :stop)
+          reload
+        end
+
+        def reboot(options = {})
+          stop unless stopped?
+          start options.merge(:blocking => true)
+        end
+
+        def suspend(options = {})
+          connection.vm_action(:id =>id, :action => :suspend)
+          reload
+        end
+
+        def destroy(options = {})
+          (stop unless stopped?) rescue nil #ignore failure, destroy the machine anyway.
+          wait_for { stopped? }
+          connection.destroy_vm(:id => id)
+        end
+
+        def save
+          if identity
+            connection.update_vm(attributes)
+          else
+            self.id = connection.create_vm(attributes).id
+          end
+          reload
+        end
+
+        def to_s
+          name
+        end
+
+      end
+
+    end
+  end
+end