fpm-aeppert 1.6.2

data/lib/fpm/package/dir.rb

@@ -0,0 +1,221 @@
+require "fpm/package"
+require "fpm/util"
+require "backports"
+require "fileutils"
+require "find"
+require "socket"
+
+# A directory package.
+#
+# This class supports both input and output. As a note, 'output' will
+# only emit the files, not any metadata. This is an effective way
+# to extract another package type.
+class FPM::Package::Dir < FPM::Package
+  private
+
+  # Add a new path to this package.
+  #
+  # A special handling of the path occurs if it includes a '=' symbol.
+  # You can say "source=destination" and it will copy files from that source
+  # to the given destination in the package.
+  #
+  # This lets you take a local directory and map it to the desired location at
+  # packaging time. Such as: "./src/redis-server=/usr/local/bin" will make
+  # the local file ./src/redis-server appear as /usr/local/bin/redis-server in
+  # your package.
+  #
+  # If the path is a directory, it is copied recursively. The behavior
+  # of the copying is modified by the :chdir and :prefix attributes.
+  #
+  # If :prefix is set, the destination path is prefixed with that value.
+  # If :chdir is set, the current directory is changed to that value
+  # during the copy.
+  #
+  # Example: Copy /etc/X11 into this package as /opt/xorg/X11:
+  #
+  #     package.attributes[:prefix] = "/opt/xorg"
+  #     package.attributes[:chdir] = "/etc"
+  #     package.input("X11")
+  def input(path)
+    chdir = attributes[:chdir] || "."
+
+    # Support mapping source=dest
+    # This mapping should work the same way 'rsync -a' does
+    #   Meaning 'rsync -a source dest'
+    #   and 'source=dest' in fpm work the same as the above rsync
+    if path =~ /.=./ && !File.exists?(chdir == '.' ? path : File.join(chdir, path))
+      origin, destination = path.split("=", 2)
+
+      if File.directory?(origin) && origin[-1,1] == "/"
+        chdir = chdir == '.' ? origin : File.join(chdir, origin)
+        source = "."
+      else
+        origin_dir = File.dirname(origin)
+        chdir = chdir == '.' ? origin_dir : File.join(chdir, origin_dir)
+        source = File.basename(origin)
+      end
+    else
+      source, destination = path, "/"
+    end
+
+    if attributes[:prefix]
+      destination = File.join(attributes[:prefix], destination)
+    end
+
+    destination = File.join(staging_path, destination)
+
+    logger["method"] = "input"
+    begin
+      ::Dir.chdir(chdir) do
+        begin
+          clone(source, destination)
+        rescue Errno::ENOENT => e
+          raise FPM::InvalidPackageConfiguration,
+            "Cannot package the path '#{File.join(chdir, source)}', does it exist?"
+        end
+      end
+    rescue Errno::ENOENT => e
+      raise FPM::InvalidPackageConfiguration,
+        "Cannot chdir to '#{chdir}'. Does it exist?"
+    end
+
+    # Set some defaults. This is useful because other package types
+    # can include license data from themselves (rpms, gems, etc),
+    # but to make sure a simple dir -> rpm works without having
+    # to specify a license.
+    self.license = "unknown"
+    self.vendor = [ENV["USER"], Socket.gethostname].join("@")
+  ensure
+    # Clean up any logger context we added.
+    logger.remove("method")
+  end # def input
+
+  # Output this package to the given directory.
+  def output(output_path)
+    output_check(output_path)
+
+    output_path = File.expand_path(output_path)
+    ::Dir.chdir(staging_path) do
+      logger["method"] = "output"
+      clone(".", output_path)
+    end
+
+    # Write the scripts, too.
+    scripts_path = File.join(output_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))
+      require "pry"
+      binding.pry
+      File.chmod(0755, out)
+    end
+
+  ensure
+    logger.remove("method")
+  end # def output
+
+  private
+  # Copy a file or directory to a destination
+  #
+  # This is special because it respects the full path of the source.
+  # Aditionally, hardlinks will be used instead of copies.
+  #
+  # Example:
+  #
+  #     clone("/tmp/hello/world", "/tmp/example")
+  #
+  # The above will copy, recursively, /tmp/hello/world into
+  # /tmp/example/hello/world
+  def clone(source, destination)
+    logger.debug("Cloning path", :source => source, :destination => destination)
+    # Edge case check; abort if the temporary directory is the source.
+    # If the temporary dir is the same path as the source, it causes
+    # fpm to recursively (and forever) copy the staging directory by
+    # accident (#542).
+    if File.expand_path(source) == File.expand_path(::Dir.tmpdir)
+      raise FPM::InvalidPackageConfiguration,
+        "A source directory cannot be the root of your temporary " \
+        "directory (#{::Dir.tmpdir}). fpm uses the temporary directory " \
+        "to stage files during packaging, so this setting would have " \
+        "caused fpm to loop creating staging directories and copying " \
+        "them into your package! Oops! If you are confused, maybe you could " \
+        "check your TMPDIR, TMP, or TEMP environment variables?"
+    end
+
+    # For single file copies, permit file destinations
+    fileinfo = File.lstat(source)
+    if fileinfo.file? && !File.directory?(destination)
+      if destination[-1,1] == "/"
+        copy(source, File.join(destination, source))
+      else
+        copy(source, destination)
+      end
+    elsif fileinfo.symlink?
+      copy(source, File.join(destination, source))
+    else
+      # Copy all files from 'path' into staging_path
+      Find.find(source) do |path|
+        target = File.join(destination, path)
+        copy(path, target)
+      end
+    end
+  end # def clone
+
+  # Copy a path.
+  #
+  # Files will be hardlinked if possible, but copied otherwise.
+  # Symlinks should be copied as symlinks.
+  def copy(source, destination)
+    logger.debug("Copying path", :source => source, :destination => destination)
+    directory = File.dirname(destination)
+    # lstat to follow symlinks
+    dstat = File.stat(directory) rescue nil
+    if dstat.nil?
+      FileUtils.mkdir_p(directory, :mode => 0755)
+    elsif dstat.directory?
+      # do nothing, it's already a directory!
+    else
+      # It exists and is not a directory. This is probably a user error or a bug.
+      readable_path = directory.gsub(staging_path, "")
+      logger.error("You wanted to copy a file into a directory, but that's not a directory, it's a file!", :path => readable_path, :stat => dstat)
+      raise FPM::InvalidPackageConfiguration, "Tried to treat #{readable_path} like a directory, but it's a file!"
+    end
+
+    if File.directory?(source)
+      if !File.symlink?(source)
+        # Create a directory if this path is a directory
+        logger.debug("Creating", :directory => destination)
+        if !File.directory?(destination)
+          FileUtils.mkdir(destination)
+        end
+      else
+        # Linking symlinked directories causes a hardlink to be created, which
+        # results in the source directory being wiped out during cleanup,
+        # so copy the symlink.
+        logger.debug("Copying symlinked directory", :source => source,
+                      :destination => destination)
+        FileUtils.copy_entry(source, destination)
+      end
+    else
+      # Otherwise try copying the file.
+      begin
+        logger.debug("Linking", :source => source, :destination => destination)
+        File.link(source, destination)
+      rescue Errno::ENOENT, Errno::EXDEV, Errno::EPERM
+        # Hardlink attempt failed, copy it instead
+        logger.debug("Copying", :source => source, :destination => destination)
+        copy_entry(source, destination)
+      rescue Errno::EEXIST
+        sane_path = destination.gsub(staging_path, "")
+        logger.error("Cannot copy file, the destination path is probably a directory and I attempted to write a file.", :path => sane_path, :staging => staging_path)
+      end
+    end
+
+    copy_metadata(source, destination)
+  end # def copy
+
+  public(:input, :output)
+end # class FPM::Package::Dir

data/lib/fpm/package/empty.rb

@@ -0,0 +1,13 @@
+require "fpm/package"
+require "backports"
+
+# Empty Package type. For strict/meta/virtual package creation
+
+class FPM::Package::Empty < FPM::Package
+  def output(output_path)
+    logger.warn("Your package has gone into the void.")
+  end
+  def to_s(fmt)
+    return ""
+  end
+end

data/lib/fpm/package/freebsd.rb

@@ -0,0 +1,147 @@
+require "backports" # gem backports
+require "fpm/package"
+require "fpm/util"
+require "digest"
+require "fileutils"
+
+class FPM::Package::FreeBSD < FPM::Package
+  SCRIPT_MAP = {
+    :before_install     => "pre-install",
+    :after_install      => "post-install",
+    :before_remove      => "pre-deinstall",
+    :after_remove       => "post-deinstall",
+  } unless defined?(SCRIPT_MAP)
+
+  def self.default_abi
+    abi_name = %x{uname -s}.chomp
+    abi_version = %x{uname -r}.chomp.split(".")[0]
+    abi_arch = %x{uname -m}.chomp
+
+    [abi_name, abi_version, abi_arch].join(":")
+  end
+
+  option "--abi", "ABI",
+         "Sets the FreeBSD abi pkg field to specify binary compatibility.",
+         :default => default_abi
+
+  option "--origin", "ABI",
+         "Sets the FreeBSD 'origin' pkg field",
+         :default => "fpm/<name>"
+
+  def output(output_path)
+    # See https://github.com/jordansissel/fpm/issues/1090
+    # require xz later, because this triggers a load of liblzma.so.5 that is
+    # unavailable on older CentOS/RH distros.
+    require "xz"
+    output_check(output_path)
+
+    # Build the packaging metadata files.
+    checksums = {}
+    self.files.each do |f|
+      path = staging_path(f)
+      if File.symlink?(path)
+        checksums[f] = "-"
+      elsif File.file?(path)
+        checksums[f] = Digest::SHA256.file(path).hexdigest
+      end
+    end
+
+    pkg_origin = attributes[:freebsd_origin]
+    if pkg_origin == "fpm/<name>"  # fill in default
+      pkg_origin = "fpm/#{name}"
+    end
+
+    # Follow similar rules to these used in ``to_s_fullversion`` method.
+    # FIXME: maybe epoch should also be introduced somehow ("#{version},#{epoch})?
+    #        should it go to pkgdata["version"] or to another place?
+    # https://www.freebsd.org/doc/en/books/porters-handbook/makefile-naming.html
+    pkg_version = (iteration and (iteration.to_i > 0)) ?  "#{version}-#{iteration}" : "#{version}"
+
+    pkgdata = {
+      "abi" => attributes[:freebsd_abi],
+      "name" => name,
+      "version" => pkg_version,
+      "comment" => description,
+      "desc" => description,
+      "origin" => pkg_origin,
+      "maintainer" => maintainer,
+      "www" => url,
+      # prefix is required, but it doesn't seem to matter
+      "prefix" => "/",
+    }
+
+    # Write +COMPACT_MANIFEST, without the "files" section.
+    File.open(staging_path("+COMPACT_MANIFEST"), "w+") do |file|
+      file.write(pkgdata.to_json + "\n")
+    end
+
+    # Populate files + checksums, then write +MANIFEST.
+    pkgdata["files"] = {}
+    checksums.each do |f, shasum|
+      # pkg expands % URL-style escapes, so make sure to escape % as %25
+      pkgdata["files"]["/" + f.gsub("%", "%25")] = shasum
+    end
+
+    # Populate scripts
+    pkgdata["scripts"] = {}
+    scripts.each do |name, data|
+      pkgdata["scripts"][SCRIPT_MAP[name]] = data
+    end
+
+    File.open(staging_path("+MANIFEST"), "w+") do |file|
+      file.write(pkgdata.to_json + "\n")
+    end
+
+    # Create the .txz package archive from the files in staging_path.
+    File.open(output_path, "wb") do |file|
+      XZ::StreamWriter.new(file) do |xz|
+        FPM::Util::TarWriter.new(xz) do |tar|
+          # The manifests must come first for pkg.
+          add_path(tar, "+COMPACT_MANIFEST",
+                   File.join(staging_path, "+COMPACT_MANIFEST"))
+          add_path(tar, "+MANIFEST",
+                   File.join(staging_path, "+MANIFEST"))
+
+          checksums.keys.each do |path|
+            add_path(tar, "/" + path, File.join(staging_path, path))
+          end
+        end
+      end
+    end
+  end # def output
+
+  def add_path(tar, tar_path, path)
+    stat = File.lstat(path)
+    if stat.directory?
+      tar.mkdir(tar_path, stat.mode)
+    elsif stat.symlink?
+      tar.add_symlink(tar_path, File.readlink(path), stat.mode)
+    else
+      tar.add_file_simple(tar_path, stat.mode, stat.size) do |io|
+        File.open(path) do |fd|
+          chunk = nil
+          size = 0
+          while chunk = fd.read(16384) do
+            size += io.write(chunk)
+          end
+          if size != stat.size
+            raise "Failed to add #{path} to the archive; expected to " +
+                  "write #{stat.size} bytes, only wrote #{size}"
+          end
+        end
+      end # tar.tar.add_file_simple
+    end
+  end # def add_path
+
+  def to_s_extension; "txz"; end
+
+  def to_s_fullversion()
+    # iteration (PORTREVISION on FreeBSD) shall be appended only(?) if non-zero.
+    # https://www.freebsd.org/doc/en/books/porters-handbook/makefile-naming.html
+    (iteration and (iteration.to_i > 0)) ?  "#{version}_#{iteration}" : "#{version}"
+  end
+
+  def to_s(format=nil)
+    return super(format.nil? ? "NAME-FULLVERSION.EXTENSION" : format)
+  end # def to_s
+end # class FPM::Package::FreeBSD

data/lib/fpm/package/gem.rb

@@ -0,0 +1,243 @@
+require "fpm/namespace"
+require "fpm/package"
+require "rubygems"
+require "fileutils"
+require "fpm/util"
+require "yaml"
+
+# A rubygems package.
+#
+# This does not currently support 'output'
+#
+# The following attributes are supported:
+#
+# * :gem_bin_path
+# * :gem_package_name_prefix
+# * :gem_gem
+class FPM::Package::Gem < FPM::Package
+  # Flags '--foo' will be accessable  as attributes[:gem_foo]
+  option "--bin-path", "DIRECTORY", "The directory to install gem executables"
+  option "--package-prefix", "NAMEPREFIX",
+    "(DEPRECATED, use --package-name-prefix) Name to prefix the package " \
+    "name with." do |value|
+    logger = Cabin::Channel.get
+    logger.warn("Using deprecated flag: --package-prefix. Please use " \
+                 "--package-name-prefix")
+    value
+  end
+  option "--package-name-prefix", "PREFIX", "Name to prefix the package " \
+    "name with.", :default => "rubygem"
+  option "--gem", "PATH_TO_GEM",
+          "The path to the 'gem' tool (defaults to 'gem' and searches " \
+          "your $PATH)", :default => "gem"
+  option "--shebang", "SHEBANG",
+          "Replace the shebang in the executables in the bin path with a " \
+          "custom string", :default => nil
+  option "--fix-name", :flag, "Should the target package name be prefixed?",
+    :default => true
+  option "--fix-dependencies", :flag, "Should the package dependencies be " \
+    "prefixed?", :default => true
+  option "--env-shebang", :flag, "Should the target package have the " \
+    "shebang rewritten to use env?", :default => true
+
+  option "--prerelease", :flag, "Allow prerelease versions of a gem", :default => false
+  option "--disable-dependency", "gem_name",
+    "The gem name to remove from dependency list",
+    :multivalued => true, :attribute_name => :gem_disable_dependencies
+
+  option "--version-bins", :flag, "Append the version to the bins", :default => false
+
+  def input(gem)
+    # 'arg'  is the name of the rubygem we should unpack.
+    path_to_gem = download_if_necessary(gem, version)
+
+    # Got a good gem now (downloaded or otherwise)
+    #
+    # 1. unpack it into staging_path
+    # 2. take the metadata from it and update our wonderful package with it.
+    load_package_info(path_to_gem)
+    install_to_staging(path_to_gem)
+  end # def input
+
+  def download_if_necessary(gem, gem_version)
+    path = gem
+    if !File.exist?(path)
+      path = download(gem, gem_version)
+    end
+
+    logger.info("Using gem file", :path => path)
+    return path
+  end # def download_if_necessary
+
+  def download(gem_name, gem_version=nil)
+
+    logger.info("Trying to download", :gem => gem_name, :version => gem_version)
+
+    gem_fetch = [ "#{attributes[:gem_gem]}", "fetch", gem_name]
+
+    gem_fetch += ["--prerelease"] if attributes[:gem_prerelease?]
+    gem_fetch += ["--version", gem_version] if gem_version
+
+    download_dir = build_path(gem_name)
+    FileUtils.mkdir(download_dir) unless File.directory?(download_dir)
+
+    ::Dir.chdir(download_dir) do |dir|
+      logger.debug("Downloading in directory #{dir}")
+      safesystem(*gem_fetch)
+    end
+
+    gem_files = ::Dir.glob(File.join(download_dir, "*.gem"))
+
+    if gem_files.length != 1
+      raise "Unexpected number of gem files in #{download_dir},  #{gem_files.length} should be 1"
+    end
+
+    return gem_files.first
+  end # def download
+
+  def load_package_info(gem_path)
+
+    spec = YAML.load(%x{#{attributes[:gem_gem]} specification #{gem_path} --yaml})
+
+    if !attributes[:gem_package_prefix].nil?
+      attributes[:gem_package_name_prefix] = attributes[:gem_package_prefix]
+    end
+
+    # name prefixing is optional, if enabled, a name 'foo' will become
+    # 'rubygem-foo' (depending on what the gem_package_name_prefix is)
+    self.name = spec.name
+    if attributes[:gem_fix_name?]
+      self.name = fix_name(spec.name)
+    end
+
+    #self.name = [attributes[:gem_package_name_prefix], spec.name].join("-")
+    self.license = (spec.license or "no license listed in #{File.basename(gem_path)}")
+
+    # expand spec's version to match RationalVersioningPolicy to prevent cases
+    # where missing 'build' number prevents correct dependency resolution by target
+    # package manager. Ie. for dpkg 1.1 != 1.1.0
+    m = spec.version.to_s.scan(/(\d+)\.?/)
+    self.version = m.flatten.fill('0', m.length..2).join('.')
+
+    self.vendor = spec.author
+    self.url = spec.homepage
+    self.category = "Languages/Development/Ruby"
+
+    # if the gemspec has C extensions defined, then this should be a 'native' arch.
+    if !spec.extensions.empty?
+      self.architecture = "native"
+    else
+      self.architecture = "all"
+    end
+
+    # make sure we have a description
+    description_options = [ spec.description, spec.summary, "#{spec.name} - no description given" ]
+    self.description = description_options.find { |d| !(d.nil? or d.strip.empty?) }
+
+    # Upstream rpms seem to do this, might as well share.
+    # TODO(sissel): Figure out how to hint this only to rpm?
+    # maybe something like attributes[:rpm_provides] for rpm specific stuff?
+    # Or just ignore it all together.
+    #self.provides << "rubygem(#{self.name})"
+
+    # By default, we'll usually automatically provide this, but in the case that we are
+    # composing multiple packages, it's best to explicitly include it in the provides list.
+    self.provides << "#{self.name} = #{self.version}"
+
+    if !attributes[:no_auto_depends?]
+      spec.runtime_dependencies.map do |dep|
+        # rubygems 1.3.5 doesn't have 'Gem::Dependency#requirement'
+        if dep.respond_to?(:requirement)
+          reqs = dep.requirement.to_s
+        else
+          reqs = dep.version_requirements
+        end
+
+        # Some reqs can be ">= a, < b" versions, let's handle that.
+        reqs.to_s.split(/, */).each do |req|
+          if attributes[:gem_disable_dependencies]
+            next if attributes[:gem_disable_dependencies].include?(dep.name)
+          end
+
+          if attributes[:gem_fix_dependencies?]
+            name = fix_name(dep.name)
+          else
+            name = dep.name
+          end
+          self.dependencies << "#{name} #{req}"
+        end
+      end # runtime_dependencies
+    end #no_auto_depends
+  end # def load_package_info
+
+  def install_to_staging(gem_path)
+    if attributes.include?(:prefix) && ! attributes[:prefix].nil?
+      installdir = "#{staging_path}/#{attributes[:prefix]}"
+    else
+      gemdir = safesystemout(*[attributes[:gem_gem], 'env', 'gemdir']).chomp
+      installdir = File.join(staging_path, gemdir)
+    end
+
+    ::FileUtils.mkdir_p(installdir)
+    # TODO(sissel): Allow setting gem tool path
+    args = [attributes[:gem_gem], "install", "--quiet", "--no-ri", "--no-rdoc",
+       "--no-user-install", "--install-dir", installdir, "--ignore-dependencies"]
+    if attributes[:gem_env_shebang?]
+      args += ["-E"]
+    end
+
+    if attributes.include?(:gem_bin_path) && ! attributes[:gem_bin_path].nil?
+      bin_path = File.join(staging_path, attributes[:gem_bin_path])
+    else
+      gem_env  = safesystemout(*[attributes[:gem_gem], 'env']).split("\n")
+      gem_bin  = gem_env.select{ |line| line =~ /EXECUTABLE DIRECTORY/ }.first.split(': ').last
+      bin_path = File.join(staging_path, gem_bin)
+    end
+
+    args += ["--bindir", bin_path]
+    ::FileUtils.mkdir_p(bin_path)
+    args << gem_path
+    safesystem(*args)
+
+    # Replace the shebangs in the executables
+    if attributes[:gem_shebang]
+      ::Dir.entries(bin_path).each do |file_name|
+        # exclude . and ..
+        next if ['.', '..'].include?(file_name)
+        # exclude everything which is not a file
+        file_path = File.join(bin_path, file_name)
+        next unless File.ftype(file_path) == 'file'
+        # replace shebang in files if there is one
+        file = File.read(file_path)
+        if file.gsub!(/\A#!.*$/, "#!#{attributes[:gem_shebang]}")
+          File.open(file_path, 'w'){|f| f << file}
+        end
+      end
+    end
+
+    # Delete bin_path if it's empty, and any empty parents (#612)
+    # Above, we mkdir_p bin_path because rubygems aborts if the parent
+    # directory doesn't exist, for example:
+    #   ERROR:  While executing gem ... (Errno::ENOENT)
+    #       No such file or directory - /tmp/something/weird/bin
+    tmp = bin_path
+    while ::Dir.entries(tmp).size == 2 || tmp == "/"  # just [ "..", "." ] is an empty directory
+      logger.info("Deleting empty bin_path", :path => tmp)
+      ::Dir.rmdir(tmp)
+      tmp = File.dirname(tmp)
+    end
+    if attributes[:gem_version_bins?] and File.directory?(bin_path)
+      (::Dir.entries(bin_path) - ['.','..']).each do |bin|
+        FileUtils.mv("#{bin_path}/#{bin}", "#{bin_path}/#{bin}-#{self.version}")
+      end
+    end
+  end # def install_to_staging
+
+  # Sanitize package name.
+  # This prefixes the package name with 'rubygem' (but depends on the attribute
+  # :gem_package_name_prefix
+  def fix_name(name)
+    return [attributes[:gem_package_name_prefix], name].join("-")
+  end # def fix_name
+  public(:input, :output)
+end # class FPM::Package::Gem