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/cita/cita-auth/src
    
    the code of the file until where you have to start completion: // Copyright Rivtower Technologies LLC.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! # Summary
//!
//!   One of CITA's core components, transaction pool management,
//!   packaging transactions to consensus modules, verifying the va
    
fn main() {
    // init app
    let matches = App::new("auth")
        .version(get_build_info_str(true))
        .long_version(get_build_info_str(false))
        .author("Rivtower")
        .about("CITA Block Chain Node powered by Rust")
        .args_from_usage(
            "-c, --config=[FILE] 'Sets a custom config file'
                          -s, --stdout 'Log to console'",
        )
        .get_matches();

    let stdout = matches.is_present("stdout");
    micro_service_init!("cita-auth", "CITA:auth", stdout);
    info!("Version: {}", get_build_info_str(true));

    let config_path = matches.value_of("config").unwrap_or("auth.toml");

    let config = Config::new(config_path);

    let count_per_batch = config.count_per_batch;
    let buffer_duration = config.buffer_duration;
    let tx_verify_thread_num = config.tx_verify_thread_num;
    let tx_verify_cache_size = config.tx_verify_cache_size;
    let tx_pool_limit = config.tx_pool_limit;
    let wal_enable = config.wal_enable;

    // Start publish and subcribe message from MQ.
    // The CITA system runs in a logic nodes, and it contains some components
    // which we called micro-service at their running time.
    // All micro-services connect to a MQ, as this design can keep them loose
    // coupling with each other.
    let (tx_sub, rx_sub) = channel::unbounded();
    let (tx_pub, rx_pub) = channel::unbounded();
    start_pubsub(
        "auth",
        routing_key!([
            Consensus >> VerifyBlockReq,
            Chain >> BlockTxHashes,
            Executor >> BlackList,
            Jsonrpc >> RequestNewTxBatch,
            Net >> Request,
            Snapshot >> SnapshotReq,
            Executor >> Miscellaneous,
            Net >> GetBlockTxn,
            Net >> BlockTxn,
        ]),
        tx_sub,
        rx_pub,
    );

    // a single thread to batch forward transactions
    let tx_pub_forward = tx_pub.clone();
    let (tx_request, rx_request) = channel::unbounded();
    thread::spawn(move || {
        let mut batch_forward =
            BatchForward::new(count_per_batch, buffer_duration, rx_request, tx_pub_forward);
        batch_forward.run();
    });

    let dispatcher = Dispatcher::new(wal_enable);

    // handle message from MQ
    let mut msg_handler = MsgHandler::new(
        rx_sub,
        tx_pub,
        dispatcher,
        tx_request,
        tx_pool_limit,
        tx_verify_thread_num,
        tx_verify_cache_size,
    );
    msg_handler.handle_remote_msg();
}