microwave 0.1006.33 → 1.0.0

data/lib/chef/provider/execute.rb

@@ -1,67 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'chef/mixin/shell_out'
-require 'chef/log'
-require 'chef/provider'
-
-class Chef
-  class Provider
-    class Execute < Chef::Provider
-
-      include Chef::Mixin::ShellOut
-
-      def load_current_resource
-        true
-      end
-
-      def action_run
-        opts = {}
-
-        if sentinel_file = @new_resource.creates
-          if ::File.exists?(sentinel_file)
-            Chef::Log.debug("#{@new_resource} sentinel file #{sentinel_file} exists - nothing to do")
-            return false
-          end
-        end
-
-        # original implementation did not specify a timeout, but ShellOut
-        # *always* times out. So, set a very long default timeout
-        opts[:timeout] = @new_resource.timeout || 3600
-        opts[:returns] = @new_resource.returns if @new_resource.returns
-        opts[:environment] = @new_resource.environment if @new_resource.environment
-        opts[:user] = @new_resource.user if @new_resource.user
-        opts[:group] = @new_resource.group if @new_resource.group
-        opts[:cwd] = @new_resource.cwd if @new_resource.cwd
-        opts[:umask] = @new_resource.umask if @new_resource.umask
-        opts[:command_log_level] = :info
-        opts[:command_log_prepend] = @new_resource.to_s
-        if STDOUT.tty? && Chef::Log.info?
-          opts[:live_stream] = STDOUT
-        end
-
-        Chef::Log.debug "Executing: #{@new_resource.command} #{$testrun}"
-        result = $testrun || shell_out!(@new_resource.command, opts)
-        @new_resource.updated_by_last_action(true)
-        Chef::Log.info("#{@new_resource} ran successfully")
-      end
-
-    end
-  end
-end
-

data/lib/chef/provider/file.rb

@@ -1,213 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'chef/config'
-require 'chef/log'
-require 'chef/resource/file'
-require 'chef/mixin/checksum'
-require 'chef/provider'
-require 'etc'
-require 'fileutils'
-
-class Chef
-  class Provider
-    class File < Chef::Provider
-      include Chef::Mixin::Checksum
-
-      def negative_complement(big)
-        if big > 1073741823 # Fixnum max
-          big -= (2**32) # diminished radix wrap to negative
-        end
-        big
-      end
-
-      def octal_mode(mode)
-        ((mode.respond_to?(:oct) ? mode.oct : mode.to_i) & 007777)
-      end
-
-      private :negative_complement, :octal_mode
-
-      def load_current_resource
-        @current_resource = Chef::Resource::File.new(@new_resource.name)
-        @new_resource.path.gsub!(/\\/, "/") # for Windows
-        @current_resource.path(@new_resource.path)
-        if ::File.exist?(@current_resource.path) && ::File.readable?(@current_resource.path)
-          cstats = ::File.stat(@current_resource.path)
-          @current_resource.owner(cstats.uid)
-          @current_resource.group(cstats.gid)
-          @current_resource.mode(octal_mode(cstats.mode))
-        end
-        @current_resource
-      end
-
-      # Compare the content of a file.  Returns true if they are the same, false if they are not.
-      def compare_content
-        checksum(@current_resource.path) == new_resource_content_checksum
-      end
-
-      # Set the content of the file, assuming it is not set correctly already.
-      def set_content
-        unless compare_content
-          backup @new_resource.path if ::File.exists?(@new_resource.path)
-          ::File.open(@new_resource.path, "w") {|f| f.write @new_resource.content }
-          Chef::Log.info("#{@new_resource} contents updated")
-          @new_resource.updated_by_last_action(true)
-        end
-      end
-
-      # Compare the ownership of a file.  Returns true if they are the same, false if they are not.
-      def compare_owner
-        return false if @new_resource.owner.nil?
-
-        @set_user_id = case @new_resource.owner
-        when /^\d+$/, Integer
-          @new_resource.owner.to_i
-        else
-          # This raises an ArgumentError if you can't find the user
-          Etc.getpwnam(@new_resource.owner).uid
-        end
-
-        @set_user_id == @current_resource.owner
-      end
-
-      # Set the ownership on the file, assuming it is not set correctly already.
-      def set_owner
-        unless compare_owner
-          @set_user_id = negative_complement(@set_user_id)
-          ::File.chown(@set_user_id, nil, @new_resource.path)
-          Chef::Log.info("#{@new_resource} owner changed to #{@set_user_id}")
-          @new_resource.updated_by_last_action(true)
-        end
-      end
-
-      # Compares the group of a file.  Returns true if they are the same, false if they are not.
-      def compare_group
-        return false if @new_resource.group.nil?
-
-        @set_group_id = case @new_resource.group
-        when /^\d+$/, Integer
-          @new_resource.group.to_i
-        else
-          Etc.getgrnam(@new_resource.group).gid
-        end
-
-        @set_group_id == @current_resource.group
-      end
-
-      def set_group
-        unless compare_group
-          @set_group_id = negative_complement(@set_group_id)
-          ::File.chown(nil, @set_group_id, @new_resource.path)
-          Chef::Log.info("#{@new_resource} group changed to #{@set_group_id}")
-          @new_resource.updated_by_last_action(true)
-        end
-      end
-
-      def compare_mode
-        case @new_resource.mode
-        when /^\d+$/, Integer
-          octal_mode(@new_resource.mode) == octal_mode(@current_resource.mode)
-        else
-          false
-        end
-      end
-
-      def set_mode
-        unless compare_mode && @new_resource.mode != nil
-          # CHEF-174, bad mojo around treating integers as octal.  If a string is passed, we try to do the "right" thing
-          ::File.chmod(octal_mode(@new_resource.mode), @new_resource.path)
-          Chef::Log.info("#{@new_resource} mode changed to #{sprintf("%o" % octal_mode(@new_resource.mode))}")
-          @new_resource.updated_by_last_action(true)
-        end
-      end
-
-      def action_create
-        assert_enclosing_directory_exists!
-        unless ::File.exists?(@new_resource.path)
-          ::File.open(@new_resource.path, "w+") {|f| f.write @new_resource.content }
-          @new_resource.updated_by_last_action(true)
-          Chef::Log.info("#{@new_resource} created file #{@new_resource.path}")
-        else
-          set_content unless @new_resource.content.nil?
-        end
-        set_owner unless @new_resource.owner.nil?
-        set_group unless @new_resource.group.nil?
-        set_mode unless @new_resource.mode.nil?
-      end
-
-      def action_create_if_missing
-        if ::File.exists?(@new_resource.path)
-          Chef::Log.debug("File #{@new_resource.path} exists, taking no action.")
-        else
-          action_create
-        end
-      end
-
-      def action_delete
-        if ::File.exists?(@new_resource.path)
-          if ::File.writable?(@new_resource.path)
-            backup unless ::File.symlink?(@new_resource.path)
-            ::File.delete(@new_resource.path)
-            Chef::Log.info("#{@new_resource} deleted file at #{@new_resource.path}")
-            @new_resource.updated_by_last_action(true)
-          else
-            raise "Cannot delete #{@new_resource} at #{@new_resource_path}!"
-          end
-        end
-      end
-
-      def action_touch
-        action_create
-        time = Time.now
-        ::File.utime(time, time, @new_resource.path)
-        Chef::Log.info("#{@new_resource} updated atime and mtime to #{time}")
-        @new_resource.updated_by_last_action(true)
-      end
-
-      def backup(file=nil)
-        file ||= @new_resource.path
-        if @new_resource.backup != false && @new_resource.backup > 0 && ::File.exist?(file)
-          time = Time.now
-          backup_filename = @new_resource.path
-          # if :file_backup_path is nil, we fallback to the old behavior of
-          # keeping the backup in the same directory. We also need to to_s it
-          # so we don't get a type error around implicit to_str conversions.
-          prefix = Chef::Config[:file_backup_path].to_s
-          backup_path = ::File.join(prefix, backup_filename)
-          FileUtils.mkdir_p(::File.dirname(backup_path)) if Chef::Config[:file_backup_path]
-          FileUtils.cp(file, backup_path, :preserve => true)
-          Chef::Log.info("#{@new_resource} backed up to #{backup_path}")
-        end
-      end
-
-      private
-
-      def assert_enclosing_directory_exists!
-        enclosing_dir = ::File.dirname(@new_resource.path)
-        unless ::File.directory?(enclosing_dir)
-          msg = "Cannot create a file at #{@new_resource.path} because the enclosing directory (#{enclosing_dir}) does not exist"
-          raise Chef::Exceptions::EnclosingDirectoryDoesNotExist, msg
-        end
-      end
-
-      def new_resource_content_checksum
-        @new_resource.content && Digest::SHA2.hexdigest(@new_resource.content)
-      end
-    end
-  end
-end

data/lib/chef/provider/link.rb

@@ -1,164 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'chef/config'
-require 'chef/log'
-require 'chef/mixin/shell_out'
-require 'chef/resource/link'
-require 'chef/provider'
-
-class Chef
-  class Provider
-    class Link < Chef::Provider
-      include Chef::Mixin::ShellOut
-      #include Chef::Mixin::Command
-
-      def negative_complement(big)
-        if big > 1073741823 # Fixnum max
-          big -= (2**32) # diminished radix wrap to negative
-        end
-        big
-      end
-
-      private :negative_complement
-
-      def load_current_resource
-        @current_resource = Chef::Resource::Link.new(@new_resource.name)
-        @current_resource.target_file(@new_resource.target_file)
-        @current_resource.link_type(@new_resource.link_type)
-        if @new_resource.link_type == :symbolic
-          if ::File.exists?(@current_resource.target_file) && ::File.symlink?(@current_resource.target_file)
-            @current_resource.to(
-              ::File.expand_path(::File.readlink(@current_resource.target_file))
-            )
-            cstats = ::File.lstat(@current_resource.target_file)
-            @current_resource.owner(cstats.uid)
-            @current_resource.group(cstats.gid)
-          else
-            @current_resource.to("")
-          end
-        elsif @new_resource.link_type == :hard
-          if ::File.exists?(@current_resource.target_file) && ::File.exists?(@new_resource.to)
-            if ::File.stat(@current_resource.target_file).ino == ::File.stat(@new_resource.to).ino
-              @current_resource.to(@new_resource.to)
-            else
-              @current_resource.to("")
-            end
-          else
-            @current_resource.to("")
-          end
-        end
-        @current_resource
-      end
-
-      # Compare the ownership of a symlink.  Returns true if they are the same, false if they are not.
-      def compare_owner
-        return false if @new_resource.owner.nil?
-
-        @set_user_id = case @new_resource.owner
-                       when /^\d+$/, Integer
-                         @new_resource.owner.to_i
-                       else
-                         # This raises an ArgumentError if you can't find the user
-                         Etc.getpwnam(@new_resource.owner).uid
-                       end
-
-        @set_user_id == @current_resource.owner
-      end
-
-      # Set the ownership on the symlink, assuming it is not set correctly already.
-      def set_owner
-        unless compare_owner
-          @set_user_id = negative_complement(@set_user_id)
-          ::File.lchown(@set_user_id, nil, @new_resource.target_file)
-          Chef::Log.info("#{@new_resource} owner changed to #{@set_user_id}")
-          @new_resource.updated_by_last_action(true)
-        end
-      end
-
-      # Compares the group of a symlink.  Returns true if they are the same, false if they are not.
-      def compare_group
-        return false if @new_resource.group.nil?
-
-        @set_group_id = case @new_resource.group
-                        when /^\d+$/, Integer
-                          @new_resource.group.to_i
-                        else
-                          Etc.getgrnam(@new_resource.group).gid
-                        end
-
-        @set_group_id == @current_resource.group
-      end
-
-      def set_group
-        unless compare_group
-          @set_group_id = negative_complement(@set_group_id)
-          ::File.lchown(nil, @set_group_id, @new_resource.target_file)
-          Chef::Log.info("#{@new_resource} group changed to #{@set_group_id}")
-          @new_resource.updated_by_last_action(true)
-        end
-      end
-
-      def action_create
-        if @current_resource.to != ::File.expand_path(@new_resource.to, @new_resource.target_file)
-          if @new_resource.link_type == :symbolic
-            unless (::File.symlink?(@new_resource.target_file) && ::File.readlink(@new_resource.target_file) == @new_resource.to)
-              if ::File.symlink?(@new_resource.target_file) || ::File.exist?(@new_resource.target_file)
-                ::File.unlink(@new_resource.target_file)
-              end
-              ::File.symlink(@new_resource.to,@new_resource.target_file)
-              Chef::Log.debug("#{@new_resource} created #{@new_resource.link_type} link from #{@new_resource.to} -> #{@new_resource.target_file}")
-              Chef::Log.info("#{@new_resource} created")
-            end
-          elsif @new_resource.link_type == :hard
-            ::File.link(@new_resource.to, @new_resource.target_file)
-            Chef::Log.debug("#{@new_resource} created #{@new_resource.link_type} link from #{@new_resource.to} -> #{@new_resource.target_file}")
-            Chef::Log.info("#{@new_resource} created")
-          end
-          @new_resource.updated_by_last_action(true)
-        end
-        if @new_resource.link_type == :symbolic
-          set_owner unless @new_resource.owner.nil?
-          set_group unless @new_resource.group.nil?
-        end
-      end
-
-      def action_delete
-        if @new_resource.link_type == :symbolic
-          if ::File.symlink?(@new_resource.target_file)
-            ::File.delete(@new_resource.target_file)
-            Chef::Log.info("#{@new_resource} deleted")
-            @new_resource.updated_by_last_action(true)
-          elsif ::File.exists?(@new_resource.target_file)
-            raise Chef::Exceptions::Link, "Cannot delete #{@new_resource} at #{@new_resource.target_file}! Not a symbolic link."
-          end
-        elsif @new_resource.link_type == :hard
-          if ::File.exists?(@new_resource.target_file)
-             if ::File.exists?(@new_resource.to) && ::File.stat(@current_resource.target_file).ino == ::File.stat(@new_resource.to).ino
-               ::File.delete(@new_resource.target_file)
-               Chef::Log.info("#{@new_resource} deleted")
-               @new_resource.updated_by_last_action(true)
-             else
-               raise Chef::Exceptions::Link, "Cannot delete #{@new_resource} at #{@new_resource.target_file}! Not a hard link."
-             end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/chef/provider/package/yum-dump.py

@@ -1,286 +0,0 @@
-#
-# Author:: Matthew Kent (<mkent@magoazul.com>)
-# Copyright:: Copyright (c) 2009, 2011 Matthew Kent
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-# 
-#     http://www.apache.org/licenses/LICENSE-2.0
-# 
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# yum-dump.py
-# Inspired by yumhelper.py by David Lutterkort
-#
-# Produce a list of installed, available and re-installable packages using yum
-# and dump the results to stdout.
-#
-# yum-dump invokes yum similarly to the command line interface which makes it
-# subject to most of the configuration paramaters in yum.conf. yum-dump will
-# also load yum plugins in the same manor as yum - these can affect the output.
-#
-# Can be run as non root, but that won't update the cache.
-#
-# Intended to support yum 2.x and 3.x
-
-import os
-import sys
-import time
-import yum
-import re
-import errno
-
-from yum import Errors
-from optparse import OptionParser
-from distutils import version
-
-YUM_PID_FILE='/var/run/yum.pid'
-
-# Seconds to wait for exclusive access to yum
-LOCK_TIMEOUT = 10
-
-YUM_VER = version.StrictVersion(yum.__version__)
-YUM_MAJOR = YUM_VER.version[0]
-
-if YUM_MAJOR > 3 or YUM_MAJOR < 2:
-  print >> sys.stderr, "yum-dump Error: Can't match supported yum version" \
-    " (%s)" % yum.__version__
-  sys.exit(1)
-
-# Required for Provides output
-if YUM_MAJOR == 2:
-  import rpm
-  import rpmUtils.miscutils
-
-def setup(yb, options):
-  # Only want our output
-  #
-  if YUM_MAJOR == 3:
-    try:
-      if YUM_VER >= version.StrictVersion("3.2.22"):
-        yb.preconf.errorlevel=0
-        yb.preconf.debuglevel=0
-
-        # initialize the config
-        yb.conf
-      else:
-        yb.doConfigSetup(errorlevel=0, debuglevel=0)
-    except yum.Errors.ConfigError, e:
-      # supresses an ignored exception at exit
-      yb.preconf = None
-      print >> sys.stderr, "yum-dump Config Error: %s" % e
-      return 1
-    except ValueError, e:
-      yb.preconf = None
-      print >> sys.stderr, "yum-dump Options Error: %s" % e
-      return 1
-  elif YUM_MAJOR == 2:
-    yb.doConfigSetup()
-
-    def __log(a,b): pass
-
-    yb.log = __log
-    yb.errorlog = __log
-
-  # Give Chef every possible package version, it can decide what to do with them
-  if YUM_MAJOR == 3:
-    yb.conf.showdupesfromrepos = True
-  elif YUM_MAJOR == 2:
-    yb.conf.setConfigOption('showdupesfromrepos', True)
-
-  # Optionally run only on cached repositories, but non root must use the cache
-  if os.geteuid() != 0:
-    if YUM_MAJOR == 3:
-      yb.conf.cache = True
-    elif YUM_MAJOR == 2:
-      yb.conf.setConfigOption('cache', True)
-  else:
-    if YUM_MAJOR == 3:
-      yb.conf.cache = options.cache
-    elif YUM_MAJOR == 2:
-      yb.conf.setConfigOption('cache', options.cache)
-
-  return 0
-
-def dump_packages(yb, list, output_provides):
-  packages = {}
-
-  if YUM_MAJOR == 2:
-    yb.doTsSetup()
-    yb.doRepoSetup()
-    yb.doSackSetup()
-
-  db = yb.doPackageLists(list)
-
-  for pkg in db.installed:
-    pkg.type = 'i'
-    packages[str(pkg)] = pkg
-
-  if YUM_VER >= version.StrictVersion("3.2.21"):
-    for pkg in db.available:
-      pkg.type = 'a'
-      packages[str(pkg)] = pkg
-
-    # These are both installed and available
-    for pkg in db.reinstall_available:
-      pkg.type = 'r'
-      packages[str(pkg)] = pkg
-  else:
-    # Old style method - no reinstall list
-    for pkg in yb.pkgSack.returnPackages():
-
-      if str(pkg) in packages:
-        if packages[str(pkg)].type == "i":
-          packages[str(pkg)].type = 'r'
-          continue
-
-      pkg.type = 'a'
-      packages[str(pkg)] = pkg
-
-  unique_packages = packages.values()
-
-  unique_packages.sort(lambda x, y: cmp(x.name, y.name))
-
-  for pkg in unique_packages:
-    if output_provides == "all" or \
-        (output_provides == "installed" and (pkg.type == "i" or pkg.type == "r")):
-
-      # yum 2 doesn't have provides_print, implement it ourselves using methods
-      # based on requires gathering in packages.py
-      if YUM_MAJOR == 2:
-        provlist = []
-
-        # Installed and available are gathered in different ways
-        if pkg.type == 'i' or pkg.type == 'r':
-          names = pkg.hdr[rpm.RPMTAG_PROVIDENAME]
-          flags = pkg.hdr[rpm.RPMTAG_PROVIDEFLAGS]
-          ver = pkg.hdr[rpm.RPMTAG_PROVIDEVERSION]
-          if names is not None:
-            tmplst = zip(names, flags, ver)
-
-          for (n, f, v) in tmplst:
-            prov = rpmUtils.miscutils.formatRequire(n, v, f)
-            provlist.append(prov)
-        # This is slow :(
-        elif pkg.type == 'a':
-          for prcoTuple in pkg.returnPrco('provides'):
-              prcostr = pkg.prcoPrintable(prcoTuple)
-              provlist.append(prcostr)
-
-        provides = provlist
-      else:
-        provides = pkg.provides_print
-    else:
-      provides = "[]"
-
-    print '%s %s %s %s %s %s %s' % (
-      pkg.name,
-      pkg.epoch,
-      pkg.version,
-      pkg.release,
-      pkg.arch,
-      provides,
-      pkg.type )
-
-  return 0
-
-def yum_dump(options):
-  lock_obtained = False
-
-  yb = yum.YumBase()
-
-  status = setup(yb, options)
-  if status != 0:
-    return status
-
-  if options.output_options:
-    print "[option installonlypkgs] %s" % " ".join(yb.conf.installonlypkgs)
-
-  # Non root can't handle locking on rhel/centos 4
-  if os.geteuid() != 0:
-    return dump_packages(yb, options.package_list, options.output_provides)
-
-  # Wrap the collection and output of packages in yum's global lock to prevent
-  # any inconsistencies.
-  try:
-    # Spin up to LOCK_TIMEOUT
-    countdown = LOCK_TIMEOUT
-    while True:
-      try:
-        yb.doLock(YUM_PID_FILE)
-        lock_obtained = True
-      except Errors.LockError, e:
-        time.sleep(1)
-        countdown -= 1
-        if countdown == 0:
-           print >> sys.stderr, "yum-dump Locking Error! Couldn't obtain an " \
-             "exclusive yum lock in %d seconds. Giving up." % LOCK_TIMEOUT
-           return 200
-      else:
-        break
-
-    return dump_packages(yb, options.package_list, options.output_provides)
-
-  # Ensure we clear the lock and cleanup any resources
-  finally:
-    try:
-      yb.closeRpmDB()
-      if lock_obtained == True:
-        yb.doUnlock(YUM_PID_FILE)
-    except Errors.LockError, e:
-      print >> sys.stderr, "yum-dump Unlock Error: %s" % e
-      return 200
-
-def main():
-  usage = "Usage: %prog [options]\n" + \
-          "Output a list of installed, available and re-installable packages via yum"
-  parser = OptionParser(usage=usage)
-  parser.add_option("-C", "--cache",
-                    action="store_true", dest="cache", default=False,
-                    help="run entirely from cache, don't update cache")
-  parser.add_option("-o", "--options",
-                    action="store_true", dest="output_options", default=False,
-                    help="output select yum options useful to Chef")
-  parser.add_option("-p", "--installed-provides",
-                    action="store_const", const="installed", dest="output_provides", default="none",
-                    help="output Provides for installed packages, big/wide output")
-  parser.add_option("-P", "--all-provides",
-                    action="store_const", const="all", dest="output_provides", default="none",
-                    help="output Provides for all package, slow, big/wide output")
-  parser.add_option("-i", "--installed",
-                    action="store_const", const="installed", dest="package_list", default="all",
-                    help="output only installed packages")
-  parser.add_option("-a", "--available",
-                    action="store_const", const="available", dest="package_list", default="all",
-                    help="output only available and re-installable packages")
-
-  (options, args) = parser.parse_args()
-
-  try:
-    return yum_dump(options)
-
-  except yum.Errors.RepoError, e:
-    print >> sys.stderr, "yum-dump Repository Error: %s" % e
-    return 1
-
-  except yum.Errors.YumBaseError, e:
-    print >> sys.stderr, "yum-dump General Error: %s" % e
-    return 1
-
-try:
-  status = main()
-# Suppress a nasty broken pipe error when output is piped to utilities like 'head'
-except IOError, e:
-  if e.errno == errno.EPIPE:
-    sys.exit(1)
-  else:
-    raise
-
-sys.exit(status)