added op mode change logic and routes

Author: YourTechBud

Diff for: model/raft.go

@@ -7,8 +7,9 @@ import (
 
 // RaftCommand is the object passed as a raft entry
 type RaftCommand struct {
-	Kind    utils.RaftCommandType `json:"kind"`
-	ID      string                `json:"projectId"`
-	Project *config.Project       `json:"project"`
-	Deploy  *config.Deploy        `json:"deploy"`
+	Kind      utils.RaftCommandType   `json:"kind"`
+	ID        string                  `json:"projectId"`
+	Project   *config.Project         `json:"project"`
+	Deploy    *config.Deploy          `json:"deploy"`
+	Operation *config.OperationConfig `json:"operation"`
 }

Diff for: model/validate.go

@@ -3,7 +3,7 @@ package model
 // RegisterRequest is the struct which carries the space cloud register payload
 type RegisterRequest struct {
 	ID      string `json:"id"` // This is the space cloud id
-	Secret  string `json:"secret"`
+	Key     string `json:"key"`
 	Account string `json:"account"`
 }
 
@@ -12,9 +12,3 @@ type RegisterResponse struct {
 	Ack   bool   `json:"ack"`
 	Error string `json:"error"`
 }
-
-// ProjectFeed is the body sent to push a project config
-type ProjectFeed struct {
-	Config  interface{} `json:"config"`
-	Project string      `json:"project"`
-}

Diff for: utils/admin/admin.go

@@ -10,13 +10,18 @@ import (
 
 // Manager manages all admin transactions
 type Manager struct {
-	lock  sync.RWMutex
-	admin *config.Admin
+	lock      sync.RWMutex
+	nodeID    string
+	admin     *config.Admin
+	validator *validator
 }
 
 // New creates a new admin manager instance
-func New() *Manager {
-	return &Manager{}
+func New(nodeID string) *Manager {
+	m := new(Manager)
+	m.nodeID = nodeID
+	m.validator = newValidator(m.reduceOpMode)
+	return m
 }
 
 // SetConfig sets the admin config
@@ -26,6 +31,29 @@ func (m *Manager) SetConfig(admin *config.Admin) {
 	m.lock.Unlock()
 }
 
+// SetOperationMode sets the operation mode
+func (m *Manager) SetOperationMode(op *config.OperationConfig) error {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	if op.Mode > 0 && (op.Email == "" || op.Key == "") {
+		return errors.New("Invalid operation setting provided")
+	}
+
+	if op.Mode > 0 {
+		// Start the validation process for higher op modes
+		if err := m.validator.startValidation(m.nodeID, op.Email, op.Key); err != nil {
+			return err
+		}
+	} else {
+		// Stop validation for open source mode
+		m.validator.stopValidation()
+	}
+
+	m.admin.Operation = *op
+	return nil
+}
+
 // Login handles the admin login operation
 func (m *Manager) Login(user, pass string) (int, string, error) {
 	m.lock.RLock()

Diff for: utils/admin/operations.go

@@ -50,7 +50,7 @@ func (m *Manager) IsAdminOpAuthorised(token, scope string) (int, error) {
 
 	if scope == utils.ScopeDeploy {
 		if m.admin.Operation.Mode < 1 {
-			return http.StatusForbidden, errors.New("Operation not supported. Upgrade to avail this feature")
+			return http.StatusForbidden, errors.New("Please upgrade your instance")
 		}
 	}
 
@@ -83,3 +83,9 @@ func (m *Manager) IsAdminOpAuthorised(token, scope string) (int, error) {
 
 	return http.StatusForbidden, errors.New("You are not authorized to make this request")
 }
+
+func (m *Manager) reduceOpMode() {
+	m.lock.RLock()
+	defer m.lock.RUnlock()
+	m.admin.Operation.Mode = 0
+}

Diff for: utils/admin/validate.go

@@ -0,0 +1,80 @@
+package admin
+
+import (
+	"log"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+const url = "wss://spaceuptech.com/v1/authenticate/socket/json"
+
+// validator is the object which valiates the space cloud instance
+type validator struct {
+	lock       sync.Mutex
+	socket     *websocket.Conn
+	active     bool
+	reduceMode func()
+}
+
+// New creates a new instance of validator
+func newValidator(cb func()) *validator {
+	return &validator{active: false, reduceMode: cb}
+}
+
+// Start starts the validation process
+func (v *validator) startValidation(id, account, key string) error {
+	// Set validation status to active
+	v.lock.Lock()
+	v.active = true
+	v.lock.Unlock()
+
+	if err := v.registerSpaceCloud(id, account, key); err != nil {
+		return err
+	}
+
+	go func() {
+		timer := time.Now()
+		for {
+			if !v.isActive() {
+				return
+			}
+
+			if err := v.routineRead(); err != nil {
+				log.Println("Validate: Error -", err)
+			}
+
+			// Sleep for 5 minutes before connecting again
+			time.Sleep(5 * time.Minute)
+
+			// Check if 15 days are lapsed without authorization
+			if time.Since(timer).Hours() > 24*15 {
+
+				// Reduce op mode to open source
+				v.reduceMode()
+				return
+			}
+
+			if err := v.registerSpaceCloud(id, account, key); err != nil {
+				log.Println("Validate: Error -", err)
+			} else {
+				timer = time.Now()
+			}
+		}
+	}()
+
+	return nil
+}
+
+func (v *validator) stopValidation() {
+	v.lock.Lock()
+	v.active = false
+	v.lock.Unlock()
+}
+
+func (v *validator) isActive() bool {
+	v.lock.Lock()
+	defer v.lock.Unlock()
+	return v.active
+}

Diff for: utils/admin/websocket.go

@@ -0,0 +1,99 @@
+package admin
+
+import (
+	"errors"
+	"log"
+	"os"
+	"time"
+
+	"github.com/gorilla/websocket"
+	"github.com/mitchellh/mapstructure"
+
+	"github.com/spaceuptech/space-cloud/model"
+	"github.com/spaceuptech/space-cloud/utils"
+)
+
+func (v *validator) connect(url string) error {
+	// Create a new client
+	c, _, err := websocket.DefaultDialer.Dial(url, nil)
+	if err != nil {
+		return err
+	}
+	v.socket = c
+
+	// Start a routine to routinely send pings
+	go func(socket *websocket.Conn) {
+		ticker := time.NewTicker(20 * time.Second)
+		for range ticker.C {
+			if err := socket.WriteMessage(websocket.PingMessage, []byte{}); err != nil {
+				log.Println("Validator Error:", err)
+				return
+			}
+		}
+	}(c)
+
+	return nil
+}
+
+func (v *validator) write(id, account, key string) error {
+	req := &model.RegisterRequest{ID: id, Account: account, Key: key}
+	msg := &model.Message{Type: utils.TypeRegisterRequest, Data: req}
+	return v.socket.WriteJSON(msg)
+}
+
+func (v *validator) read() (msg *model.Message, err error) {
+	msg = &model.Message{}
+	err = v.socket.ReadJSON(msg)
+	return
+}
+
+func (v *validator) routineRead() error {
+	for {
+		msg, err := v.read()
+		if err != nil {
+			return err
+		}
+
+		switch msg.Type {
+		case utils.TypeRegisterRequest:
+
+			// For register request
+			data := new(model.RegisterResponse)
+			mapstructure.Decode(msg.Data, data)
+
+			if !data.Ack {
+				log.Println("Validate Error -", data.Error)
+				os.Exit(-1)
+			}
+		}
+	}
+}
+
+func (v *validator) registerSpaceCloud(id, account, secret string) error {
+	err := v.connect(url)
+	if err != nil {
+		return err
+	}
+
+	err = v.write(id, account, secret)
+	if err != nil {
+		return err
+	}
+
+	msg, err := v.read()
+	if err != nil {
+		return err
+	}
+
+	if msg.Type == utils.TypeRegisterRequest {
+		// For register request
+		data := new(model.RegisterResponse)
+		mapstructure.Decode(msg.Data, data)
+
+		if !data.Ack {
+			return errors.New(data.Error)
+		}
+	}
+
+	return nil
+}

Diff for: utils/constants.go

@@ -165,6 +165,9 @@ const (
 	// RaftCommandSetDeploy is used to set the deploy config
 	RaftCommandSetDeploy RaftCommandType = "set-deploy"
 
+	// RaftCommandSetOperation is used to set the deploy config
+	RaftCommandSetOperation RaftCommandType = "set-operation"
+
 	// RaftCommandDelete is used to delete a projects config
 	RaftCommandDelete RaftCommandType = "delete"
 )
@@ -184,3 +187,6 @@ const (
 	// ScopeDeploy is te scope used for the deploy module
 	ScopeDeploy string = "deploy"
 )
+
+// TypeRegisterRequest is the space cloud register request
+const TypeRegisterRequest string = "register"

Diff for: utils/handlers/config.go

@@ -200,8 +200,76 @@ func HandleStoreDeploymentConfig(adminMan *admin.Manager, syncMan *syncman.SyncM
 			return
 		}
 
-		w.WriteHeader(http.StatusForbidden)
-		json.NewEncoder(w).Encode(map[string]string{"error": "Operation not supported. Upgrade to avail this feature"})
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{})
+	}
+}
+
+// HandleStoreOperationModeConfig returns the handler to store the deployment config via a REST endpoint
+func HandleStoreOperationModeConfig(adminMan *admin.Manager, syncMan *syncman.SyncManager) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		// Get the JWT token from header
+		token := getToken(r)
+
+		// Load the body of the request
+		c := new(config.OperationConfig)
+		if err := json.NewDecoder(r.Body).Decode(c); err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+			return
+		}
+		defer r.Body.Close()
+
+		// Check if the request is authorised
+		status, err := adminMan.IsAdminOpAuthorised(token, "deploy")
+		if err != nil {
+			w.WriteHeader(status)
+			json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+			return
+		}
+
+		// Set the operation mode config
+		if err := adminMan.SetOperationMode(c); err != nil {
+			w.WriteHeader(http.StatusInternalServerError)
+			json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+			return
+		}
+
+		// Apply it to raft log
+		if err := syncMan.SetOperationModeConfig(token, c); err != nil {
+			// Reset the operation mode
+			c.Mode = 0
+			adminMan.SetOperationMode(c)
+
+			w.WriteHeader(http.StatusInternalServerError)
+			json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+			return
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{})
+	}
+}
+
+// HandleLoadOperationModeConfig returns the handler to load the operation config via a REST endpoint
+func HandleLoadOperationModeConfig(adminMan *admin.Manager, syncMan *syncman.SyncManager) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		// Get the JWT token from header
+		token := getToken(r)
+
+		// Check if the token is valid
+		if status, err := adminMan.IsAdminOpAuthorised(token, "deploy"); err != nil {
+			w.WriteHeader(status)
+			json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
+			return
+		}
+
+		c := syncMan.GetGlobalConfig()
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]interface{}{"operation": &c.Admin.Operation})
 	}
 }
 

Diff for: utils/server/routes.go

@@ -12,9 +12,11 @@ func (s *Server) Routes(profiler bool, staticPath string) {
 	s.router.Methods("POST").Path("/v1/api/config/login").HandlerFunc(handlers.HandleAdminLogin(s.adminMan, s.syncMan))
 	s.router.Methods("GET").Path("/v1/api/config/projects").HandlerFunc(handlers.HandleLoadProjects(s.adminMan, s.syncMan))
 	s.router.Methods("POST").Path("/v1/api/config/projects").HandlerFunc(handlers.HandleStoreProjectConfig(s.adminMan, s.syncMan))
-	s.router.Methods("DELETE").Path("/v1/api/config/{project}").HandlerFunc(handlers.HandleDeleteProjectConfig(s.adminMan, s.syncMan))
 	s.router.Methods("GET").Path("/v1/api/config/deploy").HandlerFunc(handlers.HandleLoadDeploymentConfig(s.adminMan, s.syncMan))
 	s.router.Methods("POST").Path("/v1/api/config/deploy").HandlerFunc(handlers.HandleStoreDeploymentConfig(s.adminMan, s.syncMan))
+	s.router.Methods("GET").Path("/v1/api/config/operation").HandlerFunc(handlers.HandleLoadOperationModeConfig(s.adminMan, s.syncMan))
+	s.router.Methods("POST").Path("/v1/api/config/operation").HandlerFunc(handlers.HandleStoreOperationModeConfig(s.adminMan, s.syncMan))
+	s.router.Methods("DELETE").Path("/v1/api/config/{project}").HandlerFunc(handlers.HandleDeleteProjectConfig(s.adminMan, s.syncMan))
 
 	// Initialize routes for the deployment module
 	s.router.Methods("POST").Path("/v1/api/deploy").HandlerFunc(handlers.HandleUploadAndDeploy(s.adminMan, s.deploy))