B ç¹`&;ã@s0ddlmZddlmZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z ddlmZddlmZmZddlmZmZmZmZmZdd lmZmZmZe r¼dd lmZGd d „d eƒZ Gd d„dƒZ!Gdd„dƒZ"Gdd„deƒZ#ddd„Z$dd„Z%dd„Z&deddddddfdd„Z'dS)é)Údeque)ÚcontextmanagerNé)ÚWINÚglob)Ú ProcessGroup)Ú DefaultLoggerÚ SilentLogger)ÚdefaultÚis_stream_interactiveÚis_watchdog_supportedÚis_watchman_supportedÚ resolve_spec)ÚWorkerÚ get_reloaderÚ is_active)Úwinapic@sFeZdZdZdZddd„Zdd„Zdd„Zd d „Zd d „Z d d„Z dS)ÚFileMonitorProxyz¬ Wrap an :class:`hupper.interfaces.IFileMonitor` into an object that exposes a thread-safe interface back to the reloader to detect when it should reload. NcCs@||_||_tƒ|_dd„t|p"gƒDƒ|_t ¡|_d|_dS)NcSsg|]}t t |¡¡‘qS©)ÚreÚcompileÚfnmatchÚ translate)Ú.0ÚxrrúW/home/kop/projects/devel/pgwui/test_venv/lib/python3.7/site-packages/hupper/reloader.pyú *sz-FileMonitorProxy.__init__..F) ÚcallbackÚloggerÚsetÚ changed_pathsÚ ignore_filesÚ threadingÚLockÚlockÚ is_changed)Úselfrrr!rrrÚ__init__%s  zFileMonitorProxy.__init__csDx>t|ddp|gD](‰t‡fdd„|jDƒƒs|j ˆ¡qWdS)NT)Ú recursivec3s|]}| ˆ¡VqdS)N)Úmatch)rr)Úprrú 4sz,FileMonitorProxy.add_path..)rÚanyr!ÚmonitorÚadd_path)r&Úpathr)r*rr./szFileMonitorProxy.add_pathcCs|j ¡dS)N)r-Ústart)r&rrrr07szFileMonitorProxy.startcCs|j ¡|j ¡dS)N)r-ÚstopÚjoin)r&rrrr1:s zFileMonitorProxy.stopc CsV|jF||jkrH|j d |¡¡|j |¡|jsHd|_| |j¡WdQRXdS)Nz{} changed; reloading ...T)r$r rÚinfoÚformatÚaddr%r)r&r/rrrÚ file_changed>s  zFileMonitorProxy.file_changedc Cs$|jtƒ|_d|_WdQRXdS)NF)r$rr r%)r&rrrÚ clear_changesHszFileMonitorProxy.clear_changes)N) Ú__name__Ú __module__Ú __qualname__Ú__doc__r-r'r.r0r1r6r7rrrrrs  rc@sFeZdZdd„ZedƒZedƒZedƒZedƒZedƒZedƒZ [d S) Ú ControlSignalcCst|ƒ d¡S)NÚascii)ÚchrÚencode)rrrrÚOózControlSignal.réééé é N) r8r9r:ÚbyteÚSIGINTÚSIGHUPÚSIGTERMÚSIGCHLDÚ FILE_CHANGEDÚWORKER_COMMANDrrrrr<Nsr<c@seZdZdZdZdZdS)Ú WorkerResultÚexitÚreloadÚwaitN)r8r9r:ÚEXITÚRELOADÚWAITrrrrrN[srNc@sˆeZdZdZddd„Zdd„Zdd „Zd d „Zd d „Ze dd„ƒZ e dd„ƒZ dd„Z e dd„ƒZ ejejejejdœZe dd„ƒZdS)ÚReloaderzr A wrapper class around a file monitor which will handle changes by restarting a new worker process. rNc CsB||_||_||_||_||_||_||_||_d|_t ƒ|_ dS)N) Ú worker_pathÚ worker_argsÚ worker_kwargsr!Úmonitor_factoryÚreload_intervalÚshutdown_intervalrr-rÚ process_group) r&rVrYrrZr[rWrXr!rrrr'ms zReloader.__init__c Csz| ¡^xV| ¡}t ¡}|tjkr.| ¡}|tjkr:P|jt ¡|}|dkr t |¡q WWdQRXt   d¡dS)z‡ Execute the reloader forever, blocking the current thread. This will invoke ``sys.exit(1)`` if interrupted. rNr) Ú_setup_runtimeÚ _run_workerÚtimerNrTÚ_wait_for_changesrRrZÚsleepÚsysrO)r&Úresultr0ÚdtrrrÚrunƒs   z Reloader.runc Cs | ¡| ¡WdQRXdS)zd Execute the worker once. This method will return after the worker exits. N)r]r^)r&rrrÚrun_once—s zReloader.run_oncecCst|j|j|jd}t||ƒS)N)ÚargsÚkwargs)rrVrWrXr^)r&Úworkerrrrr^¡szReloader._run_workercCsttdƒ}t||tƒddS)Nz .wait_mainr)rr[)rr8r^r )r&rirrrr`§s  zReloader._wait_for_changesc csF| ¡4| ¡ | ¡ dVWdQRXWdQRXWdQRXdS)N)Ú_start_controlÚ_start_monitorÚ_capture_signals)r&rrrr]°s   zReloader._setup_runtimec csFt ¡\|_|_z dVWdt |j¡t |j¡d|_|_XdS)N)ÚosÚpipeÚ control_rÚ control_wÚclose)r&rrrrj·s    zReloader._start_controlcs‡‡fdd„S)Ncst ˆjˆ¡S)N)rmÚwriterp)rg)r&Úsignalrrr@ÂrAz)Reloader._control_proxy..r)r&rsr)r&rsrÚ_control_proxyÁszReloader._control_proxyccs`t| tj¡|j|jƒ}|j|j|j|jd|_ ||_ |j   ¡z dVWdd|_ |  ¡XdS)N)Úintervalr) rrtr<rLrr!rYr6rZr-r0r1)r&ÚproxyrrrrkÄs    zReloader._start_monitor)rHrIrJrKccs¾g}zšxŽ|j ¡D]€\}}tt|dƒ}|dkrB|j d |¡¡q| |¡}trr|dkrrt   |¡}|  |¡tj }t ||¡}|  ||fdd„¡qWdVWdxt |ƒD] }|ƒqªWXdS)Nzskipping unsupported signal={}rHcSs t ||¡S)N)rs)Úsr*rrrr@ñrAz+Reloader._capture_signals..)Ú_signalsÚitemsÚgetattrrsrÚdebugr4rtrrZAddConsoleCtrlHandlerÚappendÚSIG_IGNÚreversed)r&Z undo_handlersZsignameÚcontrolÚsignumÚhandlerZundoZpsigrrrrlßs&        zReloader._capture_signals)rrNNN)r8r9r:r;r'rerfr^r`rr]rjrtrkr<rHrIrJrKrxrlrrrrrUfs&      rUc sf|dkrˆj}|dkrˆj}tƒ‰‡‡fdd„}ˆj ¡| |¡tj}d}| d|j ¡zˆj   |j ¡xxˆr*ˆ  ¡}|dkrÄ|j ršt d¡|j r²| d¡tj}Pt ˆjtj¡qt| d |d¡¡|dd krîtj}Pqt|dd krx*|dD]}ˆj |¡qWqttd |ƒ‚qtt ˆjd¡} | sR| d ¡tj}Pqt| tjkrv| d ¡tj}d}Pqt| tjkr–| d¡tj}Pqt| tj kr¶| d¡tj}Pqt| tj!krÖˆjj"rètj}Pqt| tjkrt|j stPqtW|j r |r |r| d¡|j#dd| $|¡Wd|j rH| d¡| #¡| %¡n| %¡| d|j&¡X|S)Ncsˆ |¡t ˆjtj¡dS)N)r|rmrrrpr<rM)Úpacket)Úpacketsr&rrÚ handle_packets z"_run_worker..handle_packetTzStarting monitor for PID %s.rz3Worker pipe died unexpectedly, triggering a reload.zReceived worker command "{}".rrPZ watch_fileszreceived unknown control signalzControl pipe died unexpectedly.z/Received SIGINT, waiting for server to exit ...Fz%Received SIGHUP, triggering a reload.z(Received SIGTERM, triggering a shutdown.zGracefully killing the server.)Zsoftz(Server did not exit, forcefully killing.zServer exited with code %d.)'rr[rr-r7r0rNrTr3Úpidr\Z add_childÚpopleftÚis_aliver_rarSrmrrrpr<rKr{r4r.Ú RuntimeErrorÚreadroÚerrorrRrHrIrJrLr%ÚkillrQr2Úexitcode) r&rirr[r„rcZ soft_killÚcmdr/rsr)rƒr&rr^ùs                   r^cCsXy>tƒ}ttjƒr$tdƒ| ¡ntdƒxt d¡q.WWnt k rRYnXdS)Nz(Press ENTER or change a file to reload. z+Waiting for a file to change before reload.rE) rr rbÚstdinÚinputZtrigger_reloadÚprintr_raÚKeyboardInterrupt)ÚreloaderrrrÚ wait_mainvs  r“cCs|t d¡}|r&t|ƒ}| d|¡nRtƒrDddlm}| d¡n4tƒrbddlm }| d¡nddl m }| d ¡|S) NZHUPPER_DEFAULT_MONITORzFile monitor backend: r)ÚWatchmanFileMonitorzFile monitor backend: watchman)ÚWatchdogFileMonitorzFile monitor backend: watchdog)ÚPollingFileMonitorzFile monitor backend: polling) rmÚgetenvrr{r Zwatchmanr”r Zwatchdogr•Úpollingr–)rÚspecrYrrrÚfind_default_monitor_factory…s       ršc CsXtƒr tƒS|dkrt|ƒ}|dkr,t|ƒ}|tkr8|}t||||||||d} |  ¡S)a¥ Start a monitor and then fork a worker process which starts by executing the importable function at ``worker_path``. If this function is called from a worker process that is already being monitored then it will return a reference to the current :class:`hupper.interfaces.IReloaderProxy` which can be used to communicate with the monitor. ``worker_path`` must be a dotted string pointing to a globally importable function that will be executed to start the worker. An example could be ``myapp.cli.main``. In most cases it will point at the same function that is invoking ``start_reloader`` in the first place. ``reload_interval`` is a value in seconds and will be used to throttle restarts. Default is ``1``. ``shutdown_interval`` is a value in seconds and will be used to trigger a graceful shutdown of the server. Set to ``None`` to disable the graceful shutdown. Default is the same as ``reload_interval``. ``verbose`` controls the output. Set to ``0`` to turn off any logging of activity and turn up to ``2`` for extra output. Default is ``1``. ``logger``, if supplied, supersedes ``verbose`` and should be an object implementing :class:`hupper.interfaces.ILogger`. ``monitor_factory`` is an instance of :class:`hupper.interfaces.IFileMonitorFactory`. If left unspecified, this will try to create a :class:`hupper.watchdog.WatchdogFileMonitor` if `watchdog `_ is installed and will fallback to the less efficient :class:`hupper.polling.PollingFileMonitor` otherwise. If ``monitor_factory`` is ``None`` it can be overridden by the ``HUPPER_DEFAULT_MONITOR`` environment variable. It should be a dotted python path pointing at an object implementing :class:`hupper.interfaces.IFileMonitorFactory`. ``ignore_files`` if provided must be an iterable of shell-style patterns to ignore. N)rVrWrXrZr[rYrr!)rrrršr rUre) rVrZr[ÚverboserrYrWrXr!r’rrrÚstart_reloaderžs$5rœ)NN)(Ú collectionsrÚ contextlibrrrmrrsrbr"r_ÚcompatrrZipcrrrr Úutilsr r r r rrirrrÚrÚobjectrr<rNrUr^r“ršrœrrrrÚs>    3   }