fog 1.11.1 → 1.12.0

data/lib/fog/cloudsigma/connection.rb

@@ -0,0 +1,197 @@
+require 'fog/cloudsigma/error'
+
+module Fog
+  module CloudSigma
+    module CloudSigmaConnection
+
+      module Real
+        def auth_header(type = :basic)
+          case type
+            when :basic
+              unless @username and @password
+                raise ArgumentError, 'Username and password required for basic auth'
+              end
+              {'Authorization' => 'Basic ' << Base64.encode64("#{@username}:#{@password}").gsub("\n", '')}
+            else
+              unless @username and @password
+                raise ArgumentError, 'Username and password required for basic auth'
+              end
+              {'Authorization' => 'Basic ' << Base64.encode64("#{@username}:#{@password}").gsub("\n", '')}
+          end
+        end
+
+        def setup_connection(options)
+          @persistent = options[:persistent] || false
+          @connection_options = options[:connection_options] || {}
+          @connection_options[:ssl_verify_peer] = false
+
+          @auth_type = options[:cloudsigma_auth_type] || :basic
+
+          @username = options[:cloudsigma_username]
+          @password = options[:cloudsigma_password]
+
+          @scheme = options[:cloudsigma_scheme] || 'https'
+          @host = options[:cloudsigma_host] || 'lvs.cloudsigma.com'
+          @port = options[:cloudsigma_port] || '443'
+          @api_path_prefix = options[:cloudsigma_api_path_prefix] || 'api'
+          @api_version = options[:cloudsigma_api_version] || '2.0'
+          @path_prefix = "#{@api_path_prefix}/#{@api_version}/"
+
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def request(params)
+          params[:headers] = params.fetch(:headers, {}).merge(auth_header(@auth_type))
+          params[:headers]['Content-Type'] = 'application/json; charset=utf-8'
+
+          req_path = params[:path]
+          params[:path] = "#{@path_prefix}#{req_path}"
+
+
+          params[:body] = Fog::JSON.encode(params[:body]) if params[:body]
+
+          begin
+            response = @connection.request(params)
+          rescue Excon::Errors::HTTPStatusError => e
+
+            e.response.data[:body] = Fog::JSON.decode(e.response[:body]) unless e.response[:body].empty?
+            err = Fog::CloudSigma::Errors.slurp_http_status_error(e)
+
+            raise err
+          end
+          response.body = Fog::JSON.decode(response.body) unless response.body.empty?
+
+          response
+        end
+
+        def list_request(path, override_params={})
+          default_params = {:method => 'GET', :expects => 200, :query => {:limit => 0}}
+          override_params[:path] = path
+          params = default_params.merge(override_params)
+
+          request(params)
+        end
+
+        def get_request(path, override_params={})
+          default_params = {:method => 'GET', :expects => 200}
+          override_params[:path] = path
+          params = default_params.merge(override_params)
+
+          request(params)
+        end
+
+        def delete_request(path, override_params={})
+          default_params = {:method => 'DELETE', :expects => 204}
+          override_params[:path] = path
+          params = default_params.merge(override_params)
+
+          request(params)
+        end
+
+        def create_request(path, data, override_params={})
+          default_params = {:method => 'POST', :expects => [200, 201, 202]}
+
+          override_params[:path] = path
+          override_params[:body] = data
+          params = default_params.merge(override_params)
+
+          request(params)
+        end
+
+        def update_request(path, data, override_params={})
+          default_params = {:method => 'PUT', :expects => [200, 202]}
+
+          override_params[:path] = path
+          override_params[:body] = data
+          params = default_params.merge(override_params)
+
+          request(params)
+        end
+      end
+
+      module Mock
+        def setup_connection(options)
+          @username = options[:cloudsigma_username]
+          @password = options[:cloudsigma_password]
+
+        end
+
+        def mock_get(obj_or_collection, status, key=nil)
+          data = self.data[obj_or_collection]
+          if key
+            data = data[key]
+            unless data
+              raise Fog::CloudSigma::Errors::NotFound.new("Object with uuid #{key} does not exist", 'notexist')
+            end
+          end
+
+          Excon::Response.new(:body => Fog::JSON.decode(Fog::JSON.encode(data)), :status => status)
+        end
+
+        def mock_list(collection, status)
+          data_array = self.data[collection].values
+
+          Excon::Response.new(:body => {'objects' => data_array}, :status => status)
+        end
+
+        def mock_update(data, obj_or_collection, status, key, &clean_before_update)
+          data = Fog::JSON.decode(Fog::JSON.encode(data))
+          if key
+            unless self.data[obj_or_collection][key]
+              raise Fog::CloudSigma::Errors::NotFound.new("Object with uuid #{key} does not exist", 'notexist')
+            end
+            if clean_before_update
+              new_data = clean_before_update.call(self.data[obj_or_collection][key], data)
+            else
+              new_data = self.data[obj_or_collection][key].merge(data)
+            end
+
+            self.data[obj_or_collection][key] = new_data
+          else
+            if clean_before_update
+              new_data = clean_before_update.call(self.data[obj_or_collection], data)
+            else
+              new_data = self.data[obj_or_collection].merge(data)
+            end
+
+            self.data[obj_or_collection] = new_data
+          end
+
+          Excon::Response.new(:body =>  Fog::JSON.decode(Fog::JSON.encode(new_data)), :status => status)
+        end
+
+        def mock_delete(collection, status, key)
+          self.data[collection].delete(key)
+
+          Excon::Response.new(:body => '', :status => status)
+        end
+
+        def mock_create(collection, status, data, key, defaults={}, &clean_before_store)
+          data_with_defaults = data.merge(defaults) {|k, oldval, newval| oldval == nil ? newval: oldval}
+
+          if clean_before_store
+            cleaned_data = clean_before_store.call(data_with_defaults)
+          else
+            cleaned_data = data_with_defaults
+          end
+
+          # Encode and decode into JSON so that the result is the same as the one returned and parsed from the API
+          final_data =  Fog::JSON.decode(Fog::JSON.encode(cleaned_data))
+
+          self.data[collection][key] = final_data
+
+          # dup so that stored data is different instance from response data
+          response_data = final_data.dup
+
+          response = Excon::Response.new
+          response.body = {'objects' => [response_data]}
+          response.status = status
+
+          response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/cloudsigma/error.rb

@@ -0,0 +1,45 @@
+module Fog
+  module CloudSigma
+    module Errors
+      class Error < Fog::Errors::Error
+        attr_accessor :type, :error_point
+
+        def initialize(message, type='n/a', error_point=nil)
+          @type = type
+          @error_point = error_point
+          super(message)
+        end
+
+      end
+
+      class NotFound < Error; end
+      class RequestError < Error; end
+      class ServerError < Error; end
+
+      def self.slurp_http_status_error(error)
+        error_class =  case error.response[:status]
+                         when 404
+                           NotFound
+                         when 500..599
+                           ServerError
+                         when 400..499
+                           RequestError
+                         else
+                           Error
+                       end
+
+        new_error = error_class.new(error.response[:body].first['error_message'],
+                                    error.response[:body].first['error_type'],
+                                    error.response[:body].first['error_point'])
+        new_error.set_backtrace(error.backtrace)
+        new_error.verbose = error.message
+        new_error
+      end
+
+
+
+    end
+
+
+  end
+end

data/lib/fog/cloudsigma/mock_data.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class CloudSigma
+      class Mock
+        def self.mock_data
+          {
+              :volumes => {},
+              :servers => {},
+              :vlans => {},
+              :ips => {},
+              :profile => {:login_sms=>false,
+                           :town=>"",
+                           :postcode=>"",
+                           :reseller=>"",
+                           :has_autotopup=>false,
+                           :currency=>"CHF",
+                           :state=>"REGULAR",
+                           :uuid=>"6c2203a1-a2e6-433f-aeab-b976b8cd3d18",
+                           :company=>"",
+                           :api_https_only=>false,
+                           :my_notes=>"",
+                           :key_auth=>false,
+                           :email=>"MyFirstName.MyLasttName@MyCompany.com",
+                           :bank_reference=>"mmlastname278",
+                           :first_name=>"MyFirstName",
+                           :meta =>"",
+                           :phone=>"",
+                           :language=>"EN",
+                           :vat=>"",
+                           :last_name=>"MyLasttName",
+                           :title=>"",
+                           :mailing_list=>true,
+                           :autotopup_amount=>0.0,
+                           :country=>"",
+                           :address=>""},
+              :subscriptions => {},
+              :current_usage => {},
+              :balance => {:balance => 100, :currency => 'CHF'},
+
+
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/cloudsigma/models/balance.rb

@@ -0,0 +1,12 @@
+require 'fog/cloudsigma/nested_model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Balance < Fog::CloudSigma::CloudsigmaModel
+        attribute :balance, :type => :float
+        attribute :currency, :type => :string
+      end
+    end
+  end
+end

data/lib/fog/cloudsigma/models/current_usage.rb

@@ -0,0 +1,19 @@
+require 'fog/cloudsigma/nested_model'
+require 'fog/cloudsigma/models/usage_record'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class CurrentUsage < Fog::CloudSigma::CloudsigmaModel
+        model_attribute :cpu, UsageRecord
+        model_attribute :hdd, UsageRecord
+        model_attribute :ip, UsageRecord
+        model_attribute :mem, UsageRecord
+        model_attribute :sms, UsageRecord
+        model_attribute :ssd, UsageRecord
+        model_attribute :tx, UsageRecord
+        model_attribute :vlan, UsageRecord
+      end
+    end
+  end
+end

data/lib/fog/cloudsigma/models/ip.rb

@@ -0,0 +1,22 @@
+require 'fog/cloudsigma/nested_model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class IP < Fog::CloudSigma::CloudsigmaModel
+        identity :uuid
+        attribute :tags, :type => :array
+        attribute :nameservers, :type => :array
+        attribute :server, :type => :string
+        attribute :netmask, :type => :integer
+        attribute :meta
+        attribute :owner
+        attribute :subscription
+        attribute :gateway, :type => :string
+        attribute :resource_uri, :type => :string
+
+
+      end
+    end
+  end
+end

data/lib/fog/cloudsigma/models/ipconf.rb

@@ -0,0 +1,12 @@
+require 'fog/cloudsigma/nested_model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class IPConf < Fog::CloudSigma::CloudsigmaModel
+        attribute :ip
+        attribute :conf, :type => :string
+      end
+    end
+  end
+end

data/lib/fog/cloudsigma/models/ips.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/cloudsigma/models/ip'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Ips < Fog::Collection
+        model Fog::Compute::CloudSigma::IP
+
+        def all
+          resp = service.list_ips
+          data = resp.body['objects']
+          load(data)
+        end
+
+        def get(ip)
+          resp = service.get_ip(ip)
+          data = resp.body
+          new(data)
+        rescue Fog::CloudSigma::Errors::NotFound
+          return nil
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/cloudsigma/models/lib_volume.rb

@@ -0,0 +1,50 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class LibVolume < Fog::Model
+        identity :uuid
+
+        attribute :mounted_on, :type => :related
+        attribute :licenses
+        attribute :meta
+        attribute :owner
+        attribute :affinities
+        attribute :image_format, :type => :string
+        attribute :size, :type => :integer
+        attribute :category
+        attribute :image_type, :type => :string
+        attribute :media, :type => :string
+        attribute :state, :type => :string
+        attribute :status, :type => :string
+        attribute :jobs
+        attribute :description, :type => :string
+        attribute :tags
+        attribute :favourite, :type => :boolean
+        attribute :paid, :type => :boolean
+        attribute :allow_multimount, :type => :boolean
+        attribute :install_notes, :type => :string
+        attribute :arch, :type => :string
+        attribute :name, :type => :string
+        attribute :url, :type => :string
+        attribute :os, :type => :string
+        attribute :resource_uri, :type => :string
+
+
+
+        def reload
+          requires :identity
+          collection.get(identity)
+        end
+
+        def clone(clone_params={})
+          requires :identity
+          response = service.clone_volume(identity, clone_params)
+
+          self.class.new(response.body['objects'].first)
+        end
+      end
+    end
+  end
+end

data/lib/fog/cloudsigma/models/lib_volumes.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/cloudsigma/models/lib_volume'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class LibVolumes < Fog::Collection
+        model Fog::Compute::CloudSigma::LibVolume
+
+        def all
+          resp = service.list_lib_volumes
+          data = resp.body['objects']
+          load(data)
+        end
+
+        def get(vol_id)
+          resp = service.get_lib_volume(vol_id)
+          data = resp.body
+          new(data)
+        rescue Fog::CloudSigma::Errors::NotFound
+          return nil
+        end
+
+      end
+    end
+  end
+end