puppet 2.7.25 → 2.7.26

data/ext/packaging/lib/packaging/tar.rb

@@ -0,0 +1,186 @@
+module Pkg
+  class Tar
+    require 'fileutils'
+    require 'pathname'
+    include FileUtils
+
+    attr_accessor :files, :project, :version, :excludes, :target, :templates
+    attr_reader :tar
+
+    def initialize
+      @tar      = Pkg::Util::Tool.find_tool('tar', :required => true)
+      @project  = Pkg::Config.project
+      @version  = Pkg::Config.version
+      @files    = Pkg::Config.files
+      @target   = File.join(Pkg::Config.project_root, "pkg", "#{@project}-#{@version}.tar.gz")
+
+      # We require that the excludes list be a string (which is space
+      # separated, we hope)(deprecated) or an array.
+      #
+      if Pkg::Config.tar_excludes
+        if Pkg::Config.tar_excludes.is_a?(String)
+          warn "warning: `tar_excludes` should be an array, not a string"
+          @excludes = Pkg::Config.tar_excludes.split(' ')
+        elsif Pkg::Config.tar_excludes.is_a?(Array)
+          @excludes = Pkg::Config.tar_excludes
+        else
+          fail "Tarball excludes must either be an array or a string, not #{@excludes.class}"
+        end
+      else
+        @excludes = []
+      end
+
+      # On the other hand, support for explicit templates started with Arrays,
+      # so that's all we support.
+      #
+      if Pkg::Config.templates
+        @templates = Pkg::Config.templates.dup
+        fail "templates must be an array" unless @templates.is_a?(Array)
+        expand_templates
+      end
+    end
+
+    def install_files_to(workdir)
+      install = []
+      # It is nice to use arrays in YAML to represent array content, but we used
+      # to support a mode where a space-separated string was used.  Support both
+      # to allow a gentle migration to a modern style...
+      patterns =
+        case @files
+        when String
+          STDERR.puts "warning: `files` should be an array, not a string"
+          @files.split(' ')
+        when Array
+          @files
+        else
+          raise "`files` must be a string or an array!"
+        end
+      # We need to add our list of file patterns from the configuration; this
+      # used to be a list of "things to copy recursively", which would install
+      # editor backup files and other nasty things.
+      #
+      # This handles that case correctly, with a deprecation warning, to augment
+      # our FileList with the right things to put in place.
+      #
+      # Eventually, when all our projects are migrated to the new standard, we
+      # can drop this in favour of just pushing the patterns directly into the
+      # FileList and eliminate many lines of code and comment.
+      cd Pkg::Config.project_root do
+        patterns.each do |pattern|
+          if File.directory?(pattern) and not Pkg::Util::File.empty_dir?(pattern)
+            install << Dir[pattern + "/**/*"]
+          else
+            install << Dir[pattern]
+          end
+        end
+        install.flatten!
+
+        # Transfer all the files and symlinks into the working directory...
+        install = install.select { |x| File.file?(x) or File.symlink?(x) or Pkg::Util::File.empty_dir?(x) }
+
+        install.each do |file|
+          if Pkg::Util::File.empty_dir?(file)
+            mkpath(File.join(workdir, file), :verbose => false)
+          else
+            mkpath(File.dirname( File.join(workdir, file) ), :verbose => false)
+            cp(file, File.join(workdir, file), :verbose => false, :preserve => true)
+          end
+        end
+      end
+    end
+
+    # The templates of a project can include globs, which may expand to an
+    # arbitrary number of files. This method expands all of the templates using
+    # Dir.glob and then filters out any templates that live in the packaging
+    # tools themselves. If the template is a source/target combination, it is
+    # returned to the array untouched.
+    def expand_templates
+      @templates.map! do |tempfile|
+        if tempfile.is_a?(String)
+          # Expand possible globs to all matching entries
+          Dir.glob(File.join(Pkg::Config::project_root, tempfile))
+        elsif tempfile.is_a?(Hash)
+          tempfile
+        end
+      end
+      @templates.flatten!
+
+      # Reject matches that are templates from packaging itself. These will contain the packaging root.
+      # These tend to come from the current tar.rake implementation.
+      @templates.reject! { |temp| temp.is_a?(String) && temp.match(/#{Pkg::Config::packaging_root}/) }
+    end
+
+    # Given the tar object's template files (assumed to be in Pkg::Config.project_root), transform
+    # them, removing the originals. If workdir is passed, assume Pkg::Config.project_root
+    # exists in workdir
+    def template(workdir=nil)
+      workdir ||= Pkg::Config.project_root
+      root = Pathname.new(Pkg::Config.project_root)
+
+      # Templates can be either a string or a hash of source and target. If it
+      # is a string, the target is assumed to be the same path as the
+      # source,with the extension removed. If it is a hash, we assume nothing
+      # and use the provided source and target.
+      @templates.each do |cur_template|
+        if cur_template.is_a?(String)
+          template_file = File.expand_path(cur_template)
+          target_file = template_file.sub(File.extname(template_file),"")
+        elsif cur_template.is_a?(Hash)
+          template_file = File.expand_path(cur_template["source"])
+          target_file = File.expand_path(cur_template["target"])
+        end
+
+        #   We construct paths to the erb template and its proposed target file
+        #   relative to the project root, *not* fully qualified. This allows us
+        #   to, given a temporary workdir containing a copy of the project,
+        #   construct the full path to the erb and target file inside the
+        #   temporary workdir.
+        #
+        rel_path_to_template = Pathname.new(template_file).relative_path_from(root).to_s
+        rel_path_to_target = Pathname.new(target_file).relative_path_from(root).to_s
+
+        #   What we pass to Pkg::util::File.erb_file are the paths to the erb
+        #   and target inside of a temporary project directory. We are, in
+        #   essence, templating "in place." This is why we remove the original
+        #   files - they're not the originals in the authoritative project
+        #   directory, but the originals in the temporary working copy.
+        if File.exist?(File.join(workdir,rel_path_to_template))
+          mkpath(File.dirname( File.join(workdir, rel_path_to_target) ), :verbose => false)
+          Pkg::Util::File.erb_file(File.join(workdir,rel_path_to_template), File.join(workdir, rel_path_to_target), true, :binding => Pkg::Config.get_binding)
+        elsif File.exist?(File.join(root,rel_path_to_template))
+          mkpath(File.dirname( File.join(workdir, rel_path_to_target) ), :verbose => false)
+          Pkg::Util::File.erb_file(File.join(root,rel_path_to_template), File.join(workdir, rel_path_to_target), false, :binding => Pkg::Config.get_binding)
+        else
+          fail "Expected to find #{template_file} in #{root} for templating. But it was not there. Maybe you deleted it?"
+        end
+      end
+    end
+
+    def tar(target, source)
+      mkpath File.dirname(target)
+      cd File.dirname(source) do
+        %x[#{@tar} #{@excludes.map{ |x| (" --exclude #{x} ") }.join if @excludes} -zcf '#{File.basename(target)}' '#{File.basename(source)}']
+        unless $?.success?
+          fail "Failed to create .tar.gz archive with #{@tar}. Please ensure the tar command in your path accepts the flags '-c', '-z', and '-f'"
+        end
+        mv File.basename(target), target
+      end
+    end
+
+    def clean_up(workdir)
+      rm_rf workdir
+    end
+
+    def pkg!
+      workdir = File.join(Pkg::Util::File.mktemp, "#{@project}-#{@version}")
+      mkpath workdir
+      self.install_files_to workdir
+      self.template(workdir)
+      Pkg::Util::Version.versionbump(workdir) if Pkg::Config.update_version_file
+      self.tar(@target, workdir)
+      self.clean_up workdir
+    end
+
+  end
+end
+

data/ext/packaging/lib/packaging/util.rb

@@ -0,0 +1,44 @@
+# Utility methods used by the various rake tasks
+
+module Pkg::Util
+  require 'erb'
+  require 'benchmark'
+  require 'packaging/util/date'
+  require 'packaging/util/tool'
+  require 'packaging/util/file'
+  require 'packaging/util/net'
+  require 'packaging/util/version'
+  require 'packaging/util/serialization'
+  require 'packaging/util/rake_utils'
+  require 'packaging/util/jira'
+
+  def self.boolean_value(var)
+    return TRUE if (var == TRUE || ( var.is_a?(String) && ( var.downcase == 'true' || var.downcase =~ /^y$|^yes$/ )))
+    FALSE
+  end
+
+  def self.in_project_root(&blk)
+    result = nil
+    fail "Cannot execute in project root if Pkg::Config.project_root is not set" unless Pkg::Config.project_root
+
+    Dir.chdir Pkg::Config.project_root do
+      result = blk.call
+    end
+    result
+  end
+
+  def self.get_var(var)
+    check_var(var, ENV[var])
+    ENV[var]
+  end
+
+  def self.require_library_or_fail(library, library_name = nil)
+    library_name ||= library
+    begin
+      require library
+    rescue LoadError
+      fail "Could not load #{library_name}. #{library_name} is required by the packaging repo for this task"
+    end
+  end
+
+end

data/ext/packaging/lib/packaging/util/date.rb

@@ -0,0 +1,15 @@
+# Utilities for managing/querying date/time
+
+module Pkg::Util::Date
+
+  class << self
+    def timestamp(separator=nil)
+      if s = separator
+        format = "%Y#{s}%m#{s}%d#{s}%H#{s}%M#{s}%S"
+      else
+        format = "%Y-%m-%d %H:%M:%S"
+      end
+      Time.now.strftime(format)
+    end
+  end
+end

data/ext/packaging/lib/packaging/util/file.rb

@@ -0,0 +1,60 @@
+# Utility methods for handling files and directories
+
+module Pkg::Util::File
+
+  class << self
+    def mktemp
+      mktemp = Pkg::Util::Tool.find_tool('mktemp', :required => true)
+      `#{mktemp} -d -t pkgXXXXXX`.strip
+    end
+
+    def empty_dir?(dir)
+      File.exist?(dir) and File.directory?(dir) and Dir["#{dir}/**/*"].empty?
+    end
+
+    def file_exists?(file, args={:required => false})
+      exists = File.exist? file
+      if !exists and args[:required]
+        fail "Required file #{file} could not be found"
+      end
+      exists
+    end
+
+    def file_writable?(file, args={:required => false})
+      writable = File.writable? file
+      if !writable and args[:required]
+        fail "File #{file} is not writable"
+      end
+      writable
+    end
+
+    alias :get_temp :mktemp
+
+    def erb_string(erbfile, b = binding)
+      template = File.read(erbfile)
+      message  = ERB.new(template, nil, "-")
+      message.result(b)
+    end
+
+    def erb_file(erbfile, outfile=nil, remove_orig = false, opts = { :binding => binding })
+      outfile ||= File.join(mktemp, File.basename(erbfile).sub(File.extname(erbfile),""))
+      output = erb_string(erbfile, opts[:binding])
+      File.open(outfile, 'w') { |f| f.write output }
+      puts "Generated: #{outfile}"
+      FileUtils.rm_rf erbfile if remove_orig
+      outfile
+    end
+
+    def untar_into(source, target = nil, options = "")
+      tar = Pkg::Util::Tool.find_tool('tar', :required => true)
+      # We only accept a writable directory as a target
+      if target and !target.empty? and file_writable?(target) and File.directory?(target)
+        target_opts = "-C #{target}"
+      end
+      if file_exists?(source, :required => true)
+        ex(%Q[#{tar} #{options} #{target_opts} -xf #{source}])
+      end
+    end
+  end
+end
+

data/ext/packaging/lib/packaging/util/jira.rb

@@ -0,0 +1,83 @@
+module Pkg::Util
+  class Jira
+
+    # This class is a very thin wrapper around the jira library. For testability,
+    # the small bit of logic that does some prep for the library or processing of its
+    # output are extracted into a handful of class methods.
+
+    def self.jira_client_options(username, password, site)
+      {
+        :username           => username,
+        :password           => password,
+        :site               => site,
+        :context_path       => '',
+        :auth_type          => :basic,
+        :use_ssl            => true,
+      }
+    end
+
+    def self.jira_project_name(projects, project)
+      # projects is an array of objects with key and name methods
+      projects.find { |p| p.key == project }.name
+    end
+
+    def self.jira_issue_fields(summary, description, project, parent, assignee)
+      # build the fields hash describing the ticket
+      fields = {
+          'summary'     => summary,
+          'description' => description,
+          'project'     => { 'key' => project},
+          'issuetype'   => { 'name' => parent ? "Sub-task" : "Task" },
+          'assignee'    => { 'name' => assignee },
+      }
+      if parent
+        fields['parent'] = { 'id' => parent }
+      end
+
+      fields
+    end
+
+    # Future improvement, exception handling and more helpful error messages
+    #
+    def initialize(username, password, site)
+      # This library uses the gem called 'jira-ruby' which provides the library 'jira'.
+      # Not to be confused with the gem called 'jira'. Be careful out there.
+      Pkg::Util.require_library_or_fail('jira', 'jira-ruby')
+
+      # Construct a jira client
+      options = self.class.jira_client_options(username, password, site)
+      options[:ssl_verify_mode] = OpenSSL::SSL::VERIFY_PEER
+          # only get OpenSSL through the jira library so leave it out of the class method
+      @client = JIRA::Client.new(options)
+    end
+
+    def project?(project)
+      @client.Project.find(project)
+    rescue
+      fail "Could not find project: #{project}"
+    end
+
+    def user?(user)
+      @client.User.find(user)
+    rescue
+      fail "Could not find user: #{user}"
+    end
+
+    def project_name(project)
+      self.class.jira_project_name(@client.Project.all, project)
+    end
+
+    def create_issue(summary, description, project, parent, assignee)
+      fields = self.class.jira_issue_fields(summary, description, project,
+                                            parent, assignee)
+
+      issue = @client.Issue.build
+      issue.save!( {'fields' => fields } )
+
+      # fetch the issue back so we can report the key and id
+      issue.fetch
+
+      return issue.key, issue.id
+    end
+  end
+end

data/ext/packaging/lib/packaging/util/net.rb

@@ -0,0 +1,16 @@
+# Utility methods for handling network calls and interactions
+
+module Pkg::Util::Net
+
+  class << self
+
+    # This simple method does an HTTP get of a URI and writes it to a file
+    # in a slightly more platform agnostic way than curl/wget
+    def fetch_uri(uri, target)
+      require 'open-uri'
+      if Pkg::Util::File.file_writable?(File.dirname(target))
+        File.open(target, 'w') { |f| f.puts( open(uri).read ) }
+      end
+    end
+  end
+end

data/ext/packaging/lib/packaging/util/rake_utils.rb

@@ -0,0 +1,57 @@
+# Utility methods for working with rake tasks. These utilities will not work
+# if the packaging repo was loaded as a library unless rake has been required
+# explicitly.
+
+module Pkg::Util::RakeUtils
+  class << self
+    def using_rake?
+      defined?(Rake::Task)
+    end
+
+    def task_defined?(task_name)
+      if using_rake?
+        Rake::Task.task_defined?(task_name)
+      end
+    end
+
+    #  Return the Rake::Task object associated with a task name
+    #
+    def get_task(task_name)
+      if using_rake? and task_defined?(task_name)
+        Rake::Task[task_name]
+      end
+    end
+
+    #  Add a dependency to a rake task. "depender" must be an instance of
+    #  Rake::Task, but dependency can be either a Rake::Task instance, or a String
+    #  referring to the name of a Rake::Task instance.
+    #
+    def add_dependency(depender, dependency)
+      if using_rake?
+        if !task_defined?(depender)
+          fail "Could not locate a Rake task named '#{depender.to_s}' to add a dependency of '#{dependency.to_s}' to"
+        elsif !task_defined?(dependency)
+          fail "Could not locate a Rake task named '#{dependency.to_s}' to add as a dependency of '#{depender.to_s}'"
+        else
+          depender_task = Rake::Task[depender]
+          depender_task.enhance([dependency])
+        end
+      end
+    end
+
+    #  Evaluate any pre-tasks known by the configuration of this invocation.
+    #  Again, this is quite pointless if the user has not invoked the packaging
+    #  repo via rake, so we're just not going to do anything.
+    #
+    def evaluate_pre_tasks
+      if using_rake? and Pkg::Config.pre_tasks
+        unless Pkg::Config.pre_tasks.is_a?(Hash)
+          fail "The 'pre_tasks' key must be a Hash of depender => dependency pairs"
+        end
+        Pkg::Config.pre_tasks.each do |depender, dependency|
+          add_dependency(depender, dependency)
+        end
+      end
+    end
+  end
+end