Python Monkey patch猴子補丁

monkey patch (猴子補丁)
   用來在運行時動態修改已有的代碼，而不需要修改原始代碼。

簡單的monkey patch 實現：
[python] 
#coding=utf-8 
def originalFunc(): 
    print 'this is original function!' 
     
def modifiedFunc(): 
    modifiedFunc=1 
    print 'this is modified function!' 
     
def main(): 
    originalFunc() 
     
if __name__=='__main__': 
    originalFunc=modifiedFunc 
    main() 

 

python中所有的東西都是object，包括基本類型。查看一個object的所有屬性的方法是：dir(obj)
函數在python中可以像使用變量一樣對它進行賦值等操作。
查看屬性的方法：
 
print locals() 
print globals() 

 

當我們import一個module時，python會做以下幾件事情

  •導入一個module
  •將module對象加入到sys.modules，后續對該module的導入將直接從該dict中獲得
  •將module對象加入到globals dict中

當我們引用一個模塊時，將會從globals中查找。這里如果要替換掉一個標准模塊，我們得做以下兩件事情

    1.將我們自己的module加入到sys.modules中，替換掉原有的模塊。如果被替換模塊還沒加載，那么我們得先對其進行加載，否則第一次加載時，還會加載標准模塊。（這里有一個import hook可以用，不過這需要我們自己實現該hook，可能也可以使用該方法hook module import）
    2.如果被替換模塊引用了其他模塊，那么我們也需要進行替換，但是這里我們可以修改globals dict，將我們的module加入到globals以hook這些被引用的模塊。

一篇文章：

What is Monkey Patch

 

Monkey patch就是在運行時對已有的代碼進行修改，達到hot patch的目的。Eventlet中大量使用了該技巧，以替換標准庫中的組件，比如socket。首先來看一下最簡單的monkey patch的實現。

class Foo(object):
    def bar(self):
        print 'Foo.bar'

def bar(self):
    print 'Modified bar'

Foo().bar()

Foo.bar = bar

Foo().bar()

由於Python中的名字空間是開放，通過dict來實現，所以很容易就可以達到patch的目的。

Python namespace

Python有幾個namespace，分別是

• locals
• globals
• builtin

其中定義在函數內聲明的變量屬於locals，而模塊內定義的函數屬於globals。

Python module Import & Name Lookup

當我們import一個module時，python會做以下幾件事情

• 導入一個module
• 將module對象加入到sys.modules，后續對該module的導入將直接從該dict中獲得
• 將module對象加入到globals dict中

當我們引用一個模塊時，將會從globals中查找。這里如果要替換掉一個標准模塊，我們得做以下兩件事情

1. 將我們自己的module加入到sys.modules中，替換掉原有的模塊。如果被替換模塊還沒加載，那么我們得先對其進行加載，否則第一次加載時，還會加載標准模塊。（這里有一個import hook可以用，不過這需要我們自己實現該hook，可能也可以使用該方法hook module import）
2. 如果被替換模塊引用了其他模塊，那么我們也需要進行替換，但是這里我們可以修改globals dict，將我們的module加入到globals以hook這些被引用的模塊。

Eventlet Patcher Implementation

現在我們先來看一下eventlet中的Patcher的調用代碼吧，這段代碼對標准的ftplib做monkey patch，將eventlet的GreenSocket替換標准的socket。

from eventlet import patcher

# *NOTE: there might be some funny business with the "SOCKS" module
# if it even still exists
from eventlet.green import socket

patcher.inject('ftplib', globals(), ('socket', socket))

del patcher

inject函數會將eventlet的socket模塊注入標准的ftplib中，globals dict被傳入以做適當的修改。

讓我們接着來看一下inject的實現。

__exclude = set(('__builtins__', '__file__', '__name__'))

def inject(module_name, new_globals, *additional_modules):
    """Base 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.

    *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.
    """
    if not additional_modules:
        # supply some defaults
        additional_modules = (
            _green_os_modules() +
            _green_select_modules() +
            _green_socket_modules() +
            _green_thread_modules() +
            _green_time_modules())

    ## Put the specified modules in sys.modules for the duration of the import
    saved = {}
    for name, mod in additional_modules:
        saved[name] = sys.modules.get(name, None)
        sys.modules[name] = mod

    ## Remove the old module from sys.modules and reimport it while
    ## the specified modules are in place
    old_module = sys.modules.pop(module_name, None)
    try:
        module = __import__(module_name, {}, {}, module_name.split('.')[:-1])

        if new_globals is not None:
            ## Update the given globals dictionary with everything from this new module
            for name in dir(module):
                if name not in __exclude:
                    new_globals[name] = getattr(module, name)

        ## Keep a reference to the new module to prevent it from dying
        sys.modules['__patched_module_' + module_name] = module
    finally:
        ## Put the original module back
        if old_module is not None:
            sys.modules[module_name] = old_module
        elif module_name in sys.modules:
            del sys.modules[module_name]

        ## Put all the saved modules back
        for name, mod in additional_modules:
            if saved[name] is not None:
                sys.modules[name] = saved[name]
            else:
                del sys.modules[name]

    return module

注釋比較清楚的解釋了代碼的意圖。代碼還是比較容易理解的。這里有一個函數__import__，這個函數提供一個模塊名（字符串），來加載一個模塊。而我們import或者reload時提供的名字是對象。

if new_globals is not None:
    ## Update the given globals dictionary with everything from this new module
    for name in dir(module):
        if name not in __exclude:
            new_globals[name] = getattr(module, name)

這段代碼的作用是將標准的ftplib中的對象加入到eventlet的ftplib模塊中。因為我們在eventlet.ftplib中調用了inject，傳入了globals，而inject中我們手動__import__了這個module，只得到了一個模塊對象，所以模塊中的對象不會被加入到globals中，需要手動添加。

這里為什么不用from ftplib import *的緣故，應該是因為這樣無法做到完全替換ftplib的目的。因為from … import *會根據__init__.py中的__all__列表來導入public symbol，而這樣對於下划線開頭的private symbol將不會導入，無法做到完全patch。

轉自：http://blog.csdn.net/seizef/article/details/5732657