bbcloud 0.11.2 → 0.12.0

data/lib/bbcloud/vendor/fog/lib/fog/core/connection.rb

@@ -1,35 +0,0 @@
-module Fog
-  class Connection
-
-    def initialize(url, persistent=false, params={})
-      @excon = Excon.new(url, params)
-      @persistent = persistent
-    end
-
-    def request(params, &block)
-      unless @persistent
-        reset
-      end
-      unless block_given?
-        if (parser = params.delete(:parser))
-          body = Nokogiri::XML::SAX::PushParser.new(parser)
-          block = lambda { |chunk| body << chunk }
-        end
-      end
-
-      response = @excon.request(params, &block)
-
-      if parser
-        body.finish
-        response.body = parser.response
-      end
-
-      response
-    end
-
-    def reset
-      @excon.reset
-    end
-
-  end
-end

data/lib/bbcloud/vendor/fog/lib/fog/core/credentials.rb

@@ -1,92 +0,0 @@
-require 'yaml'
-
-module Fog
-  require 'fog/core/deprecation'
-
-  # Assign a new credential to use from configuration file
-  #   @param [String, Symbol] new_credential name of new credential to use
-  #   @ return [String, Symbol] name of the new credential
-  def self.credential=(new_credential)
-    @credentials = nil
-    @credential = new_credential
-  end
-
-  # @return [String, Symbol] The credential to use in Fog
-  def self.credential
-    @credential ||= :default
-  end
-
-  # @return [String] The path for configuration_file
-  def self.credentials_path
-    @credential_path ||= File.expand_path(ENV["FOG_RC"] || '~/.fog')
-  end
-
-  # @return [String] The new path for credentials file
-  def self.credentials_path=(new_credentials_path)
-    @credentials = nil
-    @credential_path = new_credentials_path
-  end
-
-  # @return [Hash] The credentials pulled from the configuration file
-  # @raise [LoadError] Configuration unavailable in configuration file
-  def self.credentials
-    @credentials  ||= begin
-      if File.exists?(credentials_path)
-        credentials = YAML.load_file(credentials_path)
-        (credentials && credentials[credential]) or raise LoadError.new(missing_credentials)
-      else
-        {}
-      end
-    end
-  end
-
-private
-
-  # @return [String] The error message that will be raised, if credentials cannot be found
-  def self.missing_credentials
-    <<-YML
-Missing Credentials
-
-To run as '#{credential}', add the following to your resource config file: #{credentials_path}
-An alternate file may be used by placing its path in the FOG_RC environment variable
-
-#######################################################
-# Fog Credentials File
-#
-# Key-value pairs should look like:
-# :aws_access_key_id:                 022QF06E7MXBSAMPLE
-:#{credential}:
-  :aws_access_key_id:
-  :aws_secret_access_key:
-  :bluebox_api_key:
-  :bluebox_customer_id:
-  :brightbox_client_id:
-  :brightbox_secret:
-  :go_grid_api_key:
-  :go_grid_shared_secret:
-  :google_storage_access_key_id:
-  :google_storage_secret_access_key:
-  :linode_api_key:
-  :local_root:
-  :new_servers_password:
-  :new_servers_username:
-  :public_key_path:
-  :private_key_path:
-  :rackspace_api_key:
-  :rackspace_username:
-  :slicehost_password:
-  :terremark_username:
-  :terremark_password:
-  :voxel_api_key:
-  :voxel_api_secret:
-  :zerigo_email:
-  :zerigo_token:
-  :dnsimple_email:
-  :dnsimple_password:
-#
-# End of Fog Credentials File
-#######################################################
-
-YML
-  end
-end

data/lib/bbcloud/vendor/fog/lib/fog/core/deprecation.rb

@@ -1,23 +0,0 @@
-module Fog
-  module Deprecation
-
-    def deprecate(older, newer)
-      module_eval <<-EOS, __FILE__, __LINE__
-        def #{older}(*args)
-          Formatador.display_line("[yellow][WARN] #{self} => ##{older} is deprecated, use ##{newer} instead[/] [light_black](#{caller.first})[/]")
-          send(:#{newer}, *args)
-        end
-      EOS
-    end
-
-    def self_deprecate(older, newer)
-      module_eval <<-EOS, __FILE__, __LINE__
-        def self.#{older}(*args)
-          Formatador.display_line("[yellow][WARN] #{self} => ##{older} is deprecated, use ##{newer} instead[/] [light_black](#{caller.first})[/]")
-          send(:#{newer}, *args)
-        end
-      EOS
-    end
-
-  end
-end

data/lib/bbcloud/vendor/fog/lib/fog/core/errors.rb

@@ -1,20 +0,0 @@
-module Fog
-  module Errors
-
-    class Error < StandardError
-      attr_accessor :verbose
-
-      def self.slurp(error, message = nil)
-        new_error = new(message)
-        new_error.set_backtrace(error.backtrace)
-        new_error.verbose = error.message
-        new_error
-      end
-    end
-
-    class MockNotImplemented < Fog::Errors::Error; end
-
-    class NotFound < Fog::Errors::Error; end
-
-  end
-end

data/lib/bbcloud/vendor/fog/lib/fog/core/hmac.rb

@@ -1,48 +0,0 @@
-module Fog
-  class HMAC
-
-    def initialize(type, key)
-      @key = key
-      case type
-      when 'sha1'
-        setup_sha1
-      when 'sha256'
-        setup_sha256
-      end
-    end
-
-    def sign(data)
-      @signer.call(data)
-    end
-
-    private
-
-    def setup_sha1
-      @digest = OpenSSL::Digest::Digest.new('sha1')
-      @signer = lambda do |data|
-        OpenSSL::HMAC.digest(@digest, @key, data)
-      end
-    end
-
-    def setup_sha256
-      begin
-        @digest = OpenSSL::Digest::Digest.new('sha256')
-        @signer = lambda do |data|
-          OpenSSL::HMAC.digest(@digest, @key, data)
-        end
-      rescue RuntimeError => error
-        unless error.message == 'Unsupported digest algorithm (sha256).'
-          raise error
-        else
-          require 'hmac-sha2'
-          @hmac = ::HMAC::SHA256.new(@key)
-          @signer = lambda do |data|
-            @hmac.update(data)
-            @hmac.digest
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/bbcloud/vendor/fog/lib/fog/core/mock.rb

@@ -1,68 +0,0 @@
-module Fog
-
-  @mocking = false
-
-  def self.mock!
-    @mocking = true
-  end
-
-  def self.mock?
-    @mocking
-  end
-
-  def self.mocking?
-    @mocking
-  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
-
-    def self.random_base64(length)
-      random_selection(
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-        length
-      )
-    end
-
-    def self.random_hex(length)
-      max = ('f' * length).to_i(16)
-      rand(max).to_s(16).rjust(length, '0')
-    end
-
-    def self.random_letters(length)
-      random_selection(
-        'abcdefghijklmnopqrstuvwxyz',
-        length
-      )
-    end
-
-    def self.random_numbers(length)
-      max = ('9' * length).to_i
-      rand(max).to_s
-    end
-
-    def self.random_selection(characters, length)
-      selection = ''
-      length.times do
-        position = rand(characters.length)
-        selection << characters[position..position]
-      end
-      selection
-    end
-
-  end
-
-end

data/lib/bbcloud/vendor/fog/lib/fog/core/model.rb

@@ -1,57 +0,0 @@
-module Fog
-  class Model
-
-    extend Fog::Attributes::ClassMethods
-    include Fog::Attributes::InstanceMethods
-
-    attr_accessor :collection, :connection
-
-    def initialize(new_attributes = {})
-      merge_attributes(new_attributes)
-    end
-
-    def inspect
-      Thread.current[:formatador] ||= Formatador.new
-      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}"
-      Thread.current[:formatador].indent do
-        unless self.class.attributes.empty?
-          data << "\n#{Thread.current[:formatador].indentation}"
-          data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
-        end
-      end
-      data << "\n#{Thread.current[:formatador].indentation}>"
-      data
-    end
-
-    def reload
-      requires :identity
-      if data = collection.get(identity)
-        new_attributes = data.attributes
-        merge_attributes(new_attributes)
-        self
-      end
-    end
-
-    def to_json
-      require 'json'
-      attributes.to_json
-    end
-
-    def wait_for(timeout=600, interval=1, &block)
-      reload
-      Fog.wait_for(timeout, interval) do
-        retries = 3
-        if reload
-          retries = 3
-        elsif retries > 0
-          retries -= 1
-          sleep(1)
-        elsif retries == 0
-          raise Fog::Errors::Error.new("Reload failed, #{self.class} #{self.identity} went away.")
-        end
-        instance_eval(&block)
-      end
-    end
-
-  end
-end

data/lib/bbcloud/vendor/fog/lib/fog/core/parser.rb

@@ -1,99 +0,0 @@
-require 'nokogiri'
-
-module Fog
-  module Parsers
-    class Base < Nokogiri::XML::SAX::Document
-
-      attr_reader :response
-
-      def initialize
-        reset
-      end
-
-      def reset
-        @response = {}
-      end
-
-      def characters(string)
-        @value ||= ''
-        @value << string.strip
-      end
-
-      def start_element(name, attrs = [])
-        @value = nil
-      end
-
-      def attr_value(name, attrs)
-        (entry = attrs.detect {|a, v| a == name }) && entry.last
-      end
-
-    end
-  end
-end
-
-module Fog
-  class ToHashDocument < Nokogiri::XML::SAX::Document
-
-    def initialize
-      @stack = []
-    end
-
-    def characters(string)
-      @value ||= ''
-      @value << string.strip
-    end
-
-    def end_element(name)
-      last = @stack.pop
-      if last.empty? && @value.empty?
-        @stack.last[name.to_sym] = ''
-      elsif last == {:i_nil=>"true"}
-        @stack.last[name.to_sym] = nil
-      elsif !@value.empty?
-        @stack.last[name.to_sym] = @value
-      end
-      @value = ''
-    end
-
-    def body
-      @stack.first
-    end
-
-    def response
-      body
-    end
-
-    def start_element(name, attributes = [])
-      @value = ''
-      parsed_attributes = {}
-      until attributes.empty?
-        if attributes.first.is_a?(Array)
-          key, value = attributes.shift
-        else
-          key, value = attributes.shift, attributes.shift
-        end
-        parsed_attributes[key.gsub(':','_').to_sym] = value
-      end
-      if @stack.last.is_a?(Array)
-        @stack.last << {name.to_sym => parsed_attributes}
-      else
-        data = if @stack.empty?
-          @stack.push(parsed_attributes)
-          parsed_attributes
-        elsif @stack.last[name.to_sym]
-          unless @stack.last[name.to_sym].is_a?(Array)
-            @stack.last[name.to_sym] = [@stack.last[name.to_sym]]
-          end
-          @stack.last[name.to_sym] << parsed_attributes
-          @stack.last[name.to_sym].last
-        else
-          @stack.last[name.to_sym] = {}
-          @stack.last[name.to_sym].merge!(parsed_attributes)
-          @stack.last[name.to_sym]
-        end
-        @stack.push(data)
-      end
-    end
-
-  end
-end