puppet 2.7.20 → 2.7.21

data/ext/packaging/tasks/fetch.rake

@@ -1,21 +1,46 @@
-if @build_pe
-  pl_packaging_url = "https://raw.github.com/puppetlabs/build-data/#{@team}"
-else
-  pl_packaging_url = "https://raw.github.com/puppetlabs/build-data/#{@name}"
+# 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.github.com/puppetlabs/build-data'
+project_data_branch = @build.project
+team_data_branch = @build.team
+
+if @build.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
 
-# The pl:fetch task pulls down a file from the build-data repo that contains additional
+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 file, and places it in a hidden directory in the home
-# directory, e.g. ~/.packaging/@builder_data_file
+# It uses curl to download the files, and places them in a temporary
+# directory, e.g. /tmp/somedirectory/{project,team}/@build.builder_data_file
 namespace :pl do
   task :fetch do
-    rm_rf "#{ENV['HOME']}/.packaging"
-    mkdir_p "#{ENV['HOME']}/.packaging"
+    # 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"
+    tempdir = get_temp
+    mkdir_pr("#{tempdir}/team", "#{tempdir}/project")
     begin
-      sh "curl #{pl_packaging_url}/#{@builder_data_file} > #{ENV['HOME']}/.packaging/#{@builder_data_file}"
+      if dist = el_version
+        if dist.to_i < 6
+          flag = "-k"
+        end
+      end
+      sh "curl #{flag} #{project_data_url}/#{@build.builder_data_file} > #{tempdir}/project/#{@build.builder_data_file}"
+      sh "curl #{flag} #{team_data_url}/#{@build.builder_data_file} > #{tempdir}/team/#{@build.builder_data_file}"
+      invoke_task("pl:load_extras", tempdir)
+      rm_rf(tempdir)
     rescue
       STDERR.puts "There was an error fetching the builder extras data."
       exit 1

data/ext/packaging/tasks/gem.rake

@@ -1,10 +1,10 @@
-if @build_gem
+if @build.build_gem
   require 'rubygems/package_task'
 
   def glob_gem_files
     gem_files = []
     gem_excludes_file_list = []
-    gem_excludes_raw = @gem_excludes.nil? ? [] : @gem_excludes.split(' ')
+    gem_excludes_raw = @build.gem_excludes.nil? ? [] : @build.gem_excludes.split(' ')
     gem_excludes_raw << 'ext/packaging'
     gem_excludes_raw.each do |exclude|
       if File.directory?(exclude)
@@ -13,7 +13,7 @@ if @build_gem
         gem_excludes_file_list << exclude
       end
     end
-    files = FileList[@gem_files.split(' ')]
+    files = FileList[@build.gem_files.split(' ')]
     files.each do |file|
       if File.directory?(file)
         gem_files += FileList["#{file}/**/*"]
@@ -25,44 +25,55 @@ if @build_gem
   end
 
   spec = Gem::Specification.new do |s|
-    s.name = @name                                        unless @name.nil?
-    s.name = @gem_name                                    unless @gem_name.nil?
-    s.version = @gemversion                               unless @gemversion.nil?
-    s.author = @author                                    unless @author.nil?
-    s.email = @email                                      unless @email.nil?
-    s.homepage = @homepage                                unless @homepage.nil?
-    s.summary = @summary                                  unless @summary.nil?
-    s.summary = @gem_summary                              unless @gem_summary.nil?
-    s.description = @description                          unless @description.nil?
-    s.description = @gem_description                      unless @gem_description.nil?
-    s.files = glob_gem_files                              unless glob_gem_files.nil?
-    s.executables = @gem_executables                      unless @gem_executables.nil?
-    s.require_path = @gem_require_path                    unless @gem_require_path.nil?
-    s.test_files = FileList[@gem_test_files.split(' ')]   unless @gem_test_files.nil?
-    s.rubyforge_project = @gem_forge_project              unless @gem_forge_project.nil?
+    s.name = @build.project                                     unless @build.project.nil?
+    s.name = @build.gem_name                                    unless @build.gem_name.nil?
+    s.version = @build.gemversion                               unless @build.gemversion.nil?
+    s.author = @build.author                                    unless @build.author.nil?
+    s.email = @build.email                                      unless @build.email.nil?
+    s.homepage = @build.homepage                                unless @build.homepage.nil?
+    s.summary = @build.summary                                  unless @build.summary.nil?
+    s.summary = @build.gem_summary                              unless @build.gem_summary.nil?
+    s.description = @build.description                          unless @build.description.nil?
+    s.description = @build.gem_description                      unless @build.gem_description.nil?
+    s.files = glob_gem_files                                    unless glob_gem_files.nil?
+    s.executables = @build.gem_executables                      unless @build.gem_executables.nil?
+    s.require_path = @build.gem_require_path                    unless @build.gem_require_path.nil?
+    s.test_files = FileList[@build.gem_test_files.split(' ')]   unless @build.gem_test_files.nil?
+    s.rubyforge_project = @build.gem_forge_project              unless @build.gem_forge_project.nil?
 
-    @gem_runtime_dependencies.each do |gem, version|
+    @build.gem_runtime_dependencies.each do |gem, version|
       s.add_runtime_dependency("#{gem}", "#{version}") unless (version.nil? or version.empty?)
       s.add_runtime_dependency("#{gem}") if (version.nil? or version.empty?)
-    end unless @gem_runtime_dependencies.nil?
+    end unless @build.gem_runtime_dependencies.nil?
 
-    @gem_devel_dependencies.each do |gem, version|
+    @build.gem_devel_dependencies.each do |gem, version|
       s.add_devel_dependency("#{gem}", "#{version}") unless (version.nil? or version.empty?)
       s.add_devel_dependency("#{gem}") if (version.nil? or version.empty?)
-    end unless @gem_devel_dependencies.nil?
+    end unless @build.gem_devel_dependencies.nil?
 
-    @gem_rdoc_options.each do |option|
+    @build.gem_rdoc_options.each do |option|
       s.rdoc_options << option
-    end unless @gem_rdoc_options.nil?
+    end unless @build.gem_rdoc_options.nil?
   end
 
   namespace :package do
     gem_task = Gem::PackageTask.new(spec)
     desc "Build a gem"
     task :gem => [ "clean" ] do
-      gem_task.define
-      Rake::Task[:gem].invoke
-      rm_rf "pkg/#{@name}-#{@gemversion}"
+      bench = Benchmark.realtime do
+        gem_task.define
+        Rake::Task[:gem].invoke
+        rm_rf "pkg/#{@build.project}-#{@build.gemversion}"
+      end
+      if @build.benchmark
+        add_metrics({ :dist => 'gem', :bench => bench })
+        post_metrics
+      end
     end
   end
+
+  # An alias task to simplify our remote logic in jenkins.rake
+  namespace :pl do
+    task :gem => "package:gem"
+  end
 end

data/ext/packaging/tasks/ips.rake

@@ -7,7 +7,7 @@ if @build_ips
       repo = workdir + '/repo'
       pkgs = 'pkg/ips/pkgs'
       repouri = 'file://' + Dir.pwd + '/' + repo
-      artifact = pkgs + "/#{@name}@#{@ipsversion}.p5p"
+      artifact = pkgs + "/#{@build.project}@#{@build.ipsversion}.p5p"
 
       # Create a source repo
       # We dont clean the base pkg directory only ips work dir.
@@ -27,34 +27,34 @@ if @build_ips
 
       # Process templates and write the initial manifest
       task :prototmpl do
-        erb("ext/ips/#{@name}.p5m.erb", workdir + '/' + @name + '.p5m.x')
+        erb("ext/ips/#{@build.project}.p5m.erb", workdir + '/' + @build.project + '.p5m.x')
       end
 
       # Update manifest to include the installation image information.
       task :protogen => :prototmpl do
-        sh "pkgsend generate #{proto} >> #{workdir}/#{@name}.p5m.x"
+        sh "pkgsend generate #{proto} >> #{workdir}/#{@build.project}.p5m.x"
       end
 
       # Generate and resolve dependency list
       task :protodeps => :protogen do
-        sh "pkgdepend generate -d #{proto} #{workdir}/#{@name}.p5m.x > #{workdir}/#{@name}.depends"
-        sh "pkgdepend resolve -m #{workdir}/#{@name}.depends"
-        sh "cat #{workdir}/#{@name}.depends.res >> #{workdir}/#{@name}.p5m.x"
+        sh "pkgdepend generate -d #{proto} #{workdir}/#{@build.project}.p5m.x > #{workdir}/#{@build.project}.depends"
+        sh "pkgdepend resolve -m #{workdir}/#{@build.project}.depends"
+        sh "cat #{workdir}/#{@build.project}.depends.res >> #{workdir}/#{@build.project}.p5m.x"
       end
 
       # Mogrify manifest to remove unncecessary info, and other kinds of transforms.
       task :protomogrify => :protodeps do
-        sh "pkgmogrify ./ext/ips/transforms ./#{workdir}/#{@name}.p5m.x| pkgfmt >> #{workdir}/#{@name}.p5m"
+        sh "pkgmogrify ./ext/ips/transforms ./#{workdir}/#{@build.project}.p5m.x| pkgfmt >> #{workdir}/#{@build.project}.p5m"
       end
 
       # Generate and resolve dependency list
       task :license => :protomogrify do
-        cp 'LICENSE', "#{proto}/#{@name}.license"
+        cp 'LICENSE', "#{proto}/#{@build.project}.license"
       end
 
       # Ensure that our manifest is sane.
       task :lint => :license do
-        print %x{pkglint #{workdir}/#{@name}.p5m}
+        print %x{pkglint #{workdir}/#{@build.project}.p5m}
       end
 
       task :package => [:clean_pkgs, :clean, :prepare, :lint] do
@@ -71,18 +71,18 @@ if @build_ips
       # Send a created package to the local IPS repository
       task :send do
         check_tool('pkgsend')
-        sh "pkgsend -s #{repouri} publish -d #{proto} --fmri-in-manifest #{workdir}/#{@name}.p5m"
+        sh "pkgsend -s #{repouri} publish -d #{proto} --fmri-in-manifest #{workdir}/#{@build.project}.p5m"
       end
 
       # Retrieve the package from the remote repository in .p5p archive format
       task :receive do
         check_tool('pkgrecv')
-        sh "pkgrecv -s #{repouri} -a -d #{artifact} #{@name}@#{@ipsversion}"
+        sh "pkgrecv -s #{repouri} -a -d #{artifact} #{@build.project}@#{@build.ipsversion}"
       end
 
 
       task :dry_install do
-        sh "pkg install -nv -g #{artifact} #{@name}@#{@ipsversion}"
+        sh "pkg install -nv -g #{artifact} #{@build.project}@#{@build.ipsversion}"
       end
 
       task :p5p, :sign_ips do |t, args|
@@ -100,7 +100,7 @@ if @build_ips
         # publish the package to the repository
         Rake::Task['package:ips:send'].invoke
         # signing the package occurs remotely in the repository
-        Rake::Task['pl:sign_ips'].invoke(repouri,"#{@name}@#{@ipsversion}") if sign_ips
+        Rake::Task['pl:sign_ips'].invoke(repouri,"#{@build.project}@#{@build.ipsversion}") if sign_ips
         # retrieve the signed package in a .p5p archive file format
         Rake::Task['package:ips:receive'].invoke
         # clean up the workdir area
@@ -115,7 +115,7 @@ if @build_ips
 
   namespace :pl do
     desc "Create and sign a p5p archive package from this repository"
-    task :ips => ['pl:fetch', 'pl:load_extras'] do
+    task :ips => 'pl:fetch' do
       Rake::Task['package:ips:p5p'].reenable
       Rake::Task['package:ips:p5p'].invoke(TRUE)
     end

data/ext/packaging/tasks/jenkins.rake

@@ -0,0 +1,337 @@
+##
+# The jenkins tasks enable the packaging repo to kick off packaging builds on a
+# remote jenkins slave. They work in a similar way to the :remote tasks, but
+# with a few key differences. The jenkins tasks transmit information to a
+# jenkins coordinator, which handles the rest. The data passed are the
+# following:
+#
+# 1) $PROJECT_BUNDLE - a tar.gz of a git-bundle from HEAD of the current
+#    project, which is cloned on the builder to set up a duplicate of this
+#    environment
+#
+# 2) $BUILD_PROPERTIES - a build parameters file, containing all information about the build
+#
+# 3) $BUILD_TYPE - the "type" of build, e.g. rpm, deb, gem, etc The jenkins url and job name
+#    are obtained via the team build-data file at
+#    git@github.com/puppetlabs/build-data
+#
+# 4) $PROJECT - the project we're building, e.g. facter, puppet. This is used later in
+#    determining the target for the build artifacts on the distribution server
+#
+# On the Jenkins end, the job is a parameterized job that accepts four
+# parameters. Jenkins has the Parameterized Trigger Plugin, Workspace Cleanup
+# Plugin, and Node and Label Parameter Plugin in use for this job. The
+# workspace cleanup plugin cleans the workspace before each build. Two are file
+# parameters, a string parameter, and a Label parameter provided by the Node
+# and Label Parameter Plugin, as described above. When th pl:jenkins:post task
+# triggers a build, it passes values for all of these parameters. The Label
+# parameter is associated with the build type. This way we can queue the job on
+# a builder with the appropriate capabilities just by assigning a builder the
+# label "deb" or "rpm," etc. The actual build itself is accomplished via a
+# shell build task. The contents of the task are:
+#
+#################
+#
+# #!/bin/bash
+#
+# SHA=$(echo $BUILD_PROPERTIES | cut -d '.' -f1)
+#
+# echo "Build type: $BUILD_TYPE"
+#
+# ### Create a local clone of the git-bundle that was passed
+# # The bundle is a tarball, and since this is a project-agnostic
+# # job, we don't actually know what's in it, just that it's a
+# # git bundle.
+# #
+#
+# [ -f "PROJECT_BUNDLE" ] || exit 1
+# mkdir project && tar -xzf PROJECT_BUNDLE -C project/
+#
+# pushd project
+#   git clone --recursive $(ls) git_repo
+#
+#     pushd git_repo
+#
+#     ### Clone the packaging repo
+#     rake package:bootstrap
+#
+#     ### Perform the build
+#     rake pl:build_from_params PARAMS_FILE=$WORKSPACE/BUILD_PROPERTIES
+#
+#     ### Send the results
+#     rake pl:jenkins:ship["artifacts"] PARAMS_FILE=$WORKSPACE/BUILD_PROPERTIES
+#
+#   popd
+# popd
+#
+# ### Create the repositories from our project by trigger a downstream job
+# ### Because we can't trigger downstream with a File Parameter, we use curl
+# if [ "$BUILD_TYPE" = "rpm" ] || [ "$BUILD_TYPE" = "deb" ] ; then
+#   curl -i -Fname=PROJECT_BUNDLE -Ffile0=@PROJECT_BUNDLE -FSubmit=Build -Fjson="{\"parameter\":[{\"name\":\"PROJECT_BUNDLE\",\"file\":\"file0\"}]}" \
+#   http://jenkins-release.delivery.puppetlabs.net/job/puppetlabs-packaging-repo-creation/build
+# fi
+#
+# ### If a downstream job was passed, trigger it now
+# if [ -n "$DOWNSTREAM_JOB" ] ; then
+#   pushd project
+#     pushd git_repo
+#       rake pl:jenkins:post["$DOWNSTREAM_JOB"] PARAMS_FILE=$WORKSPACE/BUILD_PROPERTIES
+#     popd
+#   popd
+# fi
+#
+#################
+
+namespace :pl do
+  namespace :jenkins do
+    ##
+    # Do the heavy lifting. This task generates the URL for the jenkins job and posts it.
+    # It expects a the following arguments
+    # 1. :build_task => The lower-level pl: or pe: task we're executing, e.g. pl:deb_all
+    #
+    task :post_build, :build_task do |t, args|
+      # Check for a dirty tree before allowing a remote build that is doomed to unexpected results
+      if source_dirty?
+        warn "The source tree is dirty, e.g. there are uncommited changes. Please commit/discard changes and try again."
+        exit 1
+      end
+
+      # We use JSON for parsing the json part of the submission to JSON
+      begin
+        require 'json'
+      rescue LoadError
+        warn "Couldn't require 'json'. JSON is required for sanely generating the string we curl to Jenkins."
+        exit 1
+      end
+
+      build_task = args.build_task
+      ##
+      # We set @:task of @build manually with our task data so the remote
+      # build knows what to do. Puppetdb needs early knowledge of if this is
+      # a PE build, so we always this along as an environment variable task
+      # argument if its the case.
+      #
+      @build.task = { :task => "#{build_task}", :args => nil }
+      @build.task[:args] = ["PE_BUILD=true"] if @build_pe
+      #
+      # Determine the type of build we're doing to inform jenkins
+      build_type = case build_task
+        when /deb/ then "deb"
+        when /mock/ then "rpm"
+        when /dmg|apple/ then "dmg"
+        when /gem/ then "gem"
+        when /tar/ then "tar"
+        when /sles/ then "sles"
+        else raise "Could not determine build type for #{build_task}"
+      end
+      #
+      # Create the data files to send to jenkins
+      properties = @build.params_to_yaml
+      bundle = git_bundle('HEAD')
+
+      # Construct the parameters, which is an array of hashes we turn into JSON
+      parameters = [{ "name" => "BUILD_PROPERTIES", "file"  => "file0" },
+                    { "name" => "PROJECT_BUNDLE",   "file"  => "file1" },
+                    { "name" => "PROJECT",          "value" => "#{@build.project}" },
+                    { "name" => "BUILD_TYPE",       "label" => "#{build_type}" }]
+
+      # Initialize the args array that will hold all of the arguments we pass
+      # to the curl utility method.
+      args = []
+
+      # If the environment variable "DOWNSTREAM_JOB" was passed, we want to
+      # send this value to the build job as well, so it knows to trigger a
+      # downstream job, and with what URI.
+      if ENV['DOWNSTREAM_JOB']
+        parameters << { "name" => "DOWNSTREAM_JOB", "value" => ENV['DOWNSTREAM_JOB'] }
+        args << [ "-Fname=DOWNSTREAM_JOB", "-Fvalue=#{ENV['DOWNSTREAM_JOB']}" ]
+      end
+
+      # Contruct the json string
+      json = JSON.generate("parameter" => parameters)
+
+      # Construct the remaining form arguments. For visual clarity, params that are tied
+      # together are on the same line.
+      #
+      args <<  [
+      "-Fname=BUILD_PROPERTIES", "-Ffile0=@#{properties}",
+      "-Fname=PROJECT_BUNDLE"  , "-Ffile1=@#{bundle}",
+      "-Fname=PROJECT"         , "-Fvalue=#{@build.project}",
+      "-Fname=BUILD_TYPE"      , "-Fvalue=#{build_type}",
+      "-FSubmit=Build",
+      "-Fjson=#{json.to_json}",
+      ]
+
+      # We have several arrays inside args by now, flatten it up.
+      args.flatten!
+
+      # Construct the job url
+      #
+      job_url = "#{@build.jenkins_build_host}/job/#{@build.jenkins_packaging_job}"
+      trigger_url = "#{job_url}/build"
+
+      # Call out to the curl_form_data utility method in 00_utils.rake
+      #
+      if curl_form_data(trigger_url, args)
+        puts "Build submitted. To view your build results, go to #{job_url}"
+        puts "Your packages will be available at #{@build.distribution_server}:#{@build.jenkins_repo_path}/#{@build.project}/#{@build.ref}"
+      else
+        warn "An error occurred submitting the job to jenkins. Take a look at the preceding http response for more info."
+      end
+    end
+  end
+end
+
+##
+# A task listing for creating jenkins tasks for our various pl: and pe: build
+# tasks. We can assume deb, mock, but not gem/dmg.
+#
+tasks = ["deb", "mock", "tar"]
+tasks << "gem" if @build.build_gem and ! @build.build_pe
+tasks << "dmg" if @build.build_dmg and ! @build.build_pe
+
+namespace :pl do
+  namespace :jenkins do
+    tasks.each do |build_task|
+      desc "Queue pl:#{build_task} build on jenkins builder"
+      task build_task => "pl:fetch" do
+        invoke_task("pl:jenkins:post_build", "pl:#{build_task}")
+      end
+    end
+
+    # While pl:remote:deb_all does all cows in serially, with jenkins we
+    # parallelize them. This breaks the cows up and posts a build for all of
+    # them. We have to sleep 5 because jenkins drops the builds when we're
+    # DOSing it with our packaging.
+    desc "Queue pl:deb_all on jenkins builder"
+    task :deb_all => "pl:fetch" do
+      @build.cows.split(' ').each do |cow|
+        @build.default_cow = cow
+        invoke_task("pl:jenkins:post_build", "pl:deb")
+        sleep 5
+      end
+    end
+
+    # This does the mocks in parallel
+    desc "Queue pl:mock-all on jenkins builder"
+    task :mock_all => "pl:fetch" do
+      @build.final_mocks.split(' ').each do |mock|
+        @build.default_mock = mock
+        invoke_task("pl:jenkins:post_build", "pl:mock")
+        sleep 5
+      end
+    end
+
+    desc "Jenkins UBER build: build all the things with jenkins"
+    task :uber_build do
+      uber_tasks = ["jenkins:deb_all", "jenkins:mock_all", "jenkins:tar"]
+      uber_tasks << "jenkins:dmg" if @build.build_dmg
+      uber_tasks << "jenkins:gem" if @build.build_gem
+      uber_tasks.map { |t| "pl:#{t}" }.each do |t|
+        invoke_task(t)
+        sleep 5
+      end
+    end
+
+    desc "Retrieve packages built by jenkins, sign, and ship all!"
+    task :uber_ship => "pl:fetch" do
+      uber_tasks = ["jenkins:retrieve", "jenkins:sign_all", "uber_ship", "remote:freight", "remote:update_yum_repo" ]
+      uber_tasks.map { |t| "pl:#{t}" }.each { |t| Rake::Task[t].invoke }
+      Rake::Task["pl:jenkins:ship"].invoke("shipped")
+    end
+  end
+end
+
+##
+# If this is a PE project, we want PE tasks as well. However, because the
+# PE tasks use :remote as their default (e.g., not namespaced under remote)
+# we have to explicily use the "local" tasks, since these will be local
+# builds on jenkins agents. Also, we support building on SLES for PE, so we
+# add a sles task.
+#
+if @build.build_pe
+  namespace :pe do
+    namespace :jenkins do
+      tasks << "sles"
+      tasks.each do |build_task|
+        desc "Queue pe:#{build_task} build on jenkins builder"
+        task build_task => "pl:fetch" do
+          check_var("PE_VER", @build.pe_version)
+          invoke_task("pl:jenkins:post_build", "pe:local_#{build_task}")
+        end
+      end
+
+      desc "Queue builds of all PE packages for this project in Jenkins"
+      task :uber_build  => "pl:fetch" do
+        check_var("PE_VER", @build.pe_version)
+        ["deb_all", "mock_all", "sles"].each do |task|
+          invoke_task("pe:jenkins:#{task}")
+          sleep 5
+        end
+      end
+
+      desc "Retrieve PE packages built by jenkins, sign, and ship all!"
+      task :uber_ship => "pl:fetch" do
+        check_var("PE_VER", @build.pe_version)
+        ["pl:jenkins:retrieve", "pe:ship_rpms", "pe:ship_debs"].each do |task|
+          Rake::Task[task].invoke
+        end
+        Rake::Task["pl:jenkins:ship"].invoke("shipped")
+      end
+    end
+  end
+end
+
+##
+# This task allows the packaging repo to post to an arbitrary jenkins job but
+# it is very limited in that it does not model well the key => value format
+# used when submitting form data on websites. This is primarily because rake
+# does not allow us to elegantly pass arbitrary key => value pairs on the
+# command line and have any idea how to reference them inside rake. We can pass
+# KEY=VALUE along with our invokation, but unless KEY is statically coded into
+# our task, we won't know how to reference it. Thus, this task will only take
+# one argument, the uri of the jenkins job to post to. This can be passed
+# either as an argument directly or as an environment variable "JOB" with the
+# uri as the value. The argument is required. The second requirement is that
+# the job to be called accept a string parameter with the name SHA. This will
+# be the SHA of the commit of the project source code HEAD, and should be used
+# by the job to check out this specific ref. To maintain the abstraction of the
+# jenkins jobs, this specific task passes on no information about the build
+# itself. The assumption is that the upstream jobs know about their project,
+# and so do the downstream jobs, but packaging itself has no business knowing
+# about it.
+#
+namespace :pl do
+  namespace :jenkins do
+    desc "Trigger a jenkins uri with SHA of HEAD as a string param, requires \"URI\""
+    task :post, :uri do |t, args|
+      uri = args.uri || ENV['URI']
+      raise "pl:jenkins:post requires a URI, either via URI= or pl:jenkin:post[URI]" if uri.nil?
+
+      # We use JSON for parsing the json part of the submission.
+      begin
+        require 'json'
+      rescue LoadError
+        warn "Couldn't require 'json'. JSON is required for sanely generating the string we curl to Jenkins."
+        exit 1
+      end
+
+      # Assemble the JSON string for the JSON parameter
+      json = JSON.generate("parameter" => [{ "name" => "SHA", "value"  => "#{@build.ref}" }])
+
+      # Assemble our arguments to the post
+      args = [
+      "-Fname=SHA", "-Fvalue=#{@build.ref}",
+      "-Fjson=#{json.to_json}",
+      "-FSubmit=Build"
+      ]
+
+      if curl_form_data(uri, args)
+        puts "Job triggered at #{uri}."
+      else
+        puts "An error occurred attempting to trigger the job at #{uri}. Please see the preceding http response for more info."
+      end
+    end
+  end
+end
+