brightbox-cli 0.13.1 → 0.14.0

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/compute.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rackspace'))
+require 'fog/compute'
+
+module Fog
+  module Compute
+    class Rackspace < Fog::Service
+
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url, :rackspace_servicenet, :persistent
+      recognizes :rackspace_auth_token, :rackspace_management_url
+
+      model_path 'fog/rackspace/models/compute'
+      model       :flavor
+      collection  :flavors
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+
+      request_path 'fog/rackspace/requests/compute'
+      request :confirm_resized_server
+      request :create_image
+      request :create_server
+      request :delete_image
+      request :delete_server
+      request :get_flavor_details
+      request :get_image_details
+      request :get_server_details
+      request :list_addresses
+      request :list_private_addresses
+      request :list_public_addresses
+      request :list_flavors
+      request :list_flavors_detail
+      request :list_images
+      request :list_images_detail
+      request :list_servers
+      request :list_servers_detail
+      request :reboot_server
+      request :revert_resized_server
+      request :resize_server
+      request :server_action
+      request :update_server
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :last_modified => {
+                :images  => {},
+                :servers => {}
+              },
+              :images  => {},
+              :servers => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          require 'multi_json'
+          @rackspace_username = options[:rackspace_username]
+        end
+
+        def data
+          self.class.data[@rackspace_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@rackspace_username)
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          require 'multi_json'
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+          @rackspace_servicenet = options[:rackspace_servicenet]
+          @rackspace_auth_token = options[:rackspace_auth_token]
+          @rackspace_management_url = options[:rackspace_management_url]
+          @rackspace_must_reauthenticate = false
+          @connection_options = options[:connection_options] || {}
+          authenticate
+          Excon.ssl_verify_peer = false if options[:rackspace_servicenet] == true
+          @persistent = options[:persistent] || false
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}",
+              :query    => ('ignore_awful_caching' << Time.now.to_i.to_s)
+            }))
+          rescue Excon::Errors::Unauthorized => error
+            if error.response.body != 'Bad username or password' # token expiration
+              @rackspace_must_reauthenticate = true
+              authenticate
+              retry
+            else # bad credentials
+              raise error
+            end
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Compute::Rackspace::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+
+        private
+
+        def authenticate
+          if @rackspace_must_reauthenticate || @rackspace_auth_token.nil?
+            options = {
+              :rackspace_api_key  => @rackspace_api_key,
+              :rackspace_username => @rackspace_username,
+              :rackspace_auth_url => @rackspace_auth_url
+            }
+            credentials = Fog::Rackspace.authenticate(options, @connection_options)
+            @auth_token = credentials['X-Auth-Token']
+            uri = URI.parse(credentials['X-Server-Management-Url'])
+          else
+            @auth_token = @rackspace_auth_token
+            uri = URI.parse(@rackspace_management_url)
+          end
+          @host   = @rackspace_servicenet == true ? "snet-#{uri.host}" : uri.host
+          @path   = uri.path
+          @port   = uri.port
+          @scheme = uri.scheme
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/dns.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rackspace'))
+require 'fog/dns'
+
+module Fog
+  module DNS
+    class Rackspace < Fog::Service
+
+      US_ENDPOINT = 'https://dns.api.rackspacecloud.com/v1.0'
+      UK_ENDPOINT = 'https://lon.dns.api.rackspacecloud.com/v1.0'
+
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url
+      recognizes :rackspace_auth_token
+
+      model_path 'fog/rackspace/models/dns'
+      model       :record
+      collection  :records
+      model       :zone
+      collection  :zones
+
+      request_path 'fog/rackspace/requests/dns'
+      #TODO - Import/Export, modify multiple domains, modify multiple records
+      request :callback
+      request :list_domains
+      request :list_domain_details
+      request :modify_domain
+      request :create_domains
+      request :remove_domain
+      request :remove_domains
+      request :list_subdomains
+      request :list_records
+      request :list_record_details
+      request :modify_record
+      request :remove_record
+      request :remove_records
+      request :add_records
+
+      class Mock
+      end
+
+      class Real
+        def initialize(options={})
+          require 'multi_json'
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+          @connection_options = options[:connection_options] || {}
+          uri = URI.parse(options[:rackspace_dns_endpoint] || US_ENDPOINT)
+
+          @auth_token, @account_id = *authenticate
+          @persistent = options[:persistent] || false
+          @path       = "#{uri.path}/#{@account_id}"
+
+          @connection_options[:headers] ||= {}
+          @connection_options[:headers].merge!({ 'Content-Type' => 'application/json', 'X-Auth-Token' => @auth_token })
+
+          @connection = Fog::Connection.new(uri.to_s, @persistent, @connection_options)
+        end
+
+        private
+
+        def request(params)
+          #TODO - Unify code with other rackspace services
+          begin
+            response = @connection.request(params.merge!({
+              :path     => "#{@path}/#{params[:path]}"
+            }))
+          rescue Excon::Errors::BadRequest => error
+            raise Fog::Rackspace::Errors::BadRequest.slurp error
+          rescue Excon::Errors::Conflict => error
+            raise Fog::Rackspace::Errors::Conflict.slurp error
+          rescue Excon::Errors::NotFound => error
+            raise Fog::Rackspace::Errors::NotFound.slurp error
+          rescue Excon::Errors::ServiceUnavailable => error
+            raise Fog::Rackspace::Errors::ServiceUnavailable.slurp error
+          end
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+
+        def authenticate
+          options = {
+            :rackspace_api_key  => @rackspace_api_key,
+            :rackspace_username => @rackspace_username,
+            :rackspace_auth_url => @rackspace_auth_url
+          }
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
+          auth_token = credentials['X-Auth-Token']
+          account_id = credentials['X-Server-Management-Url'].match(/.*\/([\d]+)$/)[1]
+          [auth_token, account_id]
+        end
+
+        def array_to_query_string(arr)
+          arr.collect {|k,v| "#{k}=#{v}" }.join('&')
+        end
+
+        def validate_path_fragment(name, fragment)
+          if fragment.nil? or fragment.to_s.empty?
+            raise ArgumentError.new("#{name} cannot be null or empty")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/load_balancers.rb

@@ -1,39 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rackspace'))
+
 module Fog
   module Rackspace
     class LoadBalancers < Fog::Service
 
-      class ServiceError < Fog::Errors::Error
-        attr_reader :response_data
-
-        def self.slurp(error)
-          if error.response.body.empty?
-            data = nil
-            message = nil
-          else
-            data = MultiJson.decode(error.response.body)
-            message = data['message']
-          end
-
-          new_error = super(error, message)
-          new_error.instance_variable_set(:@response_data, data)
-          new_error
-        end
-      end
-
-      class InternalServerError < ServiceError; end
-
-      class BadRequest < ServiceError
-        #TODO - Need to find a bette way to print out these validation errors when they are thrown
-        attr_reader :validation_errors
-
-        def self.slurp(error)
-          new_error = super(error)
-          unless new_error.response_data.nil?
-            new_error.instance_variable_set(:@validation_errors, new_error.response_data['validationErrors'])
-          end
-          new_error
-        end
-      end
+      #These references exist for backwards compatibility
+      class ServiceError < Fog::Rackspace::Errors::ServiceError; end
+      class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end
+      class BadRequest < Fog::Rackspace::Errors::BadRequest; end
 
       DFW_ENDPOINT = 'https://dfw.loadbalancers.api.rackspacecloud.com/v1.0/'
       ORD_ENDPOINT = 'https://ord.loadbalancers.api.rackspacecloud.com/v1.0/'
@@ -124,15 +98,17 @@ module Fog
           @rackspace_username = options[:rackspace_username]
           @rackspace_auth_url = options[:rackspace_auth_url]
           @rackspace_must_reauthenticate = false
+          @connection_options     = options[:connection_options] || {}
           uri = URI.parse(options[:rackspace_lb_endpoint] || DFW_ENDPOINT)
-          @host = uri.host
-          @path = uri.path
-          @port = uri.port
-          @scheme = uri.scheme
+          @host       = uri.host
+          @persistent = options[:persistent] || false
+          @path       = uri.path
+          @port       = uri.port
+          @scheme     = uri.scheme
 
           authenticate
 
-          @connection = Fog::Connection.new(uri.to_s, options[:persistent])
+          @connection = Fog::Connection.new(uri.to_s, @persistent, @connection_options)
         end
 
         def request(params)
@@ -167,7 +143,7 @@ module Fog
             :rackspace_username => @rackspace_username,
             :rackspace_auth_url => @rackspace_auth_url
           }
-          credentials = Fog::Rackspace.authenticate(options)
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
           @auth_token = credentials['X-Auth-Token']
           account_id = credentials['X-Server-Management-Url'].match(/.*\/([\d]+)$/)[1]
           @path = "#{@path}/#{account_id}"

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/models/compute/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute/flavor'
+
+module Fog
+  module Compute
+    class Rackspace
+
+      class Flavors < Fog::Collection
+
+        model Fog::Compute::Rackspace::Flavor
+
+        def all
+          data = connection.list_flavors_detail.body['flavors']
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = connection.get_flavor_details(flavor_id).body['flavor']
+          new(data)
+        rescue Fog::Compute::Rackspace::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/models/compute/images.rb

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute/image'
+
+module Fog
+  module Compute
+    class Rackspace
+
+      class Images < Fog::Collection
+
+        model Fog::Compute::Rackspace::Image
+
+        attribute :server
+
+        def all
+          data = connection.list_images_detail.body['images']
+          load(data)
+          if server
+            self.replace(self.select {|image| image.server_id == server.id})
+          end
+        end
+
+        def get(image_id)
+          data = connection.get_image_details(image_id).body['image']
+          new(data)
+        rescue Fog::Compute::Rackspace::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/models/compute/servers.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute/server'
+
+module Fog
+  module Compute
+    class Rackspace
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::Rackspace::Server
+
+        def all
+          data = connection.list_servers_detail.body['servers']
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server.setup(:password => server.password)
+          server
+        end
+
+        def get(server_id)
+          if server = connection.get_server_details(server_id).body['server']
+            new(server)
+          end
+        rescue Fog::Compute::Rackspace::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end