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
//! The Apollo framework is a toolkit for building stable and robust server software.
//!
//! **Apollo** was extracted out of [Jupiter](https://github.com/scireum/jupiter) to make its
//! core parse usable by other libraries or applications.
//!
//! Apollo provides a small **dependency injection helper** called *Platform** along with some
//! tooling to setup logging, format messages and to react on signals. This is commonly required
//! to properly run inside a Docker container.
#![deny(
warnings,
missing_docs,
trivial_casts,
trivial_numeric_casts,
unused_extern_crates,
unused_import_braces,
unused_results
)]
use simplelog::{ConfigBuilder, LevelFilter, SimpleLogger};
use std::sync::Once;
pub mod average;
pub mod config;
pub mod fmt;
pub mod platform;
pub mod server;
pub mod signals;
/// Contains the version of the Apollo framework.
pub const APOLLO_VERSION: &str = "1.0.3";
/// Contains the git commit hash of the Apollo build being used.
pub const APOLLO_REVISION: &str = "2254d3eb4cf2a97287c07b0655ad504a58e20fbc";
/// Initializes the logging system.
///
/// This uses the simple logger crate with a logging format which is compatible with docker
/// environments and quite well readable by common tools.
pub fn init_logging() {
static INIT_LOGGING: Once = Once::new();
static DATE_FORMAT: &str = "[%Y-%m-%dT%H:%M:%S%.3f]";
// We need to do this as otherwise the integration tests might crash as the logging system
// is initialized several times...
INIT_LOGGING.call_once(|| {
if let Err(error) = SimpleLogger::init(
LevelFilter::Debug,
ConfigBuilder::new()
.set_time_format_str(DATE_FORMAT)
.set_thread_level(LevelFilter::Trace)
.set_target_level(LevelFilter::Error)
.set_location_level(LevelFilter::Trace)
.build(),
) {
panic!("Failed to initialize logging system: {}", error);
}
});
}
#[cfg(test)]
mod testing {
use std::sync::Mutex;
lazy_static::lazy_static! {
/// Provides a global lock which has to be acquired if a test operates on shared
/// resources. This would either be our test port (1503) on which we start our
/// local server for integrations tests or the repository which operates on the
/// file system. Using this lock, we can still execute all other tests in parallel
/// and only block if required.
pub static ref SHARED_TEST_RESOURCES: Mutex<()> = Mutex::new(());
}
/// Executes async code within a single threaded tokio runtime.
pub fn test_async<F: std::future::Future>(future: F) {
use tokio::runtime;
let rt = runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
let _ = rt.block_on(future);
}
}