B 2dh@s@dZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddlmZddlmZddlZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl$m&Z'ddl(m)Z)ddl(m*Z*ddl+m,Z,ddl+m-Z-GdddeZ.ej/dej0dejfdZ1ej2e e fdd d!Z3e1e1d"d#d$Z4Gd%d&d&e!Z5Gd'd(d(e5Z6e#7e5d3e8e9ejej:e5e,fd+d,d-Z;d4e8e9ejej:e6e,fd+d.d/ZdS)5z%Base class to manage a running kernelN)Future)contextmanager)Enum)Any)Bool)default)DottedObjectName)Float)Instance)observe)observe_compat)Type)Unicode) import_item)ConnectionFileMixin)KernelManagerABC)KernelProvisionerBase)KernelProvisionerFactory) ensure_async)run_sync) KernelClient) kernelspecc@s eZdZdZdZdZdZdZdS)_ShutdownStatusz This is so far used only for testing in order to track the internal state of the shutdown logic, and verifying which path is taken for which missbehavior. NShutdownRequestSigtermRequestSigkillRequest)__name__ __module__ __qualname____doc__Unsetrrrr"r"c/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/jupyter_client/manager.pyr(s rF.)bound)returncCs*yttStk r$tSXdS)z Get an appropriate Future objectN)asyncioget_running_loopr RuntimeErrorCFuturer"r"r"r# _get_future:s r+)methodr&cs(tjtfdd}tt|S)zSets the kernel to a pending state by creating a fresh Future for the KernelManager's `ready` attribute. Once the method is finished, set the Future's results. c s|js |jst|_y6|f||IdH}tdIdH|jd|Stk r}z&|j||j |j |Wdd}~XYnXdS)Ng{Gz?) _attempted_start_readyr+r'sleep set_result Exception set_exceptionlog exception)selfargskwargsoute)r,r"r#wrapperJs   z!in_pending_state..wrapper)t no_type_check functoolswrapscastr$)r,r:r")r,r#in_pending_stateDsr@cseZdZUdZejejeefe d<fddZ e dZ e e d<e ejZe e d<edejdd d Zed Zee d <ed dZee d<ededddZed ejeefddddZedddZee d<dZejee d<e e j!Z"e e d<ede j!dddZ#ede$ejee fddddZ%e&ddd d!Z'e&e d"<ee j(Z)ee d#<ed#ejeefddd$d%Z*dZ+eje j,e d&<e-eje j,dd'd(Z.e d)d*Z/e e d+<ed+e0dd,d-Z1e-ejeefdd.d/Z2e-e0dd0d1Z3e4Z5e4e d2<e4Z6e4e d3<e4Z7e4e d4<e ddd5d!Z8e e d6<dZ9e0e d7<ddd8d9Z:ddd:d;Z;ddddxej=edd?dBdCZ?ej4e@dDdEdFZAdyejejBeejBedGdHdIZCejBeej4ddJdKdLZDeEeDZFdddMdNZGdddOdPZHej4ejIejBeejeej4ffdQdRdSZJeEeJZKej4ddQdTdUZLeEeLZMeNej4ddQdVdWZOeEeOZPdze0ddXdYdZZQeEeQZRd{ejeSeSeje0dd\d]d^ZTeEeTZUd|e0ddXd_d`ZVeEeVZWeNd}e0e0ddadbdcZXeEeXZYd~e0e0ej4ddddedfZZeEeZZ[e-e0ddgdhZ\de0ddXdidjZ]eEe]Z^de0ddXdkdlZ_eEe_Z`dddmdnZaeEeaZbecddodpdqZdeEedZee0ddrdsZfeEefZgdeSddtdudvZhZiS) KernelManagerzgManages a single kernel in a subprocess on this host. This version starts kernels with Popen. r.cs&tjf|tj|_d|_d|_dS)NF)super__init__rr!_shutdown_statusr-r.)r5r6r7) __class__r"r#rCgszKernelManager.__init__F_created_contextcontext)r&cCsd|_tS)NT)rFzmqContext)r5r"r"r#_context_defaultrszKernelManager._context_defaultz,jupyter_client.blocking.BlockingKernelClient client_classzjupyter_client.KernelClient)klassclient_factorycCs t|jS)N)rrK)r5r"r"r#_client_factory_default}sz%KernelManager._client_factory_defaultN)changer&cCstt|d|_dS)Nnew)rstrrM)r5rOr"r"r#_client_class_changedsz#KernelManager._client_class_changedT) allow_none kernel_id provisionerkernel_spec_managercCstj|jdS)N)data_dir)rKernelSpecManagerrW)r5r"r"r#_kernel_spec_manager_defaultsz*KernelManager._kernel_spec_manager_defaultcCs d|_dS)N) _kernel_spec)r5rOr"r"r#_kernel_spec_manager_changedsz*KernelManager._kernel_spec_manager_changedg@aTime to wait for a kernel to terminate before killing it, in seconds. When a shutdown request is initiated, the kernel will be immediately sent an interrupt (SIGINT), followedby a shutdown_request message, after 1/2 of `shutdown_wait_time`it will be sent a terminate (SIGTERM) request, and finally at the end of `shutdown_wait_time` will be killed (SIGKILL). terminate and kill may be equivalent on windows. Note that this value can beoverridden by the in-use kernel provisioner since shutdown times mayvary by provisioned environment.)confighelpshutdown_wait_time kernel_namecCsd|_|ddkrtj|_dS)NrPpython)rZrNATIVE_KERNEL_NAMEr_)r5rOr"r"r#_kernel_name_changeds z"KernelManager._kernel_name_changedrZcCs*|jdkr$|jdkr$|j|j|_|jS)N)rZr_rVZget_kernel_spec)r5r"r"r# kernel_specszKernelManager.kernel_speczQTrue if the MultiKernelManager should cache ports for this KernelManager instance)r] cache_portscCs |jdkS)NZtcp) transport)r5r"r"r#_default_cache_portssz"KernelManager._default_cache_portscCs|jst|_|jS)zMA future that resolves when the kernel process has started for the first time)r.r+)r5r"r"r#readyszKernelManager.readycCs |jdkS)N>r`python2python3)r_)r5r"r"r# ipykernelszKernelManager.ipykernel _launch_args_control_socket _restarterz,Should we autorestart the kernel if it dies. autorestart shutting_downcCs||dS)N)_close_control_socketcleanup_connection_file)r5r"r"r#__del__szKernelManager.__del__cCsdS)Nr")r5r"r"r#start_restarterszKernelManager.start_restartercCsdS)Nr")r5r"r"r#stop_restarterszKernelManager.stop_restarterrestart)callbackeventr&cCs |jdkrdS|j||dS)z;register a callback to be called when a kernel is restartedN)rnZ add_callback)r5rwrxr"r"r#add_restart_callbacks z"KernelManager.add_restart_callbackcCs |jdkrdS|j||dS)z=unregister a callback to be called when a kernel is restartedN)rnZremove_callback)r5rwrxr"r"r#remove_restart_callbacks z%KernelManager.remove_restart_callback)r7r&cKs@i}||jdd|t|j|d|||jf|S)z3Create a client configured to connect to our kernelT)session)connection_fileparent)updateZget_connection_infodictr|rM)r5r7kwr"r"r#clients  zKernelManager.client)extra_argumentsr&cs|pg}|jdk st|jj|}|rZ|dddtjddtjddhkrZtj|d<ttj |j tj d|jr|jj d< |jtd fd d fd d |DS)z/replace templated args (e.g. {connection_file})Nrr`zpython%iz python%i.%i)r|prefix resource_dirz\{([A-Za-z0-9_]+)\}cs|d|S)z9Get the key out of ns if it's there, otherwise no change.r)getgroup)match)nsr"r#from_ns)sz0KernelManager.format_kernel_cmd..from_nscsg|]}|qSr")sub).0arg)rpatr"r# -sz3KernelManager.format_kernel_cmd..)rdAssertionErrorargvsys version_info executablerospathrealpathr|rrr~rlrecompile)r5rcmdr")rrrr#format_kernel_cmds"          zKernelManager.format_kernel_cmd) kernel_cmdrr&cs>|jdk st|jj|f|IdH}|jjs0t||dS)zactually launch the kernel override in a subclass to launch kernel subprocesses differently Note that provisioners can now be used to customize kernel environments and N)rUrZ launch_kernel has_processZ_reconcile_connection_info)r5rrZconnection_infor"r"r#_async_launch_kernel/s z"KernelManager._async_launch_kernelcCs"|jdkr|d|_d|j_dS)Ncontrold)rmZ_create_connected_socketlinger)r5r"r"r#_connect_control_socketAs  z%KernelManager._connect_control_socketcCs"|jdkrdS|jd|_dS)N)rmclose)r5r"r"r#rqFs  z#KernelManager._close_control_socket)rr&cs|d|_|jp|dtt|_||_|jdkrVt j |j dj |j|j |d|_|jjf|IdH}|d}||fS)a{Prepares a kernel for startup in a separate process. If random ports (port=0) are being used, this method must be called before the channels are created. Parameters ---------- `**kw` : optional keyword arguments that are passed down to build the kernel_cmd and launching the kernel (e.g. Popen kwargs). FrTN)r}r)rprTpoprQuuiduuid4copyrlrUKPFinstancer}Zcreate_provisioner_instancerdZ pre_launch)r5rrr"r"r#_async_pre_start_kernelLs    z%KernelManager._async_pre_start_kernelcs6|||jdk st|jjf|IdHdS)zPerforms any post startup tasks relative to the kernel. Parameters ---------- `**kw` : optional keyword arguments that were used in the kernel process's launch. N)rtrrUrZ post_launch)r5rr"r"r#_async_post_start_kerneljsz&KernelManager._async_post_start_kernelcs`d|_t|jf|IdH\}}|jd|t|j|f|IdHt|jf|IdHdS)azStarts a kernel on this host in a separate process. If random ports (port=0) are being used, this method must be called before the channels are created. Parameters ---------- `**kw` : optional keyword arguments that are passed down to build the kernel_cmd and launching the kernel (e.g. Popen kwargs). TNzStarting kernel: %s)r-rpre_start_kernelr3debug_launch_kernelpost_start_kernel)r5rrr"r"r#_async_start_kernelys z!KernelManager._async_start_kernel)rvr&cs`t|d}|jjd|d}||j|j||jdk s@t|jj|dIdHt j |_ dS)z+Send a shutdown request via control channel)rvshutdown_request)contentN) rr{msgrsendrmrUrZshutdown_requestedrrrD)r5rvrrr"r"r#_async_request_shutdowns z%KernelManager._async_request_shutdown皙?)waittime pollintervalrvr&cs|dkrt|jd}|jr(|jj|d}y$tj|j|d|ddIdHWn<tjk r|j dt j |_ t |IdHYnXy$tj|j|d|ddIdHWn@tjk r|j dt j|_ t |j|d IdHYn*X|jr|jdk st|jIdHdS) zWait for kernel shutdown, then kill process if it doesn't shutdown. This does not send shutdown requests - use :meth:`request_shutdown` first. Nr)Z recommended)rr)timeoutz0Kernel is taking too long to finish, terminatingz,Kernel is taking too long to finish, killing)rv)maxr^rUZget_shutdown_wait_timer'wait_for _async_wait TimeoutErrorr3rrrrDr_send_kernel_sigtermr _kill_kernel has_kernelrwait)r5rrrvr"r"r#_async_finish_shutdowns*      z$KernelManager._async_finish_shutdowncsZ|s |||d|j_|jr<|s<|jjdd|jrV|jj |dIdHdS)z/Clean up resources when the kernel is shut downNr)r)rv) rrZcleanup_ipc_filesrqr{r}rFrGdestroyrUcleanup)r5rvr"r"r#_async_cleanup_resourcess z&KernelManager._async_cleanup_resources)nowrvr&csd|_||jr&t|IdH|r>t|IdHn,t|j|dIdHt|j|dIdHt|j|dIdHdS)aZAttempts to stop the kernel process cleanly. This attempts to shutdown the kernels cleanly by: 1. Sending it a shutdown message over the control channel. 2. If that fails, the kernel is shutdown forcibly by sending it a signal. Parameters ---------- now : bool Should the kernel be forcible killed *now*. This skips the first, nice shutdown attempt. restart: bool Will this kernel be restarted after it is shutdown. When this is True, connection files will not be cleaned up. TN)rv) rprurrinterrupt_kernelrrequest_shutdownfinish_shutdowncleanup_resources)r5rrvr"r"r#_async_shutdown_kernelsz$KernelManager._async_shutdown_kernel)rnewportsrr&cs^|jdkrtdt|j|ddIdH|r6||j|t|jf|jIdHdS)ayRestarts a kernel with the arguments that were used to launch it. Parameters ---------- now : bool, optional If True, the kernel is forcefully restarted *immediately*, without having a chance to do any cleanup action. Otherwise the kernel is given 1s to clean up before a forceful restart is issued. In all cases the kernel is restarted, the only difference is whether it is given a chance to perform a clean shutdown or not. newports : bool, optional If the old kernel was launched with random ports, this flag decides whether the same ports and connection file will be used again. If False, the same ports and connection file are used. This is the default. If True, new random port numbers are chosen and a new connection file is written. It is still possible that the newly chosen random port numbers happen to be the same as the old ones. `**kw` : optional Any options specified here will overwrite those used to launch the kernel. Nz>Cannot restart the kernel. No previous call to 'start_kernel'.T)rrv)rlr)rshutdown_kernelZcleanup_random_portsr~ start_kernel)r5rrrr"r"r#_async_restart_kernels  z#KernelManager._async_restart_kernelcCs|jdk o|jjS)z@Has a kernel process been started that we are actively managing.N)rUr)r5r"r"r#r(szKernelManager.has_kernelcs,|jr(|jdk st|jj|dIdHdS)zIsimilar to _kill_kernel, but with sigterm (not sigkill), but do not blockN)rv)rrUr terminate)r5rvr"r"r#_async_send_kernel_sigterm-sz(KernelManager._async_send_kernel_sigtermcs|jr~|jdk st|jj|dIdHytj|ddIdHWn"tjk rf|j dYnX|jr~|j IdHdS)zrKill the running kernel. This is a private method, callers should use shutdown_kernel(now=True). N)rvg@)rz>Wait for final termination of kernel timed out - continuing...) rrUrkillr'rrrr3warningr)r5rvr"r"r#_async_kill_kernel5s z KernelManager._async_kill_kernelcsz|jrn|jdk st|jj}|dkrsb                        *