cure-fpm 1.3.3b → 1.6.0b

data/lib/fpm/package/dir.rb

@@ -75,7 +75,7 @@ class FPM::Package::Dir < FPM::Package
         end
       end
     rescue Errno::ENOENT => e
-      raise FPM::InvalidPackageConfiguration, 
+      raise FPM::InvalidPackageConfiguration,
         "Cannot chdir to '#{chdir}'. Does it exist?"
     end
 
@@ -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
@@ -128,19 +142,19 @@ class FPM::Package::Dir < FPM::Package
         "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?"
+        "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 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, destination)
+      copy(source, File.join(destination, source))
     else
       # Copy all files from 'path' into staging_path
       Find.find(source) do |path|
@@ -157,8 +171,17 @@ class FPM::Package::Dir < FPM::Package
   def copy(source, destination)
     logger.debug("Copying path", :source => source, :destination => destination)
     directory = File.dirname(destination)
-    if !File.directory?(directory)
-      FileUtils.mkdir_p(directory)
+    # 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)
@@ -194,27 +217,5 @@ class FPM::Package::Dir < FPM::Package
     copy_metadata(source, destination)
   end # def copy
 
-  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
-
   public(:input, :output)
 end # class FPM::Package::Dir

data/lib/fpm/package/empty.rb

@@ -4,4 +4,10 @@ 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,144 @@
+require "backports" # gem backports
+require "fpm/package"
+require "fpm/util"
+require "digest"
+require "fileutils"
+require "xz"
+
+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)
+    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

@@ -58,7 +58,7 @@ class FPM::Package::Gem < FPM::Package
 
   def download_if_necessary(gem, gem_version)
     path = gem
-    if !File.exists?(path)
+    if !File.exist?(path)
       path = download(gem, gem_version)
     end
 
@@ -114,7 +114,7 @@ class FPM::Package::Gem < FPM::Package
     # 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.version = m.flatten.fill('0', m.length..2).join('.')
 
     self.vendor = spec.author
     self.url = spec.homepage
@@ -132,7 +132,7 @@ class FPM::Package::Gem < FPM::Package
     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? 
+    # 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})"
@@ -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
@@ -213,7 +213,7 @@ class FPM::Package::Gem < FPM::Package
       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

data/lib/fpm/package/npm.rb

@@ -72,7 +72,7 @@ class FPM::Package::NPM < FPM::Package
     end
 
     self.description = info["description"]
-    # Supposedly you can upload a package for npm with no author/author email 
+    # Supposedly you can upload a package for npm with no author/author email
     # so I'm being safer with this. Author can also be a hash or a string
     self.vendor = "Unknown <unknown@unknown.unknown>"
     if info.include?("author")
@@ -91,7 +91,7 @@ class FPM::Package::NPM < FPM::Package
     # 'npm install express' it installs dependencies (like 'connect')
     # to: node_modules/express/node_modules/connect/...
     #
-    # To that end, I don't think we necessarily need to include 
+    # To that end, I don't think we necessarily need to include
     # any automatic dependency information since every 'npm install'
     # is fully self-contained. That's why you don't see any bother, yet,
     # to include the package's dependencies in here.

data/lib/fpm/package/osxpkg.rb

@@ -21,7 +21,7 @@ class FPM::Package::OSXpkg < FPM::Package
   POSTINSTALL_ACTIONS = [ "logout", "restart", "shutdown" ]
   OWNERSHIP_OPTIONS = ["recommended", "preserve", "preserve-other"]
 
-  option "--identifier-prefix", "IDENTIFIER_PREFIX", 
+  option "--identifier-prefix", "IDENTIFIER_PREFIX",
     "Reverse domain prefix prepended to package identifier, " \
     "ie. 'org.great.my'. If this is omitted, the identifer " \
     "will be the package name."
@@ -81,18 +81,18 @@ class FPM::Package::OSXpkg < FPM::Package
     SCRIPT_MAP.each do |scriptname, filename|
       next unless script?(scriptname)
 
-      with(scripts_path(filename)) do |pkgscript|
+      scripts_path(filename).tap do |pkgscript|
         logger.info("Writing pkg script", :source => filename, :target => pkgscript)
         File.write(pkgscript, script(scriptname))
         # scripts are required to be executable
         File.chmod(0755, pkgscript)
       end
-    end 
+    end
   end # def write_scripts
 
   # Returns path of a processed template PackageInfo given to 'pkgbuild --info'
   # note: '--info' is undocumented:
-  # http://managingosx.wordpress.com/2012/07/05/stupid-tricks-with-pkgbuild 
+  # http://managingosx.wordpress.com/2012/07/05/stupid-tricks-with-pkgbuild
   def pkginfo_template_path
     pkginfo_template = Tempfile.open("fpm-PackageInfo")
     pkginfo_data = template("osxpkg.erb").result(binding)
@@ -103,7 +103,7 @@ class FPM::Package::OSXpkg < FPM::Package
 
   # Extract name and version from PackageInfo XML
   def extract_info(package)
-    with(build_path("expand")) do |path|
+    build_path("expand").tap do |path|
       doc = REXML::Document.new File.open(File.join(path, "PackageInfo"))
       pkginfo_elem = doc.elements["pkg-info"]
       identifier = pkginfo_elem.attribute("identifier").value
@@ -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/p5p.rb

@@ -0,0 +1,124 @@
+require "erb"
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/errors"
+require "fpm/util"
+
+class FPM::Package::P5P < FPM::Package
+
+  option "--user", "USER",
+    "Set the user to USER in the prototype files.",
+    :default => 'root'
+
+  option "--group", "GROUP",
+    "Set the group to GROUP in the prototype file.",
+    :default => 'root'
+
+  option "--zonetype", "ZONETYPE",
+    "Set the allowed zone types (global, nonglobal, both)",
+    :default => 'value=global value=nonglobal' do |value|
+      case @value
+      when "both"
+        value = "value=global value=nonglobal"
+      else
+        value = "value=#{value}"
+      end
+    end # value
+
+  option "--publisher", "PUBLISHER", 
+    "Set the publisher name for the repository",
+    :default => 'FPM'
+
+  option "--lint" , :flag, "Check manifest with pkglint",
+    :default => true
+
+  option "--validate", :flag, "Validate with pkg install",
+    :default => true
+
+  def architecture
+    case @architecture
+    when nil, "native"
+      @architecture = %x{uname -p}.chomp
+    when "all"
+      @architecture = 'i386 value=sparc'
+    end
+
+    return @architecture
+  end # def architecture
+
+  def output(output_path)
+    
+    # Fixup the category to an acceptable solaris category
+    case @category
+    when nil, "default"
+      @category = 'Applications/System Utilities'
+    end
+
+    # Manifest Filename
+    manifest_fn = build_path("#{name}.p5m")
+
+    # Generate a package manifest.
+    pkg_generate = safesystemout("pkgsend", "generate", "#{staging_path}")
+    File.write(build_path("#{name}.p5m.1"), pkg_generate)
+
+    # Add necessary metadata to the generated manifest.
+    metadata_template = template("p5p_metadata.erb").result(binding)
+    File.write(build_path("#{name}.mog"), metadata_template)
+
+    # Combine template and filelist; allow user to edit before proceeding
+    File.open(manifest_fn, "w") do |manifest|
+      manifest.write metadata_template
+      manifest.write pkg_generate
+    end
+    edit_file(manifest_fn) if attributes[:edit?]
+
+    # Execute the transmogrification on the manifest
+    pkg_mogrify = safesystemout("pkgmogrify", manifest_fn)
+    File.write(build_path("#{name}.p5m.2"), pkg_mogrify)
+    safesystem("cp", build_path("#{name}.p5m.2"), manifest_fn)
+
+    # Evaluate dependencies.
+    if !attributes[:no_auto_depends?]
+	    pkgdepend_gen = safesystemout("pkgdepend", "generate",  "-md", "#{staging_path}",  manifest_fn)
+      File.write(build_path("#{name}.p5m.3"), pkgdepend_gen)
+
+      # Allow user to review added dependencies
+      edit_file(build_path("#{name}.p5m.3")) if attributes[:edit?]
+
+	    safesystem("pkgdepend", "resolve",  "-m", build_path("#{name}.p5m.3"))
+      safesystem("cp", build_path("#{name}.p5m.3.res"), manifest_fn)
+    end
+
+    # Final format of manifest
+    safesystem("pkgfmt", manifest_fn)
+
+    # Final edit for lint check and packaging
+    edit_file(manifest_fn) if attributes[:edit?]
+
+    # Add any facets or actuators that are needed.
+    # TODO(jcraig): add manpage actuator to enable install wo/ man pages
+
+    # Verify the package.
+    if attributes[:p5p_lint] then
+      safesystem("pkglint", manifest_fn)
+    end
+
+    # Publish the package.
+    repo_path = build_path("#{name}_repo")
+    safesystem("pkgrepo", "create", repo_path)
+    safesystem("pkgrepo", "set", "-s", repo_path, "publisher/prefix=#{attributes[:p5p_publisher]}")
+    safesystem("pkgsend", "-s", repo_path,
+      "publish", "-d", "#{staging_path}", "#{build_path}/#{name}.p5m")
+    safesystem("pkgrecv", "-s", repo_path, "-a",
+      "-d", build_path("#{name}.p5p"), name)
+
+    # Test the package
+    if attributes[:p5p_validate] then
+      safesystem("pkg", "install",  "-nvg", build_path("#{name}.p5p"), name)
+    end
+
+    # Cleanup
+    safesystem("mv", build_path("#{name}.p5p"), output_path)
+
+  end # def output
+end # class FPM::Package::IPS