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: static_pods.rs
    path of file: ./repos/bottlerocket/sources/api/static-pods/src
    
    the code of the file until where you have to start completion: /*!
# Background

static-pods ensures static pods are running as defined in settings.

It queries for all existing static pod settings, then configures the system as follows:
* If the pod is enabled, it creates the manifest file in the pod manifest path that kubelet is
  configured to read from and populates the file with the base64-decoded manifest setting value.
* If the pod is enabled and the manifest file already exists, it overwrites the existing manifest
  file with the base64-decoded manifest setting value.
* If the pod is disabled, it ensures the manifest file is removed from the pod manifest path.
*/

use model::modeled_types::Identifier;
use simplelog::{Config as LogConfig, LevelFilter, SimpleLogger};
use snafu::{ensure, OptionExt, ResultExt};
use std::collections::HashMap;
use std::env;
use std::fs;
use std::io::Write;
use std::path::
    
fn parse_args(args: env::Args) -> Result<Args> {
    let mut log_level = None;
    let mut socket_path = None;

    let mut iter = args.skip(1);
    while let Some(arg) = iter.next() {
        match arg.as_ref() {
            "--log-level" => {
                let log_level_str = iter.next().ok_or_else(|| error::Error::Usage {
                    message: "Did not give argument to --log-level".into(),
                })?;
                log_level = Some(LevelFilter::from_str(&log_level_str).map_err(|_| {
                    error::Error::Usage {
                        message: format!("Invalid log level '{}'", log_level_str),
                    }
                })?);
            }

            "--socket-path" => {
                socket_path = Some(
                    iter.next()
                        .ok_or_else(|| error::Error::Usage {
                            message: "Did not give argument to --socket-path".into(),
                        })?
                        .into(),
                )
            }

            _ => {
                return Err(error::Error::Usage {
                    message: "unexpected argument".into(),
                })
            }
        }
    }

    Ok(Args {
        log_level: log_level.unwrap_or(LevelFilter::Info),
        socket_path: socket_path.unwrap_or_else(|| constants::API_SOCKET.into()),
    })
}