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)