Class: FPM::Package::Deb

Inherits:

FPM::Package

• Object
• FPM::Package
• FPM::Package::Deb

Defined in:

lib/fpm/package/deb.rb

Overview

Support for debian packages (.deb files)

This class supports both input and output of packages.

Constant Summary

SCRIPT_MAP =

Map of what scripts are named.

{
  :before_install     => "preinst",
  :after_install      => "postinst",
  :before_remove      => "prerm",
  :after_remove       => "postrm",
  :after_purge        => "postrm",
}

COMPRESSION_TYPES =

The list of supported compression types. Default is gz (gzip)

[ "gz", "bzip2", "xz", "none" ]

Instance Attribute Summary

Attributes inherited from FPM::Package

#attributes, #attrs, #category, #config_files, #conflicts, #dependencies, #description, #directories, #epoch, #iteration, #license, #maintainer, #provides, #replaces, #scripts, #url, #vendor, #version

Instance Method Summary

• #add_path(path, allconfigs) ⇒ Object

  expand recursively a given path to be put in allconfigs.

• #architecture ⇒ Object

  Return the architecture.

• #converted_from(origin) ⇒ Object

  def output.

• #data_tar_flags ⇒ Object

  def to_s.

• #initialize(*args) ⇒ Deb constructor

  A new instance of Deb.

• #input(input_path) ⇒ Object

  def prefix.

• #name ⇒ Object

  Get the name of this package.

• #output(output_path) ⇒ Object

  def extract_files.

• #prefix ⇒ Object

  def name.

• #to_s(format = nil) ⇒ Object

Methods inherited from FPM::Package

apply_options, #build_path, #cleanup, #cleanup_build, #cleanup_staging, #convert, default_attributes, #edit_file, #files, inherited, option, #script, #staging_path, type, #type, types

Methods included from Util

#ar_cmd, #ar_cmd_deterministic?, #copied_entries, #copy_entry, #copy_metadata, #default_shell, #execmd, #expand_pessimistic_constraints, #logger, #mknod_w, #program_exists?, #program_in_path?, #safesystem, #safesystemout, #tar_cmd, #tar_cmd_supports_sort_names_and_set_mtime?

Constructor Details

#initialize(*args) ⇒ Deb

Returns a new instance of Deb.

# File 'lib/fpm/package/deb.rb', line 202

def initialize(*args)
  super(*args)
  attributes[:deb_priority] = "extra"
end

Instance Method Details

#add_path(path, allconfigs) ⇒ Object

expand recursively a given path to be put in allconfigs

# File 'lib/fpm/package/deb.rb', line 890

def add_path(path, allconfigs)
  # Strip leading /
  path = path[1..-1] if path[0,1] == "/"
  cfg_path = File.expand_path(path, staging_path)
  Find.find(cfg_path) do |p|
    if File.file?(p)
      allconfigs << p.gsub("#{staging_path}/", '')
    end
  end
end

#architecture ⇒ Object

Return the architecture. This will default to native if not yet set. It will also try to use dpkg and ‘uname -m’ to figure out what the native ‘architecture’ value should be.

# File 'lib/fpm/package/deb.rb', line 212

def architecture
  if @architecture.nil? or @architecture == "native"
    # Default architecture should be 'native' which we'll need to ask the
    # system about.
    if program_in_path?("dpkg")
      @architecture = %x{dpkg --print-architecture 2> /dev/null}.chomp
      if $?.exitstatus != 0 or @architecture.empty?
        # if dpkg fails or emits nothing, revert back to uname -m
        @architecture = %x{uname -m}.chomp
      end
    else
      @architecture = %x{uname -m}.chomp
    end
  end

  case @architecture
  when "x86_64"
    # Debian calls x86_64 "amd64"
    @architecture = "amd64"
  when "noarch"
    # Debian calls noarch "all"
    @architecture = "all"
  end
  return @architecture
end

#converted_from(origin) ⇒ Object

def output

# File 'lib/fpm/package/deb.rb', line 648

def converted_from(origin)
  self.dependencies = self.dependencies.collect do |dep|
    fix_dependency(dep)
  end.flatten
  self.provides = self.provides.collect do |provides|
    fix_provides(provides)
  end.flatten

  if origin == FPM::Package::Deb
    changelog_path = staging_path("usr/share/doc/#{name}/changelog.Debian.gz")
    if File.exists?(changelog_path)
      logger.debug("Found a deb changelog file, using it.", :path => changelog_path)
      attributes[:deb_changelog] = build_path("deb_changelog")
      File.open(attributes[:deb_changelog], "w") do |deb_changelog|
        Zlib::GzipReader.open(changelog_path) do |gz|
          IO::copy_stream(gz, deb_changelog)
        end
      end
      File.unlink(changelog_path)
    end
  end

  if origin == FPM::Package::Deb
    changelog_path = staging_path("usr/share/doc/#{name}/changelog.gz")
    if File.exists?(changelog_path)
      logger.debug("Found an upstream changelog file, using it.", :path => changelog_path)
      attributes[:deb_upstream_changelog] = build_path("deb_upstream_changelog")
      File.open(attributes[:deb_upstream_changelog], "w") do |deb_upstream_changelog|
        Zlib::GzipReader.open(changelog_path) do |gz|
          IO::copy_stream(gz, deb_upstream_changelog)
        end
      end
      File.unlink(changelog_path)
    end
  end
end

#data_tar_flags ⇒ Object

def to_s

# File 'lib/fpm/package/deb.rb', line 1060

def data_tar_flags
  data_tar_flags = []
  if attributes[:deb_use_file_permissions?].nil?
    if !attributes[:deb_user].nil?
      if attributes[:deb_user] == 'root'
        data_tar_flags += [ "--numeric-owner", "--owner", "0" ]
      else
        data_tar_flags += [ "--owner", attributes[:deb_user] ]
      end
    end

    if !attributes[:deb_group].nil?
      if attributes[:deb_group] == 'root'
        data_tar_flags += [ "--numeric-owner", "--group", "0" ]
      else
        data_tar_flags += [ "--group", attributes[:deb_group] ]
      end
    end
  end
  return data_tar_flags
end

#input(input_path) ⇒ Object

def prefix

# File 'lib/fpm/package/deb.rb', line 272

def input(input_path)
  extract_info(input_path)
  extract_files(input_path)
end

#name ⇒ Object

Get the name of this package. See also FPM::Package#name

This accessor actually modifies the name if it has some invalid or unwise characters.

# File 'lib/fpm/package/deb.rb', line 242

def name
  if @name =~ /[A-Z]/
    logger.warn("Debian tools (dpkg/apt) don't do well with packages " \
      "that use capital letters in the name. In some cases it will " \
      "automatically downcase them, in others it will not. It is confusing." \
      " Best to not use any capital letters at all. I have downcased the " \
      "package name for you just to be safe.",
      :oldname => @name, :fixedname => @name.downcase)
    @name = @name.downcase
  end

  if @name.include?("_")
    logger.info("Debian package names cannot include underscores; " \
                 "automatically converting to dashes", :name => @name)
    @name = @name.gsub(/[_]/, "-")
  end

  if @name.include?(" ")
    logger.info("Debian package names cannot include spaces; " \
                 "automatically converting to dashes", :name => @name)
    @name = @name.gsub(/[ ]/, "-")
  end

  return @name
end

#output(output_path) ⇒ Object

def extract_files

# File 'lib/fpm/package/deb.rb', line 425

def output(output_path)
  self.provides = self.provides.collect { |p| fix_provides(p) }
  output_check(output_path)
  # Abort if the target path already exists.

  # create 'debian-binary' file, required to make a valid debian package
  File.write(build_path("debian-binary"), "2.0\n")

  # If we are given --deb-shlibs but no --after-install script, we
  # should implicitly create a before/after scripts that run ldconfig
  if attributes[:deb_shlibs]
    if !script?(:after_install)
      logger.info("You gave --deb-shlibs but no --after-install, so " \
                   "I am adding an after-install script that runs " \
                   "ldconfig to update the system library cache")
      scripts[:after_install] = template("deb/ldconfig.sh.erb").result(binding)
    end
    if !script?(:after_remove)
      logger.info("You gave --deb-shlibs but no --after-remove, so " \
                   "I am adding an after-remove script that runs " \
                   "ldconfig to update the system library cache")
      scripts[:after_remove] = template("deb/ldconfig.sh.erb").result(binding)
    end
  end

  if attributes[:source_date_epoch].nil? and not attributes[:source_date_epoch_default].nil?
    attributes[:source_date_epoch] = attributes[:source_date_epoch_default]
  end
  if attributes[:source_date_epoch] == "0"
    logger.error("Alas, ruby's Zlib::GzipWriter does not support setting an mtime of zero.  Aborting.")
    raise "#{name}: source_date_epoch of 0 not supported."
  end
  if not attributes[:source_date_epoch].nil? and not ar_cmd_deterministic?
    logger.error("Alas, could not find an ar that can handle -D option. Try installing recent gnu binutils. Aborting.")
    raise "#{name}: ar is insufficient to support source_date_epoch."
  end
  if not attributes[:source_date_epoch].nil? and not tar_cmd_supports_sort_names_and_set_mtime?
    logger.error("Alas, could not find a tar that can set mtime and sort.  Try installing recent gnu tar. Aborting.")
    raise "#{name}: tar is insufficient to support source_date_epoch."
  end

  attributes[:deb_systemd] = []
  attributes.fetch(:deb_systemd_list, []).each do |systemd|
    name = File.basename(systemd, ".service")
    dest_systemd = staging_path("lib/systemd/system/#{name}.service")
    mkdir_p(File.dirname(dest_systemd))
    FileUtils.cp(systemd, dest_systemd)
    File.chmod(0644, dest_systemd)

    # add systemd service name to attribute
    attributes[:deb_systemd] << name
  end

  if script?(:before_upgrade) or script?(:after_upgrade) or attributes[:deb_systemd].any?
    puts "Adding action files"
    if script?(:before_install) or script?(:before_upgrade)
      scripts[:before_install] = template("deb/preinst_upgrade.sh.erb").result(binding)
    end
    if script?(:before_remove) or not attributes[:deb_systemd].empty?
      scripts[:before_remove] = template("deb/prerm_upgrade.sh.erb").result(binding)
    end
    if script?(:after_install) or script?(:after_upgrade) or attributes[:deb_systemd].any?
      scripts[:after_install] = template("deb/postinst_upgrade.sh.erb").result(binding)
    end
    if script?(:after_remove)
      scripts[:after_remove] = template("deb/postrm_upgrade.sh.erb").result(binding)
    end
    if script?(:after_purge)
      scripts[:after_purge] = template("deb/postrm_upgrade.sh.erb").result(binding)
    end
  end

  # There are two changelogs that may appear:
  #   - debian-specific changelog, which should be archived as changelog.Debian.gz
  #   - upstream changelog, which should be archived as changelog.gz
  # see https://www.debian.org/doc/debian-policy/ch-docs.html#s-changelogs

  # Write the changelog.Debian.gz file
  dest_changelog = File.join(staging_path, "usr/share/doc/#{name}/changelog.Debian.gz")
  mkdir_p(File.dirname(dest_changelog))
  File.new(dest_changelog, "wb", 0644).tap do |changelog|
    Zlib::GzipWriter.new(changelog, Zlib::BEST_COMPRESSION).tap do |changelog_gz|
      if not attributes[:source_date_epoch].nil?
        changelog_gz.mtime = attributes[:source_date_epoch].to_i
      end
      if attributes[:deb_changelog]
        logger.info("Writing user-specified changelog", :source => attributes[:deb_changelog])
        File.new(attributes[:deb_changelog]).tap do |fd|
          chunk = nil
          # Ruby 1.8.7 doesn't have IO#copy_stream
          changelog_gz.write(chunk) while chunk = fd.read(16384)
        end.close
      else
        logger.info("Creating boilerplate changelog file")
        changelog_gz.write(template("deb/changelog.erb").result(binding))
      end
    end.close
  end # No need to close, GzipWriter#close will close it.

  # Write the changelog.gz file (upstream changelog)
  dest_upstream_changelog = File.join(staging_path, "usr/share/doc/#{name}/changelog.gz")
  if attributes[:deb_upstream_changelog]
    File.new(dest_upstream_changelog, "wb", 0644).tap do |changelog|
      Zlib::GzipWriter.new(changelog, Zlib::BEST_COMPRESSION).tap do |changelog_gz|
          if not attributes[:source_date_epoch].nil?
            changelog_gz.mtime = attributes[:source_date_epoch].to_i
          end
          logger.info("Writing user-specified upstream changelog", :source => attributes[:deb_upstream_changelog])
          File.new(attributes[:deb_upstream_changelog]).tap do |fd|
            chunk = nil
            # Ruby 1.8.7 doesn't have IO#copy_stream
            changelog_gz.write(chunk) while chunk = fd.read(16384)
          end.close
      end.close
    end # No need to close, GzipWriter#close will close it.
  end

  if File.exists?(dest_changelog) and not File.exists?(dest_upstream_changelog)
    # see https://www.debian.org/doc/debian-policy/ch-docs.html#s-changelogs
    File.rename(dest_changelog, dest_upstream_changelog)
  end

  attributes.fetch(:deb_init_list, []).each do |init|
    name = File.basename(init, ".init")
    dest_init = File.join(staging_path, "etc/init.d/#{name}")
    mkdir_p(File.dirname(dest_init))
    FileUtils.cp init, dest_init
    File.chmod(0755, dest_init)
  end

  attributes.fetch(:deb_default_list, []).each do |default|
    name = File.basename(default, ".default")
    dest_default = File.join(staging_path, "etc/default/#{name}")
    mkdir_p(File.dirname(dest_default))
    FileUtils.cp default, dest_default
    File.chmod(0644, dest_default)
  end

  attributes.fetch(:deb_upstart_list, []).each do |upstart|
    name = File.basename(upstart, ".upstart")
    dest_init = staging_path("etc/init.d/#{name}")
    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)

    # Install an init.d shim that calls upstart
    mkdir_p(File.dirname(dest_init))
    FileUtils.ln_s("/lib/init/upstart-job", dest_init)
  end

  attributes.fetch(:deb_systemd_list, []).each do |systemd|
    name = File.basename(systemd, ".service")
    dest_systemd = staging_path("lib/systemd/system/#{name}.service")
    mkdir_p(File.dirname(dest_systemd))
    FileUtils.cp(systemd, dest_systemd)
    File.chmod(0644, dest_systemd)
  end

  write_control_tarball

  # Tar up the staging_path into data.tar.{compression type}
  case self.attributes[:deb_compression]
    when "gz", nil
      datatar = build_path("data.tar.gz")
      compression = "-z"
    when "bzip2"
      datatar = build_path("data.tar.bz2")
      compression = "-j"
    when "xz"
      datatar = build_path("data.tar.xz")
      compression = "-J"
    when "none"
      datatar = build_path("data.tar")
      compression = ""
    else
      raise FPM::InvalidPackageConfiguration,
        "Unknown compression type '#{self.attributes[:deb_compression]}'"
  end

  args = [ tar_cmd, "-C", staging_path, compression ] + data_tar_flags + [ "-cf", datatar, "." ]
  if tar_cmd_supports_sort_names_and_set_mtime? and not attributes[:source_date_epoch].nil?
    # Use gnu tar options to force deterministic file order and timestamp
    args += ["--sort=name", ("--mtime=@%s" % attributes[:source_date_epoch])]
    # gnu tar obeys GZIP environment variable with options for gzip; -n = forget original filename and date
    args.unshift({"GZIP" => "-9n"})
  end
  safesystem(*args)

  # pack up the .deb, which is just an 'ar' archive with 3 files
  # the 'debian-binary' file has to be first
  File.expand_path(output_path).tap do |output_path|
    ::Dir.chdir(build_path) do
      safesystem(*ar_cmd, output_path, "debian-binary", "control.tar.gz", datatar)
    end
  end

  # if a PACKAGENAME.changes file is to be created
  if self.attributes[:deb_generate_changes?]
    distribution = self.attributes[:deb_dist]

    # gather information about the files to distribute
    files = [ output_path ]
    changes_files = []
    files.each do |path|
      changes_files.push({
        :name => path,
        :size => File.size?(path),
        :md5sum => Digest::MD5.file(path).hexdigest,
        :sha1sum => Digest::SHA1.file(path).hexdigest,
        :sha256sum => Digest::SHA2.file(path).hexdigest,
      })
    end

    # write change infos to .changes file
    changes_path = File.basename(output_path, '.deb') + '.changes'
    changes_data = template("deb/deb.changes.erb").result(binding)
    File.write(changes_path, changes_data)
    logger.log("Created changes", :path => changes_path)
  end # if deb_generate_changes
end

#prefix ⇒ Object

def name

# File 'lib/fpm/package/deb.rb', line 268

def prefix
  return (attributes[:prefix] or "/")
end

#to_s(format = nil) ⇒ Object

# File 'lib/fpm/package/deb.rb', line 1054

def to_s(format=nil)
  # Default format if nil
  # git_1.7.9.3-1_amd64.deb
  return super(format.nil? ? "NAME_FULLVERSION_ARCH.EXTENSION" : format)
end