berkshelf 3.0.0.beta7 → 3.0.0.beta8

data/features/step_definitions/chef_server_steps.rb

@@ -7,6 +7,7 @@ end
 Given /^the Chef Server has cookbooks:$/ do |cookbooks|
   cookbooks.raw.each do |name, version, dependencies|
     metadata = []
+    metadata << "name '#{name}'"
     metadata << "version '#{version}'"
     dependencies.to_s.split(',').map { |d| d.split(' ', 2) }.each do |(name, constraint)|
       metadata << "depends '#{name}', '#{constraint}'"

data/features/step_definitions/cli_steps.rb

@@ -1,4 +1,4 @@
 Then /^the exit status should be "(.+)"$/ do |name|
-  code = Berkshelf.const_get(name).status_code
-  assert_exit_status(code)
+  error = name.split('::').reduce(Berkshelf) { |klass, id| klass.const_get(id) }
+  assert_exit_status(error.status_code)
 end

data/features/step_definitions/filesystem_steps.rb

@@ -5,10 +5,8 @@ World(Berkshelf::RSpec::ChefAPI)
 World(Berkshelf::RSpec::FileSystemMatchers)
 
 Given /^a cookbook named "(.*?)"$/ do |name|
-  steps %{
-    Given a directory named "#{name}"
-    And an empty file named "#{name}/metadata.rb"
-  }
+  create_dir(name)
+  write_file(File.join(name, "metadata.rb"), "name '#{name}'")
 end
 
 Given /^the cookbook "(.*?)" has the file "(.*?)" with:$/ do |cookbook_name, file_name, content|

data/generator_files/chefignore

@@ -69,8 +69,6 @@ Procfile
 
 # Berkshelf #
 #############
-Berksfile
-Berksfile.lock
 cookbooks/*
 tmp
 

data/lib/berkshelf.rb

@@ -17,16 +17,30 @@ require_relative 'berkshelf/thor_ext'
 module Berkshelf
   require_relative 'berkshelf/version'
   require_relative 'berkshelf/errors'
-  require_relative 'berkshelf/mixin'
+
+  module Mixin
+    autoload :DSLEval, 'berkshelf/mixin/dsl_eval'
+    autoload :Logging, 'berkshelf/mixin/logging'
+  end
+
+  autoload :BaseFormatter,  'berkshelf/formatters/base'
+  autoload :HumanFormatter, 'berkshelf/formatters/human'
+  autoload :JsonFormatter,  'berkshelf/formatters/json'
+  autoload :NullFormatter,  'berkshelf/formatters/null'
+
+  autoload :Location,       'berkshelf/location'
+  autoload :BaseLocation,   'berkshelf/locations/base'
+  autoload :GitLocation,    'berkshelf/locations/git'
+  autoload :GithubLocation, 'berkshelf/locations/github'
+  autoload :PathLocation,   'berkshelf/locations/path'
 
   DEFAULT_FILENAME = 'Berksfile'.freeze
 
   class << self
-    include Berkshelf::Mixin::Logging
+    include Mixin::Logging
 
     attr_writer :berkshelf_path
     attr_accessor :ui
-    attr_accessor :logger
 
     # @return [Pathname]
     def root
@@ -79,8 +93,7 @@ module Berkshelf
       FileUtils.mkdir_p(berkshelf_path, mode: 0755)
 
       unless File.writable?(berkshelf_path)
-        raise InsufficientPrivledges, "You do not have permission to write to '#{berkshelf_path}'!" +
-          " Please either chown the directory or use a different filepath."
+        raise InsufficientPrivledges.new(berkshelf_path)
       end
     end
 
@@ -108,7 +121,7 @@ module Berkshelf
     #
     # @return [~Formatter]
     def formatter
-      @formatter ||= Formatters::HumanReadable.new
+      @formatter ||= HumanFormatter.new
     end
 
     # @raise [Berkshelf::ChefConnectionError]
@@ -137,7 +150,7 @@ module Berkshelf
       Celluloid.logger = nil unless ENV["DEBUG_CELLULOID"]
       Ridley.open(ridley_options, &block)
     rescue Ridley::Errors::RidleyError => ex
-      log_exception(ex)
+      log.exception(ex)
       raise ChefConnectionError, ex # todo implement
     end
 
@@ -149,8 +162,24 @@ module Berkshelf
     # @example Berkshelf.set_format :json
     #
     # @return [~Formatter]
-    def set_format(format_id)
-      @formatter = Formatters[format_id].new
+    def set_format(name)
+      id = name.to_s.capitalize
+      @formatter = Berkshelf.const_get("#{id}Formatter").new
+    end
+
+    # Location an executable in the current user's $PATH
+    #
+    # @return [String, nil]
+    #   the path to the executable, or +nil+ if not present
+    def which(executable)
+      if File.file?(executable) && File.executable?(executable)
+        executable
+      elsif ENV['PATH']
+        path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
+          File.executable?(File.join(p, executable))
+        end
+        path && File.expand_path(executable, path)
+      end
     end
 
     private
@@ -177,17 +206,13 @@ require_relative 'berkshelf/cookbook_store'
 require_relative 'berkshelf/config'
 require_relative 'berkshelf/dependency'
 require_relative 'berkshelf/downloader'
-require_relative 'berkshelf/formatters'
-require_relative 'berkshelf/git'
-require_relative 'berkshelf/mercurial'
 require_relative 'berkshelf/init_generator'
 require_relative 'berkshelf/installer'
-require_relative 'berkshelf/location'
 require_relative 'berkshelf/logger'
 require_relative 'berkshelf/resolver'
 require_relative 'berkshelf/source'
 require_relative 'berkshelf/source_uri'
 require_relative 'berkshelf/ui'
 
-Ridley.logger = Berkshelf.logger = Logger.new(STDOUT)
+Ridley.logger = Berkshelf.logger
 Berkshelf.logger.level = Logger::WARN

data/lib/berkshelf/berksfile.rb

@@ -28,13 +28,14 @@ module Berkshelf
 
     DEFAULT_API_URL = "https://api.berkshelf.com".freeze
 
-    include Berkshelf::Mixin::Logging
-    include Berkshelf::Mixin::DSLEval
+    include Mixin::Logging
+    include Mixin::DSLEval
     extend Forwardable
 
     expose_method :source
     expose_method :site     # @todo remove in Berkshelf 4.0
     expose_method :chef_api # @todo remove in Berkshelf 4.0
+    expose_method :extension
     expose_method :metadata
     expose_method :cookbook
     expose_method :group
@@ -60,7 +61,7 @@ module Berkshelf
       @sources          = Hash.new
 
       if options[:except] && options[:only]
-        raise Berkshelf::ArgumentError, 'Cannot specify both :except and :only!'
+        raise ArgumentError, 'Cannot specify both :except and :only!'
       elsif options[:except]
         except = Array(options[:except]).collect(&:to_sym)
         @filter = ->(dependency) { (except & dependency.groups).empty? }
@@ -72,6 +73,26 @@ module Berkshelf
       end
     end
 
+    # Activate a Berkshelf extension at runtime.
+    #
+    # @example Activate the Mercurial extension
+    #   extension 'hg'
+    #
+    # @raise [LoadError]
+    #   if the extension cannot be loaded
+    #
+    # @param [String] name
+    #   the name of the extension to activate
+    #
+    # @return [true]
+    def extension(name)
+      require "berkshelf/#{name}"
+      true
+    rescue LoadError
+      raise LoadError, "Could not load an extension by the name `#{name}'. " \
+        "Please make sure it is installed."
+    end
+
     # Add a cookbook dependency to the Berksfile to be retrieved and have its dependencies recursively retrieved
     # and resolved.
     #
@@ -159,14 +180,14 @@ module Berkshelf
     # @param [String] api_url
     #   url for the api to add
     #
-    # @raise [Berkshelf::InvalidSourceURI]
+    # @raise [InvalidSourceURI]
     #
-    # @return [Array<Berkshelf::Source>]
+    # @return [Array<Source>]
     def source(api_url)
       @sources[api_url] = Source.new(api_url)
     end
 
-    # @return [Array<Berkshelf::Source>]
+    # @return [Array<Source>]
     def sources
       if @sources.empty?
         raise NoAPISourcesDefined
@@ -183,7 +204,7 @@ module Berkshelf
 
     # @todo remove in Berkshelf 4.0
     #
-    # @raise [Berkshelf::DeprecatedError]
+    # @raise [DeprecatedError]
     def site(*args)
       if args.first == :opscode
         Berkshelf.formatter.deprecation "Your Berksfile contains a site location pointing to the Opscode Community " +
@@ -194,16 +215,16 @@ module Berkshelf
         return
       end
 
-      raise Berkshelf::DeprecatedError.new "Your Berksfile contains a site location. Site locations have been " +
+      raise DeprecatedError.new "Your Berksfile contains a site location. Site locations have been " +
         " replaced by the source location. Please remove your site location and try again. For more information " +
         " visit https://github.com/berkshelf/berkshelf/wiki/deprecated-locations"
     end
 
     # @todo remove in Berkshelf 4.0
     #
-    # @raise [Berkshelf::DeprecatedError]
+    # @raise [DeprecatedError]
     def chef_api(*args)
-      raise Berkshelf::DeprecatedError.new "Your Berksfile contains a chef_api location. Chef API locations have " +
+      raise DeprecatedError.new "Your Berksfile contains a chef_api location. Chef API locations have " +
         " been replaced by the source location. Please remove your site location and try again. For more " +
         " information visit https://github.com/berkshelf/berkshelf/wiki/deprecated-locations"
     end
@@ -225,14 +246,13 @@ module Berkshelf
     # @raise [DuplicateDependencyDefined] if a dependency is added whose name conflicts
     #   with a dependency who has already been added.
     #
-    # @return [Array<Berkshelf::Dependency]
+    # @return [Array<Dependency]
     def add_dependency(name, constraint = nil, options = {})
-      if has_dependency?(name)
+      if @dependencies[name]
         # Only raise an exception if the dependency is a true duplicate
         groups = (options[:group].nil? || options[:group].empty?) ? [:default] : options[:group]
         if !(@dependencies[name].groups & groups).empty?
-          raise DuplicateDependencyDefined,
-            "Berksfile contains multiple entries named '#{name}'. Use only one, or put them in different groups."
+          raise DuplicateDependencyDefined.new(name)
         end
       end
 
@@ -242,27 +262,22 @@ module Berkshelf
 
       options[:constraint] = constraint
 
-      @dependencies[name] = Berkshelf::Dependency.new(self, name, options)
+      @dependencies[name] = Dependency.new(self, name, options)
     end
 
-    # @param [#to_s] dependency
-    #   the dependency to remove
+    # Check if the Berksfile has the given dependency, taking into account
+    # +group+ and --only/--except flags.
     #
-    # @return [Berkshelf::Dependency]
-    def remove_dependency(dependency)
-      @dependencies.delete(dependency.to_s)
-    end
-
-    # @param [#to_s] dependency
-    #   the dependency to check presence of
+    # @param [String, Dependency] dependency
+    #   the dependency or name of dependency to check presence of
     #
     # @return [Boolean]
     def has_dependency?(dependency)
-      @dependencies.has_key?(dependency.to_s)
+      name = Dependency.name(dependency)
+      dependencies.map(&:name).include?(name)
     end
 
-
-    # @return [Array<Berkshelf::Dependency>]
+    # @return [Array<Dependency>]
     def dependencies
       @dependencies.values.sort.select(&@filter)
     end
@@ -288,30 +303,24 @@ module Berkshelf
     #
     # @param [String] name
     #   the name of the cookbook dependency to search for
-    # @return [Berkshelf::Dependency, nil]
+    # @return [Dependency, nil]
     #   the cookbook dependency, or nil if one does not exist
     def find(name)
       @dependencies[name]
     end
 
-    # Find a dependency, raising an exception if it is not found.
-    # @see {find}
-    def find!(name)
-      find(name) || raise(DependencyNotFound.new(name))
-    end
-
     # @return [Hash]
-    #   a hash containing group names as keys and an array of Berkshelf::Dependencies
+    #   a hash containing group names as keys and an array of Dependencies
     #   that are a member of that group as values
     #
     #   Example:
     #     {
     #       nautilus: [
-    #         #<Berkshelf::Dependency: nginx (~> 1.0.0)>,
-    #         #<Berkshelf::Dependency: mysql (~> 1.2.4)>
+    #         #<Dependency: nginx (~> 1.0.0)>,
+    #         #<Dependency: mysql (~> 1.2.4)>
     #       ],
     #       skarner: [
-    #         #<Berkshelf::Dependency: nginx (~> 1.0.0)>
+    #         #<Dependency: nginx (~> 1.0.0)>
     #       ]
     #     }
     def groups
@@ -328,7 +337,7 @@ module Berkshelf
     # @param [String] name
     #   name of the dependency to return
     #
-    # @return [Berkshelf::Dependency]
+    # @return [Dependency]
     def [](name)
       @dependencies[name]
     end
@@ -347,7 +356,7 @@ module Berkshelf
     #      sources. If not, then either a version constraint has changed,
     #      or a new source has been added to the Berksfile. In the event that
     #      a locked_source exists, but it no longer satisfies the constraint,
-    #      this method will raise a {Berkshelf::OutdatedCookbookSource}, and
+    #      this method will raise a {OutdatedCookbookSource}, and
     #      inform the user to run <tt>berks update COOKBOOK</tt> to remedy the issue.
     #    - Remove any locked sources that no longer exist in the Berksfile
     #      (i.e. a cookbook source was removed from the Berksfile).
@@ -356,10 +365,10 @@ module Berkshelf
     #
     # 3. Write out a new lockfile.
     #
-    # @raise [Berkshelf::OutdatedDependency]
+    # @raise [OutdatedDependency]
     #   if the lockfile constraints do not satisfy the Berksfile constraints
     #
-    # @return [Array<Berkshelf::CachedCookbook>]
+    # @return [Array<CachedCookbook>]
     def install
       Installer.new(self).run
     end
@@ -405,12 +414,12 @@ module Berkshelf
 
     # The cached cookbooks installed by this Berksfile.
     #
-    # @raise [Berkshelf::LockfileNotFound]
+    # @raise [LockfileNotFound]
     #   if there is no lockfile
-    # @raise [Berkshelf::CookbookNotFound]
+    # @raise [CookbookNotFound]
     #   if a listed source could not be found
     #
-    # @return [Hash<Berkshelf::Dependency, Berkshelf::CachedCookbook>]
+    # @return [Hash<Dependency, CachedCookbook>]
     #   the list of dependencies as keys and the cached cookbook as the value
     def list
       validate_lockfile_present!
@@ -465,47 +474,79 @@ module Berkshelf
 
     # Upload the cookbooks installed by this Berksfile
     #
-    # @option options [Boolean] :force (false)
-    #   Upload the Cookbook even if the version already exists and is frozen on the
-    #   target Chef Server
-    # @option options [Boolean] :freeze (true)
-    #   Freeze the uploaded Cookbook on the Chef Server so that it cannot be overwritten
-    # @option options [String, Array] :cookbooks
-    #   Names of the cookbooks to retrieve dependencies for
-    # @option options [Hash] :ssl_verify (true)
-    #   Disable/Enable SSL verification during uploads
-    # @option options [Boolean] :halt_on_frozen (false)
-    #   Raise a FrozenCookbook error if one of the cookbooks being uploaded is already located
-    #   on the remote Chef Server and frozen.
-    # @option options [String] :server_url
-    #   An overriding Chef Server to upload the cookbooks to
-    # @option options [String] :client_name
-    #   An overriding client name to use for connecting to the chef server
-    # @option options [String] :client_key
-    #   An overriding client key to use for connecting to the chef server
-    #
-    # @raise [Berkshelf::UploadFailure]
+    # @overload upload(names = [])
+    #   @param [Array<String>] names
+    #     the list of cookbooks (by name) to upload to the remote Chef Server
+    #
+    #
+    # @overload upload(names = [], options = {})
+    #   @param [Array<String>] names
+    #     the list of cookbooks (by name) to upload to the remote Chef Server
+    #   @param [Hash<Symbol, Object>] options
+    #     the list of options to pass to the uploader
+    #
+    #   @option options [Boolean] :force (false)
+    #     upload the cookbooks even if the version already exists and is frozen
+    #     on the remote Chef Server
+    #   @option options [Boolean] :freeze (true)
+    #     freeze the uploaded cookbooks on the remote Chef Server so that it
+    #     cannot be overwritten on future uploads
+    #   @option options [Hash] :ssl_verify (true)
+    #     use SSL verification while connecting to the remote Chef Server
+    #   @option options [Boolean] :halt_on_frozen (false)
+    #     raise an exception ({FrozenCookbook}) if one of the cookbooks already
+    #     exists on the remote Chef Server and is frozen
+    #   @option options [String] :server_url
+    #     the URL (endpoint) to the remote Chef Server
+    #   @option options [String] :client_name
+    #     the client name for the remote Chef Server
+    #   @option options [String] :client_key
+    #     the client key (pem) for the remote Chef Server
+    #
+    #
+    # @example Upload all cookbooks
+    #   berksfile.upload
+    #
+    # @example Upload the 'apache2' and 'mysql' cookbooks
+    #   berksfile.upload('apache2', 'mysql')
+    #
+    # @example Upload and freeze all cookbooks
+    #   berksfile.upload(freeze: true)
+    #
+    # @example Upload and freeze the `chef-sugar` cookbook
+    #   berksfile.upload('chef-sugar', freeze: true)
+    #
+    #
+    # @raise [UploadFailure]
     #   if you are uploading cookbooks with an invalid or not-specified client key
-    # @raise [Berkshelf::DependencyNotFound]
+    # @raise [DependencyNotFound]
     #   if one of the given cookbooks is not a dependency defined in the Berksfile
-    # @raise [Berkshelf::FrozenCookbook]
+    # @raise [FrozenCookbook]
     #   if the cookbook being uploaded is a {metadata} cookbook and is already
     #   frozen on the remote Chef Server; indirect dependencies or non-metadata
     #   dependencies are just skipped
-    def upload(options = {})
-      options = {
-        force: false,
-        freeze: true,
-        halt_on_frozen: false,
-        cookbooks: [],
-        validate: true
-      }.merge(options)
+    #
+    # @return [Array<CachedCookbook>]
+    #   the list of cookbooks that were uploaded to the Chef Server
+    def upload(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      names   = args.flatten
 
-      validate_cookbook_names!(options[:cookbooks])
+      validate_lockfile_present!
+      validate_lockfile_trusted!
+      validate_dependencies_installed!
+      validate_cookbook_names!(names)
 
-      cached_cookbooks = install
-      cached_cookbooks = filter_to_upload(cached_cookbooks, options[:cookbooks]) if options[:cookbooks]
-      do_upload(cached_cookbooks, options)
+      # Calculate the list of cookbooks from the given arguments
+      if names.empty?
+        list = dependencies
+      else
+        list = dependencies.select { |dependency| names.include?(dependency.name) }
+      end
+
+      cookbooks = cookbooks_for_upload(list)
+      ridley_upload(cookbooks, options)
+      cookbooks
     end
 
     # Package the given cookbook for distribution outside of berkshelf. If the
@@ -515,7 +556,7 @@ module Berkshelf
     # @param [String] path
     #   the path where the tarball will be created
     #
-    # @raise [Berkshelf::PackageError]
+    # @raise [PackageError]
     #
     # @return [String]
     #   the path to the package
@@ -524,10 +565,8 @@ module Berkshelf
       packager.validate!
 
       outdir = Dir.mktmpdir do |temp_dir|
-        source = Berkshelf.ui.mute do
-          vendor(File.join(temp_dir, 'cookbooks'))
-        end
-        packager.run(source)
+        Berkshelf.ui.mute { vendor(File.join(temp_dir, 'cookbooks')) }
+        packager.run(temp_dir)
       end
 
       Berkshelf.formatter.package(outdir)
@@ -603,7 +642,7 @@ module Berkshelf
     # the user can specify a different path to the Berksfile. So assuming the lockfile
     # is named "Berksfile.lock" is a poor assumption.
     #
-    # @return [Berkshelf::Lockfile]
+    # @return [Lockfile]
     #   the lockfile corresponding to this berksfile, or a new Lockfile if one does
     #   not exist
     def lockfile
@@ -612,8 +651,15 @@ module Berkshelf
 
     private
 
-      def do_upload(cookbooks, options = {})
-        @skipped = []
+      def ridley_upload(cookbooks, options = {})
+        options = {
+          force:          false,
+          freeze:         true,
+          halt_on_frozen: false,
+          validate:       true,
+        }.merge(options)
+
+        skipped = []
 
         Berkshelf.ridley_connection(options) do |conn|
           cookbooks.each do |cookbook|
@@ -629,45 +675,47 @@ module Berkshelf
               })
             rescue Ridley::Errors::FrozenCookbook => ex
               if options[:halt_on_frozen]
-                raise Berkshelf::FrozenCookbook.new(cookbook)
+                raise FrozenCookbook.new(cookbook)
               end
 
               Berkshelf.formatter.skip(cookbook, conn)
-              @skipped << cookbook
+              skipped << cookbook
             end
           end
         end
 
-        unless @skipped.empty?
+        unless skipped.empty?
           Berkshelf.formatter.msg "Skipped uploading some cookbooks because they" <<
             " already exist on the remote server and are frozen. Re-run with the `--force`" <<
             " flag to force overwrite these cookbooks:" <<
             "\n\n" <<
-            "  * " << @skipped.map { |c| "#{c.cookbook_name} (#{c.version})" }.join("\n  * ")
+            "  * " << skipped.map { |c| "#{c.cookbook_name} (#{c.version})" }.join("\n  * ")
         end
       end
 
-      # Filter the cookbooks to upload based on a set of given names. The dependencies of a cookbook
-      # will always be included in the filtered results even if the dependency's name is not
-      # explicitly provided.
+      # Filter the given dependencies for upload. The dependencies of a cookbook
+      # will always be included in the filtered results, even if that
+      # dependency's name is not explicitly provided.
       #
-      # @param [Array<Berkshelf::CachedCookbooks>] cookbooks
-      #   set of cookbooks to filter
-      # @param [Array<String>] names
-      #   names of cookbooks to include in the filtered results
+      # @param [Array<Dependency>] dependencies
+      #   the list of dependencies to filter for upload
       #
-      # @return [Array<Berkshelf::CachedCookbooks]
-      def filter_to_upload(cookbooks, names)
-        unless names.empty?
-          explicit = cookbooks.select { |cookbook| names.include?(cookbook.cookbook_name) }
-          explicit.each do |cookbook|
-            cookbook.dependencies.each do |name, version|
-              explicit += cookbooks.select { |cookbook| cookbook.cookbook_name == name }
+      # @return [Array<CachedCookbook>]
+      #   the cookbook objects for uploading
+      def cookbooks_for_upload(dependencies)
+        dependencies.reduce({}) do |hash, dependency|
+          if hash[dependency.name].nil?
+            # TODO: make this a configurable option for advanced users to save
+            # time.
+            lockfile.graph.find(dependency).dependencies.each do |direct, _|
+              hash[direct] ||= lockfile.retrieve(direct)
             end
+
+            hash[dependency.name] = lockfile.retrieve(dependency)
           end
-          cookbooks = explicit.uniq
-        end
-        cookbooks
+
+          hash
+        end.values
       end
 
       # Ensure the lockfile is present on disk.
@@ -705,7 +753,7 @@ module Berkshelf
       # @return [true]
       def validate_dependencies_installed!
         lockfile.graph.locks.each do |_, dependency|
-          unless dependency.downloaded?
+          unless dependency.installed?
             raise DependencyNotInstalled.new(dependency)
           end
         end
@@ -718,20 +766,20 @@ module Berkshelf
       # @param [Array<String>] names
       #   a list of cookbook names
       #
-      # @raise [Berkshelf::DependencyNotFound]
+      # @raise [DependencyNotFound]
       #   if a cookbook name is given that does not exist
       def validate_cookbook_names!(names)
         missing = names - dependencies.map(&:name)
 
         unless missing.empty?
-          raise Berkshelf::DependencyNotFound.new(missing)
+          raise DependencyNotFound.new(missing)
         end
       end
 
       # Validate that the given cookbook does not have "bad" files. Currently
       # this means including spaces in filenames (such as recipes)
       #
-      # @param [Berkshelf::CachedCookbook] cookbook
+      # @param [CachedCookbook] cookbook
       #  the Cookbook to validate
       def validate_files!(cookbook)
         path = cookbook.path.to_s
@@ -741,7 +789,7 @@ module Berkshelf
           f.gsub(parent, '') =~ /[[:space:]]/
         end
 
-        raise Berkshelf::InvalidCookbookFiles.new(cookbook, files) unless files.empty?
+        raise InvalidCookbookFiles.new(cookbook, files) unless files.empty?
       end
   end
 end