tpkg 2.3.3 → 2.3.4

data/lib/tpkg/os/redhat.rb

@@ -0,0 +1,173 @@
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+class Tpkg::OS::RedHat < Tpkg::OS
+  def self.supported?
+    Facter.loadfacts
+    ['RedHat', 'CentOS', 'Fedora'].include?(Facter['operatingsystem'].value)
+  end
+  register_implementation(self)
+  
+  def initialize(options={})
+    @yumcmd = options[:yumcmd] || options[:testcmd] || 'yum'
+    @rpmcmd = options[:rpmcmd] || options[:testcmd] || 'rpm'
+    @rpmbuildcmd = options[:rpmbuildcmd] || options[:testcmd] || 'rpmbuild'
+    # This is primarily used by the unit tests
+    @quiet = options[:quiet]
+    super
+  end
+  
+  def init_links(installed_path, tpkgfile)
+    sys_v_init_links(installed_path, tpkgfile, ['2', '3', '4', '5'], '/etc/rc.d')
+  end
+  def cron_dot_d_directory
+    '/etc/cron.d'
+  end
+  def available_native_packages(pkgname)
+    native_packages = []
+    [ {:arg => 'installed', :header => 'Installed', :source => :native_installed},
+      {:arg => 'available', :header => 'Available', :source => :native_available} ].each do |yum|
+      cmd = "#{@yumcmd} info #{yum[:arg]} #{pkgname}"
+      puts "available_native_packages running '#{cmd}'" if @debug
+      stderr_first_line = nil
+      Open3.popen3(cmd) do |stdin, stdout, stderr|
+        stdin.close
+        read_packages = false
+        name = version = package_version = nil
+        stdout.each_line do |line|
+          if line =~ /#{yum[:header]} Packages/
+            # Skip the header lines until we get to this line
+            read_packages = true
+          elsif read_packages
+            if line =~ /^Name\s*:\s*(.+)/
+              name = $1.strip
+            elsif line =~ /^Arch\s*:\s*(.+)/
+              arch = $1.strip
+            elsif line =~ /^Version\s*:\s*(.+)/
+              version = $1.strip.to_s
+            elsif line =~ /^Release\s*:\s*(.+)/
+              package_version = $1.strip.to_s
+            elsif line =~ /^Repo\s*:\s*(.+)/
+              repo = $1.strip
+            elsif line =~ /^\s*$/
+              pkg = Tpkg.pkg_for_native_package(name, version, package_version, yum[:source])
+              native_packages << pkg
+              name = version = package_version = nil
+            end
+            # In the end we ignore the architecture.  Anything that
+            # shows up in yum should be installable on this box, and
+            # the chance of a mismatch between facter's idea of the
+            # architecture and RPM's idea is high.  I.e. i386 vs i686
+            # or i32e vs x86_64 or whatever.
+          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 != "Error: No matching Packages to list\n"
+          raise "available_native_packages error running yum"
+        end
+      end
+    end
+    native_packages
+  end
+  def install_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    cmd = "#{@yumcmd} -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 = "#{@yumcmd} -y install #{pkgname}"
+    puts "Running '#{cmd}' to upgrade native package" if @debug
+    system(cmd)
+  end
+  def stub_native_pkg(pkg)
+    native_deps = pkg[:metadata].get_native_deps
+    return if native_deps.empty?
+    
+    rpm = create_rpm("stub_for_#{pkg[:metadata][:name]}", native_deps)
+    return if rpm.nil?
+    
+    cmd = "#{@rpmcmd} -i #{rpm}"
+    puts "Running '#{cmd} to install native dependency stub" if @debug
+    system(cmd)
+    if !$?.success?
+      warn "Warning: Failed to install native stub package for #{pkg[:metadata][:name]}" unless @quiet
+    end
+  end
+  def remove_native_stub_pkg(pkg)
+    native_deps = pkg[:metadata].get_native_deps
+    return if native_deps.empty?
+    
+    stub_pkg_name = "stub_for_#{pkg[:metadata][:name]}"
+    cmd = "#{@yumcmd} -y remove #{stub_pkg_name}"
+    puts "Running '#{cmd} to remove native dependency stub" if @debug
+    puts cmd if @debug
+    system(cmd)
+    if !$?.success?
+      warn "Warning: Failed to remove native stub package for #{pkg[:metadata][:name]}" unless @quiet
+    end
+  end
+  
+  def os_version
+    if !@os_version
+      if Facter['lsbmajdistrelease'] &&
+         Facter['lsbmajdistrelease'].value &&
+         !Facter['lsbmajdistrelease'].value.empty?
+        @os_version = Facter['lsbmajdistrelease'].value
+      end
+    end
+    super
+  end
+  
+  private
+  def create_rpm(name, deps=[])
+    topdir = Tpkg::tempdir('rpmbuild')
+    %w[BUILD RPMS SOURCES SPECS SRPMS].each do |dir|
+      FileUtils.mkdir_p(File.join(topdir, dir))
+    end
+    
+    dep_list = deps.collect{|dep|dep[:name]}.join(",")
+    
+    spec = <<-EOS.gsub(/^\s+/, "")
+    Name: #{name}
+    Summary: stub pkg created by tpkg
+    Version: 1
+    Release: 1
+    buildarch: noarch
+    Requires: #{dep_list}
+    Group: Applications/System
+    License: MIT
+    BuildRoot: %{_builddir}/%{name}-buildroot
+    %description
+    stub pkg created by tpkg for the following dependencies: #{dep_list}
+    %files
+    EOS
+    spec_file = File.join(topdir, 'SPECS', 'pkg.spec')
+    File.open(spec_file, 'w') do |file|
+      file.puts(spec)
+    end
+    
+    system("#{@rpmbuildcmd} -bb --define '_topdir #{topdir}' #{spec_file}")
+    if !$?.success?
+      warn "Warning: Failed to create native stub package for #{name}" unless @quiet
+      return nil
+    end
+    result = File.join(topdir, 'RPMS', 'noarch', "#{name}-1-1.noarch.rpm")
+    if !File.exists?(result)
+      warn "Warning: rpmbuild failed to produce a native stub package for #{name}" unless @quiet
+      return nil
+    end
+    tmpfile = Tempfile.new(File.basename(result))
+    FileUtils.cp(result, tmpfile.path)
+    rpm = tmpfile.path
+    FileUtils.rm_rf(topdir)
+    
+    return rpm
+  end
+  
+end

data/lib/tpkg/os/solaris.rb

@@ -0,0 +1,101 @@
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+class Tpkg::OS::Solaris < Tpkg::OS
+  def self.supported?
+    Facter.loadfacts
+    Facter['operatingsystem'].value == 'Solaris'
+  end
+  register_implementation(self)
+  
+  def initialize(options={})
+    @pkginfocmd = options[:pkginfocmd] || options[:testcmd] || 'pkginfo'
+    @pkgutilcmd = options[:pkgutilcmd] || options[:testcmd] || '/opt/csw/bin/pkgutil'
+    super
+  end
+  
+  def init_links(installed_path, tpkgfile)
+    sys_v_init_links(installed_path, tpkgfile, ['2', '3'], '/etc')
+  end
+  def available_native_packages(pkgname)
+    native_packages = []
+    # Example of pkginfo -x output:
+    # SUNWzfsu                      ZFS (Usr)
+    #                               (i386) 11.10.0,REV=2006.05.18.01.46
+    cmd = "#{@pkginfocmd} -x #{pkgname}"
+    puts "available_native_packages running '#{cmd}'" if @debug
+    IO.popen(cmd) do |pipe|
+      name = nil
+      pipe.each_line do |line|
+        if line =~ /^\w/
+          name = line.split(' ').first
+        else
+          arch, solversion = line.split(' ')
+          # Lots of Sun and some third party packages (including CSW)
+          # seem to use this REV= convention in the version.  I've
+          # never seen it documented, but since it seems to be a
+          # widely used convention we'll go with it.
+          version, package_version = solversion.split(',REV=')
+          native_packages <<
+            Tpkg.pkg_for_native_package(
+              name, version, package_version, :native_installed)
+          name = nil
+        end
+      end
+    end
+    if !$?.success?
+      raise "available_native_packages error running pkginfo"
+    end
+    if File.exist?(@pkgutilcmd)
+      cmd = "#{@pkgutilcmd} -a --parse #{pkgname}"
+      puts "available_native_packages running '#{cmd}'" if @debug
+      IO.popen(cmd) do |pipe|
+        pipe.each_line do |line|
+          shortname, name, solversion, size = line.chomp.split("\t")
+          # pkgutil treats the specified name as a regular expression, so we
+          # have filter for the ones that are an exact match
+          next if name != pkgname
+          # Lots of Sun and some third party packages (including CSW)
+          # seem to use this REV= convention in the version.  I've
+          # never seen it documented, but since it seems to be a
+          # widely used convention we'll go with it.
+          version, package_version = solversion.split(',REV=')
+          native_packages <<
+            Tpkg.pkg_for_native_package(
+              name, version, package_version, :native_available)
+        end
+      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 << ",REV=#{package_version}"
+    end
+    pkgname
+  end
+  def install_native_package(pkg)
+    pkgname = native_pkg_to_install_string(pkg)
+    if File.exist?(@pkgutilcmd)
+      cmd = "#{@pkgutilcmd} -y -i #{pkgname}"
+      puts "Running '#{cmd}' to install native package" if @debug
+      system(cmd)
+    else
+      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?(@pkgutilcmd)
+      cmd = "#{@pkgutilcmd} -y -u #{pkgname}"
+      puts "Running '#{cmd}' to upgrade native package" if @debug
+      system(cmd)
+    else
+      raise "No supported native package tool available on #{os}"
+    end
+  end
+end

data/lib/tpkg/os/windows.rb

@@ -0,0 +1,26 @@
+# tpkg package management system
+# License: MIT (http://www.opensource.org/licenses/mit-license.php)
+
+class Tpkg::OS::Windows < Tpkg::OS
+  def self.supported?
+    Facter.loadfacts
+    Facter['operatingsystem'].value == 'windows'
+  end
+  register_implementation(self)
+  
+  def os_version
+    if !@os_version
+      # Extract 6.1 from 6.1.7601, for example
+      # That seems like the right level to split at
+      # based on http://en.wikipedia.org/wiki/Ver_(command)
+      winver = Facter['operatingsystemrelease'].value
+      @os_version = winver.split('.')[0,2].join('.')
+    end
+    super
+  end
+  
+  def sudo_default?
+    # Neither of the common Windows environments for running Ruby have sudo
+    return false
+  end
+end

data/lib/tpkg/thirdparty/kwalify-0.7.2/lib/kwalify.rb

@@ -0,0 +1,67 @@
+###
+### $Rev$
+### $Release: 0.7.2 $
+### copyright(c) 2006 kuwata-lab.com all rights reserved.
+###
+
+
+module Kwalify
+
+  RELEASE = ("$Release: 0.7.2 $" =~ /[.\d]+/) && $&
+
+end
+
+require 'kwalify/types'
+require 'kwalify/messages'
+require 'kwalify/errors'
+require 'kwalify/rule'
+require 'kwalify/validator'
+require 'kwalify/meta-validator'
+require 'kwalify/yaml-parser'
+#require 'kwalify/parser/base'
+#require 'kwalify/parser/yaml'
+
+
+module Kwalify
+
+  module Util
+
+    autoload :HashLike, 'kwalify/util/hashlike'
+
+  end
+
+  module Yaml
+
+    autoload :Parser, 'kwalify/parser/yaml'
+
+    ## read yaml_str, parse it, and return yaml document.
+    ##
+    ## opts:
+    ## ::validator:        Kwalify::Validator object
+    ## ::preceding_aliass: allow preceding alias if true
+    ## ::data_binding:     enable data binding if true
+    ## ::untabify:         expand tab chars if true
+    ## ::filename:         filename
+    def self.load(yaml_str, opts={})
+      #require 'kwalify/parser/yaml'
+      parser = Kwalify::Yaml::Parser.new(opts[:validator])
+      parser.preceding_alias = true if opts[:preceding_alias]
+      parser.data_binding    = true if opts[:data_binding]
+      yaml_str = Kwalify::Util.untabify(yaml_str) if opts[:untabify]
+      ydoc = parser.parse(yaml_str, :filename=>opts[:filename])
+      return ydoc
+    end
+
+    ## read file, parse it, and return yaml document.
+    ## see Kwalify::Yaml::Parser.load()
+    def self.load_file(filename, opts={})
+      opts[:filename] = filename
+      return self.load(File.read(filename), opts)
+    end
+
+  end
+
+  module Json
+  end
+
+end

data/lib/tpkg/thirdparty/kwalify-0.7.2/lib/kwalify/errors.rb

@@ -0,0 +1,127 @@
+###
+### $Rev$
+### $Release: 0.7.2 $
+### copyright(c) 2005-2010 kuwata-lab all rights reserved.
+###
+
+require 'kwalify/messages'
+
+module Kwalify
+
+  class KwalifyError < StandardError
+  end
+
+
+  class AssertionError < KwalifyError
+    def initialize(msg)
+      super("*** assertion error: " + msg)
+    end
+  end
+
+
+  class BaseError < KwalifyError
+    def initialize(message="", path=nil, value=nil, rule=nil, error_symbol=nil)
+      super(message)
+      @path  = path.is_a?(Array) ? '/'+path.join('/') : path
+      @rule  = rule
+      @value = value
+      @error_symbol = error_symbol
+    end
+    attr_accessor :error_symbol, :rule, :path, :value
+    attr_accessor :filename, :linenum, :column
+
+    def path
+      return @path == '' ? "/" : @path
+    end
+
+    alias _to_s to_s
+    alias message to_s
+
+    def to_s
+      s = ''
+      s << @filename << ":" if @filename
+      s << "#{@linenum}:#{@column} " if @linenum
+      s << "[#{path()}] " if @path
+      s << _to_s()
+      return s
+    end
+
+    def <=>(ex)
+      #return @linenum <=> ex.linenum
+      v = 0
+      v = @linenum <=> ex.linenum if @linenum && ex.linenum
+      v = @column  <=> ex.column  if v == 0 && @column && ex.column
+      v = @path    <=> ex.path    if v == 0
+      return v
+    end
+  end
+
+
+  class SchemaError < BaseError
+    def initialize(message="", path=nil, rule=nil, value=nil, error_symbol=nil)
+      super(message, path, rule, value, error_symbol)
+    end
+  end
+
+
+  class ValidationError < BaseError
+    def initialize(message="", path=nil, rule=nil, value=nil, error_symbol=nil)
+      super(message, path, rule, value, error_symbol)
+    end
+  end
+
+
+  ## syntax error for YAML and JSON
+  class SyntaxError < BaseError  #KwalifyError
+    def initialize(msg, linenum=nil, error_symbol=nil)
+      super(linenum ? "line #{linenum}: #{msg}" : msg)
+      @linenum = linenum
+      @error_symbol = error_symbol
+    end
+    #attr_accessor :linenum, :error_symbol
+    def message
+      "file: #{@filename}, line #{@linenum}: #{super}"
+    end
+  end
+
+
+  ## (obsolete) use Kwalify::SyntaxError instead
+  class YamlSyntaxError < SyntaxError
+  end
+
+
+  module ErrorHelper
+
+    #module_function
+
+    def assert_error(message="")
+      raise AssertionError.new(message)
+    end
+
+    def validate_error(error_symbol, rule, path, val, args=nil)
+      msg = _build_message(error_symbol, val, args);
+      path = '/'+path.join('/') if path.is_a?(Array)
+      return ValidationError.new(msg, path, val, rule, error_symbol)
+    end
+    module_function :validate_error
+
+    def schema_error(error_symbol, rule, path, val, args=nil)
+      msg = _build_message(error_symbol, val, args);
+      path = '/'+path.join('/') if path.is_a?(Array)
+      return SchemaError.new(msg, path, val, rule, error_symbol)
+    end
+
+    def _build_message(message_key, val, args)
+      msg = Kwalify.msg(message_key)
+      assert_error("message_key=#{message_key.inspect}") unless msg
+      msg = msg % args if args
+      msg = "'#{val.to_s.gsub(/\n/, '\n')}': #{msg}" if !val.nil? && Types.scalar?(val)
+      return msg;
+    end
+    module_function :_build_message
+
+  end
+
+  extend ErrorHelper
+
+end