diff --git a/.forgejo/workflows/build-image.yml b/.forgejo/workflows/build-image.yml index d5c200e..3794bd8 100644 --- a/.forgejo/workflows/build-image.yml +++ b/.forgejo/workflows/build-image.yml @@ -5,22 +5,40 @@ on: jobs: build: - runs-on: ubuntu-latest + runs-on: docker + container: + image: ubuntu:latest steps: - - name: Checkout - uses: actions/checkout@v4 + - name: Checkout + uses: actions/checkout@v4 - - name: Clear image from cache - run: | - docker images git.kemitix.net/${{ env.GITHUB_REPOSITORY }} -q | sort -u | xargs -r docker rmi --force - docker system prune --force --all + - name: login to docker registry + uses: docker/login-action@v3 + with: + registry: git.ragarock.moe + username: silvana + password: ${{ secrets.REGISTRY_TOKEN }} - - name: Build - run: docker build . -t git.kemitix.net/${{ env.GITHUB_REPOSITORY }}:latest + - name: setup buildx + uses: docker/setup-buildx-action@v3 - - name: Login - run: docker login git.kemitix.net --username kemitix --password ${{ secrets.FORGEJO_TOKEN_WRITE_PACKAGE }} + - name: build and push + uses: docker/build-push-action@v6 + with: + push: true + tags: git.ragarock.moe/${{ env.GITHUB_REPOSITORY }}:latest - - name: Publish - run: docker push git.kemitix.net/${{ env.GITHUB_REPOSITORY }}:latest + # - name: Clear image from cache + # run: | + # docker images git.ragarock.moe/${{ env.GITHUB_REPOSITORY }} -q | sort -u | xargs -r docker rmi --force + # docker system prune --force --all + + # - name: Build + # run: docker build . -t git.ragarock.moe/${{ env.GITHUB_REPOSITORY }}:latest + + # - name: Login + # run: docker login git.ragarock.moe --username silvana --password ${{ secrets.FORGEJO_TOKEN_WRITE_PACKAGE }} + + # - name: Publish + # run: docker push git.ragarock.moe/${{ env.GITHUB_REPOSITORY }}:latest diff --git a/.forgejo/workflows/push-next.yml b/.forgejo/workflows/push-next.yml index 6c800c1..8aca99b 100644 --- a/.forgejo/workflows/push-next.yml +++ b/.forgejo/workflows/push-next.yml @@ -6,14 +6,12 @@ jobs: test: runs-on: docker container: - image: - git.kemitix.net/kemitix/rust:v3.1.0 + image: git.ragarock.moe/silvana/rust:latest strategy: matrix: toolchain: - name: stable - name: nightly - - name: 1.74.1 steps: - uses: actions/checkout@v4 diff --git a/Cargo.toml b/Cargo.toml index 7d75412..4b31261 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,3 +4,5 @@ version = "0.1.0" edition = "2021" [dependencies] +kxio = "5.1" +tokio = { version = "1.43", features = ["full"] } diff --git a/Dockerfile b/Dockerfile index 34f2553..15fbcaf 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,16 +1,8 @@ FROM docker.io/rust:1.84.0-alpine3.21 -LABEL org.opencontainers.image.source=https://git.kemitix.net/kemitix/rust - -# nodejs - runtime used by forgejo/github actions -# curl - to download cargo-binstall -# clang & mold - faster linkers for rust -# pkgconfig - required to compile some rust `-sys` packages -# openssl-dev - build dependency for git-next -# dbus-dev - linux os interop (e.g. desktop notifications) -# git - git -RUN apk add nodejs curl clang pkgconfig mold openssl-dev dbus-dev git bash +LABEL org.opencontainers.image.source=https://git.ragarock.moe/silvana/rust +RUN apk add --no-cache curl=8.11.1-r0 RUN curl -L https://github.com/cargo-bins/cargo-binstall/releases/download/v1.10.19/cargo-binstall-x86_64-unknown-linux-musl.tgz -o cargo-binstall.tgz && \ tar -xzf cargo-binstall.tgz && \ rm cargo-binstall.tgz && \ @@ -23,17 +15,41 @@ RUN cargo binstall -y \ cargo-mutants@25.0 \ release-plz@0.3 -# install v1.74.1 -RUN rustup install 1.74.1 && rustup component add --toolchain 1.74.1 rustfmt clippy - # should be a no-op if the FROM line is up-to-date -RUN rustup update stable && rustup component add --toolchain stable rustfmt clippy +RUN rustup update stable + +RUN rustup component add --toolchain stable-x86_64-unknown-linux-musl rustfmt clippy # install nightly RUN rustup install nightly && rustup component add --toolchain nightly rustfmt clippy -RUN git config --global user.email "action@git.kemitix.net" && \ - git config --global user.name "ForgeJo Action. See: https://git.kemitix.net/kemitix/rust" +# nodejs - runtime used by forgejo/github actions +# curl - to download cargo-binstall +# clang & mold - faster linkers for rust +# pkgconfig - required to compile some rust `-sys` packages +# openssl-dev - build dependency for git-next +# dbus-dev - linux os interop (e.g. desktop notifications) +# perl - native-tls(vendored) +# git - git +RUN apk add --no-cache \ + bash \ + nodejs \ + build-base \ + pkgconfig \ + libssl3 \ + openssl-dev \ + perl \ + dbus-dev \ + git + + # clang \ + + # mold \ + + # dbus-dev \ + +RUN git config --global user.email "holo@ragarock.moe" && \ + git config --global user.name "ForgeJo Action. See: https://git.ragarock.moe/silvana/rust" COPY scripts/ /usr/local/bin/ diff --git a/README.md b/README.md index 9e42799..cf908c1 100644 --- a/README.md +++ b/README.md @@ -42,6 +42,8 @@ The available toolchain in the image are: - cargo-chef - cargo-hack - release-plz +- dbus-dev +- perl ### Scripts @@ -57,3 +59,36 @@ steps: - name: Check for Ignored Files run: check-for-ignored ``` + +## Caveats + +### openssl + +The alpine linux install doesn't build with this dependency. You can either compile `native-tls` with the `vendored` feature, or not use `openssl`. + +#### vendoered native-tls + +This crate *must* use the `vendored` feature in order to compile in the Alpine Linux image. + +```toml +native-tls = { version = "0.2", features = ["vendored"] } +``` + +#### Don't use `openssl` + +Check that none of your dependencies require `openssl`: + +```bash +cargo tree --edges normal -i openssl +``` + +This will list the tree of dependencies that are bringing in `openssl`. + +If you do need ssl/tls, try using `rustls`. e.g. + +```toml +reqwest = { version = "0.12", default-features = false, features = [ + "json", + "rustls-tls", +] } +``` diff --git a/justfile b/justfile new file mode 100644 index 0000000..373ea93 --- /dev/null +++ b/justfile @@ -0,0 +1,19 @@ +image := "git.ragarock.moe/silvana/rust:test" + +build: + docker build . -t {{ image }} + +test: build + docker run --rm -v $PWD:/app/ {{ image }} cargo test + +clippy: build + docker run --rm -v $PWD:/app/ {{ image }} cargo clippy + +run: build + docker run --rm -v $PWD:/app/ {{ image }} cargo run + +fmt: build + docker run --rm -v $PWD:/app/ {{ image }} cargo fmt + +shell: build + docker run --rm -it -v $PWD:/app/ {{ image }} bash diff --git a/src/kxio.rs b/src/kxio.rs new file mode 100644 index 0000000..1d56825 --- /dev/null +++ b/src/kxio.rs @@ -0,0 +1,105 @@ +/// This is an example to show fetching a file from a webiste and saving to a file +/// +/// The example consts of: +/// +/// - The main program, in `main()` - demonstrates how to setup `kxio` for use in prod +/// - A test module - demonstrates how to use `kxio` in tests +/// - sample functions - showing how to use `kxio` the body of your program, and be testable +/// +/// NOTE: running this program with `cargo run --example get` will create and delete the file +/// `example-readme.md` in the current directory. +use std::path::Path; + +use kxio::fs::FileHandle; + +// #[tokio::main] +pub async fn main() -> kxio::Result<()> { + // Create a `Net` object for making real network requests. + let net: kxio::net::Net = kxio::net::new(); + + // Create a `FileSystem` object for accessing files within the current directory. + // The object created will return a `PathTraveral` error result if there is an attempt to\ + // access a file outside of this directory. + let current_dir = std::env::current_dir().map_err(kxio::fs::Error::Io)?; + let fs: kxio::fs::FileSystem = kxio::fs::new(current_dir); + + // The URL we will fetch - the readme for this library. + let url = "https://git.kemitix.net/kemitix/kxio/raw/branch/main/README.md"; + + // Create a PathBuf to a file within the directory that the `fs` object has access to. + let file_path = fs.base().join("example-readme.md"); + + // Create a generic handle for the file. This doesn't open the file, and always succeeds. + let path = fs.path(&file_path); + + // Other options are; + // `fs.file(&file_path)` - for a file + // `fs.dir(&dir_path)` - for a directory + + // Checks if the path exists (whether a file, directory, etc) + if path.exists()? { + eprintln!("The file {path} already exists. Aborting!"); + return Ok(()); + } + + // Passes a reference to the `fs` and `net` objects for use by your program. + // Your programs should not know whether they are handling a mock or the real thing. + // Any file or network access should be made using these handlers to be properly testable. + let file = download_and_save_to_file(url, &file_path, &fs, &net).await?; + read_file(&file)?; + delete_file(file)?; + + Ok(()) +} + +/// An function that uses a `FileSystem` and a `Net` object to interact with the outside world. +async fn download_and_save_to_file( + url: &str, + file_path: &Path, + // The filesystem abstraction + fs: &kxio::fs::FileSystem, + // The network abstraction + net: &kxio::net::Net, +) -> kxio::Result { + println!("fetching: {url}"); + + // Makes a GET request that can be mocked in a test + let response = net.get(url).header("key", "value").send().await?; + + // As you can see, we use [reqwest] under the hood. + // + // If you need to create a more complex request than the [kxio] fluent API allows, you + // can create a request using [reqwest] and pass it to [net.send(request)]. + + let body = response.text().await?; + println!("fetched {} bytes", body.bytes().len()); + + // Uses the file system abstraction to create a handle for a file. + let file: kxio::fs::PathReal = fs.file(file_path); + println!("writing file: {file}"); + // Writes the body to the file. + file.write(body)?; + + Ok(file) +} + +/// A function that reads the file contents +fn read_file(file: &FileHandle) -> kxio::Result<()> { + println!("reading file: {file}"); + + // Creates a `Reader` which loaded the file into memory. + let reader: kxio::fs::Reader = file.reader()?; + let contents: &str = reader.as_str()?; + println!("{contents}"); + + Ok(()) +} + +/// A function that deletes the file +fn delete_file(file: FileHandle) -> kxio::Result<()> { + println!("deleting file: {file}"); + + file.remove()?; + + Ok(()) +} diff --git a/src/main.rs b/src/main.rs index e7a11a9..93488b4 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,3 +1,17 @@ -fn main() { +// +mod kxio; + +fn main() -> Result<(), Box> { println!("Hello, world!"); + + let rt = tokio::runtime::Runtime::new()?; + Ok(rt.block_on(crate::kxio::main())?) +} + +#[cfg(test)] +mod tests { + #[test] + fn passes() { + println!("passes okay"); + } }