fpm 0.4.42 → 1.0.0

data/lib/fpm/package/dir.rb

@@ -1,4 +1,5 @@
 require "fpm/package"
+require "fpm/util"
 require "backports"
 require "fileutils"
 require "find"
@@ -42,14 +43,15 @@ class FPM::Package::Dir < FPM::Package
     # 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 =~ /.=./
+    if path =~ /.=./ && !File.exists?(chdir == '.' ? path : File.join(chdir, path))
       origin, destination = path.split("=", 2)
 
       if File.directory?(origin) && origin[-1,1] == "/"
-        chdir = origin
+        chdir = chdir == '.' ? origin : File.join(chdir, origin)
         source = "."
       else
-        chdir = File.dirname(origin)
+        origin_dir = File.dirname(origin)
+        chdir = chdir == '.' ? origin_dir : File.join(chdir, origin_dir)
         source = File.basename(origin)
       end
     else
@@ -63,8 +65,18 @@ class FPM::Package::Dir < FPM::Package
     destination = File.join(staging_path, destination)
 
     @logger["method"] = "input"
-    ::Dir.chdir(chdir) do
-      clone(source, destination)
+    begin
+      ::Dir.chdir(chdir) do
+        begin
+          clone(source, destination)
+        rescue Errno::ENOENT => e
+          raise FPM::InvalidPackageConfiguration,
+            "Cannot package the path '#{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
@@ -105,6 +117,20 @@ class FPM::Package::Dir < FPM::Package
   # /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 or TEMPDIR environment variables?"
+    end
+
     # For single file copies, permit file destinations
     if File.file?(source) && !File.directory?(destination) 
       if destination[-1,1] == "/"
@@ -155,7 +181,7 @@ class FPM::Package::Dir < FPM::Package
       rescue Errno::ENOENT, Errno::EXDEV, Errno::EPERM
         # Hardlink attempt failed, copy it instead
         @logger.debug("Copying", :source => source, :destination => destination)
-        FileUtils.copy_entry(source, 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)

data/lib/fpm/package/gem.rb

@@ -89,7 +89,7 @@ class FPM::Package::Gem < FPM::Package
 
   def load_package_info(gem_path)
 
-    spec = YAML.load(%x{#{attributes[:gem_gem]} spec #{gem_path} --yaml})
+    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]

data/lib/fpm/package/npm.rb

@@ -11,6 +11,9 @@ class FPM::Package::NPM < FPM::Package
   option "--package-name-prefix", "PREFIX", "Name to prefix the package " \
     "name with.", :default => "node"
 
+  option "--registry", "NPM_REGISTRY",
+    "The npm registry to use instead of the default."
+
   private
   def input(package)
     # Notes:
@@ -21,6 +24,10 @@ class FPM::Package::NPM < FPM::Package
       "global" => "true"
     }
 
+    if attributes.include?(:npm_registry) && !attributes[:npm_registry].nil?
+      settings["registry"] = attributes[:npm_registry]
+    end
+
     if attributes.include?(:prefix) && !attributes[:prefix].nil?
       settings["prefix"] = staging_path(attributes[:prefix])
     else

data/lib/fpm/package/pkgin.rb

@@ -0,0 +1,35 @@
+class FPM::Package::Pkgin < FPM::Package
+
+  def output(output_path)
+    output_check(output_path)
+
+    File.write(build_path("build-info"), `pkg_info -X pkg_install | egrep '^(MACHINE_ARCH|OPSYS|OS_VERSION|PKGTOOLS_VERSION)'`)
+
+    cwd = ::Dir.pwd
+    ::Dir.chdir(staging_path)
+
+    files = []
+    Find.find(".") do |path|
+      stat = File.lstat(path)
+      next unless stat.symlink? or stat.file?
+      files << path
+    end
+    ::Dir.chdir(cwd)
+
+    File.write(build_path("packlist"), files.sort.join("\n"))
+
+    File.write(build_path("comment"),  self.description + "\n")
+
+    File.write(build_path("description"), self.description + "\n")
+
+    args = [ "-B", build_path("build-info"), "-c", build_path("comment"), "-d", build_path("description"), "-f", build_path("packlist"), "-I", "/opt/local", "-p", staging_path,  "-U", "#{cwd}/#{name}-#{self.version}-#{iteration}.tgz" ]
+    safesystem("pkg_create", *args)
+
+  end
+
+  def iteration
+    return @iteration ? @iteration : 1
+  end
+
+end
+

data/lib/fpm/package/pyfpm/get_metadata.py

@@ -1,11 +1,23 @@
 from distutils.core import Command
 import os
+import sys
 import pkg_resources
 try:
     import json
 except ImportError:
     import simplejson as json
 
+PY3 = sys.version_info[0] == 3
+
+if PY3:
+    def u(s):
+        return s
+else:
+    def u(s):
+        if isinstance(u, unicode):
+            return u
+        return s.decode('utf-8')
+
 
 # Note, the last time I coded python daily was at Google, so it's entirely
 # possible some of my techniques below are outdated or bad.
@@ -17,12 +29,14 @@ class get_metadata(Command):
     user_options = [
         ('load-requirements-txt', 'l',
          "load dependencies from requirements.txt"),
-        ]
+        ("output=", "o", "output destination for metadata json")
+    ]
     boolean_options = ['load-requirements-txt']
 
     def initialize_options(self):
         self.load_requirements_txt = False
         self.cwd = None
+        self.output = None
 
     def finalize_options(self):
         self.cwd = os.getcwd()
@@ -46,9 +60,9 @@ class get_metadata(Command):
         data = {
             "name": self.distribution.get_name(),
             "version": self.distribution.get_version(),
-            "author": "%s <%s>" % (
-                self.distribution.get_author(),
-                self.distribution.get_author_email(),
+            "author": u("%s <%s>") % (
+                u(self.distribution.get_author()),
+                u(self.distribution.get_author_email()),
             ),
             "description": self.distribution.get_description(),
             "license": self.distribution.get_license(),
@@ -74,8 +88,9 @@ class get_metadata(Command):
 
         data["dependencies"] = final_deps
 
+        output = open(self.output, "w")
         if hasattr(json, 'dumps'):
-            print(json.dumps(data, indent=2))
+            output.write(json.dumps(data, indent=2))
         else:
             # For Python 2.5 and Debian's python-json
-            print(json.write(data))
+            output.write(json.write(data))

data/lib/fpm/package/python.rb

@@ -55,12 +55,12 @@ class FPM::Package::Python < FPM::Package
     "Want to what your target platform is using? Run this: " \
     "python -c 'from distutils.sysconfig import get_python_lib; " \
     "print get_python_lib()'"
-  option "--install-data", "DATA_PATH", "The path to where data should be." \
+  option "--install-data", "DATA_PATH", "The path to where data should be " \
     "installed to. This is equivalent to 'python setup.py --install-data " \
     "DATA_PATH"
   option "--dependencies", :flag, "Include requirements defined in setup.py" \
     " as dependencies.", :default => true
-  option "--obey-requirements-txt", :flag, "Use a requirements.txt file" \
+  option "--obey-requirements-txt", :flag, "Use a requirements.txt file " \
     "in the top-level directory of the python package for dependency " \
     "detection.", :default => false
 
@@ -148,8 +148,9 @@ class FPM::Package::Python < FPM::Package
     setup_dir = File.dirname(setup_py)
 
     output = ::Dir.chdir(setup_dir) do
+      tmp = build_path("metadata.json")
       setup_cmd = "env PYTHONPATH=#{pylib} #{attributes[:python_bin]} " \
-        "setup.py --command-packages=pyfpm get_metadata"
+        "setup.py --command-packages=pyfpm get_metadata --output=#{tmp}"
 
       if attributes[:python_obey_requirements_txt?]
         setup_cmd += " --load-requirements-txt"
@@ -160,16 +161,17 @@ class FPM::Package::Python < FPM::Package
       # details.
       @logger.info("fetching package metadata", :setup_cmd => setup_cmd)
 
-      output = %x{#{setup_cmd}}
-      if !$?.success?
+      success = safesystem(setup_cmd)
+      #%x{#{setup_cmd}}
+      if !success
         @logger.error("setup.py get_metadata failed", :command => setup_cmd,
                       :exitcode => $?.exitstatus)
         raise "An unexpected error occurred while processing the setup.py file"
       end
-      output
+      File.read(tmp)
     end
-    @logger.debug("full text from `setup.py get_metadata`", :data => output)
-    metadata = JSON.parse(output[/\{.*\}/msx])
+    @logger.debug("result from `setup.py get_metadata`", :data => output)
+    metadata = JSON.parse(output)
     @logger.info("object output of get_metadata", :json => metadata)
 
     self.architecture = metadata["architecture"]

data/lib/fpm/package/rpm.rb

@@ -113,6 +113,11 @@ class FPM::Package::RPM < FPM::Package
     next rpmbuild_filter_from_requires
   end
 
+  option "--ignore-iteration-in-dependencies", :flag,
+            "For '=' (equal) dependencies, allow iterations on the specified " \
+            "version. Default is to be specific. This option allows the same " \
+            "version of a package but any iteration is permitted"
+
   private
 
   # Fix path name
@@ -129,14 +134,18 @@ class FPM::Package::RPM < FPM::Package
   end
 
   def rpm_file_entry(file)
+    original_file = file
     file = rpm_fix_name(file)
     return file unless attributes[:rpm_use_file_permissions?]
 
-    stat = File.stat(file.gsub(/\"/, '').sub(/^\//,''))
-    user = Etc.getpwuid(stat.uid).name
-    group = Etc.getgrgid(stat.gid).name
-    mode = stat.mode
-    return sprintf("%%attr(%o, %s, %s) %s\n", mode & 4095 , user, group, file)
+    # Stat the original filename in the relative staging path
+    ::Dir.chdir(staging_path) do
+      stat = File.stat(original_file.gsub(/\"/, '').sub(/^\//,''))
+      user = Etc.getpwuid(stat.uid).name
+      group = Etc.getgrgid(stat.gid).name
+      mode = stat.mode
+      return sprintf("%%attr(%o, %s, %s) %s\n", mode & 4095 , user, group, file)
+    end
   end
 
 
@@ -184,25 +193,23 @@ class FPM::Package::RPM < FPM::Package
       # Convert 'rubygem-foo' provides values to 'rubygem(foo)'
       # since that's what most rpm packagers seem to do.
       self.provides = self.provides.collect do |provides|
-        first, remainder = provides.split("-", 2)
-        if first == "rubygem"
-          name, remainder = remainder.split(" ", 2)
-          # yield rubygem(name)...
-          "rubygem(#{name})#{remainder ? " #{remainder}" : ""}"
+        # Tries to match rubygem_prefix [1], gem_name [2] and version [3] if present
+        # and return it in rubygem_prefix(gem_name) form
+        if name=/^(#{attributes[:gem_package_name_prefix]})-([^\s]+)\s*(.*)$/.match(provides)
+          "#{name[1]}(#{name[2]})#{name[3] ? " #{name[3]}" : ""}"
         else
           provides
         end
       end
       self.dependencies = self.dependencies.collect do |dependency|
-        first, remainder = dependency.split("-", 2)
-        if first == "rubygem"
-          name, remainder = remainder.split(" ", 2)
-          "rubygem(#{name})#{remainder ? " #{remainder}" : ""}"
+        # Tries to match rubygem_prefix [1], gem_name [2] and version [3] if present
+        # and return it in rubygem_prefix(gem_name) form
+        if name=/^(#{attributes[:gem_package_name_prefix]})-([^\s]+)\s*(.*)$/.match(dependency)
+          "#{name[1]}(#{name[2]})#{name[3] ? " #{name[3]}" : ""}"
         else
           dependency
         end
       end
-      #self.provides << "rubygem(#{self.name})"
     end
 
     # Convert != dependency as Conflict =, as rpm doesn't understand !=
@@ -229,6 +236,23 @@ class FPM::Package::RPM < FPM::Package
       end
     end
 
+    # if --ignore-iteration-in-dependencies is true convert foo = X, to
+    # foo >= X , foo < X+1
+    if self.attributes[:rpm_ignore_iteration_in_dependencies?]
+      self.dependencies = self.dependencies.collect do |dep|
+        name, op, version = dep.split(/\s+/)
+        if op == '='
+          nextversion = version.split('.').collect { |v| v.to_i }
+          nextversion[-1] += 1
+          nextversion = nextversion.join(".")
+          @logger.warn("Converting dependency #{dep} to #{name} >= #{version}, #{name} < #{nextversion}")
+          ["#{name} >= #{version}", "#{name} < #{nextversion}"]
+        else
+          dep
+        end
+      end.flatten
+    end
+
   end # def converted
 
   def input(path)
@@ -316,7 +340,7 @@ class FPM::Package::RPM < FPM::Package
 
       Find.find(staging_path) do |path|
         next if path == staging_path
-        if File.directory? path
+        if File.directory? path and !File.symlink? path
           add_path = path.gsub(/^#{staging_path}/,'')
           self.directories << add_path if not fs_dirs.include? add_path
         end
@@ -326,7 +350,7 @@ class FPM::Package::RPM < FPM::Package
       alldirs = []
       self.directories.each do |path|
         Find.find(File.join(staging_path, path)) do |subpath|
-          if File.directory? subpath
+          if File.directory? subpath and !File.symlink? subpath
             alldirs << subpath.gsub(/^#{staging_path}/, '')
           end
         end
@@ -334,12 +358,29 @@ class FPM::Package::RPM < FPM::Package
       self.directories = alldirs
     end
 
-    self.config_files = self.config_files.map { |x| File.join(self.prefix, x) }
+    # scan all conf file paths for files and add them
+    allconfigs = []
+    self.config_files.each do |path|
+      cfg_path = File.expand_path(path, staging_path)
+      Find.find(cfg_path) do |p|
+        allconfigs << p.gsub("#{staging_path}/", '') if File.file? p
+      end
+    end
+    allconfigs.sort!.uniq!
+
+    self.config_files = allconfigs.map { |x| File.join(self.prefix, x) }
 
     (attributes[:rpm_rpmbuild_define] or []).each do |define|
       args += ["--define", define]
     end
 
+    # copy all files from staging to BUILD dir
+    Find.find(staging_path) do |path|
+      src = path.gsub(/^#{staging_path}/, '')
+      dst = File.join(build_path, build_sub_dir, src)
+      copy_entry(path, dst)
+    end
+
     rpmspec = template("rpm.erb").result(binding)
     specfile = File.join(build_path("SPECS"), "#{name}.spec")
     File.write(specfile, rpmspec)

data/lib/fpm/util.rb

@@ -1,8 +1,21 @@
 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
 
@@ -46,7 +59,9 @@ module FPM::Util
     process.start
     stdout_w.close; stderr_w.close
     @logger.debug('Process is running', :pid => process.pid)
-    @logger.pipe(stdout_r => :info, stderr_r => :error)
+    # 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)
 
     process.wait
     success = (process.exit_code == 0)
@@ -113,4 +128,30 @@ module FPM::Util
   def with(value, &block)
     block.call(value)
   end # def with
+
+  # 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_entry(src, dst)
+    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
+      FileUtils.copy_entry(src, dst)
+    end
+  end
 end # module FPM::Util