o @Bi?@sddlmZddlZddlZddlZddlmZddlZddlm Z ddl m Z ddl m ZddlmZmZmZddlmZmZddlmZmZdd lmZd Zdd d Zdd dZGdddeZGdd d e Z ddZ!dS))absolute_importN)partial)ObservableMixin) parse_url)ComponentConfigSubscribeOptionsRegisterOptions)SessionNotReadyApplicationError)create_authenticatorIAuthenticator) SERID_TO_SER ComponentcCs(|r||n t|tstdt|trd|vrtd|ddvr,td|d|D] }|dvr=td|q0|ddkrfd D] }||vrStd |qFd D] }||vrctd |qVdS|dd krd D] }||vr{td|qndD] }||vrtd|q~dSJddS)z9 Check a WAMP connecting endpoint configuration. z'endpoint' must be a dicttypez)'type' required in endpoint configuration)tcpunixzinvalid type "{}" in endpoint)rhostportpathtlsz*Invalid key '{}' in endpoint configurationrrrz&'{}' required in 'tcp' endpoint config)rz''{}' not valid in 'tcp' endpoint configrz('{}' required for 'unix' endpoint config)rrrz('{}' not valid in 'unix' endpoint configFshould not arrive hereN) isinstancedict ValueErrorformatkeys)endpointcheck_native_endpointkr W/var/www/html/Trade-python/venv/lib/python3.10/site-packages/autobahn/wamp/component.py_validate_endpoint4s^       r"c Csnt|tkrtdt|gd}|D] }||vr$td|qd}d|vr?|ddvr:td|d|d}nd|d<d|vrO|dkrOtd |dd }|d ur{|D] }|d vrjtd |q]d D] }||vrztd |qmt}d|vr|d}t|tstdt||dkrdD] }||vrtd|qd|vrt|d\} } } } } }d| | | d}n |d}t ||d|vrtdd|vrt|dt t fstdt dd|dDstdt }|dD]}||vrtd|ddd|Dq|ddd g}nu|d!krd|vrb|dd"r8t|d\}} } n|dd#rMt|d\}} } } } }nt| d$kr[d$| d%}n d| | d&}n|d}d|vrotd'd|vrt|dtjtfstd(|dg}ndg}nJd*i}d+D]}||vr||||<qt|f||dd ||||d,|S)-a Internal helper to insert defaults and create _Transport instances. :param transport: a (possibly valid) transport configuration :type transport: dict :returns: a _Transport instance :raises: ValueError on invalid configuration zsz%_create_transport..z-Invalid serializer '{}' (expected one of: {})z, cSsg|]}t|qSr )reprr2r r r!r5scborjsonr.rswsr)rr)rrrz5'serializers' is only for websocket; use 'serializer'z'serializer' must be a stringFr)r'r(r)r*r+)kindr#rr%r,r&)rrrrrgetformaTr parse_ws_urlr"listtupleallr join startswith parse_rs_url RuntimeErrorr/r0r1 _Transport)index transportrvalid_transport_keysrr;r,r&key is_securerrresourcerparamsendpoint_configvalid_serializersserialserializer_configisSecurekwr r r!_create_transportms                      rTc@sReZdZdZddddddefddZd d Zd d Zd dZddZ ddZ dS)rFz@ Thin-wrapper for WAMP transports used by a Connection. i,g?g?Nc Csx||_||_||_||_| |_||_|jdkr!t|dkr!td||_||_ ||_ | |_ | |_ | |_ d|_|dS)z r.z5'rawsocket' transport requires exactly one serializerFN)idxrr#rr&r%lenrr'r(r)r*r+r,_permanent_failurereset) selfrWr;r#rr%r'r(r)r*r+r,r&r r r!__init__ s$  z_Transport.__init__cCsd|_d|_d|_|j|_dS)zP set connection failure rates and retry-delay to initial values rN)connect_attemptsconnect_sucessesconnect_failuresr) retry_delayr[r r r!rZ/s z_Transport.resetcCs d|_dS)z Mark this transport as failed, meaning we won't try to connect to it any longer (that is: can_reconnect() will always return False afer calling this). TN)rYrar r r!failed8s z_Transport.failedcCs(|jrdS|jdkr dS|j|jdkS)NFrUTrV)rYr'r]rar r r! can_reconnect@s  z_Transport.can_reconnectcCsp|jdkrdS|jdkr|j|jdkrtd|j|j|_t|j|j|j|_|j|jkr5|j|_|jS)NrrUrVzmax reconnects reached) r]r'rEr`r*random normalvariater+r(rar r r! next_delayGs  z_Transport.next_delaycCs t|jtr |jdSt|jS)zF returns a human-readable description of the endpoint r)rrrr6rar r r!describe_endpointTs   z_Transport.describe_endpoint) __name__ __module__ __qualname____doc__rr\rZrbrcrfrgr r r r!rFs $  rFc@seZdZdZdZ dddZdddZ  ddd Zd d Zdd d Z ddZ ddZ ddZ ddZ ddZddZddZddZdS) rz A WAMP application component. A component holds configuration for (and knows how to create) transports and sessions. Nc*dus tts Jfdd}|S)a] A decorator as a shortcut for subscribing during on-join For example:: @component.subscribe( u"some.topic", options=SubscribeOptions(match=u'prefix'), ) def topic(*args, **kw): print("some.topic({}, {}): event received".format(args, kw)) Nc fdd}d|S)Nc|jdS)N)topicr&) subscribesessiondetails)fnr&ror r!do_subscription}z?Component.subscribe..decorator..do_subscriptionrBon)rtrur&r[rortr! decorator{ z&Component.subscribe..decorator)rr)r[ror&r{r ryr!rpl zComponent.subscribecrl)a\ A decorator as a shortcut for registering during on-join For example:: @component.register( u"com.example.add", options=RegisterOptions(invoke='round_robin'), ) def add(*args, **kw): print("add({}, {}): event received".format(args, kw)) Ncrm)Ncrn)N) procedurer&)registerrq)rtr&urir r!do_registrationrvz>Component.register..decorator..do_registrationrBrw)rtrr&r[rrzr!r{r|z%Component.register..decorator)rr)r[rr&r{r rr!rr}zComponent.registerrealm1c Cs|gd|durt|std||_|dur"t|s"td||_|dur+d}t|tjtfr>|} d| d} | g}nt|t rF|g}g|_ t |D]\} } |j t | | |jqM|p`i|_|rg||_||_||_d|_d|_d|_d|_dS) a :param main: After a transport has been connected and a session has been established and joined to a realm, this (async) procedure will be run until it finishes -- which signals that the component has run to completion. In this case, it usually doesn't make sense to use the ``on_*`` kwargs. If you do not pass a main() procedure, the session will not be closed (unless you arrange for .leave() to be called). :type main: callable taking 2 args: reactor, ISession :param transports: Transport configurations for creating transports. Each transport can be a WAMP URL, or a dict containing the following configuration keys: - ``type`` (optional): ``websocket`` (default) or ``rawsocket`` - ``url``: the router URL - ``endpoint`` (optional, derived from URL if not provided): - ``type``: "tcp" or "unix" - ``host``, ``port``: only for TCP - ``path``: only for unix - ``timeout``: in seconds - ``tls``: ``True`` or (under Twisted) an ``twisted.internet.ssl.IOpenSSLClientComponentCreator`` instance (such as returned from ``twisted.internet.ssl.optionsForClientTLS``) or ``CertificateOptions`` instance. - ``max_retries``: Maximum number of reconnection attempts. Unlimited if set to -1. - ``initial_retry_delay``: Initial delay for reconnection attempt in seconds (Default: 1.0s). - ``max_retry_delay``: Maximum delay for reconnection attempts in seconds (Default: 60s). - ``retry_delay_growth``: The growth factor applied to the retry delay between reconnection attempts (Default 1.5). - ``retry_delay_jitter``: A 0-argument callable that introduces nose into the delay. (Default random.random) - ``serializer`` (only for raw socket): Specify an accepted serializer (e.g. 'json', 'msgpack', 'cbor', 'ubjson', 'flatbuffers') - ``serializers``: Specify list of accepted serializers - ``options``: tbd - ``proxy``: tbd :type transports: None or unicode or list of dicts :param realm: the realm to join :type realm: unicode :param authentication: configuration of authenticators :type authentication: dict mapping auth_type to dict :param session_factory: if None, ``ApplicationSession`` is used, otherwise a callable taking a single ``config`` argument that is used to create a new `ApplicationSession` instance. :type session_factory: callable :param is_fatal: a callable taking a single argument, an ``Exception`` instance. The callable should return ``True`` if this error is "fatal", meaning we should not try connecting to the current transport again. The default behavior (on None) is to always return ``False`` :type is_fatal: callable taking one arg, or None )startconnectrBreadyleave disconnectconnectfailureNz%"is_fatal" must be a callable or Nonez""main" must be a callable if givenzws://127.0.0.1:8080/wsr-)rr#F)set_valid_eventscallabler _is_fatal_entryrr/r0r1r _transports enumerateappendrT_check_native_endpoint_authenticationsession_factory_realm_extra_delay_f_done_f_session _stopping) r[main transportsconfigrealmextraauthenticationris_fatalr#rHrWr r r!r\sB;     zComponent.__init__cCs|jD] }|r dSqdS)NTF)rrc)r[rHr r r!_can_reconnects zComponent._can_reconnectcsjdurtfdd}tj||St_fdd}tj||tjdgfddfd d fd d d }t|jS)a This starts the Component, which means it will start connecting (and re-connecting) to its configured transports. A Component runs until it is "done", which means one of: - There was a "main" function defined, and it completed successfully; - Something called ``.leave()`` on our session, and we left successfully; - ``.stop()`` was called, and completed successfully; - none of our transports were able to connect successfully (failure); :returns: a Future/Deferred which will resolve (to ``None``) when we are "done" or with an error if something went wrong. Ncst|dSN)txaioresolvearg)dr r!_cb/rvzComponent._start.._cbcs d_|S)z} if the _done_f future is resolved (good or bad), we want to set it to None in our class N)rrrar r!_reset9sz Component._start.._resetrcs\d_jrtjddSjjdt|djjdt |dt j|dS)NzInternal error {msg}msg{tb}tb) rrrrrloginfofailure_messagedebugfailure_format_tracebackreject)failrar r!errorIs zComponent._start..errorcsbd_fddfddfdd}fdd}tjd }t|||dS) Ncsjjdt|djjdt|dt|jtr(jjd|j dn7t|jt r:jj dt|dn% |jrT|jj dd\}}}jjd |d n jjd t|djdurgd }n|j}|r{j d dtdddS)Nzcomponent failed: {error})rrrz{msg}rzConnection failed: {msg}rzTLS failure: {reason})reasonzConnection failed: {error}Fz"Error was fatal; failing transport)rrrrrrvaluer r error_messageOSErrorr _is_ssl_errorargsrrb call_later)rssl_libssl_func ssl_reasonr)r[transport_candidatetransport_checkr r!handle_connect_errorYs*        zGComponent._start..attempt_connect..handle_connect_errorcs>tdj}t|fddfddS)Nrc tSrrr_chain_frr r! zYComponent._start..attempt_connect..notify_connect_error..crrrrrr r!rr)r create_futurefirer add_callbacks)r handler_frarr!notify_connect_errors  zGComponent._start..attempt_connect..notify_connect_errorcs|}t|ddSr)rr)rnotify_frrr r! connect_errorsz@Component._start..attempt_connect..connect_errorcstjddSr)rrr)xrar r! session_donesz?Component._start..attempt_connect..session_doner)rr as_future _connect_oncer)rrr connect_f)loopr[rrrr!attempt_connectVs 0 z)Component._start..attempt_connectc sjds1d}j|zt|ty0}ztj|WYd}~dSd}~ww t}| r?|d<nq2| }jjd|j |dt |_ tj dS)NzEntering re-connect loopz:Component failed: Exhausted all transport connect attemptsTrzFtrying transport {transport_idx} using connect delay {transport_delay}) transport_idxtransport_delay)rrrrrErrrnextrcrfrWsleeprr)rerr_msgerHdelay)rrr[r transport_genr r!rs2   z)Component._start..transport_checkr)rrrr itertoolscyclerr)r[rrrstart_fr )rrrrr[rrrr!_starts       NzComponent._startcCsZd|_|jr|jr|jS|jrttj|jSt|j s(t |j dt dS)NT) rr is_attachedrrrrcancel is_calledrrcreate_future_successrar r r!stops   zComponent.stopcstjjdjdtfdd}jd7_tj|}fdd}t |d|S)NzWconnecting once using transport type "{transport_type}" over endpoint "{endpoint_desc}")transport_type endpoint_descc stjj}z,|_}jD]\}}t|tr$| |qt |fi|}| |qWnt yK}z t |}t |d}~ww|_fdd}|d|fdd}jdurp|d|fdd} |d | |S) NcsXjjd|dts*|jdvrtddStt|j}t|dSdS)Nz"session leaving '{details.reason}'rs)zwamp.close.normal) rrrrrrcreate_failurer r)rrrsfdoner[r r!on_leaves  zAComponent._connect_once..create_session..on_leavercs^jd7_jjd|dtj}fdd}fdd}t|||dS)NrVzsession on_join: {details}rcs(jdfdd}td|dS)N main_successcs$zWdStyYdSwr)rr r rrr r!rs  zeComponent._connect_once..create_session..on_join..main_success..leaver)rrrr)rr)r[rrr r!rs  zVComponent._connect_once..create_session..on_join..main_successcs(jjd|dt|dS)Nzmain_error: {err}err)rrrrrr)rr[rrr r! main_error"s  zTComponent._connect_once..create_session..on_join..main_error)r^rrrrrr)rrrsrrrrreactorr[rHrr!on_joins  z@Component._connect_once..create_session..on_joinrBcsBjjd|dts|sjddStddSdS)Nz,session on_disconnect: was_clean={was_clean}) was_cleanzSession disconnected uncleanly)rrrrwarnr)rrrrr r! on_disconnect-s zFComponent._connect_once..create_session..on_disconnectr)rrrrrritemsrr add_authenticatorr Exceptionrrr_parentrxr) cfgrr auth_name auth_config authenticatorrrrrrrr r!create_sessions0          z/Component._connect_once..create_sessionrVcs,jd7_tst|dSdS)a this may seem redundant after looking at _connect_transport, but it will handle a case where something goes wrong in _connect_transport itself -- as the only connect our caller has is the 'done' future rVN)r_rrrr)rrHr r!on_errorGs z)Component._connect_once..on_error) rrrrgrrr]r_connect_transportr)r[rrHrrrr rr!rs] zComponent._connect_oncecC|d|dS)z A decorator as a shortcut for listening for 'join' events. For example:: @component.on_join def joined(session, details): print("Session {} joined: {}".format(session, details)) rBNrwr[rtr r r!rWs zComponent.on_joincCr )zM A decorator as a shortcut for listening for 'leave' events. rNrwr r r r!rczComponent.on_leavecCr )zO A decorator as a shortcut for listening for 'connect' events. rNrwr r r r! on_connectir zComponent.on_connectcCr )zR A decorator as a shortcut for listening for 'disconnect' events. rNrwr r r r!ror zComponent.on_disconnectcCr )zM A decorator as a shortcut for listening for 'ready' events. rNrwr r r r!on_readyur zComponent.on_readycCr )zV A decorator as a shortcut for listening for 'connectfailure' events. rNrwr r r r!on_connectfailure{r zComponent.on_connectfailurer)NNNrNNNN)rhrirjrkrrprr\rrrrrrr rrrr r r r!ras*   y .  c st|tr|g}t|tkrtdt||D]}t|ts)tdt|qtfddfddfdd}g}|D] }||}||qFtj |d d }fd d } t || | |S) a Internal helper. Use "run" method from autobahn.twisted.wamp or autobahn.asyncio.wamp This is the generic parts of the run() method so that there's very little code in the twisted/asyncio specific run() methods. This is called by react() (or run_until_complete() so any errors coming out of this should be handled properly. Logging will already be started. zB"components" must be a list of Component objects - encountered {0}zN"components" must be a list of Component objects - encountereditem of type {0}csjd||d|S)Nz-Component '{c}' successfully completed: {arg})crr)comprrr r!component_successsz_run..component_successcs.jd|t|djdt|ddS)NzComponent '{c}' error: {msg})rrzComponent error: {tb}r)rrrrr)rrrr r!component_failuresz_run..component_failurecs,t|j}t|t|t||Sr)rrrrr)rr)rrrr r!component_startsz_run..component_startF)consume_exceptionscsd|dS)Nz&All components ended; stopping reactorrr) done_callbackrrr r!all_dones z_run..all_done) rrrr?rrr make_loggerrgatherr) r componentsrrrdlrrdone_drr )rrrrrr!_runs4        rr)" __future__rrr/rd functoolsrr autobahn.utilrautobahn.websocket.utilrr>autobahn.rawsocket.utilrDautobahn.wamp.typesrrrautobahn.wamp.exceptionr r autobahn.wamp.authr r autobahn.wamp.serializerr __all__r"rTobjectrFrrr r r r!s2        9[ %