Skip to main content

component_debug/cli/
storage.rs

1// Copyright 2023 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::storage::{copy, delete, delete_all, list, make_directory};
6use anyhow::{Result, format_err};
7use moniker::Moniker;
8use std::io::Write;
9
10use flex_client::ProxyHasDomain;
11use flex_fuchsia_sys2 as fsys;
12
13async fn get_storage_admin(
14    realm_query: fsys::RealmQueryProxy,
15    storage_provider_moniker: String,
16    storage_capability_name: String,
17) -> Result<fsys::StorageAdminProxy> {
18    let storage_provider_moniker = Moniker::parse_str(&storage_provider_moniker).map_err(|e| {
19        format_err!("Error: {} is not a valid moniker ({})", storage_provider_moniker, e)
20    })?;
21
22    let (storage_admin, server_end) =
23        realm_query.domain().create_proxy::<fsys::StorageAdminMarker>();
24
25    realm_query
26        .connect_to_storage_admin(
27            storage_provider_moniker.as_ref(),
28            &storage_capability_name,
29            server_end,
30        )
31        .await?
32        .map_err(|e| {
33            format_err!(
34                "Failed to get StorageAdmin proxy for capability '{}' of instance '{}': {:?}",
35                storage_capability_name,
36                storage_provider_moniker,
37                e
38            )
39        })?;
40
41    Ok(storage_admin)
42}
43
44pub async fn storage_copy_cmd(
45    storage_provider_moniker: String,
46    storage_capability_name: String,
47    source_path: String,
48    destination_path: String,
49    realm_query: fsys::RealmQueryProxy,
50) -> Result<()> {
51    let storage_admin =
52        get_storage_admin(realm_query, storage_provider_moniker, storage_capability_name).await?;
53    copy(storage_admin, source_path, destination_path).await
54}
55
56pub async fn storage_list_cmd(
57    storage_provider_moniker: String,
58    storage_capability_name: String,
59    path: String,
60    realm_query: fsys::RealmQueryProxy,
61) -> Result<Vec<String>> {
62    let storage_admin =
63        get_storage_admin(realm_query, storage_provider_moniker, storage_capability_name).await?;
64    list(storage_admin, path).await
65}
66
67pub fn storage_list_cmd_write<W: Write>(entries: Vec<String>, mut writer: W) -> Result<()> {
68    for entry in entries {
69        writeln!(writer, "{entry}")?;
70    }
71    Ok(())
72}
73
74pub async fn storage_make_directory_cmd(
75    storage_provider_moniker: String,
76    storage_capability_name: String,
77    path: String,
78    realm_query: fsys::RealmQueryProxy,
79) -> Result<()> {
80    let storage_admin =
81        get_storage_admin(realm_query, storage_provider_moniker, storage_capability_name).await?;
82    make_directory(storage_admin, path).await
83}
84
85pub async fn storage_delete_cmd(
86    storage_provider_moniker: String,
87    storage_capability_name: String,
88    path: String,
89    realm_query: fsys::RealmQueryProxy,
90) -> Result<()> {
91    let storage_admin =
92        get_storage_admin(realm_query, storage_provider_moniker, storage_capability_name).await?;
93    delete(storage_admin, path).await
94}
95
96pub async fn storage_delete_all_cmd(
97    storage_provider_moniker: String,
98    storage_capability_name: String,
99    moniker: String,
100    realm_query: fsys::RealmQueryProxy,
101) -> Result<()> {
102    let storage_admin =
103        get_storage_admin(realm_query, storage_provider_moniker, storage_capability_name).await?;
104    delete_all(storage_admin, moniker).await
105}