fog-proxmox-configlmm 0.15.0

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

@@ -0,0 +1,271 @@
+# 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.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# 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/compute/models/server'
+require 'fog/proxmox/helpers/disk_helper'
+require 'fog/proxmox/hash'
+require 'fog/proxmox/errors'
+
+module Fog
+  module Proxmox
+    class Compute
+      # Server model
+      # rubocop:disable ClassLength
+      class Server < Fog::Compute::Server
+        identity  :vmid
+        attribute :type
+        attribute :node_id
+        attribute :config
+        attribute :digest
+        attribute :name
+        attribute :maxdisk
+        attribute :disk
+        attribute :diskwrite
+        attribute :diskread
+        attribute :uptime
+        attribute :netout
+        attribute :netin
+        attribute :cpu
+        attribute :cpus
+        attribute :template
+        attribute :status
+        attribute :maxcpu
+        attribute :mem
+        attribute :maxmem
+        attribute :qmpstatus
+        attribute :ha
+        attribute :pid
+        attribute :blockstat
+        attribute :balloon
+        attribute :ballooninfo
+        attribute :snapshots
+        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 to_s
+          name
+        end
+
+        def container?
+          type == 'lxc'
+        end
+
+        def persisted?
+          service.next_vmid(vmid: vmid)
+          false
+        rescue Excon::Error::InternalServerError
+          false
+        rescue Excon::Error::BadRequest
+          true
+        end
+
+        # request with async task
+        def request(name, body_params = {}, path_params = {})
+          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 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(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 = {})
+          request(:delete_server, options, vmid: vmid)
+        end
+
+        def action(action, options = {})
+          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 backup(options = {})
+          request(:create_backup, options.merge(vmid: vmid))
+          reload
+        end
+
+        def restore(backup, options = {})
+          attr_hash = if container?
+                        options.merge(ostemplate: backup.volid, force: 1, restore: 1)
+                      else
+                        options.merge(archive: backup.volid, force: 1)
+                      end
+          save(attr_hash)
+        end
+
+        def clone(newid, options = {})
+          request(:clone_server, options.merge(newid: newid), vmid: vmid)
+          reload
+        end
+
+        def create_template(options = {})
+          service.template_server({ node: node_id, type: type, vmid: vmid }, options)
+          reload
+        end
+
+        def migrate(target, options = {})
+          request(:migrate_server, options.merge(target: target), vmid: vmid)
+        end
+
+        def extend(disk, size, options = {})
+          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(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 = {})
+          disk_hash = Fog::Proxmox::DiskHelper.flatten(disk.merge(options: options))
+          update(disk_hash)
+        end
+
+        def detach(diskid)
+          update(delete: diskid)
+        end
+
+        def start_console(options = {})
+          unless ready?
+            raise ::Fog::Proxmox::Errors::ServiceError,
+                  'Unable to start console because server not running.'
+          end
+
+          if container?
+            type_console = options[:console]
+            options.delete_if { |option| [:console].include? option }
+            unless type_console
+              raise ::Fog::Proxmox::Errors::ServiceError,
+                    'Unable to start console because console container config is not set or unknown.'
+            end
+          else
+            type_console = config.type_console
+            unless type_console
+              raise ::Fog::Proxmox::Errors::ServiceError,
+                    'Unable to start console because VGA display server config is not set or unknown.'
+            end
+          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 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
+          list 'backup'
+        end
+
+        def images
+          list 'images'
+        end
+
+        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, identity) }
+          volumes
+        end
+
+        protected
+
+        def initialize_config(new_attributes = {})
+          options = { service: service, vmid: vmid }
+          attributes[:config] = Fog::Proxmox::Compute::ServerConfig.new(options.merge(new_attributes))
+        end
+
+        private
+
+        def initialize_snapshots
+          attributes[:snapshots] =
+            Fog::Proxmox::Compute::Snapshots.new(service: service, server_id: vmid, server_type: type, node_id: node_id)
+        end
+
+        def initialize_tasks
+          attributes[:tasks] = Fog::Proxmox::Compute::Tasks.new(service: service, node_id: node_id).select do |task|
+            task.id == vmid
+          end
+        end
+
+        def node
+          Fog::Proxmox::Compute::Node.new(service: service, node: node_id)
+        end
+      end
+      # rubocop:enable ClassLength
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# 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.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# 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/attributes'
+require 'fog/proxmox/helpers/nic_helper'
+require 'fog/proxmox/helpers/controller_helper'
+
+module Fog
+  module Proxmox
+    class Compute
+      # ServerConfig model: https://pve.proxmox.com/pve-docs/api-viewer/index.html#/nodes/{node}/{qemu|lxc}/{vmid}/config
+      # memory, balloon, shares and swap are in Mb
+      class ServerConfig < Fog::Model
+        identity  :vmid
+        attribute :description
+        attribute :ostype
+        attribute :smbios1
+        attribute :bios
+        attribute :numa
+        attribute :kvm
+        attribute :vcpus
+        attribute :cores
+        attribute :bootdisk
+        attribute :onboot
+        attribute :boot
+        attribute :agent
+        attribute :scsihw
+        attribute :sockets
+        attribute :memory
+        attribute :shares
+        attribute :balloon
+        attribute :name
+        attribute :cpu
+        attribute :cpulimit
+        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
+        attribute :ciuser
+        attribute :cipassword
+        attribute :cicustom
+        attribute :citype
+        attribute :ipconfigs
+        attribute :sshkeys
+        attribute :searchdomain
+        attribute :nameserver
+
+        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
+
+        def type_console
+          console = 'vnc' if %w[std cirrus vmware].include?(vga)
+          console = 'spice' if %w[qxl qxl2 qxl3 qxl4].include?(vga)
+          console = 'term' if %w[serial0 serial1 serial2 serial3].include?(vga)
+          console
+        end
+
+        def flatten
+          flat_hash = attributes.reject { |attribute| %i[node_id type vmid disks interfaces].include? attribute }
+          flat_hash.merge(interfaces_flatten)
+          flat_hash.merge(disks_flatten)
+          flat_hash
+        end
+
+        private
+
+        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::Proxmox::Compute::Interfaces.new
+          nets.each do |key, value|
+            nic_hash = {
+              id: key.to_s,
+              model: Fog::Proxmox::NicHelper.extract_nic_id(value),
+              macaddr: Fog::Proxmox::NicHelper.extract_mac_address(value)
+            }
+            names = Fog::Proxmox::Compute::Interface.attributes.reject do |attribute|
+              %i[id macaddr model].include? attribute
+            end
+            names.each { |name| nic_hash.store(name.to_sym, Fog::Proxmox::ControllerHelper.extract(name, value)) }
+            attributes[:interfaces] << Fog::Proxmox::Compute::Interface.new(nic_hash)
+          end
+        end
+
+        def initialize_disks(new_attributes)
+          controllers = Fog::Proxmox::ControllerHelper.collect_controllers(new_attributes)
+          attributes[:disks] = Fog::Proxmox::Compute::Disks.new
+          controllers.each do |key, value|
+            storage, volid, size = Fog::Proxmox::DiskHelper.extract_storage_volid_size(value)
+            disk_hash = {
+              id: key.to_s,
+              size: size,
+              volid: volid,
+              storage: storage
+            }
+            names = Fog::Proxmox::Compute::Disk.attributes.reject do |attribute|
+              %i[id size storage volid].include? attribute
+            end
+            names.each { |name| disk_hash.store(name.to_sym, Fog::Proxmox::ControllerHelper.extract(name, value)) }
+            attributes[:disks] << Fog::Proxmox::Compute::Disk.new(disk_hash)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# 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.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# 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/compute/models/server'
+
+module Fog
+  module Proxmox
+    class Compute
+      # Servers Collection
+      class Servers < Fog::Collection
+        model Fog::Proxmox::Compute::Server
+        attribute :node_id
+        attribute :type
+
+        def new(new_attributes = {})
+          super({ node_id: node_id, type: type }.merge(new_attributes))
+        end
+
+        def next_id
+          service.next_vmid
+        end
+
+        def id_valid?(vmid)
+          service.next_vmid(vmid: vmid)
+          true
+        rescue Excon::Errors::BadRequest
+          false
+        end
+
+        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 StandardError => 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)
+            end
+
+            raise(e)
+          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_id, type: type)
+          load service.list_servers(body_params)
+        end
+
+        def create(new_attributes = {})
+          object = new(new_attributes.select { |key, _value| %i[node_id vmid type].include? key.to_sym })
+          object.save(new_attributes.reject { |key, _value| %i[node_id vmid type].include? key.to_sym })
+          object
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# 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.
+
+# 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.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Fog::Proxmox. If not, see <http://www.gnu.org/licenses/>.
+
+module Fog
+  module Proxmox
+    class Compute
+      # class Snapshot model
+      class Snapshot < Fog::Model
+        identity  :name
+        attribute :description
+        attribute :snaptime
+        attribute :vmstate
+        attribute :node_id
+        attribute :server_id
+        attribute :server_type
+        attribute :vmgenid
+
+        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('server_id', attributes, new_attributes)
+          Fog::Proxmox::Attributes.set_attr_and_sym('server_type', attributes, new_attributes)
+          Fog::Proxmox::Attributes.set_attr_and_sym('name', attributes, new_attributes)
+          requires :node_id, :server_id, :server_type, :name
+          super(new_attributes)
+        end
+
+        def save
+          path_params = { node: node_id, type: server_type, vmid: server_id }
+          body_params = { snapname: name, vmstate: vmstate }
+          server.tasks.wait_for(service.create_snapshot(path_params, body_params))
+        end
+
+        def update
+          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
+          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)
+          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::Proxmox::Compute::Server.new(service: service, node_id: node_id, type: server_type, vmid: server_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# 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.
+
+# Fog::Proxmox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# 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/compute/models/snapshot'
+
+module Fog
+  module Proxmox
+    class Compute
+      # class Snapshots Collection of snapshots
+      class Snapshots < Fog::Collection
+        model Fog::Proxmox::Compute::Snapshot
+        attribute :server_id
+        attribute :server_type
+        attribute :node_id
+
+        def new(new_attributes = {})
+          super({ node_id: node_id, server_id: server_id, server_type: server_type }.merge(new_attributes))
+        end
+
+        def all
+          path_params = { node: node_id, type: server_type, vmid: server_id }
+          load service.list_snapshots(path_params)
+        end
+
+        def get(name)
+          all.find { |snapshot| snapshot.identity == name }
+        end
+      end
+    end
+  end
+end