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

//! This crate is an experimental Bitmessage node library.
//!
//! This crate uses
//! [`koibumi-core`](https://crates.io/crates/koibumi-core) library crate.
//!
//! For more information, see
//! [`koibumi`](https://crates.io/crates/koibumi) application crate.
//!
//! # Examples
//!
//! ```no_run
//! use async_std::task;
//! use futures::{sink::SinkExt, stream::StreamExt};
//!
//! use koibumi_node::{self as node, Command, Config, Event, Response};
//!
//! let (command_sender, mut response_receiver, handle) = node::spawn();
//!
//! let config = Config::builder()
//!     .server(Some("127.0.0.1:8444".parse().unwrap()))
//!     .socks(Some("127.0.0.1:9050".parse().unwrap()))
//!     .connect_to_onion(true)
//!     .connect_to_ip(true)
//!     .build();
//!
//! let mut sender = command_sender;
//! let response = task::block_on(async {
//!     if let Err(err) = sender.send(Command::Start(config)).await {
//!         eprintln!("{}", err);
//!         return None;
//!     }
//!     response_receiver.next().await
//! });
//! let Response::Started(mut receiver) = response.unwrap();
//!
//! task::block_on(async {
//!     let addr = "quzwelsuziwqgpt2.onion:8444".parse().unwrap();
//!     if let Err(err) = sender.send(Command::Connect(addr)).await {
//!         eprintln!("{}", err);
//!     }
//! });
//!
//! task::block_on(async {
//!     while let Some(event) = receiver.next().await {
//!         match event {
//!             Event::ConnectionCounts { .. } => (),
//!             Event::AddrCount(_count) => (),
//!             Event::Established { addr, user_agent } => {
//!                 println!("established: {} {}", addr, user_agent);
//!             }
//!             Event::Disconnected { addr } => {
//!                 println!("disconnected: {}", addr);
//!             }
//!             Event::Objects { .. } => (),
//!             Event::Stopped => {
//!                 break;
//!             }
//!         }
//!     }
//!
//!     handle.await;
//! });
//! ```

#![recursion_limit = "1024"]

mod config;
mod connection;
mod connection_loop;
mod constant;
mod inv_manager;
mod manager;
mod message_handler;
mod node_manager;

pub use config::{Builder as ConfigBuilder, Config};
pub use manager::{run, Command, Event, Response};

use async_std::task;
use futures::channel::mpsc::{self, Receiver, Sender};

/// Spawns a task that manage a Bitmessage node.
pub fn spawn() -> (Sender<Command>, Receiver<Response>, task::JoinHandle<()>) {
    const COMMAND_BUFFER: usize = 0x10000;
    const RESPONSE_BUFFER: usize = 0x10000;
    let (command_sender, command_receiver) = mpsc::channel(COMMAND_BUFFER);
    let (response_sender, response_receiver) = mpsc::channel(RESPONSE_BUFFER);
    let handle = task::spawn(manager::run(command_receiver, response_sender));
    (command_sender, response_receiver, handle)
}