tpkg 2.2.4 → 2.3.0

data/Rakefile

@@ -1,19 +1,19 @@
 require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
-  s.name	= 'tpkg'
-  s.summary	= 'tpkg Application Packaging & Deployment'
-  s.add_dependency('facter')
-  s.add_dependency('net-ssh')
-  s.add_dependency('kwalify')
-  s.version = '2.2.4'
+  s.name = 'tpkg'
+  s.summary = 'tpkg Application Packaging & Deployment'
+  s.version = '2.3.0'
   s.authors = ['Darren Dao', 'Jason Heiss']
   s.email = 'tpkg-users@lists.sourceforge.net'
   s.homepage = 'http://tpkg.sourceforge.net'
   s.rubyforge_project = 'tpkg'
   s.platform = Gem::Platform::RUBY
   s.required_ruby_version = '>=1.8'
-  s.files	= Dir['**/**']
+  s.files = Dir['**/**']
   s.executables = [ 'tpkg', 'cpan2tpkg', 'gem2tpkg', 'tpkg_xml_to_yml' ]
+  s.add_dependency('facter')
+  s.add_dependency('net-ssh')
+  s.add_dependency('kwalify')
 end
 Rake::GemPackageTask.new(spec).define
 

data/bin/cpan2tpkg

@@ -1,7 +1,6 @@
 #!/opt/tpkg/bin/perl
 ##############################################################################
 # tpkg package management system
-# Copyright 2009, 2010, 2011 AT&T Interactive
 # License: MIT (http://www.opensource.org/licenses/mit-license.php)
 ##############################################################################
 
@@ -78,7 +77,7 @@ while (scalar @extradepsopts)
 {
 	my $dep = shift @extradepsopts;
 	# These are optional, shift will return undef if they aren't present
-	# and we'll handle that properly when creating tpkg.xml
+	# and we'll handle that properly when creating tpkg.yml
 	my $depminver = shift @extradepsopts;
 	my $depmaxver = shift @extradepsopts;
 	$extradeps{$dep} = {};
@@ -90,7 +89,7 @@ while (scalar @nativedepsopts)
 {
 	my $dep = shift @nativedepsopts;
 	# These are optional, shift will return undef if they aren't present
-	# and we'll handle that properly when creating tpkg.xml
+	# and we'll handle that properly when creating tpkg.yml
 	my $depminver = shift @nativedepsopts;
 	my $depmaxver = shift @nativedepsopts;
 	$nativedeps{$dep} = {};
@@ -315,23 +314,29 @@ MODULE: foreach my $name ($extinst->modules)
 		$packlistfile =~ s/^$workdir//;
 		# Make directory tree in $tpkgdir
 		mkpath("$tpkgdir/root/" . dirname($packlistfile));
+
 		# Copy file
-		copy("$workdir/$packlistfile", "$tpkgdir/root/$packlistfile");
+		my $src = "$workdir/$packlistfile";
+		my $dst = "$tpkgdir/root/$packlistfile";
+		copy($src, $dst);
+
+		# preserve permissions
+		# (avoiding dependency on File::Copy::Recursive::fcopy)
+		my $mode = (stat($src))[2];
+		chmod($mode & 07777, $dst);
+
 		if ($packlistfile =~ quotemeta($Config{archname}))
 		{
 			$nativefile = 1;
 		}
 	}
-	# Create tpkg.xml
-	open(my $xmlfh, '>', "$tpkgdir/tpkg.xml") or die;
-	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-$pkgname</name>", "\n";
-	print $xmlfh "  <version>$ver</version>", "\n";
-	print $xmlfh "  <package_version>$pkgver</package_version>", "\n";
-	print $xmlfh "  <description>cpan package for $pkgname</description>", "\n";
-	print $xmlfh '  <maintainer>cpan2tpkg</maintainer>', "\n";
+	# Create tpkg.yml
+	open(my $ymlfh, '>', "$tpkgdir/tpkg.yml") or die;
+	print $ymlfh "name: cpan-perl$majorminor-$pkgname", "\n";
+	print $ymlfh "version: $ver", "\n";
+	print $ymlfh "package_version: $pkgver", "\n";
+	print $ymlfh "description: cpan package for $pkgname", "\n";
+	print $ymlfh 'maintainer: cpan2tpkg', "\n";
 	# If the package has native code then it needs to be flagged as
 	# specific to the OS and architecture
 	if ($nativefile)
@@ -360,68 +365,58 @@ MODULE: foreach my $name ($extinst->modules)
 		# vice-versa
 		if ($os =~ /RedHat-(.*)/)
 		{
-			$os = $os . ",CentOS-$1";
+			$os = $os . ", CentOS-$1";
 		}
 		elsif ($os =~ /CentOS-(.*)/)
 		{
-			$os = $os . ",RedHat-$1";
+			$os = $os . ", RedHat-$1";
 		}
-		print $xmlfh "  <operatingsystem>$os</operatingsystem>", "\n";
-		print $xmlfh "  <architecture>$arch</architecture>", "\n";
+		print $ymlfh "operatingsystem: [$os]", "\n";
+		print $ymlfh "architecture: [$arch]", "\n";
 	}
 	# Insert appropriate dependencies into the package
-	print $xmlfh '  <dependencies>', "\n";
+	print $ymlfh 'dependencies:', "\n";
 	foreach my $dep (keys %deps)
 	{
-		print $xmlfh '    <dependency>', "\n";
-		print $xmlfh "      <name>cpan-perl$majorminor-$dep</name>", "\n";
+		print $ymlfh "  - name: cpan-perl$majorminor-$dep", "\n";
 		if ($deps{$dep}{minimum_version})
 		{
-			print $xmlfh "      <minimum_version>$deps{$dep}{minimum_version}</minimum_version>", "\n";
+			print $ymlfh "    minimum_version: $deps{$dep}{minimum_version}", "\n";
 		}
 		if ($deps{$dep}{maximum_version})
 		{
-			print $xmlfh "      <maximum_version>$deps{$dep}{maximum_version}</maximum_version>", "\n";
+			print $ymlfh "    maximum_version: $deps{$dep}{maximum_version}", "\n";
 		}
-		print $xmlfh '    </dependency>', "\n";
 	}
 	foreach my $extradep (keys %extradeps)
 	{
-		print $xmlfh '    <dependency>', "\n";
-		print $xmlfh "      <name>$extradep</name>", "\n";
+		print $ymlfh "  - name: $extradep", "\n";
 		if ($extradeps{$extradep}{minimum_version})
 		{
-			print $xmlfh "      <minimum_version>$extradeps{$extradep}{minimum_version}</minimum_version>", "\n";
+			print $ymlfh "    minimum_version: $extradeps{$extradep}{minimum_version}", "\n";
 		}
 		if ($extradeps{$extradep}{maximum_version})
 		{
-		print $xmlfh "      <maximum_version>$extradeps{$extradep}{maximum_version}</maximum_version>", "\n";
+  		print $ymlfh "    maximum_version: $extradeps{$extradep}{maximum_version}", "\n";
 		}
-		print $xmlfh '    </dependency>', "\n";
 	}
 	foreach my $nativedep (keys %nativedeps)
 	{
-		print $xmlfh '    <dependency>', "\n";
-		print $xmlfh "      <name>$nativedep</name>", "\n";
+		print $ymlfh "  - name: $nativedep", "\n";
 		if ($nativedeps{$nativedep}{minimum_version})
 		{
-			print $xmlfh "      <minimum_version>$nativedeps{$nativedep}{minimum_version}</minimum_version>", "\n";
+			print $ymlfh "    minimum_version: $nativedeps{$nativedep}{minimum_version}", "\n";
 		}
 		if ($nativedeps{$nativedep}{maximum_version})
 		{
-			print $xmlfh "      <maximum_version>$nativedeps{$nativedep}{maximum_version}</maximum_version>", "\n";
+			print $ymlfh "    maximum_version: $nativedeps{$nativedep}{maximum_version}", "\n";
 		}
-		print $xmlfh '      <native/>', "\n";
-		print $xmlfh '    </dependency>', "\n";
+		print $ymlfh '    native: true', "\n";
 	}
 	# Insert an appropriate dependency on Perl itself
-	print $xmlfh '    <dependency>', "\n";
-	print $xmlfh "      <name>perl</name>", "\n";
-	print $xmlfh "      <minimum_version>", sprintf("%vd", $^V), "</minimum_version>", "\n";
-	print $xmlfh "      <maximum_version>$majordotminor.9999</maximum_version>", "\n";
-	print $xmlfh '    </dependency>', "\n";
-	print $xmlfh '  </dependencies>', "\n";
-	print $xmlfh '</tpkg>', "\n";
+	print $ymlfh '  - name: perl', "\n";
+	print $ymlfh '    minimum_version: ', sprintf("%vd", $^V), "\n";
+	print $ymlfh "    maximum_version: $majordotminor.9999", "\n";
 	# Build package
 	system("tpkg --make $tpkgdir");
 }

data/bin/gem2tpkg

@@ -1,12 +1,14 @@
 #!/usr/bin/ruby -w
 ##############################################################################
 # tpkg package management system
-# Copyright 2009, 2010, 2011 AT&T Interactive
 # License: MIT (http://www.opensource.org/licenses/mit-license.php)
 ##############################################################################
 
-# Ensure we can find tpkg.rb
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+# When run from the source repository or from an unpacked copy of the
+# distribution we want to find the local library, even if there's a copy
+# installed on the system.  The installed copy is likely older, and the API
+# may be out of sync with this executable.
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
 
 require 'fileutils' # FileUtils.cp, rm, etc.
 require 'tempfile'  # Tempfile
@@ -56,7 +58,7 @@ opts.on('--extra-deps', '=EXTRADEPS', Array, 'Extra dependencies to add to the p
   while !opt.empty?
     dep = opt.shift
     # These are optional, shift will return nil if they aren't present
-    # and we'll handle that properly when creating tpkg.xml
+    # and we'll handle that properly when creating tpkg.yml
     depminver = opt.shift
     depmaxver = opt.shift
     @extradeps[dep] = {}
@@ -69,7 +71,7 @@ opts.on('--native-deps', '=NATIVEDEPS', Array, 'Native dependencies to add to th
   while !opt.empty?
     dep = opt.shift
     # These are optional, shift will return nil if they aren't present
-    # and we'll handle that properly when creating tpkg.xml
+    # and we'll handle that properly when creating tpkg.yml
     depminver = opt.shift
     depmaxver = opt.shift
     @nativedeps[dep] = {}
@@ -273,7 +275,7 @@ def package(gem)
       operator.sub!(/^\(/, '')
       depver.sub!(/\)$/, '')
       depver.sub!(/,$/, '')
-      # Save the dependency info for tpkg.xml
+      # Save the dependency info for tpkg.yml
       # http://rubygems.org/read/chapter/16
       deps[depgem] = {}
       case operator
@@ -393,77 +395,83 @@ def package(gem)
     pkgnamesuffix = '-' + @gemdep.first.sub(/\W/, '')
   end
   
-  # Add tpkg.xml
+  # Determine if we're packaging a gem the user requested or a dependency gem.
+  # If we're packaging a dependency gem we don't want to add @extradeps or
+  # @nativedeps.  Say you run gem2tpkg for gem foo. You specify some extra
+  # dependencies with --extra-deps and/or --native-deps. Gem foo depends on
+  # gems bar and baz. The generated tpkgs for bar and baz will include those
+  # extra dependencies. I don't think they should. Bar and baz may be very
+  # general gems with no close relationship to foo. It seems to me if the user
+  # needs bar and baz to have the same extra dependencies they should gem2tpkg
+  # those separately. We shouldn't assume everything in the dependency chain
+  # needs those same dependencies.
+  packaging_requested_gem = false
+  if @gems.include?(gem)
+    packaging_requested_gem = true
+  end
+  
+  # Add tpkg.yml
   os = nil
   arch = nil
-  File.open(File.join(pkgdir, 'tpkg.xml'), 'w') do |file|
-    file.puts '<?xml version="1.0" encoding="UTF-8"?>'
-    file.puts '<!DOCTYPE tpkg SYSTEM "http://tpkg.sourceforge.net/tpkg-1.0.dtd">'
-    file.puts '<tpkg>'
-    file.puts "  <name>gem-#{gem}#{pkgnamesuffix}</name>"
-    file.puts "  <version>#{gemspec.version.to_s}</version>"
-    file.puts "  <package_version>#{@pkgver}</package_version>"
-    file.puts "  <description>Ruby gem for #{gem}</description>"
-    file.puts '  <maintainer>gem2tpkg</maintainer>'
+  File.open(File.join(pkgdir, 'tpkg.yml'), 'w') do |file|
+
+    file.puts "name: gem-#{gem}#{pkgnamesuffix}"
+    file.puts "version: #{gemspec.version.to_s}"
+    file.puts "package_version: #{@pkgver}"
+    file.puts "description: Ruby gem for #{gem}"
+    file.puts 'maintainer: gem2tpkg'
     # If the gemspec lists any extensions then the package has native
     # code and needs to be flagged as specific to the OS and architecture
     if gemspec.extensions && !gemspec.extensions.empty?
       os = Tpkg::get_os
       if os =~ /RedHat-(.*)/
-        os = os + ",CentOS-#{$1}"
+        os = os + ", CentOS-#{$1}"
       elsif os =~ /CentOS-(.*)/
-        os = os + ",RedHat-#{$1}"
+        os = os + ", RedHat-#{$1}"
       end
       arch = Facter['hardwaremodel'].value
-      file.puts "  <operatingsystem>#{os}</operatingsystem>"
-      file.puts "  <architecture>#{arch}</architecture>"
+      file.puts "operatingsystem: [#{os}]"
+      file.puts "architecture: [#{arch}]"
     end
     if !deps.empty? ||
-       !@extradeps.empty? || !@nativedeps.empty? ||
+       (!@extradeps.empty? && packaging_requested_gem) ||
+       (!@nativedeps.empty? && packaging_requested_gem) ||
        !@gemdep.empty?
-      file.puts '  <dependencies>'
+      file.puts 'dependencies:'
       deps.each do |depgem, depvers|
-        file.puts '    <dependency>'
-        file.puts "      <name>gem-#{depgem}#{pkgnamesuffix}</name>"
-        if depvers[:minimum_version]
-          file.puts "      <minimum_version>#{depvers[:minimum_version]}</minimum_version>"
-        end
-        if depvers[:maximum_version]
-          file.puts "      <maximum_version>#{depvers[:maximum_version]}</maximum_version>"
-        end
-        file.puts '    </dependency>'
-      end
-      @extradeps.each do |extradep, depvers|
-        file.puts '    <dependency>'
-        file.puts "      <name>#{extradep}</name>"
+        file.puts "  - name: gem-#{depgem}#{pkgnamesuffix}"
         if depvers[:minimum_version]
-          file.puts "      <minimum_version>#{depvers[:minimum_version]}</minimum_version>"
+          file.puts "    minimum_version: #{depvers[:minimum_version]}"
         end
         if depvers[:maximum_version]
-          file.puts "      <maximum_version>#{depvers[:maximum_version]}</maximum_version>"
+          file.puts "    maximum_version: #{depvers[:maximum_version]}"
         end
-        file.puts '    </dependency>'
       end
-      @nativedeps.each do |nativedep, depvers|
-        file.puts '    <dependency>'
-        file.puts "      <name>#{nativedep}</name>"
-        if depvers[:minimum_version]
-          file.puts "      <minimum_version>#{depvers[:minimum_version]}</minimum_version>"
+      if packaging_requested_gem
+        @extradeps.each do |extradep, depvers|
+          file.puts "  - name: #{extradep}"
+          if depvers[:minimum_version]
+            file.puts "    minimum_version: #{depvers[:minimum_version]}"
+          end
+          if depvers[:maximum_version]
+            file.puts "    maximum_version: #{depvers[:maximum_version]}"
+          end
         end
-        if depvers[:maximum_version]
-          file.puts "      <maximum_version>#{depvers[:maximum_version]}</maximum_version>"
+        @nativedeps.each do |nativedep, depvers|
+          file.puts "  - name: #{nativedep}"
+          if depvers[:minimum_version]
+            file.puts "    minimum_version: #{depvers[:minimum_version]}"
+          end
+          if depvers[:maximum_version]
+            file.puts "    maximum_version: #{depvers[:maximum_version]}"
+          end
+          file.puts '    native: true'
         end
-        file.puts '      <native/>'
-        file.puts '    </dependency>'
       end
       @gemdep.each do |gemdep|
-        file.puts '    <dependency>'
-        file.puts "      <name>#{gemdep}</name>"
-        file.puts '    </dependency>'
+        file.puts "  - name: #{gemdep}"
       end
-      file.puts '  </dependencies>'
     end
-    file.puts '</tpkg>'
   end
   
   # Make package

data/bin/tpkg

@@ -1,12 +1,14 @@
 #!/usr/bin/ruby -w
 ##############################################################################
 # tpkg package management system
-# Copyright 2009, 2010, 2011 AT&T Interactive
 # License: MIT (http://www.opensource.org/licenses/mit-license.php)
 ##############################################################################
 
-# Ensure we can find tpkg.rb
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+# When run from the source repository or from an unpacked copy of the
+# distribution we want to find the local library, even if there's a copy
+# installed on the system.  The installed copy is likely older, and the API
+# may be out of sync with this executable.
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
 
 require 'optparse'
 require 'tpkg'
@@ -20,15 +22,23 @@ require 'tpkg'
 @debug = false
 @prompt = true
 @quiet = false
-@sudo = true
-@lockforce = false
+@sudo = nil
+# Neither of the common Windows environments for running Ruby have
+# sudo, so turn it off by default on those platforms
+if RUBY_PLATFORM == 'i386-mingw32' || RUBY_PLATFORM == 'i386-cygwin'
+  @sudo = false
+else
+  @sudo = true
+end
 @force = false
 @deploy = false
 @deploy_params = ARGV   # hold parameters for how to invoke tpkg on the machines we're deploying to
 @deploy_options = {}    # options for how to run the deployer
-@servers = nil
+@servers = []
+@groups = nil
 @worker_count = 10
 @rerun_with_sudo = false
+@sources = []
 @tpkg_options = {}	# options for instantiating Tpkg object
 @init_options = {}      # options for how to run init scripts
 @other_options = {}     
@@ -37,7 +47,7 @@ require 'tpkg'
 
 def rerun_with_sudo_if_necessary
   if Process.euid != 0 && @sudo
-    warn "Executing with sudo"
+    warn "Executing with sudo" if !@quiet
     # Depending on how sudo is configured it might remove TPKG_HOME from the
     # environment.  As such we set the base as a command line option to ensure
     # it survives the sudo process.
@@ -49,21 +59,53 @@ def rerun_with_sudo_if_necessary
   end
 end
 
+# This method can only be safely called after command line option parsing is
+# complete
+@config_file_settings = nil
+def parse_config_files
+  if @config_file_settings
+    return @config_file_settings
+  end
+  
+  # FIXME: Move config file parsing to tpkg.rb
+  # http://sourceforge.net/apps/trac/tpkg/ticket/28
+  fsroot = @tpkg_options[:file_system_root] ? @tpkg_options[:file_system_root] : ''
+  settings = {:sources => []}
+  [File.join(fsroot, Tpkg::DEFAULT_CONFIGDIR, 'tpkg.conf'),
+   File.join(fsroot, ENV['HOME'], ".tpkg.conf")].each do |configfile|
+    if File.exist?(configfile)
+      IO.foreach(configfile) do |line|
+        line.chomp!
+        next if (line =~ /^\s*$/);  # Skip blank lines
+        next if (line =~ /^\s*#/);  # Skip comments
+        line.strip!  # Remove leading/trailing whitespace
+        key, value = line.split(/\s*=\s*/, 2)
+        if key == 'base'
+          settings[:base] = value
+          puts "Loaded base #{value} from #{configfile}" if @debug
+        elsif key == 'source'
+          settings[:sources] << value
+          puts "Loaded source #{value} from #{configfile}" if @debug
+        elsif key == 'report_server'
+          settings[:report_server] = value
+          puts "Loaded report server #{value} from #{configfile}" if @debug
+        elsif key == 'host_group_script'
+          settings[:host_group_script] = value
+          puts "Loaded host group script #{value} from #{configfile}" if @debug
+        end
+      end
+    end
+  end
+  
+  @config_file_settings = settings
+end
+
 opts = OptionParser.new(nil, 24, '  ')
 opts.banner = 'Usage: tpkg [options]'
-opts.on('--servers', '-s', '=SERVERS', Array, 'Servers to apply the actions to') do |opt|
-  @servers = opt
-  @deploy = true
-  @deploy_params = @deploy_params - ['--servers', '-s', @servers.join(","), "--servers=#{@servers.join(',')}"]
-end
 opts.on('--make', '-m', '=DIRECTORY', 'Make a package out of the contents of the directory') do |opt|
   @action = :make
   @action_value = opt
 end
-opts.on('--extract', '-x', '=DIRECTORY', 'Extract the metadata for a directory of packages') do |opt|
-  @action = :extract
-  @action_value = opt
-end
 installexample = "      --install pkgname=version=package_version\n          (Example: tpkg --install hive=2.1)  Will install hive version 2.1"
 opts.on('--install', '-i', '=PACKAGES', "Install one or more packages\n#{installexample}", Array) do |opt|
   @rerun_with_sudo = true
@@ -81,6 +123,27 @@ opts.on('--downgrade', '=PACKAGES', 'Downgrade one or more packages', Array) do
   @action = :upgrade
   @action_value = opt
 end
+opts.on('--servers', '-s', '=SERVERS', Array, 'Servers on which to apply actions, defaults to local') do |opt|
+  @servers.concat(opt)
+  @deploy = true
+  # FIXME: this won't remove options that the user specified as an
+  # abbreviation.  I.e. if the option is --servers and the user specified
+  # --serv (which OptionParser will accept as long as it is unambiguous) this
+  # won't detect and remove it.
+  @deploy_params = @deploy_params - ['--servers', '-s', @servers.join(","), "--servers=#{@servers.join(',')}"]
+end
+opts.on('--groups', '-g', '=GROUP', Array, 'Group of server on which to apply actions') do |opt|
+  # We'll finish processing this later.  To expand the groups we need the name
+  # of the host_group_script from the config file, but we can't safely call
+  # parse_config_files until we're done processing command line options.
+  @groups = opt
+  @deploy = true
+  # FIXME: this won't remove options that the user specified as an
+  # abbreviation.  I.e. if the option is --servers and the user specified
+  # --serv (which OptionParser will accept as long as it is unambiguous) this
+  # won't detect and remove it.
+  @deploy_params = @deploy_params - ['--groups', '-g', @groups.join(","), "--servers=#{@groups.join(',')}"]
+end
 opts.on('--ua', 'Upgrade all packages') do |opt|
   @rerun_with_sudo = true
   @action = :upgrade
@@ -174,7 +237,7 @@ opts.on('--init-cmd', '=CMD', 'Invoke 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|
+opts.on('--query', '-q', '=NAMES', 'Check if a package is installed', Array) do |opt|
   # People mistype -qa instead of --qa frequently
   if opt == ['a']
     warn "NOTE: tpkg -qa queries for a pkg named 'a', you probably want --qa for all pkgs"
@@ -182,49 +245,67 @@ opts.on('--query', '-q', '=NAMES', 'List installed packages', Array) do |opt|
   @action = :query_installed
   @action_value = opt
 end
+# --qv is deprecated
+opts.on('--qs', '--qv', '=NAME', 'Check if a package is available on server', Array) do |opt|
+  @action = :query_available
+  @action_value = opt
+end
 opts.on('--qa', 'List all installed packages') do |opt|
   @action = :query_installed
 end
-opts.on('--qi', '=NAME', 'Info for packages') do |opt|
+# --qva is deprecated
+opts.on('--qas', '--qva', 'List all packages on server') do |opt|
+  @action = :query_available
+end
+opts.on('--qi', '=NAME', 'Display the info for a package') do |opt|
   @action = :query_info
   @action_value = opt
 end
-opts.on('--ql', '=NAME', 'List files in installed packages') do |opt|
-  @action = :query_list_files
+opts.on('--qis', '=NAME', 'Display the info for a package on the server') do |opt|
+  @action = :query_info_available
   @action_value = opt
 end
-opts.on('--qf', '=FILE', 'List the package that owns a file') do |opt|
-  @action = :query_who_owns_file
+opts.on('--ql', '=NAME', 'List the files in a package') do |opt|
+  @action = :query_list_files
   @action_value = opt
 end
-opts.on('--qv', '=NAME', 'List available packages') do |opt|
-  @action = :query_available
+opts.on('--qls', '=NAME', 'List the files in a package on the server') do |opt|
+  @action = :query_list_files_available
   @action_value = opt
 end
-opts.on('--qva', 'List all available packages') do |opt|
-  @action = :query_available
+opts.on('--qf', '=FILE', 'List the package that owns a file') do |opt|
+  @action = :query_who_owns_file
+  @action_value = opt
 end
 opts.on('--qr', '=NAME', 'List installed packages that require package') do |opt|
   @action = :query_requires
   @action_value = opt
 end
-opts.on('--qd', '=NAME', 'List the packages that package depends on') do |opt|
+opts.on('--qd', '=NAME', 'List the packages on which the given package depends') do |opt|
   @action = :query_depends
   @action_value = opt
 end
-opts.on('--qld', '=NAME', 'Similar to --qd, but only look at local packages') do |opt|
-  @action = :query_local_depends
+opts.on('--qds', '=NAME', 'List pkgs on which given package on server depends') do |opt|
+  @action = :query_depends_available
   @action_value = opt
 end
 
 opts.on('--dw', '=INTEGER', 'Number of workers for deploying') do |opt|
   @worker_count = opt.to_i
+  # FIXME: this won't remove options that the user specified as an
+  # abbreviation.  I.e. if the option is --servers and the user specified
+  # --serv (which OptionParser will accept as long as it is unambiguous) this
+  # won't detect and remove it.
   @deploy_params = @deploy_params - ['--dw', @worker_count, "--dw=#{opt}"]
 end
-opts.on('--qX', '=FILENAME', 'Display tpkg.xml or tpkg.yml of the given package') do |opt|
+opts.on('--qX', '=FILENAME', 'Display raw metadata (tpkg.yml) of the given package') do |opt|
   @action = :query_tpkg_metadata
   @action_value = opt
 end
+opts.on('--qXs', '=FILENAME', 'Display raw metadata of given package on the server') do |opt|
+  @action = :query_tpkg_metadata_available
+  @action_value = opt
+end
 opts.on('--history', 'Display package installation history') do |opt|
   @action = :query_history
 end
@@ -237,8 +318,12 @@ end
 opts.on('--base', '=BASE', 'Base directory for tpkg operations') do |opt|
   @tpkg_options[:base] = opt
 end
+opts.on('--extract', '-x', '=DIRECTORY', 'Extract the metadata for a directory of packages') do |opt|
+  @action = :extract
+  @action_value = opt
+end
 opts.on('--source', '=NAME', 'Sources where packages are located', Array) do |opt|
-  @tpkg_options[:sources] = opt
+  @sources = opt
 end
 opts.on('--download', '=PACKAGES', 'Download one or more packages', Array) do |opt|
   @action = :download
@@ -255,7 +340,7 @@ opts.on('--no-sudo', 'No calls to sudo for operations that might need root') do
   @sudo = opt
 end
 opts.on('--lock-force', 'Force the removal of an existing lockfile') do |opt|
-  @lockforce = opt
+  @tpkg_options[:lockforce] = opt
 end
 opts.on('--force-replace', 'Replace conflicting pkgs with the new one(s)') do |opt|
   @other_options[:force_replace] = opt
@@ -263,20 +348,38 @@ end
 opts.on('--force', 'Force the execution of a given task') do |opt|
   @force = opt
 end
-opts.on('-o', '--out', '=DIR', 'Output directory for the -m option') do |opt|
+opts.on('-o', '--out', '=DIR', 'Output directory for the --make option') do |opt|
   @other_options[:out] = opt
 end
+opts.on('--skip-remove-stop', 'Do not run init script stop on package removal') do |opt|
+  @other_options[:skip_remove_stop] = opt
+end
 opts.on('--use-ssh-key [FILE]', 'Use ssh key for deploying instead of password') do |opt|
   @deploy_options["use-ssh-key"] = true
   @deploy_options["ssh-key"] = opt
+  # FIXME: this won't remove options that the user specified as an
+  # abbreviation.  I.e. if the option is --servers and the user specified
+  # --serv (which OptionParser will accept as long as it is unambiguous) this
+  # won't detect and remove it.
   @deploy_params = @deploy_params - ['--use-ssh-key', opt, "--use-ssh-key=#{opt}"]
 end
 opts.on('--deploy-as', '=USERNAME', 'What username to use for deploying to remote server') do |opt|
   @deploy_options["deploy-as"] = opt
+  # FIXME: this won't remove options that the user specified as an
+  # abbreviation.  I.e. if the option is --servers and the user specified
+  # --serv (which OptionParser will accept as long as it is unambiguous) this
+  # won't detect and remove it.
   @deploy_params = @deploy_params - ['--deploy-as']
 end
-opts.on('--compress', '=[TYPE]', 'Compress files when making packages') do |opt|
-  if opt == "no"
+acceptable_compress_arguments = ['gzip', 'bz2', 'no']
+opts.on('--compress [TYPE]',
+        acceptable_compress_arguments,
+        "Compress files when making packages " +
+        "(#{acceptable_compress_arguments.join(',')})") do |opt|
+  # Acceptable 
+  if opt == nil  # No argument specified by user
+    @compress = true
+  elsif opt == "no"
     @compress= false
   else
     @compress = opt
@@ -297,7 +400,14 @@ opts.on_tail("-h", "--help", "Show this message") do
   exit
 end
 
-leftovers = opts.parse(ARGV)
+leftovers = nil
+begin
+  leftovers = opts.parse(ARGV)
+rescue OptionParser::ParseError => e
+  $stderr.puts "Error parsing arguments, try --help"
+  $stderr.puts e.message
+  exit 1
+end
 
 # Rerun with sudo if necessary, unless it's a deploy, then
 # we don't need to run with sudo on this machine. It will run with sudo
@@ -312,69 +422,75 @@ if !@action
   exit
 end
 
+if @groups
+  settings = parse_config_files
+  if settings[:host_group_script]
+    if !File.executable?(settings[:host_group_script])
+      warn "Warning: host group script #{settings[:host_group_script]} is not executable, execution will likely fail"
+    end
+    servers = []
+    @groups.each do |group|
+      IO.popen(settings[:host_group_script]) do |pipe|
+        pipe.each_line do |line|
+          servers << line.chomp
+        end
+      end
+    end
+    servers.uniq!
+    puts "Expanded groups into #{servers.length} servers" if @debug
+    @servers.concat(servers)
+  else
+    abort "No host_group_script defined in config files, can't expand groups"
+  end
+end
+
 #
 # Figure out base directory, sources and other configuration
 #
 
-def instantiate_tpkg(options = {})
-  base = options[:base]
-  sources = options[:sources] || []
-  report_server = nil
+def instantiate_tpkg
+  settings = parse_config_files
   
   # base can come from four possible places.  They take precedence in this
   # order:
   # - command line option
   # - TPKG_HOME environment variable
   # - config file
-  # - Tpkg::DEFAULT_BASE
-  
+  # - Tpkg::DEFAULT_BASE constant defined in tpkg.rb
   if ENV['TPKG_HOME']
-    if !base
-      base = ENV['TPKG_HOME']
+    if !@tpkg_options[:base]
+      @tpkg_options[:base] = ENV['TPKG_HOME']
       # Warn the user, as this could potentially be confusing
       # if they don't realize there's an environment variable set.
-      warn "Using base '#{base}' base from $TPKG_HOME"
+      warn "Using base '#{@tpkg_options[:base]}' base from $TPKG_HOME" if !@quiet
     else
-      warn "Ignoring TPKG_HOME" if @debug
+      warn "Ignoring $TPKG_HOME" if @debug
     end
   end
-  
-  # FIXME: Move config file parsing to tpkg.rb
-  # http://sourceforge.net/apps/trac/tpkg/ticket/28
-  fsroot = options[:file_system_root] ? options[:file_system_root] : ''
-  [File.join(fsroot, Tpkg::DEFAULT_CONFIGDIR, 'tpkg.conf'), File.join(fsroot, ENV['HOME'], ".tpkg.conf")].each do |configfile|
-    if File.exist?(configfile)
-      IO.foreach(configfile) do |line|
-        line.chomp!
-        next if (line =~ /^\s*$/);  # Skip blank lines
-        next if (line =~ /^\s*#/);  # Skip comments
-        line.strip!  # Remove leading/trailing whitespace
-        key, value = line.split(/\s*=\s*/, 2)
-        if key == 'base'
-          if !base
-            # Warn the user, as this could potentially be confusing
-            # if they don't realize there's a config file lying
-            # around
-            base = value
-            warn "Using base #{base} from #{configfile}"
-          else
-            warn "Ignoring 'base' option in #{@configfile}" if @debug
-          end
-        elsif key == 'source'
-          sources << value
-          puts "Loaded source #{value} from #{configfile}" if (@debug)
-        elsif key == 'report_server'
-          report_server = value
-          puts "Loaded report server #{report_server} from #{configfile}" if (@debug)
-        end
-      end
+  if settings[:base]
+    if !@tpkg_options[:base]
+      # Warn the user, as this could potentially be confusing
+      # if they don't realize there's a config file lying
+      # around
+      @tpkg_options[:base] = settings[:base]
+      warn "Using base #{@tpkg_options[:base]} from config file" if !@quiet
+    else
+      warn "Ignoring 'base' option in config file" if @debug
     end
   end
-  
-  if !base
-    base = Tpkg::DEFAULT_BASE
+  if !@tpkg_options[:base]
+    @tpkg_options[:base] = Tpkg::DEFAULT_BASE
   end
   
+  # Sources can come from the command line and config files.  We use the
+  # combined set of sources.
+  @sources.concat(settings[:sources])
+  @tpkg_options[:sources] = @sources
+  
+  @tpkg_options[:report_server] = settings[:report_server]
+  @tpkg_options[:sudo] = @sudo
+  @tpkg_options[:force] = @force
+  
   if !@sudo
     curruid = Process.euid
     if curruid == 0
@@ -383,23 +499,19 @@ def instantiate_tpkg(options = {})
       # modified by other users who properly run --no-sudo as a regular user.
       raise "--no-sudo cannot be used as 'root' user or via sudo"
     end
-    baseuid = File.stat(base).uid
-    # We want to ensure that all --no-sudo usage within a given base directory
-    # is done under the same account.
-    if baseuid != curruid
-      raise "Base dir #{base} owned by UID #{baseuid}, not your UID #{curruid}"
+    fsroot = @tpkg_options[:file_system_root] ? @tpkg_options[:file_system_root] : ''
+    base = File.join(fsroot, @tpkg_options[:base])
+    if File.exist?(base)
+      baseuid = File.stat(base).uid
+      # We want to ensure that all --no-sudo usage within a given base directory
+      # is done under the same account.
+      if baseuid != curruid
+        raise "Base dir #{@tpkg_options[:base]} owned by UID #{baseuid}, not your UID #{curruid}"
+      end
     end
   end
   
-  # FIXME: This is ugly.  We would set the appropriate things in options and
-  # call Tpkg.new(options)
-  tpkg = Tpkg.new(:file_system_root => options[:file_system_root],
-                  :base => base,
-                  :sources => sources,
-                  :report_server => report_server,
-                  :lockforce => @lockforce,
-                  :force => @force,
-                  :sudo => @sudo)
+  tpkg = Tpkg.new(@tpkg_options)
 end
 
 passphrase_callback = lambda do | package |
@@ -466,25 +578,25 @@ when :make
 when :extract
   Tpkg::extract_metadata(@action_value)
 when :install
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
   ret_val = tpkg.install(@action_value, passphrase_callback, @other_options)
 when :upgrade
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
   ret_val = tpkg.upgrade(@action_value, passphrase_callback, @other_options)
 when :remove
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
   ret_val = tpkg.remove(@action_value, @other_options)
 when :download
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
   ret_val = tpkg.download_pkgs(@action_value, @other_options)
 when :verify
   result = nil
   # Verify a given .tpkg file
-  if File.exist?(@action_value)
+  if File.file?(@action_value)
     Tpkg::verify_package_checksum(@action_value)
   # Verify an installed pkg
   else
-    tpkg = instantiate_tpkg(@tpkg_options)
+    tpkg = instantiate_tpkg
     results = tpkg.verify_file_metadata([@action_value])
     if results.length == 0
       puts "No package found"
@@ -501,206 +613,525 @@ when :verify
     puts "Package verification failed" unless success 
   end
 when :execute_init
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
   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)
-  queryreq = nil
+  tpkg = instantiate_tpkg
   matches = []
   if @action_value
-    @action_value.each do | value |
-      queryreq = Tpkg::parse_request(value, tpkg.installed_directory)
-      match = tpkg.installed_packages_that_meet_requirement(queryreq)
-
+    # The --query switch is set to accept multiple values (the "Array"
+    # parameter in the opts.on line for --query) so users can do things like
+    # "tpkg -q foo,bar" to check multiple packages at once.  As such
+    # @action_value is an Array for this switch.
+    requirements = []
+    packages = {}
+    tpkg.parse_requests(@action_value, requirements, packages,
+      :installed_only => true)
+    if packages.values.all? {|pkg| pkg.empty?}
       # If the user requested specific packages and we found no matches
       # then exit with a non-zero value to indicate failure.  This allows
       # command-line syntax like "tpkg -q foo || tpkg -i foo" to ensure
       # that a package is installed.
-      ret_val = 1 if match.empty?
-      matches |= match
+      ret_val = 1
+      $stderr.puts "No packages matching '#{@action_value}' installed" if !@quiet
+    else
+      packages.each do | name, pkgs |
+        matches.concat(pkgs)
+      end
     end
   else
-    matches = tpkg.installed_packages_that_meet_requirement(queryreq)
+    # --qa is implemented by setting @action to :query_installed and
+    # @action_value to nil
+    matches = tpkg.installed_packages_that_meet_requirement
+    if matches.empty?
+      ret_val = 1
+      $stderr.puts "No packages installed" if !@quiet
+    end
   end
-
   if !@quiet
     matches.sort(&Tpkg::SORT_PACKAGES).each do |pkg|
       puts pkg[:metadata][:filename]
     end
   end
 when :query_info
-  metadatas = nil
-  if File.exist?(@action_value)
-    metadatas = [Tpkg::metadata_from_package(@action_value)]
-  else
-    tpkg = instantiate_tpkg(@tpkg_options)
-    metadatas = []
-    requirements = []
-    packages = {}
-    tpkg.parse_requests([@action_value], requirements, packages)
-    packages.each do | name, pkgs |
-      pkgs.each do | pkg |
-        metadatas << pkg[:metadata]
-      end
+  tpkg = instantiate_tpkg
+  requirements = []
+  packages = {}
+  tpkg.parse_requests([@action_value], requirements, packages,
+    :installed_only => true)
+  metadatas = []
+  packages.each do | name, pkgs |
+    pkgs.each do | pkg |
+      metadatas << pkg[:metadata]
     end
   end
+  output_strings = []
   already_displayed = {}
   metadatas.each do |metadata|
     next if already_displayed[metadata[:filename]]
     already_displayed[metadata[:filename]] = true
+    output_string = ''
     [: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(',')}"
+          output_string << "#{field}: #{metadata[field].join(',')}\n"
         else
-          puts "#{field}: #{metadata[field]}"
+          output_string << "#{field}: #{metadata[field]}\n"
         end
       end
     end
+    if metadata[:dependencies]
+      output_string << "(This package depends on other packages, use --qd to view the dependencies)\n"
+    end
+    # Older versions of tpkg did not insert a tpkg_version field into the
+    # package metadata when building packages
     tpkg_version = metadata[:tpkg_version] || "< 1.26.1"
-    puts "This package was built with tpkg version #{tpkg_version}."
-    if metadata[:dependencies] 
-      puts "This package depends on other packages, use --qd/--qld to view the dependencies."
+    output_string << "(This package was built with tpkg version #{tpkg_version})\n"
+    output_strings << output_string
+  end
+  print output_strings.join("================================================================================\n")
+  if already_displayed.empty?
+    ret_val = 1
+    # --qi --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' installed"
+  end
+when :query_info_available
+  tpkg = instantiate_tpkg
+  requirements = []
+  packages = {}
+  tpkg.parse_requests([@action_value], requirements, packages)
+  availpkgs = []
+  packages.each do | name, pkgs |
+    availpkgs.concat(pkgs)
+  end
+  available = availpkgs.select do |pkg|
+    pkg[:source] != :native_installed &&
+    pkg[:source] != :native_available &&
+    pkg[:source] != :currently_installed
+  end
+  if available.empty?
+    ret_val = 1
+    # --qis --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' available"
+  else
+    metadatas = available.collect {|avail| avail[:metadata]}
+    output_strings = []
+    already_displayed = {}
+    metadatas.each do |metadata|
+      next if already_displayed[metadata[:filename]]
+      already_displayed[metadata[:filename]] = true
+      output_string = ''
+      [: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)
+            output_string << "#{field}: #{metadata[field].join(',')}\n"
+          else
+            output_string << "#{field}: #{metadata[field]}\n"
+          end
+        end
+      end
+      if metadata[:dependencies]
+        output_string << "(This package depends on other packages, use --qd to view the dependencies)\n"
+      end
+      # Older versions of tpkg did not insert a tpkg_version field into the
+      # package metadata when building packages
+      tpkg_version = metadata[:tpkg_version] || "< 1.26.1"
+      output_string << "(This package was built with tpkg version #{tpkg_version})\n"
+      output_strings << output_string
     end
-    puts "================================================================================"
+    print output_strings.join("================================================================================\n")
   end
 when :query_list_files
-  tpkg = instantiate_tpkg(@tpkg_options)
-  pkgfiles = nil
-  if File.exist?(@action_value)
-    fipfile = Tpkg::files_in_package(@action_value)
-    tpkg.normalize_paths(fipfile)
-    puts "#{@action_value}:"
-    fipfile[:normalized].each { |file| puts file }
+  tpkg = instantiate_tpkg
+  requirements = []
+  packages = {}
+  tpkg.parse_requests([@action_value], requirements, packages,
+    :installed_only => true)
+  if packages.values.all? {|pkg| pkg.empty?}
+    ret_val = 1
+    # --ql --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' installed"
   else
-    pkgfiles = []
-    metadatas = []
-    requirements = []
-    packages = {}
-
-    queryreq = Tpkg::parse_request(@action_value)
-    instpkgs = tpkg.installed_packages_that_meet_requirement(queryreq)
-    if instpkgs.nil? or instpkgs.empty?
-      ret_val = 1
-      puts "Could not find any installed packages that meet the request \"#{@action_value}\""
-    end
-    instpkgs.each do | pkg |
-      pkgfiles << pkg[:metadata][:filename] 
+    # For this switch we need separate handling for installed and uninstalled
+    # packages.  For installed packages we know where their relocatable files
+    # ended up and can give the user regular paths.  For uninstalled packaages
+    # we don't know what base will be used when the package is installed, so
+    # we need to indicate to the user that their are relocatable files and
+    # just display their path relative to the eventual base directory.
+    ci_pkgfiles = []
+    packages.each do | name, pkgs |
+      pkgs.each do | pkg |
+        if pkg[:source] == :currently_installed
+          ci_pkgfiles << pkg[:metadata][:filename]
+        else
+          puts "#{pkg[:source]}:"
+          fip = Tpkg.files_in_package(pkg[:source])
+          fip[:root].each { |file| puts file }
+          fip[:reloc].each { |file| puts '<relocatable>/' + file }
+        end
+      end
     end
-
-    files = tpkg.files_for_installed_packages(pkgfiles)
+    files = tpkg.files_for_installed_packages(ci_pkgfiles)
     files.each do |pkgfile, fip|
       puts "#{pkgfile}:"
       fip[:normalized].each { |file| puts file }
     end
   end
+when :query_list_files_available
+  tpkg = instantiate_tpkg
+  requirements = []
+  packages = {}
+  tpkg.parse_requests([@action_value], requirements, packages)
+  availpkgs = []
+  packages.each do | name, pkgs |
+    availpkgs.concat(pkgs)
+  end
+  available = availpkgs.select do |pkg|
+    pkg[:source] != :native_installed &&
+    pkg[:source] != :native_available &&
+    pkg[:source] != :currently_installed
+  end
+  if available.empty?
+    ret_val = 1
+    # --qls --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' available"
+  else
+    downloaddir = Tpkg::tempdir('download')
+    available.each do |pkg|
+      # FIXME: I've duplicated from the install and upgrade methods this logic
+      # to calculate pkgfile, it should be encapsulated in a method
+      pkgfile = nil
+      if File.file?(pkg[:source])
+        pkgfile = pkg[:source]
+      elsif File.directory?(pkg[:source])
+        pkgfile = File.join(pkg[:source], pkg[:metadata][:filename])
+      else
+        pkgfile = download(pkg[:source], pkg[:metadata][:filename], downloaddir)
+      end
+      puts "#{pkg[:metadata][:filename]}:"
+      fip = Tpkg.files_in_package(pkgfile)
+      fip[:root].each { |file| puts file }
+      fip[:reloc].each { |file| puts '<relocatable>/' + file }
+    end
+    FileUtils.rm_rf(downloaddir)
+  end
 when :query_who_owns_file
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
+  owned = false
+  expanded_file = File.expand_path(@action_value)
   tpkg.files_for_installed_packages.each do |pkgfile, fip|
     fip[:normalized].each do |file|
-      if file == File.expand_path(@action_value)
+      if file == expanded_file
         puts "#{file}: #{pkgfile}"
+        owned = true
       end
     end
   end
+  if !owned
+    ret_val = 1
+    # --qf --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No package owns file '#{@action_value}'"
+  end
 when :query_available
-  tpkg = instantiate_tpkg(@tpkg_options)
-  queryreq = nil
+  tpkg = instantiate_tpkg
+  availpkgs = []
   if @action_value
-    queryreq = Tpkg::parse_request(@action_value)
+    # The --qs switch is set to accept multiple values (the "Array"
+    # parameter in the opts.on line for --qs) so users can do things like
+    # "tpkg --qs foo,bar" to check multiple packages at once.  As such
+    # @action_value is an Array for this switch.
+    requirements = []
+    packages = {}
+    tpkg.parse_requests(@action_value, requirements, packages)
+    packages.each do | name, pkgs |
+      availpkgs.concat(pkgs)
+    end
+  else
+    # --qas is implemented by setting @action to :query_available and
+    # @action_value to nil
+    availpkgs.concat(tpkg.available_packages_that_meet_requirement)
   end
-  tpkg.available_packages_that_meet_requirement(queryreq).each do |pkg|
-    next if pkg[:source] == :native_installed
-    next if pkg[:source] == :native_available
-    puts "#{pkg[:metadata][:filename]} (#{pkg[:source]})"
+  available = availpkgs.select do |pkg|
+    pkg[:source] != :native_installed &&
+    pkg[:source] != :native_available &&
+    # The tpkg library treats currently installed packages as "available"
+    # because they are available to meet a user's requirement.  I.e. if the
+    # user asks to install ruby and a ruby package is already installed that
+    # satisfies the user's requirement even if there's no ruby package in any
+    # of the sources.  But for these query options I think the reasonable
+    # interpretation is that the user would like to know if there's a package
+    # in a source that could be installed.  For example, if the user queries
+    # for the availability of ruby and we show it as available because it is
+    # installed, but then they go to another machine with the same sources
+    # defined and try to install ruby and it fails because there is no ruby in
+    # any of the sources I think the user is likely to find that unexpected
+    # and annoying.
+    pkg[:source] != :currently_installed
+  end
+  if available.empty?
+    ret_val = 1
+    if !@quiet
+      if @action_value
+        $stderr.puts "No packages matching '#{@action_value}' available"
+      else
+        $stderr.puts "No packages available"
+      end
+    end
+  else
+    if !@quiet
+      available.sort(&Tpkg::SORT_PACKAGES).each do |pkg|
+        puts "#{pkg[:metadata][:filename]} (#{pkg[:source]})"
+      end
+    end
   end
 when :query_requires
-  tpkg = instantiate_tpkg(@tpkg_options)
-
-  # parse the request
+  tpkg = instantiate_tpkg
+  
+  # Parse the request
   requirements = [] 
   packages = {}
-  tpkg.parse_requests([@action_value], requirements, packages)
-
-  # get dependencies of all installed packages
+  tpkg.parse_requests([@action_value], requirements, packages,
+    :installed_only => true)
+  
+  # Note that we don't stop here in the case of this switch, but continue to
+  # check if anything depends on the package the user asked about.  There
+  # shouldn't be a situation where there's another package installed that
+  # depends on the package the user is asking about, but the user's package is
+  # not installed.  I.e. if foo depends on bar but only foo is installed and
+  # the user asks what depends on bar, the answer is still foo.  That
+  # information might be useful to the user, even though that situation should
+  # have been avoided in the first place.  Broken dependency trees due to
+  # manually messing with the repo, using --force, etc. can happen and the
+  # user may be using the --qr option just because they're trying to sort out
+  # a mess.
+  if packages.values.all? {|pkg| pkg.empty?}
+    ret_val = 1
+    # --qr --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' installed"
+  end
+  
+  # Get dependencies of all installed packages
   dependencies = {}
   tpkg.metadata_for_installed_packages.each do |metadata|
     dependencies[metadata[:filename]] = metadata[:dependencies]
   end
-
-  # check to see if the any required dependencies match with what the
-  # user specified in the request
+  
+  # Check to see if any dependencies match with what the user specified in the
+  # request
+  requirees = {}
   packages.each do |name, pkgs|
     pkgs.each do |pkg|
       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}"
+            pkgfilename = pkg[:metadata][:filename]
+            if !requirees[pkgfilename]
+              requirees[pkgfilename] = []
+            end
+            requirees[pkgfilename] << requiree
           end
         end
       end
     end
   end
-when :query_local_depends
-  tpkg = instantiate_tpkg(@tpkg_options)
-  queryreq = Tpkg::parse_request(@action_value)
-  instpkgs = tpkg.installed_packages_that_meet_requirement(queryreq)
-  instpkgs.each do | pkg |
-    puts pkg[:metadata][:filename] + ':'
-    if pkg[:metadata][:dependencies]
-      pkg[:metadata][:dependencies].each do |req|
-        puts "  Requires #{req[:name]}"
-        req.each do |field, value|
-          next if field == :name
-          puts "    #{field}: #{value}"
-         end
-       end
+  
+  if !requirees.empty?
+    requirees.keys.sort.each do |pkgfilename|
+      puts "The following package(s) require #{pkgfilename}:"
+      # uniq probably isn't necessary, but it can't hurt
+      requirees[pkgfilename].sort.uniq.each do |requiree|
+        puts "  #{requiree}"
+      end
     end
+  else
+    puts "No other package depends on '#{@action_value}'"
   end
 when :query_depends
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
+  
+  requirements = []
+  packages = {}
+  tpkg.parse_requests([@action_value], requirements, packages,
+    :installed_only => true)
+  
+  if packages.values.all? {|pkg| pkg.empty?}
+    ret_val = 1
+    # --qd --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' installed"
+  else
+    depends = {}
+    packages.each do |name, pkgs|
+      pkgs.each do |pkg|
+        if pkg[:metadata][:dependencies]
+          pkgfilename = pkg[:metadata][:filename]
+          if !depends[pkgfilename]
+            depends[pkgfilename] = []
+          end
+          pkg[:metadata][:dependencies].each do |req|
+            depends[pkgfilename] << req
+          end
+        end
+      end
+    end
+    
+    if !depends.empty?
+      outputs = []
+      depends.keys.sort.each do |pkgfilename|
+        output = "Package #{pkgfilename} depends on:\n"
+        # uniq probably isn't necessary, but it can't hurt
+        outs = []
+        depends[pkgfilename].sort{|a,b| a[:name]<=>b[:name]}.uniq.each do |req|
+          out = "  name: #{req[:name]}\n"
+          req.each do |field, value|
+            next if field == 'name'
+            out << "  #{field}: #{value}\n"
+          end
+          outs << out
+        end
+        outputs << output + outs.join("\n")
+      end
+      print outputs.join("\n")
+    else
+      puts "Package '#{@action_value}' does not depend on other packages"
+    end
+  end
+when :query_depends_available
+  tpkg = instantiate_tpkg
   requirements = []
   packages = {}
   tpkg.parse_requests([@action_value], requirements, packages)
-  packages.each do |name, pkgs|
-    already_displayed = {}
-    pkgs.each do |pkg|
-      # parse_requests returns both installed and available packages.
-      # The same package may show up in both, skip any duplicates.
-      next if already_displayed[pkg[:filename]]
-      already_displayed[pkg[:metadata][:filename]] = true
-      puts pkg[:metadata][:filename] + ':'
+  availpkgs = []
+  packages.each do | name, pkgs |
+    availpkgs.concat(pkgs)
+  end
+  available = availpkgs.select do |pkg|
+    pkg[:source] != :native_installed &&
+    pkg[:source] != :native_available &&
+    pkg[:source] != :currently_installed
+  end
+  
+  if available.empty?
+    ret_val = 1
+    # --qds --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' available"
+  else
+    depends = {}
+    available.each do |pkg|
       if pkg[:metadata][:dependencies]
+        pkgfilename = pkg[:metadata][:filename]
+        if !depends[pkgfilename]
+          depends[pkgfilename] = []
+        end
         pkg[:metadata][:dependencies].each do |req|
-          puts "  Requires #{req[:name]}"
+          depends[pkgfilename] << req
+        end
+      end
+    end
+    
+    if !depends.empty?
+      outputs = []
+      depends.keys.sort.each do |pkgfilename|
+        output = "Package #{pkgfilename} depends on:\n"
+        # uniq probably isn't necessary, but it can't hurt
+        outs = []
+        depends[pkgfilename].sort{|a,b| a[:name]<=>b[:name]}.uniq.each do |req|
+          out = "  name: #{req[:name]}\n"
           req.each do |field, value|
-            next if field == :name
-            puts "    #{field}: #{value}"
+            next if field == 'name'
+            out << "  #{field}: #{value}\n"
           end
+          outs << out
         end
+        outputs << output + outs.join("\n")
       end
+      print outputs.join("\n")
+    else
+      puts "Package '#{@action_value}' does not depend on other packages"
     end
   end
 when :query_tpkg_metadata
-  tpkg = instantiate_tpkg(@tpkg_options)
-  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))
+  tpkg = instantiate_tpkg
+  requirements = []
+  packages = {}
+  tpkg.parse_requests([@action_value], requirements, packages,
+    :installed_only => true)
+  
+  if packages.values.all? {|pkg| pkg.empty?}
+    ret_val = 1
+    # --qX --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' installed"
   else
-    puts "File #{@action_value} doesn't exist."
+    packages.each do | name, pkgs |
+      pkgs.each do | pkg |
+        pkgfile = nil
+        if pkg[:source] == :currently_installed
+          pkgfile = File.join(tpkg.installed_directory, pkg[:metadata][:filename])
+        else
+          pkgfile = pkg[:source]
+        end
+        puts Tpkg::extract_tpkg_metadata_file(pkgfile)
+      end
+    end
+  end
+when :query_tpkg_metadata_available
+  tpkg = instantiate_tpkg
+  requirements = []
+  packages = {}
+  tpkg.parse_requests([@action_value], requirements, packages)
+  availpkgs = []
+  packages.each do | name, pkgs |
+    availpkgs.concat(pkgs)
+  end
+  available = availpkgs.select do |pkg|
+    pkg[:source] != :native_installed &&
+    pkg[:source] != :native_available &&
+    pkg[:source] != :currently_installed
+  end
+  
+  if available.empty?
+    ret_val = 1
+    # --qXs --quiet doesn't seem like a meaningful combination, so I'm not
+    # suppressing this for @quiet
+    $stderr.puts "No packages matching '#{@action_value}' available"
+  else
+    downloaddir = Tpkg::tempdir('download')
+    available.each do |pkg|
+      # FIXME: I've duplicated from the install and upgrade methods this logic
+      # to calculate pkgfile, it should be encapsulated in a method
+      pkgfile = nil
+      if File.file?(pkg[:source])
+        pkgfile = pkg[:source]
+      elsif File.directory?(pkg[:source])
+        pkgfile = File.join(pkg[:source], pkg[:metadata][:filename])
+      else
+        pkgfile = download(pkg[:source], pkg[:metadata][:filename], downloaddir)
+      end
+      puts Tpkg::extract_tpkg_metadata_file(pkgfile)
+    end
+    FileUtils.rm_rf(downloaddir)
   end
 when :query_env
   puts "Operating System: #{Tpkg::get_os}"
   puts "Architecture: #{Tpkg::get_arch}"
+  puts "Tar: #{Tpkg::find_tar}"
 when :query_conf
   # This is somewhat arbitrarily limited to the options read from the
   # tpkg.conf config files.  The reason it exists at all is that it is
@@ -708,12 +1139,12 @@ when :query_conf
   # without recreating all of our logic about deciding which config files to
   # read, which order to read them in, what environment variables override the
   # config files, etc.
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
   puts "Base: #{tpkg.base}"
   puts "Sources: #{tpkg.sources.inspect}"
   puts "Report server: #{tpkg.report_server}"
 when :query_history
-  tpkg = instantiate_tpkg(@tpkg_options)
+  tpkg = instantiate_tpkg
   tpkg.installation_history
 when :query_version
   puts Tpkg::VERSION