Write rendered manifests to destination bootstrap dir

Author: Danil-Grigorev

pkg/config/config.go

@@ -108,7 +108,7 @@ func ComposeConfig(platform configv1.PlatformType, imagesFile, managedNamespace
 func ComposeBootstrapConfig(infra *configv1.Infrastructure, imagesConfig *corev1.ConfigMap, managedNamespace string) (Config, error) {
 	platform, err := GetProviderFromInfrastructure(infra)
 	if err != nil {
-		klog.Errorf("Unable to detemine platform from cluster infrastrucutre file %q: %s", client.ObjectKeyFromObject(infra), err)
+		klog.Errorf("Unable to detemine platform from cluster infrastrucutre file: %s", err)
 		return Config{}, err
 	}
 

pkg/render/render.go

@@ -2,22 +2,38 @@ package render
 
 import (
 	"bytes"
+	"fmt"
+	"io/fs"
 	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
 
 	configv1 "github.com/openshift/api/config/v1"
 	"github.com/openshift/cluster-cloud-controller-manager-operator/pkg/cloud"
 	"github.com/openshift/cluster-cloud-controller-manager-operator/pkg/config"
 	"github.com/openshift/cluster-cloud-controller-manager-operator/pkg/substitution"
 	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/util/yaml"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/serializer/json"
+	k8syaml "k8s.io/apimachinery/pkg/util/yaml"
 	"k8s.io/klog"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 const (
 	bootstrapNamespace = "openshift-cloud-controller-manager"
+	bootstrapPrefix    = "bootstrap"
+	// bootstrapFileName is built from bootstrapPrefix, resource kind and name
+	bootstrapFileName = "%s/%s-%s.yaml"
 )
 
+var scheme *runtime.Scheme
+
+func init() {
+	scheme = runtime.NewScheme()
+}
+
 // Render defines render config for use in bootstrap mode
 type Render struct {
 	// dir where CCCMO reads the cloud configs, images config maps
@@ -43,6 +59,7 @@ func (r *Render) Run(destinationDir string) error {
 	infra, imagesMap, err := r.readAssets()
 	if err != nil {
 		klog.Errorf("Cannot read assets from provided paths: %v", err)
+		return err
 	}
 	config, err := config.ComposeBootstrapConfig(infra, imagesMap, bootstrapNamespace)
 	if err != nil {
@@ -57,8 +74,7 @@ func (r *Render) Run(destinationDir string) error {
 		klog.Infof("Collected resource %s %q successfully", resource.GetObjectKind().GroupVersionKind(), client.ObjectKeyFromObject(resource))
 	}
 
-	// TODO: write resourcs on disk
-	return nil
+	return writeAssets(destinationDir, resources)
 }
 
 // readAssets collects infrastructure resource and images config map from provided paths
@@ -70,7 +86,7 @@ func (r *Render) readAssets() (*configv1.Infrastructure, *corev1.ConfigMap, erro
 	}
 
 	infra := &configv1.Infrastructure{}
-	dec := yaml.NewYAMLOrJSONDecoder(bytes.NewReader(infraData), 1000)
+	dec := k8syaml.NewYAMLOrJSONDecoder(bytes.NewReader(infraData), 1000)
 	if err := dec.Decode(infra); err != nil {
 		klog.Errorf("Cannot decode data into configv1.Infrastructure from %q: %v", r.infrastructureFile, err)
 		return nil, nil, err
@@ -83,11 +99,33 @@ func (r *Render) readAssets() (*configv1.Infrastructure, *corev1.ConfigMap, erro
 	}
 
 	imagesConfigMap := &corev1.ConfigMap{}
-	dec = yaml.NewYAMLOrJSONDecoder(bytes.NewReader(imagesData), 1000)
+	dec = k8syaml.NewYAMLOrJSONDecoder(bytes.NewReader(imagesData), 1000)
 	if err := dec.Decode(imagesConfigMap); err != nil {
 		klog.Errorf("Cannot decode data into v1.ConfigMap from %q: %v", r.imagesFile, err)
 		return nil, nil, err
 	}
 
 	return infra, imagesConfigMap, nil
 }
+
+func writeAssets(destinationDir string, resources []client.Object) error {
+	for _, resource := range resources {
+		filename := fmt.Sprintf(bootstrapFileName, bootstrapPrefix, strings.ToLower(resource.GetObjectKind().GroupVersionKind().Kind), resource.GetName())
+		klog.Infof("Writing file %q on disc", filename)
+
+		path := filepath.Join(destinationDir, filename)
+		dirname := filepath.Dir(path)
+		if err := os.MkdirAll(dirname, fs.ModePerm); err != nil {
+			klog.Errorf("Unable to create destination dir %q: %v", dirname, err)
+			return err
+		}
+		file, err := os.Create(path)
+		if err != nil {
+			klog.Errorf("Failed to open %q: %v", path, err)
+			return err
+		}
+		defer file.Close()
+		json.NewYAMLSerializer(json.DefaultMetaFactory, scheme, scheme).Encode(resource, file)
+	}
+	return nil
+}

pkg/render/render_test.go

@@ -1,14 +1,20 @@
 package render
 
 import (
+	"fmt"
+	"io/fs"
 	"io/ioutil"
 	"os"
+	"path"
+	"strings"
 	"testing"
 
 	configv1 "github.com/openshift/api/config/v1"
+	"github.com/openshift/cluster-cloud-controller-manager-operator/pkg/cloud/aws"
 	"github.com/stretchr/testify/assert"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
 const (
@@ -21,6 +27,13 @@ status:
   platform: AWS
   platformStatus:
     type: AWS
+`
+	infraMissingPlatform = `apiVersion: config.openshift.io/v1
+kind: Infrastructure
+metadata:
+  name: cluster
+spec: {}
+status: {}
 `
 	imagesConfigMap = `apiVersion: v1
 kind: ConfigMap
@@ -85,28 +98,23 @@ func TestReadAssets(t *testing.T) {
 		infra:           matchingInfra,
 		imagesContent:   imagesConfigMap,
 		imagesConfigMap: matchingConfigMap,
-	},
-		{
-			name:        "Infrastructure not located",
-			expectError: "open not_found: no such file or directory",
-		},
-		{
-			name:         "ImagesConfigMap not located",
-			infraContent: infra,
-			expectError:  "open not_found: no such file or directory",
-		},
-		{
-			name:         "Bad images config map file content",
-			infraContent: "BAD",
-			expectError:  "error unmarshaling JSON: while decoding JSON: json: cannot unmarshal string into Go value of type v1.Infrastructure",
-		},
-		{
-			name:          "Bad infrastructure file content",
-			infraContent:  infra,
-			imagesContent: "BAD",
-			expectError:   "error unmarshaling JSON: while decoding JSON: json: cannot unmarshal string into Go value of type v1.ConfigMap",
-		},
-	}
+	}, {
+		name:        "Infrastructure not located",
+		expectError: "open not_found: no such file or directory",
+	}, {
+		name:         "ImagesConfigMap not located",
+		infraContent: infra,
+		expectError:  "open not_found: no such file or directory",
+	}, {
+		name:         "Bad images config map file content",
+		infraContent: "BAD",
+		expectError:  "error unmarshaling JSON: while decoding JSON: json: cannot unmarshal string into Go value of type v1.Infrastructure",
+	}, {
+		name:          "Bad infrastructure file content",
+		infraContent:  infra,
+		imagesContent: "BAD",
+		expectError:   "error unmarshaling JSON: while decoding JSON: json: cannot unmarshal string into Go value of type v1.ConfigMap",
+	}}
 
 	infraPath := "infra.yaml"
 	configPath := "imagesConfigMap.yaml"
@@ -150,3 +158,135 @@ func TestReadAssets(t *testing.T) {
 		})
 	}
 }
+
+func TestRenderRun(t *testing.T) {
+	tc := []struct {
+		name          string
+		infraContent  string
+		imagesContent string
+		expectObjects []client.Object
+		expectError   string
+	}{{
+		name:          "Unmarshal both infrastructure and images with no issue",
+		infraContent:  infra,
+		imagesContent: imagesConfigMap,
+		expectObjects: aws.GetBootstrapResources(),
+	}, {
+		name:          "Infrastructure not populated",
+		infraContent:  infraMissingPlatform,
+		imagesContent: imagesConfigMap,
+		expectError:   "platform status is not pupulated on infrastructure",
+	}, {
+		name:          "ImagesConfigMap not located",
+		infraContent:  infra,
+		imagesContent: "BAD",
+		expectError:   "error unmarshaling JSON: while decoding JSON: json: cannot unmarshal string into Go value of type v1.ConfigMap",
+	}}
+
+	infraPath := "infra.yaml"
+	configPath := "imagesConfigMap.yaml"
+
+	for _, tc := range tc {
+		t.Run(tc.name, func(t *testing.T) {
+			imagesFile := "not_found"
+			infrastructureFile := "not_found"
+			destination, err := ioutil.TempDir("", "test")
+			assert.NoError(t, err)
+
+			if tc.imagesContent != "" {
+				file, err := ioutil.TempFile(os.TempDir(), configPath)
+				path := file.Name()
+				assert.NoError(t, err)
+				defer file.Close()
+
+				_, err = file.WriteString(tc.imagesContent)
+				assert.NoError(t, err)
+				imagesFile = path
+			}
+
+			if tc.infraContent != "" {
+				file, err := ioutil.TempFile(os.TempDir(), infraPath)
+				path := file.Name()
+				assert.NoError(t, err)
+				defer file.Close()
+
+				_, err = file.WriteString(tc.infraContent)
+				assert.NoError(t, err)
+				infrastructureFile = path
+			}
+
+			r := New("", infrastructureFile, imagesFile)
+			err = r.Run(destination)
+			if tc.expectError != "" {
+				assert.EqualError(t, err, tc.expectError)
+				return
+			}
+			assert.NoError(t, err)
+
+			// Assert all files were written to bootstrap dir
+			files, err := ioutil.ReadDir(path.Join(destination, bootstrapPrefix))
+			assert.NoError(t, err)
+			assert.Len(t, files, len(tc.expectObjects))
+		})
+	}
+}
+
+func TestWriteAssets(t *testing.T) {
+	tc := []struct {
+		name          string
+		destination   string
+		preCreateMode fs.FileMode
+		objects       []client.Object
+		expectErr     string
+	}{{
+		name:        "Writing file finished with success",
+		destination: "test",
+		objects:     []client.Object{matchingInfra, matchingConfigMap},
+	}, {
+		name:      "Fail to write into /dev/null",
+		objects:   []client.Object{matchingInfra, matchingConfigMap},
+		expectErr: "mkdir /dev/null: not a directory",
+	}, {
+		name:          "Fail to write into /dev/null",
+		objects:       []client.Object{matchingInfra, matchingConfigMap},
+		destination:   "bad_permissions",
+		preCreateMode: 0444,
+		expectErr:     "permission denied",
+	}}
+
+	for _, tc := range tc {
+		t.Run(tc.name, func(t *testing.T) {
+			destination := "/dev/null"
+
+			if tc.destination != "" {
+				dirPath, err := ioutil.TempDir("", tc.destination)
+				assert.NoError(t, err)
+				destination = dirPath
+				if tc.preCreateMode != 0 {
+					os.MkdirAll(path.Join(destination, bootstrapPrefix), tc.preCreateMode)
+					assert.NoError(t, err)
+				}
+			}
+
+			err := writeAssets(destination, tc.objects)
+			if tc.expectErr != "" {
+				assert.Contains(t, err.Error(), tc.expectErr)
+				return
+			}
+			assert.NoError(t, err)
+
+			// Assert all files were written to bootstrap dir
+			files, err := ioutil.ReadDir(path.Join(destination, bootstrapPrefix))
+			assert.NoError(t, err)
+			assert.Len(t, files, len(tc.objects))
+
+			names := []string{}
+			for _, file := range files {
+				names = append(names, file.Name())
+			}
+			for _, res := range tc.objects {
+				assert.Contains(t, names, fmt.Sprintf("%s-%s.yaml", strings.ToLower(res.GetObjectKind().GroupVersionKind().Kind), res.GetName()))
+			}
+		})
+	}
+}