nova的 microversion 实现

之前想写ｎｏｖａ的ｐｏｌｉｃｙ的实现，　但是发现网上，有人写的很不错了。

但是个人认为存在一些问题。　ref: 　http://www.cnblogs.com/shaohef/p/4527436.html

希望　microversion　还没有人写。

microversion实现

microversion实现的机制，就是在ｈｔｔｐ的头部增加一个请求的小版本，　ｎｏｖａ的ｓｅｒｖｅ大家　搜索　ｎｅｗ，　ｔｙｐｅ，　ｍｅｔａｃｌａｓｓ，　都会介绍。ｒ　根据这个小版本号，做相应的ａｃｔｉｏｎ。
实在是没有什么好介绍了。

这个我想像的ｍｉｃｒｏｖｅｒｓｉｏｎ有些ｇａｐ。 我开始以为是在ｕｒｌ中指定版本号，而不是在ｈｅａｄ中。　


microversion的值得研究的是如下这段代码。

class subContorller(wsgi.Controller)
    @wsgi.Controller.api_version("2.1", "2.3")
    def my_api_method(self, req, id):
        .... method_1 ...

    @wsgi.Controller.api_version("2.4") #noqa
    def my_api_method(self, req, id):
        .... method_2 ...

来自：　http://docs.openstack.org/developer/nova/devref/api_microversions.html#changing-a-method-s-behaviour

这段代码，有点诡异，在一个类中实现了两个同名的属性，后面的那个将覆盖前面的那个。

如果是熟悉ｐｙｔｈｏｎ的类和实例创建过程的，肯定认为很ｅａｓｙ。

瞬间就能想到实现原理，　比如说　不正直的绅士，　他直接做过类似的代码。　

其实在ＩＢＭ的ｋｖｍ的ｔｅａｍ，做发行版本的同事，也能想到怎么实现的。

因为我之前给他们介绍个ｐｙｔｈｏｎ的类和实例创建过程，其实ｇｏｏｇｌｅ／ｓｏ　一大堆。

我的介绍肯定不如他们自己学习效果好，我纯粹就是显摆而已。

我们要在ｍａｇｎｕｍ上，实现ｍｉｃｒｏｖｅｒｓｉｏｎ，所以我我按照自己的思路尝试自己实现一个。

首先，在同一个类中，定义多个同名函数，最后一个函数，　会覆盖其他的。

怎么办呢？

跟大家一样，第一想法是重载　__getattribute__　的类。

做法是重名的函数，想办法重新命名。　然后在__getattribute__中，知道期望的函数。

 发现，没有找到一个合适的位置，来ｈａｃｋ重名的函数。

下面代码中的第５行，是我找到的唯一可能问位置，但是，这个代码只有类的实例才会调用。　　～～～～

def operater(min, max):
    def operate(fn):
        def wraper(self, *args, **kv):
            if fn.func_name not in self.funs:
                self.funs[fn.func_name] = [(fn.func_name+"_"+min+"_"+max, wraper)]
            else:
                self.funs[fn.func_name].append((fn.func_name+"_"+min+"_"+max, wraper))
            print getattr(self, fn.func_name)
            print "begin decorate"
            return fn(self, *args, **kv)
            print "end decorate"
            type(self)
        return wraper
    return operate


class Controller(object):
    funs = {}
    def __init__(self):
        print self

    def __getattribute__(self, name):
        if name in self.funs:
            all_funs = self.funs[name]
            fun = self.funs[0][1]
            return fun
        return object.__getattribute__(self, name)

    @operater("1.0", "1.5") # noqa
    def fun1(self):
        print self
        print "inline fun1"

    @operater("1.0", "1.6") # noqa
    def fun1(self):
        print self
        print "inline fun2"

if __name__ == '__main__':
    print "start main"
    import pdb
    pdb.set_trace()
    i = Controller()    
　print dir(i)
    i.fun1()

大家可以尝试写一下，　不知道有没有实现的可能，　过程中可能会有不少坑。

实在是给大家做过太多的培训了，类合实例的创建过程，还是比较清楚的。

休息了一下，立马清醒。　发现自己比较傻逼，这个位置是创建类的时候。

大家　搜索　ｎｅｗ，　ｔｙｐｅ，　ｍｅｔａｃｌａｓｓ，　都会介绍。

查看ｎｏｖａ的代码，果真如此。　

ｎｏｖａ采用了six.add_metaclass　来构造类。把ｎｏｖａ的相关代码摘取如下，　很简单，都不需要解释。

import six

class VersionedMethod(object):

    def __init__(self, name, start_version, end_version, func):
        self.name = name
        self.start_version = start_version
        self.end_version = end_version
        self.func = func

    def __str__(self):
        return ("Version Method %s: min: %s, max: %s"
                % (self.name, self.start_version, self.end_version))


VER_METHOD_ATTR = 'versioned_methods'
obj_min_ver = "2.0"
obj_max_ver = "2.3"


class ControllerMetaclass(type):
    def __new__(mcs, name, bases, cls_dict):
        versioned_methods = None
        # start with wsgi actions from base classes
        for base in bases:
            # actions.update(getattr(base, 'wsgi_actions', {}))

            if base.__name__ == "Controller":
                # NOTE(cyeoh): This resets the VER_METHOD_ATTR attribute
                # between API controller class creations. This allows us
                # to use a class decorator on the API methods that doesn't
                # require naming explicitly what method is being versioned as
                # it can be implicit based on the method decorated. It is a bit
                # ugly.
                print "+" * 80
                print base.__dict__
                if VER_METHOD_ATTR in base.__dict__:
                    versioned_methods = getattr(base, VER_METHOD_ATTR)
                    delattr(base, VER_METHOD_ATTR)

        for key, value in cls_dict.items():
            if not callable(value):
                continue
        if versioned_methods:
            cls_dict[VER_METHOD_ATTR] = versioned_methods

        return super(ControllerMetaclass, mcs).__new__(mcs, name, bases,
                                                       cls_dict)


class abc(object):
    pass

@six.add_metaclass(ControllerMetaclass)
class Controller(abc):


    def __getattribute__(self, key): 
        def version_select(*args, **kwargs):
            # The first arg to all versioned methods is always the request
            # object. The version for the request is attached to the
            # request object
            func_list = self.versioned_methods[key]
            print func_list
            for func in func_list:
                print "^" * 80
                return func.func(self, *args, **kwargs)
                # print func.func_name, func.obj_min_ver, func.obj_max_ver
            return func.func(self, *args, **kwargs)
            # No version match
            raise exception.VersionNotFoundForAPIMethod(version=ver)

        try:
            # super(LockerDecorator,  self).__getattribute__(self, name)
            version_meth_dict = abc.__getattribute__(self, VER_METHOD_ATTR)
        except AttributeError:
            # No versioning on this class
            return abc.__getattribute__(self, key)

        if version_meth_dict and 
          key in abc.__getattribute__(self, VER_METHOD_ATTR):
            return version_select

        return abc.__getattribute__(self, key)
    

    # NOTE(cyeoh): This decorator MUST appear first (the outermost
    # decorator) on an API method for it to work correctly
    @classmethod
    def api_version(cls, min_ver, max_ver=None):
        def decorator(f):
    
            # Add to list of versioned methods registered
            func_name = f.__name__
            new_func = VersionedMethod(func_name, obj_min_ver, obj_max_ver, f)
    
            func_dict = getattr(cls, VER_METHOD_ATTR, {})
            if not func_dict:
                setattr(cls, VER_METHOD_ATTR, func_dict)
 
            # global func_list 
            func_list = func_dict.get(func_name, [])
            if not func_list:
                func_dict[func_name] = func_list
            func_list.append(new_func)
            func_list.sort(key=lambda f: f.start_version, reverse=True)
    
            return f
    
        return decorator


class MyController(Controller):
    @Controller.api_version("2.2") 
    def create(self, req, body): 
        print "create v2.2"
 
    @Controller.api_version("2.1", "2.1")  # noqa 
    def create(self, req, body): 
        print "create v2.1"

    def delete(self, req, body): 
        print "delete no version"

if __name__ == "__main__":
    i = MyController()
    i.create("1", "2")
    i.delete("1", "2")
    print "exit"