func (s *server) createMux(ctx types.Context) *mux.Router {
m := mux.NewRouter()
for _, apiRouter := range s.routers {
for _, r := range apiRouter.Routes() {
ctx := ctx.WithValue(context.RouteKey, r)
f := s.makeHTTPHandler(ctx, r)
mr := m.Path(r.GetPath())
mr = mr.Name(r.GetName())
mr = mr.Methods(r.GetMethod())
mr = mr.Queries(r.GetQueries()...)
mr.Handler(f)
if l, ok := context.GetLogLevel(ctx); ok && l >= log.DebugLevel {
ctx.WithFields(log.Fields{
"path": r.GetPath(),
"method": r.GetMethod(),
"queries": r.GetQueries(),
"len(queries)": len(r.GetQueries()),
}).Debug("registered route")
} else {
ctx.Info("registered route")
}
}
}
return m
}
func (d *driver) Login(ctx types.Context) (interface{}, error) {
sessionsL.Lock()
defer sessionsL.Unlock()
var (
endpoint *string
ckey string
hkey = md5.New()
akey = d.accessKey
region = d.mustRegion(ctx)
)
if region != nil && d.endpointFormat != "" {
szEndpoint := fmt.Sprintf(d.endpointFormat, *region)
endpoint = &szEndpoint
} else {
endpoint = d.endpoint
}
if !d.disableSessionCache {
writeHkey(hkey, region)
writeHkey(hkey, endpoint)
writeHkey(hkey, &akey)
ckey = fmt.Sprintf("%x", hkey.Sum(nil))
// if the session is cached then return it
if svc, ok := sessions[ckey]; ok {
ctx.WithField(cacheKeyC, ckey).Debug("using cached efs service")
return svc, nil
}
}
var (
skey = d.getSecretKey()
fields = map[string]interface{}{
efs.AccessKey: akey,
efs.Tag: d.tag,
cacheKeyC: ckey,
}
)
if skey == "" {
fields[efs.SecretKey] = ""
} else {
fields[efs.SecretKey] = "******"
}
if region != nil {
fields[efs.Region] = *region
}
if endpoint != nil {
fields[efs.Endpoint] = *endpoint
}
ctx.WithFields(fields).Debug("efs service connetion attempt")
sess := session.New()
var (
awsLogger = &awsLogger{ctx: ctx}
awsLogLevel = aws.LogOff
)
if ll, ok := context.GetLogLevel(ctx); ok {
switch ll {
case log.DebugLevel:
awsLogger.lvl = log.DebugLevel
awsLogLevel = aws.LogDebugWithHTTPBody
case log.InfoLevel:
awsLogger.lvl = log.InfoLevel
awsLogLevel = aws.LogDebug
}
}
svc := awsefs.New(sess, &aws.Config{
Region: region,
Endpoint: endpoint,
MaxRetries: d.maxRetries,
Credentials: credentials.NewChainCredentials(
[]credentials.Provider{
&credentials.StaticProvider{
Value: credentials.Value{
AccessKeyID: akey,
SecretAccessKey: skey,
},
},
&credentials.EnvProvider{},
&credentials.SharedCredentialsProvider{},
&ec2rolecreds.EC2RoleProvider{
Client: ec2metadata.New(sess),
},
},
),
Logger: awsLogger,
LogLevel: aws.LogLevel(awsLogLevel),
})
ctx.WithFields(fields).Info("efs service connection created")
if !d.disableSessionCache {
sessions[ckey] = svc
ctx.WithFields(fields).Info("efs service connection cached")
}
return svc, nil
}
func newServer(goCtx gocontext.Context, config gofig.Config) (*server, error) {
adminTokenUUID, err := types.NewUUID()
if err != nil {
return nil, err
}
adminToken := adminTokenUUID.String()
serverName := randomServerName()
ctx := context.New(goCtx)
ctx = ctx.WithValue(context.ServerKey, serverName)
ctx = ctx.WithValue(context.AdminTokenKey, adminToken)
if lvl, ok := context.GetLogLevel(ctx); ok {
switch lvl {
case log.DebugLevel:
ctx = context.WithValue(
ctx, gournal.LevelKey(),
gournal.DebugLevel)
case log.InfoLevel:
ctx = context.WithValue(
ctx, gournal.LevelKey(),
gournal.InfoLevel)
case log.WarnLevel:
ctx = context.WithValue(
ctx, gournal.LevelKey(),
gournal.WarnLevel)
case log.ErrorLevel:
ctx = context.WithValue(
ctx, gournal.LevelKey(),
gournal.ErrorLevel)
case log.FatalLevel:
ctx = context.WithValue(
ctx, gournal.LevelKey(),
gournal.FatalLevel)
case log.PanicLevel:
ctx = context.WithValue(
ctx, gournal.LevelKey(),
gournal.PanicLevel)
}
}
if logger, ok := ctx.Value(context.LoggerKey).(*log.Logger); ok {
ctx = context.WithValue(
ctx, gournal.AppenderKey(),
glogrus.NewWithOptions(
logger.Out, logger.Level, logger.Formatter))
}
if config == nil {
var err error
if config, err = apicnfg.NewConfig(); err != nil {
return nil, err
}
}
config = config.Scope(types.ConfigServer)
s := &server{
ctx: ctx,
name: serverName,
adminToken: adminToken,
config: config,
closeSignal: make(chan int),
closedSignal: make(chan int),
closeOnce: &sync.Once{},
}
if logger, ok := s.ctx.Value(context.LoggerKey).(*log.Logger); ok {
s.PrintServerStartupHeader(logger.Out)
} else {
s.PrintServerStartupHeader(os.Stdout)
}
if lvl, err := log.ParseLevel(
config.GetString(types.ConfigLogLevel)); err == nil {
context.SetLogLevel(s.ctx, lvl)
}
logFields := log.Fields{}
logConfig, err := utils.ParseLoggingConfig(
config, logFields, "libstorage.server")
if err != nil {
return nil, err
}
// always update the server context's log level
context.SetLogLevel(s.ctx, logConfig.Level)
s.ctx.WithFields(logFields).Info("configured logging")
s.ctx.Info("initializing server")
if err := s.initEndpoints(s.ctx); err != nil {
return nil, err
}
s.ctx.Info("initialized endpoints")
if err := services.Init(s.ctx, s.config); err != nil {
return nil, err
}
s.ctx.Info("initialized services")
if logConfig.HTTPRequests || logConfig.HTTPResponses {
s.logHTTPEnabled = true
s.logHTTPRequests = logConfig.HTTPRequests
s.logHTTPResponses = logConfig.HTTPResponses
s.stdOut = getLogIO(logConfig.Stdout, types.ConfigLogStdout)
s.stdErr = getLogIO(logConfig.Stderr, types.ConfigLogStderr)
}
s.initGlobalMiddleware()
if err := s.initRouters(); err != nil {
return nil, err
}
servers = append(servers, s)
return s, nil
}
