fog 1.11.1 → 1.12.0

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

@@ -0,0 +1,25 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class MountPoint < Fog::Model
+        attribute :device, :type => 'string'
+        attribute :dev_channel, :type => 'string'
+        attribute :drive
+        attribute :boot_order, :type => 'integer'
+
+        def drive
+          drive = attributes[:drive]
+
+          drive.kind_of?(Hash) ? drive['uuid'] : drive
+        end
+
+        def drive=(new_drive)
+          attributes[:drive] = new_drive
+        end
+        alias :volume :drive
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'fog/core/model'
+require 'fog/cloudsigma/nested_model'
+require 'fog/cloudsigma/models/ipconf'
+
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Nic < Fog::CloudSigma::CloudsigmaModel
+
+
+        attribute :boot_order
+        attribute :mac, :type => :string
+        attribute :model, :type => :string
+        attribute :vlan
+        model_attribute :ip_v4_conf, IPConf
+        model_attribute :ip_v6_conf, IPConf
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class ObjRef < Fog::Model
+        attribute :uuid, :type => :string
+        attribute :resource_uri, :type => :string
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'fog/cloudsigma/nested_model'
+require 'fog/cloudsigma/models/subscriptions'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class PriceCalculation < Fog::CloudSigma::CloudsigmaModel
+        attribute :price, :type => :float
+        model_attribute_array :subscriptions, Subscription, :aliases => 'objects'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'fog/cloudsigma/nested_model'
+require 'bigdecimal'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class PriceRecord < Fog::CloudSigma::CloudsigmaModel
+        attribute :resource, :type => :string
+        attribute :multiplier, :type => :integer
+        attribute :price, :type => :string
+        attribute :level, :type => :integer
+        attribute :currency, :type => :string
+        attribute :unit, :type => :string
+
+        def price
+          if attributes[:price]
+            BigDecimal(attributes[:price])
+          else
+            nil
+          end
+        end
+
+        def price=(new_price)
+          attributes[:price] = new_price.kind_of?(String) ? new_price : new_price.to_s('F')
+        end
+
+        # The base price of the resource.
+        # This is the price for the base API unit which is byte for memory, data, etc. and MHz for CPU.
+        # Also the price is per second for time based resource (basically everything except data transfer which is not
+        # limited in time)
+        def base_price
+          price / multiplier
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'fog/cloudsigma/nested_model'
+require 'fog/cloudsigma/models/price_record'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Pricing < Fog::CloudSigma::CloudsigmaModel
+        model_attribute :cpu, PriceRecord
+        model_attribute :hdd, PriceRecord
+        model_attribute :ip, PriceRecord
+        model_attribute :mem, PriceRecord
+        model_attribute :sms, PriceRecord
+        model_attribute :ssd, PriceRecord
+        model_attribute :tx, PriceRecord
+        model_attribute :vlan, PriceRecord
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'fog/cloudsigma/nested_model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Profile < Fog::CloudSigma::CloudsigmaModel
+        identity :uuid
+
+        attribute :last_name, :type => :string
+        attribute :login_sms, :type => :boolean
+        attribute :currency, :type => :string
+        attribute :meta
+        attribute :api_https_only, :type => :boolean
+        attribute :first_name, :type => :string
+        attribute :uuid, :type => :string
+        attribute :title, :type => :string
+        attribute :state, :type => :string
+        attribute :email, :type => :string
+        attribute :vat, :type => :string
+        attribute :autotopup_amount, :type => :float
+        attribute :reseller, :type => :string
+        attribute :company, :type => :string
+        attribute :key_auth, :type => :boolean
+        attribute :phone, :type => :string
+        attribute :address, :type => :string
+        attribute :mailing_list, :type => :boolean
+        attribute :town, :type => :string
+        attribute :has_autotopup, :type => :boolean
+        attribute :my_notes, :type => :string
+        attribute :bank_reference, :type => :string
+        attribute :language, :type => :string
+        attribute :country, :type => :string
+        attribute :postcode, :type => :string
+
+
+        def save
+          update
+        end
+
+        def update
+          response = service.update_profile(attributes)
+          self.attribute.merge!(response.body)
+
+          self
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+require 'fog/cloudsigma/nested_model'
+require 'fog/cloudsigma/models/mountpoint'
+require 'fog/cloudsigma/models/nic'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Server < Fog::CloudSigma::CloudsigmaModel
+
+
+        identity :uuid
+
+        attribute :status, :type => :string
+        attribute :vnc_password, :type => :string
+        attribute :name, :type => :string
+        attribute :cpus_instead_of_cores, :type => :boolean
+        attribute :tags
+        attribute :mem, :type => :integer
+        attribute :enable_numa, :type => :boolean
+        attribute :smp
+        attribute :hv_relaxed, :type => :boolean
+        attribute :hv_tsc, :type => :boolean
+        attribute :meta
+        attribute :owner
+        attribute :runtime
+        attribute :cpu, :type => :integer
+        attribute :resource_uri, :type => :string
+        model_attribute_array :volumes, MountPoint, :aliases => 'drives'
+        model_attribute_array :nics, Nic
+
+
+        def save
+          if persisted?
+            update
+          else
+            create
+          end
+        end
+
+        def create
+          requires :name, :cpu, :mem, :vnc_password
+          data = attributes
+
+          response = service.create_server(data)
+          new_attributes = response.body['objects'].first
+          merge_attributes(new_attributes)
+        end
+
+        def update
+          requires :identity, :name, :cpu, :mem, :vnc_password
+
+          data = attributes
+
+          response = service.update_server(identity, data)
+          new_attributes = response.body
+          merge_attributes(new_attributes)
+
+        end
+
+        def destroy
+          requires :identity
+
+          service.delete_server(identity)
+          true
+        end
+
+        alias :delete :destroy
+
+        def start(start_params={})
+          requires :identity
+          service.start_server(identity, start_params)
+        end
+
+        def stop
+          requires :identity
+          service.stop_server(identity)
+        end
+
+        def open_vnc
+          requires :identity
+          service.open_vnc(identity)
+        end
+
+        def close_vnc
+          requires :identity
+          service.close_vnc(identity)
+        end
+
+        def clone(clone_params={})
+          requires :identity
+          response = service.clone_server(identity, clone_params)
+
+          self.class.new(response.body)
+        end
+
+        def mount_volume(volume, device = 'virtio', dev_channel = nil, boot_order = nil)
+          unless dev_channel
+            specified_channels = self.volumes.map { |v| v.dev_channel }.sort
+            if specified_channels
+              controller, controller_channel = 0, 0
+              max_ctlr, max_chnl = case device
+                                     when 'ide'
+                                       [4, 2]
+                                     else
+                                       [1024, 5]
+                                   end
+
+              dev_channel = "#{controller}:#{controller_channel}"
+              while specified_channels.include? dev_channel
+                controller_channel += 1
+                if controller_channel >= max_chnl
+                  controller_channel = 0
+                  controller += 1
+                  if controller >= max_ctlr
+                    raise Fog::CloudSigma::Errors::Error.new("Max channel reached, cannot attach more")
+                  end
+                end
+                dev_channel = "#{controller}:#{controller_channel}"
+              end
+            else # no other channels specified
+              dev_channel = '0:0'
+            end
+          end
+
+
+          vol_id = volume.kind_of?(String) ? volume : volume.identity
+          mountpoint_data = {
+              'drive' => vol_id,
+              'device' => device,
+              'dev_channel' => dev_channel,
+          }
+
+          if boot_order
+            mountpoint_data['boot_order'] = boot_order
+          end
+
+          self.volumes = self.volumes << MountPoint.new(mountpoint_data)
+        end
+
+        def unmount_volume(volume_or_position)
+          if volume_or_position.kind_of? Fixnum
+            self.volumes.delete_at(volume_or_position)
+            # assign to update attributes
+            return self.volumes = self.volumes
+          end
+
+          vol_id = volume_or_position.kind_of?(String) ? volume_or_position : volume_or_position.identity
+          self.volumes = self.volumes.reject do |v|
+            if v.volume.kind_of? Hash
+              v.volume['uuid'] == vol_id
+            else
+              v.volume == vol_id
+            end
+          end
+        end
+
+        def unmount_all_volumes
+          self.volumes = []
+        end
+
+        def add_nic(vlan=nil, ip_v4_conf=nil, ip_v6_conf=nil, model='virtio', boot_order=nil)
+          nic_data = {
+              'model' => model,
+              'vlan' => vlan,
+              'ip_v4_conf' => ip_v4_conf,
+              'ip_v6_conf' => ip_v6_conf
+          }
+          if boot_order
+            nic_data['boot_order'] = boot_order
+          end
+
+          self.nics = self.nics << Nic.new(nic_data)
+        end
+
+        def add_public_nic(ip_or_conf=:dhcp, model='virtio', boot_order=nil)
+          case ip_or_conf
+            when :dhcp
+              add_nic(nil, {:conf => :dhcp}, nil, model, boot_order)
+            when :manual
+              add_nic(nil, {:conf => :manual}, nil, model, boot_order)
+            else
+              ip = ip_or_conf.kind_of?(String) ? ip_or_conf : ip_or_conf.identity
+              add_nic(nil, {:conf => :static, :ip => ip}, nil, model, boot_order)
+          end
+        end
+
+        def add_private_nic(vlan, model='virtio', boot_order=nil)
+          vlan = vlan.kind_of?(String) ? vlan : vlan.identity
+          add_nic(vlan, nil, nil, model, boot_order)
+        end
+
+        def remove_nic(mac_or_position)
+          if mac_or_position.kind_of? Fixnum
+            self.nics.delete_at(mac_or_position)
+            # assign to update attributes
+            return self.nics = self.nics
+          end
+
+          self.nics = self.nics.reject { |n| n.mac == mac_or_position }
+        end
+
+        def remove_all_nics
+          self.nics = []
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,53 @@
+require 'fog/cloudsigma/nested_model'
+
+module Fog
+  module Compute
+    class CloudSigma
+      class Subscription < Fog::CloudSigma::CloudsigmaModel
+        identity :id
+
+        attribute :status, :type => :string
+        attribute :uuid, :type => :string
+        attribute :resource, :type => :string
+        attribute :auto_renew, :type => :boolean
+        attribute :descendants
+        attribute :start_time, :type => :time
+        attribute :price, :type => :float
+        attribute :period, :type => :string
+        attribute :remaining, :type => :string
+        attribute :amount, :type => :integer
+        attribute :end_time, :type => :time
+        attribute :discount_percent, :type => :float
+        attribute :subscribed_object, :type => :string
+        attribute :discount_amount, :type => :float
+
+        def save
+          create
+        end
+
+        def create
+          requires :resource, :amount
+          data = attributes
+
+          response = service.create_subscription(data)
+          new_attributes = response.body['objects'].first
+          merge_attributes(new_attributes)
+        end
+
+        def extend(period=nil, end_time=nil)
+          requires :identity
+          data = {}
+          if period
+            data[:period] = period
+          elsif end_time
+            data[:end_time] = end_time
+          end
+          response = service.extend_subscription(identity, data)
+
+          self.class.new(response.body)
+        end
+
+      end
+    end
+  end
+end