fog-xenserver 0.0.1.beta1 → 0.0.1.beta2

data/lib/fog/compute/xen_server/requests/assert_operation_valid_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def assert_operation_valid_server(ref, op)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.assert_operation_valid' }, ref, op)
+        end
+
+        alias_method :assert_operation_valid_vm, :assert_operation_valid_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/assert_supports_database_replication_sr.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def assert_supports_database_replication_sr(ref)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'SR.assert_supports_database_replication' }, ref)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/backup_rrds_host.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def backup_rrds_host(ref, delay)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'host.backup_rrds' }, ref, delay)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/bugreport_upload_host.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def bugreport_upload_host(ref, url, options)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'host.bugreport_upload' }, ref, url, options)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/builtin_templates.rb

@@ -4,18 +4,12 @@ module Fog
       class Real
         def builtin_templates
           data = @connection.request(:parser => Fog::Parsers::XenServer::GetRecords.new, :method => "VM.get_all_records")
-          data.keep_if { |vm| vm[:is_a_template] && !vm[:other_config]['default_template'].nil? }
+          data.delete_if { |vm| !vm[:is_a_template] || vm[:other_config]['default_template'].nil? }
           servers.load(data)
         rescue Fog::XenServer::RequestFailed => e
           []
         end
       end
-
-      class Mock
-        def builtin_templates
-          Fog::Mock.not_implemented
-        end
-      end
     end
   end
 end

data/lib/fog/compute/xen_server/requests/call_plugin_host.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def call_plugin_host(ref, plugin, fn, args)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'host.call_plugin' }, ref, plugin, fn, args)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/certificate_install_pool.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def certificate_install_pool(name, cert)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'pool.certificate_install' }, name, cert)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/certificate_list_pool.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def certificate_list_pool
+          @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => 'pool.certificate_list')
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/certificate_sync_pool.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def certificate_sync_pool
+          @connection.request(:parser => Fog::Parsers::XenServer::Base.new, :method => 'pool.certificate_sync')
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/certificate_uninstall_pool.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def certificate_uninstall_pool(string)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'pool.certificate_uninstall' }, string)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/checkpoint_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def checkpoint_server(ref, new_name)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.checkpoint' }, ref, new_name)
+        end
+
+        alias_method :checkpoint_vm, :checkpoint_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/clean_reboot_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def clean_reboot_server(ref)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.clean_reboot' }, ref)
+        end
+
+        alias_method :clean_reboot_vm, :clean_reboot_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/clean_shutdown_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def clean_shutdown_server(ref)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.clean_shutdown' }, ref)
+        end
+
+        alias_method :clean_shutdown_vm, :clean_shutdown_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/clone_server.rb

@@ -2,26 +2,12 @@ module Fog
   module Compute
     class XenServer
       class Real
-        def clone_server( server_name, template_ref )
-          # Clone the VM template
-          if template_ref.kind_of? Fog::Compute::XenServer::Server
-            template_ref = template_ref.reference
-          end
-          raise ArgumentError.new("Invalid template_ref") if template_ref.nil?
-          raise ArgumentError.new("Invalid template_ref") if server_name.nil?
-
-          ref = @connection.request(
-            {:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.clone'},
-            template_ref, server_name
-          )
+        def clone_server(ref, new_name)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.clone' }, ref, new_name)
         end
-      end
 
-      class Mock
-        def clone_server( server_name, template_ref )
-          Fog::Mock.not_implemented
-        end
+        alias_method :clone_vm, :clone_server
       end
     end
   end
-end
+end

data/lib/fog/compute/xen_server/requests/clone_vdi.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def clone_vdi(ref, driver_params)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VDI.clone' }, ref, driver_params)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/compute_free_memory_host.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def compute_free_memory_host(ref)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'host.compute_free_memory' }, ref)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/compute_memory_overhead_host.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def compute_memory_overhead_host(ref)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'host.compute_memory_overhead' }, ref)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/compute_memory_overhead_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def compute_memory_overhead_server(ref)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.compute_memory_overhead' }, ref)
+        end
+
+        alias_method :compute_memory_overhead_vm, :compute_memory_overhead_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/copy_bios_strings_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def copy_bios_strings_server(ref, host)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.copy_bios_strings' }, ref, host)
+        end
+
+        alias_method :copy_bios_strings_vm, :copy_bios_strings_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/copy_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def copy_server(ref, name, sr)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.copy' }, ref, name, sr)
+        end
+
+        alias_method :copy_vm, :copy_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/copy_vdi.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def copy_vdi(ref, sr)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VDI.copy' }, ref, sr)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/create_network.rb

@@ -2,34 +2,8 @@ module Fog
   module Compute
     class XenServer
       class Real
-        # Create a Network
-        #
-        # @see http://docs.vmd.citrix.com/XenServer/6.0.0/1.0/en_gb/api/?c=network
-        #
-        def create_network( name, config = {} )
-          config.reject! { |k,v| v.nil? }
-
-          default_config = {
-            :name_label => name,
-            # Description is mandatory in XenAPI but we default to empty
-            :name_description => config[:description] || '',
-            # Mandatory, but can be empty
-            :other_config => {}
-          }.merge config
-
-          @connection.request(
-            {
-              :parser => Fog::Parsers::XenServer::Base.new,
-              :method => 'network.create'
-            },
-            default_config
-          )
-        end
-      end
-
-      class Mock
-        def create_network( name, description = '', config = {} )
-          Fog::Mock.not_implemented
+        def create_network(config = {}, extra_params = {})
+          @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'network.create' }, config)
         end
       end
     end

data/lib/fog/compute/xen_server/requests/create_new_blob_host.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def create_new_blob_host(ref, name, mime_type, public)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'host.create_new_blob' }, ref, name, mime_type, public)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/create_new_blob_network.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def create_new_blob_network(ref, name, mime_type, public)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'network.create_new_blob' }, ref, name, mime_type, public)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/create_new_blob_pool.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def create_new_blob_pool(ref, name, mime_type, public)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'pool.create_new_blob' }, ref, name, mime_type, public)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/create_new_blob_server.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def create_new_blob_server(ref, name, mime_type, public)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.create_new_blob' }, ref, name, mime_type, public)
+        end
+
+        alias_method :create_new_blob_vm, :create_new_blob_server
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/create_new_blob_sr.rb

@@ -0,0 +1,11 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+        def create_new_blob_sr(ref, name, mime_type, public)
+          @connection.request({ :parser => Fog::Parsers::XenServer::Base.new, :method => 'SR.create_new_blob' }, ref, name, mime_type, public)
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/xen_server/requests/create_server.rb

@@ -2,115 +2,11 @@ module Fog
   module Compute
     class XenServer
       class Real
-        def create_server_raw(config = {})
-          config[:name_label] = config[:name] if config[:name]
-          config.delete :name
-          config[:affinity] = config[:__affinity] if config[:__affinity]
-          config.delete :__affinity
-          raise ArgumentError.new("Invalid :name_label attribute") \
-            if !config[:name_label]
-          raise ArgumentError.new("Invalid :affinity attribute") \
-            if not config[:affinity]
-          config[:affinity] = config[:affinity].reference \
-            if config[:affinity].kind_of? Fog::Compute::XenServer::Host
-          config.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
-          %w{ VCPUs_at_startup
-              VCPUs_max
-              VCPUs_params
-              PV_bootloader_args
-              PV_bootloader
-              PV_kernel
-              PV_ramdisk
-              PV_legacy_args
-              HVM_boot_policy
-              HVM_boot_params
-          }.each do |k|
-            if config[k.downcase.to_sym]
-              config[k.to_sym] = config[k.downcase.to_sym]
-              config.delete k.downcase.to_sym
-            end
-          end
-          vm_record = {
-            :name_label =>              '',
-            :name_description =>        'description',
-            :user_version =>            '0',
-            :affinity =>                '',
-            :is_a_template =>           true,
-            :auto_power_on =>           false,
-            :memory_static_max =>       '536870912',
-            :memory_static_min =>       '536870912',
-            :memory_dynamic_max =>      '536870912',
-            :memory_dynamic_min =>      '536870912',
-            :VCPUs_params =>            {},
-            :VCPUs_max =>               '1',
-            :VCPUs_at_startup =>        '1',
-            :actions_after_shutdown =>  'Destroy',
-            :actions_after_reboot =>    'Restart',
-            :actions_after_crash =>     'Restart',
-            :platform =>                { 'nx' => false, 'acpi' => true, 'apic' => 'true', 'pae' => true, 'viridian' => true},
-            :platform =>                {},
-            :other_config =>            {},
-            :pool_name =>               '',
-            :PV_bootloader =>           'pygrub', #pvgrub, eliloader
-            :PV_kernel =>                '',
-            :PV_ramdisk =>              '',
-            :PV_args =>                 '-- quiet console=hvc0',
-            :PV_bootloader_args =>      '',
-            :PV_legacy_args =>          '',
-            :HVM_boot_policy =>         '',
-            :HVM_boot_params =>         {},
-            :PCI_bus =>                 '',
-            :recommendations =>         '',
-          }.merge config
-          ref = @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.create' }, vm_record)
-          ref
+        def create_server(config = {}, extra_params = {})
+          @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.create' }, config)
         end
 
-        def create_server( name_label, template = nil, networks = [], extra_args = {})
-          if !networks.kind_of? Array
-            raise "Invalid networks argument"
-          end
-
-          if template.kind_of? String
-            template_string = template
-            # try template by UUID
-            template = servers.templates.find { |s| s.uuid == template_string }
-            if template.nil?
-              # Try with the template name just in case
-              template = servers.get get_vm_by_name(template_string)
-            end
-          end
-
-          if template.nil?
-            raise "Invalid template"
-          end
-
-          raise "Template #{template_string} does not exist" if template.allowed_operations.nil?
-          raise 'Clone Operation not Allowed' unless template.allowed_operations.include?('clone')
-
-          # Clone the VM template
-          ref = clone_server name_label, template.reference
-          # Add additional NICs
-          networks.each do |n|
-            create_vif ref, n.reference
-          end
-          if !extra_args[:auto_start] == false
-            @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.provision'}, ref)
-            start_vm( ref )
-          end
-
-          ref
-        end
-      end
-
-      class Mock
-        def create_server( name_label, template = nil, network = nil, extra_args = {})
-          Fog::Mock.not_implemented
-        end
-
-        def create_server_raw(config = {})
-          Fog::Mock.not_implemented
-        end
+        alias_method :create_vm, :create_server
       end
     end
   end