bolt 1.10.0 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cdc9ce6823fb077d899fce7bfa0154f5de9a0a7e994116f879b4395f8f65f59
-  data.tar.gz: 68ab9662c1613e93b1e8c51a6d5ce036de0e51e2961e759c25b67c37bb85c48b
+  metadata.gz: 29c062ea69471f56b51b9cef6ea2a3ba820773161753a13145879b7b941d2a32
+  data.tar.gz: 0f237d5aa389dee5e8a908f4fd52268d9fd397af25894a25adeeff0bc96d2ccc
 SHA512:
-  metadata.gz: be80c448bea05fbfe6a210093fc94fe90ca2e9ad3f8c8deeba4431732fa6e5e5f10f969fa976e91be0c49b9bb56117d38a74ab2e1e4435128b7a6124b7cac913
-  data.tar.gz: 6770076579d8c73e13536c2c9d2ec1c415b532b11d02f278a4f829a6f0c74455e98512717a06f9608afa258c309d3941e6d772fb99522a19e9e9c9416442ded2
+  metadata.gz: 79a0c7e11a5998175df643ed639f197f3e05c78895713562b220338b8c0df5f2fa1a506d5d4a7e063b38e314d4c046816cf7d4fd084296f313b3193b04b91c12
+  data.tar.gz: b92c3bb6f4e0fcc95895d22907c7c98e7cf5b4fef4385354dfd6a53c09817306d6d99aed1266beb1c0a65cbfb804567599c29c69a08790c3ba1d04ac5e3c7392

data/lib/bolt/cli.rb

@@ -343,9 +343,7 @@ module Bolt
     end
 
     def list_tasks
-      outputter.print_table(pal.list_tasks)
-      outputter.print_message("\nUse `bolt task show <task-name>` to view "\
-                              "details and parameters for a specific task.")
+      outputter.print_tasks(pal.list_tasks, pal.list_modulepath)
     end
 
     def show_plan(plan_name)
@@ -353,9 +351,7 @@ module Bolt
     end
 
     def list_plans
-      outputter.print_table(pal.list_plans)
-      outputter.print_message("\nUse `bolt plan show <plan-name>` to view "\
-                              "details and parameters for a specific plan.")
+      outputter.print_plans(pal.list_plans, pal.list_modulepath)
     end
 
     def run_plan(plan_name, plan_arguments, nodes, options)

data/lib/bolt/outputter/human.rb

@@ -115,6 +115,13 @@ module Bolt
         )
       end
 
+      def print_tasks(tasks, modulepath)
+        print_table(tasks)
+        print_message("\nMODULEPATH:\n#{modulepath.join(':')}\n"\
+                        "\nUse `bolt task show <task-name>` to view "\
+                        "details and parameters for a specific task.")
+      end
+
       # @param [Hash] task A hash representing the task
       def print_task_info(task)
         # Building lots of strings...
@@ -177,6 +184,13 @@ module Bolt
         @stream.puts(plan_info)
       end
 
+      def print_plans(plans, modulepath)
+        print_table(plans)
+        print_message("\nMODULEPATH:\n#{modulepath.join(':')}\n"\
+                        "\nUse `bolt plan show <plan-name>` to view "\
+                        "details and parameters for a specific plan.")
+      end
+
       # @param [Bolt::ResultSet] apply_result A ResultSet object representing the result of a `bolt apply`
       def print_apply_result(apply_result)
         apply_result.each { |result| print_result(result) }

data/lib/bolt/outputter/json.rb

@@ -53,6 +53,10 @@ module Bolt
         @stream.puts task.to_json
       end
 
+      def print_tasks(tasks, modulepath)
+        print_table('tasks' => tasks, 'modulepath' => modulepath)
+      end
+
       def print_plan_info(plan)
         path = plan.delete('module')
         plan['module_dir'] = if path.start_with?(Bolt::PAL::MODULES_PATH)
@@ -63,6 +67,10 @@ module Bolt
         @stream.puts plan.to_json
       end
 
+      def print_plans(plans, modulepath)
+        print_table('plans' => plans, 'modulepath' => modulepath)
+      end
+
       def print_apply_result(apply_result)
         @stream.puts apply_result.to_json
       end

data/lib/bolt/pal.rb

@@ -197,6 +197,10 @@ module Bolt
       end
     end
 
+    def list_modulepath
+      @modulepath - [BOLTLIB_PATH, MODULES_PATH]
+    end
+
     def parse_params(type, object_name, params)
       in_bolt_compiler do |compiler|
         if type == 'task'

data/lib/bolt/transport/orch.rb

@@ -110,7 +110,8 @@ module Bolt
         content = Base64.encode64(content)
         params = {
           'content' => content,
-          'arguments' => arguments
+          'arguments' => arguments,
+          'name' => Pathname(script).basename.to_s
         }
         callback ||= proc {}
         results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, &callback)

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '1.10.0'
+  VERSION = '1.11.0'
 end

data/lib/bolt_server/base_config.rb

@@ -76,7 +76,12 @@ module BoltServer
 
     def validate
       required_keys.each do |k|
-        next unless @data[k].nil?
+        # Handled nested config
+        if k.is_a?(Array)
+          next unless @data.dig(*k).nil?
+        else
+          next unless @data[k].nil?
+        end
         raise Bolt::ValidationError, "You must configure #{k} in #{@config_path}"
       end
 

data/lib/plan_executor/app.rb

@@ -3,10 +3,10 @@
 require 'sinatra'
 require 'bolt'
 require 'bolt/error'
-require 'bolt/executor'
 require 'bolt/inventory'
 require 'bolt/pal'
 require 'bolt/puppetdb'
+require 'bolt/version'
 require 'plan_executor/applicator'
 require 'plan_executor/executor'
 require 'concurrent'
@@ -27,18 +27,24 @@ module PlanExecutor
       end
     end
 
-    def initialize(modulepath, executor = nil)
-      @schema = JSON.parse(File.read(File.join(__dir__, 'schemas', 'run_plan.json')))
-      @worker = Concurrent::SingleThreadExecutor.new
+    def initialize(config)
+      conn_opts = { 'service-url' => config['orchestrator-url'],
+                    'cacert' => config['ssl-ca-cert'],
+                    'User-Agent' => "Bolt/#{Bolt::VERSION}" }
+      @client = OrchestratorClient.new(conn_opts, false)
 
-      # Create a basic executor, leave concurrency up to Orchestrator.
-      @executor = executor || PlanExecutor::Executor.new(0)
       # Use an empty inventory until we figure out where this data comes from.
       @inventory = Bolt::Inventory.new(nil)
-      # TODO: what should max compiles be set to for apply?
-      @pal = Bolt::PAL.new(modulepath, nil)
 
-      @applicator = PlanExecutor::Applicator.new(@inventory, @executor, nil)
+      # PAL is not threadsafe. Part of the work of making the plan executor
+      # functional will be making changes to Puppet that remove the need for
+      # global Puppet state.
+      # https://github.com/puppetlabs/bolt/blob/master/lib/bolt/pal.rb#L166
+      @pal = Bolt::PAL.new(config['modulepath'], nil)
+
+      @schema = JSON.parse(File.read(File.join(__dir__, 'schemas', 'run_plan.json')))
+      @worker = Concurrent::SingleThreadExecutor.new
+      @modulepath = config['modulepath']
 
       super(nil)
     end
@@ -77,16 +83,18 @@ module PlanExecutor
       body = JSON.parse(request.body.read)
       error = validate_schema(@schema, body)
       return [400, error.to_json] unless error.nil?
-
       name = body['plan_name']
       # Errors if plan is not found
       @pal.get_plan_info(name)
 
+      executor = PlanExecutor::Executor.new(body['job_id'], @client)
+      applicator = PlanExecutor::Applicator.new(@inventory, executor, nil)
       params = body['params']
       # This provides a wait function, which promise doesn't
       result = Concurrent::Future.execute(executor: @worker) do
-        # Stores result in result for testing
-        @pal.run_plan(name, params, @executor, @inventory, puppetdb_client, @applicator)
+        pal_result = @pal.run_plan(name, params, executor, @inventory, puppetdb_client, applicator)
+        executor.finish_plan(pal_result)
+        pal_result
       end
 
       [200, { status: 'running' }.to_json]

data/lib/plan_executor/config.rb

@@ -7,7 +7,7 @@ require 'bolt/error'
 module PlanExecutor
   class Config < BoltServer::BaseConfig
     def config_keys
-      super + %w[modulepath workers]
+      super + %w[modulepath workers orchestrator-url]
     end
 
     def defaults
@@ -21,6 +21,10 @@ module PlanExecutor
       'plan-executor'
     end
 
+    def required_keys
+      super + ['orchestrator-url']
+    end
+
     def load_env_config
       env_keys.each do |key|
         transformed_key = "BOLT_#{key.tr('-', '_').upcase}"

data/lib/plan_executor/executor.rb

@@ -7,27 +7,26 @@ require 'logging'
 require 'set'
 require 'bolt/result'
 require 'bolt/config'
-require 'bolt/transport/api'
-require 'bolt/notifier'
 require 'bolt/result_set'
 require 'bolt/puppetdb'
+require 'plan_executor/orch_client'
 
 module PlanExecutor
   class Executor
-    attr_reader :noop, :transport
+    attr_reader :noop, :logger
+    attr_accessor :transport
 
-    def initialize(noop = nil)
+    def initialize(job_id, client, noop = nil)
       @logger = Logging.logger[self]
       @plan_logging = false
       @noop = noop
       @logger.debug { "Started" }
-      @notifier = Bolt::Notifier.new
-      @transport = Bolt::Transport::Api.new
+      @transport = PlanExecutor::OrchClient.new(job_id, client, @logger)
     end
 
     # This handles running the job, catching errors, and turning the result
     # into a result set
-    def execute(targets)
+    def as_resultset(targets)
       result_array = begin
                        yield
                      rescue StandardError => e
@@ -38,7 +37,7 @@ module PlanExecutor
       Bolt::ResultSet.new(result_array)
     end
 
-    # TODO: Remove in favor of service logging
+    # BOLT-1098
     def log_action(description, targets)
       # When running a plan, info messages like starting a task are promoted to notice.
       log_method = @plan_logging ? :notice : :info
@@ -62,6 +61,7 @@ module PlanExecutor
       results
     end
 
+    # BOLT-1098
     def log_plan(plan_name)
       log_method = @plan_logging ? :notice : :info
       @logger.send(log_method, "Starting: plan #{plan_name}")
@@ -78,60 +78,48 @@ module PlanExecutor
       results
     end
 
-    def run_command(targets, command, options = {}, &callback)
+    def run_command(targets, command, options = {})
       description = options.fetch('_description', "command '#{command}'")
       log_action(description, targets) do
-        notify = proc { |event| @notifier.notify(callback, event) if callback }
-
-        results = execute(targets) do
-          @transport.batch_command(targets, command, options, &notify)
+        results = as_resultset(targets) do
+          @transport.run_command(targets, command, options)
         end
 
-        @notifier.shutdown
         results
       end
     end
 
-    def run_script(targets, script, arguments, options = {}, &callback)
+    def run_script(targets, script, arguments, options = {})
       description = options.fetch('_description', "script #{script}")
       log_action(description, targets) do
-        notify = proc { |event| @notifier.notify(callback, event) if callback }
-
-        results = execute(targets) do
-          @transport.batch_script(targets, script, arguments, options, &notify)
+        results = as_resultset(targets) do
+          @transport.run_script(targets, script, arguments, options)
         end
 
-        @notifier.shutdown
         results
       end
     end
 
-    def run_task(targets, task, arguments, options = {}, &callback)
+    def run_task(targets, task, arguments, options = {})
       description = options.fetch('_description', "task #{task.name}")
       log_action(description, targets) do
-        notify = proc { |event| @notifier.notify(callback, event) if callback }
-
         arguments['_task'] = task.name
 
-        results = execute(targets) do
-          @transport.batch_task(targets, task, arguments, options, &notify)
+        results = as_resultset(targets) do
+          @transport.run_task(targets, task, arguments, options)
         end
 
-        @notifier.shutdown
         results
       end
     end
 
-    def upload_file(targets, source, destination, options = {}, &callback)
+    def upload_file(targets, source, destination, options = {})
       description = options.fetch('_description', "file upload from #{source} to #{destination}")
       log_action(description, targets) do
-        notify = proc { |event| @notifier.notify(callback, event) if callback }
-
-        results = execute(targets) do
-          @transport.batch_upload(targets, source, destination, options, &notify)
+        results = as_resultset(targets) do
+          @transport.file_upload(targets, source, destination, options)
         end
 
-        @notifier.shutdown
         results
       end
     end
@@ -144,7 +132,7 @@ module PlanExecutor
                              retry_interval: 1)
       log_action(description, targets) do
         begin
-          wait_until(wait_time, retry_interval) { @transport.batch_connected?(targets) }
+          wait_until(wait_time, retry_interval) { @transport.connected?(targets) }
           targets.map { |target| Bolt::Result.new(target) }
         rescue TimeoutError => e
           targets.map { |target| Bolt::Result.from_exception(target, e) }
@@ -160,21 +148,6 @@ module PlanExecutor
       end
     end
 
-    # Plan context doesn't make sense for most transports but it is tightly
-    # coupled with the orchestrator transport since the transport behaves
-    # differently when a plan is running. In order to limit how much this
-    # pollutes the transport API we only handle the orchestrator transport here.
-    # Since we callt this function without resolving targets this will result
-    # in the orchestrator transport always being initialized during plan runs.
-    # For now that's ok.
-    #
-    # In the future if other transports need this or if we want a plan stack
-    # we'll need to refactor.
-    def start_plan(plan_context)
-      @transport.plan_context = plan_context
-      @plan_logging = true
-    end
-
     def finish_plan(plan_result)
       @transport.finish_plan(plan_result)
     end

data/lib/plan_executor/orch_client.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module PlanExecutor
+  class OrchClient
+    attr_reader :plan_job, :client
+
+    BOLT_COMMAND_TASK = Struct.new(:name).new('bolt_shim::command').freeze
+    BOLT_SCRIPT_TASK = Struct.new(:name).new('bolt_shim::script').freeze
+    BOLT_UPLOAD_TASK = Struct.new(:name).new('bolt_shim::upload').freeze
+
+    def initialize(plan_job, client, logger)
+      @plan_job = plan_job
+      @client = client
+      @logger = logger
+      @client_url = client.config['service-url']
+      logger.debug("Creating orchestrator client for #{@client_url}")
+      @environment = 'production'
+    end
+
+    def finish_plan(plan_result)
+      result = @client.command.plan_finish(
+        plan_job: @plan_job,
+        result: plan_result.value || '',
+        status: plan_result.status
+      )
+    rescue StandardError => e
+      @logger.debug("Failed to finish plan on #{@client_url}: #{e.message}\nResult: #{result.to_json}")
+    end
+
+    def run_task_job(targets, task, arguments, options)
+      # unpack any Sensitive data
+      arguments = unwrap_sensitive_args(arguments)
+      results = send_request(targets, task, arguments, options)
+
+      process_run_results(targets, results)
+    rescue OrchestratorClient::ApiError => e
+      targets.map do |target|
+        Bolt::Result.new(target, error: e.data)
+      end
+    rescue StandardError => e
+      targets.map do |target|
+        Bolt::Result.from_exception(target, e)
+      end
+    end
+
+    def send_request(targets, task, arguments, options = {})
+      description = options['_description']
+      body = { task: task.name,
+               environment: @environment,
+               noop: arguments['_noop'],
+               params: arguments.reject { |k, _| k.start_with?('_') },
+               scope: {
+                 nodes: targets.map(&:host)
+               } }
+      body[:description] = description if description
+      body[:plan_job] = @plan_job if @plan_job
+
+      @client.run_task(body)
+    end
+
+    def process_run_results(targets, results)
+      targets_by_name = Hash[targets.map(&:host).zip(targets)]
+      results.map do |node_result|
+        target = targets_by_name[node_result['name']]
+        state = node_result['state']
+        result = node_result['result']
+
+        # If it's finished or already has a proper error simply pass it to the
+        # the result otherwise make sure an error is generated
+        if state == 'finished' || (result && result['_error'])
+          Bolt::Result.new(target, value: result)
+        elsif state == 'skipped'
+          Bolt::Result.new(
+            target,
+            value: { '_error' => {
+              'kind' => 'puppetlabs.tasks/skipped-node',
+              'msg' => "Node #{target.host} was skipped",
+              'details' => {}
+            } }
+          )
+        else
+          # Make a generic error with a unkown exit_code
+          Bolt::Result.for_task(target, result.to_json, '', 'unknown')
+        end
+      end
+    end
+
+    def run_task(targets, task, arguments, options = {})
+      run_task_job(targets, task, arguments, options)
+    end
+
+    def run_command(targets, command, options = {})
+      params = { 'command' => command }
+      run_task_job(targets, BOLT_COMMAND_TASK, params, options)
+    end
+
+    def run_script(targets, script, arguments, options = {})
+      content = File.open(script, &:read)
+      content = Base64.encode64(content)
+      params = {
+        'content' => content,
+        'arguments' => arguments
+      }
+      callback ||= proc {}
+      results = run_task_job(targets, BOLT_SCRIPT_TASK, params, options, &callback)
+      results.map! { |result| unwrap_bolt_result(result.target, result) }
+      results.each do |result|
+        callback.call(type: :node_result, result: result)
+      end
+    end
+
+    def pack(directory)
+      start_time = Time.now
+      io = StringIO.new
+      output = Minitar::Output.new(Zlib::GzipWriter.new(io))
+      Find.find(directory) do |file|
+        next unless File.file?(file)
+
+        tar_path = Pathname.new(file).relative_path_from(Pathname.new(directory))
+        @logger.debug("Packing #{file} to #{tar_path}")
+        stat = File.stat(file)
+        content = File.binread(file)
+        output.tar.add_file_simple(
+          tar_path.to_s,
+          data: content,
+          size: content.size,
+          mode: stat.mode & 0o777,
+          mtime: stat.mtime
+        )
+      end
+
+      duration = Time.now - start_time
+      @logger.debug("Packed upload in #{duration * 1000} ms")
+
+      output.close
+      io.string
+    ensure
+      # Closes both tar and sgz.
+      output&.close
+    end
+
+    def file_upload(targets, source, destination, options = {})
+      stat = File.stat(source)
+      content = if stat.directory?
+                  pack(source)
+                else
+                  File.open(source, &:read)
+                end
+      content = Base64.encode64(content)
+      mode = File.stat(source).mode
+      params = {
+        'path' => destination,
+        'content' => content,
+        'mode' => mode,
+        'directory' => stat.directory?
+      }
+      results = run_task_job(targets, BOLT_UPLOAD_TASK, params, options)
+      results.map! do |result|
+        if result.error_hash
+          result
+        else
+          Bolt::Result.for_upload(result.target, source, destination)
+        end
+      end
+    end
+
+    # Unwraps any Sensitive data in an arguments Hash, so the plain-text is passed
+    # to the Task/Script.
+    #
+    # This works on deeply nested data structures composed of Hashes, Arrays, and
+    # and plain-old data types (int, string, etc).
+    def unwrap_sensitive_args(arguments)
+      # Skip this if Puppet isn't loaded
+      return arguments unless defined?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+
+      case arguments
+      when Array
+        # iterate over the array, unwrapping all elements
+        arguments.map { |x| unwrap_sensitive_args(x) }
+      when Hash
+        # iterate over the arguments hash and unwrap all keys and values
+        arguments.each_with_object({}) { |(k, v), h|
+          h[unwrap_sensitive_args(k)] = unwrap_sensitive_args(v)
+        }
+      when Puppet::Pops::Types::PSensitiveType::Sensitive
+        # this value is Sensitive, unwrap it
+        unwrap_sensitive_args(arguments.unwrap)
+      else
+        # unknown data type, just return it
+        arguments
+      end
+    end
+
+    # run_task generates a result that makes sense for a generic task which
+    # needs to be unwrapped to extract stdout/stderr/exitcode.
+    #
+    def unwrap_bolt_result(target, result)
+      if result.error_hash
+        # something went wrong return the failure
+        return result
+      end
+
+      Bolt::Result.for_command(target, result.value['stdout'], result.value['stderr'], result.value['exit_code'])
+    end
+
+    def connected?(targets)
+      nodes = @client.post('inventory', nodes: targets.map(&:host))
+      nodes['items'].all? { |node| node['connected'] }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-16 00:00:00.000000000 Z
+date: 2019-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -357,8 +357,6 @@ files:
 - lib/bolt/task.rb
 - lib/bolt/task/puppet_server.rb
 - lib/bolt/task/remote.rb
-- lib/bolt/transport/api.rb
-- lib/bolt/transport/api/connection.rb
 - lib/bolt/transport/base.rb
 - lib/bolt/transport/docker.rb
 - lib/bolt/transport/docker/connection.rb
@@ -396,6 +394,7 @@ files:
 - lib/plan_executor/applicator.rb
 - lib/plan_executor/config.rb
 - lib/plan_executor/executor.rb
+- lib/plan_executor/orch_client.rb
 - lib/plan_executor/schemas/run_plan.json
 - libexec/apply_catalog.rb
 - libexec/bolt_catalog

data/lib/bolt/transport/api.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'bolt/transport/api/connection'
-
-# A copy of the orchestrator transport which uses the api connection class
-# in order to bypass calling 'start_plan'
-module Bolt
-  module Transport
-    class Api < Orch
-      def initialize(*args)
-        super
-      end
-
-      def get_connection(conn_opts)
-        key = Bolt::Transport::Api::Connection.get_key(conn_opts)
-        unless (conn = @connections[key])
-          @connections[key] = Bolt::Transport::Api::Connection.new(conn_opts, logger)
-          conn = @connections[key]
-        end
-        conn
-      end
-
-      def batches(targets)
-        targets.group_by { |target| Bolt::Transport::Api::Connection.get_key(target.options) }.values
-      end
-    end
-  end
-end

data/lib/bolt/transport/api/connection.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-# This is a copy of the orchestrator transport connection, but without the
-# 'start_plan' call in the init function which is handled by the orchestrator
-# client
-module Bolt
-  module Transport
-    class Api < Orch
-      class Connection
-        attr_reader :logger, :key
-
-        CONTEXT_KEYS = Set.new(%i[plan_name description params]).freeze
-
-        def self.get_key(opts)
-          [
-            opts['service-url'],
-            opts['task-environment'],
-            opts['token-file']
-          ].join('-')
-        end
-
-        def initialize(opts, logger)
-          @logger = logger
-          @key = self.class.get_key(opts)
-          client_keys = %w[service-url token-file cacert]
-          client_opts = client_keys.each_with_object({}) do |k, acc|
-            acc[k] = opts[k] if opts.include?(k)
-          end
-          client_opts['User-Agent'] = "Bolt/#{VERSION}"
-          logger.debug("Creating orchestrator client for #{client_opts}")
-
-          @client = OrchestratorClient.new(client_opts, true)
-          @environment = opts["task-environment"]
-        end
-
-        def finish_plan(plan_result)
-          if @plan_job
-            @client.command.plan_finish(
-              plan_job: @plan_job,
-              result: plan_result.value || '',
-              status: plan_result.status
-            )
-          end
-        end
-
-        def build_request(targets, task, arguments, description = nil)
-          body = { task: task.name,
-                   environment: @environment,
-                   noop: arguments['_noop'],
-                   params: arguments.reject { |k, _| k.start_with?('_') },
-                   scope: {
-                     nodes: targets.map(&:host)
-                   } }
-          body[:description] = description if description
-          body[:plan_job] = @plan_job if @plan_job
-          body
-        end
-
-        def run_task(targets, task, arguments, options)
-          body = build_request(targets, task, arguments, options['_description'])
-          @client.run_task(body)
-        end
-
-        def query_inventory(targets)
-          @client.post('inventory', nodes: targets.map(&:host))
-        end
-      end
-    end
-  end
-end