3 Z_]C @s>ddlZddlZddlZddlZddddgZed/ZGd d d eZd dZ d dZ d dZ ddZ ddZ iZddZddZddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zgdfd+d,Zed-kr:ejjdee ejd$Z!e"e!j#ejdd.Z$e%e$WdQRXdS)0Ninjectimport_patched monkey_patchis_monkey_patched __builtins____file____name__c@s,eZdZdZffddZddZddZdS) SysModulesSaverzClass that captures some subset of the current state of sys.modules. Pass in an iterator of module names to the constructor.cCsi|_tj|j|dS)N)_savedimp acquire_locksave)self module_namesr4/tmp/pip-build-yz_zf6az/eventlet/eventlet/patcher.py__init__szSysModulesSaver.__init__cGs&x |D]}tjj|d|j|<qWdS)z&Saves the named modules to the object.N)sysmodulesgetr )rrmodnamerrrr s zSysModulesSaver.savecCsdzTxNtj|jD]>\}}|dk r,|tj|<qy tj|=Wqtk rLYqXqWWdtjXdS)zRRestores the modules that the saver knows about into sys.modules. N)six iteritemsr rrKeyErrorr release_lock)rrmodrrrrestores  zSysModulesSaver.restoreN)r __module__ __qualname____doc__rr rrrrrr s r c Gs$d|}|tjkrtj|S|s>ttttt}tdd|D}|j|x|D]\}}|tj|<q`Wtjj |dx2t tjj D] }|j |drtjj |dqWz\t |ii|jddd}|dk rx&t|D]}|tkrt||||<qW|tj|<Wd|jX|S)aBase method for "injecting" greened modules into an imported module. It imports the module specified in *module_name*, arranging things so that the already-imported modules in *additional_modules* are used when *module_name* makes its imports. **Note:** This function does not create or change any sys.modules item, so if your greened module use code like 'sys.modules["your_module_name"]', you need to update sys.modules by yourself. *new_globals* is either None or a globals dictionary that gets populated with the contents of the *module_name* module. This is useful when creating a "green" version of some other module. *additional_modules* should be a collection of two-element tuples, of the form (, ). If it's not specified, a default selection of name/module pairs is used, which should cover all use cases but may be slower because there are inevitably redundant or unnecessary imports. Z__patched_module_cSsg|] \}}|qSrr).0namemrrr Rszinject..N.)rr_green_os_modules_green_select_modules_green_socket_modules_green_thread_modules_green_time_modulesr r poplistkeys startswith __import__splitdir __excludegetattrr) module_nameZ new_globalsadditional_modulesZ patched_namesaverr!rZimported_module_namemodulerrrr-s.     cOst|df|t|jS)zImports a module in a way that ensures that the module uses "green" versions of the standard library modules, so that everything works nonblockingly. The only required argument is the name of the module to be imported. N)rtupleitems)r5r6Zkw_additional_modulesrrrrtscs4s"tttttfdd}|S)a Decorator that returns a version of the function that patches some modules for the duration of the function call. This is deeply gross and should only be used for functions that import network libraries within their function bodies that there is no way of getting around.c sFt}x$D]\}}|j||tj|<q Wz ||S|jXdS)N)r r rrr)argskwr7r!r)r6funcrrpatcheds  zpatch_function..patched)r'r(r)r*r+)r=r6r>r)r6r=rpatch_functions  r?csfdd}|S)auKind of the contrapositive of patch_function: decorates a function such that when it's called, sys.modules is populated only with the unpatched versions of the specified modules. Unlike patch_function, only the names of the modules need be supplied, and there are no defaults. This is a gross hack; tell your kids not to import inside function bodies!c s>t}xD]}t|tj|<qWz ||S|jXdS)N)r originalrrr)r;r<r7r!)r=rrrr>s   z)_original_patch_function..patchedr)r=rr>r)r=rr_original_patch_functionsrAc Csd|}|tjkrtjj|St|f}tjj|dtjrFddd}tjrVddd}||kr~||}|j|t |tj|<zPt |ii|j ddd }|dkrt |d  rt |jjd|j_|tj|<Wd|jXtj|S)zd This returns an unpatched version of a module; this is useful for Eventlet itself (i.e. tpool).Z__original_module_Nthread threading)rCQueue_thread)rCqueuer$r%rDrF _threadingr&)rDrF)rrrr r,rPY2PY3r r@r0r1hasattrrArDrr)r original_namer7deps dependencyZreal_modrrrr@s,        r@cKstjjtd}d |ko d|k s(ty|jd }Wntk rJYn X||d<|jd d }x&tj|D]}||krlt d |qlW|d krd|j k}x@|D]8}|dkr|j |d|dkr|j |d|j ||qW|drt j d rtg}xldtfdtfdtfdtfdtfdtfdtfd tfgD]4\}}||r6t j | r6||7}dt |<q6W|drt j d ry ddlm} | jdt d<Wntk rYnXtjzx|D]\}} tjj |} | d krt|} x2| j D](} t!| | d } | d k rt"| | | qWt!| dg}x$|D]} t#| | r:t$| | q:WqWWd tj%Xtj&dkrdd l'}t(d}||j)_*dd l+}|j,|_-d S)aGlobally patches certain system modules to be greenthread-friendly. The keyword arguments afford some control over which modules are patched. If no keyword arguments are supplied, all possible modules are patched. If keywords are set to True, only the specified modules are patched. E.g., ``monkey_patch(socket=True, select=True)`` patches only the select and socket modules. Most arguments patch the single module of the same name (os, time, select). The exceptions are socket, which also patches the ssl module if present; and thread, which patches thread, threading, and Queue. It's safe to call monkey_patch multiple times. osselectsocketrBtimepsycopgMySQLdbbuiltins subprocess __builtin__allNz4monkey_patch() got an unexpected keyword argument %rTFr)psycopg2_patcherZ __deleted__rE) rNrOrPrBrQrRrSrTrU)rYrY).eventletZhubsZget_hubsetAssertionErrorr,rriterkeys TypeErrorvalues setdefaultalready_patchedr_green_existing_locksr'r(r)r*r+_green_MySQLdb_green_builtins_green_subprocess_modulesZeventlet.supportrXZmake_psycopg_green ImportErrorr r rrr0Z __patched__r4setattrrJdelattrr version_infoZimportlib._bootstrapr@ _bootstraprErC_PyRLockRLock)onZ accepted_argsbZ default_onkrZmodules_to_patchr!Zmodules_functionrXrZorig_mod attr_nameZ patched_attrZdeleted importlibrBrCrrrrs                    cCs|tkpt|ddtkS)a[Returns True if the given module is monkeypatched currently, False if not. *module* can be either the module itself or its name. Based entirely off the name of the module, so if you import a module some other way than with the import keyword (including import_patched), this might not be correct about that particular module.rN)rar4)r8rrrrLscCsddl}ddl}ddl}t|j}t|j}tjddkrJt|j}|j j j }xb|j D]V}t ||r`tjddkrt |j|rt||q`tjddkr`t || r`t|q`WdS)aMake locks created before monkey-patching safe. RLocks rely on a Lock and on Python 2, if an unpatched Lock blocks, it blocks the native thread. We need to replace these with green Locks. This was originally noticed in the stdlib logging module.rNrY)gcrCZeventlet.green.threadtypeLockrlrrirkgreenrB get_identZ get_objects isinstance _RLock__block_fix_py2_rlock_fix_py3_rlock)rsrCrZZ lock_typeZ rlock_typeZ pyrlock_typetidobjrrrrbXs         rbcCs:ddl}|j}|jjj}||_|jr6|j||_dS)Nr)Zeventlet.green.threadingryrvrCrulockedacquireZ _RLock__owner)Zrlockr|rZoldnewrrrrzss rzcCsddl}ddl}|j}x|jr4|j|jqW|jrF|j|jx^|j|D]P}y t|}Wnt k r~YqZXx(|j D]\}}||krt |||qWqZWdS)Nr) rsrCrk _is_ownedreleaserZcollectZ get_referrersvarsr^r:rg)rrsrCrrefZref_varsrovrrrr{}s"   r{cCsddlm}d|fgS)Nr)rNrN)eventlet.greenrN)rNrrrr's r'cCs>ddlm}d|fg}tjdkr:ddlm}|jd|f|S) Nr)rOrOrY) selectorsr)rYr)rrOrrirappend)rOrrrrrr(s     r(c CsHddlm}yddlm}d|fd|fgStk rBd|fgSXdS)Nr)rP)sslrPr)rrPrrf)rPrrrrr)s   r)cCsddlm}d|fgS)Nr)rUrU)rrU)rUrrrres recCs`ddlm}ddlm}ddlm}tjr@d|fd|fd|fgStjr\d|fd |fd|fgSdS) Nr)rD)rB)rCrDrBrCrFrE)rrDrBrCrrHrI)rDrBrCrrrr*s   r*cCsddlm}d|fgS)Nr)rQrQ)rrQ)rQrrrr+s r+c Cs0yddlm}d|fgStk r*gSXdS)Nr)rSrS)rrSrf)rSrrrrcs   rcc Cs:y ddlm}tjrdnd|fgStk r4gSXdS)Nr)builtinrVrT)rrrrHrf)rrrrrds  rdcs0|dkrj}|jtfdd|DdS)aCopy properties from *source* (assumed to be a module) to *destination* (assumed to be a dict). *ignore* lists properties that should not be thusly copied. *srckeys* is a list of keys to copy, if the source's __all__ is untrustworthy. Ncs,g|]$}|jdp|ks|t|fqS)__)r/r4)r r!)ignoresourcerrr#sz$slurp_properties..)__all__updatedict)rZ destinationrZsrckeysr)rrrslurp_propertiess  r__main__exec)rrr)&r rrZrrr[r3objectr rrr?rAr@rarrrbrzr{r'r(r)rer*r+rcrdrrargvr,openfcompilereadcoderrrrrs@  G *q