Прерывание клавиатуры от Python не прерывает работу Rust (PyO3)

Одним из вариантов было бы создать отдельный процесс для запуска функции Rust. В дочернем процессе мы можем настроить обработчик сигнала для выхода из процесса по прерыванию. Затем Python сможет вызвать исключение KeyboardInterrupt по желанию. Вот пример того, как это сделать:

// src/lib.rs
use pyo3::prelude::*;
use pyo3::wrap_pyfunction;
use ctrlc;

#[pyfunction]
pub fn sleep() {
    ctrlc::set_handler(|| std::process::exit(2)).unwrap();
    std::thread::sleep(std::time::Duration::from_millis(10000));
}

#[pymodule]
fn wait(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_wrapped(wrap_pyfunction!(sleep))
}

# wait.py
import wait
import multiprocessing as mp

def f():
    wait.sleep()

p = mp.Process(target=f)
p.start()
p.join()
print("Done")

Вот что я получаю на своей машине после нажатия CTRL-C:

$ python3 wait.py
^CTraceback (most recent call last):
  File "wait.py", line 9, in <module>
    p.join()
  File "/home/kerby/miniconda3/lib/python3.7/multiprocessing/process.py", line 140, in join
    res = self._popen.wait(timeout)
  File "/home/kerby/miniconda3/lib/python3.7/multiprocessing/popen_fork.py", line 48, in wait
    return self.poll(os.WNOHANG if timeout == 0.0 else 0)
  File "/home/kerby/miniconda3/lib/python3.7/multiprocessing/popen_fork.py", line 28, in poll
    pid, sts = os.waitpid(self.pid, flag)
KeyboardInterrupt

Ваша проблема очень похожа на этот, за исключением того, что ваш код написан на Rust вместо C++.

Вы не сказали, какую платформу вы используете - я предполагаю, что она похожа на unix. Некоторые аспекты этого ответа могут быть неверны для Windows.

В unix-подобных системах сочетание клавиш Ctrl+C приводит к отправке вашему процессу сигнала SIGINT. На самом низком уровне библиотеки C приложения могут регистрировать функции, которые будут вызываться при получении этих сигналов. Подробнее см. man signal(7). описание сигналов.

Поскольку обработчики сигналов могут быть вызваны в любое время (даже на полпути к какой-либо операции, которую вы обычно считаете атомарной), существуют большие ограничения на то, что на самом деле может делать обработчик сигналов. Это не зависит от языка программирования или среды. Большинство программ просто устанавливают флаг, когда они получают сигнал, а затем возвращаются, а затем проверяют этот флаг и предпринимают какие-либо действия.

Python ничем не отличается — он устанавливает обработчик сигнала для сигнала SIGINT, который устанавливает некоторый флаг, который он проверяет (когда это безопасно) и выполняет действие.

Это работает нормально при выполнении кода Python — он будет проверять флаг по крайней мере один раз для каждого оператора кода — но это другое дело при выполнении долго работающей функции, написанной на Rust (или любом другом иностранном языке). Флаг не проверяется, пока ваша функция ржавчины не вернется.

Вы можете улучшить ситуацию, проверив флаг в вашей функции ржавчины. PyO3 открывает PyErr_CheckSignals, которая делает именно это. Эта функция:

проверяет, был ли отправлен сигнал процессам, и если да, то вызывает соответствующий обработчик сигнала. Если модуль сигнала поддерживается, это может вызвать обработчик сигнала, написанный на Python. Во всех случаях по умолчанию для SIGINT возникает исключение KeyboardInterrupt. Если возникает исключение, устанавливается индикатор ошибки и функция возвращает -1; иначе функция возвращает 0

Таким образом, вы можете вызывать эту функцию с подходящими интервалами внутри вашей функции Rust и проверять возвращаемое значение. Если это было -1, вы должны немедленно вернуться из своей функции Rust; иначе продолжайте.

Картина становится более сложной, если ваш код на Rust многопоточный. Вы можете вызывать PyErr_CheckSignals только из того же потока, что и интерпретатор Python, вызывающий вас; и если он вернет -1, вам придется очистить все другие потоки, которые вы начали, прежде чем вернуться. Как именно это сделать, выходит за рамки этого ответа.