rust-abci 0.1.0

An implementation of the ABCI protocol used by Tendermint Core. Allows the building of ABCI apps in 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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#![allow(unused_variables)]
#![allow(unused_must_use)]

extern crate grpc;
extern crate rust_abci;


use rust_abci::new_server;
use rust_abci::types::*;
use rust_abci::types_grpc::*;


struct DummyApp;

unsafe impl Sync for DummyApp {}

unsafe impl Send for DummyApp {}

impl ABCIApplication for DummyApp {
    fn echo(&self, o: ::grpc::RequestOptions, p: RequestEcho) -> ::grpc::SingleResponse<ResponseEcho> {
        println!("Echo");
        let response = ResponseEcho::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn flush(&self, o: ::grpc::RequestOptions, p: RequestFlush) -> ::grpc::SingleResponse<ResponseFlush> {
        println!("Flush");
        let response = ResponseFlush::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn info(&self, o: ::grpc::RequestOptions, p: RequestInfo) -> ::grpc::SingleResponse<ResponseInfo> {
        println!("Info");
        let response = ResponseInfo::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn set_option(&self, o: ::grpc::RequestOptions, p: RequestSetOption) -> ::grpc::SingleResponse<ResponseSetOption> {
        println!("SetOption");
        let response = ResponseSetOption::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn deliver_tx(&self, o: ::grpc::RequestOptions, p: RequestDeliverTx) -> ::grpc::SingleResponse<ResponseDeliverTx> {
        println!("DeliverTx");
        let response = ResponseDeliverTx::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn check_tx(&self, o: ::grpc::RequestOptions, p: RequestCheckTx) -> ::grpc::SingleResponse<ResponseCheckTx> {
        println!("CheckTx");
        let response = ResponseCheckTx::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn query(&self, o: ::grpc::RequestOptions, p: RequestQuery) -> ::grpc::SingleResponse<ResponseQuery> {
        println!("Query");
        let response = ResponseQuery::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn commit(&self, o: ::grpc::RequestOptions, p: RequestCommit) -> ::grpc::SingleResponse<ResponseCommit> {
        println!("Commit");
        let response = ResponseCommit::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn init_chain(&self, o: ::grpc::RequestOptions, p: RequestInitChain) -> ::grpc::SingleResponse<ResponseInitChain> {
        println!("InitChain");
        let response = ResponseInitChain::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn begin_block(&self, o: ::grpc::RequestOptions, p: RequestBeginBlock) -> ::grpc::SingleResponse<ResponseBeginBlock> {
        println!("BeginBlock");
        let response = ResponseBeginBlock::new();
        ::grpc::SingleResponse::completed(response)
    }

    fn end_block(&self, o: ::grpc::RequestOptions, p: RequestEndBlock) -> ::grpc::SingleResponse<ResponseEndBlock> {
        println!("EndBlock");
        let response = ResponseEndBlock::new();
        ::grpc::SingleResponse::completed(response)
    }
}


fn main() {
    use std::env;
    use std::thread;

    let args: Vec<String> = env::args().collect();
    let connection_type: &str = &args[1];
    let listen_addr: &str = &args[2];

    let _server = new_server(listen_addr, connection_type, DummyApp);

    loop {
        thread::park();
    }
}