fpm-aeppert 1.6.2

data/lib/fpm/rake_task.rb

@@ -0,0 +1,60 @@
+require "fpm/namespace"
+require "ostruct"
+require "rake"
+require "rake/tasklib"
+
+class FPM::RakeTask < Rake::TaskLib
+  attr_reader :options
+
+  def initialize(package_name, opts = {}, &block)
+    @options = OpenStruct.new(:name => package_name.to_s)
+    @source, @target = opts.values_at(:source, :target).map(&:to_s)
+    @directory = File.expand_path(opts[:directory].to_s)
+
+    (@source.empty? || @target.empty? || options.name.empty?) &&
+      abort("Must specify package name, source and output")
+
+    desc "Package #{@name}" unless ::Rake.application.last_description
+
+    task(options.name) do |_, task_args|
+      block.call(*[options, task_args].first(block.arity)) if block_given?
+      abort("Must specify args") unless options.respond_to?(:args)
+      @args = options.delete_field(:args)
+      run_cli
+    end
+  end
+
+  private
+
+  def parsed_options
+    options.to_h.map do |option, value|
+      opt = option.to_s.tr("_", "-")
+
+      case
+      when value.is_a?(String), value.is_a?(Symbol)
+        %W(--#{opt} #{value})
+      when value.is_a?(Array)
+        value.map { |v| %W(--#{opt} #{v}) }
+      when value.is_a?(TrueClass)
+        "--#{opt}"
+      when value.is_a?(FalseClass)
+        "--no-#{opt}"
+      else
+        fail TypeError, "Unexpected type: #{value.class}"
+      end
+    end
+  end
+
+  def run_cli
+    require "fpm"
+    require "fpm/command"
+
+    args = %W(-t #{@target} -s #{@source} -C #{@directory})
+    args << parsed_options
+    args << @args
+
+    args.flatten!.compact!
+
+    abort 'FPM failed!' unless FPM::Command.new("fpm").run(args) == 0
+  end
+end

data/lib/fpm/util.rb

@@ -0,0 +1,358 @@
+require "fpm/namespace"
+require "childprocess"
+require "ffi"
+
+# Some utility functions
+module FPM::Util
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+
+  # mknod is __xmknod in glibc a wrapper around mknod to handle
+  # various stat struct formats. See bits/stat.h in glibc source
+  begin
+    attach_function :mknod, :mknod, [:string, :uint, :ulong], :int
+  rescue FFI::NotFoundError
+    # glibc/io/xmknod.c int __xmknod (int vers, const char *path, mode_t mode, dev_t *dev)
+    attach_function :xmknod, :__xmknod, [:int, :string, :uint, :pointer], :int
+  end
+
+  # Raised if safesystem cannot find the program to run.
+  class ExecutableNotFound < StandardError; end
+
+  # Raised if a safesystem program exits nonzero
+  class ProcessFailed < StandardError; end
+
+  # Is the given program in the system's PATH?
+  def program_in_path?(program)
+    # return false if path is not set
+    return false unless ENV['PATH']
+    # Scan path to find the executable
+    # Do this to help the user get a better error message.
+    envpath = ENV["PATH"].split(":")
+    return envpath.select { |p| File.executable?(File.join(p, program)) }.any?
+  end # def program_in_path
+
+  def program_exists?(program)
+    # Scan path to find the executable
+    # Do this to help the user get a better error message.
+    return program_in_path?(program) if !program.include?("/")
+    return File.executable?(program)
+  end # def program_exists?
+
+  def default_shell
+    shell = ENV["SHELL"]
+    return "/bin/sh" if shell.nil? || shell.empty?
+    return shell
+  end
+
+  ############################################################################
+  # execmd([env,] cmd [,opts])
+  #
+  # Execute a command as a child process. The function allows to:
+  #
+  # - pass environment variables to child process,
+  # - communicate with stdin, stdout and stderr of the child process via pipes,
+  # - retrieve execution's status code.
+  #
+  # ---- EXAMPLE 1 (simple execution)
+  #
+  # if execmd(['which', 'python']) == 0
+  #   p "Python is installed"
+  # end
+  #
+  # ---- EXAMPLE 2 (custom environment variables)
+  #
+  # execmd({:PYTHONPATH=>'/home/me/foo'}, [ 'python', '-m', 'bar'])
+  #
+  # ---- EXAMPLE 3 (communicating via stdin, stdout and stderr)
+  #
+  # script = <<PYTHON
+  # import sys
+  # sys.stdout.write("normal output\n")
+  # sys.stdout.write("narning or error\n")
+  # PYTHON
+  # status = execmd('python') do |stdin,stdout,stderr|
+  #   stdin.write(script)
+  #   stdin.close
+  #   p "STDOUT: #{stdout.read}"
+  #   p "STDERR: #{stderr.read}"
+  # end
+  # p "STATUS: #{status}"
+  #
+  # ---- EXAMPLE 4 (additional options)
+  #
+  # execmd(['which', 'python'], :process=>true, :stdin=>false, :stderr=>false) do |process,stdout|
+  #  p = stdout.read.chomp
+  #  process.wait
+  #  if (x = process.exit_code) == 0
+  #    p "PYTHON: #{p}"
+  #  else
+  #    p "ERROR:  #{x}"
+  #  end
+  # end
+  #
+  #
+  # OPTIONS:
+  #
+  #   :process (default: false) -- pass process object as the first argument the to block,
+  #   :stdin   (default: true)  -- pass stdin object of the child process to the block for writting,
+  #   :stdout  (default: true)  -- pass stdout object of the child process to the block for reading,
+  #   :stderr  (default: true)  -- pass stderr object of the child process to the block for reading,
+  #
+  def execmd(*args)
+    i = 0
+    if i < args.size
+      if args[i].kind_of?(Hash)
+        # args[0] may contain environment variables
+        env = args[i]
+        i += 1
+      else
+        env = Hash[]
+      end
+    end
+
+    if i < args.size
+      if args[i].kind_of?(Array)
+        args2 = args[i]
+      else
+        args2 = [ args[i] ]
+      end
+      program = args2[0]
+      i += 1
+    else
+      raise ArgumentError.new("missing argument: cmd")
+    end
+
+    if i < args.size
+      if args[i].kind_of?(Hash)
+        opts = Hash[args[i].map {|k,v| [k.to_sym, v]} ]
+        i += 1
+      end
+    else
+      opts = Hash[]
+    end
+
+    opts[:process] = false unless opts.include?(:process)
+    opts[:stdin]   = true  unless opts.include?(:stdin)
+    opts[:stdout]  = true  unless opts.include?(:stdout)
+    opts[:stderr]  = true  unless opts.include?(:stderr)
+
+    if !program.include?("/") and !program_in_path?(program)
+      raise ExecutableNotFound.new(program)
+    end
+
+    logger.debug("Running command", :args => args2)
+
+    stdout_r, stdout_w = IO.pipe
+    stderr_r, stderr_w = IO.pipe
+
+    process = ChildProcess.build(*args2)
+    process.environment.merge!(env)
+
+    process.io.stdout = stdout_w
+    process.io.stderr = stderr_w
+
+    if block_given? and opts[:stdin]
+      process.duplex = true
+    end
+
+    process.start
+
+    stdout_w.close; stderr_w.close
+    logger.debug("Process is running", :pid => process.pid)
+    if block_given?
+      args3 = []
+      args3.push(process)           if opts[:process]
+      args3.push(process.io.stdin)  if opts[:stdin]
+      args3.push(stdout_r)          if opts[:stdout]
+      args3.push(stderr_r)          if opts[:stderr]
+
+      yield(*args3)
+
+      process.io.stdin.close        if opts[:stdin] and not process.io.stdin.closed?
+      stdout_r.close                unless stdout_r.closed?
+      stderr_r.close                unless stderr_r.closed?
+    else
+      # Log both stdout and stderr as 'info' because nobody uses stderr for
+      # actually reporting errors and as a result 'stderr' is a misnomer.
+      logger.pipe(stdout_r => :info, stderr_r => :info)
+    end
+
+    process.wait if process.alive?
+
+    return process.exit_code
+  end # def execmd
+
+  # Run a command safely in a way that gets reports useful errors.
+  def safesystem(*args)
+    # ChildProcess isn't smart enough to run a $SHELL if there's
+    # spaces in the first arg and there's only 1 arg.
+    if args.size == 1
+      args = [ default_shell, "-c", args[0] ]
+    end
+    program = args[0]
+
+    exit_code = execmd(args)
+    success = (exit_code == 0)
+
+    if !success
+      raise ProcessFailed.new("#{program} failed (exit code #{exit_code})" \
+                              ". Full command was:#{args.inspect}")
+    end
+    return success
+  end # def safesystem
+
+  # Run a command safely in a way that captures output and status.
+  def safesystemout(*args)
+    if args.size == 1
+      args = [ ENV["SHELL"], "-c", args[0] ]
+    end
+    program = args[0]
+
+    if !program.include?("/") and !program_in_path?(program)
+      raise ExecutableNotFound.new(program)
+    end
+
+    stdout_r_str = nil
+    exit_code = execmd(args, :stdin=>false, :stderr=>false) do |stdout|
+      stdout_r_str = stdout.read
+    end
+    success = (exit_code == 0)
+
+    if !success
+      raise ProcessFailed.new("#{program} failed (exit code #{exit_code})" \
+                              ". Full command was:#{args.inspect}")
+    end
+    return stdout_r_str
+  end # def safesystemout
+
+  # 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
+      end
+    when "FreeBSD"
+      # use gnutar instead
+      return "gtar"
+    else
+      return "tar"
+    end
+  end # def tar_cmd
+
+  # wrapper around mknod ffi calls
+  def mknod_w(path, mode, dev)
+    rc = -1
+    case %x{uname -s}.chomp
+    when 'Linux'
+      # bits/stat.h #define _MKNOD_VER_LINUX  0
+      rc = xmknod(0, path, mode, FFI::MemoryPointer.new(dev))
+    else
+      rc = mknod(path, mode, dev)
+    end
+    rc
+  end
+
+  def copy_metadata(source, destination)
+    source_stat = File::lstat(source)
+    dest_stat = File::lstat(destination)
+
+    # If this is a hard-link, there's no metadata to copy.
+    # If this is a symlink, what it points to hasn't been copied yet.
+    return if source_stat.ino == dest_stat.ino || dest_stat.symlink?
+
+    File.utime(source_stat.atime, source_stat.mtime, destination)
+    mode = source_stat.mode
+    begin
+      File.lchown(source_stat.uid, source_stat.gid, destination)
+    rescue Errno::EPERM
+      # clear setuid/setgid
+      mode &= 01777
+    end
+
+    unless source_stat.symlink?
+      File.chmod(mode, destination)
+    end
+  end # def copy_metadata
+
+
+  def copy_entry(src, dst, preserve=false, remove_destination=false)
+    case File.ftype(src)
+    when 'fifo', 'characterSpecial', 'blockSpecial', 'socket'
+      st = File.stat(src)
+      rc = mknod_w(dst, st.mode, st.dev)
+      raise SystemCallError.new("mknod error", FFI.errno) if rc == -1
+    when 'directory'
+      FileUtils.mkdir(dst) unless File.exists? dst
+    else
+      # if the file with the same dev and inode has been copied already -
+      # hard link it's copy to `dst`, otherwise make an actual copy
+      st = File.lstat(src)
+      known_entry = copied_entries[[st.dev, st.ino]]
+      if known_entry
+        FileUtils.ln(known_entry, dst)
+      else
+        FileUtils.copy_entry(src, dst, preserve=preserve,
+                             remove_destination=remove_destination)
+        copied_entries[[st.dev, st.ino]] = dst
+      end
+    end # else...
+  end # def copy_entry
+
+  def copied_entries
+    # TODO(sissel): I wonder that this entry-copy knowledge needs to be put
+    # into a separate class/module. As is, calling copy_entry the same way
+    # in slightly different contexts will result in weird or bad behavior.
+    # What I mean is if we do:
+    #   pkg = FPM::Package::Dir...
+    #   pkg.output()...
+    #   pkg.output()...
+    # The 2nd output call will fail or behave weirdly because @copied_entries
+    # is already populated. even though this is anew round of copying.
+    return @copied_entries ||= {}
+  end # def copied_entries
+
+  def expand_pessimistic_constraints(constraint)
+    name, op, version = constraint.split(/\s+/)
+
+    if op == '~>'
+
+      new_lower_constraint = "#{name} >= #{version}"
+
+      version_components = version.split('.').collect { |v| v.to_i }
+
+      version_prefix = version_components[0..-3].join('.')
+      portion_to_work_with = version_components.last(2)
+
+      prefix = ''
+      unless version_prefix.empty?
+        prefix = version_prefix + '.'
+      end
+
+      one_to_increment = portion_to_work_with[0].to_i
+      incremented = one_to_increment + 1
+
+      new_version = ''+ incremented.to_s + '.0'
+
+      upper_version = prefix + new_version
+
+      new_upper_constraint = "#{name} < #{upper_version}"
+
+      return [new_lower_constraint,new_upper_constraint]
+    else
+      return [constraint]
+    end
+  end #def expand_pesimistic_constraints
+
+  def logger
+    @logger ||= Cabin::Channel.get
+  end # def logger
+end # module FPM::Util
+
+require 'fpm/util/tar_writer'

data/lib/fpm/util/tar_writer.rb

@@ -0,0 +1,80 @@
+require 'rubygems/package'
+
+module FPM
+  module Issues
+    module TarWriter
+      # See https://github.com/rubygems/rubygems/issues/1608
+      def self.has_issue_1608?
+        name, prefix = nil,nil
+        io = StringIO.new
+        ::Gem::Package::TarWriter.new(io) do |tw|
+          name, prefix = tw.split_name('/123456789'*9 + '/1234567890') # abs name 101 chars long
+        end
+        return prefix.empty?
+      end
+
+      def self.has_issues_with_split_name?
+        return false unless ::Gem::Package::TarWriter.method_defined?(:split_name)
+        return has_issue_1608?
+      end
+
+      def self.has_issues_with_add_symlink?
+        return !::Gem::Package::TarWriter.public_instance_methods.include?(:add_symlink)
+      end
+    end # module TarWriter
+  end # module Issues
+end # module FPM
+
+module FPM; module Util; end; end
+
+# Like the ::Gem::Package::TarWriter but contains some backports and bug fixes
+class FPM::Util::TarWriter < ::Gem::Package::TarWriter
+  if FPM::Issues::TarWriter.has_issues_with_split_name?
+    def split_name(name)
+      if name.bytesize > 256 then
+        raise ::Gem::Package::TooLongFileName.new("File \"#{name}\" has a too long path (should be 256 or less)")
+      end
+
+      prefix = ''
+      if name.bytesize > 100 then
+        parts = name.split('/', -1) # parts are never empty here
+        name = parts.pop            # initially empty for names with a trailing slash ("foo/.../bar/")
+        prefix = parts.join('/')    # if empty, then it's impossible to split (parts is empty too)
+        while !parts.empty? && (prefix.bytesize > 155 || name.empty?)
+          name = parts.pop + '/' + name
+          prefix = parts.join('/')
+        end
+
+        if name.bytesize > 100 or prefix.empty? then
+          raise ::Gem::Package::TooLongFileName.new("File \"#{prefix}/#{name}\" has a too long name (should be 100 or less)")
+        end
+
+        if prefix.bytesize > 155 then
+          raise ::Gem::Package::TooLongFileName.new("File \"#{prefix}/#{name}\" has a too long base path (should be 155 or less)")
+        end
+      end
+
+      return name, prefix
+    end
+  end # if FPM::Issues::TarWriter.spit_name_has_issues?
+
+  if FPM::Issues::TarWriter.has_issues_with_add_symlink?
+    # Backport Symlink Support to TarWriter
+    # https://github.com/rubygems/rubygems/blob/4a778c9c2489745e37bcc2d0a8f12c601a9c517f/lib/rubygems/package/tar_writer.rb#L239-L253
+    def add_symlink(name, target, mode)
+      check_closed
+
+      name, prefix = split_name name
+
+      header = ::Gem::Package::TarHeader.new(:name => name, :mode => mode,
+                                             :size => 0, :typeflag => "2",
+                                             :linkname => target,
+                                             :prefix => prefix,
+                                             :mtime => Time.now).to_s
+
+      @io.write header
+
+      self
+    end # def add_symlink
+  end
+end