File: //opt/saltstack/salt/lib/python3.10/site-packages/salt/loader/__pycache__/lazy.cpython-310.pyc
o
�N�gT� � @ sr d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Z d dl
Z
d dl Z d dl Z d dl
Z
d dlZd dlZd dlmZ d dlmZ d dlZd dlZd dlZd dlZd dlZd dlZd dlZd dl Zd dl Zd dl Zd dl Zd dl Zd dl!Zd dl"Zd dl#Zd dl$Zd dl%m&Z& zd dl'Z(W n
e)y� d dl(Z(Y nw e�*e+�Z,dZ-dZ.dZ/dZ0g Z1ej2j3D ]
Z4e1�5e4d e/f� q�ej2j6D ]
Z4e1�5e4d e-f� q�ej2j7D ]
Z4e1�5e4d e.f� q�e-ej2j8e.ej2j9e/ej2j:iZ;e�<ej=j>��?� Z@d
ZAe �Bd jCe
jDdd� � �ZEdaFd d
� ZGdd� ZHG dd� de�ZIG dd� d�ZJG dd� d�ZKG dd� dejLjMjN�ZOdd� ZPdS )� N)�MutableMapping)� zipimporter)�Depends� � � � �rbz salt.loadedz \.cpython-{}{}(\.opt-[1-9])?c C sJ | t jv rd S d�| �d�d �}t�t| ��}t||j� |t j| < d S )Nz"'''Salt loaded {} parent module'''�.���) �sys�modules�format�split�types�
ModuleType�str�exec�__dict__)�name�code�module� r �D/opt/saltstack/salt/lib/python3.10/site-packages/salt/loader/lazy.py�_generate_moduleK s
r c C s | � tt��r dS dS )N�int�ext)�
startswithr �SALT_BASE_PATH)Z module_pathr r r � _mod_typeV s r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dS )�FilterDictWrapperzx
Create a dict which wraps another dict with a specific key suffix on get
This is to replace "filter_load"
c C s || _ || _d S �N��_dict�suffix)�self�dr$ r r r �__init__c s
zFilterDictWrapper.__init__c C s || j |< d S r! �r# )r% �key�valr r r � __setitem__g s z FilterDictWrapper.__setitem__c C s | j |= d S r! r( �r% r) r r r � __delitem__j � z FilterDictWrapper.__delitem__c C s | j || j S r! r" r, r r r � __getitem__m s z FilterDictWrapper.__getitem__c C s
t | j�S r! )�lenr# �r% r r r �__len__p s
zFilterDictWrapper.__len__c c s. � | j D ]}|�| j�r|�| jd�V qd S )N� )r# �endswithr$ �replacer, r r r �__iter__s s �
��zFilterDictWrapper.__iter__N)
�__name__�
__module__� __qualname__�__doc__r' r+ r- r/ r2 r6 r r r r r \ s r c @ s< e Zd ZdZdd� Zedd� �Zdd� Zdd � Zd
d � Z d S )
�
LoadedFunca�
The functions loaded by LazyLoader instances using subscript notation
'a[k]' will be wrapped with LoadedFunc.
- Makes sure functions are called with the correct loader's context.
- Provides access to a wrapped func's __global__ attribute
:param func str: The function name to wrap
:param LazyLoader loader: The loader instance to use in the context when the wrapped callable is called.
c C s || _ || _t�| | j� d S r! )r �loader� functools�update_wrapper�func)r% r r< r r r r' � s zLoadedFunc.__init__c C s | j j| j S r! )r< r# r r1 r r r r? � s zLoadedFunc.funcc C s t | j|�S r! )�getattrr? �r% r r r r � __getattr__� r. zLoadedFunc.__getattr__c O s� | j }tj|j }d}t|d�r*t|jtjj j
�s*d| jj v r*| jj d |jd< d}| jj r6t
| jj �|�}| jj|g|�R i |��}|rN|jd | jj d< |S )NF�__opts__�testT)r? r r
r8 �hasattr�
isinstancerC �saltr< �context�NamedLoaderContext�opts�inject_globals�global_injector_decorator�run)r% �args�kwargsZrun_func�modZset_test�retr r r �__call__� s
zLoadedFunc.__call__c C s d| j j� d| j�d�S )N�<z name=�>)� __class__r7 r r1 r r r �__repr__� s zLoadedFunc.__repr__N)
r7 r8 r9 r: r' �propertyr? rB rR rV r r r r r; y s
r; c @ s, e Zd ZdZdZdd� Zdd� Zdd� Zd S )
� LoadedModz:
This class is used as a proxy to a loaded module
�rP r< c C s || _ || _dS )zd
Return the wrapped func's globals via this object's __globals__
attribute.
NrY )r% rP r< r r r r' � s
zLoadedMod.__init__c C s> z | j | j� d|� � W S ty td|� d| j� ���w )zC
Run the wrapped function in the loader's context.
r
z No attribute by the name of z was found on )r< rP �KeyError�AttributeErrorrA r r r rB � s ��zLoadedMod.__getattr__c C s d� | jj| jj| j�S �Nz<{} module='{}.{}'>)r rU r7 r< �loaded_base_namerP r1 r r r rV � s �zLoadedMod.__repr__N)r7 r8 r9 r: � __slots__r' rB rV r r r r rX � s rX c s� e Zd ZdZeZ d4� fdd� Zdd� Z� fd d
�Zd d � Z d
d� Z
dd� Z dd� Z � fdd�Z
dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd5d*d+�Zd,d-� Zd.d/� Zd0d1� Ze d2d3� �Z � Z S )6�
LazyLoadera�
A pseduo-dictionary which has a set of keys which are the
name of the module and function, delimited by a dot. When
the value of the key is accessed, the function is then loaded
from disk and into memory.
.. note::
Iterating over keys will cause all modules to be loaded.
:param list module_dirs: A list of directories on disk to search for modules
:param dict opts: The salt options dictionary.
:param str tag: The tag for the type of module to load
:param func mod_type_check: A function which can be used to verify files
:param dict pack: A dictionary of function to be packed into modules as they are loaded
:param list whitelist: A list of modules to whitelist
:param bool virtual_enable: Whether or not to respect the __virtual__ function when loading modules.
:param str virtual_funcs: The name of additional functions in the module to call to verify its functionality.
If not true, the module will not load.
:param list extra_module_dirs: A list of directories that will be able to import from
:param str pack_self: Pack this module into a variable by this name into modules loaded
:returns: A LazyLoader object which functions as a dictionary. Keys are 'module.function' and values
are function references themselves which are loaded on-demand.
# TODO:
- move modules_max_memory into here
- singletons (per tag)
Nr Tc s� d| _ i | _|du r i n|| _| jD ]}t| j| tjjj�r)| j| �� | j|< q|du r0i }t �
|�}dD ]}||v rOt|| tjjj�rO|| �� ||< q7|� d� }tj jj
|d�| _| �|�| _|
| _|| _|| _d| _|ptt| _|pyt| _|| _d| jvr�d| jd< | j�� D ]\}}|du r�| j�|i � tj j� | j|�| j|< q�|| _ || _ d| _ i | _ t!� | _"t!� | _#| r�| ng | _$| du r�g } | | _%| r�| ng | _&g | _'t!| j� d�(| j| jd d kr�d
nd �g ��| _)i | _*d
g| _+t,D ]\}}}|||f| j*|< | j+�-|� q�t.�/� | _0| j0� | �1� W d � n 1 �s$w Y t2� �3� t4| j� d �� t4| j� d |� �� t4| j� d
�� t4| j� d|� �� dS )zz
In pack, if any of the values are None they will be replaced with an
empty context-specific dict
N)�pillar�grains�multiprocessing)Z
threadsafe� __context__Tz disable_{}{}r �sr3 z.intz.int.z.extz.ext.)5�
parent_loaderrK �packrF rG r< rH rI �value�copy�deepcopy�get�utilsZ ContextDict� context_dict�_LazyLoader__prep_mod_optsrJ � pack_self� module_dirs�tagZ
_gc_finalizer�LOADED_BASE_NAMEr] r �mod_type_check�(_only_pack_properly_namespaced_functions�items�
setdefault�NamespacedDictWrapper� whitelist�virtual_enable� initial_load�missing_modules�set�loaded_modules� loaded_files�static_modules�
virtual_funcs�extra_module_dirs�_clean_module_dirsr �disabled�
suffix_map� suffix_order�SUFFIXES�append� threading�RLock�_lock�_refresh_file_mapping�superr' r )r% ro rJ rp r] rr rf rw rx r~ �proxyr r� rn rs �iZ threadsafety�k�vr$ �mode�kind�rU r r r' � s�
�
��
�
�� ��
�
zLazyLoader.__init__c C s( t tj�D ] }|�| j�rtj|= qdS )z
Clean modules
N)�listr r
r r] rA r r r �
clean_modulesP s
��zLazyLoader.clean_modulesc s t � �|� t|| �S )z�
Override the __getitem__ in order to decorate the returned function if we need
to last-minute inject globals
)r� r/ r; )r% �itemr� r r r/ X s
zLazyLoader.__getitem__c C s� |dv r
t �| |�S zt �| |�W S ty Y nw || jvr=| js=| �|�D ]}|| jv r0q(| �|�r<|| jv r< nq(|| jv rGt || �S t|��)z�
Allow for "direct" attribute access-- this allows jinja templates to
access things like `salt.test.ping()`
)� __getstate__� __setstate__)
�object�__getattribute__rB r[ r| �loaded� _iter_filesr} � _load_modulerX )r% �mod_namer r r r rB ` s" �
�
zLazyLoader.__getattr__c C s d� | jj| j| j�S r\ )r rU r7 r] rp r1 r r r rV { s �zLazyLoader.__repr__c C sr |� d�d }|| jv rd|� d�S z| j| }W n ty( d|� d� Y S w |dur3d�||�S d|� d�S )z�
Return the error string for a missing function.
This can range from "not available' to "__virtual__" returned False
r
r �'z' is not available.Nz#'{}' __virtual__ returned False: {}z ' __virtual__ returned False)r r| rz rZ r )r% Z
function_namer� �reasonr r r �missing_fun_string� s
�� z LazyLoader.missing_fun_stringc s� | j �dd�du r8d| jvr8ztd�at�� t� | jd< d| jvr(| j�d� W n t y7 t
� d� Y nw | j �dd�du rWd| jvrWt� | jd< d| jvrW| j�d� ddt f| jd< t
jj�� | _g � � fd d
�}| jD �]V}ztd d � t�|�D ��}W n ty� Y qqw zd
d� tt�tj�|d���D �}W n ty� Y nw |�|� |D �]}�z tj�|�\}}|�d�r�W q�tj� |�\}} t � ||�}zt � � � �!d��"dd�d �}
W n t#t$t%fy� d}
Y nw z
| j d �&|
�} W n t'�y t
�(d|
||
� Y W q�w | | jv�rW q�|| j)v �r&t
�(d|� W q�tj�||�} | dk�rSt�| �}
| jD ]}d|k�rC�q:d|� �}||
v �rO n�q:W q�z| j| d }| j| d }W n
t'�ym Y n=w d|| fv �r�|| k�r�t
�*d| | j| d � | dk�r�|dk�r�| |k�r�W q�n|�r�| j�&| �| j�&|�k�r�W q�|�s�| dk�r�W q�| | | f| j|< W q� t�y� Y q�w qq| j+D ]}|�d �d }|d df| j|< �q�d S ) z7
refresh the mapping of the FS on disk
Z
cython_enableT�.pyx� pyximportz]Cython is enabled in the options but not present in the system path. Skipping Cython modules.Zenable_zip_modules�.zipr3 c s � � | � dS )a
Hack so we can get the optimization level that we replaced (if
any) out of the re.sub call below. We use a list here because
it is a persistent data structure that we will be able to
access after re.sub is called.
r3 )r� )�obj�Z opt_matchr r �_replace_pre_ext� s
z:LazyLoader._refresh_file_mapping.<locals>._replace_pre_extc s s � | ] }|d kr|V qdS )� __pycache__Nr ��.0�xr r r � <genexpr>� s � z3LazyLoader._refresh_file_mapping.<locals>.<genexpr>c S s g | ] }t j�d |��qS )r� )�os�path�joinr� r r r �
<listcomp>� s ��z4LazyLoader._refresh_file_mapping.<locals>.<listcomp>r� �_r �-r r Zoptimization_orderz�Disallowed optimization level %d for module name '%s', skipping. Add %d to the 'optimization_order' config option if you do not want to ignore this optimization level.z,Skipping %s, it is disabled by configurationr' r z'Module/package collision: '%s' and '%s'z.pycr
�.oN),rJ rj r� �
__import__r� �install�tupler� r� � ImportError�log�info�MODULE_KIND_PKG_DIRECTORYrG rk Zodict� OrderedDict� file_mappingro �sortedr� �listdir�OSErrorr� r� �extendr r �splitext� PY3_PRE_EXT�subr �pop�group�rsplitr[ �
IndexError�
ValueError�indexrZ �tracer� �errorr~ )r% r� Zmod_dir�filesZ
pycache_files�filename�dirname�basenameZf_noextr � opt_levelZ opt_index�fpathZsubfilesr$ Z init_fileZcurr_extZcurr_opt_index�smodr r� r r� � s�
� ��
�
� �
"��
� �
�� �
� �
���
X�z LazyLoader._refresh_file_mappingc sd | j �% t� �� t� | _i | _t� | _t| d�r | �� d| _ W d � dS 1 s+w Y dS )z
Clear the dict
rJ FN)
r� r� �clearr{ r} rz r| rE r� ry r1 r� r r r� 4 s
"�zLazyLoader.clearc C s� d| j vr(|�di �}t|tjjj�r|�� }|| jd< tj j�
| jd�| j d< d| j vrP|�di �}t|tjjj�r?|�� }|| jd< tj j�
| jd�| j d< i }t |� � �D ]
\}}|dkraqX|||< qXd| j vrp|| j d< |S )z;
Strip out of the opts any logger instance
Z
__grains__ra Z
__pillar__r` �loggerrC )
rf rj rF rG r< rH rI rg rl rk rv r� rt )r% rJ ra r` Zmod_optsr) r* r r r Z__prep_mod_optsC s0
�
�
zLazyLoader.__prep_mod_optsc c sJ � || j v r |V | j D ] }||v r|V q | j D ] }||vr"|V qdS )zW
Iterate over all file_mapping files in order of closeness to mod_name
N)r� )r% r� r� r r r r� d s �
�
��zLazyLoader._iter_filesc sJ � fdd�t � �D �}|D ]}|j�� jd �r"t�|� | �|� q
d S )Nc 3 s, � | ]}t t� |�� j�rt� |�V qd S r! )rF r@ rU )r� Zsname�rP r r r� w s � �
�z0LazyLoader._reload_submodules.<locals>.<genexpr>r
)�dirr7 r � importlib�reload�_reload_submodules)r% rP Z
submodulesZ submoduler r� r r� v s
�
��z LazyLoader._reload_submodulesc C s2 | j D ]}|tjvrtj�|� | j�|� qd S r! )r� r r� r� r� )r% � directoryr r r Z__populate_sys_path� s
��z LazyLoader.__populate_sys_pathc C sp d}| j D ]}|tjv rtj�|� d}qg | _ t�� |r4| jD ]}|tjv r3tj| d u r3tj|= q!d S d S )NFT)r� r r� �remover� �invalidate_cachesr� �path_importer_cache)r% Z invalidate_path_importer_cacher� r r r Z__clean_sys_path� s
�
��zLazyLoader.__clean_sys_pathc / C s� d }| j | d d� \}}z tjj�d�\}}||vr+||v r+t�d|tjj� W dS W n ty5 Y nw | j� |� t
j � |�}�z�z�| �
� tj �|� |dkr]t�||t�� �}n�|dkr�t|t� t� g �}|�d�} t| �dk rx|}n�|}| dd � D ]}
t||
�}q�n�|d kr�t|��|�}n�| j| } zd�| j| � |�| j |f�} W n t y� d
� | j| � |�| j |�} Y nw |d k�rt j!j"t j!j#ft j!j$t j!j%ft j!j&t j!j'fg}
t j!j(|g|
�R � }|�)| �}|d u r�t*� �|j+�� }|tj,| < | j-�s| �.|� n&t/| d | |�}t j0j1| ||d �}|d u �r!t*� �| �2|j+j�}|tj,| < W n� t3�y7 � t*�y| } z9d
t4|�v �rWd� | j |�}t�5|� || j6|< tj7d| j |dd� || j6|< W Y d }~W tj �8|� | �9� dS d }~w t:�y� } z!tj;d| j |dd� || j6|< W Y d }~W tj �8|� | �9� dS d }~w t<�y" } zmzt=�>t�?� d �d \}}}}W n
t@�y� Y n1w t
j �ddd�t
j �ddd�t
j �ddd�g}|D ]}|�A|��r�d|v �r�t�BtCjDjEjF� �q�tj;d| j |dd� || j6|< W Y d }~W tj �8|� | �9� dS d }~ww W tj �8|� | �9� n tj �8|� | �9� w tCj+jG�H� }tI|d ��rZtJ|jKtCj+jGjH��sYt�5d |� ||_Kn||_KtI|d ��r�tJ|jLtCj+jGjM��s�tI|d ��sztN�O|jL�|_PtN�O|jP�|_L|jL�Q| jR� ntI|d ��s�i |_PtN�O|jP�|_L|jL�Q| jR� | jS�T� D ]N\}}|d k�r��q�t||d �} tI| d ��r�tN�O| jU�} nd } |�V|| �} | d u �r�tW||| � �q�| | k�r�t�7d!||� tW||| � �q�tW||| � �q�| jXd u�r@t|| jXd �} tI| d ��rtN�O| jU�} nd } |�V| jX| �} | d u �r$tW|| jX| � n | | k�r9t�7d!| jX|� tW|| jX| � ntW|| jX| � |jY�Zdd�d } t|d"d �} t[�\| ��r�z | �2| | jR� W n9 t �yv }! z t�;|!� W Y d }!~!n&d }!~!w t:�y� d#}"tj7d$| j | |"dd� |"| j6| < |"| j6|< Y dS w | j]�r�d%g| j^ }#|#D ]4}$| �_|| |$�\}%} }&}'|&d u�r�t�d$| j | |&� |%du�r�| | j6v�r�|&| j6| < |&| j6|< dS �q�nd&}'d'| jRv �r
| j d(v �r
tI|d)��r�| jRd' d* |j`v�r
d+|j`v�r
d,}"|"| j6| < |"| j6|< dS z |ja}(t�7d-| � W n* t�yB z |jb}(t�7d.| � W n t�y? tc|�}(t�7d/| � Y nw Y nw | gtd|'� })|(D ]o}*|*�ed0��rV�qLt||*�}+t[�\|+��sjtJ|+tfjg��sj�qL| jh�rx|+ji�e| j��sx�qLt|d1i ��j|*|*�},|)D ]5}-z d�|-|,f�}.W n t �y� |-� d|,� �}.Y nw |.| jkv�r�|+| jk|.< | �l|+|� | jm� |-� �q��qLz tn�o| jk| j |� W dS tp�y� } z
t�qd2|� W Y d }~dS d }~ww )3Nr r� z)Trying to load %s on %s, returning False.Fr� r� r
r r� z {}.{}.{}.{}r3 )r< z magic numberztFailed to import {} {}. Bad magic number. If migrating from Python2 to Python3, remove all .pyc files and try again.zFailed to import %s %s:
T��exc_infozCFailed to import %s %s, this is due most likely to a syntax error:
r rG rk z
process.pyZcliz
daemons.pyzapi.pyZ_handle_signalsz3Failed to import %s %s as the module called exit()
�__salt_loader__z Override __salt_loader__: %srC �
__orig_opts__�defaultzOverride %s: %sr' z__init__ failedzError loading %s.%s: %s� __virtual__r r� )ra r� �__proxyenabled__Z proxytype�*z!not a proxy_minion enabled modulezTThe functions from module '%s' are being loaded from the provided __load__ attributezSThe functions from module '%s' are being loaded from the provided __all__ attributezMThe functions from module '%s' are being loaded by dir() on the loaded moduler� Z__func_alias__zBDepends.enforce_dependencies() failed for the following reason: %s)rr� r �implementation� cache_tagr r� r� r[ r} �addr� r� r� � _LazyLoader__populate_sys_pathr� r� � load_module�tempfileZ
gettempdirr� �globals�localsr0 r@ r r� r� r] rr rp � TypeErrorr r� � machinery�SourceFileLoader�SOURCE_SUFFIXES�SourcelessFileLoader�BYTECODE_SUFFIXES�ExtensionFileLoader�EXTENSION_SUFFIXES�
FileFinder� find_specr� r< r
ry r� �MODULE_KIND_MAP�util�spec_from_file_locationrM r� r �warningrz �debugr� �_LazyLoader__clean_sys_path� Exceptionr� �
SystemExit� traceback�
extract_tbr� r� r4 �exitrG �defaultsZ exitcodes�EX_OKrH Z
LoaderContextrE rF r� rC rI rh ri r� �updaterJ rf rt r� �
named_context�setattrrn r7 r� �inspect�
isfunctionrx r �_process_virtualr� Z__load__�__all__r� r� r r= �partialrs r8 rj r# �_apply_outputterr| r Zenforce_dependencies� RuntimeErrorr� )/r% r rP r� r$ Zimplementation_tagZ
cache_tag_verZ
fpath_dirnameZtop_mod�compsZsubname�descZ
mod_namespace�loader_detailsZ file_finder�specr< �excZ error_msgr� Zfn_r� ZcallerZtgt_fnsZtgt_fnZloader_contextZp_nameZp_valueZmod_named_contextr� r � module_nameZ module_init�eZ
err_stringZvirtual_funcs_to_process� virtual_funcZ virtual_retZ virtual_err�virtual_aliasesZ
funcs_to_loadZ mod_names�attrr? �funcnameZtgt_modZ
full_funcnamer r r r� � sP ��� �
�
�� ��
������
��
���
$ ���
��"����
���
�
� �
��
� �
�
��
������
� � �
�
����zLazyLoader._load_modulec s t � t�s td��d� vrtd� � d���� �dd�\}}�j�c |�jv s+� �jv r4 W d � dS �jrI|�jvrIt� d� |�j� t� ��� �fd d
�}d}d } z||�}|sh|durh��
� d}W qTW n t yz |sx��
� d}Y qTw W d � |S 1 s�w Y |S ) z3
Load a single item if you have it
zThe key must be a string.r
z The key 'z' should contain a '.'r NTzNFailed to load function %s because its module (%s) is not in the whitelist: %sc s: �� | �D ]}|�jv r
q��|�r� �jv r dS qdS )NTF)r� r} r� r# )r� r �r) r% r r � _inner_load% s
�z%LazyLoader._load.<locals>._inner_loadF) rF r rZ r r� rz r# rw r� r� r� r� )r% r) r� r� r rQ Zreloadedr r r �_load sN
��
��
�,�,zLazyLoader._loadc C s^ | j �" | jD ]}|| jv s|| jv rq| �|� qd| _W d � dS 1 s(w Y dS )z"
Load all of them
TN)r� r� r} rz r� r� rA r r r � _load_allC s
"�zLazyLoader._load_allc C s< | j � t� | _| �� W d � d S 1 sw Y d S r! )r� r{ r} r r1 r r r �reload_modulesO s
"�zLazyLoader.reload_modulesc C s2 t |d�r|j}|j|v r||j |_dS dS dS )zC
Apply the __outputter__ variable to the functions
�
__outputter__N)rE r r7 )r% r? rP Zoutpr r r r T s
�zLazyLoader._apply_outputterr� c
C s� t |dt� �}z�d}t|d�r�t�|j�r�z5t�� }t ||�}| �|�}t|t�r1|d }|d }| j �
dd�rIt�� | } d� | |�}
t �
|
� W n# tym } zd � |j| �}t j|tjd
� d}W Y d} ~ nd} ~ ww t |d |�} |s�|du r�t �
d |j|� d|||fW S |d
ur�||kr�t �d||� | |kr�t �d|j| |� | }n|d
u r�| |kr�| d
ur�| }W n) ty� t jd|d
d� Y n ty� t jd| j|d
d� d|||f Y S w d
|d|fS )a"
Given a loaded module and its default name determine its virtual name
This function returns a tuple. The first value will be either True or
False and will indicate if the module should be loaded or not (i.e. if
it threw and exception while processing its __virtual__ function). The
second value is the determined virtual name, which may be the same as
the value provided.
The default name can be calculated as follows::
module_name = mod.__name__.rsplit('.', 1)[-1]
Z__virtual_aliases__Nr� r r Z
virtual_timerFz'Virtual function took {} seconds for {}z[Exception raised when processing __virtual__ function for {}. Module will not be loaded: {})Zexc_info_on_loglevelZ__virtualname__z�%s.__virtual__() is wrongly returning `None`. It should either return `True`, `False` or a new name. If you're the developer of the module '%s', please fix this.TzLoaded %s as virtual %sz�The module '%s' is showing some bad usage. Its __virtualname__ attribute is set to '%s' yet the __virtual__() function is returning '%s'. These values should match!zKeyError when loading %sr� z.Failed to read the virtual function for %s: %s)r@ r� rE r r r� �timerM rF rJ rj r r� r� r� r7 r� �logging�DEBUGr� rZ r� rp )
r% rP r r r Z error_reason�startZ virtual_attrZvirtual�end�msgr Z virtualnamer r r r ] s~
�
�����
� �
� �� zLazyLoader._process_virtualc O s( t �� | _| jj| j|g|�R i |��S )zD
Run the `_func_or_method` in this loader's context
)� contextvarsZ copy_contextZ
_last_contextrM �_run_as)r% �_func_or_methodrN rO r r r rM � s
zLazyLoader.runc O s� d| _ z tjjj�� }W n ty d}Y nw || ur || _ tjjj�| �}z!||i |��}t|tjjj �r;|�
� }|W d| _ tjjj� |� S d| _ tjjj� |� w )zL
Handle setting up the context properly and call the method
N) re rG r< rH Z
loader_ctxvarrj � LookupErrorr{ rF rI rg �reset)r% r' rN rO Zcurrent_loader�tokenrQ r r r r& � s$ ��zLazyLoader._run_asc O s0 | |g}|� |� tj| j||d�}|�� |S )zR
Run the function in a new thread with the context of this loader
)�targetrN rO )r� r� �Threadr+ r" )r% r' rN rO Zargslist�threadr r r �
run_in_thread� s
zLazyLoader.run_in_threadc O s | j |g|�R i |�� d S r! )rM )r< r' rN rO r r r r+ � s zLazyLoader.target)
Nr NNNNTNNNNNT)r� ) r7 r8 r9 r: �dictZmod_dict_classr' r� r/ rB rV r� r� r� rm r� r� r� r� r� r r r r r rM r& r. � staticmethodr+ �
__classcell__r r r� r r_ � sV �i ! k8
{
r_ c s � fdd�}|S )z�
Decorator used by the LazyLoader to inject globals into a function at
execute time.
globals
Dictionary with global variables to inject
c s t �� �� �fdd��}|S )Nc sH t jjj� fi ���� � | i |��W d � S 1 s w Y d S r! )rG rk rH Zfunc_globals_inject)rN rO )�frK r r �wrapper
s $�zCglobal_injector_decorator.<locals>.inner_decorator.<locals>.wrapper)r= �wraps)r2 r3 �rK )r2 r �inner_decorator s z2global_injector_decorator.<locals>.inner_decoratorr )rK r6 r r5 r rL s rL )Qrh r= r� Zimportlib.machinery�importlib.utilr r r� �pathlib�rer r� r� r r� r �collections.abcr Z zipimportr Z salt.configrG Zsalt.defaults.eventsZsalt.defaults.exitcodesZsalt.loader.contextZ
salt.syspathsZsalt.utils.argsZsalt.utils.contextZsalt.utils.dataZsalt.utils.dictupdateZsalt.utils.eventZsalt.utils.filesZsalt.utils.lazyZsalt.utils.odictZsalt.utils.platformZsalt.utils.stringutilsZsalt.utils.versionsZsalt.utils.decoratorsr Z _contextvarsr% r� � getLoggerr7 r� ZMODULE_KIND_SOURCEZMODULE_KIND_COMPILEDZMODULE_KIND_EXTENSIONr� r� r� r� r$ r� r� r� r� r� r� r� �PathZsyspathsZ INSTALL_DIR�resolver rq �compiler � version_infor� r� r r r r; rX rk ZlazyZLazyDictr_ rL r r r r �<module> s� �
� / C