bbcloud 0.10.1 → 0.11.0

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

@@ -0,0 +1,99 @@
+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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,175 @@
+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

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,17 @@
+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/core.rb

@@ -0,0 +1,32 @@
+__LIB_DIR__ = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+$LOAD_PATH.unshift __LIB_DIR__ unless
+  $LOAD_PATH.include?(__LIB_DIR__) ||
+  $LOAD_PATH.include?(File.expand_path(__LIB_DIR__))
+
+# external core dependencies
+require 'rubygems'
+require 'base64'
+require 'cgi'
+require 'excon'
+require 'formatador'
+require 'time'
+require 'timeout'
+
+# internal core dependencies
+require 'fog/core/attributes'
+require 'fog/core/collection'
+require 'fog/core/connection'
+require 'fog/core/credentials'
+require 'fog/core/deprecation'
+require 'fog/core/errors'
+require 'fog/core/hmac'
+require 'fog/core/model'
+require 'fog/core/mock'
+# require 'fog/core/parser'
+require 'fog/core/provider'
+require 'fog/core/service'
+require 'fog/core/ssh'
+require 'fog/core/scp'
+require 'fog/core/time'
+require 'fog/core/wait_for'

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

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

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

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

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

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'fog', 'core')
+
+module Fog
+
+  unless const_defined?(:VERSION)
+    VERSION = '0.6.0'
+  end
+
+end
+
+# FIXME: these should go away (force usage of Fog::[Compute, CDN, DNS, Storage]  etc)
+require 'fog/providers'
+
+require 'fog/compute'

data/lib/bbcloud/version.rb

@@ -1,3 +1,3 @@
 module Brightbox
-  VERSION = "0.10.1"
+  VERSION = "0.11.0"
 end