cocaine 0.9.2

Cocaine Framework Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Storage service API.

use std::mem;

use futures::Future;

use {Error, Request, Service};
use dispatch::PrimitiveDispatch;

/// Storage service wrapper.
#[derive(Clone, Debug)]
pub struct Storage {
    service: Service,
}

impl Storage {
    /// Constructs a new storage service wrapper using the specified service.
    pub fn new(service: Service) -> Self {
        Self { service }
    }

    /// Consumes this wrapper, yielding an underlying service.
    pub fn into_inner(self) -> Service {
        self.service
    }

    /// Reads the data that is kept at the specified collection and key.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use cocaine::{Core, Service};
    /// use cocaine::service::Storage;
    ///
    /// let mut core = Core::new().unwrap();
    /// let storage = Storage::new(Service::new("storage", &core.handle()));
    ///
    /// let future = storage.read("collection", "key");
    ///
    /// let data = core.run(future).unwrap();
    /// ```
    pub fn read(&self, collection: &str, key: &str) -> impl Future<Item = Vec<u8>, Error = Error> {
        let (dispatch, future) = PrimitiveDispatch::pair();
        self.service.call(Request::new(0, &(collection, key)).unwrap(), dispatch)
            .map(|sender| {
                mem::drop(sender);
            })
            .and_then(|()| future)
    }

    /// Writes the specified data into the storage.
    ///
    /// Optional indexes can also be associated with the data written.
    ///
    /// Returns a future, which will be resolved either when the data is successfully written into
    /// the storage or some error occurred.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use cocaine::{Core, Service};
    /// use cocaine::service::Storage;
    ///
    /// let mut core = Core::new().unwrap();
    /// let storage = Storage::new(Service::new("storage", &core.handle()));
    ///
    /// let future = storage.write("collection", "key", "le message".as_bytes(), &[]);
    ///
    /// core.run(future).unwrap();
    /// ```
    pub fn write(&self, collection: &str, key: &str, data: &[u8], indexes: &[&str]) ->
        impl Future<Item = (), Error = Error>
    {
        // This is required, because of old MessagePack on the server-side.
        let data: &str = unsafe { mem::transmute(data) };

        let (dispatch, future) = PrimitiveDispatch::pair();
        self.service.call(Request::new(1, &(collection, key, data, indexes)).unwrap(), dispatch)
            .map(|sender| {
                mem::drop(sender);
            })
            .and_then(|()| future)
    }
}