HEX
Server: LiteSpeed
System: Linux kapuas.iixcp.rumahweb.net 5.14.0-427.42.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Nov 1 14:58:02 EDT 2024 x86_64
User: mirz4654 (1666)
PHP: 8.1.33
Disabled: system,exec,escapeshellarg,escapeshellcmd,passthru,proc_close,proc_get_status,proc_nice,proc_open,proc_terminate,shell_exec,popen,pclose,dl,pfsockopen,leak,apache_child_terminate,posix_kill,posix_mkfifo,posix_setsid,posix_setuid,posix_setpgid,ini_alter,show_source,define_syslog_variables,symlink,syslog,openlog,openlog,closelog,ocinumcols,listen,chgrp,apache_note,apache_setenv,debugger_on,debugger_off,ftp_exec,dll,ftp,myshellexec,socket_bind,mail,posix_getwpuid
Upload Files
File: //usr/local/lib/python3.9/site-packages/celery/events/__pycache__/state.cpython-39.pyc
a

X>h0d�	@s�dZddlZddlZddlZddlmZddlmZddlmZddl	m
Z
ddlmZddl
mZdd	lmZdd
lmZmZddlmZmZddlmZdd
lmZddlmZddlmZmZmZddl m!Z!dZ"e#ed�Z$dZ%dZ&dZ'e!e(�Z)e)j*Z+dZ,dZ-dZ.ej/ej0ej1ej2ej3ej4ej5ej6d�Z7Gdd�de�Z8e�9e8�eddd�d�d d!��Z:d"e%e
e;e<fd#d$�Z=d%d&�Z>d'd(�Z?e?d)�Gd*d+�d+��Z@e?d,�Gd-d.�d.��ZAGd/d0�d0�ZBd1d2�ZCd3d4�ZDdS)5a�In-memory representation of cluster state.

This module implements a data-structure used to keep
track of the state of a cluster of workers and the tasks
it is working on (by consuming events).

For every event consumed the state is updated,
so the state represents the state of the cluster
at the time of the last event.

Snapshots (:mod:`celery.events.snapshot`) can be used to
take "pictures" of this state at regular intervals
to for example, store that in a database.
�N)�defaultdict)�Callable)�datetime)�Decimal)�islice)�
itemgetter)�time)�Mapping�Optional)�WeakSet�ref��	timetuple)�cached_property)�states)�LRUCache�memoize�pass1)�
get_logger)�Worker�Task�State�heartbeat_expires�pypy_version_info���zmSubstantial drift from %s may mean clocks are out of sync.  Current drift is %s seconds.  [orig: %s recv: %s]z4<State: events={0.event_count} tasks={0.task_count}>z9<Worker: {0.hostname} ({0.status_string} clock:{0.clock})z4<Task: {0.name}({0.uuid}) {0.state} clock:{0.clock}>)�sent�received�started�failed�retried�	succeeded�revoked�rejectedcs(eZdZdZ�fdd�Zdd�Z�ZS)�CallableDefaultdicta�:class:`~collections.defaultdict` with configurable __call__.

    We use this for backwards compatibility in State.tasks_by_type
    etc, which used to be a method but is now an index instead.

    So you can do::

        >>> add_tasks = state.tasks_by_type['proj.tasks.add']

    while still supporting the method call::

        >>> add_tasks = list(state.tasks_by_type(
        ...     'proj.tasks.add', reverse=True))
    cs||_t�j|i|��dS�N)�fun�super�__init__)�selfr&�args�kwargs��	__class__��=/usr/local/lib/python3.9/site-packages/celery/events/state.pyr(_szCallableDefaultdict.__init__cOs|j|i|��Sr%)r&)r)r*r+r.r.r/�__call__cszCallableDefaultdict.__call__)�__name__�
__module__�__qualname__�__doc__r(r0�
__classcell__r.r.r,r/r$Osr$i�cCs|dS�Nrr.)�a�_r.r.r/�<lambda>j�r9)�maxsizeZkeyfuncCs tt||t�|�t�|��dSr%)�warn�
DRIFT_WARNINGr�
fromtimestamp)�hostname�drift�local_received�	timestampr.r.r/�_warn_driftjs�rC�<cCs8|||�r||�n|}|||�r(||�}|||dS)z#Return time when heartbeat expires.gY@r.)rB�freq�
expire_windowr�float�
isinstancer.r.r/rrs
rcCs|fi|��Sr%r.)�cls�fieldsr.r.r/�_depickle_task~srKcs�fdd�}|S)Ncs(�fdd�}||_�fdd�}||_|S)Ncs$t||j�r t|��t|��kStSr%)rHr-�getattr�NotImplemented)�this�other��attrr.r/�__eq__�sz8with_unique_field.<locals>._decorate_cls.<locals>.__eq__cstt|���Sr%)�hashrL)rNrPr.r/�__hash__�sz:with_unique_field.<locals>._decorate_cls.<locals>.__hash__)rRrT)rIrRrTrPr.r/�
_decorate_cls�s
z(with_unique_field.<locals>._decorate_clsr.)rQrUr.rPr/�with_unique_field�s
rVr?c@s�eZdZdZdZeZdZes$edZ	ddd	�Z
d
d�Zdd
�Zdd�Z
dd�Zedd��Zedd��Zeefdd��Zedd��ZdS)rz
Worker State.�)r?�pidrE�
heartbeats�clock�active�	processed�loadavg�sw_ident�sw_ver�sw_sys)�event�__dict__�__weakref__NrDrcCs`||_||_||_|durgn||_|p*d|_||_||_||_|	|_|
|_	||_
|��|_dSr6)
r?rXrErYrZr[r\r]r^r_r`�_create_event_handlerra)r)r?rXrErYrZr[r\r]r^r_r`r.r.r/r(�s
zWorker.__init__cCs6|j|j|j|j|j|j|j|j|j|j	|j
|jffSr%)r-r?rXrErYrZr[r\r]r^r_r`�r)r.r.r/�
__reduce__�s
�zWorker.__reduce__csPtj��j��j��jj��jj�dddtttt	j
tf������fdd�	}|S)Nc	
s�|pi}|��D]\}	}
��|	|
�q|dkr<g�dd�<n||rD|sHdS|||�||��}||krtt�j|||�|r�|��}|�dkr��d�|r�|�dkr��|�n
|�|�dS)N�offline�r���)�itemsrCr?)
�type_rBrArJZ	max_drift�abs�int�insort�len�k�vr@�hearts�Z_setZ	hb_appendZhb_popZhbmaxrYr)r.r/ra�s&�
z+Worker._create_event_handler.<locals>.event)�object�__setattr__�
heartbeat_maxrY�pop�append�HEARTBEAT_DRIFT_MAXrlrm�bisectrnro�r)rar.rsr/rd�s�zWorker._create_event_handlercKs:|rt|fi|��n|}|��D]\}}t|||�q dSr%)�dictrj�setattr)r)�f�kw�drprqr.r.r/�update�sz
Worker.updatecCs
t�|�Sr%)�R_WORKER�formatrer.r.r/�__repr__�szWorker.__repr__cCs|jr
dSdS)NZONLINEZOFFLINE��aliverer.r.r/�
status_string�szWorker.status_stringcCst|jd|j|j�S)Nri)rrYrErFrer.r.r/r�s
�zWorker.heartbeat_expirescCst|jo|�|jk�Sr%)�boolrYr)r)Znowfunr.r.r/r��szWorker.alivecCs
d�|�S)Nz{0.hostname}.{0.pid})r�rer.r.r/�id�sz	Worker.id)NNrDNrNNNNNN)r1r2r3r4rv�HEARTBEAT_EXPIRE_WINDOWrF�_fields�PYPY�	__slots__r(rfrdr�r��propertyr�rrr�r�r.r.r.r/r�s,�
!

r�uuidc@s6eZdZdZdZZZZZZ	Z
ZZZ
ZZZZZZZZZZZZZZZejZdZ dZ!e"s�dZ#ej$diZ%dZ&d$dd	�Z'dddej(e)e*j+ej,fd
d�Z-d%dd
�Z.dd�Z/dd�Z0dd�Z1dd�Z2dd�Z3dd�Z4e5dd��Z6e5dd��Z7e5dd��Z8e9d d!��Z:e9d"d#��Z;dS)&rzTask State.Nr)r��name�staterrrr#r!rr r"r*r+�eta�expires�retries�worker�result�	exceptionrB�runtime�	traceback�exchange�routing_keyrZ�client�root�root_id�parent�	parent_id�children)rbrc)r�r*r+r�r�r�r�r�)r*r+r�r�r�r�r�r�r�r�r�r�csd|�_|�_�jdur4t�fdd�|p(dD���_nt��_�j�j�jd��_|r`�j�	|�dS)Nc3s(|] }|�jjvr�jj�|�VqdSr%)�
cluster_state�tasks�get)�.0Ztask_idrer.r/�	<genexpr>"s�z Task.__init__.<locals>.<genexpr>r.)r�r�r�)
r�r�rr��_serializable_children�_serializable_root�_serializable_parent�_serializer_handlersrbr�)r)r�r�r�r+r.rer/r(s
��z
Task.__init__c	
s�|pi}||�}	|	dur&||||�n|��}	|	|kr~|j|kr~||	�||j�kr~|j�|	���dur��fdd�|��D�}n|j|	|d�|j�|�dS)Ncsi|]\}}|�vr||�qSr.r.)r�rprq�Zkeepr.r/�
<dictcomp>EszTask.event.<locals>.<dictcomp>)r�rB)�upperr��merge_rulesr�rjr�rb)
r)rkrBrArJ�
precedencer}Ztask_event_to_state�RETRYr�r.r�r/ra1s�
�z
Task.eventcs8�sgn���dur�jn�����fdd�}t|��S)z;Information about this task suitable for on-screen display.Nc3s8t��t��D]"}t�|d�}|dur||fVqdSr%)�listrL)�key�value��extrarJr)r.r/�_keysSszTask.info.<locals>._keys)�_info_fieldsr|)r)rJr�r�r.r�r/�infoNsz	Task.infocCs
t�|�Sr%)�R_TASKr�rer.r.r/r�[sz
Task.__repr__cs&tj��jj����fdd��jD�S)Ncs"i|]}|�|t���|���qSr.)r)r�rp�r��handlerr)r.r/r�asz Task.as_dict.<locals>.<dictcomp>)rt�__getattribute__r�r�r�rer.r�r/�as_dict^s
�zTask.as_dictcCsdd�|jD�S)NcSsg|]
}|j�qSr.�r�)r��taskr.r.r/�
<listcomp>fr:z/Task._serializable_children.<locals>.<listcomp>)r��r)r�r.r.r/r�eszTask._serializable_childrencCs|jSr%)r�r�r.r.r/r�hszTask._serializable_rootcCs|jSr%)r�r�r.r.r/r�kszTask._serializable_parentcCst|j|��ffSr%)rKr-r�rer.r.r/rfnszTask.__reduce__cCs|jSr%)r�rer.r.r/r�qszTask.idcCs|jdur|jS|jjSr%)r�r�r�rer.r.r/�originuszTask.origincCs|jtjvSr%�r�rZREADY_STATESrer.r.r/�readyysz
Task.readycCs2z|jo|jjj|jWSty,YdS0dSr%)r�r�r��data�KeyErrorrer.r.r/r�}szTask.parentcCs2z|jo|jjj|jWSty,YdS0dSr%)r�r�r�r�r�rer.r.r/r��sz	Task.root)NNN)NN)<r1r2r3r4r�rrrr!rr r"r#r*r+r�r�r�r�r�r�rBr�r�r�r�r�r�r�r�PENDINGr�rZr�r�r��RECEIVEDr�r�r(r�r}�TASK_EVENT_TO_STATEr�r�rar�r�r�r�r�r�rfr�r�r�r�rr�r�r.r.r.r/r�s�������������������
�






rc
@seZdZdZeZeZdZdZdZd9dd�Z	e
d	d
��Zdd�Zd:dd�Z
d;ed�dd�Zd<dd�Zd=ed�dd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zefd%d&�Zd>eed'�d(d)�Zd?ed*�d+d,�ZeZd@d-d.�Z dAd/d0�Z!d1d2�Z"d3d4�Z#d5d6�Z$d7d8�Z%dS)BrzRecords clusters state.rrWN��'cCs�||_|durt|�n||_|dur,t|�n||_|dur>gn||_||_||_||_||_t	�
�|_i|_t
�|_i|_|��t|jt�|_|j�t|	|j��t|jt�|_|j�t|
|j��dSr%)�event_callbackr�workersr��	_taskheap�max_workers_in_memory�max_tasks_in_memory�on_node_join�
on_node_leave�	threading�Lock�_mutex�handlers�set�_seen_types�_tasks_to_resolve�rebuild_taskheapr$�_tasks_by_typer�
tasks_by_typer��!_deserialize_Task_WeakSet_Mapping�_tasks_by_worker�tasks_by_worker)r)�callbackr�r��taskheapr�r�r�r�r�r�r.r.r/r(�s>�
��
�
�
��
�zState.__init__cCs|��Sr%)�_create_dispatcherrer.r.r/�_event�szState._eventc	Osr|�dd�}|j�Lz,||i|��W|r0|��Wd�Sn|rN|��0Wd�n1sd0YdS)N�clear_afterF)rwr��_clear)r)r&r*r+r�r.r.r/�freeze_while�s��zState.freeze_whileTcCs4|j�|�|�Wd�S1s&0YdSr%)r��_clear_tasks�r)r�r.r.r/�clear_tasks�szState.clear_tasks)r�cCsJ|r.dd�|��D�}|j��|j�|�n
|j��g|jdd�<dS)NcSs"i|]\}}|jtjvr||�qSr.r��r�r�r�r.r.r/r��s�z&State._clear_tasks.<locals>.<dictcomp>)�	itertasksr��clearr�r�)r)r�Zin_progressr.r.r/r��s�

zState._clear_taskscCs$|j��|�|�d|_d|_dSr6)r�r�r��event_count�
task_countr�r.r.r/r��s

zState._clearcCs4|j�|�|�Wd�S1s&0YdSr%)r�r�r�r.r.r/r��szState.clearcKs^z"|j|}|r|�|�|dfWStyX|j|fi|��}|j|<|dfYS0dS)zsGet or create worker by hostname.

        Returns:
            Tuple: of ``(worker, was_created)`` pairs.
        FTN)r�r�r�r)r)r?r+r�r.r.r/�get_or_create_worker�s


��zState.get_or_create_workercCsHz|j|dfWStyB|j||d�}|j|<|dfYS0dS)zGet or create task by uuid.F�r�TN)r�r�r)r)r�r�r.r.r/�get_or_create_task�s
zState.get_or_create_taskcCs4|j�|�|�Wd�S1s&0YdSr%)r�r�r{r.r.r/ra�szState.eventcCs |�t|d�d|g�d��dS)�Deprecated, use :meth:`event`.�-r���typer�r�r|�join�r)rkrJr.r.r/�
task_event�szState.task_eventcCs |�t|d�d|g�d��dS)r�r�r�r�rr�r�r.r.r/�worker_event�szState.worker_eventcs��jj��j�tddd��tddddd���j�
�
j��
j��j�j�	�j	j
��j�j�
��j
�j���j�j���jj�jj���jj��jj�tttjdf����������	�
���
������fdd�	}|S)	Nr?rBrAr�rZTcsV�jd7_�r��|�|d�d�\}}}z�|�}Wn|yNYn0|||�|fS|dk�r>z�|�\}	}
}Wn|y�Yn�0|dk}z�|	�d}
}Wn6|y�|rʈ|	�d}
}n�|	�}
�|	<Yn0|
�||
||��
�r|�s|dk�r�
|
���r.|�r.�|
���|	d�|
|f|fS�n|dk�rR�|�\}}	}
}}|d	k}z�|�d}}Wn,|�y��|�d
�}�|<d}Yn0|�r�|	|_nVz�|	�}
Wn$|�y��|	�}
�|	<Yn0|
|_|
du�r|�r|
�d||
�|�r|	n|
j}t�
�}|d�	k�r4�d�|||
|t|��}|�rd|�
d
k�rd�|�n
|�
|�|dk�r��j	d7_	|�||
||�|j
}|du�rЈ|�|�rЈ|��|��|	��|�|j�rz�j
|j}Wn|�y��|�Yn0|j�|�z�j�|�}Wn|�y8Yn0|j�|�||f|fSdS)Nrhr�r�r�rgFZonliner�rr�Trrir)r��	partitionrarwr�r�r�rorr�r��addr�r��_add_pending_task_childr�r�r�)rarr�rn�created�groupr8�subjectr�r?rBrAZ
is_offliner�r�rZZis_client_eventr�Ztask_createdr�ZheapsZtimetupZ	task_nameZparent_task�	_children�rr�add_typer�Zget_handlerZget_taskZget_task_by_type_setZget_task_by_worker_setZ
get_workerZmax_events_in_heapr�r�r)r�r�ZtfieldsZ	th_appendZth_popZwfieldsr�r.r/r�s�


�




z(State._create_dispatcher.<locals>._event)r��__getitem__r�rr�rxrwr��heap_multiplierr�r�r�r�r�rr�rr�r�r�rr�rzrn)r)r�r.rr/r�s*��4^zState._create_dispatchercCsDz|j|j}Wn$ty4t�}|j|j<Yn0|�|�dSr%)r�r�r�rr�)r)r��chr.r.r/r�|s
zState._add_pending_task_childcs2�fdd�|j��D�}|jdd�<|��dS)Ncs$g|]}�|j|j|jt|���qSr.)rZrBr�r�r��tr
r.r/r��s�z*State.rebuild_taskheap.<locals>.<listcomp>)r��valuesr��sort)r)r�heapr.r
r/r��s
�zState.rebuild_taskheap)�limitccs6t|j���D]"\}}|V|r|d|krq2qdS)Nrh)�	enumerater�rj)r)r�index�rowr.r.r/r��szState.itertasks��reverseccsb|j}|rt|�}t�}t|d|�D]8}|d�}|dur$|j}||vr$||fV|�|�q$dS)zkGenerator yielding tasks ordered by time.

        Yields:
            Tuples of ``(uuid, Task)``.
        r�N)r��reversedr�rr�r�)r)rrZ_heap�seenZevtupr�r�r.r.r/�
tasks_by_time�s

zState.tasks_by_timecs"t�fdd�|j|d�D�d|�S)z�Get all tasks by type.

        This is slower than accessing :attr:`tasks_by_type`,
        but will be ordered by time.

        Returns:
            Generator: giving ``(uuid, Task)`` pairs.
        c3s$|]\}}|j�kr||fVqdSr%�r�r�rr.r/r��s

�z'State._tasks_by_type.<locals>.<genexpr>rr�rr)r)r�rrr.rr/r��s	�zState._tasks_by_typecs"t�fdd�|j|d�D�d|�S)znGet all tasks by worker.

        Slower than accessing :attr:`tasks_by_worker`, but ordered by time.
        c3s&|]\}}|jj�kr||fVqdSr%)r�r?r��r?r.r/r��s
�z)State._tasks_by_worker.<locals>.<genexpr>rrr)r)r?rrr.rr/r��s�zState._tasks_by_workercCs
t|j�S)z%Return a list of all seen task types.)�sortedr�rer.r.r/�
task_types�szState.task_typescCsdd�|j��D�S)z+Return a list of (seemingly) alive workers.css|]}|jr|VqdSr%r�)r��wr.r.r/r��r:z&State.alive_workers.<locals>.<genexpr>)r�r	rer.r.r/�
alive_workers�szState.alive_workerscCs
t�|�Sr%)�R_STATEr�rer.r.r/r��szState.__repr__cCs8|j|j|j|jd|j|j|j|jt|j	�t|j
�f
fSr%)r-r�r�r�r�r�r�r��_serialize_Task_WeakSet_Mappingr�r�rer.r.r/rf�s�zState.__reduce__)
NNNNr�r�NNNN)T)T)T)T)N)NT)NT)NT)&r1r2r3r4rrr�r�rr(rr�r�r�r�r�r�r�r�r�rar�r�r�r�rr�r
rmr�rZtasks_by_timestampr�r�rrr�rfr.r.r.r/r�sH�

	

{

rcCsdd�|��D�S)NcSs i|]\}}|dd�|D��qS)cSsg|]
}|j�qSr.r�rr.r.r/r��r:z>_serialize_Task_WeakSet_Mapping.<locals>.<dictcomp>.<listcomp>r.)r�r�r�r.r.r/r��r:z3_serialize_Task_WeakSet_Mapping.<locals>.<dictcomp>�rj)�mappingr.r.r/r�srcs|pi}�fdd�|��D�S)Ncs(i|] \}}|t�fdd�|D���qS)c3s|]}|�vr�|VqdSr%r.)r��i�r�r.r/r��r:z?_deserialize_Task_WeakSet_Mapping.<locals>.<dictcomp>.<genexpr>)r)r�r��idsr"r.r/r��s�z5_deserialize_Task_WeakSet_Mapping.<locals>.<dictcomp>r)r r�r.r"r/r��s
�r�)Er4rz�sysr��collectionsr�collections.abcrr�decimalr�	itertoolsr�operatorrr�typingr	r
�weakrefrrZkombu.clocksrZkombu.utils.objectsrZceleryrZcelery.utils.functionalrrrZcelery.utils.logr�__all__�hasattrr�r�ryr=r1�logger�warningr<rr�r�r�r�ZSTARTED�FAILUREr��SUCCESSZREVOKEDZREJECTEDr�r$�registerrCrGrHrrKrVrrrrr�r.r.r.r/�<module>sr
��

�
]G