2017-03-16 15:21:58 -04:00
|
|
|
/*
|
2020-03-17 19:37:28 -04:00
|
|
|
* MinIO Cloud Storage, (C) 2017-2020 MinIO, Inc.
|
2017-03-16 15:21:58 -04:00
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
package cmd
|
|
|
|
|
|
|
|
import (
|
2020-04-16 14:54:12 -04:00
|
|
|
"context"
|
2017-03-16 15:21:58 -04:00
|
|
|
"fmt"
|
2020-04-16 14:54:12 -04:00
|
|
|
"net"
|
2017-04-11 20:44:26 -04:00
|
|
|
"net/url"
|
2017-07-12 19:33:21 -04:00
|
|
|
"os"
|
|
|
|
"os/signal"
|
2017-04-11 20:44:26 -04:00
|
|
|
"strings"
|
2017-07-12 19:33:21 -04:00
|
|
|
"syscall"
|
2017-06-05 18:18:03 -04:00
|
|
|
|
|
|
|
"github.com/gorilla/mux"
|
|
|
|
"github.com/minio/cli"
|
2019-10-04 13:35:33 -04:00
|
|
|
"github.com/minio/minio/cmd/config"
|
2018-04-21 22:23:54 -04:00
|
|
|
xhttp "github.com/minio/minio/cmd/http"
|
2018-04-05 18:04:40 -04:00
|
|
|
"github.com/minio/minio/cmd/logger"
|
2018-05-31 15:30:15 -04:00
|
|
|
"github.com/minio/minio/pkg/certs"
|
2019-10-04 13:35:33 -04:00
|
|
|
"github.com/minio/minio/pkg/color"
|
|
|
|
"github.com/minio/minio/pkg/env"
|
2017-03-16 15:21:58 -04:00
|
|
|
)
|
|
|
|
|
2017-06-09 22:50:51 -04:00
|
|
|
var (
|
|
|
|
gatewayCmd = cli.Command{
|
|
|
|
Name: "gateway",
|
2018-11-20 20:35:33 -05:00
|
|
|
Usage: "start object storage gateway",
|
2019-06-10 10:57:42 -04:00
|
|
|
Flags: append(ServerFlags, GlobalFlags...),
|
2017-06-09 22:50:51 -04:00
|
|
|
HideHelpCommand: true,
|
|
|
|
}
|
|
|
|
)
|
2017-06-09 02:28:45 -04:00
|
|
|
|
2020-06-29 20:07:23 -04:00
|
|
|
// GatewayLocker implements custom NewNSLock implementation
|
|
|
|
type GatewayLocker struct {
|
|
|
|
ObjectLayer
|
|
|
|
nsMutex *nsLockMap
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewNSLock - implements gateway level locker
|
|
|
|
func (l *GatewayLocker) NewNSLock(ctx context.Context, bucket string, objects ...string) RWLocker {
|
|
|
|
return l.nsMutex.NewNSLock(ctx, nil, bucket, objects...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Walk - implements common gateway level Walker, to walk on all objects recursively at a prefix
|
2020-07-11 01:21:04 -04:00
|
|
|
func (l *GatewayLocker) Walk(ctx context.Context, bucket, prefix string, results chan<- ObjectInfo, opts ObjectOptions) error {
|
2020-06-29 20:07:23 -04:00
|
|
|
walk := func(ctx context.Context, bucket, prefix string, results chan<- ObjectInfo) error {
|
2020-07-27 01:56:05 -04:00
|
|
|
go func() {
|
|
|
|
// Make sure the results channel is ready to be read when we're done.
|
|
|
|
defer close(results)
|
2020-07-01 17:29:45 -04:00
|
|
|
|
2020-07-27 01:56:05 -04:00
|
|
|
var marker string
|
2020-07-01 17:29:45 -04:00
|
|
|
|
2020-07-27 01:56:05 -04:00
|
|
|
for {
|
|
|
|
// set maxKeys to '0' to list maximum possible objects in single call.
|
|
|
|
loi, err := l.ObjectLayer.ListObjects(ctx, bucket, prefix, marker, "", 0)
|
|
|
|
if err != nil {
|
|
|
|
logger.LogIf(ctx, err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
marker = loi.NextMarker
|
|
|
|
for _, obj := range loi.Objects {
|
|
|
|
select {
|
|
|
|
case results <- obj:
|
|
|
|
case <-ctx.Done():
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !loi.IsTruncated {
|
|
|
|
break
|
2020-06-29 20:07:23 -04:00
|
|
|
}
|
|
|
|
}
|
2020-07-27 01:56:05 -04:00
|
|
|
}()
|
2020-06-29 20:07:23 -04:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2020-07-11 01:21:04 -04:00
|
|
|
if err := l.ObjectLayer.Walk(ctx, bucket, prefix, results, opts); err != nil {
|
2020-06-29 20:07:23 -04:00
|
|
|
if _, ok := err.(NotImplemented); ok {
|
|
|
|
return walk(ctx, bucket, prefix, results)
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewGatewayLayerWithLocker - initialize gateway with locker.
|
|
|
|
func NewGatewayLayerWithLocker(gwLayer ObjectLayer) ObjectLayer {
|
|
|
|
return &GatewayLocker{ObjectLayer: gwLayer, nsMutex: newNSLock(false)}
|
|
|
|
}
|
|
|
|
|
2017-10-27 18:07:46 -04:00
|
|
|
// RegisterGatewayCommand registers a new command for gateway.
|
|
|
|
func RegisterGatewayCommand(cmd cli.Command) error {
|
2019-07-03 17:31:19 -04:00
|
|
|
cmd.Flags = append(append(cmd.Flags, ServerFlags...), GlobalFlags...)
|
2017-10-27 18:07:46 -04:00
|
|
|
gatewayCmd.Subcommands = append(gatewayCmd.Subcommands, cmd)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-12-05 20:58:09 -05:00
|
|
|
// ParseGatewayEndpoint - Return endpoint.
|
|
|
|
func ParseGatewayEndpoint(arg string) (endPoint string, secure bool, err error) {
|
2017-04-11 20:44:26 -04:00
|
|
|
schemeSpecified := len(strings.Split(arg, "://")) > 1
|
|
|
|
if !schemeSpecified {
|
|
|
|
// Default connection will be "secure".
|
|
|
|
arg = "https://" + arg
|
|
|
|
}
|
2017-04-27 14:26:00 -04:00
|
|
|
|
2017-04-11 20:44:26 -04:00
|
|
|
u, err := url.Parse(arg)
|
|
|
|
if err != nil {
|
|
|
|
return "", false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
switch u.Scheme {
|
|
|
|
case "http":
|
|
|
|
return u.Host, false, nil
|
|
|
|
case "https":
|
|
|
|
return u.Host, true, nil
|
|
|
|
default:
|
|
|
|
return "", false, fmt.Errorf("Unrecognized scheme %s", u.Scheme)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-05 20:58:09 -05:00
|
|
|
// ValidateGatewayArguments - Validate gateway arguments.
|
|
|
|
func ValidateGatewayArguments(serverAddr, endpointAddr string) error {
|
2017-06-08 14:20:56 -04:00
|
|
|
if err := CheckLocalServerAddr(serverAddr); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if endpointAddr != "" {
|
|
|
|
// Reject the endpoint if it points to the gateway handler itself.
|
|
|
|
sameTarget, err := sameLocalAddrs(endpointAddr, serverAddr)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if sameTarget {
|
2017-11-25 14:58:29 -05:00
|
|
|
return fmt.Errorf("endpoint points to the local gateway")
|
2017-06-08 14:20:56 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-12-05 20:58:09 -05:00
|
|
|
// StartGateway - handler for 'minio gateway <name>'.
|
|
|
|
func StartGateway(ctx *cli.Context, gw Gateway) {
|
2020-05-18 14:35:05 -04:00
|
|
|
// This is only to uniquely identify each gateway deployments.
|
|
|
|
globalDeploymentID = env.Get("MINIO_GATEWAY_DEPLOYMENT_ID", mustGetUUID())
|
|
|
|
logger.SetDeploymentID(globalDeploymentID)
|
|
|
|
|
2017-12-05 20:58:09 -05:00
|
|
|
if gw == nil {
|
2018-05-09 18:11:24 -04:00
|
|
|
logger.FatalIf(errUnexpected, "Gateway implementation not initialized")
|
2017-12-05 20:58:09 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Validate if we have access, secret set through environment.
|
2019-08-14 14:43:43 -04:00
|
|
|
globalGatewayName = gw.Name()
|
2017-12-05 20:58:09 -05:00
|
|
|
gatewayName := gw.Name()
|
|
|
|
if ctx.Args().First() == "help" {
|
|
|
|
cli.ShowCommandHelpAndExit(ctx, gatewayName, 1)
|
|
|
|
}
|
|
|
|
|
2017-06-09 22:50:51 -04:00
|
|
|
// Handle common command args.
|
|
|
|
handleCommonCmdArgs(ctx)
|
|
|
|
|
2019-12-04 18:32:37 -05:00
|
|
|
// Initialize all help
|
|
|
|
initHelp()
|
|
|
|
|
2018-09-06 19:42:33 -04:00
|
|
|
// Get port to listen on from gateway address
|
2018-12-18 19:08:11 -05:00
|
|
|
globalMinioHost, globalMinioPort = mustSplitHostPort(globalCLIContext.Addr)
|
2018-09-06 19:42:33 -04:00
|
|
|
|
2018-08-18 00:06:36 -04:00
|
|
|
// On macOS, if a process already listens on LOCALIPADDR:PORT, net.Listen() falls back
|
|
|
|
// to IPv6 address ie minio will start listening on IPv6 address whereas another
|
|
|
|
// (non-)minio process is listening on IPv4 of given port.
|
|
|
|
// To avoid this error situation we check for port availability.
|
2019-06-24 18:02:40 -04:00
|
|
|
logger.FatalIf(checkPortAvailability(globalMinioHost, globalMinioPort), "Unable to start the gateway")
|
2018-08-18 00:06:36 -04:00
|
|
|
|
2018-10-27 20:51:00 -04:00
|
|
|
// Check and load TLS certificates.
|
2017-06-09 22:50:51 -04:00
|
|
|
var err error
|
2018-10-27 20:51:00 -04:00
|
|
|
globalPublicCerts, globalTLSCerts, globalIsSSL, err = getTLSConfig()
|
|
|
|
logger.FatalIf(err, "Invalid TLS certificate file")
|
|
|
|
|
|
|
|
// Check and load Root CAs.
|
2019-10-08 01:47:56 -04:00
|
|
|
globalRootCAs, err = config.GetRootCAs(globalCertsCADir.Get())
|
2018-10-27 20:51:00 -04:00
|
|
|
logger.FatalIf(err, "Failed to read root CAs (%v)", err)
|
2017-03-31 01:26:24 -04:00
|
|
|
|
2020-04-27 09:25:05 -04:00
|
|
|
globalMinioEndpoint = func() string {
|
|
|
|
host := globalMinioHost
|
|
|
|
if host == "" {
|
|
|
|
host = sortIPs(localIP4.ToSlice())[0]
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("%s://%s", getURLScheme(globalIsSSL), net.JoinHostPort(host, globalMinioPort))
|
|
|
|
}()
|
|
|
|
|
2019-01-05 17:16:43 -05:00
|
|
|
// Handle gateway specific env
|
2019-11-01 18:53:16 -04:00
|
|
|
gatewayHandleEnvVars()
|
2019-01-05 17:16:43 -05:00
|
|
|
|
2017-12-24 09:39:30 -05:00
|
|
|
// Set system resources to maximum.
|
2020-06-16 21:57:29 -04:00
|
|
|
setMaxResources()
|
2017-12-24 09:39:30 -05:00
|
|
|
|
2019-06-07 18:49:13 -04:00
|
|
|
// Set when gateway is enabled
|
|
|
|
globalIsGateway = true
|
|
|
|
|
2020-06-25 06:29:28 -04:00
|
|
|
enableConfigOps := false
|
2019-11-12 06:16:25 -05:00
|
|
|
|
|
|
|
// TODO: We need to move this code with globalConfigSys.Init()
|
|
|
|
// for now keep it here such that "s3" gateway layer initializes
|
|
|
|
// itself properly when KMS is set.
|
|
|
|
|
|
|
|
// Initialize server config.
|
|
|
|
srvCfg := newServerConfig()
|
|
|
|
|
|
|
|
// Override any values from ENVs.
|
2020-08-05 16:31:12 -04:00
|
|
|
lookupConfigs(srvCfg, 0)
|
2019-11-12 06:16:25 -05:00
|
|
|
|
|
|
|
// hold the mutex lock before a new config is assigned.
|
|
|
|
globalServerConfigMu.Lock()
|
|
|
|
globalServerConfig = srvCfg
|
|
|
|
globalServerConfigMu.Unlock()
|
|
|
|
|
2020-02-11 22:38:02 -05:00
|
|
|
// Initialize router. `SkipClean(true)` stops gorilla/mux from
|
|
|
|
// normalizing URL path minio/minio#3256
|
|
|
|
// avoid URL path encoding minio/minio#8950
|
|
|
|
router := mux.NewRouter().SkipClean(true).UseEncodedPath()
|
2017-06-01 12:43:20 -04:00
|
|
|
|
2018-10-17 20:25:16 -04:00
|
|
|
if globalEtcdClient != nil {
|
|
|
|
// Enable STS router if etcd is enabled.
|
|
|
|
registerSTSRouter(router)
|
|
|
|
}
|
|
|
|
|
2019-01-23 14:10:59 -05:00
|
|
|
enableIAMOps := globalEtcdClient != nil
|
|
|
|
|
2018-12-18 16:03:26 -05:00
|
|
|
// Enable IAM admin APIs if etcd is enabled, if not just enable basic
|
|
|
|
// operations such as profiling, server info etc.
|
2020-05-25 03:17:52 -04:00
|
|
|
registerAdminRouter(router, enableConfigOps, enableIAMOps)
|
2018-12-18 16:03:26 -05:00
|
|
|
|
2018-04-04 22:07:54 -04:00
|
|
|
// Add healthcheck router
|
|
|
|
registerHealthCheckRouter(router)
|
|
|
|
|
2018-05-30 00:43:46 -04:00
|
|
|
// Add server metrics router
|
|
|
|
registerMetricsRouter(router)
|
|
|
|
|
2017-06-01 12:43:20 -04:00
|
|
|
// Register web router when its enabled.
|
2019-10-23 01:59:13 -04:00
|
|
|
if globalBrowserEnabled {
|
2018-04-05 18:04:40 -04:00
|
|
|
logger.FatalIf(registerWebRouter(router), "Unable to configure web browser")
|
2017-06-01 12:43:20 -04:00
|
|
|
}
|
2017-03-16 15:21:58 -04:00
|
|
|
|
2019-01-05 17:16:43 -05:00
|
|
|
// Currently only NAS and S3 gateway support encryption headers.
|
|
|
|
encryptionEnabled := gatewayName == "s3" || gatewayName == "nas"
|
2019-06-19 20:37:08 -04:00
|
|
|
allowSSEKMS := gatewayName == "s3" // Only S3 can support SSE-KMS (as pass-through)
|
2019-01-05 17:16:43 -05:00
|
|
|
|
2018-04-04 22:07:54 -04:00
|
|
|
// Add API router.
|
2019-06-19 20:37:08 -04:00
|
|
|
registerAPIRouter(router, encryptionEnabled, allowSSEKMS)
|
2017-03-16 15:21:58 -04:00
|
|
|
|
2020-06-11 11:19:55 -04:00
|
|
|
// Use all the middlewares
|
|
|
|
router.Use(registerMiddlewares)
|
|
|
|
|
2018-05-31 15:30:15 -04:00
|
|
|
var getCert certs.GetCertificateFunc
|
|
|
|
if globalTLSCerts != nil {
|
|
|
|
getCert = globalTLSCerts.GetCertificate
|
|
|
|
}
|
|
|
|
|
2019-12-02 18:54:26 -05:00
|
|
|
httpServer := xhttp.NewServer([]string{globalCLIContext.Addr},
|
2020-07-12 13:56:57 -04:00
|
|
|
criticalErrorHandler{corsHandler(router)}, getCert)
|
2020-04-16 14:54:12 -04:00
|
|
|
httpServer.BaseContext = func(listener net.Listener) context.Context {
|
|
|
|
return GlobalContext
|
|
|
|
}
|
2017-03-16 15:21:58 -04:00
|
|
|
go func() {
|
2019-12-02 18:54:26 -05:00
|
|
|
globalHTTPServerErrorCh <- httpServer.Start()
|
2017-03-16 15:21:58 -04:00
|
|
|
}()
|
|
|
|
|
2019-12-02 18:54:26 -05:00
|
|
|
globalObjLayerMutex.Lock()
|
|
|
|
globalHTTPServer = httpServer
|
|
|
|
globalObjLayerMutex.Unlock()
|
|
|
|
|
2017-07-12 19:33:21 -04:00
|
|
|
signal.Notify(globalOSSignalCh, os.Interrupt, syscall.SIGTERM)
|
|
|
|
|
2019-10-23 01:59:13 -04:00
|
|
|
newObject, err := gw.NewGatewayLayer(globalActiveCred)
|
2018-12-18 13:42:09 -05:00
|
|
|
if err != nil {
|
|
|
|
// Stop watching for any certificate changes.
|
|
|
|
globalTLSCerts.Stop()
|
|
|
|
|
|
|
|
globalHTTPServer.Shutdown()
|
|
|
|
logger.FatalIf(err, "Unable to initialize gateway backend")
|
|
|
|
}
|
2019-11-19 19:45:35 -05:00
|
|
|
newObject = NewGatewayLayerWithLocker(newObject)
|
|
|
|
|
2019-11-09 12:27:23 -05:00
|
|
|
// Once endpoints are finalized, initialize the new object api in safe mode.
|
|
|
|
globalObjLayerMutex.Lock()
|
|
|
|
globalSafeMode = true
|
|
|
|
globalObjectAPI = newObject
|
|
|
|
globalObjLayerMutex.Unlock()
|
|
|
|
|
|
|
|
// Calls all New() for all sub-systems.
|
|
|
|
newAllSubsystems()
|
|
|
|
|
2020-06-25 06:29:28 -04:00
|
|
|
if gatewayName == "nas" {
|
2020-04-09 12:30:02 -04:00
|
|
|
buckets, err := newObject.ListBuckets(GlobalContext)
|
2020-02-02 04:52:07 -05:00
|
|
|
if err != nil {
|
|
|
|
logger.Fatal(err, "Unable to list buckets")
|
|
|
|
}
|
|
|
|
logger.FatalIf(globalNotificationSys.Init(buckets, newObject), "Unable to initialize notification system")
|
2018-12-18 13:42:09 -05:00
|
|
|
}
|
2018-10-12 15:25:59 -04:00
|
|
|
|
2019-11-01 18:53:16 -04:00
|
|
|
if globalEtcdClient != nil {
|
|
|
|
// **** WARNING ****
|
|
|
|
// Migrating to encrypted backend on etcd should happen before initialization of
|
|
|
|
// IAM sub-systems, make sure that we do not move the above codeblock elsewhere.
|
2020-04-07 17:26:39 -04:00
|
|
|
logger.FatalIf(migrateIAMConfigsEtcdToEncrypted(GlobalContext, globalEtcdClient),
|
2019-11-01 18:53:16 -04:00
|
|
|
"Unable to handle encrypted backend for iam and policies")
|
|
|
|
}
|
|
|
|
|
2019-01-23 14:10:59 -05:00
|
|
|
if enableIAMOps {
|
2018-10-12 14:32:18 -04:00
|
|
|
// Initialize IAM sys.
|
2020-06-09 22:19:03 -04:00
|
|
|
startBackgroundIAMLoad(GlobalContext)
|
2018-10-12 14:32:18 -04:00
|
|
|
}
|
2018-10-09 17:00:01 -04:00
|
|
|
|
2019-11-09 12:27:23 -05:00
|
|
|
if globalCacheConfig.Enabled {
|
|
|
|
// initialize the new disk cache objects.
|
|
|
|
var cacheAPI CacheObjectLayer
|
2020-03-22 15:16:36 -04:00
|
|
|
cacheAPI, err = newServerCacheObjects(GlobalContext, globalCacheConfig)
|
2019-11-09 12:27:23 -05:00
|
|
|
logger.FatalIf(err, "Unable to initialize disk caching")
|
2019-07-19 16:20:33 -04:00
|
|
|
|
2019-11-09 12:27:23 -05:00
|
|
|
globalObjLayerMutex.Lock()
|
|
|
|
globalCacheObjectAPI = cacheAPI
|
|
|
|
globalObjLayerMutex.Unlock()
|
2019-10-31 02:39:09 -04:00
|
|
|
}
|
2018-12-14 16:35:48 -05:00
|
|
|
|
2019-12-17 16:50:07 -05:00
|
|
|
// Populate existing buckets to the etcd backend
|
|
|
|
if globalDNSConfig != nil {
|
2020-03-22 15:16:36 -04:00
|
|
|
buckets, err := newObject.ListBuckets(GlobalContext)
|
2019-12-17 16:50:07 -05:00
|
|
|
if err != nil {
|
|
|
|
logger.Fatal(err, "Unable to list buckets")
|
|
|
|
}
|
|
|
|
initFederatorBackend(buckets, newObject)
|
|
|
|
}
|
|
|
|
|
2019-07-26 05:41:16 -04:00
|
|
|
// Verify if object layer supports
|
|
|
|
// - encryption
|
|
|
|
// - compression
|
|
|
|
verifyObjectLayerFeatures("gateway "+gatewayName, newObject)
|
2018-12-14 16:35:48 -05:00
|
|
|
|
2019-11-16 16:44:28 -05:00
|
|
|
// Disable safe mode operation, after all initialization is over.
|
|
|
|
globalObjLayerMutex.Lock()
|
|
|
|
globalSafeMode = false
|
|
|
|
globalObjLayerMutex.Unlock()
|
|
|
|
|
2017-03-16 15:21:58 -04:00
|
|
|
// Prints the formatted startup message once object layer is initialized.
|
2018-12-18 19:08:11 -05:00
|
|
|
if !globalCLIContext.Quiet {
|
2017-10-27 18:07:46 -04:00
|
|
|
mode := globalMinioModeGatewayPrefix + gatewayName
|
2017-06-09 22:50:51 -04:00
|
|
|
// Check update mode.
|
2017-03-16 15:21:58 -04:00
|
|
|
checkUpdate(mode)
|
2017-06-09 22:50:51 -04:00
|
|
|
|
2017-12-05 20:58:09 -05:00
|
|
|
// Print a warning message if gateway is not ready for production before the startup banner.
|
|
|
|
if !gw.Production() {
|
2019-10-04 13:35:33 -04:00
|
|
|
logStartupMessage(color.Yellow(" *** Warning: Not Ready for Production ***"))
|
2017-12-05 20:58:09 -05:00
|
|
|
}
|
|
|
|
|
2017-06-09 22:50:51 -04:00
|
|
|
// Print gateway startup message.
|
2018-12-14 02:37:46 -05:00
|
|
|
printGatewayStartupMessage(getAPIEndpoints(), gatewayName)
|
2017-03-16 15:21:58 -04:00
|
|
|
}
|
|
|
|
|
2017-07-12 19:33:21 -04:00
|
|
|
handleSignals()
|
2017-03-16 15:21:58 -04:00
|
|
|
}
|