bolt 1.15.0 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 271a7fea2ecaf024054a9ae2266bc352b19a9969300c882f9622341582585d48
-  data.tar.gz: d10c047f108f62efdfe1e6ac1a35bc7b3303332f0ca0bd50c55635857d41648e
+  metadata.gz: b815f57b892f3750786159c9251e03f34cae09c721a6c18a2ace76d7319324b3
+  data.tar.gz: 13d51985236eee75d10bd527a8fe4c0328b362175dc9313a84f519967c690d9a
 SHA512:
-  metadata.gz: 7d6355d7246bfa1305c02e13edf5fd7873584b70306e505f48ee1470babf6aa282b9b5f141ee5af6703b60a589f937c7997110ad21a2d6705926835a8b42b415
-  data.tar.gz: 4a1e5f3bf454ce08b084c0310b98c71119305f3c34fbeca552dffe3f6029cc16e7c410e2490605a985552e9603d7a9e653509b8a71679f3b2bb5e0a56e13951d
+  metadata.gz: f904cf6c228379b8f790ed6d102da43244cdc5b0fa8630f04758957e35c083ee9955d09b0d212c22ea5a9e07f989e72f73e88b07f99d984c9427a813386713f3
+  data.tar.gz: a755bc82082397a067d8a8bdbfc81f7687071bbb2aa993c3a95e0db24feeda4e28c7b34644cbb1a2195f3211918c9de7fafd8c232ce38acd7ce5c42cfd5359da

data/bolt-modules/boltlib/lib/puppet/datatypes/target.rb

@@ -7,8 +7,8 @@ Puppet::DataTypes.create_type('Target') do
       options => { type => Hash[String[1], Data], value => {} }
     },
     functions => {
-      host => Callable[[], String[1]],
       name => Callable[[], String[1]],
+      host => Callable[[], Optional[String]],
       password => Callable[[], Optional[String[1]]],
       port => Callable[[], Optional[Integer]],
       protocol => Callable[[], Optional[String[1]]],

data/bolt-modules/boltlib/lib/puppet/functions/run_plan.rb

@@ -82,11 +82,11 @@ Puppet::Functions.create_function(:run_plan, Puppet::Functions::InternalFunction
         end
 
         result
-      rescue Puppet::PreformattedError => err
-        if named_args['_catch_errors'] && err.cause.is_a?(Bolt::Error)
-          result = err.cause.to_puppet_error
+      rescue Puppet::PreformattedError => e
+        if named_args['_catch_errors'] && e.cause.is_a?(Bolt::Error)
+          result = e.cause.to_puppet_error
         else
-          raise err
+          raise e
         end
       ensure
         if run_as

data/lib/bolt.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# loads Logging gem, patching it for perf reasons to disable plugins
+require 'logging_extensions/logging'
+
 module Bolt
   require 'bolt/executor'
 end

data/lib/bolt/analytics.rb

@@ -2,9 +2,7 @@
 
 require 'bolt/util'
 require 'bolt/version'
-require 'httpclient'
 require 'json'
-require 'locale'
 require 'logging'
 require 'securerandom'
 
@@ -62,17 +60,21 @@ module Bolt
 
     class Client
       attr_reader :user_id
+      attr_accessor :bundled_content
 
       def initialize(user_id)
         # lazy-load expensive gem code
         require 'concurrent/configuration'
         require 'concurrent/future'
+        require 'httpclient'
+        require 'locale'
 
         @logger = Logging.logger[self]
         @http = HTTPClient.new
         @user_id = user_id
         @executor = Concurrent.global_io_executor
         @os = compute_os
+        @bundled_content = []
       end
 
       def screen_view(screen, **kwargs)
@@ -164,8 +166,11 @@ module Bolt
     end
 
     class NoopClient
+      attr_accessor :bundled_content
+
       def initialize
         @logger = Logging.logger[self]
+        @bundled_content = []
       end
 
       def screen_view(screen, **_kwargs)

data/lib/bolt/applicator.rb

@@ -4,7 +4,6 @@ require 'base64'
 require 'find'
 require 'json'
 require 'logging'
-require 'minitar'
 require 'open3'
 require 'bolt/error'
 require 'bolt/task'
@@ -83,6 +82,7 @@ module Bolt
 
     def compile(target, ast, plan_vars)
       trusted = Puppet::Context::TrustedInformation.new('local', target.host, {})
+      facts = @inventory.facts(target).merge('bolt' => true)
 
       catalog_input = {
         code_ast: ast,
@@ -91,7 +91,7 @@ module Bolt
         hiera_config: @hiera_config,
         target: {
           name: target.host,
-          facts: @inventory.facts(target),
+          facts: facts,
           variables: @inventory.vars(target).merge(plan_vars),
           trusted: trusted.to_h
         },
@@ -225,6 +225,10 @@ module Bolt
     end
 
     def build_plugin_tarball
+      # lazy-load expensive gem code
+      require 'minitar'
+      require 'zlib'
+
       start_time = Time.now
       sio = StringIO.new
       output = Minitar::Output.new(Zlib::GzipWriter.new(sio))

data/lib/bolt/bolt_option_parser.rb

@@ -314,8 +314,8 @@ Usage: bolt apply <manifest.pp> [options]
     def parse_params(params)
       json = get_arg_input(params)
       JSON.parse(json)
-    rescue JSON::ParserError => err
-      raise Bolt::CLIError, "Unable to parse --params value as JSON: #{err}"
+    rescue JSON::ParserError => e
+      raise Bolt::CLIError, "Unable to parse --params value as JSON: #{e}"
     end
 
     def get_arg_input(value)
@@ -331,8 +331,8 @@ Usage: bolt apply <manifest.pp> [options]
 
     def read_arg_file(file)
       File.read(File.expand_path(file))
-    rescue StandardError => err
-      raise Bolt::FileError.new("Error attempting to read #{file}: #{err}", file)
+    rescue StandardError => e
+      raise Bolt::FileError.new("Error attempting to read #{file}: #{e}", file)
     end
   end
 end

data/lib/bolt/cli.rb

@@ -231,6 +231,7 @@ module Bolt
       end
 
       @analytics = Bolt::Analytics.build_client
+      @analytics.bundled_content = bundled_content
 
       screen = "#{options[:subcommand]}_#{options[:action]}"
       # submit a different screen for `bolt task show` and `bolt task show foo`
@@ -282,7 +283,7 @@ module Bolt
         end
         code = apply_manifest(options[:code], options[:targets], options[:object], options[:noop])
       else
-        executor = Bolt::Executor.new(config.concurrency, @analytics, options[:noop], bundled_content: bundled_content)
+        executor = Bolt::Executor.new(config.concurrency, @analytics, options[:noop])
         targets = options[:targets]
 
         results = nil
@@ -373,7 +374,7 @@ module Bolt
                        params: params }
       plan_context[:description] = options[:description] if options[:description]
 
-      executor = Bolt::Executor.new(config.concurrency, @analytics, options[:noop], bundled_content: bundled_content)
+      executor = Bolt::Executor.new(config.concurrency, @analytics, options[:noop])
       executor.start_plan(plan_context)
       result = pal.run_plan(plan_name, plan_arguments, executor, inventory, puppetdb_client)
 
@@ -386,7 +387,7 @@ module Bolt
     def apply_manifest(code, targets, filename = nil, noop = false)
       ast = pal.parse_manifest(code, filename)
 
-      executor = Bolt::Executor.new(config.concurrency, @analytics, noop, bundled_content: bundled_content)
+      executor = Bolt::Executor.new(config.concurrency, @analytics, noop)
       # Call start_plan just to enable plan_logging
       executor.start_plan(nil)
 
@@ -469,7 +470,8 @@ module Bolt
     end
 
     def bundled_content
-      if %w[plan task].include?(options[:subcommand])
+      # We only need to enumerate bundled content when running a task or plan
+      if %w[plan task].include?(options[:subcommand]) && options[:action] == 'run'
         default_content = Bolt::PAL.new([], nil)
         plans = default_content.list_plans.each_with_object([]) do |iter, col|
           col << iter&.first
@@ -478,6 +480,8 @@ module Bolt
           col << iter&.first
         end
         plans.concat tasks
+      else
+        []
       end
     end
   end

data/lib/bolt/config.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require 'yaml'
+require 'etc'
 require 'logging'
-# limit the loaded portion of concurrent as its expensive
-require 'concurrent/utility/processor_counter'
 require 'pathname'
 require 'bolt/boltdir'
 require 'bolt/transport/ssh'
 require 'bolt/transport/winrm'
 require 'bolt/transport/orch'
 require 'bolt/transport/local'
+require 'bolt/transport/local_windows'
 require 'bolt/transport/docker'
 require 'bolt/transport/remote'
+require 'bolt/util'
 
 module Bolt
   TRANSPORTS = {
     ssh: Bolt::Transport::SSH,
     winrm: Bolt::Transport::WinRM,
     pcp: Bolt::Transport::Orch,
-    local: Bolt::Transport::Local,
+    local: Bolt::Util.windows? ? Bolt::Transport::LocalWindows : Bolt::Transport::Local,
     docker: Bolt::Transport::Docker,
     remote: Bolt::Transport::Remote
   }.freeze
@@ -60,7 +60,7 @@ module Bolt
 
       @boltdir = boltdir
       @concurrency = 100
-      @compile_concurrency = Concurrent.processor_count
+      @compile_concurrency = Etc.nprocessors
       @transport = 'ssh'
       @format = 'human'
       @puppetdb = {}
@@ -246,7 +246,7 @@ module Bolt
         raise Bolt::ValidationError, 'Compile concurrency must be a positive integer'
       end
 
-      compile_limit = 2 * Concurrent.processor_count
+      compile_limit = 2 * Etc.nprocessors
       unless @compile_concurrency < compile_limit
         raise Bolt::ValidationError, "Compilation is CPU-intensive, set concurrency less than #{compile_limit}"
       end

data/lib/bolt/executor.rb

@@ -21,17 +21,13 @@ module Bolt
     # https://makandracards.com/makandra/36011-ruby-do-not-mix-optional-and-keyword-arguments
     def initialize(concurrency = 1,
                    analytics = Bolt::Analytics::NoopClient.new,
-                   noop = nil,
-                   bundled_content: nil,
-                   load_config: true)
+                   noop = false)
 
       # lazy-load expensive gem code
       require 'concurrent'
 
       @analytics = analytics
-      @bundled_content = bundled_content
       @logger = Logging.logger[self]
-      @load_config = load_config
 
       @transports = Bolt::TRANSPORTS.each_with_object({}) do |(key, val), coll|
         coll[key.to_s] = if key == :remote
@@ -184,7 +180,7 @@ module Bolt
     end
 
     def report_bundled_content(mode, name)
-      if @bundled_content&.include?(name)
+      if @analytics.bundled_content&.include?(name)
         @analytics&.event('Bundled Content', mode, label: name)
       end
     end
@@ -263,7 +259,6 @@ module Bolt
       log_action(description, targets) do
         notify = proc { |event| @notifier.notify(callback, event) if callback }
         options = { '_run_as' => run_as }.merge(options) if run_as
-        options = options.merge('_load_config' => @load_config)
         arguments['_task'] = task.name
 
         results = batch_execute(targets) do |transport, batch|

data/lib/bolt/inventory.rb

@@ -3,8 +3,10 @@
 require 'set'
 require 'bolt/config'
 require 'bolt/inventory/group'
+require 'bolt/inventory/inventory2'
 require 'bolt/target'
 require 'bolt/util'
+require 'yaml'
 
 module Bolt
   class Inventory
@@ -52,11 +54,23 @@ module Bolt
         data = Bolt::Util.read_config_file(config.inventoryfile, config.default_inventoryfile, 'inventory')
       end
 
-      inventory = new(data, config)
+      inventory = create_version(data, config)
       inventory.validate
       inventory
     end
 
+    def self.create_version(data, config)
+      version = (data || {}).delete('version') { 1 }
+      case version
+      when 1
+        new(data, config)
+      when 2
+        Bolt::Inventory::Inventory2.new(data, config)
+      else
+        raise ValidationError, "Unsupported version #{version} specified in inventory"
+      end
+    end
+
     def initialize(data, config = nil, target_vars: {}, target_facts: {}, target_features: {})
       @logger = Logging.logger[self]
       # Config is saved to add config options to targets
@@ -163,6 +177,21 @@ module Bolt
     end
     private :groups_in
 
+    # TODO: Possibly refactor this once inventory v2 is more stable
+    def self.localhost_defaults(data)
+      defaults = {
+        'config' => {
+          'transport' => 'local',
+          'local' => { 'interpreters' => { '.rb' => RbConfig.ruby } }
+        },
+        'features' => ['puppet-agent']
+      }
+      data = Bolt::Util.deep_merge(defaults, data)
+      # If features is an empty array deep_merge won't add the puppet-agent
+      data['features'] << 'puppet-agent' if data['features'].empty?
+      data
+    end
+
     # Pass a target to get_targets for a public version of this
     # Should this reconfigure configured targets?
     def update_target(target)
@@ -174,10 +203,7 @@ module Bolt
         data['config'] = {}
       end
 
-      unless data['config']['transport']
-        data['config']['transport'] = 'local' if target.name == 'localhost'
-      end
-
+      data = self.class.localhost_defaults(data) if target.name == 'localhost'
       # These should only get set from the inventory if they have not yet
       # been instantiated
       set_vars_from_hash(target.name, data['vars']) unless @target_vars[target.name]
@@ -224,6 +250,11 @@ module Bolt
     end
     private :resolve_name
 
+    def create_target(data)
+      Target.new(data)
+    end
+    private :create_target
+
     def expand_targets(targets)
       if targets.is_a? Bolt::Target
         targets.inventory = self
@@ -235,7 +266,7 @@ module Bolt
         targets.split(/[[:space:],]+/).reject(&:empty?).map do |name|
           ts = resolve_name(name)
           ts.map do |t|
-            target = Target.new(t)
+            target = create_target(t)
             target.inventory = self
             target
           end

data/lib/bolt/inventory/group2.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'bolt/inventory/group'
+
+module Bolt
+  class Inventory
+    class Group2
+      attr_accessor :name, :nodes, :aliases, :name_or_alias, :groups, :config, :rest, :facts, :vars, :features
+
+      # THESE are duplicates with the old groups for now.
+      # Regex used to validate group names and target aliases.
+      NAME_REGEX = /\A[a-z0-9_][a-z0-9_-]*\Z/.freeze
+
+      DATA_KEYS = %w[name config facts vars features].freeze
+      NODE_KEYS = DATA_KEYS + %w[alias uri]
+      GROUP_KEYS = DATA_KEYS + %w[groups nodes]
+      CONFIG_KEYS = Bolt::TRANSPORTS.keys.map(&:to_s) + ['transport']
+
+      def initialize(data)
+        @logger = Logging.logger[self]
+
+        raise ValidationError.new("Expected group to be a Hash, not #{data.class}", nil) unless data.is_a?(Hash)
+        raise ValidationError.new("Group does not have a name", nil) unless data.key?('name')
+
+        @name = data['name']
+        raise ValidationError.new("Group name must be a String, not #{@name.inspect}", nil) unless @name.is_a?(String)
+        raise ValidationError.new("Invalid group name #{@name}", @name) unless @name =~ NAME_REGEX
+
+        unless (unexpected_keys = data.keys - GROUP_KEYS).empty?
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in group #{@name}"
+          @logger.warn(msg)
+        end
+
+        @vars = fetch_value(data, 'vars', Hash)
+        @facts = fetch_value(data, 'facts', Hash)
+        @features = fetch_value(data, 'features', Array)
+        @config = fetch_value(data, 'config', Hash)
+
+        unless (unexpected_keys = @config.keys - CONFIG_KEYS).empty?
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for group #{@name}"
+          @logger.warn(msg)
+        end
+
+        nodes = fetch_value(data, 'nodes', Array)
+        groups = fetch_value(data, 'groups', Array)
+
+        @nodes = {}
+        @aliases = {}
+        nodes.reject { |node| node.is_a?(String) }.each do |node|
+          unless node.is_a?(Hash)
+            raise ValidationError.new("Node entry must be a String or Hash, not #{node.class}", @name)
+          end
+
+          node['name'] ||= node['uri']
+
+          if node['name'].nil? || node['name'].empty?
+            raise ValidationError.new("No name or uri for node: #{node}", @name)
+          end
+
+          if @nodes.include?(node['name'])
+            @logger.warn("Ignoring duplicate node in #{@name}: #{node}")
+            next
+          end
+
+          raise ValidationError.new("Node #{node} does not have a name", @name) unless node['name']
+          @nodes[node['name']] = node
+
+          unless (unexpected_keys = node.keys - NODE_KEYS).empty?
+            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in node #{node['name']}"
+            @logger.warn(msg)
+          end
+          config_keys = node['config']&.keys || []
+          unless (unexpected_keys = config_keys - CONFIG_KEYS).empty?
+            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for node #{node['name']}"
+            @logger.warn(msg)
+          end
+
+          next unless node.include?('alias')
+
+          aliases = node['alias']
+          aliases = [aliases] if aliases.is_a?(String)
+          unless aliases.is_a?(Array)
+            msg = "Alias entry on #{node['name']} must be a String or Array, not #{aliases.class}"
+            raise ValidationError.new(msg, @name)
+          end
+
+          aliases.each do |alia|
+            raise ValidationError.new("Invalid alias #{alia}", @name) unless alia =~ NAME_REGEX
+
+            if (found = @aliases[alia])
+              raise ValidationError.new(alias_conflict(alia, found, node['name']), @name)
+            end
+            @aliases[alia] = node['name']
+          end
+        end
+
+        # If node is a string, it can refer to either a node name or alias. Which can't be determined
+        # until all groups have been resolved, and requires a depth-first traversal to categorize them.
+        @name_or_alias = nodes.select { |node| node.is_a?(String) }
+
+        @groups = groups.map { |g| Group2.new(g) }
+      end
+
+      def node_data(node_name)
+        if (data = @nodes[node_name])
+          { 'config' => data['config'] || {},
+            'vars' => data['vars'] || {},
+            'facts' => data['facts'] || {},
+            'features' => data['features'] || [],
+            # This allows us to determine if a node was found?
+            'name' => data['name'] || nil,
+            'uri' => data['uri'] || nil,
+            # groups come from group_data
+            'groups' => [] }
+        end
+      end
+
+      def data_merge(data1, data2)
+        if data2.nil? || data1.nil?
+          return data2 || data1
+        end
+
+        {
+          'config' => Bolt::Util.deep_merge(data1['config'], data2['config']),
+          'name' => data1['name'] || data2['name'],
+          'uri' => data1['uri'] || data2['uri'],
+          # Shallow merge instead of deep merge so that vars with a hash value
+          # are assigned a new hash, rather than merging the existing value
+          # with the value meant to replace it
+          'vars' => data1['vars'].merge(data2['vars']),
+          'facts' => Bolt::Util.deep_merge(data1['facts'], data2['facts']),
+          'features' => data1['features'] | data2['features'],
+          'groups' => data2['groups'] + data1['groups']
+        }
+      end
+
+      private def fetch_value(data, key, type)
+        value = data.fetch(key, type.new)
+        unless value.is_a?(type)
+          raise ValidationError.new("Expected #{key} to be of type #{type}, not #{value.class}", @name)
+        end
+        value
+      end
+
+      def resolve_aliases(aliases, node_names)
+        @name_or_alias.each do |name_or_alias|
+          # If an alias is found, insert the name into this group. Otherwise use the name as a new node's uri.
+          if node_names.include?(name_or_alias)
+            @nodes[name_or_alias] = { 'name' => name_or_alias }
+          elsif (node_name = aliases[name_or_alias])
+            if @nodes.include?(node_name)
+              @logger.warn("Ignoring duplicate node in #{@name}: #{node_name}")
+            else
+              @nodes[node_name] = { 'name' => node_name }
+            end
+          else
+            node_name = name_or_alias
+
+            if @nodes.include?(node_name)
+              @logger.warn("Ignoring duplicate node in #{@name}: #{node_name}")
+            else
+              @nodes[node_name] = { 'uri' => node_name }
+            end
+          end
+        end
+
+        @groups.each { |g| g.resolve_aliases(aliases, node_names) }
+      end
+
+      private def alias_conflict(name, node1, node2)
+        "Alias #{name} refers to multiple targets: #{node1} and #{node2}"
+      end
+
+      private def group_alias_conflict(name)
+        "Group #{name} conflicts with alias of the same name"
+      end
+
+      private def group_node_conflict(name)
+        "Group #{name} conflicts with node of the same name"
+      end
+
+      private def alias_node_conflict(name)
+        "Node name #{name} conflicts with alias of the same name"
+      end
+
+      def validate(used_names = Set.new, node_names = Set.new, aliased = {}, depth = 0)
+        # Test if this group name conflicts with anything used before.
+        raise ValidationError.new("Tried to redefine group #{@name}", @name) if used_names.include?(@name)
+        raise ValidationError.new(group_node_conflict(@name), @name) if node_names.include?(@name)
+        raise ValidationError.new(group_alias_conflict(@name), @name) if aliased.include?(@name)
+
+        used_names << @name
+
+        # Collect node names and aliases into a list used to validate that subgroups don't conflict.
+        # Used names validate that previously used group names don't conflict with new node names/aliases.
+        @nodes.each_key do |n|
+          # Require nodes to be parseable as a Target.
+          begin
+            Target.new(n)
+          rescue Bolt::ParseError => e
+            @logger.debug(e)
+            raise ValidationError.new("Invalid node name #{n}", @name)
+          end
+
+          raise ValidationError.new(group_node_conflict(n), @name) if used_names.include?(n)
+          if aliased.include?(n)
+            raise ValidationError.new(alias_node_conflict(n), @name)
+          end
+
+          node_names << n
+        end
+
+        @aliases.each do |n, target|
+          raise ValidationError.new(group_alias_conflict(n), @name) if used_names.include?(n)
+          if node_names.include?(n)
+            raise ValidationError.new(alias_node_conflict(n), @name)
+          end
+
+          if aliased.include?(n)
+            raise ValidationError.new(alias_conflict(n, target, aliased[n]), @name)
+          end
+
+          aliased[n] = target
+        end
+
+        @groups.each do |g|
+          begin
+            g.validate(used_names, node_names, aliased, depth + 1)
+          rescue ValidationError => e
+            e.add_parent(@name)
+            raise e
+          end
+        end
+
+        nil
+      end
+
+      # The data functions below expect and return nil or a hash of the schema
+      # { 'config' => Hash , 'vars' => Hash, 'facts' => Hash, 'features' => Array, groups => Array }
+      def data_for(node_name)
+        data_merge(group_collect(node_name), node_collect(node_name))
+      end
+
+      def group_data
+        { 'config' => @config,
+          'vars' => @vars,
+          'facts' => @facts,
+          'features' => @features,
+          'groups' => [@name] }
+      end
+
+      def empty_data
+        { 'config' => {},
+          'vars' => {},
+          'facts' => {},
+          'features' => [],
+          'groups' => [] }
+      end
+
+      # Returns all nodes contained within the group, which includes nodes from subgroups.
+      def node_names
+        @groups.inject(local_node_names) do |acc, g|
+          acc.merge(g.node_names)
+        end
+      end
+
+      # Returns a mapping of aliases to nodes contained within the group, which includes subgroups.
+      def node_aliases
+        @groups.inject(@aliases) do |acc, g|
+          acc.merge(g.node_aliases)
+        end
+      end
+
+      # Return a mapping of group names to group.
+      def collect_groups
+        @groups.inject(name => self) do |acc, g|
+          acc.merge(g.collect_groups)
+        end
+      end
+
+      def local_node_names
+        Set.new(@nodes.keys)
+      end
+      private :local_node_names
+
+      def node_collect(node_name)
+        data = @groups.inject(nil) do |acc, g|
+          if (d = g.node_collect(node_name))
+            data_merge(d, acc)
+          else
+            acc
+          end
+        end
+        data_merge(node_data(node_name), data)
+      end
+
+      def group_collect(node_name)
+        data = @groups.inject(nil) do |acc, g|
+          if (d = g.data_for(node_name))
+            data_merge(d, acc)
+          else
+            acc
+          end
+        end
+
+        if data
+          data_merge(group_data, data)
+        elsif @nodes.include?(node_name)
+          group_data
+        end
+      end
+    end
+  end
+end