fog-profitbricks 0.0.5 → 2.0.1

data/lib/fog/profitbricks/models/compute/nics.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../nic', __FILE__)
+require File.expand_path('../../helpers/compute/data_helper', __dir__)
+
+module Fog
+  module Compute
+    class ProfitBricks
+      class Nics < Fog::Collection
+        include Fog::Helpers::ProfitBricks::DataHelper
+        model Fog::Compute::ProfitBricks::Nic
+
+        def all(datacenter_id, server_id)
+          result = service.get_all_nic(datacenter_id, server_id)
+
+          nics = result.body['items'].each do |nic|
+            nic['datacenter_id'] = datacenter_id
+            nic['server_id'] = server_id
+          end
+
+          result.body['items'] = nics
+
+          load(result.body['items'].each { |nic| flatten(nic) })
+        end
+
+        def get(datacenter_id, server_id, nic_id)
+          nic = service.get_nic(datacenter_id, server_id, nic_id).body
+
+          Excon::Errors
+          nic['datacenter_id'] = datacenter_id
+          nic['server_id']      = server_id
+
+          new(flatten(nic))
+        rescue Excon::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/profitbricks/models/compute/request.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Request < Fog::Models::ProfitBricks::Base
+
+        identity  :id
+
+        # properties
+        attribute :method
+        attribute :headers
+        attribute :body
+        attribute :url
+
+        # metadata
+        attribute :created_date,   :aliases => 'createdDate', :type => :time
+        attribute :created_by, 	   :aliases => 'createdBy'
+        attribute :request_status, :aliases => 'requestStatus'
+        attribute :status
+        attribute :message
+        attribute :targets
+      end
+    end
+  end
+end

data/lib/fog/profitbricks/models/compute/requests.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../request', __FILE__)
+require File.expand_path('../../helpers/compute/data_helper', __dir__)
+
+module Fog
+  module Compute
+    class ProfitBricks
+      class Requests < Fog::Collection
+        include Fog::Helpers::ProfitBricks::DataHelper
+        model Fog::Compute::ProfitBricks::Request
+
+        def all
+          result = service.get_all_requests
+
+          load(result.body['items'].each {|request| flatten(request)})
+        end
+
+        def get(request_id)
+          request = service.get_request(request_id).body
+
+          Excon::Errors
+
+          new(flatten(request))
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def get_status(request_id)
+          request = service.get_request_status(request_id).body
+
+          Excon::Errors
+
+          new(flatten(request))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+# require "fog/compute/models/server"
+require File.expand_path('../../helpers/compute/data_helper', __dir__)
+
+module Fog
+  module Compute
+    class ProfitBricks
+      class Server < Fog::Models::ProfitBricks::Base
+        include Fog::Helpers::ProfitBricks::DataHelper
+
+        identity  :id
+
+        # properties
+        attribute :name
+        attribute :cores
+        attribute :ram
+        attribute :availability_zone, :aliases => 'availabilityZone'
+        attribute :vm_state,          :aliases => 'vmState'
+        attribute :boot_cdrom,        :aliases => 'bootCdrom'
+        attribute :boot_volume,       :aliases => 'bootVolume'
+        attribute :cpu_family,        :aliases => 'cpuFamily'
+        attribute :allow_reboot,      :aliases => 'allowReboot'
+
+        # metadata
+        attribute :created_date,       :aliases => 'createdDate', :type => :time
+        attribute :created_by,         :aliases => 'createdBy'
+        attribute :last_modified_date, :aliases => 'lastModifiedDate', :type => :time
+        attribute :last_modified_by,   :aliases => 'lastModifiedBy'
+        attribute :request_id,         :aliases => 'requestId'
+        attribute :state
+
+        # entities
+        # attribute :cdroms
+        attribute :volumes
+        attribute :nics
+
+        attribute :datacenter_id
+
+        attr_accessor :options
+
+        def initialize(attributes = {})
+          super
+        end
+
+        def save
+          requires :datacenter_id, :name, :cores, :ram
+
+          properties = {}
+          properties[:name]             = name if name
+          properties[:cores]            = cores if cores
+          properties[:ram]              = ram if ram
+          properties[:availabilityZone] = availability_zone if availability_zone
+          properties[:bootVolume]       = boot_volume if boot_volume
+          properties[:bootCdrom]        = boot_cdrom if boot_cdrom
+          properties[:cpuFamily]        = cpu_family if cpu_family
+
+          entities = {}
+          if volumes
+            entities[:volumes] = get_volumes(volumes)
+          end
+
+          if nics
+            entities[:nics] = get_nics(nics)
+          end
+
+          data = service.create_server(datacenter_id, properties, entities)
+          merge_attributes(flatten(data.body))
+          true
+        end
+
+        def update
+          requires :datacenter_id, :id
+
+          properties = {}
+          properties[:name]             = name if name
+          properties[:cores]            = cores if cores
+          properties[:ram]              = ram if ram
+          properties[:availabilityZone] = availability_zone if availability_zone
+          properties[:cpuFamily]        = cpu_family if cpu_family
+          properties[:allowReboot]      = allow_reboot if allow_reboot
+
+          data = service.update_server(datacenter_id, id, properties)
+          merge_attributes(flatten(data.body))
+          true
+        end
+
+        def attach_volume(storage_id)
+          requires :datacenter_id, :id
+
+          data = service.attach_volume(datacenter_id, id, storage_id)
+          flatten(data.body)
+        end
+
+        def get_attached_volume(volume_id)
+          requires :datacenter_id, :id
+
+          data = service.get_attached_volume(datacenter_id, id, volume_id)
+          volume = data.body
+          volume['datacenter_id'] = datacenter_id
+          flatten(data.body)
+        end
+
+        def detach_volume(storage_id)
+          requires :datacenter_id, :id
+
+          service.detach_volume(datacenter_id, id, storage_id)
+          true
+        end
+
+        def attach_cdrom(cdrom_image_id)
+          requires :datacenter_id, :id
+
+          data = service.attach_cdrom(datacenter_id, id, cdrom_image_id)
+          flatten(data.body)
+        end
+
+        def get_attached_cdrom(cdrom_image_id)
+          requires :datacenter_id, :id
+
+          data = service.get_attached_cdrom(datacenter_id, id, cdrom_image_id)
+          flatten(data.body)
+        end
+
+        def detach_cdrom(cdrom_id)
+          requires :datacenter_id, :id
+
+          service.detach_cdrom(datacenter_id, id, cdrom_id)
+          true
+        end
+
+        def reboot
+          requires :datacenter_id, :id
+          service.reboot_server(datacenter_id, id)
+          true
+        end
+
+        def start
+          requires :datacenter_id, :id
+          service.start_server(datacenter_id, id)
+          true
+        end
+
+        def stop
+          requires :datacenter_id, :id
+          service.stop_server(datacenter_id, id)
+          true
+        end
+
+        def delete
+          requires :datacenter_id, :id
+          service.delete_server(datacenter_id, id)
+          true
+        end
+
+        def reload
+          requires :datacenter_id, :id
+
+          data = begin
+            collection.get(datacenter_id, id)
+          rescue Excon::Errors::SocketError
+            nil
+          end
+
+          return unless data
+
+          new_attributes = data.attributes
+          merge_attributes(new_attributes)
+          self
+        end
+
+        def list_volumes
+          requires :datacenter_id, :id
+
+          result = service.list_attached_volumes(datacenter_id, id)
+
+          volumes = result.body['items'].each { |volume| volume['datacenter_id'] = datacenter_id }
+          result.body['items'] = volumes
+
+          result.body
+        end
+
+        def list_cdroms
+          requires :datacenter_id, :id
+
+          result = service.list_attached_cdroms(datacenter_id, id)
+
+          cdroms = result.body['items'].each { |cdrom| cdrom['datacenter_id'] = datacenter_id }
+          result.body['items'] = cdroms
+
+          result.body
+        end
+
+        def list_nics
+          requires :datacenter_id, :id
+          service.nics.all(datacenter_id, id)
+        end
+
+        def shutoff?
+          vm_state == 'SHUTOFF'
+        end
+
+        def running?
+          vm_state == 'RUNNING'
+        end
+
+        private
+
+        def get_volumes(volumes)
+          items = []
+          for volume in volumes do
+            item = {}
+            item[:name] = volume[:name]
+            item[:size] = volume[:size]
+            item[:type] = volume[:type]
+            item[:bus] = volume[:bus] || 'VIRTIO'
+            item[:image] = volume[:image]
+            item[:imagePassword] = volume[:image_password]
+            item[:sshKeys] = volume[:ssh_keys]
+            item[:licenceType] = volume[:licence_type]
+            items << { properties: item }
+          end
+          { items: items }
+        end
+
+        def get_nics(nics)
+          items = []
+          for nic in nics do
+            firewall_rules = nil
+            item = {}
+            item[:name]           = nic[:name] if nic.key?(:name)
+            item[:ips]            = nic[:ips] if nic.key?(:ips)
+            item[:dhcp]           = nic[:dhcp] if nic.key?(:dhcp)
+            item[:lan]            = nic[:lan] if nic.key?(:lan)
+            item[:firewallActive] = nic[:firewall_active] if nic.key?(:firewall_active)
+            if nic[:firewall_rules]
+              firewall_rules = get_firewall_rules(nic[:firewall_rules])
+              item[:firewallActive] = true
+            end
+            items << { properties: item, entities: firewall_rules }
+          end
+          { items: items }
+        end
+
+        def get_firewall_rules(firewall_rules)
+          items = []
+          for firewall_rule in firewall_rules do
+            item = {}
+            item[:name]           = firewall_rule[:name] if firewall_rule.key?(:name)
+            item[:protocol]       = firewall_rule[:protocol] if firewall_rule.key?(:protocol)
+            item[:sourceMac]      = firewall_rule[:source_mac] if firewall_rule.key?(:source_mac)
+            item[:sourceIp]       = firewall_rule[:source_ip] if firewall_rule.key?(:source_ip)
+            item[:targetIp]       = firewall_rule[:target_ip] if firewall_rule.key?(:target_ip)
+            item[:portRangeStart] = firewall_rule[:port_range_start] if firewall_rule.key?(:port_range_start)
+            item[:portRangeEnd]   = firewall_rule[:port_range_end] if firewall_rule.key?(:port_range_end)
+            item[:icmpType]       = firewall_rule[:icmp_type] if firewall_rule.key?(:icmp_type)
+            item[:icmpCode]       = firewall_rule[:icmp_code] if firewall_rule.key?(:icmp_code)
+            items << { properties: item }
+          end
+          { firewallrules: { items: items } }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require File.expand_path('../server', __FILE__)
+require File.expand_path('../../helpers/compute/data_helper', __dir__)
+
+module Fog
+  module Compute
+    class ProfitBricks
+      class Servers < Fog::Collection
+        include Fog::Helpers::ProfitBricks::DataHelper
+        model Fog::Compute::ProfitBricks::Server
+
+        def all(datacenter_id)
+          result = service.get_all_servers(datacenter_id)
+
+          servers = result.body['items'].each {|server| server['datacenter_id'] = datacenter_id}
+          result.body['items'] = servers
+
+          load(result.body['items'].each {|dc| flatten(dc)})
+        end
+
+        def get(datacenter_id, server_id)
+          server = service.get_server(datacenter_id, server_id).body
+          server['datacenter_id'] = datacenter_id
+
+          Excon::Errors
+          new(flatten(server))
+        rescue Excon::Errors::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/profitbricks/models/compute/snapshot.rb

@@ -0,0 +1,81 @@
+require File.expand_path('../../helpers/compute/data_helper', __dir__)
+
+module Fog
+  module Compute
+    class ProfitBricks
+      class Snapshot < Fog::Models::ProfitBricks::Base
+        include Fog::Helpers::ProfitBricks::DataHelper
+
+        identity  :id
+
+        # properties
+        attribute :name
+        attribute :description
+        attribute :location
+        attribute :size
+        attribute :cpu_hot_plug,            :aliases => 'cpuHotPlug'
+        attribute :cpu_hot_unplug,          :aliases => 'cpuHotUnplug'
+        attribute :ram_hot_plug,            :aliases => 'ramHotPlug'
+        attribute :ram_hot_unplug,          :aliases => 'ramHotUnplug'
+        attribute :nic_hot_plug,            :aliases => 'nicHotPlug'
+        attribute :nic_hot_unplug,          :aliases => 'nicHotUnplug'
+        attribute :disc_virtio_hot_plug,    :aliases => 'discVirtioHotPlug'
+        attribute :disc_virtio_hot_unplug,  :aliases => 'discVirtioHotUnplug'
+        attribute :disc_scsi_hot_plug,      :aliases => 'discScsiHotPlug'
+        attribute :disc_scsi_hot_unplug,    :aliases => 'discScsiHotUnplug'
+        attribute :licence_type,            :aliases => 'licenceType'
+
+        # metadata
+        attribute :created_date,        :aliases => 'createdDate', :type => :time
+        attribute :created_by,          :aliases => 'createdBy'
+        attribute :last_modified_date,  :aliases => 'lastModifiedDate', :type => :time
+        attribute :last_modified_by,    :aliases => 'lastModifiedBy'
+        attribute :request_id,          :aliases => 'requestId'
+        attribute :state
+
+        attr_accessor :options
+
+        def initialize(attributes = {})
+          super
+        end
+
+        def update
+          requires :id
+
+          options = {}
+          options[:name]                = name if name
+          options[:description]         = description if description
+          options[:cpuHotPlug]          = cpu_hot_plug if cpu_hot_plug
+          options[:cpuHotUnplug]        = cpu_hot_unplug if cpu_hot_unplug
+          options[:ramHotPlug]          = ram_hot_plug if ram_hot_plug
+          options[:ramHotUnplug]        = ram_hot_unplug if ram_hot_unplug
+          options[:nicHotPlug]          = nic_hot_plug if nic_hot_plug
+          options[:nicHotUnplug]        = nic_hot_unplug if nic_hot_unplug
+          options[:discVirtioHotPlug]   = disc_virtio_hot_plug if disc_virtio_hot_plug
+          options[:discVirtioHotUnplug] = disc_virtio_hot_unplug if disc_virtio_hot_unplug
+          options[:discScsiHotPlug]     = disc_scsi_hot_plug if disc_scsi_hot_plug
+          options[:discScsiHotUnplug]   = disc_scsi_hot_unplug if disc_scsi_hot_unplug
+          options[:licenceType]         = license_type if license_type
+
+          data = service.update_snapshot(id, options)
+          merge_attributes(flatten(data.body))
+          true
+        end
+
+        def delete
+          requires :id
+          service.delete_snapshot(id)
+          true
+        end
+
+        def ready?
+          state == 'AVAILABLE'
+        end
+
+        def failed?
+          state == 'ERROR'
+        end
+      end
+    end
+  end
+end