Metadata-Version: 2.4
Name: ichec_cicd
Version: 0.1.14
Summary: A collection of utilities to manage ICHEC project CI/CD pipelines.
Author: Irish Centre for High End Computing
License: MIT
Project-URL: Repository, https://git.ichec.ie/platform-engineering/modules/cicd/ichec-cicd
Project-URL: Homepage, https://git.ichec.ie/platform-engineering/modules/cicd/ichec-cicd
Keywords: CICD,HPC,Gitlab
Classifier: Development Status :: 3 - Alpha
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.14
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Topic :: System :: Distributed Computing
Requires-Python: >=3.14
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: build
Requires-Dist: twine
Requires-Dist: ichec_platform_core>=0.0.4
Requires-Dist: tomlkit
Requires-Dist: Jinja2
Dynamic: license-file

# ichec_cicd

This project is a collection of utilities for managing CI/CD pipelines at ICHEC.

It provides opinionated interfaces to encourage standarization of our project structures and workflows.

# Install

The package is available from PyPI:

```sh
pip install ichec_cicd
```

# Features #

## Deploy a Package to a Repository

From the package's top-level directory:

```sh
ichec_cicd deploy --token $REPO_TOKEN
```

As an example, for a Python project this might be the PyPI repository's token.

## Set a Package's Version Number

From the package's top-level directory:

```sh
ichec_cicd set_version $VERSION
```

## Increment a Repository's Tag ##

From the repository's top-level directory, and on the branch the tag will be dervied from:

``` sh
ichec_cicd increment_tag --field patch
```

Here `semver` tag versioning is assumed with a `major.minor.patch` scheme. Note: in a CI/CD pipeline some more input options are needed to initialize the git repo for pushing the tag to. You can use the `--help` flag for more details.

## Sync Content With an External Upstream ##

Here we pull content from an external upstream repository and use it to update the content in a local repo. This can be useful for public mirrors that include a subset of the content in an internal repo.

``` sh
ichec_cicd sync_external_archive \
    --source_token $SOURCE_TOKEN \ 
    --project_id $SOURCE_PROJ_ID \
    --sync_script $MY_SYNC_SCRIPT \
    --asset_name $ASSET_NAME \
    --archive_name $ARCHIVE_NAME \
    --target_token $TARGET_TOKEN
```

The inputs are:

* `SOURCE_TOKEN`: Gitlab access token for the source (private) repo - must have asset download rights
* `SOURCE_PROJ_ID`: The numeric project ID for the source repo
* `MY_SYNC_SCRIPT`: Path to a script that will use the extracted contents of the source archive to update the target repo
* `ASSET_NAME`: Name of the asset corresponding to the archive in the source repo's latest release collection
* `ARCHIVE_NAME`: Name of the downloaded file corresponding to the archive - this can differ from the asset name.
* `TARGET_TOKEN`: OATH token for the target repo - so that it can be pushed to from a CI runner

## Generate a containerfile ##

Here we generate a containerfile from a template given a release manifest in a repo:

``` sh
ichec_cicd containerfile generate --manifest <path_to_manifest> --template_dir <container_templates> 
```

where `<path_to_manifest>` is the path to an ICHEC release manifest and `<container_template>` is a directory with container templates.


## Containerize a Web App ##

Here we set up a standardized container build context for web applications, i.e. Django or FastAPI apps.

``` sh
ichec_cicd wrap --project <project_to_wrap> --template <wrapping_template> 
```

where `<project_to_wrap>` is a url or filesystem path to a repository with the project to be wrapped and `<wrapping_template>` is a url or path to a repository with a template to do the wrapping. The project to be wrapped needs to have an `ichec_manifest.yml` file at its top level with package metadata and the `<wrapping_template>` should match the framework being used, e.g. (Django/FastAPI).

# Licensing #

This project is licensed under the MIT License. See the accompanying `LICENSE` file for details.

