fog 1.25.0 → 2.0.0

data/lib/fog/riakcs/requests/provisioning/update_user.rb

@@ -1,23 +0,0 @@
-module Fog
-  module RiakCS
-    class Provisioning
-      class Real
-        include Utils
-        include UserUtils
-        include MultipartUtils
-
-        def update_user(key_id, user)
-          update_riakcs_user(key_id, user)
-        end
-      end
-
-      class Mock
-        include UserUtils
-
-        def update_user(key_id, user)
-          update_mock_user(key_id, user)
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs/requests/usage/get_usage.rb

@@ -1,68 +0,0 @@
-module Fog
-  module RiakCS
-    class Usage
-      module Utils
-        TYPES_TO_STRING = { :access  => 'a', :storage => 'b' }
-        DEFAULT_TYPES   = TYPES_TO_STRING.keys
-        DEFAULT_FORMAT  = :json
-
-        def sanitize_and_convert_time(time)
-          time.utc.iso8601.gsub(/[:-]/, '')
-        end
-
-        def format_and_types_to_path(format, types)
-          format_character = format.to_s.split('').first
-          type_characters  = types.map { |t| TYPES_TO_STRING[t] }.compact
-
-          [type_characters, format_character].flatten.compact.join
-        end
-
-        def request_uri(access_key_id, options)
-          format        = DEFAULT_FORMAT
-          types         = options[:types]       || DEFAULT_TYPES
-          start_time    = options[:start_time]  || Time.now.utc - 86400
-          end_time      = options[:end_time]    || Time.now.utc
-
-          [access_key_id,
-           format_and_types_to_path(format, types),
-           sanitize_and_convert_time(start_time),
-           sanitize_and_convert_time(end_time)].join('.')
-        end
-      end
-
-      class Real
-        include Utils
-
-        def get_usage(access_key_id, options = {})
-          response = @connection.get_object('riak-cs', ["usage", request_uri(access_key_id, options)].join("/"))
-
-          if !response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
-        end
-      end
-
-      class Mock
-        include Utils
-
-        def get_usage(access_key, options = {})
-          Excon::Response.new.tap do |response|
-            response.status = 200
-            response.headers['Content-Type'] = 'application/json'
-            response.body = {
-              'Access' => {
-                'Nodes'   => [],
-                'Errors'  => []
-              },
-              'Storage' => {
-                'Samples' => [],
-                'Errors'  => []
-              }
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs/usage.rb

@@ -1,62 +0,0 @@
-require 'fog/riakcs/core'
-require 'time'
-
-module Fog
-  module RiakCS
-    class Usage < Fog::Service
-      requires :riakcs_access_key_id, :riakcs_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent
-
-      request_path 'fog/riakcs/requests/usage'
-      request :get_usage
-
-      class Mock
-        include Utils
-
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options = {})
-          configure_uri_options(options)
-        end
-
-        def data
-          self.class.data[riakcs_uri]
-        end
-
-        def reset_data
-          self.class.data.delete(riakcs_uri)
-        end
-      end
-
-      class Real
-        include Utils
-
-        def initialize(options = {})
-          configure_uri_options(options)
-          @riakcs_access_key_id     = options[:riakcs_access_key_id]
-          @riakcs_secret_access_key = options[:riakcs_secret_access_key]
-          @connection_options       = options[:connection_options] || {}
-          @persistent               = options[:persistent]         || false
-
-          @connection = Fog::Storage.new(
-            :provider              => 'AWS',
-            :aws_access_key_id     => @riakcs_access_key_id,
-            :aws_secret_access_key => @riakcs_secret_access_key,
-            :host                  => @host,
-            :port                  => @port,
-            :scheme                => @scheme,
-            :connection_options    => @connection_options
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/serverlove.rb

@@ -1 +0,0 @@
-require 'fog/serverlove/compute'

data/lib/fog/serverlove/compute.rb

@@ -1,96 +0,0 @@
-require 'fog/serverlove/core'
-
-module Fog
-  module Compute
-    class Serverlove < Fog::Service
-      API_HOST = "api.z1-man.serverlove.com"
-
-      requires :serverlove_uuid, :serverlove_api_key
-
-      recognizes :serverlove_api_url
-
-      request_path 'fog/serverlove/requests/compute'
-
-      # Image
-      request :get_image
-      request :get_images
-      request :destroy_image
-      request :create_image
-      request :update_image
-      request :load_standard_image
-
-      # Server
-      request :get_servers
-      request :get_server
-      request :destroy_server
-      request :create_server
-      request :update_server
-      request :start_server
-      request :stop_server
-      request :shutdown_server
-      request :reset_server
-
-      model_path 'fog/serverlove/models/compute'
-
-      model       :image
-      collection  :images
-
-      model       :server
-      collection  :servers
-
-      class Mock
-        def initialize(options)
-          @serverlove_uuid = options[:serverlove_uuid]
-          @serverlove_api_key = options[:serverlove_api_key]
-        end
-
-        def request(options)
-          raise "Not implemented"
-        end
-      end
-
-      class Real
-        def initialize(options)
-          @api_uuid = options[:serverlove_uuid] || Fog.credentials[:serverlove_uuid]
-          @api_key = options[:serverlove_api_key] || Fog.credentials[:serverlove_api_key]
-          @api_host = options[:serverlove_api_url] || Fog.credentials[:serverlove_api_url] || API_HOST
-
-          @connection = Fog::XML::Connection.new("https://#{@api_uuid}:#{@api_key}@#{@api_host}")
-        end
-
-        def request(params)
-          params = params.merge!(
-            :headers => {
-              "Accept" => "application/json"
-            }
-          )
-          unless params[:options].nil?
-            params[:body] = encode_pairs(params[:options])
-            params.delete(:options)
-          end
-          response = @connection.request(params)
-
-          raise_if_error!(response)
-
-          response.body = Fog::JSON.decode(response.body) if response.body && response.body.length > 0
-
-          response
-        end
-
-        def encode_pairs(params)
-          params.keys.map do |key|
-            "#{key} #{params[key]}"
-          end.join("\n")
-        end
-
-        # TODO
-        def raise_if_error!(response)
-          case response.status
-          when 400 then
-            raise 'omg'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/serverlove/core.rb

@@ -1,10 +0,0 @@
-require 'fog/core'
-require 'fog/json'
-
-module Fog
-  module Serverlove
-    extend Fog::Provider
-
-    service(:compute, 'Compute')
-  end
-end

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

@@ -1,54 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Serverlove
-      class Image < Fog::Model
-        identity :id, :aliases => 'drive'
-
-        attribute :name
-        attribute :user
-        attribute :size
-        attribute :claimed
-        attribute :status
-        attribute :imaging
-        attribute :encryption_cipher, :aliases => 'encryption:cipher'
-
-        def save
-          attributes = {}
-
-          if(identity)
-            attributes = service.update_image(identity, allowed_attributes).body
-          else
-            requires :name
-            requires :size
-            attributes = service.create_image(allowed_attributes).body
-          end
-
-          merge_attributes(attributes)
-          self
-        end
-
-        def load_standard_image(standard_image_uuid)
-          requires :identity
-          service.load_standard_image(identity, standard_image_uuid)
-        end
-
-        def ready?
-          status.upcase == 'ACTIVE'
-        end
-
-        def destroy
-          requires :identity
-          service.destroy_image(identity)
-          self
-        end
-
-        def allowed_attributes
-          allowed = [:name, :size]
-          attributes.select {|k,v| allowed.include? k}
-        end
-      end
-    end
-  end
-end

data/lib/fog/serverlove/models/compute/images.rb

@@ -1,22 +0,0 @@
-require 'fog/core/collection'
-require 'fog/serverlove/models/compute/image'
-
-module Fog
-  module Compute
-    class Serverlove
-      class Images < Fog::Collection
-        model Fog::Compute::Serverlove::Image
-
-        def all
-          data = service.get_images.body
-          load(data)
-        end
-
-        def get(image_id)
-          data = service.get_image(image_id).body
-          new(data)
-        end
-      end
-    end
-  end
-end

data/lib/fog/serverlove/models/compute/server.rb

@@ -1,70 +0,0 @@
-require 'fog/core/model'
-require 'fog/serverlove/util/compute/password_generator'
-
-module Fog
-  module Compute
-    class Serverlove
-      class Server < Fog::Model
-        identity :id, :aliases => 'server'
-
-        attribute :name
-        attribute :cpu
-        attribute :mem
-        attribute :smp
-        attribute :ide_0_0, :aliases => 'ide:0:0'
-        attribute :ide_0_1, :aliases => 'ide:0:1'
-        attribute :ide_1_0, :aliases => 'ide:1:0'
-        attribute :ide_1_1, :aliases => 'ide:1:1'
-        attribute :boot
-        attribute :persistent
-        attribute :vnc
-        attribute :vnc_password, :aliases => 'vnc:password'
-        attribute :status
-        attribute :user
-        attribute :started
-        attribute :nic_0_model, :aliases => 'nic:0:model'
-        attribute :nic_0_dhcp,  :aliases => 'nic:0:dhcp'
-
-        def save
-          attributes = {}
-
-          if(identity)
-            attributes = service.update_server(identity, allowed_attributes).body
-          else
-            requires :name
-            requires :cpu
-            attributes = service.create_server(self.class.defaults.merge(allowed_attributes)).body
-          end
-
-          merge_attributes(attributes)
-          self
-        end
-
-        def destroy
-          requires :identity
-          service.destroy_server(identity)
-          self
-        end
-
-        def allowed_attributes
-          allowed = [
-                      :name, :cpu, :smp, :mem, :persistent,
-                      :vnc_password, :vnc,
-                      :ide_0_0, :ide_0_1, :ide_1_0, :ide_1_1,
-                      :boot, :nic_0_model, :nic_0_dhcp
-                    ]
-          attributes.select {|k,v| allowed.include? k}
-        end
-
-        def self.defaults
-          # TODO: Document default settings.
-          # Note that VNC password standards are strict (need explaining)
-          { 'nic:0:model' => 'e1000', 'nic:0:dhcp' => 'auto',
-            'smp' => 'auto', 'vnc' => 'auto',
-            'vnc:password' => Fog::Compute::Serverlove::PasswordGenerator.generate
-          }
-        end
-      end
-    end
-  end
-end

data/lib/fog/serverlove/models/compute/servers.rb

@@ -1,22 +0,0 @@
-require 'fog/core/collection'
-require 'fog/serverlove/models/compute/server'
-
-module Fog
-  module Compute
-    class Serverlove
-      class Servers < Fog::Collection
-        model Fog::Compute::Serverlove::Server
-
-        def all
-          data = service.get_servers.body
-          load(data)
-        end
-
-        def get(server_id)
-          data = service.get_server(server_id).body
-          new(data)
-        end
-      end
-    end
-  end
-end

data/lib/fog/serverlove/requests/compute/create_image.rb

@@ -1,28 +0,0 @@
-module Fog
-  module Compute
-    class Serverlove
-      class Real
-        def create_image(options)
-          return nil if options.empty? || options.nil?
-          request(:method => "post", :path => "/drives/create", :expects => 200, :options => options)
-        end
-      end
-
-      class Mock
-        def create_image(options = {})
-          response = Excon::Response.new
-          response.status = 200
-
-          data = {
-            'drive'     => Fog::Mock.random_numbers(1000000).to_s,
-            'name'      => options['name'] || 'Test',
-            'size'      => options['size'] || 12345
-          }
-
-          response.body = data
-          response
-        end
-      end
-    end
-  end
-end