fog 0.2.0 → 0.2.1

data/lib/fog/vcloud/bin.rb

@@ -17,7 +17,7 @@ module Vcloud
       if Fog.credentials.has_key?(:vcloud)
         if Fog.credentials[:vcloud].has_key?(service)
           service = Fog.credentials[:vcloud][service]
-          if Fog::Vcloud::Options::REQUIRED.all? { |option| service.has_key?(option) }
+          if Fog::Vcloud.requirements.all? { |option| service.has_key?(option) }
             return true
           end
         end
@@ -38,7 +38,7 @@ module Vcloud
       def [](service)
         @@connections ||= Hash.new do |hash, key|
           if credentials = Fog.credentials[:vcloud][key]
-            hash[key] = Fog::Vcloud.new(credentials.reject { |k,value| Fog::Vcloud::Options::ALL.include?(value) })
+            hash[key] = Fog::Vcloud.new(credentials)
           else
             raise ArgumentError.new("Unregistered service: :#{key}. Registered services are: #{Vcloud.registered_services}")
           end

data/lib/fog/vcloud/collection.rb

@@ -2,92 +2,11 @@ module Fog
   module Vcloud
     class Collection < Fog::Collection
 
-      class << self
-
-        def inherited(klass)
-          klass.instance_variable_set(:@model, @model)
-          klass.all_request @all_request
-          klass.vcloud_type @vcloud_type
-          klass.get_request @get_request
-        end
-
-        def all_request(all_request=nil)
-          unless all_request
-            @all_request
-          else
-            @all_request = all_request
-            class_eval <<-EOS, __FILE__, __LINE__
-              def all
-                raw_all = self.class.all_request.call(self)
-                data = (raw_all.is_a?(Array) ? raw_all : raw_all.body.links).select do |link|
-                  link.type == self.class.vcloud_type
-                end.map { |link| {:href => link.href, :name => link.name } }
-                load(data)
-              end
-            EOS
-          end
-        end
-
-        def vcloud_type(vcloud_type=nil)
-          unless vcloud_type
-            @vcloud_type
-          else
-            @vcloud_type = vcloud_type
-          end
-        end
-
-        def get_request(get_request=nil)
-          unless get_request
-            @get_request
-          else
-            @get_request = get_request
-            class_eval <<-EOS, __FILE__, __LINE__
-              def get(uri)
-                item = new(:href => uri)
-                item.reload
-              end
-              def get_raw(uri)
-                connection.#{@get_request}(uri)
-              end
-            EOS
-          end
-        end
-      end
-
-      attr_accessor :href
-
-      def create(attributes = {})
-        attributes.merge!(:new => true)
-        obj = super(attributes)
-        self << obj
-        obj
+      def load(objects)
+        objects = [ objects ] if objects.is_a?(Hash)
+        super
       end
 
-      def each
-        super do |item|
-          item.reload unless item.loaded?
-          yield(item)
-        end
-      end
-
-      def map
-        super do |item|
-          item.reload unless item.loaded?
-          yield(item)
-        end
-      end
-
-      def [](index)
-        if obj = super
-          obj.reload unless obj.loaded?
-        end
-        obj
-      end
-
-      #def reload
-      #  self.all
-      #end
-
     end
   end
 end

data/lib/fog/vcloud/extension.rb

@@ -0,0 +1,44 @@
+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
+          module #{other}::Versions
+            SUPPORTED = @versions
+          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
+
+      def versions(*args)
+        @versions = args
+      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

@@ -2,50 +2,17 @@ module Fog
   module Vcloud
     class Model < Fog::Model
 
-      #def self.attribute(name, other_names = [])
-      #  super
-      #  class_eval <<-EOS, __FILE__, __LINE__
-      #    def #{name}=(new_#{name})
-      #      @#{name} = new_#{name}
-      #    end
-      #  EOS
-      #end
-
-      def self.inherited(klass)
-          attributes.each { |attribute| klass.attribute attribute }
-          klass.instance_variable_set(:@identity, @identity)
-          klass.instance_variable_set(:@aliases, @aliases)
-        end
-
-      def self.delete_attribute(name)
-        if @attributes.reject! { |item| item == name }
-          class_eval <<-EOS,__FILE__,__LINE__
-            undef_method :#{name}
-            undef_method :#{name}=
-          EOS
-          aliases.reject! { |key, value| value == name || key == name }
-        end
-      end
-
       attr_accessor :loaded
       alias_method :loaded?, :loaded
 
       def reload
-        if data = collection.get_raw(identity)
-          merge_get_raw_result(data)
-          @loaded = true
-          self
-        end
+        super
+        @loaded = true
       end
 
-      def merge_get_raw_result(data)
-        #data.body.each_pair do |key,value|
-        (data.respond_to?(:body) ? data.body : data).each_pair do |key,value|
-          if aliased_key = self.class.aliases[key]
-            send("#{aliased_key}=", value)
-          else
-            send("#{key}=", value)
-          end
+      def load_unless_loaded!
+        unless @loaded
+          reload
         end
       end
 

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

@@ -1,34 +1,24 @@
-require 'fog/model'
-
 module Fog
   module Vcloud
     class Vdc < Fog::Vcloud::Model
 
       identity :href
 
-      attribute :name
-      attribute :other_links, :links
-      attribute :resource_entity_links, :resource_entities
-      attribute :network_links, :networks
-      attribute :cpu_capacity
-      attribute :storage_capacity
-      attribute :memory_capacity
-      attribute :vm_quota
-      attribute :enabled
-      attribute :nic_quota
-      attribute :network_quota
-      attribute :vcloud_type, :type
-      attribute :xmlns
-      attribute :description
-      attribute :allocation_model
-
-      #def networks
-      #  connection.networks(:vdc_uri => @uri)
-      #end
+      ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd
 
-      #def addresses
-      #  connection.addresses(:vdc_uri => @uri)
-      #end
+      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
 

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

@@ -1,10 +1,5 @@
 module Fog
   module Vcloud
-    class Mock
-      def vdcs(options = {})
-        @vdcs ||= Fog::Vcloud::Vdcs.new(options.merge(:connection => self))
-      end
-    end
 
     class Real
       def vdcs(options = {})
@@ -16,9 +11,19 @@ module Fog
 
       model Fog::Vcloud::Vdc
 
-      get_request :get_vdc
-      vcloud_type "application/vnd.vmware.vcloud.vdc+xml"
-      all_request lambda { |vdcs| vdcs.connection.get_organization(vdcs.organization_uri) }
+      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

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

@@ -1,16 +1,8 @@
 module Fog
   module Vcloud
-    class Real
-
-      def get_network(network_uri)
-       request(
-          :expects  => 200,
-          :method   => 'GET',
-          :parser   => Fog::Parsers::Vcloud::Network.new,
-          :uri      => uri
-        )
-      end
 
+    class Real
+      basic_request :get_network
     end
 
     class Mock
@@ -23,11 +15,12 @@ module Fog
         # 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 Fog::Parsers::Vcloud::Network.new, 200,
+          mock_it 200,
             xml.Network(xmlns.merge(:href => network[:href], :name => network[:name], :type => type)) {
               xml.Description(network[:name])
               xml.Configuration {

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

@@ -2,15 +2,7 @@ module Fog
   module Vcloud
 
     class Real
-      def get_organization(organization_uri)
-        request(
-          :expects  => 200,
-          :method   => 'GET',
-          :parser   => Fog::Parsers::Vcloud::GetOrganization.new,
-          :uri      => organization_uri
-        )
-      end
-
+      basic_request :get_organization
     end
 
     class Mock
@@ -22,10 +14,11 @@ module Fog
         # 
         # vCloud API Guide v0.9 - Page 26
         #
-        if org = mock_data[:organizations].detect { |org| URI.parse(org[:info][:href]) == organization_uri }
+        organization_uri = ensure_unparsed(organization_uri)
+        if org = mock_data[:organizations].detect { |org| org[:info][:href] == organization_uri }
           xml = Builder::XmlMarkup.new
 
-          mock_it Fog::Parsers::Vcloud::GetOrganization.new, 200,
+          mock_it 200,
             xml.Org(xmlns.merge(:href => org[:info][:href], :name => org[:info][:name])) {
 
               org[:vdcs].each do |vdc|

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

@@ -2,16 +2,7 @@ module Fog
   module Vcloud
 
     class Real
-      # Get details of a vdc
-      def get_vdc(vdc_uri)
-        request(
-          :expects  => 200,
-          :method   => 'GET',
-          :parser   => Fog::Parsers::Vcloud::GetVdc.new,
-          :uri      => vdc_uri
-        )
-      end
-
+      basic_request :get_vdc
     end
 
     class Mock
@@ -20,9 +11,10 @@ module Fog
       #vCloud API Guide v0.9 - Page 27
 
       def get_vdc(vdc_uri)
-        if vdc = Fog::Vcloud::Mock.data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| URI.parse(vdc[:href]) == 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 Fog::Parsers::Vcloud::GetVdc.new, 200,
+          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],

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

@@ -2,21 +2,12 @@ module Fog
   module Vcloud
 
     class Real
-
-      def get_versions
-        unauthenticated_request({
-          :expects  => 200,
-          :method   => 'GET',
-          :parser   => Fog::Parsers::Vcloud::GetVersions.new,
-          :uri      => @versions_uri
-        })
-      end
-
+      unauthenticated_basic_request :get_versions
     end
 
     class Mock
 
-      def get_versions
+      def get_versions(versions_uri)
         #
         # Based off of:
         # http://support.theenterprisecloud.com/kb/default.asp?id=535&Lang=1&SID=
@@ -25,10 +16,10 @@ module Fog
         #
         xml = Builder::XmlMarkup.new
 
-        mock_it Fog::Parsers::Vcloud::GetVersions.new, 200,
+        mock_it 200,
           xml.SupportedVersions( xmlns.merge("xmlns" => "http://www.vmware.com/vcloud/versions")) {
 
-            Fog::Vcloud::Mock.data[:versions].select {|version| version[:supported] }.each do |version|
+            mock_data[:versions].select {|version| version[:supported] }.each do |version|
               xml.VersionInfo {
                 xml.Version(version[:version])
                 xml.LoginUrl(version[:login_url])