fog 0.5.3 → 0.6.0

data/lib/fog/vcloud/model.rb

@@ -1,22 +0,0 @@
-module Fog
-  class Vcloud < Fog::Service
-    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

@@ -1,26 +0,0 @@
-module Fog
-  class 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

@@ -1,35 +0,0 @@
-require 'fog/vcloud/models/vdc'
-
-module Fog
-  class Vcloud
-    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

@@ -1,47 +0,0 @@
-module Fog
-  class 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

@@ -1,47 +0,0 @@
-module Fog
-  class 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 organization = mock_data.organization_from_href(organization_uri)
-          xml = Builder::XmlMarkup.new
-
-          mock_it 200,
-            xml.Org(xmlns.merge(:href => organization.href, :name => organization.name)) {
-
-              organization.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.catalog.href,
-                         :type => "application/vnd.vmware.vcloud.catalog+xml",
-                         :name => vdc.catalog.name)
-                xml.Link(:rel => "down",
-                         :href => vdc.task_list.href,
-                         :type => "application/vnd.vmware.vcloud.tasksList+xml",
-                         :name => vdc.task_list.name)
-              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

@@ -1,82 +0,0 @@
-module Fog
-  class 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 => mock_data.organizations.detect { |org| org.vdcs.detect { |_vdc| vdc.href == _vdc.href }.href == vdc.href }.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 {
-                mock_data.organizations.first.vdcs.first.virtual_machines.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

@@ -1,34 +0,0 @@
-module Fog
-  class 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

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

@@ -1,46 +0,0 @@
-module Fog
-  class Vcloud
-
-    class Real
-
-
-      def login
-        unauthenticated_request({
-          :expects  => 200,
-          :headers  => {
-            'Authorization' => authorization_header
-          },
-          :method   => 'POST',
-          :parse    => true,
-          :uri      => login_uri
-        })
-      end
-
-    end
-
-    class Mock
-
-      def login
-        #
-        # Based off of:
-        # http://support.theenterprisecloud.com/kb/default.asp?id=536&Lang=1&SID=
-        # https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/01-get-login-token.aspx
-        # vCloud API Guide v0.9 - Page 17
-        #
-        xml = Builder::XmlMarkup.new
-
-        mock_it 200,
-          xml.OrgList(xmlns) {
-              mock_data.organizations.each do |organization|
-                xml.Org( :type => "application/vnd.vmware.vcloud.org+xml", :href => organization.href, :name => organization.name )
-              end
-            },
-            { 'Set-Cookie' => 'vcloud-token=fc020a05-21d7-4f33-9b2a-25d8cd05a44e; path=/',
-              'Content-Type' => 'application/vnd.vmware.vcloud.orgslist+xml' }
-
-      end
-
-    end
-  end
-end
-

data/lib/fog/vcloud/terremark/ecloud.rb

@@ -1,187 +0,0 @@
-module Fog
-  class Vcloud
-    module Terremark
-      class Ecloud < Fog::Vcloud
-
-        requires   :username, :password, :versions_uri
-        recognizes :module, :version
-
-        model_path 'fog/vcloud/terremark/ecloud/models'
-        model :catalog_item
-        model :catalog
-        model :firewall_acl
-        collection :firewall_acls
-        model :internet_service
-        collection :internet_services
-        model :backup_internet_service
-        collection :backup_internet_services
-        model :ip
-        collection :ips
-        model :network
-        collection :networks
-        model :node
-        collection :nodes
-        model :public_ip
-        collection :public_ips
-        model :server
-        collection :servers
-        model :task
-        collection :tasks
-        model :vdc
-        collection :vdcs
-
-        request_path 'fog/vcloud/terremark/ecloud/requests'
-        request :add_internet_service
-        request :add_backup_internet_service
-        request :add_node
-        request :clone_vapp
-        request :configure_internet_service
-        request :configure_network
-        request :configure_network_ip
-        request :configure_node
-        request :configure_vapp
-        request :delete_internet_service
-        request :delete_node
-        request :delete_vapp
-        request :get_catalog
-        request :get_catalog_item
-        request :get_customization_options
-        request :get_firewall_acls
-        request :get_firewall_acl
-        request :get_internet_services
-        request :get_network
-        request :get_network_ip
-        request :get_network_ips
-        request :get_network_extensions
-        request :get_node
-        request :get_nodes
-        request :get_public_ip
-        request :get_public_ips
-        request :get_task
-        request :get_task_list
-        request :get_vapp
-        request :get_vapp_template
-        request :get_vdc
-        request :instantiate_vapp_template
-        request :power_off
-        request :power_on
-        request :power_reset
-        request :power_shutdown
-
-        module Shared
-          def ecloud_xmlns
-            {
-              "xmlns"     => "urn:tmrk:eCloudExtensions-2.6",
-              "xmlns:i"   => "http://www.w3.org/2001/XMLSchema-instance"
-            }
-          end
-        end
-
-        class Mock < Fog::Vcloud::Mock
-          include Shared
-
-          def initialize(options={})
-          end
-
-          def self.base_url
-            "https://fakey.com/api/v0.8b-ext2.6"
-          end
-
-          def self.data_reset
-            @mock_data = nil
-            Fog::Vcloud::Mock.data_reset
-          end
-
-          def self.data( base_url = self.base_url )
-            @mock_data ||= Fog::Vcloud::Mock.data(base_url).tap do |vcloud_mock_data|
-              vcloud_mock_data.versions.clear
-              vcloud_mock_data.versions << MockVersion.new(:version => "v0.8b-ext2.6")
-
-              vcloud_mock_data.organizations.detect {|o| o.name == "Boom Inc." }.tap do |mock_organization|
-                mock_organization.vdcs.detect {|v| v.name == "Boomstick" }.tap do |mock_vdc|
-                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.2.3").tap do |mock_public_ip|
-                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                          :protocol => "HTTP",
-                                                                                                          :port => 80,
-                                                                                                          :name => "Web Site",
-                                                                                                          :description => "Web Servers",
-                                                                                                          :redirect_url => "http://fakey.com"
-                                                                                                        }, mock_public_ip.internet_service_collection
-                                                                                                        ).tap do |mock_public_ip_service|
-                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.5", :name => "Test Node 1", :description => "web 1"}, mock_public_ip_service.node_collection)
-                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.6", :name => "Test Node 2", :description => "web 2"}, mock_public_ip_service.node_collection)
-                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.7", :name => "Test Node 3", :description => "web 3"}, mock_public_ip_service.node_collection)
-                    end
-
-                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                          :protocol => "TCP",
-                                                                                                          :port => 7000,
-                                                                                                          :name => "An SSH Map",
-                                                                                                          :description => "SSH 1"
-                                                                                                        }, mock_public_ip.internet_service_collection
-                                                                                                        ).tap do |mock_public_ip_service|
-                      mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({ :ip_address => "1.2.3.5", :port => 22, :name => "SSH", :description => "web ssh" }, mock_public_ip_service.node_collection)
-                    end
-                  end
-
-                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.2.4").tap do |mock_public_ip|
-                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                          :protocol => "HTTP",
-                                                                                                          :port => 80,
-                                                                                                          :name => "Web Site",
-                                                                                                          :description => "Web Servers",
-                                                                                                          :redirect_url => "http://fakey.com"
-                                                                                                        }, mock_public_ip.internet_service_collection
-                                                                                                        )
-
-                    mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                          :protocol => "TCP",
-                                                                                                          :port => 7000,
-                                                                                                          :name => "An SSH Map",
-                                                                                                          :description => "SSH 2"
-                                                                                                        }, mock_public_ip.internet_service_collection
-                                                                                                        )
-                  end
-
-                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.9.7")
-
-                  mock_vdc.internet_service_collection.backup_internet_services << MockBackupInternetService.new({ :port => 10000, :protocol => "TCP"}, self)
-                end
-
-                mock_organization.vdcs.detect {|v| v.name == "Rock-n-Roll" }.tap do |mock_vdc|
-                  mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.99.99.99")
-                end
-              end
-
-              vcloud_mock_data.organizations.each do |organization|
-                organization.vdcs.each do |vdc|
-                  vdc.networks.each do |network|
-                    network[:rnat] = vdc.public_ip_collection.items.first.name
-                  end
-                  vdc.virtual_machines.each do |virtual_machine|
-                    virtual_machine.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-                    virtual_machine.disks << MockVirtualMachineDisk.new(:size => 50 * 1024)
-                  end
-                end
-              end
-            end
-          end
-
-          def mock_data
-            Fog::Vcloud::Terremark::Ecloud::Mock.data
-          end
-        end
-
-        class Real < Fog::Vcloud::Real
-          include Shared
-
-          def supporting_versions
-            ["v0.8b-ext2.6", "0.8b-ext2.6"]
-          end
-
-        end
-
-      end
-    end
-  end
-end