examples/components/storage/src/main.rs

// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use anyhow::{Error, anyhow};
use byteorder::{BigEndian, ByteOrder, WriteBytesExt};
use fuchsia_component::server::ServiceFs;
use fuchsia_inspect::{Inspector, Node};
use futures::stream::StreamExt;
use log::{info, warn};
use std::fs;
use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::LazyLock;

const U64_SIZE: usize = (u64::BITS / 8) as usize;
const DEFAULT_VALUE: u64 = 1;
const FILENAME: &str = "counter";

static DIRECTORIES: LazyLock<Vec<&'static str>> = LazyLock::new(|| vec!["data", "cache", "tmp"]);
static INSPECTOR: LazyLock<Inspector> = LazyLock::new(Inspector::default);

#[fuchsia::main(logging = true)]
async fn main() -> Result<(), Error> {
    info!("Initializing and serving inspect on servicefs");
    let mut fs = ServiceFs::new();
    #[allow(clippy::collection_is_never_read)]
    let mut inspect_nodes = Vec::new();
    let _inspect_server_task =
        inspect_runtime::publish(&INSPECTOR, inspect_runtime::PublishOptions::default());

    for dirname in &*DIRECTORIES {
        let path = PathBuf::from(format!("/{}/{}", dirname, FILENAME));
        let node = INSPECTOR.root().create_child(*dirname);
        info!("Attempting to read and write from {:?}", path);
        process_file(&path, &node);
        inspect_nodes.push(node);
    }

    fs.take_and_serve_directory_handle()?;
    Ok(fs.collect::<()>().await)
}

/// Attempts to read a single u64 from the supplied path then write an incremented value back into
/// the same path. If any errors are encountered during reading the write will use a default
/// value.
fn process_file(path: &Path, inspect_node: &Node) {
    let updated_value = match read_file(path) {
        Ok(value) => {
            info!("Successfully read a value from {:?}: {}", path, value);
            inspect_node.record_uint("read_value", value);
            value.wrapping_add(1)
        }
        Err(err) => {
            let error_string = format!("{:?}", err);
            warn!("Error reading previous value from {:?}: {}", path, error_string);
            inspect_node.record_string("read_error", error_string);
            DEFAULT_VALUE
        }
    };

    match write_file(path, updated_value) {
        Ok(()) => {
            info!("Successfully wrote a value to {:?}: {}", path, updated_value);
            inspect_node.record_uint("write_value", updated_value);
        }
        Err(err) => {
            let error_string = format!("{:?}", err);
            warn!("Error writing updated value to {:?}: {}", path, error_string);
            inspect_node.record_string("write_error", error_string);
        }
    }
}

/// Reads a single u64 from the supplied path, returning an error if the file does not exists or is
/// not exactly the right length.
fn read_file(path: &Path) -> Result<u64, Error> {
    let mut buf = Vec::<u8>::new();
    let mut file = fs::File::open(path).map_err(|err| anyhow!("Error opening file: {:?}", err))?;
    let size =
        file.read_to_end(&mut buf).map_err(|err| anyhow!("Error reading file: {:?}", err))?;
    match size {
        U64_SIZE => Ok(BigEndian::read_u64(&buf)),
        _ => Err(anyhow!("File length invalid: {}", size)),
    }
}

/// Writes the supplied u64 into the supplied path, returning any errors that are encountered.
fn write_file(path: &Path, value: u64) -> Result<(), Error> {
    let mut file =
        fs::File::create(path).map_err(|err| anyhow!("Error creating file: {:?}", err))?;
    file.write_u64::<BigEndian>(value).map_err(|err| anyhow!("Error writing value: {:?}", err))
}

#[cfg(test)]
mod tests {
    use super::*;
    use diagnostics_assertions::{AnyProperty, assert_data_tree};
    use tempfile::TempDir;
    use test_case::test_case;

    fn make_path() -> (TempDir, PathBuf) {
        let dir = TempDir::new().expect("error creating tempdir");
        let path = dir.path().join("testfile");
        (dir, path)
    }

    fn make_file(data: Vec<u8>) -> (TempDir, PathBuf) {
        let (dir, path) = make_path();
        fs::write(&path, &data).expect("error writing file");
        (dir, path)
    }

    #[test_case(vec![0, 0, 0, 0, 1, 2, 3, 4], Some(0x01020304); "valid")]
    #[test_case(vec![0, 0, 0, 0, 1, 2, 3], None; "too short")]
    #[test_case(vec![0, 0, 0, 0, 1, 2, 3, 4, 5], None; "too long")]
    fn test_read_existing_file(content: Vec<u8>, expected: Option<u64>) {
        let (_tempdir, path) = make_file(content);
        match expected {
            Some(value) => assert_eq!(read_file(&path).unwrap(), value),
            None => assert!(read_file(&path).is_err(), "read should fail"),
        }
    }

    #[test]
    fn test_read_missing_file() {
        let (_tempdir, path) = make_path();
        assert!(read_file(&path).is_err(), "read should fail");
    }

    #[test_case(vec![0, 0, 0, 0, 1, 2, 3, 4], Some(0x01020304), 0x01020305; "valid")]
    #[test_case(vec![255, 255, 255, 255, 255, 255, 255, 255], Some(u64::MAX), 0x0; "rollover")]
    #[test_case(vec![0, 0, 0, 0, 1, 2], None, DEFAULT_VALUE; "content too short")]
    #[fuchsia::test]
    async fn test_process_existing_file(content: Vec<u8>, read: Option<u64>, write: u64) {
        let (_tempdir, path) = make_file(content);
        let inspector = &Inspector::default();
        process_file(&path, inspector.root());
        assert_eq!(read_file(&path).unwrap(), write);
        match read {
            Some(read_value) => assert_data_tree!(
            inspector,
            root: contains {
                read_value: read_value,
                write_value: write,
            }),
            None => assert_data_tree!(
            inspector,
            root: contains {
                read_error: AnyProperty,
                write_value: write,
            }),
        }
    }

    #[fuchsia::test]
    async fn test_process_missing_file() {
        let (_tempdir, path) = make_path();
        let inspector = &Inspector::default();
        process_file(&path, inspector.root());
        assert_eq!(read_file(&path).unwrap(), DEFAULT_VALUE);
        assert_data_tree!(
        inspector,
        root: contains {
            read_error: AnyProperty,
            write_value: DEFAULT_VALUE,
        });
    }

    #[fuchsia::test]
    async fn test_process_invalid_directory() {
        let inspector = &Inspector::default();
        process_file(&PathBuf::from("/i_dont_exist"), inspector.root());
        assert_data_tree!(
        inspector,
        root: contains {
            read_error: AnyProperty,
            write_error: AnyProperty,
        });
    }
}