2 |
3 | [Papertrail](https://papertrailapp.com) provides hosted log management. Once stored in Papertrail, you can [group](http://help.papertrailapp.com/kb/how-it-works/groups/) your logs on various dimensions, [search](http://help.papertrailapp.com/kb/how-it-works/search-syntax) them, and trigger [alerts](http://help.papertrailapp.com/kb/how-it-works/alerts).
4 |
5 | In most deployments, you'll want to send logs to Papertrail via their [remote_syslog](http://help.papertrailapp.com/kb/configuration/configuring-centralized-logging-from-text-log-files-in-unix/) daemon, which requires no application-specific configuration. This hook is intended for relatively low-volume logging, likely in managed cloud hosting deployments where installing `remote_syslog` is not possible.
6 |
7 | ## Usage
8 |
9 | You can find your Papertrail UDP port on your [Papertrail account page](https://papertrailapp.com/account/destinations). Substitute it below for `YOUR_PAPERTRAIL_UDP_PORT`.
10 |
11 | For `YOUR_APP_NAME`, substitute a short string that will readily identify your application or service in the logs.
12 |
13 | ```go
14 | import (
15 | "log/syslog"
16 | "github.com/Sirupsen/logrus"
17 | "github.com/Sirupsen/logrus/hooks/papertrail"
18 | )
19 |
20 | func main() {
21 | log := logrus.New()
22 | hook, err := logrus_papertrail.NewPapertrailHook("logs.papertrailapp.com", YOUR_PAPERTRAIL_UDP_PORT, YOUR_APP_NAME)
23 |
24 | if err == nil {
25 | log.Hooks.Add(hook)
26 | }
27 | }
28 | ```
29 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/hooks/papertrail/papertrail.go:
--------------------------------------------------------------------------------
1 | package logrus_papertrail
2 |
3 | import (
4 | "fmt"
5 | "net"
6 | "os"
7 | "time"
8 |
9 | "github.com/Sirupsen/logrus"
10 | )
11 |
12 | const (
13 | format = "Jan 2 15:04:05"
14 | )
15 |
16 | // PapertrailHook to send logs to a logging service compatible with the Papertrail API.
17 | type PapertrailHook struct {
18 | Host string
19 | Port int
20 | AppName string
21 | UDPConn net.Conn
22 | }
23 |
24 | // NewPapertrailHook creates a hook to be added to an instance of logger.
25 | func NewPapertrailHook(host string, port int, appName string) (*PapertrailHook, error) {
26 | conn, err := net.Dial("udp", fmt.Sprintf("%s:%d", host, port))
27 | return &PapertrailHook{host, port, appName, conn}, err
28 | }
29 |
30 | // Fire is called when a log event is fired.
31 | func (hook *PapertrailHook) Fire(entry *logrus.Entry) error {
32 | date := time.Now().Format(format)
33 | msg, _ := entry.String()
34 | payload := fmt.Sprintf("<22> %s %s: %s", date, hook.AppName, msg)
35 |
36 | bytesWritten, err := hook.UDPConn.Write([]byte(payload))
37 | if err != nil {
38 | fmt.Fprintf(os.Stderr, "Unable to send log line to Papertrail via UDP. Wrote %d bytes before error: %v", bytesWritten, err)
39 | return err
40 | }
41 |
42 | return nil
43 | }
44 |
45 | // Levels returns the available logging levels.
46 | func (hook *PapertrailHook) Levels() []logrus.Level {
47 | return []logrus.Level{
48 | logrus.PanicLevel,
49 | logrus.FatalLevel,
50 | logrus.ErrorLevel,
51 | logrus.WarnLevel,
52 | logrus.InfoLevel,
53 | logrus.DebugLevel,
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/hooks/papertrail/papertrail_test.go:
--------------------------------------------------------------------------------
1 | package logrus_papertrail
2 |
3 | import (
4 | "fmt"
5 | "testing"
6 |
7 | "github.com/Sirupsen/logrus"
8 | "github.com/stvp/go-udp-testing"
9 | )
10 |
11 | func TestWritingToUDP(t *testing.T) {
12 | port := 16661
13 | udp.SetAddr(fmt.Sprintf(":%d", port))
14 |
15 | hook, err := NewPapertrailHook("localhost", port, "test")
16 | if err != nil {
17 | t.Errorf("Unable to connect to local UDP server.")
18 | }
19 |
20 | log := logrus.New()
21 | log.Hooks.Add(hook)
22 |
23 | udp.ShouldReceive(t, "foo", func() {
24 | log.Info("foo")
25 | })
26 | }
27 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/hooks/syslog/README.md:
--------------------------------------------------------------------------------
1 | # Syslog Hooks for Logrus
2 |
3 | ## Usage
4 |
5 | ```go
6 | import (
7 | "log/syslog"
8 | "github.com/Sirupsen/logrus"
9 | logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
10 | )
11 |
12 | func main() {
13 | log := logrus.New()
14 | hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
15 |
16 | if err == nil {
17 | log.Hooks.Add(hook)
18 | }
19 | }
20 | ```
21 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/hooks/syslog/syslog.go:
--------------------------------------------------------------------------------
1 | package logrus_syslog
2 |
3 | import (
4 | "fmt"
5 | "github.com/Sirupsen/logrus"
6 | "log/syslog"
7 | "os"
8 | )
9 |
10 | // SyslogHook to send logs via syslog.
11 | type SyslogHook struct {
12 | Writer *syslog.Writer
13 | SyslogNetwork string
14 | SyslogRaddr string
15 | }
16 |
17 | // Creates a hook to be added to an instance of logger. This is called with
18 | // `hook, err := NewSyslogHook("udp", "localhost:514", syslog.LOG_DEBUG, "")`
19 | // `if err == nil { log.Hooks.Add(hook) }`
20 | func NewSyslogHook(network, raddr string, priority syslog.Priority, tag string) (*SyslogHook, error) {
21 | w, err := syslog.Dial(network, raddr, priority, tag)
22 | return &SyslogHook{w, network, raddr}, err
23 | }
24 |
25 | func (hook *SyslogHook) Fire(entry *logrus.Entry) error {
26 | line, err := entry.String()
27 | if err != nil {
28 | fmt.Fprintf(os.Stderr, "Unable to read entry, %v", err)
29 | return err
30 | }
31 |
32 | switch entry.Level {
33 | case logrus.PanicLevel:
34 | return hook.Writer.Crit(line)
35 | case logrus.FatalLevel:
36 | return hook.Writer.Crit(line)
37 | case logrus.ErrorLevel:
38 | return hook.Writer.Err(line)
39 | case logrus.WarnLevel:
40 | return hook.Writer.Warning(line)
41 | case logrus.InfoLevel:
42 | return hook.Writer.Info(line)
43 | case logrus.DebugLevel:
44 | return hook.Writer.Debug(line)
45 | default:
46 | return nil
47 | }
48 | }
49 |
50 | func (hook *SyslogHook) Levels() []logrus.Level {
51 | return []logrus.Level{
52 | logrus.PanicLevel,
53 | logrus.FatalLevel,
54 | logrus.ErrorLevel,
55 | logrus.WarnLevel,
56 | logrus.InfoLevel,
57 | logrus.DebugLevel,
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/hooks/syslog/syslog_test.go:
--------------------------------------------------------------------------------
1 | package logrus_syslog
2 |
3 | import (
4 | "github.com/Sirupsen/logrus"
5 | "log/syslog"
6 | "testing"
7 | )
8 |
9 | func TestLocalhostAddAndPrint(t *testing.T) {
10 | log := logrus.New()
11 | hook, err := NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
12 |
13 | if err != nil {
14 | t.Errorf("Unable to connect to local syslog.")
15 | }
16 |
17 | log.Hooks.Add(hook)
18 |
19 | for _, level := range hook.Levels() {
20 | if len(log.Hooks[level]) != 1 {
21 | t.Errorf("SyslogHook was not added. The length of log.Hooks[%v]: %v", level, len(log.Hooks[level]))
22 | }
23 | }
24 |
25 | log.Info("Congratulations!")
26 | }
27 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/json_formatter.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | )
7 |
8 | type JSONFormatter struct {
9 | // TimestampFormat sets the format used for marshaling timestamps.
10 | TimestampFormat string
11 | }
12 |
13 | func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
14 | data := make(Fields, len(entry.Data)+3)
15 | for k, v := range entry.Data {
16 | switch v := v.(type) {
17 | case error:
18 | // Otherwise errors are ignored by `encoding/json`
19 | // https://github.com/Sirupsen/logrus/issues/137
20 | data[k] = v.Error()
21 | default:
22 | data[k] = v
23 | }
24 | }
25 | prefixFieldClashes(data)
26 |
27 | timestampFormat := f.TimestampFormat
28 | if timestampFormat == "" {
29 | timestampFormat = DefaultTimestampFormat
30 | }
31 |
32 | data["time"] = entry.Time.Format(timestampFormat)
33 | data["msg"] = entry.Message
34 | data["level"] = entry.Level.String()
35 |
36 | serialized, err := json.Marshal(data)
37 | if err != nil {
38 | return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
39 | }
40 | return append(serialized, '\n'), nil
41 | }
42 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/logrus.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | import (
4 | "fmt"
5 | "log"
6 | )
7 |
8 | // Fields type, used to pass to `WithFields`.
9 | type Fields map[string]interface{}
10 |
11 | // Level type
12 | type Level uint8
13 |
14 | // Convert the Level to a string. E.g. PanicLevel becomes "panic".
15 | func (level Level) String() string {
16 | switch level {
17 | case DebugLevel:
18 | return "debug"
19 | case InfoLevel:
20 | return "info"
21 | case WarnLevel:
22 | return "warning"
23 | case ErrorLevel:
24 | return "error"
25 | case FatalLevel:
26 | return "fatal"
27 | case PanicLevel:
28 | return "panic"
29 | }
30 |
31 | return "unknown"
32 | }
33 |
34 | // ParseLevel takes a string level and returns the Logrus log level constant.
35 | func ParseLevel(lvl string) (Level, error) {
36 | switch lvl {
37 | case "panic":
38 | return PanicLevel, nil
39 | case "fatal":
40 | return FatalLevel, nil
41 | case "error":
42 | return ErrorLevel, nil
43 | case "warn", "warning":
44 | return WarnLevel, nil
45 | case "info":
46 | return InfoLevel, nil
47 | case "debug":
48 | return DebugLevel, nil
49 | }
50 |
51 | var l Level
52 | return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
53 | }
54 |
55 | // These are the different logging levels. You can set the logging level to log
56 | // on your instance of logger, obtained with `logrus.New()`.
57 | const (
58 | // PanicLevel level, highest level of severity. Logs and then calls panic with the
59 | // message passed to Debug, Info, ...
60 | PanicLevel Level = iota
61 | // FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
62 | // logging level is set to Panic.
63 | FatalLevel
64 | // ErrorLevel level. Logs. Used for errors that should definitely be noted.
65 | // Commonly used for hooks to send errors to an error tracking service.
66 | ErrorLevel
67 | // WarnLevel level. Non-critical entries that deserve eyes.
68 | WarnLevel
69 | // InfoLevel level. General operational entries about what's going on inside the
70 | // application.
71 | InfoLevel
72 | // DebugLevel level. Usually only enabled when debugging. Very verbose logging.
73 | DebugLevel
74 | )
75 |
76 | // Won't compile if StdLogger can't be realized by a log.Logger
77 | var (
78 | _ StdLogger = &log.Logger{}
79 | _ StdLogger = &Entry{}
80 | _ StdLogger = &Logger{}
81 | )
82 |
83 | // StdLogger is what your logrus-enabled library should take, that way
84 | // it'll accept a stdlib logger and a logrus logger. There's no standard
85 | // interface, this is the closest we get, unfortunately.
86 | type StdLogger interface {
87 | Print(...interface{})
88 | Printf(string, ...interface{})
89 | Println(...interface{})
90 |
91 | Fatal(...interface{})
92 | Fatalf(string, ...interface{})
93 | Fatalln(...interface{})
94 |
95 | Panic(...interface{})
96 | Panicf(string, ...interface{})
97 | Panicln(...interface{})
98 | }
99 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/terminal_bsd.go:
--------------------------------------------------------------------------------
1 | // +build darwin freebsd openbsd netbsd dragonfly
2 |
3 | package logrus
4 |
5 | import "syscall"
6 |
7 | const ioctlReadTermios = syscall.TIOCGETA
8 |
9 | type Termios syscall.Termios
10 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/terminal_linux.go:
--------------------------------------------------------------------------------
1 | // Based on ssh/terminal:
2 | // Copyright 2013 The Go Authors. All rights reserved.
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package logrus
7 |
8 | import "syscall"
9 |
10 | const ioctlReadTermios = syscall.TCGETS
11 |
12 | type Termios syscall.Termios
13 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/terminal_notwindows.go:
--------------------------------------------------------------------------------
1 | // Based on ssh/terminal:
2 | // Copyright 2011 The Go Authors. All rights reserved.
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | // +build linux darwin freebsd openbsd netbsd dragonfly
7 |
8 | package logrus
9 |
10 | import (
11 | "syscall"
12 | "unsafe"
13 | )
14 |
15 | // IsTerminal returns true if the given file descriptor is a terminal.
16 | func IsTerminal() bool {
17 | fd := syscall.Stdout
18 | var termios Termios
19 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
20 | return err == 0
21 | }
22 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/terminal_windows.go:
--------------------------------------------------------------------------------
1 | // Based on ssh/terminal:
2 | // Copyright 2011 The Go Authors. All rights reserved.
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | // +build windows
7 |
8 | package logrus
9 |
10 | import (
11 | "syscall"
12 | "unsafe"
13 | )
14 |
15 | var kernel32 = syscall.NewLazyDLL("kernel32.dll")
16 |
17 | var (
18 | procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
19 | )
20 |
21 | // IsTerminal returns true if the given file descriptor is a terminal.
22 | func IsTerminal() bool {
23 | fd := syscall.Stdout
24 | var st uint32
25 | r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
26 | return r != 0 && e == 0
27 | }
28 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/text_formatter_test.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | import (
4 | "bytes"
5 | "errors"
6 | "testing"
7 | "time"
8 | )
9 |
10 | func TestQuoting(t *testing.T) {
11 | tf := &TextFormatter{DisableColors: true}
12 |
13 | checkQuoting := func(q bool, value interface{}) {
14 | b, _ := tf.Format(WithField("test", value))
15 | idx := bytes.Index(b, ([]byte)("test="))
16 | cont := bytes.Contains(b[idx+5:], []byte{'"'})
17 | if cont != q {
18 | if q {
19 | t.Errorf("quoting expected for: %#v", value)
20 | } else {
21 | t.Errorf("quoting not expected for: %#v", value)
22 | }
23 | }
24 | }
25 |
26 | checkQuoting(false, "abcd")
27 | checkQuoting(false, "v1.0")
28 | checkQuoting(false, "1234567890")
29 | checkQuoting(true, "/foobar")
30 | checkQuoting(true, "x y")
31 | checkQuoting(true, "x,y")
32 | checkQuoting(false, errors.New("invalid"))
33 | checkQuoting(true, errors.New("invalid argument"))
34 | }
35 |
36 | func TestTimestampFormat(t *testing.T) {
37 | checkTimeStr := func(format string) {
38 | customFormatter := &TextFormatter{DisableColors: true, TimestampFormat: format}
39 | customStr, _ := customFormatter.Format(WithField("test", "test"))
40 | timeStart := bytes.Index(customStr, ([]byte)("time="))
41 | timeEnd := bytes.Index(customStr, ([]byte)("level="))
42 | timeStr := customStr[timeStart+5 : timeEnd-1]
43 | if timeStr[0] == '"' && timeStr[len(timeStr)-1] == '"' {
44 | timeStr = timeStr[1 : len(timeStr)-1]
45 | }
46 | if format == "" {
47 | format = time.RFC3339
48 | }
49 | _, e := time.Parse(format, (string)(timeStr))
50 | if e != nil {
51 | t.Errorf("time string \"%s\" did not match provided time format \"%s\": %s", timeStr, format, e)
52 | }
53 | }
54 |
55 | checkTimeStr("2006-01-02T15:04:05.000000000Z07:00")
56 | checkTimeStr("Mon Jan _2 15:04:05 2006")
57 | checkTimeStr("")
58 | }
59 |
60 | // TODO add tests for sorting etc., this requires a parser for the text
61 | // formatter output.
62 |
--------------------------------------------------------------------------------
/vendor/src/github.com/Sirupsen/logrus/writer.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | import (
4 | "bufio"
5 | "io"
6 | "runtime"
7 | )
8 |
9 | func (logger *Logger) Writer() *io.PipeWriter {
10 | reader, writer := io.Pipe()
11 |
12 | go logger.writerScanner(reader)
13 | runtime.SetFinalizer(writer, writerFinalizer)
14 |
15 | return writer
16 | }
17 |
18 | func (logger *Logger) writerScanner(reader *io.PipeReader) {
19 | scanner := bufio.NewScanner(reader)
20 | for scanner.Scan() {
21 | logger.Print(scanner.Text())
22 | }
23 | if err := scanner.Err(); err != nil {
24 | logger.Errorf("Error while reading from Writer: %s", err)
25 | }
26 | reader.Close()
27 | }
28 |
29 | func writerFinalizer(writer *io.PipeWriter) {
30 | writer.Close()
31 | }
32 |
--------------------------------------------------------------------------------
/vendor/src/github.com/alecthomas/kingpin/COPYING:
--------------------------------------------------------------------------------
1 | Copyright (C) 2014 Alec Thomas
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
4 | this software and associated documentation files (the "Software"), to deal in
5 | the Software without restriction, including without limitation the rights to
6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
7 | of the Software, and to permit persons to whom the Software is furnished to do
8 | so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 |
--------------------------------------------------------------------------------
/vendor/src/github.com/alecthomas/kingpin/actions.go:
--------------------------------------------------------------------------------
1 | package kingpin
2 |
3 | // Action callback executed at various stages after all values are populated.
4 | // The application, commands, arguments and flags all have corresponding
5 | // actions.
6 | type Action func(*ParseContext) error
7 |
8 | type actionMixin struct {
9 | actions []Action
10 | preActions []Action
11 | }
12 |
13 | type actionApplier interface {
14 | applyActions(*ParseContext) error
15 | applyPreActions(*ParseContext) error
16 | }
17 |
18 | func (a *actionMixin) addAction(action Action) {
19 | a.actions = append(a.actions, action)
20 | }
21 |
22 | func (a *actionMixin) addPreAction(action Action) {
23 | a.preActions = append(a.preActions, action)
24 | }
25 |
26 | func (a *actionMixin) applyActions(context *ParseContext) error {
27 | for _, action := range a.actions {
28 | if err := action(context); err != nil {
29 | return err
30 | }
31 | }
32 | return nil
33 | }
34 |
35 | func (a *actionMixin) applyPreActions(context *ParseContext) error {
36 | for _, preAction := range a.preActions {
37 | if err := preAction(context); err != nil {
38 | return err
39 | }
40 | }
41 | return nil
42 | }
43 |
--------------------------------------------------------------------------------
/vendor/src/github.com/alecthomas/kingpin/args.go:
--------------------------------------------------------------------------------
1 | package kingpin
2 |
3 | import "fmt"
4 |
5 | type argGroup struct {
6 | args []*ArgClause
7 | }
8 |
9 | func newArgGroup() *argGroup {
10 | return &argGroup{}
11 | }
12 |
13 | func (a *argGroup) have() bool {
14 | return len(a.args) > 0
15 | }
16 |
17 | func (a *argGroup) Arg(name, help string) *ArgClause {
18 | arg := newArg(name, help)
19 | a.args = append(a.args, arg)
20 | return arg
21 | }
22 |
23 | func (a *argGroup) init() error {
24 | required := 0
25 | seen := map[string]struct{}{}
26 | previousArgMustBeLast := false
27 | for i, arg := range a.args {
28 | if previousArgMustBeLast {
29 | return fmt.Errorf("Args() can't be followed by another argument '%s'", arg.name)
30 | }
31 | if arg.consumesRemainder() {
32 | previousArgMustBeLast = true
33 | }
34 | if _, ok := seen[arg.name]; ok {
35 | return fmt.Errorf("duplicate argument '%s'", arg.name)
36 | }
37 | seen[arg.name] = struct{}{}
38 | if arg.required && required != i {
39 | return fmt.Errorf("required arguments found after non-required")
40 | }
41 | if arg.required {
42 | required++
43 | }
44 | if err := arg.init(); err != nil {
45 | return err
46 | }
47 | }
48 | return nil
49 | }
50 |
51 | type ArgClause struct {
52 | actionMixin
53 | parserMixin
54 | name string
55 | help string
56 | defaultValue string
57 | required bool
58 | }
59 |
60 | func newArg(name, help string) *ArgClause {
61 | a := &ArgClause{
62 | name: name,
63 | help: help,
64 | }
65 | return a
66 | }
67 |
68 | func (a *ArgClause) consumesRemainder() bool {
69 | if r, ok := a.value.(remainderArg); ok {
70 | return r.IsCumulative()
71 | }
72 | return false
73 | }
74 |
75 | // Required arguments must be input by the user. They can not have a Default() value provided.
76 | func (a *ArgClause) Required() *ArgClause {
77 | a.required = true
78 | return a
79 | }
80 |
81 | // Default value for this argument. It *must* be parseable by the value of the argument.
82 | func (a *ArgClause) Default(value string) *ArgClause {
83 | a.defaultValue = value
84 | return a
85 | }
86 |
87 | func (a *ArgClause) Action(action Action) *ArgClause {
88 | a.addAction(action)
89 | return a
90 | }
91 |
92 | func (a *ArgClause) PreAction(action Action) *ArgClause {
93 | a.addPreAction(action)
94 | return a
95 | }
96 |
97 | func (a *ArgClause) init() error {
98 | if a.required && a.defaultValue != "" {
99 | return fmt.Errorf("required argument '%s' with unusable default value", a.name)
100 | }
101 | if a.value == nil {
102 | return fmt.Errorf("no parser defined for arg '%s'", a.name)
103 | }
104 | return nil
105 | }
106 |
--------------------------------------------------------------------------------
/vendor/src/github.com/alecthomas/kingpin/args_test.go:
--------------------------------------------------------------------------------
1 | package kingpin
2 |
3 | import (
4 | "io/ioutil"
5 | "testing"
6 |
7 | "github.com/stretchr/testify/assert"
8 | )
9 |
10 | func TestArgRemainder(t *testing.T) {
11 | app := New("test", "")
12 | v := app.Arg("test", "").Strings()
13 | args := []string{"hello", "world"}
14 | _, err := app.Parse(args)
15 | assert.NoError(t, err)
16 | assert.Equal(t, args, *v)
17 | }
18 |
19 | func TestArgRemainderErrorsWhenNotLast(t *testing.T) {
20 | a := newArgGroup()
21 | a.Arg("test", "").Strings()
22 | a.Arg("test2", "").String()
23 | assert.Error(t, a.init())
24 | }
25 |
26 | func TestArgMultipleRequired(t *testing.T) {
27 | terminated := false
28 | app := New("test", "")
29 | app.Version("0.0.0").Writer(ioutil.Discard)
30 | app.Arg("a", "").Required().String()
31 | app.Arg("b", "").Required().String()
32 | app.Terminate(func(int) { terminated = true })
33 |
34 | _, err := app.Parse([]string{})
35 | assert.Error(t, err)
36 | _, err = app.Parse([]string{"A"})
37 | assert.Error(t, err)
38 | _, err = app.Parse([]string{"A", "B"})
39 | assert.NoError(t, err)
40 | _, err = app.Parse([]string{"--version"})
41 | assert.True(t, terminated)
42 | }
43 |
44 | func TestInvalidArgsDefaultCanBeOverridden(t *testing.T) {
45 | app := New("test", "")
46 | app.Arg("a", "").Default("invalid").Bool()
47 | _, err := app.Parse([]string{})
48 | assert.Error(t, err)
49 | }
50 |
--------------------------------------------------------------------------------
/vendor/src/github.com/alecthomas/kingpin/doc.go:
--------------------------------------------------------------------------------
1 | // Package kingpin provides command line interfaces like this:
2 | //
3 | // $ chat
4 | // usage: chat [15 | {{.Description}} 16 |
17 | {{end}} 18 | {{end}} 19 | 20 | 21 | -------------------------------------------------------------------------------- /vendor/src/github.com/bugsnag/bugsnag-go/examples/revelapp/app/views/errors/500.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |12 | This exception has been logged. 13 |
14 | {{end}} 15 | 16 | 17 | -------------------------------------------------------------------------------- /vendor/src/github.com/bugsnag/bugsnag-go/examples/revelapp/app/views/flash.html: -------------------------------------------------------------------------------- 1 | {{if .flash.success}} 2 |