chef 18.0.169-x64-mingw-ucrt

data/lib/chef/config.rb

@@ -0,0 +1,85 @@
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Christopher Brown (<cb@chef.io>)
+# Author:: AJ Christensen (<aj@chef.io>)
+# Author:: Mark Mzyk (<mmzyk@chef.io>)
+# Author:: Kyle Goodwin (<kgoodwin@primerevenue.com>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative "log"
+require "chef-config/logger"
+
+# DI our logger into ChefConfig before we load the config. Some defaults are
+# auto-detected, and this emits log messages on some systems, all of which will
+# occur at require-time. So we need to set the logger first.
+ChefConfig.logger = Chef::Log
+
+require "chef-config/config"
+require "chef-utils" unless defined?(ChefUtils::CANARY)
+require_relative "platform/query_helpers"
+
+# Ohai::Config defines its own log_level and log_location. When loaded, it will
+# override the default ChefConfig::Config values. We save them here before
+# loading ohai/config so that we can override them again inside Chef::Config.
+#
+# REMOVEME once these configurables are removed from the top level of Ohai.
+LOG_LEVEL = ChefConfig::Config[:log_level] unless defined? LOG_LEVEL
+LOG_LOCATION = ChefConfig::Config[:log_location] unless defined? LOG_LOCATION
+
+# Load the ohai config into the chef config. We can't have an empty ohai
+# configuration context because `ohai.plugins_path << some_path` won't work,
+# and providing default ohai config values here isn't DRY.
+require "ohai/config"
+
+class Chef
+  Config = ChefConfig::Config
+
+  # We re-open ChefConfig::Config to add additional settings. Generally,
+  # everything should go in chef-config so it's shared with whoever uses that.
+  # We make exceptions to that rule when:
+  # * The functionality isn't likely to be useful outside of Chef
+  # * The functionality makes use of a dependency we don't want to add to chef-config
+  class Config
+
+    default :event_loggers do
+      evt_loggers = []
+      if ChefUtils.windows?
+        evt_loggers << :win_evt
+      end
+      evt_loggers
+    end
+
+    # Override the default values that were set by Ohai.
+    #
+    # REMOVEME once these configurables are removed from the top level of Ohai.
+    default :log_level, LOG_LEVEL
+    default :log_location, LOG_LOCATION
+
+    # Ohai::Config[:log_level] is deprecated and warns when set. Unfortunately,
+    # there is no way to distinguish between setting log_level and setting
+    # Ohai::Config[:log_level]. Since log_level and log_location are used by
+    # chef-client and other tools (e.g., knife), we will mute the warnings here
+    # by redefining the config_attr_writer to not warn for these options.
+    #
+    # REMOVEME once the warnings for these configurables are removed from Ohai.
+    %i{log_level log_location}.each do |option|
+      config_attr_writer option do |value|
+        value
+      end
+    end
+
+  end
+end

data/lib/chef/config_fetcher.rb

@@ -0,0 +1,72 @@
+require_relative "application"
+require_relative "chef_fs/path_utils"
+require_relative "http/simple"
+require_relative "json_compat"
+
+class Chef
+  class ConfigFetcher
+
+    attr_reader :config_location
+
+    def initialize(config_location)
+      @config_location = config_location
+    end
+
+    def expanded_path
+      if config_location.nil? || remote_config?
+        config_location
+      else
+        File.expand_path(config_location)
+      end
+    end
+
+    def fetch_json
+      config_data = read_config
+      begin
+        Chef::JSONCompat.from_json(config_data)
+      rescue Chef::Exceptions::JSON::ParseError => error
+        Chef::Application.fatal!("Could not parse the provided JSON file (#{config_location}): " + error.message)
+      end
+    end
+
+    def read_config
+      if remote_config?
+        fetch_remote_config
+      else
+        read_local_config
+      end
+    end
+
+    def fetch_remote_config
+      http.get("")
+    rescue SocketError, SystemCallError, Net::HTTPClientException => error
+      Chef::Application.fatal!("Cannot fetch config '#{config_location}': '#{error.class}: #{error.message}")
+    end
+
+    def read_local_config
+      ::File.read(config_location)
+    rescue Errno::ENOENT
+      Chef::Application.fatal!("Cannot load configuration from #{config_location}")
+    rescue Errno::EACCES
+      Chef::Application.fatal!("Permissions are incorrect on #{config_location}. Please chmod a+r #{config_location}")
+    end
+
+    def config_missing?
+      return false if remote_config?
+
+      # Check if the config file exists
+      Pathname.new(config_location).realpath.to_s
+      false
+    rescue Errno::ENOENT
+      true
+    end
+
+    def http
+      Chef::HTTP::Simple.new(config_location)
+    end
+
+    def remote_config?
+      !!(config_location =~ %r{^(http|https)://})
+    end
+  end
+end

data/lib/chef/constants.rb

@@ -0,0 +1,28 @@
+#
+# Author:: John Keiser <jkeiser@chef.io>
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Chef
+  NOT_PASSED = Object.new
+  def NOT_PASSED.to_s
+    "NOT_PASSED"
+  end
+
+  def NOT_PASSED.inspect
+    to_s
+  end
+  NOT_PASSED.freeze
+end

data/lib/chef/cookbook/chefignore.rb

@@ -0,0 +1,82 @@
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Chef
+  class Cookbook
+    class Chefignore
+
+      COMMENTS_AND_WHITESPACE = /^\s*(?:#.*)?$/.freeze
+
+      attr_reader :ignores
+
+      def initialize(ignore_file_or_repo)
+        # Check the 'ignore_file_or_repo' path first and then look in the parent directories till root
+        # to handle both the chef repo cookbook layout and a standalone cookbook
+        @ignore_file = find_ignore_file(ignore_file_or_repo)
+        @ignores = parse_ignore_file
+      end
+
+      # @param [Array] file_list the list of cookbook files
+      # @return [Array] list of cookbook files with chefignore files removed
+      def remove_ignores_from(file_list)
+        Array(file_list).inject([]) do |unignored, file|
+          ignored?(file) ? unignored : unignored << file
+        end
+      end
+
+      # @param [String] file_name the file name to check ignored status for
+      # @return [Boolean] is the file ignored or not
+      def ignored?(file_name)
+        @ignores.any? { |glob| File.fnmatch?(glob, file_name) }
+      end
+
+      private
+
+      def parse_ignore_file
+        ignore_globs = []
+        if @ignore_file && readable_file_or_symlink?(@ignore_file)
+          File.foreach(@ignore_file) do |line|
+            ignore_globs << line.strip unless COMMENTS_AND_WHITESPACE.match?(line)
+          end
+        else
+          Chef::Log.debug("No chefignore file found. No files will be ignored!")
+        end
+        ignore_globs
+      end
+
+      # Lookup of chefignore file till the root dir of the provided path.
+      # If file refer then lookup the parent dir till the root.
+      # eg. path: /var/.chef/cookbook_name
+      # Lookup at '/var/.chef/cookbook_name/chefignore', '/var/.chef/chefignore' '/var/chefignore' and '/chefignore' until exist
+      def find_ignore_file(path)
+        Pathname.new(path).ascend do |dir|
+          next unless dir.directory?
+
+          file = dir.join("chefignore")
+          return file.expand_path.to_s if file.exist?
+        end
+
+        nil
+      end
+
+      def readable_file_or_symlink?(path)
+        File.exist?(path) && File.readable?(path) &&
+          (File.file?(path) || File.symlink?(path))
+      end
+    end
+  end
+end

data/lib/chef/cookbook/cookbook_collection.rb

@@ -0,0 +1,62 @@
+# Author:: Tim Hinderliter (<tim@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../mash"
+require_relative "gem_installer"
+
+class Chef
+  # == Chef::CookbookCollection
+  # This class is the consistent interface for a node to obtain its
+  # cookbooks by name.
+  #
+  # This class is basically a glorified Hash, but since there are
+  # several ways this cookbook information is collected,
+  # (e.g. CookbookLoader for solo, hash of auto-vivified Cookbook
+  # objects for lazily-loaded remote cookbooks), it gets transformed
+  # into this.
+  class CookbookCollection < Mash
+
+    # The input is a mapping of cookbook name to CookbookVersion objects. We
+    # simply extract them
+    def initialize(cookbook_versions = {})
+      super() do |hash, key|
+        raise Chef::Exceptions::CookbookNotFound, "Cookbook #{key} not found. " <<
+          "If you're loading #{key} from another cookbook, make sure you configure the dependency in your metadata"
+      end
+      cookbook_versions.each { |cookbook_name, cookbook_version| self[cookbook_name] = cookbook_version }
+    end
+
+    # Validates that the cookbook metadata allows it to run on this instance.
+    #
+    # Currently checks chef_version and ohai_version in the cookbook metadata
+    # against the running Chef::VERSION and Ohai::VERSION.
+    #
+    # @raise [Chef::Exceptions::CookbookChefVersionMismatch] if the Chef::VERSION fails validation
+    # @raise [Chef::Exceptions::CookbookOhaiVersionMismatch] if the Ohai::VERSION fails validation
+    def validate!
+      each_value do |cookbook_version|
+        cookbook_version.metadata.validate_chef_version!
+        cookbook_version.metadata.validate_ohai_version!
+      end
+    end
+
+    def install_gems(events)
+      Cookbook::GemInstaller.new(self, events).install
+    end
+  end
+end

data/lib/chef/cookbook/cookbook_version_loader.rb

@@ -0,0 +1,287 @@
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "../cookbook_version"
+require_relative "chefignore"
+require_relative "metadata"
+require_relative "../util/path_helper"
+require "find" unless defined?(Find.find)
+
+class Chef
+  class Cookbook
+    # This class is only used directly from the Chef::CookbookLoader and from chef-fs,
+    # so it only affects legacy-mode chef-client runs and knife.  It is not used by
+    # server or zolo/zero modes.
+    #
+    # This seems to be mostly a glorified factory method for creating CookbookVersion
+    # objects now, with creating Metadata objects bolted onto the side?  It used
+    # to be also responsible for the merging of multiple objects when creating
+    # shadowed/merged cookbook versions from multiple sources.  It also handles
+    # Chefignore files.
+    #
+    class CookbookVersionLoader
+
+      UPLOADED_COOKBOOK_VERSION_FILE = ".uploaded-cookbook-version.json".freeze
+
+      attr_reader :cookbook_settings
+      attr_reader :frozen
+      attr_reader :uploaded_cookbook_version_file
+
+      attr_reader :cookbook_path
+
+      # The cookbook's name as inferred from its directory.
+      attr_reader :inferred_cookbook_name
+
+      attr_reader :metadata_error
+
+      def initialize(path, chefignore = nil)
+        @cookbook_path = File.expand_path( path ) # cookbook_path from which this was loaded
+
+        @inferred_cookbook_name = File.basename( path )
+        @chefignore = chefignore
+        @metadata = nil
+        @relative_path = %r{#{Regexp.escape(cookbook_path)}/(.+)$}
+        @metadata_loaded = false
+        @cookbook_settings = {
+          all_files: {},
+        }
+
+        @metadata_filenames = []
+        @metadata_error = nil
+      end
+
+      # Load the cookbook. Raises an error if the cookbook_path given to the
+      # constructor doesn't point to a valid cookbook.
+      def load!
+        metadata # force lazy evaluation to occur
+
+        # re-raise any exception that occurred when reading the metadata
+        raise_metadata_error!
+
+        load_all_files
+
+        remove_ignored_files
+
+        if empty?
+          raise Exceptions::CookbookNotFoundInRepo, "The directory #{cookbook_path} does not contain a cookbook"
+        end
+
+        cookbook_settings
+      end
+
+      def load
+        Chef.deprecated(:internal_api, "Chef::Cookbook::CookbookVersionLoader's load method is deprecated. Please use load! instead.")
+        metadata # force lazy evaluation to occur
+
+        # re-raise any exception that occurred when reading the metadata
+        raise_metadata_error!
+
+        load_all_files
+
+        remove_ignored_files
+
+        if empty?
+          Chef::Log.warn "Found a directory #{cookbook_name} in the cookbook path, but it contains no cookbook files. skipping."
+        end
+
+        cookbook_settings
+      end
+
+      alias :load_cookbooks :load
+
+      def cookbook_version
+        return nil if empty?
+
+        Chef::CookbookVersion.new(cookbook_name, cookbook_path).tap do |c|
+          c.all_files            = cookbook_settings[:all_files].values
+          c.metadata             = metadata
+
+          c.freeze_version if frozen
+        end
+      end
+
+      # Generates the Cookbook::Metadata object
+      def metadata
+        return @metadata unless @metadata.nil?
+
+        @metadata = Chef::Cookbook::Metadata.new
+
+        metadata_filenames.each do |metadata_file|
+          case metadata_file
+          when /\.rb$/
+            apply_ruby_metadata(metadata_file)
+          when uploaded_cookbook_version_file
+            apply_json_cookbook_version_metadata(metadata_file)
+          when /\.json$/
+            apply_json_metadata(metadata_file)
+          else
+            raise "Invalid metadata file: #{metadata_file} for cookbook: #{cookbook_version}"
+          end
+        end
+
+        @metadata
+
+        # Rescue errors so that users can upload cookbooks via `knife cookbook
+        # upload` even if some cookbooks in their chef-repo have errors in
+        # their metadata. We only rescue StandardError because you have to be
+        # doing something *really* terrible to raise an exception that inherits
+        # directly from Exception in your metadata.rb file.
+      rescue StandardError => e
+        @metadata_error = e
+        @metadata
+      end
+
+      def cookbook_name
+        # The `name` attribute is now required in metadata, so
+        # inferred_cookbook_name generally should not be used. Per CHEF-2923,
+        # we have to not raise errors in cookbook metadata immediately, so that
+        # users can still `knife cookbook upload some-cookbook` when an
+        # unrelated cookbook has an error in its metadata.  This situation
+        # could prevent us from reading the `name` attribute from the metadata
+        # entirely, but the name is used as a hash key in CookbookLoader, so we
+        # fall back to the inferred name here.
+        (metadata.name || inferred_cookbook_name).to_sym
+      end
+
+      private
+
+      def metadata_filenames
+        return @metadata_filenames unless @metadata_filenames.empty?
+
+        if File.exist?(File.join(cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE))
+          @uploaded_cookbook_version_file = File.join(cookbook_path, UPLOADED_COOKBOOK_VERSION_FILE)
+        end
+
+        if File.exist?(File.join(cookbook_path, "metadata.json"))
+          @metadata_filenames << File.join(cookbook_path, "metadata.json")
+        elsif File.exist?(File.join(cookbook_path, "metadata.rb"))
+          @metadata_filenames << File.join(cookbook_path, "metadata.rb")
+        elsif uploaded_cookbook_version_file
+          @metadata_filenames << uploaded_cookbook_version_file
+        end
+
+        # Set frozen based on .uploaded-cookbook-version.json
+        set_frozen
+        @metadata_filenames
+      end
+
+      def raise_metadata_error!
+        raise metadata_error unless metadata_error.nil?
+
+        # Metadata won't be valid if the cookbook is empty. If the cookbook is
+        # actually empty, a metadata error here would be misleading, so don't
+        # raise it (if called by #load!, a different error is raised).
+        if !empty? && !metadata.valid?
+          message = "Cookbook loaded at path [#{cookbook_path}] has invalid metadata: #{metadata.errors.join("; ")}"
+          raise Exceptions::MetadataNotValid, message
+        end
+        false
+      end
+
+      def empty?
+        cookbook_settings.values.all?(&:empty?) && metadata_filenames.size == 0
+      end
+
+      def chefignore
+        @chefignore ||= Chefignore.new(cookbook_path)
+      end
+
+      # Enumerate all the files in a cookbook and assign the resulting list to
+      # `cookbook_settings[:all_files]`. In order to behave in a compatible way
+      # with previous implementations, directories at the cookbook's root that
+      # begin with a dot are ignored. dotfiles are generally not ignored,
+      # however if the file is named ".uploaded-cookbook-version.json" it is
+      # assumed to be managed by chef-zero and not part of the cookbook.
+      def load_all_files
+        return unless File.exist?(cookbook_path)
+
+        # If cookbook_path is a symlink, Find on Windows Ruby 2.3 will not traverse it.
+        # Dir.entries will do so on all platforms, so we iterate the top level using
+        # Dir.entries. Since we have different behavior at the top anyway (hidden
+        # directories at the top level are not included for backcompat), this
+        # actually keeps things a bit cleaner.
+        Dir.entries(cookbook_path).each do |top_filename|
+          # Skip top-level directories starting with "."
+          top_path = File.join(cookbook_path, top_filename)
+          next if File.directory?(top_path) && top_filename.start_with?(".")
+
+          # Use Find.find because it:
+          # (a) returns any children, recursively
+          # (b) includes top_path as well
+          # (c) skips symlinks, which is backcompat (no judgement on whether it was *right*)
+          Find.find(top_path) do |path|
+            # Only add files, not directories
+            next unless File.file?(path)
+            # Don't add .uploaded-cookbook-version.json
+            next if File.basename(path) == UPLOADED_COOKBOOK_VERSION_FILE
+
+            relative_path = Chef::Util::PathHelper.relative_path_from(cookbook_path, path)
+            path = Pathname.new(path).cleanpath.to_s
+            cookbook_settings[:all_files][relative_path] = path
+          end
+        end
+      end
+
+      def remove_ignored_files
+        cookbook_settings[:all_files].reject! do |relative_path, full_path|
+          chefignore.ignored?(relative_path)
+        end
+      end
+
+      def apply_ruby_metadata(file)
+        @metadata.from_file(file)
+      rescue Chef::Exceptions::JSON::ParseError
+        Chef::Log.error("Error evaluating metadata.rb for #{inferred_cookbook_name} in " + file)
+        raise
+      end
+
+      def apply_json_metadata(file)
+        @metadata.from_json(IO.read(file))
+      rescue Chef::Exceptions::JSON::ParseError
+        Chef::Log.error("Couldn't parse cookbook metadata JSON for #{inferred_cookbook_name} in " + file)
+        raise
+      end
+
+      def apply_json_cookbook_version_metadata(file)
+        data = Chef::JSONCompat.parse(IO.read(file))
+        @metadata.from_hash(data["metadata"])
+        # the JSON cookbook metadata file is only used by chef-zero.
+        # The Chef Server API currently does not enforce that the metadata
+        # have a `name` field, but that will cause an error when attempting
+        # to load the cookbook. To keep compatibility, we fake it by setting
+        # the metadata name from the cookbook version object's name.
+        #
+        # This behavior can be removed if/when Chef Server enforces that the
+        # metadata contains a name key.
+        @metadata.name(data["cookbook_name"]) unless data["metadata"].key?("name")
+      rescue Chef::Exceptions::JSON::ParseError
+        Chef::Log.error("Couldn't parse cookbook metadata JSON for #{inferred_cookbook_name} in " + file)
+        raise
+      end
+
+      def set_frozen
+        if uploaded_cookbook_version_file
+          begin
+            data = Chef::JSONCompat.parse(IO.read(uploaded_cookbook_version_file))
+            @frozen = data["frozen?"]
+          rescue Chef::Exceptions::JSON::ParseError
+            Chef::Log.error("Couldn't parse cookbook metadata JSON for #{inferred_cookbook_name} in #{uploaded_cookbook_version_file}")
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef/cookbook/file_system_file_vendor.rb

@@ -0,0 +1,58 @@
+# Author:: Christopher Walters (<cw@chef.io>)
+# Author:: Tim Hinderliter (<tim@chef.io>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require_relative "file_vendor"
+
+class Chef
+  class Cookbook
+    # == Chef::Cookbook::FileSystemFileVendor
+    # This FileVendor loads files from Chef::Config.cookbook_path. The
+    # thing that's sort of janky about this FileVendor implementation is
+    # that it basically takes only the cookbook's name from the manifest
+    # and throws the rest away then re-builds the list of files on the
+    # disk. This is due to the manifest not having the on-disk file
+    # locations, since in the chef-client case, that information is
+    # nonsensical.
+    class FileSystemFileVendor < FileVendor
+
+      attr_reader :cookbook_name
+      attr_reader :repo_paths
+
+      def initialize(manifest, *repo_paths)
+        @cookbook_name = manifest.name
+        @repo_paths = repo_paths.flatten
+        raise ArgumentError, "You must specify at least one repo path" if repo_paths.empty?
+      end
+
+      def cookbooks
+        @cookbooks ||= Chef::CookbookLoader.new(repo_paths).load_cookbooks
+      end
+
+      # Implements abstract base's requirement. It looks in the
+      # Chef::Config.cookbook_path file hierarchy for the requested
+      # file.
+      def get_filename(filename)
+        location = File.join(cookbooks[cookbook_name].root_dir, filename) if cookbooks.key?(cookbook_name)
+        raise "File #{filename} does not exist for cookbook #{cookbook_name}" unless location && File.exist?(location)
+
+        location
+      end
+
+    end
+  end
+end