fog-proxmox 0.5.5 → 0.6.0

data/fog-proxmox.gemspec

@@ -1,4 +1,3 @@
-# frozen_string_literal: true
 # Copyright 2018 Tristan Robert
 
 # This file is part of Fog::Proxmox.
@@ -40,7 +39,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.3'
   spec.rubygems_version = '~> 2.6'
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'debase', '~> 0.2.2'
   spec.add_development_dependency 'debride', '~> 1.8'
   spec.add_development_dependency 'fasterer', '~> 0.3'

data/lib/fog/compute/proxmox.rb

@@ -47,20 +47,15 @@ module Fog
       collection :tasks
       model :snapshot
       collection :snapshots
-      model :container
-      collection :containers
-      model :container_config
 
       # Requests
       request_path 'fog/compute/proxmox/requests'
 
       # Manage nodes cluster
       request :list_nodes
-      request :get_node
       request :get_node_statistics
-      # Manage servers
       request :next_vmid
-      request :check_vmid
+      # Manage servers
       request :list_servers
       request :create_server
       request :get_server_status
@@ -83,7 +78,6 @@ module Fog
       request :create_backup
       # Manage storages
       request :list_storages
-      request :get_storage
       # Tasks
       request :list_tasks
       request :get_task
@@ -92,7 +86,7 @@ module Fog
       request :log_task
       # CRUD snapshots
       request :list_snapshots
-      request :get_snapshot
+      request :get_snapshot_config
       request :create_snapshot
       request :update_snapshot
       request :delete_snapshot

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

@@ -1,12 +1,3 @@
-# frozen_string_literal: true
-# Copyright 2018 Tristan Robert
-
-# This file is part of Fog::Proxmox.
-
-# Fog::Proxmox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
 # Copyright 2018 Tristan Robert
 
 # This file is part of Fog::Proxmox.
@@ -26,14 +17,13 @@
 
 # frozen_string_literal: true
 
-require 'fog/proxmox/models/model'
 require 'fog/proxmox/helpers/disk_helper'
 
 module Fog
   module Compute
     class Proxmox
       # class Disk model
-      class Disk < Fog::Proxmox::Model
+      class Disk < Fog::Model
         identity  :id
         attribute :volid
         attribute :size
@@ -64,6 +54,18 @@ module Fog
         def rootfs?
           id == 'rootfs'
         end
+
+        def mount_point?
+          id.match(/(mp)(\d+)/)
+        end
+
+        def controller?
+          id.match(/(scsi|ide|sata|virtio)(\d+)/)
+        end
+
+        def flatten
+          Fog::Proxmox::DiskHelper.flatten(attributes)
+        end
       end
     end
   end

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

@@ -17,23 +17,21 @@
 # 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/disk'
 
 module Fog
   module Compute
     class Proxmox
       # class Disks Collection of disk
-      class Disks < Fog::Proxmox::Collection
+      class Disks < Fog::Collection
         model Fog::Compute::Proxmox::Disk
 
-        def all(_options = {})
+        def all
           self
         end
 
         def get(id)
-          cached_disk = find { |disk| disk.id == id }
-          return cached_disk if cached_disk
+          all.find { |disk| disk.identity === id }
         end
 
         def next_device(controller)

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

@@ -1,12 +1,3 @@
-# frozen_string_literal: true
-# Copyright 2018 Tristan Robert
-
-# This file is part of Fog::Proxmox.
-
-# Fog::Proxmox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
 # Copyright 2018 Tristan Robert
 
 # This file is part of Fog::Proxmox.
@@ -26,13 +17,13 @@
 
 # frozen_string_literal: true
 
-require 'fog/proxmox/models/model'
+require "fog/proxmox/helpers/nic_helper"
 
 module Fog
   module Compute
     class Proxmox
       # class Interface model
-      class Interface < Fog::Proxmox::Model
+      class Interface < Fog::Model
         identity  :id
         attribute :mac
         attribute :model
@@ -45,6 +36,10 @@ module Fog
         attribute :rate
         attribute :queues
         attribute :tag
+
+        def flatten
+          Fog::Proxmox::NicHelper.flatten(attributes)
+        end
       end
     end
   end

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

@@ -17,7 +17,6 @@
 # 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/interface'
 require 'fog/proxmox/helpers/controller_helper'
 
@@ -25,16 +24,15 @@ module Fog
   module Compute
     class Proxmox
       # class Interfaces Collection of nodes of cluster
-      class Interfaces < Fog::Proxmox::Collection
+      class Interfaces < Fog::Collection
         model Fog::Compute::Proxmox::Interface
 
-        def all(_options = {})
+        def all
           self
         end
 
         def get(id)
-          cached_interface = find { |interface| interface.id == id }
-          return cached_interface if cached_interface
+          all.find { |interface| interface.identity === id }
         end
 
         def next_nicid

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

@@ -26,72 +26,67 @@
 
 # frozen_string_literal: true
 
-require 'fog/proxmox/models/model'
+require 'fog/proxmox/attributes'
 
 module Fog
   module Compute
     class Proxmox
       # class Node model of VMs
-      class Node < Fog::Proxmox::Model
+      class Node < Fog::Model
         identity  :node
+        attribute :cpu
+        attribute :level
+        attribute :maxcpu
+        attribute :maxmem
+        attribute :mem
+        attribute :maxdisk
+        attribute :disk
+        attribute :ssl_fingerprint
         attribute :status
-        attribute :wait
         attribute :uptime
-        attribute :pveversion
-        attribute :ksm
-        attribute :kversion
-        attribute :loadavg
-        attribute :rootfs
-        attribute :cpu
-        attribute :cpuinfo
-        attribute :memory
-        attribute :idle
-        attribute :swap
-        attribute :servers
         attribute :tasks
+        attribute :servers
+        attribute :containers
         attribute :storages
 
-        def to_s
-          node
+        def initialize(new_attributes = {})
+          prepare_service_value(new_attributes)
+          Fog::Proxmox::Attributes.set_attr_and_sym('node', attributes, new_attributes)
+          requires :node
+          initialize_tasks
+          initialize_servers
+          initialize_containers
+          initialize_storages
+          super(new_attributes)
         end
 
-        def tasks
-          @tasks ||= begin
-            Fog::Compute::Proxmox::Tasks.new(service: service,
-                                             node: self)
-          end
+        def backup(options = {})
+          task_upid = service.backup({ node: node }, options)
+          task_upid
         end
 
-        def servers
-          @servers ||= begin
-            Fog::Compute::Proxmox::Servers.new(service: service,
-                                               node: self)
-          end
+        def statistics(output = 'rrddata', options = { timeframe: 'hour', cf: 'AVERAGE'})
+          path_params = { node: node, output: output }
+          query_params = options
+          service.get_node_statistics(path_params,query_params)
         end
 
-        def containers
-          @containers ||= begin
-            Fog::Compute::Proxmox::Containers.new(service: service,
-                                                  node: self)
-          end
+        private
+
+        def initialize_tasks
+          attributes[:tasks] = Fog::Compute::Proxmox::Tasks.new(service: service, node_id: node)
         end
 
-        def storages
-          @storages ||= begin
-            Fog::Compute::Proxmox::Storages.new(service: service,
-                                                node: self)
-          end
+        def initialize_servers
+          attributes[:servers] = Fog::Compute::Proxmox::Servers.new(service: service, node_id: node, type: 'qemu')
         end
 
-        def backup(options = {})
-          task_upid = service.backup({ node: node }, options)
-          task_upid
+        def initialize_containers
+          attributes[:containers] = Fog::Compute::Proxmox::Servers.new(service: service, node_id: node, type: 'lxc')
         end
 
-        def statistics(output = 'rrddata', options = { timeframe: 'hour', cf: 'AVERAGE'})
-          path_params = { node: node, output: output }
-          query_params = options
-          service.get_node_statistics(path_params,query_params)
+        def initialize_storages
+          attributes[:storages] = Fog::Compute::Proxmox::Storages.new(service: service, node_id: node)
         end
 
       end

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

@@ -17,27 +17,21 @@
 # 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/node'
 
 module Fog
   module Compute
     class Proxmox
       # class Nodes Collection of nodes of cluster
-      class Nodes < Fog::Proxmox::Collection
+      class Nodes < Fog::Collection
         model Fog::Compute::Proxmox::Node
 
-        def all(_options = {})
-          load_response(service.list_nodes, 'nodes')
+        def all
+          load service.list_nodes
         end
 
-        def find_by_id(id)
-          cached_node = find { |node| node.node == id }
-          return cached_node if cached_node
-          node_hash = service.get_node(id)
-          Fog::Compute::Proxmox::Node.new(
-            node_hash.merge(service: service, node: id)
-          )
+        def get(id)
+          all.find { |node| node.identity === id }
         end
       end
     end

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

@@ -20,6 +20,7 @@
 require 'fog/compute/models/server'
 require 'fog/proxmox/helpers/disk_helper'
 require 'fog/proxmox/hash'
+require 'fog/proxmox/errors'
 
 module Fog
   module Compute
@@ -27,11 +28,11 @@ module Fog
       # Server model
       class Server < Fog::Compute::Server
         identity  :vmid
-        attribute :id
-        attribute :node
+        attribute :type
+        attribute :node_id
         attribute :config
+        attribute :digest
         attribute :name
-        attribute :type
         attribute :maxdisk
         attribute :disk
         attribute :diskwrite
@@ -53,116 +54,164 @@ module Fog
         attribute :balloon
         attribute :ballooninfo
         attribute :snapshots
-
-        def initialize(attributes = {})
-          prepare_service_value(attributes)
-          set_config(attributes)
-          super
-        end
-
-        def type
-          attributes[:type]
-        end 
-
+        attribute :tasks
+        attribute :vmgenid
+        attribute :lock
+        attribute :maxswap
+        attribute :swap
+
+        def initialize(new_attributes = {})
+          prepare_service_value(new_attributes)
+          Fog::Proxmox::Attributes.set_attr_and_sym('node_id', attributes, new_attributes)
+          Fog::Proxmox::Attributes.set_attr_and_sym('type', attributes, new_attributes)
+          Fog::Proxmox::Attributes.set_attr_and_sym('vmid', attributes, new_attributes)
+          requires :node_id, :type, :vmid
+          initialize_config(new_attributes)
+          initialize_snapshots
+          initialize_tasks
+          super(new_attributes)
+        end
+
+        def container?
+          type == 'lxc'
+        end
+
+        def persisted?
+          service.next_vmid(vmid: vmid)
+          persisted = false
+          persisted
+        rescue Excon::Error::InternalServerError
+          persisted = false
+          persisted
+        rescue Excon::Error::BadRequest
+          persisted = true
+          persisted
+        end
+
+        # request with async task
         def request(name, body_params = {}, path_params = {})
-          requires :node, :type
-          path = path_params.merge(node: node, type: type)
+          requires :node_id, :type
+          path = path_params.merge(node: node_id, type: type)
           task_upid = service.send(name, path, body_params)
           tasks.wait_for(task_upid)
         end
 
-        def create(config = {})
-          request(:create_server, config.merge(vmid: vmid))
+        def save(new_attributes = {})
+          body_params = new_attributes.merge(vmid: vmid)
+          body_params = body_params.merge(config.flatten) unless persisted?
+          request(:create_server, body_params)
+          reload
         end
 
-        def update(config = {})
-          requires :vmid
-          request(:update_server, config, vmid: vmid)
+        def update(new_attributes = {})
+          if container?
+            path_params = { node: node_id, type: type, vmid: vmid }
+            body_params = new_attributes
+            service.update_server(path_params, body_params)
+          else
+            request(:update_server, new_attributes, vmid: vmid)
+          end
+          reload
         end
 
         def destroy(options = {})
-          requires :vmid
           request(:delete_server, options, vmid: vmid)
         end
 
         def action(action, options = {})
-          requires :vmid
           action_known = %w[start stop resume suspend shutdown reset].include? action
           message = "Action #{action} not implemented"
           raise Fog::Errors::Error, message unless action_known
           request(:action_server, options, action: action, vmid: vmid)
+          reload
         end
 
         def ready?
           status == 'running'
         end
 
-        def reload
-          requires :vmid
-          object = collection.get(vmid)
-          merge_attributes(object.attributes)
-        end
-
         def backup(options = {})
-          requires :vmid
           request(:create_backup, options.merge(vmid: vmid))
+          reload
         end
 
         def restore(backup, options = {})
-          requires :vmid
-          config = options.merge(archive: backup.volid, force: 1)
-          create(config)
+          if container?
+            attr_hash = options.merge(ostemplate: backup.volid, force: 1, restore: 1)
+          else
+            attr_hash = options.merge(archive: backup.volid, force: 1)
+          end
+          save(attr_hash)
         end
 
         def clone(newid, options = {})
-          requires :vmid
           request(:clone_server, options.merge(newid: newid), vmid: vmid)
+          reload
         end
 
-        def template(options = {})
-          requires :vmid, :node
-          service.template_server({ node: node, type: type, vmid: vmid }, options)
+        def create_template(options = {})
+          service.template_server({ node: node_id, type: type, vmid: vmid }, options)
+          reload
         end
 
         def migrate(target, options = {})
-          requires :vmid
           request(:migrate_server, options.merge(target: target), vmid: vmid)
+          reload
         end
 
         def extend(disk, size, options = {})
-          requires :vmid, :node
-          service.resize_server({ node: node, vmid: vmid }, options.merge(disk: disk, size: size))
+          if container?
+            request(:resize_container, options.merge(disk: disk, size: size), vmid: vmid)
+          else
+            service.resize_server({ vmid: vmid, node: node_id }, options.merge(disk: disk, size: size))
+          end
+          reload
         end
 
-        def move(disk, storage, options = {})
-          requires :vmid
-          request(:move_disk, options.merge(disk: disk, storage: storage), vmid: vmid)
+        def move(volume, storage, options = {})
+          if container?
+            request(:move_volume, options.merge(volume: volume, storage: storage), vmid: vmid)
+          else
+            request(:move_disk, options.merge(disk: volume, storage: storage), vmid: vmid)
+          end
+          reload
         end
 
         def attach(disk, options = {})
-          config = Fog::Proxmox::DiskHelper.flatten(disk.merge(options: options))
-          update(config)
+          disk_hash = Fog::Proxmox::DiskHelper.flatten(disk.merge(options: options))
+          update(disk_hash)
         end
 
         def detach(diskid)
           update(delete: diskid)
         end
 
-        def set_config(attributes = {})
-          @config = Fog::Compute::Proxmox::ServerConfig.new({ service: service, vmid: vmid }.merge(attributes))
-        end
-
-        def config
-          path_params = { node: node, type: type, vmid: vmid }
-          set_config(service.get_server_config(path_params)) if uptime
-          @config
+        def start_console(options = {})
+          raise ::Fog::Proxmox::Errors::ServiceError, "Unable to start console because server not running." unless ready?
+          if container?
+            type_console = options[:console]
+            options.delete_if { |option| [:console].include? option }
+            raise ::Fog::Proxmox::Errors::ServiceError, "Unable to start console because console container config is not set or unknown." unless type_console
+          else
+            type_console = config.type_console
+            raise ::Fog::Proxmox::Errors::ServiceError, "Unable to start console because VGA display server config is not set or unknown." unless type_console
+          end
+          requires :vmid, :node_id, :type
+          path_params = { node: node_id, type: type, vmid: vmid }
+          body_params = options
+          data = service.send(('create_' + type_console).to_sym, path_params, body_params)
+          task_upid = data['upid']
+          if task_upid
+            task = tasks.get(task_upid)
+            task.wait_for { running? }
+          end
+          data
         end
 
-        def snapshots
-          @snapshots ||= begin
-            Fog::Compute::Proxmox::Snapshots.new(service: service,
-                                                 server: self)
-          end
+        def connect_vnc(options = {})
+          path_params = { node: node_id, type: type, vmid: vmid }
+          query_params = { port: options['port'], vncticket: options['ticket'] }
+          service.get_vnc(path_params, query_params)
         end
 
         def backups
@@ -176,36 +225,30 @@ module Fog
         def list(content)
           storages = node.storages.list_by_content_type content
           volumes = []
-          storages.each { |storage| volumes += storage.volumes.list_by_content_type_and_by_server(content, vmid) }
+          storages.each { |storage| volumes += storage.volumes.list_by_content_type_and_by_server(content, identity) }
           volumes
         end
 
-        def tasks
-          node.tasks.search(vmid: vmid)
+        protected 
+
+        def initialize_config(new_attributes = {})
+          options = { service: service, vmid: vmid }
+          attributes[:config] = Fog::Compute::Proxmox::ServerConfig.new(options.merge(new_attributes))
         end
 
-        def start_console(options = {})
-          raise ::Fog::Proxmox::Errors::ServiceError, "Unable to start console because server not running." unless ready?
-          type_console = config.type_console
-          raise ::Fog::Proxmox::Errors::ServiceError, "Unable to start console because VGA display server config is not set or unknown." unless type_console
-          requires :vmid, :node, :type
-          path_params = { node: node, type: type, vmid: vmid }
-          body_params = options
-          data = service.send(('create_' + type_console).to_sym, path_params, body_params)
-          task_upid = data['upid']
-          if task_upid
-            task = tasks.get(task_upid)
-            task.wait_for { running? }
-          end
-          data
+        private
+
+        def initialize_snapshots
+          attributes[:snapshots] = Fog::Compute::Proxmox::Snapshots.new(service: service, server_id: vmid, server_type: type, node_id: node_id)
         end
 
-        def connect_vnc(options = {})
-          requires :vmid, :node, :type
-          path_params = { node: node, type: type, vmid: vmid }
-          query_params = { port: options['port'], vncticket: options['ticket'] }
-          service.get_vnc(path_params, query_params)
+        def initialize_tasks
+          attributes[:tasks] = Fog::Compute::Proxmox::Tasks.new(service: service, node_id: node_id).select { |task| task.id == vmid }
         end
+
+        def node
+          Fog::Compute::Proxmox::Node.new(service: service, node: node_id)
+        end 
       end
     end
   end