hybrid_platforms_conductor 33.0.0 → 33.0.1

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

@@ -2,27 +2,34 @@ require 'hybrid_platforms_conductor/hpc_plugins/provisioner/proxmox'
 
 describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
-  context 'checking the reserve_proxmox_container sync tool' do
+  context 'when checking the reserve_proxmox_container sync tool' do
 
-    context 'checking how IPs are being assigned to containers' do
+    context 'when 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' }
+          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(
+          )
+          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'
@@ -32,21 +39,28 @@ describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
       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' }
+          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(
+          )
+          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'
@@ -56,22 +70,29 @@ describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
       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' }
+          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(
+          )
+          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'
@@ -81,27 +102,34 @@ describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
       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' }
+          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')
+          )
+          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
 

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

@@ -2,20 +2,22 @@ require 'hybrid_platforms_conductor/hpc_plugins/provisioner/proxmox'
 
 describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
-  context 'checking the reserve_proxmox_container sync tool' do
+  context 'when checking the reserve_proxmox_container sync tool' do
 
-    context 'checking resources limits when other LXC containers are present' do
+    context 'when 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 }
+          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,
@@ -26,42 +28,48 @@ describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
       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 }
+          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 }
+          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 }
+          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,
@@ -72,28 +80,32 @@ describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
       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 }
+          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 }
+          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
@@ -101,28 +113,30 @@ describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
       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 }
+          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,
@@ -133,53 +147,63 @@ describe HybridPlatformsConductor::HpcPlugins::Provisioner::Proxmox do
 
       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 }
+          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')
+          )
+          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 => {}
+          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({
+          )
+          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