func newCLI(format, tpl string, tplTabs bool) *CLI {
ctx := context.Background()
if testing.Verbose() {
context.SetLogLevel(ctx, log.DebugLevel)
} else {
context.SetLogLevel(ctx, log.WarnLevel)
}
return &CLI{
ctx: ctx,
outputFormat: format,
outputTemplate: tpl,
outputTemplateTabs: tplTabs,
}
}
func (c *CLI) updateLogLevel() {
lvl, err := log.ParseLevel(c.logLevel())
if err != nil {
return
}
c.ctx.WithField("level", lvl).Debug("updating log level")
log.SetLevel(lvl)
c.config.Set(apitypes.ConfigLogLevel, lvl.String())
context.SetLogLevel(c.ctx, lvl)
log.WithField("logLevel", lvl).Info("updated log level")
}
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
}
// New returns a new libStorage client.
func New(goCtx gocontext.Context, config gofig.Config) (types.Client, error) {
if config == nil {
var err error
if config, err = apicnfg.NewConfig(); err != nil {
return nil, err
}
}
config = config.Scope(types.ConfigClient)
types.BackCompat(config)
var (
c *client
err error
)
c = &client{ctx: context.New(goCtx), config: config}
c.ctx = c.ctx.WithValue(context.ClientKey, c)
logFields := log.Fields{}
logConfig, err := utils.ParseLoggingConfig(
config, logFields, "libstorage.client")
if err != nil {
return nil, err
}
// always update the server context's log level
context.SetLogLevel(c.ctx, logConfig.Level)
c.ctx.WithFields(logFields).Info("configured logging")
if config.IsSet(types.ConfigService) {
c.ctx = c.ctx.WithValue(
context.ServiceKey, config.GetString(types.ConfigService))
}
storDriverName := config.GetString(types.ConfigStorageDriver)
if storDriverName == "" {
c.ctx.Warn("no storage driver found")
} else {
if c.sd, err = registry.NewStorageDriver(storDriverName); err != nil {
return nil, err
}
if err = c.sd.Init(c.ctx, config); err != nil {
return nil, err
}
if papi, ok := c.sd.(types.ProvidesAPIClient); ok {
c.api = papi.API()
}
if pxli, pxliOk := c.sd.(types.ProvidesStorageExecutorCLI); pxliOk {
c.xli = pxli.XCLI()
}
c.ctx.Info("storage driver initialized")
}
// if the API or XLI are nil, then the storage driver is not the libStorage
// storage driver, and we should jump avoid any more initialization
if c.api == nil || c.xli == nil {
c.ctx.Info("created libStorage client")
return c, nil
}
osDriverName := config.GetString(types.ConfigOSDriver)
if osDriverName == "" {
c.ctx.Warn("no os driver found")
} else {
if c.od, err = registry.NewOSDriver(osDriverName); err != nil {
return nil, err
}
if err = c.od.Init(c.ctx, config); err != nil {
return nil, err
}
c.ctx.Info("os driver initialized")
}
intDriverName := config.GetString(types.ConfigIntegrationDriver)
if intDriverName == "" {
c.ctx.Warn("no integration driver found")
} else {
if c.id, err = registry.NewIntegrationDriver(
intDriverName); err != nil {
return nil, err
}
if err := c.id.Init(c.ctx, config); err != nil {
return nil, err
}
c.ctx.Info("integration driver initialized")
}
c.ctx.Info("created libStorage client")
return c, nil
}