tecnh-fog 0.2.23.vpc

data/lib/fog/vcloud/bin.rb

@@ -0,0 +1,57 @@
+module Vcloud
+  class << self
+
+    def services
+      if Fog.credentials.has_key?(:vcloud)
+        Fog.credentials[:vcloud].keys.sort { |a,b| a.to_s <=> b.to_s }
+      else
+        []
+      end
+    end
+
+    def registered_services
+      Vcloud.services.map { |service| ":" << service.to_s }.join(", ")
+    end
+
+    def complete_service_options?(service)
+      if Fog.credentials.has_key?(:vcloud)
+        if Fog.credentials[:vcloud].has_key?(service)
+          service = Fog.credentials[:vcloud][service]
+          if Fog::Vcloud.requirements.all? { |option| service.has_key?(option) }
+            return true
+          end
+        end
+      end
+      false
+    end
+
+    if Vcloud.services.any? && Vcloud.services.all? { |service| Vcloud.complete_service_options?(service) }
+
+      def initialized?
+        true
+      end
+
+      def startup_notice
+        puts "You have access to the following vCloud services: #{Vcloud.registered_services}."
+      end
+
+      def [](service)
+        @@connections ||= Hash.new do |hash, key|
+          if credentials = Fog.credentials[:vcloud][key]
+            hash[key] = Fog::Vcloud.new(credentials)
+          else
+            raise ArgumentError.new("Unregistered service: :#{key}. Registered services are: #{Vcloud.registered_services}")
+          end
+        end
+        @@connections[service]
+      end
+
+    else
+
+      def initialized?
+        false
+      end
+
+    end
+  end
+end

data/lib/fog/vcloud/collection.rb

@@ -0,0 +1,12 @@
+module Fog
+  module Vcloud
+    class Collection < Fog::Collection
+
+      def load(objects)
+        objects = [ objects ] if objects.is_a?(Hash)
+        super
+      end
+
+    end
+  end
+end

data/lib/fog/vcloud/extension.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Vcloud
+    module Extension
+      include Fog::Service
+
+      @versions = []
+
+      def self.extended(other)
+        other.module_eval <<-EOS,__FILE__,__LINE__
+          module #{other}::Real
+            extend Fog::Vcloud::Generators
+          end
+          module #{other}::Mock
+          end
+          def self.extended(klass)
+            unless @required
+              models.each do |model|
+                require File.join(@model_path, model.to_s)
+              end
+              requests.each do |request|
+                require File.join(@request_path, request.to_s)
+              end
+              @required = true
+            end
+            if Fog.mocking?
+              klass.extend #{other}::Real
+              klass.extend #{other}::Mock
+            else
+              klass.extend #{other}::Real
+            end
+          end
+        EOS
+      end
+
+    end
+  end
+end

data/lib/fog/vcloud/generators.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Vcloud
+    module Generators
+
+      def unauthenticated_basic_request(*args)
+        self.class_eval <<-EOS, __FILE__,__LINE__
+          def #{args[0]}(uri)
+            unauthenticated_request({
+              :expects => #{args[1] || 200},
+              :method  => '#{args[2] || 'GET'}',
+              :headers => #{args[3] ? args[3].inspect : '{}'},
+              :parse => true,
+              :uri     => uri })
+          end
+        EOS
+      end
+
+      def basic_request(*args)
+        self.class_eval <<-EOS, __FILE__,__LINE__
+          def #{args[0]}(uri)
+            request({
+              :expects => #{args[1] || 200},
+              :method  => '#{args[2] || 'GET'}',
+              :headers => #{args[3] ? args[3].inspect : '{}'},
+              :body => '#{args[4] ? args[4] : ''}',
+              :parse => true,
+              :uri     => uri })
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/fog/vcloud/model.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Vcloud
+    class Model < Fog::Model
+
+      attr_accessor :loaded
+      alias_method :loaded?, :loaded
+
+      def reload
+        instance = super
+        @loaded = true
+        instance
+      end
+
+      def load_unless_loaded!
+        unless @loaded
+          reload
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/vcloud/models/vdc.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Vcloud
+    class Vdc < Fog::Vcloud::Model
+
+      identity :href
+
+      ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd
+
+      attribute :name
+      attribute :type
+      attribute :description, :aliases => :Description
+      attribute :other_links, :aliases => :Link
+      attribute :compute_capacity, :aliases => :ComputeCapacity
+      attribute :storage_capacity, :aliases => :StorageCapacity
+      attribute :available_networks, :aliases => :AvailableNetworks, :squash => :Network
+      attribute :resource_entities, :aliases => :ResourceEntities, :squash => :ResourceEntity
+      attribute :enabled, :aliases => :IsEnabled
+      attribute :vm_quota, :aliases => :VmQuota
+      attribute :nic_quota, :aliases => :NicQuota
+      attribute :network_quota, :aliases => :NetworkQuota
+      attribute :allocation_model, :aliases => :AllocationModel
+
+    end
+
+  end
+end

data/lib/fog/vcloud/models/vdcs.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Vcloud
+
+    class Real
+      def vdcs(options = {})
+        @vdcs ||= Fog::Vcloud::Vdcs.new(options.merge(:connection => self))
+      end
+    end
+
+    class Vdcs < Fog::Vcloud::Collection
+
+      model Fog::Vcloud::Vdc
+
+      def all
+        data = connection.get_organization(organization_uri).body[:Link].select { |link| link[:type] == "application/vnd.vmware.vcloud.vdc+xml" }
+        data.each { |link| link.delete_if { |key, value| [:rel].include?(key) } }
+        load(data)
+      end
+
+      def get(uri)
+        if data = connection.get_vdc(uri)
+          new(data.body)
+        end
+      rescue Fog::Errors::NotFound
+        nil
+      end
+
+      def organization_uri
+        @organizatio_uri ||= connection.default_organization_uri
+      end
+
+      private
+
+      def organization_uri=(new_organization_uri)
+        @organization_uri = new_organization_uri
+      end
+
+    end
+
+  end
+end

data/lib/fog/vcloud/requests/get_network.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Vcloud
+
+    class Real
+      basic_request :get_network
+    end
+
+    class Mock
+
+      def get_network(network_uri)
+        #
+        # Based off of:
+        # vCloud API Guide v0.8 - Page 50
+        #
+        # Did not implement AssociatedNetwork, seems redundant, haven't seen it in use yet
+        # Did not implement the following features: Dhcp, Nat & Firewall
+        #
+        network_uri = ensure_unparsed(network_uri)
+        type = "application/vnd.vmware.vcloud.network+xml"
+        response = Excon::Response.new
+        if network = mock_data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:networks] } }.flatten.detect { |network| network[:href] == network_uri.to_s }
+          xml = Builder::XmlMarkup.new
+          mock_it 200,
+            xml.Network(xmlns.merge(:href => network[:href], :name => network[:name], :type => type)) {
+              xml.Description(network[:name])
+              xml.Configuration {
+                xml.Gateway(network[:gateway])
+                xml.Netmask(network[:netmask])
+                xml.Dns(network[:dns])
+              }
+              if network[:features]
+                xml.Features {
+                  if feature = network[:features].detect { |feature| feature[:type] == :fencemode }
+                    xml.FenceMode(feature[:value])
+                  end
+                }
+              end
+            },
+            { 'Content-Type' => type }
+        else
+          mock_error 200, "401 Unauthorized"
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/vcloud/requests/get_organization.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Vcloud
+
+    class Real
+      basic_request :get_organization
+    end
+
+    class Mock
+
+      def get_organization(organization_uri)
+        #
+        # Based off of:
+        # http://support.theenterprisecloud.com/kb/default.asp?id=540&Lang=1&SID=
+        # 
+        # vCloud API Guide v0.9 - Page 26
+        #
+        organization_uri = ensure_unparsed(organization_uri)
+        if org = mock_data[:organizations].detect { |org| org[:info][:href] == organization_uri }
+          xml = Builder::XmlMarkup.new
+
+          mock_it 200,
+            xml.Org(xmlns.merge(:href => org[:info][:href], :name => org[:info][:name])) {
+
+              org[:vdcs].each do |vdc|
+                xml.Link(:rel => "down",
+                         :href => vdc[:href],
+                         :type => "application/vnd.vmware.vcloud.vdc+xml",
+                         :name => vdc[:name])
+                xml.Link(:rel => "down",
+                         :href => "#{vdc[:href]}/catalog",
+                         :type => "application/vnd.vmware.vcloud.catalog+xml",
+                         :name => "#{vdc[:name]} Catalog")
+                xml.Link(:rel => "down",
+                         :href => "#{vdc[:href]}/tasksList",
+                         :type => "application/vnd.vmware.vcloud.tasksList+xml",
+                         :name => "#{vdc[:name]} Tasks List")
+              end
+            },
+            {'Content-Type' => "application/vnd.vmware.vcloud.org+xml" }
+        else
+          mock_error 200, "401 Unauthorized"
+        end
+      end
+    end
+  end
+end
+

data/lib/fog/vcloud/requests/get_vdc.rb

@@ -0,0 +1,82 @@
+module Fog
+  module Vcloud
+
+    class Real
+      basic_request :get_vdc
+    end
+
+    class Mock
+      # WARNING: Incomplete
+      #Based off of:
+      #vCloud API Guide v0.9 - Page 27
+
+      def get_vdc(vdc_uri)
+        vdc_uri = ensure_unparsed(vdc_uri)
+        if vdc = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| vdc[:href] == vdc_uri }
+          xml = Builder::XmlMarkup.new
+          mock_it 200,
+            xml.Vdc(xmlns.merge(:href => vdc[:href], :name => vdc[:name])) {
+              xml.Link(:rel => "up",
+                       :href => Fog::Vcloud::Mock.data[:organizations].detect { |org| org[:vdcs].detect { |_vdc| vdc[:href] == _vdc[:href] }[:href] == vdc[:href] }[:info][:href],
+                       :type => "application/vnd.vmware.vcloud.org+xml")
+              xml.Link(:rel => "add",
+                       :href => vdc[:href] + "/action/uploadVAppTemplate",
+                       :type => "application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml")
+              xml.Link(:rel => "add",
+                       :href => vdc[:href] + "/media",
+                       :type => "application/vnd.vmware.vcloud.media+xml")
+              xml.Link(:rel => "add",
+                       :href => vdc[:href] + "/action/instantiateVAppTemplate",
+                       :type => "application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml")
+              xml.Link(:rel => "add",
+                       :type => "application/vnd.vmware.vcloud.cloneVAppParams+xml",
+                       :href => vdc[:href] + "/action/cloneVApp")
+              xml.Link(:rel => "add",
+                       :type => "application/vnd.vmware.vcloud.captureVAppParams+xml",
+                       :href => vdc[:href] + "/action/captureVApp")
+              xml.Link(:rel => "add",
+                       :type => "application/vnd.vmware.vcloud.composeVAppParams+xml",
+                       :href => vdc[:href] + "/action/composeVApp")
+              xml.AllocationModel("AllocationPool")
+              xml.Description(vdc[:name] + " VDC")
+              xml.ResourceEntities {
+                Fog::Vcloud::Mock.data[:vdc_resources].each do |resource|
+                  xml.ResourceEntity(resource)
+                end
+              }
+              xml.AvailableNetworks {
+                vdc[:networks].each do |network|
+                  xml.Network( :name => network[:name], :href => network[:href], :type => "application/vnd.vmware.vcloud.network+xml" )
+                end
+              }
+              xml.ComputeCapacity{
+                xml.Cpu {
+                  xml.Units("Mhz")
+                  xml.Allocated(vdc[:cpu][:allocated])
+                  xml.Limit(vdc[:cpu][:allocated])
+                }
+                xml.Memory {
+                  xml.Units("MB")
+                  xml.Allocated(vdc[:memory][:allocated])
+                  xml.Limit(vdc[:memory][:allocated])
+                }
+              }
+              xml.StorageCapacity{
+                xml.Units("MB")
+                xml.Allocated(vdc[:storage][:allocated])
+                xml.Limit(vdc[:storage][:allocated])
+              }
+              xml.VmQuota(0)
+              xml.NicQuota(0)
+              xml.IsEnabled('true')
+              xml.NetworkQuota(0)
+              #FIXME: Incomplete
+            }, { 'Content-Type' => 'application/vnd.vmware.vcloud.vdc+xml' }
+        else
+          mock_error 200, "401 Unauthorized"
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/vcloud/requests/get_versions.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Vcloud
+
+    class Real
+      unauthenticated_basic_request :get_versions
+    end
+
+    class Mock
+
+      def get_versions(versions_uri)
+        #
+        # Based off of:
+        # http://support.theenterprisecloud.com/kb/default.asp?id=535&Lang=1&SID=
+        # https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/02-get-versions.aspx
+        # vCloud API Guide v0.9 - Page 89
+        #
+        xml = Builder::XmlMarkup.new
+
+        mock_it 200,
+          xml.SupportedVersions( xmlns.merge("xmlns" => "http://www.vmware.com/vcloud/versions")) {
+
+            mock_data[:versions].select {|version| version[:supported] }.each do |version|
+              xml.VersionInfo {
+                xml.Version(version[:version])
+                xml.LoginUrl(version[:login_url])
+              }
+            end
+          }
+
+      end
+
+    end
+  end
+end