fpm-itchio 1.4.0

data/lib/fpm/package/pear.rb

@@ -0,0 +1,117 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fileutils"
+require "fpm/util"
+
+# This provides PHP PEAR package support.
+#
+# This provides input support, but not output support.
+class FPM::Package::PEAR < FPM::Package
+  option "--package-name-prefix", "PREFIX",
+    "Name prefix for pear package", :default => "php-pear"
+
+  option "--channel", "CHANNEL_URL",
+    "The pear channel url to use instead of the default."
+
+  option "--channel-update", :flag,
+    "call 'pear channel-update' prior to installation"
+
+  option "--bin-dir", "BIN_DIR",
+    "Directory to put binaries in"
+
+  option "--php-bin", "PHP_BIN",
+    "Specify php executable path if differs from the os used for packaging"
+
+  option "--php-dir", "PHP_DIR",
+    "Specify php dir relative to prefix if differs from pear default (pear/php)"
+
+  option "--data-dir", "DATA_DIR",
+    "Specify php dir relative to prefix if differs from pear default (pear/data)"
+
+  # Input a PEAR package.
+  #
+  # The parameter is a PHP PEAR package name.
+  #
+  # Attributes that affect behavior here:
+  # * :prefix - changes the install root, default is /usr/share
+  # * :pear_package_name_prefix - changes the
+  def input(input_package)
+    if !program_in_path?("pear")
+      raise ExecutableNotFound.new("pear")
+    end
+
+    # Create a temporary config file
+    logger.debug("Creating pear config file")
+    config = File.expand_path(build_path("pear.config"))
+    installroot = attributes[:prefix] || "/usr/share"
+    safesystem("pear", "config-create", staging_path(installroot), config)
+
+    if attributes[:pear_php_dir]
+      logger.info("Setting php_dir", :php_dir => attributes[:pear_php_dir])
+      safesystem("pear", "-c", config, "config-set", "php_dir", "#{staging_path(installroot)}/#{attributes[:pear_php_dir]}")
+    end
+
+    if attributes[:pear_data_dir]
+      logger.info("Setting data_dir", :data_dir => attributes[:pear_data_dir])
+      safesystem("pear", "-c", config, "config-set", "data_dir", "#{staging_path(installroot)}/#{attributes[:pear_data_dir]}")
+    end
+
+    bin_dir = attributes[:pear_bin_dir] || "usr/bin"
+    logger.info("Setting bin_dir", :bin_dir => bin_dir)
+    safesystem("pear", "-c", config, "config-set", "bin_dir", bin_dir)
+
+    php_bin = attributes[:pear_php_bin] || "/usr/bin/php"
+    logger.info("Setting php_bin", :php_bin => php_bin)
+    safesystem("pear", "-c", config, "config-set", "php_bin", php_bin)
+
+    # do channel-discover if required
+    if !attributes[:pear_channel].nil?
+      logger.info("Custom channel specified", :channel => attributes[:pear_channel])
+      channel_list = safesystemout("pear", "-c", config, "list-channels")
+      if channel_list !~ /#{Regexp.quote(attributes[:pear_channel])}/
+        logger.info("Discovering new channel", :channel => attributes[:pear_channel])
+        safesystem("pear", "-c", config, "channel-discover", attributes[:pear_channel])
+      end
+      input_package = "#{attributes[:pear_channel]}/#{input_package}"
+      logger.info("Prefixing package name with channel", :package => input_package)
+    end
+
+    # do channel-update if requested
+    if attributes[:pear_channel_update?]
+      channel = attributes[:pear_channel] || "pear"
+      logger.info("Updating the channel", :channel => channel)
+      safesystem("pear", "-c", config, "channel-update", channel)
+    end
+
+    logger.info("Installing pear package", :package => input_package,
+                  :directory => staging_path)
+    ::Dir.chdir(staging_path) do
+      safesystem("pear", "-c", config, "install", "-n", "-f", input_package)
+    end
+
+    pear_cmd = "pear -c #{config} remote-info #{input_package}"
+    logger.info("Fetching package information", :package => input_package, :command => pear_cmd)
+    name = %x{#{pear_cmd} | sed -ne '/^Package\s*/s/^Package\s*//p'}.chomp
+    self.name = "#{attributes[:pear_package_name_prefix]}-#{name}"
+    self.version = %x{#{pear_cmd} | sed -ne '/^Installed\s*/s/^Installed\s*//p'}.chomp
+    self.description  = %x{#{pear_cmd} | sed -ne '/^Summary\s*/s/^Summary\s*//p'}.chomp
+    logger.debug("Package info", :name => self.name, :version => self.version,
+                  :description => self.description)
+
+    # Remove the stuff we don't want
+    delete_these = [".depdb", ".depdblock", ".filemap", ".lock", ".channel", "cache", "temp", "download", ".channels", ".registry"]
+    Find.find(staging_path) do |path|
+      if File.file?(path)
+        logger.info("replacing staging_path in file", :replace_in => path, :staging_path => staging_path)
+        begin
+          content = File.read(path).gsub(/#{Regexp.escape(staging_path)}/, "")
+          File.write(path, content)
+        rescue ArgumentError => e
+          logger.warn("error replacing staging_path in file", :replace_in => path, :error => e)
+        end
+      end
+      FileUtils.rm_r(path) if delete_these.include?(File.basename(path))
+    end
+
+  end # def input
+end # class FPM::Package::PEAR

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/puppet.rb

@@ -0,0 +1,120 @@
+require "erb"
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/errors"
+require "etc"
+require "fileutils"
+
+class FPM::Package::Puppet < FPM::Package
+  def architecture
+    case @architecture
+    when nil, "native"
+      @architecture = %x{uname -m}.chomp
+    end
+    return @architecture
+  end # def architecture
+
+  # Default specfile generator just makes one specfile, whatever that is for
+  # this package.
+  def generate_specfile(builddir)
+    paths = []
+    logger.info("PWD: #{File.join(builddir, unpack_data_to)}")
+    fileroot = File.join(builddir, unpack_data_to)
+    Dir.chdir(fileroot) do
+      Find.find(".") do |p|
+        next if p == "."
+        paths << p
+      end
+    end
+    logger.info(paths[-1])
+    manifests = %w{package.pp package/remove.pp}
+
+    ::Dir.mkdir(File.join(builddir, "manifests"))
+    manifests.each do |manifest|
+      dir = File.join(builddir, "manifests", File.dirname(manifest))
+      logger.info("manifests targeting: #{dir}")
+      ::Dir.mkdir(dir) if !File.directory?(dir)
+
+      File.open(File.join(builddir, "manifests", manifest), "w") do |f|
+        logger.info("manifest: #{f.path}")
+        template = template(File.join("puppet", "#{manifest}.erb"))
+        ::Dir.chdir(fileroot) do
+          f.puts template.result(binding)
+        end
+      end
+    end
+  end # def generate_specfile
+
+  def unpack_data_to
+    "files"
+  end
+
+  def build!(params)
+    # TODO(sissel): Support these somehow, perhaps with execs and files.
+    self.scripts.each do |name, path|
+      case name
+        when "pre-install"
+        when "post-install"
+        when "pre-uninstall"
+        when "post-uninstall"
+      end # case name
+    end # self.scripts.each
+
+    if File.exists?(params[:output])
+      # TODO(sissel): Allow folks to choose output?
+      logger.error("Puppet module directory '#{params[:output]}' already " \
+                    "exists. Delete it or choose another output (-p flag)")
+    end
+
+    ::Dir.mkdir(params[:output])
+    builddir = ::Dir.pwd
+
+    # Copy 'files' from builddir to :output/files
+    Find.find("files", "manifests") do |path|
+      logger.info("Copying path: #{path}")
+      if File.directory?(path)
+        ::Dir.mkdir(File.join(params[:output], path))
+      else
+        FileUtils.cp(path, File.join(params[:output], path))
+      end
+    end
+  end # def build!
+
+  # The directory we create should just be the name of the package as the
+  # module name
+  def default_output
+    name
+  end # def default_output
+
+  # This method is used by the puppet manifest template
+  def puppetsort(hash)
+    # TODO(sissel): Implement sorting that follows the puppet style guide
+    # Such as, 'ensure' goes first, etc.
+    return hash.to_a
+  end # def puppetsort
+
+  # Helper for user lookup
+  def uid2user(uid)
+    begin
+      pwent = Etc.getpwuid(uid)
+      return pwent.name
+    rescue ArgumentError => e
+      # Invalid user id? No user? Return the uid.
+      logger.warn("Failed to find username for uid #{uid}")
+      return uid.to_s
+    end
+  end # def uid2user
+
+  # Helper for group lookup
+  def gid2group(gid)
+    begin
+      grent = Etc.getgrgid(gid)
+      return grent.name
+    rescue ArgumentError => e
+      # Invalid user id? No user? Return the uid.
+      logger.warn("Failed to find group for gid #{gid}")
+      return gid.to_s
+    end
+  end # def uid2user
+end # class FPM::Target::Puppet
+

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

@@ -0,0 +1 @@
+__all__ = [ "get_metadata" ]

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

@@ -0,0 +1,104 @@
+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.
+# If you have fixes, let me know.
+
+
+class get_metadata(Command):
+    description = "get package metadata"
+    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()
+        self.requirements_txt = os.path.join(self.cwd, "requirements.txt")
+        # make sure we have a requirements.txt
+        if self.load_requirements_txt:
+            self.load_requirements_txt = os.path.exists(self.requirements_txt)
+
+    def process_dep(self, dep):
+        deps = []
+        if dep.specs:
+            for operator, version in dep.specs:
+                deps.append("%s %s %s" % (dep.project_name,
+                        operator, version))
+        else:
+            deps.append(dep.project_name)
+
+        return deps
+
+    def run(self):
+        data = {
+            "name": self.distribution.get_name(),
+            "version": self.distribution.get_version(),
+            "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(),
+            "url": self.distribution.get_url(),
+        }
+
+        if self.distribution.has_ext_modules():
+            data["architecture"] = "native"
+        else:
+            data["architecture"] = "all"
+
+        final_deps = []
+
+        if self.load_requirements_txt:
+            requirement = open(self.requirements_txt).readlines()
+            for dep in pkg_resources.parse_requirements(requirement):
+                final_deps.extend(self.process_dep(dep))
+        else:
+            if getattr(self.distribution, 'install_requires', None):
+                for dep in pkg_resources.parse_requirements(
+                        self.distribution.install_requires):
+                    final_deps.extend(self.process_dep(dep))
+
+        data["dependencies"] = final_deps
+
+        output = open(self.output, "w")
+        if hasattr(json, 'dumps'):
+            def default_to_str(obj):
+                """ Fall back to using __str__ if possible """
+                # This checks if the class of obj defines __str__ itself,
+                # so we don't fall back to an inherited __str__ method.
+                if "__str__" in type(obj).__dict__:
+                    return str(obj)
+                return json.JSONEncoder.default(self, obj)
+
+            output.write(json.dumps(data, indent=2, default=default_to_str))
+        else:
+            # For Python 2.5 and Debian's python-json
+            output.write(json.write(data))

data/lib/fpm/package/python.rb

@@ -0,0 +1,317 @@
+require "fpm/namespace"
+require "fpm/package"
+require "fpm/util"
+require "rubygems/package"
+require "rubygems"
+require "fileutils"
+require "tmpdir"
+require "json"
+
+# Support for python packages.
+#
+# This supports input, but not output.
+#
+# Example:
+#
+#     # Download the django python package:
+#     pkg = FPM::Package::Python.new
+#     pkg.input("Django")
+#
+class FPM::Package::Python < FPM::Package
+  # Flags '--foo' will be accessable  as attributes[:python_foo]
+  option "--bin", "PYTHON_EXECUTABLE",
+    "The path to the python executable you wish to run.", :default => "python"
+  option "--easyinstall", "EASYINSTALL_EXECUTABLE",
+    "The path to the easy_install executable tool", :default => "easy_install"
+  option "--pip", "PIP_EXECUTABLE",
+    "The path to the pip executable tool. If not specified, easy_install " \
+    "is used instead", :default => nil
+  option "--pypi", "PYPI_URL",
+    "PyPi Server uri for retrieving packages.",
+    :default => "https://pypi.python.org/simple"
+  option "--package-prefix", "NAMEPREFIX",
+    "(DEPRECATED, use --package-name-prefix) Name to prefix the package " \
+    "name with." do |value|
+    logger.warn("Using deprecated flag: --package-prefix. Please use " \
+                 "--package-name-prefix")
+    value
+  end
+  option "--package-name-prefix", "PREFIX", "Name to prefix the package " \
+    "name with.", :default => "python"
+  option "--fix-name", :flag, "Should the target package name be prefixed?",
+    :default => true
+  option "--fix-dependencies", :flag, "Should the package dependencies be " \
+    "prefixed?", :default => true
+
+  option "--downcase-name", :flag, "Should the target package name be in " \
+    "lowercase?", :default => true
+  option "--downcase-dependencies", :flag, "Should the package dependencies " \
+    "be in lowercase?", :default => true
+
+  option "--install-bin", "BIN_PATH", "The path to where python scripts " \
+    "should be installed to."
+  option "--install-lib", "LIB_PATH", "The path to where python libs " \
+    "should be installed to (default depends on your python installation). " \
+    "Want to find out 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 " \
+    "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 " \
+    "in the top-level directory of the python package for dependency " \
+    "detection.", :default => false
+  option "--scripts-executable", "PYTHON_EXECUTABLE", "Set custom python " \
+    "interpreter in installing scripts. By default distutils will replace " \
+    "python interpreter in installing scripts (specified by shebang) with " \
+    "current python interpreter (sys.executable). This option is equivalent " \
+    "to appending 'build_scripts --executable PYTHON_EXECUTABLE' arguments " \
+    "to 'setup.py install' command."
+  option "--disable-dependency", "python_package_name",
+    "The python package name to remove from dependency list",
+    :multivalued => true, :attribute_name => :python_disable_dependency,
+    :default => []
+
+  private
+
+  # Input a package.
+  #
+  # The 'package' can be any of:
+  #
+  # * A name of a package on pypi (ie; easy_install some-package)
+  # * The path to a directory containing setup.py
+  # * The path to a setup.py
+  def input(package)
+    path_to_package = download_if_necessary(package, version)
+
+    if File.directory?(path_to_package)
+      setup_py = File.join(path_to_package, "setup.py")
+    else
+      setup_py = path_to_package
+    end
+
+    if !File.exist?(setup_py)
+      logger.error("Could not find 'setup.py'", :path => setup_py)
+      raise "Unable to find python package; tried #{setup_py}"
+    end
+
+    load_package_info(setup_py)
+    install_to_staging(setup_py)
+  end # def input
+
+  # Download the given package if necessary. If version is given, that version
+  # will be downloaded, otherwise the latest is fetched.
+  def download_if_necessary(package, version=nil)
+    # TODO(sissel): this should just be a 'download' method, the 'if_necessary'
+    # part should go elsewhere.
+    path = package
+    # If it's a path, assume local build.
+    if File.directory?(path) or (File.exist?(path) and File.basename(path) == "setup.py")
+      return path
+    end
+
+    logger.info("Trying to download", :package => package)
+
+    if version.nil?
+      want_pkg = "#{package}"
+    else
+      want_pkg = "#{package}==#{version}"
+    end
+
+    target = build_path(package)
+    FileUtils.mkdir(target) unless File.directory?(target)
+
+    if attributes[:python_pip].nil?
+      # no pip, use easy_install
+      logger.debug("no pip, defaulting to easy_install", :easy_install => attributes[:python_easyinstall])
+      safesystem(attributes[:python_easyinstall], "-i",
+                 attributes[:python_pypi], "--editable", "-U",
+                 "--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)
+    end
+
+    # easy_install will put stuff in @tmpdir/packagename/, so find that:
+    #  @tmpdir/somepackage/setup.py
+    dirs = ::Dir.glob(File.join(target, "*"))
+    if dirs.length != 1
+      raise "Unexpected directory layout after easy_install. Maybe file a bug? The directory is #{build_path}"
+    end
+    return dirs.first
+  end # def download
+
+  # Load the package information like name, version, dependencies.
+  def load_package_info(setup_py)
+    if !attributes[:python_package_prefix].nil?
+      attributes[:python_package_name_prefix] = attributes[:python_package_prefix]
+    end
+
+    begin
+      json_test_code = [
+        "try:",
+        "  import json",
+        "except ImportError:",
+        "  import simplejson as json"
+      ].join("\n")
+      safesystem("#{attributes[:python_bin]} -c '#{json_test_code}'")
+    rescue FPM::Util::ProcessFailed => e
+      logger.error("Your python environment is missing json support (either json or simplejson python module). I cannot continue without this.", :python => attributes[:python_bin], :error => e)
+      raise FPM::Util::ProcessFailed, "Python (#{attributes[:python_bin]}) is missing simplejson or json modules."
+    end
+
+    begin
+      safesystem("#{attributes[:python_bin]} -c 'import pkg_resources'")
+    rescue FPM::Util::ProcessFailed => e
+      logger.error("Your python environment is missing a working setuptools module. I tried to find the 'pkg_resources' module but failed.", :python => attributes[:python_bin], :error => e)
+      raise FPM::Util::ProcessFailed, "Python (#{attributes[:python_bin]}) is missing pkg_resources module."
+    end
+
+    # Add ./pyfpm/ to the python library path
+    pylib = File.expand_path(File.dirname(__FILE__))
+
+    # chdir to the directory holding setup.py because some python setup.py's assume that you are
+    # in the same directory.
+    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 --output=#{tmp}"
+
+      if attributes[:python_obey_requirements_txt?]
+        setup_cmd += " --load-requirements-txt"
+      end
+
+      # Capture the output, which will be JSON metadata describing this python
+      # package. See fpm/lib/fpm/package/pyfpm/get_metadata.py for more
+      # details.
+      logger.info("fetching package metadata", :setup_cmd => setup_cmd)
+
+      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
+      File.read(tmp)
+    end
+    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"]
+    self.description = metadata["description"]
+    # Sometimes the license field is multiple lines; do best-effort and just
+    # use the first line.
+    self.license = metadata["license"].split(/[\r\n]+/).first
+    self.version = metadata["version"]
+    self.url = metadata["url"]
+
+    # name prefixing is optional, if enabled, a name 'foo' will become
+    # 'python-foo' (depending on what the python_package_name_prefix is)
+    if attributes[:python_fix_name?]
+      self.name = fix_name(metadata["name"])
+    else
+      self.name = metadata["name"]
+    end
+
+    # convert python-Foo to python-foo if flag is set
+    self.name = self.name.downcase if attributes[:python_downcase_name?]
+
+    if !attributes[:no_auto_depends?] and attributes[:python_dependencies?]
+      metadata["dependencies"].each do |dep|
+        dep_re = /^([^<>!= ]+)\s*(?:([<>!=]{1,2})\s*(.*))?$/
+        match = dep_re.match(dep)
+        if match.nil?
+          logger.error("Unable to parse dependency", :dependency => dep)
+          raise FPM::InvalidPackageConfiguration, "Invalid dependency '#{dep}'"
+        end
+        name, cmp, version = match.captures
+
+        next if attributes[:python_disable_dependency].include?(name)
+
+        # convert == to =
+        if cmp == "=="
+          logger.info("Converting == dependency requirement to =", :dependency => dep )
+          cmp = "="
+        end
+
+        # dependency name prefixing is optional, if enabled, a name 'foo' will
+        # become 'python-foo' (depending on what the python_package_name_prefix
+        # is)
+        name = fix_name(name) if attributes[:python_fix_dependencies?]
+
+        # convert dependencies from python-Foo to python-foo
+        name = name.downcase if attributes[:python_downcase_dependencies?]
+
+        self.dependencies << "#{name} #{cmp} #{version}"
+      end
+    end # if attributes[:python_dependencies?]
+  end # def load_package_info
+
+  # Sanitize package name.
+  # Some PyPI packages can be named 'python-foo', so we don't want to end up
+  # with a package named 'python-python-foo'.
+  # But we want packages named like 'pythonweb' to be suffixed
+  # 'python-pythonweb'.
+  def fix_name(name)
+    if name.start_with?("python")
+      # If the python package is called "python-foo" strip the "python-" part while
+      # prepending the package name prefix.
+      return [attributes[:python_package_name_prefix], name.gsub(/^python-/, "")].join("-")
+    else
+      return [attributes[:python_package_name_prefix], name].join("-")
+    end
+  end # def fix_name
+
+  # Install this package to the staging directory
+  def install_to_staging(setup_py)
+    project_dir = File.dirname(setup_py)
+
+    prefix = "/"
+    prefix = attributes[:prefix] unless attributes[:prefix].nil?
+
+    # Some setup.py's assume $PWD == current directory of setup.py, so let's
+    # chdir first.
+    ::Dir.chdir(project_dir) do
+      flags = [ "--root", staging_path ]
+      if !attributes[:python_install_lib].nil?
+        flags += [ "--install-lib", File.join(prefix, attributes[:python_install_lib]) ]
+      elsif !attributes[:prefix].nil?
+        # setup.py install --prefix PREFIX still installs libs to
+        # PREFIX/lib64/python2.7/site-packages/
+        # but we really want something saner.
+        #
+        # since prefix is given, but not python_install_lib, assume PREFIX/lib
+        flags += [ "--install-lib", File.join(prefix, "lib") ]
+      end
+
+      if !attributes[:python_install_data].nil?
+        flags += [ "--install-data", File.join(prefix, attributes[:python_install_data]) ]
+      elsif !attributes[:prefix].nil?
+        # prefix given, but not python_install_data, assume PREFIX/data
+        flags += [ "--install-data", File.join(prefix, "data") ]
+      end
+
+      if !attributes[:python_install_bin].nil?
+        flags += [ "--install-scripts", File.join(prefix, attributes[:python_install_bin]) ]
+      elsif !attributes[:prefix].nil?
+        # prefix given, but not python_install_bin, assume PREFIX/bin
+        flags += [ "--install-scripts", File.join(prefix, "bin") ]
+      end
+
+      if !attributes[:python_scripts_executable].nil?
+        # Overwrite installed python scripts shebang binary with provided executable
+        flags += [ "build_scripts", "--executable", attributes[:python_scripts_executable] ]
+      end
+
+      safesystem(attributes[:python_bin], "setup.py", "install", *flags)
+    end
+  end # def install_to_staging
+
+  public(:input)
+end # class FPM::Package::Python