puppet 2.7.25 → 2.7.26

data/bin/puppet

@@ -1,4 +1,8 @@
 #!/usr/bin/env ruby
 
+# For security reasons, ensure that '.' is not on the load path
+# This is primarily for 1.8.7 since 1.9.2+ doesn't put '.' on the load path
+$LOAD_PATH.delete '.'
+
 require 'puppet/util/command_line'
 Puppet::Util::CommandLine.new.execute

data/ext/build_defaults.yaml

@@ -9,11 +9,11 @@ gpg_name: 'info@puppetlabs.com'
 gpg_key: '4BD6EC30'
 sign_tar: False
 # a space separated list of mock configs
-final_mocks: 'pl-el-5-i386 pl-el-6-i386 pl-fedora-17-i386'
-yum_host: 'burji.puppetlabs.com'
+final_mocks: 'pl-el-5-i386 pl-el-6-i386'
+yum_host: 'yum.puppetlabs.com'
 yum_repo_path: '/opt/repository/yum/'
 build_gem: FALSE
-build_dmg: TRUE
-apt_host: 'burji.puppetlabs.com'
+build_dmg: FALSE
+apt_host: 'apt.puppetlabs.com'
 apt_repo_url: 'http://apt.puppetlabs.com'
 apt_repo_path: '/opt/repository/incoming'

data/ext/debian/control

@@ -3,7 +3,7 @@ Section: admin
 Priority: optional
 Maintainer: Puppet Labs <info@puppetlabs.com>
 Uploaders: Micah Anderson <micah@debian.org>, Andrew Pollock <apollock@debian.org>, Nigel Kersten <nigel@explanatorygap.net>, Stig Sandbeck Mathisen <ssm@debian.org>
-Build-Depends-Indep: ruby1.8, libopenssl-ruby, facter (>= 1.5), facter (<< 2.0)
+Build-Depends-Indep: ruby1.8, libopenssl-ruby, facter (>= 1.5)
 Build-Depends: debhelper (>= 7.0.0), openssl
 Standards-Version: 3.9.1
 Vcs-Git: git://git.debian.org/git/pkg-puppet/puppet.git

data/ext/packaging/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+group :development, :test do
+  gem 'rake', "~> 0.9.6"
+  gem 'rspec', "~> 2.14.1"
+  gem 'pry'
+end
+

data/ext/packaging/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    method_source (0.8.2)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (0.9.6)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    slop (3.4.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  rake (~> 0.9.6)
+  rspec (~> 2.14.1)

data/ext/packaging/README.md

@@ -1,5 +1,7 @@
 #Packaging
 
+[![Build Status](https://travis-ci.org/puppetlabs/packaging.png?branch=master)](https://travis-ci.org/puppetlabs/packaging)
+
 This is a repository for packaging automation for Puppet Labs software.
 The goal is to abstract and automate packaging processes beyond individual
 software projects to a level where this repo can be cloned inside any project
@@ -275,23 +277,32 @@ value, presumably a url to a jenkins job to trigger programmatically.
 
 An important note about `DOWNSTREAM_JOB`: `DOWNSTREAM_JOB` in the dynamic jenkins
 workflow is _always_ invoked if it is passed in as an environment variable.
-However, it is also appended with an additional parameter, `PACKAGE_BUILD_STATUS`,
+However, it is appended with an additional parameter, `PACKAGE_BUILD_STATUS`,
 which will be the string "success" if package and repo builds succeeded, or
 "failure" if package or repo builds failed. By modifying the actual downstream
 jenkins job to accept a string parameter of `PACKAGE_BUILD_STATUS`, one can
 switch on the success or failure of the packaging job, responding
-  appropriately.
+  appropriately. A second parameter, `PACKAGE_BUILD_URL` is also appended to
+  `DOWNSTREAM_JOB`, the value of which is the url of the packaging job itself.
+  This is to assist with tracing failures in a multi-jenkins environment. By
+  modifying the downstream jenkins job to accept a string parameter of
+  `PACKAGE_BUILD_URL`, one can use the value to display the url prominently in
+  case of failure, for example.
 
 E.g., a job url:
 http://jenkins.example.net/job/downstream/buildWithParameters?FOO=bar
 
 in the success case will be transformed into
 
-http://jenkins.example.net/job/downstream/buildWithParameters?FOO=bar&PACKAGE_BUILD_STATUS=success
+http://jenkins.example.net/job/downstream/buildWithParameters?FOO=bar&PACKAGE_BUILD_STATUS=success&PACKAGE_BUILD_URL=http://jenkins.example.net/job/packaging_job
 
 and in the failure case transformed into
 
-http://jenkins.example.net/job/downstream/buildWithParameters?FOO=bar&PACKAGE_BUILD_STATUS=failure
+http://jenkins.example.net/job/downstream/buildWithParameters?FOO=bar&PACKAGE_BUILD_STATUS=failure&PACKAGE_BUILD_URL=http://jenkins.example.net/job/packaging_job
+
+Since jenkins will just drop parameters that are not configured in the job,
+accepting PACKAGE_BUILD_STATUS and PACKAGE_BUILD_URL in the downstream job
+isn't mandatory.
 
 All 3 jobs are configured by default for removal by jenkins after 3 days, to
 avoid clutter.
@@ -390,6 +401,14 @@ default_cow: 'base-squeeze-i386.cow'
 cows: 'base-lucid-amd64.cow base-lucid-i386.cow base-natty-amd64.cow base-natty-i386.cow base-oneiric-amd64.cow base-oneiric-i386.cow base-precise-amd64.cow base-precise-i386.cow base-sid-amd64.cow base-sid-i386.cow base-squeeze-amd64.cow base-squeeze-i386.cow base-testing-amd64.cow base-testing-i386.cow base-wheezy-i386.cow'
 # The pbuilder configuration file to use
 pbuild_conf: '/etc/pbuilderrc'
+# Alternate debian mirrors to build against (must be an array)
+# The __DIST__ string is automatically replaced with codename of the cow being built, so when the squeeze cow is being built the deb_build_mirrors will be:
+# deb http://apt.puppetlabs.com squeeze main dependencies
+# deb http://somethingelse.com/debian squeeze
+# This will happen for each cow during the build.
+deb_build_mirrors:
+  - deb http://apt.puppetlabs.com __DIST__ main dependencies
+  - deb http://somethingelse.com/debian __DIST__
 # Who is packaging. Turns up in various packaging artifacts
 packager: 'puppetlabs'
 # Who is signing packages
@@ -854,6 +873,14 @@ files:
     `ext/project_data.yaml`, as well as whatever is overridden with environment
     variables. Useful for debugging problems with parameter values.
 
+* **pl:print_build_param[param]**
+
+    Print a specific build parameter to STDOUT as it would be used in a package
+    build. This prints data that is loaded from `ext/build_defaults.yaml` and
+    `ext/project_data.yaml`, as well as whatever is overridden with environment
+    variables. Useful for debugging problems with parameter values. param
+    should be the name of the parameter as a symbol, e.g. :ref or :version
+
 * **pl:release_deb**
 
     A composite task of `package:tar`, `pl:deb_all`, `pl:sign_deb_changes`, and

data/ext/packaging/lib/packaging.rb

@@ -0,0 +1,21 @@
+module Pkg
+
+  LIBDIR = File.expand_path(File.dirname(__FILE__))
+
+  $:.unshift(LIBDIR) unless
+    $:.include?(File.dirname(__FILE__)) || $:.include?(LIBDIR)
+
+  require 'packaging/util'
+  require 'packaging/config'
+  require 'packaging/tar'
+
+  # Load configuration defaults
+  Pkg::Config.load_defaults
+  Pkg::Config.load_default_configs
+  Pkg::Config.load_versioning
+  Pkg::Config.load_overrides
+  Pkg::Config.load_envvars
+  Pkg::Config.issue_reassignments
+  Pkg::Config.issue_deprecations
+end
+

data/ext/packaging/lib/packaging/config.rb

@@ -0,0 +1,277 @@
+module Pkg
+  ##
+  #   This class is meant to encapsulate all of the data we know about a build invoked with
+  #   `rake package:<build>` or `rake pl:<build>`. It can read in this data via a yaml file,
+  #   have it set via accessors, and serialize it back to yaml for easy transport.
+  #
+  class Config
+    require 'packaging/config/params.rb'
+    require 'yaml'
+
+    class << self
+
+      #   Every element in Pkg::Params::BUILD_PARAMS is a configurable setting
+      #   for the build. We use Pkg::Params::BUILD_PARAMS as the source of
+      #   truth for defining the the class instance variables and their
+      #   accessors of the Pkg::Config class
+      Pkg::Params::BUILD_PARAMS.each do |v|
+        attr_accessor v
+      end
+
+      #   Return the binding of class context. Used for erb templates.
+      #
+      def get_binding
+        return binding
+      end
+
+      ##
+      #   Take a hash of Config parameters, and iterate over them, setting the
+      #   value for each Config param to the corresponding hash key,value.
+      #
+      def config_from_hash(data = {})
+        data.each do |param, value|
+          if Pkg::Params::BUILD_PARAMS.include?(param.to_sym)
+            self.instance_variable_set("@#{param}", value)
+          else
+            warn "Warning - No build data parameter found for '#{param}'. Perhaps you have an erroneous entry in your yaml file?"
+          end
+        end
+      end
+
+      ##
+      # Load a yaml file and use its contents to set the values for Pkg::Config
+      # class instance variables
+      #
+      def config_from_yaml(file)
+        build_data = Pkg::Util::Serialization.load_yaml(file)
+        config_from_hash(build_data)
+      end
+
+      ##
+      # By default return a hash of the names, values of current Pkg::Config
+      # instance variables. With :format => :yaml, write a yaml file containing
+      # the current names,values of Pkg::Config class instance variables
+      #
+      def config(args={:target => nil, :format => :hash})
+        case args[:format]
+          when :hash
+            self.config_to_hash
+          when :yaml
+            self.config_to_yaml(args[:target])
+        end
+      end
+
+      ##
+      # Return a hash of all build parameters and their values, nil if unassigned.
+      #
+      def config_to_hash
+        data = {}
+        Pkg::Params::BUILD_PARAMS.each do |param|
+          data.store(param, self.instance_variable_get("@#{param}"))
+        end
+        data
+      end
+
+      ##
+      # Write all build parameters to a yaml file, either one specified or in a
+      # temporary location. Print the path to the file and return it as a
+      # string. Accept an argument for the write target file. If not specified,
+      # the name of the params file is the current git commit sha or tag.
+      #
+      def config_to_yaml(target=nil)
+        file = "#{self.ref}.yaml"
+        target = target.nil? ? File.join(Pkg::Util::File.mktemp, "#{self.ref}.yaml") : File.join(target, file)
+        Pkg::Util::File.file_writable?(File.dirname(target), :required => true)
+        File.open(target, 'w') do |f|
+          f.puts self.config_to_hash.to_yaml
+        end
+        puts target
+        target
+      end
+
+      ##
+      # Print the names and values of all the params known to the build object
+      #
+      def print_config
+        self.config_to_hash.each { |k,v| puts "#{k}: #{v}" }
+      end
+
+      ##
+      # Return the names of all of the cows for the project, taking off the
+      # base prefix, the architecture, and the .cow suffix. This is helpful in
+      # the debian changelog.
+      #
+      def cow_list
+        self.cows.split(' ').map do
+          |cow| cow.split('-')[1]
+        end.uniq.join(' ')
+      end
+
+      def default_project_root
+        # It is really quite unsafe to assume github.com/puppetlabs/packaging has been
+        # cloned into $project_root/ext/packaging even if it has _always_ been the
+        # default location. We really don't have much choice as of this moment but to
+        # assume this directory, or assume the user has passed in the correct one via
+        # ENV['PROJECT_ROOT']. It is critical we have the correct $project_root, because
+        # we get all of the package versioning from the `git-describe` of $project. If we
+        # assume $project/ext/packaging, it means packaging/lib/packaging.rb is
+        # three subdirectories below $project_root, e.g.,
+        # $project_root/ext/packaging/lib/packaging.rb.
+        #
+        ENV['PROJECT_ROOT'] || File.expand_path(File.join(LIBDIR, "..","..",".."))
+      end
+
+      def default_packaging_root
+        # It is really quite unsafe to assume github.com/puppetlabs/packaging has been
+        # cloned into $project_root/ext/packaging even if it has _always_ been the
+        # default location. Here we use the PACKAGING_ROOT constant defined in
+        # packaging.rake if it is available, or use the parent directory of the
+        # current file as the packaging_root.
+        #
+        defined?(PACKAGING_ROOT) ? File.expand_path(PACKAGING_ROOT) : File.expand_path(File.join(LIBDIR, ".."))
+      end
+
+      def load_default_configs
+        default_project_data = File.join(@project_root, "ext", "project_data.yaml")
+        default_build_defaults = File.join(@project_root, "ext", "build_defaults.yaml")
+
+        [default_project_data, default_build_defaults].each do |config|
+          if File.readable? config
+            self.config_from_yaml(config)
+          else
+            puts "Skipping load of expected default config #{config}, cannot read file."
+            #   Since the default configuration files are not readable, most
+            #   likely not present, at this point we assume the project_root
+            #   isn't what we hoped it would be, and unset it.
+            @project_root = nil
+          end
+        end
+
+        if @project_root
+          self.config
+        end
+      end
+
+      #   Set all aspects of how the package will be versioned. Versioning
+      #   relies exclusively on the git describe of the project, which will
+      #   fail if either Pkg::Config.project_root is nil, isn't in a git repo,
+      #   or is in a git repo, but there are no tags in the repo, in which case
+      #   git-describe will fail.
+      #
+      #   It probably seems odd to load packaging-specific version
+      #   determinations, such as rpmversion here, at the top-level, and it is.
+      #   The reason for this that the creation of the most basic package
+      #   composition, the tarball, includes the generation of many different
+      #   packaging-specific files from templates in the source, and if faced
+      #   with loading rpmversion in the Tar object vs rpmversion in the
+      #   Config, I opt for the latter. It's basically a lose-lose, since it
+      #   really belongs in the Rpm object.
+
+      def load_versioning
+        if @project_root and Pkg::Util::Version.git_tagged?
+          @ref         = Pkg::Util::Version.git_sha_or_tag
+          @version     = Pkg::Util::Version.get_dash_version
+          @gemversion  = Pkg::Util::Version.get_dot_version
+          @ipsversion  = Pkg::Util::Version.get_ips_version
+          @debversion  = Pkg::Util::Version.get_debversion
+          @origversion = Pkg::Util::Version.get_origversion
+          @rpmversion  = Pkg::Util::Version.get_rpmversion
+          @rpmrelease  = Pkg::Util::Version.get_rpmrelease
+        else
+          puts "Skipping determination of version via git describe, Pkg::Config.project_root is not set to the path of a tagged git repo."
+        end
+      end
+
+      ##
+      #   Since we're dealing with rake, much of the parameter override support
+      #   is via environment variables passed on the command line to a rake task.
+      #   These override any existing values of Pkg::Config class instance
+      #   variables
+      #
+      def load_envvars
+        Pkg::Params::ENV_VARS.each do |v|
+          if var = ENV[v[:envvar].to_s]
+            if v[:type] == :bool
+              self.instance_variable_set("@#{v[:var]}", Pkg::Util.boolean_value(var))
+            else
+              self.instance_variable_set("@#{v[:var]}", var)
+            end
+          end
+        end
+      end
+
+      ##
+      #   We supply several values by default, if they haven't been specified
+      #   already by config or environment variable. This includes the project
+      #   root as the default project root, which is relative to the
+      #   packaging path
+      #
+      def load_defaults
+        @project_root   ||= default_project_root
+        @packaging_root ||= default_packaging_root
+
+        Pkg::Params::DEFAULTS.each do |v|
+          unless self.instance_variable_get("@#{v[:var]}")
+            self.instance_variable_set("@#{v[:var]}", v[:val])
+          end
+        end
+      end
+
+      ##
+      #
+      #   Several workflows rely on being able to supply an optional yaml
+      #   parameters file that overrides all set values with its data. This has
+      #   always been supplied as an environment variable, "PARAMS_FILE." To
+      #   honor this, we have a method in config to override values as
+      #   expected. There is, however, a twist - it is absolutely essential
+      #   that the overrides do not override the project_root or packaging_root
+      #   settings, because this is environment-specific, and any value in a
+      #   params file is going to be wrong. Thus, if we have a project root or
+      #   packaging root before we begin overriding, we save it and restore it
+      #   after overrides.
+      #
+      def load_overrides
+        if ENV['PARAMS_FILE'] && ENV['PARAMS_FILE'] != ''
+          if File.readable?(ENV['PARAMS_FILE'])
+            project_root = self.instance_variable_get("@project_root")
+            packaging_root = self.instance_variable_get("@packaging_root")
+            self.config_from_yaml(ENV['PARAMS_FILE'])
+            self.instance_variable_set("@project_root", project_root) if project_root
+            self.instance_variable_set("@packaging_root", packaging_root) if packaging_root
+          else
+            fail "PARAMS_FILE was set, but not to the path to a readable file."
+          end
+        end
+      end
+
+      ##
+      #   We also have renamed various variables as part of deprecations, and
+      #   if any of these are still in use, we want to assign the values to the
+      #   new variables. However, we skip this if they target variable is already
+      #   populated, to avoid overwriting in the case that the user has started
+      #   by populating the new variable name but left the old crufty one behind.
+      #
+      def issue_reassignments
+        Pkg::Params::REASSIGNMENTS.each do |v|
+          oldval = self.instance_variable_get("@#{v[:oldvar]}")
+          newval = self.instance_variable_get("@#{v[:newvar]}")
+          if newval.nil? and not oldval.nil?
+            self.instance_variable_set("@#{v[:newvar]}", oldval)
+          end
+        end
+      end
+
+      ##
+      #   Quite a few variables we also want to issue custom warnings about.
+      #   These are they.
+      #
+      def issue_deprecations
+        Pkg::Params::DEPRECATIONS.each do |v|
+          if self.instance_variable_get("@#{v[:var]}")
+            warn v[:message]
+          end
+        end
+      end
+    end
+  end
+end

data/ext/packaging/lib/packaging/config/params.rb

@@ -0,0 +1,175 @@
+# These are all of the parameters known to our packaging system.
+# They are ingested by the config class as class instance variables
+module Pkg::Params
+  BUILD_PARAMS = [:apt_host,
+                  :apt_repo_path,
+                  :apt_repo_url,
+                  :author,
+                  :benchmark,
+                  :build_date,
+                  :build_defaults,
+                  :build_dmg,
+                  :build_doc,
+                  :build_gem,
+                  :build_ips,
+                  :build_pe,
+                  :builder_data_file,
+                  :builds_server,
+                  :bundle_platforms,
+                  :certificate_pem,
+                  :cows,
+                  :db_table,
+                  :deb_build_host,
+                  :deb_build_mirrors,
+                  :debversion,
+                  :debug,
+                  :default_cow,
+                  :default_mock,
+                  :description,
+                  :distribution_server,
+                  :dmg_path,
+                  :email,
+                  :files,
+                  :final_mocks,
+                  :freight_conf,
+                  :gem_default_executables,
+                  :gem_dependencies,
+                  :gem_description,
+                  :gem_devel_dependencies,
+                  :gem_development_dependencies,
+                  :gem_excludes,
+                  :gem_executables,
+                  :gem_files,
+                  :gem_forge_project,
+                  :gem_name,
+                  :gem_platform_dependencies,
+                  :gem_rdoc_options,
+                  :gem_require_path,
+                  :gem_runtime_dependencies,
+                  :gem_summary,
+                  :gem_test_files,
+                  :gemversion,
+                  :gpg_key,
+                  :gpg_name,
+                  :homepage,
+                  :ips_build_host,
+                  :ips_host,
+                  :ips_inter_cert,
+                  :ips_package_host,
+                  :ips_path,
+                  :ips_repo,
+                  :ips_store,
+                  :ipsversion,
+                  :jenkins_build_host,
+                  :jenkins_packaging_job,
+                  :jenkins_repo_path,
+                  :metrics,
+                  :metrics_url,
+                  :name,
+                  :notify,
+                  :project,
+                  :origversion,
+                  :osx_build_host,
+                  :packager,
+                  :packaging_repo,
+                  :packaging_root,
+                  :packaging_url,
+                  :pbuild_conf,
+                  :pe_name,
+                  :pe_version,
+                  :pg_major_version,
+                  :pre_tar_task,
+                  :pre_tasks,
+                  :privatekey_pem,
+                  :project_root,
+                  :random_mockroot,
+                  :rc_mocks,
+                  :redis_hostname,
+                  :release,
+                  :rpm_build_host,
+                  :rpmrelease,
+                  :rpmversion,
+                  :ref,
+                  :sign_tar,
+                  :summary,
+                  :tar_excludes,
+                  :tar_host,
+                  :tarball_path,
+                  :task,
+                  :team,
+                  :templates,
+                  :update_version_file,
+                  :version,
+                  :version_file,
+                  :version_strategy,
+                  :yum_host,
+                  :yum_repo_path]
+
+  # Environment variable overrides for Pkg::Config parameters
+  #
+  #           :var  => :config_param,    :envvar => :environment var :type => :variable type
+  #
+  #           Note: :type is assumed :string if not present
+  #
+  ENV_VARS = [{:var => :apt_host,            :envvar => :APT_HOST},
+              {:var => :apt_repo_path,       :envvar => :APT_REPO},
+              {:var => :build_dmg,           :envvar => :DMG,             :type => :bool},
+              {:var => :build_doc,           :envvar => :DOC,             :type => :bool},
+              {:var => :build_gem,           :envvar => :GEM,             :type => :bool},
+              {:var => :build_ips,           :envvar => :IPS,             :type => :bool},
+              {:var => :build_pe,            :envvar => :PE_BUILD,        :type => :bool},
+              {:var => :certificate_pem,     :envvar => :CERT_PEM},
+              {:var => :cows,                :envvar => :COW},
+              {:var => :debug,               :envvar => :DEBUG,           :type => :bool},
+              {:var => :default_cow,         :envvar => :COW},
+              {:var => :default_mock,        :envvar => :MOCK},
+              {:var => :final_mocks,         :envvar => :MOCK},
+              {:var => :gpg_name,            :envvar => :GPG_NAME},
+              {:var => :gpg_key,             :envvar => :GPG_KEY},
+              {:var => :notify,              :envvar => :NOTIFY},
+              {:var => :packager,            :envvar => :PACKAGER},
+              {:var => :pbuild_conf,         :envvar => :PBUILDCONF},
+              {:var => :pe_version,          :envvar => :PE_VER},
+              {:var => :privatekey_pem,      :envvar => :PRIVATE_PEM},
+              {:var => :project_root,        :envvar => :PROJECT_ROOT},
+              {:var => :random_mockroot,     :envvar => :RANDOM_MOCKROOT, :type => :bool},
+              {:var => :rc_mocks,            :envvar => :MOCK},
+              {:var => :release,             :envvar => :RELEASE},
+              {:var => :sign_tar,            :envvar => :SIGN_TAR,        :type => :bool},
+              {:var => :team,                :envvar => :TEAM},
+              {:var => :update_version_file, :envvar => :NEW_STYLE_PACKAGE},
+              {:var => :yum_repo_path,       :envvar => :YUM_REPO},
+              {:var => :yum_host,            :envvar => :YUM_HOST}]
+  # Default values that are supplied if the user does not supply them
+  #
+  # usage is the same as above
+  #
+  DEFAULTS = [{:var => :builder_data_file, :val => 'builder_data.yaml'},
+              {:var => :team,              :val => 'dev'},
+              {:var => :random_mockroot,   :val => true},
+              {:var => :keychain_loaded,   :val => false},
+              {:var => :build_date,        :val => Pkg::Util::Date.timestamp('-')},
+              {:var => :release,           :val => '1'}]
+
+  # These are variables which, over time, we decided to rename or replace. For
+  # backwards compatibility, we assign the value of the old/deprecated
+  # variables, if set, to the new ones. We also use this method for accessor
+  # "redirects" - e.g. defaulting the populated value of one parameter for another
+  # in case it is not set.
+  #
+  REASSIGNMENTS = [{:oldvar => :name,                   :newvar => :project},
+                   {:oldvar => :yum_host,               :newvar => :tar_host},
+                   {:oldvar => :gem_devel_dependencies, :newvar => :gem_development_dependencies},
+                   {:oldvar => :pe_name,                :newvar => :project},
+                   {:oldvar => :project,                :newvar => :gem_name}]
+
+  # These are variables that we have deprecated. If they are encountered in a
+  # project's config, we issue deprecations for them.
+  #
+  DEPRECATIONS = [{:var => :gem_devel_dependencies, :message => "
+    DEPRECATED, 9-Nov-2013: 'gem_devel_dependencies' has been replaced with
+    'gem_development_dependencies.' Please update this field in your
+    project_data.yaml"}]
+
+end
+