# salt.modules.apt

Support for APT (Advanced Packaging Tool)

`salt.modules.apt.` `del_repo`(repo, **kwargs)

  Delete a repo from the sources.list / sources.list.d

  If the .list file is in the sources.list.d directory and the file that the repo exists in does not contain any other repo configuration, the file itself will be deleted.

  The repo passed in must be a fully formed repository definition string.

  CLI Examples:

      salt '*' pkg.del_repo "myrepo definition"

`salt.modules.apt.` `expand_repo_def`(repokwargs)

  Take a repository definition and expand it to the full pkg repository dict that can be used for comparison. This is a helper function to make the Debian/Ubuntu apt sources sane for comparison in the pkgrepo states.

  There is no use to calling this function via the CLI.

`salt.modules.apt.` `file_dict`(*packages)

  List the files that belong to a package, grouped by package. Not specifying any packages will return a list of _every_ file on the system's package database (not generally recommended).

  CLI Examples:

      salt '*' pkg.file_list httpd
      salt '*' pkg.file_list httpd postfix
      salt '*' pkg.file_list

`salt.modules.apt.` `file_list`(*packages)

  List the files that belong to a package. Not specifying any packages will return a list of _every_ file on the system's package database (not generally recommended).

  CLI Examples:

      salt '*' pkg.file_list httpd
      salt '*' pkg.file_list httpd postfix
      salt '*' pkg.file_list

`salt.modules.apt.` `get_repo`(repo, **kwargs)

  Display a repo from the sources.list / sources.list.d

  The repo passwd in needs to be a complete repo entry.

  CLI Examples:

      salt '*' pkg.get_repo "myrepo definition"

`salt.modules.apt.` `get_selections`(pattern=None, state=None)

  View package state from the dpkg database.

  Returns a dict of dicts containing the state, and package names:

      {'<host>':
          {'<state>': ['pkg1',
                       ...
                      ]
          },
          ...
      }

  CLI Example:

      salt '*' pkg.get_selections
      salt '*' pkg.get_selections 'python-*'
      salt '*' pkg.get_selections state=hold
      salt '*' pkg.get_selections 'openssh*' state=hold

`salt.modules.apt.` `install`(name=None, refresh=False, fromrepo=None, skip_verify=False, debconf=None, pkgs=None, sources=None, **kwargs)

  Install the passed package, add refresh=True to update the dpkg database.

  name

    The name of the package to be installed. Note that this parameter is ignored if either "pkgs" or "sources" is passed. Additionally, please note that this option can only be used to install packages from a software repository. To install a package file manually, use the "sources" option.

    32-bit packages can be installed on 64-bit systems by appending the architecture designation (`:i386`, etc.) to the end of the package name.

    CLI Example:

        salt '*' pkg.install <package name>

  refresh
    Whether or not to refresh the package database before installing.
  fromrepo
    Specify a package repository to install from (e.g., `apt-get -t unstable install somepackage`)
  skip_verify
    Skip the GPG verification check (e.g., `--allow-unauthenticated`, or `--force-bad-verify` for install from package file).
  debconf
    Provide the path to a debconf answers file, processed before installation.
  version
    Install a specific version of the package, e.g. 1.2.3~0ubuntu0. Ignored if "pkgs" or "sources" is passed.

  Multiple Package Installation Options:

  pkgs

    A list of packages to install from a software repository. Must be passed as a python list.

    CLI Example:

        salt '*' pkg.install pkgs='["foo", "bar"]'
        salt '*' pkg.install pkgs='["foo", {"bar": "1.2.3-0ubuntu0"}]'

  sources

    A list of DEB packages to install. Must be passed as a list of dicts, with the keys being package names, and the values being the source URI or local path to the package.

    32-bit packages can be installed on 64-bit systems by appending the architecture designation (`:i386`, etc.) to the end of the package name.

    CLI Example:

        salt '*' pkg.install sources='[{"foo": "salt://foo.deb"},{"bar": "salt://bar.deb"}]'

  Returns a dict containing the new package names and versions:

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

`salt.modules.apt.` `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.

  A specific repo can be requested using the `fromrepo` keyword argument.

  CLI Example:

      salt '*' pkg.latest_version <package name>
      salt '*' pkg.latest_version <package name> fromrepo=unstable
      salt '*' pkg.latest_version <package1> <package2> <package3> ...

`salt.modules.apt.` `list_pkgs`(versions_as_list=False, removed=False, **kwargs)

  List the packages currently installed in a dict:

      {'<package_name>': '<version>'}

  If removed is `True`, then only packages which have been removed (but not purged) will be returned.

  External dependencies:

      Virtual package resolution requires dctrl-tools.
      Without dctrl-tools virtual packages will be reported as not installed.

  CLI Example:

      salt '*' pkg.list_pkgs
      salt '*' pkg.list_pkgs versions_as_list=True

`salt.modules.apt.` `list_repos`()

  Lists all repos in the sources.list (and sources.lists.d) files

  CLI Example:

      salt '*' pkg.list_repos
      salt '*' pkg.list_repos disabled=True

`salt.modules.apt.` `list_upgrades`(refresh=True)

  List all available package upgrades.

  CLI Example:

      salt '*' pkg.list_upgrades

`salt.modules.apt.` `mod_repo`(repo, saltenv='base', **kwargs)

  Modify one or more values for a repo. If the repo does not exist, it will be created, so long as the definition is well formed. For Ubuntu the "ppa:<project>/repo" format is acceptable. "ppa:" format can only be used to create a new repository.

  The following options are available to modify a repo definition:

      comps (a comma separated list of components for the repo, e.g. "main")
      file (a file name to be used)
      keyserver (keyserver to get gpg key from)
      keyid (key id to load with the keyserver argument)
      key_url (URL to a gpg key to add to the apt gpg keyring)
      consolidate (if true, will attempt to de-dup and consolidate sources)

      * Note: Due to the way keys are stored for apt, there is a known issue
              where the key wont be updated unless another change is made
              at the same time.  Keys should be properly added on initial
              configuration.

  CLI Examples:

      salt '*' pkg.mod_repo 'myrepo definition' uri=http://new/uri
      salt '*' pkg.mod_repo 'myrepo definition' comps=main,universe

`salt.modules.apt.` `purge`(name=None, pkgs=None, **kwargs)

  Remove packages via `apt-get purge` along with all configuration files and unused dependencies.

  name
    The name of the package to be deleted.

  Multiple Package Options:

  pkgs
    A list of packages to delete. Must be passed as a python list. The `name` parameter will be ignored if this option is passed.

  New in version 0.16.0.

  Returns a dict containing the changes.

  CLI Example:

      salt '*' pkg.purge <package name>
      salt '*' pkg.purge <package1>,<package2>,<package3>
      salt '*' pkg.purge pkgs='["foo", "bar"]'

`salt.modules.apt.` `refresh_db`()

  Updates the APT database to latest packages based upon repositories

  Returns a dict, with the keys being package databases and the values being the result of the update attempt. Values can be one of the following:

  - `True`: Database updated successfully
  - `False`: Problem updating database
  - `None`: Database already up-to-date

  CLI Example:

      salt '*' pkg.refresh_db

`salt.modules.apt.` `remove`(name=None, pkgs=None, **kwargs)

  Remove packages using `apt-get remove`.

  name
    The name of the package to be deleted.

  Multiple Package Options:

  pkgs
    A list of packages to delete. Must be passed as a python list. The `name` parameter will be ignored if this option is passed.

  New in version 0.16.0.

  Returns a dict containing the changes.

  CLI Example:

      salt '*' pkg.remove <package name>
      salt '*' pkg.remove <package1>,<package2>,<package3>
      salt '*' pkg.remove pkgs='["foo", "bar"]'

`salt.modules.apt.` `set_selections`(path=None, selection=None, clear=False, saltenv='base')

  Change package state in the dpkg database.

  The state can be any one of, documented in `dpkg(1)`:

  > - install
  > - hold
  > - deinstall
  > - purge

  This command is commonly used to mark specific packages to be held from being upgraded, that is, to be kept at a certain version. When a state is changed to anything but being held, then it is typically followed by `apt-get -u dselect-upgrade`.

  Note: Be careful with the `clear` argument, since it will start with setting all packages to deinstall state.

  Returns a dict of dicts containing the package names, and the new and old versions:

      {'<host>':
          {'<package>': {'new': '<new-state>',
                         'old': '<old-state>'}
          },
          ...
      }

  CLI Example:

      salt '*' pkg.set_selections selection='{"install": ["netcat"]}'
      salt '*' pkg.set_selections selection='{"hold": ["openssh-server", "openssh-client"]}'
      salt '*' pkg.set_selections salt://path/to/file
      salt '*' pkg.set_selections salt://path/to/file clear=True

`salt.modules.apt.` `upgrade`(refresh=True, **kwargs)

  Upgrades all packages via `apt-get dist-upgrade`

  Returns a dict containing the changes.

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

  CLI Example:

      salt '*' pkg.upgrade

`salt.modules.apt.` `upgrade_available`(name)

  Check whether or not an upgrade is available for a given package

  CLI Example:

      salt '*' pkg.upgrade_available <package name>

`salt.modules.apt.` `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.

  CLI Example:

      salt '*' pkg.version <package name>
      salt '*' pkg.version <package1> <package2> <package3> ...

`salt.modules.apt.` `version_cmp`(pkg1, pkg2)

  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 '0.2.4-0ubuntu1' '0.2.4.1-0ubuntu1'

Current Salt release: 0.17.1

#### Previous topic

salt.modules.apache

#### Next topic

salt.modules.archive

### Quick search

Enter search terms or a module, class or function name.

### Upcoming SaltStack Events

My conferences on Lanyrd