fog 1.41.0 → 2.3.0

data/gemfiles/Gemfile-1.9

@@ -1,16 +0,0 @@
-source "https://rubygems.org"
-
-gem "nokogiri", "1.6.8.1"
-gem "rake", "10.5.0"
-gem "rest-client", "1.8.0"
-gem "term-ansicolor", "1.3.2"
-gem "tins", "1.6.0"
-gem "public_suffix", "1.4.6"
-
-group :development, :test do
-  gem "coveralls", :require => false
-  gem "netrc", :require => false
-  gem "octokit", "4.3.0", :require => false
-end
-
-gemspec :path => "../"

data/gemfiles/Gemfile-edge-1.9

@@ -1,20 +0,0 @@
-source "https://rubygems.org"
-
-# Shared components
-gem "fog-core", :github => "fog/fog-core"
-gem "fog-json", :github => "fog/fog-json"
-
-group :development, :test do
-  gem "coveralls", :require => false
-  gem "netrc", :require => false
-  gem "octokit", "4.3.0", :require => false
-end
-
-gem "nokogiri", "1.6.8.1"
-gem "rake", "10.5.0"
-gem "rest-client", "1.8.0"
-gem "term-ansicolor", "1.3.2"
-gem "tins", "1.6.0"
-gem "public_suffix", "1.4.6"
-
-gemspec :path => "../"

data/lib/fog/bin/bluebox.rb

@@ -1,36 +0,0 @@
-class Bluebox < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :compute
-        Fog::Compute::Bluebox
-      when :dns
-        Fog::DNS::Bluebox
-      when :blb
-        Fog::Bluebox::BLB
-      else
-        raise ArgumentError, "Unsupported #{self} service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = case key
-        when :compute
-          Fog::Logger.warning("Bluebox[:compute] is not recommended, use Compute[:bluebox] for portability")
-          Fog::Compute.new(:provider => 'Bluebox')
-        when :dns
-          Fog::Logger.warning("Bluebox[:dns] is not recommended, use DNS[:bluebox] for portability")
-          Fog::DNS.new(:provider => 'Bluebox')
-        else
-          raise ArgumentError, "Unrecognized service: #{service}"
-        end
-      end
-      @@connections[service]
-    end
-
-    def services
-      Fog::Bluebox.services
-    end
-  end
-end

data/lib/fog/bin/ovirt.rb

@@ -1,28 +0,0 @@
-class Ovirt < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :compute
-        Fog::Compute::Ovirt
-      else
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = case key
-                    when :compute
-                      Fog::Compute.new(:provider => 'Ovirt')
-                    else
-                      raise ArgumentError, "Unrecognized service: #{key.inspect}"
-                    end
-      end
-      @@connections[service]
-    end
-
-    def services
-      Fog::Ovirt.services
-    end
-  end
-end

data/lib/fog/bin/zerigo.rb

@@ -1,29 +0,0 @@
-class Zerigo < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :dns
-        Fog::DNS::Zerigo
-      else
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = case key
-        when :dns
-          Fog::Logger.warning("Zerigo[:dns] is not recommended, use DNS[:zerigo] for portability")
-          Fog::DNS.new(:provider => 'Zerigo')
-        else
-          raise ArgumentError, "Unrecognized service: #{key.inspect}"
-        end
-      end
-      @@connections[service]
-    end
-
-    def services
-      Fog::Zerigo.services
-    end
-  end
-end

data/lib/fog/bluebox/blb.rb

@@ -1,82 +0,0 @@
-require 'fog/bluebox/core'
-
-module Fog
-  module Bluebox
-    class BLB < Fog::Service
-      requires :bluebox_api_key, :bluebox_customer_id
-      recognizes :bluebox_host, :bluebox_port, :bluebox_scheme, :persistent
-
-      model_path 'fog/bluebox/models/blb'
-
-      model      :lb_application
-      collection :lb_applications
-
-      model      :lb_service
-      collection :lb_services
-
-      model      :lb_backend
-      collection :lb_backends
-
-      request_path 'fog/bluebox/requests/blb'
-
-      request :get_lb_application
-      request :get_lb_applications
-
-      request :get_lb_service
-      request :get_lb_services
-
-      request :get_lb_backend
-      request :get_lb_backends
-
-      request :add_machine_to_lb_application
-
-      request :add_machine_to_lb_backend
-
-      request :remove_machine_from_lb_backend
-
-      request :update_lb_backend_machine
-
-      class Mock
-      end
-
-      class Real
-        def initialize(options={})
-          @bluebox_api_key      = options[:bluebox_api_key]
-          @bluebox_customer_id  = options[:bluebox_customer_id]
-          @connection_options   = options[:connection_options] || {}
-          @host       = options[:bluebox_host]    || "boxpanel.bluebox.net"
-          @persistent = options[:persistent]      || false
-          @port       = options[:bluebox_port]    || 443
-          @scheme     = options[:bluebox_scheme]  || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:headers] ||= {}
-          params[:headers].merge!({
-            'Authorization' => "Basic #{Base64.encode64([@bluebox_customer_id, @bluebox_api_key].join(':')).delete("\r\n")}"
-          })
-
-          begin
-            response = @connection.request(params)
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::Compute::Bluebox::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-          unless response.body.empty? || params[:headers]['Accept'] == 'text/plain'
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/compute.rb

@@ -1,98 +0,0 @@
-require 'fog/bluebox/core'
-
-module Fog
-  module Compute
-    class Bluebox < Fog::Service
-      requires :bluebox_api_key, :bluebox_customer_id
-      recognizes :bluebox_host, :bluebox_port, :bluebox_scheme, :persistent
-
-      model_path 'fog/bluebox/models/compute'
-      model       :flavor
-      collection  :flavors
-      model       :image
-      collection  :images
-      model       :server
-      collection  :servers
-      model       :location
-      collection  :locations
-
-      request_path 'fog/bluebox/requests/compute'
-      request :create_block
-      request :destroy_block
-      request :get_block
-      request :get_blocks
-      request :get_location
-      request :get_locations
-      request :get_product
-      request :get_products
-      request :get_template
-      request :get_templates
-      request :create_template
-      request :destroy_template
-      request :reboot_block
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @bluebox_api_key = options[:bluebox_api_key]
-        end
-
-        def data
-          self.class.data[@bluebox_api_key]
-        end
-
-        def reset_data
-          self.class.data.delete(@bluebox_api_key)
-        end
-      end
-
-      class Real
-        def initialize(options={})
-          @bluebox_api_key      = options[:bluebox_api_key]
-          @bluebox_customer_id  = options[:bluebox_customer_id]
-          @connection_options   = options[:connection_options] || {}
-          @host       = options[:bluebox_host]    || "boxpanel.bluebox.net"
-          @persistent = options[:persistent]      || false
-          @port       = options[:bluebox_port]    || 443
-          @scheme     = options[:bluebox_scheme]  || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:headers] ||= {}
-          params[:headers].merge!({
-            'Authorization' => "Basic #{Base64.encode64([@bluebox_customer_id, @bluebox_api_key].join(':')).delete("\r\n")}"
-          })
-
-          begin
-            response = @connection.request(params)
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::Compute::Bluebox::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-          unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/core.rb

@@ -1,12 +0,0 @@
-require 'fog/core'
-require 'fog/json'
-
-module Fog
-  module Bluebox
-    extend Fog::Provider
-
-    service(:blb,     'BLB')
-    service(:compute, 'Compute')
-    service(:dns,     'DNS')
-  end
-end

data/lib/fog/bluebox/dns.rb

@@ -1,101 +0,0 @@
-require 'fog/bluebox/core'
-
-module Fog
-  module DNS
-    class Bluebox < Fog::Service
-      requires :bluebox_api_key, :bluebox_customer_id
-      recognizes :bluebox_host, :bluebox_port, :bluebox_scheme, :persistent
-
-      model_path 'fog/bluebox/models/dns'
-      model       :record
-      collection  :records
-      model       :zone
-      collection  :zones
-
-      request_path 'fog/bluebox/requests/dns'
-      request :create_record
-      request :update_record
-      request :delete_record
-      request :create_zone
-      request :update_zone
-      request :delete_zone
-      request :get_record
-      request :get_records
-      request :get_zone
-      request :get_zones
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @bluebox_customer_id = options[:bluebox_customer_id]
-          @bluebox_api_key = options[:bluebox_api_key]
-        end
-
-        def data
-          self.class.data[@bluebox_customer_id]
-        end
-
-        def reset_data
-          self.class.data.delete(@bluebox_customer_id)
-        end
-      end
-
-      class Real
-        def initialize(options ={})
-          @bluebox_customer_id = options[:bluebox_customer_id]
-          @bluebox_api_key = options[:bluebox_api_key]
-          @connection_options     = options[:connection_options] || {}
-          @host       = options[:bluebox_host]    || "boxpanel.bluebox.net"
-          @persistent = options[:persistent]      || false
-          @port       = options[:bluebox_port]    || 443
-          @scheme     = options[:bluebox_scheme]  || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:headers] ||= {}
-
-          params[:headers]['Authorization'] = "Basic #{auth_header}"
-
-          params[:headers]['Accept'] = 'application/xml'
-          case params[:method]
-          when 'POST', 'PUT'
-            params[:headers]['Content-Type'] = 'application/xml'
-          end
-
-          begin
-            response = @connection.request(params)
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::DNS::Bluebox::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-
-          response
-        end
-
-        protected
-
-        def auth_header
-          @auth_header ||= Base64.encode64("#{@bluebox_customer_id}:#{@bluebox_api_key}").gsub("\n",'')
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/blb/lb_application.rb

@@ -1,29 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Bluebox
-    class BLB
-      class LbApplication < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :ip_v4
-        attribute :ip_v6
-        attribute :description
-        attribute :created,     :aliases => 'created_at'
-
-        def add_machine(lb_machine_id, options)
-          requires :id
-          service.add_machine_to_lb_application(id, lb_machine_id, options)
-        end
-
-        def lb_services
-          Fog::Bluebox::BLB::LbServices.new({
-            :service => service,
-            :lb_application => self
-          })
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/blb/lb_applications.rb

@@ -1,24 +0,0 @@
-require 'fog/bluebox/models/blb/lb_application'
-
-module Fog
-  module Bluebox
-    class BLB
-      class LbApplications < Fog::Collection
-        model Fog::Bluebox::BLB::LbApplication
-
-        def all
-          data = service.get_lb_applications.body
-          load(data)
-        end
-
-        def get(application_id)
-          if application_id && application = service.get_lb_application(application_id).body
-            new(application)
-          end
-        rescue Fog::Bluebox::BLB::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/blb/lb_backend.rb

@@ -1,19 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Bluebox
-    class BLB
-      class LbBackend < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :lb_machines
-        attribute :monitoring_url
-        attribute :monitoring_url_hostname
-        attribute :acl_name
-        attribute :acl_rule
-        attribute :check_interval
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/blb/lb_backends.rb

@@ -1,27 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/blb/lb_backend'
-
-module Fog
-  module Bluebox
-    class BLB
-      class LbBackends < Fog::Collection
-        model Fog::Bluebox::BLB::LbBackend
-
-        attr_accessor :lb_service
-
-        def all
-          data = service.get_lb_backends(lb_service.id).body
-          load(data)
-        end
-
-        def get(lb_backend_id)
-          if lb_backend = service.get_lb_backend(lb_service.id, lb_backend_id).body
-            new(lb_backend)
-          end
-        rescue Fog::Compute::Bluebox::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/blb/lb_service.rb

@@ -1,32 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Bluebox
-    class BLB
-      class LbService < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :port
-        attribute :service_type
-        attribute :private
-
-        attribute :status_url
-        attribute :status_username
-        attribute :status_password
-        attribute :created,     :aliases => 'created_at'
-
-        def lb_application
-          collection.lb_application
-        end
-
-        def lb_backends
-          Fog::Bluebox::BLB::LbBackends.new({
-            :service => service,
-            :lb_service => self
-          })
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/blb/lb_services.rb

@@ -1,27 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/blb/lb_service'
-
-module Fog
-  module Bluebox
-    class BLB
-      class LbServices < Fog::Collection
-        model Fog::Bluebox::BLB::LbService
-
-        attr_accessor :lb_application
-
-        def all
-          data = service.get_lb_services(lb_application.id).body
-          load(data)
-        end
-
-        def get(lb_service_id)
-          if lb_service = service.get_lb_service(lb_application.id, lb_service_id).body
-            new(lb_service)
-          end
-        rescue Fog::Bluebox::BLB::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/flavor.rb

@@ -1,41 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Flavor < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :cost
-        attribute :description
-
-        def bits
-          # 64
-          raise StandardError.new("Figure me out!?!")
-        end
-
-        def cores
-          # # 2 quad-cores >= 2Ghz = 8 cores
-          # 8 * case ram
-          # when 256
-          #   1/64.0
-          # when 512
-          #   1/32.0
-          # when 1024
-          #   1/16.0
-          # when 2048
-          #   1/8.0
-          # when 4096
-          #   1/4.0
-          # when 8192
-          #   1/2.0
-          # when 15872
-          #   1
-          # end
-          raise StandardError.new("Figure me out!?!")
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/flavors.rb

@@ -1,24 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/compute/flavor'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Flavors < Fog::Collection
-        model Fog::Compute::Bluebox::Flavor
-
-        def all
-          data = service.get_products.body
-          load(data)
-        end
-
-        def get(product_id)
-          response = service.get_product(product_id)
-          new(response.body)
-        rescue Fog::Compute::Bluebox::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/image.rb

@@ -1,30 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Image < Fog::Model
-        identity :id
-
-        attribute :block_id
-        attribute :description
-        attribute :public
-        attribute :created_at, :aliases => 'created'
-
-        def save
-          requires :block_id
-
-          data = service.create_template(block_id, attributes)
-          true
-        end
-
-        def destroy
-          requires :id
-
-          data = service.destroy_template(id)
-          true
-        end
-      end
-    end
-  end
-end