fog-proxmox-configlmm 0.15.0

data/lib/fog/proxmox/helpers/cpu_helper.rb

@@ -0,0 +1,88 @@
+# 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/>.
+
+module Fog
+  module Proxmox
+    # module Cpu mixins
+    module CpuHelper
+      CPU_REGEXP = /(\bcputype=)?(?<cputype>[\w-]+),?(\bflags=)?(?<flags>[[+-][\w-]+;?]*)/
+      FLAGS = { spectre: 'spec-ctrl', pcid: 'pcid', ssbd: 'ssbd', ibpb: 'ibpb', virt_ssbd: 'virt-ssbd',
+                amd_ssbd: 'amd-ssbd', amd_no_ssb: 'amd-no-ssb', md_clear: 'md-clear', pdpe1gb: 'pdpe1gb', hv_tlbflush: 'hv-tlbflush', aes: 'aes', hv_evmcs: 'hv-evmcs' }
+      def self.flags
+        FLAGS
+      end
+
+      def self.extract(cpu, name)
+        captures_h = cpu ? CPU_REGEXP.match(cpu.to_s) : { cputype: '', flags: '' }
+        captures_h[name]
+      end
+
+      def self.extract_cputype(cpu)
+        extract(cpu, :cputype)
+      end
+
+      def self.extract_flags(cpu)
+        extract(cpu, :flags)
+      end
+
+      def self.flag_value(cpu, flag_key)
+        flag_value = '0'
+        raw_values = extract_flags(cpu).split(';').select { |flag| ['+' + flag_key, '-' + flag_key].include?(flag) }
+        unless raw_values.empty?
+          flag_value = if raw_values[0].start_with?('+')
+                         '+1'
+                       else
+                         raw_values[0].start_with?('-') ? '-1' : '0'
+                       end
+        end
+        flag_value
+      end
+
+      def self.hash_has_no_default_flag?(cpu_h, flag_name)
+        cpu_h.key?(flag_name) && ['-1', '+1'].include?(cpu_h[flag_name])
+      end
+
+      def self.hash_flag(cpu_h, flag_name)
+        flag = ''
+        if cpu_h.key?(flag_name)
+          flag = '+' if cpu_h[flag_name] == '+1'
+          flag = '-' if cpu_h[flag_name] == '-1'
+        end
+        flag
+      end
+
+      def self.flatten(cpu_h)
+        return '' unless cpu_h['cpu_type']
+
+        cpu_type = "cputype=#{cpu_h['cpu_type']}"
+        num_flags = 0
+        FLAGS.each_key { |flag_key| num_flags += 1 if hash_has_no_default_flag?(cpu_h, flag_key.to_s) }
+        cpu_type += ',flags=' if num_flags > 0
+        flags_with_no_default_value = FLAGS.select do |flag_key, _flag_value|
+          hash_has_no_default_flag?(cpu_h, flag_key.to_s)
+        end
+        flags_with_no_default_value.each_with_index do |(flag_key, flag_value), index|
+          cpu_type += hash_flag(cpu_h, flag_key.to_s) + flag_value if hash_has_no_default_flag?(cpu_h, flag_key.to_s)
+          cpu_type += ';' if num_flags > index + 1
+        end
+        cpu_type
+      end
+    end
+  end
+end

data/lib/fog/proxmox/helpers/disk_helper.rb

@@ -0,0 +1,185 @@
+# 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/hash'
+
+module Fog
+  module Proxmox
+    # module Disk mixins
+    module DiskHelper
+      DISKS_REGEXP = /^(scsi|sata|mp|rootfs|virtio|ide)(\d+){0,1}$/
+      SERVER_DISK_REGEXP = /^(scsi|sata|virtio|ide)(\d+)$/
+      MOUNT_POINT_REGEXP = /^(mp)(\d+)$/
+      ROOTFS_REGEXP = /^(rootfs)$/
+      CDROM_REGEXP = /^(.*),{0,1}(media=cdrom),{0,1}(.*)$/
+      TEMPLATE_REGEXP = /^(.*)(base-)(.*)$/
+      CLOUD_INIT_REGEXP = /^(.*)(cloudinit)(.*)$/
+
+      # Convert disk attributes hash into API Proxmox parameters string
+      def self.flatten(disk)
+        id = disk[:id]
+        value = ''
+        if disk[:volid]
+          value += disk[:volid]
+          value += ',size=' + disk[:size].to_s if disk[:size]
+        elsif disk[:storage] && disk[:size]
+          value += disk[:storage] + ':' + disk[:size].to_s
+        elsif id == 'ide2'
+          value += 'none'
+        end
+        opts = disk[:options] if disk[:options]
+        main_a = %i[id volid storage size]
+        opts ||= disk.reject { |key, _value| main_a.include? key }
+        options = ''
+        options += Fog::Proxmox::Hash.stringify(opts) if opts
+        if id == 'ide2' && !cdrom?(options)
+          options += ',' unless options.empty?
+          options += 'media=cdrom'
+        end
+        value += ',' if !options.empty? && !value.empty?
+        value += options
+        { "#{id}": value }
+      end
+
+      def self.extract_controller(id)
+        extract(id)[0]
+      end
+
+      def self.extract_device(id)
+        extract(id)[1].to_i
+      end
+
+      def self.extract(id)
+        id.scan(/(\w+)(\d+)/).first
+      end
+
+      # Convert API Proxmox parameter string into attribute hash value
+      def self.extract_option(name, disk_value)
+        values = disk_value.scan(/#{name}=(\w+)/)
+        name_value = values.first if values
+        name_value&.first
+      end
+
+      # Convert API Proxmox volume/disk parameter string into volume/disk attributes hash value
+      def self.extract_storage_volid_size(disk_value)
+        # volid definition: <VOLUME_ID>:=<STORAGE_ID>:<storage type dependent volume name>
+        values_a = disk_value.scan(%r{^(([\w-]+):{0,1}([\w/.-]+))})
+        no_cdrom = !disk_value.match(CDROM_REGEXP)
+        creation = disk_value.split(',')[0].match(/^(([\w-]+):{1}(\d+))$/)
+        values = values_a.first if values_a
+        if no_cdrom
+          storage = values[1]
+          if creation
+            volid = nil
+            size = values[2].to_i
+          else
+            volid = values[0]
+            size = extract_size(disk_value)
+          end
+        else
+          volid = values[0]
+          storage = values[1] unless %w[none cdrom].include? volid
+          size = nil
+        end
+        [storage, volid, size]
+      end
+
+      def self.to_bytes(size)
+        val = size.match(/\d+(\w?)/)
+        m = 0
+        case val[1]
+        when 'K' then m = 1
+        when 'M' then m = 2
+        when 'G' then m = 3
+        when 'T' then m = 4
+        when 'P' then m = 5
+        end
+        val[0].to_i * 1024**m
+      end
+
+      def self.modulo_bytes(size)
+        size / 1024
+      end
+
+      def self.to_human_bytes(size)
+        units = %w[Kb Mb Gb]
+        i = 0
+        human_size = size.to_s + 'b'
+        while i < 3 && size >= 1024
+          size = modulo_bytes(size)
+          human_size = size.to_s + units[i]
+          i += 1
+        end
+        human_size
+      end
+
+      def self.to_int_gb(size_bytes)
+        val = to_human_bytes(size_bytes.to_i).match(/\d+(Gb)/)
+        val ? val[0].to_i : 0
+      end
+
+      def self.extract_size(disk_value)
+        size = extract_option('size', disk_value)
+        size = to_int_gb(to_bytes(size)).to_s if size.match?(/\d+(G)/)
+        size
+      end
+
+      def self.disk?(id)
+        DISKS_REGEXP.match(id) ? true : false
+      end
+
+      def self.cdrom?(value)
+        CDROM_REGEXP.match(value) ? true : false
+      end
+
+      def self.server_disk?(id)
+        SERVER_DISK_REGEXP.match(id) ? true : false
+      end
+
+      def self.rootfs?(id)
+        ROOTFS_REGEXP.match(id) ? true : false
+      end
+
+      def self.mount_point?(id)
+        MOUNT_POINT_REGEXP.match(id) ? true : false
+      end
+
+      def self.container_disk?(id)
+        rootfs?(id) || mount_point?(id)
+      end
+
+      def self.template?(volid)
+        TEMPLATE_REGEXP.match(volid) ? true : false
+      end
+
+      def self.cloud_init?(volid)
+        CLOUD_INIT_REGEXP.match(volid) ? true : false
+      end
+
+      def self.of_type?(disk_h, vm_type)
+        id = disk_h['id'] if disk_h.key?('id')
+        id = disk_h[:id] if disk_h.key?(:id)
+        result = false
+        result = server_disk?(id) if vm_type == 'qemu'
+        result = container_disk?(id) if vm_type == 'lxc'
+        result
+      end
+    end
+  end
+end

data/lib/fog/proxmox/helpers/ip_helper.rb

@@ -0,0 +1,101 @@
+# 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 'resolv'
+require 'fog/proxmox/hash'
+
+module Fog
+  module Proxmox
+    # module IpHelper mixins
+    module IpHelper
+      CIDRv4_PREFIX = '([0-9]|[1-2][0-9]|3[0-2])'
+      CIDRv4_PREFIX_REGEXP = /^#{CIDRv4_PREFIX}$/
+      IPv4_SRC = "#{Resolv::IPv4::Regex.source.delete_suffix('\z').delete_prefix('\A')}"
+      CIDRv4_REGEXP = Regexp.new("\\A(#{IPv4_SRC})(\/#{CIDRv4_PREFIX})?\\z")
+      CIDRv6_PREFIX = '(\d+)'
+      CIDRv6_PREFIX_REGEXP = /^#{CIDRv6_PREFIX}$/xi
+      IPv6_SRC = "#{Resolv::IPv6::Regex_8Hex.source.delete_suffix('\z').delete_prefix('\A')}"
+      CIDRv6_REGEXP = Regexp.new("\\A(#{IPv6_SRC})(\/#{CIDRv6_PREFIX})?\\z", Regexp::EXTENDED | Regexp::IGNORECASE)
+
+      def self.cidr?(ip)
+        CIDRv4_REGEXP.match?(ip)
+      end
+
+      def self.cidr6?(ip)
+        CIDRv6_REGEXP.match?(ip)
+      end
+
+      def self.prefix(ip)
+        return unless cidr = CIDRv4_REGEXP.match(ip)
+
+        cidr[7]
+      end
+
+      def self.prefix6(ip)
+        return unless cidr = CIDRv6_REGEXP.match(ip)
+
+        cidr[3]
+      end
+
+      def self.ip?(ip)
+        Resolv::IPv4::Regex.match?(ip)
+      end
+
+      def self.ip6?(ip)
+        Resolv::IPv6::Regex.match?(ip)
+      end
+
+      def self.cidr_prefix?(prefix)
+        CIDRv4_PREFIX_REGEXP.match?(prefix)
+      end
+
+      def self.cidr6_prefix?(prefix)
+        CIDRv6_PREFIX_REGEXP.match?(prefix) && prefix.to_i >= 0 && prefix.to_i <= 128
+      end
+
+      def self.ip(ip)
+        return unless cidr = CIDRv4_REGEXP.match(ip)
+
+        cidr[1]
+      end
+
+      def self.ip6(ip)
+        return unless cidr = CIDRv6_REGEXP.match(ip)
+
+        cidr[1]
+      end
+
+      def self.to_cidr(ip, prefix = nil)
+        return nil unless ip?(ip) && (!prefix || cidr_prefix?(prefix))
+
+        cidr = "#{ip}"
+        cidr += "/#{prefix}" if cidr_prefix?(prefix)
+        cidr
+      end
+
+      def self.to_cidr6(ip, prefix = nil)
+        return nil unless ip6?(ip) && (!prefix || cidr6_prefix?(prefix))
+
+        cidr = "#{ip}"
+        cidr += "/#{prefix}" if cidr6_prefix?(prefix)
+        cidr
+      end
+    end
+  end
+end

data/lib/fog/proxmox/helpers/nic_helper.rb

@@ -0,0 +1,132 @@
+# 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/hash'
+
+module Fog
+  module Proxmox
+    # module NicHelper mixins
+    module NicHelper
+      NICS_REGEXP = /^(net)(\d+)/
+
+      def self.extract_mac_address(nic_value)
+        nic_value[/([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})/]
+      end
+
+      def self.model_regexp
+        /^model=(\w+),.+/
+      end
+
+      def self.name_regexp
+        /^name=(\w+),.+/
+      end
+
+      def self.ip_regexp
+        %r{^(.+),{1}ip=([\d./]+),?(.+)?$}
+      end
+
+      def self.nic_update_regexp
+        /^(\w+)={1}([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2}).+/
+      end
+
+      def self.has_model?(nic_value)
+        nic_value.match?(model_regexp)
+      end
+
+      def self.has_name?(nic_value)
+        nic_value.match?(name_regexp)
+      end
+
+      def self.has_ip?(nic_value)
+        nic_value.match?(ip_regexp)
+      end
+
+      def self.extract_nic_id(nic_value)
+        if has_model?(nic_value)
+          nic_value.scan(model_regexp).first.first
+        elsif has_name?(nic_value)
+          nic_value.scan(name_regexp).first.first
+        else
+          nic_value.scan(nic_update_regexp).first.first
+        end
+      end
+
+      def self.to_mac_adresses_array(nics)
+        addresses = []
+        nics.each { |nic| addresses.push(nic.macaddr) }
+        addresses
+      end
+
+      def self.nic_name(nic)
+        if nic.has_key?(:model)
+          'model'
+        elsif nic.has_key?(:name)
+          'name'
+        else
+          ''
+        end
+      end
+
+      def self.set_mac(nic_id, nic_hash)
+        mac_keys = %i[macaddr hwaddr]
+        nic_value = ''
+        if (nic_hash.keys & mac_keys).empty?
+          nic_value = nic_name(nic_hash) + '=' + nic_id
+        else
+          mac_value = nic_hash[mac_keys[0]] if nic_hash.key?(mac_keys[0])
+          mac_value ||= nic_hash[mac_keys[1]] if nic_hash.key?(mac_keys[1])
+          nic_value = nic_id + '=' + mac_value
+        end
+        nic_value
+      end
+
+      # Convert nic attributes hash into API Proxmox parameters string
+      def self.flatten(nic_hash)
+        if nic_hash[:hwaddr].nil?
+          nic_id = nic_hash[nic_name(nic_hash).to_sym]
+          nic_value = set_mac(nic_id, nic_hash)
+          options = nic_hash.reject do |key, _value|
+            [nic_name(nic_hash).to_sym, :id, :hwaddr, :macaddr].include? key.to_sym
+          end
+          nic_value += ',' + Fog::Proxmox::Hash.stringify(options) unless options.empty?
+        else
+          options = nic_hash.reject do |key, _value|
+            %i[id model macaddr].include? key.to_sym
+          end
+          nic_value = Fog::Proxmox::Hash.stringify(options) unless options.empty?
+        end
+        { "#{nic_hash[:id]}": nic_value }
+      end
+
+      def self.collect_nics(attributes)
+        attributes.select { |key| nic?(key.to_s) }
+      end
+
+      def self.nic?(id)
+        NICS_REGEXP.match(id) ? true : false
+      end
+
+      def self.extract_ip(nic_value)
+        ip_regexp.match(nic_value) do |ip|
+          ip[2]
+        end
+      end
+    end
+  end
+end

data/lib/fog/proxmox/identity/models/domain.rb

@@ -0,0 +1,69 @@
+# 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 Identity
+      # class Domain model authentication
+      class Domain < Fog::Model
+        identity :realm
+        attribute :comment
+        attribute :tfa
+        attribute :type
+
+        def initialize(new_attributes = {})
+          initialize_type(new_attributes)
+          super(new_attributes)
+        end
+
+        def save(new_attributes = {})
+          service.create_domain(type.attributes.merge(new_attributes).merge(attributes.reject do |attribute|
+                                                                              [:type].include? attribute
+                                                                            end))
+          reload
+        end
+
+        def destroy
+          requires :realm
+          service.delete_domain(realm)
+          true
+        end
+
+        def update
+          requires :realm
+          service.update_domain(realm, type.attributes.merge(attributes).reject do |attribute|
+                                         %i[type realm].include? attribute
+                                       end)
+          reload
+        end
+
+        private
+
+        def initialize_type(new_attributes = {})
+          if new_attributes.has_key? :realm
+            realm = new_attributes.delete(:realm)
+          elsif new_attributes.has_key? 'realm'
+            realm = new_attributes.delete('realm')
+          end
+          attributes[:type] = Fog::Proxmox::Identity::DomainType.new(new_attributes)
+          new_attributes.delete_if { |new_attribute| attributes[:type].attributes.has_key? new_attribute.to_sym }
+          new_attributes.store(:realm, realm)
+        end
+      end
+    end
+  end
+end

data/lib/fog/proxmox/identity/models/domain_type.rb

@@ -0,0 +1,47 @@
+# 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 Identity
+      # class Domain type model authentication
+      class DomainType < Fog::Model
+        identity :type
+        attribute :id
+        attribute :key
+        attribute :url
+        attribute :base_dn
+        attribute :bind_dn
+        attribute :capath
+        attribute :cert
+        attribute :certkey
+        attribute :comment
+        attribute :default
+        attribute :domain
+        attribute :port
+        attribute :secure
+        attribute :server1
+        attribute :server2
+        attribute :tfa
+        attribute :user_attr
+        attribute :verify
+        attribute :step
+        attribute :digits
+      end
+    end
+  end
+end

data/lib/fog/proxmox/identity/models/domains.rb

@@ -0,0 +1,44 @@
+# 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/identity/models/domain'
+
+module Fog
+  module Proxmox
+    class Identity
+      # class Domains collection authentication
+      class Domains < Fog::Collection
+        model Fog::Proxmox::Identity::Domain
+
+        def all
+          load service.list_domains
+        end
+
+        def get(id)
+          all.find { |domain| domain.identity == id }
+        end
+
+        def destroy(id)
+          domain = get(id)
+          domain.destroy
+        end
+      end
+    end
+  end
+end