feat: aviator service 함수 연동

Author: 희승

internal/controller/provision_controller.go

@@ -18,6 +18,8 @@ package controller
 
 import (
 	"context"
+	"fmt"
+
 	"github.com/go-logr/logr"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -26,11 +28,12 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/log"
 
 	ncputil "github.com/cloud-club/Aviator-service/pkg"
+	server "github.com/cloud-club/Aviator-service/types/server"
 
 	vmv1 "vm.cloudclub.io/api/v1"
 )
 
-var provisionReconcileMap map[string]func(*ProvisionReconciler, logr.Logger, string, interface{}) error
+var provisionReconcileMap map[string]func(*ProvisionReconciler, logr.Logger, string, *vmv1.Provision, interface{}) error
 
 // ProvisionReconciler reconciles a Provision object
 type ProvisionReconciler struct {
@@ -42,8 +45,8 @@ type ProvisionReconciler struct {
 func NewProvisionReconciler(
 	client client.Client,
 	scheme *runtime.Scheme,
-	ncpService *ncputil.NcpService) *ProvisionReconciler {
-
+	ncpService *ncputil.NcpService,
+) *ProvisionReconciler {
 	initProvisionReconcileMap()
 	return &ProvisionReconciler{
 		Client:     client,
@@ -53,7 +56,7 @@ func NewProvisionReconciler(
 }
 
 func initProvisionReconcileMap() {
-	provisionReconcileMap = make(map[string]func(*ProvisionReconciler, logr.Logger, string, interface{}) error)
+	provisionReconcileMap = make(map[string]func(*ProvisionReconciler, logr.Logger, string, *vmv1.Provision, interface{}) error)
 	provisionReconcileMap["provision"] = provision
 	provisionReconcileMap["deProvision"] = deProvision
 	provisionReconcileMap["update"] = update
@@ -89,45 +92,45 @@ func (r *ProvisionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (
 		return ctrl.Result{}, err
 	}
 
-	switch original.Status.Phase {
+	switch original.Spec.Phase {
 	case "", vmv1.ProvisionPhaseCreate:
 		if v, ok := provisionReconcileMap["provision"]; ok {
-			if err = v(r, log, apiUrlCreate, nil); err != nil {
+			if err = v(r, log, apiUrlCreate, original, nil); err != nil {
 				log.Error(err, "Failed to create VM")
 				return ctrl.Result{}, err
 			}
 		}
 	case vmv1.ProvisionPhaseUpdate:
 		if v, ok := provisionReconcileMap["update"]; ok {
-			if err = v(r, log, apiUrlUpdate, nil); err != nil {
+			if err = v(r, log, apiUrlUpdate, original, nil); err != nil {
 				log.Error(err, "Failed to update VM")
 				return ctrl.Result{}, err
 			}
 		}
 	case vmv1.ProvisionPhaseStop:
 		if v, ok := provisionReconcileMap["stop"]; ok {
-			if err = v(r, log, apiUrlStop, nil); err != nil {
+			if err = v(r, log, apiUrlStop, original, nil); err != nil {
 				log.Error(err, "Failed to stop VM")
 				return ctrl.Result{}, err
 			}
 		}
 	case vmv1.ProvisionPhaseDelete:
 		if v, ok := provisionReconcileMap["deProvision"]; ok {
-			if err = v(r, log, apiUrlDelete, nil); err != nil {
+			if err = v(r, log, apiUrlDelete, original, nil); err != nil {
 				log.Error(err, "Failed to delete VM")
 				return ctrl.Result{}, err
 			}
 		}
 	case vmv1.ProvisionPhaseGet:
 		if v, ok := provisionReconcileMap["get"]; ok {
-			if err = v(r, log, apiUrlGet, nil); err != nil {
+			if err = v(r, log, apiUrlGet, original, nil); err != nil {
 				log.Error(err, "Failed to get VM information")
 				return ctrl.Result{}, err
 			}
 		}
 	default:
 		log.V(ErrorLevelIsAnError).Error(err, "No action defined for the current phase",
-			"reconcile phase", original.Status.Phase, "namespace", req.NamespacedName)
+			"reconcile phase", original.Spec.Phase, "namespace", req.NamespacedName)
 		return ctrl.Result{}, err
 	}
 
@@ -141,32 +144,52 @@ func (r *ProvisionReconciler) SetupWithManager(mgr ctrl.Manager) error {
 		Complete(r)
 }
 
-func provision(r *ProvisionReconciler, log logr.Logger, url string, payload interface{}) error {
+func provision(r *ProvisionReconciler, log logr.Logger, url string, original *vmv1.Provision, payload interface{}) error {
 	log.V(ErrorLevelIsInfo).Info("Creating a new VM")
-	//return r.ncpService.Server.Create(url, payload)
-	return nil
+	csr := &server.CreateServerRequest{
+		ServerImageProductCode:    original.Spec.Server.ImageProductCode,
+		VpcNo:                     original.Spec.VpcNo,
+		SubnetNo:                  original.Spec.SubnetNo,
+		NetworkInterfaceOrder:     original.Spec.NetworkInterface.Order,
+		AccessControlGroupNoListN: original.Spec.AccessControlGroupNoListN,
+		ServerProductCode:         original.Spec.Server.ProductCode,
+	}
+	createServerResponse, err := r.ncpService.Server.Create(ncputil.API_URL+ncputil.CREATE_SERVER_INSTANCE_PATH, csr, []int{1, 1})
+	fmt.Println(createServerResponse)
+	return err
 }
 
-func deProvision(r *ProvisionReconciler, log logr.Logger, url string, payload interface{}) error {
+func deProvision(r *ProvisionReconciler, log logr.Logger, url string, original *vmv1.Provision, payload interface{}) error {
 	log.V(ErrorLevelIsInfo).Info("Deleting an existing VM")
-	//return r.ncpService.Server.Delete(url)
-	return nil
+	dsr := &server.DeleteServerRequest{ServerNo: original.Spec.ServerNo}
+	deleteServerResponse, err := r.ncpService.Server.Delete(ncputil.API_URL+ncputil.DELETE_SERVER_INSTANCE_PATH, dsr)
+	fmt.Println(deleteServerResponse)
+	return err
 }
 
-func update(r *ProvisionReconciler, log logr.Logger, url string, payload interface{}) error {
+func update(r *ProvisionReconciler, log logr.Logger, url string, original *vmv1.Provision, payload interface{}) error {
 	log.V(ErrorLevelIsInfo).Info("Updating an existing VM")
-	//return r.ncpService.Server.Update(url)
-	return nil
+	usr := &server.UpdateServerRequest{
+		ServerInstanceNo:  original.Spec.ServerInstanceNo,
+		ServerProductCode: original.Spec.Server.ProductCode,
+	}
+	updateServerResponse, err := r.ncpService.Server.Update(ncputil.API_URL+ncputil.UPDATE_SERVER_INSTANCE_PATH, usr)
+	fmt.Println(updateServerResponse)
+	return err
 }
 
-func stop(r *ProvisionReconciler, log logr.Logger, url string, payload interface{}) error {
+func stop(r *ProvisionReconciler, log logr.Logger, url string, original *vmv1.Provision, payload interface{}) error {
 	log.V(ErrorLevelIsInfo).Info("Stopping an existing VM")
-	//return r.ncpService.Server.Stop(url)
-	return nil
+	ssr := &server.StopServerRequest{ServerNo: original.Spec.ServerNo}
+	stopServerResponse, err := r.ncpService.Server.Stop(ncputil.API_URL+ncputil.STOP_SERVER_INSTANCE_PATH, ssr)
+	fmt.Println(stopServerResponse)
+	return err
 }
 
-func get(r *ProvisionReconciler, log logr.Logger, url string, payload interface{}) error {
+func get(r *ProvisionReconciler, log logr.Logger, url string, original *vmv1.Provision, payload interface{}) error {
 	log.V(ErrorLevelIsInfo).Info("Getting information for an existing VM")
-	return nil
-	//return r.ncpService.Server.Get(url)
+	lsr := &server.ListServerRequest{RegionCode: original.Spec.RegionCode}
+	serverListResponse, err := r.ncpService.Server.List(ncputil.API_URL+ncputil.GET_SERVER_INSTANCE_PATH, lsr)
+	fmt.Println(serverListResponse)
+	return err
 }