+2 -2

Makefile.toml

reviewed

··· 54 54 command = "cargo" 55 55 args = ["doc", "--open", "--no-deps"] 56 56 57 57 - [tasks.run] 57 57 + [tasks.example] 58 58 command = "cargo" 59 59 - args = ["run", "--example", "windmark", "--features", "auto-deduce-mime,logger"] 59 59 + args = ["run", "--example", "${@}", "--all-features"]

+2 -750

src/lib.rs

reviewed

··· 111 111 pub mod module; 112 112 pub mod response; 113 113 pub mod returnable; 114 114 + pub mod router; 114 115 pub mod utilities; 115 116 116 117 #[macro_use] 117 118 extern crate log; 118 118 - 119 119 - use std::{ 120 120 - error::Error, 121 121 - sync::{Arc, Mutex}, 122 122 - }; 123 119 124 120 pub use module::Module; 125 125 - use openssl::ssl::{self, SslAcceptor, SslMethod}; 126 121 pub use response::Response; 122 122 + pub use router::Router; 127 123 pub use tokio::main; 128 128 - use tokio::{ 129 129 - io::{AsyncReadExt, AsyncWriteExt}, 130 130 - stream::StreamExt, 131 131 - }; 132 132 - use url::Url; 133 133 - 134 134 - use crate::{ 135 135 - handler::{Callback, ErrorResponse, Partial, RouteResponse}, 136 136 - response::to_value_set_status, 137 137 - returnable::{CallbackContext, ErrorContext, RouteContext}, 138 138 - }; 139 139 - 140 140 - macro_rules! or_error { 141 141 - ($stream:ident, $operation:expr, $error_format:literal) => { 142 142 - match $operation { 143 143 - Ok(u) => u, 144 144 - Err(e) => { 145 145 - $stream 146 146 - .write_all(format!($error_format, e).as_bytes()) 147 147 - .await?; 148 148 - 149 149 - $stream.shutdown().await?; 150 150 - 151 151 - return Ok(()); 152 152 - } 153 153 - } 154 154 - }; 155 155 - } 156 156 - 157 157 - /// A router which takes care of all tasks a Windmark server should handle: 158 158 - /// response generation, panics, logging, and more. 159 159 - #[derive(Clone)] 160 160 - pub struct Router { 161 161 - routes: matchit::Router<Arc<Mutex<RouteResponse>>>, 162 162 - error_handler: Arc<Mutex<ErrorResponse>>, 163 163 - private_key_file_name: String, 164 164 - ca_file_name: String, 165 165 - headers: Arc<Mutex<Vec<Partial>>>, 166 166 - footers: Arc<Mutex<Vec<Partial>>>, 167 167 - ssl_acceptor: Arc<SslAcceptor>, 168 168 - #[cfg(feature = "logger")] 169 169 - default_logger: bool, 170 170 - pre_route_callback: Arc<Mutex<Callback>>, 171 171 - post_route_callback: Arc<Mutex<Callback>>, 172 172 - charset: String, 173 173 - language: String, 174 174 - port: i32, 175 175 - modules: Arc<Mutex<Vec<Box<dyn Module + Send>>>>, 176 176 - fix_path: bool, 177 177 - } 178 178 - impl Router { 179 179 - /// Create a new `Router` 180 180 - /// 181 181 - /// # Examples 182 182 - /// 183 183 - /// ```rust 184 184 - /// let _router = windmark::Router::new(); 185 185 - /// ``` 186 186 - /// 187 187 - /// # Panics 188 188 - /// 189 189 - /// if a default `SslAcceptor` could not be built. 190 190 - #[must_use] 191 191 - pub fn new() -> Self { Self::default() } 192 192 - 193 193 - /// Set the filename of the private key file. 194 194 - /// 195 195 - /// # Examples 196 196 - /// 197 197 - /// ```rust 198 198 - /// windmark::Router::new().set_private_key_file("windmark_private.pem"); 199 199 - /// ``` 200 200 - pub fn set_private_key_file( 201 201 - &mut self, 202 202 - private_key_file_name: &str, 203 203 - ) -> &mut Self { 204 204 - self.private_key_file_name = private_key_file_name.to_string(); 205 205 - 206 206 - self 207 207 - } 208 208 - 209 209 - /// Set the filename of the certificate chain file. 210 210 - /// 211 211 - /// # Examples 212 212 - /// 213 213 - /// ```rust 214 214 - /// windmark::Router::new().set_certificate_file("windmark_public.pem"); 215 215 - /// ``` 216 216 - pub fn set_certificate_file(&mut self, certificate_name: &str) -> &mut Self { 217 217 - self.ca_file_name = certificate_name.to_string(); 218 218 - 219 219 - self 220 220 - } 221 221 - 222 222 - /// Map routes to URL paths 223 223 - /// 224 224 - /// # Examples 225 225 - /// 226 226 - /// ```rust 227 227 - /// use windmark::Response; 228 228 - /// 229 229 - /// windmark::Router::new() 230 230 - /// .mount( 231 231 - /// "/", 232 232 - /// Box::new(|_| Response::Success("This is the index page!".into())), 233 233 - /// ) 234 234 - /// .mount( 235 235 - /// "/test", 236 236 - /// Box::new(|_| Response::Success("This is a test page!".into())), 237 237 - /// ); 238 238 - /// ``` 239 239 - /// 240 240 - /// # Panics 241 241 - /// 242 242 - /// if the route cannot be mounted. 243 243 - pub fn mount(&mut self, route: &str, handler: RouteResponse) -> &mut Self { 244 244 - self 245 245 - .routes 246 246 - .insert(route, Arc::new(Mutex::new(handler))) 247 247 - .unwrap(); 248 248 - 249 249 - self 250 250 - } 251 251 - 252 252 - /// Create an error handler which will be displayed on any error. 253 253 - /// 254 254 - /// # Examples 255 255 - /// 256 256 - /// ```rust 257 257 - /// windmark::Router::new().set_error_handler(Box::new(|_| { 258 258 - /// windmark::Response::Success("You have encountered an error!".into()) 259 259 - /// })); 260 260 - /// ``` 261 261 - pub fn set_error_handler(&mut self, handler: ErrorResponse) -> &mut Self { 262 262 - self.error_handler = Arc::new(Mutex::new(handler)); 263 263 - 264 264 - self 265 265 - } 266 266 - 267 267 - /// Add a header for the `Router` which should be displayed on every route. 268 268 - /// 269 269 - /// # Panics 270 270 - /// 271 271 - /// May panic if the header cannot be added. 272 272 - /// 273 273 - /// # Examples 274 274 - /// 275 275 - /// ```rust 276 276 - /// windmark::Router::new().add_header(Box::new(|context| { 277 277 - /// format!("This is displayed at the top of {}!", context.url.path()) 278 278 - /// })); 279 279 - /// ``` 280 280 - pub fn add_header(&mut self, handler: Partial) -> &mut Self { 281 281 - (*self.headers.lock().unwrap()).push(handler); 282 282 - 283 283 - self 284 284 - } 285 285 - 286 286 - /// Add a footer for the `Router` which should be displayed on every route. 287 287 - /// 288 288 - /// # Panics 289 289 - /// 290 290 - /// May panic if the header cannot be added. 291 291 - /// 292 292 - /// # Examples 293 293 - /// 294 294 - /// ```rust 295 295 - /// windmark::Router::new().add_footer(Box::new(|context| { 296 296 - /// format!("This is displayed at the bottom of {}!", context.url.path()) 297 297 - /// })); 298 298 - /// ``` 299 299 - pub fn add_footer(&mut self, handler: Partial) -> &mut Self { 300 300 - (*self.footers.lock().unwrap()).push(handler); 301 301 - 302 302 - self 303 303 - } 304 304 - 305 305 - /// Run the `Router` and wait for requests 306 306 - /// 307 307 - /// # Examples 308 308 - /// 309 309 - /// ```rust 310 310 - /// windmark::Router::new().run(); 311 311 - /// ``` 312 312 - /// 313 313 - /// # Panics 314 314 - /// 315 315 - /// if the client could not be accepted. 316 316 - /// 317 317 - /// # Errors 318 318 - /// 319 319 - /// if the `TcpListener` could not be bound. 320 320 - pub async fn run(&mut self) -> Result<(), Box<dyn Error>> { 321 321 - self.create_acceptor()?; 322 322 - 323 323 - #[cfg(feature = "logger")] 324 324 - if self.default_logger { 325 325 - pretty_env_logger::init(); 326 326 - } 327 327 - 328 328 - let acceptor = self.ssl_acceptor.clone(); 329 329 - let mut listener = 330 330 - tokio::net::TcpListener::bind(format!("0.0.0.0:{}", self.port)).await?; 331 331 - 332 332 - #[cfg(feature = "logger")] 333 333 - info!("windmark is listening for connections"); 334 334 - 335 335 - while let Some(stream) = listener.incoming().next().await { 336 336 - match stream { 337 337 - Ok(stream) => { 338 338 - let acceptor = acceptor.clone(); 339 339 - let mut self_clone = self.clone(); 340 340 - 341 341 - tokio::spawn(async move { 342 342 - match tokio_openssl::accept(&acceptor, stream).await { 343 343 - Ok(mut stream) => { 344 344 - if let Err(e) = self_clone.handle(&mut stream).await { 345 345 - error!("handle error: {}", e); 346 346 - } 347 347 - } 348 348 - Err(e) => error!("ssl error: {:?}", e), 349 349 - } 350 350 - }); 351 351 - } 352 352 - Err(e) => error!("tcp error: {:?}", e), 353 353 - } 354 354 - } 355 355 - 356 356 - Ok(()) 357 357 - } 358 358 - 359 359 - #[allow(clippy::too_many_lines)] 360 360 - async fn handle( 361 361 - &mut self, 362 362 - stream: &mut tokio_openssl::SslStream<tokio::net::TcpStream>, 363 363 - ) -> Result<(), Box<dyn std::error::Error>> { 364 364 - let mut buffer = [0u8; 1024]; 365 365 - let mut url = Url::parse("gemini://fuwn.me/")?; 366 366 - let mut response_status = 0; 367 367 - #[cfg(not(feature = "auto-deduce-mime"))] 368 368 - let mut response_mime_type = "".to_string(); 369 369 - let mut footer = String::new(); 370 370 - let mut header = String::new(); 371 371 - 372 372 - while let Ok(size) = stream.read(&mut buffer).await { 373 373 - let request = or_error!( 374 374 - stream, 375 375 - String::from_utf8(buffer[0..size].to_vec()), 376 376 - "59 The server (Windmark) received a bad request: {}" 377 377 - ); 378 378 - url = or_error!( 379 379 - stream, 380 380 - url::Url::parse(&request.replace("\r\n", "")), 381 381 - "59 The server (Windmark) received a bad request: {}" 382 382 - ); 383 383 - 384 384 - if request.contains("\r\n") { 385 385 - break; 386 386 - } 387 387 - } 388 388 - 389 389 - let fixed_path = if self.fix_path { 390 390 - self 391 391 - .routes 392 392 - .fix_path(if url.path().is_empty() { 393 393 - "/" 394 394 - } else { 395 395 - url.path() 396 396 - }) 397 397 - .unwrap_or_else(|| url.path().to_string()) 398 398 - } else { 399 399 - url.path().to_string() 400 400 - }; 401 401 - let route = &mut self.routes.at(&fixed_path); 402 402 - 403 403 - for module in &mut *self.modules.lock().unwrap() { 404 404 - module.on_pre_route(CallbackContext::new(stream.get_ref(), &url, { 405 405 - if let Ok(route) = &route { 406 406 - Some(&route.params) 407 407 - } else { 408 408 - None 409 409 - } 410 410 - })); 411 411 - } 412 412 - 413 413 - (*self.pre_route_callback).lock().unwrap().call_mut(( 414 414 - stream.get_ref(), 415 415 - &url, 416 416 - { 417 417 - if let Ok(route) = &route { 418 418 - Some(&route.params) 419 419 - } else { 420 420 - None 421 421 - } 422 422 - }, 423 423 - )); 424 424 - 425 425 - let content = if let Ok(ref route) = route { 426 426 - let footers_length = (*self.footers.lock().unwrap()).len(); 427 427 - 428 428 - for partial_header in &mut *self.headers.lock().unwrap() { 429 429 - header.push_str(&format!( 430 430 - "{}\n", 431 431 - partial_header(RouteContext::new( 432 432 - stream.get_ref(), 433 433 - &url, 434 434 - &route.params, 435 435 - )), 436 436 - )); 437 437 - } 438 438 - for (i, partial_footer) in 439 439 - (&mut *self.footers.lock().unwrap()).iter_mut().enumerate() 440 440 - { 441 441 - footer.push_str(&format!( 442 442 - "{}{}", 443 443 - partial_footer(RouteContext::new( 444 444 - stream.get_ref(), 445 445 - &url, 446 446 - &route.params, 447 447 - )), 448 448 - if footers_length > 1 && i != footers_length - 1 { 449 449 - "\n" 450 450 - } else { 451 451 - "" 452 452 - }, 453 453 - )); 454 454 - } 455 455 - to_value_set_status( 456 456 - (*route.value).lock().unwrap().call_mut((RouteContext::new( 457 457 - stream.get_ref(), 458 458 - &url, 459 459 - &route.params, 460 460 - ),)), 461 461 - &mut response_status, 462 462 - #[cfg(not(feature = "auto-deduce-mime"))] 463 463 - &mut response_mime_type, 464 464 - ) 465 465 - } else { 466 466 - to_value_set_status( 467 467 - (*self.error_handler) 468 468 - .lock() 469 469 - .unwrap() 470 470 - .call_mut((ErrorContext::new(stream.get_ref(), &url),)), 471 471 - &mut response_status, 472 472 - #[cfg(not(feature = "auto-deduce-mime"))] 473 473 - &mut response_mime_type, 474 474 - ) 475 475 - }; 476 476 - 477 477 - stream 478 478 - .write_all( 479 479 - format!( 480 480 - "{}{}\r\n{}", 481 481 - if response_status == 21 { 482 482 - 20 483 483 - } else { 484 484 - response_status 485 485 - }, 486 486 - match response_status { 487 487 - 20 => 488 488 - format!( 489 489 - " text/gemini; charset={}; lang={}", 490 490 - self.charset, self.language 491 491 - ), 492 492 - #[cfg(feature = "auto-deduce-mime")] 493 493 - 21 => format!(" {}", tree_magic::from_u8(&*content.as_bytes())), 494 494 - #[cfg(not(feature = "auto-deduce-mime"))] 495 495 - 21 => response_mime_type, 496 496 - _ => format!(" {}", content), 497 497 - }, 498 498 - match response_status { 499 499 - 20 => format!("{}{}\n{}", header, content, footer), 500 500 - 21 => content.to_string(), 501 501 - _ => "".to_string(), 502 502 - } 503 503 - ) 504 504 - .as_bytes(), 505 505 - ) 506 506 - .await?; 507 507 - 508 508 - for module in &mut *self.modules.lock().unwrap() { 509 509 - module.on_post_route(CallbackContext::new(stream.get_ref(), &url, { 510 510 - if let Ok(route) = &route { 511 511 - Some(&route.params) 512 512 - } else { 513 513 - None 514 514 - } 515 515 - })); 516 516 - } 517 517 - 518 518 - (*self.post_route_callback).lock().unwrap().call_mut(( 519 519 - stream.get_ref(), 520 520 - &url, 521 521 - { 522 522 - if let Ok(route) = &route { 523 523 - Some(&route.params) 524 524 - } else { 525 525 - None 526 526 - } 527 527 - }, 528 528 - )); 529 529 - 530 530 - stream.shutdown().await?; 531 531 - 532 532 - Ok(()) 533 533 - } 534 534 - 535 535 - fn create_acceptor(&mut self) -> Result<(), Box<dyn Error>> { 536 536 - let mut builder = SslAcceptor::mozilla_intermediate(ssl::SslMethod::tls())?; 537 537 - 538 538 - builder.set_private_key_file( 539 539 - &self.private_key_file_name, 540 540 - ssl::SslFiletype::PEM, 541 541 - )?; 542 542 - builder.set_certificate_file( 543 543 - &self.ca_file_name, 544 544 - openssl::ssl::SslFiletype::PEM, 545 545 - )?; 546 546 - builder.check_private_key()?; 547 547 - 548 548 - self.ssl_acceptor = Arc::new(builder.build()); 549 549 - 550 550 - Ok(()) 551 551 - } 552 552 - 553 553 - /// Use a self-made `SslAcceptor` 554 554 - /// 555 555 - /// # Examples 556 556 - /// 557 557 - /// ```rust 558 558 - /// use openssl::ssl; 559 559 - /// 560 560 - /// windmark::Router::new().set_ssl_acceptor({ 561 561 - /// let mut builder = 562 562 - /// ssl::SslAcceptor::mozilla_intermediate(ssl::SslMethod::tls()).unwrap(); 563 563 - /// 564 564 - /// builder 565 565 - /// .set_private_key_file("windmark_private.pem", ssl::SslFiletype::PEM) 566 566 - /// .unwrap(); 567 567 - /// builder 568 568 - /// .set_certificate_file( 569 569 - /// "windmark_public.pem", 570 570 - /// openssl::ssl::SslFiletype::PEM, 571 571 - /// ) 572 572 - /// .unwrap(); 573 573 - /// builder.check_private_key().unwrap(); 574 574 - /// 575 575 - /// builder.build() 576 576 - /// }); 577 577 - /// ``` 578 578 - pub fn set_ssl_acceptor(&mut self, ssl_acceptor: SslAcceptor) -> &mut Self { 579 579 - self.ssl_acceptor = Arc::new(ssl_acceptor); 580 580 - 581 581 - self 582 582 - } 583 583 - 584 584 - /// Enabled the default logger (the 585 585 - /// [`pretty_env_logger`](https://crates.io/crates/pretty_env_logger) and 586 586 - /// [`log`](https://crates.io/crates/log) crates). 587 587 - #[cfg(feature = "logger")] 588 588 - pub fn enable_default_logger(&mut self, enable: bool) -> &mut Self { 589 589 - self.default_logger = enable; 590 590 - std::env::set_var("RUST_LOG", "windmark=trace"); 591 591 - 592 592 - self 593 593 - } 594 594 - 595 595 - /// Set the default logger's log level. 596 596 - /// 597 597 - /// If you enable Windmark's default logger with `enable_default_logger`, 598 598 - /// Windmark will only log, logs from itself. By setting a log level with 599 599 - /// this method, you are overriding the default log level, so you must choose 600 600 - /// to enable logs from Windmark with the `log_windmark` parameter. 601 601 - /// 602 602 - /// Log level "language" is detailed 603 603 - /// [here](https://docs.rs/env_logger/0.9.0/env_logger/#enabling-logging). 604 604 - /// 605 605 - /// # Examples 606 606 - /// 607 607 - /// ```rust 608 608 - /// windmark::Router::new() 609 609 - /// .enable_default_logger(true) 610 610 - /// .set_log_level("your_crate_name=trace", true); 611 611 - /// // If you would only like to log, logs from your crate: 612 612 - /// // .set_log_level("your_crate_name=trace", false); 613 613 - /// ``` 614 614 - #[cfg(feature = "logger")] 615 615 - pub fn set_log_level( 616 616 - &mut self, 617 617 - log_level: &str, 618 618 - log_windmark: bool, 619 619 - ) -> &mut Self { 620 620 - std::env::set_var( 621 621 - "RUST_LOG", 622 622 - format!( 623 623 - "{}{}", 624 624 - if log_windmark { "windmark," } else { "" }, 625 625 - log_level 626 626 - ), 627 627 - ); 628 628 - 629 629 - self 630 630 - } 631 631 - 632 632 - /// Set a callback to run before a client response is delivered 633 633 - /// 634 634 - /// # Examples 635 635 - /// 636 636 - /// ```rust 637 637 - /// use log::info; 638 638 - /// 639 639 - /// windmark::Router::new().set_pre_route_callback(Box::new( 640 640 - /// |stream, _url, _| { 641 641 - /// info!( 642 642 - /// "accepted connection from {}", 643 643 - /// stream.peer_addr().unwrap().ip(), 644 644 - /// ) 645 645 - /// }, 646 646 - /// )); 647 647 - /// ``` 648 648 - pub fn set_pre_route_callback(&mut self, callback: Callback) -> &mut Self { 649 649 - self.pre_route_callback = Arc::new(Mutex::new(callback)); 650 650 - 651 651 - self 652 652 - } 653 653 - 654 654 - /// Set a callback to run after a client response is delivered 655 655 - /// 656 656 - /// # Examples 657 657 - /// 658 658 - /// ```rust 659 659 - /// use log::info; 660 660 - /// 661 661 - /// windmark::Router::new().set_post_route_callback(Box::new( 662 662 - /// |stream, _url, _| { 663 663 - /// info!( 664 664 - /// "closed connection from {}", 665 665 - /// stream.peer_addr().unwrap().ip(), 666 666 - /// ) 667 667 - /// }, 668 668 - /// )); 669 669 - /// ``` 670 670 - pub fn set_post_route_callback(&mut self, callback: Callback) -> &mut Self { 671 671 - self.post_route_callback = Arc::new(Mutex::new(callback)); 672 672 - 673 673 - self 674 674 - } 675 675 - 676 676 - /// Attach a stateless module to a `Router`. 677 677 - /// 678 678 - /// A module is an extension or middleware to a `Router`. Modules get full 679 679 - /// access to the `Router`, but can be extended by a third party. 680 680 - /// 681 681 - /// # Examples 682 682 - /// 683 683 - /// ## Integrated Module 684 684 - /// 685 685 - /// ```rust 686 686 - /// use windmark::Response; 687 687 - /// 688 688 - /// windmark::Router::new().attach_stateless(|r| { 689 689 - /// r.mount( 690 690 - /// "/module", 691 691 - /// Box::new(|_| Response::Success("This is a module!".into())), 692 692 - /// ); 693 693 - /// r.set_error_handler(Box::new(|_| { 694 694 - /// Response::NotFound( 695 695 - /// "This error handler has been implemented by a module!".into(), 696 696 - /// ) 697 697 - /// })); 698 698 - /// }); 699 699 - /// ``` 700 700 - /// 701 701 - /// ## External Module 702 702 - /// 703 703 - /// ```rust 704 704 - /// use windmark::Response; 705 705 - /// 706 706 - /// mod windmark_example { 707 707 - /// pub fn module(router: &mut windmark::Router) { 708 708 - /// router.mount( 709 709 - /// "/module", 710 710 - /// Box::new(|_| windmark::Response::Success("This is a module!".into())), 711 711 - /// ); 712 712 - /// } 713 713 - /// } 714 714 - /// 715 715 - /// windmark::Router::new().attach_stateless(windmark_example::module); 716 716 - /// ``` 717 717 - pub fn attach_stateless<F>(&mut self, mut module: F) -> &mut Self 718 718 - where F: FnMut(&mut Self) { 719 719 - module(self); 720 720 - 721 721 - self 722 722 - } 723 723 - 724 724 - /// Attach a stateful module to a `Router`. 725 725 - /// 726 726 - /// Like a stateless module is an extension or middleware to a `Router`. 727 727 - /// Modules get full access to the `Router` and can be extended by a third 728 728 - /// party, but also, can create hooks will be executed through various parts 729 729 - /// of a routes' lifecycle. Stateful modules also have state, so variables can 730 730 - /// be stored for further access. 731 731 - /// 732 732 - /// # Panics 733 733 - /// 734 734 - /// May panic if the stateful module cannot be attached. 735 735 - /// 736 736 - /// # Examples 737 737 - /// 738 738 - /// ```rust 739 739 - /// use log::info; 740 740 - /// use windmark::{returnable::CallbackContext, Response, Router}; 741 741 - /// 742 742 - /// #[derive(Default)] 743 743 - /// struct Clicker { 744 744 - /// clicks: isize, 745 745 - /// } 746 746 - /// impl windmark::Module for Clicker { 747 747 - /// fn on_attach(&mut self, _: &mut Router) { 748 748 - /// info!("clicker has been attached!"); 749 749 - /// } 750 750 - /// 751 751 - /// fn on_pre_route(&mut self, context: CallbackContext<'_>) { 752 752 - /// self.clicks += 1; 753 753 - /// 754 754 - /// info!( 755 755 - /// "clicker has been called pre-route on {} with {} clicks!", 756 756 - /// context.url.path(), 757 757 - /// self.clicks 758 758 - /// ); 759 759 - /// } 760 760 - /// 761 761 - /// fn on_post_route(&mut self, context: CallbackContext<'_>) { 762 762 - /// info!( 763 763 - /// "clicker has been called post-route on {} with {} clicks!", 764 764 - /// context.url.path(), 765 765 - /// self.clicks 766 766 - /// ); 767 767 - /// } 768 768 - /// } 769 769 - /// 770 770 - /// Router::new().attach(Clicker::default()); 771 771 - /// ``` 772 772 - pub fn attach( 773 773 - &mut self, 774 774 - mut module: impl Module + 'static + Send, 775 775 - ) -> &mut Self { 776 776 - module.on_attach(self); 777 777 - 778 778 - (*self.modules.lock().unwrap()).push(Box::new(module)); 779 779 - 780 780 - self 781 781 - } 782 782 - 783 783 - /// Specify a custom character set. 784 784 - /// 785 785 - /// Defaults to `"utf-8"`. 786 786 - /// 787 787 - /// # Examples 788 788 - /// 789 789 - /// ```rust 790 790 - /// windmark::Router::new().set_charset("utf-8"); 791 791 - /// ``` 792 792 - pub fn set_charset(&mut self, charset: &str) -> &mut Self { 793 793 - self.charset = charset.to_string(); 794 794 - 795 795 - self 796 796 - } 797 797 - 798 798 - /// Specify a custom language. 799 799 - /// 800 800 - /// Defaults to `"en"`. 801 801 - /// 802 802 - /// # Examples 803 803 - /// 804 804 - /// ```rust 805 805 - /// windmark::Router::new().set_language("en"); 806 806 - /// ``` 807 807 - pub fn set_language(&mut self, language: &str) -> &mut Self { 808 808 - self.language = language.to_string(); 809 809 - 810 810 - self 811 811 - } 812 812 - 813 813 - /// Specify a custom port. 814 814 - /// 815 815 - /// Defaults to `1965`. 816 816 - /// 817 817 - /// # Examples 818 818 - /// 819 819 - /// ```rust 820 820 - /// windmark::Router::new().set_port(1965); 821 821 - /// ``` 822 822 - pub fn set_port(&mut self, port: i32) -> &mut Self { 823 823 - self.port = port; 824 824 - 825 825 - self 826 826 - } 827 827 - 828 828 - /// Performs a case-insensitive lookup of routes, using the case corrected 829 829 - /// path if successful. Missing/ extra trailing slashes are also corrected. 830 830 - /// 831 831 - /// # Examples 832 832 - /// 833 833 - /// ```rust 834 834 - /// windmark::Router::new().set_fix_path(true); 835 835 - /// ``` 836 836 - pub fn set_fix_path(&mut self, fix_path: bool) -> &mut Self { 837 837 - self.fix_path = fix_path; 838 838 - 839 839 - self 840 840 - } 841 841 - } 842 842 - impl Default for Router { 843 843 - fn default() -> Self { 844 844 - Self { 845 845 - routes: matchit::Router::new(), 846 846 - error_handler: Arc::new(Mutex::new(Box::new(|_| { 847 847 - Response::NotFound( 848 848 - "This capsule has not implemented an error handler...".to_string(), 849 849 - ) 850 850 - }))), 851 851 - private_key_file_name: "".to_string(), 852 852 - ca_file_name: "".to_string(), 853 853 - headers: Arc::new(Mutex::new(vec![])), 854 854 - footers: Arc::new(Mutex::new(vec![])), 855 855 - ssl_acceptor: Arc::new( 856 856 - SslAcceptor::mozilla_intermediate(SslMethod::tls()) 857 857 - .unwrap() 858 858 - .build(), 859 859 - ), 860 860 - #[cfg(feature = "logger")] 861 861 - default_logger: false, 862 862 - pre_route_callback: Arc::new(Mutex::new(Box::new(|_, _, _| {}))), 863 863 - post_route_callback: Arc::new(Mutex::new(Box::new(|_, _, _| {}))), 864 864 - charset: "utf-8".to_string(), 865 865 - language: "en".to_string(), 866 866 - port: 1965, 867 867 - modules: Arc::new(Mutex::new(vec![])), 868 868 - fix_path: false, 869 869 - } 870 870 - } 871 871 - }

+769

src/router.rs

reviewed

··· 1 1 + // This file is part of Windmark <https://github.com/gemrest/windmark>. 2 2 + // Copyright (C) 2022-2022 Fuwn <contact@fuwn.me> 3 3 + // 4 4 + // This program is free software: you can redistribute it and/or modify 5 5 + // it under the terms of the GNU General Public License as published by 6 6 + // the Free Software Foundation, version 3. 7 7 + // 8 8 + // This program is distributed in the hope that it will be useful, but 9 9 + // WITHOUT ANY WARRANTY; without even the implied warranty of 10 10 + // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 11 + // General Public License for more details. 12 12 + // 13 13 + // You should have received a copy of the GNU General Public License 14 14 + // along with this program. If not, see <http://www.gnu.org/licenses/>. 15 15 + // 16 16 + // Copyright (C) 2022-2022 Fuwn <contact@fuwn.me> 17 17 + // SPDX-License-Identifier: GPL-3.0-only 18 18 + 19 19 + use std::{ 20 20 + error::Error, 21 21 + sync::{Arc, Mutex}, 22 22 + }; 23 23 + 24 24 + use openssl::ssl::{self, SslAcceptor, SslMethod}; 25 25 + use tokio::{ 26 26 + io::{AsyncReadExt, AsyncWriteExt}, 27 27 + stream::StreamExt, 28 28 + }; 29 29 + use url::Url; 30 30 + 31 31 + use crate::{ 32 32 + handler::{Callback, ErrorResponse, Partial, RouteResponse}, 33 33 + module::Module, 34 34 + response::{to_value_set_status, Response}, 35 35 + returnable::{CallbackContext, ErrorContext, RouteContext}, 36 36 + }; 37 37 + 38 38 + macro_rules! or_error { 39 39 + ($stream:ident, $operation:expr, $error_format:literal) => { 40 40 + match $operation { 41 41 + Ok(u) => u, 42 42 + Err(e) => { 43 43 + $stream 44 44 + .write_all(format!($error_format, e).as_bytes()) 45 45 + .await?; 46 46 + 47 47 + $stream.shutdown().await?; 48 48 + 49 49 + return Ok(()); 50 50 + } 51 51 + } 52 52 + }; 53 53 + } 54 54 + 55 55 + /// A router which takes care of all tasks a Windmark server should handle: 56 56 + /// response generation, panics, logging, and more. 57 57 + #[derive(Clone)] 58 58 + pub struct Router { 59 59 + routes: matchit::Router<Arc<Mutex<RouteResponse>>>, 60 60 + error_handler: Arc<Mutex<ErrorResponse>>, 61 61 + private_key_file_name: String, 62 62 + ca_file_name: String, 63 63 + headers: Arc<Mutex<Vec<Partial>>>, 64 64 + footers: Arc<Mutex<Vec<Partial>>>, 65 65 + ssl_acceptor: Arc<SslAcceptor>, 66 66 + #[cfg(feature = "logger")] 67 67 + default_logger: bool, 68 68 + pre_route_callback: Arc<Mutex<Callback>>, 69 69 + post_route_callback: Arc<Mutex<Callback>>, 70 70 + charset: String, 71 71 + language: String, 72 72 + port: i32, 73 73 + modules: Arc<Mutex<Vec<Box<dyn Module + Send>>>>, 74 74 + fix_path: bool, 75 75 + } 76 76 + impl Router { 77 77 + /// Create a new `Router` 78 78 + /// 79 79 + /// # Examples 80 80 + /// 81 81 + /// ```rust 82 82 + /// let _router = windmark::Router::new(); 83 83 + /// ``` 84 84 + /// 85 85 + /// # Panics 86 86 + /// 87 87 + /// if a default `SslAcceptor` could not be built. 88 88 + #[must_use] 89 89 + pub fn new() -> Self { Self::default() } 90 90 + 91 91 + /// Set the filename of the private key file. 92 92 + /// 93 93 + /// # Examples 94 94 + /// 95 95 + /// ```rust 96 96 + /// windmark::Router::new().set_private_key_file("windmark_private.pem"); 97 97 + /// ``` 98 98 + pub fn set_private_key_file( 99 99 + &mut self, 100 100 + private_key_file_name: &str, 101 101 + ) -> &mut Self { 102 102 + self.private_key_file_name = private_key_file_name.to_string(); 103 103 + 104 104 + self 105 105 + } 106 106 + 107 107 + /// Set the filename of the certificate chain file. 108 108 + /// 109 109 + /// # Examples 110 110 + /// 111 111 + /// ```rust 112 112 + /// windmark::Router::new().set_certificate_file("windmark_public.pem"); 113 113 + /// ``` 114 114 + pub fn set_certificate_file(&mut self, certificate_name: &str) -> &mut Self { 115 115 + self.ca_file_name = certificate_name.to_string(); 116 116 + 117 117 + self 118 118 + } 119 119 + 120 120 + /// Map routes to URL paths 121 121 + /// 122 122 + /// # Examples 123 123 + /// 124 124 + /// ```rust 125 125 + /// use windmark::Response; 126 126 + /// 127 127 + /// windmark::Router::new() 128 128 + /// .mount( 129 129 + /// "/", 130 130 + /// Box::new(|_| Response::Success("This is the index page!".into())), 131 131 + /// ) 132 132 + /// .mount( 133 133 + /// "/test", 134 134 + /// Box::new(|_| Response::Success("This is a test page!".into())), 135 135 + /// ); 136 136 + /// ``` 137 137 + /// 138 138 + /// # Panics 139 139 + /// 140 140 + /// if the route cannot be mounted. 141 141 + pub fn mount(&mut self, route: &str, handler: RouteResponse) -> &mut Self { 142 142 + self 143 143 + .routes 144 144 + .insert(route, Arc::new(Mutex::new(handler))) 145 145 + .unwrap(); 146 146 + 147 147 + self 148 148 + } 149 149 + 150 150 + /// Create an error handler which will be displayed on any error. 151 151 + /// 152 152 + /// # Examples 153 153 + /// 154 154 + /// ```rust 155 155 + /// windmark::Router::new().set_error_handler(Box::new(|_| { 156 156 + /// windmark::Response::Success("You have encountered an error!".into()) 157 157 + /// })); 158 158 + /// ``` 159 159 + pub fn set_error_handler(&mut self, handler: ErrorResponse) -> &mut Self { 160 160 + self.error_handler = Arc::new(Mutex::new(handler)); 161 161 + 162 162 + self 163 163 + } 164 164 + 165 165 + /// Add a header for the `Router` which should be displayed on every route. 166 166 + /// 167 167 + /// # Panics 168 168 + /// 169 169 + /// May panic if the header cannot be added. 170 170 + /// 171 171 + /// # Examples 172 172 + /// 173 173 + /// ```rust 174 174 + /// windmark::Router::new().add_header(Box::new(|context| { 175 175 + /// format!("This is displayed at the top of {}!", context.url.path()) 176 176 + /// })); 177 177 + /// ``` 178 178 + pub fn add_header(&mut self, handler: Partial) -> &mut Self { 179 179 + (*self.headers.lock().unwrap()).push(handler); 180 180 + 181 181 + self 182 182 + } 183 183 + 184 184 + /// Add a footer for the `Router` which should be displayed on every route. 185 185 + /// 186 186 + /// # Panics 187 187 + /// 188 188 + /// May panic if the header cannot be added. 189 189 + /// 190 190 + /// # Examples 191 191 + /// 192 192 + /// ```rust 193 193 + /// windmark::Router::new().add_footer(Box::new(|context| { 194 194 + /// format!("This is displayed at the bottom of {}!", context.url.path()) 195 195 + /// })); 196 196 + /// ``` 197 197 + pub fn add_footer(&mut self, handler: Partial) -> &mut Self { 198 198 + (*self.footers.lock().unwrap()).push(handler); 199 199 + 200 200 + self 201 201 + } 202 202 + 203 203 + /// Run the `Router` and wait for requests 204 204 + /// 205 205 + /// # Examples 206 206 + /// 207 207 + /// ```rust 208 208 + /// windmark::Router::new().run(); 209 209 + /// ``` 210 210 + /// 211 211 + /// # Panics 212 212 + /// 213 213 + /// if the client could not be accepted. 214 214 + /// 215 215 + /// # Errors 216 216 + /// 217 217 + /// if the `TcpListener` could not be bound. 218 218 + pub async fn run(&mut self) -> Result<(), Box<dyn Error>> { 219 219 + self.create_acceptor()?; 220 220 + 221 221 + #[cfg(feature = "logger")] 222 222 + if self.default_logger { 223 223 + pretty_env_logger::init(); 224 224 + } 225 225 + 226 226 + let acceptor = self.ssl_acceptor.clone(); 227 227 + let mut listener = 228 228 + tokio::net::TcpListener::bind(format!("0.0.0.0:{}", self.port)).await?; 229 229 + 230 230 + #[cfg(feature = "logger")] 231 231 + info!("windmark is listening for connections"); 232 232 + 233 233 + while let Some(stream) = listener.incoming().next().await { 234 234 + match stream { 235 235 + Ok(stream) => { 236 236 + let acceptor = acceptor.clone(); 237 237 + let mut self_clone = self.clone(); 238 238 + 239 239 + tokio::spawn(async move { 240 240 + match tokio_openssl::accept(&acceptor, stream).await { 241 241 + Ok(mut stream) => { 242 242 + if let Err(e) = self_clone.handle(&mut stream).await { 243 243 + error!("handle error: {}", e); 244 244 + } 245 245 + } 246 246 + Err(e) => error!("ssl error: {:?}", e), 247 247 + } 248 248 + }); 249 249 + } 250 250 + Err(e) => error!("tcp error: {:?}", e), 251 251 + } 252 252 + } 253 253 + 254 254 + Ok(()) 255 255 + } 256 256 + 257 257 + #[allow(clippy::too_many_lines)] 258 258 + async fn handle( 259 259 + &mut self, 260 260 + stream: &mut tokio_openssl::SslStream<tokio::net::TcpStream>, 261 261 + ) -> Result<(), Box<dyn std::error::Error>> { 262 262 + let mut buffer = [0u8; 1024]; 263 263 + let mut url = Url::parse("gemini://fuwn.me/")?; 264 264 + let mut response_status = 0; 265 265 + #[cfg(not(feature = "auto-deduce-mime"))] 266 266 + let mut response_mime_type = "".to_string(); 267 267 + let mut footer = String::new(); 268 268 + let mut header = String::new(); 269 269 + 270 270 + while let Ok(size) = stream.read(&mut buffer).await { 271 271 + let request = or_error!( 272 272 + stream, 273 273 + String::from_utf8(buffer[0..size].to_vec()), 274 274 + "59 The server (Windmark) received a bad request: {}" 275 275 + ); 276 276 + url = or_error!( 277 277 + stream, 278 278 + url::Url::parse(&request.replace("\r\n", "")), 279 279 + "59 The server (Windmark) received a bad request: {}" 280 280 + ); 281 281 + 282 282 + if request.contains("\r\n") { 283 283 + break; 284 284 + } 285 285 + } 286 286 + 287 287 + let fixed_path = if self.fix_path { 288 288 + self 289 289 + .routes 290 290 + .fix_path(if url.path().is_empty() { 291 291 + "/" 292 292 + } else { 293 293 + url.path() 294 294 + }) 295 295 + .unwrap_or_else(|| url.path().to_string()) 296 296 + } else { 297 297 + url.path().to_string() 298 298 + }; 299 299 + let route = &mut self.routes.at(&fixed_path); 300 300 + 301 301 + for module in &mut *self.modules.lock().unwrap() { 302 302 + module.on_pre_route(CallbackContext::new(stream.get_ref(), &url, { 303 303 + if let Ok(route) = &route { 304 304 + Some(&route.params) 305 305 + } else { 306 306 + None 307 307 + } 308 308 + })); 309 309 + } 310 310 + 311 311 + (*self.pre_route_callback).lock().unwrap().call_mut(( 312 312 + stream.get_ref(), 313 313 + &url, 314 314 + { 315 315 + if let Ok(route) = &route { 316 316 + Some(&route.params) 317 317 + } else { 318 318 + None 319 319 + } 320 320 + }, 321 321 + )); 322 322 + 323 323 + let content = if let Ok(ref route) = route { 324 324 + let footers_length = (*self.footers.lock().unwrap()).len(); 325 325 + 326 326 + for partial_header in &mut *self.headers.lock().unwrap() { 327 327 + header.push_str(&format!( 328 328 + "{}\n", 329 329 + partial_header(RouteContext::new( 330 330 + stream.get_ref(), 331 331 + &url, 332 332 + &route.params, 333 333 + )), 334 334 + )); 335 335 + } 336 336 + for (i, partial_footer) in 337 337 + (&mut *self.footers.lock().unwrap()).iter_mut().enumerate() 338 338 + { 339 339 + footer.push_str(&format!( 340 340 + "{}{}", 341 341 + partial_footer(RouteContext::new( 342 342 + stream.get_ref(), 343 343 + &url, 344 344 + &route.params, 345 345 + )), 346 346 + if footers_length > 1 && i != footers_length - 1 { 347 347 + "\n" 348 348 + } else { 349 349 + "" 350 350 + }, 351 351 + )); 352 352 + } 353 353 + to_value_set_status( 354 354 + (*route.value).lock().unwrap().call_mut((RouteContext::new( 355 355 + stream.get_ref(), 356 356 + &url, 357 357 + &route.params, 358 358 + ),)), 359 359 + &mut response_status, 360 360 + #[cfg(not(feature = "auto-deduce-mime"))] 361 361 + &mut response_mime_type, 362 362 + ) 363 363 + } else { 364 364 + to_value_set_status( 365 365 + (*self.error_handler) 366 366 + .lock() 367 367 + .unwrap() 368 368 + .call_mut((ErrorContext::new(stream.get_ref(), &url),)), 369 369 + &mut response_status, 370 370 + #[cfg(not(feature = "auto-deduce-mime"))] 371 371 + &mut response_mime_type, 372 372 + ) 373 373 + }; 374 374 + 375 375 + stream 376 376 + .write_all( 377 377 + format!( 378 378 + "{}{}\r\n{}", 379 379 + if response_status == 21 { 380 380 + 20 381 381 + } else { 382 382 + response_status 383 383 + }, 384 384 + match response_status { 385 385 + 20 => 386 386 + format!( 387 387 + " text/gemini; charset={}; lang={}", 388 388 + self.charset, self.language 389 389 + ), 390 390 + #[cfg(feature = "auto-deduce-mime")] 391 391 + 21 => format!(" {}", tree_magic::from_u8(&*content.as_bytes())), 392 392 + #[cfg(not(feature = "auto-deduce-mime"))] 393 393 + 21 => response_mime_type, 394 394 + _ => format!(" {}", content), 395 395 + }, 396 396 + match response_status { 397 397 + 20 => format!("{}{}\n{}", header, content, footer), 398 398 + 21 => content.to_string(), 399 399 + _ => "".to_string(), 400 400 + } 401 401 + ) 402 402 + .as_bytes(), 403 403 + ) 404 404 + .await?; 405 405 + 406 406 + for module in &mut *self.modules.lock().unwrap() { 407 407 + module.on_post_route(CallbackContext::new(stream.get_ref(), &url, { 408 408 + if let Ok(route) = &route { 409 409 + Some(&route.params) 410 410 + } else { 411 411 + None 412 412 + } 413 413 + })); 414 414 + } 415 415 + 416 416 + (*self.post_route_callback).lock().unwrap().call_mut(( 417 417 + stream.get_ref(), 418 418 + &url, 419 419 + { 420 420 + if let Ok(route) = &route { 421 421 + Some(&route.params) 422 422 + } else { 423 423 + None 424 424 + } 425 425 + }, 426 426 + )); 427 427 + 428 428 + stream.shutdown().await?; 429 429 + 430 430 + Ok(()) 431 431 + } 432 432 + 433 433 + fn create_acceptor(&mut self) -> Result<(), Box<dyn Error>> { 434 434 + let mut builder = SslAcceptor::mozilla_intermediate(ssl::SslMethod::tls())?; 435 435 + 436 436 + builder.set_private_key_file( 437 437 + &self.private_key_file_name, 438 438 + ssl::SslFiletype::PEM, 439 439 + )?; 440 440 + builder.set_certificate_file( 441 441 + &self.ca_file_name, 442 442 + openssl::ssl::SslFiletype::PEM, 443 443 + )?; 444 444 + builder.check_private_key()?; 445 445 + 446 446 + self.ssl_acceptor = Arc::new(builder.build()); 447 447 + 448 448 + Ok(()) 449 449 + } 450 450 + 451 451 + /// Use a self-made `SslAcceptor` 452 452 + /// 453 453 + /// # Examples 454 454 + /// 455 455 + /// ```rust 456 456 + /// use openssl::ssl; 457 457 + /// 458 458 + /// windmark::Router::new().set_ssl_acceptor({ 459 459 + /// let mut builder = 460 460 + /// ssl::SslAcceptor::mozilla_intermediate(ssl::SslMethod::tls()).unwrap(); 461 461 + /// 462 462 + /// builder 463 463 + /// .set_private_key_file("windmark_private.pem", ssl::SslFiletype::PEM) 464 464 + /// .unwrap(); 465 465 + /// builder 466 466 + /// .set_certificate_file( 467 467 + /// "windmark_public.pem", 468 468 + /// openssl::ssl::SslFiletype::PEM, 469 469 + /// ) 470 470 + /// .unwrap(); 471 471 + /// builder.check_private_key().unwrap(); 472 472 + /// 473 473 + /// builder.build() 474 474 + /// }); 475 475 + /// ``` 476 476 + pub fn set_ssl_acceptor(&mut self, ssl_acceptor: SslAcceptor) -> &mut Self { 477 477 + self.ssl_acceptor = Arc::new(ssl_acceptor); 478 478 + 479 479 + self 480 480 + } 481 481 + 482 482 + /// Enabled the default logger (the 483 483 + /// [`pretty_env_logger`](https://crates.io/crates/pretty_env_logger) and 484 484 + /// [`log`](https://crates.io/crates/log) crates). 485 485 + #[cfg(feature = "logger")] 486 486 + pub fn enable_default_logger(&mut self, enable: bool) -> &mut Self { 487 487 + self.default_logger = enable; 488 488 + std::env::set_var("RUST_LOG", "windmark=trace"); 489 489 + 490 490 + self 491 491 + } 492 492 + 493 493 + /// Set the default logger's log level. 494 494 + /// 495 495 + /// If you enable Windmark's default logger with `enable_default_logger`, 496 496 + /// Windmark will only log, logs from itself. By setting a log level with 497 497 + /// this method, you are overriding the default log level, so you must choose 498 498 + /// to enable logs from Windmark with the `log_windmark` parameter. 499 499 + /// 500 500 + /// Log level "language" is detailed 501 501 + /// [here](https://docs.rs/env_logger/0.9.0/env_logger/#enabling-logging). 502 502 + /// 503 503 + /// # Examples 504 504 + /// 505 505 + /// ```rust 506 506 + /// windmark::Router::new() 507 507 + /// .enable_default_logger(true) 508 508 + /// .set_log_level("your_crate_name=trace", true); 509 509 + /// // If you would only like to log, logs from your crate: 510 510 + /// // .set_log_level("your_crate_name=trace", false); 511 511 + /// ``` 512 512 + #[cfg(feature = "logger")] 513 513 + pub fn set_log_level( 514 514 + &mut self, 515 515 + log_level: &str, 516 516 + log_windmark: bool, 517 517 + ) -> &mut Self { 518 518 + std::env::set_var( 519 519 + "RUST_LOG", 520 520 + format!( 521 521 + "{}{}", 522 522 + if log_windmark { "windmark," } else { "" }, 523 523 + log_level 524 524 + ), 525 525 + ); 526 526 + 527 527 + self 528 528 + } 529 529 + 530 530 + /// Set a callback to run before a client response is delivered 531 531 + /// 532 532 + /// # Examples 533 533 + /// 534 534 + /// ```rust 535 535 + /// use log::info; 536 536 + /// 537 537 + /// windmark::Router::new().set_pre_route_callback(Box::new( 538 538 + /// |stream, _url, _| { 539 539 + /// info!( 540 540 + /// "accepted connection from {}", 541 541 + /// stream.peer_addr().unwrap().ip(), 542 542 + /// ) 543 543 + /// }, 544 544 + /// )); 545 545 + /// ``` 546 546 + pub fn set_pre_route_callback(&mut self, callback: Callback) -> &mut Self { 547 547 + self.pre_route_callback = Arc::new(Mutex::new(callback)); 548 548 + 549 549 + self 550 550 + } 551 551 + 552 552 + /// Set a callback to run after a client response is delivered 553 553 + /// 554 554 + /// # Examples 555 555 + /// 556 556 + /// ```rust 557 557 + /// use log::info; 558 558 + /// 559 559 + /// windmark::Router::new().set_post_route_callback(Box::new( 560 560 + /// |stream, _url, _| { 561 561 + /// info!( 562 562 + /// "closed connection from {}", 563 563 + /// stream.peer_addr().unwrap().ip(), 564 564 + /// ) 565 565 + /// }, 566 566 + /// )); 567 567 + /// ``` 568 568 + pub fn set_post_route_callback(&mut self, callback: Callback) -> &mut Self { 569 569 + self.post_route_callback = Arc::new(Mutex::new(callback)); 570 570 + 571 571 + self 572 572 + } 573 573 + 574 574 + /// Attach a stateless module to a `Router`. 575 575 + /// 576 576 + /// A module is an extension or middleware to a `Router`. Modules get full 577 577 + /// access to the `Router`, but can be extended by a third party. 578 578 + /// 579 579 + /// # Examples 580 580 + /// 581 581 + /// ## Integrated Module 582 582 + /// 583 583 + /// ```rust 584 584 + /// use windmark::Response; 585 585 + /// 586 586 + /// windmark::Router::new().attach_stateless(|r| { 587 587 + /// r.mount( 588 588 + /// "/module", 589 589 + /// Box::new(|_| Response::Success("This is a module!".into())), 590 590 + /// ); 591 591 + /// r.set_error_handler(Box::new(|_| { 592 592 + /// Response::NotFound( 593 593 + /// "This error handler has been implemented by a module!".into(), 594 594 + /// ) 595 595 + /// })); 596 596 + /// }); 597 597 + /// ``` 598 598 + /// 599 599 + /// ## External Module 600 600 + /// 601 601 + /// ```rust 602 602 + /// use windmark::Response; 603 603 + /// 604 604 + /// mod windmark_example { 605 605 + /// pub fn module(router: &mut windmark::Router) { 606 606 + /// router.mount( 607 607 + /// "/module", 608 608 + /// Box::new(|_| windmark::Response::Success("This is a module!".into())), 609 609 + /// ); 610 610 + /// } 611 611 + /// } 612 612 + /// 613 613 + /// windmark::Router::new().attach_stateless(windmark_example::module); 614 614 + /// ``` 615 615 + pub fn attach_stateless<F>(&mut self, mut module: F) -> &mut Self 616 616 + where F: FnMut(&mut Self) { 617 617 + module(self); 618 618 + 619 619 + self 620 620 + } 621 621 + 622 622 + /// Attach a stateful module to a `Router`. 623 623 + /// 624 624 + /// Like a stateless module is an extension or middleware to a `Router`. 625 625 + /// Modules get full access to the `Router` and can be extended by a third 626 626 + /// party, but also, can create hooks will be executed through various parts 627 627 + /// of a routes' lifecycle. Stateful modules also have state, so variables can 628 628 + /// be stored for further access. 629 629 + /// 630 630 + /// # Panics 631 631 + /// 632 632 + /// May panic if the stateful module cannot be attached. 633 633 + /// 634 634 + /// # Examples 635 635 + /// 636 636 + /// ```rust 637 637 + /// use log::info; 638 638 + /// use windmark::{returnable::CallbackContext, Response, Router}; 639 639 + /// 640 640 + /// #[derive(Default)] 641 641 + /// struct Clicker { 642 642 + /// clicks: isize, 643 643 + /// } 644 644 + /// impl windmark::Module for Clicker { 645 645 + /// fn on_attach(&mut self, _: &mut Router) { 646 646 + /// info!("clicker has been attached!"); 647 647 + /// } 648 648 + /// 649 649 + /// fn on_pre_route(&mut self, context: CallbackContext<'_>) { 650 650 + /// self.clicks += 1; 651 651 + /// 652 652 + /// info!( 653 653 + /// "clicker has been called pre-route on {} with {} clicks!", 654 654 + /// context.url.path(), 655 655 + /// self.clicks 656 656 + /// ); 657 657 + /// } 658 658 + /// 659 659 + /// fn on_post_route(&mut self, context: CallbackContext<'_>) { 660 660 + /// info!( 661 661 + /// "clicker has been called post-route on {} with {} clicks!", 662 662 + /// context.url.path(), 663 663 + /// self.clicks 664 664 + /// ); 665 665 + /// } 666 666 + /// } 667 667 + /// 668 668 + /// Router::new().attach(Clicker::default()); 669 669 + /// ``` 670 670 + pub fn attach( 671 671 + &mut self, 672 672 + mut module: impl Module + 'static + Send, 673 673 + ) -> &mut Self { 674 674 + module.on_attach(self); 675 675 + 676 676 + (*self.modules.lock().unwrap()).push(Box::new(module)); 677 677 + 678 678 + self 679 679 + } 680 680 + 681 681 + /// Specify a custom character set. 682 682 + /// 683 683 + /// Defaults to `"utf-8"`. 684 684 + /// 685 685 + /// # Examples 686 686 + /// 687 687 + /// ```rust 688 688 + /// windmark::Router::new().set_charset("utf-8"); 689 689 + /// ``` 690 690 + pub fn set_charset(&mut self, charset: &str) -> &mut Self { 691 691 + self.charset = charset.to_string(); 692 692 + 693 693 + self 694 694 + } 695 695 + 696 696 + /// Specify a custom language. 697 697 + /// 698 698 + /// Defaults to `"en"`. 699 699 + /// 700 700 + /// # Examples 701 701 + /// 702 702 + /// ```rust 703 703 + /// windmark::Router::new().set_language("en"); 704 704 + /// ``` 705 705 + pub fn set_language(&mut self, language: &str) -> &mut Self { 706 706 + self.language = language.to_string(); 707 707 + 708 708 + self 709 709 + } 710 710 + 711 711 + /// Specify a custom port. 712 712 + /// 713 713 + /// Defaults to `1965`. 714 714 + /// 715 715 + /// # Examples 716 716 + /// 717 717 + /// ```rust 718 718 + /// windmark::Router::new().set_port(1965); 719 719 + /// ``` 720 720 + pub fn set_port(&mut self, port: i32) -> &mut Self { 721 721 + self.port = port; 722 722 + 723 723 + self 724 724 + } 725 725 + 726 726 + /// Performs a case-insensitive lookup of routes, using the case corrected 727 727 + /// path if successful. Missing/ extra trailing slashes are also corrected. 728 728 + /// 729 729 + /// # Examples 730 730 + /// 731 731 + /// ```rust 732 732 + /// windmark::Router::new().set_fix_path(true); 733 733 + /// ``` 734 734 + pub fn set_fix_path(&mut self, fix_path: bool) -> &mut Self { 735 735 + self.fix_path = fix_path; 736 736 + 737 737 + self 738 738 + } 739 739 + } 740 740 + impl Default for Router { 741 741 + fn default() -> Self { 742 742 + Self { 743 743 + routes: matchit::Router::new(), 744 744 + error_handler: Arc::new(Mutex::new(Box::new(|_| { 745 745 + Response::NotFound( 746 746 + "This capsule has not implemented an error handler...".to_string(), 747 747 + ) 748 748 + }))), 749 749 + private_key_file_name: "".to_string(), 750 750 + ca_file_name: "".to_string(), 751 751 + headers: Arc::new(Mutex::new(vec![])), 752 752 + footers: Arc::new(Mutex::new(vec![])), 753 753 + ssl_acceptor: Arc::new( 754 754 + SslAcceptor::mozilla_intermediate(SslMethod::tls()) 755 755 + .unwrap() 756 756 + .build(), 757 757 + ), 758 758 + #[cfg(feature = "logger")] 759 759 + default_logger: false, 760 760 + pre_route_callback: Arc::new(Mutex::new(Box::new(|_, _, _| {}))), 761 761 + post_route_callback: Arc::new(Mutex::new(Box::new(|_, _, _| {}))), 762 762 + charset: "utf-8".to_string(), 763 763 + language: "en".to_string(), 764 764 + port: 1965, 765 765 + modules: Arc::new(Mutex::new(vec![])), 766 766 + fix_path: false, 767 767 + } 768 768 + } 769 769 + }