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("", "")
     i.delete("", "")
     print "exit"