func main() {
flagStorage := cmdFlags{}
setupFlags(&flagStorage)
flag.Parse()
if flagStorage.debug {
go debugServer(DebugAddress)
}
// when the server starts print the version for debugging and issue logs later
logrus.Infof("Version: %s, Git commit: %s", version.NotaryVersion, version.GitCommit)
ctx, serverConfig, err := parseServerConfig(flagStorage.configFile, health.RegisterPeriodicFunc, flagStorage.doBootstrap)
if err != nil {
logrus.Fatal(err.Error())
}
c := utils.SetupSignalTrap(utils.LogLevelSignalHandle)
if c != nil {
defer signal.Stop(c)
}
if flagStorage.doBootstrap {
err = bootstrap(ctx)
} else {
logrus.Info("Starting Server")
err = server.Run(ctx, serverConfig)
}
if err != nil {
logrus.Fatal(err.Error())
}
return
}
func main() {
flag.Usage = usage
flag.Parse()
if debug {
go debugServer(DebugAddress)
}
ctx := context.Background()
filename := filepath.Base(configFile)
ext := filepath.Ext(configFile)
configPath := filepath.Dir(configFile)
viper.SetConfigType(strings.TrimPrefix(ext, "."))
viper.SetConfigName(strings.TrimSuffix(filename, ext))
viper.AddConfigPath(configPath)
err := viper.ReadInConfig()
if err != nil {
logrus.Error("Viper Error: ", err.Error())
logrus.Error("Could not read config at ", configFile)
os.Exit(1)
}
logrus.SetLevel(logrus.Level(viper.GetInt("logging.level")))
sigHup := make(chan os.Signal)
sigTerm := make(chan os.Signal)
signal.Notify(sigHup, syscall.SIGHUP)
signal.Notify(sigTerm, syscall.SIGTERM)
var trust signed.CryptoService
if viper.GetString("trust_service.type") == "remote" {
logrus.Info("[Notary Server] : Using remote signing service")
trust = signer.NewRufusSigner(
viper.GetString("trust_service.hostname"),
viper.GetString("trust_service.port"),
viper.GetString("trust_service.tls_ca_file"),
)
} else {
logrus.Info("[Notary Server] : Using local signing service")
trust = signed.NewEd25519()
}
if viper.GetString("store.backend") == "mysql" {
dbURL := viper.GetString("storage.db_url")
db, err := sql.Open("mysql", dbURL)
if err != nil {
logrus.Fatal("[Notary Server] Error starting DB driver: ", err.Error())
return // not strictly needed but let's be explicit
}
ctx = context.WithValue(ctx, "metaStore", storage.NewMySQLStorage(db))
} else {
ctx = context.WithValue(ctx, "metaStore", storage.NewMemStorage())
}
logrus.Info("[Notary Server] Starting Server")
err = server.Run(
ctx,
viper.GetString("server.addr"),
viper.GetString("server.tls_cert_file"),
viper.GetString("server.tls_key_file"),
trust,
)
logrus.Error("[Notary Server]", err.Error())
return
}
func main() {
flag.Usage = usage
flag.Parse()
if debug {
go debugServer(DebugAddress)
}
// when the server starts print the version for debugging and issue logs later
logrus.Infof("Version: %s, Git commit: %s", version.NotaryVersion, version.GitCommit)
ctx := context.Background()
filename := filepath.Base(configFile)
ext := filepath.Ext(configFile)
configPath := filepath.Dir(configFile)
mainViper.SetConfigType(strings.TrimPrefix(ext, "."))
mainViper.SetConfigName(strings.TrimSuffix(filename, ext))
mainViper.AddConfigPath(configPath)
// Automatically accept configuration options from the environment
mainViper.SetEnvPrefix("NOTARY_SERVER")
mainViper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
mainViper.AutomaticEnv()
err := mainViper.ReadInConfig()
if err != nil {
logrus.Error("Viper Error: ", err.Error())
logrus.Error("Could not read config at ", configFile)
os.Exit(1)
}
lvl, err := logrus.ParseLevel(mainViper.GetString("logging.level"))
if err != nil {
lvl = logrus.ErrorLevel
logrus.Error("Could not parse log level from config. Defaulting to ErrorLevel")
}
logrus.SetLevel(lvl)
// set up bugsnag and attach to logrus
bugs := mainViper.GetString("reporting.bugsnag")
if bugs != "" {
apiKey := mainViper.GetString("reporting.bugsnag_api_key")
releaseStage := mainViper.GetString("reporting.bugsnag_release_stage")
bugsnag.Configure(bugsnag.Configuration{
APIKey: apiKey,
ReleaseStage: releaseStage,
})
hook, err := bugsnag_hook.NewBugsnagHook()
if err != nil {
logrus.Error("Could not attach bugsnag to logrus: ", err.Error())
} else {
logrus.AddHook(hook)
}
}
keyAlgo := mainViper.GetString("trust_service.key_algorithm")
if keyAlgo == "" {
logrus.Fatal("no key algorithm configured.")
os.Exit(1)
}
ctx = context.WithValue(ctx, "keyAlgorithm", keyAlgo)
var trust signed.CryptoService
if mainViper.GetString("trust_service.type") == "remote" {
logrus.Info("Using remote signing service")
clientTLS, err := grpcTLS(mainViper)
if err != nil {
logrus.Fatal(err.Error())
}
notarySigner := client.NewNotarySigner(
mainViper.GetString("trust_service.hostname"),
mainViper.GetString("trust_service.port"),
clientTLS,
)
trust = notarySigner
minute := 1 * time.Minute
health.RegisterPeriodicFunc(
"Trust operational",
// If the trust service fails, the server is degraded but not
// exactly unheatlthy, so always return healthy and just log an
// error.
func() error {
err := notarySigner.CheckHealth(minute)
if err != nil {
logrus.Error("Trust not fully operational: ", err.Error())
}
return nil
},
minute)
} else {
logrus.Info("Using local signing service")
trust = signed.NewEd25519()
}
if mainViper.GetString("storage.backend") == "mysql" {
logrus.Info("Using mysql backend")
dbURL := mainViper.GetString("storage.db_url")
store, err := storage.NewSQLStorage("mysql", dbURL)
if err != nil {
logrus.Fatal("Error starting DB driver: ", err.Error())
return // not strictly needed but let's be explicit
}
health.RegisterPeriodicFunc(
"DB operational", store.CheckHealth, time.Second*60)
ctx = context.WithValue(ctx, "metaStore", store)
} else {
logrus.Debug("Using memory backend")
ctx = context.WithValue(ctx, "metaStore", storage.NewMemStorage())
}
tlsConfig, err := serverTLS(mainViper)
if err != nil {
logrus.Fatal(err.Error())
}
logrus.Info("Starting Server")
err = server.Run(
ctx,
mainViper.GetString("server.addr"),
tlsConfig,
trust,
mainViper.GetString("auth.type"),
mainViper.Get("auth.options"),
)
logrus.Error(err.Error())
return
}
func main() {
flag.Usage = usage
flag.Parse()
if debug {
go debugServer(DebugAddress)
}
// when the server starts print the version for debugging and issue logs later
logrus.Infof("Version: %s, Git commit: %s", version.NotaryVersion, version.GitCommit)
ctx := context.Background()
filename := filepath.Base(configFile)
ext := filepath.Ext(configFile)
configPath := filepath.Dir(configFile)
viper.SetConfigType(strings.TrimPrefix(ext, "."))
viper.SetConfigName(strings.TrimSuffix(filename, ext))
viper.AddConfigPath(configPath)
// Automatically accept configuration options from the environment
viper.SetEnvPrefix("NOTARY_SERVER")
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.AutomaticEnv()
err := viper.ReadInConfig()
if err != nil {
logrus.Error("Viper Error: ", err.Error())
logrus.Error("Could not read config at ", configFile)
os.Exit(1)
}
lvl, err := logrus.ParseLevel(viper.GetString("logging.level"))
if err != nil {
lvl = logrus.ErrorLevel
logrus.Error("Could not parse log level from config. Defaulting to ErrorLevel")
}
logrus.SetLevel(lvl)
// set up bugsnag and attach to logrus
bugs := viper.GetString("reporting.bugsnag")
if bugs != "" {
apiKey := viper.GetString("reporting.bugsnag_api_key")
releaseStage := viper.GetString("reporting.bugsnag_release_stage")
bugsnag.Configure(bugsnag.Configuration{
APIKey: apiKey,
ReleaseStage: releaseStage,
})
hook, err := bugsnag_hook.NewBugsnagHook()
if err != nil {
logrus.Error("Could not attach bugsnag to logrus: ", err.Error())
} else {
logrus.AddHook(hook)
}
}
keyAlgo := viper.GetString("trust_service.key_algorithm")
if keyAlgo == "" {
logrus.Fatal("no key algorithm configured.")
os.Exit(1)
}
ctx = context.WithValue(ctx, "keyAlgorithm", keyAlgo)
var trust signed.CryptoService
if viper.GetString("trust_service.type") == "remote" {
logrus.Info("Using remote signing service")
trust = signer.NewNotarySigner(
viper.GetString("trust_service.hostname"),
viper.GetString("trust_service.port"),
viper.GetString("trust_service.tls_ca_file"),
)
} else {
logrus.Info("Using local signing service")
trust = signed.NewEd25519()
}
if viper.GetString("storage.backend") == "mysql" {
logrus.Info("Using mysql backend")
dbURL := viper.GetString("storage.db_url")
db, err := sql.Open("mysql", dbURL)
if err != nil {
logrus.Fatal("Error starting DB driver: ", err.Error())
return // not strictly needed but let's be explicit
}
ctx = context.WithValue(ctx, "metaStore", storage.NewMySQLStorage(db))
} else {
logrus.Debug("Using memory backend")
ctx = context.WithValue(ctx, "metaStore", storage.NewMemStorage())
}
logrus.Info("Starting Server")
err = server.Run(
ctx,
viper.GetString("server.addr"),
viper.GetString("server.tls_cert_file"),
viper.GetString("server.tls_key_file"),
trust,
viper.GetString("auth.type"),
viper.Get("auth.options"),
)
logrus.Error(err.Error())
return
}
func main() {
flag.Usage = usage
flag.Parse()
if DebugAddress != "" {
go debugServer(DebugAddress)
}
ctx := context.Background()
conf, err := parseConfig(configFile)
if err != nil {
logrus.Fatal("Error parsing config: ", err.Error())
return // not strictly needed but let's be explicit
}
if conf.Logging.Level > 0 {
logrus.SetLevel(logrus.Level(conf.Logging.Level))
}
sigHup := make(chan os.Signal)
sigTerm := make(chan os.Signal)
signal.Notify(sigHup, syscall.SIGHUP)
signal.Notify(sigTerm, syscall.SIGTERM)
var trust signed.CryptoService
if conf.TrustService.Type == "remote" {
logrus.Info("[Notary Server] : Using remote signing service")
trust = signer.NewRufusSigner(conf.TrustService.Hostname, conf.TrustService.Port, conf.TrustService.TLSCAFile)
} else {
logrus.Info("[Notary Server] : Using local signing service")
trust = signed.NewEd25519()
}
db, err := sql.Open("mysql", "dockercondemo:dockercondemo@tcp(notarymysql:3306)/dockercondemo")
if err != nil {
logrus.Fatal("Error starting DB driver: ", err.Error())
return // not strictly needed but let's be explicit
}
ctx = context.WithValue(ctx, "versionStore", storage.NewMySQLStorage(db))
for {
logrus.Info("[Notary Server] Starting Server")
childCtx, cancel := context.WithCancel(ctx)
go server.Run(childCtx, conf.Server, trust)
for {
select {
// On a sighup we cancel and restart a new server
// with updated config
case <-sigHup:
logrus.Infof("[Notary Server] Server restart requested. Attempting to parse config at %s", configFile)
conf, err = parseConfig(configFile)
if err != nil {
logrus.Infof("[Notary Server] Unable to parse config. Old configuration will keep running. Parse Err: %s", err.Error())
continue
} else {
cancel()
logrus.Info("[Notary Server] Stopping server for restart")
break
}
// On sigkill we cancel and shutdown
case <-sigTerm:
cancel()
logrus.Info("[Notary Server] Shutting Down Hard")
os.Exit(0)
}
}
}
}
func main() {
flag.Usage = usage
flag.Parse()
if debug {
go debugServer(DebugAddress)
}
// when the server starts print the version for debugging and issue logs later
logrus.Infof("Version: %s, Git commit: %s", version.NotaryVersion, version.GitCommit)
ctx := context.Background()
// parse viper config
if err := utils.ParseViper(mainViper, configFile); err != nil {
logrus.Fatal(err.Error())
}
// default is error level
lvl, err := utils.ParseLogLevel(mainViper, logrus.ErrorLevel)
if err != nil {
logrus.Fatal(err.Error())
}
logrus.SetLevel(lvl)
// parse bugsnag config
bugsnagConf, err := utils.ParseBugsnag(mainViper)
if err != nil {
logrus.Fatal(err.Error())
}
utils.SetUpBugsnag(bugsnagConf)
trust, keyAlgo, err := getTrustService(mainViper,
client.NewNotarySigner, health.RegisterPeriodicFunc)
if err != nil {
logrus.Fatal(err.Error())
}
ctx = context.WithValue(ctx, "keyAlgorithm", keyAlgo)
store, err := getStore(mainViper, []string{utils.MySQLBackend, utils.MemoryBackend})
if err != nil {
logrus.Fatal(err.Error())
}
ctx = context.WithValue(ctx, "metaStore", store)
httpAddr, tlsConfig, err := getAddrAndTLSConfig(mainViper)
if err != nil {
logrus.Fatal(err.Error())
}
logrus.Info("Starting Server")
err = server.Run(
ctx,
httpAddr,
tlsConfig,
trust,
mainViper.GetString("auth.type"),
mainViper.Get("auth.options"),
)
logrus.Error(err.Error())
return
}