This patch introduces an enhancement to the existing Collectd Operator.
It has now 2 CRDS CollectdGlobal and CollectdPlugin and corresponding
controllers. CollectdGlobal is used to specify the global options of
collectd conf and CollectdPlugin is used to load/unload plugins.
Added synchronization when both controllers try to fetch the same
resources. Refactored some of the common code to collectdutils.
Issue-ID: ONAPARC-461
Signed-off-by: Dileep Ranganathan <dileep.ranganathan@intel.com>
Change-Id: Id2edf6fa6de56d9d7216ebb258b3017661c6a3dd
--- /dev/null
+apiVersion: onap.org/v1alpha1
+kind: CollectdGlobal
+metadata:
+ name: example-collectdglobal
+spec:
+ # Add fields here
+ globalOptions: |
+ BaseDir "/opt/collectd/var/lib/collectd"
+ PIDFile "/opt/collectd/var/run/collectd.pid"
+ PluginDir "/opt/collectd/lib/collectd"
+ TypesDB "/opt/collectd/share/collectd/types.db"
+ TypesDB "/opt/collectd/share/collectd/vcmts.types.db"
+ #Hostname "localhost"
+ Interval 1
+ configMap: typesdb-configmap
name: cpu
spec:
# Add fields here
- pluginName: "cpu"
+ pluginName: cpu
pluginConf: |
<Plugin "cpu">
Interval 5
ReportByState false
ReportByCpu false
</Plugin>
-
\ No newline at end of file
+
--- /dev/null
+apiVersion: apiextensions.k8s.io/v1beta1
+kind: CustomResourceDefinition
+metadata:
+ name: collectdglobals.onap.org
+spec:
+ group: onap.org
+ names:
+ kind: CollectdGlobal
+ listKind: CollectdGlobalList
+ plural: collectdglobals
+ singular: collectdglobal
+ scope: Namespaced
+ subresources:
+ status: {}
+ validation:
+ openAPIV3Schema:
+ 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/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/api-conventions.md#types-kinds'
+ type: string
+ metadata:
+ type: object
+ spec:
+ properties:
+ configMap:
+ type: string
+ globalOptions:
+ description: 'INSERT ADDITIONAL SPEC FIELDS - desired state of cluster
+ Important: Run "operator-sdk generate k8s" to regenerate code after
+ modifying this file Add custom validation using kubebuilder tags:
+ https://book.kubebuilder.io/beyond_basics/generating_crd.html'
+ type: string
+ required:
+ - globalOptions
+ type: object
+ status:
+ properties:
+ collectdAgents:
+ description: 'INSERT ADDITIONAL STATUS FIELD - define observed state
+ of cluster Important: Run "operator-sdk generate k8s" to regenerate
+ code after modifying this file Add custom validation using kubebuilder
+ tags: https://book.kubebuilder.io/beyond_basics/generating_crd.html
+ CollectdAgents are the collectd pods in the Daemonset Status can be
+ one of "", Created, Deleting, Applied, Deprecated'
+ items:
+ type: string
+ type: array
+ status:
+ type: string
+ required:
+ - status
+ type: object
+ version: v1alpha1
+ versions:
+ - name: v1alpha1
+ served: true
+ storage: true
- onap.org
resources:
- '*'
+ - collectdglobals
verbs:
- '*'
--- /dev/null
+package v1alpha1
+
+import (
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// NOTE: json tags are required. Any new fields you add must have json tags for the fields to be serialized.
+
+// CollectdGlobalSpec defines the desired state of CollectdGlobal
+// +k8s:openapi-gen=true
+type CollectdGlobalSpec struct {
+ // INSERT ADDITIONAL SPEC FIELDS - desired state of cluster
+ // Important: Run "operator-sdk generate k8s" to regenerate code after modifying this file
+ // Add custom validation using kubebuilder tags: https://book.kubebuilder.io/beyond_basics/generating_crd.html
+ GlobalOptions string `json:"globalOptions"`
+ ConfigMap string `json:"configMap,omitempty"`
+}
+
+// CollectdGlobalStatus defines the observed state of CollectdGlobal
+// +k8s:openapi-gen=true
+type CollectdGlobalStatus struct {
+ // INSERT ADDITIONAL STATUS FIELD - define observed state of cluster
+ // Important: Run "operator-sdk generate k8s" to regenerate code after modifying this file
+ // Add custom validation using kubebuilder tags: https://book.kubebuilder.io/beyond_basics/generating_crd.html
+ // CollectdAgents are the collectd pods in the Daemonset
+ // Status can be one of "", Created, Deleting, Applied, Deprecated
+ CollectdAgents []string `json:"collectdAgents,omitempty"`
+ Status string `json:"status"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// CollectdGlobal is the Schema for the collectdglobals API
+// +k8s:openapi-gen=true
+// +kubebuilder:subresource:status
+type CollectdGlobal struct {
+ metav1.TypeMeta `json:",inline"`
+ metav1.ObjectMeta `json:"metadata,omitempty"`
+
+ Spec CollectdGlobalSpec `json:"spec,omitempty"`
+ Status CollectdGlobalStatus `json:"status,omitempty"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// CollectdGlobalList contains a list of CollectdGlobal
+type CollectdGlobalList struct {
+ metav1.TypeMeta `json:",inline"`
+ metav1.ListMeta `json:"metadata,omitempty"`
+ Items []CollectdGlobal `json:"items"`
+}
+
+func init() {
+ SchemeBuilder.Register(&CollectdGlobal{}, &CollectdGlobalList{})
+}
runtime "k8s.io/apimachinery/pkg/runtime"
)
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CollectdGlobal) DeepCopyInto(out *CollectdGlobal) {
+ *out = *in
+ out.TypeMeta = in.TypeMeta
+ in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+ out.Spec = in.Spec
+ in.Status.DeepCopyInto(&out.Status)
+ return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectdGlobal.
+func (in *CollectdGlobal) DeepCopy() *CollectdGlobal {
+ if in == nil {
+ return nil
+ }
+ out := new(CollectdGlobal)
+ in.DeepCopyInto(out)
+ return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *CollectdGlobal) DeepCopyObject() runtime.Object {
+ if c := in.DeepCopy(); c != nil {
+ return c
+ }
+ return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CollectdGlobalList) DeepCopyInto(out *CollectdGlobalList) {
+ *out = *in
+ out.TypeMeta = in.TypeMeta
+ out.ListMeta = in.ListMeta
+ if in.Items != nil {
+ in, out := &in.Items, &out.Items
+ *out = make([]CollectdGlobal, len(*in))
+ for i := range *in {
+ (*in)[i].DeepCopyInto(&(*out)[i])
+ }
+ }
+ return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectdGlobalList.
+func (in *CollectdGlobalList) DeepCopy() *CollectdGlobalList {
+ if in == nil {
+ return nil
+ }
+ out := new(CollectdGlobalList)
+ in.DeepCopyInto(out)
+ return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *CollectdGlobalList) DeepCopyObject() runtime.Object {
+ if c := in.DeepCopy(); c != nil {
+ return c
+ }
+ return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CollectdGlobalSpec) DeepCopyInto(out *CollectdGlobalSpec) {
+ *out = *in
+ return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectdGlobalSpec.
+func (in *CollectdGlobalSpec) DeepCopy() *CollectdGlobalSpec {
+ if in == nil {
+ return nil
+ }
+ out := new(CollectdGlobalSpec)
+ in.DeepCopyInto(out)
+ return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CollectdGlobalStatus) DeepCopyInto(out *CollectdGlobalStatus) {
+ *out = *in
+ if in.CollectdAgents != nil {
+ in, out := &in.CollectdAgents, &out.CollectdAgents
+ *out = make([]string, len(*in))
+ copy(*out, *in)
+ }
+ return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectdGlobalStatus.
+func (in *CollectdGlobalStatus) DeepCopy() *CollectdGlobalStatus {
+ if in == nil {
+ return nil
+ }
+ out := new(CollectdGlobalStatus)
+ in.DeepCopyInto(out)
+ return out
+}
+
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *CollectdPlugin) DeepCopyInto(out *CollectdPlugin) {
*out = *in
func GetOpenAPIDefinitions(ref common.ReferenceCallback) map[string]common.OpenAPIDefinition {
return map[string]common.OpenAPIDefinition{
+ "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdGlobal": schema_pkg_apis_onap_v1alpha1_CollectdGlobal(ref),
+ "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdGlobalSpec": schema_pkg_apis_onap_v1alpha1_CollectdGlobalSpec(ref),
+ "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdGlobalStatus": schema_pkg_apis_onap_v1alpha1_CollectdGlobalStatus(ref),
"demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdPlugin": schema_pkg_apis_onap_v1alpha1_CollectdPlugin(ref),
"demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdPluginSpec": schema_pkg_apis_onap_v1alpha1_CollectdPluginSpec(ref),
"demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdPluginStatus": schema_pkg_apis_onap_v1alpha1_CollectdPluginStatus(ref),
}
}
+func schema_pkg_apis_onap_v1alpha1_CollectdGlobal(ref common.ReferenceCallback) common.OpenAPIDefinition {
+ return common.OpenAPIDefinition{
+ Schema: spec.Schema{
+ SchemaProps: spec.SchemaProps{
+ Description: "CollectdGlobal is the Schema for the collectdglobals API",
+ Properties: map[string]spec.Schema{
+ "kind": {
+ SchemaProps: spec.SchemaProps{
+ 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/api-conventions.md#types-kinds",
+ Type: []string{"string"},
+ Format: "",
+ },
+ },
+ "apiVersion": {
+ SchemaProps: spec.SchemaProps{
+ 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/api-conventions.md#resources",
+ Type: []string{"string"},
+ Format: "",
+ },
+ },
+ "metadata": {
+ SchemaProps: spec.SchemaProps{
+ Ref: ref("k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"),
+ },
+ },
+ "spec": {
+ SchemaProps: spec.SchemaProps{
+ Ref: ref("demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdGlobalSpec"),
+ },
+ },
+ "status": {
+ SchemaProps: spec.SchemaProps{
+ Ref: ref("demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdGlobalStatus"),
+ },
+ },
+ },
+ },
+ },
+ Dependencies: []string{
+ "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdGlobalSpec", "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1.CollectdGlobalStatus", "k8s.io/apimachinery/pkg/apis/meta/v1.ObjectMeta"},
+ }
+}
+
+func schema_pkg_apis_onap_v1alpha1_CollectdGlobalSpec(ref common.ReferenceCallback) common.OpenAPIDefinition {
+ return common.OpenAPIDefinition{
+ Schema: spec.Schema{
+ SchemaProps: spec.SchemaProps{
+ Description: "CollectdGlobalSpec defines the desired state of CollectdGlobal",
+ Properties: map[string]spec.Schema{
+ "globalOptions": {
+ SchemaProps: spec.SchemaProps{
+ Description: "INSERT ADDITIONAL SPEC FIELDS - desired state of cluster Important: Run \"operator-sdk generate k8s\" to regenerate code after modifying this file Add custom validation using kubebuilder tags: https://book.kubebuilder.io/beyond_basics/generating_crd.html",
+ Type: []string{"string"},
+ Format: "",
+ },
+ },
+ "configMap": {
+ SchemaProps: spec.SchemaProps{
+ Type: []string{"string"},
+ Format: "",
+ },
+ },
+ },
+ Required: []string{"globalOptions"},
+ },
+ },
+ Dependencies: []string{},
+ }
+}
+
+func schema_pkg_apis_onap_v1alpha1_CollectdGlobalStatus(ref common.ReferenceCallback) common.OpenAPIDefinition {
+ return common.OpenAPIDefinition{
+ Schema: spec.Schema{
+ SchemaProps: spec.SchemaProps{
+ Description: "CollectdGlobalStatus defines the observed state of CollectdGlobal",
+ Properties: map[string]spec.Schema{
+ "collectdAgents": {
+ SchemaProps: spec.SchemaProps{
+ Description: "INSERT ADDITIONAL STATUS FIELD - define observed state of cluster Important: Run \"operator-sdk generate k8s\" to regenerate code after modifying this file Add custom validation using kubebuilder tags: https://book.kubebuilder.io/beyond_basics/generating_crd.html CollectdAgents are the collectd pods in the Daemonset Status can be one of \"\", Created, Deleting, Applied, Deprecated",
+ Type: []string{"array"},
+ Items: &spec.SchemaOrArray{
+ Schema: &spec.Schema{
+ SchemaProps: spec.SchemaProps{
+ Type: []string{"string"},
+ Format: "",
+ },
+ },
+ },
+ },
+ },
+ "status": {
+ SchemaProps: spec.SchemaProps{
+ Type: []string{"string"},
+ Format: "",
+ },
+ },
+ },
+ Required: []string{"status"},
+ },
+ },
+ Dependencies: []string{},
+ }
+}
+
func schema_pkg_apis_onap_v1alpha1_CollectdPlugin(ref common.ReferenceCallback) common.OpenAPIDefinition {
return common.OpenAPIDefinition{
Schema: spec.Schema{
--- /dev/null
+package controller
+
+import (
+ "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/controller/collectdglobal"
+)
+
+func init() {
+ // AddToManagerFuncs is a list of functions to create controllers and add them to a manager.
+ AddToManagerFuncs = append(AddToManagerFuncs, collectdglobal.Add)
+}
--- /dev/null
+package collectdglobal
+
+import (
+ "context"
+ "fmt"
+ //"path/filepath"
+ "reflect"
+ "strings"
+
+ "github.com/go-logr/logr"
+ "github.com/operator-framework/operator-sdk/pkg/predicate"
+
+ onapv1alpha1 "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1"
+ collectdutils "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/controller/utils"
+
+ appsv1 "k8s.io/api/apps/v1"
+ corev1 "k8s.io/api/core/v1"
+ extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+ "k8s.io/apimachinery/pkg/api/errors"
+ "k8s.io/apimachinery/pkg/runtime"
+ "k8s.io/apimachinery/pkg/types"
+ "k8s.io/client-go/util/retry"
+ "sigs.k8s.io/controller-runtime/pkg/client"
+ "sigs.k8s.io/controller-runtime/pkg/controller"
+ "sigs.k8s.io/controller-runtime/pkg/handler"
+ "sigs.k8s.io/controller-runtime/pkg/manager"
+ "sigs.k8s.io/controller-runtime/pkg/reconcile"
+ logf "sigs.k8s.io/controller-runtime/pkg/runtime/log"
+ "sigs.k8s.io/controller-runtime/pkg/source"
+)
+
+var log = logf.Log.WithName("controller_collectdglobal")
+
+// Add creates a new CollectdGlobal Controller and adds it to the Manager. The Manager will set fields on the Controller
+// and Start it when the Manager is Started.
+func Add(mgr manager.Manager) error {
+ return add(mgr, newReconciler(mgr))
+}
+
+// newReconciler returns a new reconcile.Reconciler
+func newReconciler(mgr manager.Manager) reconcile.Reconciler {
+ return &ReconcileCollectdGlobal{client: mgr.GetClient(), scheme: mgr.GetScheme()}
+}
+
+// add adds a new Controller to mgr with r as the reconcile.Reconciler
+func add(mgr manager.Manager, r reconcile.Reconciler) error {
+ // Create a new controller
+ log.V(1).Info("Creating a new controller for CollectdGlobal")
+ c, err := controller.New("collectdglobal-controller", mgr, controller.Options{Reconciler: r})
+ if err != nil {
+ return err
+ }
+
+ // Watch for changes to primary resource CollectdGlobal
+ log.V(1).Info("Add watcher for primary resource CollectdGlobal")
+ err = c.Watch(&source.Kind{Type: &onapv1alpha1.CollectdGlobal{}}, &handler.EnqueueRequestForObject{}, predicate.GenerationChangedPredicate{})
+ if err != nil {
+ return err
+ }
+
+ log.V(1).Info("Add watcher for secondary resource Collectd Daemonset")
+ err = c.Watch(
+ &source.Kind{Type: &appsv1.DaemonSet{}},
+ &handler.EnqueueRequestsFromMapFunc{
+ ToRequests: handler.ToRequestsFunc(func(a handler.MapObject) []reconcile.Request {
+ labelSelector, err := collectdutils.GetWatchLabels()
+ labels := strings.Split(labelSelector, "=")
+ if err != nil {
+ log.Error(err, "Failed to get watch labels, continuing with default label")
+ }
+ rcp := r.(*ReconcileCollectdGlobal)
+ // Select the Daemonset with labelSelector (Defautl is app=collectd)
+ if a.Meta.GetLabels()[labels[0]] == labels[1] {
+ var requests []reconcile.Request
+ cg, err := collectdutils.GetCollectdGlobal(rcp.client, a.Meta.GetNamespace())
+ if err != nil || cg == nil {
+ return nil
+ }
+ requests = append(requests, reconcile.Request{
+ NamespacedName: client.ObjectKey{Namespace: cg.Namespace, Name: cg.Name}})
+ return requests
+ }
+ return nil
+ }),
+ })
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+// blank assignment to verify that ReconcileCollectdGlobal implements reconcile.Reconciler
+var _ reconcile.Reconciler = &ReconcileCollectdGlobal{}
+
+// ReconcileCollectdGlobal reconciles a CollectdGlobal object
+type ReconcileCollectdGlobal struct {
+ // This client, initialized using mgr.Client() above, is a split client
+ // that reads objects from the cache and writes to the apiserver
+ client client.Client
+ scheme *runtime.Scheme
+}
+
+// Reconcile reads that state of the cluster for a CollectdGlobal object and makes changes based on the state read
+// and what is in the CollectdGlobal.Spec
+// TODO(user): Modify this Reconcile function to implement your Controller logic. This example creates
+// a Pod as an example
+// Note:
+// The Controller will requeue the Request to be processed again if the returned error is non-nil or
+// Result.Requeue is true, otherwise upon completion it will remove the work from the queue.
+func (r *ReconcileCollectdGlobal) Reconcile(request reconcile.Request) (reconcile.Result, error) {
+ reqLogger := log.WithValues("Request.Namespace", request.Namespace, "Request.Name", request.Name)
+ reqLogger.Info("Reconciling CollectdGlobal")
+
+ // Fetch the CollectdGlobal instance
+ instance := &onapv1alpha1.CollectdGlobal{}
+ err := r.client.Get(context.TODO(), request.NamespacedName, instance)
+ if err != nil {
+ if errors.IsNotFound(err) {
+ // Request object not found, could have been deleted after reconcile request.
+ // Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
+ // Return and don't requeue
+ reqLogger.V(1).Info("CollectdGlobal object Not found")
+ return reconcile.Result{}, nil
+ }
+ // Error reading the object - requeue the request.
+ reqLogger.V(1).Info("Error reading the CollectdGlobal object, Requeuing")
+ return reconcile.Result{}, err
+ }
+
+ // Handle Delete CR for additional cleanup
+ isDelete, err := r.handleDelete(reqLogger, instance)
+ if isDelete {
+ return reconcile.Result{}, err
+ }
+
+ // Add finalizer for this CR
+ if !collectdutils.Contains(instance.GetFinalizers(), collectdutils.CollectdFinalizer) {
+ if err := r.addFinalizer(reqLogger, instance); err != nil {
+ return reconcile.Result{}, err
+ }
+ return reconcile.Result{}, nil
+ }
+ // Handle the reconciliation for CollectdGlobal.
+ // At this stage the Status of the CollectdGlobal should NOT be ""
+ err = r.handleCollectdGlobal(reqLogger, instance, false)
+ return reconcile.Result{}, err
+}
+
+// handleCollectdGlobal regenerates the collectd conf on CR Create, Update, Delete events
+func (r *ReconcileCollectdGlobal) handleCollectdGlobal(reqLogger logr.Logger, cr *onapv1alpha1.CollectdGlobal, isDelete bool) error {
+
+ rmap, err := collectdutils.FindResourceMapForCR(r.client, reqLogger, cr.Namespace)
+ if err != nil {
+ reqLogger.Info(":::: Skip current reconcile:::: Resources not found. Cache might be stale. Requeue")
+ return err
+ }
+
+ cm := rmap.ConfigMap
+ reqLogger.V(1).Info("Found ResourceMap")
+ reqLogger.V(1).Info(":::: ConfigMap Info ::::", "ConfigMap.Namespace", cm.Namespace, "ConfigMap.Name", cm.Name)
+
+ collectdConf, err := collectdutils.RebuildCollectdConf(r.client, cr.Namespace, isDelete, "")
+ if err != nil {
+ reqLogger.Error(err, "Skip reconcile: Rebuild conf failed")
+ return err
+ }
+
+ cm.SetAnnotations(map[string]string{
+ "daaas-random": collectdutils.ComputeSHA256([]byte(collectdConf)),
+ })
+
+ cm.Data["collectd.conf"] = collectdConf
+ retryErr := retry.RetryOnConflict(retry.DefaultRetry, func() error {
+ // Update the ConfigMap with new Spec and reload DaemonSets
+ reqLogger.Info("Updating the ConfigMap", "ConfigMap.Namespace", cm.Namespace, "ConfigMap.Name", cm.Name)
+ log.V(1).Info("ConfigMap Data", "Map: ", cm.Data)
+ err = r.client.Update(context.TODO(), cm)
+ if err != nil {
+ reqLogger.Error(err, "Update the ConfigMap failed", "ConfigMap.Namespace", cm.Namespace, "ConfigMap.Name", cm.Name)
+ return err
+ }
+ return nil
+ })
+ if retryErr != nil {
+ panic(fmt.Errorf("Update failed: %v", retryErr))
+ }
+
+ retryErr = retry.RetryOnConflict(retry.DefaultRetry, func() error {
+ // Retrieve the latest version of Daemonset before attempting update
+ // RetryOnConflict uses exponential backoff to avoid exhausting the apiserver
+ // Select DaemonSets with label
+ dsList := &extensionsv1beta1.DaemonSetList{}
+ opts := &client.ListOptions{}
+ labelSelector, err := collectdutils.GetWatchLabels()
+ if err != nil {
+ reqLogger.Error(err, "Failed to get watch labels, continuing with default label")
+ }
+ opts.SetLabelSelector(labelSelector)
+ opts.InNamespace(cr.Namespace)
+ err = r.client.List(context.TODO(), opts, dsList)
+ if err != nil {
+ panic(fmt.Errorf("Failed to get latest version of DaemonSet: %v", err))
+ }
+
+ if dsList.Items == nil || len(dsList.Items) == 0 {
+ return errors.NewNotFound(corev1.Resource("daemonset"), "DaemonSet")
+ }
+ ds := &dsList.Items[0]
+ //Restart Collectd Pods
+ reqLogger.Info("Reloading the Daemonset", "DaemonSet.Namespace", ds.Namespace, "DaemonSet.Name", ds.Name)
+ //Restart only if hash of conf has changed.
+ ds.Spec.Template.SetAnnotations(map[string]string{
+ "daaas-random": collectdutils.ComputeSHA256([]byte(collectdConf)),
+ })
+ r.handleAdditonalConfigMap(reqLogger, cr, ds)
+ updateErr := r.client.Update(context.TODO(), ds)
+ return updateErr
+ })
+ if retryErr != nil {
+ panic(fmt.Errorf("Update failed: %v", retryErr))
+ }
+
+ err = r.updateStatus(cr)
+ if err != nil {
+ reqLogger.Error(err, "Unable to update status")
+ return err
+ }
+ // Reconcile success
+ reqLogger.Info("Reconcile success!!")
+ return nil
+}
+
+// Handle Delete CR event for additional cleanup
+func (r *ReconcileCollectdGlobal) handleDelete(reqLogger logr.Logger, cr *onapv1alpha1.CollectdGlobal) (bool, error) {
+ // Check if the CollectdGlobal instance is marked to be deleted, which is
+ // indicated by the deletion timestamp being set.
+ isMarkedToBeDeleted := cr.GetDeletionTimestamp() != nil
+ if isMarkedToBeDeleted {
+ // Update status to Deleting state
+ cr.Status.Status = onapv1alpha1.Deleting
+ cr.Status.CollectdAgents = nil
+ _ = r.client.Status().Update(context.TODO(), cr)
+
+ if collectdutils.Contains(cr.GetFinalizers(), collectdutils.CollectdFinalizer) {
+ // Run finalization logic for CollectdFinalizer. If the
+ // finalization logic fails, don't remove the finalizer so
+ // that we can retry during the next reconciliation.
+ if err := r.finalizeCollectdGlobal(reqLogger, cr); err != nil {
+ return isMarkedToBeDeleted, err
+ }
+
+ // Remove CollectdFinalizer. Once all finalizers have been
+ // removed, the object will be deleted.
+ cr.SetFinalizers(collectdutils.Remove(cr.GetFinalizers(), collectdutils.CollectdFinalizer))
+ err := r.client.Update(context.TODO(), cr)
+ if err != nil {
+ return isMarkedToBeDeleted, err
+ }
+ }
+ }
+ return isMarkedToBeDeleted, nil
+}
+
+func (r *ReconcileCollectdGlobal) updateStatus(cr *onapv1alpha1.CollectdGlobal) error {
+ switch cr.Status.Status {
+ case onapv1alpha1.Initial:
+ cr.Status.Status = onapv1alpha1.Created
+ case onapv1alpha1.Created, onapv1alpha1.Enabled:
+ pods, err := collectdutils.GetPodList(r.client, cr.Namespace)
+ if err != nil {
+ return err
+ }
+ if !reflect.DeepEqual(pods, cr.Status.CollectdAgents) {
+ cr.Status.CollectdAgents = pods
+ cr.Status.Status = onapv1alpha1.Enabled
+ }
+ case onapv1alpha1.Deleting, onapv1alpha1.Deprecated:
+ return nil
+ }
+ err := r.client.Status().Update(context.TODO(), cr)
+ return err
+}
+
+func (r *ReconcileCollectdGlobal) finalizeCollectdGlobal(reqLogger logr.Logger, cr *onapv1alpha1.CollectdGlobal) error {
+ // Cleanup by regenerating new collectd conf and rolling update of DaemonSet
+ if err := r.handleCollectdGlobal(reqLogger, cr, true); err != nil {
+ reqLogger.Error(err, "Finalize CollectdGlobal failed!!")
+ return err
+ }
+ reqLogger.Info("Successfully finalized CollectdGlobal!!")
+ return nil
+}
+
+func (r *ReconcileCollectdGlobal) addFinalizer(reqLogger logr.Logger, cr *onapv1alpha1.CollectdGlobal) error {
+ reqLogger.Info("Adding Finalizer for the CollectdGlobal")
+ cr.SetFinalizers(append(cr.GetFinalizers(), collectdutils.CollectdFinalizer))
+ // Update status from Initial to Created
+ // Since addFinalizer will be executed only once,
+ // the status will be changed from Initial state to Created
+ updateErr := r.updateStatus(cr)
+ if updateErr != nil {
+ reqLogger.Error(updateErr, "Failed to update status from Initial state")
+ }
+ // Update CR
+ err := r.client.Update(context.TODO(), cr)
+ if err != nil {
+ reqLogger.Error(err, "Failed to update CollectdGlobal with finalizer")
+ return err
+ }
+ return nil
+}
+
+func (r *ReconcileCollectdGlobal) handleAdditonalConfigMap(reqLogger logr.Logger, cr *onapv1alpha1.CollectdGlobal, ds *extensionsv1beta1.DaemonSet) error {
+ cm := &corev1.ConfigMap{}
+ key := types.NamespacedName{Namespace: cr.Namespace, Name: cr.Spec.ConfigMap}
+ err := r.client.Get(context.TODO(), key, cm)
+ if err != nil {
+ reqLogger.Info("Error getting TypesDB")
+ return nil
+ }
+ // TODO: Implement Types.DB mounting
+ return nil
+}
import (
"context"
- "crypto/sha256"
"fmt"
- "os"
"reflect"
"strings"
"github.com/go-logr/logr"
onapv1alpha1 "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1"
+ collectdutils "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/controller/utils"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
var log = logf.Log.WithName("controller_collectdplugin")
-// ResourceMap to hold objects to update/reload
-type ResourceMap struct {
- configMap *corev1.ConfigMap
- daemonSet *extensionsv1beta1.DaemonSet
- collectdPlugins *[]onapv1alpha1.CollectdPlugin
-}
-
-/**
-* USER ACTION REQUIRED: This is a scaffold file intended for the user to modify with their own Controller
-* business logic. Delete these comments after modifying this file.*
- */
// Add creates a new CollectdPlugin Controller and adds it to the Manager. The Manager will set fields on the Controller
// and Start it when the Manager is Started.
&source.Kind{Type: &appsv1.DaemonSet{}},
&handler.EnqueueRequestsFromMapFunc{
ToRequests: handler.ToRequestsFunc(func (a handler.MapObject) []reconcile.Request {
- labelSelector, err := getWatchLabels()
+ labelSelector, err := collectdutils.GetWatchLabels()
labels := strings.Split(labelSelector, "=")
if err != nil {
log.Error(err, "Failed to get watch labels, continuing with default label")
// Select the Daemonset with labelSelector (Defautl is app=collectd)
if a.Meta.GetLabels()[labels[0]] == labels[1] {
var requests []reconcile.Request
- cpList, err := rcp.getCollectdPluginList(a.Meta.GetNamespace())
+ cpList, err := collectdutils.GetCollectdPluginList(rcp.client, a.Meta.GetNamespace())
if err != nil {
return nil
}
scheme *runtime.Scheme
}
-// Define the collectdPlugin finalizer for handling deletion
-const (
- defaultWatchLabel = "app=collectd"
- collectdPluginFinalizer = "finalizer.collectdplugin.onap.org"
-
- // WatchLabelsEnvVar is the constant for env variable WATCH_LABELS
- // which is the labels where the watch activity happens.
- // this value is empty if the operator is running with clusterScope.
- WatchLabelsEnvVar = "WATCH_LABELS"
-)
// Reconcile reads that state of the cluster for a CollectdPlugin object and makes changes based on the state read
// and what is in the CollectdPlugin.Spec
}
// Add finalizer for this CR
- if !contains(instance.GetFinalizers(), collectdPluginFinalizer) {
+ if !collectdutils.Contains(instance.GetFinalizers(), collectdutils.CollectdFinalizer) {
if err := r.addFinalizer(reqLogger, instance); err != nil {
return reconcile.Result{}, err
}
// handleCollectdPlugin regenerates the collectd conf on CR Create, Update, Delete events
func (r *ReconcileCollectdPlugin) handleCollectdPlugin(reqLogger logr.Logger, cr *onapv1alpha1.CollectdPlugin, isDelete bool) error {
- rmap, err := r.findResourceMapForCR(reqLogger, cr)
+ rmap, err := collectdutils.FindResourceMapForCR(r.client, reqLogger, cr.Namespace)
if err != nil {
reqLogger.Error(err, "Skip reconcile: Resources not found")
return err
}
- cm := rmap.configMap
- collectPlugins := rmap.collectdPlugins
+ cm := rmap.ConfigMap
reqLogger.V(1).Info("Found ResourceMap")
reqLogger.V(1).Info(":::: ConfigMap Info ::::", "ConfigMap.Namespace", cm.Namespace, "ConfigMap.Name", cm.Name)
- collectdConf, err := rebuildCollectdConf(cr, collectPlugins, isDelete)
+ collectdConf, err := collectdutils.RebuildCollectdConf(r.client, cr.Namespace, isDelete, cr.Spec.PluginName)
+ if err != nil {
+ reqLogger.Error(err, "Skip reconcile: Rebuild conf failed")
+ return err
+ }
cm.SetAnnotations(map[string]string{
- "daaas-random": ComputeSHA256([]byte(collectdConf)),
+ "daaas-random": collectdutils.ComputeSHA256([]byte(collectdConf)),
})
- cm.Data["node-collectd.conf"] = collectdConf
+ cm.Data["collectd.conf"] = collectdConf
// Update the ConfigMap with new Spec and reload DaemonSets
reqLogger.Info("Updating the ConfigMap", "ConfigMap.Namespace", cm.Namespace, "ConfigMap.Name", cm.Name)
// Select DaemonSets with label
dsList := &extensionsv1beta1.DaemonSetList{}
opts := &client.ListOptions{}
- labelSelector, err := getWatchLabels()
+ labelSelector, err := collectdutils.GetWatchLabels()
if err != nil {
reqLogger.Error(err, "Failed to get watch labels, continuing with default label")
}
reqLogger.Info("Reloading the Daemonset", "DaemonSet.Namespace", ds.Namespace, "DaemonSet.Name", ds.Name)
//Restart only if hash of conf has changed.
ds.Spec.Template.SetAnnotations(map[string]string{
- "daaas-random": ComputeSHA256([]byte(collectdConf)),
+ "daaas-random": collectdutils.ComputeSHA256([]byte(collectdConf)),
})
updateErr := r.client.Update(context.TODO(), ds)
return updateErr
return nil
}
-// ComputeSHA256 returns hash of data as string
-func ComputeSHA256(data []byte) string {
- hash := sha256.Sum256(data)
- return fmt.Sprintf("%x", hash)
-}
-
-// findResourceMapForCR returns the configMap, collectd Daemonset and list of Collectd Plugins
-func (r *ReconcileCollectdPlugin) findResourceMapForCR(reqLogger logr.Logger, cr *onapv1alpha1.CollectdPlugin) (ResourceMap, error) {
- cmList := &corev1.ConfigMapList{}
- opts := &client.ListOptions{}
- rmap := ResourceMap{}
-
- // Select ConfigMaps with label
- labelSelector, err := getWatchLabels()
- if err != nil {
- reqLogger.Error(err, "Failed to get watch labels, continuing with default label")
- }
- opts.SetLabelSelector(labelSelector)
- opts.InNamespace(cr.Namespace)
-
- err = r.client.List(context.TODO(), opts, cmList)
- if err != nil {
- return rmap, err
- }
-
- if cmList.Items == nil || len(cmList.Items) == 0 {
- return rmap, errors.NewNotFound(corev1.Resource("configmap"), "ConfigMap")
- }
-
- // Select DaemonSets with label
- dsList := &extensionsv1beta1.DaemonSetList{}
- err = r.client.List(context.TODO(), opts, dsList)
- if err != nil {
- return rmap, err
- }
-
- if dsList.Items == nil || len(dsList.Items) == 0 {
- return rmap, errors.NewNotFound(corev1.Resource("daemonset"), "DaemonSet")
- }
-
- // Get all collectd plugins in the current namespace to rebuild conf.
- cpList, err := r.getCollectdPluginList(cr.Namespace)
- if err != nil {
- return rmap, err
- }
-
- rmap.configMap = &cmList.Items[0]
- rmap.daemonSet = &dsList.Items[0]
- rmap.collectdPlugins = &cpList.Items //will be nil if no plugins exist
- return rmap, err
-}
-
-// Get all collectd plugins and reconstruct, compute Hash and check for changes
-func rebuildCollectdConf(cr *onapv1alpha1.CollectdPlugin, cpList *[]onapv1alpha1.CollectdPlugin, isDelete bool) (string, error) {
- var collectdConf string
- if *cpList == nil || len(*cpList) == 0 {
- return "", errors.NewNotFound(corev1.Resource("collectdplugin"), "CollectdPlugin")
- }
- loadPlugin := make(map[string]string)
- for _, cp := range *cpList {
- if cp.Spec.PluginName == "global" {
- collectdConf += cp.Spec.PluginConf + "\n"
- } else {
- loadPlugin[cp.Spec.PluginName] = cp.Spec.PluginConf
- }
- }
-
- if isDelete {
- delete(loadPlugin, cr.Spec.PluginName)
- }
-
- log.V(1).Info("::::::: Plugins Map ::::::: ", "PluginMap ", loadPlugin)
-
- for cpName, cpConf := range loadPlugin {
- collectdConf += "LoadPlugin" + " " + cpName + "\n"
- collectdConf += cpConf + "\n"
- }
-
- collectdConf += "#Last line (collectd requires ‘\\n’ at the last line)\n"
-
- return collectdConf, nil
-}
-
// Handle Delete CR event for additional cleanup
func (r *ReconcileCollectdPlugin) handleDelete(reqLogger logr.Logger, cr *onapv1alpha1.CollectdPlugin) (bool, error) {
// Check if the CollectdPlugin instance is marked to be deleted, which is
cr.Status.CollectdAgents = nil
_ = r.client.Status().Update(context.TODO(), cr)
- if contains(cr.GetFinalizers(), collectdPluginFinalizer) {
+ if collectdutils.Contains(cr.GetFinalizers(), collectdutils.CollectdFinalizer) {
// Run finalization logic for collectdPluginFinalizer. If the
// finalization logic fails, don't remove the finalizer so
// that we can retry during the next reconciliation.
// Remove collectdPluginFinalizer. Once all finalizers have been
// removed, the object will be deleted.
- cr.SetFinalizers(remove(cr.GetFinalizers(), collectdPluginFinalizer))
+ cr.SetFinalizers(collectdutils.Remove(cr.GetFinalizers(), collectdutils.CollectdFinalizer))
err := r.client.Update(context.TODO(), cr)
if err != nil {
return isMarkedToBeDeleted, err
case onapv1alpha1.Initial:
cr.Status.Status = onapv1alpha1.Created
case onapv1alpha1.Created, onapv1alpha1.Enabled:
- pods, err := r.getPodList(cr.Namespace)
+ pods, err := collectdutils.GetPodList(r.client, cr.Namespace)
if err != nil {
return err
}
func (r *ReconcileCollectdPlugin) addFinalizer(reqLogger logr.Logger, cr *onapv1alpha1.CollectdPlugin) error {
reqLogger.Info("Adding Finalizer for the CollectdPlugin")
- cr.SetFinalizers(append(cr.GetFinalizers(), collectdPluginFinalizer))
+ cr.SetFinalizers(append(cr.GetFinalizers(), collectdutils.CollectdFinalizer))
// Update status from Initial to Created
// Since addFinalizer will be executed only once,
// the status will be changed from Initial state to Created
}
return nil
}
-
-func contains(list []string, s string) bool {
- for _, v := range list {
- if v == s {
- return true
- }
- }
- return false
-}
-
-func remove(list []string, s string) []string {
- for i, v := range list {
- if v == s {
- list = append(list[:i], list[i+1:]...)
- }
- }
- return list
-}
-
-// getWatchLabels returns the labels the operator should be watching for changes
-func getWatchLabels() (string, error) {
- labelSelector, found := os.LookupEnv(WatchLabelsEnvVar)
- if !found {
- return defaultWatchLabel, fmt.Errorf("%s must be set", WatchLabelsEnvVar)
- }
- return labelSelector, nil
-}
-
-func (r *ReconcileCollectdPlugin) getPodList(ns string) ([]string, error) {
- var pods []string
- podList := &corev1.PodList{}
- opts := &client.ListOptions{}
- // Select ConfigMaps with label
- labelSelector, _ := getWatchLabels()
- opts.SetLabelSelector(labelSelector)
- opts.InNamespace(ns)
- err := r.client.List(context.TODO(), opts, podList)
- if err != nil {
- return nil, err
- }
-
- if podList.Items == nil || len(podList.Items) == 0 {
- return nil, err
- }
-
- for _, pod := range podList.Items {
- pods = append(pods, pod.Name)
- }
- return pods, nil
-}
-
-func (r *ReconcileCollectdPlugin) getCollectdPluginList(ns string) (*onapv1alpha1.CollectdPluginList, error) {
- // Get all collectd plugins in the current namespace to rebuild conf.
- collectdPlugins := &onapv1alpha1.CollectdPluginList{}
- cpOpts := &client.ListOptions{}
- cpOpts.InNamespace(ns)
- err := r.client.List(context.TODO(), cpOpts, collectdPlugins)
- if err != nil {
- return nil, err
- }
- return collectdPlugins, nil
-}
--- /dev/null
+package utils
+
+import (
+ "context"
+ "crypto/sha256"
+ "fmt"
+ "os"
+ "sync"
+
+ "github.com/go-logr/logr"
+
+ onapv1alpha1 "demo/vnfs/DAaaS/microservices/collectd-operator/pkg/apis/onap/v1alpha1"
+
+ corev1 "k8s.io/api/core/v1"
+ extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
+ "k8s.io/apimachinery/pkg/api/errors"
+ "sigs.k8s.io/controller-runtime/pkg/client"
+)
+
+// Define the collectdPlugin finalizer for handling deletion
+const (
+ defaultWatchLabel = "app=collectd"
+ CollectdFinalizer = "finalizer.collectd.onap.org"
+
+ // WatchLabelsEnvVar is the constant for env variable WATCH_LABELS
+ // which is the labels where the watch activity happens.
+ // this value is empty if the operator is running with clusterScope.
+ WatchLabelsEnvVar = "WATCH_LABELS"
+)
+
+var lock sync.Mutex
+
+// ResourceMap to hold objects to update/reload
+type ResourceMap struct {
+ ConfigMap *corev1.ConfigMap
+ DaemonSet *extensionsv1beta1.DaemonSet
+ CollectdPlugins *[]onapv1alpha1.CollectdPlugin
+}
+
+// ComputeSHA256 returns hash of data as string
+func ComputeSHA256(data []byte) string {
+ hash := sha256.Sum256(data)
+ return fmt.Sprintf("%x", hash)
+}
+
+// Contains checks if a string is contained in a list of strings
+func Contains(list []string, s string) bool {
+ for _, v := range list {
+ if v == s {
+ return true
+ }
+ }
+ return false
+}
+
+// Remove removes a string from a list of string
+func Remove(list []string, s string) []string {
+ for i, v := range list {
+ if v == s {
+ list = append(list[:i], list[i+1:]...)
+ }
+ }
+ return list
+}
+
+// GetWatchLabels returns the labels the operator should be watching for changes
+func GetWatchLabels() (string, error) {
+ labelSelector, found := os.LookupEnv(WatchLabelsEnvVar)
+ if !found {
+ return defaultWatchLabel, fmt.Errorf("%s must be set", WatchLabelsEnvVar)
+ }
+ return labelSelector, nil
+}
+
+// FindResourceMapForCR returns the configMap, collectd Daemonset and list of Collectd Plugins
+func FindResourceMapForCR(rc client.Client, reqLogger logr.Logger, ns string) (*ResourceMap, error) {
+ lock.Lock()
+ defer lock.Unlock()
+ cmList := &corev1.ConfigMapList{}
+ opts := &client.ListOptions{}
+ rmap := &ResourceMap{}
+
+ // Select ConfigMaps with label
+ labelSelector, err := GetWatchLabels()
+ if err != nil {
+ reqLogger.Error(err, "Failed to get watch labels, continuing with default label")
+ }
+ opts.SetLabelSelector(labelSelector)
+ opts.InNamespace(ns)
+
+ err = rc.List(context.TODO(), opts, cmList)
+ if err != nil {
+ return rmap, err
+ }
+
+ if cmList.Items == nil || len(cmList.Items) == 0 {
+ return rmap, errors.NewNotFound(corev1.Resource("configmap"), "ConfigMap")
+ }
+
+ // Select DaemonSets with label
+ dsList := &extensionsv1beta1.DaemonSetList{}
+ err = rc.List(context.TODO(), opts, dsList)
+ if err != nil {
+ return rmap, err
+ }
+
+ if dsList.Items == nil || len(dsList.Items) == 0 {
+ return rmap, errors.NewNotFound(corev1.Resource("daemonset"), "DaemonSet")
+ }
+
+ rmap.ConfigMap = &cmList.Items[0]
+ rmap.DaemonSet = &dsList.Items[0]
+
+ return rmap, err
+}
+
+// GetCollectdPluginList returns the list of CollectdPlugin instances in the namespace ns
+func GetCollectdPluginList(rc client.Client, ns string) (*onapv1alpha1.CollectdPluginList, error) {
+ // Get all collectd plugins in the current namespace to rebuild conf.
+ collectdPlugins := &onapv1alpha1.CollectdPluginList{}
+ cpOpts := &client.ListOptions{}
+ cpOpts.InNamespace(ns)
+ err := rc.List(context.TODO(), cpOpts, collectdPlugins)
+ if err != nil {
+ return nil, err
+ }
+ return collectdPlugins, nil
+}
+
+// GetCollectdGlobal returns the CollectdGlobal instance in the namespace ns
+func GetCollectdGlobal(rc client.Client, ns string) (*onapv1alpha1.CollectdGlobal, error) {
+ // Get the CollectdGlobal instance in current namespace to rebuild conf.
+ cgList := &onapv1alpha1.CollectdGlobalList{}
+ cpOpts := &client.ListOptions{}
+ cpOpts.InNamespace(ns)
+ err := rc.List(context.TODO(), cpOpts, cgList)
+ if err != nil {
+ return nil, err
+ }
+ if cgList.Items == nil || len(cgList.Items) == 0 {
+ return nil, err
+ }
+ collectdGlobals := &cgList.Items[0]
+ return collectdGlobals, nil
+}
+
+// GetPodList returns the list of pods in the namespace ns
+func GetPodList(rc client.Client, ns string) ([]string, error) {
+ var pods []string
+ podList := &corev1.PodList{}
+ opts := &client.ListOptions{}
+ // Select ConfigMaps with label
+ labelSelector, _ := GetWatchLabels()
+ opts.SetLabelSelector(labelSelector)
+ opts.InNamespace(ns)
+ err := rc.List(context.TODO(), opts, podList)
+ if err != nil {
+ return nil, err
+ }
+
+ if podList.Items == nil || len(podList.Items) == 0 {
+ return nil, err
+ }
+
+ for _, pod := range podList.Items {
+ pods = append(pods, pod.Name)
+ }
+ return pods, nil
+}
+
+// RebuildCollectdConf Get all collectd plugins and reconstruct, compute Hash and check for changes
+func RebuildCollectdConf(rc client.Client, ns string, isDelete bool, delPlugin string) (string, error) {
+ var collectdConf, collectdGlobalConf string
+ // Get the collectd global in the current namespace to rebuild conf.
+ cg, err := GetCollectdGlobal(rc, ns)
+ if err != nil {
+ return "", err
+ }
+
+ if cg != nil {
+ collectdGlobalConf += cg.Spec.GlobalOptions + "\n"
+ }
+
+ // Get all collectd plugins in the current namespace to rebuild conf.
+ cp, err := GetCollectdPluginList(rc, ns)
+ if err != nil {
+ return "", err
+ }
+ cpList := &cp.Items
+ loadPlugin := make(map[string]string)
+ if *cpList != nil && len(*cpList) > 0 {
+ for _, cp := range *cpList {
+ // using CollectdPlugin to set global options. If CollectdGlobal CRD is defined do not check for this
+ if cp.Spec.PluginName == "global" {
+ if cg == nil {
+ collectdGlobalConf += cp.Spec.PluginConf + "\n"
+ }
+ } else {
+ loadPlugin[cp.Spec.PluginName] = cp.Spec.PluginConf
+ }
+ }
+ }
+
+ if isDelete {
+ delete(loadPlugin, delPlugin)
+ } else {
+ collectdConf += collectdGlobalConf
+ }
+
+ for cpName, cpConf := range loadPlugin {
+ collectdConf += "LoadPlugin" + " " + cpName + "\n"
+ collectdConf += cpConf + "\n"
+ }
+
+ collectdConf += "#Last line (collectd requires ‘\\n’ at the last line)\n"
+
+ return collectdConf, nil
+}
Code Review / demo.git / commitdiff