adoptium_api 0.1.0

Typed wrapper for a Adoptium REST API
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

# adoptium_api

Small wrapper for a [Adoptium REST API](https://api.adoptium.net/q/swagger-ui).

> [!NOTE]
> All documentation comments are written by a LLM (ChatGPT-3.5/3.0).

## Examples

all examples can be found in a [examples](./examples) directory and runned via `cargo r --example <example_name>`.

### How endpoints are built

```rust
use adoptium_api::v3::prelude::*;
//                ^
//                |
// REST API version which we're using

// Endpoint consists of a 2 things: server and actual endpoint:
let endpoint = Adoptium::production(types::OperationgSystems::new());
//             +--------------------+------------------------------+
//             | server we're using |     actual API endpoint      |
```

You can easily translate any endpoint into a code using explanation below:

```
      Adoptium::production
              |
              |  we've imported "v3" module, so pathes are prefixed with `v3`
              |           |
              |           |  types::OperatingSystems
              |           |    |            |
              ▼           ▼    ▼            ▼
https://api.adoptium.net/v3/types/operating_systems
```

### Basic

Shows how to make simple API call without path and query params.

Run command: `cargo r --example fetch_all_supported_operating_systems`

File: [fetch_all_supported_operating_systems](./examples/fetch_all_supported_operating_systems.rs)

```rust
// Build your request
let endpoint = Adoptium::production(types::OperationgSystems::new());

// Now you can get it's URL
let url = endpoint.try_as_url()?;
println!("URL: {url}");

// Or get a parsed response body if endpoint implements [`GetRequest`] trait.
let response = endpoint.get().await?;
println!("Parsed response: {response:#?}");
```

### JRE downloader

Shows how to download a JRE.

Run command: `cargo r --example download_jre`

File: [download_jre.rs](./examples/download_jre.rs)

Warning: this example will write files into `./jre_download_output` directory.

```rust
// 1. Build the API endpoint for the desired JVM version:
let latest_version_endpoint = assets::Latest::new(DESIRED_VERSION, JvmImpl::Hotspot)
    .architecture(ARCHITECTURE)
    .os(OPERATING_SYSTEM)
    .image_type(IMAGE_TYPE);

// 2. Request the latest version info from Adoptium:
let latest_version_response = Adoptium::production(latest_version_endpoint).get().await?;

// 3. Extract the package download URL from the response:
let version_info = latest_version_response.0.first().expect("No version information found");
let binary = version_info.binary.as_ref().expect("Missing binary information — cannot download");
let package = binary.package.as_ref().expect("Missing package information — cannot download");
let package_url = package.link.as_ref();

// 4. Get decompressed stream of the package archive:
let package_data = reqwest::get(package_url).await?;
let package_data_stream = package_data.bytes_stream().map_err(std::io::Error::other);
let package_data_reader = StreamReader::new(package_data_stream);
let package_data_decoder = GzipDecoder::new(package_data_reader);

// 5. Write all package files from the stream:
tokio_tar::Archive::new(package_data_decoder).unpack(OUTPUT_PATH).await?;
```

## TODO

1. Handle redirects.
2. More robust errors.

## License

[MIT](./LICENSE) license: feel free to steal, sell, use as a drug, modify, etc.