chef 12.9.41-universal-mingw32 → 12.10.24-universal-mingw32

data/tasks/bin/bundle-platform

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+platforms = ARGV.shift
+old_platforms = Gem.platforms
+Gem.platforms = platforms.split(" ").map { |p| Gem::Platform.new(p) }
+puts "bundle-platform set Gem.platforms to #{Gem.platforms.map { |p| p.to_s }} (was #{old_platforms.map { |p| p.to_s } })"
+
+# The rest of this is a normal bundler binstub
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+
+load Gem.bin_path("bundler", "bundle")

data/tasks/bin/bundle-platform.bat

@@ -0,0 +1,2 @@
+@ECHO OFF
+ruby "%~dpn0" %*

data/tasks/bin/create-override-gemfile

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "bundler"
+
+Bundler.with_clean_env do
+  require_relative "../gemfile_util"
+
+  options = {}
+  opts = OptionParser.new do |opts|
+    opts.banner = "Usage: create-override-gemfile [OPTIONS]"
+
+    opts.on("--gemfile GEMFILE", "The Gemfile to read (default: Gemfile).") { |path| options[:gemfile_path] = path }
+    opts.on("--lockfile GEMFILE", "The lockfile to read (default: <gemfile>.lock).") { |path| options[:lockfile_path] = path }
+
+    opts.on("--group GROUP", "Groups to include (whitelist).") do |group|
+      options[:groups] ||= []
+      options[:groups] << group.to_sym
+    end
+
+    opts.on("--without GROUP", "Groups to exclude.") do |group|
+      options[:without_groups] ||= []
+      options[:without_groups] << group.to_sym
+    end
+
+    opts.on("--gem GEM", "Gems to include regardless of groups.") do |name|
+      options[:gems] ||= []
+      options[:gems] << name
+    end
+
+    opts.on("--relative-to PATH", "A path to prepend to any relative paths in the Gemfile.") do |path|
+      unless Pathname.new(path).absolute?
+        puts opts
+        raise "--relative-to #{path} was not an absolute path!"
+      end
+      options[:relative_to] = path
+    end
+
+    opts.on("--[no-]copy-groups", "Whether to copy groups over from the original Gemfile or not (default: false).") { |val| options[:copy_groups] = val }
+
+    opts.on("--[no-]override", "Whether to emit override: true on each gem line (default: false).") { |val| options[:override] = val }
+
+    opts.on("-h", "--help", "Print this message.") do
+      puts opts
+      exit(0)
+    end
+  end
+
+  args = opts.parse(ARGV)
+
+  if args.size > 0
+    puts opts
+    raise "Invalid arguments #{args}"
+  end
+
+  def create_override_gemfile(gemfile_path: "Gemfile", lockfile_path: "#{gemfile_path}.lock", groups: nil, without_groups: nil, gems: [], copy_groups: false, relative_to: ".", override: false)
+    relative_to = Pathname.new(relative_to).realpath
+    # Select the gems we want
+    bundle = GemfileUtil::Bundle.parse(gemfile_path, lockfile_path)
+    gems_to_include = bundle.select_gems(groups: groups, without_groups: without_groups)
+    gems.each do |name|
+      raise "Requested gem #{name} is not in #{gemfile_path}.lock!" if !bundle.gems[name]
+      gems_to_include[name] ||= bundle.gems[name]
+      gems_to_include[name][:dependencies].each do |dep|
+        gems_to_include[name] ||= bundle.gems[dep]
+      end
+    end
+
+    # Add the gems to the Gemfile
+    gem_root = Pathname.new(gemfile_path).dirname.realpath
+    gems_to_include.sort_by { |name, options| options[:declared_groups].empty? ? 1 : 0 }.each do |name, options|
+      comment = nil
+      options = options.dup
+      version = options.delete(:version)
+      if copy_groups
+        # Some dependencies have no groups (are not in the Gemfile--just runtime
+        # dependencies). If we actually record that they have no groups, they
+        # will *always* be installed (or perhaps never). We only want them to
+        # install if their other deps do, so we mark them with the groups of the
+        # things that brought them in (the gems that depended on them). To do
+        # this, we just leave :groups intact.
+        if options[:declared_groups].empty?
+          options.delete(:declared_groups)
+          comment = " # Transitive dependency, not actually in original Gemfile"
+        else
+          # For other things, we want to copy the actual declared_groups--the
+          # ones that were in the Gemfile. We want the same --with and --without
+          # options to include and exclude them as worked with the original
+          # Gemfile.
+          options[:groups] = options.delete(:declared_groups)
+        end
+      else
+        options.delete(:groups)
+        options.delete(:declared_groups)
+      end
+      options.delete(:dependencies)
+      options.delete(:development_dependencies)
+      options[:override] = true if override
+      options[:path] = Pathname.new(options[:path]).expand_path(gem_root).relative_path_from(relative_to).to_s if options[:path]
+      line = "gem #{name.inspect}, #{version.inspect}"
+      options.each do |name, value|
+        line << ", #{name}: #{value.inspect}"
+      end
+      line << comment if comment
+      puts line
+    end
+  end
+
+  create_override_gemfile(options)
+end

data/tasks/bin/run_chef_tests

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Fail fast (e) and echo commands (vx)
+set -evx
+
+echo --color > .rspec
+echo -fp >> .rspec
+
+sudo sed -i -e 's/^Defaults\tsecure_path.*$//' /etc/sudoers;
+# If we have any args, just run the given command
+if [ -n "$1" ]; then
+  sudo -E $(which bundle) exec $@;
+else
+  sudo -E $(which bundle) exec rake spec;
+  bundle exec rake style;
+  bundle exec bundle-audit check --update;
+fi

data/tasks/bin/run_external_test

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+# Fail fast (e) and echo commands (vx)
+set -evx
+
+# Arguments
+TEST_GEM=$1
+shift
+
+PROJECT_ROOT=$(pwd)
+PROJECT_BUNDLE_PATH=${BUNDLE_PATH:-$(grep BUNDLE_PATH: $PROJECT_ROOT/.bundle/config | cut -d' ' -f2-)}
+if [ -n "$PROJECT_BUNDLE_PATH" ]; then
+  PROJECT_BUNDLE_PATH=$PROJECT_ROOT/$PROJECT_BUNDLE_PATH
+fi
+
+TEST_GEM_ROOT=$(bundle show $TEST_GEM)
+
+# Make a copy of the original Gemfile and stitch in our Gemfile.lock
+TEST_GEMFILE=$TEST_GEM_ROOT/Gemfile
+MODIFIED_TEST_GEMFILE=$TEST_GEMFILE.externaltest
+cat <<EOM > $MODIFIED_TEST_GEMFILE
+require_relative "$PROJECT_ROOT/tasks/gemfile_util"
+GemfileUtil.include_locked_gemfile(self, "$PROJECT_ROOT/Gemfile", gems: ["$TEST_GEM"] + "$TEST_WITH_GEMS".split(/\s+/))
+$TEST_GEM_OVERRIDES
+EOM
+cat $TEST_GEMFILE >> $MODIFIED_TEST_GEMFILE
+if [ -f $TEST_GEMFILE.lock ]; then
+  cp $TEST_GEMFILE.lock $MODIFIED_TEST_GEMFILE.lock
+elif [ -f $MODIFIED_TEST_GEMFILE.lock ]; then
+  rm -f $MODIFIED_TEST_GEMFILE.lock
+fi
+
+# Run the bundle install
+cd $TEST_GEM_ROOT
+export BUNDLE_GEMFILE=$MODIFIED_TEST_GEMFILE
+# Don't read from the project .bundle/config, just our env vars
+export BUNDLE_IGNORE_CONFIG=true
+# Use the top level bundle cache so we don't have to reinstall their packages
+if [ -n "$PROJECT_BUNDLE_PATH" ]; then
+  export BUNDLE_PATH=$PROJECT_BUNDLE_PATH
+fi
+export BUNDLE_FROZEN=
+bundle install
+export BUNDLE_FROZEN=true
+
+bundle config
+bundle exec $@

data/tasks/bundle.rb

@@ -0,0 +1,97 @@
+#
+# Copyright:: Copyright (c) 2016 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 "bundle_util"
+require_relative "../version_policy"
+require "fileutils"
+
+desc "Tasks to work with the main Gemfile and Gemfile.<platform>"
+namespace :bundle do
+  desc "Update Gemfile.lock and all Gemfile.<platform>.locks (or one or more gems via bundle:update gem1 gem2 ...)."
+  task :update, [:args] do |t, rake_args|
+    extend BundleUtil
+    args = rake_args[:args] || ""
+    with_bundle_unfrozen do
+      puts ""
+      puts "-------------------------------------------------------------------"
+      puts "Updating Gemfile.lock ..."
+      puts "-------------------------------------------------------------------"
+      bundle "install #{args}", delete_gemfile_lock: true
+      platforms.each do |platform|
+        bundle "lock", platform: platform
+      end
+    end
+  end
+
+  desc "Conservatively update Gemfile.lock and all Gemfile.<platform>.locks"
+  task :install, [:args] do |t, rake_args|
+    extend BundleUtil
+    args = rake_args[:args] || ""
+    with_bundle_unfrozen do
+      puts ""
+      puts "-------------------------------------------------------------------"
+      puts "Updating Gemfile.lock ..."
+      puts "-------------------------------------------------------------------"
+      bundle "install #{args}"
+      platforms.each do |platform|
+        bundle "lock", platform: platform
+      end
+    end
+  end
+
+  # Find out if we're using the latest gems we can (so we don't regress versions)
+  desc "Check for gems that are not at the latest released version, and report if anything not in ACCEPTABLE_OUTDATED_GEMS (version_policy.rb) is out of date."
+  task :outdated do
+    extend BundleUtil
+    puts ""
+    puts "-------------------------------------------------------------------"
+    puts "Checking for outdated gems ..."
+    puts "-------------------------------------------------------------------"
+    # TODO check for outdated windows gems too
+    with_bundle_unfrozen do
+      bundle_outdated = bundle("outdated", extract_output: true)
+      puts bundle_outdated
+      outdated_gems = parse_bundle_outdated(bundle_outdated).map { |line, gem_name| gem_name }
+      # Weed out the acceptable ones
+      outdated_gems = outdated_gems.reject { |gem_name| ACCEPTABLE_OUTDATED_GEMS.include?(gem_name) }
+      if outdated_gems.empty?
+        puts ""
+        puts "SUCCESS!"
+      else
+        raise "ERROR: outdated gems: #{outdated_gems.join(", ")}. Either fix them or add them to ACCEPTABLE_OUTDATED_GEMS in #{__FILE__}."
+      end
+    end
+  end
+end
+
+desc "Run bundle with arbitrary args against the given platform; e.g. rake bundle[show]. No platform to run against the main bundle; bundle[show,windows] to run the windows one; bundle[show,*] to run against all non-default platforms."
+task :bundle, [:args, :platform] do |t, rake_args|
+  extend BundleUtil
+  args = rake_args[:args] || ""
+  platform = rake_args[:platform]
+  with_bundle_unfrozen do
+    if platform == "*"
+      platforms.each do |platform|
+        bundle args, platform: platform
+      end
+    elsif platform
+      bundle args, platform: platform
+    else
+      bundle args
+    end
+  end
+end

data/tasks/bundle_util.rb

@@ -0,0 +1,94 @@
+require "bundler"
+require "shellwords"
+
+module BundleUtil
+  PLATFORMS = { "windows" => %w{ruby x86-mingw32} }
+
+  def project_root
+    File.expand_path("../..", __FILE__)
+  end
+
+  def bundle_platform
+    File.join(project_root, "tasks", "bin", "bundle-platform")
+  end
+
+  # Parse the output of "bundle outdated" and get the list of gems that
+  # were outdated
+  def parse_bundle_outdated(bundle_outdated_output)
+    result = []
+    bundle_outdated_output.each_line do |line|
+      if line =~ /^\s*\* (.+) \(newest ([^,]+), installed ([^,)])*/
+        gem_name, newest_version, installed_version = $1, $2, $3
+        result << [ line, gem_name ]
+      end
+    end
+    result
+  end
+
+  def with_bundle_unfrozen(cwd: nil, leave_frozen: false)
+    bundle "config --delete frozen", cwd: cwd
+    begin
+      yield
+    ensure
+      bundle "config --local frozen 1", cwd: cwd unless leave_frozen
+    end
+  end
+
+  # Run bundle-platform with the given ruby platform(s)
+  def bundle(args, gemfile: nil, platform: nil, cwd: nil, extract_output: false, delete_gemfile_lock: false)
+    args = args.split(/\s+/)
+    if cwd
+      prefix = "[#{cwd}] "
+    end
+    cwd = File.expand_path(cwd || ".", project_root)
+    Bundler.with_clean_env do
+      Dir.chdir(cwd) do
+        gemfile ||= "Gemfile"
+        gemfile = File.expand_path(gemfile, cwd)
+        raise "No platform #{platform} (supported: #{PLATFORMS.keys.join(", ")})" if platform && !PLATFORMS[platform]
+
+        # First delete the gemfile.lock
+        if delete_gemfile_lock
+          if File.exist?("#{gemfile}.lock")
+            puts "Deleting #{gemfile}.lock ..."
+            File.delete("#{gemfile}.lock")
+          end
+        end
+
+        # Run the bundle command
+        ruby_platforms = platform ? PLATFORMS[platform].join(" ") : "ruby"
+        cmd = Shellwords.join([Gem.ruby, "-S", bundle_platform, ruby_platforms, *args])
+        puts "#{prefix}#{Shellwords.join(["bundle", *args])}#{platform ? " for #{platform} platform" : ""}:"
+        with_gemfile(gemfile) do
+          puts "#{prefix}BUNDLE_GEMFILE=#{gemfile}"
+          puts "#{prefix}> #{cmd}"
+          if extract_output
+            `#{cmd}`
+          else
+            unless system(bundle_platform, ruby_platforms, *args)
+              raise "#{bundle_platform} failed: exit code #{$?}"
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def with_gemfile(gemfile)
+    old_gemfile = ENV["BUNDLE_GEMFILE"]
+    ENV["BUNDLE_GEMFILE"] = gemfile
+    begin
+      yield
+    ensure
+      if old_gemfile
+        ENV["BUNDLE_GEMFILE"] = old_gemfile
+      else
+        ENV.delete("BUNDLE_GEMFILE")
+      end
+    end
+  end
+
+  def platforms
+    PLATFORMS.keys
+  end
+end

data/tasks/changelog.rb

@@ -0,0 +1,12 @@
+begin
+  require "github_changelog_generator/task"
+
+  GitHubChangelogGenerator::RakeTask.new :changelog do |config|
+    config.future_release = Chef::VERSION
+    config.enhancement_labels = "enhancement,Enhancement,New Feature,Feature".split(",")
+    config.bug_labels = "bug,Bug,Improvement,Upstream Bug".split(",")
+    config.exclude_labels = "duplicate,question,invalid,wontfix,no_changelog,Exclude From Changelog,Question,Discussion".split(",")
+  end
+rescue LoadError
+  puts "github_changelog_generator is not available. gem install github_changelog_generator to generate changelogs"
+end

data/tasks/dependencies.rb

@@ -0,0 +1,147 @@
+#
+# Copyright:: Copyright (c) 2016 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 "bundle_util"
+require_relative "bundle"
+require_relative "../version_policy"
+
+desc "Tasks to update and check dependencies"
+namespace :dependencies do
+  # Update all dependencies to the latest constraint-matching version
+  desc "Update all dependencies. dependencies:update[conservative] to update as little as possible."
+  task :update, [:conservative] => %w{
+                    dependencies:update_gemfile_lock
+                    dependencies:update_omnibus_overrides
+                    dependencies:update_omnibus_gemfile_lock
+                    dependencies:update_acceptance_gemfile_lock
+                    dependencies:update_kitchen_tests_gemfile_lock
+                    dependencies:update_kitchen_tests_berksfile_lock
+                  }
+
+  desc "Update Gemfile.lock and all Gemfile.<platform>.locks. update_gemfile_lock[conservative] to update as little as possible."
+  task :update_gemfile_lock, [:conservative] do |t, rake_args|
+    conservative = rake_args[:conservative]
+    if conservative
+      Rake::Task["bundle:install"].invoke
+    else
+      Rake::Task["bundle:update"].invoke
+    end
+  end
+
+  def gemfile_lock_task(task_name, dirs: [], other_platforms: true, leave_frozen: true)
+    dirs.each do |dir|
+      desc "Update #{dir}/Gemfile.lock. #{task_name}[conservative] to update as little as possible."
+      task task_name, [:conservative] do |t, rake_args|
+        extend BundleUtil
+        conservative = rake_args[:conservative]
+        puts ""
+        puts "-------------------------------------------------------------------"
+        puts "Updating #{dir}/Gemfile.lock#{conservative ? " (conservatively)" : ""} ..."
+        puts "-------------------------------------------------------------------"
+        with_bundle_unfrozen(cwd: dir, leave_frozen: leave_frozen) do
+          bundle "install", cwd: dir, delete_gemfile_lock: !conservative
+          if other_platforms
+            # Include all other supported platforms into the lockfile as well
+            platforms.each do |platform|
+              bundle "lock", cwd: dir, platform: platform
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def berksfile_lock_task(task_name, dirs: [])
+    dirs.each do |dir|
+      desc "Update #{dir}/Berksfile.lock. #{task_name}[conservative] to update as little as possible."
+      task task_name, [:conservative] do |t, rake_args|
+        extend BundleUtil
+        conservative = rake_args[:conservative]
+        puts ""
+        puts "-------------------------------------------------------------------"
+        puts "Updating #{dir}/Berksfile.lock#{conservative ? " (conservatively)" : ""} ..."
+        puts "-------------------------------------------------------------------"
+        if !conservative && File.exist?("#{project_root}/#{dir}/Berksfile.lock")
+          File.delete("#{project_root}/#{dir}/Berksfile.lock")
+        end
+        Dir.chdir("#{project_root}/#{dir}") do
+          Bundler.with_clean_env do
+            sh "bundle exec berks install"
+          end
+        end
+      end
+    end
+  end
+
+  gemfile_lock_task :update_omnibus_gemfile_lock, dirs: %w{omnibus}
+  gemfile_lock_task :update_acceptance_gemfile_lock, dirs: %w{acceptance},
+                                                     other_platforms: false, leave_frozen: false
+  gemfile_lock_task :update_kitchen_tests_gemfile_lock, dirs: %w{
+    kitchen-tests
+    kitchen-tests/test/integration/webapp/serverspec
+  }
+  berksfile_lock_task :update_kitchen_tests_berksfile_lock, dirs: %w{
+    kitchen-tests
+    kitchen-tests/cookbooks/audit_test
+  }
+  # kitchen-tests/cookbooks/webapp isn't solving right now ....
+
+  desc "Update omnibus overrides, including versions in version_policy.rb and latest version of gems: #{OMNIBUS_RUBYGEMS_AT_LATEST_VERSION.keys}. update_omnibus_overrides[conservative] does nothing."
+  task :update_omnibus_overrides, [:conservative] do |t, rake_args|
+    conservative = rake_args[:conservative]
+    unless conservative
+      puts ""
+      puts "-------------------------------------------------------------------"
+      puts "Updating omnibus_overrides.rb ..."
+      puts "-------------------------------------------------------------------"
+
+      # Generate the new overrides file
+      overrides = "# DO NOT EDIT. Generated by \"rake dependencies\". Edit version_policy.rb instead.\n"
+
+      # Replace the bundler and rubygems versions
+      OMNIBUS_RUBYGEMS_AT_LATEST_VERSION.each do |override_name, gem_name|
+        # Get the latest bundler version
+        puts "Running gem list -r #{gem_name} ..."
+        gem_list = `gem list -r #{gem_name}`
+        unless gem_list =~ /^#{gem_name}\s*\(([^)]*)\)$/
+          raise "gem list -r #{gem_name} failed with output:\n#{gem_list}"
+        end
+
+        # Emit it
+        puts "Latest version of #{gem_name} is #{$1}"
+        overrides << "override #{override_name.inspect}, version: #{$1.inspect}\n"
+      end
+
+      # Add explicit overrides
+      OMNIBUS_OVERRIDES.each do |override_name, version|
+        overrides << "override #{override_name.inspect}, version: #{version.inspect}\n"
+      end
+
+      # Write the file out (if changed)
+      overrides_path = File.expand_path("../../omnibus_overrides.rb", __FILE__)
+      if overrides != IO.read(overrides_path)
+        puts "Overrides changed!"
+        puts `git diff #{overrides_path}`
+        puts "Writing modified #{overrides_path} ..."
+        IO.write(overrides_path, overrides)
+      end
+    end
+  end
+end
+desc "Update all dependencies and check for outdated gems. Call dependencies[conservative] to update as little as possible."
+task :dependencies, [:conservative] => [ "dependencies:update", "bundle:outdated" ]
+task :update, [:conservative] => [ "dependencies:update", "bundle:outdated"]