python - 在 Python 中嵌入低性能脚本语言

Question

已结束。此问题不符合 Stack Overflow guidelines 。它目前不接受答案。

---

我们不允许提出有关书籍、工具、软件库等方面的建议的问题。您可以编辑问题，以便用事实和引用来回答它。

关闭1年前。

Improve this question

我有一个网络应用程序。作为其中的一部分，我需要应用程序的用户能够编写(或复制和粘贴)非常简单的脚本来针对他们的数据运行。

脚本真的可以很简单，性能只是最次要的问题。我的意思是脚本的复杂性示例如下:

ratio = 1.2345678
minimum = 10

def convert(money)
    return money * ratio
end

if price < minimum
    cost = convert(minimum)
else
    cost = convert(price)
end

其中价格和成本是一个全局变量(我可以输入环境并在计算后访问)。

不过，我确实需要保证一些东西。

1. 运行的任何脚本都无法访问 Python 环境。他们不能导入东西、调用我没有明确为他们公开的方法、读取或写入文件、生成线程等。我需要完全锁定。

2. 我需要能够对脚本运行的“周期”数量进行硬性限制。循环在这里是一个通用术语。如果语言是字节编译的，则可能是 VM 指令。应用调用 Eval/Apply 循环。或者只是通过一些运行脚本的中央处理循环进行迭代。细节不如我能够在短时间内停止运行并向所有者发送电子邮件并说“您的脚本似乎不仅仅是将几个数字相加 - 将它们整理出来。”

3. 它必须在 Vanilla 未打补丁的 CPython 上运行。

到目前为止，我一直在为这项任务编写自己的 DSL。我能做到。但我想知道我是否可以建立在巨人的肩膀上。是否有适用于 Python 的迷你语言可以做到这一点？

有很多 hacky Lisp 变体(甚至是我在 Github 上写的)，但我更喜欢非专业语法的东西(比如更多 C 或 Pascal)，因为我认为这是一个除了自己编码之外，我想要更成熟的东西。

有什么想法吗？

Answer 1

这是我对这个问题的看法。要求用户脚本在 vanilla CPython 中运行意味着您需要为您的迷你语言编写解释器，或者将其编译为 Python 字节码(或使用 Python 作为源语言)，然后在执行之前“清理”字节码。

基于用户可以编写的假设，我已经举了一个简单的例子他们在 Python 中编写的脚本，并且源代码和字节码可以足够通过从解析中过滤不安全语法的某种组合进行清理树和/或从字节码中删除不安全的操作码。

解决方案的第二部分要求用户脚本字节码是定期被看门狗任务中断，这将确保用户脚本不超过某些操作码限制，并且所有这些都可以在 vanilla CPython 上运行。

我的尝试总结，主要集中在问题的第二部分。

• 用户脚本是用 Python 编写的。
• 使用byteplay过滤和修改字节码。
• 检测用户的字节码以插入操作码计数器并调用上下文切换到看门狗任务的函数。
• 使用greenlet执行用户的字节码，带有yield切换在用户脚本和看门狗协程之间。
• 看门狗对操作码的数量实现了预设限制，在引发错误之前执行。

希望这至少朝着正确的方向发展。我有兴趣听听更多关于您的解决方案的信息。

lowperf.py的源代码:

# std
import ast
import dis
import sys
from pprint import pprint

# vendor
import byteplay
import greenlet

# bytecode snippet to increment our global opcode counter
INCREMENT = [
    (byteplay.LOAD_GLOBAL, '__op_counter'),
    (byteplay.LOAD_CONST, 1),
    (byteplay.INPLACE_ADD, None),
    (byteplay.STORE_GLOBAL, '__op_counter')
    ]

# bytecode snippet to perform a yield to our watchdog tasklet.
YIELD = [
    (byteplay.LOAD_GLOBAL, '__yield'),
    (byteplay.LOAD_GLOBAL, '__op_counter'),
    (byteplay.CALL_FUNCTION, 1),
    (byteplay.POP_TOP, None)
    ]

def instrument(orig):
    """
    Instrument bytecode.  We place a call to our yield function before
    jumps and returns.  You could choose alternate places depending on 
    your use case.
    """
    line_count = 0
    res = []
    for op, arg in orig.code:
        line_count += 1

        # NOTE: you could put an advanced bytecode filter here.

        # whenever a code block is loaded we must instrument it
        if op == byteplay.LOAD_CONST and isinstance(arg, byteplay.Code):
            code = instrument(arg)
            res.append((op, code))
            continue

        # 'setlineno' opcode is a safe place to increment our global 
        # opcode counter.
        if op == byteplay.SetLineno:
            res += INCREMENT
            line_count += 1

        # append the opcode and its argument
        res.append((op, arg))

        # if we're at a jump or return, or we've processed 10 lines of
        # source code, insert a call to our yield function.  you could 
        # choose other places to yield more appropriate for your app.
        if op in (byteplay.JUMP_ABSOLUTE, byteplay.RETURN_VALUE) \
                or line_count > 10:
            res += YIELD
            line_count = 0

    # finally, build and return new code object
    return byteplay.Code(res, orig.freevars, orig.args, orig.varargs,
        orig.varkwargs, orig.newlocals, orig.name, orig.filename,
        orig.firstlineno, orig.docstring)

def transform(path):
    """
    Transform the Python source into a form safe to execute and return
    the bytecode.
    """
    # NOTE: you could call ast.parse(data, path) here to get an
    # abstract syntax tree, then filter that tree down before compiling
    # it into bytecode.  i've skipped that step as it is pretty verbose.
    data = open(path, 'rb').read()
    suite = compile(data, path, 'exec')
    orig = byteplay.Code.from_code(suite)
    return instrument(orig)

def execute(path, limit = 40):
    """
    This transforms the user's source code into bytecode, instrumenting
    it, then kicks off the watchdog and user script tasklets.
    """
    code = transform(path)
    target = greenlet.greenlet(run_task)

    def watcher_task(op_count):
        """
        Task which is yielded to by the user script, making sure it doesn't
        use too many resources.
        """
        while 1:
            if op_count > limit:
                raise RuntimeError("script used too many resources")
            op_count = target.switch()

    watcher = greenlet.greenlet(watcher_task)
    target.switch(code, watcher.switch)

def run_task(code, yield_func):
    "This is the greenlet task which runs our user's script."
    globals_ = {'__yield': yield_func, '__op_counter': 0}
    eval(code.to_code(), globals_, globals_)

execute(sys.argv[1])

这是一个示例用户脚本user.py:

def otherfunc(b):
    return b * 7

def myfunc(a):
    for i in range(0, 20):
        print i, otherfunc(i + a + 3)

myfunc(2)

这是一个示例运行:

% python lowperf.py user.py

0 35
1 42
2 49
3 56
4 63
5 70
6 77
7 84
8 91
9 98
10 105
11 112
Traceback (most recent call last):
  File "lowperf.py", line 114, in <module>
    execute(sys.argv[1])
  File "lowperf.py", line 105, in execute
    target.switch(code, watcher.switch)
  File "lowperf.py", line 101, in watcher_task
    raise RuntimeError("script used too many resources")
RuntimeError: script used too many resources