o wvXja@s|dZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddlZddlZddlZddlmZddlmZddlmZmZddlmZddlmZd d lmZd d lmZm Z m!Z!d d l"m#Z#zdd l$m%Z%Wn e&y}dZ%Ynwe#dZ'e#dZ(e#dZ)e#dZ*e#dZ+dZ,e-e ddZ.d Z/e-e ddZ0e-e ddZ1e-e ddZ2e 3Z4e4dkZ5e4dkZ6dZ7e j8e j9Be j:BZ;e je jBe jd Z?ed!d"Z@e jABd#d$ZCd%ZDd&ZEd'd(eFe DZGd)d*eGDZHd+d,ZId-d.ZJGd/d0d0eKZLGd1d2d2eMZNeNZOd3d4ZPd5d6ZQd7d8ZRGd9d:d:eMZS  $ddd;d<ZTd=d>ZUd?d@ZVdAdBZWdCdDZXdEdFZYdGdHZZdIdJZ[dedKdLZ\dMdNZ]GdOdPdPeMZ^e^Z_e_j`Zae_jbZce_jdZee_jfZgdQdRZhdSdTZidfdUdVZje jABdWrdXdYZkndedZdYZkd[d\Zled]d^Zmd_d`ZnejodakrddlpZpdbdcZqeqejrZreqejsZseqejtZtdSejrZrejsZsejtZtdS)gziPlatforms. Utilities dealing with platform specifics: signals, daemonization, users, groups, and so on. )absolute_importprint_functionunicode_literalsN) namedtuple)contextmanager)close_open_fds get_fdmax) maybe_fileno)safe_str) SecurityError)itemsreraisestring_t) try_import)current_process setproctitleresourcepwdgrpzmultiprocessing.util)EX_OK EX_FAILUREEX_UNAVAILABLEEX_USAGESYSTEMIS_macOS IS_WINDOWSSIGMAPpyimplementation LockFailedrPidfilecreate_pidlockr DaemonContextdetached parse_uid parse_gid setgroups initgroupssetgidsetuidmaybe_drop_privilegessignals signal_nameset_process_titleset_mp_process_titleget_errno_name ignore_errno fd_by_pathisattyrrEr@ EX_CANTCREATIDarwinWindows/zLERROR: Pidfile ({0}) already exists. Seems we're already running? (pid: {1})_range)startstop C_FORCE_ROOTFa>Running a worker with superuser privileges when the worker accepts messages serialized with pickle is a very bad idea! If you really want to continue then you have to set the C_FORCE_ROOT environment variable (but please think about this before you do). User information: uid={uid} euid={euid} gid={gid} egid={egid} zYou're running the worker with superuser privileges: this is absolutely not recommended! Please specify a different user using the --uid option. User information: uid={uid} euid={euid} gid={gid} egid={egid} cCs"h|] }|drd|vr|qS)SIG_) startswith.0sigrFM/var/www/html/myproject/venv/lib/python3.10/site-packages/celery/platforms.py ^srHcCsi|]}tt||qSrF)getattr_signal)rDnamerFrFrG brLcCs z|WStyYdSw)z6Return true if the process has a controlling terminal.N)r2AttributeError)fhrFrFrGr2es   r2cCsttdr tStjdrdtjSttdrFdddtjdd D}tjd drB|d d d dtjd dD7}d |SdS)ztz#pyimplementation..Nr;-csrTrUrVrXrFrFrGrZvr[zPyPy CPython)hasattr _platformrPsysplatformrBjoinrR)vrFrFrGrms    &rc@seZdZdZdS)rz'Raised if a PID lock can't be acquired.N)__name__ __module__ __qualname____doc__rFrFrFrGr|src@s\eZdZdZdZddZddZeZddZd d Z e Z d d Z d dZ ddZ ddZdS)r aFPidfile. This is the type returned by :func:`create_pidlock`. See Also: Best practice is to not use this directly but rather use the :func:`create_pidlock` function instead: more convenient and also removes stale pidfiles (when the process holding the lock is no longer running). NcCstj||_dSrU)ospathabspath)selfrjrFrFrG__init__zPidfile.__init__c CsRz|W|Sty(}ztttt|tdWYd}~|Sd}~ww)z Acquire lock.N) write_pidOSErrorrrrWraexc_info)rlexcrFrFrGacquires &zPidfile.acquirecCstj|jS)z#Return true if the pid lock exists.)rirjexistsrlrFrFrG is_lockedszPidfile.is_lockedcGs |dS)z Release lock.N)removerlargsrFrFrGreleases zPidfile.releasec CstdMt|jd6}|}||krtd|zt|WWdWdSty@td|w1sDwYWddS1sTwYdS)z Read and return the current pid.ENOENTrz#Partial or invalid pidfile {0.path}Nz"pidfile {0.path} contents invalid.)r0openrjreadlinestrip ValueErrorformatint)rlrOlinerFrFrGread_pids$    "zPidfile.read_pidcCs@ttjtjt|jWddS1swYdS)zRemove the lock.N)r0errnor|EACCESriunlinkrjrvrFrFrGrxs"zPidfile.removec Csz|}Wntytdtjd|YdSw|s$|dSz t|dWdStjy_}z%|j t j ksB|j t j krTtdtjd|WYd}~dSWYd}~dSd}~wt ystdtjd|YdSw)zhRemove the lock if the process isn't running. I.e. process does not respons to signal. z#Broken pidfile found - Removing it.fileTrz#Stale pidfile exists - Removing it.NF) rrprintrastderrrxrikillerrorrESRCHEPERM SystemError)rlpidrsrFrFrGremove_if_stales4     zPidfile.remove_if_stalecCst}d|}t|jtt}t|d}z ||| zt |Wn t y1YnwW| n| wt|j}z| |krMtdW| dS| w)Nz{0} wz7Inconsistency: Pidfile content doesn't match at re-read)rigetpidrr~rj PIDFILE_FLAGS PIDFILE_MODEfdopenwriteflushfsyncrNclosereadr)rlrcontent pidfile_fdpidfilerfhrFrFrGrps,      zPidfile.write_pid)rerfrgrhrjrmrt __enter__rwr{__exit__rrxrrprFrFrFrGr s  r cCst|}t|j|S)aCreate and verify pidfile. If the pidfile already exists the program exits with an error message, however if the process it refers to isn't running anymore, the pidfile is deleted and the program continues. This function will automatically install an :mod:`atexit` handler to release the lock at exit, you can skip this by calling :func:`_create_pidlock` instead. Returns: Pidfile: used to manage the lock. Example: >>> pidlock = create_pidlock('/var/run/app.pid') )_create_pidlockatexitregisterr{rpidlockrFrFrGr!s r!cCsFt|}|r|stt||tjdt t | |S)Nr) r rwrr PIDLOCKEDrrrar SystemExitr5rtrrFrFrGrs rc st|D].}z t|tj}Wn tyYqwzt|ddWt|qt|wfddfddtt dDS)a[Return a list of file descriptors. This method returns list of file descriptors corresponding to file paths passed in paths variable. Arguments: paths: List[str]: List of file paths. Returns: List[int]: List of file descriptors. Example: >>> keep = fd_by_path(['/dev/urandom', '/my/precious/']) r r;cs.z t|ddvWStyYdSw)Nr r;F)rifstatrq)fd)statsrFrG fd_in_stats*s  zfd_by_path..fd_in_statscsg|]}|r|qSrFrF)rD_fd)rrFrG 0rMzfd_by_path..i) setrir~O_RDONLYrqaddrrranger)pathsrjrrF)rrrGr1s  r1c@sJeZdZdZdZ  dddZddZd d ZeZd d Z e Z d dZ dS)r"z(Context manager daemonizing the process.FNTcKsZt|trt||drdnd}|pt|_||_||_||_||_ t j t j t j f|_dS)N0 ) isinstancerrrBDAEMON_WORKDIRworkdirumaskfake after_chdir after_forkersrastdinstdoutrstdfds)rlrrrrrrkwargsrFrFrGrm8s  zDaemonContext.__init__cCs,|durttjtj}t||dSdSrU)rir~devnullO_RDWRdup2)rlrdestrFrFrGredirect_to_nullEszDaemonContext.redirect_to_nullcCs|jsP|js |t|j|jdurt|j|jr"||jsKt|j t dg}t ||j D] }| t |q6|jrKtdurKtd|_dSdS)Nz /dev/urandomT)_is_openr_detachrichdirrrrlistrr1rrr rmputil_run_after_forkers)rlkeeprrFrFrGr~Js"     zDaemonContext.opencGs|jrd|_dSdS)NF)rryrFrFrGrcs zDaemonContext.closecCs<tdkrttdkrtd|Std|SNr)riforksetsid_exitrvrFrFrGrhs    zDaemonContext._detach)NNNFNT) rerfrgrhrrmrr~rrrrrFrFrFrGr"3s   r"c  sTtstd|durtn|}tdt||dfdd}t||||dS)aDetach the current process in the background (daemonize). Arguments: logfile (str): Optional log file. The ability to write to this file will be verified before the process is detached. pidfile (str): Optional pid file. The pidfile won't be created, as this is the responsibility of the child. But the process will exit if the pid lock exists and the pid written is still running. uid (int, str): Optional user id or user name to change effective privileges to. gid (int, str): Optional group id or group name to change effective privileges to. umask (str, int): Optional umask that'll be effective in the child process. workdir (str): Optional new working directory. fake (bool): Don't actually detach, intended for debugging purposes. **opts (Any): Ignored. Example: >>> from celery.platforms import detached, create_pidlock >>> with detached( ... logfile='/var/log/app.log', ... pidfile='/var/run/app.pid', ... uid='nobody'): ... # Now in detached child process with effective user set to nobody, ... # and we know that our logfile can be written to, and that ... # the pidfile isn't locked. ... pidlock = create_pidlock('/var/run/app.pid') ... ... # Run the program ... program.run(logfile='/var/log/app.log') z&This platform does not support detach.NSIGCLDuidgidcs*otdrtdSdS)Na)r~rrr{rFlogfilerrFrGafter_chdir_dos z detached..after_chdir_do)rrrr)r RuntimeErrorrigetcwdr+resetr*r") rrrrrrroptsrrFrrGr#ss$  r#c CNzt|WSty&z t|jWYSttfy%td|ww)zParse user id. Arguments: uid (str, int): Actual uid, or the username of a user. Returns: int: The actual uid. zUser does not exist: {0})rrrgetpwnampw_uidrNKeyErrorrrrFrFrGr$  r$c Cr)zParse group id. Arguments: gid (str, int): Actual gid, or the name of a group. Returns: int: The actual gid of the group. zGroup does not exist: {0})rrrgetgrnamgr_gidrNrrrrFrFrGr%rr%c Cs|dd} zt|WSty't|dkr|dd|dd<Yn)tyO}z|jtjks:t|dkr;|dd|dd<WYd}~nd}~wwq)Nr )rir&rlenrqrEINVAL)groupsrsrFrFrG_setgroups_hacks     rc sd}ztd}Wn tyYnwz td|WStyD}z|jtjkr+tfddtDr9WYd}~dSd}~ww)z+Set active groups from a list of group ids.NSC_NGROUPS_MAXc3s|]}|vVqdSrUrF)rDgrouprrFrGrZr[zsetgroups..) risysconf Exceptionrrqrrany getgroups)r max_groupsrsrFrrGr&s   r&csNtsdSt|dttdrt|SfddtD}t|dS)zyInit process group permissions. Compat version of :func:`os.initgroups` that was first added to Python 2.7. Nrr'csg|] }|jvr|jqSrF)gr_memr)rDgrusernamerFrGrs zinitgroups..)rgetpwuidr_rir'rgetgrallr&)rrrrFrrGr's   r'cCtt|dS)z4Version of :func:`os.setgid` supporting group names.N)rir(r%rrFrFrGr(r(cCr)z2Version of :func:`os.setuid` supporting usernames.N)rir)r$rrFrFrGr)rr)cCstjdkrdStrtstd|ot|}|ot|}|r't||n|o,t ||r;ts;ts;td|rIt sKt sMtddSdSdS)aChange process privileges to new user/group. If UID and GID is specified, the real user/group is changed. If only UID is specified, the real user is changed, and the group is changed to the users primary group. If only GID is specified, only the group is changed. win32Nzcontact supportz%Still root uid after drop privileges!z%Still root gid after drop privileges!) rarbrigeteuidgetuidr r$r%_setuidr(getgidgetegidrrFrFrGr* s      r*c Csv|s tr t|j}t|t||t|z tdWt dty:}z|jtjkr/WYd}~dSd}~ww)Nrz6non-root user able to restore privileges after setuid.) rrpw_gidr(r'r)rqrrr )rrrsrFrFrGr)s     rc@seZdZdZejZejZe edrddZ nzddl m Z Wn ey+ddZ YnwddZ d d Zd d Zd dZddZddZddZddZdddZdS)SignalsaEConvenience interface to :mod:`signals`. If the requested signal isn't supported on the current platform, the operation will be ignored. Example: >>> from celery.platforms import signals >>> from proj.handlers import my_handler >>> signals['INT'] = my_handler >>> signals['INT'] my_handler >>> signals.supported('INT') True >>> signals.signum('INT') 2 >>> signals.ignore('USR1') >>> signals['USR1'] == signals.ignored True >>> signals.reset('USR1') >>> signals['USR1'] == signals.default True >>> from proj.handlers import exit_handler, hup_handler >>> signals.update(INT=exit_handler, ... TERM=exit_handler, ... HUP=hup_handler) setitimercCsttj|dSrU)rJr ITIMER_REALrlsecondsrFrFrG arm_alarmmrnzSignals.arm_alarmr)alarmcCstt|dSrU)rJr mathceilrrFrFrGr tscCst|SrU) _itimer_alarmrrFrFrGr xscCs tdSr)rJr rvrFrFrG reset_alarm{s zSignals.reset_alarmcCs&z||WdStyYdSw)z@Return true value if signal by ``name`` exists on this platform.FT)signumrNrlrKrFrFrG supported~s   zSignals.supportedcCsFt|tjr|St|tr|std|dsd|}tt|S)zGet signal number by name.z%signal name must be uppercase string.r@) rnumbersIntegralrisupper TypeErrorrBrIrJrrFrFrGrs    zSignals.signumcfdd|DdS)zReset signals to the default signal handler. Does nothing if the platform has no support for signals, or the specified signal in particular. c3|]}|jfVqdSrU)defaultrCrvrFrGrZz Signals.reset..Nupdate)rl signal_namesrFrvrGrz Signals.resetcr)zIgnore signal using :const:`SIG_IGN`. Does nothing if the platform has no support for signals, or the specified signal in particular. c3rrU)ignoredrCrvrFrGrZrz!Signals.ignore..Nr)rlnamesrFrvrGignorerzSignals.ignorecCst||SrU)rJ getsignalrrrFrFrG __getitem__szSignals.__getitem__c Cs2z t|||WdSttfyYdSw)zInstall signal handler. Does nothing if the current platform has no support for signals, or the specified signal in particular. N)rJsignalrrNr)rlrKhandlerrFrFrG __setitem__s zSignals.__setitem__NcKs.tt|pifi|D]\}}|||<q dS)z#Set signal handlers from a mapping.N)r dict)rl_d_sigmaprKr%rFrFrGrs  zSignals.updaterU)rerfrgrhrJSIG_IGNrSIG_DFLrr_r itimerr r ImportErrorrrrrr!r#r&rrFrFrFrGrEs("       rcCst|ddS)z)Return name of signal from signal number.r;N)r)rrFrFrGr,sr,cCs6d|dvrdnd}t||krd||dSdS)Nmanagerror  r])rrc)argv arg_startrFrFrGstrargvs r2cCs4d|}|r d||n|}trtt||S)zxSet the :command:`ps` name for the currently running process. Only works if :pypi:`setproctitle` is installed. z[{0}]z{0} {1})r _setproctitlerr )prognameinfo proctitlerFrFrGr-s r-NOSETPScOsdS)zDisabled feature.NrF)rkrFrFrGr.sr.cCs4|rd||}trtjnd}td|||dS)z|Set the :command:`ps` name from the current process name. Only works if :pypi:`setproctitle` is installed. z{0}: {1} MainProcessz{0}:{1})r5)rrrKr-)r4r5hostnamerKrFrFrGr.s cCst|tr tt|S|S)z(Get errno for string (e.g., ``ENOENT``).)rrrIr)nrFrFrGr/s  r/c osl|dptf}dd|D}zdVWdS|y5}zt|ds$|j|vr*WYd}~dSd}~ww)aContext manager to ignore specific POSIX error codes. Takes a list of error codes to ignore: this can be either the name of the code, or the code integer itself:: >>> with ignore_errno('ENOENT'): ... with open('foo', 'r') as fh: ... return fh.read() >>> with ignore_errno(errno.ENOENT, errno.EPERM): ... pass Arguments: types (Tuple[Exception]): A tuple of exceptions to ignore (when the errno matches). Defaults to :exc:`Exception`. typescSsg|]}t|qSrF)r/)rDrrFrFrGrsz ignore_errno..Nr)getrr_r)errnosrr<rsrFrFrGr0s   r0c Csttdr tnd}ttdrtnd}ttdrtnd}ttdr*tnd}ttdr>tddd Ds>td |rF|rF|rF|sd |vsNd |vrvtsvzt t j ||||d t j dWt j tdn t j tdwtttj ||||d dSdS)Nrirrrfchowncss|]}tt|VqdSrU)r_ri)rDattrrFrFrGrZsz#check_privileges..)rrrrz$suspicious platform, contact supportpicklezapplication/x-python-serialize)reuidregidrr )r_rirrrrallr r?rROOT_DISALLOWEDrrarrrwarningswarnRuntimeWarningROOT_DISCOURAGED)accept_contentrrrBrCrFrFrGcheck_privileges s6     rK)rorLcstfdd}|S)Ncs|g|Ri|SrU)encode)srzrfunrFrG_inner)sz_to_bytes_arg.._inner) functoolswraps)rPrQrFrOrG _to_bytes_arg(srT)NNNNrNF)NNrU)urh __future__rrrrrr rrirbr`r$rJstructrarF collectionsr contextlibrbilliard.compatrrkombu.utils.compatr kombu.utils.encodingr exceptionsr fiver rrlocalrbilliard.processrr-r3rrrr__all__rIrrrrr5systemrrrrO_CREATO_EXCLO_WRONLYrR_OKW_OKrrr<environr=r?rErIdirSIGNAMESrr2rrrobjectr PIDFiler!rr1r"r#r$r%rr&r'r(r)r*rrr+r get_signalr&install_signal_handlerr reset_signalr! ignore_signalr,r2r-r.r/r0rK version_inforRrTpackunpack unpack_fromrFrFrFrGs               n #@ 8 q