EVOLUTION-MANAGER
Edit File: __init__.cpython-36.pyc
3 �f�6 � @ s> d dl Z d dlZd dlmZ G dd� d�ZG dd� de�ZdS )� N)�sos_get_command_outputc @ s� e Zd ZdZdZdZdZdZdZdZ dZ d dd�Z e dd� �Z e dd� �Zd!d d �Zd d� Zd"dd�Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � ZdS )#�PackageManagerau Encapsulates a package manager. If you provide a query_command to the constructor it should print each package on the system in the following format:: package name|package.version You may also subclass this class and provide a _generate_pkg_list method to build the list of packages and versions. :cvar query_command: The command to use for querying packages :vartype query_command: ``str`` or ``None`` :cvar verify_command: The command to use for verifying packages :vartype verify_command: ``str`` or ``None`` :cvar verify_filter: Optional filter to use for controlling package verification :vartype verify_filter: ``str or ``None`` :cvar files_command: The command to use for getting file lists for packages :vartype files_command: ``str`` or ``None`` :cvar chroot: Perform a chroot when executing `files_command` :vartype chroot: ``bool`` :cvar remote_exec: If package manager is on a remote system (e.g. for sos collect), use this to execute commands :vartype remote_exec: ``SoSTransport.run_command()`` Nc C s i | _ g | _|| _|r || _d S )N)� _packages�files� remote_exec�chroot)�selfr r � r � /usr/lib/python3.6/__init__.py�__init__8 s zPackageManager.__init__c C s | j s| j� | j S )N)r �_generate_pkg_list)r r r r �packages@ s zPackageManager.packagesc C s | j jj� jd�d S )N�packager )� __class__�__name__�lower�split)r r r r � manager_nameF s zPackageManager.manager_name� Fc C sB | j r| j |||||�}nt||||d�}|d dkr>|d S dS )a Runs a package manager command, either via sos_get_command_output() if local, or via a SoSTransport's run_command() if this needs to be run remotely, as in the case of remote nodes for use during `sos collect`. :param command: The command to execute :type command: ``str`` :param timeout: Timeout for command to run, in seconds :type timeout: ``int`` :param need_root: Does the command require root privileges? :type need_root: ``bool`` :param env: Environment variables to set :type env: ``dict`` with keys being env vars to define :param use_shell: If running remotely, does the command require obtaining a shell? :type use_shell: ``bool`` :param chroot: If necessary, chroot command execution to here :type chroot: ``None`` or ``str`` :returns: The output of the command :rtype: ``str`` )r �envZstatusr �output� )r r )r Zcommand�timeoutZ need_rootr Z use_shellr �retr r r �exec_cmdJ s zPackageManager.exec_cmdc C s t j| jj� |�S )z� Get a list of packages that match name. :param name: The name of the package :type name: ``str`` :returns: List of all packages matching `name` :rtype: ``list`` )�fnmatch�filterr �keys)r �namer r r �all_pkgs_by_names s z PackageManager.all_pkgs_by_namer c s$ t j||�� � fdd�| jj� D �S )aL Get a list of packages that match regex_name. :param regex_name: The regex to use for matching package names against :type regex_name: ``str`` :param flags: Flags for the `re` module when matching `regex_name` :returns: All packages matching `regex_name` :rtype: ``list`` c s g | ]}� j |�r|�qS r )�match)�.0�pkg)�regr r � <listcomp>� s z9PackageManager.all_pkgs_by_name_regex.<locals>.<listcomp>)�re�compiler r )r Z regex_name�flagsr )r# r �all_pkgs_by_name_regex s z%PackageManager.all_pkgs_by_name_regexc C s$ y | j | S tk r dS X dS )z� Get a single package that matches name. :param name: The name of the package :type name: ``str`` :returns: The first package that matches `name` :rtype: ``str`` N)r � Exception)r r r r r � pkg_by_name� s zPackageManager.pkg_by_namec C s t �dS )a+ Using the output of `query_command`, build the _packages dict. This should be overridden by distinct package managers and be a generator for _generate_pkg_list which will insert the packages into the _packages dict. This method should yield a tuple of name, version, release for each package parsed. If the package manager or distribution does not use a release field, set it to None. :param pkg_list: The output of the result of `query_command` :type pkg_list: ``str`` N)�NotImplementedError)r �pkg_listr r r �_parse_pkg_list� s z PackageManager._parse_pkg_listc C sb | j r^| j }| j|d| jd�}x>| j|�D ]0}|d |d jd�|d | jd�| j|d < q*W dS ) am Generates a dictionary of packages for internal use by the package manager in the format:: {'package_name': {'name': 'package_name', 'version': 'major.minor.version', 'release': 'package release' or None, 'pkg_manager': 'package manager name'}} r )r r r � �.� )r �version�releaseZ pkg_managerN)� query_commandr r r- r r r )r �cmdr, r" r r r r � s z!PackageManager._generate_pkg_listc C s || j kr| j | S dS )z�Returns the entry in self.packages for pkg if it exists :param pkg: The name of the package :type pkg: ``str`` :returns: Package name and version, if package exists :rtype: ``dict`` if found, else ``None`` N)r )r r" r r r � pkg_version� s zPackageManager.pkg_versionc C s6 | j r0| j r0| j }| j|d| jd�}|j� | _| jS )z� Get a list of files known by the package manager :returns: All files known by the package manager :rtype: ``list`` � )r r )� files_commandr r r � splitlines)r r4 r r r r � all_files� s zPackageManager.all_filesc C sR | j s dS y.| j � d|� �}| j|d| jd�}|j� p8dS tk rL dS X dS )z�Given a path, return the package that owns that path. :param path: The filepath to check for package ownership :type path: ``str`` :returns: The package name or 'unknown' :rtype: ``str`` �unknown� � )r r N)�query_path_commandr r r8 r) )r �pathr4 r" r r r � pkg_by_path� s zPackageManager.pkg_by_pathc s� | j s dS | j}tdt||��}|s(dS d}xL|D ]D}x>|D ]6� t� fdd�| jD ��rZq<t|�rj|d7 }|� 7 }q<W q2W | j d | S )a� build_verify_command(self, packages) -> str Generate a command to verify the list of packages given in ``packages`` using the native package manager's verification tool. The command to be executed is returned as a string that may be passed to a command execution routine (for e.g. ``sos_get_command_output()``. :param packages: a string, or a list of strings giving package names to be verified. :returns: a string containing an executable command that will perform verification of the given packages. :rtype: str or ``NoneType`` Nr c s g | ] }|� k�qS r r )r! �f)r r r r$ s z7PackageManager.build_verify_command.<locals>.<listcomp>r; )�verify_commandr( r �map�any� verify_filter�len)r r Zby_regexZ verify_listZverify_packagesZ package_listr )r r �build_verify_command� s z#PackageManager.build_verify_command)NN)r FNFN)r )r � __module__� __qualname__�__doc__r3 rA rD r7 r= r r r �propertyr r r r r( r* r- r r5 r9 r? rF r r r r r s, ( r c sF e Zd ZdZd � fdd� Zdd� Zdd� Zd d � Z� fd d �Z� Z S )�MultiPackageManagera� This class is used to leverage multiple individual package managers as a single entity on systems that support multiple concurrent package managers. Policies that use this approach will need to specify a primary package manager, and at least one fallback manager. When queries are sent to this manager, the primary child manager is checked first. If there is a valid, not None, response (e.g. a given package is installed) then that response is used. However, if the response is empty or None, the fallback managers are then queried in the order they were passed to MultiPackageManager during initialization. :param primary: The primary package manager to rely on :type primary: A subclass of `PackageManager` :param fallbacks: A list of package managers to use if the primary does not provide a response :type fallbacks: ``list`` of `PackageManager` subclasses Nc s� t t| �j� �d� t|t�s.td|j� ���t|t�s@td��x&|D ] }t|t�sFtd|j� ���qFW |� �d�| _ � �fdd�|D �| _ | j s�td��| j g| _ | j j | j � d S )N)r r z=Primary package manager must be PackageManager subclass, not z%Fallbacks must be specified in a listz?Fallback package managers must be PackageManager subclass, not c s g | ]}|� �d ��qS ))r r r )r! �pm)r r r r r$ E s z0MultiPackageManager.__init__.<locals>.<listcomp>z1Must define at least one fallback package manager) �superrK r � issubclassr r) r � isinstance�list�primary� fallbacks� _managers�extend)r rQ rR r r rL )r )r r r r / s$ z MultiPackageManager.__init__c C s, | j s&x | jD ]}| j j|j� � qW | j S )N)r rS rT r9 )r rL r r r r9 P s z MultiPackageManager.all_filesc C sT | j j| jj� x>| jD ]4}|j}x(|j� D ] }|| j kr,|| | j |< q,W qW d S )N)r �updaterQ r rR r )r rL Z_pkgsr" r r r r V s z&MultiPackageManager._generate_pkg_listc s � �fdd�}|S )aJ This wrapper method is used to provide implicit iteration through the primary and any defined fallback managers that are set for a given instance of MultiPackageManager. Important note: we pass the _name_ of the method to run here as a string, and not any actual method as we rely on iteratively looking up the actual method in each package manager. :param method: The name of the method we're wrapping for the purpose of iterating through defined package managers :type method: ``str`` c s: d }x0�j D ]&}| s |dkr t|� �}|| |�}q W |S )Nr: )rS �getattr)�args�kwargsr rL Z _wrapped_func)�methodr r r �pkg_funcl s z1MultiPackageManager._pm_wrapper.<locals>.pkg_funcr )r rY rZ r )rY r r � _pm_wrapper^ s z MultiPackageManager._pm_wrapperc s8 |dkrt � j|�S t � j|�}t|d�r4| j|�S |S )Nr r[ r9 �__call__)r r[ r9 )rM �__getattribute__�hasattrr[ )r �item�attr)r r r r] u s z$MultiPackageManager.__getattribute__)NN) r rG rH rI r r9 r r[ r] � __classcell__r r )r r rK s !rK )r% r Z sos.utilitiesr r rK r r r r �<module> s