bbcloud 0.11.2 → 0.12.0

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

@@ -1,18 +0,0 @@
-module Fog
-  module Provider
-
-    def self.extended(base)
-      Fog.providers << base.to_s.split('::').last
-    end
-
-    def service(new_service, path)
-      services << new_service
-      require File.join('fog', path)
-    end
-
-    def services
-      @services ||= []
-    end
-
-  end
-end

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

@@ -1,67 +0,0 @@
-module Fog
-  module SCP
-
-    def self.new(address, username, options = {})
-      if Fog.mocking?
-        Fog::SCP::Mock.new(address, username, options)
-      else
-        Fog::SCP::Real.new(address, username, options)
-      end
-    end
-
-    def self.reset_data(keys=Mock.data.keys)
-      Mock.reset_data(keys)
-    end
-
-    class Mock
-
-      def self.data
-        @data ||= Hash.new do |hash, key|
-          hash[key] = {}
-        end
-      end
-
-      def initialize(address, username, options)
-        @address  = address
-        @username = username
-        @options  = options
-      end
-
-      def upload(local_path, remote_path)
-        Fog::Mock.not_implemented
-      end
-
-    end
-
-    class Real
-
-      def initialize(address, username, options)
-        require 'net/scp'
-
-        key_manager = Net::SSH::Authentication::KeyManager.new(nil, options)
-
-        unless options[:key_data] || options[:keys] || options[:password] || key_manager.agent
-          raise ArgumentError.new(':key_data, :keys, :password or a loaded ssh-agent is required to initialize SSH')
-        end
-
-        @address  = address
-        @username = username
-        @options  = { :paranoid => false }.merge(options)
-      end
-
-      def upload(local_path, remote_path)
-        begin
-          Net::SCP.start(@address, @username, @options) do |scp|
-            scp.upload!(local_path, remote_path) do |ch, name, sent, total|
-              # TODO: handle progress display?
-            end
-          end
-        rescue Exception => error
-          raise error
-        end
-      end
-
-    end
-
-  end
-end

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

@@ -1,175 +0,0 @@
-module Fog
-  class Service
-
-    class Error < Fog::Errors::Error; end
-    class NotFound < Fog::Errors::NotFound; end
-
-    module Collections
-
-      def collections
-        service.collections
-      end
-
-      def mocked_requests
-        service.mocked_requests
-      end
-
-      def requests
-        service.requests
-      end
-
-    end
-
-    class << self
-
-      def inherited(child)
-        child.class_eval <<-EOS, __FILE__, __LINE__
-          module Collections
-            include Fog::Service::Collections
-
-            def service
-              #{child}
-            end
-          end
-
-          def self.service
-            #{child}
-          end
-        EOS
-      end
-
-      def new(options={})
-        # attempt to load credentials from config file
-        begin
-          default_credentials = Fog.credentials.reject {|key, value| !(recognized | requirements).include?(key)}
-          options = default_credentials.merge(options)
-        rescue LoadError
-          # if there are no configured credentials, do nothing
-        end
-
-        validate_options(options)
-        setup_requirements
-
-        if Fog.mocking?
-          service::Mock.send(:include, service::Collections)
-          service::Mock.new(options)
-        else
-          service::Real.send(:include, service::Collections)
-          service::Real.new(options)
-        end
-      end
-
-      def setup_requirements
-        if superclass.respond_to?(:setup_requirements)
-          superclass.setup_requirements
-        end
-
-        @required ||= false
-        unless @required
-          for collection in collections
-            require [@model_path, collection].join('/')
-            constant = collection.to_s.split('_').map {|characters| characters[0...1].upcase << characters[1..-1]}.join('')
-            service::Collections.module_eval <<-EOS, __FILE__, __LINE__
-              def #{collection}(attributes = {})
-                #{service}::#{constant}.new({:connection => self}.merge(attributes))
-              end
-            EOS
-          end
-          for model in models
-            require [@model_path, model].join('/')
-          end
-          for request in requests
-            require [@request_path, request].join('/')
-            if service::Mock.method_defined?(request)
-              mocked_requests << request
-            else
-              service::Mock.module_eval <<-EOS, __FILE__, __LINE__
-                def #{request}(*args)
-                  Fog::Mock.not_implemented
-                end
-              EOS
-            end
-          end
-          @required = true
-        end
-      end
-
-      def model_path(new_path)
-        @model_path = new_path
-      end
-
-      def collection(new_collection)
-        collections << new_collection
-      end
-
-      def collections
-        @collections ||= []
-      end
-
-      def mocked_requests
-        @mocked_requests ||= []
-      end
-
-      def model(new_model)
-        models << new_model
-      end
-
-      def models
-        @models ||= []
-      end
-
-      def request_path(new_path)
-        @request_path = new_path
-      end
-
-      def request(new_request)
-        requests << new_request
-      end
-
-      def requests
-        @requests ||= []
-      end
-
-      def requires(*args)
-        requirements.concat(args)
-      end
-
-      def requirements
-        @requirements ||= []
-      end
-
-      def recognizes(*args)
-        recognized.concat(args)
-      end
-
-      def recognized
-        @recognized ||= []
-      end
-
-      def reset_data(keys=Mock.data.keys)
-        Mock.reset_data(keys)
-      end
-
-      def reset_data(keys=Mock.data.keys)
-        Mock.reset_data(keys)
-      end
-
-      def validate_options(options)
-        missing = requirements - options.keys
-        unless missing.empty?
-          raise ArgumentError, "Missing required arguments: #{missing.join(', ')}"
-        end
-
-        unless recognizes.empty?
-          unrecognized = options.keys - requirements - recognized
-          unless unrecognized.empty?
-            raise ArgumentError, "Unrecognized arguments: #{unrecognized.join(', ')}"
-          end
-        end
-      end
-
-    end
-
-  end
-end
-

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

@@ -1,120 +0,0 @@
-module Fog
-  module SSH
-
-    def self.new(address, username, options = {})
-      if Fog.mocking?
-        Fog::SSH::Mock.new(address, username, options)
-      else
-        Fog::SSH::Real.new(address, username, options)
-      end
-    end
-
-    def self.reset_data(keys=Mock.data.keys)
-      Mock.reset_data(keys)
-    end
-
-    class Mock
-
-      def self.data
-        @data ||= Hash.new do |hash, key|
-          hash[key] = {}
-        end
-      end
-
-      def initialize(address, username, options)
-        @address  = address
-        @username = username
-        @options  = options
-      end
-
-      def run(commands)
-        Fog::Mock.not_implemented
-      end
-
-    end
-
-    class Real
-
-      def initialize(address, username, options)
-        require 'net/ssh'
-
-        key_manager = Net::SSH::Authentication::KeyManager.new(nil, options)
-
-        unless options[:key_data] || options[:keys] || options[:password] || key_manager.agent
-          raise ArgumentError.new(':key_data, :keys, :password or a loaded ssh-agent is required to initialize SSH')
-        end
-
-        @address  = address
-        @username = username
-        @options  = { :paranoid => false }.merge(options)
-      end
-
-      def run(commands)
-        commands = [*commands]
-        results  = []
-        begin
-          Net::SSH.start(@address, @username, @options) do |ssh|
-            commands.each do |command|
-              escaped_command = command.sub(/'/, %{'"'"'})
-              result = Result.new(escaped_command)
-              ssh.open_channel do |ssh_channel|
-                ssh_channel.request_pty
-                ssh_channel.exec(%{bash -lc '#{escaped_command}'}) do |channel, success|
-                  unless success
-                    raise "Could not execute command: #{command.inspect}"
-                  end
-
-                  channel.on_data do |ch, data|
-                    result.stdout << data
-                  end
-
-                  channel.on_extended_data do |ch, type, data|
-                    next unless type == 1
-                    result.stderr << data
-                  end
-
-                  channel.on_request('exit-status') do |ch, data|
-                    result.status = data.read_long
-                  end
-
-                  channel.on_request('exit-signal') do |ch, data|
-                    result.status = 255
-                  end
-                end
-              end
-              ssh.loop
-              results << result
-            end
-          end
-        rescue Net::SSH::HostKeyMismatch => exception
-          exception.remember_host!
-          sleep 0.2
-          retry
-        end
-        results
-      end
-
-    end
-
-    class Result
-
-      attr_accessor :command, :stderr, :stdout, :status
-
-      def display_stdout
-        Formatador.display_line(stdout.split("\r\n"))
-      end
-
-      def display_stderr
-        Formatador.display_line(stderr.split("\r\n"))
-      end
-
-      def initialize(command)
-        @command = command
-        @stderr = ''
-        @stdout = ''
-      end
-
-    end
-
-  end
-end

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

@@ -1,27 +0,0 @@
-module Fog
-  class Time < ::Time
-
-    DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
-    MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-
-    def self.now
-      at((::Time.now - offset).to_i)
-    end
-
-    def self.now=(new_now)
-      old_now = ::Time.now
-      @offset = old_now - new_now
-      new_now
-    end
-
-    def self.offset
-      @offset ||= 0
-    end
-
-    def to_date_header
-      now = self.class.now.utc
-      now.strftime("#{DAYS[now.wday]}, %d #{MONTHS[now.month - 1]} %Y %H:%M:%S +0000")
-    end
-
-  end
-end

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

@@ -1,17 +0,0 @@
-module Fog
-
-  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

data/lib/bbcloud/vendor/fog/lib/fog/providers.rb

@@ -1,9 +0,0 @@
-module Fog
-
-  def self.providers
-    @providers ||= []
-  end
-
-end
-
-require 'fog/providers/brightbox'

data/lib/bbcloud/vendor/fog/lib/fog/providers/brightbox.rb

@@ -1,9 +0,0 @@
-require 'fog/core'
-
-module Fog
-  module Brightbox
-    extend Fog::Provider
-
-    service(:compute, 'compute/brightbox')
-  end
-end