fog-proxmox 0.5.5 → 0.6.0

data/lib/fog/compute/proxmox/models/server_config.rb

@@ -17,18 +17,16 @@
 # You should have received a copy of the GNU General Public License
 # along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
 
-require 'fog/proxmox/variables'
+require 'fog/proxmox/attributes'
 require 'fog/proxmox/helpers/nic_helper'
 require 'fog/proxmox/helpers/controller_helper'
-require 'fog/proxmox/models/model'
 
 module Fog
   module Compute
     class Proxmox
       # ServerConfig model
-      class ServerConfig < Fog::Proxmox::Model
+      class ServerConfig < Fog::Model
         identity  :vmid
-        attribute :digest
         attribute :description
         attribute :ostype
         attribute :smbios1
@@ -52,24 +50,39 @@ module Fog
         attribute :cpuunits
         attribute :keyboard
         attribute :vga
+        attribute :storage
+        attribute :template
+        attribute :arch
+        attribute :swap
+        attribute :hostname
+        attribute :nameserver
+        attribute :searchdomain
+        attribute :password
+        attribute :startup
+        attribute :console
+        attribute :cmode
+        attribute :tty
+        attribute :force
+        attribute :lock
+        attribute :pool
+        attribute :bwlimit
+        attribute :unprivileged
         attribute :interfaces
         attribute :disks
 
-        def initialize(attributes = {})
-          prepare_service_value(attributes)
-          compute_nets(attributes)
-          compute_disks(attributes)
-          super(attributes)
+        def initialize(new_attributes = {})
+          prepare_service_value(new_attributes)
+          Fog::Proxmox::Attributes.set_attr_and_sym('vmid', attributes, new_attributes)
+          requires :vmid
+          initialize_interfaces(new_attributes)
+          initialize_disks(new_attributes)
+          super(new_attributes)
         end
 
         def mac_addresses
           Fog::Proxmox::NicHelper.to_mac_adresses_array(interfaces)
         end
 
-        attr_reader :disks
-
-        attr_reader :interfaces
-
         def type_console
           console = 'vnc' if %w[std cirrus vmware].include?(vga)
           console = 'spice' if %w[qxl qxl2 qxl3 qxl4].include?(vga)
@@ -77,26 +90,45 @@ module Fog
           console
         end
 
+        def flatten
+          flat_hash = attributes.reject { |attribute| [:node_id, :type, :vmid, :disks, :interfaces].include? attribute }
+          flat_hash.merge(interfaces_flatten)
+          flat_hash.merge(disks_flatten)
+          flat_hash
+        end
+
         private
 
-        def compute_nets(attributes)
-          nets = Fog::Proxmox::NicHelper.collect_nics(attributes)
-          @interfaces ||= Fog::Compute::Proxmox::Interfaces.new
+        def interfaces_flatten
+          flat_hash = {}
+          interfaces.each { |interface| flat_hash.merge(interface.flatten) }
+          flat_hash
+        end
+
+        def disks_flatten
+          flat_hash = {}
+          disks.each { |disk| flat_hash.merge(disk.flatten) }
+          flat_hash
+        end
+
+        def initialize_interfaces(new_attributes)
+          nets = Fog::Proxmox::NicHelper.collect_nics(new_attributes)
+          attributes[:interfaces] = Fog::Compute::Proxmox::Interfaces.new
           nets.each do |key, value|
             nic_hash = {
               id: key.to_s,
-              model: Fog::Proxmox::NicHelper.extract_model(value),
+              model: Fog::Proxmox::NicHelper.extract_nic_id(value),
               mac: Fog::Proxmox::NicHelper.extract_mac_address(value)
             }
-            names = Fog::Compute::Proxmox::Interface.attributes.reject { |key, _value| %i[id mac model].include? key }
+            names = Fog::Compute::Proxmox::Interface.attributes.reject { |attribute| [:id, :mac, :model].include? attribute }
             names.each { |name| nic_hash.store(name.to_sym, Fog::Proxmox::ControllerHelper.extract(name, value)) }
-            @interfaces << Fog::Compute::Proxmox::Interface.new(nic_hash)
+            attributes[:interfaces] << Fog::Compute::Proxmox::Interface.new(nic_hash)
           end
         end
 
-        def compute_disks(attributes)
-          controllers = Fog::Proxmox::ControllerHelper.collect_controllers(attributes)
-          @disks ||= Fog::Compute::Proxmox::Disks.new
+        def initialize_disks(new_attributes)
+          controllers = Fog::Proxmox::ControllerHelper.collect_controllers(new_attributes)
+          attributes[:disks] = Fog::Compute::Proxmox::Disks.new
           controllers.each do |key, value|
             storage, volid, size = Fog::Proxmox::DiskHelper.extract_storage_volid_size(value)
             disk_hash = {
@@ -105,9 +137,9 @@ module Fog
               volid: volid,
               storage: storage
             }
-            names = Fog::Compute::Proxmox::Disk.attributes.reject { |key, _value| %i[id size storage volid].include? key }
+            names = Fog::Compute::Proxmox::Disk.attributes.reject { |attribute| [:id, :size, :storage, :volid].include? attribute }
             names.each { |name| disk_hash.store(name.to_sym, Fog::Proxmox::ControllerHelper.extract(name, value)) }
-            @disks << Fog::Compute::Proxmox::Disk.new(disk_hash)
+            attributes[:disks] << Fog::Compute::Proxmox::Disk.new(disk_hash)
           end
         end
       end

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

@@ -23,48 +23,56 @@ module Fog
   module Compute
     class Proxmox
       # Servers Collection
-      class Servers < Fog::Proxmox::Collection
+      class Servers < Fog::Collection
         model Fog::Compute::Proxmox::Server
-        attribute :node
+        attribute :node_id
+        attribute :type
 
-        def initialize(attributes = {})
-          super(attributes)
-        end
-
-        def type
-          'qemu'
-        end
-
-        def new(attributes = {})
-          super({ node: node, type: type }.merge(attributes))
+        def new(new_attributes = {})
+          super({ node_id: node_id, type: type }.merge(new_attributes))
         end
 
         def next_id
-          response = service.next_vmid
-          body = JSON.decode(response.body)
-          data = body['data']
-          Integer(data)
+          service.next_vmid
         end
 
         def id_valid?(vmid)
-          service.check_vmid(vmid)
+          service.next_vmid(vmid: vmid)
           true
         rescue Excon::Errors::BadRequest
           false
         end
 
-        def get(vmid)
-          requires :node
-          path_params = { node: node, type: type, vmid: vmid }
-          server_data = service.get_server_status path_params
-          config_data = service.get_server_config path_params
-          data = server_data.merge(config_data).merge(node: node, vmid: vmid)
-          new(data)
+        def containers?
+          type == 'lxc'
+        end
+
+        def get(id)
+          path_params = { node: node_id, type: type, vmid: id }
+          begin
+            status_data = service.get_server_status path_params
+            config_data = service.get_server_config path_params
+          rescue => e
+            if e.respond_to?('response') && e.response.respond_to?('data') && e.response.data.has_key?(:reason_phrase) && e.response.data[:reason_phrase].end_with?('does not exist')
+              raise(Fog::Errors::NotFound)
+            else
+              raise(e)
+            end
+          else
+            data = status_data.merge(config_data).merge(node: node_id, vmid: id)
+            new(data)
+          end
         end
 
         def all(options = {})
-          body_params = options.merge(node: node, type: type)
-          load_response(service.list_servers(body_params), 'servers')
+          body_params = options.merge(node: node_id, type: type)
+          load service.list_servers(body_params)
+        end
+
+        def create(new_attributes = {})
+          object = new(new_attributes.select { |key, _value| [:node_id, :vmid, :type].include? key.to_sym })
+          object.save(new_attributes.reject { |key, _value| [:node_id, :vmid, :type].include? key.to_sym })
+          object
         end
       end
     end

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

@@ -25,45 +25,59 @@
 # You should have received a copy of the GNU General Public License
 # along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
 
-require 'fog/proxmox/models/model'
-
 module Fog
   module Compute
     class Proxmox
       # class Snapshot model
-      class Snapshot < Fog::Proxmox::Model
+      class Snapshot < Fog::Model
         identity  :name
         attribute :description
         attribute :snaptime
         attribute :vmstate
-        attribute :server
+        attribute :node_id
+        attribute :server_id
+        attribute :server_type
+        attribute :vmgenid
+
+        def initialize(new_attributes = {})
+          prepare_service_value(new_attributes)
+          attributes[:node_id] = new_attributes[:node_id] unless new_attributes[:node_id].nil?
+          attributes[:server_id] = new_attributes[:server_id] unless new_attributes[:server_id].nil?
+          attributes[:server_type] = new_attributes[:server_type] unless new_attributes[:server_type].nil?
+          attributes[:name] = new_attributes[:name] unless new_attributes[:name].nil?
+          attributes[:name] = new_attributes['name'] unless new_attributes['name'].nil?
+          requires :node_id, :server_id, :server_type, :name
+          super(new_attributes)
+        end
 
-        def create(options = {})
-          requires :server
-          path_params = { node: server.node, type: server.type, vmid: server.vmid }
-          body_params = options
+        def save
+          path_params = { node: node_id, type: server_type, vmid: server_id }
+          body_params = { snapname: name }
           server.tasks.wait_for(service.create_snapshot(path_params, body_params))
         end
 
         def update
-          requires :name, :server
-          path_params = { node: server.node, type: server.type, vmid: server.vmid, snapname: name }
+          path_params = { node: node_id, type: server_type, vmid: server_id, snapname: name }
           body_params = { description: description }
           service.update_snapshot(path_params, body_params)
         end
 
         def rollback
-          requires :name, :server
-          path_params = { node: server.node, type: server.type, vmid: server.vmid, snapname: name }
+          path_params = { node: node_id, type: server_type, vmid: server_id, snapname: name }
           server.tasks.wait_for(service.rollback_snapshot(path_params))
         end
 
         def destroy(force = 0)
-          requires :name, :server
-          path_params = { node: server.node, type: server.type, vmid: server.vmid, snapname: name }
+          path_params = { node: node_id, type: server_type, vmid: server_id, snapname: name }
           query_params = { force: force }
           server.tasks.wait_for(service.delete_snapshot(path_params, query_params))
         end
+
+        private
+
+        def server
+          Fog::Compute::Proxmox::Server.new(service: service, node_id: node_id, type: server_type, vmid: server_id)
+        end
       end
     end
   end

data/lib/fog/compute/proxmox/models/snapshots.rb

@@ -17,37 +17,29 @@
 # You should have received a copy of the GNU General Public License
 # along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
 
-require 'fog/proxmox/models/collection'
 require 'fog/compute/proxmox/models/snapshot'
 
 module Fog
   module Compute
     class Proxmox
       # class Snapshots Collection of snapshots
-      class Snapshots < Fog::Proxmox::Collection
+      class Snapshots < Fog::Collection
         model Fog::Compute::Proxmox::Snapshot
-        attribute :server
+        attribute :server_id
+        attribute :server_type
+        attribute :node_id
 
-        def new(attributes = {})
-          requires :server
-          super({ server: server }.merge!(attributes))
+        def new(new_attributes = {})
+          super({ node_id: node_id, server_id: server_id, server_type: server_type }.merge(new_attributes))
         end
 
         def all
-          requires :server
-          path_params = { node: server.node, type: server.type, vmid: server.vmid }
-          load_response(service.list_snapshots(path_params), 'snapshots')
+          path_params = { node: node_id, type: server_type, vmid: server_id }
+          load service.list_snapshots(path_params)
         end
 
         def get(name)
-          requires :server
-          cached_snapshot = find { |snapshot| snapshot.name == name }
-          return cached_snapshot if cached_snapshot
-          path_params = { node: server.node, type: server.type, vmid: server.vmid, snapname: name }
-          snapshot_hash = service.get_snapshot(path_params)
-          Fog::Compute::Proxmox::Snapshot.new(
-            snapshot_hash.merge(service: service, server: server, name: name)
-          )
+          all.find { |snapshot| snapshot.identity === name }
         end
       end
     end

data/lib/fog/compute/proxmox/models/storage.rb

@@ -26,15 +26,13 @@
 
 # frozen_string_literal: true
 
-require 'fog/proxmox/models/model'
-
 module Fog
   module Compute
     class Proxmox
       # class Storage model
-      class Storage < Fog::Proxmox::Model
+      class Storage < Fog::Model
         identity  :storage
-        attribute :node
+        attribute :node_id, aliases: :node
         attribute :content
         attribute :type
         attribute :avail
@@ -43,17 +41,23 @@ module Fog
         attribute :shared
         attribute :active
         attribute :enabled
+        attribute :used_fraction
         attribute :volumes
 
-        def to_s
-          storage
+        def initialize(new_attributes = {})
+          prepare_service_value(new_attributes)
+          attributes[:node_id] = new_attributes[:node_id] unless new_attributes[:node_id].nil?
+          attributes[:storage] = new_attributes[:storage] unless new_attributes[:storage].nil?
+          attributes[:storage] = new_attributes['storage'] unless new_attributes['storage'].nil?
+          requires :node_id, :storage
+          initialize_volumes
+          super(new_attributes)
         end
 
-        def volumes
-          @volumes ||= begin
-            Fog::Compute::Proxmox::Volumes.new(service: service,
-                                               node: node, storage: self)
-          end
+        private
+
+        def initialize_volumes
+          attributes[:volumes] = Fog::Compute::Proxmox::Volumes.new(service: service, node_id: node_id, storage_id: identity)
         end
       end
     end

data/lib/fog/compute/proxmox/models/storages.rb

@@ -17,42 +17,33 @@
 # You should have received a copy of the GNU General Public License
 # along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
 
-require 'fog/proxmox/models/collection'
 require 'fog/compute/proxmox/models/storage'
 
 module Fog
   module Compute
     class Proxmox
       # class Storages Collection of storages
-      class Storages < Fog::Proxmox::Collection
+      class Storages < Fog::Collection
         model Fog::Compute::Proxmox::Storage
-        attribute :node
-
-        def new(attributes = {})
-          requires :node
-          super({ node: node }.merge(attributes))
-        end
-
-        def all
-          search
+        attribute :node_id
+        
+        def new(new_attributes = {})
+          super({ node_id: node_id }.merge(new_attributes))
         end
 
-        def search(options = {})
-          requires :node
-          load_response(service.list_storages(node, options), 'storages')
+        def all(filters = {})
+          requires :node_id
+          load service.list_storages(node_id, filters)
         end
 
         def list_by_content_type(content)
-          search(content: content)
+          requires :node_id
+          all.select { |storage| storage.content.include? content }
         end
 
-        def find_by_id(id)
-          cached_storage = find { |storage| storage.storage == id }
-          return cached_storage if cached_storage
-          storage_hash = service.get_storage(node, id, {})
-          Fog::Compute::Proxmox::Storage.new(
-            storage_hash.merge(service: service)
-          )
+        def get(id)
+          requires :node_id
+          all.find { |storage| storage.identity === id }
         end
       end
     end

data/lib/fog/compute/proxmox/models/task.rb

@@ -26,15 +26,13 @@
 
 # frozen_string_literal: true
 
-require 'fog/proxmox/models/model'
-
 module Fog
   module Compute
     class Proxmox
       # class Task model of a node
-      class Task < Fog::Proxmox::Model
+      class Task < Fog::Model
         identity  :upid
-        attribute :node
+        attribute :node_id, aliases: :node
         attribute :status
         attribute :exitstatus
         attribute :pid
@@ -47,13 +45,13 @@ module Fog
         attribute :status_details
         attribute :log
 
-        def new(attributes = {})
-          requires :node
-          super({ node: node }.merge(attributes))
-        end
-
-        def to_s
-          upid
+        def initialize(new_attributes = {})
+          prepare_service_value(new_attributes)
+          attributes[:node_id] = new_attributes[:node_id] unless new_attributes[:node_id].nil?
+          attributes[:upid] = new_attributes[:upid] unless new_attributes[:upid].nil?
+          attributes[:upid] = new_attributes['upid'] unless new_attributes['upid'].nil?
+          requires :node_id, :upid
+          super(new_attributes)
         end
 
         def succeeded?
@@ -69,12 +67,10 @@ module Fog
         end
 
         def stop
-          requires :node, :upid
-          service.stop_task(node, upid)
+          service.stop_task(node_id, upid)
         end
 
         def reload
-          requires :upid
           object = collection.get(upid)
           merge_attributes(object.attributes)
         end