Rusqbin

Rusqbin is a web server that stashes your requests for later retrieval. It is available as a Docker image, a binary, and a library through crates.io.

Rusdocs are published for: * Master branch * Latest release

Usage

Web API

The web server has the following API for dealing with request bins.

• POST /rusqbins To create a bin and get back bin_id
• GET /rusqbins To list bin summaries
• GET /rusqbins/${bin_id} To get bin-specific summary information
• GET /rusqbins/${bin_id}/requests To get detailed request information for a bin (lists all requests in the bin)
• DELETE /rusqbins/${bin_id} To delete a bin

In any other case, send requests with a X-Rusqbin-Id header with a bin_id to have your requests logged to a bin for later retrieval.

Docker

$ docker run lloydmeta/rusqbin:latest

Binary

To use Rusqbin as a binary, simply install it using cargo install rusqbin and then run rusqbin, and follow the simple usage instructions. The port the server runs on can be set by optionally adding a port argument.

Logging is handled by env_logger, so you can configure it at runtime using a RUST_LOG environment variable.

Library

To use it as a library, add it to your project as a crate dependency, then from within Rust code:

```rust use rusqbin::storage::; use rusqbin::server::; use rusqbin::models::*; use hyper::{Method, Uri}; use hyper::client::Client; use hyper::client::Request as HyperRequest; use std::io::Read; use std::thread; use std::sync::{Arc, Mutex}; use std::str::FromStr; use futures::future;

// Start a BinsServer on port 7000 in another thread, utilising // a simple mutex for shutting it down. A channel could also work. let server = Arc::new(BinsServer::new(7000, InMemoryBins::new())); let arcstayalive = Arc::new(Mutex::new(true)); let bgserver = server.clone(); let bgstayalive = arcstayalive.clone(); thread::spawn(move || { bgserver.rununtil(future::pollfn(|| { if *bgstayalive.lock().unwrap() { Ok(futures::Async::NotReady) } else { Ok(futures::Async::Ready(())) } })) });

let mut clientcore = tokiocore::reactor::Core::new().unwrap(); let client = Client::new(&client_core.handle());

// Create a bin via programmatically, making sure to scope the // storage unlocking with braces properly let bin = { let mut serverstorage = server.storage.lock().unwrap(); serverstorage.createbin() }; let binid = bin.id.value();

// Fire an HTTP request with the proper X-Rusqbin-Id header let mut req = HyperRequest::new(Method::Post, Uri::fromstr("http://localhost:7000/hello/world").unwrap()); req.headersmut().set(XRusqBinId(binid.toowned())); let future_resp = client.request(req);

// Here we use core.run to block on response, but you should never // do this in production code. clientcore.run(futureresp); // Check to make sure our HTTP request was received and stashed // in our rusqbin server { let mut serverstorage = server.storage.lock().unwrap(); let binrequests: &Bin = serverstorage.getbin(&bin.id).unwrap(); let req = &binrequests[0]; asserteq!(req.method, "POST".toowned()); asserteq!(req.path, "/hello/world".toowned()); } // Cleanup by shutting down our server using the mutex *arcstay_alive.lock().unwrap() = false; ```

In the example above, we use the out-of-the-box InMemoryBins for storage, but you can pass any given implementation of rusqbin::storage::Bins when creating a BinsServer.

Credit

Rusqbin is a simple port of Requestbin written in Rust. Inspired by Requestinator