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 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
#![doc(html_playground_url = "https://play.rust-lang.org/")] //! Rusqbin is a web server that stashes your requests for later retrieval. It is available as //! both a binary and a library. //! //! Rusqbin's web API is the following : //! //! - POST /rusqbins To create a bin and get back bin_id //! - GET /rusqbins To list bin summaries //! - GET /rusqbins/${bin_id}/requests To get detailed request information for a bin //! - GET /rusqbins/${bin_id} To get bin-specific information (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. //! //! To use it as a binary, simply install it using `cargo install rusqbin` and then `rusqbin`, //! and follow the simple usage instructions. //! //! To use it as a library from within Rust code: //! //! ``` //! # extern crate rusqbin; //! # extern crate hyper; //! # extern crate serde_json; //! # extern crate futures; //! # extern crate tokio_core; //! 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::time::Duration; //! use std::sync::{Arc, Mutex}; //! use std::str::FromStr; //! use futures::future; //! # fn main() { //! // Start a BinsServer on port 7000 in another thread, utilising //! // a simple mutex for shutting it down //! let server = Arc::new(BinsServer::new(7000, InMemoryBins::new())); //! let arc_stay_alive = Arc::new(Mutex::new(true)); //! let bg_server = server.clone(); //! let bg_stay_alive = arc_stay_alive.clone(); //! thread::spawn(move || { //! bg_server.run_until(future::poll_fn(|| { //! if *bg_stay_alive.lock().unwrap() { //! Ok(futures::Async::NotReady) //! } else { //! Ok(futures::Async::Ready(())) //! } //! })) //! }); //! thread::sleep(Duration::from_millis(500)); // wait a bit for the server to come up //! //! let mut client_core = tokio_core::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 server_storage = server.storage.lock().unwrap(); //! server_storage.create_bin() //! }; //! let bin_id = bin.id.value(); //! //! // Fire an HTTP request with the proper X-Rusqbin-Id header //! let mut req = HyperRequest::new(Method::Post, Uri::from_str("http://localhost:7000/hello/world").unwrap()); //! req.headers_mut().set(XRusqBinId(bin_id.to_owned())); //! let future_resp = client.request(req); //! //! // Here we use core.run to block on response, but you should never //! // do this in production code. //! client_core.run(future_resp); //! //! // Check to make sure our HTTP request was received and stashed //! // in our rusqbin server //! { //! let mut server_storage = server.storage.lock().unwrap(); //! let bin_requests: &Bin = server_storage.get_bin(&bin.id).unwrap(); //! let req = &bin_requests[0]; //! assert_eq!(req.method, "POST".to_owned()); //! assert_eq!(req.path, "/hello/world".to_owned()); //! } //! //! // Cleanup by shutting down our server //! *arc_stay_alive.lock().unwrap() = false; //! # } //! ``` //! //! In the example above, we use the default `InMemoryBins` for storage, but you can pass any given implementation of //! `rusqbin::storage::Bins` when creating a BinsServer. //! //! [Requestbin](https://requestb.in/) written in Rust. Inspired by [Requestinator](https://github.com/DonMcNamara/requestinator) #[macro_use] extern crate hyper; extern crate futures; extern crate uuid; extern crate regex; extern crate time; extern crate url; #[macro_use] extern crate lazy_static; #[macro_use] extern crate serde_derive; extern crate serde; extern crate serde_json; #[macro_use] extern crate log; pub mod models; pub mod storage; pub mod server; pub mod errors;