MdSrSSKJr SSKrSSKrSSKrSSKJr SSKJ r SSjr SSjr "SS \ 5r "S S \ 5r"S S \ 5rSr\"5rg)a+Container of APIProxy stubs for more convenient unittesting. Classes/variables/functions defined here: APIProxyStubMap: container of APIProxy stubs. apiproxy: global instance of an APIProxyStubMap. MakeSyncCall: APIProxy entry point. UserRPC: User-visible class wrapping asynchronous RPCs. )absolute_importN) apiproxy_rpc)apiproxy_errorscUc[nURU5nU(d SU-5e[US5(d SU-5eUR5$)aCreates a RPC instance for the given service. The instance is suitable for talking to remote services. Each RPC instance can be used only once, and should not be reused. Args: service: string representing which service to call. stubmap: optional APIProxyStubMap instance, for dependency injection. Returns: the rpc object. Raises: AssertionError or RuntimeError if the stub for service doesn't supply a CreateRPC method. #No api proxy found for service "%s" CreateRPCz1The service "%s" doesn't have a CreateRPC method.)apiproxyGetStubhasattrr)servicestubmapstubs 5lib/googlecloudsdk/appengine/api/apiproxy_stub_map.pyrr)sf" _G  !$ >4w>> { # #I(=@G'HI #  c8Uc[nURXX#5$)a_The APIProxy entry point for a synchronous API call. Args: service: string representing which service to call call: string representing which function to call request: protocol buffer for the request response: protocol buffer for the response stubmap: optional APIProxyStubMap instance, for dependency injection. Returns: Response protocol buffer or None. Some implementations may return a response protocol buffer instead of modifying 'response'. Caller must use returned value in such cases. If 'response' is modified then returns None. Raises: apiproxy_errors.Error or a subclass. )r MakeSyncCall)r callrequestresponser s rrrCs!& _G   gW ??rcR\rSrSrSrSrSrS SjrS SjrS Sjr S r S S jr S r g) ListOfHooks[aAn ordered collection of hooks for a particular API call. A hook is a function that has exactly the same signature as a service stub. It will be called before or after an api hook is executed, depending on whether this list is for precall of postcall hooks. Hooks can be used for debugging purposes (check certain pre- or postconditions on api calls) or to apply patches to protocol buffers before/after a call gets submitted. c0/Ul[5Ulg)z Constructor.N_ListOfHooks__contentset_ListOfHooks__unique_keysselfs r__init__ListOfHooks.__init__fsDNDrc6URR5$)z1Returns the amount of elements in the collection.)r__len__rs rr#ListOfHooks.__len__os >> ! ! ##rNcJU[R"U54nXPR;ag[[R"U5S5n[R "U5(aUS-nUR RXX4U45 URRU5 g)aAppends a hook at a certain position in the list. Args: index: the index of where to insert the function key: a unique key (within the module) for this particular function. If something from the same module with the same key is already registered, nothing will be added. function: the hook to be added. service: optional argument that restricts the hook to a particular api Returns: True if the collection was modified. FrT) inspect getmodulerlen getargspecismethodrinsertadd)rindexkeyfunctionr unique_keynum_argss r__InsertListOfHooks.__Insertssw((23J''' 7%%h/23H""!mhNN%x(!CD:& rc:UR[U5XU5$)azAppends a hook at the end of the list. Args: key: a unique key (within the module) for this particular function. If something from the same module with the same key is already registered, nothing will be added. function: the hook to be added. service: optional argument that restricts the hook to a particular api Returns: True if the collection was modified. )_ListOfHooks__Insertr)rr/r0r s rAppendListOfHooks.Appends ==TC7 ;;rc(URSXU5$)aInserts a hook at the beginning of the list. Args: key: a unique key (within the module) for this particular function. If something from the same module with the same key is already registered, nothing will be added. function: the hook to be added. service: optional argument that restricts the hook to a particular api Returns: True if the collection was modified. r)r6r7s rPushListOfHooks.Pushs ==C7 33rc0/Ul[5Ulg)z8Removes all hooks from the list (useful for unit tests).Nrrs rClearListOfHooks.ClearsDNDrc URHBupxpU bX:XdMU S:Xa U"XX4XV5 M"UbM'U S:Xa U"XX4U5 M9U"XX45 MD g)aOInvokes all hooks in this collection. NOTE: For backwards compatibility, if error is not None, hooks with 4 or 5 arguments are *not* called. This situation (error=None) only occurs when the RPC request raised an exception; in the past no hooks would be called at all in that case. Args: service: string representing which service to call call: string representing which function to call request: protocol buffer for the request response: protocol buffer for the response rpc: optional RPC used to make this call error: optional Exception instance to be passed as 6th argument N)r) rr rrrrpcerrorr/r0srvr2s rCallListOfHooks.Calls[ )-$s  q= 7'S @    ] 7'S 9 7' 4)7r) __content __unique_keysNNN) __name__ __module__ __qualname____firstlineno____doc__r r#r6r8r;r>rF__static_attributes__rrrr[s*$0 < 4 5rrcR\rSrSrSrSSjrSrSrSrSr S r S r S r S r S rg)APIProxyStubMapaContainer of APIProxy stubs for more convenient unittesting. Stubs may be either trivial implementations of APIProxy services (e.g. DatastoreFileStub, UserServiceStub) or "real" implementations. For unittests, we may want to mix and match real and trivial implementations of services in order to better focus testing on individual service implementations. To achieve this, we allow the client to attach stubs to service names, as well as define a default stub to be used if no specific matching stub is identified. NcZ0UlXl[5Ul[5Ulg)z|Constructor. Args: default_stub: optional stub 'default_stub' will be used whenever no specific matching stub is found. N)_APIProxyStubMap__stub_map_APIProxyStubMap__default_stubr_APIProxyStubMap__precall_hooks _APIProxyStubMap__postcall_hooks)r default_stubs rr APIProxyStubMap.__init__s%DO&&=D'MDrcUR$z(Gets a collection for all precall hooks.)rYrs rGetPreCallHooksAPIProxyStubMap.GetPreCallHookss   rcUR$r^)rZrs rGetPostCallHooks APIProxyStubMap.GetPostCallHookss   rcRX RU'US:XaURSU5 gg)zReplace the existing stub for the specified service with a new one. NOTE: This is a risky operation; external callers should use this with caution. Args: service: string stub: stub datastore datastore_v3N)rW RegisterStubrr rs r ReplaceStubAPIProxyStubMap.ReplaceStubs/ $OOG + -rcdXR;d[U55eURX5 g)z\Register the provided stub for the specified service. Args: service: string stub: stub N)rWreprrirhs rrgAPIProxyStubMap.RegisterStubs+ // )84=8 )W#rcLURRXR5$)zRetrieve the stub registered for the specified service. Args: service: string Returns: stub Returns the stub registered for 'service', and returns the default stub if no such stub is found. )rWgetrX)rr s rr APIProxyStubMap.GetStubs ??  w(;(; <>:N0rcUR$)zReturn the service name.)rrs rr UserRPC.services >>rcUR$)zReturn the method name.)_UserRPC__methodrs rmethodUserRPC.methods ==rc.URR$)z8Return the deadline, if set explicitly (otherwise None).)rrrs rrUserRPC.deadline ::  rc.URR$)z*Return the request protocol buffer object.)rrrs rrUserRPC.requests ::  rc.URR$)z+Return the response protocol buffer object.)rrrs rrUserRPC.responserrc.URR$)zeReturn the RPC state. Possible values are attributes of apiproxy_rpc.RPC: IDLE, RUNNING, FINISHING. )rstaters rr UserRPC.states ::  rcUR$)z$Return the get-result hook function.)_UserRPC__get_result_hookrs rget_result_hookUserRPC.get_result_hooks  ! !!rcUR$)z+Return the user data for the hook function.)_UserRPC__user_datars r user_dataUserRPC.user_datas   rcURR[RR:Xd[ UR55eXlX@lXPlURR5RURXX0R5 URRURXU5 g)a?Initiate a call. Args: method: The method name. request: The request protocol buffer. response: The response protocol buffer. get_result_hook: Optional get-result hook function. If not None, this must be a function with exactly one argument, the RPC object (self). Its return value is returned from get_result(). user_data: Optional additional arbitrary data for the get-result hook function. This can be accessed as rpc.user_data. The type of this value is up to the service module. This function may only be called once per RPC object. It sends the request to the remote server, but does not wait for a response. This allows concurrent execution of the remote call and further local processing (e.g., making additional remote calls). Before the call is initiated, the precall hooks are called. N)rrrRPCIDLErlrrrrr_rFrrv)rrrrrrs r make_callUserRPC.make_calls. ::  |//44 4Fd4::6FF 4M, NN""$)) ::? JJBrcURR[RR:wd[ UR55eURR[RR :XaURR5 URR[RR:Xd[ UR55eUR5 g)aWait for the call to complete, and call callback if needed. This and wait_any()/wait_all() are the only time callback functions may be called. (However, note that check_success() and get_result() call wait().) Waiting for one RPC will not cause callbacks for other RPCs to be called. Callback functions may call check_success() and get_result(). Callbacks are called without arguments; if a callback needs access to the RPC object a Python nested function (a.k.a. closure) or a bound may be used. To facilitate this, the callback may be assigned after the RPC object is created (but before make_call() is called). Note: don't confuse callbacks with get-result hooks or precall and postcall hooks. N) rrrrrrlRUNNINGrw FINISHING_UserRPC__call_user_callbackrs rwait UserRPC.wait s& ::  |//44 4Fd4::6FF 4 zz<++333 jjoo ::  |//99 9K4 ;KK 9rcrUR(a&SUlURbUR5 ggg)z+Call the high-level callback, if requested.FN)rrrs r__call_user_callbackUserRPC.__call_user_callback&s0 %%',d$  "  #&rc `UR5 URR5 UR(dgSUlURR 5R URURURURUR5 gg![a~nUR(dgSUlURR 5R URURURURURU5 eSnAff=f)aCCheck for success of the RPC, possibly raising an exception. This function should be called at least once per RPC. If wait() hasn't been called yet, it is called first. If the RPC caused an exceptional condition, an exception will be raised here. The first time check_success() is called, the postcall hooks are called. TN) rrrx_UserRPC__postcall_hooks_calledrrbrFrrrrry)rrzs r check_successUserRPC.check_success-s IIK; jj ) )'+$ '')..t~~t}}/3||T]]/3zz ;*   ) )'+$ '')..t~~t}}/3||T]]/3zz3 @  sB%% D-/A9D((D-c`URcUR5 gURU5$)a=Get the result of the RPC, or possibly raise an exception. This implies a call to check_success(). If a get-result hook was passed to make_call(), that hook is responsible for calling check_success(), and the return value of the hook is returned. Otherwise, check_success() is called directly and None is returned. N)rrrs r get_resultUserRPC.get_resultKs0 %    # #D ))rcPSnUHn[X 5(d[U55eURRnU[R R :XaUR5 US4s $U[R R:waM[U55e SU4$)avCheck the list of RPCs for one that is finished, or one that is running. Args: rpcs: Iterable collection of UserRPC instances. Returns: A pair (finished, running), as follows: (UserRPC, None) indicating the first RPC found that is finished; (None, UserRPC) indicating the first RPC found that is running; (None, None) indicating no RPCs are finished or running. N) isinstancerlrrrrrrr)clsrpcsrCrs r __check_oneUserRPC.__check_one^s C  ! !,49, !iiooe ,"",, ,   "Dy l&&++ +6T#Y6 +  9rc[U5ULdS5eURU5up#UbU$UcgSURlURR 5 SURlURU5up#U$![ Ra,nSURl SURl SnANaSnAff=f!SURlf=f)aWait until an RPC is finished. Args: rpcs: Iterable collection of UserRPC instances. Returns: A UserRPC instance, indicating the first RPC among the given RPCs that finished; or None, indicating that either an RPC not among the given RPCs finished in the mean time, or the iterable is empty. NOTES: (1) Repeatedly calling wait_any() with the same arguments will not make progress; it will keep returning the same RPC (the one that finished first). The callback, however, will only be called the first time the RPC finishes (which may be here or in the wait() method). (2) It may return before any of the given RPCs finishes, if another pending RPC exists that is not included in the rpcs argument. In this case the other RPC's callback will *not* be called. The motivation for this feature is that wait_any() may be used as a low-level building block for a variety of high-level constructs, some of which prefer to block for the minimal amount of time without busy-waiting. z*rpcs must be a collection, not an iteratorNTF) iter_UserRPC__check_onerrrrwrrrC _exception _traceback)rrfinishedrunningrzs rwait_anyUserRPC.wait_anyus: :T !O#OO !-H o  -'+ckk$ " (-ckk$-H O - -" "!"(-ckk$s/CBC"C;CCCCc[U5nU(a/URU5nUbURU5 U(aM.gg)zWait until all given RPCs are finished. This is a thin wrapper around wait_any() that loops until all given RPCs have finished. Args: rpcs: Iterable collection of UserRPC instances. Returns: None. N)rrremove)rrrs rwait_allUserRPC.wait_alls7 t9D d#h   H $r) __get_result_hook__method__must_call_user_callback__postcall_hooks_called__rpc __service __stubmap __user_datar)NNNrK)#rLrMrNrOrPrrrrr threadinglocalrrr rpropertyr rrrrrrrrrrrr classmethodrrrrQrRrrrrWsG!F(+!#  I'6@?(             " "   15!CF 6;<*&,11frrc[S[5[5S/5n[UR5$![ [ 4a [5s$f=f)Nz googlecloudsdk.appengine.runtimer ) __import__globalslocalsrTr AttributeError ImportError)runtimes rGetDefaultAPIProxyrsQ  ;WY$'G 7++ ,, + &  s36AArJ)rP __future__rr'sysrgooglecloudsdk.appengine.apir googlecloudsdk.appengine.runtimerrrobjectrrTrrr rRrrrse ' 5<4@0n5&n5bH+fH+VcfcN   r