File: //opt/saltstack/salt/lib/python3.10/site-packages/salt/utils/__pycache__/process.cpython-310.pyc
o
�N�gή � @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
Z ddl Z ddl Z ddl
Z
ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZ ddlm Z e� e �Z dZ!zddl"Z"dZ!W n e#y� Y nw zddl$Z$dZ%W n e#y� dZ%Y nw g Z&dd� Z'd4d d
�Z(d d � Z)d
d� Z*dd� Z+dd� Z,d5dd�Z-dd� Z.dd� Z/dd� Z0dd � Z1d d � Z2d6d d!�Z3d"d#� Z4G d$d%� d%�Z5G d&d'� d'�Z6G d(d)� d)e j7�Z7G d*d+� d+e7�Z8ej9d,d-� �Z:G d.d/� d/�Z;d0d1� Z<d2d3� Z=dS )7zE
Functions for daemonizing and otherwise modifying running processes
� N)�gen)�get_machine_identifierFTc C sJ t r#t�� }|�� �d�r|�dd�\}}t�|�� � d| � �� dS dS )z4
Append "name" to the current process title
� MainProcess� � N)�HAS_SETPROCTITLE� setproctitleZ getproctitle�strip�endswith�rsplit�rstrip)�name�current�_� r �F/opt/saltstack/salt/lib/python3.10/site-packages/salt/utils/process.py�appendproctitle6 s �r c
C sx ddl }zt�� }|dkrt�|jjj� W n" ty8 } zt� d|j
|� t � |jjj
� W Y d}~nd}~ww t�d� t�� t�d� zt�� }|dkrXt � |jjj� W n" ty{ } zt� d|j
|� t � |jjj
� W Y d}~nd}~ww | r�|jj�dd��*}t|t j� t|t j� t|t j� t|d� t|d � t|d
� W d � dS 1 s�w Y dS dS ) z
Daemonize a process
r Nzfork #1 failed: %s (%s)�/� zfork #2 failed: %s (%s)z /dev/nullzr+r � )Zsalt.utils.crypt�os�fork�_exit�defaults� exitcodes�EX_OK�OSError�log�error�errno�sys�exitZ
EX_GENERIC�chdir�setsid�umask�utils�files�fopen�dup2�stdin�stdout�stderr)Z redirect_out�salt�pid�excZdev_nullr r r � daemonizeA sD � ��
� ��
"��r/ c C s� t | t�r| }nz| �� }W n tjy t�d| � Y dS w t |t�r(|}nz|�� }W n tjy? t�d|� Y dS w t�||� dS )z�
Duplicate file descriptor fd to fd2, closing the latter first if necessary.
This method is similar to os.dup2 but ignores streams that do not have a
supported fileno method.
z!Unsupported operation on file: %rN) �
isinstance�int�fileno�io�UnsupportedOperationr �warningr r( )Zfile1Zfile2Zfno1Zfno2r r r r( p s"
�
�r( c C s> dt jd v r dS | �dd�sdS t j�d�rdS td� dS )z}
Daemonize a module function process if multiprocessing is True and the
process is not being called by salt-call
z salt-callr N�multiprocessingT�winF)r �argv�get�platform�
startswithr/ )�optsr r r � daemonize_if� s r= c C s0 t jd| gt jt jd�}|�� |�� }|dkS )�6
Notify systemd that this process has started
�systemd-notify�r* r+ r )�
subprocess�Popen�PIPE� communicate�poll)�action�process�statusr r r �systemd_notify_call� s �rI c C s� zddl } W nT tyZ tjj�d�rWtd�rWt�d�}|rW|� d�r-d|dd� � �}zt
�
t
j t
j �}|�
|� |�d � |�� W Y d S tyV td
� Y Y S w Y d S w | j�� rrz| j�d
�W S tyq Y dS w dS )r> r Nr? z--bootedZ
NOTIFY_SOCKET�@� r s READY=1z--readyTFzREADY=1)Zsystemd.daemon� ImportErrorr, r% �path�whichrI r �getenvr; �socket�AF_UNIX�
SOCK_DGRAM�connect�sendall�closer �daemonZbooted�notify� SystemError)ZsystemdZ
notify_socket�sockr r r �notify_systemd� s4
���
��rZ c C sd | du r t �� } nt�| �sdS t�| �}z|�� W n tjy& Y dS w |j|�� |� � d�S )z�
Gets basic info about a process.
pid: None, or int: None will get the current process pid
Return: None or Dict
N)r- r
Z
start_time)
r �getpid�psutil�
pid_exists�ProcessrH �
NoSuchProcessr- r
Z create_time)r- Zraw_process_infor r r �get_process_info� s
��r` c C sN t s
t�d| � dS tj�| �}tj�|�s |r t�|� d}z tj j
� | d��
}t �
|�}W d � n1 s8w Y W n t jjyO t�d| � Y n ty] t�d| � Y nw t� }||krgdS t|t�rtt|�d�t�svd}t|t�r�|t|�d��kr�dS tj j
� | d ��}t �||� W d � dS 1 s�w Y dS )
z�
Checks that no other live processes has this responsibility.
If claiming the mantle of responsibility was successful True will be returned.
file_name: str
Return: bool
�>Assuming no other Process has this responsibility! pidfile: %sTN�r�pidfile: %s is corrupted�pidfile: %s not foundr- F�w)�
HAS_PSUTILr �criticalr rM �dirname�isdir�makedirsr, r% r& r' �json�load�decoder�JSONDecodeErrorr �FileNotFoundError�infor` r0 �dictr9 r1 �dump)� file_nameZfile_directory_name�file_process_info�fileZthis_process_infor r r � claim_mantle_of_responsibility� sH �
�� �
��
��rv c C s� t s
t�d| � dS z tjj�| d��
}t�|�}W d � n1 s#w Y W n! tj j
y; t� d| � Y dS t yJ t�
d| � Y dS w t|t�rXt|�d�t�sZdS |t|d �krf|d S dS )z^
Sees who has the mantle of responsibility
file_name: str
Return: None or int
ra Nrb rc rd r- )rf r rg r, r% r& r' rk rl rm rn r ro rp r0 rq r9 r1 r` )rs ru rt r r r � check_mantle_of_responsibility s0 � �� �
��rw c
C s� t j�| �}t j�|�s|rt �|� z#tjj�| d��}|� t
t � � �� W d � n1 s0w Y W n t y? Y nw t
�d| � tjj�� rNdS ddl}z|�|�}|d }|d }W n ttfy} tj� d�|�� t�tjjj� Y nw t � � |kr�dS z t � | ||� W n/ t y� } z#d �| |�} t
jd
| dd � tj� | � d �� t�|j � W Y d}~nd}~ww t
�d
| |� dS )z
Save the pidfile
zw+NzCreated pidfile: %sTr r � z>Failed to set the pid to user: {}. The user is not available.
z6Failed to set the ownership of PID file {} to user {}.z%s Traceback follows:��exc_info�
z Chowned pidfile: %s to user: %s) r rM rh ri rj r, r% r& r' �write�strr[ r r �debugr: �
is_windows�pwd�getpwnam�KeyError�
IndexErrorr r+ �formatr! r r � EX_NOUSER�getuid�chownr )
�pidfile�userZpdirZofiler� Zpwnam�uid�gid�err�msgr r r � set_pidfile6 sR
�� �
��� ���r� c C s t j�| �S )z5
Determine if a pidfile has been written out
)r rM �isfile)r� r r r �
check_pidfileg s r� c
C s` z"t jj�| ��}|�� �� }W d � n1 sw Y t|�W S ttt fy/ Y dS w )z5
Return the pid from a pidfile as an integer
N���)
r, r% r& r' �readr r1 r � TypeError�
ValueError)r� Zpdfr- r r r � get_pidfilen s �
�r� �
c C s� | sdS z4d}| � � r6| �� |d7 }t�d� | � � r/||kr/t�d| j� t�| jt j
� | � � s W dS W dS t t fyD Y dS w )z>
Generic method for cleaning up multiprocessing procs
Nr r g�������?z(Process did not die with terminate(): %s)
�is_alive� terminate�time�sleepr r r- r �kill�signal�SIGKILL�AssertionError�AttributeError)�proc�
wait_for_killZwaitedr r r �
clean_procz s
��r� c C sH t | t�r t| �} trt�| �S z t�| d� W dS ty# Y dS w )z@
Use OS facilities to determine if a process is running
r TF) r0 r} r1 rf r\ r] r r� r )r- r r r �
os_is_running� s
�r� c @ s, e Zd ZdZd
dd�Zd dd�Zdd � ZdS ) �
ThreadPoola%
This is a very VERY basic threadpool implementation
This was made instead of using multiprocessing ThreadPool because
we want to set max queue size and we want to daemonize threads (neither
is exposed in the stdlib version).
Since there isn't much use for this class as of right now this implementation
Only supports daemonized threads and will *not* return results
TODO: if this is found to be more generally useful it would be nice to pull
in the majority of code from upstream or from http://bit.ly/1wTeJtM
Nr c C sb |d u rt �� }|| _t�|�| _g | _t|�D ]}tj | j
d�}d|_ |� � | j�
|� qd S )N)�targetT)r6 � cpu_count� num_threads�queue�Queue�
_job_queueZ_workers�range� threading�Thread�_thread_targetrV �start�append)�selfr� Z
queue_sizer �threadr r r �__init__� s �zThreadPool.__init__c C sH |d u rg }|d u r i }z | j �|||f� W dS tjy# Y dS w )NTF)r� �
put_nowaitr� �Full)r� �func�args�kwargsr r r �
fire_async� s �zThreadPool.fire_asyncc
C s� z z| j jdd�\}}}| j �� W n tjy Y W q w W n ty) Y q w zt�d|||� ||i |�� W n tyT } z
tj|dd� W Y d }~nd }~ww q)NTr )�timeoutz4ThreadPool executing func: %s with args=%s kwargs=%sry ) r� r9 � task_doner� �Emptyr� r r~ � Exception)r� r� r� r� r� r r r r� � s2 �� �����zThreadPool._thread_target�Nr �NN)�__name__�
__module__� __qualname__�__doc__r� r� r� r r r r r� � s
r� c @ sl e Zd ZdZddd�Zddd�Zdd � Zd
d � Zd d
� Ze j
ddd��Z dd� Z dd� Z
dd� Zdd� ZdS ) �ProcessManagerzD
A class which will manage processes that should be running
Nr c C sH i | _ || _| jd u r| jj| _|| _t�� | _t� tj
�| _ d| _ d S )NT)
� _process_mapr
� __class__r� r� r r[ �_pidr� � getsignal�SIGTERM�_sigterm_handler�_restart_processes)r� r
r� r r r r� � s
zProcessManager.__init__c C s� |du rg }|du r i }t �|�r&t|tj�r&|p|j|d< ||i |��}n t||||p.|jd�}|�t||� t|t �rYt
t j t j
�� |�� W d � n1 sSw Y n|�� t�d|j|j� ||||d�| j|j< |S )z�
Create a processes and args + kwargs
This will deterimine if it is a Process class, otherwise it assumes
it is a function
Nr
)r� r� r� r
zStarted '%s' with pid %s)�tgtr� r� r^ )�inspectZisclass�
issubclassr6 r^ r� �register_finalize_method�cleanup_finalize_processr0 �SignalHandlingProcess�default_signalsr� �SIGINTr� r� r r~ r
r- r� )r� r� r� r� r
rG r r r � add_process� s0 �
���zProcessManager.add_processc C s� | j du rdS | j| d j}|dkr't�d| j| d || j| d j� nt�d| j| d || j| d j� | j| d �d� | �| j| d | j| d | j| d � | j|= dS )
zY
Create new process (assuming this one is dead), then remove the old one
FNr^ r z7Process %s (%s) died with exit status %s, restarting...r� r r� r� )r� r� �exitcoder rp r~ �joinr� )r� r- r! r r r �restart_process" s.
� � � z ProcessManager.restart_processc C s
d| _ d S )NF)r� �r� r r r �stop_restartingB s
z ProcessManager.stop_restartingc C s� t jj�� r|tjtjfv rd S | j�� D ]*}zt �
||� W q t y? } z|j t j
t jfvr1� | j|= W Y d }~qd }~ww d S �N)r, r% r: r r� r� r� r� �copyr r� r r �ESRCH�EACCES)r� Zsignal_r- r. r r r �send_signal_to_processesE s ����z'ProcessManager.send_signal_to_processesFc
c s� � t �d� t�� jdkrt| j� t�tj�tj u r#t�tj| j
� t�tj �tj u r4t�tj | j
� t � d� z| �
� |rHt�d�V nt�d� | jsSW dS W n# ty^ Y dS tyw } z|jtjkrl� W Y d}~dS d}~ww q5)z:
Load and start all available api modules
zProcess Manager starting!r TzProcess manager iterationr� N)r r~ r6 �current_processr
r r� r� r� �SIG_DFL�_handle_signalsr� �trace�check_childrenr r� r� r� r r ZEINTR)r� Z asynchronousr. r r r �run` s6 �
� ���zProcessManager.runc C sL | j du r"| j�� �� D ]\}}|d �� s!t�d|� | �|� q dS dS )z)
Check the children once
Tr^ zProcess restart of %sN)r� r� r� �itemsr� r r� r� )r� r- �mappingr r r r� � s
��z ProcessManager.check_childrenc
O s� t jj�� rHt�� jdkrdS t jj�t j
d��'}| j � � D ]\}}t
jddddt|�g||d� |d �� q W d � n1 sBw Y nf| j �� � � D ]^\}}t�d
||d � |rrz
t �||d � W n tyq Y nw z|d �� W n ty� } z|jtjtjfvr�� W Y d}~nd}~ww |d �� s�z| j |= W qO ty� Y qOw qOt�� | j }t�d � | j r�t�� |k r�| j �� � � D ]*\}}t�d
||d � |d � d � |d �� s�z| j |= W q� ty� Y q�w q�| j r�t�� |k s�d}|d k�rx|d8 }| j �� � � D ]b\}}|d �� �s.z| j |= W n
t�y+ Y nw �qt�d||d � z
t �|t j � W �q t�yr } z$t� |� |d �� �sgz| j |= W n
t�yf Y nw W Y d}~�qd}~ww |d k�s| j �r�|�!dd�} | d k�r�t�"dd� dd� | j � � D ��� t�"d| � | d |d< | j#|i |��S t�$dd� dd� | j � � D ��� t�$d� dS dS )z*
Kill all of the children
r N�wbZtaskkillz/Fz/Tz/PIDr@ r^ zTerminating pid %s: %sr z(Waiting to kill process manager childrenzJoining pid %s: %sr r zKilling pid %s: %sZretryrx z4Some processes failed to respect the KILL signal: %sz; c s �$ � | ]
\}}d � |d |�V qdS �zProcess: {} (Pid: {})r^ N�r� ��.0�k�vr r r � <genexpr>� s
� �
�z/ProcessManager.kill_children.<locals>.<genexpr>z kill_children retries left: %sz*Failed to kill the following processes: %sc s r� r� r� r� r r r r� � s � �
�zLSalt will either fail to terminate now or leave some zombie processes behind)%r, r% r: r r6 r� r
r& r' r �devnullr� r� rA �callr} r� r� r r� r� r r r� r� r� r� r� r� r� r� r� � exceptionr9 rp �
kill_childrenr5 )
r� r� r� r� r- Zp_mapr. Zend_timeZkill_iterationsZavailable_retriesr r r r� � s� �� �� � ��� ��
���
�
���
�
��
��
��z ProcessManager.kill_childrenc C s | � � | �tj� | �� dS )zB
Properly terminate this process manager instance
N)r� r� r� r� r� r� r r r r� s zProcessManager.terminatec O s� t � t jt j� t � t jt j� | �� | �t j� t�� | jkr:t | j
�r+| j
|� S | j
d ur8t � t j�|� S d S | j |i |�� d S r� )
r� r� �SIG_IGNr� r� r� r r[ r� �callabler� �default_int_handlerr� �r� r� r� r r r r� s
z ProcessManager._handle_signals)Nr )NNN)F)r� r� r� r� r� r� r� r� r� r � coroutiner� r� r� r� r� r r r r r� � s
% (
u r� c sH e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd
d � Zd d
� Z � Z
S )r^ a�
Salt relies on this custom implementation of :py:class:`~multiprocessing.Process` to
simplify/automate some common procedures, for example, logging in the new process is
configured for "free" for every new process.
This is most important in platforms which default to ``spawn` instead of ``fork`` for
new processes.
This is achieved by some dunder methods in the class:
* ``__new__``:
This method ensures that any arguments and/or keyword arguments that are passed to
``__init__`` are captured.
By having this information captured, we can define ``__setstate__`` and ``__getstate__``
to automatically take care of reconstructing the object state on spawned processes.
* ``__getstate__``:
This method should return a dictionary which will be used as the ``state`` argument to
:py:method:`salt.utils.process.Process.__setstate__`.
Usually, when subclassing, this method does not need to be implemented, however,
if implemented, `super()` **must** be called.
* ``__setstate__``:
This method reconstructs the object on the spawned process.
The ``state`` argument is constructed by the
:py:method:`salt.utils.process.Process.__getstate__` method.
Usually, when subclassing, this method does not need to be implemented, however,
if implemented, `super()` **must** be called.
An example of where ``__setstate__`` and ``__getstate__`` needed to be subclassed can be
seen in :py:class:`salt.master.MWorker`.
The gist of it is something like, if there are internal attributes which need to maintain
their state on spawned processes, then, subclasses must implement ``__getstate__`` and
``__setstate__`` to ensure that.
For example:
.. code-block:: python
import salt.utils.process
class MyCustomProcess(salt.utils.process.Process):
def __init__(self, opts, **kwargs):
super().__init__(**kwargs)
self.opts = opts
# This attribute, counter, should only start at 0 on the initial(parent) process.
# Any child processes, need to carry the current value of the counter(instead of
# starting at zero).
self.counter = 0
def __getstate__(self):
state = super().__getstate__()
state.update(
{
"counter": self.counter,
}
)
return state
def __setstate__(self, state):
super().__setstate__(state)
self.counter = state["counter"]
c s` t � �| �}g |_g |_tj�� |_tjj �
� r$t � |�|_ t � |�|_
t|d|�|j�� |S )au
This method ensures that any arguments and/or keyword arguments that are passed to
``__init__`` are captured.
By having this information captured, we can define ``__setstate__`` and ``__getstate__``
to automatically take care of object pickling which is required for platforms that
spawn processes instead of forking them.
r� )�super�__new__�_after_fork_methods�_finalize_methodsr, �_logging�get_logging_options_dict�__logging_config__r% r: �spawning_platformr� �_args_for_getstate�_kwargs_for_getstate�setattr�_Process__decorate_runr� ��clsr� r� �instance�r� r r r� p s zProcess.__new__c C s� |d }|d }|d }| j |i |�� || _|d D ]\}}}| j|g|�R i |�� q|d D ]\}}}| j|g|�R i |�� q1dS )aD
This method reconstructs the object on the spawned process.
The ``state`` argument is constructed by :py:method:`salt.utils.process.Process.__getstate__`.
Usually, when subclassing, this method does not need to be implemented, however,
if implemented, `super()` **must** be called.
r� r� �logging_config�after_fork_methods�finalize_methodsN)r� r� �register_after_fork_methodr� )r� �stater� r� r �functionr r r � __setstate__� s �zProcess.__setstate__c C s" | j }| j}||| j| j| jd�S )a5
This method should return a dictionary which will be used as the ``state`` argument to
:py:method:`salt.utils.process.Process.__setstate__`.
Usually, when subclassing, this method does not need to be implemented, however,
if implemented, `super()` **must** be called.
)r� r� r
r r )r r r� r� r� r� r r r � __getstate__� s �zProcess.__getstate__c s t �� �� �fdd��}|S )Nc s� t �j� tj�� stj��j� tjj� � s8ztj�
� W n t y7 } z
t �
d�| � W Y d } ~ nd } ~ ww ztj�� W n t yX } z
t �
d�| � W Y d } ~ nd } ~ ww �jD ] \}}}z ||i |�� W q\ t y| t �
d�|||� Y q\w z�zl� � W W zF�jD ] \}}}z ||i |�� W q� t y� t �
d�|||� Y q�w W ztj�
� W S t y� } z
t �
d�| � W Y d } ~ S d } ~ ww ztj�
� W w t y� } z
t �
d�| � W Y d } ~ w d } ~ ww ty� � t �y t jd�jdd� � w zJ�jD ]#\}}}z
||i |�� W �q t �y+ t �
d�|||� Y �qw W ztj�
� W w t �yN } z
t �
d�| � W Y d } ~ w d } ~ ww ztj�
� W w t �yp } z
t �
d�| � W Y d } ~ w d } ~ ww ) Nz2Failed to shutdown logging when starting on %s: %sz%Failed to configure logging on %s: %szJFailed to run after fork callback on %s; method=%r; args=%r; and kwargs=%r�HFailed to run finalize callback on %s; method=%r; args=%r; and kwargs=%rz$Failed to shutdown logging on %s: %szJAn un-handled exception from the multiprocessing process '%s' was caught:
Try )r r
r, r� r� Zset_logging_options_dictr� r% r: r Zshutdown_loggingr� r r� Z
setup_loggingr� r� �
SystemExitr )r. �methodr� r� ��run_funcr� r r �wrapped_run_func� s�
������ �� �������� �� �
��������z0Process.__decorate_run.<locals>.wrapped_run_func)� functools�wraps)r� r r r r r Z__decorate_run� s SzProcess.__decorate_runc O �( |||f}|| j vr| j �|� dS dS )zI
Register a function to run after the process has forked
N)r� r� )r� r r� r� Zafter_fork_method_tupler r r r �
�z"Process.register_after_fork_methodc O r )zB
Register a function to run as process terminates
N)r� r� )r� r r� r� Zfinalize_method_tupler r r r� r z Process.register_finalize_method) r� r� r� r� r� r r r r r� �
__classcell__r r r r r^ & s I"Wr^ c s8 e Zd Z� fdd�Zdd� Zdd� Z� fdd�Z� ZS ) r� c s, t � j| g|�R i |��}|�tj|� |S r� )r� r� r r� �_setup_signalsr r r r r� s
�z SignalHandlingProcess.__new__c C s$ t � t j| j� t � t j| j� d S r� )r� r� r� r� r� r r r r ' s z$SignalHandlingProcess._setup_signalsc C sZ t � t jt j� t � t jt j� | jj� d�}|t jkr!|d7 }n |t jkr*|d7 }|d7 }t�|� | jD ] \}}}z ||i |�� W q6 t yV t�
d| |||� Y q6w t r�z5t �
t�� �}t|d�r�|jdd�D ] }z
|�� rw|�� W ql t jy� t�d | jt�� � Y qlw W n t jy� t�d
| jt�� � Y nw t�tjjj� d S ) Nz received a r� r� z . Exitingr �childrenT)� recursivezCUnable to kill child of process %d, it does not exist. My pid is %dzEUnable to kill children of process %d, it does not exist.My pid is %d) r� r� r� r� r� r� r r~ r� r� r� rf r\ r^ r r[ �hasattrr Z
is_runningr� r_ r5 r- r r, r r r ) r� �signumZsigframer� r r� r� rG �childr r r r� + s^
��
������z%SignalHandlingProcess._handle_signalsc s> t tjtj�� t� �� W d � d S 1 sw Y d S r� )r� r� r� r� r� r� r� r r r r� ^ s "�zSignalHandlingProcess.start)r� r� r� r� r r� r� r r r r r r� s
3r� c g s� � i }| D ].}zt �|�}t � |t j� W n ty. } z
t�d||� W Y d}~qd}~ww |||< qzdV W |D ]
}t � ||| � q;~dS |D ]
}t � ||| � qK~w )z>
Temporarily restore signals to their default values.
z+Failed to register signal for signum %d: %sN)r� r� r� r� r r� )ZsignalsZ old_signalsr Z saved_signalr. r r r r� c s& �
��
�r� c @ s& e Zd Zddd�Zdd� Zdd� ZdS ) �SubprocessListNc C s: |d u rg | _ n|| _ |d u rt�� | _n|| _d| _d S r� )� processesr6 �Lock�lock�count)r� r# r% r r r r� � s
zSubprocessList.__init__c C sT | j � | j�|� t�d|j� | jd7 _W d � d S 1 s#w Y d S )NzSubprocess %s addedr )r% r# r� r r~ r
r& �r� r� r r r �add� s
"�zSubprocessList.addc C s� | j �A | jd d � D ]0}|�d� t|d�r"|jd u r q |�� n|�� r'q | j�|� | jd8 _t �
d|j � q W d � d S 1 sGw Y d S )Ng{�G�z�?r� r zSubprocess %s cleaned up) r% r# r� r r� rU r� �remover& r r~ r
r' r r r �cleanup� s
�"�zSubprocessList.cleanupr� )r� r� r� r� r( r* r r r r r" � s
r" c
O sX t D ]'\}} }t�d|| |� z || i |�� W q ty) t�d|| |� Y qw dS )a�
Generic process to allow for any registered process cleanup routines to execute.
While class Process has a register_finalize_method, when a process is looked up by pid
using psutil.Process, there is no method available to register a cleanup process.
Hence, this function is added as part of the add_process to allow usage of other cleanup processes
which cannot be added by the register_finalize_method.
z7cleanup_finalize_process, method=%r, args=%r, kwargs=%rzVFailed to run registered function finalize callback; method=%r; args=%r; and kwargs=%rN)�(_INTERNAL_PROCESS_FINALIZE_FUNCTION_LISTr r~ r� r� )r� r� r r r r r� � s& � ���r� c O s4 t �d| ||� | ||f}|tvrt�|� dS dS )a�
Register a function to run as process terminates
While class Process has a register_finalize_method, when a process is looked up by pid
using psutil.Process, there is no method available to register a cleanup process.
Hence, this function can be used to register a function to allow cleanup processes
which cannot be added by class Process register_finalize_method.
Note: there is no deletion, since it is assummed that if something is registered, it will continue to be used
zIregister_cleanup_finalize_function entry, function=%r, args=%r, kwargs=%rN)r r~ r+ r� )r r� r� Zfinalize_function_tupler r r �"register_cleanup_finalize_function� s �
�r, )Tr� )r� )>r� �
contextlibr� r r r� r3 rk �loggingr6 Zmultiprocessing.utilr r� r� rP rA r r� r� Z
salt._loggingr, Zsalt.defaults.exitcodesZsalt.utils.filesZsalt.utils.pathZsalt.utils.platformZsalt.utils.versionsZsalt.ext.tornador r Z_get_machine_identifier� getLoggerr� r rf r\ rL r r r+ r r/ r( r= rI rZ r` rv rw r� r� r� r� r� r� r� r^ r� �contextmanagerr� r" r� r, r r r r �<module> s�
� �
/
5"1
H ? zD
$