-2

我还不太了解 Rust，无法理解生命周期和闭包......

尝试使用 tokio-curl 将下载的数据收集到向量中：

extern crate curl;
extern crate futures;
extern crate tokio_core;
extern crate tokio_curl;

use std::io::{self, Write};
use std::str;

use curl::easy::Easy;
use tokio_core::reactor::Core;
use tokio_curl::Session;

fn main() {
    // Create an event loop that we'll run on, as well as an HTTP `Session`
    // which we'll be routing all requests through.
    let mut lp = Core::new().unwrap();
    let mut out = Vec::new();
    let session = Session::new(lp.handle());

    // Prepare the HTTP request to be sent.
    let mut req = Easy::new();
    req.get(true).unwrap();
    req.url("https://www.rust-lang.org").unwrap();
    req.write_function(|data| {
            out.extend_from_slice(data);
            io::stdout().write_all(data).unwrap();
            Ok(data.len())
        })
        .unwrap();

    // Once we've got our session, issue an HTTP request to download the
    // rust-lang home page
    let request = session.perform(req);

    // Execute the request, and print the response code as well as the error
    // that happened (if any).
    let mut req = lp.run(request).unwrap();
    println!("{:?}", req.response_code());
    println!("out: {}", str::from_utf8(&out).unwrap());
}

产生错误：

error[E0373]: closure may outlive the current function, but it borrows `out`, which is owned by the current function
  --> src/main.rs:25:24
   |
25 |     req.write_function(|data| {
   |                        ^^^^^^ may outlive borrowed value `out`
26 |             out.extend_from_slice(data);
   |             --- `out` is borrowed here
   |
help: to force the closure to take ownership of `out` (and any other referenced variables), use the `move` keyword, as shown:
   |     req.write_function(move |data| {

进一步调查，我发现这Easy::write_function需要'static生命周期，但是如何从 curl-rust 文档收集输出的示例使用Transfer::write_function改为使用：

use curl::easy::Easy;

let mut data = Vec::new();
let mut handle = Easy::new();
handle.url("https://www.rust-lang.org/").unwrap();
{
    let mut transfer = handle.transfer();
    transfer.write_function(|new_data| {
        data.extend_from_slice(new_data);
        Ok(new_data.len())
    }).unwrap();
    transfer.perform().unwrap();
}
println!("{:?}", data);

Transfer::write_function不需要'static生命周期：

impl<'easy, 'data> Transfer<'easy, 'data> {
    /// Same as `Easy::write_function`, just takes a non `'static` lifetime
    /// corresponding to the lifetime of this transfer.
    pub fn write_function<F>(&mut self, f: F) -> Result<(), Error>
        where F: FnMut(&[u8]) -> Result<usize, WriteError> + 'data
    {
...

但我不能Transfer在 tokio-curl 上使用实例，Session::perform因为它需要Easy类型：

pub fn perform(&self, handle: Easy) -> Perform {

transfer.easy是一个私有字段，直接传递给session.perform。

这是 tokio-curl 的问题吗？也许它应该将该transfer.easy字段标记为公共或实现新功能，例如perform_transfer？还有另一种使用 tokio-curl 每次传输来收集输出的方法吗？

4

1 回答 1

2

使用 futures 库时，您必须了解的第一件事是您无法控制代码将在哪个线程上运行。

此外， curl 的文档Easy::write_function说：

请注意，此函数的生命周期限制为'static，但这通常过于严格。要使用堆栈数据，请考虑调用该transfer方法，然后使用write_function配置一个可以引用堆栈本地数据的回调。

最直接的解决方案是使用某种类型的锁定原语来确保一次只有一个线程可以访问向量。您还必须在主线程和闭包之间共享向量的所有权：

use std::sync::Mutex;
use std::sync::Arc;

let out = Arc::new(Mutex::new(Vec::new()));
let out_closure = out.clone();

// ...

req.write_function(move |data| {
    let mut out = out_closure.lock().expect("Unable to lock output");
    // ...
}).expect("Cannot set writing function");

// ...

let out = out.lock().expect("Unable to lock output");
println!("out: {}", str::from_utf8(&out).expect("Data was not UTF-8"));

不幸的是，tokio-curl 库目前不支持使用Transfer允许基于堆栈的数据的类型。

于 2016-09-16T13:44:15.443 回答