# salt.modules.pkgng

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 here.

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 `sys.doc` function:

    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 `providers` parameter in your Minion config file, in order to use this module to manage packages, like so:

    providers:
      pkg: pkgng

salt.modules.pkgng.audit(jail=None, chroot=None, root=None)

  Audits installed packages against known vulnerabilities

  CLI Example:

      salt '*' pkg.audit

  jail

    Audit packages within the specified jail

    CLI Example:

        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:

        salt '*' pkg.audit chroot=/path/to/chroot

salt.modules.pkgng.autoremove(jail=None, chroot=None, root=None, dryrun=False)

  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:

      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

salt.modules.pkgng.available_version(*names, **kwargs)

  This function is an alias of `latest_version`.

  > 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:

  >     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

salt.modules.pkgng.backup(file_name, jail=None, chroot=None, root=None)

  Export installed packages into yaml+mtree file

  CLI Example:

      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:

        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:

        salt '*' pkg.backup /tmp/pkg chroot=/path/to/chroot

salt.modules.pkgng.check(jail=None, chroot=None, root=None, depends=False, recompute=False, checksum=False, checklibs=False)

  Sanity checks installed packages

  jail

    Perform the sanity check in the specified jail

    CLI Example:

        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:

        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:

        salt '*' pkg.check depends=True

  recompute

    Recompute sizes and checksums of installed packages.

    CLI Example:

        salt '*' pkg.check recompute=True

  checksum

    Find invalid checksums for installed packages.

    CLI Example:

        salt '*' pkg.check checksum=True

  checklibs

    Regenerates the library dependency metadata for a package.

    CLI Example:

        salt '*' pkg.check checklibs=True

salt.modules.pkgng.clean(jail=None, chroot=None, root=None, clean_all=False, dryrun=False)

  Cleans the local cache of fetched remote packages

  CLI Example:

      salt '*' pkg.clean

  jail

    Cleans the package cache in the specified jail

    CLI Example:

        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:

        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:

    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:

        salt '*' pkg.clean dryrun=True

salt.modules.pkgng.delete(name=None, pkgs=None, jail=None, chroot=None, root=None, all_installed=False, force=False, glob=False, dryrun=False, recurse=False, regex=False, pcre=False, **kwargs)

  This function is an alias of `remove`.

  > 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:

  >       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:

  >       salt '*' pkg.remove all all_installed=True force=True

  > force

  >   Forces packages to be removed despite leaving unresolved dependencies.

  >   CLI Example:

  >       salt '*' pkg.remove <package name> force=True

  > glob

  >   Treat the package names as shell glob patterns.

  >   CLI Example:

  >       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:

  >       salt '*' pkg.remove <package name> dryrun=True

  > recurse

  >   Delete all packages that require the listed package as well.

  >   CLI Example:

  >       salt '*' pkg.remove <package name> recurse=True

  > regex

  >   Treat the package names as regular expressions.

  >   CLI Example:

  >       salt '*' pkg.remove <regular expression> regex=True

  > pcre

  >   Treat the package names as extended regular expressions.

  >   CLI Example:

  >       salt '*' pkg.remove <extended regular expression> pcre=True

salt.modules.pkgng.fetch(name, jail=None, chroot=None, root=None, fetch_all=False, quiet=False, fromrepo=None, glob=True, regex=False, pcre=False, local=False, depends=False)

  Fetches remote packages

  CLI Example:

      salt '*' pkg.fetch <package name>

  jail

    Fetch package in the specified jail

    CLI Example:

        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:

        salt '*' pkg.fetch <package name> chroot=/path/to/chroot

  fetch_all

    Fetch all packages.

    CLI Example:

        salt '*' pkg.fetch <package name> fetch_all=True

  quiet

    Quiet mode. Show less output.

    CLI Example:

        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:

        salt '*' pkg.fetch <package name> fromrepo=repo

  glob

    Treat pkg_name as a shell glob pattern.

    CLI Example:

        salt '*' pkg.fetch <package name> glob=True

  regex

    Treat pkg_name as a regular expression.

    CLI Example:

        salt '*' pkg.fetch <regular expression> regex=True

  pcre

    Treat pkg_name is an extended regular expression.

    CLI Example:

        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:

        salt '*' pkg.fetch <package name> local=True

  depends

    Fetch the package and its dependencies as well.

    CLI Example:

        salt '*' pkg.fetch <package name> depends=True

salt.modules.pkgng.hold(name=None, pkgs=None, **kwargs)

  Version-lock packages

  Note

  This function is provided primarily for compatibility with some parts of `states.pkg`. Consider using Consider using `pkg.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:

      salt '*' pkg.hold <package name>
      salt '*' pkg.hold pkgs='["foo", "bar"]'

salt.modules.pkgng.info(*names, **kwargs)

  This function is an alias of `version`.

  > 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_originFalse

  >   Return a nested dictionary containing both the origin name and version for each specified package.

  >   Added in version 2014.1.0.

  > CLI Example:

  >     salt '*' pkg.version <package name>
  >     salt '*' pkg.version <package name> jail=<jail name or id>
  >     salt '*' pkg.version <package1> <package2> <package3> ...

salt.modules.pkgng.install(name=None, fromrepo=None, pkgs=None, sources=None, jail=None, chroot=None, root=None, orphan=False, force=False, glob=False, local=False, dryrun=False, quiet=False, reinstall_requires=False, regex=False, pcre=False, batch=False, **kwargs)

  Install package(s) from a repository

  name

    The name of the package to install

    CLI Example:

        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:

        salt '*' pkg.install <package name> orphan=True

  force

    Force the reinstallation of the package if already installed.

    CLI Example:

        salt '*' pkg.install <package name> force=True

  glob

    Treat the package names as shell glob patterns.

    CLI Example:

        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:

        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:

        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:

        salt '*' pkg.install <package name> quiet=True

  reinstall_requires

    When used with force, reinstalls any packages that require the given package.

    CLI Example:

        salt '*' pkg.install <package name> reinstall_requires=True force=True

    Changed in version 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:

        salt '*' pkg.install <package name> fromrepo=repo

  regex

    Treat the package names as a regular expression

    CLI Example:

        salt '*' pkg.install <regular expression> regex=True

  pcre

    Treat the package names as extended regular expressions.

    CLI Example:

  batch

    Use BATCH=true for pkg install, skipping all questions. Be careful when using in production.

    CLI Example:

        salt '*' pkg.install <package name> batch=True

salt.modules.pkgng.latest_version(*names, **kwargs)

  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:

      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

salt.modules.pkgng.list_locked(**kwargs)

  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:

      salt '*' pkg.list_locked

  jail

    List locked packages within the specified jail

    CLI Example:

        salt '*' pkg.list_locked jail=<jail name or id>

  chroot

    List locked packages within the specified chroot (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.list_locked chroot=/path/to/chroot

  root

    List locked packages within the specified root (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.list_locked root=/path/to/chroot

salt.modules.pkgng.list_pkgs(versions_as_list=False, jail=None, chroot=None, root=None, with_origin=False, **kwargs)

  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_originFalse

    Return a nested dictionary containing both the origin name and version for each installed package.

    Added in version 2014.1.0.

  CLI Example:

      salt '*' pkg.list_pkgs
      salt '*' pkg.list_pkgs jail=<jail name or id>
      salt '*' pkg.list_pkgs chroot=/path/to/chroot

salt.modules.pkgng.list_upgrades(refresh=True, **kwargs)

  List those packages for which an upgrade is available

  The `fromrepo` argument is also supported, as used in pkg states.

  CLI Example:

      salt '*' pkg.list_upgrades

  jail

    List upgrades within the specified jail

    CLI Example:

        salt '*' pkg.list_upgrades jail=<jail name or id>

  chroot

    List upgrades within the specified chroot (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.list_upgrades chroot=/path/to/chroot

  root

    List upgrades within the specified root (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.list_upgrades root=/path/to/chroot

salt.modules.pkgng.lock(name, **kwargs)

  Lock the named package against reinstallation, modification or deletion.

  Returns True if the named package was successfully locked.

  CLI Example:

      salt '*' pkg.lock <package name>

  jail

    Lock packages within the specified jail

    CLI Example:

        salt '*' pkg.lock <package name> jail=<jail name or id>

  chroot

    Lock packages within the specified chroot (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.lock <package name> chroot=/path/to/chroot

  root

    Lock packages within the specified root (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.lock <package name> root=/path/to/chroot

salt.modules.pkgng.locked(name, **kwargs)

  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:

      salt '*' pkg.locked <package name>

  jail

    Test if a package is locked within the specified jail

    CLI Example:

        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:

        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:

        salt '*' pkg.locked <package name> root=/path/to/chroot

salt.modules.pkgng.parse_config(file_name='/usr/local/etc/pkg.conf')

  Return dict of uncommented global variables.

  CLI Example:

      salt '*' pkg.parse_config

  `NOTE:` not working properly right now

salt.modules.pkgng.purge(name=None, pkgs=None, jail=None, chroot=None, root=None, all_installed=False, force=False, glob=False, dryrun=False, recurse=False, regex=False, pcre=False, **kwargs)

  This function is an alias of `remove`.

  > 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:

  >       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:

  >       salt '*' pkg.remove all all_installed=True force=True

  > force

  >   Forces packages to be removed despite leaving unresolved dependencies.

  >   CLI Example:

  >       salt '*' pkg.remove <package name> force=True

  > glob

  >   Treat the package names as shell glob patterns.

  >   CLI Example:

  >       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:

  >       salt '*' pkg.remove <package name> dryrun=True

  > recurse

  >   Delete all packages that require the listed package as well.

  >   CLI Example:

  >       salt '*' pkg.remove <package name> recurse=True

  > regex

  >   Treat the package names as regular expressions.

  >   CLI Example:

  >       salt '*' pkg.remove <regular expression> regex=True

  > pcre

  >   Treat the package names as extended regular expressions.

  >   CLI Example:

  >       salt '*' pkg.remove <extended regular expression> pcre=True

salt.modules.pkgng.refresh_db(jail=None, chroot=None, root=None, force=False, **kwargs)

  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:

      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:

        salt '*' pkg.refresh_db force=True

salt.modules.pkgng.remove(name=None, pkgs=None, jail=None, chroot=None, root=None, all_installed=False, force=False, glob=False, dryrun=False, recurse=False, regex=False, pcre=False, **kwargs)

  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:

        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:

        salt '*' pkg.remove all all_installed=True force=True

  force

    Forces packages to be removed despite leaving unresolved dependencies.

    CLI Example:

        salt '*' pkg.remove <package name> force=True

  glob

    Treat the package names as shell glob patterns.

    CLI Example:

        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:

        salt '*' pkg.remove <package name> dryrun=True

  recurse

    Delete all packages that require the listed package as well.

    CLI Example:

        salt '*' pkg.remove <package name> recurse=True

  regex

    Treat the package names as regular expressions.

    CLI Example:

        salt '*' pkg.remove <regular expression> regex=True

  pcre

    Treat the package names as extended regular expressions.

    CLI Example:

        salt '*' pkg.remove <extended regular expression> pcre=True

salt.modules.pkgng.restore(file_name, jail=None, chroot=None, root=None)

  Reads archive created by pkg backup -d and recreates the database.

  CLI Example:

      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:

        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:

        salt '*' pkg.restore /tmp/pkg chroot=/path/to/chroot

salt.modules.pkgng.search(name, jail=None, chroot=None, root=None, exact=False, glob=False, regex=False, pcre=False, comment=False, desc=False, full=False, depends=False, size=False, quiet=False, origin=False, prefix=False)

  Searches in remote package repositories

  CLI Example:

      salt '*' pkg.search pattern

  jail

    Perform the search using the `pkg.conf(5)` from the specified jail

    CLI Example:

        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:

        salt '*' pkg.search pattern chroot=/path/to/chroot

  exact

    Treat pattern as exact pattern.

    CLI Example:

        salt '*' pkg.search pattern exact=True

  glob

    Treat pattern as a shell glob pattern.

    CLI Example:

        salt '*' pkg.search pattern glob=True

  regex

    Treat pattern as a regular expression.

    CLI Example:

        salt '*' pkg.search pattern regex=True

  pcre

    Treat pattern as an extended regular expression.

    CLI Example:

        salt '*' pkg.search pattern pcre=True

  comment

    Search for pattern in the package comment one-line description.

    CLI Example:

        salt '*' pkg.search pattern comment=True

  desc

    Search for pattern in the package description.

    CLI Example:

        salt '*' pkg.search pattern desc=True

  full

    Displays full information about the matching packages.

    CLI Example:

        salt '*' pkg.search pattern full=True

  depends

    Displays the dependencies of pattern.

    CLI Example:

        salt '*' pkg.search pattern depends=True

  size

    Displays the size of the package

    CLI Example:

        salt '*' pkg.search pattern size=True

  quiet

    Be quiet. Prints only the requested information without displaying many hints.

    CLI Example:

        salt '*' pkg.search pattern quiet=True

  origin

    Displays pattern origin.

    CLI Example:

        salt '*' pkg.search pattern origin=True

  prefix

    Displays the installation prefix for each package matching pattern.

    CLI Example:

        salt '*' pkg.search pattern prefix=True

salt.modules.pkgng.stats(local=False, remote=False, jail=None, chroot=None, root=None, bytes=False)

  Return pkgng stats.

  CLI Example:

      salt '*' pkg.stats

  local

    Display stats only for the local package database.

    CLI Example:

        salt '*' pkg.stats local=True

  remote

    Display stats only for the remote package database(s).

    CLI Example:

        salt '*' pkg.stats remote=True

  bytes

    Display disk space usage in bytes only.

    CLI Example:

        salt '*' pkg.stats bytes=True

  jail

    Retrieve stats from the specified jail.

    CLI Example:

        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:

        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

salt.modules.pkgng.unhold(name=None, pkgs=None, **kwargs)

  Remove version locks

  Note

  This function is provided primarily for compatibility with some parts of `states.pkg`. Consider using `pkg.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:

      salt '*' pkg.unhold <package name>
      salt '*' pkg.unhold pkgs='["foo", "bar"]'

salt.modules.pkgng.unlock(name, **kwargs)

  Unlock the named package against reinstallation, modification or deletion.

  Returns True if the named package was successfully unlocked.

  CLI Example:

      salt '*' pkg.unlock <package name>

  jail

    Unlock packages within the specified jail

    CLI Example:

        salt '*' pkg.unlock <package name> jail=<jail name or id>

  chroot

    Unlock packages within the specified chroot (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.unlock <package name> chroot=/path/to/chroot

  root

    Unlock packages within the specified root (ignored if `jail` is specified)

    CLI Example:

        salt '*' pkg.unlock <package name> root=/path/to/chroot

salt.modules.pkgng.update(jail=None, chroot=None, root=None, force=False, **kwargs)

  This function is an alias of `refresh_db`.

  > 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:

  >     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:

  >       salt '*' pkg.refresh_db force=True

salt.modules.pkgng.update_package_site(new_url)

  Updates remote package repo URL, PACKAGESITE var to be exact.

  Must use `http://`, `ftp://`, or `https://` protocol

  CLI Example:

      salt '*' pkg.update_package_site http://127.0.0.1/

salt.modules.pkgng.updating(name, jail=None, chroot=None, root=None, filedate=None, filename=None)

  ' Displays UPDATING entries of software packages

  CLI Example:

      salt '*' pkg.updating foo

  jail

    Perform the action in the specified jail

    CLI Example:

        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:

        salt '*' pkg.updating foo chroot=/path/to/chroot

  filedate

    Only entries newer than date are shown. Use a YYYYMMDD date format.

    CLI Example:

        salt '*' pkg.updating foo filedate=20130101

  filename

    Defines an alternative location of the UPDATING file.

    CLI Example:

        salt '*' pkg.updating foo filename=/tmp/UPDATING

salt.modules.pkgng.upgrade(*names, **kwargs)

  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:

      {'<package>':  {'old': '<old-version>',
                      'new': '<new-version>'}}

  CLI Example:

      salt '*' pkg.upgrade <package name>

  jail

    Audit packages within the specified jail

    CLI Example:

        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:

        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:

        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:

        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:

        salt '*' pkg.upgrade <package name> dryrun=True

  fromrepo

    In multi-repo mode, override the pkg.conf ordering and only attempt to upgrade packages from the named repository.

    CLI Example:

        salt '*' pkg.upgrade <package name> fromrepo=repo

  fetchonly

    Do not perform installation of packages, merely fetch packages that should be upgraded and detect possible conflicts.

    CLI Example:

        salt '*' pkg.upgrade <package name> fetchonly=True

salt.modules.pkgng.version(*names, **kwargs)

  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_originFalse

    Return a nested dictionary containing both the origin name and version for each specified package.

    Added in version 2014.1.0.

  CLI Example:

      salt '*' pkg.version <package name>
      salt '*' pkg.version <package name> jail=<jail name or id>
      salt '*' pkg.version <package1> <package2> <package3> ...

salt.modules.pkgng.version_cmp(pkg1, pkg2, ignore_epoch=False, **kwargs)

  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:

      salt '*' pkg.version_cmp '2.1.11' '2.1.12'

salt.modules.pkgng.which(path, jail=None, chroot=None, root=None, origin=False, quiet=False)

  Displays which package installed a specific file

  CLI Example:

      salt '*' pkg.which <file name>

  jail

    Perform the check in the specified jail

    CLI Example:

        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:

        salt '*' pkg.which <file name> chroot=/path/to/chroot

  origin

    Shows the origin of the package instead of name-version.

    CLI Example:

        salt '*' pkg.which <file name> origin=True

  quiet

    Quiet output.

    CLI Example:

        salt '*' pkg.which <file name> quiet=True