tpkg 2.3.3 → 2.3.4

data/lib/tpkg/os.rb

@@ -0,0 +1,164 @@
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+begin
+  # Try loading facter w/o gems first so that we don't introduce a
+  # dependency on rubygems if it is not needed.
+  require 'facter'
+rescue LoadError
+  require 'rubygems'
+  require 'facter'
+end
+
+class Tpkg::OS
+  @@implementations = []
+  def self.register_implementation(impl)
+    @@implementations << impl
+  end
+  Dir.glob(File.expand_path('os/*.rb', File.dirname(__FILE__))).each {|d| require d}
+  def self.create(options={})
+    impl = @@implementations.detect{|i| i.supported?} || raise(NotImplementedError)
+    impl.new(options)
+  end
+  
+  def initialize(options={})
+    @debug = options[:debug]
+    @os = nil
+    @os_name = nil
+    @os_version = nil
+    @arch = nil
+    Facter.loadfacts
+  end
+  
+  #
+  # OS-specific classes should (must?) implement these methods
+  #
+  
+  # Given info for a init script from a package's metadata return an array
+  # of paths where that init script should linked to on the system
+  def init_links(installed_path, tpkgfile)
+    # I think users would rather have packages install without their init
+    # scripts enabled than have them fail to install on platforms where we
+    # don't have init script support.
+    # raise NotImplementedError
+    warn "No init script support for OS #{os}"
+    []
+  end
+  def available_native_packages(pkgname)
+    raise NotImplementedError
+  end
+  def install_native_package(pkg)
+    raise NotImplementedError
+  end
+  def upgrade_native_package(pkg)
+    raise NotImplementedError
+  end
+  # Create and install a native stub package, if pkg has native
+  # dependencies, to express those dependencies to the native package
+  # system.  This helps ensure that users don't inadvertently remove native
+  # packages that tpkg packages depend on.
+  def stub_native_pkg(pkg)
+    # I think users would rather have packages install without a native stub
+    # than have them fail to install on platforms where we don't have native
+    # stub support.
+    # raise NotImplementedError
+    native_deps = pkg[:metadata].get_native_deps
+    if !native_deps.empty?
+      warn "No native stub support for OS #{os}"
+    end
+  end
+  # Remove the native dependency stub package (if there is one) associated
+  # with pkg
+  def remove_native_stub_pkg(pkg)
+    # raise NotImplementedError
+    warn "No native stub support for OS #{os}"
+  end
+  # This rarely works as-is, most platforms need something more specific
+  def os_version
+    if !@os_version
+      if Facter['operatingsystemrelease'] &&
+         Facter['operatingsystemrelease'].value &&
+         !Facter['operatingsystemrelease'].value.empty?
+        @os_version = Facter['operatingsystemrelease'].value
+      else
+        raise "Unable to determine proper OS value on this platform"
+      end
+    end
+    @os_version.dup
+  end
+  # This also rarely works as-is
+  def native_pkg_to_install_string(pkg)
+    name = pkg[:metadata][:name]
+    version = pkg[:metadata][:version]
+    package_version = pkg[:metadata][:package_version]
+    pkgname = "#{name}-#{version}"
+    if package_version
+       pkgname << "-#{package_version}"
+    end
+    pkgname
+  end
+  
+  #
+  # These methods have implementations that work in most cases, but
+  # OS-specific classes may modify these definitions if needed.
+  #
+  
+  def os
+    if !@os
+      @os = "#{os_name}-#{os_version}"
+    end
+    @os.dup
+  end
+  def os_name
+    if !@os_name
+      @os_name = Facter['operatingsystem'].value
+    end
+    @os_name.dup
+  end
+  def arch
+    if !@arch
+      @arch = Facter['hardwaremodel'].value
+    end
+    @arch.dup
+  end
+  def fqdn
+    # Note that we intentionally do not cache the fqdn.  The hostname of a
+    # machine can change at any time and it would be unexpected if the user
+    # had to restart a tpkg-based application to pick up a hostname change.
+    if Facter['fqdn'] && Facter['fqdn'].value
+      Facter['fqdn'].value
+    else
+      Facter['hostname'].value << '.' << Facter['domain'].value
+    end
+  end
+  # Systems with cron.d support should override this
+  def cron_dot_d_directory
+  end
+  # Should sudo be on by default?
+  def sudo_default?
+    true
+  end
+  
+  #
+  # Utility methods
+  #
+  
+  def sys_v_init_links(installed_path, tpkgfile, default_levels, init_directory)
+    start = '99'
+    if tpkgfile[:init][:start]
+      start = tpkgfile[:init][:start]
+    end
+    levels = default_levels
+    if tpkgfile[:init][:levels]
+      levels = tpkgfile[:init][:levels]
+      # In case the user specified levels in yaml as string/integer
+      # instead of array
+      if !levels.kind_of?(Array)
+        levels = levels.to_s.split(//)
+      end
+    end
+    levels.collect do |level|
+      File.join(init_directory, "rc#{level}.d", 'S' + start.to_s + File.basename(installed_path))
+    end
+  end
+end

data/lib/tpkg/os/debian.rb

@@ -0,0 +1,159 @@
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+class Tpkg::OS::Debian < Tpkg::OS
+  def self.supported?
+    Facter.loadfacts
+    ['Debian', 'Ubuntu'].include?(Facter['operatingsystem'].value)
+  end
+  register_implementation(self)
+  
+  def initialize(options={})
+    @dpkgquerycmd = options[:dpkgquerycmd] || options[:testcmd] || 'dpkg-query'
+    @aptcachecmd = options[:aptcachecmd] || options[:testcmd] || 'apt-cache'
+    @aptgetcmd = options[:aptgetcmd] || options[:testcmd] || 'apt-get'
+    super
+  end
+  
+  def init_links(installed_path, tpkgfile)
+    sys_v_init_links(installed_path, tpkgfile, ['2', '3', '4', '5'], '/etc')
+  end
+  def cron_dot_d_directory
+    '/etc/cron.d'
+  end
+  def available_native_packages(pkgname)
+    native_packages = []
+    # The default 'dpkg -l' format has an optional third column for errors
+    # which makes it hard to parse reliably, so we specify a custom format.
+    cmd = "#{@dpkgquerycmd} -W -f='${Package} ${Version} ${Status}\n' #{pkgname}"
+    puts "available_native_packages running #{cmd}" if @debug
+    stderr_first_line = nil
+    Open3.popen3(cmd) do |stdin, stdout, stderr|
+      stdin.close
+      stdout.each_line do |line|
+        name, debversion, status = line.split(' ', 3)
+        # Seems to be Debian convention that if the package has a
+        # package version you seperate that from the upstream version
+        # with a hyphen.
+        version = nil
+        package_version = nil
+        if debversion =~ /-/
+          version, package_version = debversion.split('-', 2)
+        else
+          version = debversion
+        end
+        # We want packages with a state of "installed".  However,
+        # there's also a state of "not-installed", and the state
+        # field contains several space-seperated values, so we have
+        # to be somewhat careful to pick out "installed".
+        if status.split(' ').include?('installed')
+          pkg = Tpkg.pkg_for_native_package(name, version, package_version, :native_installed)
+          native_packages << pkg
+        end
+      end
+      stderr_first_line = stderr.gets
+    end
+    # FIXME: popen3 doesn't set $?
+    if !$?.success?
+      # Ignore 'no matching packages', raise anything else
+      if stderr_first_line !~ 'No packages found matching'
+        raise "available_native_packages error running dpkg-query"
+      end
+    end
+    
+    cmd = "#{@aptcachecmd} show #{pkgname}"
+    puts "available_native_packages running '#{cmd}'" if @debug
+    stderr_first_line = nil
+    Open3.popen3(cmd) do |stdin, stdout, stderr|
+      stdin.close
+      name = nil
+      version = nil
+      package_version = nil
+      skip = false
+      stdout.each_line do |line|
+        if line =~ /^Package: (.*)/
+          name = $1
+          version = nil
+          package_version = nil
+          skip = false
+        elsif line =~ /Status: (.*)/
+          # Packages with status are coming from dpkg rather than apt. They're
+          # either already installed (and thus captured by the dpkg-query
+          # above) or uninstalled and not really available.  This seems to be
+          # a new feature of apt-get in Debian 7.  On older systems these
+          # packages don't show up in apt-get show, which is why we still need
+          # the dpkg-query command above.
+          skip = true
+        elsif line =~ /^Version: (.*)/ && !skip
+          debversion = $1
+          # Seems to be Debian convention that if the package has a
+          # package version you seperate that from the upstream version
+          # with a hyphen.
+          if debversion =~ /-/
+            version, package_version = debversion.split('-', 2)
+          else
+            version = debversion
+          end
+          pkg = Tpkg.pkg_for_native_package(name, version, package_version, :native_available)
+          native_packages << pkg
+        end
+      end
+      stderr_first_line = stderr.gets
+    end
+    # FIXME: popen3 doesn't set $?
+    if !$?.success?
+      # Ignore 'no matching packages', raise anything else
+      if stderr_first_line !~ 'No packages found'
+        raise "available_native_packages error running apt-cache"
+      end
+    end
+    native_packages
+  end
+  def native_pkg_to_install_string(pkg)
+    name = pkg[:metadata][:name]
+    version = pkg[:metadata][:version]
+    package_version = pkg[:metadata][:package_version]
+    pkgname = "#{name}=#{version}"
+    if package_version
+       pkgname << "-#{package_version}"
+    end
+    pkgname
+  end
+  def install_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    cmd = "#{@aptgetcmd} -y install #{pkgname}"
+    puts "Running '#{cmd}' to install native package" if @debug
+    system(cmd)
+  end
+  def upgrade_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    cmd = "#{@aptgetcmd} -y install #{pkgname}"
+    puts "Running '#{cmd}' to upgrade native package" if @debug
+    system(cmd)
+  end
+  
+  def os_version
+    if !@os_version
+      if Facter['lsbmajdistrelease'] &&
+         Facter['lsbmajdistrelease'].value &&
+         !Facter['lsbmajdistrelease'].value.empty?
+        lsbmajdistrelease = Facter['lsbmajdistrelease'].value
+        # Normal wheezy beta returns 'testing', but Raspian on the
+        # Raspberry Pi returns this uglier string.  Normalize it.
+        if lsbmajdistrelease == 'testing/unstable'
+          lsbmajdistrelease = 'testing'
+        end
+        @os_version = lsbmajdistrelease
+      elsif Facter['lsbdistrelease'] &&
+            Facter['lsbdistrelease'].value &&
+            !Facter['lsbdistrelease'].value.empty? &&
+        # Work around lack of lsbmajdistrelease on older versions of Ubuntu
+        # due to older version of facter.  Support for lsbmajdistrelease on
+        # Ubuntu was added in facter 1.5.3, but there's no good way to force
+        # older Ubuntu systems to a newer version of facter.
+        @os_version = Facter['lsbdistrelease'].value.split('.').first
+      end
+    end
+    super
+  end
+end

data/lib/tpkg/os/freebsd.rb

@@ -0,0 +1,113 @@
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+require 'erb'
+
+class Tpkg::OS::FreeBSD < Tpkg::OS
+  def self.supported?
+    Facter.loadfacts
+    Facter['operatingsystem'].value == 'FreeBSD'
+  end
+  register_implementation(self)
+  
+  def initialize(options={})
+    @pkginfocmd = options[:pkginfocmd] || options[:testcmd] || 'pkg_info'
+    @pkgaddcmd = options[:pkgaddcmd] || options[:testcmd] || 'pkg_add'
+    @pkgdeletecmd = options[:pkgdeletecmd] || options[:testcmd] || 'pkg_delete'
+    # pkg_add -r defaults to the Latest/ directory, which just has generic
+    # versionless symlinks like curl.tbz.  We want to use the All/ directory
+    # so that we can specify a versioned file like curl-7.24.0.tbz.
+    @packagesite = options[:packagesite] ||
+      'ftp://ftp.freebsd.org/pub/FreeBSD/ports/<%= arch %>/packages-<%= os_version %>-stable/All/'
+    super
+  end
+  
+  def packagesite
+    url = ERB.new(@packagesite).result(binding)
+    # pkg_add expects the URL to end with a /
+    url << '/' if (url[-1] != '/')
+    url
+  end
+  
+  def init_links(installed_path, tpkgfile)
+    links = []
+    init_directory = '/usr/local/etc/rc.d'
+    if tpkgfile[:init][:levels] && tpkgfile[:init][:levels].empty?
+      # User doesn't want the init script linked in to auto-start
+    else
+      links << File.join(init_directory, File.basename(installed_path))
+    end
+    links
+  end
+  def available_native_packages(pkgname)
+    native_packages = []
+    cmd = "#{@pkginfocmd} -E #{pkgname}-*"
+    puts "available_native_packages running '#{cmd}'" if @debug
+    Open3.popen3(cmd) do |stdin, stdout, stderr|
+      stdin.close
+      stdout.each_line do |line|
+        fbversion = line.sub("#{pkgname}-", '').chomp
+        # Seems to be FreeBSD convention that if the package has a
+        # package version you seperate that from the upstream version
+        # with an underscore.
+        version, package_version = fbversion.split('_', 2)
+        native_packages <<
+          Tpkg.pkg_for_native_package(
+            pkgname, version, package_version, :native_installed)
+      end
+      stderr_first_line = stderr.gets
+    end
+    # FIXME: popen3 doesn't set $?
+    if !$?.success?
+      # Ignore 'no matching packages', raise anything else
+      if stderr_first_line !~ 'No match'
+        raise "available_native_packages error running pkg_info"
+      end
+    end
+    # FIXME: FreeBSD available packages
+    # We could either poke around in the ports tree (if installed), or
+    # try to recreate the URL "pkg_add -r" would use and pull a
+    # directory listing.
+    native_packages
+  end
+  def native_pkg_to_install_string(pkg)
+    name = pkg[:metadata][:name]
+    version = pkg[:metadata][:version]
+    package_version = pkg[:metadata][:package_version]
+    pkgname = "#{name}-#{version}"
+    if package_version
+       pkgname << "_#{package_version}"
+    end
+    pkgname
+  end
+  def install_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    cmd = "PACKAGESITE=#{packagesite} #{@pkgaddcmd} -r #{pkgname}"
+    puts "Running '#{cmd}' to install native package" if @debug
+    system('sh', '-c', cmd)
+  end
+  def upgrade_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    # This is not very ideal.  It would be better to download the
+    # new package, and if the download is successful remove the
+    # old package and install the new one.  The way we're doing it
+    # here we risk leaving the system with neither version
+    # installed if the download of the new package fails.
+    # However, the FreeBSD package tools don't make it easy to
+    # handle things properly.
+    deletecmd = "#{@pkgdeletecmd} #{pkgname}"
+    addcmd = "PACKAGESITE=#{packagesite} #{@pkgaddcmd} -r #{pkgname}"
+    puts "Running '#{deletecmd}' and '#{addcmd}' to upgrade native package" if @debug
+    system(deletecmd)
+    system('sh', '-c', addcmd)
+  end
+  
+  def os_version
+    if !@os_version
+      # Extract 7 from 7.1-RELEASE, for example
+      fbver = Facter['operatingsystemrelease'].value
+      @os_version = fbver.split('.').first
+    end
+    super
+  end
+end

data/lib/tpkg/os/macosx.rb

@@ -0,0 +1,113 @@
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+class Tpkg::OS::MacOSX < Tpkg::OS
+  def self.supported?
+    Facter.loadfacts
+    Facter['operatingsystem'].value == 'Darwin'
+  end
+  register_implementation(self)
+  
+  def initialize(options={})
+    @portcmd = options[:portcmd] || options[:testcmd] || '/opt/local/bin/port'
+    super
+  end
+  
+  def available_native_packages(pkgname)
+    native_packages = []
+    if File.exist?(@portcmd)
+      # Ports can also have an "epoch" number, but that appears to be
+      # invisible from the command line
+      # http://guide.macports.org/#reference.keywords
+      cmd = "#{@portcmd} installed #{pkgname}"
+      puts "available_native_packages running '#{cmd}'" if @debug
+      IO.popen(cmd) do |pipe|
+        pipe.each_line do |line|
+          next if line =~ /The following ports are currently installed/
+          next if line =~ /None of the specified ports are installed/
+          next if line !~ /\(active\)/
+          name, portversion = line.split(' ')
+          portversion.sub!(/^@/, '')
+          # Remove variant names
+          portversion.sub!(/\+.*/, '')
+          version, package_version = portversion.split('_', 2)
+          pkg = Tpkg.pkg_for_native_package(name, version, package_version, :native_installed)
+          native_packages << pkg
+        end
+      end
+      if !$?.success?
+        raise "available_native_packages error running port"
+      end
+      cmd = "#{@portcmd} list #{pkgname}"
+      puts "available_native_packages running '#{cmd}'" if @debug
+      IO.popen(cmd) do |pipe|
+        pipe.each_line do |line|
+          name, version = line.split(' ')
+          version.sub!(/^@/, '')
+          package_version = nil
+          pkg = Tpkg.pkg_for_native_package(name, version, package_version, :native_available)
+          native_packages << pkg
+        end
+      end
+      if !$?.success?
+        raise "available_native_packages error running port"
+      end
+    else
+      # Fink, Homebrew support would be nice
+      raise "No supported native package tool available on #{os}"
+    end
+    native_packages
+  end
+  def native_pkg_to_install_string(pkg)
+    pkgname = nil
+    if File.exist?(@portcmd)
+      pkgname = pkg[:metadata][:name]
+      # MacPorts doesn't support installing a specific version (AFAIK)
+      if pkg[:metadata][:version]
+        warn "Ignoring version with MacPorts"
+      end
+      if pkg[:metadata][:package_version]
+        warn "Ignoring package version with MacPorts"
+      end
+    else
+      # Fink, Homebrew support would be nice
+      raise "No supported native package tool available on #{os}"
+    end
+    pkgname
+  end
+  def install_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    if File.exist?(@portcmd)
+      cmd = "#{@portcmd} install #{pkgname}"
+      puts "Running '#{cmd}' to install native package" if @debug
+      system(cmd)
+    else
+      # Fink, Homebrew support would be nice
+      raise "No supported native package tool available on #{os}"
+    end
+  end
+  def upgrade_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    if File.exist?(@portcmd)
+      cmd = "#{@portcmd} upgrade #{pkgname}"
+      puts "Running '#{cmd}' to upgrade native package" if @debug
+      system(cmd)
+    else
+      # Fink, Homebrew support would be nice
+      raise "No supported native package tool available on #{os}"
+    end
+  end
+  
+  def os_version
+    if !@os_version
+      if Facter['macosx_productversion'] &&
+         Facter['macosx_productversion'].value &&
+         !Facter['macosx_productversion'].value.empty?
+        macver = Facter['macosx_productversion'].value
+        # Extract 10.5 from 10.5.6, for example
+        @os_version = macver.split('.')[0,2].join('.')
+      end
+    end
+    super
+  end
+end