test/main.go: move more kubectl commands to native go code

Gopkg.toml

@@ -14,6 +14,10 @@
   name = "k8s.io/apimachinery"
   version = "kubernetes-1.9.3"
 
+[[override]]
+  name = "k8s.io/apiextensions-apiserver"
+  version = "kubernetes-1.9.3"
+
 [[override]]
   name = "k8s.io/client-go"
   version = "kubernetes-1.9.3"

test/main.go

@@ -1,17 +1,24 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strconv"
 	"time"
 
+	y2j "github.com/ghodss/yaml"
 	"github.com/operator-framework/operator-sdk/pkg/util/retryutil"
 	apps "k8s.io/api/apps/v1"
 	core "k8s.io/api/core/v1"
+	"k8s.io/api/rbac/v1beta1"
+	crd "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
+	extensions "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
+	extensions_scheme "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset/scheme"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
@@ -37,6 +44,10 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
+	extensionclient, err := extensions.NewForConfig(config)
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	// create namespace
 	namespaceObj := &core.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespace}}
@@ -46,15 +57,24 @@ func main() {
 	}
 
 	// create rbac
-	kubectlWrapper("create", namespace, "deploy/rbac.yaml")
+	dat, err := ioutil.ReadFile("deploy/rbac.yaml")
+	splitDat := bytes.Split(dat, []byte("\n---\n"))
+	for _, thing := range splitDat {
+		createFromYAML(thing, kubeclient, namespace)
+	}
+	//	kubectlWrapper("create", namespace, "deploy/rbac.yaml")
 	fmt.Println("Created rbac")
 
 	// create crd
-	kubectlWrapper("create", namespace, "deploy/crd.yaml")
+	dat, err = ioutil.ReadFile("deploy/crd.yaml")
+	//	kubectlWrapper("create", namespace, "deploy/crd.yaml")
+	createCRDFromYAML(dat, extensionclient)
 	fmt.Println("Created crd")
 
 	// create operator
-	kubectlWrapper("create", namespace, "deploy/operator.yaml")
+	dat, err = ioutil.ReadFile("deploy/operator.yaml")
+	//kubectlWrapper("create", namespace, "deploy/operator.yaml")
+	createFromYAML(dat, kubeclient, namespace)
 	fmt.Println("Created operator")
 
 	err = deploymentReplicaCheck(kubeclient, namespace, "memcached-operator", 1, 6)
@@ -76,26 +96,19 @@ func main() {
 
 	file.Close()
 
-	kubectlWrapper("apply", namespace, "deploy/cr.yaml")
+	dat, err = ioutil.ReadFile("deploy/cr.yaml")
+	memcachedClient := getCRClient(config, "cache.example.com", "v1alpha1")
+	createCRFromYAML(dat, memcachedClient, namespace, "memcacheds")
+
+	//kubectlWrapper("apply", namespace, "deploy/cr.yaml")
 
 	err = deploymentReplicaCheck(kubeclient, namespace, "example-memcached", 3, 6)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	// get new RESTClient for memcached resources
-	var SchemeGroupVersion = schema.GroupVersion{Group: "cache.example.com", Version: "v1alpha1"}
-	config.GroupVersion = &SchemeGroupVersion
-	config.APIPath = "/apis"
-	config.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
-
-	if config.UserAgent == "" {
-		config.UserAgent = rest.DefaultKubernetesUserAgent()
-	}
-	restClient, err := rest.RESTClientFor(config)
-
 	// update CR size to 4
-	err = restClient.Patch(types.JSONPatchType).
+	err = memcachedClient.Patch(types.JSONPatchType).
 		Namespace(namespace).
 		Resource("memcacheds").
 		Name("example-memcached").
@@ -115,6 +128,73 @@ func main() {
 	kubectlWrapper("delete", namespace, "deploy/operator.yaml")
 }
 
+func getCRClient(config *rest.Config, group, version string) *rest.RESTClient {
+	// get new RESTClient for custom resources
+	crConfig := config
+	crGV := schema.GroupVersion{Group: group, Version: version}
+	crConfig.GroupVersion = &crGV
+	crConfig.APIPath = "/apis"
+	crConfig.NegotiatedSerializer = serializer.DirectCodecFactory{CodecFactory: scheme.Codecs}
+
+	if crConfig.UserAgent == "" {
+		crConfig.UserAgent = rest.DefaultKubernetesUserAgent()
+	}
+	crRESTClient, err := rest.RESTClientFor(crConfig)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return crRESTClient
+}
+
+// create a custom resource from a yaml file; not fully automated (still needs more work)
+func createCRFromYAML(yaml []byte, client *rest.RESTClient, namespace, resourceName string) {
+	jsonDat, err := y2j.YAMLToJSON(yaml)
+	err = client.Post().
+		Namespace(namespace).
+		Resource(resourceName).
+		Body(jsonDat).
+		Do().
+		Error()
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func createCRDFromYAML(yaml []byte, extensionsClient *extensions.Clientset) {
+	decode := extensions_scheme.Codecs.UniversalDeserializer().Decode
+	obj, _, err := decode(yaml, nil, nil)
+
+	if err != nil {
+		fmt.Println("Failed to deserialize CustomResourceDefinition")
+		log.Fatal(err)
+	}
+	switch o := obj.(type) {
+	case *crd.CustomResourceDefinition:
+		extensionsClient.ApiextensionsV1beta1().CustomResourceDefinitions().Create(o)
+	}
+}
+
+func createFromYAML(yaml []byte, kubeclient *kubernetes.Clientset, namespace string) {
+	decode := scheme.Codecs.UniversalDeserializer().Decode
+	obj, _, err := decode(yaml, nil, nil)
+
+	if err != nil {
+		fmt.Println("Unable to deserialize resource; is it a custom resource?")
+		log.Fatal(err)
+	}
+
+	switch o := obj.(type) {
+	case *v1beta1.Role:
+		kubeclient.RbacV1beta1().Roles(namespace).Create(o)
+	case *v1beta1.RoleBinding:
+		kubeclient.RbacV1beta1().RoleBindings(namespace).Create(o)
+	case *apps.Deployment:
+		kubeclient.AppsV1().Deployments(namespace).Create(o)
+	default:
+		log.Fatalf("unknown type: %s", o)
+	}
+}
+
 func printDeployments(deployments *apps.DeploymentList) {
 	template := "%-40s%-10s\n"
 	fmt.Printf(template, "NAME", "NUM_REPLICAS")