Compare commits
2 Commits
new-readme
...
debian/1.0
| Author | SHA1 | Date | |
|---|---|---|---|
| 4c05749d02 | |||
| c0e6c5d89d |
@@ -8,11 +8,6 @@ jobs:
|
||||
name: Compile and upload a release build
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Get Cargo version
|
||||
run: echo "cargo_version=v$(grep "^version" Cargo.toml | cut -d \" -f2)" >> $GITHUB_ENV
|
||||
- name: Abort if Cargo.toml & Git Tag versions don't match
|
||||
if: ${{ env.cargo_version != github.ref_name }}
|
||||
run: exit 1
|
||||
- name: Install Rust Stable
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
- name: Build binary crate
|
||||
@@ -22,9 +17,7 @@ jobs:
|
||||
- name: Upload the program (using itself!)
|
||||
run: >
|
||||
target/release/gt-tool-${{ github.ref_name }}-$(arch)
|
||||
-u ${{ vars.DEST_GITEA }}
|
||||
-o ${{ vars.DEST_OWNER }}
|
||||
-r ${{ vars.DEST_REPO }}
|
||||
-u ${{ vars.DEST_GITEA }} -r ${{ vars.DEST_REPO }}
|
||||
upload-release
|
||||
"${{ github.ref_name }}"
|
||||
target/release/gt-tool-${{ github.ref_name }}-$(arch)
|
||||
|
||||
28
Cargo.toml
28
Cargo.toml
@@ -1,18 +1,20 @@
|
||||
[package]
|
||||
name = "gt-tool"
|
||||
version = "3.0.1"
|
||||
version = "1.0.0"
|
||||
edition = "2024"
|
||||
license = "GPL-3.0-only"
|
||||
description = "CLI tools for interacting with the Gitea API. Mainly for attaching files to releases."
|
||||
# homepage = "" I have no website for a project home page :(
|
||||
repository = "https://git.gelvin.dev/robert/gt-tool"
|
||||
readme = "README.md"
|
||||
|
||||
[dependencies]
|
||||
clap = { version = "4.5.23", features = ["derive", "env"] }
|
||||
colored = "2.2.0"
|
||||
itertools = "0.13.0"
|
||||
reqwest = { version = "0.12.15", features = ["json", "stream", "multipart"] }
|
||||
serde = { version = "1.0.217", features = ["derive"] }
|
||||
tokio = { version = "1.43.1", features = ["macros", "rt-multi-thread"] }
|
||||
toml = "0.8.19"
|
||||
clap = { version = "4.0.7", features = ["derive", "env"] }
|
||||
reqwest = { version = "0.11.13", features = ["json", "stream", "multipart"] }
|
||||
serde = { version = "1.0.152", features = ["derive"] }
|
||||
tokio = { version = "1.24.2", features = ["macros", "rt-multi-thread"] }
|
||||
|
||||
# Packages available in Debian (Sid)
|
||||
# clap = "4.5.23"
|
||||
# reqwest = "0.12.15"
|
||||
# tokio = "1.43.1"
|
||||
|
||||
# Debian (Bookworm)
|
||||
# clap = "4.0.32"
|
||||
# reqwest = "0.11.13"
|
||||
# tokio = "1.24.2"
|
||||
|
||||
118
README.md
118
README.md
@@ -1,17 +1,11 @@
|
||||
# gt-tool
|
||||
# gt-tools
|
||||
|
||||
A CLI tool for interacting with the Gitea API. List existing releases, create new ones, and attach release-items (files) to them. It can be used interactively as one publishes their work, or automatically as part of a CI/CD pipeline.
|
||||
|
||||
## Why this thing exists
|
||||
|
||||
This program exists because I find GitHub Actions to be an insufficient system. There is no official "release-attachment" workflow. I have to either make my own or find someone else's. Since there is no standard Workflow for this task, the [Gitea version](https://gitea.com/actions/gitea-release-action) has a different API. Since I can only use branches, tags, or exact commit hashes, my dependency resolution is often manual or happens in surprising ways (e.g.: force pushing a new version tag). Adjacent to this is the issue that lots of dependencies are "assumed" and cannot be named -- like how the Ubuntu base image contains NodeJS, even if I never ask to install it. Finally, I can't easily execute or re-execute the workflows. There is no "run Action" button and I can't run any of it from my dev machine.
|
||||
|
||||
So I figured I'll make my own as a learning exercise and try to address as many of those problems as I can. The key is recognizing that a CI/CD platform needs a package manager. I like Debian, so I will stand on its package manager, although it might be better to pick NixOS or Gentoo. A GH Workflow which depends on this tool needs only to record it's name -- declarative build dependencies! This feature extends to the entire Debian container, automatically giving me full-system dependency knowledge. Updating the build environment is exactly like updating a normal Linux host because it *is* a normal Linux host. Lastly, it's also *a normal CLI program* so you can use it from your own dev workstation. There is no need for a "run Action" button.
|
||||
CLI tools for interacting with the Gitea API. Use interactively to talk to your Gitea instance, or automatically via a CI/CD pipeline.
|
||||
|
||||
## Usage
|
||||
|
||||
```txt
|
||||
Usage: gt-tool [OPTIONS] <COMMAND>
|
||||
Usage: gt-tools --url <GITEA_URL> --repo <REPO> <COMMAND>
|
||||
|
||||
Commands:
|
||||
list-releases
|
||||
@@ -21,51 +15,34 @@ Commands:
|
||||
|
||||
Options:
|
||||
-u, --url <GITEA_URL> [env: GTTOOL_GITEA_URL=]
|
||||
-o, --owner <OWNER> [env: GTTOOL_OWNER=]
|
||||
-r, --repo <REPO> [env: GTTOOL_REPO=]
|
||||
-p, --project <PROJECT> Path to project (relative or absolute). Used to override configuration selection.
|
||||
-r, --repo <REPO> [env: GTTOOL_FQRN=]
|
||||
-h, --help Print help
|
||||
-V, --version Print version
|
||||
```
|
||||
|
||||
### Required Information
|
||||
|
||||
To function, this program requires knowledge of these items:
|
||||
|
||||
- Gitea URL
|
||||
- Owner of repository
|
||||
- Repository name
|
||||
|
||||
This info will be gathered from these locations, in order of priority:
|
||||
|
||||
1. CLI argument
|
||||
2. Environment variable
|
||||
3. Configuration files
|
||||
|
||||
It's worth noting that the "owner" is the entity that controls the repo on the Gitea instance. This will be the first part of the route in the URL: `http://demo.gitea.com/{owner}`.
|
||||
|
||||
Likewise, the "repo" is what ever the Gitea instance thinks it's called -- which doesn't have to match anyone's local copy! It will be the second part of the route in the URL: `http://demo.gitea.com/{owner}/{repo}`.
|
||||
|
||||
### Authentication
|
||||
|
||||
Authentication is token-based. There is no CLI option to prevent the token from appearing in any command logs.
|
||||
Authentication is token-based via environment variable `RELEASE_KEY_GITEA`.
|
||||
|
||||
In order of priority, the token is loaded from:
|
||||
Ensure your token has the appropriate access for your usage. This depends on what you're doing and how your Gitea instance is configured, so you'll have to figure it out for yourself.
|
||||
|
||||
1. The environment variable `RELEASE_KEY_GITEA`
|
||||
2. Config files, key `token`
|
||||
Most likely, you will need a token with "repository: read-and-write" permissions. See Gitea's documentation on [token scopes](https://docs.gitea.com/development/oauth2-provider#scopes) for more.
|
||||
|
||||
Whether or not it is required depends on how your Gitea instance and the repositories inside are configured. For example, a default Gitea configuration will allow unauthenticated users to see public repositories but not make any changes. This means no token is required to run `gt-tool list-releases`, while `gt-tool upload-release` *will* require a token.
|
||||
### `<GITEA_URL>`:
|
||||
|
||||
For details, see Gitea's documentation on [token scopes](https://docs.gitea.com/development/oauth2-provider#scopes).
|
||||
The Gitea server URL must be provided with `--url` or `-u` on the command line, or via the environment variable `GTTOOL_GITEA_URL`. Use the base URL for your Gitea instance.
|
||||
|
||||
### The `--project` option
|
||||
E.g.: Using the Gitea org's demo instance, it would be: `--url "https://demo.gitea.com/"`
|
||||
|
||||
Settings retrieved from config files are selected based on the project's path. By default, the current directory will be used. In case that guess is incorrect, this option can be specified with another path.
|
||||
### `<REPO>`:
|
||||
|
||||
See [configuration](#configuration) for details on format and file locations.
|
||||
The repository name must be provided with `--repo` or `-u` on the command line, or via the environment variable `GTTOOL_GITEA_FQRN` ("fully qualified repo name"). Use the format `<owner>/<repo>`, which is the route immediately following the GITEA_URL base. This is how GitHub and Gitea identify repos in the URL, and how Golang locates it's modules, so this tool does the same.
|
||||
|
||||
### Commands:
|
||||
E.g.: `--repo "go-gitea/gitea"` would name the Gitea repo belonging to the go-gitea organization.
|
||||
|
||||
### `<COMMAND>`:
|
||||
|
||||
One of these, defaults to `help`:
|
||||
|
||||
| Command | Description |
|
||||
|-|-|
|
||||
@@ -74,61 +51,14 @@ See [configuration](#configuration) for details on format and file locations.
|
||||
| upload-release | Uploads one-or-more files to an existing release, identified by it's tag name. |
|
||||
| help | prints the help text (the usage summary above). |
|
||||
|
||||
## Configuration
|
||||
## Unit Testing
|
||||
|
||||
Instead of specifying everything on the command line every single run, some TOML files can be used to persist project settings.
|
||||
The unit test~~s~~ require a Gitea server to execute against. This information is supplied by environment variables rather than on the command line, but it is otherwise exactly the same usage.
|
||||
|
||||
> Exporting some environment variables would be similar, but that would be *more* annoying when working on multiple projects. One would have to constantly re-export the settings or use two shells. But then there's the issue of losing track of which shell has which settings.
|
||||
|
||||
### File Format
|
||||
|
||||
Settings are retrieved from a table named the same as the project's path on disk. For example, gt_tool itself could have an entry as follows:
|
||||
|
||||
```toml
|
||||
["/home/robert/projects/gt-tool"]
|
||||
gitea_url = "https://demo.gitea.com/"
|
||||
owner = "dummy"
|
||||
repo = "gt-tool"
|
||||
token = "fake-token"
|
||||
```
|
||||
|
||||
Sometimes one may want to apply a setting to all projects. For this, they can use the special `[all]` table.
|
||||
|
||||
```toml
|
||||
[all]
|
||||
gitea_url = "https://demo.gitea.com/"
|
||||
```
|
||||
|
||||
Since the more-specific settings are preferred, these can be combined to have an override effect.
|
||||
|
||||
```toml
|
||||
[all]
|
||||
gitea_url = "https://demo.gitea.com/"
|
||||
owner = "robert"
|
||||
token = "fake-token"
|
||||
|
||||
# Override Gitea target so I can test my uploads privately.
|
||||
["/home/robert/projects/gt-tool"]
|
||||
gitea_url = "http://localhost:3000"
|
||||
repo = "gt-tool"
|
||||
```
|
||||
|
||||
### Search Paths
|
||||
|
||||
Similar to how unspecified project settings will fall back to those in the "`[all]`" table, whole files will fall back to other, lower priority files.
|
||||
|
||||
1. First, each dir in `$XDG_CONFIG_DIRS` is scanned for a `gt-tool.toml` file.
|
||||
2. Then, `/etc/gt-tool.toml`.
|
||||
|
||||
> All config files **MUST** be named named `gt-tool.toml`.
|
||||
|
||||
### Recognized Keys
|
||||
|
||||
| Key | Description |
|
||||
| Variable | Description |
|
||||
|-|-|
|
||||
| gitea_url | URL of the Gitea server. Same as `-u`, `--url`, and `$GTTOOL_GITEA_URL`. |
|
||||
| owner | Owner of the repository (individual, or organization). Combined with "repo" key to produce the fully-qualified-repo-name. Front-half of `-r`, `--repo`, and `$GTTOOL_FQRN` |
|
||||
| repo | Name of the repository on the Gitea server. Combined with "owner" key to produce the fully-qualified-repo-name. Back-half of `-r`, `--repo`, and `$GTTOOL_FQRN` |
|
||||
| token | Gitea auth token, exactly the same as `$RELEASE_KEY_GITEA` |
|
||||
| TEST_GITEA_SERVER | Server URL, match `-u`, `--url` |
|
||||
| TEST_GITEA_REPO | Owner + repo name, match `-u` `--repo` |
|
||||
| TEST_GITEA_KEY | API key, match `RELEASE_KEY_GITEA`. The use of a new variable for the API token is to help avoid accidentally touching a production environment during test execution. |
|
||||
| TEST_GITEA_RELEASE_TAG | Git tag used to identify the Release. Same as `upload-release`'s positional argument `<TAG_NAME>`. |
|
||||
|
||||
Additional keys are quietly ignored. The config loading is done by querying a HashMap, so anything not touched doesn't get inspected. The only requirements are that the file is valid TOML, and that these keys are all strings.h
|
||||
|
||||
5
debian/changelog
vendored
Normal file
5
debian/changelog
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
gt-tool (1.0.0-1) UNRELEASED; urgency=low
|
||||
|
||||
* Experimental release.
|
||||
|
||||
-- Robert Garrett <robertgarrett404@gmail.com> Sun, 1 Jun 2025 16:05:00 -0500
|
||||
30
debian/control
vendored
Normal file
30
debian/control
vendored
Normal file
@@ -0,0 +1,30 @@
|
||||
Source: gt-tool
|
||||
Maintainer: Robert Garrett <robertgarrett404@gmail.com>
|
||||
Section: misc
|
||||
Priority: optional
|
||||
Standards-Version: 4.6.2
|
||||
Build-Depends:
|
||||
debhelper-compat (= 13),
|
||||
dh-cargo,
|
||||
librust-clap-dev,
|
||||
librust-reqwest-dev,
|
||||
librust-tokio-dev,
|
||||
librust-serde-dev,
|
||||
Homepage: https://git.gelvin.dev/robert/gt-tool
|
||||
Vcs-Git: https://git.gelvin.dev/robert/gt-tool
|
||||
Vcs-Browser: https://git.gelvin.dev/robert/gt-tool
|
||||
Rules-Requires-Root: no
|
||||
|
||||
Package: gt-tool
|
||||
Architecture: any
|
||||
Depends:
|
||||
${misc:Depends},
|
||||
${shlibs:Depends},
|
||||
Description: CLI tools for interacting with the Gitea API.
|
||||
Use interactively to talk to your Gitea instance, or automatically via a CI/CD
|
||||
pipeline. Currently supports:
|
||||
.
|
||||
- showing the Releases for a project
|
||||
- creating a new Release for a project
|
||||
- attaching files to a release
|
||||
|
||||
43
debian/copyright
vendored
Normal file
43
debian/copyright
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
|
||||
Upstream-Name: gt-tools
|
||||
Upstream-Contact: Robert Garrett <robertgarrett404@gmail.com>
|
||||
Source: https://source.mnt.re/reform/mnt-reform-setup-wizard
|
||||
|
||||
Files: *
|
||||
Copyright: 2025 Robert Garrett <robertgarrett404@gmail.com>
|
||||
License: GPL-3+
|
||||
|
||||
Files: debian/*
|
||||
Copyright: 2025 Robert Garrett <robertgarrett404@gmail.com>
|
||||
License: GPL-3+
|
||||
|
||||
Files: debian/rules
|
||||
Copyright:
|
||||
Johannes Schauer Marin Rodrigues <josch@debian.org>
|
||||
2025 Robert Garrett <robertgarrett404@gmail.com>
|
||||
License: GPL-3+
|
||||
Comment:
|
||||
The debian/rules file is liften directly from the tuigreet package. It was
|
||||
linked in the Debian Rust Team Book as a pretty simple example package. The
|
||||
only change I've made is to remove the documentation generation target.
|
||||
.
|
||||
https://salsa.debian.org/debian/tuigreet/-/blob/master/debian/rules?ref_type=heads
|
||||
|
||||
|
||||
License: GPL-3+
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
.
|
||||
It is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
||||
License for more details.
|
||||
.
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with it. If not, see <http://www.gnu.org/licenses/>.
|
||||
.
|
||||
On Debian systems, the full text of the GNU General Public License version 3
|
||||
can be found in the file /usr/share/common-licenses/GPL-3.
|
||||
|
||||
6
debian/gbp.conf
vendored
Normal file
6
debian/gbp.conf
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
[DEFAULT]
|
||||
compression = xz
|
||||
compression-level = 9
|
||||
upstream-tag = v%(version)s
|
||||
debian-branch = deb
|
||||
|
||||
23
debian/patches/0001-Rust-edition-downgrade-to-2021.patch
vendored
Normal file
23
debian/patches/0001-Rust-edition-downgrade-to-2021.patch
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
From: Robert Garrett <robertgarrett404@gmail.com>
|
||||
Date: Sun, 1 Jun 2025 17:59:20 -0500
|
||||
Subject: Rust edition downgrade to 2021
|
||||
|
||||
Debian Bookworm uses Rust 1.64 which only supports up to the 2021
|
||||
edition.
|
||||
---
|
||||
Cargo.toml | 2 +-
|
||||
1 file changed, 1 insertion(+), 1 deletion(-)
|
||||
|
||||
diff --git a/Cargo.toml b/Cargo.toml
|
||||
index febccc4..cf52754 100644
|
||||
--- a/Cargo.toml
|
||||
+++ b/Cargo.toml
|
||||
@@ -1,7 +1,7 @@
|
||||
[package]
|
||||
name = "gt-tool"
|
||||
version = "1.0.0"
|
||||
-edition = "2024"
|
||||
+edition = "2021"
|
||||
|
||||
[dependencies]
|
||||
clap = { version = "4.0.7", features = ["derive", "env"] }
|
||||
31
debian/patches/0002-Use-pre-Rust-1.81-compatible-file-exists-test.patch
vendored
Normal file
31
debian/patches/0002-Use-pre-Rust-1.81-compatible-file-exists-test.patch
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
From: Robert Garrett <robertgarrett404@gmail.com>
|
||||
Date: Sun, 1 Jun 2025 18:01:21 -0500
|
||||
Subject: Use pre Rust 1.81 compatible file-exists test
|
||||
|
||||
The function `std::fs::exists(...)` was stabilized in Rust 1.81, which
|
||||
means it can't be used in the Debian Bookworm build. This patch swaps to
|
||||
a compatible implementation leaning on the std::path::Path struct.
|
||||
---
|
||||
src/api/release_attachment.rs | 5 +++--
|
||||
1 file changed, 3 insertions(+), 2 deletions(-)
|
||||
|
||||
diff --git a/src/api/release_attachment.rs b/src/api/release_attachment.rs
|
||||
index 9af71bf..8a0c798 100644
|
||||
--- a/src/api/release_attachment.rs
|
||||
+++ b/src/api/release_attachment.rs
|
||||
@@ -1,4 +1,4 @@
|
||||
-use std::fs;
|
||||
+use std::{fs, path};
|
||||
|
||||
pub fn check_release_match_repo() {}
|
||||
pub fn get_release_attachment() {}
|
||||
@@ -16,7 +16,8 @@ pub async fn create_release_attachment(
|
||||
|
||||
// Ensure all files exists before starting the uploads
|
||||
for file in &files {
|
||||
- match fs::exists(file) {
|
||||
+ let path = path::Path::new(file);
|
||||
+ match path.try_exists() {
|
||||
Ok(true) => continue,
|
||||
Ok(false) => return Err(crate::Error::NoSuchFile),
|
||||
Err(e) => {
|
||||
2
debian/patches/series
vendored
Normal file
2
debian/patches/series
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
0001-Rust-edition-downgrade-to-2021.patch
|
||||
0002-Use-pre-Rust-1.81-compatible-file-exists-test.patch
|
||||
26
debian/rules
vendored
Executable file
26
debian/rules
vendored
Executable file
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/make -f
|
||||
|
||||
export DEB_BUILD_MAINT_OPTIONS = hardening=+all
|
||||
DPKG_EXPORT_BUILDFLAGS = 1
|
||||
include /usr/share/dpkg/default.mk
|
||||
include /usr/share/rustc/architecture.mk
|
||||
export DEB_HOST_RUST_TYPE
|
||||
export PATH:=/usr/share/cargo/bin:$(PATH)
|
||||
export CARGO=/usr/share/cargo/bin/cargo
|
||||
export CARGO_HOME=$(CURDIR)/debian/cargo_home
|
||||
export CARGO_REGISTRY=$(CURDIR)/debian/cargo_registry
|
||||
export DEB_CARGO_CRATE=$(DEB_SOURCE)_$(DEB_VERSION_UPSTREAM)
|
||||
|
||||
%:
|
||||
dh $@ --buildsystem=cargo
|
||||
|
||||
execute_after_dh_auto_clean:
|
||||
$(CARGO) clean
|
||||
rm -rf $(CARGO_HOME)
|
||||
rm -rf $(CARGO_REGISTRY)
|
||||
rm -f debian/cargo-checksum.json
|
||||
|
||||
execute_before_dh_auto_configure:
|
||||
$(CARGO) prepare-debian $(CARGO_REGISTRY) --link-from-system
|
||||
rm -f Cargo.lock
|
||||
touch debian/cargo-checksum.json
|
||||
1
debian/source/format
vendored
Normal file
1
debian/source/format
vendored
Normal file
@@ -0,0 +1 @@
|
||||
3.0 (quilt)
|
||||
@@ -1,9 +1,14 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{
|
||||
Result,
|
||||
structs::release::{CreateReleaseOption, Release},
|
||||
ApiError, Result,
|
||||
structs::{
|
||||
self,
|
||||
release::{CreateReleaseOption, Release},
|
||||
},
|
||||
};
|
||||
|
||||
pub fn get_release(_id: u64) -> Result<Release> {
|
||||
pub fn get_release(id: u64) -> Result<Release> {
|
||||
todo!();
|
||||
}
|
||||
pub fn get_latest_release() -> Result<Release> {
|
||||
@@ -17,8 +22,7 @@ pub async fn list_releases(
|
||||
) -> Result<Vec<Release>> {
|
||||
let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases/");
|
||||
let req = client.get(request_url).send().await;
|
||||
let response = req.map_err(crate::Error::WrappedReqwestErr)?;
|
||||
if response.status().is_success() {
|
||||
let response = req.map_err(|reqwest_err| crate::Error::WrappedReqwestErr(reqwest_err))?;
|
||||
let release_list = response
|
||||
.json::<Vec<Release>>()
|
||||
.await
|
||||
@@ -28,11 +32,14 @@ pub async fn list_releases(
|
||||
crate::Error::WrappedReqwestErr(reqwest_err)
|
||||
})?;
|
||||
return Ok(release_list);
|
||||
} else if response.status().is_client_error() {
|
||||
let mesg = crate::decode_client_error(response).await?;
|
||||
return Err(crate::Error::ApiErrorMessage(mesg));
|
||||
}
|
||||
panic!("Reached end of list_releases without matching a return pathway.");
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
#[serde(untagged)]
|
||||
enum CreateResult {
|
||||
Success(structs::release::Release),
|
||||
ErrWithMessage(ApiError),
|
||||
Empty,
|
||||
}
|
||||
|
||||
pub async fn create_release(
|
||||
@@ -42,27 +49,31 @@ pub async fn create_release(
|
||||
submission: CreateReleaseOption,
|
||||
) -> Result<Release> {
|
||||
let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases");
|
||||
let response = client
|
||||
let req = client
|
||||
.post(request_url)
|
||||
.json(&submission)
|
||||
.send()
|
||||
.await
|
||||
.map_err(crate::Error::from)?;
|
||||
if response.status().is_success() {
|
||||
let new_release = response
|
||||
.json::<Release>()
|
||||
.map_err(|e| crate::Error::from(e))?;
|
||||
let new_release = req
|
||||
.json::<CreateResult>()
|
||||
.await
|
||||
.map_err(crate::Error::from)?;
|
||||
return Ok(new_release);
|
||||
} else if response.status().is_client_error() {
|
||||
let mesg = crate::decode_client_error(response).await?;
|
||||
return Err(crate::Error::ApiErrorMessage(mesg));
|
||||
.map_err(|e| crate::Error::from(e))?;
|
||||
match new_release {
|
||||
CreateResult::Success(release) => Ok(release),
|
||||
CreateResult::ErrWithMessage(api_error) => {
|
||||
if api_error.message == "token is required" {
|
||||
Err(crate::Error::MissingAuthToken)
|
||||
} else {
|
||||
Err(crate::Error::ApiErrorMessage(api_error))
|
||||
}
|
||||
panic!("Reached end of create_release without matching a return path");
|
||||
}
|
||||
pub fn edit_release(_id: u64) -> Result<Release> {
|
||||
CreateResult::Empty => panic!("How can we have 200 OK and no release info? No. Crash"),
|
||||
}
|
||||
}
|
||||
pub fn edit_release(id: u64) -> Result<Release> {
|
||||
todo!();
|
||||
}
|
||||
pub fn delete_release(_id: u64) -> Result<()> {
|
||||
pub fn delete_release(id: u64) -> Result<()> {
|
||||
todo!();
|
||||
}
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
use std::{fs, path};
|
||||
|
||||
use crate::structs::Attachment;
|
||||
use std::fs;
|
||||
|
||||
pub fn check_release_match_repo() {}
|
||||
pub fn get_release_attachment() {}
|
||||
@@ -12,22 +10,23 @@ pub async fn create_release_attachment(
|
||||
gitea_url: &str,
|
||||
repo: &str,
|
||||
release_id: usize,
|
||||
file: String,
|
||||
) -> crate::Result<Attachment> {
|
||||
files: Vec<String>,
|
||||
) -> crate::Result<()> {
|
||||
let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases/{release_id}/assets");
|
||||
|
||||
let path = path::Path::new(&file);
|
||||
match path.try_exists() {
|
||||
Ok(true) => (),
|
||||
// Ensure all files exists before starting the uploads
|
||||
for file in &files {
|
||||
match fs::exists(file) {
|
||||
Ok(true) => continue,
|
||||
Ok(false) => return Err(crate::Error::NoSuchFile),
|
||||
Err(e) => {
|
||||
eprintln!("Uh oh! The file-exists check couldn't be done: {e}");
|
||||
panic!(
|
||||
"TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)"
|
||||
);
|
||||
panic!("TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)");
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
for file in files {
|
||||
println!("Uploading file {}", &file);
|
||||
let data = reqwest::multipart::Part::stream(fs::read(&file).unwrap())
|
||||
.file_name("attachment")
|
||||
@@ -35,24 +34,150 @@ pub async fn create_release_attachment(
|
||||
|
||||
let form = reqwest::multipart::Form::new().part("attachment", data);
|
||||
|
||||
let response = client
|
||||
let request = client
|
||||
.post(&request_url)
|
||||
.multipart(form)
|
||||
.query(&[("name", file.split("/").last())])
|
||||
.send()
|
||||
.await?;
|
||||
if response.status().is_success() {
|
||||
// TODO: create a struct Attachment and return it to the caller.
|
||||
let attachment_desc = response
|
||||
.json::<Attachment>()
|
||||
.await
|
||||
.map_err(crate::Error::from)?;
|
||||
return Ok(attachment_desc);
|
||||
} else if response.status().is_client_error() {
|
||||
let mesg = crate::decode_client_error(response).await?;
|
||||
return Err(crate::Error::ApiErrorMessage(mesg));
|
||||
}
|
||||
panic!("Reached end of release_attachment without matching a return path");
|
||||
Ok(())
|
||||
}
|
||||
pub fn edit_release_attachment() {}
|
||||
pub fn delete_release_attachment() {}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use reqwest::header::{self, ACCEPT};
|
||||
|
||||
use crate::structs::release::Release;
|
||||
|
||||
|
||||
#[tokio::test]
|
||||
async fn attach_file_exists() {
|
||||
let conf = TestConfig::new();
|
||||
let release_candidates =
|
||||
crate::api::release::list_releases(
|
||||
&conf.client,
|
||||
&conf.server,
|
||||
&conf.repo
|
||||
)
|
||||
.await
|
||||
.expect("Failed to get releases. Pre-conditions unmet, aborting test!");
|
||||
|
||||
let release = match_release_by_tag(&conf.release_tag, release_candidates)
|
||||
.expect("Failed to select matching release. Pre-conditions unmet, aborting test!");
|
||||
|
||||
let api_result = super::create_release_attachment(
|
||||
&conf.client,
|
||||
&conf.server,
|
||||
&conf.repo,
|
||||
release.id,
|
||||
vec![String::from("Cargo.toml")],
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn attach_file_missing() {
|
||||
let conf = TestConfig::new();
|
||||
let release_candidates =
|
||||
crate::api::release::list_releases(
|
||||
&conf.client,
|
||||
&conf.server,
|
||||
&conf.repo
|
||||
)
|
||||
.await
|
||||
.expect("Failed to get releases. Pre-conditions unmet, aborting test!");
|
||||
|
||||
let release = match_release_by_tag(&conf.release_tag, release_candidates)
|
||||
.expect("Failed to select matching release. Pre-conditions unmet, aborting test!");
|
||||
|
||||
let api_result = super::create_release_attachment(
|
||||
&conf.client,
|
||||
&conf.server,
|
||||
&conf.repo,
|
||||
release.id,
|
||||
vec![String::from("./this-file-doesnt-exist")],
|
||||
)
|
||||
.await;
|
||||
let api_err = api_result.expect_err("Received Ok(()) after uploading non-existent file. That's nonsense, the API Function is wrong.");
|
||||
match api_err {
|
||||
crate::Error::Placeholder => panic!("Received dummy response from the API function. Finish implementing it, stupid"),
|
||||
crate::Error::WrappedReqwestErr(error) => panic!("Received a reqwest::Error from the API function: {error}"),
|
||||
crate::Error::MissingAuthToken => unreachable!("Missing auth token... in a unit test that already panics without the auth token..."),
|
||||
crate::Error::NoSuchFile => (), // test passes
|
||||
crate::Error::ApiErrorMessage(api_error) => panic!("Received an error message from the API: {api_error:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
struct TestConfig {
|
||||
server: String,
|
||||
repo: String,
|
||||
release_tag: String,
|
||||
client: reqwest::Client,
|
||||
}
|
||||
|
||||
impl TestConfig {
|
||||
fn new() -> Self {
|
||||
let server = std::env::var("TEST_GITEA_SERVER")
|
||||
.expect("Must set server address in env var \"TEST_GITEA_SERVER\"");
|
||||
let repo = std::env::var("TEST_GITEA_REPO")
|
||||
.expect("Must set <user>/<repo> name in env var \"TEST_GITEA_REPO\"");
|
||||
let token = format!(
|
||||
"token {}",
|
||||
std::env::var("TEST_GITEA_KEY")
|
||||
.expect("Must set the API token in env var \"TEST_GITEA_KEY\"")
|
||||
);
|
||||
let release_tag = std::env::var("TEST_GITEA_RELEASE_TAG")
|
||||
.expect("Must set the target release tag in env var \"TEST_GITEA_RELEASE_TAG\"");
|
||||
|
||||
let mut headers = reqwest::header::HeaderMap::new();
|
||||
headers.append(ACCEPT, header::HeaderValue::from_static("application/json"));
|
||||
headers.append("Authorization", token.parse().unwrap());
|
||||
|
||||
let client = reqwest::Client::builder()
|
||||
.user_agent(format!(
|
||||
"gt-tools-autotest-agent{}",
|
||||
env!("CARGO_PKG_VERSION")
|
||||
))
|
||||
.default_headers(headers)
|
||||
.build()
|
||||
.expect("Failed to build reqwest::Client.");
|
||||
|
||||
return Self {
|
||||
server,
|
||||
repo,
|
||||
release_tag,
|
||||
client
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Testing utils
|
||||
fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release> {
|
||||
let mut release: Option<Release> = None;
|
||||
for rel in releases {
|
||||
if rel.tag_name == *tag {
|
||||
// Only store the value if one hasn't been stored already
|
||||
if let Some(first_release) = &release {
|
||||
// if there was already a match, begin the error diagnostic creation.
|
||||
let first_id = first_release.id;
|
||||
let second_id = rel.id;
|
||||
assert!(
|
||||
first_id != second_id,
|
||||
"FAILURE: Found the same release ID twice while scanning for duplicate tags. How did we get the same one twice?"
|
||||
);
|
||||
eprintln!("ERROR: Two releases have been found for the tag \"{tag}\".");
|
||||
eprintln!("ERROR: first ID: {first_id}");
|
||||
eprintln!("ERROR: second ID: {second_id}");
|
||||
panic!("ERROR: Nonsense detected, I'm bailing out!");
|
||||
} else {
|
||||
// else, store our first (and hopefully only) match
|
||||
release = Some(rel);
|
||||
}
|
||||
}
|
||||
}
|
||||
return release;
|
||||
}
|
||||
}
|
||||
14
src/cli.rs
14
src/cli.rs
@@ -4,17 +4,9 @@ use clap::{Parser, Subcommand};
|
||||
#[command(version, about, long_about = None)]
|
||||
pub struct Args {
|
||||
#[arg(short = 'u', long = "url", env = "GTTOOL_GITEA_URL")]
|
||||
pub gitea_url: Option<String>,
|
||||
#[arg(short = 'o', long = "owner", env = "GTTOOL_OWNER")]
|
||||
pub owner: Option<String>,
|
||||
#[arg(short = 'r', long = "repo", env = "GTTOOL_REPO")]
|
||||
pub repo: Option<String>,
|
||||
#[arg(
|
||||
short = 'p',
|
||||
long = "project",
|
||||
help = "Path to project (relative or absolute). Used to override configuration selection."
|
||||
)]
|
||||
pub project: Option<String>,
|
||||
pub gitea_url: String,
|
||||
#[arg(short = 'r', long = "repo", env = "GTTOOL_FQRN")]
|
||||
pub repo: String,
|
||||
|
||||
#[command(subcommand)]
|
||||
pub command: Commands,
|
||||
|
||||
352
src/config.rs
352
src/config.rs
@@ -1,352 +0,0 @@
|
||||
use std::path::PathBuf;
|
||||
|
||||
use toml::{Value, value::Table};
|
||||
|
||||
pub type Result<T> = core::result::Result<T, Error>;
|
||||
|
||||
#[derive(Debug)]
|
||||
#[cfg_attr(test, derive(PartialEq))]
|
||||
pub enum Error {
|
||||
BadFormat,
|
||||
NoSuchProperty,
|
||||
NoSuchTable,
|
||||
CouldntReadFile,
|
||||
TomlWrap(toml::de::Error),
|
||||
}
|
||||
|
||||
impl From<toml::de::Error> for Error {
|
||||
fn from(value: toml::de::Error) -> Self {
|
||||
Error::TomlWrap(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl core::fmt::Display for Error {
|
||||
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
// FIXME: Print a nice output, don't just reuse the Debug impl
|
||||
write!(fmt, "{self:?}")
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for Error {}
|
||||
|
||||
/// Creates an iterator of default (Linux) search paths. The iterator output
|
||||
/// is a list of files named "gt-tool.toml" found in decreasingly specific
|
||||
/// configuration folders.
|
||||
///
|
||||
/// - any dirs listed in env var `$XDG_CONFIG_DIRS`
|
||||
/// - and the `/etc` dir
|
||||
///
|
||||
/// This is so that user-specific configs are used first, then machine-wide
|
||||
/// ones.
|
||||
pub fn default_paths() -> impl Iterator<Item = PathBuf> {
|
||||
// Read env var `XDG_CONFIG_DIRS` and split on ":" to get highest-priority list
|
||||
// TODO: Emit warning when paths aren't unicode
|
||||
std::env::var("XDG_CONFIG_DIRS")
|
||||
.unwrap_or(String::from(""))
|
||||
.split(":")
|
||||
// Set up the "/etc" list
|
||||
// Which is pretty silly, in this case.
|
||||
// Maybe a future version will scan nested folders and this will make
|
||||
// more sense.
|
||||
// glue on the "/etc" path
|
||||
.chain(["/etc"])
|
||||
.map(|path_str| {
|
||||
let mut path = PathBuf::from(path_str);
|
||||
path.push("gt-tool.toml");
|
||||
path
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.into_iter()
|
||||
}
|
||||
|
||||
/// Searches through the files, `search_files`, for configuration related to a
|
||||
/// project, `project`.
|
||||
///
|
||||
/// The project string is used as a map key and should match the real path of a
|
||||
/// project on disk. These are the table names for each config section.
|
||||
///
|
||||
/// The search files iterator must produce *files* not *folders.* For now,
|
||||
/// there is no mechanism to ensure correct usage. Files that can't be opened
|
||||
/// will quietly be skipped, so there will be no warning when one gives a
|
||||
/// folder.
|
||||
///
|
||||
/// Use `fn default_paths()` to get a reasonable (Linux) default.
|
||||
///
|
||||
/// TODO: Check for, and warn or error when given a dir.
|
||||
pub fn get_config(
|
||||
project: &str,
|
||||
search_files: impl Iterator<Item = PathBuf>,
|
||||
) -> Result<PartialConfig> {
|
||||
/*
|
||||
1. Get conf search (from fn input)
|
||||
2. Iterate config dirs
|
||||
3. Try load toml::Value from file
|
||||
4. Try-get proj-specific table
|
||||
5. Try-get "[all]" table
|
||||
6. (merge) Update `Option::None`s in proj-spec with `Some(_)`s from "[all]"
|
||||
7. (merge, again) Fold the PartialConfigs into a finished one
|
||||
*/
|
||||
|
||||
let file_iter = search_files;
|
||||
|
||||
let toml_iter = file_iter
|
||||
.map(std::fs::read_to_string) // read text from file
|
||||
.filter_map(|res| res.ok()) // remove any error messages
|
||||
// TODO: Log warnings when files couldn't be read.
|
||||
.map(|toml_text| toml_text.parse::<Value>()) // try convert to `toml::Value`
|
||||
.filter_map(|res| res.ok()); // remove any failed parses
|
||||
let config_iter = toml_iter
|
||||
.map(|val| -> Result<PartialConfig> {
|
||||
// Like `fn read_conf_str(...)`, but doesn't produce a `WholeFile`
|
||||
|
||||
// 1. Get the top-level table that is the config file
|
||||
let cfg_table = val.as_table().ok_or(Error::BadFormat)?;
|
||||
|
||||
// 2. Get table
|
||||
|
||||
get_table(cfg_table, project)
|
||||
// 3a. convert to PartialConfig
|
||||
.and_then(PartialConfig::try_from)
|
||||
// 3b. or default, if the table couldn't be found.
|
||||
.or(Ok(PartialConfig::default()))
|
||||
// 4. assemble a 2-tuple of PartialConfigs by...
|
||||
.map(|proj| {
|
||||
(
|
||||
// 4-1. Passing in the project-specific PartialConfig
|
||||
proj.project_path(project),
|
||||
// 4-2. Getting and converting to PartialConfig, or returning any Err() if one appears.
|
||||
get_table(cfg_table, "all")
|
||||
.and_then(PartialConfig::try_from)
|
||||
.unwrap_or(PartialConfig::default()),
|
||||
)
|
||||
})
|
||||
.map(|pair| pair.0.merge(pair.1))
|
||||
})
|
||||
.filter_map(|res| res.ok())
|
||||
.fold(PartialConfig::default(), |acc, inc| acc.merge(inc));
|
||||
Ok(config_iter)
|
||||
}
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
#[cfg_attr(test, derive(PartialEq))]
|
||||
pub struct PartialConfig {
|
||||
project_path: Option<String>,
|
||||
pub gitea_url: Option<String>,
|
||||
pub owner: Option<String>,
|
||||
pub repo: Option<String>,
|
||||
pub token: Option<String>,
|
||||
}
|
||||
|
||||
impl PartialConfig {
|
||||
// One lonely builder-pattern function to set the project path.
|
||||
// This is so I can do continuation style calls instead of a bunch of
|
||||
// successive `let conf = ...` temporaries.
|
||||
fn project_path(self, path: impl ToString) -> Self {
|
||||
PartialConfig {
|
||||
project_path: Some(path.to_string()),
|
||||
..self
|
||||
}
|
||||
}
|
||||
|
||||
// Merges two `PartialConfig`'s together, producing a new one.
|
||||
// Non-None values on the right-hand side are used to replace values
|
||||
// in the left-hand side, even if they are Some(_).
|
||||
fn merge(self, other: Self) -> Self {
|
||||
Self {
|
||||
project_path: other.project_path.or(self.project_path),
|
||||
gitea_url: other.gitea_url.or(self.gitea_url),
|
||||
owner: other.owner.or(self.owner),
|
||||
repo: other.repo.or(self.repo),
|
||||
token: other.token.or(self.token),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl TryFrom<&Table> for PartialConfig {
|
||||
type Error = crate::config::Error;
|
||||
|
||||
/// Scans properties out of a `toml::Table` to get a PartialConfig.
|
||||
///
|
||||
/// `Error::NoSuchProperty` is quietly ignored (mapped to `None`) since it
|
||||
/// isn't an error in this context.
|
||||
///
|
||||
/// All other errors are propagated and should be treated as real failures.
|
||||
fn try_from(value: &Table) -> Result<Self> {
|
||||
Ok(Self {
|
||||
// can't get table name because that key is gone by this point.
|
||||
project_path: None,
|
||||
gitea_url: get_maybe_property(value, "gitea_url")?.cloned(),
|
||||
owner: get_maybe_property(value, "owner")?.cloned(),
|
||||
repo: get_maybe_property(value, "repo")?.cloned(),
|
||||
token: get_maybe_property(value, "token")?.cloned(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// The outer value must be a Table so we can get the sub-table from it.
|
||||
fn get_table(outer: &Table, table_name: impl ToString) -> Result<&Table> {
|
||||
outer
|
||||
.get(&table_name.to_string())
|
||||
.ok_or(Error::NoSuchTable)?
|
||||
.as_table()
|
||||
.ok_or(Error::BadFormat)
|
||||
}
|
||||
|
||||
/// Similar to `get_property()` but maps the "Error::NoSuchProperty" result to
|
||||
/// Option::None. Some properties aren't specified, and that's okay... sometimes.
|
||||
fn get_maybe_property(outer: &Table, property: impl ToString) -> Result<Option<&String>> {
|
||||
let maybe_prop = get_property(outer, property);
|
||||
match maybe_prop {
|
||||
Ok(value) => Ok(Some(value)),
|
||||
Err(e) => {
|
||||
if let Error::NoSuchProperty = e {
|
||||
Ok(None)
|
||||
} else {
|
||||
Err(e)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The config properties are individual strings. This gets the named property,
|
||||
/// or an error explaining why it couldn't be fetched.
|
||||
fn get_property(outer: &Table, property: impl ToString) -> Result<&String> {
|
||||
let maybe_prop = outer
|
||||
.get(&property.to_string())
|
||||
.ok_or(Error::NoSuchProperty)?;
|
||||
if let Value::String(text) = maybe_prop {
|
||||
Ok(text)
|
||||
} else {
|
||||
Err(Error::BadFormat)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use toml::map::Map;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn read_single_prop() -> Result<()> {
|
||||
let fx_input_str = "owner = \"dingus\"";
|
||||
let fx_value = fx_input_str.parse::<Value>()?;
|
||||
let fx_value = fx_value.as_table().ok_or(Error::NoSuchTable)?;
|
||||
let expected = "dingus";
|
||||
|
||||
let res = get_property(&fx_value, String::from("owner"))?;
|
||||
assert_eq!(res, expected);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// The property is given the value of empty-string `""`
|
||||
#[test]
|
||||
fn read_single_prop_empty_quotes() -> Result<()> {
|
||||
let fx_input_str = "owner = \"\"";
|
||||
let fx_value = fx_input_str.parse::<Value>()?;
|
||||
let fx_value = fx_value.as_table().ok_or(Error::NoSuchTable)?;
|
||||
let expected = "";
|
||||
|
||||
let res = get_property(&fx_value, String::from("owner"))?;
|
||||
assert_eq!(res, expected);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_table() -> Result<()> {
|
||||
let fx_input_str = "[tab]\nwith_a_garbage = \"value\"";
|
||||
let fx_value = fx_input_str.parse::<Value>()?;
|
||||
let fx_value = fx_value.as_table().ok_or(Error::BadFormat)?;
|
||||
let mut expected: Map<String, Value> = Map::new();
|
||||
expected.insert(
|
||||
String::from("with_a_garbage"),
|
||||
Value::String(String::from("value")),
|
||||
);
|
||||
|
||||
let res = get_table(&fx_value, String::from("tab"))?;
|
||||
assert_eq!(res, &expected);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_get_config_with_specific_match() -> Result<()> {
|
||||
let search_paths = ["./test_data/sample_config.toml"]
|
||||
.into_iter()
|
||||
.map(PathBuf::from);
|
||||
let load_result = get_config("/home/robert/projects/gt-tool", search_paths)?;
|
||||
let expected = PartialConfig {
|
||||
project_path: Some(String::from("/home/robert/projects/gt-tool")),
|
||||
owner: Some(String::from("robert")),
|
||||
repo: Some(String::from("gt-tool")),
|
||||
gitea_url: Some(String::from("http://localhost:3000")),
|
||||
token: Some(String::from("fake-token")),
|
||||
};
|
||||
|
||||
assert_eq!(load_result, expected);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Ensure the config comes back with something even when there is no
|
||||
// matching project-specific table.
|
||||
#[test]
|
||||
fn test_get_config_no_specific_match() -> Result<()> {
|
||||
let search_paths = ["./test_data/sample_config.toml"]
|
||||
.into_iter()
|
||||
.map(PathBuf::from);
|
||||
let load_result = get_config("/no/such/project", search_paths)?;
|
||||
let expected = PartialConfig {
|
||||
project_path: Some(String::from("/no/such/project")),
|
||||
owner: None,
|
||||
repo: None,
|
||||
gitea_url: Some(String::from("http://localhost:3000")),
|
||||
token: Some(String::from("fake-token")),
|
||||
};
|
||||
assert_eq!(load_result, expected);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Ensure the config comes back with something even when there is no
|
||||
// "[all]" table
|
||||
#[test]
|
||||
fn test_get_config_without_all() -> Result<()> {
|
||||
let search_paths = ["./test_data/missing_all_table.toml"]
|
||||
.into_iter()
|
||||
.map(PathBuf::from);
|
||||
let load_result = get_config("/some/other/path", search_paths)?;
|
||||
let expected = PartialConfig {
|
||||
project_path: Some(String::from("/some/other/path")),
|
||||
gitea_url: Some(String::from("fake-url")),
|
||||
..PartialConfig::default()
|
||||
};
|
||||
assert_eq!(load_result, expected);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// Ensure that trying to load files that don't exist simply get skipped over
|
||||
// instead of causing a short-circuit exit or other bogus output.
|
||||
#[test]
|
||||
fn test_get_config_many_missing_files() -> Result<()> {
|
||||
let search_paths = [
|
||||
"./test_data/not_real_1.toml",
|
||||
"./test_data/not_real_2.toml",
|
||||
"./test_data/not_real_3.toml",
|
||||
"./test_data/not_real_4.toml",
|
||||
"./test_data/not_real_5.toml",
|
||||
"./test_data/sample_config.toml",
|
||||
"./test_data/not_real_6.toml",
|
||||
]
|
||||
.into_iter()
|
||||
.map(PathBuf::from);
|
||||
let load_result = get_config("/home/robert/projects/gt-tool", search_paths)?;
|
||||
let expected = PartialConfig {
|
||||
project_path: Some(String::from("/home/robert/projects/gt-tool")),
|
||||
owner: Some(String::from("robert")),
|
||||
repo: Some(String::from("gt-tool")),
|
||||
gitea_url: Some(String::from("http://localhost:3000")),
|
||||
token: Some(String::from("fake-token")),
|
||||
};
|
||||
|
||||
assert_eq!(load_result, expected);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
19
src/lib.rs
19
src/lib.rs
@@ -2,7 +2,6 @@ use serde::{Deserialize, Serialize};
|
||||
|
||||
pub mod api;
|
||||
pub mod cli;
|
||||
pub mod config;
|
||||
pub mod structs;
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
@@ -11,21 +10,9 @@ pub struct ApiError {
|
||||
url: String,
|
||||
}
|
||||
|
||||
pub(crate) async fn decode_client_error(response: reqwest::Response) -> Result<ApiError> {
|
||||
response
|
||||
.json::<ApiError>()
|
||||
.await
|
||||
.map_err(crate::Error::WrappedReqwestErr)
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Error {
|
||||
Placeholder, // TODO: Enumerate error modes
|
||||
MissingGiteaUrl, // the gitea URL wasn't specified on the CLI, env, or config file.
|
||||
MissingRepoFRQN, // either the owner, repo, or both weren't specified in the loaded PartialConfig
|
||||
MissingRepoOwner,
|
||||
MissingRepoName,
|
||||
WrappedConfigErr(config::Error),
|
||||
WrappedReqwestErr(reqwest::Error),
|
||||
MissingAuthToken,
|
||||
NoSuchFile, // for release attachment 'file exists' pre-check.
|
||||
@@ -39,10 +26,4 @@ impl From<reqwest::Error> for crate::Error {
|
||||
}
|
||||
}
|
||||
|
||||
impl From<crate::config::Error> for crate::Error {
|
||||
fn from(value: crate::config::Error) -> Self {
|
||||
Self::WrappedConfigErr(value)
|
||||
}
|
||||
}
|
||||
|
||||
type Result<T> = core::result::Result<T, Error>;
|
||||
|
||||
94
src/main.rs
94
src/main.rs
@@ -1,5 +1,3 @@
|
||||
use std::path::{self, PathBuf};
|
||||
|
||||
use gt_tool::cli::Args;
|
||||
use gt_tool::structs::release::{CreateReleaseOption, Release};
|
||||
|
||||
@@ -12,38 +10,6 @@ use reqwest::header::ACCEPT;
|
||||
async fn main() -> Result<(), gt_tool::Error> {
|
||||
let args = Args::parse();
|
||||
|
||||
let project_path =
|
||||
args.project
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or(std::env::current_dir().map_err(|_e| {
|
||||
gt_tool::Error::WrappedConfigErr(gt_tool::config::Error::CouldntReadFile)
|
||||
})?);
|
||||
let config = gt_tool::config::get_config(
|
||||
project_path
|
||||
.to_str()
|
||||
.expect("I assumed the path can be UTF-8, but that didn't work out..."),
|
||||
gt_tool::config::default_paths(),
|
||||
)?;
|
||||
println!("->> Loaded Config: {config:?}");
|
||||
// arg parser also checks the environment. Prefer CLI/env, then config file.
|
||||
let gitea_url = args
|
||||
.gitea_url
|
||||
.or(config.gitea_url)
|
||||
.ok_or(gt_tool::Error::MissingGiteaUrl)?;
|
||||
|
||||
let owner = args
|
||||
.owner
|
||||
.or(config.owner)
|
||||
.ok_or(gt_tool::Error::MissingRepoOwner)?;
|
||||
|
||||
let repo = args
|
||||
.repo
|
||||
.or(config.repo)
|
||||
.or_else(infer_repo)
|
||||
.ok_or(gt_tool::Error::MissingRepoName)?;
|
||||
|
||||
let repo_fqrn = format!("{owner}/{repo}");
|
||||
|
||||
let mut headers = reqwest::header::HeaderMap::new();
|
||||
headers.append(ACCEPT, header::HeaderValue::from_static("application/json"));
|
||||
|
||||
@@ -53,23 +19,20 @@ async fn main() -> Result<(), gt_tool::Error> {
|
||||
headers.append("Authorization", token.parse().unwrap());
|
||||
}
|
||||
let client = reqwest::Client::builder()
|
||||
.user_agent(format!("gt-tools-agent-{}", env!("CARGO_PKG_VERSION")))
|
||||
.user_agent(format!(
|
||||
"gt-tools-agent-{}",
|
||||
env!("CARGO_PKG_VERSION")
|
||||
))
|
||||
.default_headers(headers)
|
||||
.build()?;
|
||||
|
||||
match args.command {
|
||||
gt_tool::cli::Commands::ListReleases => {
|
||||
let releases =
|
||||
gt_tool::api::release::list_releases(&client, &gitea_url, &repo_fqrn).await?;
|
||||
// Print in reverse order so the newest items are closest to the
|
||||
// user's command prompt. Otherwise the newest item scrolls off the
|
||||
// screen and can't be seen.
|
||||
itertools::Itertools::intersperse(
|
||||
releases.iter().rev().map(|release| release.colorized()),
|
||||
String::from(""),
|
||||
)
|
||||
.map(|release| println!("{release}"))
|
||||
.fold((), |_, _| ());
|
||||
gt_tool::api::release::list_releases(&client, &args.gitea_url, &args.repo).await?;
|
||||
for release in releases {
|
||||
println!("{:?}", release);
|
||||
}
|
||||
}
|
||||
gt_tool::cli::Commands::CreateRelease {
|
||||
name,
|
||||
@@ -86,7 +49,12 @@ async fn main() -> Result<(), gt_tool::Error> {
|
||||
tag_name,
|
||||
target_commitish,
|
||||
};
|
||||
gt_tool::api::release::create_release(&client, &gitea_url, &repo_fqrn, submission)
|
||||
gt_tool::api::release::create_release(
|
||||
&client,
|
||||
&args.gitea_url,
|
||||
&args.repo,
|
||||
submission,
|
||||
)
|
||||
.await?;
|
||||
}
|
||||
gt_tool::cli::Commands::UploadRelease {
|
||||
@@ -107,28 +75,17 @@ async fn main() -> Result<(), gt_tool::Error> {
|
||||
// Grab all, find the one that matches the input tag.
|
||||
// Scream if there are multiple matches.
|
||||
let release_candidates =
|
||||
gt_tool::api::release::list_releases(&client, &gitea_url, &repo_fqrn).await?;
|
||||
gt_tool::api::release::list_releases(&client, &args.gitea_url, &args.repo).await?;
|
||||
|
||||
if let Some(release) = match_release_by_tag(&tag_name, release_candidates) {
|
||||
for file in &files {
|
||||
let path = path::Path::new(&file);
|
||||
match path.try_exists() {
|
||||
Ok(true) => continue,
|
||||
Ok(false) => return Err(gt_tool::Error::NoSuchFile),
|
||||
Err(e) => {
|
||||
eprintln!("Uh oh! The file-exists check couldn't be done: {e}");
|
||||
panic!(
|
||||
"TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
for file in files {
|
||||
let _attach_desc = gt_tool::api::release_attachment::create_release_attachment(
|
||||
&client, &gitea_url, &repo_fqrn, release.id, file,
|
||||
gt_tool::api::release_attachment::create_release_attachment(
|
||||
&client,
|
||||
&args.gitea_url,
|
||||
&args.repo,
|
||||
release.id,
|
||||
files,
|
||||
)
|
||||
.await?;
|
||||
}
|
||||
} else {
|
||||
println!("ERR: Couldn't find a release matching the tag \"{tag_name}\".");
|
||||
return Err(gt_tool::Error::NoSuchRelease);
|
||||
@@ -170,12 +127,5 @@ fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release>
|
||||
}
|
||||
}
|
||||
}
|
||||
release
|
||||
}
|
||||
|
||||
fn infer_repo() -> Option<String> {
|
||||
let pwd = std::env::current_dir().ok()?;
|
||||
let file_name = pwd.file_name()?;
|
||||
let file_name_string = file_name.to_str()?;
|
||||
Some(String::from(file_name_string))
|
||||
return release;
|
||||
}
|
||||
|
||||
@@ -1,15 +1,2 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
pub mod release;
|
||||
pub mod repo;
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Attachment {
|
||||
id: usize,
|
||||
name: String,
|
||||
size: i64,
|
||||
download_count: i64,
|
||||
created_at: String, // TODO: Date-time struct
|
||||
uuid: String,
|
||||
browser_download_url: String,
|
||||
}
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
use colored::Colorize;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
@@ -20,36 +19,6 @@ pub struct Release {
|
||||
author: Author,
|
||||
}
|
||||
|
||||
impl Release {
|
||||
pub fn colorized(&self) -> String {
|
||||
let tag = "Tag:".green().bold();
|
||||
let name = "Name:".green();
|
||||
let published = "Published:".bright_green();
|
||||
let created = "Created:".green().dimmed();
|
||||
let author = "Author:".blue();
|
||||
let body = if !self.body.is_empty() {
|
||||
&self.body.white()
|
||||
} else {
|
||||
&String::from("(empty body)").dimmed()
|
||||
};
|
||||
|
||||
format!(
|
||||
"{tag} {}
|
||||
{name} {}
|
||||
{}
|
||||
{published} {} ({created} {})
|
||||
{author} {} ({})",
|
||||
self.tag_name.bold(),
|
||||
self.name,
|
||||
body,
|
||||
self.published_at,
|
||||
self.created_at.dimmed(),
|
||||
self.author.login,
|
||||
self.author.email,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize, Serialize)]
|
||||
pub struct Author {
|
||||
id: usize,
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
# There must be an "[all]" table or the loader will reject the config file.
|
||||
|
||||
["/some/other/path"]
|
||||
gitea_url = "fake-url"
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
[all]
|
||||
gitea_url = "http://localhost:3000"
|
||||
token = "fake-token"
|
||||
|
||||
["/home/robert/projects/gt-tool"]
|
||||
owner = "robert"
|
||||
repo = "gt-tool"
|
||||
|
||||
["/home/robert/projects/rcalc"]
|
||||
owner = "jamis"
|
||||
repo = "rcalc"
|
||||
|
||||
["/home/robert/projects/rcalc-builders"]
|
||||
owner = "jamis"
|
||||
repo = "rcalc"
|
||||
Reference in New Issue
Block a user