brightbox-cli 0.13.1 → 0.14.0

data/lib/brightbox-cli/vendor/fog/lib/fog/ninefold/storage.rb

@@ -0,0 +1,152 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'ninefold'))
+require 'fog/storage'
+
+module Fog
+  module Storage
+    class Ninefold < Fog::Service
+      STORAGE_HOST = "onlinestorage.ninefold.com" #"api.ninefold.com"
+      STORAGE_PATH = "" #"/storage/v1.0"
+      STORAGE_PORT = "80" # "443"
+      STORAGE_SCHEME = "http" # "https"
+
+      requires :ninefold_storage_token, :ninefold_storage_secret
+
+      model_path 'fog/ninefold/models/storage'
+      model       :directory
+      collection  :directories
+      model       :file
+      collection  :files
+
+      request_path 'fog/ninefold/requests/storage'
+      # request :delete_container
+      request :get_namespace
+      request :post_namespace
+      request :put_namespace
+      request :delete_namespace
+
+      module Utils
+      end
+
+      class Mock
+        include Utils
+
+        def initialize(options={})
+          require 'mime/types'
+          @ninefold_storage_token = options[:ninefold_storage_token]
+          @ninefold_storage_secret = options[:ninefold_storage_secret]
+        end
+
+        def request(options)
+          raise "Ninefold Storage mocks not implemented"
+        end
+
+      end
+
+      class Real
+        include Utils
+
+        def initialize(options={})
+          require 'mime/types'
+          @ninefold_storage_token = options[:ninefold_storage_token]
+          @ninefold_storage_secret = options[:ninefold_storage_secret]
+          @ninefold_storage_secret_decoded = Base64.decode64( @ninefold_storage_secret )
+
+          @connection_options = options[:connection_options] || {}
+          @hmac               = Fog::HMAC.new('sha1', @ninefold_storage_secret_decoded)
+          @persistent         = options[:persistent] || true
+
+          @connection = Fog::Connection.new("#{Fog::Storage::Ninefold::STORAGE_SCHEME}://#{Fog::Storage::Ninefold::STORAGE_HOST}:#{Fog::Storage::Ninefold::STORAGE_PORT}", @persistent, @connection_options)
+        end
+
+        def uid
+          @ninefold_storage_token#.split('/')[-1]
+        end
+
+        def sign(string)
+          value = @hmac.sign(string)
+          Base64.encode64( value ).chomp()
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params, &block)
+          req_path = params[:path]
+          # Force set host and port
+          params.merge!({
+                          :host     => Fog::Storage::Ninefold::STORAGE_HOST,
+                          :path     => "#{Fog::Storage::Ninefold::STORAGE_PATH}/rest/#{params[:path]}",
+                        })
+          # Set default method and headers
+          params = {:method => 'GET', :headers => {}}.merge params
+
+          params[:headers]["Content-Type"] ||= "application/octet-stream"
+
+          # Add request date
+          params[:headers]["date"] = Time.now().httpdate()
+          params[:headers]["x-emc-uid"] = @ninefold_storage_token
+
+          # Build signature string
+          signstring = ""
+          signstring += params[:method]
+          signstring += "\n"
+          signstring += params[:headers]["Content-Type"]
+          signstring += "\n"
+          if( params[:headers]["range"] )
+            signstring += params[:headers]["range"]
+          end
+          signstring += "\n"
+          signstring += params[:headers]["date"]
+          signstring += "\n"
+
+          signstring += "/rest/" + URI.unescape( req_path ).downcase
+          query_str = params[:query].map{|k,v| "#{k}=#{v}"}.join('&')
+          signstring += '?' + query_str unless query_str.empty?
+          signstring += "\n"
+
+          customheaders = {}
+          params[:headers].each { |key,value|
+            if key == "x-emc-date"
+              #skip
+            elsif key =~ /^x-emc-/
+              customheaders[ key.downcase ] = value
+            end
+          }
+          header_arr = customheaders.sort()
+          first = true
+          header_arr.each { |key,value|
+            # Values are lowercase and whitespace-normalized
+            signstring += key + ":" + value.strip.chomp.squeeze( " " ) + "\n"
+          }
+
+          digest = @hmac.sign(signstring.chomp())
+          signature = Base64.encode64( digest ).chomp()
+          params[:headers]["x-emc-signature"] = signature
+
+          begin
+            response = @connection.request(params, &block)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Storage::Ninefold::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          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
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/providers.rb

@@ -1,28 +1,24 @@
-module Fog
-
-  def self.providers
-    @providers ||= []
-  end
-
-end
-
-require 'fog/providers/aws'
-require 'fog/providers/bluebox'
-require 'fog/providers/brightbox'
-require 'fog/providers/dnsimple'
-require 'fog/providers/dnsmadeeasy'
-require 'fog/providers/dynect'
-require 'fog/providers/ecloud'
-require 'fog/providers/go_grid'
-require 'fog/providers/google'
-require 'fog/providers/linode'
-require 'fog/providers/local'
-require 'fog/providers/new_servers'
-require 'fog/providers/ninefold'
-require 'fog/providers/rackspace'
-require 'fog/providers/slicehost'
-require 'fog/providers/storm_on_demand'
-require 'fog/providers/vcloud'
-require 'fog/providers/virtual_box'
-require 'fog/providers/voxel'
-require 'fog/providers/zerigo'
+require 'fog/aws'
+require 'fog/bluebox'
+require 'fog/brightbox'
+require 'fog/dnsimple'
+require 'fog/dnsmadeeasy'
+require 'fog/dynect'
+require 'fog/ecloud'
+require 'fog/glesys'
+require 'fog/go_grid'
+require 'fog/google'
+require 'fog/libvirt'
+require 'fog/linode'
+require 'fog/local'
+require 'fog/new_servers'
+require 'fog/ninefold'
+require 'fog/rackspace'
+require 'fog/slicehost'
+require 'fog/storm_on_demand'
+require 'fog/vcloud'
+require 'fog/virtual_box'
+require 'fog/vmfusion'
+require 'fog/vsphere'
+require 'fog/voxel'
+require 'fog/zerigo'

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

@@ -0,0 +1,81 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+
+module Fog
+  module Rackspace
+    extend Fog::Provider
+
+    module Errors
+      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 Conflict < ServiceError; end
+      class NotFound < ServiceError; end
+      class ServiceUnavailable < 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
+    end
+
+    service(:cdn,             'rackspace/cdn')
+    service(:compute,         'rackspace/compute')
+    service(:dns,             'rackspace/dns')
+    service(:storage,         'rackspace/storage')
+    service(:load_balancers,  'rackspace/load_balancers')
+
+    def self.authenticate(options, connection_options = {})
+      rackspace_auth_url = options[:rackspace_auth_url] || "auth.api.rackspacecloud.com"
+      url = rackspace_auth_url.match(/^https?:/) ? \
+                rackspace_auth_url : 'https://' + rackspace_auth_url
+      uri = URI.parse(url)
+      connection = Fog::Connection.new(url, false, connection_options)
+      @rackspace_api_key  = options[:rackspace_api_key]
+      @rackspace_username = options[:rackspace_username]
+      response = connection.request({
+        :expects  => [200, 204],
+        :headers  => {
+          'X-Auth-Key'  => @rackspace_api_key,
+          'X-Auth-User' => @rackspace_username
+        },
+        :host     => uri.host,
+        :method   => 'GET',
+        :path     =>  (uri.path and not uri.path.empty?) ? uri.path : 'v1.0'
+      })
+      response.headers.reject do |key, value|
+        !['X-Server-Management-Url', 'X-Storage-Url', 'X-CDN-Management-Url', 'X-Auth-Token'].include?(key)
+      end
+    end
+
+    # CGI.escape, but without special treatment on spaces
+    def self.escape(str,extra_exclude_chars = '')
+      str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
+        '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rackspace'))
+require 'fog/cdn'
+
+module Fog
+  module CDN
+    class Rackspace < Fog::Service
+
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url, :persistent
+
+      model_path 'fog/rackspace/models/cdn'
+
+      request_path 'fog/rackspace/requests/cdn'
+      request :get_containers
+      request :head_container
+      request :post_container
+      request :put_container
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @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'
+          @connection_options = options[:connection_options] || {}
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
+          @auth_token = credentials['X-Auth-Token']
+          @enabled = false
+          @persistent = options[:persistent] || false
+
+          if credentials['X-CDN-Management-Url']
+            uri = URI.parse(credentials['X-CDN-Management-Url'])
+            @host   = uri.host
+            @path   = uri.path
+            @port   = uri.port
+            @scheme = uri.scheme
+            @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+            @enabled = true
+          end
+        end
+
+        def enabled?
+          @enabled
+        end
+
+        def reload
+          @cdn_connection.reset
+        end
+
+        def request(params, parse_json = true)
+          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]}",
+            }))
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Storage::Rackspace::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+
+      end
+    end
+  end
+end