fpm-aeppert 1.6.2 → 1.11.0

data/lib/fpm/package/rpm.rb

@@ -1,5 +1,5 @@
 require "fpm/package"
-require "backports"
+require "backports/latest"
 require "fileutils"
 require "find"
 require "arr-pm/file" # gem 'arr-pm'
@@ -24,9 +24,10 @@ class FPM::Package::RPM < FPM::Package
 
   COMPRESSION_MAP = {
     "none" => "w0.gzdio",
-    "xz" => "w9.xzdio",
-    "gzip" => "w9.gzdio",
-    "bzip2" => "w9.bzdio"
+    "xz" => ".xzdio",
+    "xzmt" => "T.xzdio",
+    "gzip" => ".gzdio",
+    "bzip2" => ".bzdio"
   } unless defined?(COMPRESSION_MAP)
 
   option "--use-file-permissions", :flag,
@@ -67,6 +68,15 @@ class FPM::Package::RPM < FPM::Package
     value.downcase
   end
 
+  option "--compression-level", "[0-9]", "Select a compression level. 0 is store-only. 9 is max compression.",
+    :default => "9" do |value|
+    valint = value.to_i
+    unless value =~ /^\d$/ && valint >= 0 && valint <= 9
+      raise "Invalid compression level '#{value}'. Valid values are integers between 0 and 9 inclusive."
+    end
+    valint
+  end
+
   option "--compression", COMPRESSION_MAP.keys.join("|"),
     "Select a compression method. gzip works on the most platforms.",
     :default => "gzip" do |value|
@@ -141,6 +151,10 @@ class FPM::Package::RPM < FPM::Package
            "names in rpm requires instead of the redhat style " \
            "rubygem(foo).", :default => false
 
+  option "--macro-expansion", :flag,
+           "install-time macro expansion in %pre %post %preun %postun scripts " \
+           "(see: https://rpm.org/user_doc/scriptlet_expansion.html)", :default => false
+
   option "--verifyscript", "FILE",
     "a script to be run on verification" do |val|
     File.expand_path(val) # Get the full path to the script
@@ -472,6 +486,22 @@ class FPM::Package::RPM < FPM::Package
       self.directories = alldirs
     end
 
+    # include external config files
+    (attributes[:config_files] or []).each do |conf|
+      dest_conf = File.join(staging_path, conf)
+
+      if File.exist?(dest_conf)
+        logger.debug("Using --config-file from staging area", :path => conf)
+      elsif File.exist?(conf)
+        logger.info("Copying --config-file from local path", :path => conf)
+        FileUtils.mkdir_p(File.dirname(dest_conf))
+        FileUtils.cp_r conf, dest_conf
+      else
+        logger.error("Failed to find given --config-file", :path => conf)
+        raise "Could not find config file '#{conf}' in staging area or on host. This can happen if you specify `--config-file '#{conf}'` but this file does not exist in the source package and also does not exist in filesystem."
+      end
+    end
+
     # scan all conf file paths for files and add them
     allconfigs = []
     self.config_files.each do |path|
@@ -499,10 +529,11 @@ class FPM::Package::RPM < FPM::Package
     end
 
     # copy all files from staging to BUILD dir
+    # [#1538] Be sure to preserve the original timestamps.
     Find.find(staging_path) do |path|
       src = path.gsub(/^#{staging_path}/, '')
       dst = File.join(build_path, build_sub_dir, src)
-      copy_entry(path, dst)
+      copy_entry(path, dst, preserve=true)
     end
 
     rpmspec = template("rpm.erb").result(binding)
@@ -537,7 +568,7 @@ class FPM::Package::RPM < FPM::Package
 
   def summary
     if !attributes[:rpm_summary]
-      return @description.split("\n").first || "_"
+      return @description.split("\n").find { |line| !line.strip.empty? } || "_"
     end
 
     return attributes[:rpm_summary]
@@ -580,7 +611,12 @@ class FPM::Package::RPM < FPM::Package
   end # def to_s
 
   def payload_compression
-    return COMPRESSION_MAP[attributes[:rpm_compression]]
+    if attributes[:rpm_compression] == 'none'
+      # when 'none' ignore any compression level and return w0.gzdio
+      return COMPRESSION_MAP[attributes[:rpm_compression]]
+    else
+      return "w#{attributes[:rpm_compression_level]}" + COMPRESSION_MAP[attributes[:rpm_compression]]
+    end
   end # def payload_compression
 
   def digest_algorithm

data/lib/fpm/package/sh.rb

@@ -3,7 +3,7 @@ require "fpm/namespace"
 require "fpm/package"
 require "fpm/errors"
 require "fpm/util"
-require "backports"
+require "backports/latest"
 require "fileutils"
 require "digest"
 

data/lib/fpm/package/snap.rb

@@ -0,0 +1,130 @@
+require "yaml"
+
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+require "fpm/package/dir"
+
+# Support for snaps (.snap files).
+#
+# This supports the input and output of snaps.
+class FPM::Package::Snap < FPM::Package
+
+  option "--yaml", "FILEPATH",
+    "Custom version of the snap.yaml file." do | snap_yaml |
+    File.expand_path(snap_yaml)
+  end
+
+  option "--confinement", "CONFINEMENT",
+    "Type of confinement to use for this snap.",
+    default: "devmode" do | confinement |
+    if ['strict', 'devmode', 'classic'].include? confinement
+      confinement
+    else
+      raise "Unsupported confinement type '#{confinement}'"
+    end
+  end
+
+  option "--grade", "GRADE", "Grade of this snap.",
+    default: "devel" do | grade |
+    if ['stable', 'devel'].include? grade
+      grade
+    else
+      raise "Unsupported grade type '#{grade}'"
+    end
+  end
+
+   # Input a snap
+  def input(input_snap)
+    extract_snap_to_staging input_snap
+    extract_snap_metadata_from_staging
+  end # def input
+
+  # Output a snap.
+  def output(output_snap)
+    output_check(output_snap)
+
+    write_snap_yaml
+
+    # Create the snap from the staging path
+    safesystem("mksquashfs", staging_path, output_snap, "-noappend", "-comp",
+               "xz", "-no-xattrs", "-no-fragments", "-all-root")
+  end # def output
+
+  def to_s(format=nil)
+    # Default format if nil
+    # name_version_arch.snap
+    return super(format.nil? ? "NAME_FULLVERSION_ARCH.EXTENSION" : format)
+  end # def to_s
+
+  private
+
+  def extract_snap_to_staging(snap_path)
+    safesystem("unsquashfs", "-f", "-d", staging_path, snap_path)
+  end
+
+  def extract_snap_metadata_from_staging
+    metadata = YAML.safe_load(File.read(
+      staging_path(File.join("meta", "snap.yaml"))))
+
+    self.name = metadata["name"]
+    self.version = metadata["version"]
+    self.description = metadata["summary"] + "\n" + metadata["description"]
+    self.architecture = metadata["architectures"][0]
+    self.attributes[:snap_confinement] = metadata["confinement"]
+    self.attributes[:snap_grade] = metadata["grade"]
+
+    if metadata["apps"].nil?
+      attributes[:snap_apps] = []
+    else
+      attributes[:snap_apps] = metadata["apps"]
+    end
+
+    if metadata["hooks"].nil?
+      attributes[:snap_hooks] = []
+    else
+      attributes[:snap_hooks] = metadata["hooks"]
+    end
+  end
+
+  def write_snap_yaml
+    # Write the snap.yaml
+    if attributes[:snap_yaml]
+      logger.debug("Using '#{attributes[:snap_yaml]}' as the snap.yaml")
+      yaml_data = File.read(attributes[:snap_yaml])
+    else
+      summary, *remainder = (self.description or "no summary given").split("\n")
+      description = "no description given"
+      if remainder.any?
+        description = remainder.join("\n")
+      end
+
+      yaml_data = {
+        "name" => self.name,
+        "version" => self.version,
+        "summary" => summary,
+        "description" => description,
+        "architectures" => [self.architecture],
+        "confinement" => self.attributes[:snap_confinement],
+        "grade" => self.attributes[:snap_grade],
+      }
+
+      unless attributes[:snap_apps].nil? or attributes[:snap_apps].empty?
+        yaml_data["apps"] = attributes[:snap_apps]
+      end
+
+      unless attributes[:snap_hooks].nil? or attributes[:snap_hooks].empty?
+        yaml_data["hooks"] = attributes[:snap_hooks]
+      end
+
+      yaml_data = yaml_data.to_yaml
+    end
+
+    FileUtils.mkdir_p(staging_path("meta"))
+    snap_yaml_path = staging_path(File.join("meta", "snap.yaml"))
+    logger.debug("Writing snap.yaml", :path => snap_yaml_path)
+    File.write(snap_yaml_path, yaml_data)
+    File.chmod(0644, snap_yaml_path)
+    edit_file(snap_yaml_path) if attributes[:edit?]
+  end # def write_snap_yaml
+end # class FPM::Package::Snap

data/lib/fpm/package/tar.rb

@@ -1,4 +1,4 @@
-require "backports" # gem backports
+require "backports/latest" # gem backports
 require "fpm/package"
 require "fpm/util"
 require "fileutils"
@@ -50,15 +50,7 @@ class FPM::Package::Tar < FPM::Package
     output_check(output_path)
 
     # Write the scripts, too.
-    scripts_path = File.join(staging_path, ".scripts")
-    ::Dir.mkdir(scripts_path)
-    [:before_install, :after_install, :before_remove, :after_remove].each do |name|
-      next unless script?(name)
-      out = File.join(scripts_path, name.to_s)
-      logger.debug("Writing script", :source => name, :target => out)
-      File.write(out, script(name))
-      File.chmod(0755, out)
-    end
+    write_scripts
 
     # Unpack the tarball to the staging path
     args = ["-cf", output_path, "-C", staging_path]

data/lib/fpm/package/virtualenv.rb

@@ -15,8 +15,11 @@ class FPM::Package::Virtualenv < FPM::Package
   option "--package-name-prefix", "PREFIX", "Name to prefix the package " \
   "name with.", :default => "virtualenv"
 
-  option "--install-location", "DIRECTORY", "Location to which to " \
-  "install the virtualenv by default.", :default => "/usr/share/python" do |path|
+  option "--install-location", "DIRECTORY", "DEPRECATED: Use --prefix instead." \
+    "  Location to which to install the virtualenv by default.",
+    :default => "/usr/share/python" do |path|
+    logger.warn("Using deprecated flag: --install-location. Please use " \
+                  "--prefix instead.")
     File.expand_path(path)
   end
 
@@ -30,6 +33,19 @@ class FPM::Package::Virtualenv < FPM::Package
     :multivalued => true, :attribute_name => :virtualenv_pypi_extra_index_urls,
     :default => nil
 
+  option "--setup-install", :flag, "After building virtualenv run setup.py install "\
+  "useful when building a virtualenv for packages and including their requirements from "
+  "requirements.txt"
+
+  option "--system-site-packages", :flag, "Give the virtual environment access to the "\
+  "global site-packages"
+
+  option "--find-links", "PIP_FIND_LINKS", "If a url or path to an html file, then parse for "\
+    "links to archives. If a local path or file:// url that's a directory, then look "\
+    "for archives in the directory listing.",
+    :multivalued => true, :attribute_name => :virtualenv_find_links_urls,
+    :default => nil
+
   private
 
   # Input a package.
@@ -69,23 +85,33 @@ class FPM::Package::Virtualenv < FPM::Package
                    self.name].join("-")
     end
 
+    # prefix wins over previous virtual_install_location behaviour
     virtualenv_folder =
-      File.join(installdir,
-                virtualenv_name)
+      if self.attributes[:prefix]
+        self.attributes[:prefix]
+      else
+        File.join(installdir,
+                  virtualenv_name)
+      end
 
     virtualenv_build_folder = build_path(virtualenv_folder)
 
     ::FileUtils.mkdir_p(virtualenv_build_folder)
 
-    safesystem("virtualenv", virtualenv_build_folder)
+    if self.attributes[:virtualenv_system_site_packages?]
+        logger.info("Creating virtualenv with --system-site-packages")
+        safesystem("virtualenv", "--system-site-packages", virtualenv_build_folder)
+    else
+        safesystem("virtualenv", virtualenv_build_folder)
+    end
+
     pip_exe = File.join(virtualenv_build_folder, "bin", "pip")
     python_exe = File.join(virtualenv_build_folder, "bin", "python")
 
     # Why is this hack here? It looks important, so I'll keep it in.
-    safesystem(pip_exe, "install", "-U", "-i",
+    safesystem(python_exe, pip_exe, "install", "-U", "-i",
                attributes[:virtualenv_pypi],
-               "pip", "distribute")
-    safesystem(pip_exe, "uninstall", "-y", "distribute")
+               "pip")
 
     extra_index_url_args = []
     if attributes[:virtualenv_pypi_extra_index_urls]
@@ -94,6 +120,13 @@ class FPM::Package::Virtualenv < FPM::Package
       end
     end
 
+    find_links_url_args = []
+    if attributes[:virtualenv_find_links_urls]
+      attributes[:virtualenv_find_links_urls].each do |links_url|
+        find_links_url_args << "--find-links" << links_url
+      end
+    end
+
     target_args = []
     if is_requirements_file
       target_args << "-r" << package
@@ -101,12 +134,19 @@ class FPM::Package::Virtualenv < FPM::Package
       target_args << package
     end
 
-    pip_args = [pip_exe, "install", "-i", attributes[:virtualenv_pypi]] << extra_index_url_args << target_args
+    pip_args = [python_exe, pip_exe, "install", "-i", attributes[:virtualenv_pypi]] << extra_index_url_args << find_links_url_args << target_args
     safesystem(*pip_args.flatten)
 
+    if attributes[:virtualenv_setup_install?]
+      logger.info("Running PACKAGE setup.py")
+      setup_args = [python_exe, "setup.py", "install"]
+      safesystem(*setup_args.flatten)
+    end
+
     if ! is_requirements_file && package_version.nil?
-      frozen = safesystemout(pip_exe, "freeze")
-      package_version = frozen[/#{package}==[^=]+$/].split("==")[1].chomp!
+      frozen = safesystemout(python_exe, pip_exe, "freeze")
+      frozen_version = frozen[/#{package}==[^=]+$/]
+      package_version = frozen_version && frozen_version.split("==")[1].chomp!
       self.version ||= package_version
     end
 
@@ -135,7 +175,8 @@ class FPM::Package::Virtualenv < FPM::Package
     # use dir to set stuff up properly, mainly so I don't have to reimplement
     # the chdir/prefix stuff special for tar.
     dir = convert(FPM::Package::Dir)
-
+    # don't double prefix the files
+    dir.attributes[:prefix] = nil
     if attributes[:chdir]
       dir.attributes[:chdir] = File.join(build_path, attributes[:chdir])
     else

data/lib/fpm/package/zip.rb

@@ -1,4 +1,4 @@
-require "backports" # gem backports
+require "backports/latest" # gem backports
 require "fpm/package"
 require "fpm/util"
 require "fileutils"
@@ -36,28 +36,12 @@ class FPM::Package::Zip < FPM::Package
     dir.cleanup_build
   end # def input
 
-  # Output a tarball.
-  #
-  # If the output path ends predictably (like in .tar.gz) it will try to obey
-  # the compression type.
+  # Output a zipfile.
   def output(output_path)
     output_check(output_path)
-
-    files = Find.find(staging_path).to_a
-    safesystem("zip", output_path, *files)
-  end # def output
-
-  # Generate the proper tar flags based on the path name.
-  def tar_compression_flag(path)
-    case path
-      when /\.tar\.bz2$/
-        return "-j"
-      when /\.tar\.gz$|\.tgz$/
-        return "-z"
-      when /\.tar\.xz$/
-        return "-J"
-      else
-        return nil
+    realpath = Pathname.new(output_path).realdirpath.to_s
+    ::Dir.chdir(staging_path) do
+      safesystem("zip", "-9r", realpath, ".")
     end
-  end # def tar_compression_flag
+  end # def output
 end # class FPM::Package::Tar

data/lib/fpm/util.rb

@@ -1,6 +1,7 @@
 require "fpm/namespace"
 require "childprocess"
 require "ffi"
+require "fileutils"
 
 # Some utility functions
 module FPM::Util
@@ -190,9 +191,14 @@ module FPM::Util
     if args.size == 1
       args = [ default_shell, "-c", args[0] ]
     end
-    program = args[0]
 
-    exit_code = execmd(args)
+    if args[0].kind_of?(Hash)
+      env = args.shift()
+      exit_code = execmd(env, args)
+    else
+      exit_code = execmd(args)
+    end
+    program = args[0]
     success = (exit_code == 0)
 
     if !success
@@ -226,26 +232,90 @@ module FPM::Util
     return stdout_r_str
   end # def safesystemout
 
+  # Get an array containing the recommended 'ar' command for this platform
+  # and the recommended options to quickly create/append to an archive
+  # without timestamps or uids (if possible).
+  def ar_cmd
+    return @@ar_cmd if defined? @@ar_cmd
+
+    @@ar_cmd_deterministic = false
+
+    # FIXME: don't assume current directory writeable
+    FileUtils.touch(["fpm-dummy.tmp"])
+    ["ar", "gar"].each do |ar|
+      ["-qc", "-qcD"].each do |ar_create_opts|
+        FileUtils.rm_f(["fpm-dummy.ar.tmp"])
+        # Return this combination if it creates archives without uids or timestamps.
+        # Exitstatus will be nonzero if the archive can't be created,
+        # or its table of contents doesn't match the regular expression.
+        # Be extra-careful about locale and timezone when matching output.
+        system("#{ar} #{ar_create_opts} fpm-dummy.ar.tmp fpm-dummy.tmp 2>/dev/null && env TZ=UTC LANG=C LC_TIME=C #{ar} -tv fpm-dummy.ar.tmp | grep '0/0.*1970' > /dev/null 2>&1")
+        if $?.exitstatus == 0
+           @@ar_cmd = [ar, ar_create_opts]
+           @@ar_cmd_deterministic = true
+           return @@ar_cmd
+        end
+      end
+    end
+    # If no combination of ar and options omits timestamps, fall back to default.
+    @@ar_cmd = ["ar", "-qc"]
+    return @@ar_cmd
+  ensure
+    # Clean up
+    FileUtils.rm_f(["fpm-dummy.ar.tmp", "fpm-dummy.tmp"])
+  end # def ar_cmd
+
+  # Return whether the command returned by ar_cmd can create deterministic archives
+  def ar_cmd_deterministic?
+    ar_cmd if not defined? @@ar_cmd_deterministic
+    return @@ar_cmd_deterministic
+  end
+
   # Get the recommended 'tar' command for this platform.
   def tar_cmd
-    # Rely on gnu tar for solaris and OSX.
-    case %x{uname -s}.chomp
-    when "SunOS"
-      return "gtar"
-    when "Darwin"
-      # Try running gnutar, it was renamed(??) in homebrew to 'gtar' at some point, I guess? I don't know.
-      ["gnutar", "gtar"].each do |tar|
-        system("#{tar} > /dev/null 2> /dev/null")
-        return tar unless $?.exitstatus == 127
+    return @@tar_cmd if defined? @@tar_cmd
+
+    # FIXME: don't assume current directory writeable
+    FileUtils.touch(["fpm-dummy.tmp"])
+
+    # Prefer tar that supports more of the features we want, stop if we find tar of our dreams
+    best="tar"
+    bestscore=0
+    @@tar_cmd_deterministic = false
+    # GNU Tar, if not the default, is usually on the path as gtar, but
+    # Mac OS X 10.8 and earlier shipped it as /usr/bin/gnutar
+    ["tar", "gtar", "gnutar"].each do |tar|
+      opts=[]
+      score=0
+      ["--sort=name", "--mtime=@0"].each do |opt|
+        system("#{tar} #{opt} -cf fpm-dummy.tar.tmp fpm-dummy.tmp > /dev/null 2>&1")
+        if $?.exitstatus == 0
+          opts << opt
+          score += 1
+        end
+      end
+      if score > bestscore
+        best=tar
+        bestscore=score
+        if score == 2
+          @@tar_cmd_deterministic = true
+          break
+        end
       end
-    when "FreeBSD"
-      # use gnutar instead
-      return "gtar"
-    else
-      return "tar"
     end
+    @@tar_cmd = best
+    return @@tar_cmd
+  ensure
+    # Clean up
+    FileUtils.rm_f(["fpm-dummy.tar.tmp", "fpm-dummy.tmp"])
   end # def tar_cmd
 
+  # Return whether the command returned by tar_cmd can create deterministic archives
+  def tar_cmd_supports_sort_names_and_set_mtime?
+    tar_cmd if not defined? @@tar_cmd_deterministic
+    return @@tar_cmd_deterministic
+  end
+
   # wrapper around mknod ffi calls
   def mknod_w(path, mode, dev)
     rc = -1
@@ -298,8 +368,8 @@ module FPM::Util
       if known_entry
         FileUtils.ln(known_entry, dst)
       else
-        FileUtils.copy_entry(src, dst, preserve=preserve,
-                             remove_destination=remove_destination)
+        FileUtils.copy_entry(src, dst, preserve, false,
+                             remove_destination)
         copied_entries[[st.dev, st.ino]] = dst
       end
     end # else...