Struct Server

pub struct Server { /* private fields */ }

jsonrpc http server instance

Implementations

impl Server

pub fn address(&self) -> &SocketAddr

Returns address of this server

pub fn close(self)

Closes the server.

pub fn wait(self)

Will block, waiting for the server to finish.

Examples found in repository

examples/http_async.rs (line 15)

fn main() {
	let mut io = IoHandler::default();
	io.add_method("say_hello", |_params| {
		futures::finished(Value::String("hello".to_owned()))
	});

	let server = ServerBuilder::new(io)
		.cors(DomainsValidation::AllowOnly(vec![AccessControlAllowOrigin::Null]))
		.start_http(&"127.0.0.1:3030".parse().unwrap())
		.expect("Unable to start RPC server");

	server.wait();
}

examples/server.rs (line 15)

fn main() {
	let mut io = IoHandler::default();
	io.add_method("say_hello", |_params: Params| Ok(Value::String("hello".to_string())));

	let server = ServerBuilder::new(io)
		.threads(3)
		.rest_api(RestApi::Unsecure)
		.cors(DomainsValidation::AllowOnly(vec![AccessControlAllowOrigin::Any]))
		.start_http(&"127.0.0.1:3030".parse().unwrap())
		.expect("Unable to start RPC server");

	server.wait();
}

examples/http_middleware.rs (line 24)

fn main() {
	let mut io = IoHandler::default();
	io.add_method("say_hello", |_params| {
		futures::finished(Value::String("hello".to_owned()))
	});

	let server = ServerBuilder::new(io)
		.cors(DomainsValidation::AllowOnly(vec![AccessControlAllowOrigin::Null]))
		.request_middleware(|request: hyper::Request<hyper::Body>| {
			if request.uri() == "/status" {
				Response::ok("Server running OK.").into()
			} else {
				request.into()
			}
		})
		.rest_api(RestApi::Unsecure)
		.start_http(&"127.0.0.1:3030".parse().unwrap())
		.expect("Unable to start RPC server");

	server.wait();
}

examples/http_meta.rs (line 40)

fn main() {
	let mut io = MetaIoHandler::default();

	io.add_method_with_meta("say_hello", |_params: Params, meta: Meta| {
		let auth = meta.auth.unwrap_or_else(String::new);
		if auth.as_str() == "let-me-in" {
			Ok(Value::String("Hello World!".to_owned()))
		} else {
			Ok(Value::String(
				"Please send a valid Bearer token in Authorization header.".to_owned(),
			))
		}
	});

	let server = ServerBuilder::new(io)
		.cors_allow_headers(AccessControlAllowHeaders::Only(vec!["Authorization".to_owned()]))
		.rest_api(RestApi::Unsecure)
		// You can also implement `MetaExtractor` trait and pass a struct here.
		.meta_extractor(|req: &hyper::Request<hyper::Body>| {
			let auth = req
				.headers()
				.get(hyper::header::AUTHORIZATION)
				.map(|h| h.to_str().unwrap_or("").to_owned());

			Meta { auth }
		})
		.start_http(&"127.0.0.1:3030".parse().unwrap())
		.expect("Unable to start RPC server");

	server.wait();
}

Trait Implementations

impl Drop for Server

fn drop(&mut self)

Executes the destructor for this type.