fog-xenserver 0.0.1.alpha

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

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/xenserver/models/compute/vbd'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class Vbds < Fog::Collection
+
+        model Fog::Compute::XenServer::VBD
+
+        def initialize(attributes)
+          super
+        end
+
+        def all(options = {})
+          data = service.get_records 'VBD'
+          load(data)
+        end
+
+        def get( vbd_ref )
+          if vbd_ref && vbd = service.get_record( vbd_ref, 'VBD' )
+            new(vbd)
+          end
+        rescue Fog::XenServer::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class VDI < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/api/?c=VDI
+
+        identity :reference
+
+        attribute :uuid
+        attribute :is_a_snapshot
+        attribute :name,                        :aliases => :name_label
+        attribute :description,                 :aliases => :name_description
+        attribute :__parent,                    :aliases => :parent
+        attribute :virtual_size
+        attribute :__vbds,                      :aliases => :VBDs
+        attribute :__sr,                        :aliases => :SR
+        attribute :sharable
+        attribute :read_only
+        attribute :current_operations
+        attribute :allowed_operations
+        attribute :__crash_dumps,               :aliases => :crash_dumps
+        attribute :type
+        attribute :other_config
+        attribute :tags
+        attribute :storage_lock
+        attribute :physical_utilisation
+        attribute :missing
+        attribute :location
+        attribute :managed
+        attribute :metadata_latest
+        attribute :metadata_of_pool
+        attribute :allow_caching
+        attribute :on_boot
+        attribute :sm_config
+        attribute :snapshot_time
+        attribute :__snapshots,                 :aliases => :snapshots
+        attribute :__snapshot_of,               :aliases => :snapshot_of
+        attribute :xenstore_data
+
+        #
+        # Default VDI type is system
+        # Default size 8GB
+        # Sharable is false by default
+        # read_only is false by default
+        #
+        def initialize(attributes = {})
+          self.virtual_size ||= '8589934592' unless attributes[:virtual_size]
+          self.type ||= 'system' unless attributes[:type]
+          self.read_only ||= false unless attributes[:read_only]
+          self.sharable ||= false unless attributes[:sharable]
+          self.other_config ||= {} unless attributes[:other_config]
+          super
+        end
+
+        def set_attribute(name, *val)
+          data = service.set_attribute( 'VDI', reference, name, *val )
+        end
+
+        def snapshot_of
+          service.vdis.get __sr
+        end
+
+        def parent
+          service.vdis.get __parent
+        end
+
+        def snapshots
+          __snapshots.collect do |ref|
+            service.vdis.get ref
+          end
+        end
+
+        def vbds
+          __vbds.collect do |ref|
+            service.vbds.get ref
+          end
+        end
+
+        def save
+          requires :name, :storage_repository
+          ref = service.create_vdi attributes
+          merge_attributes service.vdis.get(ref).attributes
+        end
+
+        def destroy
+          service.destroy_vdi reference
+        end
+
+        def storage_repository
+          service.storage_repositories.get __sr
+        end
+
+        def sr
+          storage_repository
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/xenserver/models/compute/vdi'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class Vdis < Fog::Collection
+
+        model Fog::Compute::XenServer::VDI
+
+        def all(options = {})
+          data = service.get_records 'VDI'
+          load(data)
+        end
+
+        def get( vdi_ref )
+          if vdi_ref && vdi = service.get_record( vdi_ref, 'VDI' )
+            new(vdi)
+          end
+        rescue Fog::XenServer::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class VIF < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/api/?c=VIF
+
+        identity :reference
+
+        attribute :mac,                :aliases => :MAC
+        attribute :uuid
+        attribute :allowed_operations
+        attribute :current_operations
+        attribute :currently_attached
+        attribute :device
+        attribute :ipv4_allowed
+        attribute :ipv6_allowed
+        attribute :locking_mode
+        attribute :mac_autogenerated,  :aliases => :MAC_autogenerated
+        attribute :__metrics,          :aliases => :metrics
+        attribute :other_config
+        attribute :qos_algorithm_params
+        attribute :qos_algorithm_type
+        attribute :qos_supported_algorithms
+        attribute :runtime_properties
+        attribute :mtu,                :aliases => :MTU
+        attribute :__network,          :aliases => :network
+        attribute :status_code
+        attribute :status_detail
+        attribute :__vm,               :aliases => :VM
+
+
+        def destroy
+          service.destroy_vif reference
+        end
+
+        def network
+          service.networks.get __network
+        end
+
+        def server
+          service.servers.get __vm
+        end
+
+        def save
+          requires :server
+          raise ArgumentError.new('network is required for this operation') \
+            unless attributes[:__network]
+          ref = service.create_vif attributes[:server], attributes[:__network]
+          merge_attributes service.vifs.get(ref).attributes
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/xenserver/models/compute/vif'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class Vifs < Fog::Collection
+
+        model Fog::Compute::XenServer::VIF
+
+        def all(options = {})
+          data = service.get_records 'VIF'
+          load(data)
+        end
+
+        def get( ref )
+          if ref && obj = service.get_record( ref, 'VIF' )
+            new(obj)
+          end
+        rescue Fog::XenServer::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class VLAN < Fog::Model
+        # API Reference here:
+        # @see http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/api/?c=VLAN
+
+        identity :reference
+
+        attribute :uuid
+        attribute :tag,                :type => :integer
+        attribute :other_config
+        attribute :__untagged_pif,     :aliases => :untagged_PIF
+        attribute :__tagged_pif,       :aliases => :tagged_PIF
+
+        # @return [Fog::Compute::XenServer::PIF] interface on which traffic is tagged
+        #
+        # @see http://docs.vmd.citrix.com/XenServer/6.1.0/1.0/en_gb/api/?c=VLAN
+        #
+        def untagged_pif
+          service.pifs.get __untagged_pif
+        end
+
+        # @return [Fog::Compute::XenServer::PIF] interface on which traffic is untagged
+        #
+        # @see http://docs.vmd.citrix.com/XenServer/6.1.0/1.0/en_gb/api/?c=VLAN
+        #
+        def tagged_pif
+          service.pifs.get __tagged_pif
+        end
+
+        # Creates a new VLAN.
+        #
+        #     service = Fog::Compute[:xenserver]
+        #
+        #     # create a network 'foo-net'
+        #     net = service.networks.create :name => 'foo-net'
+        #
+        #     # get the eth0 physical interface where the
+        #     # VLAN subinterface will be added
+        #     pif = service.pifs.find { |p| p.device == 'eth0' and p.physical }
+        #
+        #     Fog::Compute[:xenserver].vlans.create :tag => 123,
+        #                                           :network => net,
+        #                                           :pif => pif
+        def save
+          requires :tag
+          pif = attributes[:pif]
+          net = attributes[:network]
+          unless pif and net
+            raise Fog::Error.new 'save requires :pif and :network attributes'
+          end
+          ref = service.create_vlan attributes[:pif].reference,
+                                    tag,
+                                    attributes[:network].reference
+          data = service.get_record ref, 'VLAN'
+          merge_attributes data
+          true
+        end
+
+        # Destroys a VLAN.
+        #
+        #     service = Fog::Compute[:xenserver]
+        #
+        #     # Find VLAN 123 and destroy it
+        #     (service.vlans.find { |v| v.tag == 123 }).destroy
+        #
+        def destroy
+          requires :reference
+          service.destroy_vlan reference
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/xenserver/models/compute/vlan'
+
+module Fog
+  module Compute
+    class XenServer
+
+      class Vlans < Fog::Collection
+
+        model Fog::Compute::XenServer::VLAN
+
+        # Return the list of VLANs available
+        #
+        # @return [Array] a list of Fog::Compute::XenServer::VLAN
+        #
+        def all(options = {})
+          data = service.get_records 'VLAN'
+          load(data)
+        end
+
+        # Retrieve a VLAN object by by reference.
+        #
+        # @return [Fog::Compute::XenServer::VLAN]
+        #
+        # Returns nil if not found
+        #
+        def get( ref )
+          if ref && obj = service.get_record( ref, 'VLAN' )
+            new(obj)
+          end
+        rescue Fog::XenServer::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class XenServer
+      class Vmpp < Fog::Model
+        # API Reference here:
+        # http://docs.vmd.citrix.com/XenServer/6.2.0/1.0/en_gb/api/?c=VMPP
+
+        identity :reference
+
+        attribute :alarm_config
+        attribute :archive_frequency
+        attribute :archive_last_run_time
+        attribute :archive_schedule
+        attribute :archive_target_config
+        attribute :archive_target_type
+        attribute :backup_frequency
+        attribute :backup_last_run_time
+        attribute :backup_retention_value
+        attribute :backup_schedule
+        attribute :backup_type
+        attribute :is_alarm_enabled
+        attribute :is_archive_running
+        attribute :is_backup_running
+        attribute :is_policy_enabled
+        attribute :description,         :aliases => :name_description
+        attribute :name,                :aliases => :name_label
+        attribute :recent_alerts
+        attribute :uuid
+        attribute :__vms,               :aliases => :VMs
+      end
+    end
+  end
+end

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

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