Why?

Web产品一旦上线,重启应用就会造成业务中断,对于实时性要求很高或者业务关联紧密的应用,重启程序是非常重的代价。

将代码对象序列化之后保存到存储内(比如redis, 关系数据库),在运行业务的时候通过制定的路由机制加载这部分业务。

对于线上应用,使用这种方式可以更加方便的部署新业务。

对于性能要求不是很高的场合,可以牺牲一些性能做代码动态装载。

更好的设计还是做到重启应用不影响业务,将业务状态同应用程序剥离。但这不是本篇文章讨论的范围。

下面说说具体一点的。

主要可以在以下场景做代码动态生成和加载。

1.使用配置文件管理表单和页面的生成以及表单校验,这样你的代码只需要写一份,在需要的时候根据配置文件动态生成和校验你的表单,在配置文件内存储表单的字段类型和验证需即可。(实现参考wtforms即可,只不过把配置文件变为可序列化的其他格式,比如json)

Q:代码注入问题

A:必须校验配置文件,并对配置文件的可执行部分进行转义和过滤,根据配置文件生成代码的时候必须注意%s这种会发生代码注入的部分。

2.将Python脚本序列化保存,在需要的时候编译,然后载入到内存. 代码存储在数据库或者文件系统,为了提高效率可以将编译好的code object放置到缓存,每次数据库更新的时候主动刷新缓存.

Q:代码作用域或者脚本出错的情况怎么处理?

A:使用局部作用域(比如将代码段包裹在一个函数内,这样就不会影响全局作用域,也很难修改外部namespace的数据),并用try…expect…包裹载入的脚本部分.对于出错的脚本直接提示错误就好,不要回报具体的错误而是将错误log下来以免泄露runtime 信息。

2.在数据API当中使用动态装载

提前在数据API外部做好鉴权等操作,类似于RPC式的调用,然后通过API返回数据。适合于需要和后端程序通信作为Proxy使用的场景。

以下是关于动态装载代码部分的范例

代码范例:

以下是简单的范例,实现的CodeLoader可以动态的装载和执行代码的指定部分(执行指定部分是一般插件的编写方式,仅允许运行指定方法并将接口通用化.)代码还算清晰吧,不需要太多说明,所以罗列如下.

from abc import ABCMeta, abstractmethod
import logging
import imp
import sys
import traceback
try:
    import cPickle as pickle
except ImportError:
    import pickle
 
 
logger = logging.getLogger("CodeLoader")
 
__all__ = (
    'StorageBackendMixin',
    'CacheBackendMixin',
    'CodeLoader',
)
 
 
class StorageBackendMixin(object):
        __metaclass__ = ABCMeta
 
        @abstractmethod
        def get(self, key, *args, **kwargs):
            pass
 
        @abstractmethod
        def set(self, key, value, *args, **kwargs):
            pass
 
 
class DummyStorageBackend(StorageBackendMixin):
    """
    Just a example, do not apply it to productive application.
    """
 
    _storage = {}
 
    @classmethod
    def get(cls, key):
        return cls._storage.get(key)
 
    @classmethod
    def set(cls, key, value, *args, **kwargs):
        cls._storage[key] = value
 
 
class CacheBackendMixin(object):
    __metaclass__ = ABCMeta
 
    @abstractmethod
    def get(self, key):
        pass
 
    @abstractmethod
    def set(self, key, value):
        pass
 
    @abstractmethod
    def delete(self, key):
        pass
 
 
class DummyCacheBackend(CacheBackendMixin):
    """
    Just a example, do not apply it to productive application.
    """
    _cached = {}
    @classmethod
    def get(cls, key):
        return cls._cached.get(key)
 
    @classmethod
    def set(cls, key, value):
        cls._cached[key] = value
 
    @classmethod
    def delete(cls, key):
        if key in cls._cached:
            del cls._cached[key]
 
 
class CodeLoader(object):
    """
    Get a module object from script file or string.
    """
    _module_prefix = "_dynamic_loaded_"
 
    def __init__(self, name, storage_backend=DummyStorageBackend, cache_backend=DummyCacheBackend):
        if not issubclass(storage_backend, StorageBackendMixin):
            raise TypeError("storage_backend must be subclass of StorageBackendMixin")
        if not issubclass(cache_backend, CacheBackendMixin):
            raise TypeError("cache_backend must be subclass of CacheBackendMixin")
        self.name = name
        self._cache_prefix = 'Loader_{cache_backend_name}_'.format(cache_backend_name=cache_backend.__name__)
        self._storage_backend = storage_backend
        self._cache_backend = cache_backend
 
    def create_module(self, fullname, code_script, save_key=None):
        """
        :param fullname: module name, will be joined with prefix `dynamic_loaded.`
        :param code_script: the utf-8 encoded bytes object(in python2, it is `str`)
        :param save_key: save key that will be used by storage_backend, You can also run 'CodeLoader.load(save_key)' to
            access the saved code object.
        :type fullname: str or unicode
        :type code_script: str
        :return: module object if success, return None if fail with anything wrong with the code's runtime error.
        """
        if not isinstance(code_script, str):
            raise TypeError("code_script param must instance of str")
 
        code = self._compile(fullname, code_script)
        if code is None:
            return None
 
        mod = imp.new_module(fullname)
        mod.__file__ = self._module_prefix + fullname
        mod.__loader__ = self
        mod.__package__ = ''
        mod.__script__ = code_script
        if save_key is None:
            mod.__save_key__ = self._module_prefix + fullname
        else:
            mod.__save_key__ = save_key
 
        try:
            exec(code, mod.__dict__)
            return mod
        except:
            exc_type, exc_value, traceback = sys.exc_info()
            logger.warning(
                "Bad codes, info listed below:\n"
                "exec_type: %s\n exec_value: %s\n traceback: %s" % (exc_type, exc_value, traceback)
            )
            return None
 
    def save(self, mod, cached=False, *args, **kwargs):
        """
        Save mod's script to storage backend, is cached=True, cache_backend will be refreshed.
        """
        self._storage_backend.set(mod.__save_key__, mod.__script__, *args, **kwargs)
        if cached:
            self._cache_backend.set(mod.__save_key__, pickle.dumps(mod))
        else:
            self._cache_backend.delete(mod.__save_key__)
 
    def load(self, fullname, save_key=None, *args, **kwargs):
        if save_key:
            access_key = save_key
        else:
            access_key = self._module_prefix + fullname
        result = self._cache_backend.get(access_key)
        print result
        if result:
            return pickle.loads(result)
        else:
            result = self._storage_backend.get(access_key, *args, **kwargs)
            return self.create_module(fullname, result, access_key)
 
    def _compile(self, fullname, code_script):
        """
        :type fullname: str or unicode
        :type code_script: str
        """
        try:
            return compile(code_script, self._module_prefix + fullname, 'exec')
        except SyntaxError:
            exc_type, exc_value, tb = sys.exc_info()
            traceback.print_exception(exc_type, exc_value, tb)
            logger.warning("code script `%s` has SyntaxError:\n"
                           "The code:\n%s" % (fullname, code_script))
            return None

—————补充—————–

考察了很多沙盒方案之后,发现现有的Python沙盒基本都无法满足安全性需求,所以在线修改项目代码这种操作还是不能暴露给普通用户,只能在上线添加功能的时候临时开启,从数据存储层级控制权限。

PyPy类沙盒太重了,无法在应用和动态代码需要同时运作的时候使用。

别的类别的sandbox成本太高,一套GAE模式的沙盒需要太多的定制,不是个人能完成的。

—————end——————

标签: python, 代码重载

添加新评论