func setupLogging(cfg *config) { capnslog.SetGlobalLogLevel(capnslog.INFO) if cfg.Debug { capnslog.SetGlobalLogLevel(capnslog.DEBUG) } if cfg.LogPkgLevels != "" { repoLog := capnslog.MustRepoLogger("github.com/coreos/etcd") settings, err := repoLog.ParseLogLevelConfig(cfg.LogPkgLevels) if err != nil { plog.Warningf("couldn't parse log level string: %s, continuing with default levels", err.Error()) return } repoLog.SetLogLevel(settings) } // capnslog initially SetFormatter(NewDefaultFormatter(os.Stderr)) // where NewDefaultFormatter returns NewJournaldFormatter when syscall.Getppid() == 1 // specify 'stdout' or 'stderr' to skip journald logging even when running under systemd switch cfg.logOutput { case "stdout": capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, cfg.Debug)) case "stderr": capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stderr, cfg.Debug)) case "default": default: plog.Panicf(`unknown log-output %q (only supports "default", "stdout", "stderr")`, cfg.logOutput) } }
func configure(cmd *cobra.Command, args []string) { capnslog.SetGlobalLogLevel(capnslog.WARNING) if debug { capnslog.SetGlobalLogLevel(capnslog.DEBUG) } }
func init() { capabilities.SetForTests(capabilities.Capabilities{ AllowPrivileged: true, }) flag.Set("v", "5") if len(os.Getenv("OS_TEST_VERBOSE_ETCD")) > 0 { capnslog.SetGlobalLogLevel(capnslog.DEBUG) capnslog.SetFormatter(capnslog.NewGlogFormatter(os.Stderr)) } else { capnslog.SetGlobalLogLevel(capnslog.INFO) capnslog.SetFormatter(capnslog.NewGlogFormatter(os.Stderr)) } }
func configureServer(cmd *cobra.Command, args []string) { if version { fmt.Printf("torusd\nVersion: %s\n", torus.Version) os.Exit(0) } switch { case debug: capnslog.SetGlobalLogLevel(capnslog.DEBUG) default: capnslog.SetGlobalLogLevel(capnslog.INFO) } if logpkg != "" { capnslog.SetGlobalLogLevel(capnslog.NOTICE) rl := capnslog.MustRepoLogger("github.com/coreos/torus") llc, err := rl.ParseLogLevelConfig(logpkg) if err != nil { fmt.Fprintf(os.Stderr, "error parsing logpkg: %s\n", err) os.Exit(1) } rl.SetLogLevel(llc) } if host != "" { httpAddress = fmt.Sprintf("%s:%d", host, port) } var ( err error size uint64 ) if strings.Contains(sizeStr, "%") { percent, err := parsePercentage(sizeStr) if err != nil { fmt.Fprintf(os.Stderr, "error parsing size %s: %s\n", sizeStr, err) os.Exit(1) } directory, _ := filepath.Abs(dataDir) size = du.NewDiskUsage(directory).Size() * percent / 100 } else { size, err = humanize.ParseBytes(sizeStr) if err != nil { fmt.Fprintf(os.Stderr, "error parsing size %s: %s\n", sizeStr, err) os.Exit(1) } } cfg = flagconfig.BuildConfigFromFlags() cfg.DataDir = dataDir cfg.StorageSize = size }
func setupLogging(cfg *config) { capnslog.SetGlobalLogLevel(capnslog.INFO) if cfg.debug { capnslog.SetGlobalLogLevel(capnslog.DEBUG) } if cfg.logPkgLevels != "" { repoLog := capnslog.MustRepoLogger("github.com/coreos/etcd") settings, err := repoLog.ParseLogLevelConfig(cfg.logPkgLevels) if err != nil { plog.Warningf("couldn't parse log level string: %s, continuing with default levels", err.Error()) return } repoLog.SetLogLevel(settings) } }
func main() { rl := capnslog.MustRepoLogger("github.com/coreos/pkg/capnslog/cmd") // We can parse the log level configs from the command line flag.Parse() if flag.NArg() > 1 { cfg, err := rl.ParseLogLevelConfig(flag.Arg(1)) if err != nil { log.Fatal(err) } rl.SetLogLevel(cfg) log.Infof("Setting output to %s", flag.Arg(1)) } // Send some messages at different levels to the different packages dlog.Infof("Hello Dolly") dlog.Warningf("Well hello, Dolly") log.Errorf("It's so nice to have you back where you belong") dlog.Debugf("You're looking swell, Dolly") dlog.Tracef("I can tell, Dolly") // We also have control over the built-in "log" package. capnslog.SetGlobalLogLevel(logLevel) oldlog.Println("You're still glowin', you're still crowin', you're still lookin' strong") log.Fatalf("Dolly'll never go away again") }
func main() { // Parse command-line arguments flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError) flagConfigPath := flag.String("config", "/etc/clair/config.yaml", "Load configuration from the specified file.") flagCPUProfilePath := flag.String("cpu-profile", "", "Write a CPU profile to the specified file before exiting.") flagLogLevel := flag.String("log-level", "info", "Define the logging level.") flag.Parse() // Load configuration config, err := config.Load(*flagConfigPath) if err != nil { log.Fatalf("failed to load configuration: %s", err) } // Initialize logging system logLevel, err := capnslog.ParseLevel(strings.ToUpper(*flagLogLevel)) capnslog.SetGlobalLogLevel(logLevel) capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) // Enable CPU Profiling if specified if *flagCPUProfilePath != "" { defer stopCPUProfiling(startCPUProfiling(*flagCPUProfilePath)) } clair.Boot(config) }
func init() { capabilities.SetForTests(capabilities.Capabilities{ AllowPrivileged: true, }) flag.Set("v", "5") capnslog.SetGlobalLogLevel(capnslog.DEBUG) capnslog.SetFormatter(capnslog.NewGlogFormatter(os.Stderr)) }
func main() { capnslog.SetGlobalLogLevel(capnslog.WARNING) if err := rootCommand.Execute(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } }
func ClairServiceInit() error { // Load database setting if setting.ClairDBPath != "" { clairConf.DBPath = setting.ClairDBPath } else { clairConf.DBPath = DefaultClairDBPath } clairConf.KeepDB = setting.ClairKeepDB clairConf.LogLevel = setting.ClairLogLevel clairConf.Duration = setting.ClairUpdateDuration clairConf.VulnPriority = setting.ClairVulnPriority // Set database if err := database.Open("bolt", clairConf.DBPath); err != nil { logrus.Debug(err) return err } // Set logLevel of clair lib logLevel, err := capnslog.ParseLevel(strings.ToUpper(clairConf.LogLevel)) if err != nil { logLevel, _ = capnslog.ParseLevel(strings.ToUpper(DefaultClairLogLevel)) } capnslog.SetGlobalLogLevel(logLevel) capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) // Set minumum priority parameter. if types.Priority(clairConf.VulnPriority).IsValid() { logrus.Debugf("Vuln priority is invalid :%v.", clairConf.VulnPriority) clairConf.VulnPriority = DefaultClairVulnPriority } // Set 'duration' and Update the CVE database if clairConf.Duration == "" { logrus.Debugf("No duration set, so only update at the beginning.") go updater.Update() clairStopper = nil } else { st := utils.NewStopper() st.Begin() d, err := time.ParseDuration(clairConf.Duration) if err != nil { logrus.Warnf("Wrong duration format, use the default duration: %v.", DefaultClairUpdateDuration) clairConf.Duration = DefaultClairUpdateDuration d, err = time.ParseDuration(clairConf.Duration) if err != nil { logrus.Debugf("Cannot pare du %v", err) } } go updater.Run(d, st) clairStopper = st st.Begin() } return nil }
func init() { log.SetFormatter(log.NewPrettyFormatter(os.Stdout, true)) apnsLogger = log.NewPackageLogger("apns-microservice", "apns") serverLogger = log.NewPackageLogger("apns-microservice", "http") log.SetGlobalLogLevel(log.INFO) apns.SetLogger(apnsLogger) server.SetLogger(serverLogger) }
func configureServer(cmd *cobra.Command, args []string) { switch { case debug: capnslog.SetGlobalLogLevel(capnslog.DEBUG) default: capnslog.SetGlobalLogLevel(capnslog.INFO) } if logpkg != "" { capnslog.SetGlobalLogLevel(capnslog.NOTICE) rl := capnslog.MustRepoLogger("github.com/coreos/torus") llc, err := rl.ParseLogLevelConfig(logpkg) if err != nil { fmt.Fprintf(os.Stderr, "error parsing logpkg: %s\n", err) os.Exit(1) } rl.SetLogLevel(llc) } cfg = flagconfig.BuildConfigFromFlags() }
func main() { capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) capnslog.SetGlobalLogLevel(capnslog.TRACE) plog.Debug("aaa") plog.Trace("aaa") plog.Info("aaa") plog.Notice("aaa") plog.Warning("aaa") plog.Error("aaa") plog.Fatal("aaa") plog.Panic("aaa") }
func configureServer(cmd *cobra.Command, args []string) { capnslog.SetGlobalLogLevel(capnslog.NOTICE) if logpkg != "" { rl := capnslog.MustRepoLogger("github.com/coreos/torus") llc, err := rl.ParseLogLevelConfig(logpkg) if err != nil { fmt.Fprintf(os.Stderr, "error parsing logpkg: %s\n", err) os.Exit(1) } rl.SetLogLevel(llc) } cfg = flagconfig.BuildConfigFromFlags() cfg.MetadataAddress = etcdAddress }
func main() { capnslog.SetGlobalLogLevel(capnslog.DEBUG) capnslog.SetFormatter(capnslog.NewGlogFormatter(os.Stderr)) f, err := capnslog.NewJournaldFormatter() if err == nil { capnslog.SetFormatter(f) } plog.Tracef("trace") plog.Debugf("debug") plog.Noticef("notice") plog.Infof("info") plog.Warningf("warn") plog.Errorf("error") plog.Fatalf("fatal") plog.Panicf("panic") }
func logHandleFunc(w http.ResponseWriter, r *http.Request) { if !allowMethod(w, r.Method, "PUT") { return } in := struct{ Level string }{} d := json.NewDecoder(r.Body) if err := d.Decode(&in); err != nil { writeError(w, r, httptypes.NewHTTPError(http.StatusBadRequest, "Invalid json body")) return } logl, err := capnslog.ParseLevel(strings.ToUpper(in.Level)) if err != nil { writeError(w, r, httptypes.NewHTTPError(http.StatusBadRequest, "Invalid log level "+in.Level)) return } plog.Noticef("globalLogLevel set to %q", logl.String()) capnslog.SetGlobalLogLevel(logl) w.WriteHeader(http.StatusNoContent) }
func InitializeConfig() { rl := capnslog.MustRepoLogger("github.com/ecnahc515/core") capnslog.SetFormatter(capnslog.NewStringFormatter(os.Stderr)) capnslog.SetGlobalLogLevel(capnslog.INFO) if logLevel != "" { llc, err := rl.ParseLogLevelConfig(logLevel) if err != nil { plog.Fatal(err) } rl.SetLogLevel(llc) plog.Printf("Setting log level to %s", logLevel) } // TODO move to fetch/run specifically? if coreCfg.ImageDirectory == coreos.DefaultImageDirectory { coreCfg.ImageDirectory = os.ExpandEnv(coreCfg.ImageDirectory) err := CreateDirIfNotExist(coreCfg.ImageDirectory) if err != nil { plog.Errorf("Unable to create default image directory, err: %s", err) } } }
func main() { flags := struct { address string configPath string dataPath string assetsPath string logLevel string version bool help bool }{} flag.StringVar(&flags.address, "address", "127.0.0.1:8080", "HTTP listen address") flag.StringVar(&flags.configPath, "config", "./data/config.yaml", "Path to config file") flag.StringVar(&flags.dataPath, "data-path", "./data", "Path to data directory") flag.StringVar(&flags.assetsPath, "assets-path", "./assets", "Path to static assets") // available log levels https://godoc.org/github.com/coreos/pkg/capnslog#LogLevel flag.StringVar(&flags.logLevel, "log-level", "info", "Set the logging level") // subcommands flag.BoolVar(&flags.version, "version", false, "print version and exit") flag.BoolVar(&flags.help, "help", false, "print usage and exit") // parse command-line and environment variable arguments flag.Parse() if err := flagutil.SetFlagsFromEnv(flag.CommandLine, "BOOTCFG"); err != nil { log.Fatal(err.Error()) } if flags.version { fmt.Println(version) return } if flags.help { flag.Usage() return } // validate arguments if url, err := url.Parse(flags.address); err != nil || url.String() == "" { log.Fatal("A valid HTTP listen address is required") } if finfo, err := os.Stat(flags.configPath); err != nil || finfo.IsDir() { log.Fatal("A path to a config file is required") } if finfo, err := os.Stat(flags.dataPath); err != nil || !finfo.IsDir() { log.Fatal("A path to a data directory is required") } if finfo, err := os.Stat(flags.assetsPath); err != nil || !finfo.IsDir() { log.Fatal("A path to an assets directory is required") } // logging setup lvl, err := capnslog.ParseLevel(strings.ToUpper(flags.logLevel)) if err != nil { log.Fatalf("Invalid log-level: %v", err.Error()) } capnslog.SetGlobalLogLevel(lvl) capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) // storage store := api.NewFileStore(http.Dir(flags.dataPath)) // load bootstrap config cfg, err := config.LoadConfig(flags.configPath) if err != nil { log.Fatal(err) } store.BootstrapGroups(cfg.Groups) // API server config := &api.Config{ Store: store, AssetsPath: flags.assetsPath, } server := api.NewServer(config) log.Infof("starting bootcfg API Server on %s", flags.address) err = http.ListenAndServe(flags.address, server.HTTPHandler()) if err != nil { log.Fatalf("failed to start listening: %s", err) } }
func init() { capnslog.SetGlobalLogLevel(capnslog.CRITICAL) }
func init() { capnslog.SetGlobalLogLevel(capnslog.INFO) }
func main() { flags := struct { address string rpcAddress string dataPath string assetsPath string logLevel string certFile string keyFile string caFile string keyRingPath string version bool help bool }{} flag.StringVar(&flags.address, "address", "127.0.0.1:8080", "HTTP listen address") flag.StringVar(&flags.rpcAddress, "rpc-address", "", "RPC listen address") flag.StringVar(&flags.dataPath, "data-path", "/var/lib/bootcfg", "Path to data directory") flag.StringVar(&flags.assetsPath, "assets-path", "/var/lib/bootcfg/assets", "Path to static assets") // Log levels https://godoc.org/github.com/coreos/pkg/capnslog#LogLevel flag.StringVar(&flags.logLevel, "log-level", "info", "Set the logging level") // gRPC Server TLS flag.StringVar(&flags.certFile, "cert-file", "/etc/bootcfg/server.crt", "Path to the server TLS certificate file") flag.StringVar(&flags.keyFile, "key-file", "/etc/bootcfg/server.key", "Path to the server TLS key file") // TLS Client Authentication flag.StringVar(&flags.caFile, "ca-file", "/etc/bootcfg/ca.crt", "Path to the CA verify and authenticate client certificates") // Signing flag.StringVar(&flags.keyRingPath, "key-ring-path", "", "Path to a private keyring file") // subcommands flag.BoolVar(&flags.version, "version", false, "print version and exit") flag.BoolVar(&flags.help, "help", false, "print usage and exit") // parse command-line and environment variable arguments flag.Parse() if err := flagutil.SetFlagsFromEnv(flag.CommandLine, "BOOTCFG"); err != nil { log.Fatal(err.Error()) } // restrict OpenPGP passphrase to pass via environment variable only passphrase := os.Getenv("BOOTCFG_PASSPHRASE") if flags.version { fmt.Println(version.Version) return } if flags.help { flag.Usage() return } // validate arguments if url, err := url.Parse(flags.address); err != nil || url.String() == "" { log.Fatal("A valid HTTP listen address is required") } if finfo, err := os.Stat(flags.dataPath); err != nil || !finfo.IsDir() { log.Fatal("A valid -data-path is required") } if flags.assetsPath != "" { if finfo, err := os.Stat(flags.assetsPath); err != nil || !finfo.IsDir() { log.Fatalf("Provide a valid -assets-path or '' to disable asset serving: %s", flags.assetsPath) } } if flags.rpcAddress != "" { if _, err := os.Stat(flags.certFile); err != nil { log.Fatalf("Provide a valid TLS server certificate with -cert-file: %v", err) } if _, err := os.Stat(flags.keyFile); err != nil { log.Fatalf("Provide a valid TLS server key with -key-file: %v", err) } if _, err := os.Stat(flags.caFile); err != nil { log.Fatalf("Provide a valid TLS certificate authority for authorizing client certificates: %v", err) } } // logging setup lvl, err := capnslog.ParseLevel(strings.ToUpper(flags.logLevel)) if err != nil { log.Fatalf("invalid log-level: %v", err) } capnslog.SetGlobalLogLevel(lvl) capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) // (optional) signing var signer, armoredSigner sign.Signer if flags.keyRingPath != "" { entity, err := sign.LoadGPGEntity(flags.keyRingPath, passphrase) if err != nil { log.Fatal(err) } signer = sign.NewGPGSigner(entity) armoredSigner = sign.NewArmoredGPGSigner(entity) } // storage store := storage.NewFileStore(&storage.Config{ Root: flags.dataPath, }) // core logic server := server.NewServer(&server.Config{ Store: store, }) // gRPC Server (feature disabled by default) if flags.rpcAddress != "" { log.Infof("starting bootcfg gRPC server on %s", flags.rpcAddress) log.Infof("Using TLS server certificate: %s", flags.certFile) log.Infof("Using TLS server key: %s", flags.keyFile) log.Infof("Using CA certificate: %s to authenticate client certificates", flags.caFile) lis, err := net.Listen("tcp", flags.rpcAddress) if err != nil { log.Fatalf("failed to start listening: %v", err) } tlsinfo := tlsutil.TLSInfo{ CertFile: flags.certFile, KeyFile: flags.keyFile, CAFile: flags.caFile, } tlscfg, err := tlsinfo.ServerConfig() if err != nil { log.Fatalf("Invalid TLS credentials: %v", err) } grpcServer := rpc.NewServer(server, tlscfg) go grpcServer.Serve(lis) defer grpcServer.Stop() } // HTTP Server config := &web.Config{ Store: store, AssetsPath: flags.assetsPath, Signer: signer, ArmoredSigner: armoredSigner, } httpServer := web.NewServer(config) log.Infof("starting bootcfg HTTP server on %s", flags.address) err = http.ListenAndServe(flags.address, httpServer.HTTPHandler()) if err != nil { log.Fatalf("failed to start listening: %v", err) } }
func main() { rand.Seed(time.Now().UTC().UnixNano()) var err error st := utils.NewStopper() // Parse command-line arguments kingpin.Parse() if *cfgDbType != "memstore" && *cfgDbPath == "" { kingpin.Errorf("required flag --db-path not provided, try --help") os.Exit(1) } if *cfgNotifierType == "http" && *cfgNotifierHTTPURL == "" { kingpin.Errorf("required flag --notifier-http-url not provided, try --help") os.Exit(1) } // Initialize error/logging system logLevel, err := capnslog.ParseLevel(strings.ToUpper(*cfgLogLevel)) capnslog.SetGlobalLogLevel(logLevel) capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) // Enable CPU Profiling if specified if *cfgCPUProfilePath != "" { f, err := os.Create(*cfgCPUProfilePath) if err != nil { log.Fatalf("failed to create profile file: %s", err) } defer f.Close() pprof.StartCPUProfile(f) log.Info("started profiling") defer func() { pprof.StopCPUProfile() log.Info("stopped profiling") }() } // Open database err = database.Open(*cfgDbType, *cfgDbPath) if err != nil { log.Fatal(err) } defer database.Close() // Start notifier var notifierService notifier.Notifier switch *cfgNotifierType { case "http": notifierService, err = notifier.NewHTTPNotifier(*cfgNotifierHTTPURL) if err != nil { log.Fatalf("could not initialize HTTP notifier: %s", err) } } if notifierService != nil { st.Begin() go notifierService.Run(st) } // Start Main API and Health API st.Begin() go api.RunMain(&api.Config{ Port: *cfgAPIPort, TimeOut: *cfgAPITimeout, CertFile: *cfgAPICertFile, KeyFile: *cfgAPIKeyFile, CAFile: *cfgAPICAFile, }, st) st.Begin() go api.RunHealth(*cfgAPIPort+1, st) // Start updater st.Begin() go updater.Run(*cfgUpdateInterval, st) // This blocks the main goroutine which is required to keep all the other goroutines running interrupts := make(chan os.Signal, 1) signal.Notify(interrupts, os.Interrupt) <-interrupts log.Info("Received interruption, gracefully stopping ...") st.Stop() }
func configureServer(cmd *cobra.Command, args []string) { if version { fmt.Printf("torusd\nVersion: %s\n", torus.Version) os.Exit(0) } switch { case debug: capnslog.SetGlobalLogLevel(capnslog.DEBUG) default: capnslog.SetGlobalLogLevel(capnslog.INFO) } if logpkg != "" { capnslog.SetGlobalLogLevel(capnslog.NOTICE) rl := capnslog.MustRepoLogger("github.com/coreos/torus") llc, err := rl.ParseLogLevelConfig(logpkg) if err != nil { fmt.Fprintf(os.Stderr, "error parsing logpkg: %s\n", err) os.Exit(1) } rl.SetLogLevel(llc) } if host != "" { httpAddress = fmt.Sprintf("%s:%d", host, port) } var err error readCacheSize, err = humanize.ParseBytes(readCacheSizeStr) if err != nil { fmt.Fprintf(os.Stderr, "error parsing read-cache-size: %s\n", err) os.Exit(1) } size, err = humanize.ParseBytes(sizeStr) if err != nil { fmt.Fprintf(os.Stderr, "error parsing size: %s\n", err) os.Exit(1) } var rl torus.ReadLevel switch readLevel { case "spread": rl = torus.ReadSpread case "seq": rl = torus.ReadSequential case "block": rl = torus.ReadBlock default: fmt.Fprintf(os.Stderr, "invalid readlevel; use one of 'spread', 'seq', or 'block'") os.Exit(1) } var wl torus.WriteLevel switch writeLevel { case "all": wl = torus.WriteAll case "one": wl = torus.WriteOne case "local": wl = torus.WriteLocal default: fmt.Fprintf(os.Stderr, "invalid writelevel; use one of 'one', 'all', or 'local'") os.Exit(1) } cfg = torus.Config{ DataDir: dataDir, StorageSize: size, MetadataAddress: etcdAddress, ReadCacheSize: readCacheSize, WriteLevel: wl, ReadLevel: rl, } }