fix(CR status/updates/SDKConfigMap) : Doing fixes and refactoris in t…

…he code

pkg/apis/mobilesecurityservice/v1alpha1/mobilesecurityservice_types.go

@@ -54,6 +54,8 @@ type MobileSecurityServiceStatus struct {
 	DeploymentStatus v1beta1.DeploymentStatus `json:"deploymentStatus"`
 	ServiceName      string                   `json:"serviceName"`
 	ServiceStatus    v1.ServiceStatus         `json:"serviceStatus"`
+	ProxyServiceName      string              `json:"proxyServiceName"`
+	ProxyServiceStatus v1.ServiceStatus       `json:"proxyServiceStatus"`
 	RouteName        string                   `json:"routeName"`
 	RouteStatus      routev1.RouteStatus      `json:"routeStatus"`
 	AppStatus        string                   `json:"appStatus"`

pkg/controller/mobilesecurityservice/controller.go

@@ -88,31 +88,31 @@ type ReconcileMobileSecurityService struct {
 }
 
 //Update the factory object and requeue
-func (r *ReconcileMobileSecurityService) update(obj runtime.Object, reqLogger logr.Logger) (reconcile.Result, error) {
+func (r *ReconcileMobileSecurityService) update(obj runtime.Object, reqLogger logr.Logger) error {
 	err := r.client.Update(context.TODO(), obj)
 	if err != nil {
 		reqLogger.Error(err, "Failed to update Spec")
-		return reconcile.Result{}, err
+		return err
 	}
 	reqLogger.Info("Spec updated - return and create")
-	return reconcile.Result{Requeue: true}, nil
+	return nil
 }
 
 //Create the factory object and requeue
-func (r *ReconcileMobileSecurityService) create(instance *mobilesecurityservicev1alpha1.MobileSecurityService, reqLogger logr.Logger, kind string) (reconcile.Result, error) {
+func (r *ReconcileMobileSecurityService) create(instance *mobilesecurityservicev1alpha1.MobileSecurityService, reqLogger logr.Logger, kind string) error {
 	obj, err := r.buildFactory(reqLogger, instance, kind)
 	if err != nil {
-		return reconcile.Result{}, err
+		return err
 	}
 
 	reqLogger.Info("Creating a new ", "kind", kind, "Namespace", instance.Namespace)
 	err = r.client.Create(context.TODO(), obj)
 	if err != nil {
 		reqLogger.Error(err, "Failed to create new ", "kind", kind, "Namespace", instance.Namespace)
-		return reconcile.Result{}, err
+		return err
 	}
 	reqLogger.Info("Created successfully - return and create", "kind", kind, "Namespace", instance.Namespace)
-	return reconcile.Result{Requeue: true}, nil
+	return nil
 }
 
 // buildFactory will return the resource according to the resource defined
@@ -168,40 +168,61 @@ func (r *ReconcileMobileSecurityService) Reconcile(request reconcile.Request) (r
 
 	//Check specs
 	if !hasMandatorySpecs(instance, reqLogger) {
-		return reconcile.Result{Requeue: true}, nil
+		//Stop to reconcile since has not the mandatory specs
+		return reconcile.Result{}, nil
 	}
 
 	//Check if ConfigMap for the app exist, if not create one.
 	if _, err := r.fetchConfigMap(reqLogger, instance); err != nil {
-		return r.create(instance, reqLogger, CONFIGMAP)
+		if err := r.create(instance, reqLogger, CONFIGMAP) ; err != nil {
+			return reconcile.Result{}, err
+		}
+		return reconcile.Result{Requeue: true}, nil
 	}
 
 	//Check if Deployment for the app exist, if not create one
 	deployment, err := r.fetchDeployment(reqLogger, instance)
 	if err != nil {
-		return r.create(instance, reqLogger, DEEPLOYMENT)
+		if err := r.create(instance, reqLogger, DEEPLOYMENT) ; err != nil {
+			return reconcile.Result{}, err
+		}
+		return reconcile.Result{Requeue: true}, nil
 	}
 
 	reqLogger.Info("Ensuring the Mobile Security Service deployment size is the same as the spec")
 	size := instance.Spec.Size
 	if *deployment.Spec.Replicas != size {
+		//Set size of the deployment spec
 		deployment.Spec.Replicas = &size
-		return r.update(deployment, reqLogger)
+		if err := r.update(deployment, reqLogger) ; err != nil {
+			return reconcile.Result{}, err
+		}
+		return reconcile.Result{Requeue: true}, nil
 	}
 
 	//Check if Service for the app exist, if not create one
-	if _, err := r.fetchService(reqLogger, instance, utils.PROXY_SERVICE_INSTANCE_NAME); err != nil {
-		return r.create(instance, reqLogger, PROXY_SERVICE)
+	if _, err := r.fetchService(reqLogger, instance, utils.APPLICATION_SERVICE_INSTANCE_NAME); err != nil {
+		if err := r.create(instance, reqLogger, APPLICATION_SERVICE) ; err != nil {
+			return reconcile.Result{}, err
+		}
+		return reconcile.Result{Requeue: true}, nil
 	}
 
-	//Check if Service for the app exist, if not create one
-	if _, err := r.fetchService(reqLogger, instance, utils.APPLICATION_SERVICE_INSTANCE_NAME); err != nil {
-		return r.create(instance, reqLogger, APPLICATION_SERVICE)
+	//Check if Proxy Service for the app exist, if not create one
+	if _, err := r.fetchService(reqLogger, instance, utils.PROXY_SERVICE_INSTANCE_NAME); err != nil {
+		if err := r.create(instance, reqLogger, PROXY_SERVICE) ; err != nil {
+			return reconcile.Result{}, err
+		}
+		return reconcile.Result{Requeue: true}, nil
 	}
 
+
 	//Check if Route for the Service exist, if not create one
 	if _, err := r.fetchRoute(reqLogger, instance); err != nil {
-		return r.create(instance, reqLogger, ROUTE)
+		if err := r.create(instance, reqLogger, ROUTE) ; err != nil {
+			return reconcile.Result{}, err
+		}
+		return reconcile.Result{Requeue: true}, nil
 	}
 
 	//Update status for ConfigMap
@@ -217,12 +238,12 @@ func (r *ReconcileMobileSecurityService) Reconcile(request reconcile.Request) (r
 	}
 
 	//Update status for Proxy Service
-	proxyServiceStatus, err := r.updateServiceStatus(reqLogger, request, utils.PROXY_SERVICE_INSTANCE_NAME)
+	proxyServiceStatus, err := r.updateProxyServiceStatus(reqLogger, request)
 	if err != nil {
 		return reconcile.Result{}, err
 	}
 
-	applicationServiceStatus, err := r.updateServiceStatus(reqLogger, request, utils.APPLICATION_SERVICE_INSTANCE_NAME)
+	applicationServiceStatus, err := r.updateAppServiceStatus(reqLogger, request)
 	if err != nil {
 		return reconcile.Result{}, err
 	}