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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_darwin.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.TIOCGETA
11 |
12 | type Termios syscall.Termios
13 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_freebsd.go:
--------------------------------------------------------------------------------
1 | /*
2 | Go 1.2 doesn't include Termios for FreeBSD. This should be added in 1.3 and this could be merged with terminal_darwin.
3 | */
4 | package logrus
5 |
6 | import (
7 | "syscall"
8 | )
9 |
10 | const ioctlReadTermios = syscall.TIOCGETA
11 |
12 | type Termios struct {
13 | Iflag uint32
14 | Oflag uint32
15 | Cflag uint32
16 | Lflag uint32
17 | Cc [20]uint8
18 | Ispeed uint32
19 | Ospeed uint32
20 | }
21 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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
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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_openbsd.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | import "syscall"
4 |
5 | const ioctlReadTermios = syscall.TIOCGETA
6 |
7 | type Termios syscall.Termios
8 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/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 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/docker/docker/pkg/units/duration.go:
--------------------------------------------------------------------------------
1 | package units
2 |
3 | import (
4 | "fmt"
5 | "time"
6 | )
7 |
8 | // HumanDuration returns a human-readable approximation of a duration
9 | // (eg. "About a minute", "4 hours ago", etc.)
10 | func HumanDuration(d time.Duration) string {
11 | if seconds := int(d.Seconds()); seconds < 1 {
12 | return "Less than a second"
13 | } else if seconds < 60 {
14 | return fmt.Sprintf("%d seconds", seconds)
15 | } else if minutes := int(d.Minutes()); minutes == 1 {
16 | return "About a minute"
17 | } else if minutes < 60 {
18 | return fmt.Sprintf("%d minutes", minutes)
19 | } else if hours := int(d.Hours()); hours == 1 {
20 | return "About an hour"
21 | } else if hours < 48 {
22 | return fmt.Sprintf("%d hours", hours)
23 | } else if hours < 24*7*2 {
24 | return fmt.Sprintf("%d days", hours/24)
25 | } else if hours < 24*30*3 {
26 | return fmt.Sprintf("%d weeks", hours/24/7)
27 | } else if hours < 24*365*2 {
28 | return fmt.Sprintf("%d months", hours/24/30)
29 | }
30 | return fmt.Sprintf("%d years", int(d.Hours())/24/365)
31 | }
32 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2014, Elazar Leibovich
2 | All rights reserved.
3 |
4 | Redistribution and use in source and binary forms, with or without
5 | modification, are permitted provided that the following conditions are met:
6 |
7 | * Redistributions of source code must retain the above copyright notice, this
8 | list of conditions and the following disclaimer.
9 |
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 | this list of conditions and the following disclaimer in the documentation
12 | and/or other materials provided with the distribution.
13 |
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/README.md:
--------------------------------------------------------------------------------
1 | # go-bindata-assetfs
2 |
3 | Serve embedded files from [jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata) with `net/http`.
4 |
5 | [GoDoc](http://godoc.org/github.com/elazarl/go-bindata-assetfs)
6 |
7 | ### Installation
8 |
9 | Install with
10 |
11 | $ go get github.com/jteeuwen/go-bindata/...
12 | $ go get github.com/elazarl/go-bindata-assetfs/...
13 |
14 | ### Creating embedded data
15 |
16 | Usage is identical to [jteeuwen/go-bindata](https://github.com/jteeuwen/go-bindata) usage,
17 | instead of running `go-bindata` run `go-bindata-assetfs`.
18 |
19 | The tool will create a `bindata_assetfs.go` file, which contains the embedded data.
20 |
21 | A typical use case is
22 |
23 | $ go-bindata-assetfs data/...
24 |
25 | ### Using assetFS in your code
26 |
27 | The generated file provides an `assetFS()` function that returns a `http.Filesystem`
28 | wrapping the embedded files. What you usually want to do is:
29 |
30 | http.Handle("/", http.FileServer(assetFS()))
31 |
32 | This would run an HTTP server serving the embedded files.
33 |
34 | ## Without running binary tool
35 |
36 | You can always just run the `go-bindata` tool, and then
37 |
38 | use
39 |
40 | import "github.com/elazarl/go-bindata-assetfs"
41 | ...
42 | http.Handle("/",
43 | http.FileServer(
44 | &assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "data"}))
45 |
46 | to serve files embedded from the `data` directory.
47 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/elazarl/go-bindata-assetfs/doc.go:
--------------------------------------------------------------------------------
1 | // assetfs allows packages to serve static content embedded
2 | // with the go-bindata tool with the standard net/http package.
3 | //
4 | // See https://github.com/jteeuwen/go-bindata for more information
5 | // about embedding binary data with go-bindata.
6 | //
7 | // Usage example, after running
8 | // $ go-bindata data/...
9 | // use:
10 | // http.Handle("/",
11 | // http.FileServer(
12 | // &assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: "data"}))
13 | package assetfs
14 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/.gitignore:
--------------------------------------------------------------------------------
1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
2 | *.o
3 | *.a
4 | *.so
5 |
6 | # Folders
7 | _obj
8 | _test
9 |
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 |
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 |
20 | _testmain.go
21 |
22 | *.exe
23 |
24 | restful.html
25 |
26 | *.out
27 |
28 | tmp.prof
29 |
30 | go-restful.test
31 |
32 | examples/restful-basic-authentication
33 |
34 | examples/restful-encoding-filter
35 |
36 | examples/restful-filters
37 |
38 | examples/restful-hello-world
39 |
40 | examples/restful-resource-functions
41 |
42 | examples/restful-serve-static
43 |
44 | examples/restful-user-service
45 |
46 | *.DS_Store
47 | examples/restful-user-resource
48 |
49 | examples/restful-multi-containers
50 |
51 | examples/restful-form-handling
52 |
53 | examples/restful-CORS-filter
54 |
55 | examples/restful-options-filter
56 |
57 | examples/restful-curly-router
58 |
59 | examples/restful-cpuprofiler-service
60 |
61 | examples/restful-pre-post-filters
62 |
63 | curly.prof
64 |
65 | examples/restful-NCSA-logging
66 |
67 | examples/restful-html-template
68 |
69 | s.html
70 | restful-path-tail
71 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2012,2013 Ernest Micklei
2 |
3 | MIT License
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining
6 | a copy of this software and associated documentation files (the
7 | "Software"), to deal in the Software without restriction, including
8 | without limitation the rights to use, copy, modify, merge, publish,
9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 |
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 |
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/Srcfile:
--------------------------------------------------------------------------------
1 | {"SkipDirs": ["examples"]}
2 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/bench_curly_test.go:
--------------------------------------------------------------------------------
1 | package restful
2 |
3 | import (
4 | "fmt"
5 | "net/http"
6 | "net/http/httptest"
7 | "testing"
8 | )
9 |
10 | func setupCurly(container *Container) []string {
11 | wsCount := 26
12 | rtCount := 26
13 | urisCurly := []string{}
14 |
15 | container.Router(CurlyRouter{})
16 | for i := 0; i < wsCount; i++ {
17 | root := fmt.Sprintf("/%s/{%s}/", string(i+97), string(i+97))
18 | ws := new(WebService).Path(root)
19 | for j := 0; j < rtCount; j++ {
20 | sub := fmt.Sprintf("/%s2/{%s2}", string(j+97), string(j+97))
21 | ws.Route(ws.GET(sub).Consumes("application/xml").Produces("application/xml").To(echoCurly))
22 | }
23 | container.Add(ws)
24 | for _, each := range ws.Routes() {
25 | urisCurly = append(urisCurly, "http://bench.com"+each.Path)
26 | }
27 | }
28 | return urisCurly
29 | }
30 |
31 | func echoCurly(req *Request, resp *Response) {}
32 |
33 | func BenchmarkManyCurly(b *testing.B) {
34 | container := NewContainer()
35 | urisCurly := setupCurly(container)
36 | b.ResetTimer()
37 | for t := 0; t < b.N; t++ {
38 | for r := 0; r < 1000; r++ {
39 | for _, each := range urisCurly {
40 | sendNoReturnTo(each, container, t)
41 | }
42 | }
43 | }
44 | }
45 |
46 | func sendNoReturnTo(address string, container *Container, t int) {
47 | httpRequest, _ := http.NewRequest("GET", address, nil)
48 | httpRequest.Header.Set("Accept", "application/xml")
49 | httpWriter := httptest.NewRecorder()
50 | container.dispatch(httpWriter, httpRequest)
51 | }
52 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/bench_test.go:
--------------------------------------------------------------------------------
1 | package restful
2 |
3 | import (
4 | "fmt"
5 | "io"
6 | "testing"
7 | )
8 |
9 | var uris = []string{}
10 |
11 | func setup(container *Container) {
12 | wsCount := 26
13 | rtCount := 26
14 |
15 | for i := 0; i < wsCount; i++ {
16 | root := fmt.Sprintf("/%s/{%s}/", string(i+97), string(i+97))
17 | ws := new(WebService).Path(root)
18 | for j := 0; j < rtCount; j++ {
19 | sub := fmt.Sprintf("/%s2/{%s2}", string(j+97), string(j+97))
20 | ws.Route(ws.GET(sub).To(echo))
21 | }
22 | container.Add(ws)
23 | for _, each := range ws.Routes() {
24 | uris = append(uris, "http://bench.com"+each.Path)
25 | }
26 | }
27 | }
28 |
29 | func echo(req *Request, resp *Response) {
30 | io.WriteString(resp.ResponseWriter, "echo")
31 | }
32 |
33 | func BenchmarkMany(b *testing.B) {
34 | container := NewContainer()
35 | setup(container)
36 | b.ResetTimer()
37 | for t := 0; t < b.N; t++ {
38 | for _, each := range uris {
39 | // println(each)
40 | sendItTo(each, container)
41 | }
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/bench_test.sh:
--------------------------------------------------------------------------------
1 | #go test -run=none -file bench_test.go -test.bench . -cpuprofile=bench_test.out
2 |
3 | go test -c
4 | ./go-restful.test -test.run=none -test.cpuprofile=tmp.prof -test.bench=BenchmarkMany
5 | ./go-restful.test -test.run=none -test.cpuprofile=curly.prof -test.bench=BenchmarkManyCurly
6 |
7 | #go tool pprof go-restful.test tmp.prof
8 | go tool pprof go-restful.test curly.prof
9 |
10 |
11 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/compress_test.go:
--------------------------------------------------------------------------------
1 | package restful
2 |
3 | import (
4 | "net/http"
5 | "net/http/httptest"
6 | "testing"
7 | )
8 |
9 | func TestGzip(t *testing.T) {
10 | EnableContentEncoding = true
11 | httpRequest, _ := http.NewRequest("GET", "/test", nil)
12 | httpRequest.Header.Set("Accept-Encoding", "gzip,deflate")
13 | httpWriter := httptest.NewRecorder()
14 | wanted, encoding := wantsCompressedResponse(httpRequest)
15 | if !wanted {
16 | t.Fatal("should accept gzip")
17 | }
18 | if encoding != "gzip" {
19 | t.Fatal("expected gzip")
20 | }
21 | c, err := NewCompressingResponseWriter(httpWriter, encoding)
22 | if err != nil {
23 | t.Fatal(err.Error())
24 | }
25 | c.Write([]byte("Hello World"))
26 | c.Close()
27 | if httpWriter.Header().Get("Content-Encoding") != "gzip" {
28 | t.Fatal("Missing gzip header")
29 | }
30 | }
31 |
32 | func TestDeflate(t *testing.T) {
33 | EnableContentEncoding = true
34 | httpRequest, _ := http.NewRequest("GET", "/test", nil)
35 | httpRequest.Header.Set("Accept-Encoding", "deflate,gzip")
36 | httpWriter := httptest.NewRecorder()
37 | wanted, encoding := wantsCompressedResponse(httpRequest)
38 | if !wanted {
39 | t.Fatal("should accept deflate")
40 | }
41 | if encoding != "deflate" {
42 | t.Fatal("expected deflate")
43 | }
44 | c, err := NewCompressingResponseWriter(httpWriter, encoding)
45 | if err != nil {
46 | t.Fatal(err.Error())
47 | }
48 | c.Write([]byte("Hello World"))
49 | c.Close()
50 | if httpWriter.Header().Get("Content-Encoding") != "deflate" {
51 | t.Fatal("Missing deflate header")
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/constants.go:
--------------------------------------------------------------------------------
1 | package restful
2 |
3 | // Copyright 2013 Ernest Micklei. All rights reserved.
4 | // Use of this source code is governed by a license
5 | // that can be found in the LICENSE file.
6 |
7 | const (
8 | MIME_XML = "application/xml" // Accept or Content-Type used in Consumes() and/or Produces()
9 | MIME_JSON = "application/json" // Accept or Content-Type used in Consumes() and/or Produces()
10 | MIME_OCTET = "application/octet-stream" // If Content-Type is not present in request, use the default
11 |
12 | HEADER_Allow = "Allow"
13 | HEADER_Accept = "Accept"
14 | HEADER_Origin = "Origin"
15 | HEADER_ContentType = "Content-Type"
16 | HEADER_LastModified = "Last-Modified"
17 | HEADER_AcceptEncoding = "Accept-Encoding"
18 | HEADER_ContentEncoding = "Content-Encoding"
19 | HEADER_AccessControlExposeHeaders = "Access-Control-Expose-Headers"
20 | HEADER_AccessControlRequestMethod = "Access-Control-Request-Method"
21 | HEADER_AccessControlRequestHeaders = "Access-Control-Request-Headers"
22 | HEADER_AccessControlAllowMethods = "Access-Control-Allow-Methods"
23 | HEADER_AccessControlAllowOrigin = "Access-Control-Allow-Origin"
24 | HEADER_AccessControlAllowCredentials = "Access-Control-Allow-Credentials"
25 | HEADER_AccessControlAllowHeaders = "Access-Control-Allow-Headers"
26 | HEADER_AccessControlMaxAge = "Access-Control-Max-Age"
27 |
28 | ENCODING_GZIP = "gzip"
29 | ENCODING_DEFLATE = "deflate"
30 | )
31 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/container_test.go:
--------------------------------------------------------------------------------
1 | package restful
2 |
3 | import (
4 | "net/http"
5 | "testing"
6 | )
7 |
8 | // go test -v -test.run TestContainer_computeAllowedMethods ...restful
9 | func TestContainer_computeAllowedMethods(t *testing.T) {
10 | wc := NewContainer()
11 | ws1 := new(WebService).Path("/users")
12 | ws1.Route(ws1.GET("{i}").To(dummy))
13 | ws1.Route(ws1.POST("{i}").To(dummy))
14 | wc.Add(ws1)
15 | httpRequest, _ := http.NewRequest("GET", "http://api.his.com/users/1", nil)
16 | rreq := Request{Request: httpRequest}
17 | m := wc.computeAllowedMethods(&rreq)
18 | if len(m) != 2 {
19 | t.Errorf("got %d expected 2 methods, %v", len(m), m)
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/coverage.sh:
--------------------------------------------------------------------------------
1 | go test -coverprofile=coverage.out
2 | go tool cover -html=coverage.out
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/curly_route.go:
--------------------------------------------------------------------------------
1 | package restful
2 |
3 | // Copyright 2013 Ernest Micklei. All rights reserved.
4 | // Use of this source code is governed by a license
5 | // that can be found in the LICENSE file.
6 |
7 | // curlyRoute exits for sorting Routes by the CurlyRouter based on number of parameters and number of static path elements.
8 | type curlyRoute struct {
9 | route Route
10 | paramCount int
11 | staticCount int
12 | }
13 |
14 | type sortableCurlyRoutes struct {
15 | candidates []*curlyRoute
16 | }
17 |
18 | func (s *sortableCurlyRoutes) add(route *curlyRoute) {
19 | s.candidates = append(s.candidates, route)
20 | }
21 |
22 | func (s *sortableCurlyRoutes) routes() (routes []Route) {
23 | for _, each := range s.candidates {
24 | routes = append(routes, each.route) // TODO change return type
25 | }
26 | return routes
27 | }
28 |
29 | func (s *sortableCurlyRoutes) Len() int {
30 | return len(s.candidates)
31 | }
32 | func (s *sortableCurlyRoutes) Swap(i, j int) {
33 | s.candidates[i], s.candidates[j] = s.candidates[j], s.candidates[i]
34 | }
35 | func (s *sortableCurlyRoutes) Less(i, j int) bool {
36 | ci := s.candidates[i]
37 | cj := s.candidates[j]
38 |
39 | // primary key
40 | if ci.staticCount < cj.staticCount {
41 | return true
42 | }
43 | if ci.staticCount > cj.staticCount {
44 | return false
45 | }
46 | // secundary key
47 | if ci.paramCount < cj.paramCount {
48 | return true
49 | }
50 | if ci.paramCount > cj.paramCount {
51 | return false
52 | }
53 | return ci.route.Path < cj.route.Path
54 | }
55 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/doc_examples_test.go:
--------------------------------------------------------------------------------
1 | package restful
2 |
3 | import "net/http"
4 |
5 | func ExampleOPTIONSFilter() {
6 | // Install the OPTIONS filter on the default Container
7 | Filter(OPTIONSFilter())
8 | }
9 | func ExampleContainer_OPTIONSFilter() {
10 | // Install the OPTIONS filter on a Container
11 | myContainer := new(Container)
12 | myContainer.Filter(myContainer.OPTIONSFilter)
13 | }
14 |
15 | func ExampleContainer() {
16 | // The Default container of go-restful uses the http.DefaultServeMux.
17 | // You can create your own Container using restful.NewContainer() and create a new http.Server for that particular container
18 |
19 | ws := new(WebService)
20 | wsContainer := NewContainer()
21 | wsContainer.Add(ws)
22 | server := &http.Server{Addr: ":8080", Handler: wsContainer}
23 | server.ListenAndServe()
24 | }
25 |
26 | func ExampleCrossOriginResourceSharing() {
27 | // To install this filter on the Default Container use:
28 | cors := CrossOriginResourceSharing{ExposeHeaders: []string{"X-My-Header"}, CookiesAllowed: false, Container: DefaultContainer}
29 | Filter(cors.Filter)
30 | }
31 |
32 | func ExampleServiceError() {
33 | resp := new(Response)
34 | resp.WriteEntity(NewError(http.StatusBadRequest, "Non-integer {id} path parameter"))
35 | }
36 |
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/examples/.goconvey:
--------------------------------------------------------------------------------
1 | ignore
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/examples/google_app_engine/.goconvey:
--------------------------------------------------------------------------------
1 | ignore
--------------------------------------------------------------------------------
/Godeps/_workspace/src/github.com/emicklei/go-restful/examples/google_app_engine/app.yaml:
--------------------------------------------------------------------------------
1 | #
2 | # Include your application ID here
3 | #
4 | application: 4 |
18 | Every {{input value=model.PullIntervalMinutes class="form-control" style="display: inline-block; width: 100px;"}} minutes, pull the latest version of these images: 19 |
20 | {{#each obj in images}} 21 | {{input value=obj.value class="form-control"}} 22 | {{/each}} 23 || ID | 7 |Parent | 8 |Tags | 9 |Size | 10 |Virtual Size | 11 |
|---|---|---|---|---|
| {{short-id image.Id}}… | 17 |{{short-id image.ParentId}}… | 18 |
19 | {{#each tag in image.RepoTags}}
20 | {{#unless (eq tag " |
25 | {{display-size image.Size}} | 26 |{{display-size image.VirtualSize}} | 27 |
| ID | 10 |Container | 11 |Path | 12 |In Use | 13 |14 | | |
|---|---|---|---|---|---|
| {{short-id volume.ID}}… | 20 |{{short-id volume.ContainerID}}… | 21 |Host: | 22 |23 | {{volume.DockerPath}} 24 | | 25 |{{#if volume.Attached}}Yes{{else}}No{{/if}} | 26 |27 | {{#unless volume.Attached}} 28 | 29 | {{/unless}} 30 | | 31 |
| Container: | 34 |35 | {{volume.ContainerPath}} 36 | | 37 |||||