func (pv *PersistentValues) preRun(c *cobra.Command, args []string) { if l, err := log.ParseLevel(pv.LogLevel); err == nil { log.SetLevel(l) } pv.session = session.New(aws.NewConfig()) pv.project = &project.Project{ Log: log.Log, Path: ".", } if pv.DryRun { log.SetLevel(log.WarnLevel) pv.project.Service = dryrun.New(pv.session) pv.project.Concurrency = 1 } else { pv.project.Service = lambda.New(pv.session) } if pv.Chdir != "" { if err := os.Chdir(pv.Chdir); err != nil { log.Fatalf("error: %s", err) } } if err := pv.project.Open(); err != nil { log.Fatalf("error opening project: %s", err) } }
// PreRun sets up global tasks used for most commands, some use PreRunNoop // to remove this default behaviour. func preRun(c *cobra.Command, args []string) error { if l, err := log.ParseLevel(logLevel); err == nil { log.SetLevel(l) } config := aws.NewConfig() if profile != "" { config = config.WithCredentials(credentials.NewSharedCredentials("", profile)) } Session = session.New(config) Project = &project.Project{ Log: log.Log, Path: ".", } if dryRun { log.SetLevel(log.WarnLevel) Project.Service = dryrun.New(Session) Project.Concurrency = 1 } else { Project.Service = lambda.New(Session) } if chdir != "" { if err := os.Chdir(chdir); err != nil { return err } } return Project.Open() }
// Prepare handles the global CLI flags and shared functionality without // the assumption that a Project has already been initialized. // // Precedence is currently: // // - flags such as --profile // - env vars such as AWS_PROFILE // - files such as ~/.aws/config // func Prepare(c *cobra.Command, args []string) error { if l, err := log.ParseLevel(logLevel); err == nil { log.SetLevel(l) } // config defaults Config = aws.NewConfig() // profile from flag, config, env, "default" if profile == "" { profile, _ = utils.ProfileFromConfig(environment) if profile == "" { profile = os.Getenv("AWS_PROFILE") if profile == "" { profile = "default" } } } // the default SharedCredentialsProvider checks the env os.Setenv("AWS_PROFILE", profile) // region from flag, env, file if region == "" { region = os.Getenv("AWS_REGION") if region == "" { region, _ = utils.GetRegion(profile) } } if region != "" { Config = Config.WithRegion(region) } Session = session.New(Config) Project = &project.Project{ Environment: environment, InfraEnvironment: environment, Log: log.Log, Path: ".", } if dryRun { log.SetLevel(log.WarnLevel) Project.Service = dryrun.New(Session) Project.Concurrency = 1 } else { Project.Service = lambda.New(Session) } if chdir != "" { if err := os.Chdir(chdir); err != nil { return err } } return nil }
func main() { args, err := docopt.Parse(usage, nil, true, version, false) if err != nil { log.Fatalf("error: %s", err) } log.SetHandler(cli.Default) if l, err := log.ParseLevel(args["--log-level"].(string)); err == nil { log.SetLevel(l) } if args["help"].(bool) { showHelp(args["<topic>"]) return } session := session.New(aws.NewConfig()) project := &project.Project{ Log: log.Log, Path: ".", } if args["--dry-run"].(bool) { log.SetLevel(log.WarnLevel) project.Service = dryrun.New(session) project.Concurrency = 1 } else { project.Service = lambda.New(session) } if dir, ok := args["--chdir"].(string); ok { if err := os.Chdir(dir); err != nil { log.Fatalf("error: %s", err) } } if err := project.Open(); err != nil { log.Fatalf("error opening project: %s", err) } switch { case args["list"].(bool): list(project) case args["deploy"].(bool): deploy(project, args["<name>"].([]string), args["--env"].([]string)) case args["delete"].(bool): delete(project, args["<name>"].([]string), args["--yes"].(bool)) case args["invoke"].(bool): invoke(project, args["<name>"].([]string), args["--verbose"].(bool), args["--async"].(bool)) case args["rollback"].(bool): rollback(project, args["<name>"].([]string), args["<version>"]) case args["build"].(bool): build(project, args["<name>"].([]string)) case args["logs"].(bool): tail(project, args["<name>"].([]string), args["--filter"].(string)) } }
func main() { flag.Parse() log.SetHandler(text.New(os.Stderr)) log.SetLevel(log.DebugLevel) // set up producer svc := kinesis.New(session.New()) p := producer.New(producer.Config{ StreamName: *stream, BacklogSize: 500, Client: svc, }) p.Start() // open data file f, err := os.Open("/tmp/users.txt") if err != nil { log.Fatal("Cannot open users.txt file") } defer f.Close() // loop over file data b := bufio.NewScanner(f) for b.Scan() { err := p.Put(b.Bytes(), "site") if err != nil { log.WithError(err).Fatal("error producing") } } p.Stop() }
// PreRun sets up global tasks used for most commands, some use PreRunNoop // to remove this default behaviour. func preRun(c *cobra.Command, args []string) error { if l, err := log.ParseLevel(logLevel); err == nil { log.SetLevel(l) } // credential defaults config := aws.NewConfig() // explicit profile if profile != "" { config = config.WithCredentials(credentials.NewSharedCredentials("", profile)) } // support region from ~/.aws/config for AWS_PROFILE if profile == "" { profile = os.Getenv("AWS_PROFILE") } // region from ~/.aws/config if region, _ := utils.GetRegion(profile); region != "" { config = config.WithRegion(region) } Session = session.New(config) Project = &project.Project{ Log: log.Log, Path: ".", } if dryRun { log.SetLevel(log.WarnLevel) Project.Service = dryrun.New(Session) Project.Concurrency = 1 } else { Project.Service = lambda.New(Session) } if chdir != "" { if err := os.Chdir(chdir); err != nil { return err } } return Project.Open() }
func main() { cli.Colors[log.DebugLevel] = 90 cli.Colors[log.InfoLevel] = 32 log.SetHandler(cli.New(os.Stdout)) log.SetLevel(log.DebugLevel) cmd.Execute() }
func main() { flag.Parse() log.SetHandler(text.New(os.Stderr)) if *verbose { log.SetLevel(log.DebugLevel) } else { log.SetLevel(log.InfoLevel) } if _, err := os.Stat(tpl); os.IsNotExist(err) { log.WithError(err).Fatal("template provided does not exist") } ctx := log.WithFields(log.Fields{ "app": "spacegophers", }) s := NewServer(ctx, *addr, tpl) // serve the server s.Serve() }
func main() { log.SetHandler(text.New(os.Stderr)) log.SetLevel(log.DebugLevel) var ( app = flag.String("a", "", "App name") bucket = flag.String("b", "", "Bucket name") stream = flag.String("s", "", "Stream name") ) flag.Parse() e := &s3.Emitter{ Bucket: *bucket, Region: "us-west-1", } c := connector.NewConsumer(connector.Config{ AppName: *app, StreamName: *stream, }) c.Start(connector.HandlerFunc(func(b connector.Buffer) { body := new(bytes.Buffer) for _, r := range b.GetRecords() { body.Write(r.Data) } err := e.Emit( s3.Key("", b.FirstSeq(), b.LastSeq()), bytes.NewReader(body.Bytes()), ) if err != nil { fmt.Printf("error %s\n", err) os.Exit(1) } })) select {} // run forever }
func main() { log.SetHandler(cli.Default) log.SetLevel(log.DebugLevel) ctx := log.WithFields(log.Fields{ "file": "something.png", "type": "image/png", "user": "******", }) go func() { for range time.Tick(time.Second) { ctx.Debug("doing stuff") } }() go func() { for range time.Tick(100 * time.Millisecond) { ctx.Info("uploading") ctx.Info("upload complete") } }() go func() { for range time.Tick(time.Second) { ctx.Warn("upload slow") } }() go func() { for range time.Tick(2 * time.Second) { err := errors.New("boom") ctx.WithError(err).Error("upload failed") } }() select {} }
func main() { log.SetHandler(cli.New(os.Stdout)) log.SetLevel(log.DebugLevel) s, err := config.LoadConfig(ConfigurationFileName) if err != nil { log.Warnf("Unable to read configuration file: %s", err.Error()) } d, err := store.Init(s.Location.Database, 2500) if err != nil { log.Fatalf("Unable to connect to data store at %s: %s", s.Location.Database, err.Error()) } r := gin.New() // If redirects to the secure are enabled, attach the secure middleware helper if s.Bind.Redirect { log.Debug("Secure redirects enabled") r.Use(secure.RedirectToSecureByProxy(s.Domain, s.Bind.Ports.Secure, s.Bind.Proxy.Secure)) } r.Use(gin.Logger()) r.Use(gin.Recovery()) // Add out own Middleware r.Use(store.Connect(d)) // Connect the relevant modules to the router alive.Init(r) log.Debug("Starting Run()") err = r.Run(s.Bind.Address + ":" + strconv.FormatInt(int64(s.Bind.Ports.Standard), 10)) if err != nil { log.Fatalf("Fatal error during Run: %s", err.Error()) } }
func hookBefore(c *cli.Context) error { level := log.InfoLevel syslogLevel := syslog.LOG_INFO if c.Bool("verbose") { level = log.DebugLevel syslogLevel = syslog.LOG_DEBUG } log.SetLevel(level) log.SetHandler(text.New(os.Stderr)) if c.String("syslog-server") != "" { server := strings.Split(c.String("syslog-server"), "://") if server[0] == "unix" { log.SetHandler(multi.New(text.New(os.Stderr), sysloghandler.New("", "", syslogLevel, ""))) } else { if len(server) != 2 { log.Fatal("invalid syslog parameter") } log.SetHandler(multi.New(text.New(os.Stderr), sysloghandler.New(server[0], server[1], syslogLevel, ""))) } } return nil }
func (a *app) Run(logger service.Logger) { var logFilePath string usr, err := user.Current() if err == nil { logFilePath = filepath.Join(usr.HomeDir, ".config/go-psexec/server-hidden.log") } else { logFilePath = "server-hidden.log" } rollingFile := &lumberjack.Logger{ Filename: logFilePath, MaxSize: 20, // megabytes MaxBackups: 20, MaxAge: 28, //days } apex.SetLevel(apex.DebugLevel) //Global level apex.SetHandler(json.New(rollingFile)) tmpLogger := &defaultLogger{ logger, apex.WithField("exe", filepath.Base(os.Args[0])), } a.logger = tmpLogger defer func() { if r := recover(); r != nil { a.logger.Errorf("Panic recovery in service RUN function: %T %+v", r, r) } }() a.logger.Infof("Running server version %s", TempVersion) a.gracefulTimeout = 30 * time.Second //Because a command could be busy executing pvtKey, err := shared.ReadPemKey(*serverPemFlag) if err != nil { logger.Errorf("Cannot read server pem file, error: %s. Exiting server.", err.Error()) return } a.privateKey = pvtKey checksumsSvc := checksums.New() handlerServices := &HandlerServices{ FilePathSummaries: filepath_summary.New(checksumsSvc), } a.h = &handler{logger, a.privateKey, handlerServices} allowedKeys, err := shared.LoadAllowedPublicKeysFile(*allowedPublicKeysFileFlag) if err != nil { logger.Errorf("Cannot read allowed public keys, error: %s. Exiting server.", err.Error()) return } if len(allowedKeys) == 0 { logger.Errorf("Allowed public key file '%s' was read but contains no keys. Exiting server.", *allowedPublicKeysFileFlag) return } a.setAllowedPublicKeys(allowedKeys) watcher, err := shared.StartWatcher(*allowedPublicKeysFileFlag, a) if err != nil { } else { a.watcherPublicKeys = watcher } e := echo.New() if a.debugMode { e.SetDebug(true) } e.Use(middleware.Recover()) if a.accessLogger { loggerCfg := middleware.DefaultLoggerConfig loggerCfg.Output = tmpLogger e.Use(middleware.LoggerWithConfig(loggerCfg)) } t := &htmlTemplateRenderer{} e.SetRenderer(t) // Unrestricted group e.POST("/token", a.h.handleGenerateTokenFunc) e.GET("/webui", a.h.handleWebUIFunc) // Restricted group r := e.Group("/auth") r.Use(GetClientPubkey()) r.GET("/ping", a.h.handlePingFunc) r.GET("/version", a.h.handleVersionFunc) r.POST("/stream", a.h.handleStreamFunc) r.POST("/start", a.h.handleStartFunc) r.POST("/upload-tar", a.h.handleUploadTarFunc) r.GET("/download-tar", a.h.handleDownloadTarFunc) r.POST("/delete", a.h.handleDeleteFunc) r.POST("/move", a.h.handleMoveFunc) r.POST("/copy", a.h.handleCopyFunc) r.POST("/symlink", a.h.handleSymlinkFunc) r.GET("/stats", a.h.handleStatsFunc) r.GET("/path-summary", a.h.handlePathSummaryFunc) r.GET("/get-temp-dir", a.h.handleGetTempDirFunc) r.GET("/get-os-type", a.h.handleGetOsTypeFunc) a.logger.Infof("Now serving on '%s'", *addressFlag) server := standard.New(*addressFlag) server.SetHandler(e) server.SetLogger(e.Logger()) if e.Debug() { e.Logger().Debug("running in debug mode") } a.srv = &graceful.Server{ Timeout: a.gracefulTimeout, Server: server.Server, } a.registerInterruptSignal() err = a.srv.ListenAndServe() if err != nil { if !strings.Contains(err.Error(), "closed network connection") { logger.Errorf("Unable to ListenAndServe, error: %s", err.Error()) time.Sleep(time.Second) //Sleep a second to give log time to write out } } }
import ( "os" "time" . "github.com/onsi/ginkgo" // . "github.com/onsi/gomega" "github.com/apex/log" "github.com/apex/log/handlers/text" "github.com/joho/godotenv" ) var _ = Describe("Motivewave", func() { log.SetHandler(text.New(os.Stdout)) log.SetLevel(log.InfoLevel) godotenv.Load() path := os.Getenv("PATH_MWML") Describe("Selectors", func() { log.SetLevel(log.InfoLevel) mw := &mwQuery{} _ = mw.importMotiveWaveXML(path) markup, _ := mw.parse() It("Ongoing", func() { price := &Point{T: time.Now()} helper := NewHelper("My", markup, price)
import ( "os" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" "github.com/apex/log" "github.com/apex/log/handlers/text" "github.com/joho/godotenv" ) var _ = Describe("Markup", func() { log.SetHandler(text.New(os.Stdout)) log.SetLevel(log.DebugLevel) godotenv.Load() path := os.Getenv("PATH_MWML") Describe("Tree", func() { It("Dev", func() { mw := &mwQuery{} err := mw.importMotiveWaveXML(path) Expect(err).Should(Succeed()) markup := &Markup{} markup.processImpulses(mw)