gapinc-fog 1.12.1.2.1 → 1.14.0

data/lib/fog/vsphere/requests/compute/get_virtual_machine.rb

@@ -9,52 +9,34 @@ module Fog
         protected
 
         def get_vm_ref(id, dc = nil)
-          vm = case id
-                 # UUID based
-                 when /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
-                   @connection.searchIndex.FindByUuid :uuid => id, :vmSearch => true, :instanceUuid => true, :datacenter => dc
-                 else
-                   # try to find based on VM name
-                   if dc
-                     get_raw_datacenter(dc).find_vm(id)
-                   else
-                     raw_datacenters.map { |d| d.find_vm(id) }.compact.first
-                   end
-               end
+          raw_datacenter = find_raw_datacenter(dc) if dc
+          vm = case is_uuid?(id)
+            # UUID based
+            when true
+              params = {:uuid => id, :vmSearch => true, :instanceUuid => true}
+              params[:datacenter] = raw_datacenter if dc
+              @connection.searchIndex.FindByUuid(params)
+            else
+              # try to find based on VM name
+              if dc
+                raw_datacenter.find_vm(id)
+              else
+                raw_datacenters.map { |d| d.find_vm(id) }.compact.first
+              end
+          end
           vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
         end
       end
 
       class Mock
         def get_virtual_machine(id, datacenter_name = nil)
-          case id
-          when "5032c8a5-9c5e-ba7a-3804-832a03e16381", 'vm-715'
-            { :resource_pool    => "Resources",
-              :memory_mb        => 2196,
-              :power_state      => "poweredOn",
-              :mac_addresses    => { "Network adapter 1" => "00:50:56:b2:00:af" },
-              :hostname         => "centos56gm.localdomain",
-              :cpus             => 1,
-              :connection_state => "connected",
-              :mo_ref           => "vm-715",
-              :overall_status   => "green",
-              :datacenter       => "Solutions",
-              :instance_uuid    => "5029c440-85ee-c2a1-e9dd-b63e39364603",
-              :hypervisor       => "gunab.puppetlabs.lan",
-              :guest_id         => "rhel6_64Guest",
-              :cluster          => "virtlabcluster",
-              :tools_state      => "toolsOk",
-              :name             => "jefftest",
-              :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
-              :path             => "/",
-              :tools_version    => "guestToolsUnmanaged",
-              :ipaddress        => "192.168.100.187",
-              :id               => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
-              :uuid             => "42329da7-e8ab-29ec-1892-d6a4a964912a"
-            }
+          if is_uuid?(id)
+            vm = list_virtual_machines({ 'instance_uuid' => id, 'datacenter' => datacenter_name }).first
           else
-            raise Fog::Compute::Vsphere::NotFound
+            # try to find based on VM name. May need to handle the path of the VM
+            vm = list_virtual_machines({ 'name' => id, 'datacenter' => datacenter_name }).first
           end
+          vm ? vm : raise(Fog::Compute::Vsphere::NotFound, "#{id} was not found")
         end
 
       end

data/lib/fog/vsphere/requests/compute/list_datacenters.rb

@@ -15,6 +15,7 @@ module Fog
 
         protected
 
+        # RbVmomi::VIM::Datacenter Array
         def raw_datacenters
           @raw_datacenters ||= @connection.rootFolder.childEntity.grep(RbVmomi::VIM::Datacenter)
         end

data/lib/fog/vsphere/requests/compute/list_virtual_machines.rb

@@ -9,7 +9,7 @@ module Fog
 
           options[:folder] ||= options['folder']
           if options['instance_uuid'] then
-            [service.get_virtual_machine(options['instance_uuid'])]
+            [get_virtual_machine(options['instance_uuid'])]
           elsif options[:folder] && options[:datacenter] then
             list_all_virtual_machines_in_folder(options[:folder], options[:datacenter])
           else
@@ -61,119 +61,13 @@ module Fog
         end
 
         def list_virtual_machines(options = { })
-          case options['instance_uuid']
-            when nil
-
-              [
-                { :resource_pool    => "Resources",
-                  :memory_mb        => 2196,
-                  :mac_addresses    => { "Network adapter 1" => "00:50:56:a9:00:28" },
-                  :power_state      => "poweredOn",
-                  :cpus             => 1,
-                  :hostname         => "dhcp75-197.virt.bos.redhat.com",
-                  :mo_ref           => "vm-562",
-                  :connection_state => "connected",
-                  :overall_status   => "green",
-                  :datacenter       => "Solutions",
-                  :volumes          =>
-                    [{
-                       :id        => "6000C29c-a47d-4cd9-5249-c371de775f06",
-                       :datastore => "Storage1",
-                       :mode      => "persistent",
-                       :size      => 8388608,
-                       :thin      => true,
-                       :name      => "Hard disk 1",
-                       :filename  => "[Storage1] rhel6-mfojtik/rhel6-mfojtik.vmdk",
-                       :size_gb   => 8
-                     }],
-                  :interfaces       =>
-                    [{ :mac     => "00:50:56:a9:00:28",
-                       :network => "VM Network",
-                       :name    => "Network adapter 1",
-                       :status  => "ok",
-                       :summary => "VM Network",
-                     }],
-                  :hypervisor       => "gunab.puppetlabs.lan",
-                  :guest_id         => "rhel6_64Guest",
-                  :tools_state      => "toolsOk",
-                  :cluster          => "Solutionscluster",
-                  :name             => "rhel64",
-                  :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
-                  :uuid             => "4229f0e9-bfdc-d9a7-7bac-12070772e6dc",
-                  :path             => "/Datacenters/Solutions/vm",
-                  :id               => "5029c440-85ee-c2a1-e9dd-b63e39364603",
-                  :tools_version    => "guestToolsUnmanaged",
-                  :ipaddress        => "192.168.100.184",
-                },
-                { :resource_pool    => "Resources",
-                  :memory_mb        => 512,
-                  :power_state      => "poweredOn",
-                  :mac_addresses    => { "Network adapter 1" => "00:50:56:a9:00:00" },
-                  :hostname         => nil,
-                  :cpus             => 1,
-                  :connection_state => "connected",
-                  :mo_ref           => "vm-621",
-                  :overall_status   => "green",
-                  :datacenter       => "Solutions",
-                  :volumes          =>
-                    [{ :thin      => false,
-                       :size_gb   => 10,
-                       :datastore => "datastore1",
-                       :filename  => "[datastore1] i-1342439683/i-1342439683.vmdk",
-                       :size      => 10485762,
-                       :name      => "Hard disk 1",
-                       :mode      => "persistent",
-                       :id        => "6000C29b-f364-d073-8316-8e98ac0a0eae" }],
-                  :interfaces       =>
-                    [{  :summary => "VM Network",
-                       :mac     => "00:50:56:a9:00:00",
-                       :status  => "ok",
-                       :network => "VM Network",
-                       :name    => "Network adapter 1" }],
-                  :instance_uuid    => "502916a3-b42e-17c7-43ce-b3206e9524dc",
-                  :hypervisor       => "gunab.puppetlabs.lan",
-                  :guest_id         => nil,
-                  :cluster          => "Solutionscluster",
-                  :tools_state      => "toolsNotInstalled",
-                  :uuid             => "4229e0de-30cb-ceb2-21f9-4d8d8beabb52",
-                  :name             => "i-1342439683",
-                  :operatingsystem  => nil,
-                  :path             => "/",
-                  :tools_version    => "guestToolsNotInstalled",
-                  :id               => "502916a3-b42e-17c7-43ce-b3206e9524dc",
-                  :ipaddress        => nil }
-
-
-              ]
-            when '5032c8a5-9c5e-ba7a-3804-832a03e16381'
-              [{ :resource_pool    => "Resources",
-                 :memory_mb        => 2196,
-                 :power_state      => "poweredOn",
-                 :mac_addresses    => { "Network adapter 1" => "00:50:56:b2:00:af" },
-                 :hostname         => "centos56gm.localdomain",
-                 :cpus             => 1,
-                 :connection_state => "connected",
-                 :mo_ref           => "vm-715",
-                 :overall_status   => "green",
-                 :datacenter       => "Solutions",
-                 :instance_uuid    => "5029c440-85ee-c2a1-e9dd-b63e39364603",
-                 :hypervisor       => "gunab.puppetlabs.lan",
-                 :guest_id         => "rhel6_64Guest",
-                 :cluster          => "Solutionscluster",
-                 :tools_state      => "toolsOk",
-                 :name             => "jefftest",
-                 :operatingsystem  => "Red Hat Enterprise Linux 6 (64-bit)",
-                 :path             => "/",
-                 :tools_version    => "guestToolsUnmanaged",
-                 :ipaddress        => "192.168.100.187",
-                 :id               => "5032c8a5-9c5e-ba7a-3804-832a03e16381",
-                 :uuid             => "42329da7-e8ab-29ec-1892-d6a4a964912a"
-
-               }
-
-              ]
-            when 'does-not-exist-and-is-not-a-uuid', '50323f93-6835-1178-8b8f-9e2109890e1a'
-              []
+          if options['instance_uuid'].nil? and options['mo_ref'].nil?
+            self.data[:servers].values
+          elsif !options['instance_uuid'].nil?
+            server = self.data[:servers][options['instance_uuid']]
+            server.nil? ? [] : [server]
+          else
+            self.data[:servers].values.select{|vm| vm['mo_ref'] == options['mo_ref']}
           end
         end
       end

data/lib/fog/vsphere/requests/compute/vm_clone.rb

@@ -17,11 +17,8 @@ module Fog
           required_options.each do |param|
             raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
           end
-          # TODO This is ugly and needs to rethink mocks
-          unless Fog.mock?
-            raise ArgumentError, "#{options["datacenter"]} Doesn't Exist!" unless get_datacenter(options["datacenter"])
-            raise ArgumentError, "#{options["template_path"]} Doesn't Exist!" unless get_virtual_machine(options["template_path"], options["datacenter"])
-          end
+          raise Fog::Compute::Vsphere::NotFound, "Datacenter #{options["datacenter"]} Doesn't Exist!" unless get_datacenter(options["datacenter"])
+          raise Fog::Compute::Vsphere::NotFound, "Template #{options["template_path"]} Doesn't Exist!" unless get_virtual_machine(options["template_path"], options["datacenter"])
           options
         end
       end
@@ -291,12 +288,24 @@ module Fog
           # Option handling TODO Needs better method of checking
           options = vm_clone_check_options(options)
           notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
-          list_virtual_machines.find(notfound) do |vm|
-            vm[:name] == options['template_path'].split("/")[-1]
+          template = list_virtual_machines.find(notfound) do |vm|
+            vm['name'] == options['template_path'].split("/")[-1]
           end
+
+          # generate a random id
+          id = [8,4,4,4,12].map{|i| Fog::Mock.random_hex(i)}.join("-")
+          new_vm = template.clone.merge({
+            "name" => options['name'],
+            "id" => id,
+            "instance_uuid" => id,
+            "path" => "/Datacenters/#{options['datacenter']}/#{options['dest_folder'] ? options['dest_folder']+"/" : ""}#{options['name']}"
+          })
+          self.data[:servers][id] = new_vm
+
           {
-            'vm_ref'   => 'vm-123',
-            'task_ref' => 'task-1234',
+            'vm_ref'   => "vm-#{Fog::Mock.random_numbers(3)}",
+            'new_vm'   => new_vm,
+            'task_ref' => "task-#{Fog::Mock.random_numbers(4)}",
           }
         end
 

data/lib/fog/vsphere/requests/compute/vm_power_off.rb

@@ -29,6 +29,8 @@ module Fog
 
         def vm_power_off(options = {})
           raise ArgumentError, "instance_uuid is a required parameter" unless options.has_key? 'instance_uuid'
+          vm = get_virtual_machine(options['instance_uuid'])
+          vm["power_state"] = "poweredOff"
           {
             'task_state'     => "running",
             'power_off_type' => options['force'] ? 'cut_power' : 'shutdown_guest',

data/lib/fog/xenserver/compute.rb

@@ -2,17 +2,17 @@ require 'fog/xenserver'
 require 'fog/compute'
 
 module Fog
-  module Compute 
+  module Compute
     class XenServer < Fog::Service
 
       require 'fog/xenserver/utilities'
       require 'fog/xenserver/parser'
-      
+
       requires :xenserver_username
       requires :xenserver_password
       requires :xenserver_url
       recognizes :xenserver_defaults
-      
+
       model_path 'fog/xenserver/models/compute'
       model :server
       collection :servers
@@ -40,6 +40,8 @@ module Fog
       model  :host_cpu
       model  :vlan
       collection :vlans
+      model  :console
+      collection :consoles
 
       request_path 'fog/xenserver/requests/compute'
       request :create_server
@@ -76,9 +78,9 @@ module Fog
       request :destroy_vlan
       request :snapshot_server
       request :snapshot_revert
-    
+
       class Real
-        
+
         def initialize(options={})
           @host        = options[:xenserver_url]
           @username    = options[:xenserver_username]
@@ -91,7 +93,7 @@ module Fog
         def reload
           @connection.authenticate(@username, @password)
         end
-        
+
         def default_template=(name)
           @defaults[:template] = name
         end
@@ -102,13 +104,13 @@ module Fog
             (s.name == @defaults[:template]) or (s.uuid == @defaults[:template])
           end
         end
-        
+
         def default_network
           networks.find { |n| n.name == (@defaults[:network] || "Pool-wide network associated with eth0") }
         end
-        
+
       end
-      
+
       class Mock
 
         def self.data
@@ -116,13 +118,13 @@ module Fog
             hash[key] = {}
           end
         end
-        
+
         def self.reset_data(keys=data.keys)
           for key in [*keys]
             data.delete(key)
           end
         end
-        
+
         def initialize(options={})
           @host        = options[:xenserver_pool_master]
           @username    = options[:xenserver_username]
@@ -130,7 +132,7 @@ module Fog
           @connection  = Fog::Connection.new(@host)
           @connection.authenticate(@username, @password)
         end
-        
+
       end
     end
   end

data/lib/fog/xenserver/models/compute/console.rb

@@ -0,0 +1,27 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+      class Console < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=console
+
+        identity :reference
+        attribute :location
+        attribute :protocol
+        attribute :uuid
+        attribute :__vm, aliases: :VM
+
+        def vm
+          begin
+            vm = service.servers.get __vm
+          rescue Fog::XenServer::RequestFailed => e
+            vm = nil
+          end
+          vm
+        end
+      end
+    end
+  end
+end

data/lib/fog/xenserver/models/compute/consoles.rb

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/xenserver/models/compute/console'
+
+module Fog
+  module Compute
+    class XenServer
+      class Consoles < Fog::Collection
+        model Fog::Compute::XenServer::Console
+
+        def all(options={})
+          data = service.get_records 'console'
+          load(data)
+        end
+
+        def get( console_ref )
+          if console_ref && console = service.get_record( console_ref, 'console' )
+            new(console)
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module Fog
         attribute :name,                 :aliases => :name_label
         attribute :__affinity,           :aliases => :affinity
         attribute :allowed_operations
-        attribute :consoles
+        attribute :__consoles
         attribute :domarch
         attribute :domid
         attribute :tags
@@ -64,6 +64,10 @@ module Fog
           service.hosts.get __affinity
         end
 
+        def consoles
+          __consoles.collect {|console| service.consoles.get console }
+        end
+
         def destroy
           # Make sure it's halted
           stop('hard')
@@ -210,4 +214,4 @@ module Fog
 
     end
   end
-end
+end

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

@@ -48,6 +48,11 @@ module Fog
           get ref
         end
 
+        def get_by_uuid( uuid )
+          ref = service.get_vm_by_uuid( uuid )
+          get ref
+        end
+
         def get( vm_ref )
           if vm_ref && vm = service.get_record( vm_ref, 'VM' )
             new(vm)