graphforge-cli 0.6.0-rc.4

GraphForge command-line interface
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Thin native Slice requests and bounded Arrow capsule input.
use clap::{Args, Subcommand};
use graphforge_api::{
    CancellationToken, GfError, GraphForge, PageRequest, PageToken, SlicePageKind,
};
use std::{
    io::{Read, Write},
    path::PathBuf,
};
#[derive(Subcommand)]
pub(crate) enum SliceCommand {
    /// Preview a JSON SliceRequest against one explicit source.
    Preview {
        #[arg(long)]
        file: PathBuf,
        #[command(flatten)]
        page: SlicePage,
    },
    /// Freeze a Version-based JSON SliceRequest to Arrow IPC on stdout.
    Freeze {
        #[arg(long)]
        file: PathBuf,
    },
    /// Inspect a frozen Arrow IPC capsule without reevaluating it.
    Inspect {
        #[arg(long)]
        capsule: PathBuf,
        #[command(flatten)]
        page: SlicePage,
    },
    /// Revise exact membership using a JSON SliceRevisionRequest.
    Revise {
        #[arg(long)]
        capsule: PathBuf,
        #[arg(long)]
        file: PathBuf,
    },
}
#[derive(Args)]
pub(crate) struct SlicePage {
    #[arg(long, default_value="included", value_parser=["included", "boundary", "explanations", "dependencies", "counts"])]
    kind: String,
    #[arg(long, default_value_t = 100)]
    limit: u32,
    #[arg(long)]
    after: Option<String>,
}
impl SlicePage {
    fn native(self) -> Result<(SlicePageKind, PageRequest), GfError> {
        let kind = serde_json::from_value(serde_json::Value::String(self.kind))
            .map_err(|_| GfError::Validation("invalid Slice page kind".into()))?;
        Ok((
            kind,
            PageRequest {
                limit: self.limit,
                after: self.after.as_deref().map(PageToken::parse).transpose()?,
                cancellation: None,
            },
        ))
    }
}
fn bytes(path: PathBuf, bound: usize) -> Result<Vec<u8>, GfError> {
    let file = std::fs::File::open(path)
        .map_err(|_| GfError::Validation("cannot open Slice input file".into()))?;
    let mut bytes = Vec::new();
    file.take(bound as u64 + 1)
        .read_to_end(&mut bytes)
        .map_err(|_| GfError::Validation("cannot read Slice input file".into()))?;
    if bytes.len() > bound {
        return Err(GfError::Api {
            code: graphforge_api::ApiErrorCode::ResourceLimit,
            message: "Slice input exceeds its byte bound".into(),
        });
    }
    Ok(bytes)
}
fn request<T: serde::de::DeserializeOwned>(path: PathBuf) -> Result<T, GfError> {
    serde_json::from_slice(&bytes(path, 1024 * 1024)?)
        .map_err(|_| GfError::Validation("invalid Slice JSON contract".into()))
}
pub(crate) fn run(
    graph: &GraphForge,
    command: SliceCommand,
    json: bool,
    output: &mut dyn Write,
) -> Result<(), GfError> {
    let result = match command {
        SliceCommand::Preview { file, page } => {
            let (kind, page) = page.native()?;
            graph.preview_slice(&request(file)?, kind, page)?
        }
        SliceCommand::Inspect { capsule, page } => {
            let (kind, page) = page.native()?;
            graph.inspect_frozen_slice(&bytes(capsule, 16 * 1024 * 1024)?, kind, page)?
        }
        SliceCommand::Freeze { file } => {
            if json {
                return Err(GfError::Validation(
                    "Slice freeze produces an Arrow IPC capsule; omit --json".into(),
                ));
            }
            graph.freeze_slice(&request(file)?, &CancellationToken::new())?
        }
        SliceCommand::Revise { capsule, file } => {
            if json {
                return Err(GfError::Validation(
                    "Slice revision produces an Arrow IPC capsule; omit --json".into(),
                ));
            }
            graph.revise_frozen_slice(
                &bytes(capsule, 16 * 1024 * 1024)?,
                &request(file)?,
                &CancellationToken::new(),
            )?
        }
    };
    crate::write_execution_result(&result, json, output)
}