[Cherry pick for 1.2.2] (#59)

* (fix) Added name of the runner Pod in ChaosEngine Events (#56)

Signed-off-by: Rahul M Chheda <rahul.chheda@mayadata.io>

* (feat) Added support for AdminMode (#45)

* (feat) Added support for AdminMode
    - Replaced EngineDetails.AppNamespace to EngineDetails.EngineNamespace
    - Added logic to check for resources in chaosEngine namespace
    - Only job will be created in AppNamespace (experiment.Namespace)
    - Synced the experiment.Namespace = engineDetails.EngineNamespace, when AdminMode is true
    - Added OS ENV as ENGINE_NAMESPACE passed from operator, into engineDetails struct
* Sycned experiment.Namespace and engineDetails.EngineNamespace

Signed-off-by: Rahul M Chheda <rahul.chheda@mayadata.io>

* refcator(chaos_ns): Rename Engine_NAMESPACE to CHAOS_NAMESPACE (#57)

Signed-off-by: shubhamchaudhary <shubham.chaudhary@mayadata.io>

Co-authored-by: Shubham Chaudhary <shubham.chaudhary@mayadata.io>

Author: rahulchheda

bin/runner.go

@@ -18,7 +18,7 @@ func main() {
 	}
 	// Fetching all the ENV's needed
 	utils.GetOsEnv(&engineDetails)
-	klog.V(0).Infoln("Experiments List: ", engineDetails.Experiments, " ", "Engine Name: ", engineDetails.Name, " ", "appLabels : ", engineDetails.AppLabel, " ", "appNamespace: ", engineDetails.AppNamespace, " ", "appKind: ", engineDetails.AppKind, " ", "Service Account Name: ", engineDetails.SvcAccount)
+	klog.V(0).Infoln("Experiments List: ", engineDetails.Experiments, " ", "Engine Name: ", engineDetails.Name, " ", "appLabels : ", engineDetails.AppLabel, " ", "appKind: ", engineDetails.AppKind, " ", "Service Account Name: ", engineDetails.SvcAccount, "Engine Namespace: ", engineDetails.EngineNamespace)
 
 	recorder, err := utils.NewEventRecorder(clients, engineDetails)
 	if err != nil {
@@ -31,10 +31,12 @@ func main() {
 		if engineDetails.ClientUUID != "" {
 			analytics.TriggerAnalytics(engineDetails.Experiments[i], engineDetails.ClientUUID)
 		}
+
 		experiment := utils.NewExperimentDetails(&engineDetails, i)
 
 		if err := experiment.SetValueFromChaosResources(&engineDetails, clients); err != nil {
 			klog.V(0).Infof("Unable to set values from Chaos Resources due to error: %v", err)
+			recorder.ExperimentSkipped(engineDetails.Experiments[i], utils.ExperimentNotFoundErrorReason)
 		}
 
 		if err := experiment.SetENV(engineDetails, clients); err != nil {
@@ -50,12 +52,6 @@ func main() {
 
 		klog.V(0).Infof("Preparing to run Chaos Experiment: %v", experiment.Name)
 
-		if err := experiment.HandleChaosExperimentExistence(engineDetails, clients); err != nil {
-			klog.V(0).Infof("Unable to get ChaosExperiment Name: %v, in namespace: %v, due to error: %v", experiment.Name, experiment.Namespace, err)
-			recorder.ExperimentSkipped(engineDetails.Experiments[i], utils.ExperimentNotFoundErrorReason)
-			break
-		}
-
 		if err := experiment.PatchResources(engineDetails, clients); err != nil {
 			klog.V(0).Infof("Unable to patch Chaos Resources required for Chaos Experiment: %v, due to error: %v", experiment.Name, err)
 		}

pkg/utils/experimentHelpers.go

@@ -1,6 +1,8 @@
 package utils
 
 import (
+	"os"
+
 	"github.com/pkg/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/klog"
@@ -33,7 +35,7 @@ func (expDetails *ExperimentDetails) SetENV(engineDetails EngineDetails, clients
 		return err
 	}
 	// Store ENV in a map
-	ENVList := map[string]string{"CHAOSENGINE": engineDetails.Name, "APP_LABEL": engineDetails.AppLabel, "APP_NAMESPACE": engineDetails.AppNamespace, "APP_KIND": engineDetails.AppKind, "AUXILIARY_APPINFO": engineDetails.AuxiliaryAppInfo, "CHAOS_UID": engineDetails.UID}
+	ENVList := map[string]string{"CHAOSENGINE": engineDetails.Name, "APP_LABEL": engineDetails.AppLabel, "CHAOS_NAMESPACE": engineDetails.EngineNamespace, "APP_NAMESPACE": os.Getenv("APP_NAMESPACE"), "APP_KIND": engineDetails.AppKind, "AUXILIARY_APPINFO": engineDetails.AuxiliaryAppInfo, "CHAOS_UID": engineDetails.UID}
 	// Adding some addition ENV's from spec.AppInfo of ChaosEngine
 	for key, value := range ENVList {
 		expDetails.Env[key] = value
@@ -49,8 +51,8 @@ func NewExperimentDetails(engineDetails *EngineDetails, i int) *ExperimentDetail
 
 	// Initial set to values from EngineDetails Struct
 	experimentDetails.Name = engineDetails.Experiments[i]
-	experimentDetails.Namespace = engineDetails.AppNamespace
 	experimentDetails.SvcAccount = engineDetails.SvcAccount
+	experimentDetails.Namespace = os.Getenv("CHAOS_NAMESPACE")
 
 	// Generation of Random String for appending it into Job Name
 	randomString := RandomString()
@@ -65,7 +67,7 @@ func (expDetails *ExperimentDetails) HandleChaosExperimentExistence(engineDetail
 	_, err := clients.LitmusClient.LitmuschaosV1alpha1().ChaosExperiments(expDetails.Namespace).Get(expDetails.Name, metav1.GetOptions{})
 	if err != nil {
 		if err := engineDetails.ExperimentNotFoundPatchEngine(expDetails, clients); err != nil {
-			return errors.Wrapf(err, "Unable to patch Chaos Engine Name: %v, in namespace: %v, due to error: %v", engineDetails.Name, engineDetails.AppNamespace, err)
+			return errors.Wrapf(err, "Unable to patch Chaos Engine Name: %v, in namespace: %v, due to error: %v", engineDetails.Name, engineDetails.EngineNamespace, err)
 		}
 		return errors.Wrapf(err, "Unable to list Chaos Experiment Name: %v,in Namespace: %v, due to error: %v", expDetails.Name, expDetails.Namespace, err)
 	}
@@ -142,9 +144,15 @@ func (expDetails *ExperimentDetails) SetArgs(clients ClientSets) error {
 
 // SetValueFromChaosResources fetchs required values from various Chaos Resources
 func (expDetails *ExperimentDetails) SetValueFromChaosResources(engineDetails *EngineDetails, clients ClientSets) error {
+	if err := expDetails.SetValueFromChaosEngine(engineDetails, clients); err != nil {
+		return errors.Wrapf(err, "Unable to set value from Chaos Engine due to error: %v", err)
+	}
+
 	if err := engineDetails.SetValueFromChaosRunner(clients); err != nil {
 		return errors.Wrapf(err, "Unable to set value from Chaos Runner due to error: %v", err)
-
+	}
+	if err := expDetails.HandleChaosExperimentExistence(*engineDetails, clients); err != nil {
+		return errors.Wrapf(err, "Unable to get ChaosExperiment Name: %v, in namespace: %v, due to error: %v", expDetails.Name, expDetails.Namespace, err)
 	}
 	if err := expDetails.SetValueFromChaosExperiment(clients, engineDetails); err != nil {
 		return errors.Wrapf(err, "Unable to set value from Chaos Experiment due to error: %v", err)
@@ -155,9 +163,9 @@ func (expDetails *ExperimentDetails) SetValueFromChaosResources(engineDetails *E
 // SetValueFromChaosRunner fetch the engineUID from ChaosRunner
 func (engine *EngineDetails) SetValueFromChaosRunner(clients ClientSets) error {
 	runnerName := engine.Name + "-runner"
-	runnerSpec, err := clients.KubeClient.CoreV1().Pods(engine.AppNamespace).Get(runnerName, metav1.GetOptions{})
+	runnerSpec, err := clients.KubeClient.CoreV1().Pods(engine.EngineNamespace).Get(runnerName, metav1.GetOptions{})
 	if err != nil {
-		return errors.Wrapf(err, "Unable to get runner pod in namespace: %v", engine.AppNamespace)
+		return errors.Wrapf(err, "Unable to get runner pod in namespace: %v", engine.EngineNamespace)
 	}
 	chaosUID := runnerSpec.Labels["chaosUID"]
 	if chaosUID != "" {
@@ -167,3 +175,13 @@ func (engine *EngineDetails) SetValueFromChaosRunner(clients ClientSets) error {
 	}
 	return nil
 }
+
+func (expDetails *ExperimentDetails) SetValueFromChaosEngine(engine *EngineDetails, clients ClientSets) error {
+
+	chaosEngine, err := engine.GetChaosEngine(clients)
+	if err != nil {
+		return errors.Wrapf(err, "Unable to get chaosEngine in namespace: %s", engine.EngineNamespace)
+	}
+	expDetails.Namespace = chaosEngine.Namespace
+	return nil
+}

pkg/utils/getOSenv.go

@@ -10,10 +10,16 @@ func GetOsEnv(engineDetails *EngineDetails) {
 	experimentList := os.Getenv("EXPERIMENT_LIST")
 	engineDetails.Name = os.Getenv("CHAOSENGINE")
 	engineDetails.AppLabel = os.Getenv("APP_LABEL")
-	engineDetails.AppNamespace = os.Getenv("APP_NAMESPACE")
+	engineDetails.EngineNamespace = os.Getenv("CHAOS_NAMESPACE")
 	engineDetails.AppKind = os.Getenv("APP_KIND")
 	engineDetails.SvcAccount = os.Getenv("CHAOS_SVC_ACC")
 	engineDetails.ClientUUID = os.Getenv("CLIENT_UUID")
 	engineDetails.Experiments = strings.Split(experimentList, ",")
 	engineDetails.AuxiliaryAppInfo = os.Getenv("AUXILIARY_APPINFO")
+
+	//TODO: Use engineDetails.AdminMode, to change behaviour of chaos-runner
+	// engineDetails.AdminMode = false
+	// if os.Getenv("ADMIN_MODE") == "true" {
+	// 	engineDetails.AdminMode = true
+	// }
 }

pkg/utils/initialPatchEngine.go

@@ -18,9 +18,9 @@ func (expStatus *ExperimentStatus) InitialPatchEngine(engineDetails EngineDetail
 			return errors.Wrapf(err, "Unable to get ChaosEngine, due to error: %v", err)
 		}
 		expEngine.Status.Experiments = append(expEngine.Status.Experiments, v1alpha1.ExperimentStatuses(*expStatus))
-		_, updateErr := clients.LitmusClient.LitmuschaosV1alpha1().ChaosEngines(engineDetails.AppNamespace).Update(expEngine)
+		_, updateErr := clients.LitmusClient.LitmuschaosV1alpha1().ChaosEngines(engineDetails.EngineNamespace).Update(expEngine)
 		if updateErr != nil {
-			return errors.Wrapf(err, "Unable to update ChaosEngine in namespace: %v, due to error: %v", engineDetails.AppNamespace, err)
+			return errors.Wrapf(err, "Unable to update ChaosEngine in namespace: %v, due to error: %v", engineDetails.EngineNamespace, err)
 		}
 	}
 	return nil

pkg/utils/recorder.go

@@ -11,14 +11,14 @@ import (
 	litmuschaosScheme "github.com/litmuschaos/chaos-operator/pkg/client/clientset/versioned/scheme"
 )
 
-func generateEventRecorder(kubeClient *kubernetes.Clientset) (record.EventRecorder, error) {
+func generateEventRecorder(kubeClient *kubernetes.Clientset, componentName string) (record.EventRecorder, error) {
 	err := litmuschaosScheme.AddToScheme(scheme.Scheme)
 	if err != nil {
 		return nil, err
 	}
 	eventBroadcaster := record.NewBroadcaster()
 	eventBroadcaster.StartRecordingToSink(&typedcorev1.EventSinkImpl{Interface: kubeClient.CoreV1().Events("")})
-	recorder := eventBroadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: "chaos-runner"})
+	recorder := eventBroadcaster.NewRecorder(scheme.Scheme, corev1.EventSource{Component: componentName})
 	return recorder, nil
 }
 
@@ -28,7 +28,7 @@ func NewEventRecorder(clients ClientSets, engineDetails EngineDetails) (*Recorde
 	if err != nil {
 		return &Recorder{}, err
 	}
-	eventBroadCaster, err := generateEventRecorder(clients.KubeClient)
+	eventBroadCaster, err := generateEventRecorder(clients.KubeClient, engineDetails.Name+"-runner")
 	if err != nil {
 		return &Recorder{}, err
 	}

pkg/utils/types.go

@@ -24,10 +24,10 @@ type EngineDetails struct {
 	AppLabel         string
 	SvcAccount       string
 	AppKind          string
-	AppNamespace     string
 	ClientUUID       string
 	AuxiliaryAppInfo string
 	UID              string
+	EngineNamespace  string
 }
 
 // ExperimentDetails is for collecting all the experiment-related details

pkg/utils/watchJob.go

@@ -37,10 +37,10 @@ func GetJobStatus(experimentDetails *ExperimentDetails, clients ClientSets) (int
 
 // GetChaosEngine returns chaosEngine Object
 func (engineDetails EngineDetails) GetChaosEngine(clients ClientSets) (*v1alpha1.ChaosEngine, error) {
-	expEngine, err := clients.LitmusClient.LitmuschaosV1alpha1().ChaosEngines(engineDetails.AppNamespace).Get(engineDetails.Name, metav1.GetOptions{})
+	expEngine, err := clients.LitmusClient.LitmuschaosV1alpha1().ChaosEngines(engineDetails.EngineNamespace).Get(engineDetails.Name, metav1.GetOptions{})
 	if err != nil {
 
-		return nil, errors.Wrapf(err, "Unable to get ChaosEngine Name: %v, in namespace: %v, due to error: %v", engineDetails.Name, engineDetails.AppNamespace, err)
+		return nil, errors.Wrapf(err, "Unable to get ChaosEngine Name: %v, in namespace: %v, due to error: %v", engineDetails.Name, engineDetails.EngineNamespace, err)
 	}
 	return expEngine, nil
 }
@@ -57,7 +57,7 @@ func (expStatus *ExperimentStatus) PatchChaosEngineStatus(engineDetails EngineDe
 		return errors.Wrapf(err, "Unable to find the status for JobName: %v in ChaosEngine: %v", expStatus.Name, expEngine.Name)
 	}
 	expEngine.Status.Experiments[jobIndex] = v1alpha1.ExperimentStatuses(*expStatus)
-	if _, err := clients.LitmusClient.LitmuschaosV1alpha1().ChaosEngines(engineDetails.AppNamespace).Update(expEngine); err != nil {
+	if _, err := clients.LitmusClient.LitmuschaosV1alpha1().ChaosEngines(engineDetails.EngineNamespace).Update(expEngine); err != nil {
 		return err
 	}
 	return nil
@@ -78,7 +78,7 @@ func (engineDetails EngineDetails) WatchJobForCompletion(experiment *ExperimentD
 		var expStatus ExperimentStatus
 		expStatus.AwaitedExperimentStatus(experiment)
 		if err := expStatus.PatchChaosEngineStatus(engineDetails, clients); err != nil {
-			return errors.Wrapf(err, "Unable to patch ChaosEngine in namespace: %v, due to error: %v", engineDetails.AppNamespace, err)
+			return errors.Wrapf(err, "Unable to patch ChaosEngine in namespace: %v, due to error: %v", engineDetails.EngineNamespace, err)
 		}
 		time.Sleep(5 * time.Second)
 
@@ -96,9 +96,9 @@ func GetResultName(engineName string, experimentName string) string {
 func (experimentDetails *ExperimentDetails) GetChaosResult(engineDetails EngineDetails, clients ClientSets) (*v1alpha1.ChaosResult, error) {
 
 	resultName := GetResultName(engineDetails.Name, experimentDetails.Name)
-	expResult, err := clients.LitmusClient.LitmuschaosV1alpha1().ChaosResults(engineDetails.AppNamespace).Get(resultName, metav1.GetOptions{})
+	expResult, err := clients.LitmusClient.LitmuschaosV1alpha1().ChaosResults(engineDetails.EngineNamespace).Get(resultName, metav1.GetOptions{})
 	if err != nil {
-		return nil, errors.Wrapf(err, "Unable to get ChaosResult Name: %v in namespace: %v, due to error: %v", resultName, engineDetails.AppNamespace, err)
+		return nil, errors.Wrapf(err, "Unable to get ChaosResult Name: %v in namespace: %v, due to error: %v", resultName, engineDetails.EngineNamespace, err)
 	}
 	return expResult, nil
 }
@@ -133,7 +133,7 @@ func (engineDetails EngineDetails) DeleteJobAccordingToJobCleanUpPolicy(experime
 		klog.V(0).Infoln("Will delete the job as jobCleanPolicy is set to : " + expEngine.Spec.JobCleanUpPolicy)
 
 		deletePolicy := metav1.DeletePropagationForeground
-		deleteJob := clients.KubeClient.BatchV1().Jobs(engineDetails.AppNamespace).Delete(experiment.JobName, &metav1.DeleteOptions{
+		deleteJob := clients.KubeClient.BatchV1().Jobs(experiment.Namespace).Delete(experiment.JobName, &metav1.DeleteOptions{
 			PropagationPolicy: &deletePolicy,
 		})
 		if deleteJob != nil {