Merge branch 'v0.10.0' into ee-v0.10.0

Author: YourTechBud

Diff for: Dockerfile

@@ -9,13 +9,12 @@ COPY space-cloud .
 RUN set -ex  \
   && apk add --no-cache ca-certificates wget \
   && chmod +x space-cloud
-  
 ENV PROD=false
 ENV PATH="/space-cloud:${PATH}"
 
 # ports for the http and https servers
-EXPOSE 4242 4244
-EXPOSE 4343 4245
+EXPOSE 4122 4124
+EXPOSE 4126 4128
 
 # ports for nats
 EXPOSE 4222 4248

Diff for: main.go

@@ -13,26 +13,6 @@ import (
 )
 
 var essentialFlags = []cli.Flag{
-	cli.StringFlag{
-		Name:  "port",
-		Value: "8080",
-		Usage: "Start HTTP server on port `PORT`",
-	},
-	cli.StringFlag{
-		Name:  "grpc-port",
-		Value: "8081",
-		Usage: "Start grpc on port `GRPC_PORT`",
-	},
-	cli.IntFlag{
-		Name:  "nats-port",
-		Value: 4222,
-		Usage: "Start nats on port `NATS_PORT`",
-	},
-	cli.IntFlag{
-		Name:  "cluster-port",
-		Value: 4248,
-		Usage: "Start nats on port `NATS_PORT`",
-	},
 	cli.StringFlag{
 		Name:  "config",
 		Value: "config.yaml",
@@ -112,11 +92,7 @@ func main() {
 
 func actionRun(c *cli.Context) error {
 	// Load cli flags
-	port := c.String("port")
-	grpcPort := c.String("grpc-port")
 	configPath := c.String("config")
-	natsPort := c.Int("nats-port")
-	clusterPort := c.Int("cluster-port")
 	isProd := c.Bool("prod")
 	disableMetrics := c.Bool("disable-metrics")
 	disableNats := c.Bool("disable-nats")
@@ -131,13 +107,6 @@ func actionRun(c *cli.Context) error {
 	// Project and env cannot be changed once space cloud has started
 	s := server.New(isProd)
 
-	if !disableNats {
-		err := s.RunNatsServer(seeds, natsPort, clusterPort)
-		if err != nil {
-			return err
-		}
-	}
-
 	// Load the configFile from path if provided
 	conf, err := config.LoadConfigFromFile(configPath)
 	if err != nil {
@@ -173,7 +142,16 @@ func actionRun(c *cli.Context) error {
 	}
 
 	s.Routes(profiler, staticPath)
-	return s.Start(port, grpcPort, seeds)
+
+	// Start nats if not disabled
+	if !disableNats {
+		err := s.RunNatsServer(seeds, utils.PortNatsServer, utils.PortNatsCluster)
+		if err != nil {
+			return err
+		}
+	}
+
+	return s.Start(seeds)
 }
 
 func actionInit(*cli.Context) error {
@@ -184,18 +162,21 @@ func initMissionContol(version string) (string, error) {
 	homeDir := utils.UserHomeDir()
 	uiPath := homeDir + "/.space-cloud/mission-control-v" + version
 	if _, err := os.Stat(uiPath); os.IsNotExist(err) {
+		fmt.Println("Could not find mission control")
 		if _, err := os.Stat(homeDir + "/space-cloud"); os.IsNotExist(err) {
 			os.Mkdir(homeDir+"/.space-cloud", os.ModePerm)
 		}
-		fmt.Println("Downloading Mission Control UI...")
+		fmt.Println("Downloading...")
 		err := utils.DownloadFileFromURL("https://spaceuptech.com/downloads/mission-control/mission-control-v"+version+".zip", uiPath+".zip")
 		if err != nil {
 			return "", err
 		}
+		fmt.Println("Extracting...")
 		err = utils.Unzip(uiPath+".zip", uiPath)
 		if err != nil {
 			return "", err
 		}
+		fmt.Println("Done...")
 		err = os.Remove(uiPath + ".zip")
 		if err != nil {
 			return "", err

Diff for: utils/constants.go

@@ -190,3 +190,29 @@ const (
 
 // TypeRegisterRequest is the space cloud register request
 const TypeRegisterRequest string = "register"
+
+const (
+	// PortHTTP is the port used for the http server
+	PortHTTP string = "4122"
+
+	// PortGRPC is the port used for the grpc server
+	PortGRPC string = "4124"
+
+	// PortHTTPSecure is the port used for the http server with tls
+	PortHTTPSecure string = "4126"
+
+	// PortGRPCSecure is the port used for the grpc server with tls
+	PortGRPCSecure string = "4128"
+
+	// PortNatsServer is the port used for nats
+	PortNatsServer int = 4222
+
+	// PortNatsCluster is the port used by nats for clustering
+	PortNatsCluster int = 4248
+
+	// PortGossip is used for the membership protocol
+	PortGossip string = "4232"
+
+	// PortRaft is used internally by raft
+	PortRaft string = "4234"
+)

Diff for: utils/server/server.go

@@ -55,16 +55,16 @@ func New(isProd bool) *Server {
 }
 
 // Start begins the server operations
-func (s *Server) Start(port, grpcPort, seeds string) error {
-
-	go s.initGRPCServer(grpcPort)
+func (s *Server) Start(seeds string) error {
+	// Start gRPC server in a separate goroutine
+	go s.initGRPCServer()
 
 	// Start the sync manager
 	if seeds == "" {
 		seeds = "127.0.0.1"
 	}
 	array := strings.Split(seeds, ",")
-	if err := s.syncMan.Start(s.nodeID, s.configFilePath, "4232", "4234", array); err != nil {
+	if err := s.syncMan.Start(s.nodeID, s.configFilePath, utils.PortGossip, utils.PortRaft, array); err != nil {
 		return err
 	}
 
@@ -81,14 +81,24 @@ func (s *Server) Start(port, grpcPort, seeds string) error {
 
 	handler := corsObj.Handler(s.router)
 
-	fmt.Println("Starting HTTP Server on port: " + port)
+	fmt.Println("Starting http server on port: " + utils.PortHTTP)
 
-	fmt.Println("Space Cloud is running on the specified ports :D")
 	if s.ssl != nil && s.ssl.Enabled {
-		return http.ListenAndServeTLS(":"+port, s.ssl.Crt, s.ssl.Key, handler)
+		fmt.Println("Starting https server on port: " + utils.PortHTTPSecure)
+		go func() {
+
+			if err := http.ListenAndServeTLS(":"+utils.PortHTTPSecure, s.ssl.Crt, s.ssl.Key, handler); err != nil {
+				fmt.Println("Error starting https server:", err)
+			}
+		}()
 	}
 
-	return http.ListenAndServe(":"+port, handler)
+	fmt.Println()
+	fmt.Println("\t Hosting mission control on http://localhost:" + utils.PortHTTP + "/mission-control/")
+	fmt.Println()
+
+	fmt.Println("Space cloud is running on the specified ports :D")
+	return http.ListenAndServe(":"+utils.PortHTTP, handler)
 }
 
 // SetConfig sets the config
@@ -99,27 +109,42 @@ func (s *Server) SetConfig(c *config.Config) {
 	s.deploy.SetConfig(&c.Deploy)
 }
 
-func (s *Server) initGRPCServer(port string) {
-	lis, err := net.Listen("tcp", ":"+port)
-	if err != nil {
-		log.Fatal("Failed to listen:", err)
-	}
+func (s *Server) initGRPCServer() {
 
-	options := []grpc.ServerOption{}
 	if s.ssl != nil && s.ssl.Enabled {
+		lis, err := net.Listen("tcp", ":"+utils.PortGRPCSecure)
+		if err != nil {
+			log.Fatal("Failed to listen:", err)
+		}
 		creds, err := credentials.NewServerTLSFromFile(s.ssl.Crt, s.ssl.Key)
 		if err != nil {
 			log.Fatalln("Error: ", err)
 		}
-		options = append(options, grpc.Creds(creds))
+		options := []grpc.ServerOption{grpc.Creds(creds)}
+
+		grpcServer := grpc.NewServer(options...)
+		proto.RegisterSpaceCloudServer(grpcServer, s)
+
+		fmt.Println("Starting grpc secure server on port: " + utils.PortGRPCSecure)
+		go func() {
+			if err := grpcServer.Serve(lis); err != nil {
+				log.Fatal("Error starting grpc secure server:", err)
+			}
+		}()
+	}
+
+	lis, err := net.Listen("tcp", ":"+utils.PortGRPC)
+	if err != nil {
+		log.Fatal("Failed to listen:", err)
 	}
 
+	options := []grpc.ServerOption{}
 	grpcServer := grpc.NewServer(options...)
 	proto.RegisterSpaceCloudServer(grpcServer, s)
 
-	fmt.Println("Starting gRPC Server on port: " + port)
+	fmt.Println("Starting grpc server on port: " + utils.PortGRPC)
 	if err := grpcServer.Serve(lis); err != nil {
-		log.Fatal("failed to serve:", err)
+		log.Fatal("Error starting grpc server:", err)
 	}
 }