Current File : //usr/lib/python2.7/site-packages/salt/modules/pkgng.pyc
�
���^c @@ s d Z d d l m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l Z
d d l Z
d d l Z
d d l
Z
d d l Z
d d l Z
d d l Z
d d l m Z m Z d d l m Z e j e � Z d Z d � Z d d d d � Z d d d d � Z d
� Z d d d d d � Z d
d � Z d � Z! e
j" j# j$ e! d � Z% d d d e& d � Z' e
j" j# j$ e' d � Z( d � Z) e
j" j# j$ e) d � Z* e& d d d e& d � Z+ d � Z, e& e& d d d d � Z- d d d d � Z. d d d d � Z/ d d d d � Z0 d d d d d d d e& e& e& e& e& e& e& e& e& e& d � Z1 d d d d d e& e& e& e& e& e& e& d � Z2 e
j" j# j$ e2 d � Z3 e
j" j# j$ e2 d � Z4 d � Z5 d d d e& e& d � Z6 d d d e& d! � Z7 d d d e& e& e& d" � Z8 d d d e& e& d# � Z9 d d d e& e& e& e& e& e& e& e& e& e& e& e& d$ � Z: d d d e& e& d e; e& e& e& e& d% � Z< d d d d d d& � Z= d d d' � Z> d d d( � Z? d) � Z@ d* � ZA d+ � ZB d, � ZC d d- � ZD e; d. � ZE d/ � ZF e& d0 � ZG d S(1 us
Support for ``pkgng``, the new package manager for FreeBSD
.. important::
If you feel that Salt should be using this module to manage packages on a
minion, and it is using a different module (or gives an error similar to
*'pkg.install' is not available*), see :ref:`here
<module-provider-override>`.
.. warning::
This module has been completely rewritten. Up to and including version
0.17.x, it was available as the ``pkgng`` module, (``pkgng.install``,
``pkgng.delete``, etc.), but moving forward this module will no longer be
available as ``pkgng``, as it will behave like a normal Salt ``pkg``
provider. The documentation below should not be considered to apply to this
module in versions <= 0.17.x. If your minion is running a 0.17.x release or
older, then the documentation for this module can be viewed using the
:mod:`sys.doc <salt.modules.sys.doc>` function:
.. code-block:: bash
salt bsdminion sys.doc pkgng
This module provides an interface to ``pkg(8)``. It acts as the default
package provider for FreeBSD 10 and newer. For FreeBSD hosts which have
been upgraded to use pkgng, you will need to override the ``pkg`` provider
by setting the :conf_minion:`providers` parameter in your Minion config
file, in order to use this module to manage packages, like so:
.. code-block:: yaml
providers:
pkg: pkgng
i ( t absolute_importt print_functiont unicode_literalsN( t CommandExecutionErrort MinionError( t sixu pkgc C@ s� t d d k r t St d d k r> t t d � d k r> t St d d k r� t t d � d k r� i } d t k r� t d } n t j d
| � | r� d | k r� | d d k r� t j d
� t Sn t d f S( u�
Load as 'pkg' on FreeBSD 10 and greater.
Load as 'pkg' on DragonFly BSD.
Load as 'pkg' on FreeBSD 9 when config option
``providers:pkg`` is set to 'pkgng'.
u kernelu DragonFlyu osu FreeBSDu osreleasei
u osmajorreleasei u providersu __opts__.providers: %su pkgu pkgngu_ Configuration option 'providers:pkg' is set to 'pkgng', using 'pkgng' in favor of 'freebsdpkg'.uw The pkgng execution module cannot be loaded: only available on FreeBSD 10 or FreeBSD 9 with providers.pkg set to pkgng.( t
__grains__t __virtualname__t floatt intt __opts__t logt debugt False( t providers( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt __virtual__@ s &&
"
c C@ sa d g } | r% | j d | g � n8 | rA | j d | g � n | r] | j d | g � n | S( ur
Returns the prefix for a pkg command, using -j if a jail is specified, or
-c if chroot is specified.
u pkgu -ju -cu -r( t extend( t jailt chroott roott ret( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt _pkgY s c C@ s- t | | | � d g } t d | � j � S( u%
return the version of 'pkg'
u --versionu cmd.run( R t __salt__t strip( R R R t cmd( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt _get_pkgng_versionh s c C@ sv xo t j j j | d � D]U } | s+ q n y | j d d � \ } } Wn t k
r] q n X| | k r | Sq Wd S( u�
``pkg search`` will return all packages for which the pattern is a match.
Narrow this down and return the package version, or None if no exact match.
u
u -i N( t saltt utilst itertoolst splitt rsplitt
ValueErrort None( t namet resultst linet pkgnamet pkgver( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt _get_versionp s
u
pkg.list_pkgsc C@ sd | r t j | � d j | � S| r@ t j | � d j | � S| r` t j | � d j | � S| S( u�
As this module is designed to manipulate packages in jails and chroots, use
the passed jail/chroot to ensure that a key in the __context__ dict that is
unique to that jail/chroot is used.
u .jail_{0}u .chroot_{0}u .root_{0}( R t text_typet format( R R R t prefix( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt _contextkey� s u /usr/local/etc/pkg.confc C@ s� i } t j j | � s% d j | � St j j j | � �m } xc | D][ } t j j j | � } | j
d � s� | j
d � r� qD | j d � \ } } | | | <qD WWd QX| | d <| S( u�
Return dict of uncommented global variables.
CLI Example:
.. code-block:: bash
salt '*' pkg.parse_config
``NOTE:`` not working properly right now
u! Unable to find {0} on file systemu #u
u Nu config_file( t ost patht isfileR( R R t filest fopent stringutilst
to_unicodet
startswithR ( t file_nameR t ifileR# t keyt value( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt parse_config� s
c O@ s� | j d t � } t d | | � } t j j j | � s> | St | � d k rd i | | d 6} n t j d i � } t
g t j | � D]2 \ } } | i | j | d � d 6| d 6f ^ q� � S( u#
Returns a string representing the package version or an empty string if not
installed. If more than one package name is specified, a dict of
name/version pairs is returned.
.. note::
This function can accessed using ``pkg.info`` in addition to
``pkg.version``, to more closely match the CLI usage of ``pkg(8)``.
jail
Get package version information for the specified jail
chroot
Get package version information for the specified chroot (ignored if
``jail`` is specified)
root
Get package version information for the specified root (ignored if
``jail`` is specified)
with_origin : False
Return a nested dictionary containing both the origin name and version
for each specified package.
.. versionadded:: 2014.1.0
CLI Example:
.. code-block:: bash
salt '*' pkg.version <package name>
salt '*' pkg.version <package name> jail=<jail name or id>
salt '*' pkg.version <package1> <package2> <package3> ...
u with_originu pkg_resource.versioni i u
pkg.originu u originu version(
t popR
R R R t datat is_truet lent __context__t gett dictR t iteritems( t namest kwargst with_originR t originst xt y( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt version� s %u infoc C@ sb t j j j t � t | | | � } | j d � | rH | j d � n t d | d t �d k S( uF
Refresh PACKAGESITE contents
.. note::
This function can accessed using ``pkg.update`` in addition to
``pkg.refresh_db``, to more closely match the CLI usage of ``pkg(8)``.
CLI Example:
.. code-block:: bash
salt '*' pkg.refresh_db
jail
Refresh the pkg database within the specified jail
chroot
Refresh the pkg database within the specified chroot (ignored if
``jail`` is specified)
root
Refresh the pkg database within the specified root (ignored if
``jail`` is specified)
force
Force a full download of the repository catalog without regard to the
respective ages of the local and remote copies of the catalog.
CLI Example:
.. code-block:: bash
salt '*' pkg.refresh_db force=True
u updateu -fu cmd.retcodet python_shelli ( R R t pkgt
clear_rtagR
R t appendR R
( R R R t forceR ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt
refresh_db� s %
u updatec
@ s2 t | � d k r d Si } x | D] } d | | <q# W| j d � } | j d � } | j d � } | j d � } t d t d | d | d
| � } t j j j t | | | � d d � r� t } n t } xC| D];} d
| k r� t
| | | � d g }
n( t
| | | � d d d d d d g }
| r=|
j d � n t j j j
| � sb|
j d � n |
j | � t | t t d |
d t d d �j � d t �j d � � � � d k r� | j | g � } | s�� | | <q t � f d � | D� � s � | | <q q� q� Wt | � d k r.| | d S| S( u,
Return the latest version of the named package available for upgrade or
installation. If more than one package name is specified, a dict of
name/version pairs is returned.
If the latest version of a given package is already installed, an empty
string will be returned for that package.
CLI Example:
.. code-block:: bash
salt '*' pkg.latest_version <package name>
salt '*' pkg.latest_version <package name> jail=<jail name or id>
salt '*' pkg.latest_version <package name> chroot=/path/to/chroot
i u u jailu chrootu refreshu roott versions_as_listR R R u >=u 1.6.0u /u searchu -Su nameu -Qu versionu -eu -qu -Uu cmd.runRG t output_loglevelu tracet reversec 3@ s3 | ]) } t j j j d | d d d � � Vq d S( t ver1t operu >=t ver2N( R R t versionst compare( t .0RD ( R% ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pys <genexpr>Q s i N( R; R= t list_pkgst TrueR R RS RT R R
R RJ R9 R: R& t sortedR t
splitlinesR8 R t any( R@ RA R R! R R t refreshR t pkgst quietR t installed( ( R% s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt latest_version sN
!'
(
"
u available_versionc K@ s� t g d D]$ } t j j j | j | � � ^ q
� r; i St j j j | � } t | | | � } t | | | d d �} | t k r't j t | � } | s� t
d | � n t j j j | � r#t j | i � }
t g t j
| � D]2 \ } } | i |
j | d � d 6| d 6f ^ q� � S| Si } i }
t
d t | | | � d
d g d d
d t �} x� t j j j | d � D]u }
|
s�q~n y. |
j � \ } } | j d d � \ } } Wn t k
r�q~n Xt
d | | | � | |
| <q~Wt
d | � t j | � t | <|
t | <| s9t
d | � n t j j j | � r�t g t j
| � D]2 \ } } | i |
j | d � d 6| d 6f ^ qa� S| S( u�
List the packages currently installed as a dict::
{'<package_name>': '<version>'}
jail
List the packages in the specified jail
chroot
List the packages in the specified chroot (ignored if ``jail`` is
specified)
root
List the packages in the specified root (ignored if ``jail`` is
specified)
with_origin : False
Return a nested dictionary containing both the origin name and version
for each installed package.
.. versionadded:: 2014.1.0
CLI Example:
.. code-block:: bash
salt '*' pkg.list_pkgs
salt '*' pkg.list_pkgs jail=<jail name or id>
salt '*' pkg.list_pkgs chroot=/path/to/chroot
u removedu
purge_desiredR) u
pkg.originu pkg_resource.stringifyu u originu versionu cmd.run_stdoutu infou -aoRN u traceRG u
u -i u pkg_resource.add_pkgu pkg_resource.sort_pkglist( u removedu
purge_desired( RZ R R R9 R: R= R* R< t copyt deepcopyR R> R R? R R
R R R R ( RM R R R RB RA RD t contextkey_pkgt contextkey_originsR RC RE t outR# RH t originR$ R% ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyRV b sT %1 F
Fc C@ s. t � d } t d | d d j | � � t S( u�
Updates remote package repo URL, PACKAGESITE var to be exact.
Must use ``http://``, ``ftp://``, or ``https://`` protocol
CLI Example:
.. code-block:: bash
salt '*' pkg.update_package_site http://127.0.0.1/
u config_fileu file.sedu
PACKAGESITE.*u PACKAGESITE : {0}( R7 R R( RW ( t new_urlt config_file( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt update_package_site� s
c C@ s� d } | r | d 7} n | r, | d 7} n t | | | � } | j d � | re | j d | � n t d | d d d t �} g t j j j | d
� D] } | j d � ^ q� S( u�
Return pkgng stats.
CLI Example:
.. code-block:: bash
salt '*' pkg.stats
local
Display stats only for the local package database.
CLI Example:
.. code-block:: bash
salt '*' pkg.stats local=True
remote
Display stats only for the remote package database(s).
CLI Example:
.. code-block:: bash
salt '*' pkg.stats remote=True
jail
Retrieve stats from the specified jail.
CLI Example:
.. code-block:: bash
salt '*' pkg.stats jail=<jail name or id>
salt '*' pkg.stats jail=<jail name or id> local=True
salt '*' pkg.stats jail=<jail name or id> remote=True
chroot
Retrieve stats from the specified chroot (ignored if ``jail`` is
specified).
root
Retrieve stats from the specified root (ignored if ``jail`` is
specified).
CLI Example:
.. code-block:: bash
salt '*' pkg.stats chroot=/path/to/chroot
salt '*' pkg.stats chroot=/path/to/chroot local=True
salt '*' pkg.stats chroot=/path/to/chroot remote=True
u u lu ru statsu -u cmd.runRN u traceRG u
u ( R RJ R R
R R R R R ( t localt remoteR R R t optsR Rd RD ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt stats� s 8
c C@ sF t d t | | | � d d | g d d d t �} | j d � d S( u8
Export installed packages into yaml+mtree file
CLI Example:
.. code-block:: bash
salt '*' pkg.backup /tmp/pkg
jail
Backup packages from the specified jail. Note that this will run the
command within the jail, and so the path to the backup file will be
relative to the root of the jail
CLI Example:
.. code-block:: bash
salt '*' pkg.backup /tmp/pkg jail=<jail name or id>
chroot
Backup packages from the specified chroot (ignored if ``jail`` is
specified). Note that this will run the command within the chroot, and
so the path to the backup file will be relative to the root of the
chroot.
root
Backup packages from the specified root (ignored if ``jail`` is
specified). Note that this will run the command within the root, and
so the path to the backup file will be relative to the root of the
root.
CLI Example:
.. code-block:: bash
salt '*' pkg.backup /tmp/pkg chroot=/path/to/chroot
u cmd.runu backupu -dRN u traceRG u ...i ( R R R
R ( R3 R R R R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt backup s
' c C@ s3 t d t | | | � d d | g d d d t �S( u�
Reads archive created by pkg backup -d and recreates the database.
CLI Example:
.. code-block:: bash
salt '*' pkg.restore /tmp/pkg
jail
Restore database to the specified jail. Note that this will run the
command within the jail, and so the path to the file from which the pkg
database will be restored is relative to the root of the jail.
CLI Example:
.. code-block:: bash
salt '*' pkg.restore /tmp/pkg jail=<jail name or id>
chroot
Restore database to the specified chroot (ignored if ``jail`` is
specified). Note that this will run the command within the chroot, and
so the path to the file from which the pkg database will be restored is
relative to the root of the chroot.
root
Restore database to the specified root (ignored if ``jail`` is
specified). Note that this will run the command within the root, and
so the path to the file from which the pkg database will be restored is
relative to the root of the root.
CLI Example:
.. code-block:: bash
salt '*' pkg.restore /tmp/pkg chroot=/path/to/chroot
u cmd.runu backupu -rRN u traceRG ( R R R
( R3 R R R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt restoreC s ' c C@ s0 t d t | | | � d d g d d d t �S( uj
Audits installed packages against known vulnerabilities
CLI Example:
.. code-block:: bash
salt '*' pkg.audit
jail
Audit packages within the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.audit jail=<jail name or id>
chroot
Audit packages within the specified chroot (ignored if ``jail`` is
specified)
root
Audit packages within the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.audit chroot=/path/to/chroot
u cmd.runu auditu -FRN u traceRG ( R R R
( R R R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt auditq s ! c " K@ sw y# t d | | | | � \ } } Wn t k
rD } t | � � n X| d- k sc t | � d k rg i Si } d } t j j j | � r� | d 7} n t j j j | � r� | d 7} n t j j j | � r� | d 7} n t j j j |
� r� | d 7} n t j j j | � r | d 7} n t j j j | � r?| d 7} n t j j j |
� ra| d
7} n t j j j | � r�| d 7} n t j j j | � r�| d 7} n t j j j | � r�i d
d 6d d 6} n t d | d | d | � } | d k r5d } d j
g | D] } | d k r | ^ q � } | } n� | d k r�d } | d- k r�| j d � r�t | � d k r�i | j d � | 6} n g } xa t j
| � D]A \ } } | d- k r�| j | � q�| j d j | | � � q�Wn t d � � t | | | � } | j | � | r2| j d | g � n | rL| j d | � n | j | � | d k r�t j j j | � r�d j
| � St d! | d" d# d$ t d% | �} | d& d k r�| d' r�| d' g } n g } t j t | | | � d- � t j t | | | d( d) �d- � t d | d | d | � } t j j j | | � }! | rst d d* i | d+ 6|! d, 6�� n |! S(. u7
Install package(s) from a repository
name
The name of the package to install
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name>
jail
Install the package into the specified jail
chroot
Install the package into the specified chroot (ignored if ``jail`` is
specified)
root
Install the package into the specified root (ignored if ``jail`` is
specified)
orphan
Mark the installed package as orphan. Will be automatically removed
if no other packages depend on them. For more information please
refer to ``pkg-autoremove(8)``.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> orphan=True
force
Force the reinstallation of the package if already installed.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> force=True
glob
Treat the package names as shell glob patterns.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> glob=True
local
Do not update the repository catalogs with ``pkg-update(8)``. A
value of ``True`` here is equivalent to using the ``-U`` flag with
``pkg install``.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> local=True
dryrun
Dru-run mode. The list of changes to packages is always printed,
but no changes are actually made.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> dryrun=True
quiet
Force quiet output, except when dryrun is used, where pkg install
will always show packages to be installed, upgraded or deleted.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> quiet=True
reinstall_requires
When used with force, reinstalls any packages that require the
given package.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> reinstall_requires=True force=True
.. versionchanged:: 2014.7.0
``require`` kwarg renamed to ``reinstall_requires``
fromrepo
In multi-repo mode, override the pkg.conf ordering and only attempt
to download packages from the named repository.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> fromrepo=repo
regex
Treat the package names as a regular expression
CLI Example:
.. code-block:: bash
salt '*' pkg.install <regular expression> regex=True
pcre
Treat the package names as extended regular expressions.
CLI Example:
.. code-block:: bash
batch
Use BATCH=true for pkg install, skipping all questions.
Be careful when using in production.
CLI Example:
.. code-block:: bash
salt '*' pkg.install <package name> batch=True
u pkg_resource.parse_targetsi u yu Au fu gu Uu nu qu Ru xu Xu trueu BATCHu YESu ASSUME_ALWAYS_YESR R R u fileu addu u AfIMqu
repositoryu installu versioni u {0}-{1}u) Problem encountered installing package(s)u -ru -u u cmd.run_allRN u traceRG t envu retcodeu stderrR) u
pkg.origint infou errorsu changesN( R R R R R; R R R9 R: RV t joinR= R R? RJ R( R R R
R< R8 R* t
compare_dicts(" R! t fromrepoR\ t sourcesR R R t orphanRK t globRi t dryrunR] t reinstall_requirest regext pcret batchRA t
pkg_paramst pkg_typet excRp Rk t oldt pkg_cmdt optt targetst paramt version_numR Rd t errorst newR ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt install� s� �
. -
!
"c
K@ sZ ~ y t d | | � d }
Wn t k
r? } t | � � n Xg } t d | d | d | d t � } x� |
j � D]� } | d j d � d k r� | d } g t j | � D]" \ } } | d | k r� | ^ q� d } n | d | k rt | j | d � qt qt W| si Sd } t
j j j
| � r6| d
7} n t
j j j
| � rX| d 7} n t
j j j
| � rz| d 7} n t
j j j
| � r�| d
7} n t
j j j
| � s�| d 7} n t
j j j
| � r�| d 7} n t
j j j
|
� r| d 7} n t
j j j
| � r$| d 7} n t | | | � } | j d � | r]| j d | � n | j | � t d | d d d t �} | d d k r�| d r�| d g } n g } t j t | | | � d � t j t | | | d d �d � t d | d | d | d t � } t
j j j | | � } | rVt d d i | d 6| d 6�� n | S(! u!
Remove a package from the database and system
.. note::
This function can accessed using ``pkg.delete`` in addition to
``pkg.remove``, to more closely match the CLI usage of ``pkg(8)``.
name
The package to remove
CLI Example:
.. code-block:: bash
salt '*' pkg.remove <package name>
jail
Delete the package from the specified jail
chroot
Delete the package from the specified chroot (ignored if ``jail`` is
specified)
root
Delete the package from the specified root (ignored if ``jail`` is
specified)
all_installed
Deletes all installed packages from the system and empties the
database. USE WITH CAUTION!
CLI Example:
.. code-block:: bash
salt '*' pkg.remove all all_installed=True force=True
force
Forces packages to be removed despite leaving unresolved
dependencies.
CLI Example:
.. code-block:: bash
salt '*' pkg.remove <package name> force=True
glob
Treat the package names as shell glob patterns.
CLI Example:
.. code-block:: bash
salt '*' pkg.remove <package name> glob=True
dryrun
Dry run mode. The list of packages to delete is always printed, but
no packages are actually deleted.
CLI Example:
.. code-block:: bash
salt '*' pkg.remove <package name> dryrun=True
recurse
Delete all packages that require the listed package as well.
CLI Example:
.. code-block:: bash
salt '*' pkg.remove <package name> recurse=True
regex
Treat the package names as regular expressions.
CLI Example:
.. code-block:: bash
salt '*' pkg.remove <regular expression> regex=True
pcre
Treat the package names as extended regular expressions.
CLI Example:
.. code-block:: bash
salt '*' pkg.remove <extended regular expression> pcre=True
u pkg_resource.parse_targetsi R R R RB u /u originu u au fu gu nu yu Ru xu Xu deleteu -u cmd.run_allRN u traceRG u retcodeu stderrR) u
pkg.originu' Problem encountered removing package(s)Rq u errorsu changesN( R R R RV RW t itemst findR R? RJ R R R9 R: R R R
R< R8 R* R Rs ( R! R\ R R R t
all_installedRK Rw Rx t recurseRz R{ RA R} R R� R� RH Re t kt vRk R Rd R� R� R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt remove� sj k!
?
"!u deleteu purgec O@ s� | j d d � } | j d d � } | j d d � } | j d t � } | j d t � } | j d t � } | j d g � } d } | r� | d 7} n | r� | d
7} n | r� | d 7} n | s� | d 7} n t | | | � }
|
j d
� | r |
j d | � n | r |
j | � n | r5|
j | � n t � } t d |
d d d t �} t j t | | | � d � t j t | | | d d �d � t � }
t
j j j
| |
� } | d d k r�t d d i | d 6| d 6�� n | S( u
Upgrade named or all packages (run a ``pkg upgrade``). If <package name> is
omitted, the operation is executed on all packages.
Returns a dictionary containing the changes:
.. code-block:: python
{'<package>': {'old': '<old-version>',
'new': '<new-version>'}}
CLI Example:
.. code-block:: bash
salt '*' pkg.upgrade <package name>
jail
Audit packages within the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.upgrade <package name> jail=<jail name or id>
chroot
Audit packages within the specified chroot (ignored if ``jail`` is
specified)
root
Audit packages within the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.upgrade <package name> chroot=/path/to/chroot
Any of the below options can also be used with ``jail`` or ``chroot``.
force
Force reinstalling/upgrading the whole set of packages.
CLI Example:
.. code-block:: bash
salt '*' pkg.upgrade <package name> force=True
local
Do not update the repository catalogs with ``pkg-update(8)``. A value
of ``True`` here is equivalent to using the ``-U`` flag with ``pkg
upgrade``.
CLI Example:
.. code-block:: bash
salt '*' pkg.upgrade <package name> local=True
dryrun
Dry-run mode: show what packages have updates available, but do not
perform any upgrades. Repository catalogs will be updated as usual
unless the local option is also given.
CLI Example:
.. code-block:: bash
salt '*' pkg.upgrade <package name> dryrun=True
u jailu chrootu rootu forceu localu dryrunu pkgsu u fu Lu nu yu upgradeu -u cmd.run_allRN u traceRG R) u
pkg.originu retcodei u& Problem encountered upgrading packagesRq u changesu resultN( R8 R R
R RJ R RV R R< R* R R R9 Rs R ( R@ RA R R R RK Ri Rx R\ Rk R R� t resultR� R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt upgradeG sJ L
" c C@ s� d } | r | d 7} n | r, | d 7} n
| d 7} t | | | � } | j d � | ro | j d | � n t d | d d d
t �S( uA
Cleans the local cache of fetched remote packages
CLI Example:
.. code-block:: bash
salt '*' pkg.clean
jail
Cleans the package cache in the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.clean jail=<jail name or id>
chroot
Cleans the package cache in the specified chroot (ignored if ``jail``
is specified)
root
Cleans the package cache in the specified root (ignored if ``jail``
is specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.clean chroot=/path/to/chroot
clean_all
Clean all packages from the local cache (not just those that have been
superseded by newer versions).
CLI Example:
.. code-block:: bash
salt '*' pkg.clean clean_all=True
dryrun
Dry-run mode. This list of changes to the local cache is always
printed, but no changes are actually made.
CLI Example:
.. code-block:: bash
salt '*' pkg.clean dryrun=True
u u au nu yu cleanu -u cmd.runRN u traceRG ( R RJ R R
( R R R t clean_allRx Rk R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt clean� s 9
c C@ sv d } | r | d 7} n
| d 7} t | | | � } | j d � | r\ | j d | � n t d | d d d t �S(
u�
Delete packages which were automatically installed as dependencies and are
not required anymore.
dryrun
Dry-run mode. The list of changes to packages is always printed,
but no changes are actually made.
CLI Example:
.. code-block:: bash
salt '*' pkg.autoremove
salt '*' pkg.autoremove jail=<jail name or id>
salt '*' pkg.autoremove dryrun=True
salt '*' pkg.autoremove jail=<jail name or id> dryrun=True
u u nu yu
autoremoveu -u cmd.runRN u traceRG ( R RJ R R
( R R R Rx Rk R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt
autoremove s
c C@ s� t | | | f � s d Sd } | r2 | d 7} n | rE | d 7} n | rX | d 7} n t | | | � } | j d � | r� | j d | � n t d | d d
d t �S( uO
Sanity checks installed packages
jail
Perform the sanity check in the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.check jail=<jail name or id>
chroot
Perform the sanity check in the specified chroot (ignored if ``jail``
is specified)
root
Perform the sanity check in the specified root (ignored if ``jail``
is specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.check chroot=/path/to/chroot
Of the below, at least one must be set to ``True``.
depends
Check for and install missing dependencies.
CLI Example:
.. code-block:: bash
salt '*' pkg.check recompute=True
recompute
Recompute sizes and checksums of installed packages.
CLI Example:
.. code-block:: bash
salt '*' pkg.check depends=True
checksum
Find invalid checksums for installed packages.
CLI Example:
.. code-block:: bash
salt '*' pkg.check checksum=True
u: One of depends, recompute, or checksum must be set to Trueu u dyu ru su checku -u cmd.runRN u traceRG ( RZ R RJ R R
( R R R t dependst recomputet checksumRk R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt check. s" >
c C@ s� d } | r | d 7} n | r, | d 7} n t | | | � } | j d � | re | j d | � n | j | � t d | d d d t �S(
u�
Displays which package installed a specific file
CLI Example:
.. code-block:: bash
salt '*' pkg.which <file name>
jail
Perform the check in the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.which <file name> jail=<jail name or id>
chroot
Perform the check in the specified chroot (ignored if ``jail`` is
specified)
root
Perform the check in the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.which <file name> chroot=/path/to/chroot
origin
Shows the origin of the package instead of name-version.
CLI Example:
.. code-block:: bash
salt '*' pkg.which <file name> origin=True
quiet
Quiet output.
CLI Example:
.. code-block:: bash
salt '*' pkg.which <file name> quiet=True
u u qu ou whichu -u cmd.runRN u traceRG ( R RJ R R
( R, R R R Re R] Rk R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt which� s 4
c C@ sJ d } | r | d 7} n | r, | d 7} n | r? | d 7} n | rR | d 7} n | re | d 7} n | rx | d 7} n |
r� | d 7} n | r� | d 7} n | r� | d
7} n |
r� | d 7} n | r� | d 7} n | r� | d
7} n t | | | � } | j d � | r#| j d | � n | j | � t d | d d d t �S( u�
Searches in remote package repositories
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern
jail
Perform the search using the ``pkg.conf(5)`` from the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern jail=<jail name or id>
chroot
Perform the search using the ``pkg.conf(5)`` from the specified chroot
(ignored if ``jail`` is specified)
root
Perform the search using the ``pkg.conf(5)`` from the specified root
(ignored if ``jail`` is specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern chroot=/path/to/chroot
exact
Treat pattern as exact pattern.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern exact=True
glob
Treat pattern as a shell glob pattern.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern glob=True
regex
Treat pattern as a regular expression.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern regex=True
pcre
Treat pattern as an extended regular expression.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern pcre=True
comment
Search for pattern in the package comment one-line description.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern comment=True
desc
Search for pattern in the package description.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern desc=True
full
Displays full information about the matching packages.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern full=True
depends
Displays the dependencies of pattern.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern depends=True
size
Displays the size of the package
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern size=True
quiet
Be quiet. Prints only the requested information without displaying
many hints.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern quiet=True
origin
Displays pattern origin.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern origin=True
prefix
Displays the installation prefix for each package matching pattern.
CLI Example:
.. code-block:: bash
salt '*' pkg.search pattern prefix=True
u u eu gu xu Xu cu Du fu du su qu ou pu searchu -u cmd.runRN u traceRG ( R RJ R R
( R! R R R t exactRw Rz R{ t commentt desct fullR� t sizeR] Re R) Rk R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt search� sD �
c C@ s
d } | r | d 7} n | r, | d 7} n | r? | d 7} n | rR | d 7} n | re | d 7} n |
rx | d 7} n | r� | d 7} n t | | | � }
|
j d d
g � | r� |
j d | g � n | r� |
j d | � n |
j | � t d
|
d d d t �S( u:
Fetches remote packages
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name>
jail
Fetch package in the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> jail=<jail name or id>
chroot
Fetch package in the specified chroot (ignored if ``jail`` is
specified)
root
Fetch package in the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> chroot=/path/to/chroot
fetch_all
Fetch all packages.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> fetch_all=True
quiet
Quiet mode. Show less output.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> quiet=True
fromrepo
Fetches packages from the given repo if multiple repo support
is enabled. See ``pkg.conf(5)``.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> fromrepo=repo
glob
Treat pkg_name as a shell glob pattern.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> glob=True
regex
Treat pkg_name as a regular expression.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <regular expression> regex=True
pcre
Treat pkg_name is an extended regular expression.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <extended regular expression> pcre=True
local
Skip updating the repository catalogs with pkg-update(8). Use the
local cache only.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> local=True
depends
Fetch the package and its dependencies as well.
CLI Example:
.. code-block:: bash
salt '*' pkg.fetch <package name> depends=True
u u au qu gu xu Xu Lu du fetchu -yu -ru -u cmd.runRN u traceRG ( R R RJ R R
( R! R R R t fetch_allR] Rt Rw Rz R{ Ri R� Rk R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt fetch� s4 v
c C@ s� d } | r" | d j | � 7} n | r> | d j | � 7} n t | | | � } | j d � | rw | j d | � n | j | � t d | d d d t �S(
u� '
Displays UPDATING entries of software packages
CLI Example:
.. code-block:: bash
salt '*' pkg.updating foo
jail
Perform the action in the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.updating foo jail=<jail name or id>
chroot
Perform the action in the specified chroot (ignored if ``jail`` is
specified)
root
Perform the action in the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.updating foo chroot=/path/to/chroot
filedate
Only entries newer than date are shown. Use a YYYYMMDD date format.
CLI Example:
.. code-block:: bash
salt '*' pkg.updating foo filedate=20130101
filename
Defines an alternative location of the UPDATING file.
CLI Example:
.. code-block:: bash
salt '*' pkg.updating foo filename=/tmp/UPDATING
u u d {0}u f {0}u updatingu -u cmd.runRN u traceRG ( R( R RJ R R
( R! R R R t filedatet filenameRk R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt updating s 9
c K@ s� g } | r | j | � n
| j | � i } xT| D]L} t | t � rc t t j | � � } n i | d 6i d 6t d 6d d 6| | <t | | � sWd t k r� t d r� | | j
d d � d j | � | | d <q�t
| | � r=| | j
d t � d j | � | | d <d
| | d d <d | | d d <q�d
j | � | | d <q6 | | j
d t � d j | � | | d <q6 W| S( u�
Version-lock packages
.. note::
This function is provided primarily for compatibilty with some
parts of :py:mod:`states.pkg <salt.states.pkg>`.
Consider using Consider using :py:func:`pkg.lock <salt.modules.pkgng.lock>` instead. instead.
name
The name of the package to be held.
Multiple Package Options:
pkgs
A list of packages to hold. Must be passed as a python list. The
``name`` parameter will be ignored if this option is passed.
Returns a dict containing the changes.
CLI Example:
.. code-block:: bash
salt '*' pkg.hold <package name>
salt '*' pkg.hold pkgs='["foo", "bar"]'
u nameu changesu resultu u commentu testR� u Package {0} is set to be held.u Package {0} is now being held.u holdu newu oldu" Package {0} was unable to be held.u& Package {0} is already set to be held.N( R RJ t
isinstanceR> t nextR t iterkeysR
t lockedR
t updateR R( t lockRW ( R! R\ RA R� R t target( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt holdk s:
c K@ s~ g } | r | j | � n
| j | � i } xH| D]@} t | t � rc t t j | � � } n i | d 6i d 6t d 6d d 6| | <t | | � rKt d r� | | j
d d � d j | � | | d <qvt
| | � r1| | j
d t � d j | � | | d <d | | d d
<d | | d d <qvd
j | � | | d <q6 | | j
d t � d j | � | | d <q6 W| S( u�
Remove version locks
.. note::
This function is provided primarily for compatibilty with some parts of
:py:mod:`states.pkg <salt.states.pkg>`. Consider using
:py:func:`pkg.unlock <salt.modules.pkgng.unlock>` instead.
name
The name of the package to be unheld
Multiple Package Options:
pkgs
A list of packages to unhold. Must be passed as a python list. The
``name`` parameter will be ignored if this option is passed.
Returns a dict containing the changes.
CLI Example:
.. code-block:: bash
salt '*' pkg.unhold <package name>
salt '*' pkg.unhold pkgs='["foo", "bar"]'
u nameu changesu resultu u commentu testR� u Package {0} is set to be unheld.u Package {0} is no longer held.u newu holdu oldu$ Package {0} was unable to be unheld.u Package {0} is not being held.N( R RJ R� R> R� R R� R
R� R
R� R R( t unlockRW ( R! R\ RA R� R R� ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt unhold� s:
c K@ s; g t d d d | �D]! } d j | t | | � � ^ q S( uy
Query the package database those packages which are
locked against reinstallation, modification or deletion.
Returns returns a list of package names with version strings
CLI Example:
.. code-block:: bash
salt '*' pkg.list_locked
jail
List locked packages within the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.list_locked jail=<jail name or id>
chroot
List locked packages within the specified chroot (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.list_locked chroot=/path/to/chroot
root
List locked packages within the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.list_locked root=/path/to/chroot
u lockR! u {0}-{1}N( t _lockcmdR R( RF ( RA R$ ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt list_locked� s +c K@ s# | t d d d | �k r t St S( u�
Query the package database to determine if the named package
is locked against reinstallation, modification or deletion.
Returns True if the named package is locked, False otherwise.
CLI Example:
.. code-block:: bash
salt '*' pkg.locked <package name>
jail
Test if a package is locked within the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.locked <package name> jail=<jail name or id>
chroot
Test if a package is locked within the specified chroot (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.locked <package name> chroot=/path/to/chroot
root
Test if a package is locked within the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.locked <package name> root=/path/to/chroot
u lockR! N( R� R RW R
( R! RA ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyR� s +c K@ s | t d | | � k r t St S( uZ
Lock the named package against reinstallation, modification or deletion.
Returns True if the named package was successfully locked.
CLI Example:
.. code-block:: bash
salt '*' pkg.lock <package name>
jail
Lock packages within the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.lock <package name> jail=<jail name or id>
chroot
Lock packages within the specified chroot (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.lock <package name> chroot=/path/to/chroot
root
Lock packages within the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.lock <package name> root=/path/to/chroot
u lock( R� RW R
( R! RA ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyR� M s *c K@ s | t d | | � k r t St S( ul
Unlock the named package against reinstallation, modification or deletion.
Returns True if the named package was successfully unlocked.
CLI Example:
.. code-block:: bash
salt '*' pkg.unlock <package name>
jail
Unlock packages within the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.unlock <package name> jail=<jail name or id>
chroot
Unlock packages within the specified chroot (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.unlock <package name> chroot=/path/to/chroot
root
Unlock packages within the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.unlock <package name> root=/path/to/chroot
u unlock( R� R
RW ( R! RA ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyR� } s *c
K@ sw | j d d � } | j d d � } | j d d � } g } t | | | � } | j | � | j d � | j d � | j d � | r� | j | � n t d | d d d
t �} | d d k r� t d
j | � d i | d 6�� n xn t j j
j | d d � D]P } | sqn y | j d d � d } Wn t
k
rHqn X| j | � qWt j d d j | � � | S( u�
Helper function for lock and unlock commands, because their syntax is identical.
Run the lock/unlock command, and return a list of locked packages
u jailu chrootu rootu -yu --quietu
--show-lockedu cmd.run_allRN u traceRG u retcodei u# Problem encountered {0}ing packagesRq u resultu stdoutu
u -i u Locked packages: %su , N( R8 R R RJ R R
R R( R R R R R R R R Rr (
t subcmdR$ RA R R R t locked_pkgsR Rd R# ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyR� � s4
#
c K@ s� | j d d � } | j d d � } | j d d � } | j d d � } t | | | � } | j d d d g � | s� | j d � n | r� | j d | g � n t d
| d d d
t d t �} d � t j t
| � d � D� S( u8
List those packages for which an upgrade is available
The ``fromrepo`` argument is also supported, as used in pkg states.
CLI Example:
.. code-block:: bash
salt '*' pkg.list_upgrades
jail
List upgrades within the specified jail
CLI Example:
.. code-block:: bash
salt '*' pkg.list_upgrades jail=<jail name or id>
chroot
List upgrades within the specified chroot (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.list_upgrades chroot=/path/to/chroot
root
List upgrades within the specified root (ignored if ``jail`` is
specified)
CLI Example:
.. code-block:: bash
salt '*' pkg.list_upgrades root=/path/to/chroot
u jailu chrootu rootu fromrepou upgradeu --dry-runu --quietu --no-repo-updateu --repositoryu cmd.run_stdoutRN u traceRG t ignore_retcodec S@ s' i | ] \ } } | d d | � q S( u versionu new( ( RU R$ t pkgstat( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pys
<dictcomp> s N( R8 R R R RJ R R
RW R R? t _parse_upgrade( R[ RA R R R Rt R Rd ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt
list_upgrades� s *"c C@ s� t j d � } t j d � } t j d � } i i d 6i d 6i d 6i d 6i d 6} d } xjt j j j | d � D]P} | s� d } qu n | d
k r� d } qu n | d k r� d } qu n | d k r� d } qu n | d
k r� d } qu n | d k rd } qu n | d k s | d k r�| j | � } | r�i i | j d � d 6| j d � d 6d 6| j d � d 6| j d � d 6| | | j d � <q�t j
d | | � n | d k r1| j | � } | ri i | j d � d 6d 6| j d � d 6| j d � d 6| | | j d � <q1t j
d | | � n | d k sI| d k ru | j | � } | r�i i | j d � d 6d 6| j d � d 6| j d � d 6| | | j d � <q�t j
d | | � qu qu W| S( u�
Parse the output from the ``pkg upgrade --dry-run`` command
Returns a dictionary of the expected actions:
.. code-block:: yaml
'upgrade':
pkgname:
'repo': repository
'reason': reason
'version':
'current': n.n.n
'new': n.n.n
'install':
pkgname:
'repo': repository
'reason': reason
'version':
'current': n.n.n
'reinstall':
pkgname:
'repo': repository
'reason': reason
'version':
'current': n.n.n
'downgrade':
pkgname:
'repo': repository
'reason': reason
'version':
'current': n.n.n
'new': n.n.n
'remove':
pkgname:
'repo': repository
'reason': reason
'version':
'current': n.n.n
uT ^\s+([^:]+):\s([0-9a-z_,.]+)\s+->\s+([0-9a-z_,.]+)\s*(\[([^]]+)\])?\s*(\(([^)]+)\))?u? ^\s+([^:]+):\s+([0-9a-z_,.]+)\s*(\[([^]]+)\])?\s*(\(([^)]+)\))?u@ ^\s+(\S+)-(?<=-)([0-9a-z_,.]+)\s*(\[([^]]+)\])?\s*(\(([^)]+)\))?u upgradeu installu reinstallu removeu downgradeu
u" Installed packages to be UPGRADED:u New packages to be INSTALLED:u% Installed packages to be REINSTALLED:u! Installed packages to be REMOVED:u$ Installed packages to be DOWNGRADED:i u currenti u newu versioni u repoi u reasoni u Unable to parse %s: '%s'i i N( t ret compileR R R R R t matcht groupR t error( t stdoutt
upgrade_regext
install_regext reinstall_regexR� t actionR# R� ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyR� sj *) ' ''c C@ s� ~ i d d 6d d 6d d 6} yW d d d | | g } t d
| d d d
t d t �} | d | k rt | | d SWn t k
r� } t j | � n Xd S( u
Do a cmp-style comparison on two packages. Return -1 if pkg1 < pkg2, 0 if
pkg1 == pkg2, and 1 if pkg1 > pkg2. Return None if there was a problem
making the comparison.
CLI Example:
.. code-block:: bash
salt '*' pkg.version_cmp '2.1.11' '2.1.12'
i����u <i u >i u =u pkgu versionu --test-versionu cmd.run_allRN u traceRG R� u stdoutN( R R
RW t ExceptionR R� R ( t pkg1t pkg2t ignore_epocht symR R R ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt version_cmp� s
(H t __doc__t
__future__R R R R` t loggingR+ R� t salt.utils.dataR t salt.utils.filest salt.utils.functoolst salt.utils.itertoolst salt.utils.pkgt salt.utils.stringutilst salt.utils.versionst salt.exceptionsR R t salt.extR t getLoggert __name__R R R R R R R& R* R7 RF R t functoolst alias_functionRq R
RL R� R_ t available_versionRV Rh Rl Rm Rn Ro R� R� t deletet purgeR� R� R� R� R� R� RW R� R� R� R� R� R� R� R� R� R� R� R� ( ( ( s6 /usr/lib/python2.7/site-packages/salt/modules/pkgng.pyt <module>& s� 4. K S F/.( � � x H# OG � � FAA / 1 0 0 + = w
Mini Shell