feat: Deprecate embedded browser and import console (#12460)

This feature also changes the default port where
the browser is running, now the port has moved
to 9001 and it can be configured with

```
--console-address ":9001"
```

cmd/common-main.go

@@ -32,16 +32,22 @@ import (
 	"path/filepath"
 	"runtime"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
-	"github.com/fatih/color"
+	fcolor "github.com/fatih/color"
+	"github.com/go-openapi/loads"
 	dns2 "github.com/miekg/dns"
 	"github.com/minio/cli"
+	consoleCerts "github.com/minio/console/pkg/certs"
+	"github.com/minio/console/restapi"
+	"github.com/minio/console/restapi/operations"
 	"github.com/minio/kes"
 	"github.com/minio/minio-go/v7/pkg/credentials"
 	"github.com/minio/minio-go/v7/pkg/set"
 	"github.com/minio/minio/internal/auth"
+	"github.com/minio/minio/internal/color"
 	"github.com/minio/minio/internal/config"
 	"github.com/minio/minio/internal/handlers"
 	xhttp "github.com/minio/minio/internal/http"
@@ -51,6 +57,7 @@ import (
 	"github.com/minio/pkg/console"
 	"github.com/minio/pkg/ellipses"
 	"github.com/minio/pkg/env"
+	xnet "github.com/minio/pkg/net"
 )
 
 // serverDebugLog will enable debug printing
@@ -63,10 +70,6 @@ func init() {
 	logger.Init(GOPATH, GOROOT)
 	logger.RegisterError(config.FmtError)
 
-	// Inject into config package.
-	config.Logger.Info = logger.Info
-	config.Logger.LogIf = logger.LogIf
-
 	if IsKubernetes() || IsDocker() || IsBOSH() || IsDCOS() || IsKubernetesReplicaSet() || IsPCFTile() {
 		// 30 seconds matches the orchestrator DNS TTLs, have
 		// a 5 second timeout to lookup from DNS servers.
@@ -90,7 +93,7 @@ func init() {
 
 	globalTransitionState = newTransitionState()
 
-	console.SetColor("Debug", color.New())
+	console.SetColor("Debug", fcolor.New())
 
 	gob.Register(StorageErr(""))
 
@@ -103,6 +106,115 @@ func init() {
 	}
 }
 
+const consolePrefix = "CONSOLE_"
+
+func minioConfigToConsoleFeatures() {
+	os.Setenv("CONSOLE_PBKDF_PASSPHRASE", restapi.RandomCharString(16))
+	os.Setenv("CONSOLE_PBKDF_SALT", restapi.RandomCharString(8))
+	os.Setenv("CONSOLE_MINIO_SERVER", getAPIEndpoints()[0])
+	if value := os.Getenv("MINIO_LOG_QUERY_URL"); value != "" {
+		os.Setenv("CONSOLE_LOG_QUERY_URL", value)
+	}
+	// Enable if prometheus URL is set.
+	if value := os.Getenv("MINIO_PROMETHEUS_URL"); value != "" {
+		os.Setenv("CONSOLE_PROMETHEUS_URL", value)
+	}
+	// Enable if LDAP is enabled.
+	if globalLDAPConfig.Enabled {
+		os.Setenv("CONSOLE_LDAP_ENABLED", config.EnableOn)
+	}
+	// if IDP is enabled, set IDP environment variables
+	if globalOpenIDConfig.URL != nil {
+		os.Setenv("CONSOLE_IDP_URL", globalOpenIDConfig.DiscoveryDoc.Issuer)
+		os.Setenv("CONSOLE_IDP_SCOPES", strings.Join(globalOpenIDConfig.DiscoveryDoc.ScopesSupported, ","))
+		os.Setenv("CONSOLE_IDP_CLIENT_ID", globalOpenIDConfig.ClientID)
+		os.Setenv("CONSOLE_IDP_SECRET", globalOpenIDConfig.ClientSecret)
+	}
+	os.Setenv("CONSOLE_MINIO_REGION", globalServerRegion)
+	os.Setenv("CONSOLE_CERT_PASSWD", os.Getenv("MINIO_CERT_PASSWD"))
+	os.Setenv("CONSOLE_IDP_CALLBACK", getConsoleEndpoints()[0]+"/oauth_callback")
+}
+
+func initConsoleServer() (*restapi.Server, error) {
+	// unset all console_ environment variables.
+	for _, cenv := range env.List(consolePrefix) {
+		os.Unsetenv(cenv)
+	}
+
+	// enable all console environment variables
+	minioConfigToConsoleFeatures()
+
+	// set certs dir to minio directory
+	consoleCerts.GlobalCertsDir = &consoleCerts.ConfigDir{
+		Path: globalCertsDir.Get(),
+	}
+	consoleCerts.GlobalCertsCADir = &consoleCerts.ConfigDir{
+		Path: globalCertsCADir.Get(),
+	}
+
+	swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
+	if err != nil {
+		return nil, err
+	}
+
+	// Initialize MinIO loggers
+	restapi.LogInfo = logger.Info
+	restapi.LogError = logger.Error
+
+	api := operations.NewConsoleAPI(swaggerSpec)
+	api.Logger = func(_ string, _ ...interface{}) {
+		// nothing to log.
+	}
+
+	server := restapi.NewServer(api)
+	// register all APIs
+	server.ConfigureAPI()
+
+	restapi.GlobalRootCAs, restapi.GlobalPublicCerts, restapi.GlobalTLSCertsManager = globalRootCAs, globalPublicCerts, globalTLSCerts
+
+	consolePort, _ := strconv.Atoi(globalMinioConsolePort)
+
+	server.Host = globalMinioConsoleHost
+	server.Port = consolePort
+	restapi.Port = globalMinioConsolePort
+	restapi.Hostname = globalMinioConsoleHost
+
+	if globalIsTLS {
+		// If TLS certificates are provided enforce the HTTPS.
+		server.EnabledListeners = []string{"https"}
+		server.TLSPort = consolePort
+		// Need to store tls-port, tls-host un config variables so secure.middleware can read from there
+		restapi.TLSPort = globalMinioConsolePort
+		restapi.Hostname = globalMinioConsoleHost
+	}
+
+	// subnet license refresh process
+	go func() {
+		// start refreshing subnet license after 5 seconds..
+		time.Sleep(time.Second * 5)
+
+		failedAttempts := 0
+		for {
+			if err := restapi.RefreshLicense(); err != nil {
+				failedAttempts++
+				// end license refresh after 3 consecutive failed attempts
+				if failedAttempts >= 3 {
+					return
+				}
+				// wait 5 minutes and retry again
+				time.Sleep(time.Minute * 5)
+				continue
+			}
+			// if license refreshed successfully reset the counter
+			failedAttempts = 0
+			// try to refresh license every 24 hrs
+			time.Sleep(time.Hour * 24)
+		}
+	}()
+
+	return server, nil
+}
+
 func verifyObjectLayerFeatures(name string, objAPI ObjectLayer) {
 	if (GlobalKMS != nil) && !objAPI.IsEncryptionSupported() {
 		logger.Fatal(errInvalidArgument,
@@ -230,6 +342,35 @@ func handleCommonCmdArgs(ctx *cli.Context) {
 		globalCLIContext.Addr = ctx.String("address")
 	}
 
+	// Fetch console address option
+	globalCLIContext.ConsoleAddr = ctx.GlobalString("console-address")
+	if globalCLIContext.ConsoleAddr == "" {
+		globalCLIContext.ConsoleAddr = ctx.String("console-address")
+	}
+
+	if globalCLIContext.ConsoleAddr == "" {
+		p, err := xnet.GetFreePort()
+		if err != nil {
+			logger.FatalIf(err, "Unable to get free port for console on the host")
+		}
+		globalMinioConsolePortAuto = true
+		globalCLIContext.ConsoleAddr = net.JoinHostPort("", p.String())
+	}
+
+	if globalCLIContext.ConsoleAddr == globalCLIContext.Addr {
+		logger.FatalIf(errors.New("--console-address cannot be same as --address"), "Unable to start the server")
+	}
+
+	globalMinioAddr = globalCLIContext.Addr
+	globalMinioConsoleAddr = globalCLIContext.ConsoleAddr
+
+	globalMinioHost, globalMinioPort = mustSplitHostPort(globalMinioAddr)
+	globalMinioConsoleHost, globalMinioConsolePort = mustSplitHostPort(globalMinioConsoleAddr)
+
+	if globalMinioPort == globalMinioConsolePort {
+		logger.FatalIf(errors.New("--console-address port cannot be same as --address port"), "Unable to start the server")
+	}
+
 	// Check "no-compat" flag from command line argument.
 	globalCLIContext.StrictS3Compat = true
 	if ctx.IsSet("no-compat") || ctx.GlobalIsSet("no-compat") {
@@ -360,16 +501,10 @@ func handleCommonEnvVars() {
 				"         Please use %s and %s",
 				config.EnvAccessKey, config.EnvSecretKey,
 				config.EnvRootUser, config.EnvRootPassword)
-			logger.StartupMessage(color.RedString(msg))
+			logStartupMessage(color.RedBold(msg))
 		}
 		globalActiveCred = cred
 	}
-	if !haveRootCredentials && !haveAccessCredentials {
-		msg := "No credential environment variables defined. Going with the defaults.\n" +
-			"It is strongly recommended to define your own credentials" +
-			" via environment variables %s and %s instead of using default values"
-		logger.StartupMessage(color.RedString(msg, config.EnvRootUser, config.EnvRootPassword))
-	}
 
 	switch {
 	case env.IsSet(config.EnvKMSSecretKey) && env.IsSet(config.EnvKESEndpoint):