basic_usage/
basic_usage.rs

1use std::io::BufRead;
2
3use wsl_api::{ExportFlags, ImportFlags, Version, Wsl2, WslErrorKind};
4
5fn run_command(wsl: &Wsl2, distro_uuid: uuid::Uuid) -> Result<(), Box<dyn std::error::Error>> {
6    println!("Running command...");
7    let result = wsl.launch(
8        distro_uuid,
9        "/bin/echo",
10        &["echo", "Hello, world!"],
11        None,
12        "root",
13    );
14    let mut process = {
15        match result {
16            Ok(process) => {
17                println!("Successfully ran command: {process:?}");
18                process
19            }
20            Err(e) => {
21                eprintln!("Failed to run command: {:?}", e);
22                return Err(e.into());
23            }
24        }
25    };
26
27    let stdout = process.stdout.take().unwrap();
28    let stderr = process.stderr.take().unwrap();
29
30    let stdout_thread = std::thread::spawn(move || {
31        let reader = std::io::BufReader::new(stdout);
32        for line in reader.lines() {
33            match line {
34                Ok(line) => println!("stdout: {}", line),
35                Err(e) => {
36                    eprintln!("Error reading stdout: {}", e);
37                    return;
38                }
39            }
40        }
41    });
42
43    let stderr_thread = std::thread::spawn(move || {
44        let reader = std::io::BufReader::new(stderr);
45        for line in reader.lines() {
46            match line {
47                Ok(line) => println!("stderr: {}", line),
48                Err(e) => {
49                    eprintln!("Error reading stderr: {}", e);
50                    return;
51                }
52            }
53        }
54    });
55
56    println!("Waiting for process to finish...");
57    let status = process.wait()?;
58    println!("Process finished with status: {status:?}");
59
60    stdout_thread.join().unwrap();
61    stderr_thread.join().unwrap();
62
63    Ok(())
64}
65
66fn main() -> Result<(), Box<dyn std::error::Error>> {
67    println!("Creating WSL API instance...");
68
69    let wsl = match Wsl2::new() {
70        Ok(wsl) => {
71            println!("WSL API instance created successfully");
72            wsl
73        }
74        Err(e) if e.kind() == Some(WslErrorKind::UnsupportedOperatingSystem) => {
75            eprintln!("WSL is not installed or enabled on this operating system");
76            return Ok(());
77        }
78        Err(e) if e.kind() == Some(WslErrorKind::UnsupportedWslVersion) => {
79            eprintln!("WSL version is not supported");
80            return Ok(());
81        }
82        Err(e) => {
83            eprintln!("Failed to create WSL1/2 API instance: {:?}", e);
84            eprintln!("This may be due to WSL2 not being installed or enabled");
85            return Err(e.into());
86        }
87    };
88
89    println!("Getting default distribution...");
90    let default_distro = match wsl.get_default_distribution() {
91        Ok(distro) => {
92            println!("Successfully retrieved default distribution: {:?}", distro);
93            distro
94        }
95        Err(e) => {
96            eprintln!("Failed to get default distribution: {:?}", e);
97            return Err(e.into());
98        }
99    };
100
101    println!("Enumerating distributions...");
102    match wsl.enumerate_distributions() {
103        Ok(distros) => println!("Successfully enumerated distributions: {:?}", distros),
104        Err(e) => {
105            eprintln!("Failed to enumerate distributions: {:?}", e);
106            return Err(e.into());
107        }
108    }
109
110    println!("Exporting distribution...");
111    let file = std::fs::File::create("distro.tar.gz").unwrap();
112    let (r, w) = std::io::pipe().unwrap();
113    let result = wsl.export_distribution(default_distro, file, w, ExportFlags::empty());
114    // Keep the read end alive until after the export completes
115    drop(r);
116    match result {
117        Ok(_) => println!("Successfully exported distribution"),
118        Err(e) => {
119            eprintln!("Failed to export distribution: {:?}", e);
120            return Err(e.into());
121        }
122    }
123
124    let file = std::fs::File::open("distro.tar.gz").unwrap();
125
126    println!("Registering distribution...");
127    let (r, w) = std::io::pipe().unwrap();
128    let result = wsl.register_distribution("test", Version::WSL2, file, w, ImportFlags::empty());
129    let guid_copy = match result {
130        Ok((guid, name)) => {
131            println!("Successfully registered distribution: {:?} {}", guid, name);
132            guid
133        }
134        Err(e) => {
135            eprintln!("Failed to register distribution: {:?}", e);
136            return Err(e.into());
137        }
138    };
139    drop(r);
140
141    println!("Setting version...");
142    let result = wsl.set_version(guid_copy, Version::WSL1, std::io::stderr());
143    match result {
144        Ok(_) => println!("Successfully set version"),
145        Err(e) => {
146            eprintln!("Failed to set version: {:?}", e);
147            return Err(e.into());
148        }
149    }
150
151    println!("Enumerating distributions...");
152    match wsl.enumerate_distributions() {
153        Ok(distros) => println!("Successfully enumerated distributions: {:?}", distros),
154        Err(e) => {
155            eprintln!("Failed to enumerate distributions: {:?}", e);
156            return Err(e.into());
157        }
158    }
159
160    run_command(&wsl, default_distro)?;
161
162    run_command(&wsl, guid_copy)?;
163
164    println!("Shutting down WSL...");
165    match wsl.shutdown(false) {
166        Ok(_) => println!("Successfully shut down WSL"),
167        Err(e) => {
168            eprintln!("Failed to shut down WSL: {:?}", e);
169            return Err(e.into());
170        }
171    }
172
173    println!("Example completed successfully");
174    Ok(())
175}
basic_usage/basic_usage.rs

basic_usage/
basic_usage.rs
