artifactory-version-management 0.0.8
A solution to manage artifactory versions for projects
Requires Python: >=3.8

# Artifactory Version Management

## Context

`artifactory-version-management` is used to supplement the Development and
Productionization Process that Python projects follow.

Ex. Your project is currently at version 2.0.1. You would add a bug fix to
the project as follows:

* Create a branch. When you have preliminary changes you would like to
test, commit them and upload your project as a whl file to AWS S3.
You can then install that whl file to test your changes. This prevents
an overload of packages beng published to Artifactory while your changes
are still being tested.
* Once your changes are ready to be reviewed, open a PR and publish
package version 2.0.2.dev0 to Artifactory. Your changes can then
be tested by installing that package from Artifactory.
* If additional changes are needed to your PR, publish versions
2.0.2.dev1, 2.0.2.dev2, etc, and test your changes the same way.
* Once your changes are approved, strip the dev syntax and publish
package version 2.0.2 to Artifactory before merging.

In this example, if you were to add a new feature, you would instead
publish the packages 2.1.0.dev0 -> 2.1.0.dev1 -> etc -> 2.1.0
And if you were to add a new major change, you would instead publish
the packages 3.0.0.dev0 -> 3.0.0.dev1 -> etc -> 3.0.0

The `artifactory-version-management` package was created to check that
you are properly bumping the your version number at every step of the process.
We will discuss how specifically it works as well as the special cases
it handles.

## Setup and how it works

`artifactory-version-management` can enforce package rules in two ways. For both
methods, if your pakage bump is incorrect, it will tell you the correct version to
bump to. It is recommend to set up both methods.

### As a pre-push check locally

`artifactory-version-management` can run when you push your branch locally
and block your push if the package rules are not followed.

To setup this pre-push check:

1. Install pre-commit by running `pip install pre-commit`. This is the library
   that powers our pre-push check.
2. Add the pre-push hook to pre-commit by running:
   `pre-commit install --hook-type pre-commit --hook-type pre-push`
3. Make your pre-push script executable by running:
   `chmod +x .git/hooks/pre-commit` and `chmod +x .git/hooks/pre-push`
4. Run the following commands to add Artifactory and GitHub credentials that
   will allow the script to run:
    * export ARTIFACTORY_USER=artifactory_user
    * export ARTIFACTORY_PWD=artifactory_pwd
    * export ARTIFACTORY_BASE_URL=artifactory_base_url
    * export ARTIFACTORY_REPO=artifactory_repo
    * export ARTIFACTORY_PKG=artifactory_pkg
    * export GITHUB_ORG=your_org
    * export GITHUB_REPO=your_repo
    * export GITHUB_PAT=your_token

   The Artifactory credentials are necessary to ensure that you're not
   publishing a conflicting version of the package. And the GitHub
   credentials are necessary to determine if there is an open PR for
   your branch and if you are at the stage of the development process
   where you should be publishing packages.

After these steps, create a `.pre-commit-config.yaml` file with the
following code:

```
default_stages: [pre-push]

repos:
  - repo: local
    hooks:
      - id: check-version-bump
        name: check-version-bump
        entry: bash -c "pip3 install artifactory-version-management --upgrade && python3 -m artifactory-version-management"
        language: python
        pass_filenames: false
        additional_dependencies: [requests]
```

This code uses the `install --upgrade` command at every run to reflect new
changes in the package. (*NOTE*: When this package becomes stable, this may be
removed and `artifactory-version-management` should then be added to
additional_dependencies. As an additional dependency, you'll then need to
install it locally by running `pip3 install artifactory-version-management`)

`artifactory-version-management` will run automatically everytime you push
locally. If your push is blocked, you will have the opportunity to fix
them and push again.

### As a Jenkins check

In your `Jenkinsfile`, add this command so that the version check will trigger
on every commit in an open PR.

```
pip3 install requests
pip3 install artifactory-version-management --upgrade
python3 -m artifactory-version-management --ARTIFACTORY_USER=${ARTIFACTORY_USERNAME} --ARTIFACTORY_PWD=${ARTIFACTORY_PASSWORD} --ARTIFACTORY_BASE_URL=${ARTIFACTORY_BASE_URL} --ARTIFACTORY_REPO=${ARTIFACTORY_REPO} --ARTIFACTORY_PKG=${ARTIFACTORY_PKG}
```

Be sure to replace the variables accordingly. Unlike the pre-push check, we
specify the Artifactory credentials via command line arguments as you won't
be able to read exported variables locally. And we don't need GitHub credentials
as running this check from Jenkins already establishes that you have an open PR
and should be publishing new changes to Artifactory.

## Managing multiple developers

This script is particularly useful for avoiding package version conflicts when
multiple developers are contributing to a project.

Ex. Your project is currently at version 2.0.1.
* Developers A and B branch off and work on bug fixes.
* Developer C branches off and works on a new feature.
* Dev A is ready to open a PR and publishes 2.0.2.dev0
* Dev B is ready to open a PR. They attempt to publish 2.0.2.dev0, but the
script informs them that someone else is already using 2.0.2, so they
instead publish 2.0.3.dev0
* Dev C is ready to open a PR and publishes 2.1.0.dev0
* Dev A gets their PR approved, publishes 2.0.2, and merges.
* Dev C gets their PR approved, publishes 2.1.0, and merges.
* Dev B gets their PR approved and attempts to publish 2.0.3. But the script
informs them that they are behind the highest version of 2.1.0. So they
instead publish 2.1.1 and merge.

The version management ensures that no two developers publish the same
package and that no complete package version (without the dev syntax)
is published behind an existing higher version.

## Managing failed to publish versions

There are situations in which the CI/CD pipeline may fail to publish
your package after your local check passes. Ways this can happen include
if there are syntax errors in your `Jenkinsfile` causing the CI/CD
to break or if artifactory is down when you attempt to publish your package.

When you publish a sequential dev version of your package, the script will
check if your last dev version successfully published. And if not, it will
have you re-publish your last version.

## Bypassing the check and caveats

`artifactory-version-management` can be buggy when checking your version
bump after resolving a merge conflict. There maybe be other bugs as well
that I will work to resolve. But in the meantime, if you need to bypass
the check for this reason, you can run:

```
python -m artifactory-version-management SKIP=True
```