fog-xenserver 0.0.1.alpha

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

@@ -0,0 +1,18 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+      class Vtpm < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/api/?c=VTPM
+
+        identity :reference
+
+        attribute :__backend,       :aliases => :backend
+        attribute :uuid
+        attribute :__vm,            :aliases => :vm
+      end
+    end
+  end
+end

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

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

data/lib/fog/xenserver/parser.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Parsers
+    module XenServer
+      class Base
+
+        attr_reader :response
+
+        def initialize
+          reset
+        end
+
+        def reset
+          @response = {}
+        end
+
+        def parse( data )
+          if data.kind_of? Hash
+            @response = data.symbolize_keys!
+            @response.each do |k,v|
+              if @response[k] == "OpaqueRef:NULL"
+                @response[k] = nil
+              end
+            end
+          elsif data.kind_of? Array
+            @response = data.first
+          elsif data.kind_of?(String) and data =~ /OpaqueRef:/
+            @response = data
+          end
+
+          @response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_hosts.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module XenServer
+      class GetHosts < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, host_hash| @response << parser.parse( host_hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_networks.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module XenServer
+      class GetNetworks < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, network_hash| @response << parser.parse( network_hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_pools.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module XenServer
+      class GetPools < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, pool_hash| @response << parser.parse( pool_hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_records.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module XenServer
+      class GetRecords < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, hash| @response << parser.parse( hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_storage_repositories.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module XenServer
+      class GetStorageRepositories < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, sr_hash| @response << parser.parse( sr_hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_vbds.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module XenServer
+      class GetVBDs < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, hash| @response << parser.parse( hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_vifs.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Parsers
+    module XenServer
+      class GetVIFs < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, vif_hash| @response << parser.parse( vif_hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/xenserver/parsers/get_vms.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Parsers
+    module XenServer
+
+      class GetVms < Fog::Parsers::XenServer::Base
+
+        def reset
+          @response = []
+        end
+
+        def parse( data )
+          parser = Fog::Parsers::XenServer::Base.new
+          data.each_pair {|reference, vm_hash| @response << parser.parse( vm_hash ).merge(:reference => reference) }
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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
+          )
+        end
+
+      end
+
+      class Mock
+
+        def clone_server( server_name, template_ref )
+          Fog::Mock.not_implemented
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+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
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Fog
+  module Compute
+    class XenServer
+      class Real
+
+        def get_vm_by_name(label)
+          @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.get_by_name_label' }, label)
+        end
+
+        def get_vm_by_uuid(uuid)
+          @connection.request({:parser => Fog::Parsers::XenServer::Base.new, :method => 'VM.get_by_uuid' }, uuid)
+        end
+
+        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
+        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
+
+      end
+
+    end
+  end
+end