tpkg 1.16.2 → 1.18.2

data/Rakefile

@@ -4,7 +4,7 @@ spec = Gem::Specification.new do |s|
   s.summary	= 'tpkg Application Packaging & Deployment'
   s.add_dependency('facter')
   s.add_dependency('net-ssh')
-  s.version = '1.16.2'
+  s.version = '1.18.2'
   s.authors = ['Darren Dao', 'Jason Heiss']
   s.email = 'tpkg-users@lists.sourceforge.net'
   s.homepage = 'http://tpkg.sourceforge.net'
@@ -12,7 +12,7 @@ spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>=1.8'
   s.files	= Dir['**/**']
-  s.executables = [ 'tpkg', 'cpan2tpkg', 'gem2tpkg' ]
+  s.executables = [ 'tpkg', 'cpan2tpkg', 'gem2tpkg', 'tpkg_xml_to_yml' ]
 end
 Rake::GemPackageTask.new(spec).define
 

data/bin/cpan2tpkg

@@ -36,7 +36,6 @@ All options can be shortened to anything that's unique.
 EOF
 }
 
-# FIXME: we're not actually using $modver, we're just letting CPAN installed the latest available version
 my $modver;
 my $pkgver = 1;
 my %extradeps = ();
@@ -58,6 +57,13 @@ usage() if (!$getopt);
 usage() if ($help);
 usage() if (!$module);
 
+# FIXME: we're not actually using $modver, we're just letting CPAN install
+# the latest available version
+if ($modver)
+{
+	die "--version not implemented\n";
+}
+
 my @extradepsopts = split(/,/, $extradepsopts);
 while (scalar @extradepsopts)
 {
@@ -161,16 +167,51 @@ print "Installed modules to be packaged (except Perl):\n";
 print join(', ', $extinst->modules), "\n";
 
 # Inspect temp directory and package each installed module
-foreach my $name ($extinst->modules)
+MODULE: foreach my $name ($extinst->modules)
 {
-	next if ($name eq 'Perl');
+	next MODULE if ($name eq 'Perl');
 	print "Packaging $name\n";
-	my $dashname = $name;
-	$dashname =~ s/::/-/g;
-	my $ver = $extinst->version($name);
-	print "Module version is $ver\n";
 	my %deps = ();
 	my $mod = CPAN::Shell->expand('Module', $name);
+	# Sometimes calling expand on a result from EU::I->modules doesn't
+	# work.  For example, if the user requests Date::Parse that module
+	# is part of the TimeDate distribution.  EU::I->modules will return
+	# ['Perl', 'TimeDate'], but calling expand on TimeDate fails.  It
+	# seems like we should find an alternative to EU::I->modules,
+	# something that returns the distributions installed rather than the
+	# modules.
+	if (!$mod)
+	{
+		# If EU::I->modules only returned two results we can safely
+		# assume the !Perl one is whatever the user asked to have
+		# installed and use its expansion instead.  Continue the example
+		# mentioned above, calling expand on TimeDate fails but calling
+		# expand on Date::Parse works, for whatever reason.
+		if (scalar($extinst->modules) == 2)
+		{
+			# We've already called expand on the user's request, so we
+			# can reuse that result.
+			$mod = $modobj;
+			warn "Failed to expand $name the usual way, secondary efforts ",
+				"successful\n";
+		}
+		else
+		{
+			warn "Failed to expand $name, secondary efforts failed, skipping\n";
+			next MODULE;
+		}
+	}
+	# Note that this won't work if we ever implement letting the user
+	# select a specific version (via the --version CLI option), as
+	# expand presumably returns the info for the latest available
+	# version of the distribution.  Note that EU::I->version returns the
+	# version of the module, not the version of the distribution, and
+	# those can differ.  We're packaging the distribution, which may
+	# include multiple modules with their own, differing versions.
+	my $ver = module_to_dist_ver($mod);
+	print "Module version is $ver\n";
+	my $pkgname = module_to_pkg_name($mod);
+	print "Package name, based on distribution, is $pkgname\n";
 	# Looks like newer versions of CPAN.pm have a CPAN::Module::distribution()
 	# method.  What I'm using here is a little hacky but works, so I
 	# don't think it is worth forcing users to use a newer version.
@@ -199,7 +240,7 @@ foreach my $name ($extinst->modules)
 				%prereqs = ();
 			}
 		}
-		foreach my $dep (keys %prereqs)
+		PREREQ: foreach my $dep (keys %prereqs)
 		{
 			# Skip dependencies on core modules
 			my $depmod = CPAN::Shell->expand('Module', $dep);
@@ -213,15 +254,14 @@ foreach my $name ($extinst->modules)
 			if ($depmod->inst_file =~ m,/home/t/perl,)
 			{
 				print "Prereq $dep is a core module, skipping\n";
-				next;
+				next PREREQ;
 			}
 			
-			my $dashdep = $dep;
-			$dashdep =~ s/::/-/g;
-			$deps{$dashdep} = {};
+			my $deppkgname = module_to_pkg_name($depmod);
+			$deps{$deppkgname} = {};
 			if ($prereqs{$dep} ne '0')
 			{
-				$deps{$dashdep}{minimum_version} = $prereqs{$dep};
+				$deps{$deppkgname}{minimum_version} = $prereqs{$dep};
 			}
 		}
 	}
@@ -248,7 +288,7 @@ foreach my $name ($extinst->modules)
 	print $xmlfh '<?xml version="1.0" encoding="UTF-8"?>', "\n";
 	print $xmlfh '<!DOCTYPE tpkg SYSTEM "http://tpkg.sourceforge.net/tpkg-1.0.dtd">', "\n";
 	print $xmlfh '<tpkg>', "\n";
-	print $xmlfh "  <name>cpan-perl$majorminor-$dashname</name>", "\n";
+	print $xmlfh "  <name>cpan-perl$majorminor-$pkgname</name>", "\n";
 	print $xmlfh "  <version>$ver</version>", "\n";
 	print $xmlfh "  <package_version>$pkgver</package_version>", "\n";
 	print $xmlfh '  <maintainer>cpan2tpkg</maintainer>', "\n";
@@ -346,3 +386,31 @@ foreach my $name ($extinst->modules)
 	system("tpkg --make $tpkgdir");
 }
 
+# Pass in an expanded module (CPAN::Shell->expand), get back a name
+# suitable for use in packaging.
+# The package name is based on the distribution that contains the
+# module, as sometimes multiple modules are packaged into a single
+# distribution file.
+sub module_to_pkg_name
+{
+	my $mod = shift;
+	my $distfilename = basename($mod->{RO}{CPAN_FILE});
+	my $pkgname = $distfilename;
+	# Cut off the version and suffix
+	# I.e. TimeDate-1.20.tar.gz -> TimeDate
+	$pkgname =~ s/-\d.*//;
+	return $pkgname;
+}
+# Pass in an expanded module (CPAN::Shell->expand), get back the version
+# of the associated distribution.
+sub module_to_dist_ver
+{
+	my $mod = shift;
+	my $distfilename = basename($mod->{RO}{CPAN_FILE});
+	# Cut off the distribution name and suffix
+	# I.e. TimeDate-1.20.tar.gz -> 1.20
+	$distfilename =~ /-(\d.*?)\.\D/;
+	my $distver = $1;
+	return $distver;
+}
+

data/bin/tpkg

@@ -29,6 +29,7 @@ require 'tpkg'
 @worker_count = 10
 @rerun_with_sudo = false
 @tpkg_options = {}
+@init_options = {}           
 
 def rerun_with_sudo_if_necessary
   if Process.euid != 0 && @sudo
@@ -97,39 +98,60 @@ opts.on('--verify', '-V', '=NAME', 'Verify packages') do |opt|
 end
 opts.on('--start', '=NAME', 'Start the init script for the specified package', Array) do |opt|
   @rerun_with_sudo = true
-  @action = :start_init
-  @action_value = opt
+  @action = :execute_init
+  @init_options[:packages] = opt
+  @init_options[:cmd] = 'start'
 end
 opts.on('--stop', '=NAME', 'Stop the init script for the specified package', Array) do |opt|
   @rerun_with_sudo = true
-  @action = :stop_init
-  @action_value = opt
+  @action = :execute_init
+  @init_options[:packages] = opt
+  @init_options[:cmd] = 'stop'
 end
 opts.on('--restart', '=NAME', 'Restart the init script for the specified package', Array) do |opt|
   @rerun_with_sudo = true
-  @action = :restart_init
-  @action_value = opt
+  @action = :execute_init
+  @init_options[:packages] = opt
+  @init_options[:cmd] = 'restart'
 end
 opts.on('--reload', '=NAME', 'Reload the init script for the specified package', Array) do |opt|
   @rerun_with_sudo = true
-  @action = :reload_init
-  @action_value = opt
+  @action = :execute_init
+  @init_options[:packages] = opt
+  @init_options[:cmd] = 'reload'
 end
 opts.on('--start-all', 'Start the init scripts for all packages') do |opt|
   @rerun_with_sudo = true
-  @action = :start_init
+  @action = :execute_init
+  @init_options[:cmd] = 'start'
 end
 opts.on('--stop-all', 'Stop the init script for all packages') do |opt|
   @rerun_with_sudo = true
-  @action = :stop_init
+  @action = :execute_init
+  @init_options[:cmd] = 'stop'
 end
 opts.on('--restart-all', 'Restart the init script for all packages') do |opt|
   @rerun_with_sudo = true
-  @action = :restart_init
+  @action = :execute_init
+  @init_options[:cmd] = 'restart'
 end
 opts.on('--reload-all', 'Reload the init script for all packages') do |opt|
   @rerun_with_sudo = true
-  @action = :reload_init
+  @action = :execute_init
+  @init_options[:cmd] = 'reload'
+end
+opts.on('--exec-init', '=NAME', 'Execute init scripts for the specified packages', Array) do |opt|
+  @rerun_with_sudo = true
+  @init_options[:packages] = opt
+  @action = :execute_init
+end
+opts.on('--init-script', '=NAME', 'What init scripts to execute', Array) do |opt|
+  @rerun_with_sudo = true
+  @init_options[:scripts] = opt
+end
+opts.on('--init-cmd', '=CMD', 'Invoke the specified init script command') do |opt|
+  @rerun_with_sudo = true
+  @init_options[:cmd] = opt
 end
 opts.on('--query', '-q', '=NAMES', 'List installed packages', Array) do |opt|
   # People mistype -qa instead of --qa frequently
@@ -178,8 +200,8 @@ opts.on('--dw', '=INTEGER', 'Number of workers for deploying') do |opt|
   @worker_count = opt.to_i
   @deploy_params = @deploy_params - ['--dw', @worker_count, "--dw=#{opt}"]
 end
-opts.on('--qX', '=FILENAME', 'Display tpkg.xml of the given package') do |opt|
-  @action = :query_tpkgxml
+opts.on('--qX', '=FILENAME', 'Display tpkg.xml or tpkg.yml of the given package') do |opt|
+  @action = :query_tpkg_metadata
   @action_value = opt
 end
 opts.on('--qenv', "Display machine's information") do |opt|
@@ -360,18 +382,12 @@ when :verify
     end 
     puts "Package verification failed" unless success 
   end
-when :start_init
-  tpkg = instantiate_tpkg(@tpkg_options)
-  ret_val = tpkg.execute_init(@action_value, "start")
-when :stop_init
-  tpkg = instantiate_tpkg(@tpkg_options)
-  ret_val = tpkg.execute_init(@action_value, "stop")
-when :restart_init
+when :execute_init
   tpkg = instantiate_tpkg(@tpkg_options)
-  ret_val = tpkg.execute_init(@action_value, "restart")
-when :reload_init
-  tpkg = instantiate_tpkg(@tpkg_options)
-  ret_val = tpkg.execute_init(@action_value, "reload")
+  if @init_options[:cmd].nil?
+    raise "You didn't specify what init command to run"
+  end
+  ret_val = tpkg.execute_init(@init_options)
 when :query_installed
   tpkg = instantiate_tpkg(@tpkg_options)
   req = nil
@@ -418,6 +434,8 @@ when :query_info
     next if already_displayed[metadata[:filename]]
     already_displayed[metadata[:filename]] = true
     [:name, :version, :package_version, :operatingsystem, :architecture, :maintainer, :description, :bugreporting].each do |field|
+      metadata[field] = 'any' if field == :operatingsystem && metadata[field].nil?
+      metadata[field] = 'any' if field == :architecture && metadata[field].nil?
       if metadata[field]
         if metadata[field].kind_of?(Array)
           puts "#{field}: #{metadata[field].join(',')}"
@@ -426,6 +444,10 @@ when :query_info
         end
       end
     end
+    if metadata[:dependencies] 
+      puts "This package depends on other packages, use --qd/--qld to view the dependencies."
+    end
+    puts "================================================================================"
   end
 when :query_list_files
   tpkg = instantiate_tpkg(@tpkg_options)
@@ -498,6 +520,7 @@ when :query_requires
       next if pkg[:source] != :currently_installed
       puts "The following package(s) require #{pkg[:metadata][:filename]}:"
       dependencies.each do | requiree, deps |
+        next if deps.nil?
         deps.each do | dep | 
           if Tpkg::package_meets_requirement?(pkg, dep)
             puts "  #{requiree}"
@@ -546,12 +569,14 @@ when :query_depends
       end
     end
   end
-when :query_tpkgxml
+when :query_tpkg_metadata
   tpkg = instantiate_tpkg(@tpkg_options)
-  if !File.exist?(@action_value)
-    puts "File #{@action_value} doesn't exist."
+  if File.exist?(@action_value)
+    puts Tpkg::extract_tpkg_metadata_file(@action_value)
+  elsif File.exists?(File.join(tpkg.installed_directory, @action_value))
+    puts Tpkg::extract_tpkg_metadata_file(File.join(tpkg.installed_directory, @action_value))
   else
-    puts Tpkg::extract_tpkgxml(@action_value)
+    puts "File #{@action_value} doesn't exist."
   end
 when :query_env
   puts "Operating System: #{Tpkg::get_os}"

data/bin/tpkg_xml_to_yml

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby -w
+
+# This script expects one argument, which is the tpkg.xml file
+# that you want to convert to yml format.
+# The resulting data is output to stdout
+require 'tpkg'
+
+if ARGV.size < 1
+  raise "You didn't specify a file"
+end
+
+xmlfile =  ARGV[0]
+if !File.exist?(xmlfile)
+  raise "File doesn't exist"
+end
+
+metadata_text = File.read(xmlfile)
+metadata = Metadata.new(metadata_text, 'xml')
+metadata.write($stdout)

data/lib/tpkg.rb

@@ -1,6 +1,6 @@
 ##############################################################################
 # tpkg package management system library
-# Copyright 2009, AT&T Interactive
+# Copyright 2009, 2010 AT&T Interactive
 # License: MIT (http://www.opensource.org/licenses/mit-license.php)
 ##############################################################################
 
@@ -48,7 +48,7 @@ require 'metadata'
 
 class Tpkg
   
-  VERSION = '1.16.2'
+  VERSION = '1.18.2'
   CONFIGDIR = '/etc'
   
   POSTINSTALL_ERR = 2
@@ -241,8 +241,8 @@ class Tpkg
       # by the package. For example, checksum, path, relocatable or not, etc.
       File.open(File.join(tpkgdir, "file_metadata.bin"), "w") do |file|
         filemetadata = get_filemetadata_from_directory(tpkgdir)
-        Marshal::dump(filemetadata.hash, file)
-#        YAML::dump(filemetadata.hash, file)  
+        Marshal::dump(filemetadata.to_hash, file)
+#        YAML::dump(filemetadata.to_hash, file)  
       end
 
       # Check all the files are there as specified in the metadata config file
@@ -510,7 +510,8 @@ class Tpkg
       tpkg_xml = REXML::Document.new(pipe.read)
     end
     if !$?.success?
-      raise "Extracting tpkg.xml from #{package_file} failed"
+      warn "Warning: Extracting tpkg.xml from #{package_file} failed"
+      return nil
     end
 
     # Insert an attribute on the root element with the package filename
@@ -543,7 +544,7 @@ class Tpkg
         metadata << existing_metadata[File.basename(pkg)]
       else
         xml = xml_metadata_from_package(pkg)
-        metadata << xml.root
+        metadata << xml.root if xml
       end
     end
 
@@ -560,8 +561,13 @@ class Tpkg
     existing_metadata = {}
 
     if File.exists?(existing_metadata_file)
-      metadata_contents = File.read(File.join(directory, 'metadata.yml'))
-      Metadata::get_pkgs_metadata_from_yml_doc(metadata_contents, existing_metadata)
+      metadata_lists = File.read(File.join(directory, 'metadata.yml')).split("---")
+      metadata_lists.each do | metadata_text |
+        if metadata_text =~ /^:?filename:(.+)/
+           filename = $1.strip
+           existing_metadata[filename] = Metadata.new(metadata_text,'yml')
+        end
+      end
     end
 
     # Populate the metadata array with metadata for all of the packages
@@ -577,7 +583,7 @@ class Tpkg
 
     return metadata
   end
-  
+
   # Extracts the metadata from a directory of package files and saves it
   # to metadata.xml in that directory
   def self.extract_metadata(directory, dest=nil)
@@ -605,7 +611,7 @@ class Tpkg
     # And write that out to metadata.yml
     metadata_tmpfile = Tempfile.new('metadata.yml', dest)
     metadata.each do | metadata |
-      YAML::dump(metadata.hash, metadata_tmpfile)  
+      YAML::dump(metadata.to_hash, metadata_tmpfile)  
     end
     metadata_tmpfile.close
     File.chmod(0644, metadata_tmpfile.path)
@@ -698,7 +704,9 @@ class Tpkg
       # A req for a native package must be satisfied by a native package
       puts "Package fails native requirement" if @@debug
       result = false
-    elsif (!req[:type] || req[:type] == :tpkg) &&
+    elsif req[:filename]
+      result = false if req[:filename] != metadata[:filename]
+    elsif req[:type] == :tpkg &&
           (pkg[:source] == :native_installed || pkg[:source] == :native_available)
       # Likewise a req for a tpkg must be satisfied by a tpkg
       puts "Package fails non-native requirement" if @@debug
@@ -771,6 +779,9 @@ class Tpkg
       puts "Package fails name" if @@debug
       result = false
     end
+    if result
+      puts "Package matches" if @@debug
+    end
     result
   end
   
@@ -963,18 +974,11 @@ class Tpkg
     req = {}
     parts = request.split('=')
 
-    # upgrade/remove/query options should take package filenames
-    # First, look inside installed dir to see if we can find the request package. This is to support
-    # request that uses package filename rather than package name
-    if installed_dir && File.exists?(File.join(installed_dir, request))
-      metadata = Tpkg::metadata_from_package(File.join(installed_dir, request))
-      req[:name] = metadata[:name]
-      req[:minimum_version] = metadata[:version].to_s
-      req[:maximum_version] = metadata[:version].to_s
-      if metadata[:package_version] && !metadata[:package_version].to_s.empty? 
-        req[:minimum_package_version] = metadata[:package_version].to_s
-        req[:maximum_package_version] = metadata[:package_version].to_s
-      end
+    # upgrade/remove/query options could take package filenames
+    # assuming that the filename is of the correct format, such as
+    # foo-1.0.tpkg or foo-1.0-1.tpkg
+    if request =~ /\.tpkg$/
+      req = {:filename => request, :name => request.split("-")[0]}
     elsif parts.length > 2 && parts[-2] =~ /^[\d\.]/ && parts[-1] =~ /^[\d\.]/
       package_version = parts.pop
       version = parts.pop
@@ -991,6 +995,7 @@ class Tpkg
     else
       req[:name] = parts.join('-')
     end
+    req[:type] = :tpkg
     req
   end
 
@@ -1032,21 +1037,22 @@ class Tpkg
     end
   end
 
-  def self.extract_tpkgxml(package_file)
+  def self.extract_tpkg_metadata_file(package_file)
     result = ""
     workdir = ""
     begin
       topleveldir = Tpkg::package_toplevel_directory(package_file)
       workdir = Tpkg::tempdir(topleveldir)
       system("#{find_tar} -xf #{package_file} -O #{File.join(topleveldir, 'tpkg.tar')} | #{find_tar} -C #{workdir} -xpf -")
-
-      if !File.exist?(File.join(workdir,"tpkg", "tpkg.xml"))
-        raise "#{package_file} does not contain tpkg.xml"
+     
+      if File.exist?(File.join(workdir,"tpkg", "tpkg.yml"))
+        metadata_file = File.join(workdir,"tpkg", "tpkg.yml")
+      elsif File.exist?(File.join(workdir,"tpkg", "tpkg.xml"))
+        metadata_file = File.join(workdir,"tpkg", "tpkg.xml")
       else
-        File.open(File.join(workdir,"tpkg", "tpkg.xml"), "r") do | f |
-          result = f.read
-        end
+        raise "#{package_file} does not contain metadata configuration file."
       end
+      result = File.read(metadata_file)
     rescue
       puts "Failed to extract package."
     ensure
@@ -1275,13 +1281,12 @@ class Tpkg
       if @@debug
         @sources.each do |source|
           count = metadata.inject(0) do |memo,m|
-                    # metadata is a hash of pkgname => array of metadata
-                    # hashes
+                    # metadata is a hash of pkgname => array of Metadata
+                    # objects.
                     # Thus m is a 2 element array of [pkgname, array of
-                    # metadata hashes]  And thus m[1] is the array of
-                    # metadata hashes.  And metadata hashes are themselves
-                    # a hash of XML metadata and source.
-                    memo + m[1].select{|mh| mh[:source] == source}.length
+                    # Metadata objects]  And thus m[1] is the array of
+                    # Metadata objects.
+                    memo + m[1].select{|mo| mo.source == source}.length
                   end
           puts "Found #{count} packages from #{source}"
         end
@@ -1346,34 +1351,35 @@ class Tpkg
           {:arg => 'available', :header => 'Available', :source => :native_available} ].each do |yum|
           puts "available_native_packages running 'yum list #{yum[:arg]} #{pkgname}'" if @@debug
           stderr_first_line = nil
-          Open3.popen3("yum list #{yum[:arg]} #{pkgname}") do |stdin, stdout, stderr|
+          Open3.popen3("yum info #{yum[:arg]} #{pkgname}") 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
-                name_and_arch, ver_and_release, repo = line.split
+                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 = 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.
-                name, arch = name_and_arch.split('.')
-                # This is prone to error, as both the version and release
-                # (what we call package version) could contain '-', so
-                # there's no reliable way to parse the combined value.
-                # RPM can show them separately, but seemingly not yum.
-                # We could use rpm to list installed packages, but we
-                # have to use yum to get available packages so we're
-                # stuck with the problem.
-                verparts = ver_and_release.split('-')
-                package_version = verparts.pop
-                version = verparts.join('-')
-                # Create the pkg structure
-                pkg = pkg_for_native_package(name, version, package_version, yum[:source])
-                native_packages << pkg
               end
             end
             stderr_first_line = stderr.gets
@@ -1629,7 +1635,7 @@ class Tpkg
             begin
               FileUtils.mkdir_p(package_metadata_dir)
               File.open(metadata_file, "w") do |file|
-                YAML::dump(m.hash, file)
+                YAML::dump(m.to_hash, file)
               end
             rescue Errno::EACCES
               raise if Process.euid == 0
@@ -1778,18 +1784,21 @@ class Tpkg
     files
   end
   
-  # Returns the best solution that meets the given requirements.  Some
-  # or all packages may be optionally pre-selected and specified via the
-  # packages parameter, otherwise packages are picked from the set of
-  # available packages.  The packages parameter is in the form of a hash
-  # with package names as keys pointing to arrays of package specs (our
-  # standard hash of package metadata and source).  The return value
+  # Returns the best solution that meets the given requirements.  Some or all
+  # packages may be optionally pre-selected and specified via the packages
+  # parameter, otherwise packages are picked from the set of available
+  # packages.  The requirements parameter is an array of package requirements.
+  # The packages parameter is in the form of a hash with package names as keys
+  # pointing to arrays of package specs (our standard hash of package metadata
+  # and source).  The core_packages parameter is an array of the names of
+  # packages that should be considered core requirements, i.e. the user
+  # specifically requested they be installed or upgraded. The return value
   # will be an array of package specs.
   MAX_POSSIBLE_SOLUTIONS_TO_CHECK = 10000
   def best_solution(requirements, packages, core_packages)
     # Dup objects passed to us so that resolve_dependencies is free to
     # change them without potentially messing up our caller
-    result = resolve_dependencies(requirements.dup, packages.dup, core_packages.dup)
+    result = resolve_dependencies(requirements.dup, {:tpkg => packages.dup, :native => {}}, core_packages.dup)
     if @@debug
       if result[:solution]
         puts "bestsol picks: #{result[:solution].inspect}" if @@debug
@@ -1801,21 +1810,30 @@ class Tpkg
   end
   
   # Recursive method used by best_solution
+  # Parameters mostly map from best_solution, but packages turns into a hash
+  # with two possible keys, :tpkg and :native.  The value for the :tpkg key
+  # would be the packages parameter from best_solution.  Native packages are
+  # only installed due to dependencies, we don't let the user request them
+  # directly, so callers of best_solution never need to pass in a package list
+  # for native packages.  Separating the two sets of packages allows us to
+  # calculate a solution that contains both a tpkg and a native package with
+  # the same name.  This may be necessary if different dependencies of the
+  # core packages end up needing both.
   def resolve_dependencies(requirements, packages, core_packages, number_of_possible_solutions_checked=0)
     # Make sure we have populated package lists for all requirements.
     # Filter the package lists against the requirements and
     # ensure we can at least satisfy the initial requirements.
     requirements.each do |req|
-      if !packages[req[:name]]
+      if !packages[req[:type]][req[:name]]
         puts "resolvedeps initializing packages for #{req.inspect}" if @@debug
-        packages[req[:name]] =
+        packages[req[:type]][req[:name]] =
           available_packages_that_meet_requirement(req)
       else
         # Loop over packages and eliminate ones that don't work for
         # this requirement
         puts "resolvedeps filtering packages for #{req.inspect}" if @@debug
-        packages[req[:name]] =
-          packages[req[:name]].select do |pkg|
+        packages[req[:type]][req[:name]] =
+          packages[req[:type]][req[:name]].select do |pkg|
             # When this method is called recursively there might be a
             # nil entry inserted into packages by the sorting code
             # below.  We need to skip those.
@@ -1824,7 +1842,7 @@ class Tpkg
             end
           end
       end
-      if packages[req[:name]].empty?
+      if packages[req[:type]][req[:name]].empty?
         if @@debug
           puts "No packages matching #{req.inspect}"
         end
@@ -1832,15 +1850,17 @@ class Tpkg
       end
     end
     # Sort the packages
-    packages.each do |pkgname, pkgs|
-      pkgs.sort!(&SORT_PACKAGES)
-      # Only currently installed packages are allowed to score 0.
-      # Anything else can score 1 at best.  This ensures
-      # that we prefer the solution which leaves the most
-      # currently installed packages alone.
-      if pkgs[0][:source] != :currently_installed &&
-         pkgs[0][:source] != :native_installed
-        pkgs.unshift(nil)
+    [:tpkg, :native].each do |type|
+      packages[type].each do |pkgname, pkgs|
+        pkgs.sort!(&SORT_PACKAGES)
+        # Only currently installed packages are allowed to score 0.
+        # Anything else can score 1 at best.  This ensures
+        # that we prefer the solution which leaves the most
+        # currently installed packages alone.
+        if pkgs[0][:source] != :currently_installed &&
+           pkgs[0][:source] != :native_installed
+          pkgs.unshift(nil)
+        end
       end
     end
     
@@ -1885,13 +1905,16 @@ class Tpkg
     # [a2, b2, c2]                (avg 2)
     
     # Divide packages into core and non-core packages
-    corepkgs = packages.reject{|pkgname, pkgs| !core_packages.include?(pkgname)}
-    noncorepkgs = packages.reject{|pkgname, pkgs| core_packages.include?(pkgname)}
+    corepkgs = packages[:tpkg].reject{|pkgname, pkgs| !core_packages.include?(pkgname)}
+    noncorepkgs = {}
+    noncorepkgs[:tpkg] = packages[:tpkg].reject{|pkgname, pkgs| core_packages.include?(pkgname)}
+    noncorepkgs[:native] = packages[:native]
     
     # Calculate total package depth, the sum of the lengths (or rather
     # the max array index) of each array of packages.
     coretotaldepth = corepkgs.inject(0) {|memo, pkgs| memo + pkgs[1].length - 1}
-    noncoretotaldepth = noncorepkgs.inject(0) {|memo, pkgs| memo + pkgs[1].length - 1}
+    noncoretotaldepth = noncorepkgs[:tpkg].inject(0) {|memo, pkgs| memo + pkgs[1].length - 1} +
+                        noncorepkgs[:native].inject(0) {|memo, pkgs| memo + pkgs[1].length - 1}
     if @@debug
       puts "resolvedeps coretotaldepth #{coretotaldepth}"
       puts "resolvedeps noncoretotaldepth #{noncoretotaldepth}"
@@ -1935,7 +1958,7 @@ class Tpkg
                 # {:pkgs=>{a1,b0}, :remaining_coredepth=0}
                 if coresol[:remaining_coredepth] == 0
                   # Second pass, add combinations of non-core packages
-                  if noncorepkgs.empty?
+                  if noncorepkgs[:tpkg].empty? && noncorepkgs[:native].empty?
                     puts "resolvedeps noncorepkgs empty, checking solution" if @@debug
                     result = check_solution(coresol, requirements, packages, core_packages, number_of_possible_solutions_checked)
                     if result[:solution]
@@ -1948,45 +1971,47 @@ class Tpkg
                       puts "resolvedeps noncoredepth: #{noncoredepth}" if @@debug
                       coresol[:remaining_noncoredepth] = noncoredepth
                       solutions = [coresol]
-                      noncorepkgs.each do |ncpkgname, ncpkgs|
-                        puts "resolvedeps noncorepkg #{ncpkgname}: #{ncpkgs.inspect}" if @@debug
-                        new_solutions = []
-                        solutions.each do |solution|
-                          remaining_noncoredepth = solution[:remaining_noncoredepth]
-                          puts "resolvedeps :remaining_noncoredepth: #{remaining_noncoredepth}" if @@debug
-                          (0..[remaining_noncoredepth, ncpkgs.length-1].min).each do |ncpkgdepth|
-                            puts "resolvedeps ncpkgdepth: #{ncpkgdepth}" if @@debug
-                            # We insert a nil entry in some situations (see the sort
-                            # step earlier), so skip nil entries in the pkgs array.
-                            if ncpkgs[ncpkgdepth] != nil
-                              sol = solution.dup
-                              # Hash#dup doesn't dup each key/value, so we need to
-                              # explicitly dup :pkgs so that each copy has an
-                              # independent array that we can modify.
-                              sol[:pkgs] = solution[:pkgs].dup
-                              sol[:remaining_noncoredepth] -= ncpkgdepth
-                              sol[:pkgs] << ncpkgs[ncpkgdepth]
-                              new_solutions << sol
-                              # If this is a complete combination of packages then
-                              # proceed to the next step
-                              puts "resolvedeps sol[:pkgs] #{sol[:pkgs].inspect}" if @@debug
-                              if sol[:pkgs].length == packages.length
-                                puts "resolvedeps complete pkg set: #{sol.inspect}" if @@debug
-                                # Solutions with remaining depth are duplicates of
-                                # solutions we already checked at lower depth levels
-                                if sol[:remaining_noncoredepth] == 0
-                                  result = check_solution(sol, requirements, packages, core_packages, number_of_possible_solutions_checked)
-                                  if result[:solution]
-                                    return result
-                                  else
-                                    number_of_possible_solutions_checked = result[:number_of_possible_solutions_checked]
+                      [:tpkg, :native].each do |nctype|
+                        noncorepkgs[nctype].each do |ncpkgname, ncpkgs|
+                          puts "resolvedeps noncorepkg #{nctype} #{ncpkgname}: #{ncpkgs.inspect}" if @@debug
+                          new_solutions = []
+                          solutions.each do |solution|
+                            remaining_noncoredepth = solution[:remaining_noncoredepth]
+                            puts "resolvedeps :remaining_noncoredepth: #{remaining_noncoredepth}" if @@debug
+                            (0..[remaining_noncoredepth, ncpkgs.length-1].min).each do |ncpkgdepth|
+                              puts "resolvedeps ncpkgdepth: #{ncpkgdepth}" if @@debug
+                              # We insert a nil entry in some situations (see the sort
+                              # step earlier), so skip nil entries in the pkgs array.
+                              if ncpkgs[ncpkgdepth] != nil
+                                sol = solution.dup
+                                # Hash#dup doesn't dup each key/value, so we need to
+                                # explicitly dup :pkgs so that each copy has an
+                                # independent array that we can modify.
+                                sol[:pkgs] = solution[:pkgs].dup
+                                sol[:remaining_noncoredepth] -= ncpkgdepth
+                                sol[:pkgs] << ncpkgs[ncpkgdepth]
+                                new_solutions << sol
+                                # If this is a complete combination of packages then
+                                # proceed to the next step
+                                puts "resolvedeps sol[:pkgs] #{sol[:pkgs].inspect}" if @@debug
+                                if sol[:pkgs].length == packages[:tpkg].length + packages[:native].length
+                                  puts "resolvedeps complete pkg set: #{sol.inspect}" if @@debug
+                                  # Solutions with remaining depth are duplicates of
+                                  # solutions we already checked at lower depth levels
+                                  if sol[:remaining_noncoredepth] == 0
+                                    result = check_solution(sol, requirements, packages, core_packages, number_of_possible_solutions_checked)
+                                    if result[:solution]
+                                      return result
+                                    else
+                                      number_of_possible_solutions_checked = result[:number_of_possible_solutions_checked]
+                                    end
                                   end
                                 end
                               end
                             end
                           end
+                          solutions = new_solutions
                         end
-                        solutions = new_solutions
                       end
                     end
                   end
@@ -2036,7 +2061,7 @@ class Tpkg
       newreqs_that_need_packages = []
       newreqs.each do |newreq|
         puts "checksol checking newreq: #{newreq.inspect}" if @@debug
-        if packages[newreq[:name]]
+        if packages[newreq[:type]][newreq[:name]]
           pkg = solution[:pkgs].find{|solpkg| solpkg[:metadata][:name] == newreq[:name]}
           puts "checksol newreq pkg: #{pkg.inspect}" if @@debug
           if Tpkg::package_meets_requirement?(pkg, newreq)
@@ -2171,7 +2196,13 @@ class Tpkg
               Tpkg::get_os =~ /Solaris/
           init_directory = File.join(@file_system_root, 'etc')
         end
-        levels.to_s.each do |level|
+      
+        # in case user specify levels in yaml as string/integer instead of array
+        if !levels.kind_of?(Array)
+          levels = levels.to_s.split(//)  
+        end
+    
+        levels.each do |level|
           links[File.join(init_directory, "rc#{level}.d", 'S' + start.to_s + File.basename(installed_path))] = installed_path
         end
       elsif Tpkg::get_os =~ /FreeBSD/
@@ -2260,12 +2291,22 @@ class Tpkg
     end
     case operation
     when :install
-      IO.popen("#{externalpath} '#{pkgfile}' install", 'w') do |pipe|
-        pipe.write(data)
+      begin
+        IO.popen("#{externalpath} '#{pkgfile}' install", 'w') do |pipe|
+          pipe.write(data)
+        end
+      rescue => e
+        # Tell the user which external and package were involved, otherwise
+        # failures in externals are very hard to debug
+        raise e.exception("External #{name} #{operation} for #{File.basename(pkgfile)}: " + e.message)
       end
     when :remove
-      IO.popen("#{externalpath} '#{pkgfile}' remove", 'w') do |pipe|
-        pipe.write(data)
+      begin
+        IO.popen("#{externalpath} '#{pkgfile}' remove", 'w') do |pipe|
+          pipe.write(data)
+        end
+      rescue => e
+        raise e.exception("External #{name} #{operation} for #{File.basename(pkgfile)}: " + e.message)
       end
     else
       raise "Bug, unknown external operation #{operation}"
@@ -2718,7 +2759,7 @@ class Tpkg
       end
       
       file = File.open(File.join(package_metadata_dir, "file_metadata.bin"), "w")
-      Marshal.dump(file_metadata.hash, file)
+      Marshal.dump(file_metadata.to_hash, file)
       file.close
     else
       warn "Warning: package #{File.basename(package_file)} does not include file_metadata information."
@@ -2737,7 +2778,8 @@ class Tpkg
     metadata_for_installed_packages.each do |metadata|
       if !pkgname || pkgname == metadata[:name]
         req = { :name => metadata[:name],
-                :minimum_version => metadata[:version] }
+                :minimum_version => metadata[:version],
+                :type => :tpkg }
         if metadata[:package_version]
           req[:minimum_package_version] = metadata[:package_version]
         end
@@ -2756,7 +2798,7 @@ class Tpkg
       version = installed_xml[:version]
       # For each currently installed package we insert a requirement for
       # at least that version of the package
-      req = { :name => name, :minimum_version => version }
+      req = { :name => name, :minimum_version => version, :type => :tpkg }
       requirements << req
       # Initialize the list of possible packages for this req
       if !packages[name]
@@ -2782,6 +2824,7 @@ class Tpkg
     
     requests.each do |request|
       puts "parse_requests processing #{request.inspect}" if @@debug
+
       if request =~ /^[-\w=<>\d\.]+$/ && !File.file?(request)  # basic package specs ('foo' or 'foo=1.0')
         puts "parse_requests request looks like package spec" if @@debug
 
@@ -2816,6 +2859,7 @@ class Tpkg
           FileUtils.rm_rf(localpath)
         end
         req[:name] = metadata[:name]
+        req[:type] = :tpkg
         pkg = { :metadata => metadata, :source => source }
 
         newreqs << req
@@ -2824,7 +2868,7 @@ class Tpkg
         packages[req[:name]] = [pkg]
       end
     end
-    
+
     requirements.concat(newreqs)
     newreqs
   end
@@ -2845,23 +2889,24 @@ class Tpkg
       request_satisfied = false # whether or not this request can be satisfied
       possible_errors = []
       pkgs.each do |pkg|
+        good_package = true
         metadata = pkg[:metadata]
-        req = { :name => metadata[:name] }
+        req = { :name => metadata[:name], :type => :tpkg }
         # Quick sanity check that the package can be installed on this machine.  
         if !Tpkg::package_meets_requirement?(pkg, req)
           possible_errors << "  Requested package #{metadata[:filename]} doesn't match this machine's OS or architecture"
+          good_package = false
           next
         end
         # a sanity check that there is at least one package
         # available for each dependency of this package
-        dep_satisfied = true
         metadata[:dependencies].each do |depreq|
           if available_packages_that_meet_requirement(depreq).empty? && !Tpkg::packages_meet_requirement?(packages.values.flatten, depreq)
             possible_errors << "  Requested package #{metadata[:filename]} depends on #{depreq.inspect}, no packages that satisfy that dependency are available"
-            dep_satisfied = false
+            good_package = false
           end
         end if metadata[:dependencies]
-        request_satisfied = true if dep_satisfied
+        request_satisfied = true if good_package
       end
       if !request_satisfied
         errors << ["Unable to find any packages which satisfy #{name}. Possible error(s):"]
@@ -2987,7 +3032,11 @@ class Tpkg
             name = pkg[:metadata][:name]
             version = pkg[:metadata][:version]
             package_version = pkg[:metadata][:package_version]
-            puts "Native #{name}=#{version}=#{package_version}"
+            pkgname = "#{name}-#{version}"
+            if package_version
+              pkgname << "-#{package_version}"
+            end
+            puts "Native #{pkgname}"
           else    
             puts pkg[:metadata][:filename]
           end
@@ -3008,13 +3057,20 @@ class Tpkg
     parse_requests(requests, requirements, packages)
     check_requests(packages)
     core_packages = []
-    currently_installed_requirements = []
+    #currently_installed_requirements = []
     requirements.each do |req|
       core_packages << req[:name] if !core_packages.include?(req[:name])
-      currently_installed_requirements.concat(
-        requirements_for_currently_installed_package(req[:name]))
+
+    # This was here to ensure that nothing went backwards.  But I guess in the 
+    # install case (as opposed to upgrade) going backwards can't really happen, 
+    # we may just install an older version alongside a newer version, which is
+    # perfectly fine.
+    #  currently_installed_requirements.concat(
+    #    requirements_for_currently_installed_package(req[:name]))
     end
-    requirements.concat(currently_installed_requirements).uniq!
+    #requirements.concat(currently_installed_requirements).uniq!
+
+
     
     puts "install calling best_solution" if @@debug
     puts "install requirements: #{requirements.inspect}" if @@debug
@@ -3192,7 +3248,11 @@ class Tpkg
         metadata_for_installed_packages.each do | metadata |
           metadata[:dependencies].each do | dep |
             if dep[:name] == req[:name]
-              additional_requirements << metadata.hash
+              # Package metadata is almost usable as-is as a req, just need to
+              # set :type
+              addreq = metadata.to_hash
+              addreq[:type] = :tpkg
+              additional_requirements << addreq
             end
           end if metadata[:dependencies]
         end
@@ -3330,10 +3390,10 @@ class Tpkg
           # If the old and new packages have overlapping externals flag them
           # to be skipped so that the external isn't removed and then
           # immediately re-added
-          oldpkgs = installed_packages_that_meet_requirement({:name => pkg[:metadata][:name]})
+          oldpkgs = installed_packages_that_meet_requirement({:name => pkg[:metadata][:name], :type => :tpkg})
           externals_to_skip = []
           pkg[:metadata][:externals].each do |external|
-            if oldpkgs.all? {|oldpkg| oldpkg[:metadata][:externals].include?(external)}
+            if oldpkgs.all? {|oldpkg| oldpkg[:metadata][:externals] && oldpkg[:metadata][:externals].include?(external)}
               externals_to_skip << external
             end
           end if pkg[:metadata][:externals]
@@ -3416,7 +3476,7 @@ class Tpkg
           # We ignore native dependencies because there is no way a removal
           # can break a native dependency, we don't support removing native
           # packages.
-          if req[:type] != :native && req[:type] != :native_installed
+          if req[:type] != :native
             iptmr = installed_packages_that_meet_requirement(req)
             if iptmr.all? { |pkg| pkg_files_to_remove.include?(pkg[:metadata][:filename]) }
               non_removable_pkg_files |= iptmr.map{ |pkg| pkg[:metadata][:filename]}
@@ -3768,32 +3828,43 @@ class Tpkg
     end
     return results
   end
-  
-  def execute_init(requests, action)
+ 
+  def execute_init(options, *moreoptions)
     ret_val = 0
     packages_to_execute_on = []
-    if requests.nil?
+    if options.is_a?(Hash)
+      action = options[:cmd]
+      requested_packages = options[:packages]
+      requested_init_scripts = options[:scripts]
+    else # for backward compatibility
+      action = moreoptions[0]
+      requested_packages = options
+    end
+
+    # if user specified no packages, then assume all
+    if requested_packages.nil?
       packages_to_execute_on = installed_packages_that_meet_requirement(nil)
     else
-      requests.each do |request|
+      requested_packages.each do |request|
         req = Tpkg::parse_request(request)
         packages_to_execute_on.concat(installed_packages_that_meet_requirement(req))
       end
     end
     
     packages_to_execute_on.each do |pkg|
-      ret_val |= execute_init_for_package(pkg, action)
+      ret_val |= execute_init_for_package(pkg, action, requested_init_scripts)
     end 
     return ret_val
   end
-  
-  def execute_init_for_package(pkg, action)
+ 
+  def execute_init_for_package(pkg, action, requested_init_scripts = nil)
     ret_val = 0
-    init_scripts_metadata = init_scripts(pkg[:metadata])
 
+    # Get init scripts metadata for the given package
+    init_scripts_metadata = init_scripts(pkg[:metadata])
     # warn if there's no init script and then return
     if init_scripts_metadata.nil? || init_scripts_metadata.empty?
-      warn "Warning: There is no init script for #{pkg[:metadata][:name]}"
+      warn "Warning: There is no init script for #{pkg[:metadata][:name]}."
       return 1
     end
 
@@ -3805,9 +3876,18 @@ class Tpkg
       init = {}
       init[:path] = installed_path
       init[:start] = init_info[:init][:start] || 0
-      init_scripts << init
+
+      # if user requests specific init scripts, then only include those
+      if requested_init_scripts.nil? or 
+         requested_init_scripts && requested_init_scripts.include?(File.basename(installed_path))
+        init_scripts << init 
+      end
     end
 
+    if requested_init_scripts && init_scripts.empty?
+      warn "Warning: There are no init scripts that satisfy your request: #{requested_init_scripts.inspect} for package #{pkg[:metadata][:name]}."
+    end
+    
     # Reverse order if doing stop. 
     if action == "stop"
       ordered_init_scripts = init_scripts.sort{ |a,b| b[:start] <=> a[:start] }
@@ -3880,7 +3960,7 @@ class Tpkg
 
   # TODO: update server side to accept yaml data
   def send_update_to_server
-    metadata = metadata_for_installed_packages.collect{|metadata| metadata.hash}
+    metadata = metadata_for_installed_packages.collect{|metadata| metadata.to_hash}
     yml = YAML.dump(metadata)
     begin
       update_uri =  URI.parse("#{@report_server}")

data/lib/tpkg/metadata.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'rexml/document'
 
 module SymbolizeKeys
 
@@ -86,14 +87,14 @@ class Metadata
   end
 
   def [](key)
-    return hash[key]
+    return to_hash[key]
   end
 
   def []=(key,value)
-    hash[key]=value
+    to_hash[key]=value
   end
 
-  def hash
+  def to_hash
     if @hash  
       return @hash 
     end
@@ -101,6 +102,18 @@ class Metadata
     if @format == 'yml'
       hash = YAML::load(@metadata_text)
       @hash = hash.extend(SymbolizeKeys)
+
+      # We need this for backward compatibility. With xml, we specify
+      # native dependency as type: :native rather then native: true
+      @hash[:dependencies].each do | dep |
+        if !dep[:type]
+          if dep[:native]
+            dep[:type] = :native
+          else
+            dep[:type] = :tpkg
+          end
+        end
+      end if @hash[:dependencies]
     else
       @hash = metadata_xml_to_hash
     end
@@ -108,18 +121,18 @@ class Metadata
   end
 
   def write(file)
-    YAML::dump(hash, file)
+    YAML::dump(to_hash, file)
   end
 
   def get_files_list
   end
 
   def generate_package_filename
-    name = hash[:name]
-    version = hash[:version]
+    name = to_hash[:name]
+    version = to_hash[:version]
     packageversion = nil
-    if hash[:package_version] && !hash[:package_version].to_s.empty?
-      packageversion = hash[:package_version]
+    if to_hash[:package_version] && !to_hash[:package_version].to_s.empty?
+      packageversion = to_hash[:package_version]
     end
     package_filename = "#{name}-#{version}"
     if packageversion
@@ -127,11 +140,11 @@ class Metadata
     end
 
 
-    if hash[:operatingsystem] and !hash[:operatingsystem].empty?
-      if hash[:operatingsystem].length == 1
-        package_filename << "-#{Metadata::clean_for_filename(hash[:operatingsystem].first)}"
+    if to_hash[:operatingsystem] and !to_hash[:operatingsystem].empty?
+      if to_hash[:operatingsystem].length == 1
+        package_filename << "-#{Metadata::clean_for_filename(to_hash[:operatingsystem].first)}"
       else
-        operatingsystems = hash[:operatingsystem].dup
+        operatingsystems = to_hash[:operatingsystem].dup
         # Genericize any equivalent operating systems
         # FIXME: more generic handling of equivalent OSs is probably called for
         operatingsystems.each do |os|
@@ -154,9 +167,9 @@ class Metadata
         end
       end
     end
-    if hash[:architecture] and !hash[:architecture].empty?
-      if hash[:architecture].length == 1
-        package_filename << "-#{Metadata::clean_for_filename(hash[:architecture].first)}"
+    if to_hash[:architecture] and !to_hash[:architecture].empty?
+      if to_hash[:architecture].length == 1
+        package_filename << "-#{Metadata::clean_for_filename(to_hash[:architecture].first)}"
       else
         package_filename << "-multiarch"
       end
@@ -167,16 +180,16 @@ class Metadata
 
   def verify_required_fields
     REQUIRED_FIELDS.each do |reqfield|
-      if hash[reqfield].nil?
+      if to_hash[reqfield].nil?
         raise "Required field #{reqfield} not found"
-      elsif hash[reqfield].to_s.empty?
+      elsif to_hash[reqfield].to_s.empty?
         raise "Required field #{reqfield} is empty"
       end
     end
   end
 
   def metadata_xml_to_hash
-    # Don't do anything if metadata is from xml file
+    # Don't do anything if metadata is not from xml file
     return if @format != "xml"
 
     metadata_hash = {}
@@ -230,6 +243,8 @@ class Metadata
       end
       if depxml.elements['native']
         dep[:type] = :native
+      else
+        dep[:type] = :tpkg
       end
       deps << dep
     end
@@ -247,6 +262,8 @@ class Metadata
       end
       if conflictxml.elements['native']
         conflict[:type] = :native
+      else
+        conflict[:type] = :tpkg
       end
       conflicts << conflict
     end
@@ -387,13 +404,13 @@ class Metadata
 end
 
 class FileMetadata < Metadata
-  def hash
+  def to_hash
     if @hash
       return @hash
     end
 
     if @format == 'bin'
-      @hash = Marshal::load(@metadata_text)
+      hash = Marshal::load(@metadata_text)
       @hash = hash.extend(SymbolizeKeys)
     elsif @format == 'yml'
       hash = YAML::load(@metadata_text)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tpkg
 version: !ruby/object:Gem::Version 
-  version: 1.16.2
+  version: 1.18.2
 platform: ruby
 authors: 
 - Darren Dao
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-16 00:00:00 -08:00
+date: 2010-01-28 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,18 +39,20 @@ executables:
 - tpkg
 - cpan2tpkg
 - gem2tpkg
+- tpkg_xml_to_yml
 extensions: []
 
 extra_rdoc_files: []
 
 files: 
 - bin/cpan2tpkg
-- bin/gem2tpkg
+- bin/tpkg_xml_to_yml
 - bin/tpkg
+- bin/gem2tpkg
+- lib/tpkg/versiontype.rb
 - lib/tpkg/deployer.rb
-- lib/tpkg/metadata.rb
 - lib/tpkg/thread_pool.rb
-- lib/tpkg/versiontype.rb
+- lib/tpkg/metadata.rb
 - lib/tpkg.rb
 - Rakefile
 has_rdoc: true