webc 6.0.0-alpha9

WebContainer implementation for wapm.io
Documentation 
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use std::{fs::File, path::PathBuf};

use bytes::Buf;
use clap::{Parser, Subcommand, ValueEnum};
use shared_buffer::OwnedBuffer;
use webc::migration::are_semantically_equivalent;

#[derive(Debug, PartialEq, Eq, Clone, ValueEnum)]
enum TargetVersion {
    V2,
    V3,
}

/// Main CLI entry point
#[derive(Parser)]
#[clap(name = "webc", about = "Client to work with webc files")]
struct Cli {
    #[clap(subcommand)]
    command: Commands,
}

/// Subcommands for the CLI
#[derive(Subcommand)]
enum Commands {
    Migrate(Migrate),
    Validate(Validate),
    Compare(Compare),
}

/// Migrates webc from one format to another
#[derive(Parser)]
struct Migrate {
    /// Input file to migrate
    #[clap(value_parser)]
    input: PathBuf,

    /// Output file to write the results to
    #[clap(short, long, value_parser)]
    output: PathBuf,

    /// Target version to migrate to
    #[clap(long, value_enum)]
    target: TargetVersion,
}

impl Migrate {
    fn run(&self) -> Result<(), anyhow::Error> {
        println!(
            "Migrating '{}' to '{}' targeting version '{:?}'",
            self.input.display(),
            self.output.display(),
            self.target
        );

        let webc = OwnedBuffer::from_bytes(std::fs::read(self.input.as_path())?);

        let version = webc::detect(webc.clone().reader())?;

        if (version == webc::Version::V2 && self.target == TargetVersion::V2)
            || (version == webc::Version::V3 && self.target == TargetVersion::V3)
        {
            println!("Input file is already {:?}", self.target);

            return Ok(());
        }

        let webc = match self.target {
            TargetVersion::V2 => webc::migration::v3_to_v2(webc)?,
            TargetVersion::V3 => webc::migration::v2_to_v3(webc)?,
        };

        std::fs::write(self.output.as_path(), webc)?;

        Ok(())
    }
}

/// Validates a local webc file
#[derive(Parser)]
struct Validate {
    /// Input file to validate
    #[clap(value_parser)]
    input: PathBuf,
}

impl Validate {
    fn run(&self) -> Result<(), anyhow::Error> {
        println!("Validating '{}'...", self.input.display());

        webc::Container::from_disk(&self.input)?.validate()?;

        Ok(())
    }
}

/// Semantically compares a webc v2 with a webc v3
#[derive(Parser)]
struct Compare {
    /// Input webc v2 file
    #[clap(value_parser)]
    v2: PathBuf,

    /// Input webc v3 file
    #[clap(value_parser)]
    v3: PathBuf,
}

impl Compare {
    fn run(&self) -> Result<(), anyhow::Error> {
        let webc_v2 = {
            let file = File::open(&self.v2)?;
            OwnedBuffer::from_file(&file)?
        };
        let webc_v3 = {
            let file = File::open(&self.v3)?;
            OwnedBuffer::from_file(&file)?
        };

        are_semantically_equivalent(webc_v2, webc_v3)?;

        Ok(())
    }
}

fn main() -> Result<(), anyhow::Error> {
    let cli = Cli::parse();

    match cli.command {
        Commands::Migrate(migrate) => migrate.run()?,
        Commands::Validate(validate) => validate.run()?,
        Commands::Compare(compare) => compare.run()?,
    }

    Ok(())
}