cure-fpm 1.3.3b → 1.6.0b

data/lib/fpm/package/zip.rb

@@ -42,7 +42,7 @@ class FPM::Package::Zip < FPM::Package
   # the compression type.
   def output(output_path)
     output_check(output_path)
-    
+
     files = Find.find(staging_path).to_a
     safesystem("zip", output_path, *files)
   end # def output

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_comment
+
+    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

@@ -24,6 +24,8 @@ module FPM::Util
 
   # 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(":")
@@ -33,52 +35,168 @@ module FPM::Util
   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 program_in_path?(program) if !program.include?("/")
     return File.executable?(program)
   end # def program_exists?
 
   def default_shell
-    shell = ENV["SHELL"] 
+    shell = ENV["SHELL"]
     return "/bin/sh" if shell.nil? || shell.empty?
     return shell
   end
 
-  # 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] ]
+  ############################################################################
+  # 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
-    program = args[0]
 
-    if !program_exists?(program)
+    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 => args)
+    logger.debug("Running command", :args => args2)
 
-    # Create a pair of pipes to connect the
-    # invoked process to the cabin logger
     stdout_r, stdout_w = IO.pipe
     stderr_r, stderr_w = IO.pipe
 
-    process           = ChildProcess.build(*args)
+    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)
-    # 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)
+    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
-    success = (process.exit_code == 0)
+    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 #{process.exit_code})" \
+      raise ProcessFailed.new("#{program} failed (exit code #{exit_code})" \
                               ". Full command was:#{args.inspect}")
     end
     return success
@@ -95,29 +213,16 @@ module FPM::Util
       raise ExecutableNotFound.new(program)
     end
 
-    logger.debug("Running command", :args => args)
-
-    stdout_r, stdout_w = IO.pipe
-    stderr_r, stderr_w = IO.pipe
-
-    process           = ChildProcess.build(*args)
-    process.io.stdout = stdout_w
-    process.io.stderr = stderr_w
-
-    process.start
-    stdout_w.close; stderr_w.close
-    stdout_r_str = stdout_r.read
-    stdout_r.close; stderr_r.close
-    logger.debug("Process is running", :pid => process.pid)
-
-    process.wait
-    success = (process.exit_code == 0)
+    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 #{process.exit_code})" \
+      raise ProcessFailed.new("#{program} failed (exit code #{exit_code})" \
                               ". Full command was:#{args.inspect}")
     end
-
     return stdout_r_str
   end # def safesystemout
 
@@ -133,17 +238,14 @@ module FPM::Util
         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
 
-  # Run a block with a value.
-  # Useful in lieu of assigning variables 
-  def with(value, &block)
-    block.call(value)
-  end # def with
-
   # wrapper around mknod ffi calls
   def mknod_w(path, mode, dev)
     rc = -1
@@ -157,7 +259,30 @@ module FPM::Util
     rc
   end
 
-  def copy_entry(src, dst)
+  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)
@@ -173,7 +298,8 @@ module FPM::Util
       if known_entry
         FileUtils.ln(known_entry, dst)
       else
-        FileUtils.copy_entry(src, dst)
+        FileUtils.copy_entry(src, dst, preserve=preserve,
+                             remove_destination=remove_destination)
         copied_entries[[st.dev, st.ino]] = dst
       end
     end # else...
@@ -228,3 +354,5 @@ module FPM::Util
     @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