add pgo delete label command, update docs

Author: jmccormick2001

apiserver.go

@@ -92,6 +92,7 @@ func main() {
 	//here
 	r.HandleFunc("/ingestdelete/{name}", ingestservice.DeleteIngestHandler).Methods("GET")
 	r.HandleFunc("/label", labelservice.LabelHandler).Methods("POST")
+	r.HandleFunc("/labeldelete", labelservice.DeleteLabelHandler).Methods("POST")
 	r.HandleFunc("/load", loadservice.LoadHandler).Methods("POST")
 	r.HandleFunc("/user", userservice.UserHandler).Methods("POST")
 	r.HandleFunc("/users", userservice.CreateUserHandler).Methods("POST")

apiserver/labelservice/labelimpl.go

@@ -34,7 +34,6 @@ import (
 
 // Label ... 2 forms ...
 // pgo label  myucluser yourcluster --label=env=prod
-// pgo label  myucluser yourcluster --label=env=prod --delete-label
 // pgo label  --label=env=prod --selector=name=mycluster
 func Label(request *msgs.LabelRequest) msgs.LabelResponse {
 	var err error
@@ -190,7 +189,7 @@ func updateLabels(deployment *v1beta1.Deployment, clusterName string, newLabels
 
 	_, err = apiserver.Clientset.ExtensionsV1beta1().Deployments(apiserver.Namespace).Patch(clusterName, types.MergePatchType, patchBytes, "")
 	if err != nil {
-		log.Debug("error patching deployment " + err.Error())
+		log.Debug("error updating patching deployment " + err.Error())
 	}
 	return err
 
@@ -256,3 +255,205 @@ func validateLabel(LabelCmdLabel string) (map[string]string, error) {
 	}
 	return labelMap, err
 }
+
+// DeleteLabel ...
+// pgo delete label  mycluster yourcluster --label=env=prod
+// pgo delete label  --label=env=prod --selector=group=somegroup
+func DeleteLabel(request *msgs.DeleteLabelRequest) msgs.LabelResponse {
+	var err error
+	var labelsMap map[string]string
+	resp := msgs.LabelResponse{}
+	resp.Status.Code = msgs.Ok
+	resp.Status.Msg = ""
+	resp.Results = make([]string, 0)
+
+	if len(request.Args) == 0 && request.Selector == "" {
+		resp.Status.Code = msgs.Error
+		resp.Status.Msg = "no clusters specified"
+		return resp
+	}
+
+	labelsMap, err = validateLabel(request.LabelCmdLabel)
+	if err != nil {
+		resp.Status.Code = msgs.Error
+		resp.Status.Msg = "labels not formatted correctly"
+		return resp
+	}
+
+	clusterList := crv1.PgclusterList{}
+	if len(request.Args) > 0 && request.Args[0] == "all" {
+		err = kubeapi.GetpgclustersBySelector(apiserver.RESTClient,
+			&clusterList, "", apiserver.Namespace)
+		if err != nil {
+			log.Error("error getting list of clusters" + err.Error())
+			resp.Status.Code = msgs.Error
+			resp.Status.Msg = "error getting list of clusters" + err.Error()
+			return resp
+		}
+		if len(clusterList.Items) == 0 {
+			resp.Status.Code = msgs.Error
+			resp.Status.Msg = "no clusters found"
+			return resp
+		}
+
+	} else if request.Selector != "" {
+		err = kubeapi.GetpgclustersBySelector(apiserver.RESTClient,
+			&clusterList, request.Selector, apiserver.Namespace)
+		if err != nil {
+			log.Error("error getting list of clusters" + err.Error())
+			resp.Status.Code = msgs.Error
+			resp.Status.Msg = "error getting list of clusters" + err.Error()
+			return resp
+		}
+		if len(clusterList.Items) == 0 {
+			resp.Status.Code = msgs.Error
+			resp.Status.Msg = "no clusters found"
+			return resp
+		}
+	} else {
+		//each arg represents a cluster name
+		items := make([]crv1.Pgcluster, 0)
+		for _, cluster := range request.Args {
+			result := crv1.Pgcluster{}
+			_, err := kubeapi.Getpgcluster(apiserver.RESTClient,
+				&result, cluster, apiserver.Namespace)
+			if err != nil {
+				resp.Status.Code = msgs.Error
+				resp.Status.Msg = "error getting list of clusters" + err.Error()
+				return resp
+			}
+
+			items = append(items, result)
+		}
+		clusterList.Items = items
+	}
+
+	for _, c := range clusterList.Items {
+		resp.Results = append(resp.Results, "deleting label from "+c.Spec.Name)
+	}
+
+	err = deleteLabels(clusterList.Items, request.LabelCmdLabel, labelsMap)
+	if err != nil {
+		resp.Status.Code = msgs.Error
+		resp.Status.Msg = err.Error()
+		return resp
+	}
+
+	return resp
+
+}
+
+func deleteLabels(items []crv1.Pgcluster, LabelCmdLabel string, labelsMap map[string]string) error {
+	var err error
+
+	for i := 0; i < len(items); i++ {
+		log.Debugf("deleting label from %s", items[i].Spec.Name)
+		err = deletePatchPgcluster(LabelCmdLabel, items[i])
+		if err != nil {
+			log.Error(err.Error())
+			return err
+		}
+	}
+
+	for i := 0; i < len(items); i++ {
+		//get deployments for this CRD
+		selector := util.LABEL_PG_CLUSTER + "=" + items[i].Spec.Name
+		deployments, err := kubeapi.GetDeployments(apiserver.Clientset, selector, apiserver.Namespace)
+		if err != nil {
+			return err
+		}
+
+		for _, d := range deployments.Items {
+			err = deleteTheLabel(&d, items[i].Spec.Name, labelsMap)
+			if err != nil {
+				log.Error(err.Error())
+				return err
+			}
+		}
+
+	}
+	return err
+}
+
+func deletePatchPgcluster(newLabel string, oldCRD crv1.Pgcluster) error {
+
+	fields := strings.Split(newLabel, "=")
+	labelKey := fields[0]
+	//labelValue := fields[1]
+	oldData, err := json.Marshal(oldCRD)
+	if err != nil {
+		return err
+	}
+	if oldCRD.ObjectMeta.Labels == nil {
+		oldCRD.ObjectMeta.Labels = make(map[string]string)
+	}
+	delete(oldCRD.ObjectMeta.Labels, labelKey)
+
+	var newData, patchBytes []byte
+	newData, err = json.Marshal(oldCRD)
+	if err != nil {
+		return err
+	}
+	patchBytes, err = jsonpatch.CreateMergePatch(oldData, newData)
+	if err != nil {
+		return err
+	}
+
+	log.Debug(string(patchBytes))
+	_, err6 := apiserver.RESTClient.Patch(types.MergePatchType).
+		Namespace(apiserver.Namespace).
+		Resource(crv1.PgclusterResourcePlural).
+		Name(oldCRD.Spec.Name).
+		Body(patchBytes).
+		Do().
+		Get()
+
+	return err6
+
+}
+
+func deleteTheLabel(deployment *v1beta1.Deployment, clusterName string, labelsMap map[string]string) error {
+
+	var err error
+
+	log.Debugf("%v are the labels to delete\n", labelsMap)
+
+	var patchBytes, newData, origData []byte
+	origData, err = json.Marshal(deployment)
+	if err != nil {
+		return err
+	}
+
+	accessor, err2 := meta.Accessor(deployment)
+	if err2 != nil {
+		return err2
+	}
+
+	objLabels := accessor.GetLabels()
+	if objLabels == nil {
+		objLabels = make(map[string]string)
+	}
+
+	for k, _ := range labelsMap {
+		delete(objLabels, k)
+	}
+	log.Debugf("revised labels after delete are %v\n", objLabels)
+
+	accessor.SetLabels(objLabels)
+	newData, err = json.Marshal(deployment)
+	if err != nil {
+		return err
+	}
+
+	patchBytes, err = jsonpatch.CreateMergePatch(origData, newData)
+	if err != nil {
+		return err
+	}
+
+	_, err = apiserver.Clientset.ExtensionsV1beta1().Deployments(apiserver.Namespace).Patch(deployment.Name, types.MergePatchType, patchBytes, "")
+	if err != nil {
+		log.Debug("error patching deployment " + err.Error())
+	}
+	return err
+
+}

apiserver/labelservice/labelservice.go

@@ -49,3 +49,30 @@ func LabelHandler(w http.ResponseWriter, r *http.Request) {
 
 	json.NewEncoder(w).Encode(resp)
 }
+
+// DeleteLabelHandler ...
+func DeleteLabelHandler(w http.ResponseWriter, r *http.Request) {
+
+	log.Debug("labelservice.DeleteLabelHandler called")
+
+	var request msgs.DeleteLabelRequest
+	_ = json.NewDecoder(r.Body).Decode(&request)
+
+	err := apiserver.Authn(apiserver.LABEL_PERM, w, r)
+	if err != nil {
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+	w.Header().Set("Content-Type", "application/json")
+
+	var resp msgs.LabelResponse
+	if request.ClientVersion != msgs.PGO_VERSION {
+		resp = msgs.LabelResponse{}
+		resp.Status = msgs.Status{Msg: apiserver.VERSION_MISMATCH_ERROR, Code: msgs.Error}
+	} else {
+		resp = DeleteLabel(&request)
+	}
+
+	json.NewEncoder(w).Encode(resp)
+}

apiservermsgs/labelmsgs.go

@@ -28,6 +28,15 @@ type LabelRequest struct {
 	ClientVersion string
 }
 
+// DeleteLabelRequest ...
+type DeleteLabelRequest struct {
+	Selector      string
+	Namespace     string
+	Args          []string
+	LabelCmdLabel string
+	ClientVersion string
+}
+
 // LabelResponse ...
 type LabelResponse struct {
 	Results []string

hugo/content/getting-started/_index.adoc

@@ -1011,9 +1011,6 @@ $ pgo label [NAME]|all [FLAGS]
 |=========================================================
 |Name |Shorthand |Input |Usage
 
-|`--delete-label` |N/A |String |
-Deletes a label from specified clusters.
-
 |`--dry-run` |N/A |N/A |
 Shows the clusters that the label would be applied to, without labelling them.
 
@@ -1043,6 +1040,13 @@ In the first example, a label of *env=research* is applied to the cluster
 *mycluster*. The second example will apply the label to any clusters that
 have an existing label of *project=xray* applied or to all clusters.
 
+===== Removing Labels
+
+You can delete a user defined label from a cluster as follows:
+....
+pgo delete label mycluster --label=env=research
+....
+
 === Creating SQL Policies
 
 Policies are SQL files that can be applied to a single cluster, a selection

pgo/api/label.go

@@ -59,3 +59,40 @@ func LabelClusters(httpclient *http.Client, SessionCredentials *msgs.BasicAuthCr
 
 	return response, err
 }
+
+func DeleteLabel(httpclient *http.Client, SessionCredentials *msgs.BasicAuthCredentials, request *msgs.DeleteLabelRequest) (msgs.LabelResponse, error) {
+
+	var response msgs.LabelResponse
+	url := SessionCredentials.APIServerURL + "/labeldelete"
+	log.Debug("delete label called...[" + url + "]")
+
+	jsonValue, _ := json.Marshal(request)
+
+	action := "POST"
+	req, err := http.NewRequest(action, url, bytes.NewBuffer(jsonValue))
+	if err != nil {
+		return response, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.SetBasicAuth(SessionCredentials.Username, SessionCredentials.Password)
+
+	resp, err := httpclient.Do(req)
+	if err != nil {
+		return response, err
+	}
+	defer resp.Body.Close()
+
+	log.Debugf("%v\n", resp)
+	err = StatusCheck(resp)
+	if err != nil {
+		return response, err
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
+		log.Printf("%v\n", resp.Body)
+		log.Println(err)
+		return response, err
+	}
+
+	return response, err
+}