fpm 1.5.0 → 1.6.0

data/lib/fpm/package/cpan.rb

@@ -297,7 +297,7 @@ class FPM::Package::CPAN < FPM::Package
       release_response = httpfetch(metacpan_release_url)
     rescue Net::HTTPServerException => e
       logger.error("metacpan release query failed.", :error => e.message,
-                    :module => package, :url => metacpan_release_url)
+                    :url => metacpan_release_url)
       raise FPM::InvalidPackageConfiguration, "metacpan release query failed"
     end
 

data/lib/fpm/package/deb.rb

@@ -494,7 +494,8 @@ class FPM::Package::Deb < FPM::Package
 
     attributes.fetch(:deb_upstart_list, []).each do |upstart|
       name = File.basename(upstart, ".upstart")
-      dest_upstart = staging_path("etc/init/#{name}.conf")
+      name = "#{name}.conf" if !(name =~ /\.conf$/)
+      dest_upstart = staging_path("etc/init/#{name}")
       mkdir_p(File.dirname(dest_upstart))
       FileUtils.cp(upstart, dest_upstart)
       File.chmod(0644, dest_upstart)
@@ -905,8 +906,7 @@ class FPM::Package::Deb < FPM::Package
   def to_s(format=nil)
     # Default format if nil
     # git_1.7.9.3-1_amd64.deb
-    return super("NAME_FULLVERSION_ARCH.TYPE") if format.nil?
-    return super(format)
+    return super(format.nil? ? "NAME_FULLVERSION_ARCH.EXTENSION" : format)
   end # def to_s
 
   def data_tar_flags

data/lib/fpm/package/dir.rb

@@ -99,6 +99,20 @@ class FPM::Package::Dir < FPM::Package
       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

data/lib/fpm/package/freebsd.rb

@@ -3,9 +3,7 @@ require "fpm/package"
 require "fpm/util"
 require "digest"
 require "fileutils"
-require "rubygems/package"
 require "xz"
-require "corefines"
 
 class FPM::Package::FreeBSD < FPM::Package
   SCRIPT_MAP = {
@@ -50,7 +48,11 @@ class FPM::Package::FreeBSD < FPM::Package
       pkg_origin = "fpm/#{name}"
     end
 
-    pkg_version = "#{version}-#{iteration || 1}"
+    # 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],
@@ -90,7 +92,7 @@ class FPM::Package::FreeBSD < FPM::Package
     # Create the .txz package archive from the files in staging_path.
     File.open(output_path, "wb") do |file|
       XZ::StreamWriter.new(file) do |xz|
-        ::Gem::Package::TarWriter.new(xz) do |tar|
+        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"))
@@ -128,38 +130,15 @@ class FPM::Package::FreeBSD < FPM::Package
     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 "#{name}-#{version}_#{iteration || 1}.txz"
-    return super(format)
+    return super(format.nil? ? "NAME-FULLVERSION.EXTENSION" : format)
   end # def to_s
 end # class FPM::Package::FreeBSD
-
-# Backport Symlink Support to TarWriter
-# https://github.com/rubygems/rubygems/blob/4a778c9c2489745e37bcc2d0a8f12c601a9c517f/lib/rubygems/package/tar_writer.rb#L239-L253
-module TarWriterAddSymlink
-  refine Gem::Package::TarWriter do
-    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 # refine Gem::Package::TarWriter
-end # module TarWriterAddSymlink
-
-module Util
-  module Tar
-    unless Gem::Package::TarWriter.public_instance_methods.include? :add_symlink
-      using TarWriterAddSymlink
-    end
-  end # module Tar
-end # module Util

data/lib/fpm/package/gem.rb

@@ -178,7 +178,7 @@ class FPM::Package::Gem < FPM::Package
     ::FileUtils.mkdir_p(installdir)
     # TODO(sissel): Allow setting gem tool path
     args = [attributes[:gem_gem], "install", "--quiet", "--no-ri", "--no-rdoc",
-       "--install-dir", installdir, "--ignore-dependencies"]
+       "--no-user-install", "--install-dir", installdir, "--ignore-dependencies"]
     if attributes[:gem_env_shebang?]
       args += ["-E"]
     end

data/lib/fpm/package/osxpkg.rb

@@ -154,9 +154,10 @@ class FPM::Package::OSXpkg < FPM::Package
     FileUtils.remove_file(temp_info)
   end # def output
 
+  def to_s_extension; "pkg"; end
+
   def to_s(format=nil)
-    return super("NAME-VERSION.pkg") if format.nil?
-    return super(format)
+    return super(format.nil? ? "NAME-VERSION.EXTENSION" : format)
   end # def to_s
 
   public(:input, :output, :identifier, :to_s)

data/lib/fpm/package/pacman.rb

@@ -306,11 +306,12 @@ class FPM::Package::Pacman < FPM::Package
     end
   end # def default_output
 
+  def to_s_extension; "pkg.tar#{compression_ending}"; end
+
   def to_s(format=nil)
     # Default format if nil
-    # git_1.7.9.3-1_amd64.deb
-    return super("NAME-FULLVERSION-ARCH.pkg.tar#{compression_ending}") if format.nil?
-    return super(format)
+    # git_1.7.9.3-1-amd64.pkg.tar.xz
+    return super(format.nil? ? "NAME-FULLVERSION-ARCH.EXTENSION" : format)
   end # def to_s
 
   private

data/lib/fpm/package/pleaserun.rb

@@ -0,0 +1,63 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+
+require "pleaserun/cli"
+
+# A pleaserun package.
+#
+# This does not currently support 'output'
+class FPM::Package::PleaseRun < FPM::Package
+  # TODO(sissel): Implement flags.
+  
+  require "pleaserun/platform/systemd"
+  require "pleaserun/platform/upstart"
+  require "pleaserun/platform/launchd"
+  require "pleaserun/platform/sysv"
+
+  option "--name", "SERVICE_NAME", "The name of the service you are creating"
+
+  private
+  def input(command)
+    platforms = [
+      ::PleaseRun::Platform::Systemd.new("default"), # RHEL 7, Fedora 19+, Debian 8, Ubuntu 16.04
+      ::PleaseRun::Platform::Upstart.new("1.5"), # Recent Ubuntus
+      ::PleaseRun::Platform::Upstart.new("0.6.5"), # CentOS 6
+      ::PleaseRun::Platform::Launchd.new("10.9"), # OS X
+      ::PleaseRun::Platform::SYSV.new("lsb-3.1") # Ancient stuff
+    ]
+
+    attributes[:pleaserun_name] ||= File.basename(command.first)
+    attributes[:prefix] ||= "/usr/share/pleaserun/#{attributes[:pleaserun_name]}"
+
+    platforms.each do |platform|
+      logger.info("Generating service manifest.", :platform => platform.class.name)
+      platform.program = command.first
+      platform.name = attributes[:pleaserun_name]
+      platform.args = command[1..-1]
+      platform.description = if attributes[:description_given?]
+        attributes[:description]
+      else
+        platform.name
+      end
+      base = staging_path(File.join(attributes[:prefix], "#{platform.platform}/#{platform.target_version || "default"}"))
+      target = File.join(base, "files")
+      actions_script = File.join(base, "install_actions.sh")
+      ::PleaseRun::Installer.install_files(platform, target, false)
+      ::PleaseRun::Installer.write_actions(platform, actions_script)
+    end
+
+    libs = [ "install.sh", "install-path.sh", "generate-cleanup.sh" ]
+    libs.each do |file|
+      base = staging_path(File.join(attributes[:prefix]))
+      File.write(File.join(base, file), template(File.join("pleaserun", file)).result(binding))
+      File.chmod(0755, File.join(base, file))
+    end
+
+    scripts[:after_install] = template(File.join("pleaserun", "scripts", "after-install.sh")).result(binding)
+    scripts[:before_remove] = template(File.join("pleaserun", "scripts", "before-remove.sh")).result(binding)
+  end # def input
+
+  public(:input)
+end # class FPM::Package::PleaseRun

data/lib/fpm/package/python.rb

@@ -131,7 +131,8 @@ class FPM::Package::Python < FPM::Package
                  "--build-directory", target, want_pkg)
     else
       logger.debug("using pip", :pip => attributes[:python_pip])
-      safesystem(attributes[:python_pip], "install", "--no-deps", "--no-install", "--no-use-wheel", "-i", attributes[:python_pypi], "-U", "--build", target, want_pkg)
+      # TODO: Support older versions of pip
+      safesystem(attributes[:python_pip], "download", "--no-clean", "--no-deps", "--no-binary", ":all:", "-i", attributes[:python_pypi], "--build", target,  want_pkg)
     end
 
     # easy_install will put stuff in @tmpdir/packagename/, so find that:

data/lib/fpm/package/rpm.rb

@@ -560,12 +560,19 @@ class FPM::Package::RPM < FPM::Package
     return @epoch
   end # def epoch
 
+  def to_s_dist;
+    attributes[:rpm_dist] ? "#{attributes[:rpm_dist]}" : "DIST";
+  end
+
   def to_s(format=nil)
     if format.nil?
-      return super("NAME-VERSION-ITERATION.DIST.ARCH.TYPE").gsub('DIST', attributes[:rpm_dist]) if attributes[:rpm_dist]
-      return super("NAME-VERSION-ITERATION.ARCH.TYPE")
+      format = if attributes[:rpm_dist]
+        "NAME-VERSION-ITERATION.DIST.ARCH.EXTENSION"
+      else
+        "NAME-VERSION-ITERATION.ARCH.EXTENSION"
+      end
     end
-    return super(format)
+    return super(format.gsub("DIST", to_s_dist))
   end # def to_s
 
   def payload_compression

data/lib/fpm/package/tar.rb

@@ -48,6 +48,18 @@ class FPM::Package::Tar < FPM::Package
   # the compression type.
   def output(output_path)
     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
+
     # Unpack the tarball to the staging path
     args = ["-cf", output_path, "-C", staging_path]
     tar_compression_flag(output_path).tap do |flag|

data/lib/fpm/package/virtualenv.rb

@@ -92,7 +92,7 @@ class FPM::Package::Virtualenv < FPM::Package
     end
 
     ::Dir[build_path + "/**/*"].each do |f|
-      if ! File.world_readable? f
+      if ! File.readable? f
         File.lchmod(File.stat(f).mode | 444)
       end
     end

data/lib/fpm/rake_task.rb

@@ -1,3 +1,4 @@
+require "fpm/namespace"
 require "ostruct"
 require "rake"
 require "rake/tasklib"
@@ -54,6 +55,6 @@ class FPM::RakeTask < Rake::TaskLib
 
     args.flatten!.compact!
 
-    exit(FPM::Command.new("fpm").run(args) || 0)
+    abort 'FPM failed!' unless FPM::Command.new("fpm").run(args) == 0
   end
 end

data/lib/fpm/util.rb

@@ -45,42 +45,158 @@ module FPM::Util
     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
+
+    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
-    program = args[0]
 
-    if !program_exists?(program)
+    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 if process.alive?
 
-    process.wait
-    success = (process.exit_code == 0)
+    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
@@ -97,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
 
@@ -251,3 +354,5 @@ module FPM::Util
     @logger ||= Cabin::Channel.get
   end # def logger
 end # module FPM::Util
+
+require 'fpm/util/tar_writer'