fpm-aeppert 1.6.2

data/lib/fpm/package/sh.rb

@@ -0,0 +1,69 @@
+require "erb"
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/errors"
+require "fpm/util"
+require "backports"
+require "fileutils"
+require "digest"
+
+# Support for self extracting sh files (.sh files)
+#
+# This class only supports output of packages.
+#
+# The sh package is a single sh file with a tar payload concatenated to the end.
+# The script can unpack the tarball to install it and call optional post install scripts.
+class FPM::Package::Sh < FPM::Package
+
+  def output(output_path)
+    create_scripts
+
+    # Make one file. The installscript can unpack itself.
+    `cat #{install_script} #{payload} > #{output_path}`
+    FileUtils.chmod("+x", output_path)
+  end
+
+  def create_scripts
+    if script?(:after_install)
+      File.write(File.join(fpm_meta_path, "after_install"), script(:after_install))
+    end
+  end
+
+  def install_script
+    path = build_path("installer.sh")
+    File.open(path, "w") do |file|
+      file.write template("sh.erb").result(binding)
+    end
+    path
+  end
+
+  # Returns the path to the tar file containing the packed up staging directory
+  def payload
+    payload_tar = build_path("payload.tar")
+    logger.info("Creating payload tar ", :path => payload_tar)
+
+    args = [ tar_cmd,
+             "-C",
+             staging_path,
+             "-cf",
+             payload_tar,
+             "--owner=0",
+             "--group=0",
+             "--numeric-owner",
+             "." ]
+
+    unless safesystem(*args)
+      raise "Command failed while creating payload tar: #{args}"
+    end
+    payload_tar
+  end
+
+  # Where we keep metadata and post install scripts and such
+  def fpm_meta_path
+    @fpm_meta_path ||= begin
+                         path = File.join(staging_path, ".fpm")
+                         FileUtils.mkdir_p(path)
+                         path
+                       end
+  end
+end

data/lib/fpm/package/solaris.rb

@@ -0,0 +1,95 @@
+require "erb"
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/errors"
+require "fpm/util"
+
+# TODO(sissel): Add dependency checking support.
+# IIRC this has to be done as a 'checkinstall' step.
+class FPM::Package::Solaris < 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'
+
+  def architecture
+    case @architecture
+    when nil, "native"
+      @architecture = %x{uname -p}.chomp
+    end
+    # "all" is a valid arch according to
+    # http://www.bolthole.com/solaris/makeapackage.html
+
+    return @architecture
+  end # def architecture
+
+  def specfile(builddir)
+    "#{builddir}/pkginfo"
+  end
+
+  def output(output_path)
+    self.scripts.each do |name, path|
+      case name
+        when "pre-install"
+          safesystem("cp", path, "./preinstall")
+          File.chmod(0755, "./preinstall")
+        when "post-install"
+          safesystem("cp", path, "./postinstall")
+          File.chmod(0755, "./postinstall")
+        when "pre-uninstall"
+          raise FPM::InvalidPackageConfiguration.new(
+            "pre-uninstall is not supported by Solaris packages"
+          )
+        when "post-uninstall"
+          raise FPM::InvalidPackageConfiguration.new(
+            "post-uninstall is not supported by Solaris packages"
+          )
+      end # case name
+    end # self.scripts.each
+
+    template = template("solaris.erb")
+    File.open("#{build_path}/pkginfo", "w") do |pkginfo|
+      pkginfo.puts template.result(binding)
+    end
+
+    # Generate the package 'Prototype' file
+    File.open("#{build_path}/Prototype", "w") do |prototype|
+      prototype.puts("i pkginfo")
+      prototype.puts("i preinstall") if self.scripts["pre-install"]
+      prototype.puts("i postinstall") if self.scripts["post-install"]
+
+      # TODO(sissel): preinstall/postinstall
+      # strip @prefix, since BASEDIR will set prefix via the pkginfo file
+      IO.popen("pkgproto #{staging_path}/#{@prefix}=").each_line do |line|
+        type, klass, path, mode, user, group = line.split
+
+        prototype.puts([type, klass, path, mode, attributes[:solaris_user], attributes[:solaris_group]].join(" "))
+      end # popen "pkgproto ..."
+    end # File prototype
+
+    ::Dir.chdir staging_path do
+      # Should create a package directory named by the package name.
+      safesystem("pkgmk", "-o", "-f", "#{build_path}/Prototype", "-d", build_path)
+    end
+
+
+    # Convert the 'package directory' built above to a real solaris package.
+    safesystem("pkgtrans", "-s", build_path, output_path, name)
+    safesystem("cp", "#{build_path}/#{output_path}", output_path)
+  end # def output
+
+  def default_output
+    v = version
+    v = "#{epoch}:#{v}" if epoch
+    if iteration
+      "#{name}_#{v}-#{iteration}_#{architecture}.#{type}"
+    else
+      "#{name}_#{v}_#{architecture}.#{type}"
+    end
+  end # def default_output
+end # class FPM::Deb
+

data/lib/fpm/package/tar.rb

@@ -0,0 +1,86 @@
+require "backports" # gem backports
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+require "fpm/package/dir"
+
+# Use a tarball as a package.
+#
+# This provides no metadata. Both input and output are supported.
+class FPM::Package::Tar < FPM::Package
+
+  # Input a tarball. Compressed tarballs should be OK.
+  def input(input_path)
+    # use part of the filename as the package name
+    self.name = File.basename(input_path).split(".").first
+
+    # Unpack the tarball to the build path before ultimately moving it to
+    # staging.
+    args = ["-xf", input_path, "-C", build_path]
+
+    # Add the tar compression flag if necessary
+    tar_compression_flag(input_path).tap do |flag|
+      args << flag unless flag.nil?
+    end
+
+    safesystem("tar", *args)
+
+    # use dir to set stuff up properly, mainly so I don't have to reimplement
+    # the chdir/prefix stuff special for tar.
+    dir = convert(FPM::Package::Dir)
+    if attributes[:chdir]
+      dir.attributes[:chdir] = File.join(build_path, attributes[:chdir])
+    else
+      dir.attributes[:chdir] = build_path
+    end
+
+    cleanup_staging
+    # Tell 'dir' to input "." and chdir/prefix will help it figure out the
+    # rest.
+    dir.input(".")
+    @staging_path = dir.staging_path
+    dir.cleanup_build
+  end # def input
+
+  # Output a tarball.
+  #
+  # If the output path ends predictably (like in .tar.gz) it will try to obey
+  # 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|
+      args << flag unless flag.nil?
+    end
+    args << "."
+
+    safesystem("tar", *args)
+  end # def output
+
+  # Generate the proper tar flags based on the path name.
+  def tar_compression_flag(path)
+    case path
+      when /\.tar\.bz2$/
+        return "-j"
+      when /\.tar\.gz$|\.tgz$/
+        return "-z"
+      when /\.tar\.xz$/
+        return "-J"
+      else
+        return nil
+    end
+  end # def tar_compression_flag
+end # class FPM::Package::Tar

data/lib/fpm/package/virtualenv.rb

@@ -0,0 +1,164 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/util"
+
+# Support for python virtualenv packages.
+#
+# This supports input, but not output.
+#
+class FPM::Package::Virtualenv < FPM::Package
+  # Flags '--foo' will be accessable  as attributes[:virtualenv_foo]
+
+  option "--pypi", "PYPI_URL",
+  "PyPi Server uri for retrieving packages.",
+  :default => "https://pypi.python.org/simple"
+  option "--package-name-prefix", "PREFIX", "Name to prefix the package " \
+  "name with.", :default => "virtualenv"
+
+  option "--install-location", "DIRECTORY", "Location to which to " \
+  "install the virtualenv by default.", :default => "/usr/share/python" do |path|
+    File.expand_path(path)
+  end
+
+  option "--fix-name", :flag, "Should the target package name be prefixed?",
+  :default => true
+  option "--other-files-dir", "DIRECTORY", "Optionally, the contents of the " \
+  "specified directory may be added to the package. This is useful if the " \
+  "virtualenv needs configuration files, etc.", :default => nil
+  option "--pypi-extra-url", "PYPI_EXTRA_URL",
+    "PyPi extra-index-url for pointing to your priviate PyPi",
+    :multivalued => true, :attribute_name => :virtualenv_pypi_extra_index_urls,
+    :default => nil
+
+  private
+
+  # Input a package.
+  #
+  #     `package` can look like `psutil==2.2.1` or `psutil`.
+  def input(package)
+    installdir = attributes[:virtualenv_install_location]
+    m = /^([^=]+)==([^=]+)$/.match(package)
+    package_version = nil
+
+    is_requirements_file = (File.basename(package) == "requirements.txt")
+
+    if is_requirements_file
+      if !File.file?(package)
+        raise FPM::InvalidPackageConfiguration, "Path looks like a requirements.txt, but it doesn't exist: #{package}"
+      end
+
+      package = File.join(::Dir.pwd, package) if File.dirname(package) == "."
+      package_name = File.basename(File.dirname(package))
+      logger.info("No name given. Using the directory's name", :name => package_name)
+      package_version = nil
+    elsif m
+      package_name = m[1]
+      package_version = m[2]
+      self.version ||= package_version
+    else
+      package_name = package
+      package_version = nil
+    end
+
+    virtualenv_name = package_name
+
+    self.name ||= package_name
+
+    if self.attributes[:virtualenv_fix_name?]
+      self.name = [self.attributes[:virtualenv_package_name_prefix],
+                   self.name].join("-")
+    end
+
+    virtualenv_folder =
+      File.join(installdir,
+                virtualenv_name)
+
+    virtualenv_build_folder = build_path(virtualenv_folder)
+
+    ::FileUtils.mkdir_p(virtualenv_build_folder)
+
+    safesystem("virtualenv", virtualenv_build_folder)
+    pip_exe = File.join(virtualenv_build_folder, "bin", "pip")
+    python_exe = File.join(virtualenv_build_folder, "bin", "python")
+
+    # Why is this hack here? It looks important, so I'll keep it in.
+    safesystem(pip_exe, "install", "-U", "-i",
+               attributes[:virtualenv_pypi],
+               "pip", "distribute")
+    safesystem(pip_exe, "uninstall", "-y", "distribute")
+
+    extra_index_url_args = []
+    if attributes[:virtualenv_pypi_extra_index_urls]
+      attributes[:virtualenv_pypi_extra_index_urls].each do |extra_url|
+        extra_index_url_args << "--extra-index-url" << extra_url
+      end
+    end
+
+    target_args = []
+    if is_requirements_file
+      target_args << "-r" << package
+    else
+      target_args << package
+    end
+
+    pip_args = [pip_exe, "install", "-i", attributes[:virtualenv_pypi]] << extra_index_url_args << target_args
+    safesystem(*pip_args.flatten)
+
+    if ! is_requirements_file && package_version.nil?
+      frozen = safesystemout(pip_exe, "freeze")
+      package_version = frozen[/#{package}==[^=]+$/].split("==")[1].chomp!
+      self.version ||= package_version
+    end
+
+    ::Dir[build_path + "/**/*"].each do |f|
+      if ! File.readable? f
+        File.lchmod(File.stat(f).mode | 444)
+      end
+    end
+
+    ::Dir.chdir(virtualenv_build_folder) do
+      safesystem("virtualenv-tools", "--update-path", virtualenv_folder)
+    end
+
+    if !attributes[:virtualenv_other_files_dir].nil?
+      # Copy all files from other dir to build_path
+      Find.find(attributes[:virtualenv_other_files_dir]) do |path|
+        src = path.gsub(/^#{attributes[:virtualenv_other_files_dir]}/, '')
+        dst = File.join(build_path, src)
+        copy_entry(path, dst, preserve=true, remove_destination=true)
+        copy_metadata(path, dst)
+      end
+    end
+
+    remove_python_compiled_files virtualenv_build_folder
+
+    # use dir to set stuff up properly, mainly so I don't have to reimplement
+    # the chdir/prefix stuff special for tar.
+    dir = convert(FPM::Package::Dir)
+
+    if attributes[:chdir]
+      dir.attributes[:chdir] = File.join(build_path, attributes[:chdir])
+    else
+      dir.attributes[:chdir] = build_path
+    end
+
+    cleanup_staging
+    # Tell 'dir' to input "." and chdir/prefix will help it figure out the
+    # rest.
+    dir.input(".")
+    @staging_path = dir.staging_path
+    dir.cleanup_build
+
+  end # def input
+
+  # Delete python precompiled files found in a given folder.
+  def remove_python_compiled_files path
+    logger.debug("Now removing python object and compiled files from the virtualenv")
+    Find.find(path) do |path|
+      if path.end_with? '.pyc' or path.end_with? '.pyo'
+        FileUtils.rm path
+      end
+    end
+  end
+  public(:input)
+end # class FPM::Package::Virtualenv

data/lib/fpm/package/zip.rb

@@ -0,0 +1,63 @@
+require "backports" # gem backports
+require "fpm/package"
+require "fpm/util"
+require "fileutils"
+require "fpm/package/dir"
+
+# Use a zip as a package.
+#
+# This provides no metadata. Both input and output are supported.
+class FPM::Package::Zip < FPM::Package
+
+  # Input a zipfile.
+  def input(input_path)
+    # use part of the filename as the package name
+    self.name = File.extname(input_path)[1..-1]
+
+    realpath = Pathname.new(input_path).realpath.to_s
+    ::Dir.chdir(build_path) do
+      safesystem("unzip", realpath)
+    end
+
+    # use dir to set stuff up properly, mainly so I don't have to reimplement
+    # the chdir/prefix stuff special for zip.
+    dir = convert(FPM::Package::Dir)
+    if attributes[:chdir]
+      dir.attributes[:chdir] = File.join(build_path, attributes[:chdir])
+    else
+      dir.attributes[:chdir] = build_path
+    end
+
+    cleanup_staging
+    # Tell 'dir' to input "." and chdir/prefix will help it figure out the
+    # rest.
+    dir.input(".")
+    @staging_path = dir.staging_path
+    dir.cleanup_build
+  end # def input
+
+  # Output a tarball.
+  #
+  # If the output path ends predictably (like in .tar.gz) it will try to obey
+  # 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
+
+  # Generate the proper tar flags based on the path name.
+  def tar_compression_flag(path)
+    case path
+      when /\.tar\.bz2$/
+        return "-j"
+      when /\.tar\.gz$|\.tgz$/
+        return "-z"
+      when /\.tar\.xz$/
+        return "-J"
+      else
+        return nil
+    end
+  end # def tar_compression_flag
+end # class FPM::Package::Tar