Package Providers¶

list_pkgs¶

This function should declare an empty dict, and then add packages to it by calling pkg_resource.add_pkg, like so:

__salt__["pkg_resource.add_pkg"](ret, name, version)

The last thing that should be done before returning is to execute pkg_resource.sort_pkglist. This function does not presently do anything to the return dict, but will be used in future versions of Salt.

__salt__["pkg_resource.sort_pkglist"](ret)

list_pkgs returns a dictionary of installed packages, with the keys being the package names and the values being the version installed. Example return data:

{"foo": "1.2.3-4", "bar": "5.6.7-8"}

latest_version¶

Accepts an arbitrary number of arguments. Each argument is a package name. The return value for a package will be an empty string if the package is not found or if the package is up-to-date. The only case in which a non-empty string is returned is if the package is available for new installation (i.e. not already installed) or if there is an upgrade available.

If only one argument was passed, this function return a string, otherwise a dict of name/version pairs is returned.

This function must also accept **kwargs, in order to receive the fromrepo and repo keyword arguments from pkg states. Where supported, these arguments should be used to find the install/upgrade candidate in the specified repository. The fromrepo kwarg takes precedence over repo, so if both of those kwargs are present, the repository specified in fromrepo should be used. However, if repo is used instead of fromrepo, it should still work, to preserve backwards compatibility with older versions of Salt.

version¶

Like latest_version, accepts an arbitrary number of arguments and returns a string if a single package name was passed, or a dict of name/value pairs if more than one was passed. The only difference is that the return values are the currently-installed versions of whatever packages are passed. If the package is not installed, an empty string is returned for that package.

upgrade_available¶

Deprecated and destined to be removed. For now, should just do the following:

def myfunc():
    return __salt__["pkg.latest_version"](name) != ""

install¶

The following arguments are required and should default to None:

1. name (for single-package pkg states)

2. pkgs (for multiple-package pkg states)

3. sources (for binary package file installation)

The first thing that this function should do is call pkg_resource.parse_targets (see below). This function will convert the SLS input into a more easily parsed data structure. pkg_resource.parse_targets may need to be modified to support your new package provider, as it does things like parsing package metadata which cannot be done for every package management system.

pkg_params, pkg_type = __salt__["pkg_resource.parse_targets"](name, pkgs, sources)

Two values will be returned to the install function. The first of them will be a dictionary. The keys of this dictionary will be package names, though the values will differ depending on what kind of installation is being done:

• If name was provided (and pkgs was not), then there will be a single key in the dictionary, and its value will be None. Once the data has been returned, if the version keyword argument was provided, then it should replace the None value in the dictionary.

• If pkgs was provided, then name is ignored, and the dictionary will contain one entry for each package in the pkgs list. The values in the dictionary will be None if a version was not specified for the package, and the desired version if specified. See the Multiple Package Installation Options section of the pkg.installed state for more info.

• If sources was provided, then name is ignored, and the dictionary values will be the path/URI for the package.

The second return value will be a string with two possible values: repository or file. The install function can use this value (if necessary) to build the proper command to install the targeted package(s).

Both before and after the installing the target(s), you should run list_pkgs to obtain a list of the installed packages. You should then return the output of salt.utils.data.compare_dicts():

def myfunc():
    return salt.utils.data.compare_dicts(old, new)

remove¶

Removes the passed package and return a list of the packages removed.

list_repos¶

Lists the repositories that are currently configured on this system.

__salt__["pkg.list_repos"]()

Returns a dictionary, in the following format:

{'reponame': 'config_key_1': 'config value 1',
             'config_key_2': 'config value 2',
             'config_key_3': ['list item 1 (when appropriate)',
                              'list item 2 (when appropriate)]}

get_repo¶

Displays all local configuration for a specific repository.

__salt__["pkg.get_repo"](repo="myrepo")

The information is formatted in much the same way as list_repos, but is specific to only one repo.

{'config_key_1': 'config value 1',
 'config_key_2': 'config value 2',
 'config_key_3': ['list item 1 (when appropriate)',
                  'list item 2 (when appropriate)]}

del_repo¶

Removes the local configuration for a specific repository. Requires a repo argument, which must match the locally configured name. This function returns a string, which informs the user as to whether or not the operation was a success.

__salt__["pkg.del_repo"](repo="myrepo")

mod_repo¶

Modify the local configuration for one or more option for a configured repo. This is also the way to create new repository configuration on the local system; if a repo is specified which does not yet exist, it will be created.

The options specified for this function are specific to the system; please refer to the documentation for your specific repo manager for specifics.

__salt__["pkg.mod_repo"](repo="myrepo", url="http://myurl.com/repo")

list_pkgs¶

Returns a dict of packages installed, including the package name and version. Can accept a list of packages; if none are specified, then all installed packages will be listed.

installed = __salt__["lowpkg.list_pkgs"]("foo", "bar")

Example output:

{"foo": "1.2.3-4", "bar": "5.6.7-8"}

verify¶

Many (but not all) package management systems provide a way to verify that the files installed by the package manager have or have not changed. This function accepts a list of packages; if none are specified, all packages will be included.

installed = __salt__["lowpkg.verify"]("httpd")

Example output:

{
    "/etc/httpd/conf/httpd.conf": {
        "mismatch": ["size", "md5sum", "mtime"],
        "type": "config",
    }
}

file_list¶

Lists all of the files installed by all packages specified. If not packages are specified, then all files for all known packages are returned.

installed = __salt__["lowpkg.file_list"]("httpd", "apache")

This function does not return which files belong to which packages; all files are returned as one giant list (hence the file_list function name. However, This information is still returned inside of a dict, so that it can provide any errors to the user in a sane manner.

{
    "errors": ["package apache is not installed"],
    "files": ["/etc/httpd", "/etc/httpd/conf", "/etc/httpd/conf.d", "...SNIP..."],
}

file_dict¶

Lists all of the files installed by all packages specified. If not packages are specified, then all files for all known packages are returned.

installed = __salt__["lowpkg.file_dict"]("httpd", "apache", "kernel")

Unlike file_list, this function will break down which files belong to which packages. It will also return errors in the same manner as file_list.

{
    "errors": ["package apache is not installed"],
    "packages": {
        "httpd": ["/etc/httpd", "/etc/httpd/conf", "...SNIP..."],
        "kernel": [
            "/boot/.vmlinuz-2.6.32-279.el6.x86_64.hmac",
            "/boot/System.map-2.6.32-279.el6.x86_64",
            "...SNIP...",
        ],
    },
}