You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: main.rs
    path of file: ./repos/skytable/server/src
    
    the code of the file until where you have to start completion: /*
 * Created on Thu Jul 02 2020
 *
 * This file is a part of Skytable
 * Skytable (formerly known as TerrabaseDB or Skybase) is a free and open-source
 * NoSQL database written by Sayan Nandan ("the Author") with the
 * vision to provide flexibility in data modelling without compromising
 * on performance, queryability or scalability.
 *
 * Co
    
fn entrypoint(config: engine::config::Configuration) {
    println!("{TEXT}\nSkytable v{VERSION} | {URL}\n");
    let run = || {
        let f_rt_start = || {
            engine::set_context_init("locking PID file");
            let pid_file = util::os::FileLock::new(SKY_PID_FILE)?;
            engine::set_context_init("initializing runtime");
            let runtime = tokio::runtime::Builder::new_multi_thread()
                .thread_name("server")
                .enable_all()
                .build()?;
            Ok((pid_file, runtime))
        };
        let (pid_file, runtime) = match f_rt_start() {
            Ok((pf, rt)) => (pf, rt),
            Err(e) => return (None, None, Err(e)),
        };
        let f_glob_init = runtime.block_on(async move {
            engine::set_context_init("binding system signals");
            let signal = util::os::TerminationSignal::init()?;
            let (config, global) = tokio::task::spawn_blocking(|| engine::load_all(config))
                .await
                .unwrap()?;
            engine::RuntimeResult::Ok((signal, config, global))
        });
        let (signal, config, global) = match f_glob_init {
            Ok((sig, cfg, g)) => (sig, cfg, g),
            Err(e) => return (Some(pid_file), None, Err(e)),
        };
        let g = global.global.clone();
        let result_start =
            runtime.block_on(async move { engine::start(signal, config, global).await });
        (Some(pid_file), Some(g), result_start)
    };
    let (pid_file, global, result) = run();
    if let Some(g) = global {
        info!("cleaning up data");
        engine::finish(g);
    }
    if let Some(_) = pid_file {
        if let Err(e) = std::fs::remove_file(SKY_PID_FILE) {
            error!("failed to remove PID file: {e}");
        }
    }
    match result {
        Ok(()) => println!("goodbye"),
        Err(e) => exit_fatal!(error!("{e}")),
    }
}