bbcloud 0.8 → 0.8.1

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

@@ -0,0 +1,93 @@
+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
+
+    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-0.3.23/lib/fog/core/provider.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Provider
+
+    def service_path(new_path)
+      @service_path = new_path
+    end
+
+    def service(new_service)
+      services << new_service
+      require File.join(@service_path, new_service.to_s)
+    end
+
+    def services
+      @services ||= []
+    end
+
+  end
+end

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

@@ -0,0 +1,152 @@
+module Fog
+  class Service
+
+    class Error < Fog::Errors::Error; end
+    class NotFound < Fog::Errors::NotFound; end
+
+    module Collections
+
+      def collections
+        service.collections
+      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={})
+        if Fog.bin
+          default_credentials = Fog.credentials.reject {|key, value| !requirements.include?(key)}
+          options = default_credentials.merge(options)
+        end
+
+        validate_arguments(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('/')
+          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 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 validate_arguments(options)
+        missing = requirements - options.keys
+        unless missing.empty?
+          raise ArgumentError, "Missing required arguments: #{missing.join(', ')}"
+        end
+
+        # FIXME: avoid failing for the services that don't have recognizes yet
+        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-0.3.23/lib/fog/core/ssh.rb

@@ -0,0 +1,117 @@
+module Fog
+  module SSH
+
+    def self.new(address, username, options = {})
+      unless options[:key_data] || options[:keys] || options[:password]
+        raise ArgumentError.new(':key_data, :keys or :password are required to initialize SSH')
+      end
+      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'
+        @address  = address
+        @username = username
+        @options  = options.merge(:paranoid => false)
+        @options.merge(:verbose => true)
+      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-0.3.23/lib/fog/core/storage.rb

@@ -0,0 +1,24 @@
+module Fog
+  class Storage
+
+    def self.new(attributes)
+      case provider = attributes.delete(:provider)
+      when 'AWS'
+        require 'fog/aws'
+        Fog::AWS::Storage.new(attributes)
+      when 'Google'
+        require 'fog/google'
+        Fog::Google::Storage.new(attributes)
+      when 'Local'
+        require 'fog/local'
+        Fog::Local::Storage.new(attributes)
+      when 'Rackspace'
+        require 'fog/rackspace'
+        Fog::Rackspace::Storage.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized storage provider")
+      end
+    end
+
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/core.rb

@@ -0,0 +1,13 @@
+require 'fog/core/attributes'
+require 'fog/core/collection'
+require 'fog/core/compute'
+require 'fog/core/connection'
+require 'fog/core/deprecation'
+require 'fog/core/errors'
+require 'fog/core/hmac'
+require 'fog/core/model'
+# require 'fog/core/parser'
+require 'fog/core/provider'
+require 'fog/core/service'
+require 'fog/core/ssh'
+require 'fog/core/storage'

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/go_grid/bin.rb

@@ -0,0 +1,25 @@
+class GoGrid < Fog::Bin
+  class << self
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::GoGrid::Compute.new
+        when :servers
+          location = caller.first
+          warning = "[yellow][WARN] GoGrid[:servers] is deprecated, use GoGrid[:compute] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::GoGrid::Compute.new
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:compute]
+    end
+
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/go_grid/compute.rb

@@ -0,0 +1,103 @@
+module Fog
+  module GoGrid
+    class Compute < Fog::Service
+
+      requires :go_grid_api_key
+      requires :go_grid_shared_secret
+
+      model_path 'fog/go_grid/models/compute'
+      model         :image
+      collection    :images
+      model         :server
+      collection    :servers
+
+      request_path 'fog/go_grid/requests/compute'
+      request :common_lookup_list
+      request :grid_image_get
+      request :grid_image_list
+      request :grid_ip_list
+      request :grid_loadbalancer_list
+      request :grid_server_add
+      request :grid_server_delete
+      request :grid_server_get
+      request :grid_server_list
+      request :grid_server_power
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @go_grid_api_key = options[:go_grid_api_key]
+          @go_grid_shared_secret = options[:go_grid_shared_secret]
+          @data = self.class.data[@go_grid_api_key]
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          require 'digest/md5'
+          require 'json'
+          @go_grid_api_key = options[:go_grid_api_key]
+          @go_grid_shared_secret = options[:go_grid_shared_secret]
+          @host   = options[:host]    || "api.gogrid.com"
+          @path   = options[:path]    || "/api"
+          @port   = options[:port]    || 443
+          @scheme = options[:scheme]  || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params = {
+            :expects  => 200,
+            :method   => 'GET'
+          }.merge!(params)
+
+          params[:query] ||= {}
+          params[:query].merge!({
+            'api_key' => @go_grid_api_key,
+            'format'  => 'json',
+            'sig'     => Digest::MD5.hexdigest("#{@go_grid_api_key}#{@go_grid_shared_secret}#{Time.now.to_i}"),
+            'v'       => '1.5'
+          })
+
+          begin
+            response = @connection.request(
+              params.merge!(:path => "#{@path}/#{params[:path]}")
+            )
+          rescue Excon::Errors::Error => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::GoGrid::Compute::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+
+          unless response.body.empty?
+            response.body = JSON.parse(response.body)
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/go_grid/models/compute/image.rb

@@ -0,0 +1,60 @@
+require 'fog/core/model'
+
+module Fog
+  module GoGrid
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :description
+        attribute :friendly_name, :aliases => 'friendlyName'
+        attribute :created_at,    :aliases => 'createdTime'
+        attribute :updated_at,    :aliases => 'updatedTime'
+        attribute :server_id,     :aliases => 'id'
+        attribute :state
+        attribute :price
+        attribute :location
+        attribute :billingtokens
+        attribute :os
+        attribute :architecture
+        attribute :type
+        attribute :active,        :aliases => 'isActive'
+        attribute :public,        :aliases => 'isPublic'
+        attribute :object_type,   :aliases => 'object'
+        attribute :owner
+
+
+        def server=(new_server)
+          requires :id
+
+          @server_id = new_server.id
+        end
+
+        def destroy
+          requires :id
+
+          connection.grid_server_delete(id)
+          true
+        end
+
+        def ready?
+          status == 'Available'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :server_id
+
+          data = connection.grid_server_add(server_id, 'name' => name)
+          merge_attributes(data.body['image'])
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/go_grid/models/compute/images.rb

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

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/go_grid/models/compute/server.rb

@@ -0,0 +1,56 @@
+require 'fog/core/model'
+
+module Fog
+  module GoGrid
+    class Compute
+
+      class BlockInstantiationError < StandardError; end
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :image_id        # id or name
+        attribute :ip
+        attribute :memory       # server.ram
+        attribute :state
+        attribute :description  # Optional
+        attribute :sandbox      # Optional. Default: False
+
+        def initialize(attributes={})
+          super
+        end
+
+        def destroy
+          requires :id
+          connection.grid_server_destroy(id)
+          true
+        end
+
+        def image
+          requires :image_id
+          connection.grid_image_get(image_id)
+        end
+
+        def ready?
+          @state == 'On'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :name, :image_id, :ip, :memory
+          options['isSandbox'] = sandbox if sandbox
+          options['server.ram'] = memory
+          options['image'] = image_id
+          data = connection.grid_server_add(name, image, ip, options)
+          merge_attributes(data.body)
+          true
+        end
+
+      end
+
+    end
+
+  end
+end