Внедрение низкопроизводительного языка сценариев в Python

Ответ 1

Вот мой вопрос по этой проблеме. Требование, чтобы пользовательские скрипты выполнялись внутри ванильного CPython, вам нужно либо написать интерпретатор для вашего мини-языка, либо скомпилировать его на байт-код Python (или использовать Python в качестве исходного языка), а затем "дезинфицировать" байт-код перед его выполнением.

Я пошел на быстрый пример, основанный на предположении, что пользователи могут писать их скрипты на Python и что источник и байт-код могут быть достаточно санируется с помощью некоторой комбинации фильтрации небезопасного синтаксиса из анализа дерево и/или удаление небезопасных кодов операций из байт-кода.

Вторая часть решения требует, чтобы пользовательский script байт-код был периодически прерывается задачей сторожевого таймера, которая гарантирует, что пользователь script не превышает некоторого предела кода операции, и для всего этого для работы с ванильным CPython.

Резюме моей попытки, которая в основном фокусируется на 2-й части проблемы.

• Пользовательские скрипты написаны на Python.
• Используйте byteplay для фильтрации и изменения байт-кода.
• Инструмент байт-кода пользователя для вставки счетчика операций и вызывает функцию, контекст которой переключается на задачу сторожевого таймера.
• Используйте greenlet, чтобы выполнить пользовательский байт-код, с выходом переключения между пользователем script и сторожевой сторожей.
• Сторожевой таймер накладывает пресет на число опкодов, которые могут быть выполненных до возникновения ошибки.

Надеюсь, это по крайней мере идет в правильном направлении. Мне интересно услышать больше о вашем решении, когда вы приедете на него.

Исходный код для 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 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 script."
    globals_ = {'__yield': yield_func, '__op_counter': 0}
    eval(code.to_code(), globals_, globals_)

execute(sys.argv[1])

Вот пример пользователя script 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

Ответ 2

Jispy - это идеальное решение!

• Это интерпретатор JavaScript в Python, созданный прежде всего для встраивания JS в Python.

• Примечательно, что он предоставляет проверки и ограничения на рекурсию и цикл. Так же, как это необходимо.

• Он легко позволяет вам использовать функции python для кода JavaScript.

• По умолчанию он не обнаруживает файловую систему хоста или любой другой чувствительный элемент.

Полное раскрытие информации:

• Jispy - мой проект. Я явно склонен к этому.
• Тем не менее, здесь это действительно идеально подходит.

PS:

• Этот ответ записывается ~ через 3 года после того, как этот вопрос был задан.
• Мотивация такого позднего ответа проста:
  Учитывая, насколько близко Jispy ограничивается вопросом, будущие читатели с аналогичными требованиями должны быть в состоянии извлечь из этого выгоду.

Ответ 3

Попробуйте Lua. Синтаксис, который вы упомянули, почти идентичен синтаксису Lua's. См. Как вставить Lua в Python 3.x?

Ответ 4

Я не знаю ничего, что действительно решает эту проблему.

Я думаю, что самая простая вещь, которую вы могли бы сделать, это написать собственную версию виртуальной машины python в python.

Я часто думал о том, чтобы делать это в чем-то вроде Cython, поэтому вы можете просто импортировать его в виде модуля, и вы можете опираться на существующее время выполнения для большинства жестких бит.

Возможно, вы уже можете создавать интерпретатор python-in-python с PyPy, но вывод PyPy - это среда выполнения, которая делает ВСЕ, включая реализацию эквивалентных PyObjects для встроенных типов и всего этого, и я думаю это переполнение для такого рода вещей.

Все, что вам действительно нужно, это то, что работает как кадр в стеке выполнения, а затем метод для каждого кода операции. Я не думаю, что вам даже нужно реализовать его самостоятельно. Вы могли бы просто написать модуль, который отображал существующие объекты фрейма во время выполнения.

В любом случае, вы просто сохраняете свой собственный стек объектов фрейма и обрабатываете байт-коды, и вы можете дросселировать его с помощью байт-кодов в секунду или что-то еще.

Ответ 5

Почему не python-код в pysandbox http://pypi.python.org/pypi/pysandbox/1.0.3?

Ответ 6

Взгляните на LimPy. Это означает ограниченный Python и был построен именно для этой цели.

Там была среда, где пользователям приходилось писать основную логику для управления пользовательским интерфейсом. Я не знаю, как он будет взаимодействовать с ограничениями времени выполнения, но я думаю, вы можете это сделать, если захотите написать небольшой код.

Ответ 7

Я использовал Python как "мини-конфигурационный язык" для более раннего проекта. Мой подход состоял в том, чтобы взять код, проанализировать его с помощью модуля parser, а затем пройти AST из сгенерированного кода и выпустить "не разрешенные" операции (например, определение классов, называемых __ методами и т.д.).

После этого создайте синтетическую среду, в которой есть только модули и переменные, которые были "разрешены", и оценил код внутри этого, чтобы получить что-то, что я мог бы запустить.

Это сработало хорошо для меня. Я не знаю, действительно ли это доказательство пули, если вы хотите предоставить своим пользователям больше энергии, чем я сделал для языка конфигурации.

Что касается ограничения по времени, вы можете запустить свою программу в отдельном потоке или процессе и завершить ее через определенный промежуток времени.

Ответ 8

Самый простой способ сделать реальный DSL - ANTLR, у него есть синтаксические шаблоны для некоторых популярных языков.