bbcloud 0.8 → 0.8.1

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

@@ -0,0 +1,172 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud < Fog::Vcloud
+
+        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 :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_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
+
+        class Mock < Fog::Vcloud::Mock
+
+          def initialize(options={})
+          end
+
+          def self.base_url
+            "https://fakey.com/api/v0.8b-ext2.3"
+          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.3")
+
+              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")
+                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 ecloud_xmlns
+            { :xmlns => "urn:tmrk:eCloudExtensions-2.3", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" }
+          end
+
+          def mock_data
+            Fog::Vcloud::Terremark::Ecloud::Mock.data
+          end
+        end
+
+        class Real < Fog::Vcloud::Real
+
+          def supporting_versions
+            ["v0.8b-ext2.3", "0.8b-ext2.3"]
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Vcloud
+
+        class Real
+          # Handled by the main Vcloud get_vdc
+        end
+
+        class Mock
+          #
+          #Based off of:
+          #https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/09-get-vdc.aspx
+
+          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 => "down",
+                           :href => vdc[:href] + "/catalog",
+                           :type => "application/vnd.vmware.vcloud.catalog+xml",
+                           :name => vdc[:name])
+                  xml.Link(:rel => "down",
+                           :href => vdc[:href] + "/publicIps",
+                           :type => "application/xml",
+                           :name => "Public IPs")
+                  xml.Link(:rel => "down",
+                           :href => vdc[:href] + "/internetServices",
+                           :type => "application/xml",
+                           :name => "Internet Services")
+                  xml.ResourceEntities {
+                    vdc[:vms].each do |vm|
+                      xml.ResourceEntity(:href => vm[:href],
+                                         :type => "application/vnd.vmware.vcloud.vApp+xml",
+                                         :name => vm[:name])
+                    end
+                  }
+                  xml.AvailableNetworks {
+                    vdc[:networks].each do |network|
+                      xml.Network(:href => network[:href],
+                                  :type => "application/vnd.vmware.vcloud.network+xml",
+                                  :name => network[:name])
+                    end
+                  }
+                }, { 'Content-Type' => 'application/vnd.vmware.vcloud.vdc+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Vcloud < Fog::Vcloud
+        request_path 'fog/vcloud/terremark/vcloud/requests'
+        request :get_vdc
+
+        class Real < Fog::Vcloud::Real
+
+          def supporting_versions
+            ["0.8", "0.8a-ext1.6"]
+          end
+
+        end
+
+        class Mock < Fog::Vcloud::Mock
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,334 @@
+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.rb

@@ -0,0 +1,83 @@
+require 'base64'
+require 'cgi'
+require 'excon'
+require 'formatador'
+require 'time'
+
+__DIR__ = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift __DIR__ unless
+  $LOAD_PATH.include?(__DIR__) ||
+  $LOAD_PATH.include?(File.expand_path(__DIR__))
+
+require 'fog/core'
+
+module Fog
+
+  @mocking = false
+
+  unless const_defined?(:VERSION)
+    VERSION = '0.3.23'
+  end
+
+  module Mock
+    @delay = 1
+    def self.delay
+      @delay
+    end
+
+    def self.delay=(new_delay)
+      raise ArgumentError, "delay must be non-negative" unless new_delay >= 0
+      @delay = new_delay
+    end
+
+    def self.not_implemented
+      raise Fog::Errors::MockNotImplemented.new("Contributions welcome!")
+    end
+
+  end
+
+  def self.bin
+    @bin ||= false
+  end
+
+  def self.bin=(new_bin)
+    @bin = new_bin
+  end
+
+  def self.mock!
+    @mocking = true
+  end
+
+  def self.mocking?
+    !!@mocking
+  end
+
+  def self.wait_for(timeout=600, interval=1, &block)
+    duration = 0
+    start = Time.now
+    until yield || duration > timeout
+      sleep(interval)
+      duration = Time.now - start
+    end
+    if duration > timeout
+      false
+    else
+      { :duration => duration }
+    end
+  end
+  
+end
+
+require 'fog/aws'
+require 'fog/bluebox'
+require 'fog/brightbox'
+require 'fog/go_grid'
+require 'fog/linode'
+require 'fog/local'
+require 'fog/new_servers'
+require 'fog/rackspace'
+require 'fog/slicehost'
+require 'fog/terremark'
+require 'fog/vcloud'
+require 'fog/google'