package main

import (
  "encoding/json"
  "fmt"
  "flag"
  "os"

  v1 "k8s.io/api/core/v1"
  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  "k8s.io/client-go/kubernetes"
  "k8s.io/apimachinery/pkg/runtime/schema"
  "k8s.io/apimachinery/pkg/types"
  autoscalingv1 "k8s.io/api/autoscaling/v1"
  "k8s.io/client-go/dynamic"
  "k8s.io/client-go/tools/clientcmd"
  //"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
)

func main() {
  // uses the current context in kubeconfig
  kubeconfig := flag.String("kubeconfig", fmt.Sprintf("%v/%v/%v", os.Getenv("HOME"), ".kube", "config"), "(optional) absolute path to the kubeconfig file")
  flag.Parse()
  config, err := clientcmd.BuildConfigFromFlags("", *kubeconfig)
  if err != nil {
    fmt.Println(err)
  }
  // make our work easier to find in the audit_event queries
  config.UserAgent = "live-test-writing"
  // creates the clientset
  ClientSet, _ := kubernetes.NewForConfig(config)
  DynamicClientSet, _ := dynamic.NewForConfig(config)
  rcResource := schema.GroupVersionResource{Group: "", Version: "v1", Resource: "replicationcontrollers"}

  testRcName := "rc-test"
  testRcNamespace := "default"
  testRcInitialReplicaCount := int32(1)
  testRcMaxReplicaCount := int32(2)

  rcTest := v1.ReplicationController{
      ObjectMeta: metav1.ObjectMeta{
          Name: testRcName,
          Labels: map[string]string{"test-rc-static": "true"},
      },
      Spec: v1.ReplicationControllerSpec{
          Replicas: &testRcInitialReplicaCount,
          Selector: map[string]string{"test-rc-static": "true"},
          Template: &v1.PodTemplateSpec{
              ObjectMeta: metav1.ObjectMeta{
                  Name: testRcName,
                  Labels: map[string]string{"test-rc-static": "true"},
              },
              Spec: v1.PodSpec{
                  Containers: []v1.Container{{
                      Name: testRcName,
                      Image: "nginx",
                  }},
              },
          },
      },
  }

  // Create a ReplicationController
  _, err = ClientSet.CoreV1().ReplicationControllers(testRcNamespace).Create(&rcTest)
  if err != nil {
      fmt.Println(err)
      return
  }
  fmt.Println("[status] created ReplicationController")

  // setup a watch for the RC
  rcWatch, err := ClientSet.CoreV1().ReplicationControllers(testRcNamespace).Watch(metav1.ListOptions{LabelSelector: "test-rc-static=true"})
  if err != nil {
      fmt.Println(err)
      return
  }
  rcWatchChan := rcWatch.ResultChan()

  fmt.Println("[status] watching for all Replicas to be ready")
  for event := range rcWatchChan {
      rc, ok := event.Object.(*v1.ReplicationController)
      if ok != true {
          fmt.Println("Unable to fix type")
          return
      }
      if rc.Status.Replicas == testRcInitialReplicaCount && rc.Status.ReadyReplicas == testRcInitialReplicaCount {
          break
      }
  }

  rcLabelPatchPayload, err := json.Marshal(v1.ReplicationController{
      ObjectMeta: metav1.ObjectMeta{
          Labels: map[string]string{"test-rc": "patched"},
      },
  })
  if err != nil {
    fmt.Println(err)
    return
  }
  // Patch the ReplicationController
  _, err = ClientSet.CoreV1().ReplicationControllers(testRcNamespace).Patch(testRcName, types.StrategicMergePatchType, []byte(rcLabelPatchPayload))
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println("[status] patched ReplicationController")

  rcStatusPatchPayload, err := json.Marshal(map[string]interface{}{
    "status": map[string]interface{}{
      "readyReplicas": 0,
      "availableReplicas": 0,
    },
  })
  if err != nil {
      fmt.Println(err)
      return
  }

  // Patch the ReplicationController's status
  rcStatus, err := ClientSet.CoreV1().ReplicationControllers(testRcNamespace).Patch(testRcName, types.StrategicMergePatchType, []byte(rcStatusPatchPayload), "status")
  if err != nil {
      fmt.Println(err)
      return
  }
  if rcStatus.Status.ReadyReplicas != 0 {
      fmt.Println("[error] failed to patch ReplicationController status; ReadyReplicas != 0")
      return
  }
  fmt.Println("[status] patched status of ReplicationController")

  rcStatusUnstructured, err := DynamicClientSet.Resource(rcResource).Namespace(testRcNamespace).Get(testRcName, metav1.GetOptions{}, "status")
  if err != nil {
      fmt.Println(err)
      return
  }
  rcStatusUjson, _ := json.Marshal(rcStatusUnstructured)
	json.Unmarshal(rcStatusUjson, &rcStatus)
  if rcStatus.Status.Replicas != testRcInitialReplicaCount {
     fmt.Println("[error] Replica count does not match initial Replica count")
  }
  fmt.Println("[status] fetched ReplicationController status")

  rcScalePatchPayload, err := json.Marshal(autoscalingv1.Scale{
      Spec: autoscalingv1.ScaleSpec{
          Replicas: 2,
      },
  })
  if err != nil {
      fmt.Println(err)
      return
  }

  // Patch the ReplicationController's scale
  rcScale, err := ClientSet.CoreV1().ReplicationControllers(testRcNamespace).Patch(testRcName, types.StrategicMergePatchType, []byte(rcScalePatchPayload), "scale")
  if err != nil {
      fmt.Println(err)
      return
  }
  rcScaleReplicasExpect := int32(2)
  if rcScale.Status.Replicas == rcScaleReplicasExpect {
      fmt.Println("[error] failed to patch ReplicationController scale; ReadyReplicas != 2")
      return
  }
  fmt.Println("[status] patched scale of ReplicationController")

  fmt.Println("[status] watching for all Replicas to be ready")
  for event := range rcWatchChan {
      rc, ok := event.Object.(*v1.ReplicationController)
      if ok != true {
          fmt.Println("Unable to fix type")
          return
      }
      if rc.Status.Replicas == testRcMaxReplicaCount && rc.Status.ReadyReplicas == testRcMaxReplicaCount {
          break
      }
  }

  // Get the ReplicationController
  rc, err := ClientSet.CoreV1().ReplicationControllers(testRcNamespace).Get(testRcName, metav1.GetOptions{})
  if err != nil {
      fmt.Println(err)
      return
  }
  if rc.ObjectMeta.Labels["test-rc"] != "patched" {
      fmt.Println(err)
      return
  }
  fmt.Println("[status] fetched ReplicationController")

  rcStatusUpdatePayload := rc
  rcStatusUpdatePayload.Status.AvailableReplicas = 1
  rcStatusUpdatePayload.Status.ReadyReplicas = 1

  // Replace the ReplicationController's status	
  rcStatus, err = ClientSet.CoreV1().ReplicationControllers(testRcNamespace).UpdateStatus(rcStatusUpdatePayload)
  if err != nil {
      fmt.Println(err)
      return
  }
  if rcStatus.Status.ReadyReplicas != 1 {
      fmt.Println("[error] failed to patch ReplicationController status; ReadyReplicas != 1")
      return
  }
  fmt.Println("[status] updated ReplicationController status")

  fmt.Println("[status] watching for all Replicas to be ready")
  for event := range rcWatchChan {
      rc, ok := event.Object.(*v1.ReplicationController)
      if ok != true {
          fmt.Println("Unable to fix type")
          return
      }
      if rc.Status.Replicas == testRcMaxReplicaCount && rc.Status.ReadyReplicas == testRcMaxReplicaCount {
          fmt.Println("[status] all Replicas are ready")
          break
      }
  }

  rcs, err := ClientSet.CoreV1().ReplicationControllers("").List(metav1.ListOptions{LabelSelector: "test-rc-static=true"})
  if err != nil {
      fmt.Println(err)
      return
  }
  if len(rcs.Items) == 0 {
      fmt.Println("[error] no ReplicationController were found")
  }
  foundRc := false
  for _, rcItem := range rcs.Items {
      if rcItem.ObjectMeta.Name == testRcName &&
         rcItem.ObjectMeta.Namespace == testRcNamespace &&
         rcItem.ObjectMeta.Labels["test-rc-static"] == "true" &&
         rcItem.ObjectMeta.Labels["test-rc"] == "patched" && 
         rcItem.Status.Replicas == testRcMaxReplicaCount &&
         rcItem.Status.ReadyReplicas == testRcMaxReplicaCount {
         foundRc = true
      }
  }
  if foundRc == false {
      fmt.Println("[error] unable to find ReplicationController")
      return
  }
  fmt.Println("[status] retrieved all ReplicationControllers selecting with LabelSelector")

  // Delete ReplicationController
  err = ClientSet.CoreV1().ReplicationControllers(testRcNamespace).DeleteCollection(&metav1.DeleteOptions{}, metav1.ListOptions{LabelSelector: "test-rc-static=true"})
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println("[status] deleted ReplicationController")

  fmt.Println("[status] complete")

}

[status] created ReplicationController
[status] watching for all Replicas to be ready
[status] patched ReplicationController
[status] patched status of ReplicationController
[status] fetched ReplicationController status
[status] patched scale of ReplicationController
[status] watching for all Replicas to be ready
[status] fetched ReplicationController
[status] updated ReplicationController status
[status] watching for all Replicas to be ready
[status] all Replicas are ready
[status] retrieved all ReplicationControllers selecting with LabelSelector
[status] deleted ReplicationController
[status] complete