golden hour
/opt/saltstack/salt/lib/python3.10/site-packages/salt/utils/decorators/__pycache__
⬆️ Go Up
Upload
File/Folder
Size
Actions
__init__.cpython-310.pyc
21.71 KB
Del
OK
jinja.cpython-310.pyc
1.98 KB
Del
OK
path.cpython-310.pyc
1.62 KB
Del
OK
state.cpython-310.pyc
3.45 KB
Del
OK
Edit: __init__.cpython-310.pyc
o �xemr � @ s d Z ddlZddlZddlZddlZddlZddlZddlmZ ddl m Z ddl Z ddl Z ddlZ ddlmZmZmZ dZeedd�rFdZe�e�ZG d d � d �ZeZd d � Zd d� ZG dd� d�Z G dd� de �Z e Z G dd� de �Z e Z dd� Z!dd� Z"dd� Z#dd � Z$dS ) z' Helpful decorators for module writing � N)� defaultdict��wraps)�CommandExecutionError�SaltConfigurationError�SaltInvocationErrorF�getwindowsversionTc @ sD e Zd ZdZedd� �Zdd� Zdd� Zedd � �Z e d d � �Z d S ) �Dependsz� This decorator will check the module when it is loaded and check that the dependencies passed in are in the globals of the module. If not, it will cause the function to be unloaded (or replaced). c C s t t�S �N)r �dict� r r �R/opt/saltstack/salt/lib/python3.10/site-packages/salt/utils/decorators/__init__.py�<lambda>' s zDepends.<lambda>c O s t �d||� || _|| _dS )az The decorator is instantiated with a list of dependencies (string of global name) An example use of this would be: .. code-block:: python @depends('modulename') def test(): return 'foo' OR @depends('modulename', fallback_function=function) def test(): return 'foo' .. code-block:: python This can also be done with the retcode of a command, using the ``retcode`` argument: @depends('/opt/bin/check_cmd', retcode=0) def test(): return 'foo' It is also possible to check for any nonzero retcode using the ``nonzero_retcode`` argument: @depends('/opt/bin/check_cmd', nonzero_retcode=True) def test(): return 'foo' .. note:: The command must be formatted as a string, not a list of args. Additionally, I/O redirection and other shell-specific syntax are not supported since this uses shell=False when calling subprocess.Popen(). z@Depends decorator instantiated with dep list of %s and kwargs %sN)�log�trace� dependencies�params)�selfr �kwargsr r r �__init__) s *� zDepends.__init__c C s� z+t �� j}|jd �dd�\}}}|j}| jD ]}|| jf| j| | ||f< qW |S t yC } z t � d� W Y d}~|S d}~ww )z� The decorator is "__call__"d with the function, we take that function and determine which module and function name it is to store in the class wide dependency_dict �__name__�.� zNException encountered when attempting to inspect frame in dependency decoratorN) �inspectZ currentframe�f_back� f_globals�rsplitr r r �dependency_dict� Exceptionr � exception) r �function�frame�_�kind�mod_nameZfun_nameZdep�excr r r �__call__[ s" �� ����zDepends.__call__c C s� d� ||�}t�d| |� trtjjj| dd�}ntjj�| �}t�d|� tj |dtj tj d�}|� � d }|j }t�d| |� t�d | |� |S ) N�{}.{}zRunning '%s' for '%s'F)�posixz Command after shlex_split: %s)�shell�stdout�stderrr zOutput from '%s': %szRetcode from '%s': %d)�formatr r � IS_WINDOWS�salt�utils�argsZ shlex_split� subprocess�Popen�PIPE�STDOUT� communicate� returncode)� dependencyr$ � func_name� full_namer0 �proc�output�retcoder r r � run_commandv s � zDepends.run_commandc C s> | j | �� D �]\}}|�� D �] \\}}\}} ||kr q|j�|�p)|j�|�} t| dd�} d| v s8d| v r�z | �|||�} W n* tyk } z | jtj krXt � d|| j � nt � d|| � d} W Y d} ~ nd} ~ ww d| v rx| d | krwqnGd| v r�| d r�| dkr�qn9| dkr�qn3|d u r�t � d ||� q| r�d | v r�t jj�| | d �dkr�t � d ||| | d � qnt � d ||� qt � d|||d | v r�d�| d �nd� |�rz |jd | }W n ttfy� Y nw d�||�}||vr�qz| �d�}|du�r|||< n||= W q t�y t � d|� Y qw qqdS )z� This is a class global method to enforce the dependencies that you currently know about. It will modify the "functions" dict and remove/replace modules that are missing dependencies. � __version__Nr< Znonzero_retcodez&Failed to run command %s, %s not foundz Failed to run command '%s': %s���r Tz*Dependency for %s.%s exists, not unloading�versionzSDependency (%s) already loaded inside %s with version (%s), required (%s), skippingz2Dependency (%s) already loaded inside %s, skippingz4Unloading %s.%s because dependency (%s%s) is not metz version {}� Z__func_alias__r' �fallback_functionz %s already removed, skipping)r �items�f_locals�getr �getattrr= �OSError�errno�ENOENTr r �filenamer. r/ ZversionsZ version_cmpr, �AttributeError�KeyError)�clsZ functionsr# Ztgt_modr7 Zdependent_dictr$ r8 r! r Z dep_foundZ dep_versionr< r% Zmod_keyrB r r r �enforce_dependencies� s� � ��� ����������� � � ����z Depends.enforce_dependenciesN) r � __module__� __qualname__�__doc__r r r r& � staticmethodr= � classmethodrN r r r r r s 2 r c � t � �� fdd��}|S )zI Decorator wrapper to log execution time, for profiling purposes c sx t � � }� | i tjjjdi |����}t � � }� j�d�r%� jdd � }n� j}d�tj j �}t � ||� j || � |S )Nzsalt.loaded.int.� z,Function %s.%s took %.{}f seconds to executer )�timer. r/ r0 � clean_kwargsrO � startswithr, �sys� float_info�digr Zprofiler )r0 r Z start_time�retZend_timer$ Zfstr�r r r �wrapped s ztiming.<locals>.wrappedr �r r^ r r] r �timing� s r` c s i � t ��� �fdd��}|S )z� Memoize aka cache the return output of a function given a specific set of arguments .. versionedited:: 2016.3.4 Added **kwargs support. c sx g }| D ]}t |t�s|�t|�� q|�|� qd�t|�� fdd�t� �D � �}|�vr8�| i � ���|< �| S )N�,c s g | ] }d � |� | ��qS )z{}={})r, )�.0�k�r r r � <listcomp>& s z-memoize.<locals>._memoize.<locals>.<listcomp>)� isinstance�str�append�join�list�sorted)r0 r Zstr_args�argZargs_��cache�funcrd r �_memoize s �zmemoize.<locals>._memoizer )ro rp r rm r �memoize s rq c @ s8 e Zd ZdZdZdZdd� Zdd� Zdd � Zd d � Z d S ) �_DeprecationDecoratorz} Base mix-in class for the deprecation decorator. Takes care of a common functionality, used in its derivatives. � r c C sH ddl m}m} || _|| _|�| j�| _|j| _d| _ d| _ d| _ dS )z� Constructor. :param globals: Module globals. Important for finding out replacement functions :param version: Expiration version :return: r )�SaltStackVersion�__saltstack_version__N) Z salt.versionrt ru �_globals�_exp_version_name� from_name� _exp_version�info� _curr_version� _raise_later� _function� _orig_f_name)r �globalsr@ rt ru r r r r 8 s z _DeprecationDecorator.__init__c C s" t � }tjjjdi |��}||fS )z Discard all keywords which aren't function-specific from the kwargs. :param kwargs: :return: Nr )rj r. r/ r0 rW )r r �_args�_kwargsr r r � _get_argsJ s z _DeprecationDecorator._get_argsc C s� | j r| j �| jrW| �|�\}}z | j|i |��W S tyA } z t|��| j| j�}t�d| j|� | jj W Y d}~S d}~w t yV } z t�d| jj |� � d}~ww t d��)zQ Call target function that has been decorated. :return: z)Function "%s" was not properly called: %sNz0Unhandled exception occurred in function "%s: %szAFunction is deprecated, but the successor function was not found.) r| r} r� � TypeErrorrg �replacer~ r �errorrQ r r r )r r r0 r� r r r �_call_functionV s: �������z$_DeprecationDecorator._call_functionc C s || _ | j j| _dS )�� Callable method of the decorator object when the decorated function is gets called. :param function: :return: N)r} r r~ )r r r r r r& y s z _DeprecationDecorator.__call__N) r rO rP rQ �OPT_IN�OPT_OUTr r� r� r& r r r r rr / s #rr c @ s" e Zd ZdZddd�Zdd� ZdS )� _IsDeprecateda_ This decorator should be used only with the deprecated functions to mark them as deprecated and alter its behavior a corresponding way. The usage is only suitable if deprecation process is renaming the function from one to another. In case function name or even function signature stays the same, please use 'with_deprecated' decorator instead. It has the following functionality: 1. Put a warning level message to the log, informing that the deprecated function has been in use. 2. Raise an exception, if deprecated function is being called, but the lifetime of it already expired. 3. Point to the successor of the deprecated function in the log messages as well during the blocking it, once expired. Usage of this decorator as follows. In this example no successor is mentioned, hence the function "foo()" will be logged with the warning each time is called and blocked completely, once EOF of it is reached: from salt.util.decorators import is_deprecated @is_deprecated(globals(), "Beryllium") def foo(): pass In the following example a successor function is mentioned, hence every time the function "bar()" is called, message will suggest to use function "baz()" instead. Once EOF is reached of the function "bar()", an exception will ask to use function "baz()", in order to continue: from salt.util.decorators import is_deprecated @is_deprecated(globals(), "Beryllium", with_successor="baz") def bar(): pass def baz(): pass Nc C s t �| ||� || _dS )z� Constructor of the decorator 'is_deprecated'. :param globals: Module globals :param version: Version to be deprecated :param with_successor: Successor function (optional) :return: N)rr r � _successor)r r r@ Zwith_successorr r r r � s z_IsDeprecated.__init__c s$ t �� |� t|�� fdd��}|S )r� c s� � j � jk r'dj� jj� jd�g}� jr |�dj� jd�� t� d� |�� n%dj� jjd�g}� jr=|�dj� jd�� t� d� |�� t d� |���� � |�S ) �w Decorator function. :param args: :param kwargs: :return: �RThe function "{f_name}" is deprecated and will expire in version "{version_name}".��f_nameZ version_namez$Use successor "{successor}" instead.�� successor� �0The lifetime of the function "{f_name}" expired.�r� �/Please use its successor "{successor}" instead.) r{ ry r, r} r rw r� rh r �warningri r r� )r0 r �msg�r r r � _decorate� s6 �������� z)_IsDeprecated.__call__.<locals>._decorate)rr r& r �r r r� r r� r r& � s 'z_IsDeprecated.__call__r )r rO rP rQ r r& r r r r r� � s - r� c @ sD e Zd ZdZdZdZdZdejfdd�Z dd � Z d d � Z d d � Z dS )�_WithDeprecatedaf This decorator should be used with the successor functions to mark them as a new and alter its behavior in a corresponding way. It is used alone if a function content or function signature needs to be replaced, leaving the name of the function same. In case function needs to be renamed or just dropped, it has to be used in pair with 'is_deprecated' decorator. It has the following functionality: 1. Put a warning level message to the log, in case a component is using its deprecated version. 2. Switch between old and new function in case an older version is configured for the desired use. 3. Raise an exception, if deprecated version reached EOL and point out for the new version. Usage of this decorator as follows. If 'with_name' is not specified, then the name of the deprecated function is assumed with the "_" prefix. In this case, in order to deprecate a function, it is required: - Add a prefix "_" to an existing function. E.g.: "foo()" to "_foo()". - Implement a new function with exactly the same name, just without the prefix "_". Example: from salt.util.decorators import with_deprecated @with_deprecated(globals(), "Beryllium") def foo(): "This is a new function" def _foo(): "This is a deprecated function" In case there is a need to deprecate a function and rename it, the decorator should be used with the 'with_name' parameter. This parameter is pointing to the existing deprecated function. In this case deprecation process as follows: - Leave a deprecated function without changes, as is. - Implement a new function and decorate it with this decorator. - Set a parameter 'with_name' to the deprecated function. - If a new function has a different name than a deprecated, decorate a deprecated function with the 'is_deprecated' decorator in order to let the function have a deprecated behavior. Example: from salt.util.decorators import with_deprecated @with_deprecated(globals(), "Beryllium", with_name="an_old_function") def a_new_function(): "This is a new function" @is_deprecated(globals(), "Beryllium", with_successor="a_new_function") def an_old_function(): "This is a deprecated function" Z__virtualname__�use_deprecated�use_supersededNc C s t �| ||� || _|| _dS )z� Constructor of the decorator 'with_deprecated' :param globals: :param version: :param with_name: :param policy: :return: N)rr r � _with_name�_policy)r r r@ � with_name�policyr r r r A s z_WithDeprecated.__init__c C s dj | j�| jd�p| jd �d�d |jd�}|�d�r'tdj |jd��| _| j�d d �}| j�d d �}||�| j t � �v pH||�| j t � �v }||�| j t � �v p\||�| j t � �v }|rh|rht d � |���| j�| j psd � |j��}| j| jkr�|r�|| _dS || _dS |r�|n|| _dS )zg Based on the configuration, set to execute an old or a new function. :return: �{m_name}.{f_name}rA r r r? �Zm_namer� z(Module not found for function "{f_name}"r� �__opts__z{}� __pillar__zaFunction '{}' is mentioned both in deprecated and superseded sections. Please remove any of that.z_{}N)r, rv rE � MODULE_NAME�splitr rX r r| �CFG_USE_DEPRECATEDrj �CFG_USE_SUPERSEDEDr r� r� r� r} )r r r9 �optsZpillarr� r� Z old_functionr r r � _set_functionQ sD � �������� z _WithDeprecated._set_functionc C s� dj | j�| jd�p| jd �d�d | jd�}|| j�d��| jt� �v pW|| j�d��| jt� �v pW| j| j koW|| j�di ��| j t� �voW|| j�di ��| j t� �v|fS ) z� Returns True, if a component configuration explicitly is asking to use an old version of the deprecated function. :return: r� rA r r r? r� r� r� ) r, rv rE r� r� r~ r� rj r� r� r� )r � func_pathr r r �_is_used_deprecatedz s4 ���� ������z#_WithDeprecated._is_used_deprecatedc s8 t ��� � t� �� �fdd��}�jj|_�j|_|S )r� c s$ �� � � ��� \}}|r��j�jk rMt� }�jr9|�dj�j�d�r&�j p(�j�j d�� |�dj�j d�� n |�dj|�j d�� t � d� |�� n@d}d�j �jjkrb|j�j d �d g}n d j�j �jpk�j d �|j�jpt�j d �d j�j d�g}t �d� |�� td� |�����|�S )r� r� r" r� z(Use its successor "{successor}" instead.r� zdThe function "{f_name}" is using its deprecated version and will expire in version "{version_name}".r� r� r� z;Please turn off its deprecated version in the configurationzeAlthough function "{f_name}" is called, an alias "{f_alias}" is configured as its deprecated version.)r� Zf_aliasr� )r� r� r{ ry rj r� rh r, rX r~ rw r r� ri r} r r� r r� )r0 r � is_deprecatedr� r� Zmsg_patt�r r r r r� � s` ��� ���� � � ��� z+_WithDeprecated.__call__.<locals>._decorate)rr r& r r} rQ � __wrapped__r� r r� r r& � s >z_WithDeprecated.__call__) r rO rP rQ r� r� r� rr r� r r� r� r& r r r r r� � s E �) $r� c � � fdd�}|S )aK Decorator to filter out exclusive arguments from the call. kwarg_names: Limit which combination of arguments may be passed to the call. Example: # Require one of the following arguments to be supplied to foo() @require_one_of('arg1', 'arg2', 'arg3') def foo(arg1, arg2, arg3): c � t � �� �fdd��}|S )Nc sz ��fdd��D �}|� � ��fdd�t� �D �� t|�dkr*td�d������|s6td�d�������� i ���S )Nc � g | ] }�| r|� v r|�qS r r �rb �key�� kwarg_namesr r r re � zArequire_one_of.<locals>.wrapper.<locals>.func.<locals>.<listcomp>c �0 g | ]\}}� | r�j j| �v r� | �qS r ��__code__� co_varnames�rb �irl �r0 �fr� r r re � ��rs z(Only one of the following is allowed: {}�, z)One of the following must be provided: {}��extend� enumerate�lenr r, ri �r0 r �names�r� r� �r0 r r ro s& �� ����z-require_one_of.<locals>.wrapper.<locals>.funcr �r� ro �r� �r� r �wrapper� s z require_one_of.<locals>.wrapperr �r� r� r r� r �require_one_of� s r� c r� )aL Decorator to filter out exclusive arguments from the call. kwarg_names: Limit which combination of arguments may be passed to the call. Example: # Allow only one of the following arguments to be supplied to foo() @allow_one_of('arg1', 'arg2', 'arg3') def foo(arg1, arg2, arg3): c r� )Nc sb ��fdd��D �}|� � ��fdd�t� �D �� t|�dkr*td�d�������� i ���S )Nc r� r r r� r� r r re 0 r� z?allow_one_of.<locals>.wrapper.<locals>.func.<locals>.<listcomp>c r� r r� r� r� r r re 2 r� rs z$Only of the following is allowed: {}r� r� r� r� r� r ro . s �� ��z+allow_one_of.<locals>.wrapper.<locals>.funcr r� r� r� r r� - s z allow_one_of.<locals>.wrapperr r� r r� r � allow_one_of s r� c r� )z� Decorator to filter out unexpected keyword arguments from the call kwarg_names: List of argument names to ignore c r� )Nc s. |� � }�D ] }||v r||= q� | i |��S r )�copy)r0 r Zkwargs_filtered�name)�fnr� r r �__ignores_kwargsN s �zAignores_kwargs.<locals>._ignores_kwargs.<locals>.__ignores_kwargsr )r� r� r� )r� r �_ignores_kwargsM s z'ignores_kwargs.<locals>._ignores_kwargsr )r� r� r r� r �ignores_kwargsE s r� c rT )z> Decodes all arguments passed to the wrapped function c s � | i |��S r r r� r] r r r^ ` s z$ensure_unicode_args.<locals>.wrappedr r_ r r] r �ensure_unicode_args[ s r� )%rQ rH r Zloggingr1 rY rV � collectionsr � functoolsr Zsalt.utils.argsr. Zsalt.utils.dataZsalt.utils.versionsZsalt.exceptionsr r r r- rF Z getLoggerr r r Zdependsr` rq rr r� r� r� Zwith_deprecatedr� r� r� r� r r r r �<module> s@ [ Vo v.(
Save