vmpooler 2.0.0 → 2.3.0

data/lib/vmpooler/pool_manager.rb

@@ -60,6 +60,7 @@ module Vmpooler
             to_set[k] = pool[k]
           end
           to_set['alias'] = pool['alias'].join(',') if to_set.key?('alias')
+          to_set['domain'] = Parsing.get_domain_for_pool(config, pool['name'])
           redis.hmset("vmpooler__pool__#{pool['name']}", to_set.to_a.flatten) unless to_set.empty?
         end
         previously_configured_pools.each do |pool|
@@ -148,15 +149,15 @@ module Vmpooler
         end
         pool_alias = redis.hget("vmpooler__vm__#{vm}", 'pool_alias')
 
-        redis.pipelined do
-          redis.hset("vmpooler__active__#{pool}", vm, Time.now)
-          redis.hset("vmpooler__vm__#{vm}", 'checkout', Time.now)
+        redis.pipelined do |pipeline|
+          pipeline.hset("vmpooler__active__#{pool}", vm, Time.now)
+          pipeline.hset("vmpooler__vm__#{vm}", 'checkout', Time.now)
           if ondemandrequest_hash['token:token']
-            redis.hset("vmpooler__vm__#{vm}", 'token:token', ondemandrequest_hash['token:token'])
-            redis.hset("vmpooler__vm__#{vm}", 'token:user', ondemandrequest_hash['token:user'])
-            redis.hset("vmpooler__vm__#{vm}", 'lifetime', $config[:config]['vm_lifetime_auth'].to_i)
+            pipeline.hset("vmpooler__vm__#{vm}", 'token:token', ondemandrequest_hash['token:token'])
+            pipeline.hset("vmpooler__vm__#{vm}", 'token:user', ondemandrequest_hash['token:user'])
+            pipeline.hset("vmpooler__vm__#{vm}", 'lifetime', $config[:config]['vm_lifetime_auth'].to_i)
           end
-          redis.sadd("vmpooler__#{request_id}__#{pool_alias}__#{pool}", vm)
+          pipeline.sadd("vmpooler__#{request_id}__#{pool_alias}__#{pool}", vm)
         end
         move_vm_queue(pool, vm, 'pending', 'running', redis)
         check_ondemand_request_ready(request_id, redis)
@@ -164,12 +165,12 @@ module Vmpooler
         redis.smove("vmpooler__pending__#{pool}", "vmpooler__ready__#{pool}", vm)
       end
 
-      redis.pipelined do
-        redis.hset("vmpooler__boot__#{Date.today}", "#{pool}:#{vm}", finish) # maybe remove as this is never used by vmpooler itself?
-        redis.hset("vmpooler__vm__#{vm}", 'ready', Time.now)
+      redis.pipelined do |pipeline|
+        pipeline.hset("vmpooler__boot__#{Date.today}", "#{pool}:#{vm}", finish) # maybe remove as this is never used by vmpooler itself?
+        pipeline.hset("vmpooler__vm__#{vm}", 'ready', Time.now)
 
         # last boot time is displayed in API, and used by alarming script
-        redis.hset('vmpooler__lastboot', pool, Time.now)
+        pipeline.hset('vmpooler__lastboot', pool, Time.now)
       end
 
       $metrics.timing("time_to_ready_state.#{pool}", finish)
@@ -294,6 +295,12 @@ module Vmpooler
               move_vm_queue(pool, vm, 'running', 'completed', redis, 'is listed as running, but has no checkouttime data. Removing from running')
             end
 
+            # tag VM if not tagged yet, this ensures the method is only called once
+            unless redis.hget("vmpooler__vm__#{vm}", 'user_tagged')
+              success = provider.tag_vm_user(pool, vm)
+              redis.hset("vmpooler__vm__#{vm}", 'user_tagged', 'true') if success
+            end
+
             throw :stop_checking if provider.vm_ready?(pool, vm)
 
             throw :stop_checking if provider.get_vm(pool, vm)
@@ -355,35 +362,47 @@ module Vmpooler
       max_hostname_retries = 3
       while hostname_retries < max_hostname_retries
         hostname, hostname_available = generate_and_check_hostname
-        domain = $config[:config]['domain']
-        dns_ip, dns_available = check_dns_available(hostname, domain)
+        domain = Parsing.get_domain_for_pool(config, pool_name)
+        if domain
+          fqdn = "#{hostname}.#{domain}"
+        else
+          fqdn = hostname
+        end
+
+        # skip dns check if the provider is set to skip_dns_check_before_creating_vm
+        provider = get_provider_for_pool(pool_name)
+        if provider && provider.provider_config['skip_dns_check_before_creating_vm']
+          dns_available = true
+        else
+          dns_ip, dns_available = check_dns_available(fqdn)
+        end
+
         break if hostname_available && dns_available
 
         hostname_retries += 1
 
         if !hostname_available
           $metrics.increment("errors.duplicatehostname.#{pool_name}")
-          $logger.log('s', "[!] [#{pool_name}] Generated hostname #{hostname} was not unique (attempt \##{hostname_retries} of #{max_hostname_retries})")
+          $logger.log('s', "[!] [#{pool_name}] Generated hostname #{fqdn} was not unique (attempt \##{hostname_retries} of #{max_hostname_retries})")
         elsif !dns_available
           $metrics.increment("errors.staledns.#{pool_name}")
-          $logger.log('s', "[!] [#{pool_name}] Generated hostname #{hostname} already exists in DNS records (#{dns_ip}), stale DNS")
+          $logger.log('s', "[!] [#{pool_name}] Generated hostname #{fqdn} already exists in DNS records (#{dns_ip}), stale DNS")
         end
       end
 
-      raise "Unable to generate a unique hostname after #{hostname_retries} attempts. The last hostname checked was #{hostname}" unless hostname_available && dns_available
+      raise "Unable to generate a unique hostname after #{hostname_retries} attempts. The last hostname checked was #{fqdn}" unless hostname_available && dns_available
 
       hostname
     end
 
-    def check_dns_available(vm_name, domain = nil)
-      # Query the DNS for the name we want to create and if it already exists, mark it unavailable
-      # This protects against stale DNS records
-      vm_name = "#{vm_name}.#{domain}" if domain
+    # Query the DNS for the name we want to create and if it already exists, mark it unavailable
+    # This protects against stale DNS records
+    def check_dns_available(vm_name)
       begin
         dns_ip = Resolv.getaddress(vm_name)
       rescue Resolv::ResolvError
         # this is the expected case, swallow the error
-        # eg "no address for blah-daisy"
+        # eg "no address for blah-daisy.example.com"
         return ['', true]
       end
       [dns_ip, false]
@@ -391,6 +410,7 @@ module Vmpooler
 
     def _clone_vm(pool_name, provider, request_id = nil, pool_alias = nil)
       new_vmname = find_unique_hostname(pool_name)
+      pool_domain = Parsing.get_domain_for_pool(config, pool_name)
       mutex = vm_mutex(new_vmname)
       mutex.synchronize do
         @redis.with_metrics do |redis|
@@ -400,6 +420,7 @@ module Vmpooler
           redis.hset("vmpooler__vm__#{new_vmname}", 'clone', Time.now)
           redis.hset("vmpooler__vm__#{new_vmname}", 'template', pool_name) # This value is used to represent the pool.
           redis.hset("vmpooler__vm__#{new_vmname}", 'pool', pool_name)
+          redis.hset("vmpooler__vm__#{new_vmname}", 'domain', pool_domain) if pool_domain
           redis.hset("vmpooler__vm__#{new_vmname}", 'request_id', request_id) if request_id
           redis.hset("vmpooler__vm__#{new_vmname}", 'pool_alias', pool_alias) if pool_alias
           redis.exec
@@ -412,9 +433,9 @@ module Vmpooler
           finish = format('%<time>.2f', time: Time.now - start)
 
           @redis.with_metrics do |redis|
-            redis.pipelined do
-              redis.hset("vmpooler__clone__#{Date.today}", "#{pool_name}:#{new_vmname}", finish)
-              redis.hset("vmpooler__vm__#{new_vmname}", 'clone_time', finish)
+            redis.pipelined do |pipeline|
+              pipeline.hset("vmpooler__clone__#{Date.today}", "#{pool_name}:#{new_vmname}", finish)
+              pipeline.hset("vmpooler__vm__#{new_vmname}", 'clone_time', finish)
             end
           end
           $logger.log('s', "[+] [#{pool_name}] '#{new_vmname}' cloned in #{finish} seconds")
@@ -422,10 +443,10 @@ module Vmpooler
           $metrics.timing("clone.#{pool_name}", finish)
         rescue StandardError
           @redis.with_metrics do |redis|
-            redis.pipelined do
-              redis.srem("vmpooler__pending__#{pool_name}", new_vmname)
+            redis.pipelined do |pipeline|
+              pipeline.srem("vmpooler__pending__#{pool_name}", new_vmname)
               expiration_ttl = $config[:redis]['data_ttl'].to_i * 60 * 60
-              redis.expire("vmpooler__vm__#{new_vmname}", expiration_ttl)
+              pipeline.expire("vmpooler__vm__#{new_vmname}", expiration_ttl)
             end
           end
           raise
@@ -456,12 +477,12 @@ module Vmpooler
 
       mutex.synchronize do
         @redis.with_metrics do |redis|
-          redis.pipelined do
-            redis.hdel("vmpooler__active__#{pool}", vm)
-            redis.hset("vmpooler__vm__#{vm}", 'destroy', Time.now)
+          redis.pipelined do |pipeline|
+            pipeline.hdel("vmpooler__active__#{pool}", vm)
+            pipeline.hset("vmpooler__vm__#{vm}", 'destroy', Time.now)
 
             # Auto-expire metadata key
-            redis.expire("vmpooler__vm__#{vm}", ($config[:redis]['data_ttl'].to_i * 60 * 60))
+            pipeline.expire("vmpooler__vm__#{vm}", ($config[:redis]['data_ttl'].to_i * 60 * 60))
           end
 
           start = Time.now
@@ -478,15 +499,15 @@ module Vmpooler
       dereference_mutex(vm)
     end
 
-    def purge_unused_vms_and_folders
-      global_purge = $config[:config]['purge_unconfigured_folders']
+    def purge_unused_vms_and_resources
+      global_purge = $config[:config]['purge_unconfigured_resources']
       providers = $config[:providers].keys
       providers.each do |provider_key|
-        provider_purge = $config[:providers][provider_key]['purge_unconfigured_folders'] || global_purge
+        provider_purge = $config[:providers][provider_key]['purge_unconfigured_resources'] || global_purge
         if provider_purge
           Thread.new do
             begin
-              purge_vms_and_folders(provider_key)
+              purge_vms_and_resources(provider_key)
             rescue StandardError => e
               $logger.log('s', "[!] failed while purging provider #{provider_key} VMs and folders with an error: #{e}")
             end
@@ -496,33 +517,16 @@ module Vmpooler
       nil
     end
 
-    # Return a list of pool folders
-    def pool_folders(provider_name)
-      folders = {}
-      $config[:pools].each do |pool|
-        next unless pool['provider'] == provider_name.to_s
-
-        folder_parts = pool['folder'].split('/')
-        datacenter = $providers[provider_name.to_s].get_target_datacenter_from_config(pool['name'])
-        folders[folder_parts.pop] = "#{datacenter}/vm/#{folder_parts.join('/')}"
-      end
-      folders
-    end
-
-    def get_base_folders(folders)
-      base = []
-      folders.each do |_key, value|
-        base << value
-      end
-      base.uniq
-    end
-
-    def purge_vms_and_folders(provider_name)
+    def purge_vms_and_resources(provider_name)
       provider = $providers[provider_name.to_s]
-      configured_folders = pool_folders(provider_name)
-      base_folders = get_base_folders(configured_folders)
-      whitelist = provider.provider_config['folder_whitelist']
-      provider.purge_unconfigured_folders(base_folders, configured_folders, whitelist)
+      # Deprecated, will be removed in version 3
+      if provider.provider_config['folder_whitelist']
+        $logger.log('d', "[!] [deprecation] rename configuration 'folder_whitelist' to 'resources_allowlist' for provider #{provider_name}")
+        allowlist = provider.provider_config['folder_whitelist']
+      else
+        allowlist = provider.provider_config['resources_allowlist']
+      end
+      provider.purge_unconfigured_resources(allowlist)
     end
 
     def create_vm_disk(pool_name, vm, disk_size, provider)
@@ -630,8 +634,21 @@ module Vmpooler
     # @return [Array] - a list of used providers from the config file, defaults to the default providers
     # ie. ["dummy"]
     def used_providers
-      pools = config[:pools] || []
-      @used_providers ||= (pools.map { |pool| pool[:provider] || pool['provider'] }.compact + default_providers).uniq
+      # create an array of provider classes based on the config
+      if config[:providers]
+        config_provider_names = config[:providers].keys
+        config_providers = config_provider_names.map do |config_provider_name|
+          if config[:providers][config_provider_name] && config[:providers][config_provider_name]['provider_class']
+            config[:providers][config_provider_name]['provider_class'].to_s
+          else
+            config_provider_name.to_s
+          end
+        end.compact.uniq
+      else
+        config_providers = []
+      end
+      # return the unique array of providers from the config and VMPooler defaults
+      @used_providers ||= (config_providers + default_providers).uniq
     end
 
     # @return [Array] - returns a list of providers that should always be loaded
@@ -877,7 +894,7 @@ module Vmpooler
           loop_count = 1
           loop_delay = loop_delay_min
           provider = get_provider_for_pool(pool['name'])
-          raise("Could not find provider '#{pool['provider']}") if provider.nil?
+          raise("Could not find provider '#{pool['provider']}'") if provider.nil?
 
           sync_pool_template(pool)
           loop do
@@ -1202,19 +1219,19 @@ module Vmpooler
               pool_check_response[:destroyed_vms] += 1
               destroy_vm(vm, pool_name, provider)
             rescue StandardError => e
-              redis.pipelined do
-                redis.srem("vmpooler__completed__#{pool_name}", vm)
-                redis.hdel("vmpooler__active__#{pool_name}", vm)
-                redis.del("vmpooler__vm__#{vm}")
+              redis.pipelined do |pipeline|
+                pipeline.srem("vmpooler__completed__#{pool_name}", vm)
+                pipeline.hdel("vmpooler__active__#{pool_name}", vm)
+                pipeline.del("vmpooler__vm__#{vm}")
               end
               $logger.log('d', "[!] [#{pool_name}] _check_pool failed with an error while evaluating completed VMs: #{e}")
             end
           else
             $logger.log('s', "[!] [#{pool_name}] '#{vm}' not found in inventory, removed from 'completed' queue")
-            redis.pipelined do
-              redis.srem("vmpooler__completed__#{pool_name}", vm)
-              redis.hdel("vmpooler__active__#{pool_name}", vm)
-              redis.del("vmpooler__vm__#{vm}")
+            redis.pipelined do |pipeline|
+              pipeline.srem("vmpooler__completed__#{pool_name}", vm)
+              pipeline.hdel("vmpooler__active__#{pool_name}", vm)
+              pipeline.del("vmpooler__vm__#{vm}")
             end
           end
         end
@@ -1364,7 +1381,7 @@ module Vmpooler
 
         return provider_klass.const_get(classname).new(config, logger, metrics, redis_connection_pool, provider_name, options)
       end
-      raise("Provider '#{provider_class}' is unknown for pool with provider name '#{provider_name}'") if provider.nil?
+      raise("Provider '#{provider_class}' is unknown for pool with provider name '#{provider_name}'") if provider_klass.nil?
     end
 
     def check_ondemand_requests(maxloop = 0,
@@ -1430,12 +1447,12 @@ module Vmpooler
       score = redis.zscore('vmpooler__provisioning__request', request_id)
       requested = requested.split(',')
 
-      redis.pipelined do
+      redis.pipelined do |pipeline|
         requested.each do |request|
-          redis.zadd('vmpooler__odcreate__task', Time.now.to_i, "#{request}:#{request_id}")
+          pipeline.zadd('vmpooler__odcreate__task', Time.now.to_i, "#{request}:#{request_id}")
         end
-        redis.zrem('vmpooler__provisioning__request', request_id)
-        redis.zadd('vmpooler__provisioning__processing', score, request_id)
+        pipeline.zrem('vmpooler__provisioning__request', request_id)
+        pipeline.zadd('vmpooler__provisioning__processing', score, request_id)
       end
     end
 
@@ -1465,9 +1482,9 @@ module Vmpooler
             redis.incr('vmpooler__tasks__ondemandclone')
             clone_vm(pool, provider, request_id, pool_alias)
           end
-          redis.pipelined do
-            redis.zrem(queue_key, request)
-            redis.zadd(queue_key, score, "#{pool_alias}:#{pool}:#{remaining_count}:#{request_id}")
+          redis.pipelined do |pipeline|
+            pipeline.zrem(queue_key, request)
+            pipeline.zadd(queue_key, score, "#{pool_alias}:#{pool}:#{remaining_count}:#{request_id}")
           end
         end
       end
@@ -1518,10 +1535,10 @@ module Vmpooler
 
       $logger.log('s', "Ondemand request for '#{request_id}' failed to provision all instances within the configured ttl '#{ondemand_request_ttl}'")
       expiration_ttl = $config[:redis]['data_ttl'].to_i * 60 * 60
-      redis.pipelined do
-        redis.zrem('vmpooler__provisioning__processing', request_id)
-        redis.hset("vmpooler__odrequest__#{request_id}", 'status', 'failed')
-        redis.expire("vmpooler__odrequest__#{request_id}", expiration_ttl)
+      redis.pipelined do |pipeline|
+        pipeline.zrem('vmpooler__provisioning__processing', request_id)
+        pipeline.hset("vmpooler__odrequest__#{request_id}", 'status', 'failed')
+        pipeline.expire("vmpooler__odrequest__#{request_id}", expiration_ttl)
       end
       remove_vms_for_failed_request(request_id, expiration_ttl, redis)
       true
@@ -1531,11 +1548,11 @@ module Vmpooler
       request_hash = redis.hgetall("vmpooler__odrequest__#{request_id}")
       Parsing.get_platform_pool_count(request_hash['requested']) do |platform_alias, pool, _count|
         pools_filled = redis.smembers("vmpooler__#{request_id}__#{platform_alias}__#{pool}")
-        redis.pipelined do
+        redis.pipelined do |pipeline|
           pools_filled&.each do |vm|
-            move_vm_queue(pool, vm, 'running', 'completed', redis, "moved to completed queue. '#{request_id}' could not be filled in time")
+            move_vm_queue(pool, vm, 'running', 'completed', pipeline, "moved to completed queue. '#{request_id}' could not be filled in time")
           end
-          redis.expire("vmpooler__#{request_id}__#{platform_alias}__#{pool}", expiration_ttl)
+          pipeline.expire("vmpooler__#{request_id}__#{platform_alias}__#{pool}", expiration_ttl)
         end
       end
     end
@@ -1606,7 +1623,7 @@ module Vmpooler
         end
       end
 
-      purge_unused_vms_and_folders
+      purge_unused_vms_and_resources
 
       loop_count = 1
       loop do

data/lib/vmpooler/providers/base.rb

@@ -212,6 +212,22 @@ module Vmpooler
           raise("#{self.class.name} does not implement vm_ready?")
         end
 
+        # tag_vm_user This method is called once we know who is using the VM (it is running). This method enables seeing
+        # who is using what in the provider pools.
+        # This method should be implemented in the providers, if it is not implemented, this base method will be called
+        # and should be a noop. The implementation should check if the vm has a user (as per redis) and add a new tag
+        # with the information.
+        # inputs
+        #   [String] pool_name : Name of the pool
+        #   [String] vm_name   : Name of the VM to check if ready
+        # returns
+        #   [Boolean] : true if successful, false if an error occurred and it should retry
+        def tag_vm_user(_pool_name, _vm_name)
+          # noop by design. If the provider does not implement this method, this base method is called (because inherited)
+          # and should basically do nothing.
+          true
+        end
+
         # inputs
         #   [String] pool_name : Name of the pool
         #   [String] vm_name   : Name of the VM to check if it exists
@@ -226,7 +242,7 @@ module Vmpooler
         # returns
         #   nil when successful. Raises error when encountered
         def create_template_delta_disks(_pool)
-          raise("#{self.class.name} does not implement create_template_delta_disks")
+          puts("#{self.class.name} does not implement create_template_delta_disks")
         end
 
         # inputs
@@ -237,8 +253,15 @@ module Vmpooler
           raise("#{self.class.name} does not implement get_target_datacenter_from_config")
         end
 
-        def purge_unconfigured_folders(_base_folders, _configured_folders, _whitelist)
-          raise("#{self.class.name} does not implement purge_unconfigured_folders")
+        def purge_unconfigured_resources(_allowlist)
+          raise("#{self.class.name} does not implement purge_unconfigured_resources")
+        end
+
+        # DEPRECATED if a provider does not implement the new method, it will hit this base class method
+        # and return a deprecation message
+        def purge_unconfigured_folders(_deprecated, _deprecated2, allowlist)
+          logger.log('s', '[!] purge_unconfigured_folders was renamed to purge_unconfigured_resources, please update your provider implementation')
+          purge_unconfigured_resources(allowlist)
         end
       end
     end

data/lib/vmpooler/util/parsing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# utility class shared between apps
+# utility class shared between apps api and pool_manager
 module Vmpooler
   class Parsing
     def self.get_platform_pool_count(requested, &_block)
@@ -12,5 +12,25 @@ module Vmpooler
         yield platform_alias, pool, count
       end
     end
+
+    # @param config [String] - the full config structure
+    # @param pool_name [String] - the name of the pool
+    # @return [String] - domain name for pool, if set in the provider for the pool or in the config block
+    def self.get_domain_for_pool(config, pool_name)
+      pool = config[:pools].find { |p| p['name'] == pool_name }
+      return nil unless pool
+
+      provider_name = pool.fetch('provider', 'vsphere') # see vmpooler.yaml.example where it states defaulting to vsphere
+
+      if config[:providers] && config[:providers][provider_name.to_sym] && config[:providers][provider_name.to_sym]['domain']
+        domain = config[:providers][provider_name.to_sym]['domain']
+      elsif config[:config] && config[:config]['domain']
+        domain = config[:config]['domain']
+      else
+        domain = nil
+      end
+
+      domain
+    end
   end
 end

data/lib/vmpooler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vmpooler
-  VERSION = '2.0.0'
+  VERSION = '2.3.0'
 end

data/lib/vmpooler.rb

@@ -3,6 +3,7 @@
 module Vmpooler
   require 'concurrent'
   require 'date'
+  require 'deep_merge'
   require 'json'
   require 'net/ldap'
   require 'open-uri'
@@ -16,6 +17,7 @@ module Vmpooler
 
   # Dependencies for tracing
   require 'opentelemetry-instrumentation-concurrent_ruby'
+  require 'opentelemetry-instrumentation-http_client'
   require 'opentelemetry-instrumentation-redis'
   require 'opentelemetry-instrumentation-sinatra'
   require 'opentelemetry-sdk'
@@ -31,7 +33,7 @@ module Vmpooler
     if ENV['VMPOOLER_CONFIG']
       config_string = ENV['VMPOOLER_CONFIG']
       # Parse the YAML config into a Hash
-      # Whitelist the Symbol class
+      # Allow the Symbol class
       parsed_config = YAML.safe_load(config_string, [Symbol])
     else
       # Take the name of the config file either from an ENV variable or from the filepath argument
@@ -41,8 +43,9 @@ module Vmpooler
       if parsed_config[:config]['extra_config']
         extra_configs = parsed_config[:config]['extra_config'].split(',')
         extra_configs.each do |config|
+          puts "loading extra_config file #{config}"
           extra_config = YAML.load_file(config)
-          parsed_config.merge!(extra_config)
+          parsed_config.deep_merge(extra_config)
         end
       end
     end
@@ -81,10 +84,13 @@ module Vmpooler
     parsed_config[:config]['retry_factor']                       = string_to_int(ENV['RETRY_FACTOR']) if ENV['RETRY_FACTOR']
     parsed_config[:config]['create_folders']                     = true?(ENV['CREATE_FOLDERS']) if ENV['CREATE_FOLDERS']
     parsed_config[:config]['experimental_features']              = ENV['EXPERIMENTAL_FEATURES'] if ENV['EXPERIMENTAL_FEATURES']
-    parsed_config[:config]['purge_unconfigured_folders']         = ENV['PURGE_UNCONFIGURED_FOLDERS'] if ENV['PURGE_UNCONFIGURED_FOLDERS']
     parsed_config[:config]['usage_stats']                        = ENV['USAGE_STATS'] if ENV['USAGE_STATS']
     parsed_config[:config]['request_logger']                     = ENV['REQUEST_LOGGER'] if ENV['REQUEST_LOGGER']
     parsed_config[:config]['create_template_delta_disks']        = ENV['CREATE_TEMPLATE_DELTA_DISKS'] if ENV['CREATE_TEMPLATE_DELTA_DISKS']
+    parsed_config[:config]['purge_unconfigured_resources']       = ENV['PURGE_UNCONFIGURED_RESOURCES'] if ENV['PURGE_UNCONFIGURED_RESOURCES']
+    parsed_config[:config]['purge_unconfigured_resources']       = ENV['PURGE_UNCONFIGURED_FOLDERS'] if ENV['PURGE_UNCONFIGURED_FOLDERS']
+    # ENV PURGE_UNCONFIGURED_FOLDERS deprecated, will be removed in version 3
+    puts '[!] [deprecation] rename ENV var \'PURGE_UNCONFIGURED_FOLDERS\' to \'PURGE_UNCONFIGURED_RESOURCES\'' if ENV['PURGE_UNCONFIGURED_FOLDERS']
     set_linked_clone(parsed_config)
 
     parsed_config[:redis]                            = parsed_config[:redis] || {}
@@ -128,6 +134,7 @@ module Vmpooler
     # Create an index of pool aliases
     parsed_config[:pool_names] = Set.new
     unless parsed_config[:pools]
+      puts 'loading pools configuration from redis, since the config[:pools] is empty'
       redis = new_redis(parsed_config[:redis]['server'], parsed_config[:redis]['port'], parsed_config[:redis]['password'])
       parsed_config[:pools] = load_pools_from_redis(redis)
     end
@@ -261,6 +268,7 @@ module Vmpooler
     OpenTelemetry::SDK.configure do |c|
       c.use 'OpenTelemetry::Instrumentation::Sinatra'
       c.use 'OpenTelemetry::Instrumentation::ConcurrentRuby'
+      c.use 'OpenTelemetry::Instrumentation::HttpClient'
       c.use 'OpenTelemetry::Instrumentation::Redis'
 
       c.add_span_processor(span_processor)