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: fetcher.rs
    path of file: ./repos/dim/dim-core/src
    
    the code of the file until where you have to start completion: use crate::core::*;

use tokio::sync::mpsc::unbounded_channel;
use tokio::sync::mpsc::UnboundedReceiver;
use tokio::sync::mps
    
async fn process_queue(mut rx: UnboundedReceiver<(String, String)>) {
    while let Some((url, outfile)) = rx.recv().await {
        debug!("Trying to cache {}", url);

        match reqwest::get(url.as_str()).await {
            Ok(resp) => {
                let meta_path = METADATA_PATH.get().unwrap();
                let mut out_path = PathBuf::from(meta_path);
                out_path.push(outfile);

                debug!("Caching {} -> {:?}", url, out_path);

                let mut file = match File::create(out_path) {
                    Ok(x) => x,
                    Err(e) => {
                        error!(error = ?e, url = &url, "Failed to create local file.");
                        continue;
                    }
                };

                let bytes = match resp.bytes().await {
                    Ok(bytes) => bytes,
                    Err(e) => {
                        error!(error = ?e, url = &url, "Failed to acquire handle on bytes from stream.");
                        continue;
                    }
                };

                let mut content = Cursor::new(bytes);
                if let Err(e) = copy(&mut content, &mut file) {
                    error!(error = ?e, url = &url, "Failed to copy bytes into file.");
                }
            }
            Err(e) => {
                error!(e = ?e, "Failed to cache URL locally: {}", url);
            }
        }
    }
}