hybrid_platforms_conductor 32.3.6

data/spec/hybrid_platforms_conductor_test/api/deployer/provisioners/proxmox/reserve_proxmox_container/ips_assignment_spec.rb

@@ -0,0 +1,112 @@
+require 'hybrid_platforms_conductor/hpc_plugins/provisioner/proxmox'
+
+describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
+
+  context 'checking the reserve_proxmox_container sync tool' do
+
+    context 'checking how IPs are being assigned to containers' do
+
+      it 'makes sure to not use an IP already assigned to another container' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              lxc_containers: {
+                1050 => { ip: '192.168.0.100' },
+                1051 => { ip: '192.168.0.101' }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 1, config: {
+            vm_ips_list: %w[
+              192.168.0.100
+              192.168.0.101
+              192.168.0.102
+            ]
+          })).to eq(
+            pve_node: 'pve_node_name',
+            vm_id: 1000,
+            vm_ip: '192.168.0.102'
+          )
+        end
+      end
+
+      it 'makes sure to not use an IP already assigned to another container even outside the VM ID range' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              lxc_containers: {
+                1 => { ip: '192.168.0.100' },
+                2 => { ip: '192.168.0.101' }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 1, config: {
+            vm_ips_list: %w[
+              192.168.0.100
+              192.168.0.101
+              192.168.0.102
+            ]
+          })).to eq(
+            pve_node: 'pve_node_name',
+            vm_id: 1000,
+            vm_ip: '192.168.0.102'
+          )
+        end
+      end
+
+      it 'makes sure to not use an IP already assigned to another container even on another PVE node' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {},
+            'pve_other_node_name' => {
+              lxc_containers: {
+                1 => { ip: '192.168.0.100' },
+                2 => { ip: '192.168.0.101' }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 1, config: {
+            vm_ips_list: %w[
+              192.168.0.100
+              192.168.0.101
+              192.168.0.102
+            ]
+          })).to eq(
+            pve_node: 'pve_node_name',
+            vm_id: 1000,
+            vm_ip: '192.168.0.102'
+          )
+        end
+      end
+
+      it 'does not reserve when no IP is available' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              lxc_containers: {
+                1 => { ip: '192.168.0.100' },
+                2 => { ip: '192.168.0.101' }
+              }
+            },
+            'pve_other_node_name' => {
+              lxc_containers: {
+                3 => { ip: '192.168.0.102' },
+                4 => { ip: '192.168.0.103' }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 1, config: {
+            vm_ips_list: %w[
+              192.168.0.100
+              192.168.0.101
+              192.168.0.102
+            ]
+          })).to eq(error: 'no_available_ip')
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/deployer/provisioners/proxmox/reserve_proxmox_container/other_lxc_containers_resources_spec.rb

@@ -0,0 +1,190 @@
+require 'hybrid_platforms_conductor/hpc_plugins/provisioner/proxmox'
+
+describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
+
+  context 'checking the reserve_proxmox_container sync tool' do
+
+    context 'checking resources limits when other LXC containers are present' do
+
+      it 'selects the PVE node when it has enough RAM despite existing containers' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              memory_total: 16 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                1 => { maxmem: 4 * 1024 * 1024 * 1024 }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 4 * 1024, 1)).to eq(
+            pve_node: 'pve_node_name',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'does not select the PVE node when it has not enough RAM because of existing containers' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              memory_total: 16 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                1 => { maxmem: 14 * 1024 * 1024 * 1024 }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 4 * 1024, 1)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'does not select the PVE node when RAM limit would be exceeded because of existing containers' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              memory_total: 16 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                1 => { maxmem: 9 * 1024 * 1024 * 1024 }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 4 * 1024, 1)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'selects the PVE node when it has enough disk despite existing containers' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              storage_total: 16 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                1 => { maxdisk: 4 * 1024 * 1024 * 1024 }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 4)).to eq(
+            pve_node: 'pve_node_name',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'does not select the PVE node when it has not enough disk because of existing containers' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              storage_total: 16 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                1 => { maxdisk: 14 * 1024 * 1024 * 1024 }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 4)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'does not select the PVE node when disk limit would be exceeded because of existing containers' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              storage_total: 16 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                1 => { maxdisk: 9 * 1024 * 1024 * 1024 }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 4)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'selects the PVE node having the most free resources considering all LXC containers' do
+        with_sync_node do
+          # Commented is the current free space in each PVE node, as well as the % of free resource if the PVE node hosts the new container.
+          mock_proxmox(mocked_pve_nodes: {
+            # Free: 4gb => 100%
+            'pve_node_0_4gb' => {
+              memory_total: 4 * 1024 * 1024 * 1024
+            },
+            # Free: 10gb => 66%
+            'pve_node_8_18gb' => {
+              memory_total: 18 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                1 => { maxmem: 2 * 1024 * 1024 * 1024 },
+                2 => { maxmem: 2 * 1024 * 1024 * 1024 },
+                3 => { maxmem: 4 * 1024 * 1024 * 1024 }
+              }
+            },
+            # Free: 24gb => 68.75%
+            'pve_node_40_64gb' => {
+              memory_total: 64 * 1024 * 1024 * 1024,
+              lxc_containers: {
+                4 => { maxmem: 40 * 1024 * 1024 * 1024 }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 4 * 1024, 1, config: { pve_nodes: nil })).to eq(
+            pve_node: 'pve_node_8_18gb',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'does not select the PVE node when the maximum number of containers has been hit' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              lxc_containers: {
+                # Make sure those containers are not expired
+                1000 => { creation_date: (Time.now - 60).utc },
+                1001 => { creation_date: (Time.now - 60).utc },
+                1002 => { creation_date: (Time.now - 60).utc },
+                1003 => { creation_date: (Time.now - 60).utc }
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 4,
+            config: { limits: {
+              nbr_vms_max: 3,
+              cpu_loads_thresholds: [10, 10, 10],
+              ram_percent_used_max: 0.75,
+              disk_percent_used_max: 0.75
+            } }
+          )).to eq(error: 'exceeded_number_of_vms')
+        end
+      end
+
+      it 'does not count containers outside the VM ID range in the containers limit' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_name' => {
+              lxc_containers: {
+                # Make sure those containers are not expired
+                1000 => { creation_date: (Time.now - 60).utc },
+                1001 => { creation_date: (Time.now - 60).utc },
+                1 => {},
+                2 => {}
+              }
+            }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 4,
+            config: { limits: {
+              nbr_vms_max: 3,
+              cpu_loads_thresholds: [10, 10, 10],
+              ram_percent_used_max: 0.75,
+              disk_percent_used_max: 0.75
+            } }
+          )).to eq({
+            pve_node: 'pve_node_name',
+            vm_id: 1002,
+            vm_ip: '192.168.0.100'
+          })
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/deployer/provisioners/proxmox/reserve_proxmox_container/pve_node_resources_spec.rb

@@ -0,0 +1,200 @@
+require 'hybrid_platforms_conductor/hpc_plugins/provisioner/proxmox'
+
+describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
+
+  context 'checking the reserve_proxmox_container sync tool' do
+
+    context 'checking resources limits at the PVE node level' do
+
+      it 'reserves a resource on an empty PVE node having enough resources' do
+        with_sync_node do
+          mock_proxmox
+          expect(call_reserve_proxmox_container(2, 1024, 4)).to eq(
+            pve_node: 'pve_node_name',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+          expect_proxmox_actions_to_be [
+            [:post, 'nodes/pve_node_name/lxc', {
+              'cores' => 2,
+              'cpulimit' => 2,
+              'description' => /^===== HPC info =====\nnode: test_node\nenvironment: test_env\ncreation_date: .+\n/,
+              'hostname' => 'test.hostname.my-domain.com',
+              'memory' => 1024,
+              'net0' => 'name=eth0,bridge=vmbr0,gw=172.16.16.16,ip=192.168.0.100/32',
+              'ostemplate' => 'test_template.iso',
+              'rootfs' => 'local-lvm:4',
+              'vmid' => 1000
+            }]
+          ]
+        end
+      end
+
+      it 'reserves a resource on an empty PVE node having enough resources using Proxmox user, password and realm from environment' do
+        with_sync_node do
+          ENV['hpc_user_for_proxmox'] = 'test_proxmox_user'
+          ENV['hpc_password_for_proxmox'] = 'test_proxmox_password'
+          ENV['hpc_realm_for_proxmox'] = 'test_proxmox_realm'
+          mock_proxmox(proxmox_user: 'test_proxmox_user', proxmox_password: 'test_proxmox_password', proxmox_realm: 'test_proxmox_realm')
+          expect(call_reserve_proxmox_container(2, 1024, 4)).to eq(
+            pve_node: 'pve_node_name',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'does not reserve a resource on an empty PVE node not having enough RAM in total' do
+        with_sync_node do
+          mock_proxmox
+          # Default Proxmox mock has 16 GB RAM. Try reserving 128 GB.
+          expect(call_reserve_proxmox_container(2, 128 * 1024, 4)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'does not reserve a resource on an empty PVE node having enough RAM but with a limit that would be exceeded by the new container' do
+        with_sync_node do
+          mock_proxmox
+          # Default Proxmox mock has 16 GB RAM and limit is 75% (12 GB). Try reserving 13 GB.
+          expect(call_reserve_proxmox_container(2, 13 * 1024, 4)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'does not reserve a resource on an empty PVE node not having enough disk in total' do
+        with_sync_node do
+          mock_proxmox
+          # Default Proxmox mock has 100 GB disk. Try reserving 128 GB.
+          expect(call_reserve_proxmox_container(2, 1024, 128)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'does not reserve a resource on an empty PVE node having enough disk but with a limit that would be exceeded by the new container' do
+        with_sync_node do
+          mock_proxmox
+          # Default Proxmox mock has 100 GB disk and limit is 75% (75 GB). Try reserving 76 GB.
+          expect(call_reserve_proxmox_container(2, 1024, 76)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'does not reserve a resource on an empty PVE node exceeding a CPU load limit' do
+        with_sync_node do
+          # Default Proxmox mock has a limit of load 10. Try reserving while the load is greater.
+          mock_proxmox(mocked_pve_nodes: { 'pve_node_name' => { loadavg: [0.1, 11, 0.1] } })
+          expect(call_reserve_proxmox_container(2, 1024, 4)).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'chooses among several PVE nodes the one having enough resources' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_1' => { loadavg: [0.1, 11, 0.1] },
+            'pve_node_2' => { memory_total: 1126 * 1024 * 1024 },
+            'pve_node_3' => {},
+            'pve_node_4' => { storage_total: 512 * 1024 * 1024 }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 4, config: { pve_nodes: %w[pve_node_1 pve_node_2 pve_node_3 pve_node_4] })).to eq(
+            pve_node: 'pve_node_3',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'chooses among several PVE nodes by discovering them instead of limiting them in the config' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_1' => { loadavg: [0.1, 11, 0.1] },
+            'pve_node_2' => { memory_total: 1126 * 1024 * 1024 },
+            'pve_node_3' => {},
+            'pve_node_4' => { storage_total: 512 * 1024 * 1024 }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 4, config: { pve_nodes: nil })).to eq(
+            pve_node: 'pve_node_3',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'chooses among several PVE nodes the one having the most free resources' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_1gb' => { memory_total: 1 * 1024 * 1024 * 1024 },
+            'pve_node_4.5gb' => { memory_total: 4608 * 1024 * 1024 },
+            'pve_node_5gb' => { memory_total: 5 * 1024 * 1024 * 1024 },
+            'pve_node_10gb' => { memory_total: 10 * 1024 * 1024 * 1024 },
+            'pve_node_7gb' => { memory_total: 7 * 1024 * 1024 * 1024 }
+          })
+          expect(call_reserve_proxmox_container(2, 4096, 4, config: { pve_nodes: %w[pve_node_1gb pve_node_4.5gb pve_node_5gb pve_node_10gb pve_node_7gb] })).to eq(
+            pve_node: 'pve_node_10gb',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'chooses among several PVE nodes the one having the most free resources and that are part of the authorized PVE nodes' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_1gb' => { memory_total: 1 * 1024 * 1024 * 1024 },
+            'pve_node_4.5gb' => { memory_total: 4608 * 1024 * 1024 },
+            'pve_node_5gb' => { memory_total: 5 * 1024 * 1024 * 1024 },
+            'pve_node_10gb' => { memory_total: 10 * 1024 * 1024 * 1024 },
+            'pve_node_7gb' => { memory_total: 7 * 1024 * 1024 * 1024 }
+          })
+          expect(call_reserve_proxmox_container(2, 4096, 4, config: { pve_nodes: %w[pve_node_1gb pve_node_5gb pve_node_7gb] })).to eq(
+            pve_node: 'pve_node_7gb',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+      it 'does not reserve a resource if the only PVE nodes having resources are not in the list of authorized PVE nodes' do
+        with_sync_node do
+          mock_proxmox(mocked_pve_nodes: {
+            'pve_node_1gb' => { memory_total: 1 * 1024 * 1024 * 1024 },
+            'pve_node_4.5gb' => { memory_total: 4608 * 1024 * 1024 },
+            'pve_node_5gb' => { memory_total: 5 * 1024 * 1024 * 1024 },
+            'pve_node_10gb' => { memory_total: 10 * 1024 * 1024 * 1024 },
+            'pve_node_7gb' => { memory_total: 7 * 1024 * 1024 * 1024 }
+          })
+          expect(call_reserve_proxmox_container(2, 4096, 4, config: { pve_nodes: %w[pve_node_1gb pve_node_4.5gb] })).to eq(error: 'not_enough_resources')
+        end
+      end
+
+      it 'chooses among several PVE nodes the one having the most free resources using coeffs between different criteria' do
+        with_sync_node do
+          # We ask to reserve 1GB of RAM and 1GB of disk.
+          # Commented are the % of those resources' usage when having such a container in each PVE node, with the resulting score considering RAM 3 times as important than disk.
+          mock_proxmox(mocked_pve_nodes: {
+            # 100% RAM 25% disk => 325
+            'pve_node_1gb_4gb' => { memory_total: 1 * 1024 * 1024 * 1024, storage_total: 4 * 1024 * 1024 * 1024 },
+            # 50% RAM 25% disk => 175
+            'pve_node_2gb_4gb' => { memory_total: 2 * 1024 * 1024 * 1024, storage_total: 4 * 1024 * 1024 * 1024 },
+            # 50% RAM 50% disk => 200
+            'pve_node_2gb_2gb' => { memory_total: 2 * 1024 * 1024 * 1024, storage_total: 2 * 1024 * 1024 * 1024 },
+            # 40% RAM 10% disk => 130
+            'pve_node_2.5gb_10gb' => { memory_total: 2560 * 1024 * 1024, storage_total: 10 * 1024 * 1024 * 1024 },
+            # 25% RAM 50% disk => 125
+            'pve_node_4gb_2gb' => { memory_total: 4 * 1024 * 1024 * 1024, storage_total: 2 * 1024 * 1024 * 1024 },
+            # 25% RAM 100% disk => 175
+            'pve_node_4gb_1gb' => { memory_total: 4 * 1024 * 1024 * 1024, storage_total: 1 * 1024 * 1024 * 1024 }
+          })
+          expect(call_reserve_proxmox_container(2, 1024, 1, config: {
+            coeff_ram_consumption: 3,
+            coeff_disk_consumption: 1,
+            pve_nodes: nil
+          })).to eq(
+            pve_node: 'pve_node_4gb_2gb',
+            vm_id: 1000,
+            vm_ip: '192.168.0.100'
+          )
+        end
+      end
+
+    end
+
+  end
+
+end