rwx.work/spcd
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: rwx.work:c5c01f14cb477b32bc2eae4379555d21a6c70654
Branches Tags
rwx.work:main
rwx.work:dev
..
compare: rwx.work:95c3e169710edc93c4f03453f9722e3a9a1e9987
Branches Tags
rwx.work:main
rwx.work:dev

No commits in common. "c5c01f14cb477b32bc2eae4379555d21a6c70654" and "95c3e169710edc93c4f03453f9722e3a9a1e9987" have entirely different histories.
c5c01f14cb ... 95c3e16971

39 changed files with 1113 additions and 1116 deletions
Show stats Expand all files Collapse all files

16
.forgejo/workflows/almalinux:8.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: almalinux:8
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/almalinux:9.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: almalinux:9
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/almalinux_8.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: almalinux:8
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/almalinux_9.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: almalinux:9
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/alpine:3.18.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: alpine:3.18
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/alpine:3.19.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: alpine:3.19
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/alpine_3.18.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: alpine:3.18
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/alpine_3.19.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: alpine:3.19
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/archlinux:base-20231112.0.191179.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: archlinux:base-20231112.0.191179
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/archlinux:base-20240101.0.204074.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: archlinux:base-20240101.0.204074
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/archlinux_base-20231112.0.191179.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: archlinux:base-20231112.0.191179
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/archlinux_base-20240101.0.204074.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: archlinux:base-20240101.0.204074
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

17
.forgejo/workflows/debian:bookworm.yaml Normal file
View file

@ -0,0 +1,17 @@
on: [push]
jobs:
job:
container:
image: debian:bookworm
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace
- run: cd-synchronize

16
.forgejo/workflows/debian:bullseye.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: debian:bullseye
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

17
.forgejo/workflows/debian_bookworm.yaml
View file

@ -1,17 +0,0 @@
on: [push]
jobs:
job:
container:
image: debian:bookworm
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace
- run: cidd-synchronize

16
.forgejo/workflows/debian_bullseye.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: debian:bullseye
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/fedora:39.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: fedora:39
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/fedora:40.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: fedora:40
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/fedora_39.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: fedora:39
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/fedora_40.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: fedora:40
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/rockylinux:8.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: rockylinux:8
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/rockylinux:9.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: rockylinux:9
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/rockylinux_8.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: rockylinux:8
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/rockylinux_9.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: rockylinux:9
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/ubuntu:jammy.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: ubuntu:jammy
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/ubuntu:noble.yaml Normal file
View file

@ -0,0 +1,16 @@
on: [push]
jobs:
job:
container:
image: ubuntu:noble
steps:
- name: cd
run: >
${{vars.CD}}
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace

16
.forgejo/workflows/ubuntu_jammy.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: ubuntu:jammy
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

16
.forgejo/workflows/ubuntu_noble.yaml
View file

@ -1,16 +0,0 @@
on: [push]
jobs:
job:
container:
image: ubuntu:noble
steps:
- name: cidd
run: >
${{vars.CIDD}}
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace

18
.github/workflows/debian:bookworm.yaml vendored
View file

@ -5,14 +5,14 @@ jobs:
container:
image: debian:bookworm
steps:
- name: cidd
- name: cd
run: >
echo '${{vars.CIDD}}' | tr -d '\r' | sh -s
"${{secrets.CIDD_SSH_KEY}}"
"${{vars.CIDD_SSH_HOSTS}}"
echo '${{vars.CD}}' | tr -d '\r' | sh -s
"${{secrets.CD_SSH_KEY}}"
"${{vars.CD_SSH_HOSTS}}"
- run: cidd-list-environment
- run: cidd-clone-branch
- run: cidd-build-project
- run: cidd-browse-workspace
- run: cidd-synchronize
- run: cd-list-environment
- run: cd-clone-branch
- run: cd-build-project
- run: cd-browse-workspace
- run: cd-synchronize

14
.gitlab-ci.yml
View file

@ -2,11 +2,11 @@ image: debian:bookworm
job:
script:
- >
sh ${CIDD}
${CIDD_SSH_KEY}
${CIDD_SSH_HOSTS}
sh ${CD}
${CD_SSH_KEY}
${CD_SSH_HOSTS}
- cidd-list-environment
- cidd-clone-branch
- cidd-build-project
- cidd-browse-workspace
- cd-list-environment
- cd-clone-branch
- cd-build-project
- cd-browse-workspace

817
cd.sh Normal file
View file

@ -0,0 +1,817 @@
#! /usr/bin/env sh
# defaults
[ -n "${CD_DNS}" ] || CD_DNS="\
9.9.9.9 \
"
[ -n "${CD_GIT_CHILD}" ] || CD_GIT_CHILD="cd"
[ -n "${CD_GIT_PARENT}" ] || CD_GIT_PARENT="rwx"
# main
cd_main () {
cd_set_environment_variables
cd_set_packages_repositories
cd_set_packages_configuration
#
cd_list_working_directory
cd_set_https_verification_off
cd_set_dns_resolving
cd_update_packages_catalog
cd_install_packages_tools
cd_install_ca_certificates
cd_write_ca_certificates
cd_update_ca_certificates
cd_set_https_verification_on
cd_update_packages_catalog
cd_upgrade_packages
cd_install_git
cd_install_python
# TODO move to Python
cd_install_rsync
# TODO move to Python
cd_install_ssh
cd_clean_packages_cache
cd_install_python_modules
cd_write_python_module
cd_switch_to_python "${@}"
}
# steps
cd_set_environment_variables () {
cd_step "Set environment variables"
# set path
CD_PATH="$(realpath "${0}")"
cd_echo "CD_PATH"
# set operating system id
CD_OS_ID="$(cd_grep_os ID)"
case "${CD_OS_ID}" in
"almalinux") CD_OS_ID="${CD_OS_ALMA}" ;;
"alpine") CD_OS_ID="${CD_OS_ALPINE}" ;;
"arch") CD_OS_ID="${CD_OS_ARCH}" ;;
"debian") CD_OS_ID="${CD_OS_DEBIAN}" ;;
"fedora") CD_OS_ID="${CD_OS_FEDORA}" ;;
"rocky") CD_OS_ID="${CD_OS_ROCKY}" ;;
"ubuntu") CD_OS_ID="${CD_OS_UBUNTU}" ;;
*) cd_error_os "CD_OS_ID" ;;
esac
# set operating system version
case "${CD_OS_ID}" in
"${CD_OS_ALMA}"|"${CD_OS_ARCH}"|"${CD_OS_FEDORA}"|"${CD_OS_ROCKY}")
CD_OS_VERSION=$(cd_grep_os VERSION_ID \
| sed "s|^\([0-9]\+\)\..*|\1|")
;;
"${CD_OS_ALPINE}")
CD_OS_VERSION=$(cd_grep_os VERSION_ID \
| sed "s|^\([0-9]\+\.[0-9]\+\)\..*|\1|")
;;
"${CD_OS_DEBIAN}"|"${CD_OS_UBUNTU}")
CD_OS_VERSION="$(cd_grep_os VERSION_CODENAME)"
;;
*)
esac
# check operating system version
case "${CD_OS_ID}" in
"${CD_OS_ALMA}"|"${CD_OS_ROCKY}")
case "${CD_OS_VERSION}" in
"8"|"9") ;;
*) cd_error_os "CD_OS_VERSION" ;;
esac
;;
"${CD_OS_ALPINE}")
case "${CD_OS_VERSION}" in
"3.18"|"3.19") ;;
*) cd_error_os "CD_OS_VERSION" ;;
esac
;;
"${CD_OS_ARCH}")
case "${CD_OS_VERSION}" in
"20231112"|"20240101") ;;
*) cd_error_os "CD_OS_VERSION" ;;
esac
;;
"${CD_OS_DEBIAN}")
case "${CD_OS_VERSION}" in
"bookworm"|"bullseye") ;;
*) cd_error_os "CD_OS_VERSION" ;;
esac
;;
"${CD_OS_FEDORA}")
case "${CD_OS_VERSION}" in
"39"|"40") ;;
*) cd_error_os "CD_OS_VERSION" ;;
esac
;;
"${CD_OS_UBUNTU}")
case "${CD_OS_VERSION}" in
"jammy"|"noble") ;;
*) cd_error_os "CD_OS_VERSION" ;;
esac
;;
*)
esac
cd_split
cd_echo "CD_OS_ID" "CD_OS_VERSION"
# universal
CD_DNS_FILE="/etc/resolv.conf"
CD_PKG_CA="ca-certificates"
CD_PKG_GIT="git"
# TODO move to Python
CD_PKG_RSYNC="rsync"
CD_PYTHON_ALIAS="python3"
cd_split
cd_echo "CD_DNS_FILE" "CD_PKG_CA" "CD_PKG_GIT" "CD_PYTHON_ALIAS"
# set ca command & root
case "${CD_OS_ID}" in
"${CD_OS_ALMA}"|"${CD_OS_FEDORA}"|"${CD_OS_ROCKY}")
CD_CA_ROOT="/etc/pki/ca-trust/source/anchors"
CD_CMD_CA="update-ca-trust"
;;
"${CD_OS_ALPINE}")
CD_CA_ROOT="/usr/local/share/ca-certificates"
CD_CMD_CA="update-ca-certificates"
;;
"${CD_OS_ARCH}")
CD_CA_ROOT="/etc/ca-certificates/trust-source/anchors"
CD_CMD_CA="update-ca-trust"
;;
"${CD_OS_DEBIAN}"|"${CD_OS_UBUNTU}")
CD_CA_ROOT="/usr/local/share/ca-certificates"
CD_CMD_CA="update-ca-certificates"
;;
*)
esac
cd_split
cd_echo "CD_CA_ROOT" "CD_CMD_CA"
# set package manager
case "${CD_OS_ID}" in
"${CD_OS_ALPINE}")
CD_PM="${CD_PM_APK}"
;;
"${CD_OS_DEBIAN}"|"${CD_OS_UBUNTU}")
CD_PM="${CD_PM_APT}"
;;
"${CD_OS_ALMA}"|"${CD_OS_FEDORA}"|"${CD_OS_ROCKY}")
CD_PM="${CD_PM_DNF}"
;;
"${CD_OS_ARCH}")
CD_PM="${CD_PM_PACMAN}"
;;
*)
esac
cd_split
cd_echo "CD_PM"
case "${CD_PM}" in
"${CD_PM_DNF}")
CD_PM_CLEAN="dnf clean all"
CD_PM_INSTALL="dnf install --assumeyes"
CD_PM_QUERY="rpm --query"
CD_PM_UPDATE="dnf makecache"
CD_PM_UPGRADE="dnf upgrade --assumeyes"
CD_PKG_PKG=""
CD_PM_CONF_PATH="/etc/dnf/dnf.conf"
CD_PM_CONF_TEXT="\
[main]
best=True
clean_requirements_on_remove=True
gpgcheck=1
installonly_limit=3
skip_if_unavailable=False
"
CD_PM_HTTPS_PATH="/etc/dnf/dnf.conf.d/https.conf"
CD_PM_HTTPS_TEXT="\
sslverify=False
"
;;
"${CD_PM_APK}")
CD_PM_CLEAN="apk cache purge"
CD_PM_INSTALL="apk add"
CD_PM_QUERY="apk info"
CD_PM_UPDATE="apk update"
CD_PM_UPGRADE="apk upgrade"
CD_PKG_PKG=""
CD_PM_CONF_PATH=""
CD_PM_CONF_TEXT=""
CD_PM_HTTPS_PATH="/etc/apk/repositories.d/https"
CD_PM_HTTPS_TEXT="\
--no-verify
"
;;
"${CD_PM_PACMAN}")
CD_PM_CLEAN="pacman --sync --clean --noconfirm"
CD_PM_INSTALL="pacman --sync --noconfirm"
CD_PM_QUERY="pacman --query"
CD_PM_UPDATE="pacman --sync --refresh"
CD_PM_UPGRADE="pacman --sync --sysupgrade --noconfirm"
CD_PKG_PKG=""
CD_PM_CONF_PATH=""
CD_PM_CONF_TEXT=""
CD_PM_HTTPS_PATH="/etc/pacman.d/https.conf"
CD_PM_HTTPS_TEXT="\
SSLVerify = No
"
;;
"${CD_PM_APT}")
CD_PM_CLEAN="apt-get clean"
CD_PM_INSTALL="apt-get install --assume-yes"
CD_PM_QUERY="dpkg-query --show"
CD_PM_UPDATE="apt-get update"
CD_PM_UPGRADE="apt-get upgrade --assume-yes"
CD_PKG_PKG="apt-utils"
CD_PM_CONF_PATH="/etc/apt/apt.conf.d/apt.conf"
CD_PM_CONF_TEXT="\
Acquire::Check-Valid-Until True;
APT::Get::Show-Versions True;
APT::Install-Recommends False;
APT::Install-Suggests False;
Dir::Etc::SourceParts \"\";
"
CD_PM_HTTPS_PATH="/etc/apt/apt.conf.d/https"
CD_PM_HTTPS_TEXT="\
Acquire::https::Verify-Peer False;
"
;;
*)
esac
cd_split
cd_echo "CD_PM_CLEAN" \
"CD_PM_INSTALL" "CD_PM_QUERY" "CD_PM_UPDATE" "CD_PM_UPGRADE"
cd_split
cd_echo "CD_PKG_PKG" "CD_PM_CONF_PATH" "CD_PM_HTTPS_PATH"
# specific
case "${CD_OS_ID}" in
"${CD_OS_ALMA}")
CD_URL_DEFAULT="https://repo.almalinux.org/almalinux"
;;
"${CD_OS_ALPINE}")
CD_URL_DEFAULT="https://dl-cdn.alpinelinux.org/alpine"
;;
"${CD_OS_ARCH}")
CD_URL_DEFAULT="https://geo.mirror.pkgbuild.com"
;;
"${CD_OS_DEBIAN}")
CD_URL_DEFAULT="http://deb.debian.org/debian"
;;
"${CD_OS_FEDORA}")
CD_URL_DEFAULT="http://download.example/pub/fedora/linux/releases"
;;
"${CD_OS_ROCKY}")
CD_URL_DEFAULT="http://dl.rockylinux.org/\$contentdir"
;;
"${CD_OS_UBUNTU}")
CD_URL_DEFAULT="http://archive.ubuntu.com/ubuntu"
;;
*)
esac
CD_URL_CHOSEN="${CD_URL_DEFAULT}"
case "${CD_OS_ID}" in
"${CD_OS_ALMA}")
[ -n "${CD_URL_ALMA}" ] && CD_URL_CHOSEN="${CD_URL_ALMA}"
;;
"${CD_OS_ALPINE}")
[ -n "${CD_URL_ALPINE}" ] && CD_URL_CHOSEN="${CD_URL_ALPINE}"
;;
"${CD_OS_ARCH}")
[ -n "${CD_URL_ARCH}" ] && CD_URL_CHOSEN="${CD_URL_ARCH}"
;;
"${CD_OS_DEBIAN}")
[ -n "${CD_URL_DEBIAN}" ] && CD_URL_CHOSEN="${CD_URL_DEBIAN}" \
|| CD_URL_CHOSEN="https://deb.debian.org/debian"
;;
"${CD_OS_FEDORA}")
[ -n "${CD_URL_FEDORA}" ] && CD_URL_CHOSEN="${CD_URL_FEDORA}" \
|| CD_URL_CHOSEN="https://rpmfind.net/linux/fedora/linux/releases"
;;
"${CD_OS_ROCKY}")
[ -n "${CD_URL_ROCKY}" ] && CD_URL_CHOSEN="${CD_URL_ROCKY}" \
|| CD_URL_CHOSEN="https://dl.rockylinux.org/\$contentdir"
;;
"${CD_OS_UBUNTU}")
[ -n "${CD_URL_UBUNTU}" ] && CD_URL_CHOSEN="${CD_URL_UBUNTU}" \
|| CD_URL_CHOSEN="https://ubuntu.mirrors.ovh.net/ubuntu"
;;
*)
esac
cd_split
cd_echo "CD_URL_DEFAULT" "CD_URL_CHOSEN"
# set python command & package
case "${CD_OS_ID}" in
"${CD_OS_ALMA}"|"${CD_OS_ROCKY}")
CD_PYTHON_COMMAND="python3.11"
CD_PYTHON_PACKAGE="python3.11"
;;
"${CD_OS_ALPINE}")
CD_PYTHON_COMMAND="python3.11"
CD_PYTHON_PACKAGE="python3"
;;
"${CD_OS_ARCH}")
CD_PYTHON_COMMAND="python3.12"
CD_PYTHON_PACKAGE="python"
;;
"${CD_OS_DEBIAN}")
case "${CD_OS_VERSION}" in
"bookworm") CD_PYTHON_COMMAND="python3.11" ;;
"bullseye") CD_PYTHON_COMMAND="python3.9" ;;
*)
esac
CD_PYTHON_PACKAGE="python3"
;;
"${CD_OS_FEDORA}")
CD_PYTHON_COMMAND="python3.12"
CD_PYTHON_PACKAGE="python3"
;;
"${CD_OS_UBUNTU}")
case "${CD_OS_VERSION}" in
"noble") CD_PYTHON_COMMAND="python3.12" ;;
"jammy") CD_PYTHON_COMMAND="python3.10" ;;
*)
esac
CD_PYTHON_PACKAGE="python3"
;;
*)
esac
# set python packages
case "${CD_OS_ID}" in
"${CD_OS_ALMA}"|"${CD_OS_FEDORA}"|"${CD_OS_ROCKY}")
CD_PYTHON_PACKAGES="/usr/lib64/${CD_PYTHON_COMMAND}/site-packages"
;;
"${CD_OS_ALPINE}"|"${CD_OS_ARCH}")
CD_PYTHON_PACKAGES="/usr/lib/${CD_PYTHON_COMMAND}/site-packages"
;;
"${CD_OS_DEBIAN}"|"${CD_OS_UBUNTU}")
CD_PYTHON_PACKAGES="/usr/lib/${CD_PYTHON_ALIAS}/dist-packages"
;;
*)
esac
cd_split
cd_echo "CD_PYTHON_COMMAND" "CD_PYTHON_PACKAGE" "CD_PYTHON_PACKAGES"
# variables
[ -n "${CD_CA_1}" ] && CD_CA=true
# continuous integration platform
if [ -n "${GITHUB_ACTIONS}" ] ; then
# github → gitea → forgejo
if [ -n "${GITHUB_SERVER_URL}" ] ; then
CD_SERVER_URL="${GITHUB_SERVER_URL}"
else
cd_error_ci "GITHUB_SERVER_URL"
fi
if [ -n "${GITHUB_REPOSITORY}" ] ; then
CD_PROJECTS_GROUP="$(dirname "${GITHUB_REPOSITORY}")"
CD_PROJECT_NAME="$(basename "${GITHUB_REPOSITORY}")"
else
cd_error_ci "GITHUB_REPOSITORY"
fi
if [ -n "${GITHUB_REF_NAME}" ] ; then
CD_PROJECT_BRANCH="${GITHUB_REF_NAME}"
else
cd_error_ci "GITHUB_REF_NAME"
fi
elif [ -n "${GITLAB_CI}" ] ; then
# gitlab
if [ -n "${CI_SERVER_URL}" ] ; then
CD_SERVER_URL="${CI_SERVER_URL}"
else
cd_error_ci "CI_SERVER_URL"
fi
if [ -n "${CI_PROJECT_PATH}" ] ; then
CD_PROJECTS_GROUP="$(dirname "${CI_PROJECT_PATH}")"
CD_PROJECT_NAME="$(basename "${CI_PROJECT_PATH}")"
else
cd_error_ci "CI_PROJECT_PATH"
fi
if [ -n "${CI_COMMIT_BRANCH}" ] ; then
CD_PROJECT_BRANCH="${CI_COMMIT_BRANCH}"
else
cd_error_ci "CI_COMMIT_BRANCH"
fi
else
# unsupported
cd_error_ci "ø"
fi
[ -n "${CD_SERVER_URL}" ] || cd_error_ci "CD_SERVER_URL"
[ -n "${CD_PROJECTS_GROUP}" ] || cd_error_ci "CD_PROJECTS_GROUP"
[ -n "${CD_PROJECT_NAME}" ] || cd_error_ci "CD_PROJECT_NAME"
[ -n "${CD_PROJECT_BRANCH}" ] || cd_error_ci "CD_PROJECT_BRANCH"
#
CD_PROJECTS_URL="${CD_SERVER_URL}/${CD_PROJECTS_GROUP}"
#
cd_split
cd_echo "CD_CA"
cd_split
cd_echo "CD_SERVER_URL" \
"CD_PROJECTS_GROUP" "CD_PROJECT_NAME" "CD_PROJECT_BRANCH"
cd_split
cd_echo "CD_PROJECTS_URL"
# TODO move to Python
case "${CD_PM}" in
"${CD_PM_APK}"|"${CD_PM_APT}") CD_PKG_SSH="openssh-client" ;;
"${CD_PM_DNF}") CD_PKG_SSH="openssh-clients" ;;
"${CD_PM_PACMAN}") CD_PKG_SSH="openssh" ;;
*)
esac
}
cd_set_packages_repositories () {
cd_step "Set packages repositories"
case "${CD_OS_ID}" in
"${CD_OS_ALMA}")
case "${CD_OS_VERSION}" in
"8") \
cd_set_packages_repositories__file="/etc/yum.repos.d/almalinux.repo" ;;
"9") \
cd_set_packages_repositories__file="/etc/yum.repos.d/almalinux-baseos.repo" ;;
*)
esac
cd_sed "${cd_set_packages_repositories__file}" \
"|^mirrorlist|# mirrorlist|" \
"|${CD_URL_DEFAULT}|${CD_URL_CHOSEN}|" \
"|^# baseurl|baseurl|"
;;
"${CD_OS_ALPINE}")
cd_set_packages_repositories__file="/etc/apk/repositories"
cd_write "${cd_set_packages_repositories__file}" "\
${CD_URL_CHOSEN}/v${CD_OS_VERSION}/main
${CD_URL_CHOSEN}/v${CD_OS_VERSION}/community
"
;;
"${CD_OS_DEBIAN}")
cd_set_packages_repositories__file="/etc/apt/sources.list"
cd_write "${cd_set_packages_repositories__file}" "\
deb ${CD_URL_CHOSEN} ${CD_OS_VERSION} main
deb ${CD_URL_CHOSEN} ${CD_OS_VERSION}-backports main
deb ${CD_URL_CHOSEN} ${CD_OS_VERSION}-updates main
deb ${CD_URL_CHOSEN}-security ${CD_OS_VERSION}-security main
"
;;
"${CD_OS_ROCKY}")
case "${CD_OS_VERSION}" in
"8") \
cd_set_packages_repositories__file="/etc/yum.repos.d/Rocky-BaseOS.repo" ;;
"9") \
cd_set_packages_repositories__file="/etc/yum.repos.d/rocky.repo" ;;
*)
esac
cd_sed "${cd_set_packages_repositories__file}" \
"|^mirrorlist|# mirrorlist|" \
"|${CD_URL_DEFAULT}|${CD_URL_CHOSEN}|" \
"|^#baseurl|baseurl|"
;;
"${CD_OS_UBUNTU}")
cd_set_packages_repositories__file="/etc/apt/sources.list"
cd_write "${cd_set_packages_repositories__file}" "\
deb ${CD_URL_CHOSEN} ${CD_OS_VERSION} main
deb ${CD_URL_CHOSEN} ${CD_OS_VERSION}-backports main
deb ${CD_URL_CHOSEN} ${CD_OS_VERSION}-updates main
deb ${CD_URL_CHOSEN} ${CD_OS_VERSION}-security main
"
;;
*)
esac
}
cd_set_packages_configuration () {
cd_step "Set packages configuration"
cd_write "${CD_PM_CONF_PATH}" "${CD_PM_CONF_TEXT}"
case "${CD_OS_ID}" in
"${CD_OS_DEBIAN}"|"${CD_OS_UBUNTU}")
export DEBIAN_FRONTEND="noninteractive"
;;
*)
esac
}
# agnostic steps
cd_list_working_directory () {
cd_step "List working directory"
cd_list_working_directory__path="$(realpath .)"
cd_ls "${cd_list_working_directory__path}"
}
cd_set_https_verification_off () {
if [ -n "${CD_CA}" ] || [ "${CD_PM}" = "${CD_PM_APT}" ] ; then
cd_step "Set HTTPS verification off"
cd_mkdir "$(dirname "${CD_PM_HTTPS_PATH}")"
cd_write "${CD_PM_HTTPS_PATH}" "${CD_PM_HTTPS_TEXT}"
fi
}
cd_set_dns_resolving () {
cd_step "Set DNS resolving"
for cd_set_dns_resolving__server in ${CD_DNS} ; do
cd_set_dns_resolving__text="${cd_set_dns_resolving__text}\
nameserver ${cd_set_dns_resolving__server}
"
done
cd_write "${CD_DNS_FILE}" "${cd_set_dns_resolving__text}"
}
cd_update_packages_catalog () {
cd_step "Update packages catalog"
${CD_PM_UPDATE} || exit
}
cd_install_packages_tools () {
cd_step "Install packages tools"
cd_install_package "${CD_PKG_PKG}"
}
cd_install_ca_certificates () {
cd_step "Install CA"
cd_install_package "${CD_PKG_CA}"
}
cd_write_ca_certificates () {
cd_step "Write CA certificates"
cd_mkdir "${CD_CA_ROOT}"
cd_write_ca_certificates__index=1
eval "cd_write_ca_certificates__text=\
\"\${CD_CA_${cd_write_ca_certificates__index}}\""
while [ -n "${cd_write_ca_certificates__text}" ] ; do
cd_write_ca_certificates__path="\
${CD_CA_ROOT}/${cd_write_ca_certificates__index}.crt"
cd_split
cd_write \
"${cd_write_ca_certificates__path}" \
"${cd_write_ca_certificates__text}"
cd_openssl "${cd_write_ca_certificates__path}"
cd_write_ca_certificates__index=$((cd_write_ca_certificates__index+1))
eval "cd_write_ca_certificates__text=\
\"\${CD_CA_${cd_write_ca_certificates__index}}\""
done
}
cd_update_ca_certificates () {
cd_step "Update CA certificates"
${CD_CMD_CA} || exit
}
cd_set_https_verification_on () {
cd_step "Set HTTPS verification on"
cd_rm "${CD_PM_HTTPS_PATH}"
}
cd_upgrade_packages () {
cd_step "Upgrade packages"
${CD_PM_UPGRADE} || exit
}
cd_install_git () {
cd_step "Install Git"
cd_install_package "${CD_PKG_GIT}"
}
cd_install_python () {
cd_step "Install Python"
cd_install_package "${CD_PYTHON_PACKAGE}"
cd_split
cd_ln_python "${CD_PYTHON_COMMAND}"
}
# TODO move to Python
cd_install_rsync () {
cd_step "Install Rsync"
cd_install_package "${CD_PKG_RSYNC}"
}
# TODO move to Python
cd_install_ssh () {
cd_step "Install SSH"
cd_install_package "${CD_PKG_SSH}"
}
cd_clean_packages_cache () {
cd_step "Clean packages cache"
${CD_PM_CLEAN} || exit
}
cd_install_python_modules () {
cd_step "Install Python modules"
cd_install_python_modules__root="$(mktemp --directory)" || exit
echo "→ ${cd_install_python_modules__root}"
for cd_install_python_modules__repository \
in "${CD_GIT_CHILD}" "${CD_GIT_PARENT}" ; do
cd_split
cd_install_python_modules__url="\
${CD_PROJECTS_URL}/${cd_install_python_modules__repository}"
echo "\
${cd_install_python_modules__url}
↓"
git clone \
"${cd_install_python_modules__url}" \
"${cd_install_python_modules__root}\
/${cd_install_python_modules__repository}" \
|| exit
cd_install_python_modules__path="\
${cd_install_python_modules__root}\
/${cd_install_python_modules__repository}\
/${cd_install_python_modules__repository}"
echo "\
${cd_install_python_modules__path}
↓
${CD_PYTHON_PACKAGES}"
cp --recursive \
"${cd_install_python_modules__path}" "${CD_PYTHON_PACKAGES}" \
|| exit
done
cd_split
cd_ls "${CD_PYTHON_PACKAGES}"
cd_split
cd_rm "${cd_install_python_modules__root}"
}
cd_write_python_module () {
cd_step "Write Python module"
for cd_write_python_module__variable \
in OPEN DOWN VERT SPLT __UP SHUT OS_ID OS_VERSION ; do
cd_write_python_module__value="\
$(cd_echo "CD_${cd_write_python_module__variable}")"
cd_write_python_module__text="${cd_write_python_module__text}\
${cd_write_python_module__value}
"
done
cd_write "${CD_PYTHON_PACKAGES}/env.py" "${cd_write_python_module__text}\
CD_STEP = $((CD_STEP+1))
"
}
cd_switch_to_python () {
cd_step "Switch to Python"
echo "\
${CD_PATH}
↓
${CD_PYTHON_PACKAGES}/${CD_GIT_CHILD}"
"${CD_PYTHON_ALIAS}" -m "${CD_GIT_CHILD}" "${@}"
}
# functions
cd_cat () {
cd_cat__file="${1}"
if [ -n "${cd_cat__file}" ] ; then
cd_open "${cd_cat__file}"
cat "${cd_cat__file}" || exit
cd_shut "${cd_cat__file}"
fi
}
cd_echo () {
if [ -n "${1}" ] ; then
for cd_echo__name in "${@}" ; do
eval "cd_echo__text=\"\${${cd_echo__name}}\""
echo "${cd_echo__name} = \"${cd_echo__text}\""
done
fi
}
cd_error_ci () {
echo "× CI: ${*}"
exit "${CD_ERROR_CI}"
}
cd_error_os () {
cd_error_os__variable="${1}"
printf "× OS: "
cd_echo "${cd_error_os__variable}"
exit "${CD_ERROR_OS}"
}
cd_grep_os () {
cd_grep_os__variable="${1}"
if [ -n "${cd_grep_os__variable}" ] ; then
grep "^${cd_grep_os__variable}=" "/etc/os-release" \
| sed "s|^${cd_grep_os__variable}=||" \
| sed "s|^\"\(.*\)\"$|\1|"
fi
}
cd_install_package () {
cd_install_package__name="${1}"
if [ -n "${cd_install_package__name}" ] ; then
${CD_PM_INSTALL} "${cd_install_package__name}" || exit
fi
}
cd_ln_python () {
cd_ln_python__command="${1}"
if [ -n "${cd_ln_python__command}" ] ; then
echo "→ ${CD_PYTHON_ALIAS} → ${cd_ln_python__command}"
ln -f -s "${cd_ln_python__command}" "/usr/bin/${CD_PYTHON_ALIAS}" \
|| exit
fi
}
cd_ls () {
cd_ls__path="${1}"
if [ -n "${cd_ls__path}" ] ; then
cd_open "${cd_ls__path}"
ls -a -l "${cd_ls__path}" || exit
cd_shut "${cd_ls__path}"
fi
}
cd_mkdir () {
cd_mkdir__path="${1}"
if [ -n "${cd_mkdir__path}" ] ; then
echo "→ ${cd_mkdir__path}"
mkdir --parents "${cd_mkdir__path}" || exit
fi
}
cd_open () {
echo "${CD_OPEN}${*}"
}
cd_openssl () {
cd_openssl__file="${1}"
if [ -f "${cd_openssl__file}" ] ; then
openssl x509 \
-in "${cd_openssl__file}" \
-noout -text \
|| exit
fi
}
cd_rm () {
cd_rm__path="${1}"
if [ -e "${cd_rm__path}" ] ; then
echo "← ${cd_rm__path}"
rm -r "${cd_rm__path}" || exit
fi
}
cd_sed () {
cd_sed__file="${1}"
shift
if [ -f "${cd_sed__file}" ] ; then
cd_cat "${cd_sed__file}"
for cd_sed__regex in "${@}" ; do
sed --in-place "s${cd_sed__regex}g" "${cd_sed__file}" \
&& cd_cat "${cd_sed__file}" \
|| exit
done
fi
}
cd_shut () {
echo "${CD_SHUT}${*}"
}
cd_split () {
echo "${CD_SPLT}"
}
cd_step () {
CD_STEP=$((CD_STEP+1))
echo "\
${CD_DOWN}
${CD_VERT} ${CD_STEP} ${*}
${CD___UP}"
}
cd_write () {
cd_write__file="${1}"
cd_write__text="${2}"
if [ -n "${cd_write__file}" ] ; then
[ -f "${cd_write__file}" ] && cd_cat "${cd_write__file}"
echo "→ ${cd_write__file}"
printf "%s" "${cd_write__text}" > "${cd_write__file}" || exit
cd_cat "${cd_write__file}"
fi
}
# constants
CD_BOX_DOWN="╭"
CD_BOX_LEFT="╴"
CD_BOX_RIGHT="╶"
CD_BOX_UP="╰"
CD_BOX_VERTICAL="│"
CD_ERROR_CI=2
CD_ERROR_OS=1
CD_OS_ALMA="alma"
CD_OS_ALPINE="alpine"
CD_OS_ARCH="arch"
CD_OS_DEBIAN="debian"
CD_OS_FEDORA="fedora"
CD_OS_ROCKY="rocky"
CD_OS_UBUNTU="ubuntu"
CD_PM_APK="apk"
CD_PM_APT="apt"
CD_PM_DNF="dnf"
CD_PM_PACMAN="pacman"
CD_HORIZONTAL="────╌╌╌╌┄┄┄┄┈┈┈┈"
CD_OPEN="${CD_BOX_DOWN}${CD_BOX_LEFT}"
CD_DOWN="${CD_BOX_DOWN}${CD_HORIZONTAL}"
CD_VERT="${CD_BOX_VERTICAL}"
CD_SPLT="${CD_BOX_RIGHT}${CD_HORIZONTAL}"
CD___UP="${CD_BOX_UP}${CD_HORIZONTAL}"
CD_SHUT="${CD_BOX_UP}${CD_BOX_LEFT}"
# run
cd_main "${@}"

45
cidd/__init__.py → cd/__init__.py
View file

@ -1,30 +1,28 @@
"""Continuous Integration, Delivery & Deployment."""
"""Continuous Deployment."""
__version__ = "0.0.1"
import os
import sys
from pathlib import Path
import env
from rwx import fs, ps
from rwx.log import stream as log
import cidd
from cidd.project import Project
from cidd.projects import Projects
from cd.project import Project
from cd.projects import Projects
COMMANDS_PREFIX = "cidd-"
COMMANDS_PREFIX = "cd-"
projects = Projects()
project = Project(projects)
def cidd_browse_workspace() -> None:
def cd_browse_workspace() -> None:
browse(project.root)
def cidd_build_project() -> None:
def cd_build_project() -> None:
for extension in ["py", "sh"]:
path = Path(project.root) / f"build.{extension}"
if path.exists():
@ -34,7 +32,7 @@ def cidd_build_project() -> None:
pass
def cidd_clone_branch() -> None:
def cd_clone_branch() -> None:
log.info(projects)
split()
log.info(project)
@ -58,12 +56,12 @@ def cidd_clone_branch() -> None:
)
def cidd_list_environment() -> None:
def cd_list_environment() -> None:
for variable, value in sorted(projects.environment.items()):
log.info(f"{variable} = {value}")
def cidd_synchronize() -> None:
def cd_synchronize() -> None:
host = "rwx.work"
source = "out"
user = "cd"
@ -115,17 +113,6 @@ def install_commands(path: str) -> None:
(user / f"{COMMANDS_PREFIX}{command}").symlink_to(path)
def main() -> None:
path, *arguments = sys.argv
name = Path(path).name
if name == "__main__.py":
cidd.set_ssh(*arguments)
cidd.install_commands(__file__)
else:
function = getattr(cidd, name.replace("-", "_"))
function(*arguments)
def set_ssh(*arguments: str) -> None:
step("Set SSH")
#
@ -154,19 +141,19 @@ def set_ssh(*arguments: str) -> None:
def frame(text: str) -> None:
log.info(f"{env.CIDD_OPEN}{text}")
log.info(f"{env.CD_OPEN}{text}")
def shut(text: str) -> None:
log.info(f"{env.CIDD_SHUT}{text}")
log.info(f"{env.CD_SHUT}{text}")
def split() -> None:
log.info(env.CIDD_SPLT)
log.info(env.CD_SPLT)
def step(text: str) -> None:
env.CIDD_STEP += 1
log.info(env.CIDD_DOWN)
log.info(f"{env.CIDD_VERT} {env.CIDD_STEP} {text}")
log.info(env.CIDD___UP)
env.CD_STEP += 1
log.info(env.CD_DOWN)
log.info(f"{env.CD_VERT} {env.CD_STEP} {text}")
log.info(env.CD___UP)

18
cd/__main__.py Executable file
View file

@ -0,0 +1,18 @@
#! /usr/bin/env python3
"""Entry point to either bootstrap or command."""
import sys
from pathlib import Path
import cd
if __name__ == "__main__":
path, *arguments = sys.argv
name = Path(path).name
if name == "__main__.py":
cd.set_ssh(*arguments)
cd.install_commands(__file__)
else:
function = getattr(cd, name.replace("-", "_"))
function(*arguments)

2
cidd/project.py → cd/project.py
View file

@ -7,7 +7,7 @@ from typing import TYPE_CHECKING
from urllib.parse import urljoin
if TYPE_CHECKING:
from cidd.projects import Projects
from cd.projects import Projects
BRANCH = [
"GITHUB_REF_NAME",

0
cidd/projects.py → cd/projects.py
View file

817
cidd.sh
View file

@ -1,817 +0,0 @@
#! /usr/bin/env sh
# defaults
[ -n "${CIDD_DNS}" ] || CIDD_DNS="\
9.9.9.9 \
"
[ -n "${CIDD_GIT_CHILD}" ] || CIDD_GIT_CHILD="cd"
[ -n "${CIDD_GIT_PARENT}" ] || CIDD_GIT_PARENT="rwx"
# main
cidd_main () {
cidd_set_environment_variables
cidd_set_packages_repositories
cidd_set_packages_configuration
#
cidd_list_working_directory
cidd_set_https_verification_off
cidd_set_dns_resolving
cidd_update_packages_catalog
cidd_install_packages_tools
cidd_install_ca_certificates
cidd_write_ca_certificates
cidd_update_ca_certificates
cidd_set_https_verification_on
cidd_update_packages_catalog
cidd_upgrade_packages
cidd_install_git
cidd_install_python
# TODO move to Python
cidd_install_rsync
# TODO move to Python
cidd_install_ssh
cidd_clean_packages_cache
cidd_install_python_modules
cidd_write_python_module
cidd_switch_to_python "${@}"
}
# steps
cidd_set_environment_variables () {
cidd_step "Set environment variables"
# set path
CIDD_PATH="$(realpath "${0}")"
cidd_echo "CIDD_PATH"
# set operating system id
CIDD_OS_ID="$(cidd_grep_os ID)"
case "${CIDD_OS_ID}" in
"almalinux") CIDD_OS_ID="${CIDD_OS_ALMA}" ;;
"alpine") CIDD_OS_ID="${CIDD_OS_ALPINE}" ;;
"arch") CIDD_OS_ID="${CIDD_OS_ARCH}" ;;
"debian") CIDD_OS_ID="${CIDD_OS_DEBIAN}" ;;
"fedora") CIDD_OS_ID="${CIDD_OS_FEDORA}" ;;
"rocky") CIDD_OS_ID="${CIDD_OS_ROCKY}" ;;
"ubuntu") CIDD_OS_ID="${CIDD_OS_UBUNTU}" ;;
*) cidd_error_os "CIDD_OS_ID" ;;
esac
# set operating system version
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}"|"${CIDD_OS_ARCH}"|"${CIDD_OS_FEDORA}"|"${CIDD_OS_ROCKY}")
CIDD_OS_VERSION=$(cidd_grep_os VERSION_ID \
| sed "s|^\([0-9]\+\)\..*|\1|")
;;
"${CIDD_OS_ALPINE}")
CIDD_OS_VERSION=$(cidd_grep_os VERSION_ID \
| sed "s|^\([0-9]\+\.[0-9]\+\)\..*|\1|")
;;
"${CIDD_OS_DEBIAN}"|"${CIDD_OS_UBUNTU}")
CIDD_OS_VERSION="$(cidd_grep_os VERSION_CODENAME)"
;;
*)
esac
# check operating system version
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}"|"${CIDD_OS_ROCKY}")
case "${CIDD_OS_VERSION}" in
"8"|"9") ;;
*) cidd_error_os "CIDD_OS_VERSION" ;;
esac
;;
"${CIDD_OS_ALPINE}")
case "${CIDD_OS_VERSION}" in
"3.18"|"3.19") ;;
*) cidd_error_os "CIDD_OS_VERSION" ;;
esac
;;
"${CIDD_OS_ARCH}")
case "${CIDD_OS_VERSION}" in
"20231112"|"20240101") ;;
*) cidd_error_os "CIDD_OS_VERSION" ;;
esac
;;
"${CIDD_OS_DEBIAN}")
case "${CIDD_OS_VERSION}" in
"bookworm"|"bullseye") ;;
*) cidd_error_os "CIDD_OS_VERSION" ;;
esac
;;
"${CIDD_OS_FEDORA}")
case "${CIDD_OS_VERSION}" in
"39"|"40") ;;
*) cidd_error_os "CIDD_OS_VERSION" ;;
esac
;;
"${CIDD_OS_UBUNTU}")
case "${CIDD_OS_VERSION}" in
"jammy"|"noble") ;;
*) cidd_error_os "CIDD_OS_VERSION" ;;
esac
;;
*)
esac
cidd_split
cidd_echo "CIDD_OS_ID" "CIDD_OS_VERSION"
# universal
CIDD_DNS_FILE="/etc/resolv.conf"
CIDD_PKG_CA="ca-certificates"
CIDD_PKG_GIT="git"
# TODO move to Python
CIDD_PKG_RSYNC="rsync"
CIDD_PYTHON_ALIAS="python3"
cidd_split
cidd_echo "CIDD_DNS_FILE" "CIDD_PKG_CA" "CIDD_PKG_GIT" "CIDD_PYTHON_ALIAS"
# set ca command & root
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}"|"${CIDD_OS_FEDORA}"|"${CIDD_OS_ROCKY}")
CIDD_CA_ROOT="/etc/pki/ca-trust/source/anchors"
CIDD_CMD_CA="update-ca-trust"
;;
"${CIDD_OS_ALPINE}")
CIDD_CA_ROOT="/usr/local/share/ca-certificates"
CIDD_CMD_CA="update-ca-certificates"
;;
"${CIDD_OS_ARCH}")
CIDD_CA_ROOT="/etc/ca-certificates/trust-source/anchors"
CIDD_CMD_CA="update-ca-trust"
;;
"${CIDD_OS_DEBIAN}"|"${CIDD_OS_UBUNTU}")
CIDD_CA_ROOT="/usr/local/share/ca-certificates"
CIDD_CMD_CA="update-ca-certificates"
;;
*)
esac
cidd_split
cidd_echo "CIDD_CA_ROOT" "CIDD_CMD_CA"
# set package manager
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALPINE}")
CIDD_PM="${CIDD_PM_APK}"
;;
"${CIDD_OS_DEBIAN}"|"${CIDD_OS_UBUNTU}")
CIDD_PM="${CIDD_PM_APT}"
;;
"${CIDD_OS_ALMA}"|"${CIDD_OS_FEDORA}"|"${CIDD_OS_ROCKY}")
CIDD_PM="${CIDD_PM_DNF}"
;;
"${CIDD_OS_ARCH}")
CIDD_PM="${CIDD_PM_PACMAN}"
;;
*)
esac
cidd_split
cidd_echo "CIDD_PM"
case "${CIDD_PM}" in
"${CIDD_PM_DNF}")
CIDD_PM_CLEAN="dnf clean all"
CIDD_PM_INSTALL="dnf install --assumeyes"
CIDD_PM_QUERY="rpm --query"
CIDD_PM_UPDATE="dnf makecache"
CIDD_PM_UPGRADE="dnf upgrade --assumeyes"
CIDD_PKG_PKG=""
CIDD_PM_CONF_PATH="/etc/dnf/dnf.conf"
CIDD_PM_CONF_TEXT="\
[main]
best=True
clean_requirements_on_remove=True
gpgcheck=1
installonly_limit=3
skip_if_unavailable=False
"
CIDD_PM_HTTPS_PATH="/etc/dnf/dnf.conf.d/https.conf"
CIDD_PM_HTTPS_TEXT="\
sslverify=False
"
;;
"${CIDD_PM_APK}")
CIDD_PM_CLEAN="apk cache purge"
CIDD_PM_INSTALL="apk add"
CIDD_PM_QUERY="apk info"
CIDD_PM_UPDATE="apk update"
CIDD_PM_UPGRADE="apk upgrade"
CIDD_PKG_PKG=""
CIDD_PM_CONF_PATH=""
CIDD_PM_CONF_TEXT=""
CIDD_PM_HTTPS_PATH="/etc/apk/repositories.d/https"
CIDD_PM_HTTPS_TEXT="\
--no-verify
"
;;
"${CIDD_PM_PACMAN}")
CIDD_PM_CLEAN="pacman --sync --clean --noconfirm"
CIDD_PM_INSTALL="pacman --sync --noconfirm"
CIDD_PM_QUERY="pacman --query"
CIDD_PM_UPDATE="pacman --sync --refresh"
CIDD_PM_UPGRADE="pacman --sync --sysupgrade --noconfirm"
CIDD_PKG_PKG=""
CIDD_PM_CONF_PATH=""
CIDD_PM_CONF_TEXT=""
CIDD_PM_HTTPS_PATH="/etc/pacman.d/https.conf"
CIDD_PM_HTTPS_TEXT="\
SSLVerify = No
"
;;
"${CIDD_PM_APT}")
CIDD_PM_CLEAN="apt-get clean"
CIDD_PM_INSTALL="apt-get install --assume-yes"
CIDD_PM_QUERY="dpkg-query --show"
CIDD_PM_UPDATE="apt-get update"
CIDD_PM_UPGRADE="apt-get upgrade --assume-yes"
CIDD_PKG_PKG="apt-utils"
CIDD_PM_CONF_PATH="/etc/apt/apt.conf.d/apt.conf"
CIDD_PM_CONF_TEXT="\
Acquire::Check-Valid-Until True;
APT::Get::Show-Versions True;
APT::Install-Recommends False;
APT::Install-Suggests False;
Dir::Etc::SourceParts \"\";
"
CIDD_PM_HTTPS_PATH="/etc/apt/apt.conf.d/https"
CIDD_PM_HTTPS_TEXT="\
Acquire::https::Verify-Peer False;
"
;;
*)
esac
cidd_split
cidd_echo "CIDD_PM_CLEAN" \
"CIDD_PM_INSTALL" "CIDD_PM_QUERY" "CIDD_PM_UPDATE" "CIDD_PM_UPGRADE"
cidd_split
cidd_echo "CIDD_PKG_PKG" "CIDD_PM_CONF_PATH" "CIDD_PM_HTTPS_PATH"
# specific
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}")
CIDD_URL_DEFAULT="https://repo.almalinux.org/almalinux"
;;
"${CIDD_OS_ALPINE}")
CIDD_URL_DEFAULT="https://dl-cdn.alpinelinux.org/alpine"
;;
"${CIDD_OS_ARCH}")
CIDD_URL_DEFAULT="https://geo.mirror.pkgbuild.com"
;;
"${CIDD_OS_DEBIAN}")
CIDD_URL_DEFAULT="http://deb.debian.org/debian"
;;
"${CIDD_OS_FEDORA}")
CIDD_URL_DEFAULT="http://download.example/pub/fedora/linux/releases"
;;
"${CIDD_OS_ROCKY}")
CIDD_URL_DEFAULT="http://dl.rockylinux.org/\$contentdir"
;;
"${CIDD_OS_UBUNTU}")
CIDD_URL_DEFAULT="http://archive.ubuntu.com/ubuntu"
;;
*)
esac
CIDD_URL_CHOSEN="${CIDD_URL_DEFAULT}"
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}")
[ -n "${CIDD_URL_ALMA}" ] && CIDD_URL_CHOSEN="${CIDD_URL_ALMA}"
;;
"${CIDD_OS_ALPINE}")
[ -n "${CIDD_URL_ALPINE}" ] && CIDD_URL_CHOSEN="${CIDD_URL_ALPINE}"
;;
"${CIDD_OS_ARCH}")
[ -n "${CIDD_URL_ARCH}" ] && CIDD_URL_CHOSEN="${CIDD_URL_ARCH}"
;;
"${CIDD_OS_DEBIAN}")
[ -n "${CIDD_URL_DEBIAN}" ] && CIDD_URL_CHOSEN="${CIDD_URL_DEBIAN}" \
|| CIDD_URL_CHOSEN="https://deb.debian.org/debian"
;;
"${CIDD_OS_FEDORA}")
[ -n "${CIDD_URL_FEDORA}" ] && CIDD_URL_CHOSEN="${CIDD_URL_FEDORA}" \
|| CIDD_URL_CHOSEN="https://rpmfind.net/linux/fedora/linux/releases"
;;
"${CIDD_OS_ROCKY}")
[ -n "${CIDD_URL_ROCKY}" ] && CIDD_URL_CHOSEN="${CIDD_URL_ROCKY}" \
|| CIDD_URL_CHOSEN="https://dl.rockylinux.org/\$contentdir"
;;
"${CIDD_OS_UBUNTU}")
[ -n "${CIDD_URL_UBUNTU}" ] && CIDD_URL_CHOSEN="${CIDD_URL_UBUNTU}" \
|| CIDD_URL_CHOSEN="https://ubuntu.mirrors.ovh.net/ubuntu"
;;
*)
esac
cidd_split
cidd_echo "CIDD_URL_DEFAULT" "CIDD_URL_CHOSEN"
# set python command & package
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}"|"${CIDD_OS_ROCKY}")
CIDD_PYTHON_COMMAND="python3.11"
CIDD_PYTHON_PACKAGE="python3.11"
;;
"${CIDD_OS_ALPINE}")
CIDD_PYTHON_COMMAND="python3.11"
CIDD_PYTHON_PACKAGE="python3"
;;
"${CIDD_OS_ARCH}")
CIDD_PYTHON_COMMAND="python3.12"
CIDD_PYTHON_PACKAGE="python"
;;
"${CIDD_OS_DEBIAN}")
case "${CIDD_OS_VERSION}" in
"bookworm") CIDD_PYTHON_COMMAND="python3.11" ;;
"bullseye") CIDD_PYTHON_COMMAND="python3.9" ;;
*)
esac
CIDD_PYTHON_PACKAGE="python3"
;;
"${CIDD_OS_FEDORA}")
CIDD_PYTHON_COMMAND="python3.12"
CIDD_PYTHON_PACKAGE="python3"
;;
"${CIDD_OS_UBUNTU}")
case "${CIDD_OS_VERSION}" in
"noble") CIDD_PYTHON_COMMAND="python3.12" ;;
"jammy") CIDD_PYTHON_COMMAND="python3.10" ;;
*)
esac
CIDD_PYTHON_PACKAGE="python3"
;;
*)
esac
# set python packages
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}"|"${CIDD_OS_FEDORA}"|"${CIDD_OS_ROCKY}")
CIDD_PYTHON_PACKAGES="/usr/lib64/${CIDD_PYTHON_COMMAND}/site-packages"
;;
"${CIDD_OS_ALPINE}"|"${CIDD_OS_ARCH}")
CIDD_PYTHON_PACKAGES="/usr/lib/${CIDD_PYTHON_COMMAND}/site-packages"
;;
"${CIDD_OS_DEBIAN}"|"${CIDD_OS_UBUNTU}")
CIDD_PYTHON_PACKAGES="/usr/lib/${CIDD_PYTHON_ALIAS}/dist-packages"
;;
*)
esac
cidd_split
cidd_echo "CIDD_PYTHON_COMMAND" "CIDD_PYTHON_PACKAGE" "CIDD_PYTHON_PACKAGES"
# variables
[ -n "${CIDD_CA_1}" ] && CIDD_CA=true
# continuous integration platform
if [ -n "${GITHUB_ACTIONS}" ] ; then
# github → gitea → forgejo
if [ -n "${GITHUB_SERVER_URL}" ] ; then
CIDD_SERVER_URL="${GITHUB_SERVER_URL}"
else
cidd_error_ci "GITHUB_SERVER_URL"
fi
if [ -n "${GITHUB_REPOSITORY}" ] ; then
CIDD_PROJECTS_GROUP="$(dirname "${GITHUB_REPOSITORY}")"
CIDD_PROJECT_NAME="$(basename "${GITHUB_REPOSITORY}")"
else
cidd_error_ci "GITHUB_REPOSITORY"
fi
if [ -n "${GITHUB_REF_NAME}" ] ; then
CIDD_PROJECT_BRANCH="${GITHUB_REF_NAME}"
else
cidd_error_ci "GITHUB_REF_NAME"
fi
elif [ -n "${GITLAB_CI}" ] ; then
# gitlab
if [ -n "${CI_SERVER_URL}" ] ; then
CIDD_SERVER_URL="${CI_SERVER_URL}"
else
cidd_error_ci "CI_SERVER_URL"
fi
if [ -n "${CI_PROJECT_PATH}" ] ; then
CIDD_PROJECTS_GROUP="$(dirname "${CI_PROJECT_PATH}")"
CIDD_PROJECT_NAME="$(basename "${CI_PROJECT_PATH}")"
else
cidd_error_ci "CI_PROJECT_PATH"
fi
if [ -n "${CI_COMMIT_BRANCH}" ] ; then
CIDD_PROJECT_BRANCH="${CI_COMMIT_BRANCH}"
else
cidd_error_ci "CI_COMMIT_BRANCH"
fi
else
# unsupported
cidd_error_ci "ø"
fi
[ -n "${CIDD_SERVER_URL}" ] || cidd_error_ci "CIDD_SERVER_URL"
[ -n "${CIDD_PROJECTS_GROUP}" ] || cidd_error_ci "CIDD_PROJECTS_GROUP"
[ -n "${CIDD_PROJECT_NAME}" ] || cidd_error_ci "CIDD_PROJECT_NAME"
[ -n "${CIDD_PROJECT_BRANCH}" ] || cidd_error_ci "CIDD_PROJECT_BRANCH"
#
CIDD_PROJECTS_URL="${CIDD_SERVER_URL}/${CIDD_PROJECTS_GROUP}"
#
cidd_split
cidd_echo "CIDD_CA"
cidd_split
cidd_echo "CIDD_SERVER_URL" \
"CIDD_PROJECTS_GROUP" "CIDD_PROJECT_NAME" "CIDD_PROJECT_BRANCH"
cidd_split
cidd_echo "CIDD_PROJECTS_URL"
# TODO move to Python
case "${CIDD_PM}" in
"${CIDD_PM_APK}"|"${CIDD_PM_APT}") CIDD_PKG_SSH="openssh-client" ;;
"${CIDD_PM_DNF}") CIDD_PKG_SSH="openssh-clients" ;;
"${CIDD_PM_PACMAN}") CIDD_PKG_SSH="openssh" ;;
*)
esac
}
cidd_set_packages_repositories () {
cidd_step "Set packages repositories"
case "${CIDD_OS_ID}" in
"${CIDD_OS_ALMA}")
case "${CIDD_OS_VERSION}" in
"8") \
cidd_set_packages_repositories__file="/etc/yum.repos.d/almalinux.repo" ;;
"9") \
cidd_set_packages_repositories__file="/etc/yum.repos.d/almalinux-baseos.repo" ;;
*)
esac
cidd_sed "${cidd_set_packages_repositories__file}" \
"|^mirrorlist|# mirrorlist|" \
"|${CIDD_URL_DEFAULT}|${CIDD_URL_CHOSEN}|" \
"|^# baseurl|baseurl|"
;;
"${CIDD_OS_ALPINE}")
cidd_set_packages_repositories__file="/etc/apk/repositories"
cidd_write "${cidd_set_packages_repositories__file}" "\
${CIDD_URL_CHOSEN}/v${CIDD_OS_VERSION}/main
${CIDD_URL_CHOSEN}/v${CIDD_OS_VERSION}/community
"
;;
"${CIDD_OS_DEBIAN}")
cidd_set_packages_repositories__file="/etc/apt/sources.list"
cidd_write "${cidd_set_packages_repositories__file}" "\
deb ${CIDD_URL_CHOSEN} ${CIDD_OS_VERSION} main
deb ${CIDD_URL_CHOSEN} ${CIDD_OS_VERSION}-backports main
deb ${CIDD_URL_CHOSEN} ${CIDD_OS_VERSION}-updates main
deb ${CIDD_URL_CHOSEN}-security ${CIDD_OS_VERSION}-security main
"
;;
"${CIDD_OS_ROCKY}")
case "${CIDD_OS_VERSION}" in
"8") \
cidd_set_packages_repositories__file="/etc/yum.repos.d/Rocky-BaseOS.repo" ;;
"9") \
cidd_set_packages_repositories__file="/etc/yum.repos.d/rocky.repo" ;;
*)
esac
cidd_sed "${cidd_set_packages_repositories__file}" \
"|^mirrorlist|# mirrorlist|" \
"|${CIDD_URL_DEFAULT}|${CIDD_URL_CHOSEN}|" \
"|^#baseurl|baseurl|"
;;
"${CIDD_OS_UBUNTU}")
cidd_set_packages_repositories__file="/etc/apt/sources.list"
cidd_write "${cidd_set_packages_repositories__file}" "\
deb ${CIDD_URL_CHOSEN} ${CIDD_OS_VERSION} main
deb ${CIDD_URL_CHOSEN} ${CIDD_OS_VERSION}-backports main
deb ${CIDD_URL_CHOSEN} ${CIDD_OS_VERSION}-updates main
deb ${CIDD_URL_CHOSEN} ${CIDD_OS_VERSION}-security main
"
;;
*)
esac
}
cidd_set_packages_configuration () {
cidd_step "Set packages configuration"
cidd_write "${CIDD_PM_CONF_PATH}" "${CIDD_PM_CONF_TEXT}"
case "${CIDD_OS_ID}" in
"${CIDD_OS_DEBIAN}"|"${CIDD_OS_UBUNTU}")
export DEBIAN_FRONTEND="noninteractive"
;;
*)
esac
}
# agnostic steps
cidd_list_working_directory () {
cidd_step "List working directory"
cidd_list_working_directory__path="$(realpath .)"
cidd_ls "${cidd_list_working_directory__path}"
}
cidd_set_https_verification_off () {
if [ -n "${CIDD_CA}" ] || [ "${CIDD_PM}" = "${CIDD_PM_APT}" ] ; then
cidd_step "Set HTTPS verification off"
cidd_mkdir "$(dirname "${CIDD_PM_HTTPS_PATH}")"
cidd_write "${CIDD_PM_HTTPS_PATH}" "${CIDD_PM_HTTPS_TEXT}"
fi
}
cidd_set_dns_resolving () {
cidd_step "Set DNS resolving"
for cidd_set_dns_resolving__server in ${CIDD_DNS} ; do
cidd_set_dns_resolving__text="${cidd_set_dns_resolving__text}\
nameserver ${cidd_set_dns_resolving__server}
"
done
cidd_write "${CIDD_DNS_FILE}" "${cidd_set_dns_resolving__text}"
}
cidd_update_packages_catalog () {
cidd_step "Update packages catalog"
${CIDD_PM_UPDATE} || exit
}
cidd_install_packages_tools () {
cidd_step "Install packages tools"
cidd_install_package "${CIDD_PKG_PKG}"
}
cidd_install_ca_certificates () {
cidd_step "Install CA"
cidd_install_package "${CIDD_PKG_CA}"
}
cidd_write_ca_certificates () {
cidd_step "Write CA certificates"
cidd_mkdir "${CIDD_CA_ROOT}"
cidd_write_ca_certificates__index=1
eval "cidd_write_ca_certificates__text=\
\"\${CIDD_CA_${cidd_write_ca_certificates__index}}\""
while [ -n "${cidd_write_ca_certificates__text}" ] ; do
cidd_write_ca_certificates__path="\
${CIDD_CA_ROOT}/${cidd_write_ca_certificates__index}.crt"
cidd_split
cidd_write \
"${cidd_write_ca_certificates__path}" \
"${cidd_write_ca_certificates__text}"
cidd_openssl "${cidd_write_ca_certificates__path}"
cidd_write_ca_certificates__index=$((cidd_write_ca_certificates__index+1))
eval "cidd_write_ca_certificates__text=\
\"\${CIDD_CA_${cidd_write_ca_certificates__index}}\""
done
}
cidd_update_ca_certificates () {
cidd_step "Update CA certificates"
${CIDD_CMD_CA} || exit
}
cidd_set_https_verification_on () {
cidd_step "Set HTTPS verification on"
cidd_rm "${CIDD_PM_HTTPS_PATH}"
}
cidd_upgrade_packages () {
cidd_step "Upgrade packages"
${CIDD_PM_UPGRADE} || exit
}
cidd_install_git () {
cidd_step "Install Git"
cidd_install_package "${CIDD_PKG_GIT}"
}
cidd_install_python () {
cidd_step "Install Python"
cidd_install_package "${CIDD_PYTHON_PACKAGE}"
cidd_split
cidd_ln_python "${CIDD_PYTHON_COMMAND}"
}
# TODO move to Python
cidd_install_rsync () {
cidd_step "Install Rsync"
cidd_install_package "${CIDD_PKG_RSYNC}"
}
# TODO move to Python
cidd_install_ssh () {
cidd_step "Install SSH"
cidd_install_package "${CIDD_PKG_SSH}"
}
cidd_clean_packages_cache () {
cidd_step "Clean packages cache"
${CIDD_PM_CLEAN} || exit
}
cidd_install_python_modules () {
cidd_step "Install Python modules"
cidd_install_python_modules__root="$(mktemp --directory)" || exit
echo "→ ${cidd_install_python_modules__root}"
for cidd_install_python_modules__repository \
in "${CIDD_GIT_CHILD}" "${CIDD_GIT_PARENT}" ; do
cidd_split
cidd_install_python_modules__url="\
${CIDD_PROJECTS_URL}/${cidd_install_python_modules__repository}"
echo "\
${cidd_install_python_modules__url}
↓"
git clone \
"${cidd_install_python_modules__url}" \
"${cidd_install_python_modules__root}\
/${cidd_install_python_modules__repository}" \
|| exit
cidd_install_python_modules__path="\
${cidd_install_python_modules__root}\
/${cidd_install_python_modules__repository}\
/${cidd_install_python_modules__repository}"
echo "\
${cidd_install_python_modules__path}
↓
${CIDD_PYTHON_PACKAGES}"
cp --recursive \
"${cidd_install_python_modules__path}" "${CIDD_PYTHON_PACKAGES}" \
|| exit
done
cidd_split
cidd_ls "${CIDD_PYTHON_PACKAGES}"
cidd_split
cidd_rm "${cidd_install_python_modules__root}"
}
cidd_write_python_module () {
cidd_step "Write Python module"
for cidd_write_python_module__variable \
in OPEN DOWN VERT SPLT __UP SHUT OS_ID OS_VERSION ; do
cidd_write_python_module__value="\
$(cidd_echo "CIDD_${cidd_write_python_module__variable}")"
cidd_write_python_module__text="${cidd_write_python_module__text}\
${cidd_write_python_module__value}
"
done
cidd_write "${CIDD_PYTHON_PACKAGES}/env.py" "${cidd_write_python_module__text}\
CIDD_STEP = $((CIDD_STEP+1))
"
}
cidd_switch_to_python () {
cidd_step "Switch to Python"
echo "\
${CIDD_PATH}
↓
${CIDD_PYTHON_PACKAGES}/${CIDD_GIT_CHILD}"
"${CIDD_PYTHON_ALIAS}" -m "${CIDD_GIT_CHILD}" "${@}"
}
# functions
cidd_cat () {
cidd_cat__file="${1}"
if [ -n "${cidd_cat__file}" ] ; then
cidd_open "${cidd_cat__file}"
cat "${cidd_cat__file}" || exit
cidd_shut "${cidd_cat__file}"
fi
}
cidd_echo () {
if [ -n "${1}" ] ; then
for cidd_echo__name in "${@}" ; do
eval "cidd_echo__text=\"\${${cidd_echo__name}}\""
echo "${cidd_echo__name} = \"${cidd_echo__text}\""
done
fi
}
cidd_error_ci () {
echo "× CI: ${*}"
exit "${CIDD_ERROR_CI}"
}
cidd_error_os () {
cidd_error_os__variable="${1}"
printf "× OS: "
cidd_echo "${cidd_error_os__variable}"
exit "${CIDD_ERROR_OS}"
}
cidd_grep_os () {
cidd_grep_os__variable="${1}"
if [ -n "${cidd_grep_os__variable}" ] ; then
grep "^${cidd_grep_os__variable}=" "/etc/os-release" \
| sed "s|^${cidd_grep_os__variable}=||" \
| sed "s|^\"\(.*\)\"$|\1|"
fi
}
cidd_install_package () {
cidd_install_package__name="${1}"
if [ -n "${cidd_install_package__name}" ] ; then
${CIDD_PM_INSTALL} "${cidd_install_package__name}" || exit
fi
}
cidd_ln_python () {
cidd_ln_python__command="${1}"
if [ -n "${cidd_ln_python__command}" ] ; then
echo "→ ${CIDD_PYTHON_ALIAS} → ${cidd_ln_python__command}"
ln -f -s "${cidd_ln_python__command}" "/usr/bin/${CIDD_PYTHON_ALIAS}" \
|| exit
fi
}
cidd_ls () {
cidd_ls__path="${1}"
if [ -n "${cidd_ls__path}" ] ; then
cidd_open "${cidd_ls__path}"
ls -a -l "${cidd_ls__path}" || exit
cidd_shut "${cidd_ls__path}"
fi
}
cidd_mkdir () {
cidd_mkdir__path="${1}"
if [ -n "${cidd_mkdir__path}" ] ; then
echo "→ ${cidd_mkdir__path}"
mkdir --parents "${cidd_mkdir__path}" || exit
fi
}
cidd_open () {
echo "${CIDD_OPEN}${*}"
}
cidd_openssl () {
cidd_openssl__file="${1}"
if [ -f "${cidd_openssl__file}" ] ; then
openssl x509 \
-in "${cidd_openssl__file}" \
-noout -text \
|| exit
fi
}
cidd_rm () {
cidd_rm__path="${1}"
if [ -e "${cidd_rm__path}" ] ; then
echo "← ${cidd_rm__path}"
rm -r "${cidd_rm__path}" || exit
fi
}
cidd_sed () {
cidd_sed__file="${1}"
shift
if [ -f "${cidd_sed__file}" ] ; then
cidd_cat "${cidd_sed__file}"
for cidd_sed__regex in "${@}" ; do
sed --in-place "s${cidd_sed__regex}g" "${cidd_sed__file}" \
&& cidd_cat "${cidd_sed__file}" \
|| exit
done
fi
}
cidd_shut () {
echo "${CIDD_SHUT}${*}"
}
cidd_split () {
echo "${CIDD_SPLT}"
}
cidd_step () {
CIDD_STEP=$((CIDD_STEP+1))
echo "\
${CIDD_DOWN}
${CIDD_VERT} ${CIDD_STEP} ${*}
${CIDD___UP}"
}
cidd_write () {
cidd_write__file="${1}"
cidd_write__text="${2}"
if [ -n "${cidd_write__file}" ] ; then
[ -f "${cidd_write__file}" ] && cidd_cat "${cidd_write__file}"
echo "→ ${cidd_write__file}"
printf "%s" "${cidd_write__text}" > "${cidd_write__file}" || exit
cidd_cat "${cidd_write__file}"
fi
}
# constants
CIDD_BOX_DOWN="╭"
CIDD_BOX_LEFT="╴"
CIDD_BOX_RIGHT="╶"
CIDD_BOX_UP="╰"
CIDD_BOX_VERTICAL="│"
CIDD_ERROR_CI=2
CIDD_ERROR_OS=1
CIDD_OS_ALMA="alma"
CIDD_OS_ALPINE="alpine"
CIDD_OS_ARCH="arch"
CIDD_OS_DEBIAN="debian"
CIDD_OS_FEDORA="fedora"
CIDD_OS_ROCKY="rocky"
CIDD_OS_UBUNTU="ubuntu"
CIDD_PM_APK="apk"
CIDD_PM_APT="apt"
CIDD_PM_DNF="dnf"
CIDD_PM_PACMAN="pacman"
CIDD_HORIZONTAL="────╌╌╌╌┄┄┄┄┈┈┈┈"
CIDD_OPEN="${CIDD_BOX_DOWN}${CIDD_BOX_LEFT}"
CIDD_DOWN="${CIDD_BOX_DOWN}${CIDD_HORIZONTAL}"
CIDD_VERT="${CIDD_BOX_VERTICAL}"
CIDD_SPLT="${CIDD_BOX_RIGHT}${CIDD_HORIZONTAL}"
CIDD___UP="${CIDD_BOX_UP}${CIDD_HORIZONTAL}"
CIDD_SHUT="${CIDD_BOX_UP}${CIDD_BOX_LEFT}"
# run
cidd_main "${@}"

8
cidd/__main__.py
View file

@ -1,8 +0,0 @@
#! /usr/bin/env python3
"""Entry point."""
import cidd
if __name__ == "__main__":
cidd.main(__file__)

6
pyproject.toml
View file

@ -15,11 +15,11 @@ classifiers = [
"Operating System :: OS Independent",
]
dependencies = ["rwx"]
description = "Continuous Integration, Delivery & Deployment"
description = "Continuous Deployment"
dynamic = ["version"]
keywords = []
license-files = { paths = ["license.md"] }
name = "cidd"
name = "cd"
readme = "readme.md"
requires-python = ">= 3.10"
@ -29,7 +29,7 @@ requires-python = ">= 3.10"
[project.urls]
[tool.hatch.version]
path = "cidd/__init__.py"
path = "cd/__init__.py"
[tool.ruff]
line-length = 80

34
readme.md
View file

@ -1,6 +1,6 @@
# Continuous Integration, Delivery & Deployment
# Continuous Deployment
Get a common set of Python CI & CD commands \
Get a common set of Python CI/CD commands \
from various contexts of CA, CI and OCI / OS.
## Features
@ -39,21 +39,21 @@ from various contexts of CA, CI and OCI / OS.
## How
| Variable | Description | Default |
|:----------------|:------------------------|:--------------------------------|
| CIDD_CA_n | Numbered CA certificate | |
| CIDD_DNS | Space separated servers | 9.9.9.9 |
| CIDD_GIT_CHILD | Child Git repository | cidd |
| CIDD_GIT_PARENT | Parent Git repository | rwx |
| CIDD_SSH_HOSTS | domain.tld ssh-type pub | |
| CIDD_SSH_KEY | SSH private key | |
| CIDD_URL_ALMA | Alma repository URL | https://repo.almalinux.org |
| CIDD_URL_ALPINE | Alpine repository URL | https://dl-cdn.alpinelinux.org |
| CIDD_URL_ARCH | Arch repository URL | https://geo.mirror.pkgbuild.com |
| CIDD_URL_DEBIAN | Debian repository URL | https://deb.debian.org |
| CIDD_URL_FEDORA | Fedora repository URL | https://rpmfind.net |
| CIDD_URL_ROCKY | Rocky repository URL | https://dl.rockylinux.org |
| CIDD_URL_UBUNTU | Ubuntu repository URL | https://ubuntu.mirrors.ovh.net |
| Variable | Description | Default |
|:--------------|:------------------------|:--------------------------------|
| CD_CA_n | Numbered CA certificate | |
| CD_DNS | Space separated servers | 9.9.9.9 |
| CD_GIT_CHILD | Child Git repository | cd |
| CD_GIT_PARENT | Parent Git repository | rwx |
| CD_SSH_HOSTS | domain.tld ssh-type pub | |
| CD_SSH_KEY | SSH private key | |
| CD_URL_ALMA | Alma repository URL | https://repo.almalinux.org |
| CD_URL_ALPINE | Alpine repository URL | https://dl-cdn.alpinelinux.org |
| CD_URL_ARCH | Arch repository URL | https://geo.mirror.pkgbuild.com |
| CD_URL_DEBIAN | Debian repository URL | https://deb.debian.org |
| CD_URL_FEDORA | Fedora repository URL | https://rpmfind.net |
| CD_URL_ROCKY | Rocky repository URL | https://dl.rockylinux.org |
| CD_URL_UBUNTU | Ubuntu repository URL | https://ubuntu.mirrors.ovh.net |
## HTTPS & Python