Merge pull request #74 from Itxaka/master

Signed-off-by: Itxaka <itxaka.garcia@spectrocloud.com>

.github/workflows/bump_repos.yml

@@ -0,0 +1,26 @@
+name: Bump repositories
+on:
+  schedule:
+    - cron: 0 20 * * *
+  workflow_dispatch:
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install earthly
+        uses: Luet-lab/luet-install-action@v1
+        with:
+          repository: quay.io/kairos/packages
+          packages: utils/earthly
+      - name: Bump cos 🔧
+        run: earthly +bump-repositories
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v5
+        with:
+          token: ${{ secrets.PAT_TOKEN }}
+          push-to-fork: ci-forks/osbuilder
+          commit-message: ':arrow_up: Update repositories'
+          title: ':arrow_up: Update repositories'
+          body: Bump of Kairos repositories
+          signoff: true

.github/workflows/enki.yml

@@ -0,0 +1,24 @@
+---
+name: 'run enki unit tests'
+
+on:
+  pull_request:
+
+concurrency:
+  group: enki-${{ github.ref || github.head_ref }}
+  cancel-in-progress: true
+
+env:
+  FORCE_COLOR: 1
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: earthly/actions-setup@v1.0.7
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Build
+        run: cd tools-image/enki && earthly -P +test

.github/workflows/image.yml

@@ -8,17 +8,21 @@ on:
     tags:
       - '*'
 
+concurrency:
+  group: image-${{ github.ref || github.head_ref }}
+  cancel-in-progress: true
+
 jobs:
   docker:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Prepare
         id: prep
         run: |
-          DOCKER_IMAGE=quay.io/c3os/osbuilder
+          DOCKER_IMAGE=quay.io/kairos/osbuilder
           VERSION=latest
           SHORTREF=${GITHUB_SHA::8}
           # If this is git tag, use the tag name as a docker tag
@@ -46,14 +50,14 @@ jobs:
 
       - name: Login to DockerHub
         if: github.event_name != 'pull_request'
-        uses: docker/login-action@v1
+        uses: docker/login-action@v2
         with:
           registry: quay.io
           username: ${{ secrets.QUAY_USERNAME }}
           password: ${{ secrets.QUAY_PASSWORD }}
 
       - name: Build
-        uses: docker/build-push-action@v2
+        uses: docker/build-push-action@v4
         with:
           builder: ${{ steps.buildx.outputs.name }}
           context: .

.github/workflows/lint.yaml

@@ -0,0 +1,21 @@
+name: Lint
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    paths:
+      - '**'
+
+concurrency:
+  group: lint-${{ github.ref || github.head_ref }}
+  cancel-in-progress: true
+
+env:
+  FORCE_COLOR: 1
+jobs:
+  call-workflow:
+    uses: kairos-io/linting-composite-action/.github/workflows/reusable-linting.yaml@v0.0.6
+    with:
+      yamldirs: ".github/workflows/ config/ tools-image/"
+      is-go: true

.github/workflows/test.yml

@@ -0,0 +1,24 @@
+---
+name: 'test'
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - '*'
+  pull_request:
+
+concurrency:
+  group: test-${{ github.ref || github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Test
+        run: |
+          make kind-e2e-tests

.github/workflows/tool-image.yml

@@ -0,0 +1,66 @@
+---
+name: 'build tools container images'
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - '*'
+concurrency:
+  group: tool-image-${{ github.ref || github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Prepare
+        id: prep
+        run: |
+          DOCKER_IMAGE=quay.io/kairos/osbuilder-tools
+          VERSION=latest
+          SHORTREF=${GITHUB_SHA::8}
+          # If this is git tag, use the tag name as a docker tag
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          fi
+          TAGS="${DOCKER_IMAGE}:${VERSION},${DOCKER_IMAGE}:${SHORTREF}"
+          # If the VERSION looks like a version number, assume that
+          # this is the most recent version of the image and also
+          # tag it 'latest'.
+          if [[ $VERSION =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
+            TAGS="$TAGS,${DOCKER_IMAGE}:latest"
+          fi
+          # Set output parameters.
+          echo ::set-output name=tags::${TAGS}
+          echo ::set-output name=docker_image::${DOCKER_IMAGE}
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@master
+        with:
+          platforms: all
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@master
+
+      - name: Login to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v2
+        with:
+          registry: quay.io
+          username: ${{ secrets.QUAY_USERNAME }}
+          password: ${{ secrets.QUAY_PASSWORD }}
+
+      - name: Build
+        uses: docker/build-push-action@v4
+        with:
+          builder: ${{ steps.buildx.outputs.name }}
+          context: ./tools-image
+          file: ./tools-image/Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.prep.outputs.tags }}

.shellcheckrc

@@ -0,0 +1,5 @@
+disable=SC2086
+disable=SC2034
+disable=SC2046
+disable=SC2068
+disable=SC2154

.yamllint

@@ -0,0 +1,21 @@
+extends: default
+
+rules:
+  # 80 chars should be enough, but don't fail if a line is longer
+  line-length:
+    max: 150
+    level: warning
+
+  # accept both     key:
+  #                   - item
+  #
+  # and             key:
+  #                 - item
+  indentation:
+    indent-sequences: whatever
+
+  truthy:
+    check-keys: false
+
+  document-start:
+    present: false

Dockerfile

@@ -1,5 +1,5 @@
 # Build the manager binary
-FROM golang:1.18 as builder
+FROM golang:1.20 as builder
 
 WORKDIR /workspace
 # Copy the Go Modules manifests

Earthfile

@@ -0,0 +1,22 @@
+VERSION 0.6
+
+last-commit-packages:
+    FROM quay.io/skopeo/stable
+    RUN dnf install -y jq
+    WORKDIR build
+    RUN skopeo list-tags docker://quay.io/kairos/packages | jq -rc '.Tags | map(select( (. | contains("-repository.yaml")) )) | sort_by(. | sub("v";"") | sub("-repository.yaml";"") | sub("-";"") | split(".") | map(tonumber) ) | .[-1]' > REPO_AMD64
+    RUN skopeo list-tags docker://quay.io/kairos/packages-arm64 | jq -rc '.Tags | map(select( (. | contains("-repository.yaml")) )) | sort_by(. | sub("v";"") | sub("-repository.yaml";"") | sub("-";"") | split(".") | map(tonumber) ) | .[-1]' > REPO_ARM64
+    SAVE ARTIFACT REPO_AMD64 REPO_AMD64
+    SAVE ARTIFACT REPO_ARM64 REPO_ARM64
+
+bump-repositories:
+    FROM mikefarah/yq
+    WORKDIR build
+    COPY +last-commit-packages/REPO_AMD64 REPO_AMD64
+    COPY +last-commit-packages/REPO_ARM64 REPO_ARM64
+    ARG REPO_AMD64=$(cat REPO_AMD64)
+    ARG REPO_ARM64=$(cat REPO_ARM64)
+    COPY tools-image/luet.yaml luet.yaml
+    RUN yq eval ".repositories[0] |= . * { \"reference\": \"${REPO_AMD64}\" }" -i luet.yaml
+    RUN yq eval ".repositories[1] |= . * { \"reference\": \"${REPO_ARM64}\" }" -i luet.yaml
+    SAVE ARTIFACT luet.yaml AS LOCAL tools-image/luet.yaml

Makefile

@@ -4,8 +4,8 @@
 # - use the VERSION as arg of the bundle target (e.g make bundle VERSION=0.0.2)
 # - use environment variables to overwrite this value (e.g export VERSION=0.0.2)
 VERSION ?= 0.0.1
-IMG ?= quay.io/c3os/osbuilder:test
-CLUSTER_NAME?="c3os-osbuilder-e2e"
+IMG ?= quay.io/kairos/osbuilder:test
+CLUSTER_NAME?="kairos-osbuilder-e2e"
 export ROOT_DIR:=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
 
 # CHANNELS define the bundle channels used in the bundle.
@@ -31,8 +31,8 @@ BUNDLE_METADATA_OPTS ?= $(BUNDLE_CHANNELS) $(BUNDLE_DEFAULT_CHANNEL)
 # This variable is used to construct full image tags for bundle and catalog images.
 #
 # For example, running 'make bundle-build bundle-push catalog-build catalog-push' will build and push both
-# c3os-x.io/osbuilder-operator-bundle:$VERSION and c3os-x.io/osbuilder-operator-catalog:$VERSION.
-IMAGE_TAG_BASE ?= c3os-x.io/osbuilder-operator
+# kairos.io/osbuilder-bundle:$VERSION and kairos.io/osbuilder-catalog:$VERSION.
+IMAGE_TAG_BASE ?= kairos.io/osbuilder
 
 # BUNDLE_IMG defines the image:tag used for the bundle.
 # You can use it as an arg. (E.g make bundle-build BUNDLE_IMG=<some-registry>/<project-name-bundle>:<tag>)
@@ -147,13 +147,12 @@ uninstall: manifests kustomize ## Uninstall CRDs from the K8s cluster specified
 .PHONY: deploy
 deploy: manifests kustomize ## Deploy controller to the K8s cluster specified in ~/.kube/config.
 	cd config/manager && $(KUSTOMIZE) edit set image controller=${IMG}
+	# TODO: No need to build and then apply. `kubectl apply -k config/default` does the trick
 	$(KUSTOMIZE) build config/default | kubectl apply -f -
 
-
 .PHONY: deploy-dev
 deploy-dev: manifests kustomize ## Deploy controller to the K8s cluster specified in ~/.kube/config.
-	cd config/manager && $(KUSTOMIZE) edit set image controller=${IMG}
-	$(KUSTOMIZE) build config/dev | kubectl apply -f -
+	kubectl apply -k config/dev
 
 .PHONY: undeploy
 undeploy: ## Undeploy controller from the K8s cluster specified in ~/.kube/config. Call with ignore-not-found=true to ignore resource not found errors during deletion.
@@ -172,6 +171,7 @@ $(LOCALBIN):
 
 ## Tool Binaries
 KUSTOMIZE ?= $(LOCALBIN)/kustomize
+GINKGO ?= $(LOCALBIN)/ginkgo
 CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen
 ENVTEST ?= $(LOCALBIN)/setup-envtest
 
@@ -190,6 +190,10 @@ controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessar
 $(CONTROLLER_GEN): $(LOCALBIN)
 	GOBIN=$(LOCALBIN) go install sigs.k8s.io/controller-tools/cmd/controller-gen@$(CONTROLLER_TOOLS_VERSION)
 
+ginkgo: $(GINKGO) ## Download ginkgo locally if necessary.
+$(GINKGO): $(LOCALBIN)
+	GOBIN=$(LOCALBIN) go install -mod=mod github.com/onsi/ginkgo/v2/ginkgo
+
 .PHONY: envtest
 envtest: $(ENVTEST) ## Download envtest-setup locally if necessary.
 $(ENVTEST): $(LOCALBIN)
@@ -266,9 +270,15 @@ test_deps:
 
 .PHONY: unit-tests
 unit-tests: test_deps
-	ginkgo -r -v  --covermode=atomic --coverprofile=coverage.out -p -r ./pkg/...
+	$(GINKGO) -r -v  --covermode=atomic --coverprofile=coverage.out -p -r ./pkg/...
 
 e2e-tests:
-	KUBE_VERSION=${KUBE_VERSION} $(ROOT_DIR)/script/test.sh
+	GINKGO=$(GINKGO) KUBE_VERSION=${KUBE_VERSION} $(ROOT_DIR)/script/test.sh
 
-kind-e2e-tests: kind-setup install undeploy-dev deploy-dev e2e-tests
+kind-e2e-tests: ginkgo kind-setup install undeploy-dev deploy-dev e2e-tests
+
+
+kubesplit: manifests kustomize
+	rm -rf helm-chart
+	mkdir helm-chart
+	$(KUSTOMIZE) build config/default | kubesplit -helm helm-chart

PROJECT

@@ -1,19 +1,19 @@
-domain: c3os-x.io
+domain: kairos.io
 layout:
 - go.kubebuilder.io/v3
 plugins:
   manifests.sdk.operatorframework.io/v2: {}
   scorecard.sdk.operatorframework.io/v2: {}
 projectName: osartifactbuilder-operator
-repo: github.com/c3os-io/osbuilder-operator
+repo: github.com/kairos-io/osbuilder
 resources:
 - api:
     crdVersion: v1
     namespaced: true
   controller: true
-  domain: c3os-x.io
+  domain: kairos.io
   group: build
   kind: OSArtifact
-  path: github.com/c3os-io/osbuilder-operator/api/v1alpha1
+  path: github.com/kairos-io/osbuilder/api/v1alpha1
   version: v1alpha1
 version: "3"

README.md

@@ -1,94 +1,87 @@
-# osartifactbuilder-operator
-// TODO(user): Add simple overview of use/purpose
+<h1 align="center">
+  <br>
+     <img width="184" alt="kairos-white-column 5bc2fe34" src="https://user-images.githubusercontent.com/2420543/193010398-72d4ba6e-7efe-4c2e-b7ba-d3a826a55b7d.png"><br>
+    osbuilder
+<br>
+</h1>
 
-## Description
-// TODO(user): An in-depth paragraph about your project and overview of use
+<h3 align="center">Kubernetes Native Extension to build Linux distributions artifacts from container images</h3>
+<p align="center">
+  <a href="https://opensource.org/licenses/">
+    <img src="https://img.shields.io/badge/licence-APL2-brightgreen"
+         alt="license">
+  </a>
+  <a href="https://github.com/kairos-io/osbuilder/issues"><img src="https://img.shields.io/github/issues/kairos-io/osbuilder"></a>
+  <a href="https://kairos.io/docs/" target=_blank> <img src="https://img.shields.io/badge/Documentation-blue"
+         alt="docs"></a>
+  <img src="https://img.shields.io/badge/made%20with-Go-blue">
+  <img src="https://goreportcard.com/badge/github.com/kairos-io/osbuilder" alt="go report card" />
+</p>
 
-## Getting Started
-You’ll need a Kubernetes cluster to run against. You can use [KIND](https://sigs.k8s.io/kind) to get a local cluster for testing, or run against a remote cluster.
-**Note:** Your controller will automatically use the current context in your kubeconfig file (i.e. whatever cluster `kubectl cluster-info` shows).
 
-### Running on the cluster
-1. Install Instances of Custom Resources:
+With Kairos you can build immutable, bootable Kubernetes and OS images for your edge devices as easily as writing a Dockerfile. Optional P2P mesh with distributed ledger automates node bootstrapping and coordination. Updating nodes is as easy as CI/CD: push a new image to your container registry and let secure, risk-free A/B atomic upgrades do the rest.
 
-```sh
-kubectl apply -f config/samples/
+
+<table>
+<tr>
+<th align="center">
+<img width="640" height="1px">
+<p> 
+<small>
+Documentation
+</small>
+</p>
+</th>
+<th align="center">
+<img width="640" height="1">
+<p> 
+<small>
+Contribute
+</small>
+</p>
+</th>
+</tr>
+<tr>
+<td>
+
+ 📚 [Getting started with Kairos](https://kairos.io/docs/getting-started) <br> :bulb: [Examples](https://kairos.io/docs/examples) <br> :movie_camera: [Video](https://kairos.io/docs/media/) <br> :open_hands:[Engage with the Community](https://kairos.io/community/)
+  
+</td>
+<td>
+  
+🙌[ CONTRIBUTING.md ]( https://github.com/kairos-io/kairos/blob/master/CONTRIBUTING.md ) <br> :raising_hand: [ GOVERNANCE ]( https://github.com/kairos-io/kairos/blob/master/GOVERNANCE.md ) <br>:construction_worker:[Code of conduct](https://github.com/kairos-io/kairos/blob/master/CODE_OF_CONDUCT.md) 
+  
+</td>
+</tr>
+</table>
+
+| :exclamation: | This is experimental! |
+|-|:-|
+
+## Installation
+
+To install, use helm:
+
+```
+# Adds the kairos repo to helm
+$ helm repo add kairos https://kairos-io.github.io/helm-charts
+"kairos" has been added to your repositories
+$ helm repo update                                        
+Hang tight while we grab the latest from your chart repositories...
+...Successfully got an update from the "kairos" chart repository
+Update Complete. ⎈Happy Helming!⎈
+
+# Install the CRD chart
+$ helm install kairos-crd kairos/kairos-crds
+NAME: kairos-crd
+LAST DEPLOYED: Tue Sep  6 20:35:34 2022
+NAMESPACE: default
+STATUS: deployed
+REVISION: 1
+TEST SUITE: None
+
+# Installs osbuilder
+$ helm install kairos-osbuilder kairos/osbuilder
 ```
 
-2. Build and push your image to the location specified by `IMG`:
-	
-```sh
-make docker-build docker-push IMG=<some-registry>/osartifactbuilder-operator:tag
-```
-	
-3. Deploy the controller to the cluster with the image specified by `IMG`:
-
-```sh
-make deploy IMG=<some-registry>/osartifactbuilder-operator:tag
-```
-
-### Uninstall CRDs
-To delete the CRDs from the cluster:
-
-```sh
-make uninstall
-```
-
-### Undeploy controller
-UnDeploy the controller to the cluster:
-
-```sh
-make undeploy
-```
-
-## Contributing
-// TODO(user): Add detailed information on how you would like others to contribute to this project
-
-### How it works
-This project aims to follow the Kubernetes [Operator pattern](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/)
-
-It uses [Controllers](https://kubernetes.io/docs/concepts/architecture/controller/) 
-which provides a reconcile function responsible for synchronizing resources untile the desired state is reached on the cluster 
-
-### Test It Out
-1. Install the CRDs into the cluster:
-
-```sh
-make install
-```
-
-2. Run your controller (this will run in the foreground, so switch to a new terminal if you want to leave it running):
-
-```sh
-make run
-```
-
-**NOTE:** You can also run this in one step by running: `make install run`
-
-### Modifying the API definitions
-If you are editing the API definitions, generate the manifests such as CRs or CRDs using:
-
-```sh
-make manifests
-```
-
-**NOTE:** Run `make --help` for more information on all potential `make` targets
-
-More information can be found via the [Kubebuilder Documentation](https://book.kubebuilder.io/introduction.html)
-
-## License
-
-Copyright 2022.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
+Documentation available at: https://kairos.io/docs/advanced/build/

api/v1alpha2/groupversion_info.go

@@ -14,10 +14,10 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// Package v1alpha1 contains API Schema definitions for the build v1alpha1 API group
-//+kubebuilder:object:generate=true
-//+groupName=build.c3os-x.io
-package v1alpha1
+// Package v1alpha2 contains API Schema definitions for the build v1alpha2 API group
+// +kubebuilder:object:generate=true
+// +groupName=build.kairos.io
+package v1alpha2
 
 import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
@@ -26,7 +26,7 @@ import (
 
 var (
 	// GroupVersion is group version used to register these objects
-	GroupVersion = schema.GroupVersion{Group: "build.c3os-x.io", Version: "v1alpha1"}
+	GroupVersion = schema.GroupVersion{Group: "build.kairos.io", Version: "v1alpha2"}
 
 	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
 	SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}

api/v1alpha2/osartifact_types.go

@@ -14,62 +14,65 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package v1alpha1
+package v1alpha2
 
 import (
+	batchv1 "k8s.io/api/batch/v1"
+	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-// EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!
-// NOTE: json tags are required.  Any new fields you add must have json tags for the fields to be serialized.
-
 // OSArtifactSpec defines the desired state of OSArtifact
 type OSArtifactSpec struct {
-	// INSERT ADDITIONAL SPEC FIELDS - desired state of cluster
-	// Important: Run "make" to regenerate code after modifying this file
-
-	// Foo is an example field of OSArtifact. Edit osartifact_types.go to remove/update
 	ImageName string `json:"imageName,omitempty"`
-	ISO       bool   `json:"iso,omitempty"`
-	// TODO: treat cloudconfig as a secret, and take a secretRef where to store it (optionally)
-	CloudConfig string `json:"cloudConfig,omitempty"`
-	GRUBConfig  string `json:"grubConfig,omitempty"`
 
-	Bundles     []string `json:"bundles,omitempty"`
-	PullOptions *Pull    `json:"pull,omitempty"`
-	PushOptions *Push    `json:"push,omitempty"`
-}
+	ISO bool `json:"iso,omitempty"`
 
-type Push struct {
-	Push                         bool               `json:"push,omitempty"`
-	ImageName                    string             `json:"imageName,omitempty"`
-	ContainerRegistryCredentials *SecretKeySelector `json:"containerRegistryCredentials,omitempty"`
-}
+	//Disk-only stuff
+	DiskSize   string `json:"diskSize,omitempty"`
+	CloudImage bool   `json:"cloudImage,omitempty"`
+	AzureImage bool   `json:"azureImage,omitempty"`
+	GCEImage   bool   `json:"gceImage,omitempty"`
 
-type Pull struct {
-	ContainerRegistryCredentials *SecretKeySelector `json:"containerRegistryCredentials,omitempty"`
-}
-type LocalObjectReference struct {
-	Name string `json:"name"`
+	Netboot    bool   `json:"netboot,omitempty"`
+	NetbootURL string `json:"netbootURL,omitempty"`
+
+	CloudConfigRef *SecretKeySelector `json:"cloudConfigRef,omitempty"`
+	GRUBConfig     string             `json:"grubConfig,omitempty"`
+
+	Bundles   []string `json:"bundles,omitempty"`
+	OSRelease string   `json:"osRelease,omitempty"`
+
+	ImagePullSecrets []corev1.LocalObjectReference     `json:"imagePullSecrets,omitempty"`
+	Exporters        []batchv1.JobSpec                 `json:"exporters,omitempty"`
+	Volume           *corev1.PersistentVolumeClaimSpec `json:"volume,omitempty"`
 }
 
 type SecretKeySelector struct {
-	LocalObjectReference `json:",inline"`
-	// +optional
-	Namespace string `json:"namespace,omitempty"`
+	Name string `json:"name"`
 	// +optional
 	Key string `json:"key,omitempty"`
 }
 
+type ArtifactPhase string
+
+const (
+	Pending   = "Pending"
+	Building  = "Building"
+	Exporting = "Exporting"
+	Ready     = "Ready"
+	Error     = "Error"
+)
+
 // OSArtifactStatus defines the observed state of OSArtifact
 type OSArtifactStatus struct {
-	// INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
-	// Important: Run "make" to regenerate code after modifying this file
-	Phase string `json:"phase,omitempty"`
+	// +kubebuilder:default=Pending
+	Phase ArtifactPhase `json:"phase,omitempty"`
 }
 
 //+kubebuilder:object:root=true
 //+kubebuilder:subresource:status
+// +kubebuilder:printcolumn:name="Phase",type=string,JSONPath=`.status.phase`
 
 // OSArtifact is the Schema for the osartifacts API
 type OSArtifact struct {

api/v1alpha2/zz_generated.deepcopy.go

@@ -19,9 +19,11 @@ limitations under the License.
 
 // Code generated by controller-gen. DO NOT EDIT.
 
-package v1alpha1
+package v1alpha2
 
 import (
+	batchv1 "k8s.io/api/batch/v1"
+	"k8s.io/api/core/v1"
 	runtime "k8s.io/apimachinery/pkg/runtime"
 )
 
@@ -30,7 +32,7 @@ func (in *OSArtifact) DeepCopyInto(out *OSArtifact) {
 	*out = *in
 	out.TypeMeta = in.TypeMeta
 	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
-	out.Spec = in.Spec
+	in.Spec.DeepCopyInto(&out.Spec)
 	out.Status = in.Status
 }
 
@@ -87,6 +89,33 @@ func (in *OSArtifactList) DeepCopyObject() runtime.Object {
 // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
 func (in *OSArtifactSpec) DeepCopyInto(out *OSArtifactSpec) {
 	*out = *in
+	if in.CloudConfigRef != nil {
+		in, out := &in.CloudConfigRef, &out.CloudConfigRef
+		*out = new(SecretKeySelector)
+		**out = **in
+	}
+	if in.Bundles != nil {
+		in, out := &in.Bundles, &out.Bundles
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.ImagePullSecrets != nil {
+		in, out := &in.ImagePullSecrets, &out.ImagePullSecrets
+		*out = make([]v1.LocalObjectReference, len(*in))
+		copy(*out, *in)
+	}
+	if in.Exporters != nil {
+		in, out := &in.Exporters, &out.Exporters
+		*out = make([]batchv1.JobSpec, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Volume != nil {
+		in, out := &in.Volume, &out.Volume
+		*out = new(v1.PersistentVolumeClaimSpec)
+		(*in).DeepCopyInto(*out)
+	}
 }
 
 // DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OSArtifactSpec.
@@ -113,3 +142,18 @@ func (in *OSArtifactStatus) DeepCopy() *OSArtifactStatus {
 	in.DeepCopyInto(out)
 	return out
 }
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *SecretKeySelector) DeepCopyInto(out *SecretKeySelector) {
+	*out = *in
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SecretKeySelector.
+func (in *SecretKeySelector) DeepCopy() *SecretKeySelector {
+	if in == nil {
+		return nil
+	}
+	out := new(SecretKeySelector)
+	in.DeepCopyInto(out)
+	return out
+}

config/crd/bases/build.c3os-x.io_osartifacts.yaml

@@ -1,66 +0,0 @@
----
-apiVersion: apiextensions.k8s.io/v1
-kind: CustomResourceDefinition
-metadata:
-  annotations:
-    controller-gen.kubebuilder.io/version: v0.9.0
-  creationTimestamp: null
-  name: osartifacts.build.c3os-x.io
-spec:
-  group: build.c3os-x.io
-  names:
-    kind: OSArtifact
-    listKind: OSArtifactList
-    plural: osartifacts
-    singular: osartifact
-  scope: Namespaced
-  versions:
-  - name: v1alpha1
-    schema:
-      openAPIV3Schema:
-        description: OSArtifact is the Schema for the osartifacts API
-        properties:
-          apiVersion:
-            description: 'APIVersion defines the versioned schema of this representation
-              of an object. Servers should convert recognized schemas to the latest
-              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
-            type: string
-          kind:
-            description: 'Kind is a string value representing the REST resource this
-              object represents. Servers may infer this from the endpoint the client
-              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
-            type: string
-          metadata:
-            type: object
-          spec:
-            description: OSArtifactSpec defines the desired state of OSArtifact
-            properties:
-              cloudConfig:
-                description: 'TODO: treat cloudconfig as a secret, and take a secretRef
-                  where to store it (optionally)'
-                type: string
-              grubConfig:
-                type: string
-              imageName:
-                description: Foo is an example field of OSArtifact. Edit osartifact_types.go
-                  to remove/update
-                type: string
-              iso:
-                type: boolean
-              pullFromKube:
-                type: boolean
-            type: object
-          status:
-            description: OSArtifactStatus defines the observed state of OSArtifact
-            properties:
-              phase:
-                description: 'INSERT ADDITIONAL STATUS FIELD - define observed state
-                  of cluster Important: Run "make" to regenerate code after modifying
-                  this file'
-                type: string
-            type: object
-        type: object
-    served: true
-    storage: true
-    subresources:
-      status: {}

config/crd/kustomization.yaml

@@ -2,7 +2,7 @@
 # since it depends on service name and namespace that are out of this kustomize package.
 # It should be run by config/default
 resources:
-- bases/build.c3os-x.io_osartifacts.yaml
+- bases/build.kairos.io_osartifacts.yaml
 #+kubebuilder:scaffold:crdkustomizeresource
 
 patchesStrategicMerge:

config/crd/patches/cainjection_in_osartifacts.yaml

@@ -4,4 +4,4 @@ kind: CustomResourceDefinition
 metadata:
   annotations:
     cert-manager.io/inject-ca-from: $(CERTIFICATE_NAMESPACE)/$(CERTIFICATE_NAME)
-  name: osartifacts.build.c3os-x.io
+  name: osartifacts.build.kairos.io

config/crd/patches/webhook_in_osartifacts.yaml

@@ -2,7 +2,7 @@
 apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
-  name: osartifacts.build.c3os-x.io
+  name: osartifacts.build.kairos.io
 spec:
   conversion:
     strategy: Webhook

config/default/kustomization.yaml

@@ -16,6 +16,7 @@ bases:
 - ../crd
 - ../rbac
 - ../manager
+- ../nginx
 # [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix including the one in
 # crd/kustomization.yaml
 #- ../webhook
@@ -72,3 +73,14 @@ vars:
 #    kind: Service
 #    version: v1
 #    name: webhook-service
+- name: NGINX_NAMESPACE
+  objref:
+    kind: Namespace
+    name: system
+    apiVersion: v1
+
+- name: ARTIFACT_COPIER_ROLE
+  objref:
+    kind: Role
+    name: artifactCopier
+    apiVersion: rbac.authorization.k8s.io/v1

config/dev/kustomization.yaml

@@ -1,74 +1,7 @@
-# Adds namespace to all resources.
-namespace: osartifactbuilder-operator-system
-
-# Value of this field is prepended to the
-# names of all resources, e.g. a deployment named
-# "wordpress" becomes "alices-wordpress".
-# Note that it should also match with the prefix (text before '-') of the namespace
-# field above.
-namePrefix: osartifactbuilder-operator-
-
-# Labels to add to all resources and selectors.
-#commonLabels:
-#  someName: someValue
-
 bases:
-- ../crd
-- ../rbac
-- ../manager
-# [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix including the one in
-# crd/kustomization.yaml
-#- ../webhook
-# [CERTMANAGER] To enable cert-manager, uncomment all sections with 'CERTMANAGER'. 'WEBHOOK' components are required.
-#- ../certmanager
-# [PROMETHEUS] To enable prometheus monitor, uncomment all sections with 'PROMETHEUS'.
-#- ../prometheus
+- ../default
 
-patchesStrategicMerge:
-# Protect the /metrics endpoint by putting it behind auth.
-# If you want your controller-manager to expose the /metrics
-# endpoint w/o any authn/z, please comment the following line.
-- manager_auth_proxy_patch.yaml
-
-# Mount the controller config file for loading manager configurations
-# through a ComponentConfig type
-#- manager_config_patch.yaml
-
-# [WEBHOOK] To enable webhook, uncomment all the sections with [WEBHOOK] prefix including the one in
-# crd/kustomization.yaml
-#- manager_webhook_patch.yaml
-
-# [CERTMANAGER] To enable cert-manager, uncomment all sections with 'CERTMANAGER'.
-# Uncomment 'CERTMANAGER' sections in crd/kustomization.yaml to enable the CA injection in the admission webhooks.
-# 'CERTMANAGER' needs to be enabled to use ca injection
-#- webhookcainjection_patch.yaml
-
-# the following config is for teaching kustomize how to do var substitution
-vars:
-# [CERTMANAGER] To enable cert-manager, uncomment all sections with 'CERTMANAGER' prefix.
-#- name: CERTIFICATE_NAMESPACE # namespace of the certificate CR
-#  objref:
-#    kind: Certificate
-#    group: cert-manager.io
-#    version: v1
-#    name: serving-cert # this name should match the one in certificate.yaml
-#  fieldref:
-#    fieldpath: metadata.namespace
-#- name: CERTIFICATE_NAME
-#  objref:
-#    kind: Certificate
-#    group: cert-manager.io
-#    version: v1
-#    name: serving-cert # this name should match the one in certificate.yaml
-#- name: SERVICE_NAMESPACE # namespace of the service
-#  objref:
-#    kind: Service
-#    version: v1
-#    name: webhook-service
-#  fieldref:
-#    fieldpath: metadata.namespace
-#- name: SERVICE_NAME
-#  objref:
-#    kind: Service
-#    version: v1
-#    name: webhook-service
+images:
+- name: quay.io/kairos/osbuilder
+  newName: quay.io/kairos/osbuilder
+  newTag: test

config/dev/manager_auth_proxy_patch.yaml

@@ -1,40 +0,0 @@
-# This patch inject a sidecar container which is a HTTP proxy for the
-# controller manager, it performs RBAC authorization against the Kubernetes API using SubjectAccessReviews.
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: controller-manager
-  namespace: system
-spec:
-  template:
-    spec:
-      containers:
-      - name: kube-rbac-proxy
-        securityContext:
-          allowPrivilegeEscalation: false
-        # TODO(user): uncomment for common cases that do not require escalating privileges
-        # capabilities:
-        #   drop:
-        #     - "ALL"
-        image: gcr.io/kubebuilder/kube-rbac-proxy:v0.11.0
-        args:
-        - "--secure-listen-address=0.0.0.0:8443"
-        - "--upstream=http://127.0.0.1:8080/"
-        - "--logtostderr=true"
-        - "--v=0"
-        ports:
-        - containerPort: 8443
-          protocol: TCP
-          name: https
-        resources:
-          limits:
-            cpu: 500m
-            memory: 128Mi
-          requests:
-            cpu: 5m
-            memory: 64Mi
-      - name: manager
-        args:
-        - "--health-probe-bind-address=:8081"
-        - "--metrics-bind-address=127.0.0.1:8080"
-        - "--leader-elect"

config/dev/manager_config_patch.yaml

@@ -1,21 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: controller-manager
-  namespace: system
-spec:
-  template:
-    spec:
-      containers:
-      - name: manager
-        imagePullPolicy: Never
-        args:
-        - "--config=controller_manager_config.yaml"
-        volumeMounts:
-        - name: manager-config
-          mountPath: /controller_manager_config.yaml
-          subPath: controller_manager_config.yaml
-      volumes:
-      - name: manager-config
-        configMap:
-          name: manager-config

config/manager/controller_manager_config.yaml

@@ -8,14 +8,14 @@ webhook:
   port: 9443
 leaderElection:
   leaderElect: true
-  resourceName: 98ca89ca.c3os-x.io
-#   leaderElectionReleaseOnCancel defines if the leader should step down volume 
+  resourceName: 98ca89ca.kairos.io
+#   leaderElectionReleaseOnCancel defines if the leader should step down volume
 #   when the Manager ends. This requires the binary to immediately end when the
 #   Manager is stopped, otherwise, this setting is unsafe. Setting this significantly
 #   speeds up voluntary leader transitions as the new leader don't have to wait
 #   LeaseDuration time first.
-#   In the default scaffold provided, the program ends immediately after 
-#   the manager stops, so would be fine to enable this option. However, 
-#   if you are doing or is intended to do any operation such as perform cleanups 
+#   In the default scaffold provided, the program ends immediately after
+#   the manager stops, so would be fine to enable this option. However,
+#   if you are doing or is intended to do any operation such as perform cleanups
 #   after the manager stops then its usage might be unsafe.
 #   leaderElectionReleaseOnCancel: true

config/manager/kustomization.yaml

@@ -1,6 +1,8 @@
 resources:
 - manager.yaml
 
+namespace: system
+
 generatorOptions:
   disableNameSuffixHash: true
 
@@ -12,5 +14,5 @@ apiVersion: kustomize.config.k8s.io/v1beta1
 kind: Kustomization
 images:
 - name: controller
-  newName: quay.io/c3os/osbuilder
+  newName: quay.io/kairos/osbuilder
   newTag: test

config/manager/manager.yaml

@@ -9,7 +9,6 @@ apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: controller-manager
-  namespace: system
   labels:
     control-plane: controller-manager
 spec:

config/nginx/deployment.yaml

@@ -0,0 +1,41 @@
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: nginx-public
+spec:
+  accessModes:
+    - ReadWriteOnce
+  resources:
+    requests:
+      storage: 3Gi
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: nginx
+  labels:
+    app.kubernetes.io/name: osbuilder-nginx
+spec:
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: osbuilder-nginx
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: osbuilder-nginx
+    spec:
+      containers:
+      - image: nginx
+        name: nginx
+        volumeMounts:
+          - mountPath: "/usr/share/nginx/html"
+            name: nginx-public
+        ports:
+          - containerPort: 80
+      serviceAccountName: controller-manager
+      terminationGracePeriodSeconds: 10
+      volumes:
+        - name: nginx-public
+          persistentVolumeClaim:
+            claimName: nginx-public

config/nginx/kustomization.yaml

@@ -0,0 +1,4 @@
+resources:
+- deployment.yaml
+- service.yaml
+- role.yaml

config/nginx/role.yaml

@@ -0,0 +1,18 @@
+apiVersion: rbac.authorization.k8s.io/v1
+kind: Role
+metadata:
+  name: artifactCopier
+rules:
+- apiGroups:
+  - ""
+  resources:
+  - pods
+  verbs:
+  - list
+  - get
+- apiGroups:
+  - ""
+  resources:
+  - pods/exec
+  verbs:
+  - create

config/nginx/service.yaml

@@ -0,0 +1,12 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: osbuilder-nginx
+spec:
+  type: NodePort
+  selector:
+    app.kubernetes.io/name: osbuilder-nginx
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 80

config/prometheus/monitor.yaml

@@ -1,4 +1,3 @@
-
 # Prometheus Monitor Service (Metrics)
 apiVersion: monitoring.coreos.com/v1
 kind: ServiceMonitor

config/rbac/kustomization.yaml

@@ -16,6 +16,3 @@ resources:
 - auth_proxy_role.yaml
 - auth_proxy_role_binding.yaml
 - auth_proxy_client_clusterrole.yaml
-
-patchesStrategicMerge:
-- role_custom.yaml

config/rbac/osartifact_editor_role.yaml

@@ -5,7 +5,7 @@ metadata:
   name: osartifact-editor-role
 rules:
 - apiGroups:
-  - build.c3os-x.io
+  - build.kairos.io
   resources:
   - osartifacts
   verbs:
@@ -17,7 +17,7 @@ rules:
   - update
   - watch
 - apiGroups:
-  - build.c3os-x.io
+  - build.kairos.io
   resources:
   - osartifacts/status
   verbs:

config/rbac/osartifact_viewer_role.yaml

@@ -5,7 +5,7 @@ metadata:
   name: osartifact-viewer-role
 rules:
 - apiGroups:
-  - build.c3os-x.io
+  - build.kairos.io
   resources:
   - osartifacts
   verbs:
@@ -13,7 +13,7 @@ rules:
   - list
   - watch
 - apiGroups:
-  - build.c3os-x.io
+  - build.kairos.io
   resources:
   - osartifacts/status
   verbs:

config/rbac/role.yaml

@@ -6,7 +6,50 @@ metadata:
   name: manager-role
 rules:
 - apiGroups:
-  - build.c3os-x.io
+  - ""
+  resources:
+  - configmaps
+  verbs:
+  - create
+  - get
+- apiGroups:
+  - ""
+  resources:
+  - persistentvolumeclaims
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - watch
+- apiGroups:
+  - ""
+  resources:
+  - pods
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - watch
+- apiGroups:
+  - ""
+  resources:
+  - secrets
+  verbs:
+  - get
+- apiGroups:
+  - batch
+  resources:
+  - jobs
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - watch
+- apiGroups:
+  - build.kairos.io
   resources:
   - osartifacts
   verbs:
@@ -18,13 +61,13 @@ rules:
   - update
   - watch
 - apiGroups:
-  - build.c3os-x.io
+  - build.kairos.io
   resources:
   - osartifacts/finalizers
   verbs:
   - update
 - apiGroups:
-  - build.c3os-x.io
+  - build.kairos.io
   resources:
   - osartifacts/status
   verbs:

config/rbac/role_custom.yaml

@@ -1,56 +0,0 @@
----
-apiVersion: rbac.authorization.k8s.io/v1
-kind: ClusterRole
-metadata:
-  creationTimestamp: null
-  name: manager-role
-rules:
-- apiGroups:
-  - build.c3os-x.io
-  resources:
-  - osartifacts
-  verbs:
-  - create
-  - delete
-  - get
-  - list
-  - patch
-  - update
-  - watch
-- apiGroups:
-  - build.c3os-x.io
-  resources:
-  - osartifacts/finalizers
-  verbs:
-  - update
-- apiGroups:
-  - build.c3os-x.io
-  resources:
-  - osartifacts/status
-  verbs:
-  - get
-  - patch
-  - update
-- apiGroups:
-  - build.c3os-x.io
-  resources:
-  - osartifacts/finalizers
-  verbs:
-  - update
-- apiGroups:
-  - ""
-  resources:
-  - services
-  - configmaps
-  verbs:
-  - get
-  - create
-  - update
-- apiGroups:
-  - "apps"
-  resources:
-  - deployments
-  verbs:
-  - get
-  - create
-  - update

config/samples/build_v1alpha1_osartifact.yaml

@@ -1,4 +1,4 @@
-apiVersion: build.c3os-x.io/v1alpha1
+apiVersion: build.kairos.io/v1alpha1
 kind: OSArtifact
 metadata:
   name: osartifact-sample

controllers/configmap.go

@@ -17,22 +17,20 @@ limitations under the License.
 package controllers
 
 import (
-	buildv1alpha1 "github.com/c3os-io/osbuilder-operator/api/v1alpha1"
+	osbuilder "github.com/kairos-io/osbuilder/api/v1alpha2"
 	v1 "k8s.io/api/core/v1"
 
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-func (r *OSArtifactReconciler) genConfigMap(artifact buildv1alpha1.OSArtifact) *v1.ConfigMap {
+func (r *OSArtifactReconciler) genConfigMap(artifact *osbuilder.OSArtifact) *v1.ConfigMap {
 	return &v1.ConfigMap{
-
 		ObjectMeta: metav1.ObjectMeta{
-			Name:            artifact.Name,
-			Namespace:       artifact.Namespace,
-			OwnerReferences: genOwner(artifact),
+			Name:      artifact.Name,
+			Namespace: artifact.Namespace,
 		},
 		Data: map[string]string{
-			"config":   artifact.Spec.CloudConfig,
-			"grub.cfg": artifact.Spec.GRUBConfig,
+			"grub.cfg":   artifact.Spec.GRUBConfig,
+			"os-release": artifact.Spec.OSRelease,
 		}}
 }

controllers/deployment.go

@@ -1,211 +0,0 @@
-/*
-Copyright 2022.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package controllers
-
-import (
-	"fmt"
-
-	buildv1alpha1 "github.com/c3os-io/osbuilder-operator/api/v1alpha1"
-	appsv1 "k8s.io/api/apps/v1"
-	v1 "k8s.io/api/core/v1"
-
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-)
-
-func genDeploymentLabel(s string) map[string]string {
-	return map[string]string{
-		"osbuild": "workload" + s,
-	}
-}
-
-// TODO: Handle registry auth
-// TODO: This shells out, but needs ENV_VAR with key refs mapping
-func unpackContainer(containerImage, pullImage string, pullOptions buildv1alpha1.Pull) v1.Container {
-	return v1.Container{
-		ImagePullPolicy: v1.PullAlways,
-		Name:            "pull-image",
-		Image:           containerImage,
-		Command:         []string{"/bin/bash", "-cxe"},
-		Args: []string{
-			fmt.Sprintf(
-				"luet util unpack %s %s",
-				pullImage,
-				"/rootfs",
-			),
-		},
-		VolumeMounts: []v1.VolumeMount{
-			{
-				Name:      "rootfs",
-				MountPath: "/rootfs",
-			},
-		},
-	}
-}
-
-func createImageContainer(containerImage string, pushOptions buildv1alpha1.Push) v1.Container {
-	return v1.Container{
-		ImagePullPolicy: v1.PullAlways,
-		Name:            "create-image",
-		Image:           containerImage,
-		Command:         []string{"/bin/bash", "-cxe"},
-		Args: []string{
-			fmt.Sprintf(
-				"tar -czvpf test.tar -C /rootfs . && luet util pack %s test.tar image.tar && mv image.tar /public",
-				pushOptions.ImageName,
-			),
-		},
-		VolumeMounts: []v1.VolumeMount{
-			{
-				Name:      "rootfs",
-				MountPath: "/rootfs",
-			},
-			{
-				Name:      "public",
-				MountPath: "/public",
-			},
-		},
-	}
-}
-
-func pushImageContainer(containerImage string, pushOptions buildv1alpha1.Push) v1.Container {
-	return v1.Container{
-		ImagePullPolicy: v1.PullAlways,
-		Name:            "push-image",
-		Image:           containerImage,
-		Command:         []string{"/bin/bash", "-cxe"},
-		Args: []string{
-			fmt.Sprintf(
-				"skopeo /public/image.tar %s",
-				pushOptions.ImageName,
-			),
-		},
-		VolumeMounts: []v1.VolumeMount{
-
-			{
-				Name:      "public",
-				MountPath: "/public",
-			},
-		},
-	}
-}
-
-func (r *OSArtifactReconciler) genDeployment(artifact buildv1alpha1.OSArtifact) *appsv1.Deployment {
-	objMeta := metav1.ObjectMeta{
-		Name:            artifact.Name,
-		Namespace:       artifact.Namespace,
-		OwnerReferences: genOwner(artifact),
-	}
-
-	privileged := false
-	serviceAccount := false
-
-	buildIsoContainer := v1.Container{
-		ImagePullPolicy: v1.PullAlways,
-		SecurityContext: &v1.SecurityContext{Privileged: &privileged},
-		Name:            "build-iso",
-		Image:           r.BuildImage,
-		Command:         []string{"/bin/bash", "-cxe"},
-		Args: []string{
-			fmt.Sprintf(
-				"elemental --debug --name %s build-iso --date=false --overlay-iso /iso/iso-overlay --output /public dir:/rootfs",
-				artifact.Name,
-			),
-		},
-		VolumeMounts: []v1.VolumeMount{
-			{
-				Name:      "public",
-				MountPath: "/public",
-			},
-			{
-				Name:      "config",
-				MountPath: "/iso/iso-overlay/cloud_config.yaml",
-				SubPath:   "config",
-			},
-			{
-				Name:      "grub",
-				MountPath: "/iso/iso-overlay/boot/grub2/grub.cfg",
-				SubPath:   "grub.cfg",
-			},
-			{
-				Name:      "rootfs",
-				MountPath: "/rootfs",
-			},
-		},
-	}
-
-	servingContainer := v1.Container{
-		ImagePullPolicy: v1.PullAlways,
-		SecurityContext: &v1.SecurityContext{Privileged: &privileged},
-		Name:            "serve",
-		Ports:           []v1.ContainerPort{v1.ContainerPort{Name: "http", ContainerPort: 80}},
-		Image:           r.ServingImage,
-		VolumeMounts: []v1.VolumeMount{
-			{
-				Name:      "public",
-				MountPath: "/usr/share/nginx/html",
-			},
-		},
-	}
-
-	pod := v1.PodSpec{
-		AutomountServiceAccountToken: &serviceAccount,
-		Volumes: []v1.Volume{
-			{
-				Name:         "public",
-				VolumeSource: v1.VolumeSource{EmptyDir: &v1.EmptyDirVolumeSource{}},
-			},
-			{
-				Name:         "rootfs",
-				VolumeSource: v1.VolumeSource{EmptyDir: &v1.EmptyDirVolumeSource{}},
-			},
-			{
-				Name: "config",
-				VolumeSource: v1.VolumeSource{
-					ConfigMap: &v1.ConfigMapVolumeSource{
-						LocalObjectReference: v1.LocalObjectReference{Name: artifact.Name}}},
-			},
-		},
-	}
-
-	pod.InitContainers = []v1.Container{buildIsoContainer, unpackContainer(r.ToolImage, artifact.Spec.ImageName, *artifact.Spec.PullOptions)}
-
-	for _, bundle := range artifact.Spec.Bundles {
-		pod.InitContainers = append(pod.InitContainers, unpackContainer(r.ToolImage, bundle, *artifact.Spec.PullOptions))
-	}
-
-	pod.InitContainers = append(pod.InitContainers, buildIsoContainer)
-
-	pod.Containers = []v1.Container{servingContainer}
-
-	deploymentLabels := genDeploymentLabel(artifact.Name)
-	replicas := int32(1)
-
-	return &appsv1.Deployment{
-		ObjectMeta: objMeta,
-
-		Spec: appsv1.DeploymentSpec{
-			Selector: &metav1.LabelSelector{MatchLabels: deploymentLabels},
-			Replicas: &replicas,
-			Template: v1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{
-					Labels: deploymentLabels,
-				},
-				Spec: pod,
-			},
-		},
-	}
-}

controllers/job.go

@@ -0,0 +1,354 @@
+/*
+Copyright 2022.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package controllers
+
+import (
+	"fmt"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	osbuilder "github.com/kairos-io/osbuilder/api/v1alpha2"
+	corev1 "k8s.io/api/core/v1"
+)
+
+func unpackContainer(id, containerImage, pullImage string) corev1.Container {
+	return corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		Name:            fmt.Sprintf("pull-image-%s", id),
+		Image:           containerImage,
+		Command:         []string{"/bin/bash", "-cxe"},
+		Args: []string{
+			fmt.Sprintf(
+				"luet util unpack %s %s",
+				pullImage,
+				"/rootfs",
+			),
+		},
+		VolumeMounts: []corev1.VolumeMount{
+			{
+				Name:      "rootfs",
+				MountPath: "/rootfs",
+			},
+		},
+	}
+}
+
+func pushImageName(artifact *osbuilder.OSArtifact) string {
+	pushName := artifact.Spec.ImageName
+	if pushName != "" {
+		return pushName
+	}
+	return artifact.Name
+}
+
+func createImageContainer(containerImage string, artifact *osbuilder.OSArtifact) corev1.Container {
+	imageName := pushImageName(artifact)
+
+	return corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		Name:            "create-image",
+		Image:           containerImage,
+		Command:         []string{"/bin/bash", "-cxe"},
+		Args: []string{
+			fmt.Sprintf(
+				"tar -czvpf test.tar -C /rootfs . && luet util pack %[1]s test.tar %[2]s.tar && chmod +r %[2]s.tar && mv %[2]s.tar /artifacts",
+				imageName,
+				artifact.Name,
+			),
+		},
+		VolumeMounts: []corev1.VolumeMount{
+			{
+				Name:      "rootfs",
+				MountPath: "/rootfs",
+			},
+			{
+				Name:      "artifacts",
+				MountPath: "/artifacts",
+			},
+		},
+	}
+}
+
+func osReleaseContainer(containerImage string) corev1.Container {
+	return corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		Name:            "os-release",
+		Image:           containerImage,
+		Command:         []string{"/bin/bash", "-cxe"},
+		Args: []string{
+			"cp -rfv /etc/os-release /rootfs/etc/os-release",
+		},
+		VolumeMounts: []corev1.VolumeMount{
+			{
+				Name:      "config",
+				MountPath: "/etc/os-release",
+				SubPath:   "os-release",
+			},
+			{
+				Name:      "rootfs",
+				MountPath: "/rootfs",
+			},
+		},
+	}
+}
+
+func (r *OSArtifactReconciler) newArtifactPVC(artifact *osbuilder.OSArtifact) *corev1.PersistentVolumeClaim {
+	if artifact.Spec.Volume == nil {
+		artifact.Spec.Volume = &corev1.PersistentVolumeClaimSpec{
+			AccessModes: []corev1.PersistentVolumeAccessMode{
+				corev1.ReadWriteOnce,
+			},
+			Resources: corev1.ResourceRequirements{
+				Requests: map[corev1.ResourceName]resource.Quantity{
+					"storage": resource.MustParse("10Gi"),
+				},
+			},
+		}
+	}
+
+	pvc := &corev1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      artifact.Name + "-artifacts",
+			Namespace: artifact.Namespace,
+		},
+		Spec: *artifact.Spec.Volume,
+	}
+
+	return pvc
+}
+
+func (r *OSArtifactReconciler) newBuilderPod(pvcName string, artifact *osbuilder.OSArtifact) *corev1.Pod {
+	cmd := fmt.Sprintf(
+		"/entrypoint.sh --debug --name %s build-iso --date=false --output /artifacts dir:/rootfs",
+		artifact.Name,
+	)
+
+	volumeMounts := []corev1.VolumeMount{
+		{
+			Name:      "artifacts",
+			MountPath: "/artifacts",
+		},
+		{
+			Name:      "rootfs",
+			MountPath: "/rootfs",
+		},
+	}
+
+	if artifact.Spec.GRUBConfig != "" {
+		volumeMounts = append(volumeMounts, corev1.VolumeMount{
+			Name:      "config",
+			MountPath: "/iso/iso-overlay/boot/grub2/grub.cfg",
+			SubPath:   "grub.cfg",
+		})
+	}
+
+	cloudImgCmd := fmt.Sprintf(
+		"/raw-images.sh /rootfs /artifacts/%s.raw",
+		artifact.Name,
+	)
+
+	if artifact.Spec.CloudConfigRef != nil {
+		volumeMounts = append(volumeMounts, corev1.VolumeMount{
+			Name:      "cloudconfig",
+			MountPath: "/iso/iso-overlay/cloud_config.yaml",
+			SubPath:   artifact.Spec.CloudConfigRef.Key,
+		})
+
+		cloudImgCmd += " /iso/iso-overlay/cloud_config.yaml"
+	}
+
+	if artifact.Spec.CloudConfigRef != nil || artifact.Spec.GRUBConfig != "" {
+		cmd = fmt.Sprintf(
+			"/entrypoint.sh --debug --name %s build-iso --date=false --overlay-iso /iso/iso-overlay --output /artifacts dir:/rootfs",
+			artifact.Name,
+		)
+	}
+
+	buildIsoContainer := corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		SecurityContext: &corev1.SecurityContext{Privileged: ptr(true)},
+		Name:            "build-iso",
+		Image:           r.ToolImage,
+		Command:         []string{"/bin/bash", "-cxe"},
+		Args: []string{
+			cmd,
+		},
+		VolumeMounts: volumeMounts,
+	}
+
+	buildCloudImageContainer := corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		SecurityContext: &corev1.SecurityContext{Privileged: ptr(true)},
+		Name:            "build-cloud-image",
+		Image:           r.ToolImage,
+
+		Command: []string{"/bin/bash", "-cxe"},
+		Args: []string{
+			cloudImgCmd,
+		},
+		VolumeMounts: volumeMounts,
+	}
+
+	if artifact.Spec.DiskSize != "" {
+		buildCloudImageContainer.Env = []corev1.EnvVar{{
+			Name:  "EXTEND",
+			Value: artifact.Spec.DiskSize,
+		}}
+	}
+
+	extractNetboot := corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		SecurityContext: &corev1.SecurityContext{Privileged: ptr(true)},
+		Name:            "build-netboot",
+		Image:           r.ToolImage,
+		Command:         []string{"/bin/bash", "-cxe"},
+		Env: []corev1.EnvVar{{
+			Name:  "URL",
+			Value: artifact.Spec.NetbootURL,
+		}},
+		Args: []string{
+			fmt.Sprintf(
+				"/netboot.sh /artifacts/%s.iso /artifacts/%s",
+				artifact.Name,
+				artifact.Name,
+			),
+		},
+		VolumeMounts: volumeMounts,
+	}
+
+	buildAzureCloudImageContainer := corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		SecurityContext: &corev1.SecurityContext{Privileged: ptr(true)},
+		Name:            "build-azure-cloud-image",
+		Image:           r.ToolImage,
+		Command:         []string{"/bin/bash", "-cxe"},
+		Args: []string{
+			fmt.Sprintf(
+				"/azure.sh /artifacts/%s.raw /artifacts/%s.vhd",
+				artifact.Name,
+				artifact.Name,
+			),
+		},
+		VolumeMounts: volumeMounts,
+	}
+
+	buildGCECloudImageContainer := corev1.Container{
+		ImagePullPolicy: corev1.PullAlways,
+		SecurityContext: &corev1.SecurityContext{Privileged: ptr(true)},
+		Name:            "build-gce-cloud-image",
+		Image:           r.ToolImage,
+		Command:         []string{"/bin/bash", "-cxe"},
+		Args: []string{
+			fmt.Sprintf(
+				"/gce.sh /artifacts/%s.raw /artifacts/%s.gce.raw",
+				artifact.Name,
+				artifact.Name,
+			),
+		},
+		VolumeMounts: volumeMounts,
+	}
+
+	podSpec := corev1.PodSpec{
+		AutomountServiceAccountToken: ptr(false),
+		RestartPolicy:                corev1.RestartPolicyNever,
+		Volumes: []corev1.Volume{
+			{
+				Name: "artifacts",
+				VolumeSource: corev1.VolumeSource{
+					PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
+						ClaimName: pvcName,
+						ReadOnly:  false,
+					},
+				},
+			},
+			{
+				Name:         "rootfs",
+				VolumeSource: corev1.VolumeSource{EmptyDir: &corev1.EmptyDirVolumeSource{}},
+			},
+			{
+				Name: "config",
+				VolumeSource: corev1.VolumeSource{
+					ConfigMap: &corev1.ConfigMapVolumeSource{
+						LocalObjectReference: corev1.LocalObjectReference{
+							Name: artifact.Name,
+						},
+					},
+				},
+			},
+		},
+	}
+
+	if artifact.Spec.CloudConfigRef != nil {
+		podSpec.Volumes = append(podSpec.Volumes, corev1.Volume{
+			Name: "cloudconfig",
+			VolumeSource: corev1.VolumeSource{
+				Secret: &corev1.SecretVolumeSource{
+					SecretName: artifact.Spec.CloudConfigRef.Name,
+					Optional:   ptr(true),
+				},
+			},
+		})
+	}
+
+	for i := range artifact.Spec.ImagePullSecrets {
+		podSpec.ImagePullSecrets = append(podSpec.ImagePullSecrets, artifact.Spec.ImagePullSecrets[i])
+	}
+
+	podSpec.InitContainers = []corev1.Container{unpackContainer("baseimage", r.ToolImage, artifact.Spec.ImageName)}
+
+	for i, bundle := range artifact.Spec.Bundles {
+		podSpec.InitContainers = append(podSpec.InitContainers, unpackContainer(fmt.Sprint(i), r.ToolImage, bundle))
+	}
+
+	if artifact.Spec.OSRelease != "" {
+		podSpec.InitContainers = append(podSpec.InitContainers, osReleaseContainer(r.ToolImage))
+	}
+
+	if artifact.Spec.ISO || artifact.Spec.Netboot {
+		podSpec.Containers = append(podSpec.Containers, buildIsoContainer)
+	}
+
+	if artifact.Spec.Netboot {
+		podSpec.Containers = append(podSpec.Containers, extractNetboot)
+	}
+
+	if artifact.Spec.CloudImage {
+		podSpec.Containers = append(podSpec.Containers, buildCloudImageContainer)
+	}
+
+	if artifact.Spec.AzureImage {
+		podSpec.Containers = append(podSpec.Containers, buildAzureCloudImageContainer)
+	}
+
+	if artifact.Spec.GCEImage {
+		podSpec.Containers = append(podSpec.Containers, buildGCECloudImageContainer)
+	}
+
+	podSpec.Containers = append(podSpec.Containers, createImageContainer(r.ToolImage, artifact))
+
+	return &corev1.Pod{
+		ObjectMeta: metav1.ObjectMeta{
+			GenerateName: artifact.Name + "-",
+			Namespace:    artifact.Namespace,
+		},
+		Spec: podSpec,
+	}
+}
+
+func ptr[T any](val T) *T {
+	return &val
+}

controllers/osartifact_controller.go

@@ -19,159 +19,287 @@ package controllers
 import (
 	"context"
 	"fmt"
-	"time"
-
-	buildv1alpha1 "github.com/c3os-io/osbuilder-operator/api/v1alpha1"
-	"github.com/pkg/errors"
+	osbuilder "github.com/kairos-io/osbuilder/api/v1alpha2"
+	batchv1 "k8s.io/api/batch/v1"
+	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/client-go/kubernetes"
-	"sigs.k8s.io/cluster-api/util/patch"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/predicate"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
+)
+
+const (
+	FinalizerName                   = "build.kairos.io/osbuilder-finalizer"
+	artifactLabel                   = "build.kairos.io/artifact"
+	artifactExporterIndexAnnotation = "build.kairos.io/export-index"
 )
 
 // OSArtifactReconciler reconciles a OSArtifact object
 type OSArtifactReconciler struct {
 	client.Client
-	Scheme                              *runtime.Scheme
-	clientSet                           *kubernetes.Clientset
-	ServingImage, BuildImage, ToolImage string
+	ServingImage, ToolImage, CopierImage string
 }
 
-func genOwner(artifact buildv1alpha1.OSArtifact) []metav1.OwnerReference {
-	return []metav1.OwnerReference{
-		*metav1.NewControllerRef(&artifact.ObjectMeta, schema.GroupVersionKind{
-			Group:   buildv1alpha1.GroupVersion.Group,
-			Version: buildv1alpha1.GroupVersion.Version,
-			Kind:    "OSArtifact",
-		}),
-	}
+func (r *OSArtifactReconciler) InjectClient(c client.Client) error {
+	r.Client = c
+
+	return nil
 }
 
-//+kubebuilder:rbac:groups=build.c3os-x.io,resources=osartifacts,verbs=get;list;watch;create;update;patch;delete
-//+kubebuilder:rbac:groups=build.c3os-x.io,resources=osartifacts/status,verbs=get;update;patch
-//+kubebuilder:rbac:groups=build.c3os-x.io,resources=osartifacts/finalizers,verbs=update
+//+kubebuilder:rbac:groups=build.kairos.io,resources=osartifacts,verbs=get;list;watch;create;update;patch;delete
+//+kubebuilder:rbac:groups=build.kairos.io,resources=osartifacts/status,verbs=get;update;patch
+//+kubebuilder:rbac:groups=build.kairos.io,resources=osartifacts/finalizers,verbs=update
+//+kubebuilder:rbac:groups="",resources=pods,verbs=get;list;watch;create;delete
+//+kubebuilder:rbac:groups="",resources=persistentvolumeclaims,verbs=get;list;create;delete;watch
+//+kubebuilder:rbac:groups="",resources=secrets,verbs=get;
+//+kubebuilder:rbac:groups="",resources=configmaps,verbs=get;create;
+//+kubebuilder:rbac:groups=batch,resources=jobs,verbs=get;list;watch;create;delete
 
-// Reconcile is part of the main kubernetes reconciliation loop which aims to
-// move the current state of the cluster closer to the desired state.
-// TODO(user): Modify the Reconcile function to compare the state specified by
-// the OSArtifact object against the actual cluster state, and then
-// perform operations to make the cluster state reflect the state specified by
-// the user.
-//
-// For more details, check Reconcile and its Result here:
-// - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.12.1/pkg/reconcile
 func (r *OSArtifactReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
 
-	var osbuild buildv1alpha1.OSArtifact
-	if err := r.Get(ctx, req.NamespacedName, &osbuild); err != nil {
+	var artifact osbuilder.OSArtifact
+	if err := r.Get(ctx, req.NamespacedName, &artifact); err != nil {
 		if apierrors.IsNotFound(err) {
 			return ctrl.Result{}, nil
 		}
-		return ctrl.Result{}, err
+		return ctrl.Result{Requeue: true}, err
 	}
 
-	logger.Info(fmt.Sprintf("Reconciling %v", osbuild))
+	if artifact.DeletionTimestamp != nil {
+		controllerutil.RemoveFinalizer(&artifact, FinalizerName)
+		return ctrl.Result{}, r.Update(ctx, &artifact)
+	}
 
+	if !controllerutil.ContainsFinalizer(&artifact, FinalizerName) {
+		controllerutil.AddFinalizer(&artifact, FinalizerName)
+		if err := r.Update(ctx, &artifact); err != nil {
+			return ctrl.Result{Requeue: true}, err
+		}
+	}
+
+	logger.Info(fmt.Sprintf("Reconciling %s/%s", artifact.Namespace, artifact.Name))
+
+	switch artifact.Status.Phase {
+	case osbuilder.Exporting:
+		return r.checkExport(ctx, &artifact)
+	case osbuilder.Ready, osbuilder.Error:
+		return ctrl.Result{}, nil
+	default:
+		return r.checkBuild(ctx, &artifact)
+	}
+}
+
+func (r *OSArtifactReconciler) startBuild(ctx context.Context, artifact *osbuilder.OSArtifact) (ctrl.Result, error) {
 	// generate configmap required for building a custom image
-	desiredConfigMap := r.genConfigMap(osbuild)
-	logger.Info(fmt.Sprintf("Checking configmap %v", osbuild))
-
-	cfgMap, err := r.clientSet.CoreV1().ConfigMaps(req.Namespace).Get(ctx, desiredConfigMap.Name, v1.GetOptions{})
-	if cfgMap == nil || apierrors.IsNotFound(err) {
-		logger.Info(fmt.Sprintf("Creating service %v", desiredConfigMap))
-
-		cfgMap, err = r.clientSet.CoreV1().ConfigMaps(req.Namespace).Create(ctx, desiredConfigMap, v1.CreateOptions{})
-		if err != nil {
-			logger.Error(err, "Failed while creating svc")
-			return ctrl.Result{}, err
-		}
+	cm := r.genConfigMap(artifact)
+	if cm.Labels == nil {
+		cm.Labels = map[string]string{}
+	}
+	cm.Labels[artifactLabel] = artifact.Name
+	if err := controllerutil.SetOwnerReference(artifact, cm, r.Scheme()); err != nil {
 		return ctrl.Result{Requeue: true}, err
 	}
-	if err != nil {
+	if err := r.Create(ctx, cm); err != nil && !apierrors.IsAlreadyExists(err) {
 		return ctrl.Result{Requeue: true}, err
 	}
 
-	desiredService := genService(osbuild)
-	logger.Info(fmt.Sprintf("Checking service %v", osbuild))
-
-	svc, err := r.clientSet.CoreV1().Services(req.Namespace).Get(ctx, desiredService.Name, v1.GetOptions{})
-	if svc == nil || apierrors.IsNotFound(err) {
-		logger.Info(fmt.Sprintf("Creating service %v", desiredService))
-
-		svc, err = r.clientSet.CoreV1().Services(req.Namespace).Create(ctx, desiredService, v1.CreateOptions{})
-		if err != nil {
-			logger.Error(err, "Failed while creating svc")
-			return ctrl.Result{}, err
-		}
+	pvc := r.newArtifactPVC(artifact)
+	if pvc.Labels == nil {
+		pvc.Labels = map[string]string{}
+	}
+	pvc.Labels[artifactLabel] = artifact.Name
+	if err := controllerutil.SetOwnerReference(artifact, pvc, r.Scheme()); err != nil {
 		return ctrl.Result{Requeue: true}, err
 	}
-	if err != nil {
+	if err := r.Create(ctx, pvc); err != nil {
 		return ctrl.Result{Requeue: true}, err
 	}
-	logger.Info(fmt.Sprintf("Checking deployment %v", osbuild))
 
-	desiredDeployment := r.genDeployment(osbuild)
-	deployment, err := r.clientSet.AppsV1().Deployments(req.Namespace).Get(ctx, desiredDeployment.Name, v1.GetOptions{})
-	if deployment == nil || apierrors.IsNotFound(err) {
-		logger.Info(fmt.Sprintf("Creating Deployment %v", deployment))
+	pod := r.newBuilderPod(pvc.Name, artifact)
+	if pod.Labels == nil {
+		pod.Labels = map[string]string{}
+	}
+	pod.Labels[artifactLabel] = artifact.Name
+	if err := controllerutil.SetOwnerReference(artifact, pod, r.Scheme()); err != nil {
+		return ctrl.Result{Requeue: true}, err
+	}
+	if err := r.Create(ctx, pod); err != nil {
+		return ctrl.Result{Requeue: true}, err
+	}
 
-		deployment, err = r.clientSet.AppsV1().Deployments(req.Namespace).Create(ctx, desiredDeployment, v1.CreateOptions{})
-		if err != nil {
-			logger.Error(err, "Failed while creating deployment")
+	artifact.Status.Phase = osbuilder.Building
+	if err := r.Status().Update(ctx, artifact); err != nil {
+		return ctrl.Result{Requeue: true}, err
+	}
+
+	return ctrl.Result{}, nil
+}
+
+func (r *OSArtifactReconciler) checkBuild(ctx context.Context, artifact *osbuilder.OSArtifact) (ctrl.Result, error) {
+	var pods corev1.PodList
+	if err := r.List(ctx, &pods, &client.ListOptions{
+		LabelSelector: labels.SelectorFromSet(labels.Set{
+			artifactLabel: artifact.Name,
+		}),
+	}); err != nil {
+		return ctrl.Result{Requeue: true}, err
+	}
+
+	for _, pod := range pods.Items {
+		switch pod.Status.Phase {
+		case corev1.PodSucceeded:
+			artifact.Status.Phase = osbuilder.Exporting
+			return ctrl.Result{Requeue: true}, r.Status().Update(ctx, artifact)
+		case corev1.PodFailed:
+			artifact.Status.Phase = osbuilder.Error
+			return ctrl.Result{Requeue: true}, r.Status().Update(ctx, artifact)
+		case corev1.PodPending, corev1.PodRunning:
 			return ctrl.Result{}, nil
 		}
-
-		return ctrl.Result{Requeue: true}, nil
 	}
-	if err != nil {
+
+	return r.startBuild(ctx, artifact)
+}
+
+func (r *OSArtifactReconciler) checkExport(ctx context.Context, artifact *osbuilder.OSArtifact) (ctrl.Result, error) {
+	var jobs batchv1.JobList
+	if err := r.List(ctx, &jobs, &client.ListOptions{
+		LabelSelector: labels.SelectorFromSet(labels.Set{
+			artifactLabel: artifact.Name,
+		}),
+	}); err != nil {
 		return ctrl.Result{Requeue: true}, err
 	}
 
-	logger.Info(fmt.Sprintf("Updating state %v", osbuild))
-
-	copy := osbuild.DeepCopy()
-
-	helper, err := patch.NewHelper(&osbuild, r.Client)
-	if err != nil {
-		return ctrl.Result{}, err
-	}
-	if deployment.Status.ReadyReplicas == deployment.Status.Replicas {
-		copy.Status.Phase = "Ready"
-	} else if copy.Status.Phase != "Building" {
-		copy.Status.Phase = "Building"
-	}
-	ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
-	defer cancel()
-	if err := helper.Patch(ctx, copy); err != nil {
-		return ctrl.Result{}, errors.Wrapf(err, "couldn't patch osbuild %q", copy.Name)
+	indexedJobs := make(map[string]*batchv1.Job, len(artifact.Spec.Exporters))
+	for _, job := range jobs.Items {
+		if job.GetAnnotations() != nil {
+			if idx, ok := job.GetAnnotations()[artifactExporterIndexAnnotation]; ok {
+				indexedJobs[idx] = &job
+			}
+		}
 	}
 
-	// for _, c := range append(pod.Status.ContainerStatuses, pod.Status.InitContainerStatuses...) {
-	// 	if c.State.Terminated != nil && c.State.Terminated.ExitCode != 0 {
-	// 		packageBuildCopy.Status.State = "Failed"
-	// 	}
-	// }
+	var pvcs corev1.PersistentVolumeClaimList
+	var pvc *corev1.PersistentVolumeClaim
+	if err := r.List(ctx, &pvcs, &client.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set{artifactLabel: artifact.Name})}); err != nil {
+		return ctrl.Result{Requeue: true}, err
+	}
+
+	for _, item := range pvcs.Items {
+		pvc = &item
+		break
+	}
+
+	if pvc == nil {
+		log.FromContext(ctx).Error(nil, "failed to locate pvc for artifact, this should not happen")
+		return ctrl.Result{}, fmt.Errorf("failed to locate artifact pvc")
+	}
+
+	var succeeded int
+	for i := range artifact.Spec.Exporters {
+		idx := fmt.Sprintf("%d", i)
+
+		job := indexedJobs[idx]
+		if job == nil {
+			job = &batchv1.Job{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      fmt.Sprintf("%s-export-%s", artifact.Name, idx),
+					Namespace: artifact.Namespace,
+					Annotations: map[string]string{
+						artifactExporterIndexAnnotation: idx,
+					},
+					Labels: map[string]string{
+						artifactLabel: artifact.Name,
+					},
+				},
+				Spec: artifact.Spec.Exporters[i],
+			}
+
+			job.Spec.Template.Spec.Volumes = append(job.Spec.Template.Spec.Volumes, corev1.Volume{
+				Name: "artifacts",
+				VolumeSource: corev1.VolumeSource{
+					PersistentVolumeClaim: &corev1.PersistentVolumeClaimVolumeSource{
+						ClaimName: pvc.Name,
+						ReadOnly:  true,
+					},
+				},
+			})
+
+			if err := controllerutil.SetOwnerReference(artifact, job, r.Scheme()); err != nil {
+				return ctrl.Result{Requeue: true}, err
+			}
+
+			if err := r.Create(ctx, job); err != nil {
+				return ctrl.Result{Requeue: true}, err
+			}
+
+		} else if job.Spec.Completions == nil || *job.Spec.Completions == 1 {
+			if job.Status.Succeeded > 0 {
+				succeeded++
+			}
+		} else if *job.Spec.BackoffLimit <= job.Status.Failed {
+			artifact.Status.Phase = osbuilder.Error
+			if err := r.Status().Update(ctx, artifact); err != nil {
+				return ctrl.Result{Requeue: true}, err
+			}
+			break
+		}
+	}
+
+	if succeeded == len(artifact.Spec.Exporters) {
+		artifact.Status.Phase = osbuilder.Ready
+		if err := r.Status().Update(ctx, artifact); err != nil {
+			return ctrl.Result{Requeue: true}, err
+		}
+	}
 
 	return ctrl.Result{}, nil
 }
 
 // SetupWithManager sets up the controller with the Manager.
 func (r *OSArtifactReconciler) SetupWithManager(mgr ctrl.Manager) error {
-
-	clientset, err := kubernetes.NewForConfig(mgr.GetConfig())
-	if err != nil {
-		return err
-	}
-	r.clientSet = clientset
-
 	return ctrl.NewControllerManagedBy(mgr).
-		For(&buildv1alpha1.OSArtifact{}).
+		For(&osbuilder.OSArtifact{}).
+		Owns(&osbuilder.OSArtifact{}).
+		Watches(
+			&source.Kind{Type: &corev1.Pod{}},
+			handler.EnqueueRequestsFromMapFunc(r.findOwningArtifact),
+			builder.WithPredicates(predicate.ResourceVersionChangedPredicate{}),
+		).
+		Watches(
+			&source.Kind{Type: &batchv1.Job{}},
+			handler.EnqueueRequestsFromMapFunc(r.findOwningArtifact),
+			builder.WithPredicates(predicate.ResourceVersionChangedPredicate{}),
+		).
 		Complete(r)
 }
+
+func (r *OSArtifactReconciler) findOwningArtifact(obj client.Object) []reconcile.Request {
+	if obj.GetLabels() == nil {
+		return nil
+	}
+
+	if artifactName, ok := obj.GetLabels()[artifactLabel]; ok {
+		return []reconcile.Request{
+			{
+				NamespacedName: types.NamespacedName{
+					Name:      artifactName,
+					Namespace: obj.GetNamespace(),
+				},
+			},
+		}
+	}
+
+	return nil
+}

controllers/service.go

@@ -1,39 +0,0 @@
-/*
-Copyright 2022.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-package controllers
-
-import (
-	buildv1alpha1 "github.com/c3os-io/osbuilder-operator/api/v1alpha1"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/intstr"
-)
-
-func genService(artifact buildv1alpha1.OSArtifact) *v1.Service {
-	objMeta := metav1.ObjectMeta{
-		Name:            artifact.Name,
-		Namespace:       artifact.Namespace,
-		OwnerReferences: genOwner(artifact),
-	}
-	return &v1.Service{
-		ObjectMeta: objMeta,
-		Spec: v1.ServiceSpec{
-			Ports:    []v1.ServicePort{{Name: "http", Port: int32(80), TargetPort: intstr.FromInt(80)}},
-			Selector: genDeploymentLabel(artifact.Name),
-		},
-	}
-}

controllers/suite_test.go

@@ -30,7 +30,7 @@ import (
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 
-	buildv1alpha1 "github.com/c3os-io/osbuilder-operator/api/v1alpha1"
+	buildv1alpha1 "github.com/kairos-io/osbuilder/api/v1alpha1"
 	//+kubebuilder:scaffold:imports
 )
 

go.mod

@@ -1,11 +1,11 @@
-module github.com/c3os-io/osbuilder-operator
+module github.com/kairos-io/osbuilder
 
 go 1.18
 
 require (
 	github.com/onsi/ginkgo v1.16.5
-	github.com/onsi/ginkgo/v2 v2.1.3
-	github.com/onsi/gomega v1.18.1
+	github.com/onsi/ginkgo/v2 v2.9.5
+	github.com/onsi/gomega v1.27.7
 	github.com/pkg/errors v0.9.1
 	github.com/rancher-sandbox/ele-testhelpers v0.0.0-20220614101555-2eddf3b113e2
 	k8s.io/api v0.24.0
@@ -33,24 +33,27 @@ require (
 	github.com/evanphx/json-patch v4.12.0+incompatible // indirect
 	github.com/form3tech-oss/jwt-go v3.2.3+incompatible // indirect
 	github.com/fsnotify/fsnotify v1.5.1 // indirect
-	github.com/go-logr/logr v1.2.0 // indirect
+	github.com/go-logr/logr v1.2.4 // indirect
 	github.com/go-logr/zapr v1.2.0 // indirect
 	github.com/go-openapi/jsonpointer v0.19.5 // indirect
 	github.com/go-openapi/jsonreference v0.19.5 // indirect
 	github.com/go-openapi/swag v0.19.14 // indirect
+	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/gobuffalo/flect v0.2.4 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/google/gnostic v0.5.7-v3refs // indirect
-	github.com/google/go-cmp v0.5.6 // indirect
+	github.com/google/go-cmp v0.5.9 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
+	github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1 // indirect
 	github.com/google/uuid v1.1.2 // indirect
 	github.com/imdario/mergo v0.3.12 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/mailru/easyjson v0.7.6 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
+	github.com/moby/spdystream v0.2.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
@@ -64,19 +67,20 @@ require (
 	go.uber.org/multierr v1.6.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
 	golang.org/x/crypto v0.0.0-20220214200702-86341886e292 // indirect
-	golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd // indirect
+	golang.org/x/net v0.10.0 // indirect
 	golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8 // indirect
-	golang.org/x/sys v0.0.0-20220209214540-3681064d5158 // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
-	golang.org/x/text v0.3.7 // indirect
+	golang.org/x/sys v0.8.0 // indirect
+	golang.org/x/term v0.8.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
 	golang.org/x/time v0.0.0-20220210224613-90d013bbcef8 // indirect
+	golang.org/x/tools v0.9.1 // indirect
 	gomodules.xyz/jsonpatch/v2 v2.2.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/protobuf v1.27.1 // indirect
+	google.golang.org/protobuf v1.28.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 	k8s.io/apiextensions-apiserver v0.24.0 // indirect
 	k8s.io/component-base v0.24.0 // indirect
 	k8s.io/klog/v2 v2.60.1 // indirect

go.sum

@@ -82,6 +82,7 @@ github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20210826220005-b48c857c3a0e/go.m
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
 github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a h1:idn718Q4B6AGu/h5Sxe66HYVdqdGu2l9Iebqhi/AEoA=
 github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY=
@@ -136,6 +137,7 @@ github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8
 github.com/docker/distribution v2.7.1+incompatible h1:a5mlkVzth6W5A4fOsS3D2EO5BUmsJpcB+cRlLU7cSug=
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153 h1:yUdfgN0XgIJw7foRItutHYUIhlcKzcSf5vDpdhQAKTc=
 github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
 github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
 github.com/emicklei/go-restful v2.9.5+incompatible h1:spTtZBk5DYEvbxMVutUuTyh1Ao2r4iyvLdACqsl/Ljk=
@@ -177,6 +179,8 @@ github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7
 github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
 github.com/go-logr/logr v1.2.0 h1:QK40JKJyMdUDz+h+xvCsru/bJhvG0UxvePV0ufL/AcE=
 github.com/go-logr/logr v1.2.0/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
+github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/zapr v1.2.0 h1:n4JnPI1T3Qq1SFEi/F8rwLrZERp2bso19PJZDB9dayk=
 github.com/go-logr/zapr v1.2.0/go.mod h1:Qa4Bsj2Vb+FAVeAKsLD8RLQ+YRJB8YDmOAKxaBQf7Ro=
 github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
@@ -190,6 +194,8 @@ github.com/go-openapi/swag v0.19.14 h1:gm3vOOXfiuw5i9p5N9xJvfjvuofpyvLA9Wr6QfK5F
 github.com/go-openapi/swag v0.19.14/go.mod h1:QYRuS/SOXUCsnplDa677K7+DxSOj6IPNl/eQntq43wQ=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
 github.com/gobuffalo/flect v0.2.4 h1:BSYA8+T60cdyq+vynaSUjqSVI9mDEg9ZfQUXKmfjo4I=
 github.com/gobuffalo/flect v0.2.4/go.mod h1:1ZyCLIbg0YD7sDkzvFdPoOydPtD8y9JQnrOROolUcM8=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
@@ -233,6 +239,8 @@ github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaS
 github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
 github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
@@ -255,6 +263,8 @@ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
@@ -373,6 +383,7 @@ github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh
 github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mitchellh/mapstructure v1.4.2 h1:6h7AQ0yhTcIsmFmnAwQls75jp2Gzs4iB8W7pjMO+rqo=
 github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ=
+github.com/moby/spdystream v0.2.0 h1:cjW1zVyyoiM0T7b6UoySUFqzXMoqRckQtXwGPiBhOM8=
 github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c=
 github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6/go.mod h1:E2VnQOmVuvZB6UYnnDB0qG5Nq/1tD9acaOpo6xmt0Kw=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -404,12 +415,18 @@ github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042
 github.com/onsi/ginkgo/v2 v2.0.0/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
 github.com/onsi/ginkgo/v2 v2.1.3 h1:e/3Cwtogj0HA+25nMP1jCMDIf8RtRYbGwGGuBIFztkc=
 github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
+github.com/onsi/ginkgo/v2 v2.9.5 h1:+6Hr4uxzP4XIUyAkg61dWBw8lb/gc4/X5luuxN/EC+Q=
+github.com/onsi/ginkgo/v2 v2.9.5/go.mod h1:tvAoo1QUJwNEU2ITftXTpR7R1RbCzoZUOs3RonqW57k=
 github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
 github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE=
 github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs=
+github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
+github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg=
+github.com/onsi/gomega v1.27.7 h1:fVih9JD6ogIiHUN6ePK7HJidyEDpWGVB5mzM7cWNXoU=
+github.com/onsi/gomega v1.27.7/go.mod h1:1p8OOlwo2iUUDsHnOrjE5UKYJ+e3W8eQ3qSlRahPmr4=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
@@ -649,6 +666,8 @@ golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qx
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd h1:O7DYs+zxREGLKzKoMQrtrEacpb0ZVXA5rIwylE2Xchk=
 golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -746,9 +765,13 @@ golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220209214540-3681064d5158 h1:rm+CHSpPEEW2IsXUib1ThaHIjuBVZjxNgSKmBLFfD4c=
 golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.8.0 h1:n5xxQn2i3PC0yLAbjTpNT85q/Kgzcr2gIoX9OrJUols=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -759,6 +782,8 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -827,6 +852,8 @@ golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.10-0.20220218145154-897bd77cd717/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E=
+golang.org/x/tools v0.9.1 h1:8WMNJAz3zrtPmnYC7ISf5dEn3MT0gY7jBJfw27yrrLo=
+golang.org/x/tools v0.9.1/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -964,6 +991,8 @@ google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp0
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
 google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ=
 google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.0 h1:w43yiav+6bVFTBQFZX0r7ipe9JQ1QsbMgHwbBziscLw=
+google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -994,6 +1023,8 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk=
 gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

main.go

@@ -31,8 +31,8 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/healthz"
 	"sigs.k8s.io/controller-runtime/pkg/log/zap"
 
-	buildv1alpha1 "github.com/c3os-io/osbuilder-operator/api/v1alpha1"
-	"github.com/c3os-io/osbuilder-operator/controllers"
+	buildv1alpha2 "github.com/kairos-io/osbuilder/api/v1alpha2"
+	"github.com/kairos-io/osbuilder/controllers"
 	//+kubebuilder:scaffold:imports
 )
 
@@ -44,7 +44,7 @@ var (
 func init() {
 	utilruntime.Must(clientgoscheme.AddToScheme(scheme))
 
-	utilruntime.Must(buildv1alpha1.AddToScheme(scheme))
+	utilruntime.Must(buildv1alpha2.AddToScheme(scheme))
 	//+kubebuilder:scaffold:scheme
 }
 
@@ -52,11 +52,12 @@ func main() {
 	var metricsAddr string
 	var enableLeaderElection bool
 	var probeAddr string
-	var buildImage, serveImage, toolImage string
+	var serveImage, toolImage, copierImage string
+
 	flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.")
-	flag.StringVar(&buildImage, "build-image", "quay.io/costoolkit/elemental-cli:v0.0.15-ae4f000", "Build image.")
-	flag.StringVar(&serveImage, "serve-image", "nginx", "Serve image.")
-	flag.StringVar(&toolImage, "tool-image", "quay.io/costoolkit/elemental-cli:v0.0.15-ae4f000", "Tool image.")
+
+	// It needs luet inside
+	flag.StringVar(&toolImage, "tool-image", "quay.io/kairos/osbuilder-tools:latest", "Tool image.")
 
 	flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")
 	flag.BoolVar(&enableLeaderElection, "leader-elect", false,
@@ -76,7 +77,7 @@ func main() {
 		Port:                   9443,
 		HealthProbeBindAddress: probeAddr,
 		LeaderElection:         enableLeaderElection,
-		LeaderElectionID:       "98ca89ca.c3os-x.io",
+		LeaderElectionID:       "98ca89ca.kairos.io",
 		// LeaderElectionReleaseOnCancel defines if the leader should step down voluntarily
 		// when the Manager ends. This requires the binary to immediately end when the
 		// Manager is stopped, otherwise, this setting is unsafe. Setting this significantly
@@ -95,11 +96,9 @@ func main() {
 	}
 
 	if err = (&controllers.OSArtifactReconciler{
-		Client:       mgr.GetClient(),
 		ServingImage: serveImage,
 		ToolImage:    toolImage,
-		BuildImage:   buildImage,
-		Scheme:       mgr.GetScheme(),
+		CopierImage:  copierImage,
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "unable to create controller", "controller", "OSArtifact")
 		os.Exit(1)

renovate.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ],
+  "schedule": [
+    "after 11pm every weekday",
+    "before 7am every weekday",
+    "every weekend"
+  ],
+  "timezone": "Europe/Brussels"
+}

script/test.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 KUBE_VERSION=${KUBE_VERSION:-v1.22.7}
-CLUSTER_NAME="${CLUSTER_NAME:-c3os-osbuilder-e2e}"
+CLUSTER_NAME="${CLUSTER_NAME:-kairos-osbuilder-e2e}"
 
 if ! kind get clusters | grep "$CLUSTER_NAME"; then
 cat << EOF > kind.config
@@ -26,7 +26,8 @@ set -e
 kubectl cluster-info --context kind-$CLUSTER_NAME
 echo "Sleep to give times to node to populate with all info"
 kubectl wait --for=condition=Ready node/$CLUSTER_NAME-control-plane
-export EXTERNAL_IP=$(kubectl get nodes -o jsonpath='{.items[].status.addresses[?(@.type == "InternalIP")].address}')
+EXTERNAL_IP=$(kubectl get nodes -o jsonpath='{.items[].status.addresses[?(@.type == "InternalIP")].address}')
+export EXTERNAL_IP
 export BRIDGE_IP="172.18.0.1"
 kubectl get nodes -o wide
-cd $ROOT_DIR/tests &&  ginkgo -r -v ./e2e
+cd $ROOT_DIR/tests && $GINKGO -r -v ./e2e

tests/e2e/e2e_simple_test.go

@@ -0,0 +1,162 @@
+package e2e_test
+
+import (
+	"context"
+	"time"
+
+	osbuilder "github.com/kairos-io/osbuilder/api/v1alpha2"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	batchv1 "k8s.io/api/batch/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/labels"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/selection"
+	"k8s.io/apimachinery/pkg/watch"
+	"k8s.io/client-go/dynamic"
+	ctrl "sigs.k8s.io/controller-runtime"
+)
+
+var _ = Describe("ISO build test", func() {
+	var artifactName string
+	var artifacts, pods, pvcs, jobs dynamic.ResourceInterface
+	var scheme *runtime.Scheme
+	var artifactLabelSelector labels.Selector
+
+	BeforeEach(func() {
+		k8s := dynamic.NewForConfigOrDie(ctrl.GetConfigOrDie())
+		scheme = runtime.NewScheme()
+		err := osbuilder.AddToScheme(scheme)
+		Expect(err).ToNot(HaveOccurred())
+
+		artifacts = k8s.Resource(schema.GroupVersionResource{Group: osbuilder.GroupVersion.Group, Version: osbuilder.GroupVersion.Version, Resource: "osartifacts"}).Namespace("default")
+		pods = k8s.Resource(schema.GroupVersionResource{Group: corev1.GroupName, Version: corev1.SchemeGroupVersion.Version, Resource: "pods"}).Namespace("default")
+		pvcs = k8s.Resource(schema.GroupVersionResource{Group: corev1.GroupName, Version: corev1.SchemeGroupVersion.Version, Resource: "persistentvolumeclaims"}).Namespace("default")
+		jobs = k8s.Resource(schema.GroupVersionResource{Group: batchv1.GroupName, Version: batchv1.SchemeGroupVersion.Version, Resource: "jobs"}).Namespace("default")
+
+		artifact := &osbuilder.OSArtifact{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       "OSArtifact",
+				APIVersion: osbuilder.GroupVersion.String(),
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				GenerateName: "simple-",
+			},
+			Spec: osbuilder.OSArtifactSpec{
+				ImageName: "quay.io/kairos/core-opensuse:latest",
+				ISO:       true,
+				DiskSize:  "",
+				Exporters: []batchv1.JobSpec{
+					{
+						Template: corev1.PodTemplateSpec{
+							Spec: corev1.PodSpec{
+								RestartPolicy: corev1.RestartPolicyNever,
+								Containers: []corev1.Container{
+									{
+										Name:    "test",
+										Image:   "debian:latest",
+										Command: []string{"bash"},
+										Args:    []string{"-xec", "[ -f /artifacts/*.iso ]"},
+										VolumeMounts: []corev1.VolumeMount{
+											{
+												Name:      "artifacts",
+												ReadOnly:  true,
+												MountPath: "/artifacts",
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+
+		uArtifact := unstructured.Unstructured{}
+		uArtifact.Object, _ = runtime.DefaultUnstructuredConverter.ToUnstructured(artifact)
+		resp, err := artifacts.Create(context.TODO(), &uArtifact, metav1.CreateOptions{})
+		Expect(err).ToNot(HaveOccurred())
+		artifactName = resp.GetName()
+
+		artifactLabelSelectorReq, err := labels.NewRequirement("build.kairos.io/artifact", selection.Equals, []string{artifactName})
+		Expect(err).ToNot(HaveOccurred())
+		artifactLabelSelector = labels.NewSelector().Add(*artifactLabelSelectorReq)
+	})
+
+	It("works", func() {
+		By("starting the build")
+		Eventually(func(g Gomega) {
+			w, err := pods.Watch(context.TODO(), metav1.ListOptions{LabelSelector: artifactLabelSelector.String()})
+			Expect(err).ToNot(HaveOccurred())
+
+			var stopped bool
+			for !stopped {
+				event, ok := <-w.ResultChan()
+
+				stopped = event.Type != watch.Deleted && event.Type != watch.Error || !ok
+			}
+		}).WithTimeout(time.Hour).Should(Succeed())
+
+		By("exporting the artifacts")
+		Eventually(func(g Gomega) {
+			w, err := jobs.Watch(context.TODO(), metav1.ListOptions{LabelSelector: artifactLabelSelector.String()})
+			Expect(err).ToNot(HaveOccurred())
+
+			var stopped bool
+			for !stopped {
+				event, ok := <-w.ResultChan()
+
+				stopped = event.Type != watch.Deleted && event.Type != watch.Error || !ok
+			}
+		}).WithTimeout(time.Hour).Should(Succeed())
+
+		By("building the artifacts successfully")
+		Eventually(func(g Gomega) {
+			w, err := artifacts.Watch(context.TODO(), metav1.ListOptions{})
+			Expect(err).ToNot(HaveOccurred())
+
+			var artifact osbuilder.OSArtifact
+			var stopped bool
+			for !stopped {
+				event, ok := <-w.ResultChan()
+				stopped = !ok
+
+				if event.Type == watch.Modified && event.Object.(*unstructured.Unstructured).GetName() == artifactName {
+					err := scheme.Convert(event.Object, &artifact, nil)
+					Expect(err).ToNot(HaveOccurred())
+					stopped = artifact.Status.Phase == osbuilder.Ready
+				}
+
+			}
+		}).WithTimeout(time.Hour).Should(Succeed())
+
+		By("cleaning up resources on deletion")
+		err := artifacts.Delete(context.TODO(), artifactName, metav1.DeleteOptions{})
+		Expect(err).ToNot(HaveOccurred())
+
+		Eventually(func(g Gomega) int {
+			res, err := artifacts.List(context.TODO(), metav1.ListOptions{})
+			Expect(err).ToNot(HaveOccurred())
+			return len(res.Items)
+		}).WithTimeout(time.Minute).Should(Equal(0))
+		Eventually(func(g Gomega) int {
+			res, err := pods.List(context.TODO(), metav1.ListOptions{LabelSelector: artifactLabelSelector.String()})
+			Expect(err).ToNot(HaveOccurred())
+			return len(res.Items)
+		}).WithTimeout(time.Minute).Should(Equal(0))
+		Eventually(func(g Gomega) int {
+			res, err := pvcs.List(context.TODO(), metav1.ListOptions{LabelSelector: artifactLabelSelector.String()})
+			Expect(err).ToNot(HaveOccurred())
+			return len(res.Items)
+		}).WithTimeout(time.Minute).Should(Equal(0))
+		Eventually(func(g Gomega) int {
+			res, err := jobs.List(context.TODO(), metav1.ListOptions{LabelSelector: artifactLabelSelector.String()})
+			Expect(err).ToNot(HaveOccurred())
+			return len(res.Items)
+		}).WithTimeout(time.Minute).Should(Equal(0))
+	})
+})

tests/e2e/e2e_suite_test.go

@@ -1,39 +1,13 @@
 package e2e_test
 
 import (
-	"time"
+	"testing"
 
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
-	kubectl "github.com/rancher-sandbox/ele-testhelpers/kubectl"
 )
 
-var _ = Describe("ISO build test", func() {
-	//k := kubectl.New()
-	Context("registration", func() {
-
-		AfterEach(func() {
-			kubectl.New().Delete("osartifacts", "-n", "default", "hello-c3os")
-		})
-
-		It("creates a simple iso", func() {
-			err := kubectl.Apply("", "../../tests/fixtures/simple.yaml")
-			Expect(err).ToNot(HaveOccurred())
-
-			Eventually(func() string {
-				b, _ := kubectl.GetData("default", "osartifacts", "hello-c3os", "jsonpath={.spec.imageName}")
-				return string(b)
-			}, 2*time.Minute, 2*time.Second).Should(Equal("quay.io/c3os/c3os:opensuse-latest"))
-
-			Eventually(func() string {
-				b, _ := kubectl.GetData("default", "deployments", "hello-c3os", "jsonpath={.spec.template.metadata.labels.osbuild}")
-				return string(b)
-			}, 2*time.Minute, 2*time.Second).Should(Equal("workloadhello-c3os"))
-			Eventually(func() string {
-				b, _ := kubectl.GetData("default", "deployments", "hello-c3os", "jsonpath={.spec.status.unavailableReplicas}")
-				return string(b)
-			}, 15*time.Minute, 2*time.Second).ShouldNot(Equal("1"))
-		})
-	})
-
-})
+func TestE2e(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "kairos-operator e2e test Suite")
+}

tests/e2e/e2e_test.go

@@ -1,13 +0,0 @@
-package e2e_test
-
-import (
-	"testing"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestE2e(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "c3os-operator e2e test Suite")
-}

tests/fixtures/simple.yaml

@@ -1,7 +1,52 @@
-apiVersion: build.c3os-x.io/v1alpha1
+apiVersion: build.kairos.io/v1alpha1
 kind: OSArtifact
 metadata:
-  name: hello-c3os
+  name: hello-kairos
 spec:
-  imageName: "quay.io/c3os/c3os:opensuse-latest"
-  iso: true
+  imageName: "quay.io/kairos/core-opensuse:latest"
+  iso: true
+  bundles:
+  - quay.io/kairos/packages:goreleaser-utils-1.13.1
+  grubConfig: |
+          search --file --set=root /boot/kernel.xz
+          set default=0
+          set timeout=10
+          set timeout_style=menu
+          set linux=linux
+          set initrd=initrd
+          if [ "${grub_cpu}" = "x86_64" -o "${grub_cpu}" = "i386" -o "${grub_cpu}" = "arm64" ];then
+              if [ "${grub_platform}" = "efi" ]; then
+                  if [ "${grub_cpu}" != "arm64" ]; then
+                      set linux=linuxefi
+                      set initrd=initrdefi
+                  fi
+              fi
+          fi
+          if [ "${grub_platform}" = "efi" ]; then
+              echo "Please press 't' to show the boot menu on this console"
+          fi
+          set font=($root)/boot/${grub_cpu}/loader/grub2/fonts/unicode.pf2
+          if [ -f ${font} ];then
+              loadfont ${font}
+          fi
+          menuentry "install" --class os --unrestricted {
+              echo Loading kernel...
+              $linux ($root)/boot/kernel.xz cdroot root=live:CDLABEL=COS_LIVE rd.live.dir=/ rd.live.squashimg=rootfs.squashfs console=tty1 console=ttyS0 rd.cos.disable vga=795 nomodeset nodepair.enable
+              echo Loading initrd...
+              $initrd ($root)/boot/rootfs.xz
+          }
+
+          if [ "${grub_platform}" = "efi" ]; then
+              hiddenentry "Text mode" --hotkey "t" {
+                  set textmode=true
+                  terminal_output console
+              }
+          fi
+
+  cloudConfig: |
+            #node-config
+            install:
+              device: "/dev/sda"
+              reboot: true
+              poweroff: true
+              auto: true # Required, for automated installations

tools-image/Dockerfile

@@ -0,0 +1,81 @@
+# https://quay.io/repository/kairos/packages?tab=tags&tag=latest
+ARG LEAP_VERSION=15.5
+ARG LUET_VERSION=0.34.0
+FROM quay.io/luet/base:$LUET_VERSION AS luet
+
+FROM golang:1.20 as enki
+ENV CGO_ENABLED=0
+COPY ./enki /src/enki
+WORKDIR /src/enki
+RUN go mod download
+# Set arg/env after go mod download, otherwise we invalidate the cached layers due to the commit changing easily
+ARG ENKI_VERSION=0.0.1
+ARG ENKI_COMMIT=""
+ENV ENKI_VERSION=${ENKI_VERSION}
+ENV ENKI_COMMIT=${ENKI_COMMIT}
+RUN go build \
+    -ldflags "-w -s \
+    -X github.com/kairos-io/enki/internal/version.version=$ENKI_VERSION \
+    -X github.com/kairos-io/enki/internal/version.gitCommit=$ENKI_COMMIT" \
+    -o /usr/bin/enki
+
+FROM opensuse/leap:$LEAP_VERSION as default
+COPY --from=luet /usr/bin/luet /usr/bin/luet
+ENV LUET_NOLOCK=true
+ENV TMPDIR=/tmp
+COPY luet.yaml /etc/luet/luet.yaml
+
+RUN zypper ref && zypper dup -y
+## ISO+ Arm image + Netboot + cloud images Build depedencies
+RUN zypper ref && zypper in -y bc qemu-tools jq cdrtools docker git curl gptfdisk kpartx sudo xfsprogs parted util-linux-systemd e2fsprogs curl util-linux udev rsync grub2 dosfstools grub2-x86_64-efi squashfs mtools xorriso lvm2 zstd
+
+## Live CD artifacts
+RUN luet install -y livecd/grub2 --system-target /grub2
+RUN luet install -y livecd/grub2-efi-image --system-target /efi
+
+## RPI64
+RUN luet install -y firmware/u-boot-rpi64 firmware/raspberrypi-firmware firmware/raspberrypi-firmware-config firmware/raspberrypi-firmware-dt --system-target /rpi/
+
+## PineBook64 Pro
+RUN luet install -y arm-vendor-blob/u-boot-rockchip --system-target /pinebookpro/u-boot
+
+ ## RAW images
+RUN luet install -y static/grub-efi --system-target /raw/grub
+RUN luet install -y static/grub-config --system-target /raw/grubconfig
+RUN luet install -y static/grub-artifacts --system-target /raw/grubartifacts
+
+# remove luet tmp files. Side effect of setting the system-target is that it treats it as a root fs
+# so temporal files are stored in each dir
+RUN rm -Rf /grub2/var/tmp
+RUN rm -Rf /efi/var/tmp
+RUN rm -Rf /rpi/var/tmp
+RUN rm -Rf /pinebookpro/u-boot/var/tmp
+RUN rm -Rf /raw/grub/var/tmp
+RUN rm -Rf /raw/grubconfig/var/tmp
+RUN rm -Rf /raw/grubartifacts/var/tmp
+
+RUN mkdir /config
+
+# ISO build config
+COPY ./config.yaml /config/manifest.yaml
+COPY ./entrypoint.sh /entrypoint.sh
+COPY ./add-cloud-init.sh /add-cloud-init.sh
+COPY ./os-release.tmpl /os-release.tmpl
+COPY ./update-os-release.sh /update-os-release.sh
+
+# ARM helpers
+COPY ./build-arm-image.sh /build-arm-image.sh
+COPY ./arm /arm
+COPY ./prepare_arm_images.sh /prepare_arm_images.sh
+
+# RAW images helpers
+COPY ./gce.sh /gce.sh
+COPY ./raw-images.sh /raw-images.sh
+COPY ./azure.sh /azure.sh
+COPY ./netboot.sh /netboot.sh
+
+COPY defaults.yaml /defaults.yaml
+
+COPY --from=enki /usr/bin/enki /usr/bin/enki
+
+ENTRYPOINT [ "/entrypoint.sh" ]

tools-image/add-cloud-init.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# docker run --entrypoint /add-cloud-init.sh -v $PWD:/work -ti --rm test https://github.com/kairos-io/kairos/releases/download/v1.1.2/kairos-alpine-v1.1.2.iso /work/test.iso /work/config.yaml
+
+set -ex
+
+ISO=$1
+OUT=$2
+CONFIG=$3
+
+case ${ISO} in
+http*)
+    curl -L "${ISO}" -o in.iso
+    ISO=in.iso
+    ;;
+esac
+
+# Needs xorriso >=1.5.4
+xorriso -indev $ISO -outdev $OUT -map $CONFIG /config.yaml -boot_image any replay

tools-image/arm/boards/odroid_c2.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+image=$1
+
+if [ -z "$image" ]; then
+    echo "No image specified"
+    exit 1
+fi
+
+if [ ! -e "$WORKDIR/luet.yaml" ]; then
+    ls -liah $WORKDIR
+    echo "No valid config file"
+    cat "$WORKDIR/luet.yaml"
+    exit 1
+fi
+
+sudo luet install --config $WORKDIR/luet.yaml -y --system-target $WORKDIR firmware/odroid-c2
+# conv=notrunc ?
+dd if=$WORKDIR/bl1.bin.hardkernel of=$image conv=fsync bs=1 count=442
+dd if=$WORKDIR/bl1.bin.hardkernel of=$image conv=fsync bs=512 skip=1 seek=1
+dd if=$WORKDIR/u-boot.odroidc2 of=$image conv=fsync bs=512 seek=97

tools-image/arm/boards/pinebookpro.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+image=$1
+
+if [ -z "$image" ]; then
+    echo "No image specified"
+    exit 1
+fi
+
+LOADER_OFFSET=${LOADER_OFFSET:-"64"}
+LOADER_IMAGE=${LOADER_IMAGE:-"idbloader.img"}
+UBOOT_IMAGE=${UBOOT_IMAGE:-"u-boot.itb"}
+UBOOT_OFFSET=${UBOOT_OFFSET:-"16384"}
+
+echo "Writing idbloader"
+dd conv=notrunc if=/pinebookpro/u-boot/usr/lib/u-boot/pinebook-pro-rk3399/${LOADER_IMAGE} of="$image" conv=fsync seek=${LOADER_OFFSET}
+echo "Writing u-boot image"
+dd conv=notrunc if=/pinebookpro/u-boot/usr/lib/u-boot/pinebook-pro-rk3399/${UBOOT_IMAGE} of="$image" conv=fsync seek=${UBOOT_OFFSET}
+sync $image

tools-image/arm/boards/rpi64.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+partprobe
+
+kpartx -va $DRIVE
+
+image=$1
+
+if [ -z "$image" ]; then
+    echo "No image specified"
+    exit 1
+fi
+
+set -ax
+TEMPDIR="$(mktemp -d)"
+echo $TEMPDIR
+mount "${device}p1" "${TEMPDIR}"
+
+# Copy all rpi files
+cp -rfv /rpi/* $TEMPDIR
+
+umount "${TEMPDIR}"

tools-image/azure.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Transform a raw image disk to azure vhd
+RAWIMAGE="$1"
+VHDDISK="${2:-disk.vhd}"
+cp -rf $RAWIMAGE $VHDDISK.work
+
+MB=$((1024*1024))
+size=$(qemu-img info -f raw --output json "$RAWIMAGE" | gawk 'match($0, /"virtual-size": ([0-9]+),/, val) {print val[1]}')
+# shellcheck disable=SC2004
+ROUNDED_SIZE=$(((($size+$MB-1)/$MB)*$MB))
+echo "Resizing raw image to $ROUNDED_SIZE"
+qemu-img resize -f raw "$VHDDISK.work" $ROUNDED_SIZE
+echo "Converting $RAWIMAGE to $VHDDISK"
+qemu-img convert -f raw -o subformat=fixed,force_size -O vpc "$VHDDISK.work" "$VHDDISK"
+echo "Done"
+rm -rf "$VHDDISK.work"

tools-image/build-arm-image.sh

@@ -0,0 +1,486 @@
+#!/bin/bash
+
+## This is a re-adaptation of https://github.com/rancher/elemental-toolkit/blob/main/images/arm-img-builder.sh
+
+set -ex
+
+load_vars() {
+
+  model=${MODEL:-odroid_c2}
+  disable_lvm=${DISABLE_LVM:-false}
+  directory=${DIRECTORY:-}
+  output_image="${OUTPUT_IMAGE:-arm.img}"
+  # Img creation options. Size is in MB for all of the vars below
+  size="${SIZE:-7608}"
+  state_size="${STATE_SIZE:-4992}"
+  oem_size="${OEM_SIZE:-64}"
+  recovery_size="${RECOVERY_SIZE:-2192}"
+  default_active_size="${DEFAULT_ACTIVE_SIZE:-2400}"
+  menu_entry="${DEFAULT_MENU_ENTRY:-Kairos}"
+
+  ## Repositories
+  final_repo="${FINAL_REPO:-quay.io/costoolkit/releases-teal-arm64}"
+  repo_type="${REPO_TYPE:-docker}"
+
+  # Warning: these default values must be aligned with the values provided
+  # in 'packages/cos-config/cos-config', provide an environment file using the
+  # --cos-config flag if different values are needed.
+  : "${OEM_LABEL:=COS_OEM}"
+  : "${RECOVERY_LABEL:=COS_RECOVERY}"
+  : "${ACTIVE_LABEL:=COS_ACTIVE}"
+  : "${PASSIVE_LABEL:=COS_PASSIVE}"
+  : "${PERSISTENT_LABEL:=COS_PERSISTENT}"
+  : "${SYSTEM_LABEL:=COS_SYSTEM}"
+  : "${STATE_LABEL:=COS_STATE}"
+}
+
+cleanup() {
+	sync
+	sync
+	sleep 5
+	sync
+  if [ -n "$EFI" ]; then
+    rm -rf $EFI
+  fi
+  if [ -n "$RECOVERY" ]; then
+    rm -rf $RECOVERY
+  fi
+  if [ -n "$STATEDIR" ]; then
+    rm -rf $STATEDIR
+  fi
+  if [ -n "$TARGET" ]; then
+    umount $TARGET || true
+    umount $LOOP || true
+    rm -rf $TARGET
+  fi
+  if [ -n "$WORKDIR" ]; then
+    rm -rf $WORKDIR
+  fi
+  if [ -n "$DRIVE" ]; then
+    umount $DRIVE || true
+  fi
+  if [ -n "$recovery" ]; then
+    umount $recovery || true
+  fi
+  if [ -n "$state" ]; then
+    umount $state || true
+  fi
+  if [ -n "$efi" ]; then
+    umount $efi || true
+  fi
+  if [ -n "$oem" ]; then
+    umount $oem || true
+  fi
+
+  losetup -D "${LOOP}" || true;
+}
+
+ensure_dir_structure() {
+    local target=$1
+    for mnt in /sys /proc /dev /tmp /boot /usr/local /oem
+    do
+        if [ ! -d "${target}${mnt}" ]; then
+          mkdir -p ${target}${mnt}
+        fi
+    done
+}
+
+usage()
+{
+    echo "Usage: $0 [options] image.img"
+    echo ""
+    echo "Example: $0 --cos-config cos-config  --model odroid-c2 --docker-image <image> output.img"
+    echo ""
+    echo "Flags:"
+    echo " --cos-config: (optional) Specifies a cos-config file for required environment variables"
+    echo " --config: (optional) Specify a cloud-init config file to embed into the final image"
+    echo " --manifest: (optional) Specify a manifest file to customize efi/grub packages installed into the image"
+    echo " --size: (optional) Image size (MB)"
+    echo " --state-partition-size: (optional) Size of the state partition (MB)"
+    echo " --recovery-partition-size: (optional) Size of the recovery partition (MB)"
+    echo " --images-size: (optional) Size of the active/passive/recovery images (MB)"
+    echo " --docker-image: (optional) A container image which will be used for active/passive/recovery system"
+    echo " --local: (optional) Use local repository when building"
+    echo " --directory: (optional) A directory which will be used for active/passive/recovery system"
+    echo " --model: (optional) The board model"
+    echo " --efi-dir: (optional) A directory with files which will be added to the efi partition"
+    echo " --disable-lvm: (optional- no arguments) LVM for the recovery and oem partitions will be disabled"
+    echo " --use-lvm: (deprecated and ignored. Kept for backwards compatibility)"
+    exit 1
+}
+
+get_url()
+{
+    FROM=$1
+    TO=$2
+    case $FROM in
+        ftp*|http*|tftp*)
+            n=0
+            attempts=5
+            until [ "$n" -ge "$attempts" ]
+            do
+                curl -o $TO -fL ${FROM} && break
+                n=$((n+1))
+                echo "Failed to download, retry attempt ${n} out of ${attempts}"
+                sleep 2
+            done
+            ;;
+        *)
+            cp -f $FROM $TO
+            ;;
+    esac
+}
+
+trap "cleanup" 1 2 3 6 14 15 EXIT
+
+load_vars
+
+while [ "$#" -gt 0 ]; do
+    case $1 in
+        --cos-config)
+            shift 1
+            cos_config=$1
+            ;;
+        --config)
+            shift 1
+            config=$1
+            ;;
+        --manifest)
+            shift 1
+            manifest=$1
+            ;;
+        --size)
+            shift 1
+            size=$1
+            ;;
+        --local)
+            local_build=true
+            ;;
+        --state-partition-size)
+            shift 1
+            state_size=$1
+            ;;
+        --recovery-partition-size)
+            shift 1
+            recovery_size=$1
+            ;;
+        --images-size)
+            shift 1
+            default_active_size=$1
+            ;;
+        --docker-image)
+            shift 1
+            CONTAINER_IMAGE=$1
+            ;;
+        --directory)
+            shift 1
+            directory=$1
+            ;;
+        --model)
+            shift 1
+            model=$1
+            ;;
+        --efi-dir)
+            shift 1
+            efi_dir=$1
+            ;;
+        --final-repo)
+            shift 1
+            final_repo=$1
+            ;;
+        --repo-type)
+            shift 1
+            repo_type=$1
+            ;;
+        --disable-lvm)
+            disable_lvm=true
+            ;;
+        --use-lvm)
+            disable_lvm=false
+            ;;
+        -h)
+            usage
+            ;;
+        --help)
+            usage
+            ;;
+        *)
+            if [ "$#" -gt 2 ]; then
+                usage
+            fi
+            output_image=$1
+            break
+            ;;
+    esac
+    shift 1
+done
+
+if [ "$model" == "rpi64" ]; then
+    container_image=${CONTAINER_IMAGE:-quay.io/costoolkit/examples:rpi-latest}
+else
+    # Odroid C2 image contains kernel-default-extra, might have broader support
+    container_image=${CONTAINER_IMAGE:-quay.io/costoolkit/examples:odroid-c2-latest}
+fi
+
+if [ -n "$cos_config" ] && [ -e "$cos_config" ]; then
+  # shellcheck source=/dev/null
+  source "$cos_config"
+fi
+
+if [ -z "$output_image" ]; then
+  echo "No image file specified"
+  exit 1
+fi
+
+if [ -n "$manifest" ]; then
+  YQ_PACKAGES_COMMAND=(yq e -o=json "$manifest")
+  final_repo=${final_repo:-$(yq e ".raw_disk.$model.repo" "${manifest}")}
+fi
+
+echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
+echo "Image Size: $size MB."
+echo "Recovery Partition: $recovery_size."
+echo "State Partition: $state_size MB."
+echo "Images size (active/passive/recovery.img): $default_active_size MB."
+echo "Model: $model"
+if [ -n "$container_image" ] && [ -z "$directory" ]; then
+  echo "Container image: $container_image"
+fi
+if [ -n "$directory" ]; then
+  echo "Root from directory: $directory"
+fi
+echo "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"
+
+# Temp dir used during build
+WORKDIR=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+#ROOT_DIR=$(git rev-parse --show-toplevel)
+TARGET=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+STATEDIR=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+
+
+export WORKDIR
+
+# Prepare active.img
+
+echo ">> Preparing active.img"
+mkdir -p ${STATEDIR}/cOS
+
+dd if=/dev/zero of=${STATEDIR}/cOS/active.img bs=1M count=$default_active_size
+
+mkfs.ext2 ${STATEDIR}/cOS/active.img -L ${ACTIVE_LABEL}
+
+sync
+
+LOOP=$(losetup --show -f ${STATEDIR}/cOS/active.img)
+if [ -z "$LOOP" ]; then
+echo "No device"
+exit 1
+fi
+
+mount -t ext2 $LOOP $TARGET
+
+ensure_dir_structure $TARGET
+
+# Download the container image
+if [ -z "$directory" ]; then
+  echo ">>> Downloading container image"
+  elemental pull-image $( (( local_build == 'true')) && printf %s '--local' ) $container_image $TARGET
+else
+  echo ">>> Copying files from $directory"
+  rsync -axq --exclude='host' --exclude='mnt' --exclude='proc' --exclude='sys' --exclude='dev' --exclude='tmp' ${directory}/ $TARGET
+fi
+
+# We copy the grubmenu.cfg to a temporary location to be copied later in the state partition
+# https://github.com/kairos-io/kairos/blob/62c67e3e61d49435c362014522e5c6696335376f/overlay/files/system/oem/08_grub.yaml#L105
+# This is a hack and we need a better way: https://github.com/kairos-io/kairos/issues/1427
+tmpgrubconfig=$(mktemp /tmp/grubmeny.cfg.XXXXXX)
+cp -rfv $TARGET/etc/kairos/branding/grubmenu.cfg "${tmpgrubconfig}"
+
+umount $TARGET
+sync
+
+if [ -n "$LOOP" ]; then
+    losetup -d $LOOP
+fi
+
+echo ">> Preparing passive.img"
+cp -rfv ${STATEDIR}/cOS/active.img ${STATEDIR}/cOS/passive.img
+tune2fs -L ${PASSIVE_LABEL} ${STATEDIR}/cOS/passive.img
+
+# Preparing recovery
+echo ">> Preparing recovery.img"
+RECOVERY=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+if [ -z "$RECOVERY" ]; then
+  echo "No recovery directory"
+  exit 1
+fi
+
+mkdir -p ${RECOVERY}/cOS
+cp -rfv ${STATEDIR}/cOS/active.img ${RECOVERY}/cOS/recovery.img
+
+tune2fs -L ${SYSTEM_LABEL} ${RECOVERY}/cOS/recovery.img
+
+# Install real grub config to recovery
+cp -rfv /raw/grubconfig/* $RECOVERY
+mkdir -p $RECOVERY/grub2/fonts
+cp -rfv /raw/grubartifacts/* $RECOVERY/grub2
+mv $RECOVERY/grub2/*pf2 $RECOVERY/grub2/fonts
+
+sync
+
+# Prepare efi files
+echo ">> Preparing EFI partition"
+EFI=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+if [ -z "$EFI" ]; then
+  echo "No EFI directory"
+  exit 1
+fi
+
+cp -rfv /efi/* $EFI
+if [ -n "$EFI" ] && [  -n "$efi_dir" ]; then
+  echo "Copy $efi_dir to EFI directory"
+  cp -rfv $efi_dir/* $EFI
+fi
+
+partprobe
+
+echo ">> Writing image and partition table"
+dd if=/dev/zero of="${output_image}" bs=1024000 count="${size}" || exit 1
+if [ "$model" == "rpi64" ]; then 
+    sgdisk -n 1:8192:+96M -c 1:EFI -t 1:0c00 ${output_image}
+else
+    sgdisk -n 1:8192:+16M -c 1:EFI -t 1:0700 ${output_image}
+fi
+sgdisk -n 2:0:+${state_size}M -c 2:state -t 2:8300 ${output_image}
+if [ "$disable_lvm" == 'true' ]; then
+sgdisk -n 3:0:+${recovery_size}M -c 3:recovery -t 3:8300 ${output_image}
+else 
+sgdisk -n 3:0:+$(( recovery_size + oem_size ))M -c 3:lvm -t 3:8e00 ${output_image}
+fi
+sgdisk -n 4:0:+64M -c 4:persistent -t 4:8300 ${output_image}
+
+sgdisk -m 1:2:3:4 ${output_image}
+
+if [ "$model" == "rpi64" ]; then 
+    sfdisk --part-type ${output_image} 1 c
+fi
+
+# Prepare the image and copy over the files
+
+DRIVE=$(losetup -f "${output_image}" --show)
+export DRIVE
+if [ -z "${DRIVE}" ]; then
+	echo "Cannot execute losetup for $output_image"
+	exit 1
+fi
+
+device=${DRIVE/\/dev\//}
+
+if [ -z "$device" ]; then
+  echo "No device"
+  exit 1
+fi
+
+export device="/dev/mapper/${device}"
+
+partprobe
+
+kpartx -va $DRIVE
+
+echo ">> Populating partitions"
+efi=${device}p1
+state=${device}p2
+recovery=${device}p3
+persistent=${device}p4
+oem_lv=/dev/mapper/KairosVG-oem
+recovery_lv=/dev/mapper/KairosVG-recovery
+
+# Create partitions (RECOVERY, STATE, COS_PERSISTENT)
+mkfs.vfat -F 32 ${efi}
+fatlabel ${efi} COS_GRUB
+
+if [ "$disable_lvm" == 'true' ]; then
+mkfs.ext4 -F -L ${RECOVERY_LABEL} $recovery
+else
+pvcreate $recovery
+vgcreate KairosVG $recovery
+lvcreate -Z n -n oem -L ${oem_size} KairosVG
+lvcreate -Z n -n recovery -l 100%FREE KairosVG
+vgchange -ay
+vgmknodes
+mkfs.ext4 -F -L ${OEM_LABEL} $oem_lv
+mkfs.ext4 -F -L ${RECOVERY_LABEL} $recovery_lv
+fi
+mkfs.ext4 -F -L ${STATE_LABEL} $state
+mkfs.ext4 -F -L ${PERSISTENT_LABEL} $persistent
+
+mkdir $WORKDIR/state
+mkdir $WORKDIR/recovery
+mkdir $WORKDIR/efi
+
+if [ "$disable_lvm" == 'true' ]; then
+mount $recovery $WORKDIR/recovery
+else
+mount $recovery_lv $WORKDIR/recovery
+fi
+mount $state $WORKDIR/state
+mount $efi $WORKDIR/efi
+
+
+if [ "$disable_lvm" == "false" ]; then
+  mkdir $WORKDIR/oem
+  mount $oem_lv $WORKDIR/oem
+
+  cp -rfv /defaults.yaml $WORKDIR/oem/01_defaults.yaml
+
+  # Set a OEM config file if specified
+  if [ -n "$config" ]; then
+    echo ">> Copying $config OEM config file"
+    get_url $config $WORKDIR/oem/99_custom.yaml
+  fi
+
+  umount $WORKDIR/oem
+else
+  echo "LVM disabled: Not adding default config with default user/pass and custom config file"
+  echo "Enable LVM to copy those files into /oem"
+fi
+
+grub2-editenv $WORKDIR/state/grub_oem_env set "default_menu_entry=$menu_entry"
+
+# We copy the file we saved earier to the STATE partition
+cp -rfv "${tmpgrubconfig}" $WORKDIR/state/grubmenu
+
+
+# Copy over content
+cp -arf $EFI/* $WORKDIR/efi
+cp -arf $RECOVERY/* $WORKDIR/recovery
+cp -arf $STATEDIR/* $WORKDIR/state
+
+umount $WORKDIR/recovery
+umount $WORKDIR/state
+umount $WORKDIR/efi
+
+if [ "$disable_lvm" == 'false' ]; then
+vgchange -an
+fi
+sync
+
+# Flash uboot and vendor-specific bits
+echo ">> Performing $model specific bits.."
+/arm/boards/$model.sh ${DRIVE}
+
+sync
+sleep 5
+sync
+
+kpartx -dv $DRIVE || true
+
+umount $DRIVE || true
+
+echo ">> Done writing $output_image"
+
+echo ">> Creating SHA256 sum"
+
+sha256sum $output_image > $output_image.sha256
+
+cleanup

tools-image/config.yaml

@@ -0,0 +1,6 @@
+iso:
+  uefi:
+  - dir:/efi
+  image:
+  - dir:/efi
+  - dir:/grub2

tools-image/defaults.yaml

@@ -0,0 +1,8 @@
+#cloud-config
+name: "Default user"
+stages:
+  initramfs:
+    - name: "Set default user/pass"
+      users:
+        kairos:
+          passwd: "kairos"

tools-image/enki/Earthfile

@@ -0,0 +1,19 @@
+VERSION 0.7
+
+# renovate: datasource=docker depName=golang
+ARG --global GO_VERSION=1.20-alpine3.18
+
+test:
+    FROM golang:$GO_VERSION
+    RUN apk add rsync gcc musl-dev docker jq
+    WORKDIR /build
+    COPY . .
+    RUN go mod download
+    ARG TEST_PATHS=./...
+    ARG LABEL_FILTER=
+    ENV CGO_ENABLED=1
+    # Some test require the docker sock exposed
+    WITH DOCKER
+        RUN go run github.com/onsi/ginkgo/v2/ginkgo run --label-filter "$LABEL_FILTER" -v --fail-fast --race --covermode=atomic --coverprofile=coverage.out --coverpkg=github.com/kairos-io/enki/... -p -r $TEST_PATHS
+    END
+    SAVE ARTIFACT coverage.out AS LOCAL coverage.out

tools-image/enki/cmd/build-iso.go

@@ -0,0 +1,122 @@
+package cmd
+
+import (
+	"fmt"
+	"os/exec"
+
+	"github.com/kairos-io/enki/pkg/action"
+	"github.com/kairos-io/enki/pkg/config"
+	"github.com/kairos-io/enki/pkg/utils"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"k8s.io/mount-utils"
+)
+
+// NewBuildISOCmd returns a new instance of the build-iso subcommand and appends it to
+// the root command.
+func NewBuildISOCmd() *cobra.Command {
+	c := &cobra.Command{
+		Use:   "build-iso SOURCE",
+		Short: "Build bootable installation media ISOs",
+		Long: "Build bootable installation media ISOs\n\n" +
+			"SOURCE - should be provided as uri in following format <sourceType>:<sourceName>\n" +
+			"    * <sourceType> - might be [\"dir\", \"file\", \"oci\", \"docker\"], as default is \"docker\"\n" +
+			"    * <sourceName> - is path to file or directory, image name with tag version",
+		Args: cobra.MaximumNArgs(1),
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			return CheckRoot()
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			path, err := exec.LookPath("mount")
+			if err != nil {
+				return err
+			}
+			mounter := mount.New(path)
+
+			cfg, err := config.ReadConfigBuild(viper.GetString("config-dir"), cmd.Flags(), mounter)
+			if err != nil {
+				cfg.Logger.Errorf("Error reading config: %s\n", err)
+			}
+
+			flags := cmd.Flags()
+
+			// Set this after parsing of the flags, so it fails on parsing and prints usage properly
+			cmd.SilenceUsage = true
+			cmd.SilenceErrors = true // Do not propagate errors down the line, we control them
+			spec, err := config.ReadBuildISO(cfg, flags)
+			if err != nil {
+				cfg.Logger.Errorf("invalid install command setup %v", err)
+				return err
+			}
+
+			if len(args) == 1 {
+				imgSource, err := v1.NewSrcFromURI(args[0])
+				if err != nil {
+					cfg.Logger.Errorf("not a valid rootfs source image argument: %s", args[0])
+					return err
+				}
+				spec.RootFS = []*v1.ImageSource{imgSource}
+			} else if len(spec.RootFS) == 0 {
+				errmsg := "rootfs source image for building ISO was not provided"
+				cfg.Logger.Errorf(errmsg)
+				return fmt.Errorf(errmsg)
+			}
+
+			// Repos and overlays can't be unmarshaled directly as they require
+			// to be merged on top and flags do not match any config value key
+			oRootfs, _ := flags.GetString("overlay-rootfs")
+			oUEFI, _ := flags.GetString("overlay-uefi")
+			oISO, _ := flags.GetString("overlay-iso")
+
+			if oRootfs != "" {
+				if ok, err := utils.Exists(cfg.Fs, oRootfs); ok {
+					spec.RootFS = append(spec.RootFS, v1.NewDirSrc(oRootfs))
+				} else {
+					cfg.Logger.Errorf("Invalid value for overlay-rootfs")
+					return fmt.Errorf("Invalid path '%s': %v", oRootfs, err)
+				}
+			}
+			if oUEFI != "" {
+				if ok, err := utils.Exists(cfg.Fs, oUEFI); ok {
+					spec.UEFI = append(spec.UEFI, v1.NewDirSrc(oUEFI))
+				} else {
+					cfg.Logger.Errorf("Invalid value for overlay-uefi")
+					return fmt.Errorf("Invalid path '%s': %v", oUEFI, err)
+				}
+			}
+			if oISO != "" {
+				if ok, err := utils.Exists(cfg.Fs, oISO); ok {
+					spec.Image = append(spec.Image, v1.NewDirSrc(oISO))
+				} else {
+					cfg.Logger.Errorf("Invalid value for overlay-iso")
+					return fmt.Errorf("Invalid path '%s': %v", oISO, err)
+				}
+			}
+
+			buildISO := action.NewBuildISOAction(cfg, spec)
+			err = buildISO.ISORun()
+			if err != nil {
+				cfg.Logger.Errorf(err.Error())
+				return err
+			}
+
+			return nil
+		},
+	}
+	c.Flags().StringP("name", "n", "", "Basename of the generated ISO file")
+	c.Flags().StringP("output", "o", "", "Output directory (defaults to current directory)")
+	c.Flags().Bool("date", false, "Adds a date suffix into the generated ISO file")
+	c.Flags().String("overlay-rootfs", "", "Path of the overlayed rootfs data")
+	c.Flags().String("overlay-uefi", "", "Path of the overlayed uefi data")
+	c.Flags().String("overlay-iso", "", "Path of the overlayed iso data")
+	c.Flags().String("label", "", "Label of the ISO volume")
+	archType := newEnumFlag([]string{"x86_64", "arm64"}, "x86_64")
+	c.Flags().Bool("squash-no-compression", true, "Disable squashfs compression.")
+	c.Flags().VarP(archType, "arch", "a", "Arch to build the image for")
+	return c
+}
+
+func init() {
+	rootCmd.AddCommand(NewBuildISOCmd())
+}

tools-image/enki/cmd/build-iso_test.go

@@ -0,0 +1,70 @@
+/*
+Copyright © 2022 SUSE LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cmd
+
+import (
+	"bytes"
+	"fmt"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/spf13/viper"
+)
+
+var _ = Describe("BuildISO", Label("iso", "cmd"), func() {
+	var buf *bytes.Buffer
+	BeforeEach(func() {
+		buf = new(bytes.Buffer)
+		rootCmd.SetOut(buf)
+		rootCmd.SetErr(buf)
+	})
+	AfterEach(func() {
+		viper.Reset()
+	})
+	It("Errors out if no rootfs sources are defined", Label("flags"), func() {
+		_, _, err := executeCommandC(rootCmd, "build-iso")
+		fmt.Println(buf)
+		Expect(err).ToNot(BeNil())
+		Expect(err.Error()).To(ContainSubstring("rootfs source image for building ISO was not provided"))
+	})
+	It("Errors out if rootfs is a non valid argument", Label("flags"), func() {
+		_, _, err := executeCommandC(rootCmd, "build-iso", "/no/image/reference")
+		Expect(err).ToNot(BeNil())
+		Expect(err.Error()).To(ContainSubstring("invalid image reference"))
+	})
+	It("Errors out if overlay roofs path does not exist", Label("flags"), func() {
+		_, _, err := executeCommandC(
+			rootCmd, "build-iso", "system/cos", "--overlay-rootfs", "/nonexistingpath",
+		)
+		Expect(err).ToNot(BeNil())
+		Expect(err.Error()).To(ContainSubstring("Invalid path"))
+	})
+	It("Errors out if overlay uefi path does not exist", Label("flags"), func() {
+		_, _, err := executeCommandC(
+			rootCmd, "build-iso", "someimage:latest", "--overlay-uefi", "/nonexistingpath",
+		)
+		Expect(err).ToNot(BeNil())
+		Expect(err.Error()).To(ContainSubstring("Invalid path"))
+	})
+	It("Errors out if overlay iso path does not exist", Label("flags"), func() {
+		_, _, err := executeCommandC(
+			rootCmd, "build-iso", "some/image:latest", "--overlay-iso", "/nonexistingpath",
+		)
+		Expect(err).ToNot(BeNil())
+		Expect(err.Error()).To(ContainSubstring("Invalid path"))
+	})
+})

tools-image/enki/cmd/cmd_suite_test.go

@@ -0,0 +1,29 @@
+/*
+Copyright © 2021 SUSE LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cmd
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestWhitebox(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "CLI whitebox test suite")
+}

tools-image/enki/cmd/command_test.go

@@ -0,0 +1,53 @@
+/*
+Copyright © 2021 SUSE LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package cmd
+
+import (
+	"io/ioutil"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+func executeCommandC(cmd *cobra.Command, args ...string) (c *cobra.Command, output string, err error) {
+	// Set args to command
+	cmd.SetArgs(args)
+	// store old stdout
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	// Change stdout to our pipe
+	os.Stdout = w
+	// run the command
+	c, err = cmd.ExecuteC()
+	if err != nil {
+		// Remember to restore stdout!
+		os.Stdout = oldStdout
+		return nil, "", err
+	}
+	err = w.Close()
+	if err != nil {
+		// Remember to restore stdout!
+		os.Stdout = oldStdout
+		return nil, "", err
+	}
+	// Read output from our pipe
+	out, _ := ioutil.ReadAll(r)
+	// restore stdout
+	os.Stdout = oldStdout
+
+	return c, string(out), nil
+}

tools-image/enki/cmd/root.go

@@ -0,0 +1,90 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+func NewRootCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "enki",
+		Short: "enki",
+	}
+	cmd.PersistentFlags().Bool("debug", false, "Enable debug output")
+	cmd.PersistentFlags().String("config-dir", "/etc/elemental", "Set config dir (default is /etc/elemental)")
+	cmd.PersistentFlags().String("logfile", "", "Set logfile")
+	cmd.PersistentFlags().Bool("quiet", false, "Do not output to stdout")
+	_ = viper.BindPFlag("debug", cmd.PersistentFlags().Lookup("debug"))
+	_ = viper.BindPFlag("config-dir", cmd.PersistentFlags().Lookup("config-dir"))
+	_ = viper.BindPFlag("logfile", cmd.PersistentFlags().Lookup("logfile"))
+	_ = viper.BindPFlag("quiet", cmd.PersistentFlags().Lookup("quiet"))
+
+	if viper.GetBool("debug") {
+		logrus.SetLevel(logrus.DebugLevel)
+	}
+	return cmd
+}
+
+// rootCmd represents the base command when called without any subcommands
+var rootCmd = NewRootCmd()
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+
+	err := rootCmd.Execute()
+	if err != nil {
+		os.Exit(1)
+	}
+}
+
+// CheckRoot is a helper to return on PreRunE, so we can add it to commands that require root
+func CheckRoot() error {
+	if os.Geteuid() != 0 {
+		return errors.New("this command requires root privileges")
+	}
+	return nil
+}
+
+type enum struct {
+	Allowed []string
+	Value   string
+}
+
+func (a enum) String() string {
+	return a.Value
+}
+
+func (a *enum) Set(p string) error {
+	isIncluded := func(opts []string, val string) bool {
+		for _, opt := range opts {
+			if val == opt {
+				return true
+			}
+		}
+		return false
+	}
+	if !isIncluded(a.Allowed, p) {
+		return fmt.Errorf("%s is not included in %s", p, strings.Join(a.Allowed, ","))
+	}
+	a.Value = p
+	return nil
+}
+
+func (a *enum) Type() string {
+	return "string"
+}
+
+// newEnum give a list of allowed flag parameters, where the second argument is the default
+func newEnumFlag(allowed []string, d string) *enum {
+	return &enum{
+		Allowed: allowed,
+		Value:   d,
+	}
+}

tools-image/enki/go.mod

@@ -0,0 +1,154 @@
+module github.com/kairos-io/enki
+
+go 1.20
+
+require (
+	github.com/kairos-io/kairos-agent/v2 v2.1.11-0.20230713071318-9a16b94e2af6
+	github.com/kairos-io/kairos-sdk v0.0.9-0.20230719194412-fe26d1de9166
+	github.com/mitchellh/mapstructure v1.5.0
+	github.com/onsi/ginkgo/v2 v2.9.7
+	github.com/onsi/gomega v1.27.8
+	github.com/sanity-io/litter v1.5.5
+	github.com/sirupsen/logrus v1.9.3
+	github.com/spf13/cobra v1.7.0
+	github.com/spf13/pflag v1.0.5
+	github.com/spf13/viper v1.16.0
+	github.com/twpayne/go-vfs v1.7.2
+	k8s.io/mount-utils v0.27.3
+
+)
+
+require (
+	atomicgo.dev/cursor v0.1.3 // indirect
+	atomicgo.dev/keyboard v0.2.9 // indirect
+	atomicgo.dev/schedule v0.0.2 // indirect
+	github.com/Masterminds/goutils v1.1.1 // indirect
+	github.com/Masterminds/semver/v3 v3.2.1 // indirect
+	github.com/Masterminds/sprig/v3 v3.2.3 // indirect
+	github.com/Microsoft/go-winio v0.6.1 // indirect
+	github.com/Microsoft/hcsshim v0.10.0-rc.8 // indirect
+	github.com/ProtonMail/go-crypto v0.0.0-20230117203413-a47887b8f098 // indirect
+	github.com/StackExchange/wmi v1.2.1 // indirect
+	github.com/acomagu/bufpipe v1.0.3 // indirect
+	github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59 // indirect
+	github.com/cavaliergopher/grab v2.0.0+incompatible // indirect
+	github.com/cavaliergopher/grab/v3 v3.0.1 // indirect
+	github.com/cloudflare/circl v1.3.1 // indirect
+	github.com/containerd/cgroups v1.1.0 // indirect
+	github.com/containerd/console v1.0.3 // indirect
+	github.com/containerd/containerd v1.7.1 // indirect
+	github.com/containerd/continuity v0.3.0 // indirect
+	github.com/containerd/stargz-snapshotter/estargz v0.14.3 // indirect
+	github.com/denisbrodbeck/machineid v1.0.1 // indirect
+	github.com/diskfs/go-diskfs v1.3.0 // indirect
+	github.com/distribution/distribution v2.8.2+incompatible // indirect
+	github.com/docker/cli v23.0.5+incompatible // indirect
+	github.com/docker/distribution v2.8.2+incompatible // indirect
+	github.com/docker/docker v23.0.6+incompatible // indirect
+	github.com/docker/docker-credential-helpers v0.7.0 // indirect
+	github.com/docker/go-connections v0.4.0 // indirect
+	github.com/docker/go-units v0.5.0 // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/ghodss/yaml v1.0.0 // indirect
+	github.com/go-git/gcfg v1.5.0 // indirect
+	github.com/go-git/go-billy/v5 v5.3.1 // indirect
+	github.com/go-git/go-git/v5 v5.4.2 // indirect
+	github.com/go-logr/logr v1.2.4 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/google/go-cmp v0.5.9 // indirect
+	github.com/google/go-containerregistry v0.15.2 // indirect
+	github.com/google/pprof v0.0.0-20230228050547-1710fef4ab10 // indirect
+	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 // indirect
+	github.com/google/uuid v1.3.0 // indirect
+	github.com/gookit/color v1.5.3 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/huandu/xstrings v1.4.0 // indirect
+	github.com/imdario/mergo v0.3.15 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/itchyny/gojq v0.12.12 // indirect
+	github.com/itchyny/timefmt-go v0.1.5 // indirect
+	github.com/jaypipes/ghw v0.10.0 // indirect
+	github.com/jaypipes/pcidb v1.0.0 // indirect
+	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
+	github.com/kendru/darwin/go/depgraph v0.0.0-20221105232959-877d6a81060c // indirect
+	github.com/kevinburke/ssh_config v1.2.0 // indirect
+	github.com/klauspost/compress v1.16.5 // indirect
+	github.com/lithammer/fuzzysearch v1.1.8 // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/mattn/go-runewidth v0.0.14 // indirect
+	github.com/mitchellh/copystructure v1.2.0 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/mitchellh/reflectwalk v1.0.2 // indirect
+	github.com/moby/moby v23.0.4+incompatible // indirect
+	github.com/moby/sys/mountinfo v0.6.2 // indirect
+	github.com/moby/sys/sequential v0.5.0 // indirect
+	github.com/mudler/entities v0.0.0-20220905203055-68348bae0f49 // indirect
+	github.com/mudler/yip v1.3.1-0.20230704124832-e5812d0f5890 // indirect
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.1.0-rc3 // indirect
+	github.com/packethost/packngo v0.29.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/phayes/permbits v0.0.0-20190612203442-39d7c581d2ee // indirect
+	github.com/pierrec/lz4 v2.6.1+incompatible // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pkg/xattr v0.4.9 // indirect
+	github.com/pterm/pterm v0.12.63 // indirect
+	github.com/qeesung/image2ascii v1.0.1 // indirect
+	github.com/rancher-sandbox/linuxkit v1.0.1-0.20230517173613-432a87ba3e09 // indirect
+	github.com/rivo/uniseg v0.4.4 // indirect
+	github.com/samber/lo v1.37.0 // indirect
+	github.com/satori/go.uuid v1.2.1-0.20181028125025-b2ce2384e17b // indirect
+	github.com/sergi/go-diff v1.3.1 // indirect
+	github.com/shopspring/decimal v1.3.1 // indirect
+	github.com/spectrocloud-labs/herd v0.4.2 // indirect
+	github.com/spf13/afero v1.9.5 // indirect
+	github.com/spf13/cast v1.5.1 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/subosito/gotenv v1.4.2 // indirect
+	github.com/tredoe/osutil/v2 v2.0.0-rc.16 // indirect
+	github.com/ulikunitz/xz v0.5.11 // indirect
+	github.com/vbatts/tar-split v0.11.3 // indirect
+	github.com/vishvananda/netlink v1.2.1-beta.2 // indirect
+	github.com/vishvananda/netns v0.0.4 // indirect
+	github.com/vmware/vmw-guestinfo v0.0.0-20220317130741-510905f0efa3 // indirect
+	github.com/wayneashleyberry/terminal-dimensions v1.1.0 // indirect
+	github.com/willdonnelly/passwd v0.0.0-20141013001024-7935dab3074c // indirect
+	github.com/xanzy/ssh-agent v0.3.1 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	github.com/zcalusic/sysinfo v0.9.5 // indirect
+	go.opencensus.io v0.24.0 // indirect
+	golang.org/x/crypto v0.9.0 // indirect
+	golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 // indirect
+	golang.org/x/mod v0.10.0 // indirect
+	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/sync v0.2.0 // indirect
+	golang.org/x/sys v0.10.0 // indirect
+	golang.org/x/term v0.10.0 // indirect
+	golang.org/x/text v0.11.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
+	golang.org/x/tools v0.9.1 // indirect
+	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
+	google.golang.org/grpc v1.55.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
+	gopkg.in/djherbis/times.v1 v1.3.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/warnings.v0 v0.1.2 // indirect
+	gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	howett.net/plist v1.0.0 // indirect
+	k8s.io/klog/v2 v2.90.1 // indirect
+	k8s.io/utils v0.0.0-20230220204549-a5ecb0141aa5 // indirect
+	pault.ag/go/modprobe v0.1.2 // indirect
+	pault.ag/go/topsort v0.1.1 // indirect
+)

tools-image/enki/internal/version/version.go

@@ -0,0 +1,36 @@
+package version
+
+import (
+	"runtime"
+)
+
+var (
+	version = "v0.0.1"
+	// gitCommit is the git sha1
+	gitCommit = ""
+)
+
+// BuildInfo describes the compile time information.
+type BuildInfo struct {
+	// Version is the current semver.
+	Version string `json:"version,omitempty"`
+	// GitCommit is the git sha1.
+	GitCommit string `json:"git_commit,omitempty"`
+	// GoVersion is the version of the Go compiler used.
+	GoVersion string `json:"go_version,omitempty"`
+}
+
+func GetVersion() string {
+	return version
+}
+
+// Get returns build info
+func Get() BuildInfo {
+	v := BuildInfo{
+		Version:   GetVersion(),
+		GitCommit: gitCommit,
+		GoVersion: runtime.Version(),
+	}
+
+	return v
+}

tools-image/enki/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "github.com/kairos-io/enki/cmd"
+
+func main() {
+	cmd.Execute()
+}

tools-image/enki/pkg/action/action_suite_test.go

@@ -0,0 +1,28 @@
+/*
+Copyright © 2022 SUSE LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+package action_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestActionSuite(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Actions test suite")
+}

tools-image/enki/pkg/action/build-iso.go

@@ -0,0 +1,360 @@
+package action
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/kairos-io/enki/pkg/constants"
+	"github.com/kairos-io/enki/pkg/utils"
+	"github.com/kairos-io/kairos-agent/v2/pkg/elemental"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+	sdk "github.com/kairos-io/kairos-sdk/utils"
+)
+
+type BuildISOAction struct {
+	cfg  *v1.BuildConfig
+	spec *v1.LiveISO
+	e    *elemental.Elemental
+}
+
+type BuildISOActionOption func(a *BuildISOAction)
+
+func NewBuildISOAction(cfg *v1.BuildConfig, spec *v1.LiveISO, opts ...BuildISOActionOption) *BuildISOAction {
+	b := &BuildISOAction{
+		cfg:  cfg,
+		e:    elemental.NewElemental(&cfg.Config),
+		spec: spec,
+	}
+	for _, opt := range opts {
+		opt(b)
+	}
+	return b
+}
+
+// ISORun will install the system from a given configuration
+func (b *BuildISOAction) ISORun() (err error) {
+	cleanup := sdk.NewCleanStack()
+	defer func() { err = cleanup.Cleanup(err) }()
+
+	isoTmpDir, err := utils.TempDir(b.cfg.Fs, "", "enki-iso")
+	if err != nil {
+		return err
+	}
+	cleanup.Push(func() error { return b.cfg.Fs.RemoveAll(isoTmpDir) })
+
+	rootDir := filepath.Join(isoTmpDir, "rootfs")
+	err = utils.MkdirAll(b.cfg.Fs, rootDir, constants.DirPerm)
+	if err != nil {
+		return err
+	}
+
+	uefiDir := filepath.Join(isoTmpDir, "uefi")
+	err = utils.MkdirAll(b.cfg.Fs, uefiDir, constants.DirPerm)
+	if err != nil {
+		return err
+	}
+
+	isoDir := filepath.Join(isoTmpDir, "iso")
+	err = utils.MkdirAll(b.cfg.Fs, isoDir, constants.DirPerm)
+	if err != nil {
+		return err
+	}
+
+	if b.cfg.OutDir != "" {
+		err = utils.MkdirAll(b.cfg.Fs, b.cfg.OutDir, constants.DirPerm)
+		if err != nil {
+			b.cfg.Logger.Errorf("Failed creating output folder: %s", b.cfg.OutDir)
+			return err
+		}
+	}
+
+	b.cfg.Logger.Infof("Preparing squashfs root...")
+	err = b.applySources(rootDir, b.spec.RootFS...)
+	if err != nil {
+		b.cfg.Logger.Errorf("Failed installing OS packages: %v", err)
+		return err
+	}
+	err = utils.CreateDirStructure(b.cfg.Fs, rootDir)
+	if err != nil {
+		b.cfg.Logger.Errorf("Failed creating root directory structure: %v", err)
+		return err
+	}
+
+	b.cfg.Logger.Infof("Preparing EFI image...")
+	err = b.applySources(uefiDir, b.spec.UEFI...)
+	if err != nil {
+		b.cfg.Logger.Errorf("Failed installing EFI packages: %v", err)
+		return err
+	}
+
+	b.cfg.Logger.Infof("Preparing ISO image root tree...")
+	err = b.applySources(isoDir, b.spec.Image...)
+	if err != nil {
+		b.cfg.Logger.Errorf("Failed installing ISO image packages: %v", err)
+		return err
+	}
+
+	err = b.prepareISORoot(isoDir, rootDir, uefiDir)
+	if err != nil {
+		b.cfg.Logger.Errorf("Failed preparing ISO's root tree: %v", err)
+		return err
+	}
+
+	b.cfg.Logger.Infof("Creating ISO image...")
+	err = b.burnISO(isoDir)
+	if err != nil {
+		b.cfg.Logger.Errorf("Failed preparing ISO's root tree: %v", err)
+		return err
+	}
+
+	return err
+}
+
+func (b BuildISOAction) prepareISORoot(isoDir string, rootDir string, uefiDir string) error {
+	kernel, initrd, err := b.e.FindKernelInitrd(rootDir)
+	if err != nil {
+		b.cfg.Logger.Error("Could not find kernel and/or initrd")
+		return err
+	}
+	err = utils.MkdirAll(b.cfg.Fs, filepath.Join(isoDir, "boot"), constants.DirPerm)
+	if err != nil {
+		return err
+	}
+	//TODO document boot/kernel and boot/initrd expectation in bootloader config
+	b.cfg.Logger.Debugf("Copying Kernel file %s to iso root tree", kernel)
+	err = utils.CopyFile(b.cfg.Fs, kernel, filepath.Join(isoDir, constants.IsoKernelPath))
+	if err != nil {
+		return err
+	}
+
+	b.cfg.Logger.Debugf("Copying initrd file %s to iso root tree", initrd)
+	err = utils.CopyFile(b.cfg.Fs, initrd, filepath.Join(isoDir, constants.IsoInitrdPath))
+	if err != nil {
+		return err
+	}
+
+	b.cfg.Logger.Info("Creating squashfs...")
+	err = utils.CreateSquashFS(b.cfg.Runner, b.cfg.Logger, rootDir, filepath.Join(isoDir, constants.IsoRootFile), constants.GetDefaultSquashfsOptions())
+	if err != nil {
+		return err
+	}
+
+	b.cfg.Logger.Info("Creating EFI image...")
+	err = b.createEFI(uefiDir, filepath.Join(isoDir, constants.IsoEFIPath))
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (b BuildISOAction) createEFI(root string, img string) error {
+	efiSize, err := utils.DirSize(b.cfg.Fs, root)
+	if err != nil {
+		return err
+	}
+
+	// align efiSize to the next 4MB slot
+	align := int64(4 * 1024 * 1024)
+	efiSizeMB := (efiSize/align*align + align) / (1024 * 1024)
+
+	err = b.e.CreateFileSystemImage(&v1.Image{
+		File:  img,
+		Size:  uint(efiSizeMB),
+		FS:    constants.EfiFs,
+		Label: constants.EfiLabel,
+	})
+	if err != nil {
+		return err
+	}
+
+	files, err := b.cfg.Fs.ReadDir(root)
+	if err != nil {
+		return err
+	}
+
+	for _, f := range files {
+		_, err = b.cfg.Runner.Run("mcopy", "-s", "-i", img, filepath.Join(root, f.Name()), "::")
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (b BuildISOAction) burnISO(root string) error {
+	cmd := "xorriso"
+	var outputFile string
+	var isoFileName string
+
+	if b.cfg.Date {
+		currTime := time.Now()
+		isoFileName = fmt.Sprintf("%s.%s.iso", b.cfg.Name, currTime.Format("20060102"))
+	} else {
+		isoFileName = fmt.Sprintf("%s.iso", b.cfg.Name)
+	}
+
+	outputFile = isoFileName
+	if b.cfg.OutDir != "" {
+		outputFile = filepath.Join(b.cfg.OutDir, outputFile)
+	}
+
+	if exists, _ := utils.Exists(b.cfg.Fs, outputFile); exists {
+		b.cfg.Logger.Warnf("Overwriting already existing %s", outputFile)
+		err := b.cfg.Fs.Remove(outputFile)
+		if err != nil {
+			return err
+		}
+	}
+
+	args := []string{
+		"-volid", b.spec.Label, "-joliet", "on", "-padding", "0",
+		"-outdev", outputFile, "-map", root, "/", "-chmod", "0755", "--",
+	}
+	args = append(args, constants.GetXorrisoBooloaderArgs(root)...)
+
+	out, err := b.cfg.Runner.Run(cmd, args...)
+	b.cfg.Logger.Debugf("Xorriso: %s", string(out))
+	if err != nil {
+		return err
+	}
+
+	checksum, err := utils.CalcFileChecksum(b.cfg.Fs, outputFile)
+	if err != nil {
+		return fmt.Errorf("checksum computation failed: %w", err)
+	}
+	err = b.cfg.Fs.WriteFile(fmt.Sprintf("%s.sha256", outputFile), []byte(fmt.Sprintf("%s %s\n", checksum, isoFileName)), 0644)
+	if err != nil {
+		return fmt.Errorf("cannot write checksum file: %w", err)
+	}
+
+	return nil
+}
+
+func (b BuildISOAction) applySources(target string, sources ...*v1.ImageSource) error {
+	for _, src := range sources {
+		_, err := b.e.DumpSource(target, src)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (g *BuildISOAction) PrepareEFI(rootDir, uefiDir string) error {
+	err := utils.MkdirAll(g.cfg.Fs, filepath.Join(uefiDir, constants.EfiBootPath), constants.DirPerm)
+	if err != nil {
+		return err
+	}
+
+	switch g.cfg.Arch {
+	case constants.ArchAmd64, constants.Archx86:
+		err = utils.CopyFile(
+			g.cfg.Fs,
+			filepath.Join(rootDir, constants.GrubEfiImagex86),
+			filepath.Join(uefiDir, constants.GrubEfiImagex86Dest),
+		)
+	case constants.ArchArm64:
+		err = utils.CopyFile(
+			g.cfg.Fs,
+			filepath.Join(rootDir, constants.GrubEfiImageArm64),
+			filepath.Join(uefiDir, constants.GrubEfiImageArm64Dest),
+		)
+	default:
+		err = fmt.Errorf("Not supported architecture: %v", g.cfg.Arch)
+	}
+	if err != nil {
+		return err
+	}
+
+	return g.cfg.Fs.WriteFile(filepath.Join(uefiDir, constants.EfiBootPath, constants.GrubCfg), []byte(constants.GrubEfiCfg), constants.FilePerm)
+}
+
+func (g *BuildISOAction) PrepareISO(rootDir, imageDir string) error {
+
+	err := utils.MkdirAll(g.cfg.Fs, filepath.Join(imageDir, constants.GrubPrefixDir), constants.DirPerm)
+	if err != nil {
+		return err
+	}
+
+	switch g.cfg.Arch {
+	case constants.ArchAmd64, constants.Archx86:
+		// Create eltorito image
+		eltorito, err := g.BuildEltoritoImg(rootDir)
+		if err != nil {
+			return err
+		}
+
+		// Inlude loaders in expected paths
+		loaderDir := filepath.Join(imageDir, constants.IsoLoaderPath)
+		err = utils.MkdirAll(g.cfg.Fs, loaderDir, constants.DirPerm)
+		if err != nil {
+			return err
+		}
+		loaderFiles := []string{eltorito, constants.GrubBootHybridImg}
+		loaderFiles = append(loaderFiles, strings.Split(constants.SyslinuxFiles, " ")...)
+		for _, f := range loaderFiles {
+			err = utils.CopyFile(g.cfg.Fs, filepath.Join(rootDir, f), loaderDir)
+			if err != nil {
+				return err
+			}
+		}
+		fontsDir := filepath.Join(loaderDir, "/grub2/fonts")
+		err = utils.MkdirAll(g.cfg.Fs, fontsDir, constants.DirPerm)
+		if err != nil {
+			return err
+		}
+		err = utils.CopyFile(g.cfg.Fs, filepath.Join(rootDir, constants.GrubFont), fontsDir)
+		if err != nil {
+			return err
+		}
+	case constants.ArchArm64:
+		// TBC
+	default:
+		return fmt.Errorf("Not supported architecture: %v", g.cfg.Arch)
+	}
+
+	// Write grub.cfg file
+	err = g.cfg.Fs.WriteFile(
+		filepath.Join(imageDir, constants.GrubPrefixDir, constants.GrubCfg),
+		[]byte(fmt.Sprintf(constants.GrubCfgTemplate, g.spec.GrubEntry, g.spec.Label)),
+		constants.FilePerm,
+	)
+	if err != nil {
+		return err
+	}
+
+	// Include EFI contents in iso root too
+	return g.PrepareEFI(rootDir, imageDir)
+}
+
+func (g *BuildISOAction) BuildEltoritoImg(rootDir string) (string, error) {
+	var args []string
+	args = append(args, "-O", constants.GrubBiosTarget)
+	args = append(args, "-o", constants.GrubBiosImg)
+	args = append(args, "-p", constants.GrubPrefixDir)
+	args = append(args, "-d", constants.GrubI386BinDir)
+	args = append(args, strings.Split(constants.GrubModules, " ")...)
+
+	chRoot := utils.NewChroot(rootDir, &g.cfg.Config)
+	out, err := chRoot.Run("grub2-mkimage", args...)
+	if err != nil {
+		g.cfg.Logger.Errorf("grub2-mkimage failed: %s", string(out))
+		g.cfg.Logger.Errorf("Error: %v", err)
+		return "", err
+	}
+
+	concatFiles := func() error {
+		return utils.ConcatFiles(
+			g.cfg.Fs, []string{constants.GrubBiosCDBoot, constants.GrubBiosImg},
+			constants.GrubEltoritoImg,
+		)
+	}
+	err = chRoot.RunCallback(concatFiles)
+	if err != nil {
+		return "", err
+	}
+	return constants.GrubEltoritoImg, nil
+}

tools-image/enki/pkg/action/build_test.go

@@ -0,0 +1,195 @@
+/*
+   Copyright © 2022 SUSE LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+package action_test
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"github.com/kairos-io/enki/pkg/action"
+	"github.com/kairos-io/enki/pkg/config"
+	"github.com/kairos-io/enki/pkg/constants"
+	"github.com/kairos-io/enki/pkg/utils"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+	v1mock "github.com/kairos-io/kairos-agent/v2/tests/mocks"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/sirupsen/logrus"
+	"github.com/twpayne/go-vfs"
+	"github.com/twpayne/go-vfs/vfst"
+	"path/filepath"
+)
+
+var _ = Describe("Runtime Actions", func() {
+	var cfg *v1.BuildConfig
+	var runner *v1mock.FakeRunner
+	var fs vfs.FS
+	var logger v1.Logger
+	var mounter *v1mock.ErrorMounter
+	var syscall *v1mock.FakeSyscall
+	var client *v1mock.FakeHTTPClient
+	var cloudInit *v1mock.FakeCloudInitRunner
+	var cleanup func()
+	var memLog *bytes.Buffer
+	var imageExtractor *v1mock.FakeImageExtractor
+	BeforeEach(func() {
+		runner = v1mock.NewFakeRunner()
+		syscall = &v1mock.FakeSyscall{}
+		mounter = v1mock.NewErrorMounter()
+		client = &v1mock.FakeHTTPClient{}
+		memLog = &bytes.Buffer{}
+		logger = v1.NewBufferLogger(memLog)
+		logger.SetLevel(logrus.DebugLevel)
+		cloudInit = &v1mock.FakeCloudInitRunner{}
+		fs, cleanup, _ = vfst.NewTestFS(map[string]interface{}{})
+		imageExtractor = v1mock.NewFakeImageExtractor(logger)
+
+		cfg = config.NewBuildConfig(
+			config.WithFs(fs),
+			config.WithRunner(runner),
+			config.WithLogger(logger),
+			config.WithMounter(mounter),
+			config.WithSyscall(syscall),
+			config.WithClient(client),
+			config.WithCloudInitRunner(cloudInit),
+			config.WithImageExtractor(imageExtractor),
+		)
+	})
+	AfterEach(func() {
+		cleanup()
+	})
+	Describe("Build ISO", Label("iso"), func() {
+		var iso *v1.LiveISO
+		BeforeEach(func() {
+			iso = config.NewISO()
+
+			tmpDir, err := utils.TempDir(fs, "", "test")
+			Expect(err).ShouldNot(HaveOccurred())
+
+			cfg.Date = false
+			cfg.OutDir = tmpDir
+
+			runner.SideEffect = func(cmd string, args ...string) ([]byte, error) {
+				switch cmd {
+				case "xorriso":
+					err := fs.WriteFile(filepath.Join(tmpDir, "elemental.iso"), []byte("profound thoughts"), constants.FilePerm)
+					return []byte{}, err
+				default:
+					return []byte{}, nil
+				}
+			}
+		})
+		It("Successfully builds an ISO from a Docker image", func() {
+			rootSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.RootFS = []*v1.ImageSource{rootSrc}
+			uefiSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.UEFI = []*v1.ImageSource{uefiSrc}
+			imageSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.Image = []*v1.ImageSource{imageSrc}
+
+			// Create kernel and vmlinuz
+			// Thanks to the testfs stuff in utils.TempDir we know what the temp fs is gonna be as
+			// its predictable
+			bootDir := filepath.Join("/tmp/enki-iso/rootfs", "boot")
+			err := utils.MkdirAll(fs, bootDir, constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Create(filepath.Join(bootDir, "vmlinuz"))
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Create(filepath.Join(bootDir, "initrd"))
+			Expect(err).ShouldNot(HaveOccurred())
+
+			buildISO := action.NewBuildISOAction(cfg, iso)
+			err = buildISO.ISORun()
+
+			Expect(err).ShouldNot(HaveOccurred())
+		})
+		It("Fails if kernel or initrd is not found in rootfs", func() {
+			rootSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.RootFS = []*v1.ImageSource{rootSrc}
+			uefiSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.UEFI = []*v1.ImageSource{uefiSrc}
+			imageSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.Image = []*v1.ImageSource{imageSrc}
+
+			By("fails without kernel")
+			buildISO := action.NewBuildISOAction(cfg, iso)
+			err := buildISO.ISORun()
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("No file found with prefixes"))
+			Expect(err.Error()).To(ContainSubstring("uImage Image zImage vmlinuz image"))
+
+			bootDir := filepath.Join("/tmp/enki-iso/rootfs", "boot")
+			err = utils.MkdirAll(fs, bootDir, constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Create(filepath.Join(bootDir, "vmlinuz"))
+			Expect(err).ShouldNot(HaveOccurred())
+
+			By("fails without initrd")
+			buildISO = action.NewBuildISOAction(cfg, iso)
+			err = buildISO.ISORun()
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("No file found with prefixes"))
+			Expect(err.Error()).To(ContainSubstring("initrd initramfs"))
+		})
+		It("Fails installing image sources", func() {
+			rootSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.RootFS = []*v1.ImageSource{rootSrc}
+			uefiSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.UEFI = []*v1.ImageSource{uefiSrc}
+			imageSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.Image = []*v1.ImageSource{imageSrc}
+
+			imageExtractor.SideEffect = func(imageRef, destination, platformRef string) error {
+				return fmt.Errorf("uh oh")
+			}
+
+			buildISO := action.NewBuildISOAction(cfg, iso)
+			err := buildISO.ISORun()
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("uh oh"))
+		})
+		It("Fails on ISO filesystem creation", func() {
+			rootSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.RootFS = []*v1.ImageSource{rootSrc}
+			uefiSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.UEFI = []*v1.ImageSource{uefiSrc}
+			imageSrc, _ := v1.NewSrcFromURI("oci:image:version")
+			iso.Image = []*v1.ImageSource{imageSrc}
+
+			bootDir := filepath.Join("/tmp/enki-iso/rootfs", "boot")
+			err := utils.MkdirAll(fs, bootDir, constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Create(filepath.Join(bootDir, "vmlinuz"))
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Create(filepath.Join(bootDir, "initrd"))
+			Expect(err).ShouldNot(HaveOccurred())
+
+			runner.SideEffect = func(command string, args ...string) ([]byte, error) {
+				if command == "xorriso" {
+					return []byte{}, errors.New("Burn ISO error")
+				}
+				return []byte{}, nil
+			}
+
+			buildISO := action.NewBuildISOAction(cfg, iso)
+			err = buildISO.ISORun()
+
+			Expect(err).Should(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("Burn ISO error"))
+		})
+	})
+})

tools-image/enki/pkg/config/config.go

@@ -0,0 +1,303 @@
+package config
+
+import (
+	"github.com/kairos-io/enki/internal/version"
+	"github.com/kairos-io/enki/pkg/constants"
+	"github.com/kairos-io/enki/pkg/utils"
+	"github.com/kairos-io/kairos-agent/v2/pkg/cloudinit"
+	"github.com/kairos-io/kairos-agent/v2/pkg/http"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+	"github.com/mitchellh/mapstructure"
+	"github.com/sanity-io/litter"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
+	"github.com/twpayne/go-vfs"
+	"io"
+	"io/fs"
+	"k8s.io/mount-utils"
+	"os"
+	"reflect"
+	"runtime"
+)
+
+var decodeHook = viper.DecodeHook(
+	mapstructure.ComposeDecodeHookFunc(
+		UnmarshalerHook(),
+		mapstructure.StringToTimeDurationHookFunc(),
+		mapstructure.StringToSliceHookFunc(","),
+	),
+)
+
+func WithFs(fs v1.FS) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.Fs = fs
+		return nil
+	}
+}
+
+func WithLogger(logger v1.Logger) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.Logger = logger
+		return nil
+	}
+}
+
+func WithSyscall(syscall v1.SyscallInterface) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.Syscall = syscall
+		return nil
+	}
+}
+
+func WithMounter(mounter mount.Interface) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.Mounter = mounter
+		return nil
+	}
+}
+
+func WithRunner(runner v1.Runner) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.Runner = runner
+		return nil
+	}
+}
+
+func WithClient(client v1.HTTPClient) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.Client = client
+		return nil
+	}
+}
+
+func WithCloudInitRunner(ci v1.CloudInitRunner) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.CloudInitRunner = ci
+		return nil
+	}
+}
+
+func WithArch(arch string) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.Arch = arch
+		return nil
+	}
+}
+
+func WithImageExtractor(extractor v1.ImageExtractor) func(r *v1.Config) error {
+	return func(r *v1.Config) error {
+		r.ImageExtractor = extractor
+		return nil
+	}
+}
+
+type GenericOptions func(a *v1.Config) error
+
+func ReadConfigBuild(configDir string, flags *pflag.FlagSet, mounter mount.Interface) (*v1.BuildConfig, error) {
+	logger := v1.NewLogger()
+	if configDir == "" {
+		configDir = "."
+	}
+
+	cfg := NewBuildConfig(
+		WithLogger(logger),
+		WithMounter(mounter),
+	)
+
+	configLogger(cfg.Logger, cfg.Fs)
+
+	viper.AddConfigPath(configDir)
+	viper.SetConfigType("yaml")
+	viper.SetConfigName("manifest.yaml")
+	// If a config file is found, read it in.
+	_ = viper.MergeInConfig()
+
+	// Bind buildconfig flags
+	bindGivenFlags(viper.GetViper(), flags)
+
+	// unmarshal all the vars into the config object
+	err := viper.Unmarshal(cfg, setDecoder, decodeHook)
+	if err != nil {
+		cfg.Logger.Warnf("error unmarshalling config: %s", err)
+	}
+
+	err = cfg.Sanitize()
+	cfg.Logger.Debugf("Full config loaded: %s", litter.Sdump(cfg))
+	return cfg, err
+}
+
+func ReadBuildISO(b *v1.BuildConfig, flags *pflag.FlagSet) (*v1.LiveISO, error) {
+	iso := NewISO()
+	vp := viper.Sub("iso")
+	if vp == nil {
+		vp = viper.New()
+	}
+	// Bind build-iso cmd flags
+	bindGivenFlags(vp, flags)
+
+	err := vp.Unmarshal(iso, setDecoder, decodeHook)
+	if err != nil {
+		b.Logger.Warnf("error unmarshalling LiveISO: %s", err)
+	}
+	err = iso.Sanitize()
+	b.Logger.Debugf("Loaded LiveISO: %s", litter.Sdump(iso))
+	return iso, err
+}
+
+func NewISO() *v1.LiveISO {
+	return &v1.LiveISO{
+		Label:     constants.ISOLabel,
+		GrubEntry: constants.GrubDefEntry,
+		UEFI:      []*v1.ImageSource{},
+		Image:     []*v1.ImageSource{},
+	}
+}
+
+func NewBuildConfig(opts ...GenericOptions) *v1.BuildConfig {
+	b := &v1.BuildConfig{
+		Config: *NewConfig(opts...),
+		Name:   constants.BuildImgName,
+	}
+	return b
+}
+
+func NewConfig(opts ...GenericOptions) *v1.Config {
+	log := v1.NewLogger()
+	arch, err := utils.GolangArchToArch(runtime.GOARCH)
+	if err != nil {
+		log.Errorf("invalid arch: %s", err.Error())
+		return nil
+	}
+
+	c := &v1.Config{
+		Fs:                    vfs.OSFS,
+		Logger:                log,
+		Syscall:               &v1.RealSyscall{},
+		Client:                http.NewClient(),
+		Repos:                 []v1.Repository{},
+		Arch:                  arch,
+		SquashFsNoCompression: true,
+	}
+	for _, o := range opts {
+		err := o(c)
+		if err != nil {
+			log.Errorf("error applying config option: %s", err.Error())
+			return nil
+		}
+	}
+
+	// delay runner creation after we have run over the options in case we use WithRunner
+	if c.Runner == nil {
+		c.Runner = &v1.RealRunner{Logger: c.Logger}
+	}
+
+	// Now check if the runner has a logger inside, otherwise point our logger into it
+	// This can happen if we set the WithRunner option as that doesn't set a logger
+	if c.Runner.GetLogger() == nil {
+		c.Runner.SetLogger(c.Logger)
+	}
+
+	// Delay the yip runner creation, so we set the proper logger instead of blindly setting it to the logger we create
+	// at the start of NewRunConfig, as WithLogger can be passed on init, and that would result in 2 different logger
+	// instances, on the config.Logger and the other on config.CloudInitRunner
+	if c.CloudInitRunner == nil {
+		c.CloudInitRunner = cloudinit.NewYipCloudInitRunner(c.Logger, c.Runner, vfs.OSFS)
+	}
+
+	if c.Mounter == nil {
+		c.Mounter = mount.New(constants.MountBinary)
+	}
+
+	return c
+}
+
+func configLogger(log v1.Logger, vfs v1.FS) {
+	// Set debug level
+	if viper.GetBool("debug") {
+		log.SetLevel(v1.DebugLevel())
+	}
+
+	// Set formatter so both file and stdout format are equal
+	log.SetFormatter(&logrus.TextFormatter{
+		ForceColors:      true,
+		DisableColors:    false,
+		DisableTimestamp: false,
+		FullTimestamp:    true,
+	})
+
+	// Logfile
+	logfile := viper.GetString("logfile")
+	if logfile != "" {
+		o, err := vfs.OpenFile(logfile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, fs.ModePerm)
+
+		if err != nil {
+			log.Errorf("Could not open %s for logging to file: %s", logfile, err.Error())
+		}
+
+		// else set it to both stdout and the file
+		mw := io.MultiWriter(os.Stdout, o)
+		log.SetOutput(mw)
+	} else { // no logfile
+		if viper.GetBool("quiet") { // quiet is enabled so discard all logging
+			log.SetOutput(io.Discard)
+		} else { // default to stdout
+			log.SetOutput(os.Stdout)
+		}
+	}
+
+	log.Infof("Starting enki version %s", version.GetVersion())
+	if log.GetLevel() == logrus.DebugLevel {
+		log.Debugf("%+v\n", version.Get())
+	}
+}
+
+// BindGivenFlags binds to viper only passed flags, ignoring any non provided flag
+func bindGivenFlags(vp *viper.Viper, flagSet *pflag.FlagSet) {
+	if flagSet != nil {
+		flagSet.VisitAll(func(f *pflag.Flag) {
+			if f.Changed {
+				_ = vp.BindPFlag(f.Name, f)
+			}
+		})
+	}
+}
+
+// setDecoder sets ZeroFields mastructure attribute to true
+func setDecoder(config *mapstructure.DecoderConfig) {
+	// Make sure we zero fields before applying them, this is relevant for slices
+	// so we do not merge with any already present value and directly apply whatever
+	// we got form configs.
+	config.ZeroFields = true
+}
+
+type Unmarshaler interface {
+	CustomUnmarshal(interface{}) (bool, error)
+}
+
+func UnmarshalerHook() mapstructure.DecodeHookFunc {
+	return func(from reflect.Value, to reflect.Value) (interface{}, error) {
+		// get the destination object address if it is not passed by reference
+		if to.CanAddr() {
+			to = to.Addr()
+		}
+		// If the destination implements the unmarshaling interface
+		u, ok := to.Interface().(Unmarshaler)
+		if !ok {
+			return from.Interface(), nil
+		}
+		// If it is nil and a pointer, create and assign the target value first
+		if to.IsNil() && to.Type().Kind() == reflect.Ptr {
+			to.Set(reflect.New(to.Type().Elem()))
+			u = to.Interface().(Unmarshaler)
+		}
+		// Call the custom unmarshaling method
+		cont, err := u.CustomUnmarshal(from.Interface())
+		if cont {
+			// Continue with the decoding stack
+			return from.Interface(), err
+		}
+		// Decoding finalized
+		return to.Interface(), err
+	}
+}

tools-image/enki/pkg/constants/constants.go

@@ -0,0 +1,124 @@
+package constants
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+const (
+	GrubDefEntry          = "Kairos"
+	EfiLabel              = "COS_GRUB"
+	ISOLabel              = "COS_LIVE"
+	MountBinary           = "/usr/bin/mount"
+	EfiFs                 = "vfat"
+	IsoRootFile           = "rootfs.squashfs"
+	IsoEFIPath            = "/boot/uefi.img"
+	BuildImgName          = "elemental"
+	EfiBootPath           = "/EFI/BOOT"
+	GrubEfiImagex86       = "/usr/share/grub2/x86_64-efi/grub.efi"
+	GrubEfiImageArm64     = "/usr/share/grub2/arm64-efi/grub.efi"
+	GrubEfiImagex86Dest   = EfiBootPath + "/bootx64.efi"
+	GrubEfiImageArm64Dest = EfiBootPath + "/bootaa64.efi"
+	GrubCfg               = "grub.cfg"
+	GrubPrefixDir         = "/boot/grub2"
+	GrubEfiCfg            = "search --no-floppy --file --set=root " + IsoKernelPath +
+		"\nset prefix=($root)" + GrubPrefixDir +
+		"\nconfigfile $prefix/" + GrubCfg
+
+	GrubFont          = "/usr/share/grub2/unicode.pf2"
+	GrubBootHybridImg = "/usr/share/grub2/i386-pc/boot_hybrid.img"
+	SyslinuxFiles     = "/usr/share/syslinux/isolinux.bin " +
+		"/usr/share/syslinux/menu.c32 " +
+		"/usr/share/syslinux/chain.c32 " +
+		"/usr/share/syslinux/mboot.c32"
+	IsoLoaderPath   = "/boot/x86_64/loader"
+	GrubCfgTemplate = `search --no-floppy --file --set=root /boot/kernel                               
+	set default=0                                                                   
+	set timeout=10                                                                  
+	set timeout_style=menu                                                          
+	set linux=linux                                                                 
+	set initrd=initrd                                                               
+	if [ "${grub_cpu}" = "x86_64" -o "${grub_cpu}" = "i386" -o "${grub_cpu}" = "arm64" ];then
+		if [ "${grub_platform}" = "efi" ]; then                                     
+			if [ "${grub_cpu}" != "arm64" ]; then                                   
+				set linux=linuxefi                                                  
+				set initrd=initrdefi                                                
+			fi                                                                      
+		fi                                                                          
+	fi                                                                              
+	if [ "${grub_platform}" = "efi" ]; then                                         
+		echo "Please press 't' to show the boot menu on this console"               
+	fi                                                                              
+	set font=($root)/boot/${grub_cpu}/loader/grub2/fonts/unicode.pf2                
+	if [ -f ${font} ];then                                                          
+		loadfont ${font}                                                            
+	fi                                                                              
+	menuentry "%s" --class os --unrestricted {                                     
+		echo Loading kernel...                                                      
+		$linux ($root)/boot/kernel cdroot root=live:CDLABEL=%s rd.live.dir=/ rd.live.squashimg=rootfs.squashfs rd.live.overlay.overlayfs console=tty1 console=ttyS0 rd.cos.disable
+		echo Loading initrd...                                                      
+		$initrd ($root)/boot/initrd                                                 
+	}                                                                               
+																					
+	if [ "${grub_platform}" = "efi" ]; then                                         
+		hiddenentry "Text mode" --hotkey "t" {                                      
+			set textmode=true                                                       
+			terminal_output console                                                 
+		}                                                                           
+	fi`
+	GrubBiosTarget  = "i386-pc"
+	GrubI386BinDir  = "/usr/share/grub2/i386-pc"
+	GrubBiosImg     = GrubI386BinDir + "/core.img"
+	GrubBiosCDBoot  = GrubI386BinDir + "/cdboot.img"
+	GrubEltoritoImg = GrubI386BinDir + "/eltorito.img"
+	//TODO this list could be optimized
+	GrubModules = "ext2 iso9660 linux echo configfile search_label search_fs_file search search_fs_uuid " +
+		"ls normal gzio png fat gettext font minicmd gfxterm gfxmenu all_video xfs btrfs lvm luks " +
+		"gcry_rijndael gcry_sha256 gcry_sha512 crypto cryptodisk test true loadenv part_gpt " +
+		"part_msdos biosdisk vga vbe chain boot"
+
+	IsoHybridMBR   = "/boot/x86_64/loader/boot_hybrid.img"
+	IsoBootCatalog = "/boot/x86_64/boot.catalog"
+	IsoBootFile    = "/boot/x86_64/loader/eltorito.img"
+
+	// These paths are arbitrary but coupled to grub.cfg
+	IsoKernelPath = "/boot/kernel"
+	IsoInitrdPath = "/boot/initrd"
+
+	// Default directory and file fileModes
+	DirPerm        = os.ModeDir | os.ModePerm
+	FilePerm       = 0666
+	NoWriteDirPerm = 0555 | os.ModeDir
+	TempDirPerm    = os.ModePerm | os.ModeSticky | os.ModeDir
+
+	ArchAmd64 = "amd64"
+	Archx86   = "x86_64"
+	ArchArm64 = "arm64"
+)
+
+// GetDefaultSquashfsOptions returns the default options to use when creating a squashfs
+func GetDefaultSquashfsOptions() []string {
+	return []string{"-b", "1024k"}
+}
+
+func GetXorrisoBooloaderArgs(root string) []string {
+	args := []string{
+		"-boot_image", "grub", fmt.Sprintf("bin_path=%s", IsoBootFile),
+		"-boot_image", "grub", fmt.Sprintf("grub2_mbr=%s/%s", root, IsoHybridMBR),
+		"-boot_image", "grub", "grub2_boot_info=on",
+		"-boot_image", "any", "partition_offset=16",
+		"-boot_image", "any", fmt.Sprintf("cat_path=%s", IsoBootCatalog),
+		"-boot_image", "any", "cat_hidden=on",
+		"-boot_image", "any", "boot_info_table=on",
+		"-boot_image", "any", "platform_id=0x00",
+		"-boot_image", "any", "emul_type=no_emulation",
+		"-boot_image", "any", "load_size=2048",
+		"-append_partition", "2", "0xef", filepath.Join(root, IsoEFIPath),
+		"-boot_image", "any", "next",
+		"-boot_image", "any", "efi_path=--interval:appended_partition_2:all::",
+		"-boot_image", "any", "platform_id=0xef",
+		"-boot_image", "any", "emul_type=no_emulation",
+	}
+	return args
+}

tools-image/enki/pkg/utils/chroot.go

@@ -0,0 +1,218 @@
+/*
+Copyright © 2022 SUSE LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/kairos-io/enki/pkg/constants"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+)
+
+// Chroot represents the struct that will allow us to run commands inside a given chroot
+type Chroot struct {
+	path          string
+	defaultMounts []string
+	extraMounts   map[string]string
+	activeMounts  []string
+	config        *v1.Config
+}
+
+func NewChroot(path string, config *v1.Config) *Chroot {
+	return &Chroot{
+		path:          path,
+		defaultMounts: []string{"/dev", "/dev/pts", "/proc", "/sys"},
+		extraMounts:   map[string]string{},
+		activeMounts:  []string{},
+		config:        config,
+	}
+}
+
+// ChrootedCallback runs the given callback in a chroot environment
+func ChrootedCallback(cfg *v1.Config, path string, bindMounts map[string]string, callback func() error) error {
+	chroot := NewChroot(path, cfg)
+	chroot.SetExtraMounts(bindMounts)
+	return chroot.RunCallback(callback)
+}
+
+// Sets additional bind mounts for the chroot enviornment. They are represented
+// in a map where the key is the path outside the chroot and the value is the
+// path inside the chroot.
+func (c *Chroot) SetExtraMounts(extraMounts map[string]string) {
+	c.extraMounts = extraMounts
+}
+
+// Prepare will mount the defaultMounts as bind mounts, to be ready when we run chroot
+func (c *Chroot) Prepare() error {
+	var err error
+	keys := []string{}
+	mountOptions := []string{"bind"}
+
+	if len(c.activeMounts) > 0 {
+		return errors.New("There are already active mountpoints for this instance")
+	}
+
+	defer func() {
+		if err != nil {
+			c.Close()
+		}
+	}()
+
+	for _, mnt := range c.defaultMounts {
+		mountPoint := fmt.Sprintf("%s%s", strings.TrimSuffix(c.path, "/"), mnt)
+		err = MkdirAll(c.config.Fs, mountPoint, constants.DirPerm)
+		if err != nil {
+			return err
+		}
+		err = c.config.Mounter.Mount(mnt, mountPoint, "bind", mountOptions)
+		if err != nil {
+			return err
+		}
+		c.activeMounts = append(c.activeMounts, mountPoint)
+	}
+
+	for k := range c.extraMounts {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	for _, k := range keys {
+		mountPoint := fmt.Sprintf("%s%s", strings.TrimSuffix(c.path, "/"), c.extraMounts[k])
+		err = MkdirAll(c.config.Fs, mountPoint, constants.DirPerm)
+		if err != nil {
+			return err
+		}
+		err = c.config.Mounter.Mount(k, mountPoint, "bind", mountOptions)
+		if err != nil {
+			return err
+		}
+		c.activeMounts = append(c.activeMounts, mountPoint)
+	}
+
+	return nil
+}
+
+// Close will unmount all active mounts created in Prepare on reverse order
+func (c *Chroot) Close() error {
+	failures := []string{}
+	for len(c.activeMounts) > 0 {
+		curr := c.activeMounts[len(c.activeMounts)-1]
+		c.config.Logger.Debugf("Unmounting %s from chroot", curr)
+		c.activeMounts = c.activeMounts[:len(c.activeMounts)-1]
+		err := c.config.Mounter.Unmount(curr)
+		if err != nil {
+			c.config.Logger.Errorf("Error unmounting %s: %s", curr, err)
+			failures = append(failures, curr)
+		}
+	}
+	if len(failures) > 0 {
+		c.activeMounts = failures
+		return fmt.Errorf("failed closing chroot environment. Unmount failures: %v", failures)
+	}
+	return nil
+}
+
+// RunCallback runs the given callback in a chroot environment
+func (c *Chroot) RunCallback(callback func() error) (err error) {
+	var currentPath string
+	var oldRootF *os.File
+
+	// Store current path
+	currentPath, err = os.Getwd()
+	if err != nil {
+		c.config.Logger.Error("Failed to get current path")
+		return err
+	}
+	defer func() {
+		tmpErr := os.Chdir(currentPath)
+		if err == nil && tmpErr != nil {
+			err = tmpErr
+		}
+	}()
+
+	// Store current root
+	oldRootF, err = c.config.Fs.Open("/")
+	if err != nil {
+		c.config.Logger.Errorf("Can't open current root")
+		return err
+	}
+	defer oldRootF.Close()
+
+	if len(c.activeMounts) == 0 {
+		err = c.Prepare()
+		if err != nil {
+			c.config.Logger.Errorf("Can't mount default mounts")
+			return err
+		}
+		defer func() {
+			tmpErr := c.Close()
+			if err == nil {
+				err = tmpErr
+			}
+		}()
+	}
+	// Change to new dir before running chroot!
+	err = c.config.Syscall.Chdir(c.path)
+	if err != nil {
+		c.config.Logger.Errorf("Can't chdir %s: %s", c.path, err)
+		return err
+	}
+
+	err = c.config.Syscall.Chroot(c.path)
+	if err != nil {
+		c.config.Logger.Errorf("Can't chroot %s: %s", c.path, err)
+		return err
+	}
+
+	// Restore to old root
+	defer func() {
+		tmpErr := oldRootF.Chdir()
+		if tmpErr != nil {
+			c.config.Logger.Errorf("Can't change to old root dir")
+			if err == nil {
+				err = tmpErr
+			}
+		} else {
+			tmpErr = c.config.Syscall.Chroot(".")
+			if tmpErr != nil {
+				c.config.Logger.Errorf("Can't chroot back to old root")
+				if err == nil {
+					err = tmpErr
+				}
+			}
+		}
+	}()
+
+	return callback()
+}
+
+// Run executes a command inside a chroot
+func (c *Chroot) Run(command string, args ...string) (out []byte, err error) {
+	callback := func() error {
+		out, err = c.config.Runner.Run(command, args...)
+		return err
+	}
+	err = c.RunCallback(callback)
+	if err != nil {
+		c.config.Logger.Errorf("Cant run command %s with args %v on chroot: %s", command, args, err)
+		c.config.Logger.Debugf("Output from command: %s", out)
+	}
+	return out, err
+}

tools-image/enki/pkg/utils/common.go

@@ -0,0 +1,40 @@
+package utils
+
+import (
+	"fmt"
+	"github.com/kairos-io/enki/pkg/constants"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+	"strings"
+)
+
+// CreateSquashFS creates a squash file at destination from a source, with options
+// TODO: Check validity of source maybe?
+func CreateSquashFS(runner v1.Runner, logger v1.Logger, source string, destination string, options []string) error {
+	// create args
+	args := []string{source, destination}
+	// append options passed to args in order to have the correct order
+	// protect against options passed together in the same string , i.e. "-x add" instead of "-x", "add"
+	var optionsExpanded []string
+	for _, op := range options {
+		optionsExpanded = append(optionsExpanded, strings.Split(op, " ")...)
+	}
+	args = append(args, optionsExpanded...)
+	out, err := runner.Run("mksquashfs", args...)
+	if err != nil {
+		logger.Debugf("Error running squashfs creation, stdout: %s", out)
+		logger.Errorf("Error while creating squashfs from %s to %s: %s", source, destination, err)
+		return err
+	}
+	return nil
+}
+
+func GolangArchToArch(arch string) (string, error) {
+	switch strings.ToLower(arch) {
+	case constants.ArchAmd64:
+		return constants.Archx86, nil
+	case constants.ArchArm64:
+		return constants.ArchArm64, nil
+	default:
+		return "", fmt.Errorf("invalid arch")
+	}
+}

tools-image/enki/pkg/utils/fs.go

@@ -0,0 +1,223 @@
+package utils
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strconv"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/kairos-io/enki/pkg/constants"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+	"github.com/twpayne/go-vfs"
+	"github.com/twpayne/go-vfs/vfst"
+)
+
+// MkdirAll directory and all parents if not existing
+func MkdirAll(fs v1.FS, name string, mode os.FileMode) (err error) {
+	if _, isReadOnly := fs.(*vfs.ReadOnlyFS); isReadOnly {
+		return permError("mkdir", name)
+	}
+	if name, err = fs.RawPath(name); err != nil {
+		return &os.PathError{Op: "mkdir", Path: name, Err: err}
+	}
+	return os.MkdirAll(name, mode)
+}
+
+// permError returns an *os.PathError with Err syscall.EPERM.
+func permError(op, path string) error {
+	return &os.PathError{
+		Op:   op,
+		Path: path,
+		Err:  syscall.EPERM,
+	}
+}
+
+// Copies source file to target file using Fs interface
+func CreateDirStructure(fs v1.FS, target string) error {
+	for _, dir := range []string{"/run", "/dev", "/boot", "/usr/local", "/oem"} {
+		err := MkdirAll(fs, filepath.Join(target, dir), constants.DirPerm)
+		if err != nil {
+			return err
+		}
+	}
+	for _, dir := range []string{"/proc", "/sys"} {
+		err := MkdirAll(fs, filepath.Join(target, dir), constants.NoWriteDirPerm)
+		if err != nil {
+			return err
+		}
+	}
+	err := MkdirAll(fs, filepath.Join(target, "/tmp"), constants.DirPerm)
+	if err != nil {
+		return err
+	}
+	// Set /tmp permissions regardless the umask setup
+	err = fs.Chmod(filepath.Join(target, "/tmp"), constants.TempDirPerm)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// TempDir creates a temp file in the virtual fs
+// Took from afero.FS code and adapted
+func TempDir(fs v1.FS, dir, prefix string) (name string, err error) {
+	if dir == "" {
+		dir = os.TempDir()
+	}
+	// This skips adding random stuff to the created temp dir so the temp dir created is predictable for testing
+	if _, isTestFs := fs.(*vfst.TestFS); isTestFs {
+		err = MkdirAll(fs, filepath.Join(dir, prefix), 0700)
+		if err != nil {
+			return "", err
+		}
+		name = filepath.Join(dir, prefix)
+		return
+	}
+	nconflict := 0
+	for i := 0; i < 10000; i++ {
+		try := filepath.Join(dir, prefix+nextRandom())
+		err = MkdirAll(fs, try, 0700)
+		if os.IsExist(err) {
+			if nconflict++; nconflict > 10 {
+				randmu.Lock()
+				rand = reseed()
+				randmu.Unlock()
+			}
+			continue
+		}
+		if err == nil {
+			name = try
+		}
+		break
+	}
+	return
+}
+
+// Random number state.
+// We generate random temporary file names so that there's a good
+// chance the file doesn't exist yet - keeps the number of tries in
+// TempFile to a minimum.
+var rand uint32
+var randmu sync.Mutex
+
+func reseed() uint32 {
+	return uint32(time.Now().UnixNano() + int64(os.Getpid()))
+}
+
+func nextRandom() string {
+	randmu.Lock()
+	r := rand
+	if r == 0 {
+		r = reseed()
+	}
+	r = r*1664525 + 1013904223 // constants from Numerical Recipes
+	rand = r
+	randmu.Unlock()
+	return strconv.Itoa(int(1e9 + r%1e9))[1:]
+}
+
+// CopyFile Copies source file to target file using Fs interface. If target
+// is  directory source is copied into that directory using source name file.
+func CopyFile(fs v1.FS, source string, target string) (err error) {
+	return ConcatFiles(fs, []string{source}, target)
+}
+
+// IsDir check if the path is a dir
+func IsDir(fs v1.FS, path string) (bool, error) {
+	fi, err := fs.Stat(path)
+	if err != nil {
+		return false, err
+	}
+	return fi.IsDir(), nil
+}
+
+// ConcatFiles Copies source files to target file using Fs interface.
+// Source files are concatenated into target file in the given order.
+// If target is a directory source is copied into that directory using
+// 1st source name file.
+func ConcatFiles(fs v1.FS, sources []string, target string) (err error) {
+	if len(sources) == 0 {
+		return fmt.Errorf("Empty sources list")
+	}
+	if dir, _ := IsDir(fs, target); dir {
+		target = filepath.Join(target, filepath.Base(sources[0]))
+	}
+
+	targetFile, err := fs.Create(target)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == nil {
+			err = targetFile.Close()
+		} else {
+			_ = fs.Remove(target)
+		}
+	}()
+
+	var sourceFile *os.File
+	for _, source := range sources {
+		sourceFile, err = fs.Open(source)
+		if err != nil {
+			break
+		}
+		_, err = io.Copy(targetFile, sourceFile)
+		if err != nil {
+			break
+		}
+		err = sourceFile.Close()
+		if err != nil {
+			break
+		}
+	}
+
+	return err
+}
+
+// DirSize returns the accumulated size of all files in folder
+func DirSize(fs v1.FS, path string) (int64, error) {
+	var size int64
+	err := vfs.Walk(fs, path, func(_ string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			size += info.Size()
+		}
+		return err
+	})
+	return size, err
+}
+
+// Check if a file or directory exists.
+func Exists(fs v1.FS, path string) (bool, error) {
+	_, err := fs.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return false, err
+}
+
+// CalcFileChecksum opens the given file and returns the sha256 checksum of it.
+func CalcFileChecksum(fs v1.FS, fileName string) (string, error) {
+	f, err := fs.Open(fileName)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+
+	h := sha256.New()
+	if _, err := io.Copy(h, f); err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%x", h.Sum(nil)), nil
+}

tools-image/enki/pkg/utils/utils_suite_test.go

@@ -0,0 +1,29 @@
+/*
+Copyright © 2021 SUSE LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestWhitebox(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Utils test suite")
+}

tools-image/enki/pkg/utils/utils_test.go

@@ -0,0 +1,368 @@
+/*
+Copyright © 2021 SUSE LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package utils_test
+
+import (
+	"errors"
+	"fmt"
+	conf "github.com/kairos-io/enki/pkg/config"
+	"github.com/kairos-io/enki/pkg/constants"
+	"github.com/kairos-io/enki/pkg/utils"
+	v1 "github.com/kairos-io/kairos-agent/v2/pkg/types/v1"
+	v1mock "github.com/kairos-io/kairos-agent/v2/tests/mocks"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+	"github.com/twpayne/go-vfs"
+	"github.com/twpayne/go-vfs/vfst"
+	"os"
+	"strings"
+)
+
+var _ = Describe("Utils", Label("utils"), func() {
+	var config *v1.Config
+	var runner *v1mock.FakeRunner
+	var logger v1.Logger
+	var syscall *v1mock.FakeSyscall
+	var client *v1mock.FakeHTTPClient
+	var mounter *v1mock.ErrorMounter
+	var fs vfs.FS
+	var cleanup func()
+
+	BeforeEach(func() {
+		runner = v1mock.NewFakeRunner()
+		syscall = &v1mock.FakeSyscall{}
+		mounter = v1mock.NewErrorMounter()
+		client = &v1mock.FakeHTTPClient{}
+		logger = v1.NewNullLogger()
+		// Ensure /tmp exists in the VFS
+		fs, cleanup, _ = vfst.NewTestFS(nil)
+		fs.Mkdir("/tmp", constants.DirPerm)
+		fs.Mkdir("/run", constants.DirPerm)
+		fs.Mkdir("/etc", constants.DirPerm)
+
+		config = conf.NewConfig(
+			conf.WithFs(fs),
+			conf.WithRunner(runner),
+			conf.WithLogger(logger),
+			conf.WithMounter(mounter),
+			conf.WithSyscall(syscall),
+			conf.WithClient(client),
+		)
+	})
+	AfterEach(func() { cleanup() })
+
+	Describe("Chroot", Label("chroot"), func() {
+		var chroot *utils.Chroot
+		BeforeEach(func() {
+			chroot = utils.NewChroot(
+				"/whatever",
+				config,
+			)
+		})
+		Describe("ChrootedCallback method", func() {
+			It("runs a callback in a chroot", func() {
+				err := utils.ChrootedCallback(config, "/somepath", map[string]string{}, func() error {
+					return nil
+				})
+				Expect(err).ShouldNot(HaveOccurred())
+				err = utils.ChrootedCallback(config, "/somepath", map[string]string{}, func() error {
+					return fmt.Errorf("callback error")
+				})
+				Expect(err).Should(HaveOccurred())
+				Expect(err.Error()).To(ContainSubstring("callback error"))
+			})
+		})
+		Describe("on success", func() {
+			It("command should be called in the chroot", func() {
+				_, err := chroot.Run("chroot-command")
+				Expect(err).To(BeNil())
+				Expect(syscall.WasChrootCalledWith("/whatever")).To(BeTrue())
+			})
+			It("commands should be called with a customized chroot", func() {
+				chroot.SetExtraMounts(map[string]string{"/real/path": "/in/chroot/path"})
+				Expect(chroot.Prepare()).To(BeNil())
+				defer chroot.Close()
+				_, err := chroot.Run("chroot-command")
+				Expect(err).To(BeNil())
+				Expect(syscall.WasChrootCalledWith("/whatever")).To(BeTrue())
+				_, err = chroot.Run("chroot-another-command")
+				Expect(err).To(BeNil())
+			})
+			It("runs a callback in a custom chroot", func() {
+				called := false
+				callback := func() error {
+					called = true
+					return nil
+				}
+				err := chroot.RunCallback(callback)
+				Expect(err).To(BeNil())
+				Expect(syscall.WasChrootCalledWith("/whatever")).To(BeTrue())
+				Expect(called).To(BeTrue())
+			})
+		})
+		Describe("on failure", func() {
+			It("should return error if chroot-command fails", func() {
+				runner.ReturnError = errors.New("run error")
+				_, err := chroot.Run("chroot-command")
+				Expect(err).NotTo(BeNil())
+				Expect(syscall.WasChrootCalledWith("/whatever")).To(BeTrue())
+			})
+			It("should return error if callback fails", func() {
+				called := false
+				callback := func() error {
+					called = true
+					return errors.New("Callback error")
+				}
+				err := chroot.RunCallback(callback)
+				Expect(err).NotTo(BeNil())
+				Expect(syscall.WasChrootCalledWith("/whatever")).To(BeTrue())
+				Expect(called).To(BeTrue())
+			})
+			It("should return error if preparing twice before closing", func() {
+				Expect(chroot.Prepare()).To(BeNil())
+				defer chroot.Close()
+				Expect(chroot.Prepare()).NotTo(BeNil())
+				Expect(chroot.Close()).To(BeNil())
+				Expect(chroot.Prepare()).To(BeNil())
+			})
+			It("should return error if failed to chroot", func() {
+				syscall.ErrorOnChroot = true
+				_, err := chroot.Run("chroot-command")
+				Expect(err).ToNot(BeNil())
+				Expect(syscall.WasChrootCalledWith("/whatever")).To(BeTrue())
+				Expect(err.Error()).To(ContainSubstring("chroot error"))
+			})
+			It("should return error if failed to mount on prepare", Label("mount"), func() {
+				mounter.ErrorOnMount = true
+				_, err := chroot.Run("chroot-command")
+				Expect(err).ToNot(BeNil())
+				Expect(err.Error()).To(ContainSubstring("mount error"))
+			})
+			It("should return error if failed to unmount on close", Label("unmount"), func() {
+				mounter.ErrorOnUnmount = true
+				_, err := chroot.Run("chroot-command")
+				Expect(err).ToNot(BeNil())
+				Expect(err.Error()).To(ContainSubstring("failed closing chroot"))
+			})
+		})
+	})
+	Describe("CopyFile", Label("CopyFile"), func() {
+		It("Copies source file to target file", func() {
+			err := utils.MkdirAll(fs, "/some", constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Create("/some/file")
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Stat("/some/otherfile")
+			Expect(err).Should(HaveOccurred())
+			Expect(utils.CopyFile(fs, "/some/file", "/some/otherfile")).ShouldNot(HaveOccurred())
+			e, err := utils.Exists(fs, "/some/otherfile")
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(e).To(BeTrue())
+		})
+		It("Copies source file to target folder", func() {
+			err := utils.MkdirAll(fs, "/some", constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			err = utils.MkdirAll(fs, "/someotherfolder", constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Create("/some/file")
+			Expect(err).ShouldNot(HaveOccurred())
+			_, err = fs.Stat("/someotherfolder/file")
+			Expect(err).Should(HaveOccurred())
+			Expect(utils.CopyFile(fs, "/some/file", "/someotherfolder")).ShouldNot(HaveOccurred())
+			e, err := utils.Exists(fs, "/someotherfolder/file")
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(e).To(BeTrue())
+		})
+		It("Fails to open non existing file", func() {
+			err := utils.MkdirAll(fs, "/some", constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(utils.CopyFile(fs, "/some/file", "/some/otherfile")).NotTo(BeNil())
+			_, err = fs.Stat("/some/otherfile")
+			Expect(err).NotTo(BeNil())
+		})
+		It("Fails to copy on non writable target", func() {
+			err := utils.MkdirAll(fs, "/some", constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			fs.Create("/some/file")
+			_, err = fs.Stat("/some/otherfile")
+			Expect(err).NotTo(BeNil())
+			fs = vfs.NewReadOnlyFS(fs)
+			Expect(utils.CopyFile(fs, "/some/file", "/some/otherfile")).NotTo(BeNil())
+			_, err = fs.Stat("/some/otherfile")
+			Expect(err).NotTo(BeNil())
+		})
+	})
+	Describe("CreateDirStructure", Label("CreateDirStructure"), func() {
+		It("Creates essential directories", func() {
+			dirList := []string{"sys", "proc", "dev", "tmp", "boot", "usr/local", "oem"}
+			for _, dir := range dirList {
+				_, err := fs.Stat(fmt.Sprintf("/my/root/%s", dir))
+				Expect(err).NotTo(BeNil())
+			}
+			Expect(utils.CreateDirStructure(fs, "/my/root")).To(BeNil())
+			for _, dir := range dirList {
+				fi, err := fs.Stat(fmt.Sprintf("/my/root/%s", dir))
+				Expect(err).To(BeNil())
+				if fi.Name() == "tmp" {
+					Expect(fmt.Sprintf("%04o", fi.Mode().Perm())).To(Equal("0777"))
+					Expect(fi.Mode() & os.ModeSticky).NotTo(Equal(0))
+				}
+				if fi.Name() == "sys" {
+					Expect(fmt.Sprintf("%04o", fi.Mode().Perm())).To(Equal("0555"))
+				}
+			}
+		})
+		It("Fails on non writable target", func() {
+			fs = vfs.NewReadOnlyFS(fs)
+			Expect(utils.CreateDirStructure(fs, "/my/root")).NotTo(BeNil())
+		})
+	})
+	Describe("DirSize", Label("fs"), func() {
+		BeforeEach(func() {
+			err := utils.MkdirAll(fs, "/folder/subfolder", constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			f, err := fs.Create("/folder/file")
+			Expect(err).ShouldNot(HaveOccurred())
+			err = f.Truncate(1024)
+			Expect(err).ShouldNot(HaveOccurred())
+			f, err = fs.Create("/folder/subfolder/file")
+			Expect(err).ShouldNot(HaveOccurred())
+			err = f.Truncate(2048)
+			Expect(err).ShouldNot(HaveOccurred())
+		})
+		It("Returns the expected size of a test folder", func() {
+			size, err := utils.DirSize(fs, "/folder")
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(size).To(Equal(int64(3072)))
+		})
+	})
+	Describe("CalcFileChecksum", Label("checksum"), func() {
+		It("compute correct sha256 checksum", func() {
+			testData := strings.Repeat("abcdefghilmnopqrstuvz\n", 20)
+			testDataSHA256 := "7f182529f6362ae9cfa952ab87342a7180db45d2c57b52b50a68b6130b15a422"
+
+			err := fs.Mkdir("/iso", constants.DirPerm)
+			Expect(err).ShouldNot(HaveOccurred())
+			err = fs.WriteFile("/iso/test.iso", []byte(testData), 0644)
+			Expect(err).ShouldNot(HaveOccurred())
+
+			checksum, err := utils.CalcFileChecksum(fs, "/iso/test.iso")
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(checksum).To(Equal(testDataSHA256))
+		})
+	})
+	Describe("CreateSquashFS", Label("CreateSquashFS"), func() {
+		It("runs with no options if none given", func() {
+			err := utils.CreateSquashFS(runner, logger, "source", "dest", []string{})
+			Expect(runner.IncludesCmds([][]string{
+				{"mksquashfs", "source", "dest"},
+			})).To(BeNil())
+			Expect(err).ToNot(HaveOccurred())
+		})
+		It("runs with options if given", func() {
+			err := utils.CreateSquashFS(runner, logger, "source", "dest", constants.GetDefaultSquashfsOptions())
+			cmd := []string{"mksquashfs", "source", "dest"}
+			cmd = append(cmd, constants.GetDefaultSquashfsOptions()...)
+			Expect(runner.IncludesCmds([][]string{
+				cmd,
+			})).To(BeNil())
+			Expect(err).ToNot(HaveOccurred())
+		})
+		It("returns an error if it fails", func() {
+			runner.ReturnError = errors.New("error")
+			err := utils.CreateSquashFS(runner, logger, "source", "dest", []string{})
+			Expect(runner.IncludesCmds([][]string{
+				{"mksquashfs", "source", "dest"},
+			})).To(BeNil())
+			Expect(err).To(HaveOccurred())
+		})
+	})
+	Describe("CleanStack", Label("CleanStack"), func() {
+		var cleaner *utils.CleanStack
+		BeforeEach(func() {
+			cleaner = utils.NewCleanStack()
+		})
+		It("Adds a callback to the stack and pops it", func() {
+			var flag bool
+			callback := func() error {
+				flag = true
+				return nil
+			}
+			Expect(cleaner.Pop()).To(BeNil())
+			cleaner.Push(callback)
+			poppedJob := cleaner.Pop()
+			Expect(poppedJob).NotTo(BeNil())
+			poppedJob()
+			Expect(flag).To(BeTrue())
+		})
+		It("On Cleanup runs callback stack in reverse order", func() {
+			result := ""
+			callback1 := func() error {
+				result = result + "one "
+				return nil
+			}
+			callback2 := func() error {
+				result = result + "two "
+				return nil
+			}
+			callback3 := func() error {
+				result = result + "three "
+				return nil
+			}
+			cleaner.Push(callback1)
+			cleaner.Push(callback2)
+			cleaner.Push(callback3)
+			cleaner.Cleanup(nil)
+			Expect(result).To(Equal("three two one "))
+		})
+		It("On Cleanup keeps former error and all callbacks are executed", func() {
+			err := errors.New("Former error")
+			count := 0
+			callback := func() error {
+				count++
+				if count == 2 {
+					return errors.New("Cleanup Error")
+				}
+				return nil
+			}
+			cleaner.Push(callback)
+			cleaner.Push(callback)
+			cleaner.Push(callback)
+			err = cleaner.Cleanup(err)
+			Expect(count).To(Equal(3))
+			Expect(err.Error()).To(ContainSubstring("Former error"))
+		})
+		It("On Cleanup error reports first error and all callbacks are executed", func() {
+			var err error
+			count := 0
+			callback := func() error {
+				count++
+				if count >= 2 {
+					return errors.New(fmt.Sprintf("Cleanup error %d", count))
+				}
+				return nil
+			}
+			cleaner.Push(callback)
+			cleaner.Push(callback)
+			cleaner.Push(callback)
+			err = cleaner.Cleanup(err)
+			Expect(count).To(Equal(3))
+			Expect(err.Error()).To(ContainSubstring("Cleanup error 2"))
+			Expect(err.Error()).To(ContainSubstring("Cleanup error 3"))
+		})
+	})
+})

tools-image/entrypoint.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -ex
+
+enki --config-dir /config $@

tools-image/gce.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Transform a raw image disk to gce compatible
+RAWIMAGE="$1"
+OUT="${2:-$RAWIMAGE.gce.raw}"
+cp -rf $RAWIMAGE $OUT
+
+GB=$((1024*1024*1024))
+size=$(qemu-img info -f raw --output json "$OUT" | gawk 'match($0, /"virtual-size": ([0-9]+),/, val) {print val[1]}')
+# shellcheck disable=SC2004
+ROUNDED_SIZE=$(echo "$size/$GB+1"|bc)
+echo "Resizing raw image from \"$size\"MB to \"$ROUNDED_SIZE\"GB"
+qemu-img resize -f raw "$OUT" "$ROUNDED_SIZE"G
+echo "Compressing raw image $OUT to $OUT.tar.gz"
+tar -c -z --format=oldgnu -f "$OUT".tar.gz $OUT

tools-image/luet.yaml

@@ -0,0 +1,24 @@
+general:
+  debug: false
+  spinner_charset: 9
+logging:
+  enable_emoji: false
+repositories:
+  - name: "kairos"
+    description: "kairos repository"
+    type: "docker"
+    arch: amd64
+    cached: true
+    priority: 2
+    urls:
+      - "quay.io/kairos/packages"
+    reference: 20230718103103-repository.yaml
+  - name: "kairos-arm64"
+    description: "kairos repository arm64"
+    type: "docker"
+    arch: arm64
+    cached: true
+    priority: 2
+    urls:
+      - "quay.io/kairos/packages-arm64"
+    reference: 20230718102351-repository.yaml

tools-image/netboot.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# Extracts squashfs, kernel, initrd and generates a ipxe template script
+
+ISO=$1
+OUTPUT_NAME=$2
+ARTIFACT_NAME=$(basename $OUTPUT_NAME)
+
+isoinfo -x /rootfs.squashfs -R -i $ISO > $OUTPUT_NAME.squashfs
+isoinfo -x /boot/kernel -R -i $ISO > $OUTPUT_NAME-kernel
+isoinfo -x /boot/initrd -R -i $ISO > $OUTPUT_NAME-initrd
+
+URL=${URL:-https://github.com/kairos-io/kairos/releases/download}
+
+cat > $OUTPUT_NAME.ipxe << EOF
+#!ipxe
+set url ${URL}/
+set kernel $ARTIFACT_NAME-kernel
+set initrd $ARTIFACT_NAME-initrd
+set rootfs $ARTIFACT_NAME.squashfs
+# set config https://example.com/machine-config
+# set cmdline extra.values=1
+kernel \${url}/\${kernel} initrd=\${initrd} ip=dhcp rd.cos.disable root=live:\${url}/\${rootfs} netboot nodepair.enable config_url=\${config} console=tty1 console=ttyS0 \${cmdline}
+initrd \${url}/\${initrd}
+boot
+EOF

tools-image/os-release.tmpl

@@ -0,0 +1,13 @@
+KAIROS_NAME="${OS_NAME}"
+KAIROS_VERSION="${OS_VERSION}"
+KAIROS_ID="${OS_ID}"
+KAIROS_ID_LIKE="${OS_NAME}"
+KAIROS_VERSION_ID="${OS_VERSION}"
+KAIROS_PRETTY_NAME="${OS_NAME} ${OS_VERSION}"
+KAIROS_BUG_REPORT_URL="${BUG_REPORT_URL}"
+KAIROS_HOME_URL="${HOME_URL}"
+KAIROS_IMAGE_REPO="${OS_REPO}"
+KAIROS_IMAGE_LABEL="${OS_LABEL}"
+KAIROS_GITHUB_REPO="${GITHUB_REPO}"
+KAIROS_VARIANT="${VARIANT}"
+KAIROS_FLAVOR="${FLAVOR}"

tools-image/prepare_arm_images.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+# This script prepares Kairos state, recovery, oem and pesistent partitions as img files.
+
+set -e
+
+# Temp dir used during build
+WORKDIR=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+TARGET=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+STATEDIR=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+
+: "${OEM_LABEL:=COS_OEM}"
+: "${RECOVERY_LABEL:=COS_RECOVERY}"
+: "${ACTIVE_LABEL:=COS_ACTIVE}"
+: "${PASSIVE_LABEL:=COS_PASSIVE}"
+: "${PERSISTENT_LABEL:=COS_PERSISTENT}"
+: "${SYSTEM_LABEL:=COS_SYSTEM}"
+: "${STATE_LABEL:=COS_STATE}"
+  
+size="${SIZE:-7544}"
+state_size="${STATE_SIZE:-4992}"
+recovery_size="${RECOVERY_SIZE:-2192}"
+default_active_size="${DEFAULT_ACTIVE_SIZE:-2400}"
+menu_entry="${DEFAULT_MENU_ENTRY:-Kairos}"
+
+container_image="${container_image:-quay.io/kairos/kairos-opensuse-leap-arm-rpi:v1.5.1-k3sv1.25.6-k3s1}"
+
+ensure_dir_structure() {
+    local target=$1
+    for mnt in /sys /proc /dev /tmp /boot /usr/local /oem
+    do
+        if [ ! -d "${target}${mnt}" ]; then
+          mkdir -p ${target}${mnt}
+        fi
+    done
+}
+
+mkdir -p $WORKDIR/tmpefi
+
+# Create the EFI partition FAT16 and include the EFI image and a basic grub.cfg
+truncate -s $((20*1024*1024)) bootloader/efi.img
+cp -rfv /efi/* $WORKDIR/tmpefi
+mkfs.fat -F16 -n COS_GRUB bootloader/efi.img
+mcopy -s -i bootloader/efi.img $WORKDIR/tmpefi/EFI ::EFI
+
+mkdir -p ${STATEDIR}/cOS
+
+dd if=/dev/zero of=${STATEDIR}/cOS/active.img bs=1M count=$default_active_size
+
+mkfs.ext2 ${STATEDIR}/cOS/active.img -L ${ACTIVE_LABEL}
+
+
+LOOP=$(losetup --show -f ${STATEDIR}/cOS/active.img)
+if [ -z "$LOOP" ]; then
+  echo "No device"
+  exit 1
+fi
+
+mount -t ext2 $LOOP $TARGET
+
+ensure_dir_structure $TARGET
+
+# Download the container image
+if [ -z "$directory" ]; then
+  echo ">>> Downloading container image"
+  luet util unpack $container_image $TARGET
+else
+  echo ">>> Copying files from $directory"
+  rsync -axq --exclude='host' --exclude='mnt' --exclude='proc' --exclude='sys' --exclude='dev' --exclude='tmp' ${directory}/ $TARGET
+fi
+
+# We copy the grubmenu.cfg to a temporary location to be copied later in the state partition
+# https://github.com/kairos-io/kairos/blob/62c67e3e61d49435c362014522e5c6696335376f/overlay/files/system/oem/08_grub.yaml#L105
+# This is a hack and we need a better way: https://github.com/kairos-io/kairos/issues/1427
+tmpgrubconfig=$(mktemp /tmp/grubmeny.cfg.XXXXXX)
+cp -rfv $TARGET/etc/kairos/branding/grubmenu.cfg "${tmpgrubconfig}"
+
+umount $TARGET
+sync
+
+losetup -d $LOOP
+
+
+echo ">> Preparing passive.img"
+cp -rfv ${STATEDIR}/cOS/active.img ${STATEDIR}/cOS/passive.img
+tune2fs -L ${PASSIVE_LABEL} ${STATEDIR}/cOS/passive.img
+
+
+# Preparing recovery
+echo ">> Preparing recovery.img"
+RECOVERY=$(mktemp -d --tmpdir arm-builder.XXXXXXXXXX)
+mkdir -p ${RECOVERY}/cOS
+cp -rfv ${STATEDIR}/cOS/active.img ${RECOVERY}/cOS/recovery.img
+tune2fs -L ${SYSTEM_LABEL} ${RECOVERY}/cOS/recovery.img
+
+# Install real grub config to recovery
+cp -rfv /raw/grubconfig/* $RECOVERY
+mkdir -p $RECOVERY/grub2/fonts
+cp -rfv /raw/grubartifacts/* $RECOVERY/grub2
+mv $RECOVERY/grub2/*pf2 $RECOVERY/grub2/fonts
+
+dd if=/dev/zero of=recovery_partition.img bs=1M count=$recovery_size
+dd if=/dev/zero of=state_partition.img bs=1M count=$state_size
+
+mkfs.ext4 -F -L ${RECOVERY_LABEL} recovery_partition.img
+LOOP=$(losetup --show -f recovery_partition.img)
+mkdir -p $WORKDIR/recovery
+mount $LOOP $WORKDIR/recovery
+cp -arf $RECOVERY/* $WORKDIR/recovery
+umount $WORKDIR/recovery
+losetup -d $LOOP
+
+mkfs.ext4 -F -L ${STATE_LABEL} state_partition.img
+LOOP=$(losetup --show -f state_partition.img)
+mkdir -p $WORKDIR/state
+mount $LOOP $WORKDIR/state
+cp -arf $STATEDIR/* $WORKDIR/state
+grub2-editenv $WORKDIR/state/grub_oem_env set "default_menu_entry=$menu_entry"
+
+# We copy the file we saved earier to the STATE partition
+cp -rfv "${tmpgrubconfig}" $WORKDIR/state/grubmenu
+
+umount $WORKDIR/state
+losetup -d $LOOP
+
+cp -rfv state_partition.img bootloader/
+cp -rfv recovery_partition.img bootloader/
+
+## Optional, prepare COS_OEM and COS_PERSISTENT
+
+# Create the grubenv forcing first boot to be on recovery system
+mkdir -p $WORKDIR/oem
+cp -rfv /defaults.yaml $WORKDIR/oem/01_defaults.yaml
+
+# Create a 64MB filesystem for OEM volume
+truncate -s $((64*1024*1024)) bootloader/oem.img
+mkfs.ext2 -L "${OEM_LABEL}" -d $WORKDIR/oem bootloader/oem.img
+
+# Create a 2GB filesystem for COS_PERSISTENT volume
+truncate -s $((2048*1024*1024)) bootloader/persistent.img
+mkfs.ext2 -L "${PERSISTENT_LABEL}" bootloader/persistent.img

tools-image/raw-images.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+# Generates EFI bootable images (statically)
+# This is a re-adaptation of https://github.com/rancher/elemental-toolkit/blob/v0.8.10-1/images/img-builder.sh, which was dropped
+# How to use:
+# First extract the image which you want to create an image from:
+### luet util unpack <image> rootfs
+# Then convert it to a raw disk (EFI only):
+### docker run -v $PWD:/output --entrypoint /raw-images.sh -ti --rm test-image /output/rootfs /output/foo.raw cloud-init.yaml
+
+: "${OEM_LABEL:=COS_OEM}"
+: "${RECOVERY_LABEL:=COS_RECOVERY}"
+: "${EXTEND:=}"
+: "${RECOVERY_SIZE:=2048}"
+
+DIRECTORY=$1
+OUT=${2:-disk.raw}
+CONFIG=$3
+
+echo "Output: $OUT"
+
+set -e
+
+mkdir -p /build/root/grub2
+mkdir /build/root/cOS
+mkdir /build/efi
+
+cp -rf /raw/grub/* /build/efi
+cp -rf /raw/grubconfig/* /build/root
+cp -rf /raw/grubartifacts/* /build/root/grub2
+
+echo "Generating squashfs from $DIRECTORY"
+mksquashfs $DIRECTORY recovery.squashfs -b 1024k -comp xz -Xbcj x86
+mv recovery.squashfs /build/root/cOS/recovery.squashfs
+
+grub2-editenv /build/root/grub_oem_env set "default_menu_entry=Kairos"
+
+# Create a 2GB filesystem for RECOVERY including the contents for root (grub config and squasfs container)
+# shellcheck disable=SC2004
+truncate -s $(($RECOVERY_SIZE*1024*1024)) rootfs.part
+mkfs.ext2 -L "${RECOVERY_LABEL}" -d /build/root rootfs.part
+
+# Create the EFI partition FAT16 and include the EFI image and a basic grub.cfg
+truncate -s $((20*1024*1024)) efi.part
+
+mkfs.fat -F16 -n COS_GRUB efi.part
+mcopy -s -i efi.part /build/efi/EFI ::EFI
+
+# Create the grubenv forcing first boot to be on recovery system
+mkdir -p /build/oem
+cp /build/root/etc/cos/grubenv_firstboot /build/oem/grubenv
+if [ -n "$CONFIG" ]; then
+  echo "Copying config file ($CONFIG)"
+  cp $CONFIG /build/oem
+fi
+
+# Create a 64MB filesystem for OEM volume
+truncate -s $((64*1024*1024)) oem.part
+mkfs.ext2 -L "${OEM_LABEL}" -d /build/oem oem.part
+
+echo "Generating image $OUT"
+# Create disk image, add 3MB of initial free space to disk, 1MB is for proper alignement, 2MB are for the hybrid legacy boot.
+truncate -s $((3*1024*1024)) $OUT
+{
+    cat efi.part
+    cat oem.part
+    cat rootfs.part
+} >> $OUT
+
+# Add an extra MB at the end of the disk for the gpt headers, in fact 34 sectors would be enough, but adding some more does not hurt.
+truncate -s "+$((1024*1024))" $OUT
+
+if [ -n "$EXTEND" ]; then
+  echo "Extending image of $EXTEND MB"
+  truncate -s "+$((EXTEND*1024*1024))" $OUT
+fi
+
+# Create the partition table in $OUT (assumes sectors of 512 bytes)
+sgdisk -n 1:2048:+2M -c 1:legacy -t 1:EF02 $OUT
+sgdisk -n 2:0:+20M -c 2:UEFI -t 2:EF00 $OUT
+sgdisk -n 3:0:+64M -c 3:oem -t 3:8300 $OUT
+sgdisk -n 4:0:+${RECOVERY_SIZE}M -c 4:root -t 4:8300 $OUT

tools-image/update-os-release.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# usage:
+# docker run --rm -ti --entrypoint /update-os-release.sh \
+# -v /etc:/workspace \ # mount the directory where your os-release is, this is by default in /etc but you can mount a different dir for testing
+# -e OS_NAME=kairos-core-opensuse-leap \
+# -e OS_VERSION=v2.2.0 \
+# -e OS_ID="kairos" \
+# -e OS_NAME=kairos-core-opensuse-leap \
+# -e BUG_REPORT_URL="https://github.com/kairos-io/kairos/issues" \
+# -e HOME_URL="https://github.com/kairos-io/kairos" \
+# -e OS_REPO="quay.io/kairos/core-opensuse-leap" \
+# -e OS_LABEL="latest" \
+# -e GITHUB_REPO="kairos-io/kairos" \
+# -e VARIANT="core" \
+# -e FLAVOR="opensuse-leap"
+# quay.io/kairos/osbuilder-tools:latest
+
+set -ex
+
+sed -i -n '/KAIROS_/!p' /workspace/os-release
+envsubst >>/workspace/os-release < /os-release.tmpl
+
+cat /workspace/os-release