puppet 2.7.26 → 3.0.0.rc4

data/ext/packaging/tasks/build.rake

@@ -1,12 +0,0 @@
-# Perform a build exclusively from a build params file. Requires that the build
-# params file include a setting for task, which is an array of the arguments
-# given to rake originally, including, first, the task name. The params file is
-# always loaded when passed, so these variables are accessible immediately.
-namespace :pl do
-  desc "Build from a build params file"
-  task :build_from_params do
-    check_var('PARAMS_FILE', ENV['PARAMS_FILE'])
-    Pkg::Util::Version.git_co(Pkg::Config.ref)
-    Rake::Task[Pkg::Config.task[:task]].invoke(Pkg::Config.task[:args])
-  end
-end

data/ext/packaging/tasks/clean.rake

@@ -1,5 +0,0 @@
-desc "Clean all built packages, eg rm -rf pkg"
-task :clean do
-  rm_rf 'pkg'
-end
-

data/ext/packaging/tasks/deb.rake

@@ -1,127 +0,0 @@
-require 'pathname'
-
-def pdebuild args
-  results_dir = args[:work_dir]
-  cow         = args[:cow]
-  set_cow_envs(cow)
-  update_cow(cow)
-  sh "pdebuild  --configfile #{Pkg::Config.pbuild_conf} \
-                --buildresult #{results_dir} \
-                --pbuilder cowbuilder -- \
-                --basepath /var/cache/pbuilder/#{cow}/"
-  $?.success? or fail "Failed to build deb with #{cow}!"
-end
-
-def update_cow(cow)
-  ENV['PATH'] = "/usr/sbin:#{ENV['PATH']}"
-  set_cow_envs(cow)
-  retry_on_fail(:times => 3) do
-    sh "sudo -E /usr/sbin/cowbuilder --update --override-config --configfile #{Pkg::Config.pbuild_conf} --basepath /var/cache/pbuilder/#{cow} --distribution #{ENV['DIST']} --architecture #{ENV['ARCH']}"
-  end
-end
-
-def debuild args
-  results_dir = args[:work_dir]
-  begin
-    sh "debuild --no-lintian -uc -us"
-  rescue
-    fail "Something went wrong. Hopefully the backscroll or #{results_dir}/#{Pkg::Config.project}_#{Pkg::Config.debversion}.build file has a clue."
-  end
-end
-
-task :prep_deb_tars, :work_dir do |t,args|
-  work_dir = args.work_dir
-  cp_p "pkg/#{Pkg::Config.project}-#{Pkg::Config.version}.tar.gz", work_dir
-  cd work_dir do
-    sh "tar zxf #{Pkg::Config.project}-#{Pkg::Config.version}.tar.gz"
-    mv "#{Pkg::Config.project}-#{Pkg::Config.version}", "#{Pkg::Config.project}-#{Pkg::Config.debversion}"
-    mv "#{Pkg::Config.project}-#{Pkg::Config.version}.tar.gz", "#{Pkg::Config.project}_#{Pkg::Config.origversion}.orig.tar.gz"
-  end
-
-
-  # This assumes that work_dir is absolute, which I hope is a safe assumption.
-  #
-  # Also, it turns out that invoking 'find' on a directory that doesn't exist
-  # will fail in nasty ways, so we only do this if the target exists...
-  if Pathname('ext/debian').directory?
-    pkg_dir = "#{work_dir}/#{Pkg::Config.project}-#{Pkg::Config.debversion}"
-    cd 'ext' do
-      Pathname('debian').find do |file|
-        case
-        when file.to_s =~ /~$/, file.to_s =~ /^#/
-          next
-        when file.directory?
-          mkdir_p "#{pkg_dir}/#{file}"
-        when file.extname == '.erb'
-          Pkg::Util::File.erb_file(file, "#{pkg_dir}/#{file.sub(/\.[^\.]*$/, '')}", false, :binding => Pkg::Config.get_binding)
-        else
-          cp file, "#{pkg_dir}/#{file}"
-        end
-      end
-    end
-  end
-end
-
-task :build_deb, :deb_command, :cow do |t,args|
-  bench = Benchmark.realtime do
-    deb_build = args.deb_command
-    cow       = args.cow
-    work_dir  = Pkg::Util::File.mktemp
-    subdir    = 'pe/' if Pkg::Config.build_pe
-    dest_dir  = "#{Pkg::Config.project_root}/pkg/#{subdir}deb/#{cow.split('-')[1] unless cow.nil?}"
-    Pkg::Util::Tool.check_tool(deb_build)
-    mkdir_p dest_dir
-    deb_args  = { :work_dir => work_dir, :cow => cow}
-    Rake::Task[:prep_deb_tars].reenable
-    Rake::Task[:prep_deb_tars].invoke(work_dir)
-    cd "#{work_dir}/#{Pkg::Config.project}-#{Pkg::Config.debversion}" do
-      if !File.directory?('debian') and File.directory?('ext/debian')
-        mv 'ext/debian', 'debian'
-      end
-
-      # So this is terrible. It is a hacky hacky bandaid for until this can be
-      # totally refactored into a library with templates drawn entirely from
-      # the tarball. The following two lines are needed because the deb.rake
-      # logic currently re-templates all of the templates in ext/debian for use
-      # in packaging. Then, before the package is built, if the debian
-      # directory doesn't exist (this is really only the case for puppetdb),
-      # the ext/debian directory from the tarball is moved into place. This
-      # breaks ezbake because ezbake maps templates to differently named files
-      # in the tarball templating, but those newly generated templates are
-      # completely ignored without the following two lines that unconditionally
-      # copy anything in ext/debian into the debian directory.
-      mkdir_p 'debian'
-      cp_pr(Dir.glob("ext/debian/*"), 'debian')
-      send(deb_build, deb_args)
-      cp FileList["#{work_dir}/*.deb", "#{work_dir}/*.dsc", "#{work_dir}/*.changes", "#{work_dir}/*.debian.tar.gz", "#{work_dir}/*.orig.tar.gz", "${work_dir}/*.diff.gz"], dest_dir
-      rm_rf "#{work_dir}/#{Pkg::Config.project}-#{Pkg::Config.debversion}"
-      rm_rf work_dir
-    end
-  end
-  puts "Finished building in: #{bench}"
-end
-
-namespace :package do
-  desc "Create a deb from this repo, using debuild (all builddeps must be installed)"
-  task :deb => :tar do
-    Rake::Task[:build_deb].invoke('debuild')
-  end
-end
-
-namespace :pl do
-  desc "Create a deb from this repo using the default cow #{Pkg::Config.default_cow}."
-  task :deb => "package:tar"  do
-    check_var('PE_VER', Pkg::Config.pe_version) if Pkg::Config.build_pe
-    Rake::Task[:build_deb].invoke('pdebuild', Pkg::Config.default_cow)
-  end
-
-  desc "Create debs from this git repository using all cows specified in build_defaults yaml"
-  task :deb_all do
-    check_var('PE_VER', Pkg::Config.pe_version) if Pkg::Config.build_pe
-    Pkg::Config.cows.split(' ').each do |cow|
-      Rake::Task["package:tar"].invoke
-      Rake::Task[:build_deb].reenable
-      Rake::Task[:build_deb].invoke('pdebuild', cow)
-    end
-  end
-end

data/ext/packaging/tasks/deb_repos.rake

@@ -1,128 +0,0 @@
-##
-# Create a debian repository under the standard pkg/ directory layout that the
-# packaging repo creates. The standard layout is pkg/deb/$distribution/files.
-# The repository is created in the 'repos' directory under the jenkins build
-# directories on the distribution server, e.g.
-# /opt/jenkins-builds/$project/$sha/repos. Because we're creating deb
-# repositories on the fly, we have to generate the configuration files as well.
-# We assume every directory under the `deb` directory is named for a
-# distribution, and we use this in creating our configurations.
-#
-namespace :pl do
-  namespace :jenkins do
-    desc "Create apt repositories of build DEB packages for this SHA on the distributions erver"
-    task :deb_repos => "pl:fetch" do
-      prefix = Pkg::Config.build_pe ? "pe/" : ""
-
-      # First, we test that artifacts exist and set up the repos directory
-      artifact_directory = File.join(Pkg::Config.jenkins_repo_path, Pkg::Config.project, Pkg::Config.ref)
-
-      cmd = 'echo " Checking for deb build artifacts. Will exit if not found.." ; '
-      cmd << "[ -d #{artifact_directory}/artifacts/#{prefix}deb ] || exit 1 ; "
-      # Descend into the deb directory and obtain the list of distributions
-      # we'll be building repos for
-      cmd << "pushd #{artifact_directory}/artifacts/#{prefix}deb && dists=$(ls) && popd; "
-      # We do one more check here to make sure we actually have distributions
-      # to build for. If deb is empty we want to just exit.
-      #
-      cmd << '[ -n "$dists" ] || exit 1 ; '
-      cmd << "pushd #{artifact_directory} ; "
-
-      cmd << 'echo "Checking for running repo creation. Will wait if detected." ; '
-      cmd << "while [ -f .lock ] ; do sleep 1 ; echo -n '.' ; done ; "
-      cmd << 'echo "Setting lock" ; '
-      cmd << "touch .lock ; "
-      cmd << "rsync -avxl artifacts/ repos/ ; pushd repos ; "
-
-      # Make the conf directory and write out our configuration file
-      cmd << "rm -rf apt && mkdir -p apt ; pushd apt ; "
-      cmd << 'for dist in $dists ; do mkdir -p $dist/conf ; pushd $dist ;
-      echo "
-Origin: Puppet Labs
-Label: Puppet Labs
-Codename: $dist
-Architectures: i386 amd64
-Components: main
-Description: Apt repository for acceptance testing" >> conf/distributions ; '
-
-      # Create the repositories using reprepro. Since these are for acceptance
-      # testing only, we'll just add the debs and ignore source files for now.
-      #
-      cmd << "reprepro=$(which reprepro) ; "
-      cmd << "$reprepro includedeb $dist ../../#{prefix}deb/$dist/*.deb ; popd ; done ; "
-      cmd << "popd ; popd "
-
-      begin
-        remote_ssh_cmd(Pkg::Config.distribution_server, cmd)
-        # Now that we've created our package repositories, we can generate repo
-        # configurations for use with downstream jobs, acceptance clients, etc.
-        Rake::Task["pl:jenkins:generate_deb_repo_configs"].execute
-
-        # Now that we've created the repo configs, we can ship them
-        Rake::Task["pl:jenkins:ship_repo_configs"].execute
-      ensure
-        # Always remove the lock file, even if we've failed
-        remote_ssh_cmd(Pkg::Config.distribution_server, "rm -f #{artifact_directory}/.lock")
-      end
-
-    end
-
-    # Generate apt configuration files that point to the repositories created
-    # on the distribution server with packages created from the current source
-    # repo commit. There is one for each dist that is packaged for (e.g. lucid,
-    # squeeze, etc). Files are created in pkg/repo_configs/deb and are named
-    # pl-$project-$sha.list, and can be placed in /etc/apt/sources.list.d to
-    # enable clients to install these packages.
-    #
-    desc "Create apt repository configs for package repos for this sha/tag on the distribution server"
-    task :generate_deb_repo_configs => "pl:fetch" do
-
-      # This is the standard path to all debian build artifact repositories on
-      # the distribution server for this commit
-      #
-      base_url = "http://#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repos/apt/"
-
-      # We use wget to obtain a directory listing of what are presumably our deb repos
-      #
-      repo_urls = []
-      wget = Pkg::Util::Tool.find_tool("wget") or fail "Could not find `wget` tool. This is needed for composing the debian repo configurations. Install `wget` and try again."
-      # First test if the directory even exists
-      #
-      wget_results = %x{#{wget} --spider -r -l 1 --no-parent #{base_url} 2>&1}
-      if $?.success?
-        # We want to exclude index and robots files and only include the http: prefixed elements
-        repo_urls = wget_results.split.uniq.reject{|x| x=~ /\?|index|robots/}.select{|x| x =~ /http:/}.map{|x| x.chomp('/')}
-      else
-        fail "No debian repos available for #{Pkg::Config.project} at #{Pkg::Config.ref}."
-      end
-
-      # Create apt sources.list files that can be added to hosts for installing
-      # these packages. We use the list of distributions to create a config
-      # file for every distribution.
-      #
-      mkdir_p File.join("pkg", "repo_configs", "deb")
-      repo_urls.each do |url|
-        # We want to skip the base_url, which wget returns as one of the results
-        next if "#{url}/" == base_url
-        dist = url.split('/').last
-        repoconfig = ["# Packages for #{Pkg::Config.project} built from ref #{Pkg::Config.ref}",
-                      "deb #{url} #{dist} main"]
-        config = File.join("pkg", "repo_configs", "deb", "pl-#{Pkg::Config.project}-#{Pkg::Config.ref}-#{dist}.list")
-        File.open(config, 'w') { |f| f.puts repoconfig }
-      end
-      puts "Wrote apt repo configs for #{Pkg::Config.project} at #{Pkg::Config.ref} to pkg/repo_configs/deb."
-    end
-
-    desc "Retrieve debian apt repository configs for this sha"
-    task :deb_repo_configs => "pl:fetch" do
-      wget = Pkg::Util::Tool.find_tool("wget") or fail "Could not find `wget` tool. This is needed for composing the debian repo configurations. Install `wget` and try again."
-      mkdir_p "pkg/repo_configs"
-      config_url = "#{Pkg::Config.builds_server}/#{Pkg::Config.project}/#{Pkg::Config.ref}/repo_configs/deb/"
-      begin
-        sh "#{wget} -r -np -nH --cut-dirs 3 -P pkg/repo_configs --reject 'index*' #{config_url}"
-      rescue
-        fail "Couldn't retrieve deb apt repo configs. See preceding http response for more info."
-      end
-    end
-  end
-end

data/ext/packaging/tasks/doc.rake

@@ -1,20 +0,0 @@
-# Most projects set rdoc options in the context of gem building. However, mcollective
-# generates its own rdoc package. We can reuse the Pkg::Config.gem_rdoc_options here
-
-if Pkg::Config.build_doc
-  begin
-    require 'rdoc/task'
-  rescue LoadError
-    require 'rake/rdoctask'
-  end
-
-  namespace :package do
-    RDoc::Task.new(:doc) do |rdoc|
-      rdoc.rdoc_dir = 'doc'
-      rdoc.title = "#{Pkg::Config.project} version #{Pkg::Config.version}"
-      Pkg::Config.gem_rdoc_options.each do |option|
-        rdoc.options << option
-      end unless Pkg::Config.gem_rdoc_options.nil?
-    end
-  end
-end

data/ext/packaging/tasks/fetch.rake

@@ -1,58 +0,0 @@
-# Each team has a build-defaults file that specifies local infrastructure targets
-# for things like builders, target locations for build artifacts, etc Since much
-# of these don't change, one file can be maintained for the team.  Each project
-# also has a data file for information specific to it. If the project builds
-# both PE and not PE, it has two files, one for PE, and the other for FOSS
-#
-data_repo = 'https://raw.githubusercontent.com/puppetlabs/build-data'
-project_data_branch = Pkg::Config.project
-team_data_branch = Pkg::Config.team
-
-if Pkg::Config.build_pe
-  project_data_branch = 'pe-' + project_data_branch unless project_data_branch =~ /^pe-/
-  team_data_branch = 'pe-' + team_data_branch unless team_data_branch =~ /^pe-/
-end
-
-project_data_url = data_repo + '/' + project_data_branch
-team_data_url = data_repo + '/' + team_data_branch
-
-
-# The pl:fetch task pulls down two files from the build-data repo that contain additional
-# data specific to Puppet Labs release infrastructure intended to augment/override any
-# defaults specified in the source project repo, e.g. in ext/build_defaults.yaml
-#
-# It uses curl to download the files, and places them in a temporary
-# directory, e.g. /tmp/somedirectory/{project,team}/Pkg::Config.builder_data_file
-namespace :pl do
-  task :fetch do
-    # Remove .packaging directory from old-style extras loading
-    rm_rf "#{ENV['HOME']}/.packaging" if File.directory?("#{ENV['HOME']}/.packaging")
-    # Touch the .packaging file which is allows packaging to present remote tasks
-    touch "#{ENV['HOME']}/.packaging"
-    if dist = Pkg::Util::Version.el_version
-      if dist.to_i < 6
-        flag = "-k"
-      end
-    end
-    [project_data_url, team_data_url].each do |url|
-      begin
-        tempdir = Pkg::Util::File.mktemp
-        %x{curl --fail --silent #{flag} #{url}/#{Pkg::Config.builder_data_file} > #{tempdir}/#{Pkg::Config.builder_data_file}}
-        case $?.exitstatus
-        when 0
-          invoke_task("pl:load_extras", tempdir)
-        when 22
-          if url == team_data_url
-            fail "Could not load team extras data from #{url}. This should not normally happen"
-          else
-            puts "No build data file for #{Pkg::Config.project}, skipping load of extra build data."
-          end
-        else
-          fail "There was an error fetching the builder extras data from #{url}."
-        end
-      ensure
-        rm_rf tempdir
-      end
-    end
-  end
-end

data/ext/packaging/tasks/gem.rake

@@ -1,158 +0,0 @@
-if Pkg::Config.build_gem
-  require 'rubygems/package_task'
-
-  def glob_gem_files
-    gem_files = []
-    gem_excludes_file_list = []
-    gem_excludes_raw = Pkg::Config.gem_excludes.nil? ? [] : Pkg::Config.gem_excludes.split(' ')
-    gem_excludes_raw << 'ext/packaging'
-    gem_excludes_raw.each do |exclude|
-      if File.directory?(exclude)
-        gem_excludes_file_list += FileList["#{exclude}/**/*"]
-      else
-        gem_excludes_file_list << exclude
-      end
-    end
-    files = FileList[Pkg::Config.gem_files.split(' ')]
-    files.each do |file|
-      if File.directory?(file)
-        gem_files += FileList["#{file}/**/*"]
-      else
-        gem_files << file
-      end
-    end
-    gem_files = gem_files - gem_excludes_file_list
-  end
-
-  def add_gem_dependency(opts = {})
-    spec = opts[:spec]
-    version = opts[:version]
-    type = opts[:type].to_s
-    gem = opts[:gem].to_s
-    if opts[:version].nil? or opts[:version].empty?
-      spec.send("add_#{type}_dependency".to_sym, gem)
-    else
-      spec.send("add_#{type}_dependency".to_sym, gem, version)
-    end
-    spec
-  end
-
-  def create_default_gem_spec
-    spec = Gem::Specification.new do |s|
-      s.name = Pkg::Config.project                                     unless Pkg::Config.project.nil?
-      s.name = Pkg::Config.gem_name                                    unless Pkg::Config.gem_name.nil?
-      s.version = Pkg::Config.gemversion                               unless Pkg::Config.gemversion.nil?
-      s.author = Pkg::Config.author                                    unless Pkg::Config.author.nil?
-      s.email = Pkg::Config.email                                      unless Pkg::Config.email.nil?
-      s.homepage = Pkg::Config.homepage                                unless Pkg::Config.homepage.nil?
-      s.summary = Pkg::Config.summary                                  unless Pkg::Config.summary.nil?
-      s.summary = Pkg::Config.gem_summary                              unless Pkg::Config.gem_summary.nil?
-      s.description = Pkg::Config.description                          unless Pkg::Config.description.nil?
-      s.description = Pkg::Config.gem_description                      unless Pkg::Config.gem_description.nil?
-      s.files = glob_gem_files                                         unless glob_gem_files.nil?
-      s.executables = Pkg::Config.gem_executables                      unless Pkg::Config.gem_executables.nil?
-      s.require_path = Pkg::Config.gem_require_path                    unless Pkg::Config.gem_require_path.nil?
-      s.test_files = FileList[Pkg::Config.gem_test_files.split(' ')]   unless Pkg::Config.gem_test_files.nil?
-      s.rubyforge_project = Pkg::Config.gem_forge_project              unless Pkg::Config.gem_forge_project.nil?
-      Pkg::Config.gem_rdoc_options.each do |option|
-        s.rdoc_options << option
-      end unless Pkg::Config.gem_rdoc_options.nil?
-    end
-
-    Pkg::Config.gem_runtime_dependencies.each do |gem, version|
-      spec = add_gem_dependency(:spec => spec, :gem => gem, :version => version, :type => :runtime)
-    end unless Pkg::Config.gem_runtime_dependencies.nil?
-
-    Pkg::Config.gem_development_dependencies.each do |gem, version|
-      spec = add_gem_dependency(:spec => spec, :gem => gem, :version => version, :type => :development)
-    end unless Pkg::Config.gem_development_dependencies.nil?
-    spec
-  end
-
-  def copy_gem_files_into(workdir)
-    # Take all of the gem files (both test and lib), and copy them into the workdir
-    (glob_gem_files + FileList[(Pkg::Config.gem_test_files || '').split(' ')]).each do |file|
-      if File.directory?(file)
-        mkpath(File.join(workdir, file))
-      else
-        mkpath(File.dirname( File.join(workdir, file) ), :verbose => false)
-        cp(file, File.join(workdir, file), :verbose => true, :preserve => false)
-      end
-    end
-  end
-
-  def create_gem(spec, gembuilddir)
-    workdir = File.join(Pkg::Util::File.mktemp)
-    mkpath workdir
-
-    bench = Benchmark.realtime do
-      copy_gem_files_into(workdir)
-
-      # Burn in the version for the project if needed
-      Pkg::Util::Version.versionbump(workdir) if Pkg::Config.update_version_file
-
-      cd workdir do
-        gem_task = Gem::PackageTask.new(spec)
-        gem_task.define
-        Rake::Task[:gem].reenable
-        Rake::Task[:gem].invoke
-        rm_rf File.join("pkg", gembuilddir)
-        mv Dir.glob("pkg/#{Pkg::Config.gem_name}-#{Pkg::Config.gemversion}*.gem"), File.join(Pkg::Config.project_root, "pkg")
-      end
-    end
-
-    rm_rf workdir
-    puts "Finished building in: #{bench}"
-  end
-
-  def create_default_gem
-    spec = create_default_gem_spec
-    create_gem(spec, "#{Pkg::Config.gem_name}-#{Pkg::Config.gemversion}")
-  end
-
-  def unknown_gems_platform?(platform)
-    return true if platform.os == "unknown"
-    false
-  end
-
-  def create_platform_specific_gems
-    Pkg::Config.gem_platform_dependencies.each do |platform, dependency_hash|
-      spec = create_default_gem_spec
-      pf = Gem::Platform.new(platform)
-      fail "
-        Platform: '#{platform}' is not recognized by rubygems.
-        This is probably an erroneous 'gem_platform_dependencies' entry!" if unknown_gems_platform?(pf)
-      spec.platform = pf
-      dependency_hash.each do |type, gems|
-        t = case type
-        when "gem_runtime_dependencies"
-          "runtime"
-        when "gem_development_dependencies"
-          "development"
-        else
-          fail "Platform specific gem dependency type must be 'gem_runtime_dependencies' or 'gem_development_dependencies', not '#{type}'"
-        end
-        gems.each do |gem, version|
-          spec = add_gem_dependency(:spec => spec, :gem => gem, :version => version, :type => t)
-        end
-      end
-      create_gem(spec, "#{Pkg::Config.gem_name}-#{Pkg::Config.gemversion}-#{platform}")
-    end
-  end
-
-  namespace :package do
-    desc "Build a gem - All gems if platform specific"
-    task :gem => [ "clean" ] do
-      mkdir_p File.join(Pkg::Config.project_root, "pkg")
-      create_default_gem
-      if Pkg::Config.gem_platform_dependencies
-        create_platform_specific_gems
-      end
-    end
-  end
-
-  # An alias task to simplify our remote logic in jenkins.rake
-  namespace :pl do
-    task :gem => "package:gem"
-  end
-end