vmpooler 2.5.0 → 3.0.0

data/lib/vmpooler/api.rb

@@ -3,7 +3,7 @@
 module Vmpooler
   class API < Sinatra::Base
     # Load API components
-    %w[helpers dashboard reroute v1 v2 request_logger healthcheck].each do |lib|
+    %w[helpers dashboard v3 request_logger healthcheck].each do |lib|
       require "vmpooler/api/#{lib}"
     end
     # Load dashboard components
@@ -52,9 +52,7 @@ module Vmpooler
 
         use Vmpooler::Dashboard
         use Vmpooler::API::Dashboard
-        use Vmpooler::API::Reroute
-        use Vmpooler::API::V1
-        use Vmpooler::API::V2
+        use Vmpooler::API::V3
       end
 
       # Get thee started O WebServer

data/lib/vmpooler/dns/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Vmpooler
+  class PoolManager
+    class Dns
+      class Base
+        # These defs must be overidden in child classes
+
+        # Helper Methods
+        # Global Logger object
+        attr_reader :logger
+        # Global Metrics object
+        attr_reader :metrics
+        # Provider options passed in during initialization
+        attr_reader :dns_options
+
+        def initialize(config, logger, metrics, redis_connection_pool, name, options)
+          @config = config
+          @logger = logger
+          @metrics = metrics
+          @redis = redis_connection_pool
+          @dns_plugin_name = name
+
+          @dns_options = options
+
+          logger.log('s', "[!] Creating dns plugin '#{name}'")
+        end
+
+        def pool_config(pool_name)
+          # Get the configuration of a specific pool
+          @config[:pools].each do |pool|
+            return pool if pool['name'] == pool_name
+          end
+
+          nil
+        end
+
+        # Returns this dns plugin's configuration
+        #
+        # @returns [Hashtable] This dns plugins's configuration from the config file.  Returns nil if the dns plugin config does not exist
+        def dns_config
+          @config[:dns_configs].each do |dns|
+            # Convert the symbol from the config into a string for comparison
+            return (dns[1].nil? ? {} : dns[1]) if dns[0].to_s == @dns_plugin_name
+          end
+
+          nil
+        end
+
+        def global_config
+          # This entire VM Pooler config
+          @config
+        end
+
+        def name
+          @dns_plugin_name
+        end
+
+        def get_ip(vm_name)
+          @redis.with_metrics do |redis|
+            redis.hget("vmpooler__vm__#{vm_name}", 'ip')
+          end
+        end
+
+        # returns
+        #   Array[String] : Array of pool names this provider services
+        def provided_pools
+          @config[:pools].select { |pool| pool['dns_config'] == name }.map { |pool| pool['name'] }
+        end
+
+        def create_or_replace_record(hostname)
+          raise("#{self.class.name} does not implement create_or_replace_record #{hostname}")
+        end
+
+        def delete_record(hostname)
+          raise("#{self.class.name} does not implement delete_record for #{hostname}")
+        end
+      end
+    end
+  end
+end

data/lib/vmpooler/dns.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Vmpooler
+  class Dns
+    # Load one or more VMPooler DNS plugin gems by name
+    #
+    # @param names [Array<String>] The list of gem names to load
+    def self.load_by_name(names)
+      names = Array(names)
+      instance = new
+      names.map { |name| instance.load_from_gems(name) }.flatten
+    end
+
+    # Returns the plugin class for the specified dns config by name
+    #
+    # @param config [Object] The entire VMPooler config object
+    # @param name [Symbol] The name of the dns config key to get the dns class
+    # @return [String] The plugin class for the specifid dns config
+    def self.get_dns_plugin_class_by_name(config, name)
+      dns_configs = config[:dns_configs].keys
+      plugin_class = ''
+
+      dns_configs.map do |dns_config_name|
+        plugin_class = config[:dns_configs][dns_config_name]['dns_class'] if dns_config_name.to_s == name
+      end
+
+      plugin_class
+    end
+
+    # Returns the domain for the specified pool
+    #
+    # @param config [String] - the full config structure
+    # @param pool_name [String] - the name of the pool
+    # @return [String] - domain name for pool, which is set via reference to the dns_configs block
+    def self.get_domain_for_pool(config, pool_name)
+      pool = config[:pools].find { |p| p['name'] == pool_name }
+      pool_dns_config = pool['dns_plugin']
+      dns_configs = config[:dns_configs].keys
+      dns_configs.map do |dns_config_name|
+        return config[:dns_configs][dns_config_name]['domain'] if dns_config_name.to_s == pool_dns_config
+      end
+    end
+
+    # Returns the plugin domain for the specified dns config by name
+    #
+    # @param config [Object] The entire VMPooler config object
+    # @param name [Symbol] The name of the dns config key to get the dns domain
+    # @return [String] The domain for the specifid dns config
+    def self.get_dns_plugin_domain_by_name(config, name)
+      dns_configs = config[:dns_configs].keys
+      dns_configs.map do |dns_config_name|
+        return config[:dns_configs][dns_config_name]['domain'] if dns_config_name.to_s == name
+      end
+    end
+
+    # Returns a list of DNS plugin classes specified in the vmpooler configuration
+    #
+    # @param config [Object] The entire VMPooler config object
+    # @return nil || [Array<String>] A list of DNS plugin classes
+    def self.get_dns_plugin_config_classes(config)
+      return nil unless config[:dns_configs]
+
+      dns_configs = config[:dns_configs].keys
+      dns_plugins = dns_configs.map do |dns_config_name|
+        if config[:dns_configs][dns_config_name] && config[:dns_configs][dns_config_name]['dns_class']
+          config[:dns_configs][dns_config_name]['dns_class'].to_s
+        else
+          dns_config_name.to_s
+        end
+      end.compact.uniq
+
+      # dynamic-dns is not actually a class, it's just used as a value to denote
+      # that dynamic dns is used so no loading or record management is needed
+      dns_plugins.delete('dynamic-dns')
+
+      dns_plugins
+    end
+
+    # Load a single DNS plugin gem by name
+    #
+    # @param name [String] The name of the DNS plugin gem to load
+    # @return [String] The full require path to the specified gem
+    def load_from_gems(name = nil)
+      require_path = "vmpooler/dns/#{name.gsub('-', '/')}"
+      require require_path
+      require_path
+    end
+  end
+end

data/lib/vmpooler/pool_manager.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'vmpooler/dns'
 require 'vmpooler/providers'
 require 'vmpooler/util/parsing'
 require 'spicy-proton'
@@ -26,6 +27,9 @@ module Vmpooler
       # VM Provider objects
       $providers = Concurrent::Hash.new
 
+      # VM DNS objects
+      $dns_plugins = Concurrent::Hash.new
+
       # Our thread-tracker object
       $threads = Concurrent::Hash.new
 
@@ -39,6 +43,9 @@ module Vmpooler
 
       # load specified providers from config file
       load_used_providers
+
+      # load specified dns plugins from config file
+      load_used_dns_plugins
     end
 
     def config
@@ -60,7 +67,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'])
+          to_set['domain'] = Vmpooler::Dns.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|
@@ -106,6 +113,11 @@ module Vmpooler
 
     def remove_nonexistent_vm(vm, pool, redis)
       redis.srem("vmpooler__pending__#{pool}", vm)
+      dns_plugin = get_dns_plugin_class_for_pool(pool)
+      dns_plugin_class_name = get_dns_plugin_class_name_for_pool(pool)
+      domain = get_dns_plugin_domain_for_pool(pool)
+      fqdn = "#{vm}.#{domain}"
+      dns_plugin.delete_record(fqdn) unless dns_plugin_class_name == 'dynamic-dns'
       $logger.log('d', "[!] [#{pool}] '#{vm}' no longer exists. Removing from pending.")
     end
 
@@ -323,10 +335,10 @@ module Vmpooler
     end
 
     # Clone a VM
-    def clone_vm(pool_name, provider, request_id = nil, pool_alias = nil)
+    def clone_vm(pool_name, provider, dns_plugin, request_id = nil, pool_alias = nil)
       Thread.new do
         begin
-          _clone_vm(pool_name, provider, request_id, pool_alias)
+          _clone_vm(pool_name, provider, dns_plugin, request_id, pool_alias)
         rescue StandardError => e
           if request_id
             $logger.log('s', "[!] [#{pool_name}] failed while cloning VM for request #{request_id} with an error: #{e}")
@@ -368,12 +380,8 @@ module Vmpooler
       max_hostname_retries = 3
       while hostname_retries < max_hostname_retries
         hostname, hostname_available = generate_and_check_hostname
-        domain = Parsing.get_domain_for_pool(config, pool_name)
-        if domain
-          fqdn = "#{hostname}.#{domain}"
-        else
-          fqdn = hostname
-        end
+        domain = Vmpooler::Dns.get_domain_for_pool(config, pool_name)
+        fqdn = "#{hostname}.#{domain}"
 
         # skip dns check if the provider is set to skip_dns_check_before_creating_vm
         provider = get_provider_for_pool(pool_name)
@@ -414,9 +422,9 @@ module Vmpooler
       [dns_ip, false]
     end
 
-    def _clone_vm(pool_name, provider, request_id = nil, pool_alias = nil)
+    def _clone_vm(pool_name, provider, dns_plugin, request_id = nil, pool_alias = nil)
       new_vmname = find_unique_hostname(pool_name)
-      pool_domain = Parsing.get_domain_for_pool(config, pool_name)
+      pool_domain = Vmpooler::Dns.get_domain_for_pool(config, pool_name)
       mutex = vm_mutex(new_vmname)
       mutex.synchronize do
         @redis.with_metrics do |redis|
@@ -426,7 +434,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}", 'domain', 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
@@ -437,16 +445,25 @@ module Vmpooler
           start = Time.now
           provider.create_vm(pool_name, new_vmname)
           finish = format('%<time>.2f', time: Time.now - start)
+          $logger.log('s', "[+] [#{pool_name}] '#{new_vmname}' cloned in #{finish} seconds")
+          $metrics.timing("clone.#{pool_name}", finish)
+
+          $logger.log('d', "[ ] [#{pool_name}] Obtaining IP for '#{new_vmname}'")
+          ip_start = Time.now
+          ip = provider.get_vm_ip_address(new_vmname, pool_name)
+          ip_finish = format('%<time>.2f', time: Time.now - ip_start)
+          $logger.log('s', "[+] [#{pool_name}] Obtained IP for '#{new_vmname}' in #{ip_finish} seconds")
 
           @redis.with_metrics do |redis|
             redis.pipelined do |pipeline|
               pipeline.hset("vmpooler__clone__#{Date.today}", "#{pool_name}:#{new_vmname}", finish)
               pipeline.hset("vmpooler__vm__#{new_vmname}", 'clone_time', finish)
+              pipeline.hset("vmpooler__vm__#{new_vmname}", 'ip', ip)
             end
           end
-          $logger.log('s', "[+] [#{pool_name}] '#{new_vmname}' cloned in #{finish} seconds")
 
-          $metrics.timing("clone.#{pool_name}", finish)
+          dns_plugin_class_name = get_dns_plugin_class_name_for_pool(pool_name)
+          dns_plugin.create_or_replace_record(new_vmname) unless dns_plugin_class_name == 'dynamic-dns'
         rescue StandardError
           @redis.with_metrics do |redis|
             redis.pipelined do |pipeline|
@@ -466,10 +483,10 @@ module Vmpooler
     end
 
     # Destroy a VM
-    def destroy_vm(vm, pool, provider)
+    def destroy_vm(vm, pool, provider, dns_plugin)
       Thread.new do
         begin
-          _destroy_vm(vm, pool, provider)
+          _destroy_vm(vm, pool, provider, dns_plugin)
         rescue StandardError => e
           $logger.log('d', "[!] [#{pool}] '#{vm}' failed while destroying the VM with an error: #{e}")
           raise
@@ -477,7 +494,7 @@ module Vmpooler
       end
     end
 
-    def _destroy_vm(vm, pool, provider)
+    def _destroy_vm(vm, pool, provider, dns_plugin)
       mutex = vm_mutex(vm)
       return if mutex.locked?
 
@@ -494,6 +511,11 @@ module Vmpooler
           start = Time.now
 
           provider.destroy_vm(pool, vm)
+          domain = get_dns_plugin_domain_for_pool(pool)
+          fqdn = "#{vm}.#{domain}"
+
+          dns_plugin_class_name = get_dns_plugin_class_name_for_pool(pool)
+          dns_plugin.delete_record(fqdn) unless dns_plugin_class_name == 'dynamic-dns'
 
           redis.srem("vmpooler__completed__#{pool}", vm)
 
@@ -632,6 +654,12 @@ module Vmpooler
       result
     end
 
+    # load only dns plugins used in config file
+    def load_used_dns_plugins
+      dns_plugins = Vmpooler::Dns.get_dns_plugin_config_classes(config)
+      Vmpooler::Dns.load_by_name(dns_plugins)
+    end
+
     # load only providers used in config file
     def load_used_providers
       Vmpooler::Providers.load_by_name(used_providers)
@@ -679,6 +707,31 @@ module Vmpooler
       $providers[provider_name]
     end
 
+    def get_dns_plugin_class_name_for_pool(pool_name)
+      pool = $config[:pools].find { |p| p['name'] == pool_name }
+      return nil unless pool
+
+      plugin_name = pool.fetch('dns_plugin')
+      Vmpooler::Dns.get_dns_plugin_class_by_name(config, plugin_name)
+    end
+
+    def get_dns_plugin_class_for_pool(pool_name)
+      pool = $config[:pools].find { |p| p['name'] == pool_name }
+      return nil unless pool
+
+      plugin_name = pool.fetch('dns_plugin')
+      plugin_class = Vmpooler::Dns.get_dns_plugin_class_by_name(config, plugin_name)
+      $dns_plugins[plugin_class]
+    end
+
+    def get_dns_plugin_domain_for_pool(pool_name)
+      pool = $config[:pools].find { |p| p['name'] == pool_name }
+      return nil unless pool
+
+      plugin_name = pool.fetch('dns_plugin')
+      Vmpooler::Dns.get_dns_plugin_domain_by_name(config, plugin_name)
+    end
+
     def check_disk_queue(maxloop = 0, loop_delay = 5)
       $logger.log('d', '[*] [disk_manager] starting worker thread')
 
@@ -1223,7 +1276,8 @@ module Vmpooler
           if inventory[vm]
             begin
               pool_check_response[:destroyed_vms] += 1
-              destroy_vm(vm, pool_name, provider)
+              dns_plugin = get_dns_plugin_class_for_pool(pool_name)
+              destroy_vm(vm, pool_name, provider, dns_plugin)
             rescue StandardError => e
               redis.pipelined do |pipeline|
                 pipeline.srem("vmpooler__completed__#{pool_name}", vm)
@@ -1290,6 +1344,8 @@ module Vmpooler
         $metrics.gauge("ready.#{pool_name}", ready)
         $metrics.gauge("running.#{pool_name}", running)
 
+        dns_plugin = get_dns_plugin_class_for_pool(pool_name)
+
         unless pool_size == 0
           if redis.get("vmpooler__empty__#{pool_name}")
             redis.del("vmpooler__empty__#{pool_name}") unless ready == 0
@@ -1304,7 +1360,7 @@ module Vmpooler
             begin
               redis.incr('vmpooler__tasks__clone')
               pool_check_response[:cloned_vms] += 1
-              clone_vm(pool_name, provider)
+              clone_vm(pool_name, provider, dns_plugin)
             rescue StandardError => e
               $logger.log('s', "[!] [#{pool_name}] clone failed during check_pool with an error: #{e}")
               redis.decr('vmpooler__tasks__clone')
@@ -1390,6 +1446,16 @@ module Vmpooler
       raise("Provider '#{provider_class}' is unknown for pool with provider name '#{provider_name}'") if provider_klass.nil?
     end
 
+    def create_dns_object(config, logger, metrics, redis_connection_pool, dns_class, dns_name, options)
+      dns_klass = Vmpooler::PoolManager::Dns
+      dns_klass.constants.each do |classname|
+        next unless classname.to_s.casecmp(dns_class) == 0
+
+        return dns_klass.const_get(classname).new(config, logger, metrics, redis_connection_pool, dns_name, options)
+      end
+      raise("DNS '#{dns_class}' is unknown for pool with dns name '#{dns_name}'") if dns_klass.nil?
+    end
+
     def check_ondemand_requests(maxloop = 0,
                                 loop_delay_min = CHECK_LOOP_DELAY_MIN_DEFAULT,
                                 loop_delay_max = CHECK_LOOP_DELAY_MAX_DEFAULT,
@@ -1473,20 +1539,21 @@ module Vmpooler
         pool_alias, pool, count, request_id = request.split(':')
         count = count.to_i
         provider = get_provider_for_pool(pool)
+        dns_plugin = get_dns_plugin_class_for_pool(pool)
         slots = ondemand_clone_limit - clone_count
         break if slots == 0
 
         if slots >= count
           count.times do
             redis.incr('vmpooler__tasks__ondemandclone')
-            clone_vm(pool, provider, request_id, pool_alias)
+            clone_vm(pool, provider, dns_plugin, request_id, pool_alias)
           end
           redis.zrem(queue_key, request)
         else
           remaining_count = count - slots
           slots.times do
             redis.incr('vmpooler__tasks__ondemandclone')
-            clone_vm(pool, provider, request_id, pool_alias)
+            clone_vm(pool, provider, dns_plugin, request_id, pool_alias)
           end
           redis.pipelined do |pipeline|
             pipeline.zrem(queue_key, request)
@@ -1601,6 +1668,7 @@ module Vmpooler
       # Create the providers
       $config[:pools].each do |pool|
         provider_name = pool['provider']
+        dns_plugin_name = pool['dns_plugin']
         # The provider_class parameter can be defined in the provider's data eg
         # :providers:
         #   :vsphere:
@@ -1621,12 +1689,22 @@ module Vmpooler
         else
           provider_class = $config[:providers][provider_name.to_sym]['provider_class']
         end
+
         begin
           $providers[provider_name] = create_provider_object($config, $logger, $metrics, @redis, provider_class, provider_name, {}) if $providers[provider_name].nil?
         rescue StandardError => e
           $logger.log('s', "Error while creating provider for pool #{pool['name']}: #{e}")
           raise
         end
+
+        dns_plugin_class = $config[:dns_configs][dns_plugin_name.to_sym]['dns_class']
+
+        begin
+          $dns_plugins[dns_plugin_class] = create_dns_object($config, $logger, $metrics, @redis, dns_plugin_class, dns_plugin_name, {}) if $dns_plugins[dns_plugin_class].nil?
+        rescue StandardError => e
+          $logger.log('s', "Error while creating dns plugin for pool #{pool['name']}: #{e}")
+          raise
+        end
       end
 
       purge_unused_vms_and_resources

data/lib/vmpooler/providers/base.rb

@@ -58,6 +58,10 @@ module Vmpooler
           nil
         end
 
+        def dns_config(dns_config_name)
+          Vmpooler::Dns.get_dns_plugin_domain_by_name(@config, dns_config_name)
+        end
+
         # returns
         #   [Hashtable] : The entire VMPooler configuration
         def global_config
@@ -257,6 +261,10 @@ module Vmpooler
           raise("#{self.class.name} does not implement purge_unconfigured_resources")
         end
 
+        def get_vm_ip_address(vm_name, pool_name)
+          raise("#{self.class.name} does not implement get_vm_ip_address for vm #{vm_name} in pool #{pool_name}")
+        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)

data/lib/vmpooler/public/lib/dashboard.js

@@ -29,10 +29,10 @@ Date.prototype.yyyymmdd = function() {
 
 var data_url = {
   'capacity': '/dashboard/stats/vmpooler/pool',
-  'pools'   : '/api/v1/vm',
+  'pools'   : '/api/v3/vm',
   'running' : '/dashboard/stats/vmpooler/running',
-  'status'  : '/api/v1/status',
-  'summary' : '/api/v1/summary'
+  'status'  : '/api/v3/status',
+  'summary' : '/api/v3/summary'
 };
 
 

data/lib/vmpooler/util/parsing.rb

@@ -12,25 +12,5 @@ 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.5.0'
+  VERSION = '3.0.0'
 end

data/lib/vmpooler.rb

@@ -76,7 +76,10 @@ module Vmpooler
     parsed_config[:config]['prefix']                             = ENV['PREFIX'] || parsed_config[:config]['prefix'] || ''
     parsed_config[:config]['logfile']                            = ENV['LOGFILE'] if ENV['LOGFILE']
     parsed_config[:config]['site_name']                          = ENV['SITE_NAME'] if ENV['SITE_NAME']
-    parsed_config[:config]['domain']                             = ENV['DOMAIN'] if ENV['DOMAIN']
+    if !parsed_config[:config]['domain'].nil? || !ENV['DOMAIN'].nil?
+      puts '[!] [error] The "domain" config setting has been removed in v3. Please see the docs for migrating the domain config to use a dns plugin at https://github.com/puppetlabs/vmpooler/blob/main/README.md#migrating-to-v3'
+      exit 1
+    end
     parsed_config[:config]['clone_target']                       = ENV['CLONE_TARGET'] if ENV['CLONE_TARGET']
     parsed_config[:config]['timeout']                            = string_to_int(ENV['TIMEOUT']) if ENV['TIMEOUT']
     parsed_config[:config]['vm_lifetime_auth']                   = string_to_int(ENV['VM_LIFETIME_AUTH']) if ENV['VM_LIFETIME_AUTH']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vmpooler
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Puppet
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-06 00:00:00.000000000 Z
+date: 2023-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -449,10 +449,10 @@ files:
 - lib/vmpooler/api/healthcheck.rb
 - lib/vmpooler/api/helpers.rb
 - lib/vmpooler/api/request_logger.rb
-- lib/vmpooler/api/reroute.rb
-- lib/vmpooler/api/v1.rb
-- lib/vmpooler/api/v2.rb
+- lib/vmpooler/api/v3.rb
 - lib/vmpooler/dashboard.rb
+- lib/vmpooler/dns.rb
+- lib/vmpooler/dns/base.rb
 - lib/vmpooler/generic_connection_pool.rb
 - lib/vmpooler/logger.rb
 - lib/vmpooler/metrics.rb