bbcloud 0.8.1 → 0.8.2

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/terremark/vcloud.rb

@@ -1,113 +0,0 @@
-module Fog
-  module Terremark
-   module Vcloud
-
-     module Bin
-     end
-
-     module Defaults
-       HOST   = 'services.vcloudexpress.terremark.com'
-       PATH   = '/api/v0.8'
-       PORT   = 443
-       SCHEME = 'https'
-     end
-
-     extend Fog::Terremark::Shared
-
-     def self.new(options={})
-
-       unless @required
-         shared_requires
-         @required = true
-       end
-
-       check_shared_options(options)
-
-       if Fog.mocking?
-          Fog::Terremark::Vcloud::Mock.new(options)
-       else
-          Fog::Terremark::Vcloud::Real.new(options)
-       end
-     end
-
-     class Real
-
-       include Fog::Terremark::Shared::Real
-       include Fog::Terremark::Shared::Parser
-
-        def initialize(options={})
-          @terremark_password = options[:terremark_vcloud_password]
-          @terremark_username = options[:terremark_vcloud_username]
-          @host   = options[:host]   || Fog::Terremark::Vcloud::Defaults::HOST
-          @path   = options[:path]   || Fog::Terremark::Vcloud::Defaults::PATH
-          @port   = options[:port]   || Fog::Terremark::Vcloud::Defaults::PORT
-          @scheme = options[:scheme] || Fog::Terremark::Vcloud::Defaults::SCHEME
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
-        end
-
-        def default_vdc_id
-          if default_organization_id
-            @default_vdc_id ||= begin
-              vdcs = get_organization(default_organization_id).body['Links'].select {|link|
-                link['type'] == 'application/vnd.vmware.vcloud.vdc+xml'
-              }
-              if vdcs.length == 1
-                vdcs.first['href'].split('/').last.to_i
-              else
-                nil
-              end
-            end
-          else
-            nil
-          end
-        end
-
-        def default_network_id
-          if default_vdc_id
-            @default_network_id ||= begin
-              networks = get_vdc(default_vdc_id).body['AvailableNetworks']
-              if networks.length == 1
-                networks.first['href'].split('/').last.to_i
-              else
-                nil
-              end
-            end
-          else
-            nil
-          end
-        end
-
-        def default_public_ip_id
-          if default_vdc_id
-            @default_public_ip_id ||= begin
-              ips = get_public_ips(default_vdc_id).body['PublicIpAddresses']
-              if ips.length == 1
-                ips.first['href'].split('/').last.to_i
-              else
-                nil
-              end
-            end
-          else
-            nil
-          end
-        end
-     end
-
-     class Mock
-       include Fog::Terremark::Shared::Mock
-       include Fog::Terremark::Shared::Parser
-
-       def initialize(option = {})
-         super
-         @base_url = Fog::Terremark::Vcloud::Defaults::SCHEME + "://" +
-                     Fog::Terremark::Vcloud::Defaults::HOST +
-                     Fog::Terremark::Vcloud::Defaults::PATH
-         @data = self.class.data[:terremark_vcloud_username]
-       end
-     end
-
-   end
-  end
-end
-
-

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/vcloud.rb

@@ -1,334 +0,0 @@
-require 'nokogiri'
-require 'fog/core/parser'
-
-require 'builder'
-require 'fog/vcloud/model'
-require 'fog/vcloud/collection'
-require 'fog/vcloud/generators'
-require 'fog/vcloud/mock_data_classes'
-# ecloud/vcloud requires at the bottom so that the following will be defined
-
-module URI
-  class Generic
-    def host_url
-      @host_url ||= "#{self.scheme}://#{self.host}#{self.port ? ":#{self.port}" : ''}"
-    end
-  end
-end
-
-module Fog
-  class Vcloud < Fog::Service
-
-    requires :username, :password, :versions_uri
-
-    model_path 'fog/vcloud/models'
-    model :vdc
-    collection :vdcs
-
-    request_path 'fog/vcloud/requests'
-    request :login
-    request :get_versions
-    request :get_vdc
-    request :get_organization
-    request :get_network
-
-    class UnsupportedVersion < Exception ; end
-
-    module Shared
-      attr_reader :versions_uri
-
-      def default_organization_uri
-        @default_organization_uri ||= begin
-          unless @login_results
-            do_login
-          end
-          case @login_results.body[:Org]
-          when Array
-            @login_results.body[:Org].first[:href]
-          when Hash
-            @login_results.body[:Org][:href]
-          else
-            nil
-          end
-        end
-      end
-
-      # login handles the auth, but we just need the Set-Cookie
-      # header from that call.
-      def do_login
-        @login_results = login
-        @cookie = @login_results.headers['Set-Cookie']
-      end
-
-      def supported_versions
-        @supported_versions ||= get_versions(@versions_uri).body[:VersionInfo]
-      end
-
-      def xmlns
-        { "xmlns" => "http://www.vmware.com/vcloud/v0.8",
-          "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance",
-          "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
-      end
-
-      # private
-
-      def ensure_unparsed(uri)
-        if uri.is_a?(String)
-          uri
-        else
-          uri.to_s
-        end
-      end
-
-    end
-
-    class Real
-      include Shared
-      extend Fog::Vcloud::Generators
-
-      def supporting_versions
-        ["0.8"]
-      end
-
-      def initialize(options = {})
-        @connections = {}
-        @versions_uri = URI.parse(options[:versions_uri])
-        @module = options[:module]
-        @version = options[:version]
-        @username = options[:username]
-        @password = options[:password]
-        @persistent = options[:persistent]
-      end
-
-      def default_organization_uri
-        @default_organization_uri ||= begin
-          unless @login_results
-            do_login
-          end
-          case @login_results.body[:Org]
-          when Array
-            @login_results.body[:Org].first[:href]
-          when Hash
-            @login_results.body[:Org][:href]
-          else
-            nil
-          end
-        end
-      end
-
-      def reload
-        @connections.each_value { |k,v| v.reset if v }
-      end
-
-      # If the cookie isn't set, do a get_organizations call to set it
-      # and try the request.
-      # If we get an Unauthorized error, we assume the token expired, re-auth and try again
-      def request(params)
-        unless @cookie
-          do_login
-        end
-        begin
-          do_request(params)
-        rescue Excon::Errors::Unauthorized => e
-          do_login
-          do_request(params)
-        end
-      end
-
-      private
-
-      def ensure_parsed(uri)
-        if uri.is_a?(String)
-          URI.parse(uri)
-        else
-          uri
-        end
-      end
-
-      def supported_version_numbers
-        case supported_versions
-        when Array
-          supported_versions.map { |version| version[:Version] }
-        when Hash
-          [ supported_versions[:Version] ]
-        end
-      end
-
-      def get_login_uri
-        check_versions
-        URI.parse case supported_versions
-        when Array
-          supported_versions.detect {|version| version[:Version] == @version }[:LoginUrl]
-        when Hash
-          supported_versions[:LoginUrl]
-        end
-      end
-
-      # If we don't support any versions the service does, then raise an error.
-      # If the @version that super selected isn't in our supported list, then select one that is.
-      def check_versions
-        if @version
-          unless supported_version_numbers.include?(@version.to_s)
-            raise UnsupportedVersion.new("#{@version} is not supported by the server.")
-          end
-          unless supporting_versions.include?(@version.to_s)
-            raise UnsupportedVersion.new("#{@version} is not supported by #{self.class}")
-          end
-        else
-          unless @version = (supported_version_numbers & supporting_versions).sort.first
-            raise UnsupportedVersion.new("\nService @ #{@versions_uri} supports: #{supported_version_numbers.join(', ')}\n" +
-                                         "#{self.class} supports: #{supporting_versions.join(', ')}")
-          end
-        end
-      end
-
-      # Don't need to  set the cookie for these or retry them if the cookie timed out
-      def unauthenticated_request(params)
-        do_request(params)
-      end
-
-      # Use this to set the Authorization header for login
-      def authorization_header
-        "Basic #{Base64.encode64("#{@username}:#{@password}").chomp!}"
-      end
-
-      def login_uri
-        @login_uri ||= get_login_uri
-      end
-
-      # login handles the auth, but we just need the Set-Cookie
-      # header from that call.
-      def do_login
-        @login_results = login
-        @cookie = @login_results.headers['Set-Cookie']
-      end
-
-      # Actually do the request
-      def do_request(params)
-        # Convert the uri to a URI if it's a string.
-        if params[:uri].is_a?(String)
-          params[:uri] = URI.parse(params[:uri])
-        end
-
-        # Hash connections on the host_url ... There's nothing to say we won't get URI's that go to
-        # different hosts.
-        @connections[params[:uri].host_url] ||= Fog::Connection.new(params[:uri].host_url, @persistent)
-
-        # Set headers to an empty hash if none are set.
-        headers = params[:headers] || {}
-
-        # Add our auth cookie to the headers
-        if @cookie
-          headers.merge!('Cookie' => @cookie)
-        end
-
-        # Make the request
-        response = @connections[params[:uri].host_url].request({
-          :body     => params[:body] || '',
-          :expects  => params[:expects] || 200,
-          :headers  => headers,
-          :method   => params[:method] || 'GET',
-          :path     => params[:uri].path
-        })
-
-        # Parse the response body into a hash
-        #puts response.body
-        unless response.body.empty?
-          if params[:parse]
-            document = Fog::ToHashDocument.new
-            parser = Nokogiri::XML::SAX::PushParser.new(document)
-            parser << response.body
-            parser.finish
-
-            response.body = document.body
-          end
-        end
-
-        response
-      end
-    end
-
-    class Mock
-      include Shared
-      include MockDataClasses
-
-      def self.base_url
-        "https://fakey.com/api/v0.8"
-      end
-
-      def self.data_reset
-        @mock_data = nil
-      end
-
-      def self.data( base_url = self.base_url )
-        MockDataClasses::Base.base_url = base_url
-
-        @mock_data ||= MockData.new.tap do |mock_data|
-          mock_data.versions << MockVersion.new(:version => "v0.8", :supported => true)
-
-          mock_data.organizations << MockOrganization.new(:name => "Boom Inc.").tap do |mock_organization|
-            mock_organization.vdcs << MockVdc.new(:name => "Boomstick").tap do |mock_vdc|
-              mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 0").tap do |mock_catalog_item|
-                mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-              end
-              mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 1").tap do |mock_catalog_item|
-                mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-              end
-              mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 2").tap do |mock_catalog_item|
-                mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-              end
-
-              mock_vdc.networks << MockNetwork.new({ :subnet => "1.2.3.0/24" }, mock_vdc)
-              mock_vdc.networks << MockNetwork.new({ :subnet => "4.5.6.0/24" }, mock_vdc)
-
-              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Broom 1", :ip => "1.2.3.3" }, mock_vdc)
-              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Broom 2", :ip => "1.2.3.4" }, mock_vdc)
-              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Email!", :ip => "1.2.3.10" }, mock_vdc)
-            end
-
-            mock_organization.vdcs << MockVdc.new(:name => "Rock-n-Roll", :storage_allocated => 150, :storage_used => 40, :cpu_allocated => 1000, :memory_allocated => 2048).tap do |mock_vdc|
-              mock_vdc.networks << MockNetwork.new({ :subnet => "7.8.9.0/24" }, mock_vdc)
-
-              mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Master Blaster", :ip => "7.8.9.10" }, mock_vdc)
-            end
-          end
-        end
-      end
-
-      def initialize(options = {})
-        @versions_uri = URI.parse('https://vcloud.fakey.com/api/versions')
-      end
-
-      def mock_it(status, mock_data, mock_headers = {})
-        response = Excon::Response.new
-
-        #Parse the response body into a hash
-        if mock_data.empty?
-          response.body = mock_data
-        else
-          document = Fog::ToHashDocument.new
-          parser = Nokogiri::XML::SAX::PushParser.new(document)
-          parser << mock_data
-          parser.finish
-          response.body = document.body
-        end
-
-        response.status = status
-        response.headers = mock_headers
-        response
-      end
-
-      def mock_error(expected, status, body='', headers={})
-        raise Excon::Errors::Unauthorized.new("Expected(#{expected}) <=> Actual(#{status})")
-      end
-
-      def mock_data
-        Fog::Vcloud::Mock.data
-      end
-
-    end
-  end
-end
-
-require 'fog/vcloud/terremark/ecloud'
-require 'fog/vcloud/terremark/vcloud'

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/vcloud/bin.rb

@@ -1,57 +0,0 @@
-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
-        Formatador.display_line("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] = eval(credentials[:module]).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