fpm 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce725d9c506143e502cfc1e27ff5c6346240f305
-  data.tar.gz: 09b9b1840e5525eb9930e7dad71070abc589275a
+  metadata.gz: 173d3185b39df15876683e91714e7a93970490cc
+  data.tar.gz: 15ffd8f3ff5b2658cd35aeb8b6188d90a00d3f7f
 SHA512:
-  metadata.gz: 4a33d2dc5a2ca57fcceef601c5ed80da8021bbd8ae6365ec62b5a2b91bc7c2bd59f62ced044dafe592dd48b6f211b68c6200cd761dbd105f0d684c56105d2922
-  data.tar.gz: 526287eceec55b3280544fbfcf851f091bc614a14137efbaf796a5ac549a7743ee04438099901f7896a823f627d731c019a44f6ac2f623f8b38bf0fc0edf30d7
+  metadata.gz: d25c03ef3397d2731d75d97c976a69174caa7b8eed89d8318d561e4516ecf5b4fb47d1f0fe5e96edb26094870b9c27e30d9366e89c3384bc527dea6cfd85c7f6
+  data.tar.gz: e6ee35e8c70e12f88d8350bfb7d5f4e06939d33257fcea64e3f16918f60acb84865c66bd7ac2ee6e6c0dea0ade119e7982256f0e9644ad860c6a8b40936427ca

data/CHANGELIST

@@ -1,3 +1,13 @@
+1.6.0 (May 25, 2016)
+  - New source: pleaserun. This lets you create packages that will install a
+    system service. An after-install script is used in the package to determine
+    which service platform to target (systemd, upstart, etc). (#1119, #1112)
+  - New target: Alpine Linux "apk" packages. (#1054, George Lester)
+  - deb: don't append `.conf` to an upstart file if the file name already ends
+    in `.conf`. (#1115, josegonzalez)
+  - freebsd: fix bug where --package flag was ignored. (#1093, Paweł Tomulik)
+  - Improvements to the fpm rake tasks (#1101, Evan Gilman)
+  
 1.5.0 (April 12, 2016)
   - Arch package support is now available via -s pacman and -t pacman. 
     (#916; wonderful community effort making this happen!)

data/LICENSE

@@ -1,6 +1,6 @@
 (This is an MIT-style license)
 
-Copyright (c) 2011,2012,2013 Jordan Sissel and contributors.
+Copyright (c) 2011-2016 Jordan Sissel and contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/fpm/command.rb

@@ -111,8 +111,8 @@ class FPM::Command < Clamp::Command
     "specified multiple times.", :multivalued => true,
     :attribute_name => :conflicts
   option "--replaces", "REPLACES",
-    "Other packages/versions this package replaces. This flag can be " \
-    "specified multiple times.", :multivalued => true,
+    "Other packages/versions this package replaces. Equivalent of rpm's 'Obsoletes'. " \
+    "This flag can be specified multiple times.", :multivalued => true,
     :attribute_name => :replaces
 
   option "--config-files", "CONFIG_FILES",
@@ -332,12 +332,18 @@ class FPM::Command < Clamp::Command
       end
     end
 
-    # Each remaining command line parameter is used as an 'input' argument.
-    # For directories, this means paths. For things like gem and python, this
-    # means package name or paths to the packages (rails, foo-1.0.gem, django,
-    # bar/setup.py, etc)
-    args.each do |arg|
-      input.input(arg)
+    if input_type == "pleaserun"
+      # Special case for pleaserun that all parameters are considered the 'command'
+      # to run through pleaserun.
+      input.input(args)
+    else
+      # Each remaining command line parameter is used as an 'input' argument.
+      # For directories, this means paths. For things like gem and python, this
+      # means package name or paths to the packages (rails, foo-1.0.gem, django,
+      # bar/setup.py, etc)
+      args.each do |arg|
+        input.input(arg)
+      end
     end
 
     # If --inputs was specified, read it as a file.

data/lib/fpm/package.rb

@@ -331,17 +331,31 @@ class FPM::Package
     return erb
   end # def template
 
-  def to_s(fmt="NAME.TYPE")
-    fmt = "NAME.TYPE" if fmt.nil?
-    fullversion = version.to_s
-    fullversion += "-#{iteration}" if iteration
-    return fmt.gsub("ARCH", architecture.to_s) \
-      .gsub("NAME", name.to_s) \
-      .gsub("FULLVERSION", fullversion) \
-      .gsub("VERSION", version.to_s) \
-      .gsub("ITERATION", iteration.to_s) \
-      .gsub("EPOCH", epoch.to_s) \
-      .gsub("TYPE", type.to_s)
+  #######################################
+  # The following methods are provided to
+  # easily override particular substitut-
+  # ions performed by to_s for subclasses
+  #######################################
+  def to_s_arch;        architecture.to_s;  end
+  def to_s_name;        name.to_s;          end
+  def to_s_fullversion; iteration ? "#{version}-#{iteration}" : "#{version}"; end
+  def to_s_version;     version.to_s;       end
+  def to_s_iteration;   iteration.to_s;     end
+  def to_s_epoch;       epoch.to_s;         end
+  def to_s_type;        type.to_s;          end
+  def to_s_extension;   type.to_s;          end
+  #######################################
+
+  def to_s(fmt=nil)
+    fmt = "NAME.EXTENSION" if fmt.nil?
+    return fmt.gsub("ARCH", to_s_arch) \
+      .gsub("NAME",         to_s_name) \
+      .gsub("FULLVERSION",  to_s_fullversion) \
+      .gsub("VERSION",      to_s_version) \
+      .gsub("ITERATION",    to_s_iteration) \
+      .gsub("EPOCH",        to_s_epoch) \
+      .gsub("TYPE",         to_s_type) \
+      .gsub("EXTENSION",    to_s_extension)
   end # def to_s
 
   def edit_file(path)

data/lib/fpm/package/apk.rb

@@ -0,0 +1,510 @@
+require "erb"
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/errors"
+require "fpm/util"
+require "backports"
+require "fileutils"
+require "digest"
+require 'digest/sha1'
+
+# Support for debian packages (.deb files)
+#
+# This class supports both input and output of packages.
+class FPM::Package::APK< FPM::Package
+
+  TAR_CHUNK_SIZE = 512
+  TAR_TYPEFLAG_OFFSET = 156
+  TAR_NAME_OFFSET_START = 0
+  TAR_NAME_OFFSET_END = 99
+  TAR_LENGTH_OFFSET_START = 124
+  TAR_LENGTH_OFFSET_END = 135
+  TAR_CHECKSUM_OFFSET_START = 148
+  TAR_CHECKSUM_OFFSET_END = 155
+  TAR_MAGIC_START = 257
+  TAR_MAGIC_END = 264
+  TAR_UID_START = 108
+  TAR_UID_END = 115
+  TAR_GID_START = 116
+  TAR_GID_END = 123
+  TAR_UNAME_START = 265
+  TAR_UNAME_END = 296
+  TAR_GNAME_START = 297
+  TAR_GNAME_END = 328
+  TAR_MAJOR_START = 329
+  TAR_MAJOR_END = 336
+  TAR_MINOR_START = 337
+  TAR_MINOR_END = 344
+
+  private
+
+  # Get the name of this package. See also FPM::Package#name
+  #
+  # This accessor actually modifies the name if it has some invalid or unwise
+  # characters.
+  def name
+    if @name =~ /[A-Z]/
+      logger.warn("apk packages should not have uppercase characters in their names")
+      @name = @name.downcase
+    end
+
+    if @name.include?("_")
+      logger.warn("apk packages should not include underscores")
+      @name = @name.gsub(/[_]/, "-")
+    end
+
+    if @name.include?(" ")
+      logger.warn("apk packages should not contain spaces")
+      @name = @name.gsub(/[ ]/, "-")
+    end
+
+    return @name
+  end
+
+  def prefix
+    return (attributes[:prefix] or "/")
+  end
+
+  def architecture
+
+    # "native" in apk should be "noarch"
+    if @architecture.nil? or @architecture == "native"
+      @architecture = "noarch"
+    end
+    return @architecture
+  end
+
+  def input(input_path)
+    logger.error("apk extraction is not yet implemented")
+  end
+
+  def output(output_path)
+
+    output_check(output_path)
+
+    control_path = build_path("control")
+    controltar_path = build_path("control.tar")
+    datatar_path = build_path("data.tar")
+
+    FileUtils.mkdir(control_path)
+
+    # data tar.
+    tar_path(staging_path(""), datatar_path)
+
+    # control tar.
+    begin
+      write_pkginfo(control_path)
+      write_control_scripts(control_path)
+      tar_path(control_path, controltar_path)
+    ensure
+      FileUtils.rm_r(control_path)
+    end
+
+    # concatenate the two into a real apk.
+    begin
+
+      # cut end-of-tar record from control tar
+      cut_tar_record(controltar_path)
+
+      # calculate/rewrite sha1 hashes for data tar
+      hash_datatar(datatar_path)
+
+      # concatenate the two into the final apk
+      concat_zip_tars(controltar_path, datatar_path, output_path)
+    end
+
+    logger.warn("apk output does not currently sign packages.")
+    logger.warn("It's recommended that your package be installed with '--allow-untrusted'")
+  end
+
+  def write_pkginfo(base_path)
+
+    pkginfo = ""
+
+    pkginfo << "# Generated by fpm\n"
+    pkginfo << "pkgname = #{@name}\n"
+    pkginfo << "pkgver = #{to_s("FULLVERSION")}\n"
+    pkginfo << "arch = #{architecture()}\n"
+    pkginfo << "pkgdesc = #{description()}\n"
+    pkginfo << "url = #{url()}\n"
+    pkginfo << "size = 102400\n" # totally magic, not sure what it's used for.
+
+    # write depends lines
+    for dependency in dependencies()
+      pkginfo << "depend = #{dependency}\n"
+    end
+
+    File.write("#{base_path}/.PKGINFO", pkginfo)
+  end
+
+  # Writes each control script from template into the build path,
+  # in the folder given by [base_path]
+  def write_control_scripts(base_path)
+
+    scripts = {}
+
+    scripts = register_script('post-install',   :after_install,   scripts)
+    scripts = register_script('post-install',   :before_install,  scripts)
+    scripts = register_script('post-install',   :before_upgrade,  scripts)
+    scripts = register_script('post-install',   :after_upgrade,  scripts)
+    scripts = register_script('pre-deinstall',  :before_remove,   scripts)
+    scripts = register_script('post-deinstall', :after_remove,    scripts)
+
+    scripts.each do |key, content|
+
+      File.write("#{base_path}/.#{key}", content)
+    end
+  end
+
+  # Convenience method for 'write_control_scripts' to register control scripts
+  # if they exist.
+  def register_script(key, value, hash)
+
+    if(script?(value))
+      hash[key] = scripts[value]
+    end
+    return hash
+  end
+
+  # Removes the end-of-tar records from the given [target_path].
+  # End of tar records are two contiguous empty tar records at the end of the file
+  # Taken together, they comprise 1k of null data.
+  def cut_tar_record(target_path)
+
+    temporary_target_path = target_path + "~"
+
+    record_length = 0
+    empty_records = 0
+
+    open(temporary_target_path, "wb") do |target_file|
+
+      # Scan to find the location of the two contiguous null records
+      open(target_path, "rb") do |file|
+
+        until(empty_records == 2)
+
+          header = file.read(TAR_CHUNK_SIZE)
+
+          # clear off ownership info
+          header = replace_ownership_headers(header, true)
+
+          typeflag = header[TAR_TYPEFLAG_OFFSET]
+          ascii_length = header[TAR_LENGTH_OFFSET_START..TAR_LENGTH_OFFSET_END]
+
+          if(file.eof?())
+            raise StandardError.new("Invalid tar stream, eof before end-of-tar record")
+          end
+
+          if(typeflag == "\0")
+            empty_records += 1
+            next
+          end
+
+          record_length = ascii_length.to_i(8)
+          record_length = determine_record_length(record_length)
+
+          target_file.write(header)
+          target_file.write(file.read(record_length))
+        end
+      end
+    end
+
+    FileUtils::mv(temporary_target_path, target_path)
+  end
+
+  # Rewrites the tar file located at the given [target_tar_path]
+  # to have its record headers use a simple checksum,
+  # and the apk sha1 hash extension.
+  def hash_datatar(target_path)
+
+    header = extension_header = ""
+    data = extension_data = ""
+    record_length = extension_length = 0
+    empty_records = 0
+
+    temporary_file_name = target_path + "~"
+
+    target_file = open(temporary_file_name, "wb")
+    file = open(target_path, "rb")
+    begin
+
+      until(file.eof?() || empty_records == 2)
+
+        header = file.read(TAR_CHUNK_SIZE)
+        typeflag = header[TAR_TYPEFLAG_OFFSET]
+        record_length = header[TAR_LENGTH_OFFSET_START..TAR_LENGTH_OFFSET_END].to_i(8)
+
+        data = ""
+        record_length = determine_record_length(record_length)
+
+        until(data.length == record_length)
+          data += file.read(TAR_CHUNK_SIZE)
+        end
+
+        # Clear ownership fields
+        header = replace_ownership_headers(header, false)
+
+        # If it's not a null record, do extension hash.
+        if(typeflag != "\0")
+          extension_header = header.dup()
+
+          extension_header = replace_ownership_headers(extension_header, true)
+
+          # directories have a magic string inserted into their name
+          full_record_path = extension_header[TAR_NAME_OFFSET_START..TAR_NAME_OFFSET_END].delete("\0")
+          full_record_path = add_paxstring(full_record_path)
+
+          # hash data contents with sha1, if there is any content.
+          if(typeflag == '5')
+
+            extension_data = ""
+
+            # ensure it doesn't end with a slash
+            if(full_record_path[full_record_path.length-1] == '/')
+              full_record_path = full_record_path.chop()
+            end
+          else
+            extension_data = hash_record(data)
+          end
+
+          full_record_path = pad_string_to(full_record_path, 100)
+          extension_header[TAR_NAME_OFFSET_START..TAR_NAME_OFFSET_END] = full_record_path
+
+          extension_header[TAR_TYPEFLAG_OFFSET] = 'x'
+          extension_header[TAR_LENGTH_OFFSET_START..TAR_LENGTH_OFFSET_END] = extension_data.length.to_s(8).rjust(12, '0')
+          extension_header = checksum_header(extension_header)
+
+          # write extension record
+          target_file.write(extension_header)
+          target_file.write(extension_data)
+        else
+          empty_records += 1
+        end
+
+        # write header and data to target file.
+        target_file.write(header)
+        target_file.write(data)
+      end
+      FileUtils.mv(temporary_file_name, target_path)
+    ensure
+      file.close()
+      target_file.close()
+    end
+  end
+
+  # Concatenates each of the given [apath] and [bpath] into the given [target_path]
+  def concat_zip_tars(apath, bpath, target_path)
+
+    temp_apath = apath + "~"
+    temp_bpath = bpath + "~"
+
+    # zip each path separately
+    Zlib::GzipWriter.open(temp_apath) do |target_writer|
+      open(apath, "rb") do |file|
+        until(file.eof?())
+          target_writer.write(file.read(4096))
+        end
+      end
+    end
+
+    Zlib::GzipWriter.open(temp_bpath) do |target_writer|
+      open(bpath, "rb") do |file|
+        until(file.eof?())
+          target_writer.write(file.read(4096))
+        end
+      end
+    end
+
+    # concat both into one.
+    File.open(target_path, "wb") do |target_writer|
+      open(temp_apath, "rb") do |file|
+        until(file.eof?())
+          target_writer.write(file.read(4096))
+        end
+      end
+      open(temp_bpath, "rb") do |file|
+        until(file.eof?())
+          target_writer.write(file.read(4096))
+        end
+      end
+    end
+  end
+
+  # Rounds the given [record_length] to the nearest highest evenly-divisble number of 512.
+  def determine_record_length(record_length)
+
+    sans_size = TAR_CHUNK_SIZE-1
+
+    if(record_length % TAR_CHUNK_SIZE != 0)
+      record_length = (record_length + sans_size) & ~sans_size;
+    end
+    return record_length
+  end
+
+  # Checksums the entire contents of the given [header]
+  # Writes the resultant checksum into indices 148-155 of the same [header],
+  # and returns the modified header.
+  # 148-155 is the "size" range in a tar/ustar header.
+  def checksum_header(header)
+
+    # blank out header checksum
+    replace_string_range(header, TAR_CHECKSUM_OFFSET_START, TAR_CHECKSUM_OFFSET_END, ' ')
+
+    # calculate new checksum
+    checksum = 0
+
+    for i in 0..(TAR_CHUNK_SIZE-1)
+      checksum += header.getbyte(i)
+    end
+
+    checksum = checksum.to_s(8).rjust(6, '0')
+    header[TAR_CHECKSUM_OFFSET_START..TAR_CHECKSUM_OFFSET_END-2] = checksum
+    header[TAR_CHECKSUM_OFFSET_END-1] = "\0"
+    return header
+  end
+
+  # SHA-1 hashes the given data, then places it in the APK hash string format
+  # then returns.
+  def hash_record(data)
+
+    # %u %s=%s\n
+    # len name=hash
+
+    hash = Digest::SHA1.hexdigest(data)
+    name = "APK-TOOLS.checksum.SHA1"
+
+    ret = "#{name}=#{hash}\n"
+
+    # the length requirement needs to know its own length too, because the length
+    # is the entire length of the line, not just the contents.
+    length = ret.length
+    line_length = length.to_s
+    length += line_length.length
+    candidate_ret = "#{line_length} #{ret}"
+
+    if(candidate_ret.length != length)
+      length += 1
+      candidate_ret = "#{length.to_s} #{ret}"
+    end
+
+    ret = candidate_ret
+
+    # pad out the result
+    ret = pad_string_to(ret, TAR_CHUNK_SIZE)
+    return ret
+  end
+
+  # Tars the current contents of the given [path] to the given [target_path].
+  def tar_path(path, target_path)
+
+    # Change directory to the source path, and glob files
+    # This is done so that we end up with a "flat" archive, that doesn't
+    # have any path artifacts from the packager's absolute path.
+    ::Dir::chdir(path) do
+      entries = ::Dir::glob("**", File::FNM_DOTMATCH)
+
+      args =
+      [
+        tar_cmd,
+        "-f",
+        target_path,
+        "-c"
+      ]
+
+      # Move pkginfo to the front, if it exists.
+      for i in (0..entries.length)
+        if(entries[i] == ".PKGINFO")
+          entries[i] = entries[0]
+          entries[0] = ".PKGINFO"
+          break
+        end
+      end
+
+      # add entries to arguments.
+      entries.each do |entry|
+        unless(entry == '..' || entry == '.')
+          args = args << entry
+        end
+      end
+
+      safesystem(*args)
+    end
+  end
+
+  # APK adds a "PAX" magic string into most directory names.
+  # This takes an unchanged directory name and "paxifies" it.
+  def add_paxstring(ret)
+
+    pax_slash = ret.rindex('/')
+    if(pax_slash == nil)
+      pax_slash = 0
+    else
+      pax_slash = ret.rindex('/', pax_slash-1)
+      if(pax_slash == nil || pax_slash < 0)
+        pax_slash = 0
+      end
+    end
+
+    ret = ret.insert(pax_slash, "/PaxHeaders.14670/")
+    ret = ret.sub("//", "/")
+    return ret
+  end
+
+  # Appends null zeroes to the end of [ret] until it is divisible by [length].
+  # Returns the padded result.
+  def pad_string_to(ret, length)
+
+    until(ret.length % length == 0)
+      ret << "\0"
+    end
+    return ret
+  end
+
+  # Replaces every character between [start] and [finish] in the given [str]
+  # with [character].
+  def replace_string_range(str, start, finish, character)
+
+    for i in (start..finish)
+      str[i] = character
+    end
+
+    return str
+  end
+
+  # Nulls out the ownership bits of the given tar [header].
+  def replace_ownership_headers(header, nullify_names)
+
+    # magic
+    header[TAR_MAGIC_START..TAR_MAGIC_END] = "ustar\0" + "00"
+
+    # ids
+    header = replace_string_range(header, TAR_UID_START, TAR_UID_END, "0")
+    header = replace_string_range(header, TAR_GID_START, TAR_GID_END, "0")
+    header[TAR_GID_END] = "\0"
+    header[TAR_UID_END] = "\0"
+
+    # names
+    if(nullify_names)
+      header = replace_string_range(header, TAR_UNAME_START, TAR_UNAME_END, "\0")
+      header = replace_string_range(header, TAR_GNAME_START, TAR_GNAME_END, "\0")
+
+      # major/minor
+      header[TAR_MAJOR_START..TAR_MAJOR_END] = "0".rjust(8, '0')
+      header[TAR_MINOR_START..TAR_MINOR_END] = "0".rjust(8, '0')
+      header[TAR_MAJOR_END] = "\0"
+      header[TAR_MINOR_END] = "\0"
+    else
+      header[TAR_UNAME_START..TAR_UNAME_END] = pad_string_to("root", 32)
+      header[TAR_GNAME_START..TAR_GNAME_END] = pad_string_to("root", 32)
+    end
+
+    return header
+  end
+
+  def to_s(format=nil)
+    return super("NAME_FULLVERSION_ARCH.TYPE") if format.nil?
+    return super(format)
+  end
+
+  public(:input, :output, :architecture, :name, :prefix, :converted_from, :to_s)
+end