29 |
30 |
31 | `
32 |
--------------------------------------------------------------------------------
/frontend/static/index.css:
--------------------------------------------------------------------------------
1 | .main-container {
2 | padding:16px;
3 | }
4 | .container-title {
5 | margin:0 auto;
6 | text-align: center;
7 | font-size: 24px;
8 | }
9 | .item-key {
10 | display: inline-block;
11 | border: 1px solid #ccc;
12 | padding: 5px 10px;
13 | text-decoration: none;
14 | color: #666;
15 | font-family: arial, verdana, tahoma;
16 | font-size: 11px;
17 | border-radius: 5px;
18 | pointer: cursor;
19 | }
20 |
21 | .item-key.has-key {
22 | background-color: green;
23 | color: white;
24 | }
25 |
26 | .item-key:hover {
27 | background-color: #428bca;
28 | text-decoration: none;
29 | }
30 |
31 | .item-value {
32 | display: inline-block;
33 | }
34 |
35 | .data-viewer {
36 | border: 1px solid #cccccc;
37 | border-radius: 5px;
38 | min-height: 500px;
39 | overflow: auto;
40 | width:95%;
41 | }
--------------------------------------------------------------------------------
/kubernetes-deployment.yaml:
--------------------------------------------------------------------------------
1 | ---
2 | apiVersion: v1
3 | kind: Service
4 | metadata:
5 | annotations:
6 | derrick.service.type: nodeport
7 | derrick.version: 0.0.14
8 | labels:
9 | derrick.service: lucas
10 | name: lucas
11 | spec:
12 | ports:
13 | - name: "8080"
14 | port: 8080
15 | targetPort: 8080
16 | selector:
17 | derrick.service: lucas
18 | type: LoadBalancer
19 | ---
20 | apiVersion: extensions/v1beta1
21 | kind: Deployment
22 | metadata:
23 | annotations:
24 | derrick.version: 0.0.14
25 | labels:
26 | derrick.service: lucas
27 | name: lucas
28 | spec:
29 | replicas: 1
30 | template:
31 | metadata:
32 | labels:
33 | derrick.service: lucas
34 | spec:
35 | nodeSelector:
36 | node-role.kubernetes.io/master: ''
37 | tolerations:
38 | - key: node-role.kubernetes.io/master
39 | operator: Exists
40 | containers:
41 | - image: registry.cn-hangzhou.aliyuncs.com/ringtail/lucas:0.0.2
42 | name: web
43 | ports:
44 | - containerPort: 8080
45 | env:
46 | - name: CA_FILE
47 | value: /etc/kubernetes/pki/etcd/ca.pem
48 | - name: CERT_FILE
49 | value: /etc/kubernetes/pki/etcd/etcd-client.pem
50 | - name: KEY_FILE
51 | value: /etc/kubernetes/pki/etcd/etcd-client-key.pem
52 | - name: ENDPOINTS
53 | value: "{{ENDPOINTS}}"
54 | volumeMounts:
55 | - mountPath: /etc/kubernetes/pki/etcd
56 | name: etcd-certs-0
57 | readOnly: true
58 | volumes:
59 | - hostPath:
60 | path: /etc/kubernetes/pki/etcd
61 | type: DirectoryOrCreate
62 | name: etcd-certs-0
63 |
--------------------------------------------------------------------------------
/test.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | set -e
4 | echo "" > coverage.txt
5 |
6 | for d in $(go list ./... | grep -v vendor); do
7 | go test -race -coverprofile=profile.out -covermode=atomic $d
8 | if [ -f profile.out ]; then
9 | cat profile.out >> coverage.txt
10 | rm profile.out
11 | fi
12 | done
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # 0.10.0
2 |
3 | * feature: Add a test hook (#180)
4 | * feature: `ParseLevel` is now case-insensitive (#326)
5 | * feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308)
6 | * performance: avoid re-allocations on `WithFields` (#335)
7 |
8 | # 0.9.0
9 |
10 | * logrus/text_formatter: don't emit empty msg
11 | * logrus/hooks/airbrake: move out of main repository
12 | * logrus/hooks/sentry: move out of main repository
13 | * logrus/hooks/papertrail: move out of main repository
14 | * logrus/hooks/bugsnag: move out of main repository
15 | * logrus/core: run tests with `-race`
16 | * logrus/core: detect TTY based on `stderr`
17 | * logrus/core: support `WithError` on logger
18 | * logrus/core: Solaris support
19 |
20 | # 0.8.7
21 |
22 | * logrus/core: fix possible race (#216)
23 | * logrus/doc: small typo fixes and doc improvements
24 |
25 |
26 | # 0.8.6
27 |
28 | * hooks/raven: allow passing an initialized client
29 |
30 | # 0.8.5
31 |
32 | * logrus/core: revert #208
33 |
34 | # 0.8.4
35 |
36 | * formatter/text: fix data race (#218)
37 |
38 | # 0.8.3
39 |
40 | * logrus/core: fix entry log level (#208)
41 | * logrus/core: improve performance of text formatter by 40%
42 | * logrus/core: expose `LevelHooks` type
43 | * logrus/core: add support for DragonflyBSD and NetBSD
44 | * formatter/text: print structs more verbosely
45 |
46 | # 0.8.2
47 |
48 | * logrus: fix more Fatal family functions
49 |
50 | # 0.8.1
51 |
52 | * logrus: fix not exiting on `Fatalf` and `Fatalln`
53 |
54 | # 0.8.0
55 |
56 | * logrus: defaults to stderr instead of stdout
57 | * hooks/sentry: add special field for `*http.Request`
58 | * formatter/text: ignore Windows for colors
59 |
60 | # 0.7.3
61 |
62 | * formatter/\*: allow configuration of timestamp layout
63 |
64 | # 0.7.2
65 |
66 | * formatter/text: Add configuration option for time format (#158)
67 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2014 Simon Eskildsen
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/doc.go:
--------------------------------------------------------------------------------
1 | /*
2 | Package logrus is a structured logger for Go, completely API compatible with the standard library logger.
3 |
4 |
5 | The simplest way to use Logrus is simply the package-level exported logger:
6 |
7 | package main
8 |
9 | import (
10 | log "github.com/Sirupsen/logrus"
11 | )
12 |
13 | func main() {
14 | log.WithFields(log.Fields{
15 | "animal": "walrus",
16 | "number": 1,
17 | "size": 10,
18 | }).Info("A walrus appears")
19 | }
20 |
21 | Output:
22 | time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10
23 |
24 | For a full guide visit https://github.com/Sirupsen/logrus
25 | */
26 | package logrus
27 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/formatter.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | import "time"
4 |
5 | const DefaultTimestampFormat = time.RFC3339
6 |
7 | // The Formatter interface is used to implement a custom Formatter. It takes an
8 | // `Entry`. It exposes all the fields, including the default ones:
9 | //
10 | // * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
11 | // * `entry.Data["time"]`. The timestamp.
12 | // * `entry.Data["level"]. The level the entry was logged at.
13 | //
14 | // Any additional fields added with `WithField` or `WithFields` are also in
15 | // `entry.Data`. Format is expected to return an array of bytes which are then
16 | // logged to `logger.Out`.
17 | type Formatter interface {
18 | Format(*Entry) ([]byte, error)
19 | }
20 |
21 | // This is to not silently overwrite `time`, `msg` and `level` fields when
22 | // dumping it. If this code wasn't there doing:
23 | //
24 | // logrus.WithField("level", 1).Info("hello")
25 | //
26 | // Would just silently drop the user provided level. Instead with this code
27 | // it'll logged as:
28 | //
29 | // {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
30 | //
31 | // It's not exported because it's still using Data in an opinionated way. It's to
32 | // avoid code duplication between the two default formatters.
33 | func prefixFieldClashes(data Fields) {
34 | if t, ok := data["time"]; ok {
35 | data["fields.time"] = t
36 | }
37 |
38 | if m, ok := data["msg"]; ok {
39 | data["fields.msg"] = m
40 | }
41 |
42 | if l, ok := data["level"]; ok {
43 | data["fields.level"] = l
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/hooks.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | // A hook to be fired when logging on the logging levels returned from
4 | // `Levels()` on your implementation of the interface. Note that this is not
5 | // fired in a goroutine or a channel with workers, you should handle such
6 | // functionality yourself if your call is non-blocking and you don't wish for
7 | // the logging calls for levels returned from `Levels()` to block.
8 | type Hook interface {
9 | Levels() []Level
10 | Fire(*Entry) error
11 | }
12 |
13 | // Internal type for storing the hooks on a logger instance.
14 | type LevelHooks map[Level][]Hook
15 |
16 | // Add a hook to an instance of logger. This is called with
17 | // `log.Hooks.Add(new(MyHook))` where `MyHook` implements the `Hook` interface.
18 | func (hooks LevelHooks) Add(hook Hook) {
19 | for _, level := range hook.Levels() {
20 | hooks[level] = append(hooks[level], hook)
21 | }
22 | }
23 |
24 | // Fire all the hooks for the passed level. Used by `entry.log` to fire
25 | // appropriate hooks for a log entry.
26 | func (hooks LevelHooks) Fire(level Level, entry *Entry) error {
27 | for _, hook := range hooks[level] {
28 | if err := hook.Fire(entry); err != nil {
29 | return err
30 | }
31 | }
32 |
33 | return nil
34 | }
35 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/json_formatter.go:
--------------------------------------------------------------------------------
1 | package logrus
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | )
7 |
8 | type fieldKey string
9 | type FieldMap map[fieldKey]string
10 |
11 | const (
12 | FieldKeyMsg = "msg"
13 | FieldKeyLevel = "level"
14 | FieldKeyTime = "time"
15 | )
16 |
17 | func (f FieldMap) resolve(key fieldKey) string {
18 | if k, ok := f[key]; ok {
19 | return k
20 | }
21 |
22 | return string(key)
23 | }
24 |
25 | type JSONFormatter struct {
26 | // TimestampFormat sets the format used for marshaling timestamps.
27 | TimestampFormat string
28 |
29 | // DisableTimestamp allows disabling automatic timestamps in output
30 | DisableTimestamp bool
31 |
32 | // FieldMap allows users to customize the names of keys for various fields.
33 | // As an example:
34 | // formatter := &JSONFormatter{
35 | // FieldMap: FieldMap{
36 | // FieldKeyTime: "@timestamp",
37 | // FieldKeyLevel: "@level",
38 | // FieldKeyLevel: "@message",
39 | // },
40 | // }
41 | FieldMap FieldMap
42 | }
43 |
44 | func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
45 | data := make(Fields, len(entry.Data)+3)
46 | for k, v := range entry.Data {
47 | switch v := v.(type) {
48 | case error:
49 | // Otherwise errors are ignored by `encoding/json`
50 | // https://github.com/Sirupsen/logrus/issues/137
51 | data[k] = v.Error()
52 | default:
53 | data[k] = v
54 | }
55 | }
56 | prefixFieldClashes(data)
57 |
58 | timestampFormat := f.TimestampFormat
59 | if timestampFormat == "" {
60 | timestampFormat = DefaultTimestampFormat
61 | }
62 |
63 | if !f.DisableTimestamp {
64 | data[f.FieldMap.resolve(FieldKeyTime)] = entry.Time.Format(timestampFormat)
65 | }
66 | data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message
67 | data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String()
68 |
69 | serialized, err := json.Marshal(data)
70 | if err != nil {
71 | return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
72 | }
73 | return append(serialized, '\n'), nil
74 | }
75 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/terminal_appengine.go:
--------------------------------------------------------------------------------
1 | // +build appengine
2 |
3 | package logrus
4 |
5 | // IsTerminal returns true if stderr's file descriptor is a terminal.
6 | func IsTerminal() bool {
7 | return true
8 | }
9 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/terminal_bsd.go:
--------------------------------------------------------------------------------
1 | // +build darwin freebsd openbsd netbsd dragonfly
2 | // +build !appengine
3 |
4 | package logrus
5 |
6 | import "syscall"
7 |
8 | const ioctlReadTermios = syscall.TIOCGETA
9 |
10 | type Termios syscall.Termios
11 |
--------------------------------------------------------------------------------
/vendor/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 | // +build !appengine
7 |
8 | package logrus
9 |
10 | import "syscall"
11 |
12 | const ioctlReadTermios = syscall.TCGETS
13 |
14 | type Termios syscall.Termios
15 |
--------------------------------------------------------------------------------
/vendor/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 | // +build !appengine
8 |
9 | package logrus
10 |
11 | import (
12 | "syscall"
13 | "unsafe"
14 | )
15 |
16 | // IsTerminal returns true if stderr's file descriptor is a terminal.
17 | func IsTerminal() bool {
18 | fd := syscall.Stderr
19 | var termios Termios
20 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
21 | return err == 0
22 | }
23 |
--------------------------------------------------------------------------------
/vendor/github.com/Sirupsen/logrus/terminal_solaris.go:
--------------------------------------------------------------------------------
1 | // +build solaris,!appengine
2 |
3 | package logrus
4 |
5 | import (
6 | "os"
7 |
8 | "golang.org/x/sys/unix"
9 | )
10 |
11 | // IsTerminal returns true if the given file descriptor is a terminal.
12 | func IsTerminal() bool {
13 | _, err := unix.IoctlGetTermios(int(os.Stdout.Fd()), unix.TCGETA)
14 | return err == nil
15 | }
16 |
--------------------------------------------------------------------------------
/vendor/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,!appengine
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 stderr's file descriptor is a terminal.
22 | func IsTerminal() bool {
23 | fd := syscall.Stderr
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/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 | return logger.WriterLevel(InfoLevel)
11 | }
12 |
13 | func (logger *Logger) WriterLevel(level Level) *io.PipeWriter {
14 | reader, writer := io.Pipe()
15 |
16 | var printFunc func(args ...interface{})
17 | switch level {
18 | case DebugLevel:
19 | printFunc = logger.Debug
20 | case InfoLevel:
21 | printFunc = logger.Info
22 | case WarnLevel:
23 | printFunc = logger.Warn
24 | case ErrorLevel:
25 | printFunc = logger.Error
26 | case FatalLevel:
27 | printFunc = logger.Fatal
28 | case PanicLevel:
29 | printFunc = logger.Panic
30 | default:
31 | printFunc = logger.Print
32 | }
33 |
34 | go logger.writerScanner(reader, printFunc)
35 | runtime.SetFinalizer(writer, writerFinalizer)
36 |
37 | return writer
38 | }
39 |
40 | func (logger *Logger) writerScanner(reader *io.PipeReader, printFunc func(args ...interface{})) {
41 | scanner := bufio.NewScanner(reader)
42 | for scanner.Scan() {
43 | printFunc(scanner.Text())
44 | }
45 | if err := scanner.Err(); err != nil {
46 | logger.Errorf("Error while reading from Writer: %s", err)
47 | }
48 | reader.Close()
49 | }
50 |
51 | func writerFinalizer(writer *io.PipeWriter) {
52 | writer.Close()
53 | }
54 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/NOTICE:
--------------------------------------------------------------------------------
1 | CoreOS Project
2 | Copyright 2014 CoreOS, Inc
3 |
4 | This product includes software developed at CoreOS, Inc.
5 | (http://www.coreos.com/).
6 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/auth/authpb/auth.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto3";
2 | package authpb;
3 |
4 | import "gogoproto/gogo.proto";
5 |
6 | option (gogoproto.marshaler_all) = true;
7 | option (gogoproto.sizer_all) = true;
8 | option (gogoproto.unmarshaler_all) = true;
9 | option (gogoproto.goproto_getters_all) = false;
10 | option (gogoproto.goproto_enum_prefix_all) = false;
11 |
12 | // User is a single entry in the bucket authUsers
13 | message User {
14 | bytes name = 1;
15 | bytes password = 2;
16 | repeated string roles = 3;
17 | }
18 |
19 | // Permission is a single entity
20 | message Permission {
21 | enum Type {
22 | READ = 0;
23 | WRITE = 1;
24 | READWRITE = 2;
25 | }
26 | Type permType = 1;
27 |
28 | bytes key = 2;
29 | bytes range_end = 3;
30 | }
31 |
32 | // Role is a single entry in the bucket authRoles
33 | message Role {
34 | bytes name = 1;
35 |
36 | repeated Permission keyPermission = 2;
37 | }
38 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/clientv3/compact_op.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package clientv3
16 |
17 | import (
18 | pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
19 | )
20 |
21 | // CompactOp represents a compact operation.
22 | type CompactOp struct {
23 | revision int64
24 | physical bool
25 | }
26 |
27 | // CompactOption configures compact operation.
28 | type CompactOption func(*CompactOp)
29 |
30 | func (op *CompactOp) applyCompactOpts(opts []CompactOption) {
31 | for _, opt := range opts {
32 | opt(op)
33 | }
34 | }
35 |
36 | // OpCompact wraps slice CompactOption to create a CompactOp.
37 | func OpCompact(rev int64, opts ...CompactOption) CompactOp {
38 | ret := CompactOp{revision: rev}
39 | ret.applyCompactOpts(opts)
40 | return ret
41 | }
42 |
43 | func (op CompactOp) toRequest() *pb.CompactionRequest {
44 | return &pb.CompactionRequest{Revision: op.revision, Physical: op.physical}
45 | }
46 |
47 | // WithCompactPhysical makes Compact wait until all compacted entries are
48 | // removed from the etcd server's storage.
49 | func WithCompactPhysical() CompactOption {
50 | return func(op *CompactOp) { op.physical = true }
51 | }
52 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/clientv3/config.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package clientv3
16 |
17 | import (
18 | "crypto/tls"
19 | "time"
20 |
21 | "golang.org/x/net/context"
22 | "google.golang.org/grpc"
23 | )
24 |
25 | type Config struct {
26 | // Endpoints is a list of URLs.
27 | Endpoints []string `json:"endpoints"`
28 |
29 | // AutoSyncInterval is the interval to update endpoints with its latest members.
30 | // 0 disables auto-sync. By default auto-sync is disabled.
31 | AutoSyncInterval time.Duration `json:"auto-sync-interval"`
32 |
33 | // DialTimeout is the timeout for failing to establish a connection.
34 | DialTimeout time.Duration `json:"dial-timeout"`
35 |
36 | // DialKeepAliveTime is the time in seconds after which client pings the server to see if
37 | // transport is alive.
38 | DialKeepAliveTime time.Duration `json:"dial-keep-alive-time"`
39 |
40 | // DialKeepAliveTimeout is the time in seconds that the client waits for a response for the
41 | // keep-alive probe. If the response is not received in this time, the connection is closed.
42 | DialKeepAliveTimeout time.Duration `json:"dial-keep-alive-timeout"`
43 |
44 | // TLS holds the client secure credentials, if any.
45 | TLS *tls.Config
46 |
47 | // Username is a user name for authentication.
48 | Username string `json:"username"`
49 |
50 | // Password is a password for authentication.
51 | Password string `json:"password"`
52 |
53 | // RejectOldCluster when set will refuse to create a client against an outdated cluster.
54 | RejectOldCluster bool `json:"reject-old-cluster"`
55 |
56 | // DialOptions is a list of dial options for the grpc client (e.g., for interceptors).
57 | DialOptions []grpc.DialOption
58 |
59 | // Context is the default client context; it can be used to cancel grpc dial out and
60 | // other operations that do not have an explicit context.
61 | Context context.Context
62 | }
63 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/clientv3/ready_wait.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package clientv3
16 |
17 | import "golang.org/x/net/context"
18 |
19 | // TODO: remove this when "FailFast=false" is fixed.
20 | // See https://github.com/grpc/grpc-go/issues/1532.
21 | func readyWait(rpcCtx, clientCtx context.Context, ready <-chan struct{}) error {
22 | select {
23 | case <-ready:
24 | return nil
25 | case <-rpcCtx.Done():
26 | return rpcCtx.Err()
27 | case <-clientCtx.Done():
28 | return clientCtx.Err()
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/clientv3/sort.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package clientv3
16 |
17 | type SortTarget int
18 | type SortOrder int
19 |
20 | const (
21 | SortNone SortOrder = iota
22 | SortAscend
23 | SortDescend
24 | )
25 |
26 | const (
27 | SortByKey SortTarget = iota
28 | SortByVersion
29 | SortByCreateRevision
30 | SortByModRevision
31 | SortByValue
32 | )
33 |
34 | type SortOption struct {
35 | Target SortTarget
36 | Order SortOrder
37 | }
38 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/doc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | // Package rpctypes has types and values shared by the etcd server and client for v3 RPC interaction.
16 | package rpctypes
17 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/md.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package rpctypes
16 |
17 | var (
18 | MetadataRequireLeaderKey = "hasleader"
19 | MetadataHasLeader = "true"
20 | )
21 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto2";
2 | package etcdserverpb;
3 |
4 | import "gogoproto/gogo.proto";
5 |
6 | option (gogoproto.marshaler_all) = true;
7 | option (gogoproto.sizer_all) = true;
8 | option (gogoproto.unmarshaler_all) = true;
9 | option (gogoproto.goproto_getters_all) = false;
10 |
11 | message Request {
12 | optional uint64 ID = 1 [(gogoproto.nullable) = false];
13 | optional string Method = 2 [(gogoproto.nullable) = false];
14 | optional string Path = 3 [(gogoproto.nullable) = false];
15 | optional string Val = 4 [(gogoproto.nullable) = false];
16 | optional bool Dir = 5 [(gogoproto.nullable) = false];
17 | optional string PrevValue = 6 [(gogoproto.nullable) = false];
18 | optional uint64 PrevIndex = 7 [(gogoproto.nullable) = false];
19 | optional bool PrevExist = 8 [(gogoproto.nullable) = true];
20 | optional int64 Expiration = 9 [(gogoproto.nullable) = false];
21 | optional bool Wait = 10 [(gogoproto.nullable) = false];
22 | optional uint64 Since = 11 [(gogoproto.nullable) = false];
23 | optional bool Recursive = 12 [(gogoproto.nullable) = false];
24 | optional bool Sorted = 13 [(gogoproto.nullable) = false];
25 | optional bool Quorum = 14 [(gogoproto.nullable) = false];
26 | optional int64 Time = 15 [(gogoproto.nullable) = false];
27 | optional bool Stream = 16 [(gogoproto.nullable) = false];
28 | optional bool Refresh = 17 [(gogoproto.nullable) = true];
29 | }
30 |
31 | message Metadata {
32 | optional uint64 NodeID = 1 [(gogoproto.nullable) = false];
33 | optional uint64 ClusterID = 2 [(gogoproto.nullable) = false];
34 | }
35 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.proto:
--------------------------------------------------------------------------------
1 | syntax = "proto3";
2 | package mvccpb;
3 |
4 | import "gogoproto/gogo.proto";
5 |
6 | option (gogoproto.marshaler_all) = true;
7 | option (gogoproto.sizer_all) = true;
8 | option (gogoproto.unmarshaler_all) = true;
9 | option (gogoproto.goproto_getters_all) = false;
10 | option (gogoproto.goproto_enum_prefix_all) = false;
11 |
12 | message KeyValue {
13 | // key is the key in bytes. An empty key is not allowed.
14 | bytes key = 1;
15 | // create_revision is the revision of last creation on this key.
16 | int64 create_revision = 2;
17 | // mod_revision is the revision of last modification on this key.
18 | int64 mod_revision = 3;
19 | // version is the version of the key. A deletion resets
20 | // the version to zero and any modification of the key
21 | // increases its version.
22 | int64 version = 4;
23 | // value is the value held by the key, in bytes.
24 | bytes value = 5;
25 | // lease is the ID of the lease that attached to key.
26 | // When the attached lease expires, the key will be deleted.
27 | // If lease is 0, then no lease is attached to the key.
28 | int64 lease = 6;
29 | }
30 |
31 | message Event {
32 | enum EventType {
33 | PUT = 0;
34 | DELETE = 1;
35 | }
36 | // type is the kind of event. If type is a PUT, it indicates
37 | // new data has been stored to the key. If type is a DELETE,
38 | // it indicates the key was deleted.
39 | EventType type = 1;
40 | // kv holds the KeyValue for the event.
41 | // A PUT event contains current kv pair.
42 | // A PUT event with kv.Version=1 indicates the creation of a key.
43 | // A DELETE/EXPIRE event contains the deleted key with
44 | // its modification revision set to the revision of deletion.
45 | KeyValue kv = 2;
46 |
47 | // prev_kv holds the key-value pair before the event happens.
48 | KeyValue prev_kv = 3;
49 | }
50 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/tlsutil/doc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | // Package tlsutil provides utility functions for handling TLS.
16 | package tlsutil
17 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/tlsutil/tlsutil.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package tlsutil
16 |
17 | import (
18 | "crypto/tls"
19 | "crypto/x509"
20 | "encoding/pem"
21 | "io/ioutil"
22 | )
23 |
24 | // NewCertPool creates x509 certPool with provided CA files.
25 | func NewCertPool(CAFiles []string) (*x509.CertPool, error) {
26 | certPool := x509.NewCertPool()
27 |
28 | for _, CAFile := range CAFiles {
29 | pemByte, err := ioutil.ReadFile(CAFile)
30 | if err != nil {
31 | return nil, err
32 | }
33 |
34 | for {
35 | var block *pem.Block
36 | block, pemByte = pem.Decode(pemByte)
37 | if block == nil {
38 | break
39 | }
40 | cert, err := x509.ParseCertificate(block.Bytes)
41 | if err != nil {
42 | return nil, err
43 | }
44 | certPool.AddCert(cert)
45 | }
46 | }
47 |
48 | return certPool, nil
49 | }
50 |
51 | // NewCert generates TLS cert by using the given cert,key and parse function.
52 | func NewCert(certfile, keyfile string, parseFunc func([]byte, []byte) (tls.Certificate, error)) (*tls.Certificate, error) {
53 | cert, err := ioutil.ReadFile(certfile)
54 | if err != nil {
55 | return nil, err
56 | }
57 |
58 | key, err := ioutil.ReadFile(keyfile)
59 | if err != nil {
60 | return nil, err
61 | }
62 |
63 | if parseFunc == nil {
64 | parseFunc = tls.X509KeyPair
65 | }
66 |
67 | tlsCert, err := parseFunc(cert, key)
68 | if err != nil {
69 | return nil, err
70 | }
71 | return &tlsCert, nil
72 | }
73 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/doc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | // Package transport implements various HTTP transport utilities based on Go
16 | // net package.
17 | package transport
18 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/limit_listen.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | // Package transport provides network utility functions, complementing the more
16 | // common ones in the net package.
17 | package transport
18 |
19 | import (
20 | "errors"
21 | "net"
22 | "sync"
23 | "time"
24 | )
25 |
26 | var (
27 | ErrNotTCP = errors.New("only tcp connections have keepalive")
28 | )
29 |
30 | // LimitListener returns a Listener that accepts at most n simultaneous
31 | // connections from the provided Listener.
32 | func LimitListener(l net.Listener, n int) net.Listener {
33 | return &limitListener{l, make(chan struct{}, n)}
34 | }
35 |
36 | type limitListener struct {
37 | net.Listener
38 | sem chan struct{}
39 | }
40 |
41 | func (l *limitListener) acquire() { l.sem <- struct{}{} }
42 | func (l *limitListener) release() { <-l.sem }
43 |
44 | func (l *limitListener) Accept() (net.Conn, error) {
45 | l.acquire()
46 | c, err := l.Listener.Accept()
47 | if err != nil {
48 | l.release()
49 | return nil, err
50 | }
51 | return &limitListenerConn{Conn: c, release: l.release}, nil
52 | }
53 |
54 | type limitListenerConn struct {
55 | net.Conn
56 | releaseOnce sync.Once
57 | release func()
58 | }
59 |
60 | func (l *limitListenerConn) Close() error {
61 | err := l.Conn.Close()
62 | l.releaseOnce.Do(l.release)
63 | return err
64 | }
65 |
66 | func (l *limitListenerConn) SetKeepAlive(doKeepAlive bool) error {
67 | tcpc, ok := l.Conn.(*net.TCPConn)
68 | if !ok {
69 | return ErrNotTCP
70 | }
71 | return tcpc.SetKeepAlive(doKeepAlive)
72 | }
73 |
74 | func (l *limitListenerConn) SetKeepAlivePeriod(d time.Duration) error {
75 | tcpc, ok := l.Conn.(*net.TCPConn)
76 | if !ok {
77 | return ErrNotTCP
78 | }
79 | return tcpc.SetKeepAlivePeriod(d)
80 | }
81 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/timeout_conn.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package transport
16 |
17 | import (
18 | "net"
19 | "time"
20 | )
21 |
22 | type timeoutConn struct {
23 | net.Conn
24 | wtimeoutd time.Duration
25 | rdtimeoutd time.Duration
26 | }
27 |
28 | func (c timeoutConn) Write(b []byte) (n int, err error) {
29 | if c.wtimeoutd > 0 {
30 | if err := c.SetWriteDeadline(time.Now().Add(c.wtimeoutd)); err != nil {
31 | return 0, err
32 | }
33 | }
34 | return c.Conn.Write(b)
35 | }
36 |
37 | func (c timeoutConn) Read(b []byte) (n int, err error) {
38 | if c.rdtimeoutd > 0 {
39 | if err := c.SetReadDeadline(time.Now().Add(c.rdtimeoutd)); err != nil {
40 | return 0, err
41 | }
42 | }
43 | return c.Conn.Read(b)
44 | }
45 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/timeout_dialer.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package transport
16 |
17 | import (
18 | "net"
19 | "time"
20 | )
21 |
22 | type rwTimeoutDialer struct {
23 | wtimeoutd time.Duration
24 | rdtimeoutd time.Duration
25 | net.Dialer
26 | }
27 |
28 | func (d *rwTimeoutDialer) Dial(network, address string) (net.Conn, error) {
29 | conn, err := d.Dialer.Dial(network, address)
30 | tconn := &timeoutConn{
31 | rdtimeoutd: d.rdtimeoutd,
32 | wtimeoutd: d.wtimeoutd,
33 | Conn: conn,
34 | }
35 | return tconn, err
36 | }
37 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/timeout_listener.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package transport
16 |
17 | import (
18 | "net"
19 | "time"
20 | )
21 |
22 | // NewTimeoutListener returns a listener that listens on the given address.
23 | // If read/write on the accepted connection blocks longer than its time limit,
24 | // it will return timeout error.
25 | func NewTimeoutListener(addr string, scheme string, tlsinfo *TLSInfo, rdtimeoutd, wtimeoutd time.Duration) (net.Listener, error) {
26 | ln, err := newListener(addr, scheme)
27 | if err != nil {
28 | return nil, err
29 | }
30 | ln = &rwTimeoutListener{
31 | Listener: ln,
32 | rdtimeoutd: rdtimeoutd,
33 | wtimeoutd: wtimeoutd,
34 | }
35 | if ln, err = wrapTLS(addr, scheme, tlsinfo, ln); err != nil {
36 | return nil, err
37 | }
38 | return ln, nil
39 | }
40 |
41 | type rwTimeoutListener struct {
42 | net.Listener
43 | wtimeoutd time.Duration
44 | rdtimeoutd time.Duration
45 | }
46 |
47 | func (rwln *rwTimeoutListener) Accept() (net.Conn, error) {
48 | c, err := rwln.Listener.Accept()
49 | if err != nil {
50 | return nil, err
51 | }
52 | return timeoutConn{
53 | Conn: c,
54 | wtimeoutd: rwln.wtimeoutd,
55 | rdtimeoutd: rwln.rdtimeoutd,
56 | }, nil
57 | }
58 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/timeout_transport.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package transport
16 |
17 | import (
18 | "net"
19 | "net/http"
20 | "time"
21 | )
22 |
23 | // NewTimeoutTransport returns a transport created using the given TLS info.
24 | // If read/write on the created connection blocks longer than its time limit,
25 | // it will return timeout error.
26 | // If read/write timeout is set, transport will not be able to reuse connection.
27 | func NewTimeoutTransport(info TLSInfo, dialtimeoutd, rdtimeoutd, wtimeoutd time.Duration) (*http.Transport, error) {
28 | tr, err := NewTransport(info, dialtimeoutd)
29 | if err != nil {
30 | return nil, err
31 | }
32 |
33 | if rdtimeoutd != 0 || wtimeoutd != 0 {
34 | // the timed out connection will timeout soon after it is idle.
35 | // it should not be put back to http transport as an idle connection for future usage.
36 | tr.MaxIdleConnsPerHost = -1
37 | } else {
38 | // allow more idle connections between peers to avoid unnecessary port allocation.
39 | tr.MaxIdleConnsPerHost = 1024
40 | }
41 |
42 | tr.Dial = (&rwTimeoutDialer{
43 | Dialer: net.Dialer{
44 | Timeout: dialtimeoutd,
45 | KeepAlive: 30 * time.Second,
46 | },
47 | rdtimeoutd: rdtimeoutd,
48 | wtimeoutd: wtimeoutd,
49 | }).Dial
50 | return tr, nil
51 | }
52 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/tls.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package transport
16 |
17 | import (
18 | "fmt"
19 | "strings"
20 | "time"
21 | )
22 |
23 | // ValidateSecureEndpoints scans the given endpoints against tls info, returning only those
24 | // endpoints that could be validated as secure.
25 | func ValidateSecureEndpoints(tlsInfo TLSInfo, eps []string) ([]string, error) {
26 | t, err := NewTransport(tlsInfo, 5*time.Second)
27 | if err != nil {
28 | return nil, err
29 | }
30 | var errs []string
31 | var endpoints []string
32 | for _, ep := range eps {
33 | if !strings.HasPrefix(ep, "https://") {
34 | errs = append(errs, fmt.Sprintf("%q is insecure", ep))
35 | continue
36 | }
37 | conn, cerr := t.Dial("tcp", ep[len("https://"):])
38 | if cerr != nil {
39 | errs = append(errs, fmt.Sprintf("%q failed to dial (%v)", ep, cerr))
40 | continue
41 | }
42 | conn.Close()
43 | endpoints = append(endpoints, ep)
44 | }
45 | if len(errs) != 0 {
46 | err = fmt.Errorf("%s", strings.Join(errs, ","))
47 | }
48 | return endpoints, err
49 | }
50 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/transport.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package transport
16 |
17 | import (
18 | "net"
19 | "net/http"
20 | "strings"
21 | "time"
22 | )
23 |
24 | type unixTransport struct{ *http.Transport }
25 |
26 | func NewTransport(info TLSInfo, dialtimeoutd time.Duration) (*http.Transport, error) {
27 | cfg, err := info.ClientConfig()
28 | if err != nil {
29 | return nil, err
30 | }
31 |
32 | t := &http.Transport{
33 | Proxy: http.ProxyFromEnvironment,
34 | Dial: (&net.Dialer{
35 | Timeout: dialtimeoutd,
36 | // value taken from http.DefaultTransport
37 | KeepAlive: 30 * time.Second,
38 | }).Dial,
39 | // value taken from http.DefaultTransport
40 | TLSHandshakeTimeout: 10 * time.Second,
41 | TLSClientConfig: cfg,
42 | }
43 |
44 | dialer := (&net.Dialer{
45 | Timeout: dialtimeoutd,
46 | KeepAlive: 30 * time.Second,
47 | })
48 | dial := func(net, addr string) (net.Conn, error) {
49 | return dialer.Dial("unix", addr)
50 | }
51 |
52 | tu := &http.Transport{
53 | Proxy: http.ProxyFromEnvironment,
54 | Dial: dial,
55 | TLSHandshakeTimeout: 10 * time.Second,
56 | TLSClientConfig: cfg,
57 | }
58 | ut := &unixTransport{tu}
59 |
60 | t.RegisterProtocol("unix", ut)
61 | t.RegisterProtocol("unixs", ut)
62 |
63 | return t, nil
64 | }
65 |
66 | func (urt *unixTransport) RoundTrip(req *http.Request) (*http.Response, error) {
67 | url := *req.URL
68 | req.URL = &url
69 | req.URL.Scheme = strings.Replace(req.URL.Scheme, "unix", "http", 1)
70 | return urt.Transport.RoundTrip(req)
71 | }
72 |
--------------------------------------------------------------------------------
/vendor/github.com/coreos/etcd/pkg/transport/unix_listener.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The etcd Authors
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | package transport
16 |
17 | import (
18 | "net"
19 | "os"
20 | )
21 |
22 | type unixListener struct{ net.Listener }
23 |
24 | func NewUnixListener(addr string) (net.Listener, error) {
25 | if err := os.Remove(addr); err != nil && !os.IsNotExist(err) {
26 | return nil, err
27 | }
28 | l, err := net.Listen("unix", addr)
29 | if err != nil {
30 | return nil, err
31 | }
32 | return &unixListener{l}, nil
33 | }
34 |
35 | func (ul *unixListener) Close() error {
36 | if err := os.Remove(ul.Addr().String()); err != nil && !os.IsNotExist(err) {
37 | return err
38 | }
39 | return ul.Listener.Close()
40 | }
41 |
--------------------------------------------------------------------------------
/vendor/github.com/golang/protobuf/LICENSE:
--------------------------------------------------------------------------------
1 | Go support for Protocol Buffers - Google's data interchange format
2 |
3 | Copyright 2010 The Go Authors. All rights reserved.
4 | https://github.com/golang/protobuf
5 |
6 | Redistribution and use in source and binary forms, with or without
7 | modification, are permitted provided that the following conditions are
8 | met:
9 |
10 | * Redistributions of source code must retain the above copyright
11 | notice, this list of conditions and the following disclaimer.
12 | * Redistributions in binary form must reproduce the above
13 | copyright notice, this list of conditions and the following disclaimer
14 | in the documentation and/or other materials provided with the
15 | distribution.
16 | * Neither the name of Google Inc. nor the names of its
17 | contributors may be used to endorse or promote products derived from
18 | this software without specific prior written permission.
19 |
20 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 |
32 |
--------------------------------------------------------------------------------
/vendor/github.com/golang/protobuf/proto/Makefile:
--------------------------------------------------------------------------------
1 | # Go support for Protocol Buffers - Google's data interchange format
2 | #
3 | # Copyright 2010 The Go Authors. All rights reserved.
4 | # https://github.com/golang/protobuf
5 | #
6 | # Redistribution and use in source and binary forms, with or without
7 | # modification, are permitted provided that the following conditions are
8 | # met:
9 | #
10 | # * Redistributions of source code must retain the above copyright
11 | # notice, this list of conditions and the following disclaimer.
12 | # * Redistributions in binary form must reproduce the above
13 | # copyright notice, this list of conditions and the following disclaimer
14 | # in the documentation and/or other materials provided with the
15 | # distribution.
16 | # * Neither the name of Google Inc. nor the names of its
17 | # contributors may be used to endorse or promote products derived from
18 | # this software without specific prior written permission.
19 | #
20 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 |
32 | install:
33 | go install
34 |
35 | test: install generate-test-pbs
36 | go test
37 |
38 |
39 | generate-test-pbs:
40 | make install
41 | make -C testdata
42 | protoc --go_out=Mtestdata/test.proto=github.com/golang/protobuf/proto/testdata,Mgoogle/protobuf/any.proto=github.com/golang/protobuf/ptypes/any:. proto3_proto/proto3.proto
43 | make
44 |
--------------------------------------------------------------------------------
/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/Makefile:
--------------------------------------------------------------------------------
1 | # Go support for Protocol Buffers - Google's data interchange format
2 | #
3 | # Copyright 2010 The Go Authors. All rights reserved.
4 | # https://github.com/golang/protobuf
5 | #
6 | # Redistribution and use in source and binary forms, with or without
7 | # modification, are permitted provided that the following conditions are
8 | # met:
9 | #
10 | # * Redistributions of source code must retain the above copyright
11 | # notice, this list of conditions and the following disclaimer.
12 | # * Redistributions in binary form must reproduce the above
13 | # copyright notice, this list of conditions and the following disclaimer
14 | # in the documentation and/or other materials provided with the
15 | # distribution.
16 | # * Neither the name of Google Inc. nor the names of its
17 | # contributors may be used to endorse or promote products derived from
18 | # this software without specific prior written permission.
19 | #
20 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 |
32 | # Not stored here, but descriptor.proto is in https://github.com/google/protobuf/
33 | # at src/google/protobuf/descriptor.proto
34 | regenerate:
35 | echo WARNING! THIS RULE IS PROBABLY NOT RIGHT FOR YOUR INSTALLATION
36 | protoc --go_out=. -I$(HOME)/src/protobuf/src $(HOME)/src/protobuf/src/google/protobuf/descriptor.proto && \
37 | sed 's,^package google_protobuf,package descriptor,' google/protobuf/descriptor.pb.go > \
38 | $(GOPATH)/src/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go && \
39 | rm -f google/protobuf/descriptor.pb.go
40 |
--------------------------------------------------------------------------------
/vendor/github.com/golang/protobuf/ptypes/doc.go:
--------------------------------------------------------------------------------
1 | // Go support for Protocol Buffers - Google's data interchange format
2 | //
3 | // Copyright 2016 The Go Authors. All rights reserved.
4 | // https://github.com/golang/protobuf
5 | //
6 | // Redistribution and use in source and binary forms, with or without
7 | // modification, are permitted provided that the following conditions are
8 | // met:
9 | //
10 | // * Redistributions of source code must retain the above copyright
11 | // notice, this list of conditions and the following disclaimer.
12 | // * Redistributions in binary form must reproduce the above
13 | // copyright notice, this list of conditions and the following disclaimer
14 | // in the documentation and/or other materials provided with the
15 | // distribution.
16 | // * Neither the name of Google Inc. nor the names of its
17 | // contributors may be used to endorse or promote products derived from
18 | // this software without specific prior written permission.
19 | //
20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 |
32 | /*
33 | Package ptypes contains code for interacting with well-known types.
34 | */
35 | package ptypes
36 |
--------------------------------------------------------------------------------
/vendor/github.com/golang/protobuf/ptypes/regen.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash -e
2 | #
3 | # This script fetches and rebuilds the "well-known types" protocol buffers.
4 | # To run this you will need protoc and goprotobuf installed;
5 | # see https://github.com/golang/protobuf for instructions.
6 | # You also need Go and Git installed.
7 |
8 | PKG=github.com/golang/protobuf/ptypes
9 | UPSTREAM=https://github.com/google/protobuf
10 | UPSTREAM_SUBDIR=src/google/protobuf
11 | PROTO_FILES='
12 | any.proto
13 | duration.proto
14 | empty.proto
15 | struct.proto
16 | timestamp.proto
17 | wrappers.proto
18 | '
19 |
20 | function die() {
21 | echo 1>&2 $*
22 | exit 1
23 | }
24 |
25 | # Sanity check that the right tools are accessible.
26 | for tool in go git protoc protoc-gen-go; do
27 | q=$(which $tool) || die "didn't find $tool"
28 | echo 1>&2 "$tool: $q"
29 | done
30 |
31 | tmpdir=$(mktemp -d -t regen-wkt.XXXXXX)
32 | trap 'rm -rf $tmpdir' EXIT
33 |
34 | echo -n 1>&2 "finding package dir... "
35 | pkgdir=$(go list -f '{{.Dir}}' $PKG)
36 | echo 1>&2 $pkgdir
37 | base=$(echo $pkgdir | sed "s,/$PKG\$,,")
38 | echo 1>&2 "base: $base"
39 | cd $base
40 |
41 | echo 1>&2 "fetching latest protos... "
42 | git clone -q $UPSTREAM $tmpdir
43 | # Pass 1: build mapping from upstream filename to our filename.
44 | declare -A filename_map
45 | for f in $(cd $PKG && find * -name '*.proto'); do
46 | echo -n 1>&2 "looking for latest version of $f... "
47 | up=$(cd $tmpdir/$UPSTREAM_SUBDIR && find * -name $(basename $f) | grep -v /testdata/)
48 | echo 1>&2 $up
49 | if [ $(echo $up | wc -w) != "1" ]; then
50 | die "not exactly one match"
51 | fi
52 | filename_map[$up]=$f
53 | done
54 | # Pass 2: copy files
55 | for up in "${!filename_map[@]}"; do
56 | f=${filename_map[$up]}
57 | shortname=$(basename $f | sed 's,\.proto$,,')
58 | cp $tmpdir/$UPSTREAM_SUBDIR/$up $PKG/$f
59 | done
60 |
61 | # Run protoc once per package.
62 | for dir in $(find $PKG -name '*.proto' | xargs dirname | sort | uniq); do
63 | echo 1>&2 "* $dir"
64 | protoc --go_out=. $dir/*.proto
65 | done
66 | echo 1>&2 "All OK"
67 |
--------------------------------------------------------------------------------
/vendor/github.com/gorilla/context/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2012 Rodrigo Moraes. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are
5 | met:
6 |
7 | * Redistributions of source code must retain the above copyright
8 | notice, this list of conditions and the following disclaimer.
9 | * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 | * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/github.com/gorilla/context/README.md:
--------------------------------------------------------------------------------
1 | context
2 | =======
3 | [](https://travis-ci.org/gorilla/context)
4 |
5 | gorilla/context is a general purpose registry for global request variables.
6 |
7 | Read the full documentation here: http://www.gorillatoolkit.org/pkg/context
8 |
--------------------------------------------------------------------------------
/vendor/github.com/gorilla/mux/ISSUE_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | **What version of Go are you running?** (Paste the output of `go version`)
2 |
3 |
4 | **What version of gorilla/mux are you at?** (Paste the output of `git rev-parse HEAD` inside `$GOPATH/src/github.com/gorilla/mux`)
5 |
6 |
7 | **Describe your problem** (and what you have tried so far)
8 |
9 |
10 | **Paste a minimal, runnable, reproduction of your issue below** (use backticks to format it)
11 |
12 |
--------------------------------------------------------------------------------
/vendor/github.com/gorilla/mux/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2012 Rodrigo Moraes. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are
5 | met:
6 |
7 | * Redistributions of source code must retain the above copyright
8 | notice, this list of conditions and the following disclaimer.
9 | * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 | * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/github.com/gorilla/mux/context_gorilla.go:
--------------------------------------------------------------------------------
1 | // +build !go1.7
2 |
3 | package mux
4 |
5 | import (
6 | "net/http"
7 |
8 | "github.com/gorilla/context"
9 | )
10 |
11 | func contextGet(r *http.Request, key interface{}) interface{} {
12 | return context.Get(r, key)
13 | }
14 |
15 | func contextSet(r *http.Request, key, val interface{}) *http.Request {
16 | if val == nil {
17 | return r
18 | }
19 |
20 | context.Set(r, key, val)
21 | return r
22 | }
23 |
24 | func contextClear(r *http.Request) {
25 | context.Clear(r)
26 | }
27 |
--------------------------------------------------------------------------------
/vendor/github.com/gorilla/mux/context_native.go:
--------------------------------------------------------------------------------
1 | // +build go1.7
2 |
3 | package mux
4 |
5 | import (
6 | "context"
7 | "net/http"
8 | )
9 |
10 | func contextGet(r *http.Request, key interface{}) interface{} {
11 | return r.Context().Value(key)
12 | }
13 |
14 | func contextSet(r *http.Request, key, val interface{}) *http.Request {
15 | if val == nil {
16 | return r
17 | }
18 |
19 | return r.WithContext(context.WithValue(r.Context(), key, val))
20 | }
21 |
22 | func contextClear(r *http.Request) {
23 | return
24 | }
25 |
--------------------------------------------------------------------------------
/vendor/github.com/gorilla/mux/test_helpers.go:
--------------------------------------------------------------------------------
1 | // Copyright 2012 The Gorilla Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package mux
6 |
7 | import "net/http"
8 |
9 | // SetURLVars sets the URL variables for the given request, to be accessed via
10 | // mux.Vars for testing route behaviour.
11 | //
12 | // This API should only be used for testing purposes; it provides a way to
13 | // inject variables into the request context. Alternatively, URL variables
14 | // can be set by making a route that captures the required variables,
15 | // starting a server and sending the request to that server.
16 | func SetURLVars(r *http.Request, val map[string]string) *http.Request {
17 | return setVars(r, val)
18 | }
19 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2009 The Go Authors. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are
5 | met:
6 |
7 | * Redistributions of source code must retain the above copyright
8 | notice, this list of conditions and the following disclaimer.
9 | * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 | * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/PATENTS:
--------------------------------------------------------------------------------
1 | Additional IP Rights Grant (Patents)
2 |
3 | "This implementation" means the copyrightable works distributed by
4 | Google as part of the Go project.
5 |
6 | Google hereby grants to You a perpetual, worldwide, non-exclusive,
7 | no-charge, royalty-free, irrevocable (except as stated in this section)
8 | patent license to make, have made, use, offer to sell, sell, import,
9 | transfer and otherwise run, modify and propagate the contents of this
10 | implementation of Go, where such license applies only to those patent
11 | claims, both currently owned or controlled by Google and acquired in
12 | the future, licensable by Google that are necessarily infringed by this
13 | implementation of Go. This grant does not include claims that would be
14 | infringed only as a consequence of further modification of this
15 | implementation. If you or your agent or exclusive licensee institute or
16 | order or agree to the institution of patent litigation against any
17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging
18 | that this implementation of Go or any code incorporated within this
19 | implementation of Go constitutes direct or contributory patent
20 | infringement, or inducement of patent infringement, then any patent
21 | rights granted to you under this License for this implementation of Go
22 | shall terminate as of the date such litigation is filed.
23 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/context/go19.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build go1.9
6 |
7 | package context
8 |
9 | import "context" // standard library's context, as of Go 1.7
10 |
11 | // A Context carries a deadline, a cancelation signal, and other values across
12 | // API boundaries.
13 | //
14 | // Context's methods may be called by multiple goroutines simultaneously.
15 | type Context = context.Context
16 |
17 | // A CancelFunc tells an operation to abandon its work.
18 | // A CancelFunc does not wait for the work to stop.
19 | // After the first call, subsequent calls to a CancelFunc do nothing.
20 | type CancelFunc = context.CancelFunc
21 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/Dockerfile:
--------------------------------------------------------------------------------
1 | #
2 | # This Dockerfile builds a recent curl with HTTP/2 client support, using
3 | # a recent nghttp2 build.
4 | #
5 | # See the Makefile for how to tag it. If Docker and that image is found, the
6 | # Go tests use this curl binary for integration tests.
7 | #
8 |
9 | FROM ubuntu:trusty
10 |
11 | RUN apt-get update && \
12 | apt-get upgrade -y && \
13 | apt-get install -y git-core build-essential wget
14 |
15 | RUN apt-get install -y --no-install-recommends \
16 | autotools-dev libtool pkg-config zlib1g-dev \
17 | libcunit1-dev libssl-dev libxml2-dev libevent-dev \
18 | automake autoconf
19 |
20 | # The list of packages nghttp2 recommends for h2load:
21 | RUN apt-get install -y --no-install-recommends make binutils \
22 | autoconf automake autotools-dev \
23 | libtool pkg-config zlib1g-dev libcunit1-dev libssl-dev libxml2-dev \
24 | libev-dev libevent-dev libjansson-dev libjemalloc-dev \
25 | cython python3.4-dev python-setuptools
26 |
27 | # Note: setting NGHTTP2_VER before the git clone, so an old git clone isn't cached:
28 | ENV NGHTTP2_VER 895da9a
29 | RUN cd /root && git clone https://github.com/tatsuhiro-t/nghttp2.git
30 |
31 | WORKDIR /root/nghttp2
32 | RUN git reset --hard $NGHTTP2_VER
33 | RUN autoreconf -i
34 | RUN automake
35 | RUN autoconf
36 | RUN ./configure
37 | RUN make
38 | RUN make install
39 |
40 | WORKDIR /root
41 | RUN wget http://curl.haxx.se/download/curl-7.45.0.tar.gz
42 | RUN tar -zxvf curl-7.45.0.tar.gz
43 | WORKDIR /root/curl-7.45.0
44 | RUN ./configure --with-ssl --with-nghttp2=/usr/local
45 | RUN make
46 | RUN make install
47 | RUN ldconfig
48 |
49 | CMD ["-h"]
50 | ENTRYPOINT ["/usr/local/bin/curl"]
51 |
52 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/Makefile:
--------------------------------------------------------------------------------
1 | curlimage:
2 | docker build -t gohttp2/curl .
3 |
4 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/README:
--------------------------------------------------------------------------------
1 | This is a work-in-progress HTTP/2 implementation for Go.
2 |
3 | It will eventually live in the Go standard library and won't require
4 | any changes to your code to use. It will just be automatic.
5 |
6 | Status:
7 |
8 | * The server support is pretty good. A few things are missing
9 | but are being worked on.
10 | * The client work has just started but shares a lot of code
11 | is coming along much quicker.
12 |
13 | Docs are at https://godoc.org/golang.org/x/net/http2
14 |
15 | Demo test server at https://http2.golang.org/
16 |
17 | Help & bug reports welcome!
18 |
19 | Contributing: https://golang.org/doc/contribute.html
20 | Bugs: https://golang.org/issue/new?title=x/net/http2:+
21 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/flow.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // Flow control
6 |
7 | package http2
8 |
9 | // flow is the flow control window's size.
10 | type flow struct {
11 | // n is the number of DATA bytes we're allowed to send.
12 | // A flow is kept both on a conn and a per-stream.
13 | n int32
14 |
15 | // conn points to the shared connection-level flow that is
16 | // shared by all streams on that conn. It is nil for the flow
17 | // that's on the conn directly.
18 | conn *flow
19 | }
20 |
21 | func (f *flow) setConnFlow(cf *flow) { f.conn = cf }
22 |
23 | func (f *flow) available() int32 {
24 | n := f.n
25 | if f.conn != nil && f.conn.n < n {
26 | n = f.conn.n
27 | }
28 | return n
29 | }
30 |
31 | func (f *flow) take(n int32) {
32 | if n > f.available() {
33 | panic("internal error: took too much")
34 | }
35 | f.n -= n
36 | if f.conn != nil {
37 | f.conn.n -= n
38 | }
39 | }
40 |
41 | // add adds n bytes (positive or negative) to the flow control window.
42 | // It returns false if the sum would exceed 2^31-1.
43 | func (f *flow) add(n int32) bool {
44 | remain := (1<<31 - 1) - f.n
45 | if n > remain {
46 | return false
47 | }
48 | f.n += n
49 | return true
50 | }
51 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/go16.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build go1.6
6 |
7 | package http2
8 |
9 | import (
10 | "net/http"
11 | "time"
12 | )
13 |
14 | func transportExpectContinueTimeout(t1 *http.Transport) time.Duration {
15 | return t1.ExpectContinueTimeout
16 | }
17 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/go17_not18.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build go1.7,!go1.8
6 |
7 | package http2
8 |
9 | import "crypto/tls"
10 |
11 | // temporary copy of Go 1.7's private tls.Config.clone:
12 | func cloneTLSConfig(c *tls.Config) *tls.Config {
13 | return &tls.Config{
14 | Rand: c.Rand,
15 | Time: c.Time,
16 | Certificates: c.Certificates,
17 | NameToCertificate: c.NameToCertificate,
18 | GetCertificate: c.GetCertificate,
19 | RootCAs: c.RootCAs,
20 | NextProtos: c.NextProtos,
21 | ServerName: c.ServerName,
22 | ClientAuth: c.ClientAuth,
23 | ClientCAs: c.ClientCAs,
24 | InsecureSkipVerify: c.InsecureSkipVerify,
25 | CipherSuites: c.CipherSuites,
26 | PreferServerCipherSuites: c.PreferServerCipherSuites,
27 | SessionTicketsDisabled: c.SessionTicketsDisabled,
28 | SessionTicketKey: c.SessionTicketKey,
29 | ClientSessionCache: c.ClientSessionCache,
30 | MinVersion: c.MinVersion,
31 | MaxVersion: c.MaxVersion,
32 | CurvePreferences: c.CurvePreferences,
33 | DynamicRecordSizingDisabled: c.DynamicRecordSizingDisabled,
34 | Renegotiation: c.Renegotiation,
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/go18.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build go1.8
6 |
7 | package http2
8 |
9 | import (
10 | "crypto/tls"
11 | "io"
12 | "net/http"
13 | )
14 |
15 | func cloneTLSConfig(c *tls.Config) *tls.Config {
16 | c2 := c.Clone()
17 | c2.GetClientCertificate = c.GetClientCertificate // golang.org/issue/19264
18 | return c2
19 | }
20 |
21 | var _ http.Pusher = (*responseWriter)(nil)
22 |
23 | // Push implements http.Pusher.
24 | func (w *responseWriter) Push(target string, opts *http.PushOptions) error {
25 | internalOpts := pushOptions{}
26 | if opts != nil {
27 | internalOpts.Method = opts.Method
28 | internalOpts.Header = opts.Header
29 | }
30 | return w.push(target, internalOpts)
31 | }
32 |
33 | func configureServer18(h1 *http.Server, h2 *Server) error {
34 | if h2.IdleTimeout == 0 {
35 | if h1.IdleTimeout != 0 {
36 | h2.IdleTimeout = h1.IdleTimeout
37 | } else {
38 | h2.IdleTimeout = h1.ReadTimeout
39 | }
40 | }
41 | return nil
42 | }
43 |
44 | func shouldLogPanic(panicValue interface{}) bool {
45 | return panicValue != nil && panicValue != http.ErrAbortHandler
46 | }
47 |
48 | func reqGetBody(req *http.Request) func() (io.ReadCloser, error) {
49 | return req.GetBody
50 | }
51 |
52 | func reqBodyIsNoBody(body io.ReadCloser) bool {
53 | return body == http.NoBody
54 | }
55 |
56 | func go18httpNoBody() io.ReadCloser { return http.NoBody } // for tests only
57 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/go19.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build go1.9
6 |
7 | package http2
8 |
9 | import (
10 | "net/http"
11 | )
12 |
13 | func configureServer19(s *http.Server, conf *Server) error {
14 | s.RegisterOnShutdown(conf.state.startGracefulShutdown)
15 | return nil
16 | }
17 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/headermap.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package http2
6 |
7 | import (
8 | "net/http"
9 | "strings"
10 | )
11 |
12 | var (
13 | commonLowerHeader = map[string]string{} // Go-Canonical-Case -> lower-case
14 | commonCanonHeader = map[string]string{} // lower-case -> Go-Canonical-Case
15 | )
16 |
17 | func init() {
18 | for _, v := range []string{
19 | "accept",
20 | "accept-charset",
21 | "accept-encoding",
22 | "accept-language",
23 | "accept-ranges",
24 | "age",
25 | "access-control-allow-origin",
26 | "allow",
27 | "authorization",
28 | "cache-control",
29 | "content-disposition",
30 | "content-encoding",
31 | "content-language",
32 | "content-length",
33 | "content-location",
34 | "content-range",
35 | "content-type",
36 | "cookie",
37 | "date",
38 | "etag",
39 | "expect",
40 | "expires",
41 | "from",
42 | "host",
43 | "if-match",
44 | "if-modified-since",
45 | "if-none-match",
46 | "if-unmodified-since",
47 | "last-modified",
48 | "link",
49 | "location",
50 | "max-forwards",
51 | "proxy-authenticate",
52 | "proxy-authorization",
53 | "range",
54 | "referer",
55 | "refresh",
56 | "retry-after",
57 | "server",
58 | "set-cookie",
59 | "strict-transport-security",
60 | "trailer",
61 | "transfer-encoding",
62 | "user-agent",
63 | "vary",
64 | "via",
65 | "www-authenticate",
66 | } {
67 | chk := http.CanonicalHeaderKey(v)
68 | commonLowerHeader[chk] = v
69 | commonCanonHeader[v] = chk
70 | }
71 | }
72 |
73 | func lowerHeader(v string) string {
74 | if s, ok := commonLowerHeader[v]; ok {
75 | return s
76 | }
77 | return strings.ToLower(v)
78 | }
79 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/not_go16.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !go1.6
6 |
7 | package http2
8 |
9 | import (
10 | "net/http"
11 | "time"
12 | )
13 |
14 | func configureTransport(t1 *http.Transport) (*Transport, error) {
15 | return nil, errTransportVersion
16 | }
17 |
18 | func transportExpectContinueTimeout(t1 *http.Transport) time.Duration {
19 | return 0
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/not_go18.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !go1.8
6 |
7 | package http2
8 |
9 | import (
10 | "io"
11 | "net/http"
12 | )
13 |
14 | func configureServer18(h1 *http.Server, h2 *Server) error {
15 | // No IdleTimeout to sync prior to Go 1.8.
16 | return nil
17 | }
18 |
19 | func shouldLogPanic(panicValue interface{}) bool {
20 | return panicValue != nil
21 | }
22 |
23 | func reqGetBody(req *http.Request) func() (io.ReadCloser, error) {
24 | return nil
25 | }
26 |
27 | func reqBodyIsNoBody(io.ReadCloser) bool { return false }
28 |
29 | func go18httpNoBody() io.ReadCloser { return nil } // for tests only
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/not_go19.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !go1.9
6 |
7 | package http2
8 |
9 | import (
10 | "net/http"
11 | )
12 |
13 | func configureServer19(s *http.Server, conf *Server) error {
14 | // not supported prior to go1.9
15 | return nil
16 | }
17 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/http2/writesched_random.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package http2
6 |
7 | import "math"
8 |
9 | // NewRandomWriteScheduler constructs a WriteScheduler that ignores HTTP/2
10 | // priorities. Control frames like SETTINGS and PING are written before DATA
11 | // frames, but if no control frames are queued and multiple streams have queued
12 | // HEADERS or DATA frames, Pop selects a ready stream arbitrarily.
13 | func NewRandomWriteScheduler() WriteScheduler {
14 | return &randomWriteScheduler{sq: make(map[uint32]*writeQueue)}
15 | }
16 |
17 | type randomWriteScheduler struct {
18 | // zero are frames not associated with a specific stream.
19 | zero writeQueue
20 |
21 | // sq contains the stream-specific queues, keyed by stream ID.
22 | // When a stream is idle or closed, it's deleted from the map.
23 | sq map[uint32]*writeQueue
24 |
25 | // pool of empty queues for reuse.
26 | queuePool writeQueuePool
27 | }
28 |
29 | func (ws *randomWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) {
30 | // no-op: idle streams are not tracked
31 | }
32 |
33 | func (ws *randomWriteScheduler) CloseStream(streamID uint32) {
34 | q, ok := ws.sq[streamID]
35 | if !ok {
36 | return
37 | }
38 | delete(ws.sq, streamID)
39 | ws.queuePool.put(q)
40 | }
41 |
42 | func (ws *randomWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) {
43 | // no-op: priorities are ignored
44 | }
45 |
46 | func (ws *randomWriteScheduler) Push(wr FrameWriteRequest) {
47 | id := wr.StreamID()
48 | if id == 0 {
49 | ws.zero.push(wr)
50 | return
51 | }
52 | q, ok := ws.sq[id]
53 | if !ok {
54 | q = ws.queuePool.get()
55 | ws.sq[id] = q
56 | }
57 | q.push(wr)
58 | }
59 |
60 | func (ws *randomWriteScheduler) Pop() (FrameWriteRequest, bool) {
61 | // Control frames first.
62 | if !ws.zero.empty() {
63 | return ws.zero.shift(), true
64 | }
65 | // Iterate over all non-idle streams until finding one that can be consumed.
66 | for _, q := range ws.sq {
67 | if wr, ok := q.consume(math.MaxInt32); ok {
68 | return wr, true
69 | }
70 | }
71 | return FrameWriteRequest{}, false
72 | }
73 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/idna/trie.go:
--------------------------------------------------------------------------------
1 | // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
2 |
3 | // Copyright 2016 The Go Authors. All rights reserved.
4 | // Use of this source code is governed by a BSD-style
5 | // license that can be found in the LICENSE file.
6 |
7 | package idna
8 |
9 | // appendMapping appends the mapping for the respective rune. isMapped must be
10 | // true. A mapping is a categorization of a rune as defined in UTS #46.
11 | func (c info) appendMapping(b []byte, s string) []byte {
12 | index := int(c >> indexShift)
13 | if c&xorBit == 0 {
14 | s := mappings[index:]
15 | return append(b, s[1:s[0]+1]...)
16 | }
17 | b = append(b, s...)
18 | if c&inlineXOR == inlineXOR {
19 | // TODO: support and handle two-byte inline masks
20 | b[len(b)-1] ^= byte(index)
21 | } else {
22 | for p := len(b) - int(xorData[index]); p < len(b); p++ {
23 | index++
24 | b[p] ^= xorData[index]
25 | }
26 | }
27 | return b
28 | }
29 |
30 | // Sparse block handling code.
31 |
32 | type valueRange struct {
33 | value uint16 // header: value:stride
34 | lo, hi byte // header: lo:n
35 | }
36 |
37 | type sparseBlocks struct {
38 | values []valueRange
39 | offset []uint16
40 | }
41 |
42 | var idnaSparse = sparseBlocks{
43 | values: idnaSparseValues[:],
44 | offset: idnaSparseOffset[:],
45 | }
46 |
47 | // Don't use newIdnaTrie to avoid unconditional linking in of the table.
48 | var trie = &idnaTrie{}
49 |
50 | // lookup determines the type of block n and looks up the value for b.
51 | // For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
52 | // is a list of ranges with an accompanying value. Given a matching range r,
53 | // the value for b is by r.value + (b - r.lo) * stride.
54 | func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
55 | offset := t.offset[n]
56 | header := t.values[offset]
57 | lo := offset + 1
58 | hi := lo + uint16(header.lo)
59 | for lo < hi {
60 | m := lo + (hi-lo)/2
61 | r := t.values[m]
62 | if r.lo <= b && b <= r.hi {
63 | return r.value + uint16(b-r.lo)*header.value
64 | }
65 | if b < r.lo {
66 | hi = m
67 | } else {
68 | lo = m + 1
69 | }
70 | }
71 | return 0
72 | }
73 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/trace/trace_go16.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !go1.7
6 |
7 | package trace
8 |
9 | import "golang.org/x/net/context"
10 |
11 | // NewContext returns a copy of the parent context
12 | // and associates it with a Trace.
13 | func NewContext(ctx context.Context, tr Trace) context.Context {
14 | return context.WithValue(ctx, contextKey, tr)
15 | }
16 |
17 | // FromContext returns the Trace bound to the context, if any.
18 | func FromContext(ctx context.Context) (tr Trace, ok bool) {
19 | tr, ok = ctx.Value(contextKey).(Trace)
20 | return
21 | }
22 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/net/trace/trace_go17.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build go1.7
6 |
7 | package trace
8 |
9 | import "context"
10 |
11 | // NewContext returns a copy of the parent context
12 | // and associates it with a Trace.
13 | func NewContext(ctx context.Context, tr Trace) context.Context {
14 | return context.WithValue(ctx, contextKey, tr)
15 | }
16 |
17 | // FromContext returns the Trace bound to the context, if any.
18 | func FromContext(ctx context.Context) (tr Trace, ok bool) {
19 | tr, ok = ctx.Value(contextKey).(Trace)
20 | return
21 | }
22 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2009 The Go Authors. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are
5 | met:
6 |
7 | * Redistributions of source code must retain the above copyright
8 | notice, this list of conditions and the following disclaimer.
9 | * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 | * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/PATENTS:
--------------------------------------------------------------------------------
1 | Additional IP Rights Grant (Patents)
2 |
3 | "This implementation" means the copyrightable works distributed by
4 | Google as part of the Go project.
5 |
6 | Google hereby grants to You a perpetual, worldwide, non-exclusive,
7 | no-charge, royalty-free, irrevocable (except as stated in this section)
8 | patent license to make, have made, use, offer to sell, sell, import,
9 | transfer and otherwise run, modify and propagate the contents of this
10 | implementation of Go, where such license applies only to those patent
11 | claims, both currently owned or controlled by Google and acquired in
12 | the future, licensable by Google that are necessarily infringed by this
13 | implementation of Go. This grant does not include claims that would be
14 | infringed only as a consequence of further modification of this
15 | implementation. If you or your agent or exclusive licensee institute or
16 | order or agree to the institution of patent litigation against any
17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging
18 | that this implementation of Go or any code incorporated within this
19 | implementation of Go constitutes direct or contributory patent
20 | infringement, or inducement of patent infringement, then any patent
21 | rights granted to you under this License for this implementation of Go
22 | shall terminate as of the date such litigation is filed.
23 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_386.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for 386, Darwin
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_amd64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for AMD64, Darwin
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-56
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_arm.s:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 | // +build arm,darwin
7 |
8 | #include "textflag.h"
9 |
10 | //
11 | // System call support for ARM, Darwin
12 | //
13 |
14 | // Just jump to package syscall's implementation for all these functions.
15 | // The runtime may know about them.
16 |
17 | TEXT ·Syscall(SB),NOSPLIT,$0-28
18 | B syscall·Syscall(SB)
19 |
20 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
21 | B syscall·Syscall6(SB)
22 |
23 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
24 | B syscall·Syscall9(SB)
25 |
26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
27 | B syscall·RawSyscall(SB)
28 |
29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
30 | B syscall·RawSyscall6(SB)
31 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_arm64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 | // +build arm64,darwin
7 |
8 | #include "textflag.h"
9 |
10 | //
11 | // System call support for AMD64, Darwin
12 | //
13 |
14 | // Just jump to package syscall's implementation for all these functions.
15 | // The runtime may know about them.
16 |
17 | TEXT ·Syscall(SB),NOSPLIT,$0-56
18 | B syscall·Syscall(SB)
19 |
20 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
21 | B syscall·Syscall6(SB)
22 |
23 | TEXT ·Syscall9(SB),NOSPLIT,$0-104
24 | B syscall·Syscall9(SB)
25 |
26 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
27 | B syscall·RawSyscall(SB)
28 |
29 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
30 | B syscall·RawSyscall6(SB)
31 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for AMD64, DragonFly
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-64
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-88
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-112
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-64
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-88
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_freebsd_386.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for 386, FreeBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for AMD64, FreeBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-56
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_freebsd_arm.s:
--------------------------------------------------------------------------------
1 | // Copyright 2012 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for ARM, FreeBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | B syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | B syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
23 | B syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | B syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
29 | B syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_386.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System calls for 386, Linux
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
23 | JMP syscall·RawSyscall(SB)
24 |
25 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
26 | JMP syscall·RawSyscall6(SB)
27 |
28 | TEXT ·socketcall(SB),NOSPLIT,$0-36
29 | JMP syscall·socketcall(SB)
30 |
31 | TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
32 | JMP syscall·rawsocketcall(SB)
33 |
34 | TEXT ·seek(SB),NOSPLIT,$0-28
35 | JMP syscall·seek(SB)
36 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_amd64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System calls for AMD64, Linux
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-56
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
23 | JMP syscall·RawSyscall(SB)
24 |
25 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
26 | JMP syscall·RawSyscall6(SB)
27 |
28 | TEXT ·gettimeofday(SB),NOSPLIT,$0-16
29 | JMP syscall·gettimeofday(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_arm.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System calls for arm, Linux
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | B syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | B syscall·Syscall6(SB)
21 |
22 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
23 | B syscall·RawSyscall(SB)
24 |
25 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
26 | B syscall·RawSyscall6(SB)
27 |
28 | TEXT ·seek(SB),NOSPLIT,$0-32
29 | B syscall·seek(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_arm64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build linux
6 | // +build arm64
7 | // +build !gccgo
8 |
9 | #include "textflag.h"
10 |
11 | // Just jump to package syscall's implementation for all these functions.
12 | // The runtime may know about them.
13 |
14 | TEXT ·Syscall(SB),NOSPLIT,$0-56
15 | B syscall·Syscall(SB)
16 |
17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
18 | B syscall·Syscall6(SB)
19 |
20 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
21 | B syscall·RawSyscall(SB)
22 |
23 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
24 | B syscall·RawSyscall6(SB)
25 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build linux
6 | // +build mips64 mips64le
7 | // +build !gccgo
8 |
9 | #include "textflag.h"
10 |
11 | //
12 | // System calls for mips64, Linux
13 | //
14 |
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 |
18 | TEXT ·Syscall(SB),NOSPLIT,$0-56
19 | JMP syscall·Syscall(SB)
20 |
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
22 | JMP syscall·Syscall6(SB)
23 |
24 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
25 | JMP syscall·RawSyscall(SB)
26 |
27 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
28 | JMP syscall·RawSyscall6(SB)
29 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build linux
6 | // +build mips mipsle
7 | // +build !gccgo
8 |
9 | #include "textflag.h"
10 |
11 | //
12 | // System calls for mips, Linux
13 | //
14 |
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 |
18 | TEXT ·Syscall(SB),NOSPLIT,$0-28
19 | JMP syscall·Syscall(SB)
20 |
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
22 | JMP syscall·Syscall6(SB)
23 |
24 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
25 | JMP syscall·Syscall9(SB)
26 |
27 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
28 | JMP syscall·RawSyscall(SB)
29 |
30 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
31 | JMP syscall·RawSyscall6(SB)
32 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build linux
6 | // +build ppc64 ppc64le
7 | // +build !gccgo
8 |
9 | #include "textflag.h"
10 |
11 | //
12 | // System calls for ppc64, Linux
13 | //
14 |
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 |
18 | TEXT ·Syscall(SB),NOSPLIT,$0-56
19 | BR syscall·Syscall(SB)
20 |
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
22 | BR syscall·Syscall6(SB)
23 |
24 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
25 | BR syscall·RawSyscall(SB)
26 |
27 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
28 | BR syscall·RawSyscall6(SB)
29 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_s390x.s:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build s390x
6 | // +build linux
7 | // +build !gccgo
8 |
9 | #include "textflag.h"
10 |
11 | //
12 | // System calls for s390x, Linux
13 | //
14 |
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 |
18 | TEXT ·Syscall(SB),NOSPLIT,$0-56
19 | BR syscall·Syscall(SB)
20 |
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
22 | BR syscall·Syscall6(SB)
23 |
24 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
25 | BR syscall·RawSyscall(SB)
26 |
27 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
28 | BR syscall·RawSyscall6(SB)
29 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_netbsd_386.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for 386, NetBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for AMD64, NetBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-56
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_netbsd_arm.s:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for ARM, NetBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | B syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | B syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
23 | B syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | B syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
29 | B syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_openbsd_386.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for 386, OpenBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for AMD64, OpenBSD
11 | //
12 |
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 |
16 | TEXT ·Syscall(SB),NOSPLIT,$0-56
17 | JMP syscall·Syscall(SB)
18 |
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
20 | JMP syscall·Syscall6(SB)
21 |
22 | TEXT ·Syscall9(SB),NOSPLIT,$0-104
23 | JMP syscall·Syscall9(SB)
24 |
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
26 | JMP syscall·RawSyscall(SB)
27 |
28 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
29 | JMP syscall·RawSyscall6(SB)
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go
11 | //
12 |
13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88
14 | JMP syscall·sysvicall6(SB)
15 |
16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88
17 | JMP syscall·rawSysvicall6(SB)
18 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/bluetooth_linux.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // Bluetooth sockets and messages
6 |
7 | package unix
8 |
9 | // Bluetooth Protocols
10 | const (
11 | BTPROTO_L2CAP = 0
12 | BTPROTO_HCI = 1
13 | BTPROTO_SCO = 2
14 | BTPROTO_RFCOMM = 3
15 | BTPROTO_BNEP = 4
16 | BTPROTO_CMTP = 5
17 | BTPROTO_HIDP = 6
18 | BTPROTO_AVDTP = 7
19 | )
20 |
21 | const (
22 | HCI_CHANNEL_RAW = 0
23 | HCI_CHANNEL_USER = 1
24 | HCI_CHANNEL_MONITOR = 2
25 | HCI_CHANNEL_CONTROL = 3
26 | )
27 |
28 | // Socketoption Level
29 | const (
30 | SOL_BLUETOOTH = 0x112
31 | SOL_HCI = 0x0
32 | SOL_L2CAP = 0x6
33 | SOL_RFCOMM = 0x12
34 | SOL_SCO = 0x11
35 | )
36 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/constants.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris
6 |
7 | package unix
8 |
9 | const (
10 | R_OK = 0x4
11 | W_OK = 0x2
12 | X_OK = 0x1
13 | )
14 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/endian_big.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 | //
5 | // +build ppc64 s390x mips mips64
6 |
7 | package unix
8 |
9 | const isBigEndian = true
10 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/endian_little.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 | //
5 | // +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le
6 |
7 | package unix
8 |
9 | const isBigEndian = false
10 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/env_unix.go:
--------------------------------------------------------------------------------
1 | // Copyright 2010 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris
6 |
7 | // Unix environment variables.
8 |
9 | package unix
10 |
11 | import "syscall"
12 |
13 | func Getenv(key string) (value string, found bool) {
14 | return syscall.Getenv(key)
15 | }
16 |
17 | func Setenv(key, value string) error {
18 | return syscall.Setenv(key, value)
19 | }
20 |
21 | func Clearenv() {
22 | syscall.Clearenv()
23 | }
24 |
25 | func Environ() []string {
26 | return syscall.Environ()
27 | }
28 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/env_unset.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build go1.4
6 |
7 | package unix
8 |
9 | import "syscall"
10 |
11 | func Unsetenv(key string) error {
12 | // This was added in Go 1.4.
13 | return syscall.Unsetenv(key)
14 | }
15 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/flock.go:
--------------------------------------------------------------------------------
1 | // +build linux darwin freebsd openbsd netbsd dragonfly
2 |
3 | // Copyright 2014 The Go Authors. All rights reserved.
4 | // Use of this source code is governed by a BSD-style
5 | // license that can be found in the LICENSE file.
6 |
7 | // +build darwin dragonfly freebsd linux netbsd openbsd
8 |
9 | package unix
10 |
11 | import "unsafe"
12 |
13 | // fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux
14 | // systems by flock_linux_32bit.go to be SYS_FCNTL64.
15 | var fcntl64Syscall uintptr = SYS_FCNTL
16 |
17 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
18 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
19 | _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))
20 | if errno == 0 {
21 | return nil
22 | }
23 | return errno
24 | }
25 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/flock_linux_32bit.go:
--------------------------------------------------------------------------------
1 | // +build linux,386 linux,arm linux,mips linux,mipsle
2 |
3 | // Copyright 2014 The Go Authors. All rights reserved.
4 | // Use of this source code is governed by a BSD-style
5 | // license that can be found in the LICENSE file.
6 |
7 | package unix
8 |
9 | func init() {
10 | // On 32-bit Linux systems, the fcntl syscall that matches Go's
11 | // Flock_t type is SYS_FCNTL64, not SYS_FCNTL.
12 | fcntl64Syscall = SYS_FCNTL64
13 | }
14 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/gccgo.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build gccgo
6 |
7 | package unix
8 |
9 | import "syscall"
10 |
11 | // We can't use the gc-syntax .s files for gccgo. On the plus side
12 | // much of the functionality can be written directly in Go.
13 |
14 | //extern gccgoRealSyscall
15 | func realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r, errno uintptr)
16 |
17 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
18 | syscall.Entersyscall()
19 | r, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
20 | syscall.Exitsyscall()
21 | return r, 0, syscall.Errno(errno)
22 | }
23 |
24 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
25 | syscall.Entersyscall()
26 | r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
27 | syscall.Exitsyscall()
28 | return r, 0, syscall.Errno(errno)
29 | }
30 |
31 | func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) {
32 | syscall.Entersyscall()
33 | r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)
34 | syscall.Exitsyscall()
35 | return r, 0, syscall.Errno(errno)
36 | }
37 |
38 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
39 | r, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
40 | return r, 0, syscall.Errno(errno)
41 | }
42 |
43 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
44 | r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
45 | return r, 0, syscall.Errno(errno)
46 | }
47 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/gccgo_c.c:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build gccgo
6 |
7 | #include
8 | #include
9 | #include
10 |
11 | #define _STRINGIFY2_(x) #x
12 | #define _STRINGIFY_(x) _STRINGIFY2_(x)
13 | #define GOSYM_PREFIX _STRINGIFY_(__USER_LABEL_PREFIX__)
14 |
15 | // Call syscall from C code because the gccgo support for calling from
16 | // Go to C does not support varargs functions.
17 |
18 | struct ret {
19 | uintptr_t r;
20 | uintptr_t err;
21 | };
22 |
23 | struct ret
24 | gccgoRealSyscall(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)
25 | {
26 | struct ret r;
27 |
28 | errno = 0;
29 | r.r = syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);
30 | r.err = errno;
31 | return r;
32 | }
33 |
34 | // Define the use function in C so that it is not inlined.
35 |
36 | extern void use(void *) __asm__ (GOSYM_PREFIX GOPKGPATH ".use") __attribute__((noinline));
37 |
38 | void
39 | use(void *p __attribute__ ((unused)))
40 | {
41 | }
42 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build gccgo,linux,amd64
6 |
7 | package unix
8 |
9 | import "syscall"
10 |
11 | //extern gettimeofday
12 | func realGettimeofday(*Timeval, *byte) int32
13 |
14 | func gettimeofday(tv *Timeval) (err syscall.Errno) {
15 | r := realGettimeofday(tv, nil)
16 | if r < 0 {
17 | return syscall.GetErrno()
18 | }
19 | return 0
20 | }
21 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/gccgo_linux_sparc64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build gccgo,linux,sparc64
6 |
7 | package unix
8 |
9 | import "syscall"
10 |
11 | //extern sysconf
12 | func realSysconf(name int) int64
13 |
14 | func sysconf(name int) (n int64, err syscall.Errno) {
15 | r := realSysconf(name)
16 | if r < 0 {
17 | return 0, syscall.GetErrno()
18 | }
19 | return r, 0
20 | }
21 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/mksysnum_darwin.pl:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env perl
2 | # Copyright 2009 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 | # Generate system call table for Darwin from sys/syscall.h
7 |
8 | use strict;
9 |
10 | if($ENV{'GOARCH'} eq "" || $ENV{'GOOS'} eq "") {
11 | print STDERR "GOARCH or GOOS not defined in environment\n";
12 | exit 1;
13 | }
14 |
15 | my $command = "mksysnum_darwin.pl " . join(' ', @ARGV);
16 |
17 | print <){
29 | if(/^#define\s+SYS_(\w+)\s+([0-9]+)/){
30 | my $name = $1;
31 | my $num = $2;
32 | $name =~ y/a-z/A-Z/;
33 | print " SYS_$name = $num;"
34 | }
35 | }
36 |
37 | print <){
30 | if(/^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$/){
31 | my $num = $1;
32 | my $proto = $2;
33 | my $name = "SYS_$3";
34 | $name =~ y/a-z/A-Z/;
35 |
36 | # There are multiple entries for enosys and nosys, so comment them out.
37 | if($name =~ /^SYS_E?NOSYS$/){
38 | $name = "// $name";
39 | }
40 | if($name eq 'SYS_SYS_EXIT'){
41 | $name = 'SYS_EXIT';
42 | }
43 |
44 | print " $name = $num; // $proto\n";
45 | }
46 | }
47 |
48 | print <){
30 | if(/^([0-9]+)\s+\S+\s+STD\s+({ \S+\s+(\w+).*)$/){
31 | my $num = $1;
32 | my $proto = $2;
33 | my $name = "SYS_$3";
34 | $name =~ y/a-z/A-Z/;
35 |
36 | # There are multiple entries for enosys and nosys, so comment them out.
37 | if($name =~ /^SYS_E?NOSYS$/){
38 | $name = "// $name";
39 | }
40 | if($name eq 'SYS_SYS_EXIT'){
41 | $name = 'SYS_EXIT';
42 | }
43 | if($name =~ /^SYS_CAP_+/ || $name =~ /^SYS___CAP_+/){
44 | next
45 | }
46 |
47 | print " $name = $num; // $proto\n";
48 |
49 | # We keep Capsicum syscall numbers for FreeBSD
50 | # 9-STABLE here because we are not sure whether they
51 | # are mature and stable.
52 | if($num == 513){
53 | print " SYS_CAP_NEW = 514 // { int cap_new(int fd, uint64_t rights); }\n";
54 | print " SYS_CAP_GETRIGHTS = 515 // { int cap_getrights(int fd, \\\n";
55 | print " SYS_CAP_ENTER = 516 // { int cap_enter(void); }\n";
56 | print " SYS_CAP_GETMODE = 517 // { int cap_getmode(u_int *modep); }\n";
57 | }
58 | }
59 | }
60 |
61 | print <){
31 | if($line =~ /^(.*)\\$/) {
32 | # Handle continuation
33 | $line = $1;
34 | $_ =~ s/^\s+//;
35 | $line .= $_;
36 | } else {
37 | # New line
38 | $line = $_;
39 | }
40 | next if $line =~ /\\$/;
41 | if($line =~ /^([0-9]+)\s+((STD)|(NOERR))\s+(RUMP\s+)?({\s+\S+\s*\*?\s*\|(\S+)\|(\S*)\|(\w+).*\s+})(\s+(\S+))?$/) {
42 | my $num = $1;
43 | my $proto = $6;
44 | my $compat = $8;
45 | my $name = "$7_$9";
46 |
47 | $name = "$7_$11" if $11 ne '';
48 | $name =~ y/a-z/A-Z/;
49 |
50 | if($compat eq '' || $compat eq '30' || $compat eq '50') {
51 | print " $name = $num; // $proto\n";
52 | }
53 | }
54 | }
55 |
56 | print <){
30 | if(/^([0-9]+)\s+STD\s+(NOLOCK\s+)?({ \S+\s+\*?(\w+).*)$/){
31 | my $num = $1;
32 | my $proto = $3;
33 | my $name = $4;
34 | $name =~ y/a-z/A-Z/;
35 |
36 | # There are multiple entries for enosys and nosys, so comment them out.
37 | if($name =~ /^SYS_E?NOSYS$/){
38 | $name = "// $name";
39 | }
40 | if($name eq 'SYS_SYS_EXIT'){
41 | $name = 'SYS_EXIT';
42 | }
43 |
44 | print " $name = $num; // $proto\n";
45 | }
46 | }
47 |
48 | print <= 10 {
20 | buf[i] = byte(val%10 + '0')
21 | i--
22 | val /= 10
23 | }
24 | buf[i] = byte(val + '0')
25 | return string(buf[i:])
26 | }
27 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_386.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build 386,darwin
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func Getpagesize() int { return 4096 }
15 |
16 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
17 |
18 | func NsecToTimespec(nsec int64) (ts Timespec) {
19 | ts.Sec = int32(nsec / 1e9)
20 | ts.Nsec = int32(nsec % 1e9)
21 | return
22 | }
23 |
24 | func NsecToTimeval(nsec int64) (tv Timeval) {
25 | nsec += 999 // round up to microsecond
26 | tv.Usec = int32(nsec % 1e9 / 1e3)
27 | tv.Sec = int32(nsec / 1e9)
28 | return
29 | }
30 |
31 | //sysnb gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
32 | func Gettimeofday(tv *Timeval) (err error) {
33 | // The tv passed to gettimeofday must be non-nil
34 | // but is otherwise unused. The answers come back
35 | // in the two registers.
36 | sec, usec, err := gettimeofday(tv)
37 | tv.Sec = int32(sec)
38 | tv.Usec = int32(usec)
39 | return err
40 | }
41 |
42 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
43 | k.Ident = uint32(fd)
44 | k.Filter = int16(mode)
45 | k.Flags = uint16(flags)
46 | }
47 |
48 | func (iov *Iovec) SetLen(length int) {
49 | iov.Len = uint32(length)
50 | }
51 |
52 | func (msghdr *Msghdr) SetControllen(length int) {
53 | msghdr.Controllen = uint32(length)
54 | }
55 |
56 | func (cmsg *Cmsghdr) SetLen(length int) {
57 | cmsg.Len = uint32(length)
58 | }
59 |
60 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
61 | var length = uint64(count)
62 |
63 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(*offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
64 |
65 | written = int(length)
66 |
67 | if e1 != 0 {
68 | err = e1
69 | }
70 | return
71 | }
72 |
73 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
74 |
75 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
76 | // of darwin/386 the syscall is called sysctl instead of __sysctl.
77 | const SYS___SYSCTL = SYS_SYSCTL
78 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,darwin
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error)
15 |
16 | func Getpagesize() int { return 4096 }
17 |
18 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
19 |
20 | func NsecToTimespec(nsec int64) (ts Timespec) {
21 | ts.Sec = nsec / 1e9
22 | ts.Nsec = nsec % 1e9
23 | return
24 | }
25 |
26 | func NsecToTimeval(nsec int64) (tv Timeval) {
27 | nsec += 999 // round up to microsecond
28 | tv.Usec = int32(nsec % 1e9 / 1e3)
29 | tv.Sec = int64(nsec / 1e9)
30 | return
31 | }
32 |
33 | //sysnb gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
34 | func Gettimeofday(tv *Timeval) (err error) {
35 | // The tv passed to gettimeofday must be non-nil
36 | // but is otherwise unused. The answers come back
37 | // in the two registers.
38 | sec, usec, err := gettimeofday(tv)
39 | tv.Sec = sec
40 | tv.Usec = usec
41 | return err
42 | }
43 |
44 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
45 | k.Ident = uint64(fd)
46 | k.Filter = int16(mode)
47 | k.Flags = uint16(flags)
48 | }
49 |
50 | func (iov *Iovec) SetLen(length int) {
51 | iov.Len = uint64(length)
52 | }
53 |
54 | func (msghdr *Msghdr) SetControllen(length int) {
55 | msghdr.Controllen = uint32(length)
56 | }
57 |
58 | func (cmsg *Cmsghdr) SetLen(length int) {
59 | cmsg.Len = uint32(length)
60 | }
61 |
62 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
63 | var length = uint64(count)
64 |
65 | _, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
66 |
67 | written = int(length)
68 |
69 | if e1 != 0 {
70 | err = e1
71 | }
72 | return
73 | }
74 |
75 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
76 |
77 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
78 | // of darwin/amd64 the syscall is called sysctl instead of __sysctl.
79 | const SYS___SYSCTL = SYS_SYSCTL
80 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package unix
6 |
7 | import (
8 | "syscall"
9 | "unsafe"
10 | )
11 |
12 | func Getpagesize() int { return 4096 }
13 |
14 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
15 |
16 | func NsecToTimespec(nsec int64) (ts Timespec) {
17 | ts.Sec = int32(nsec / 1e9)
18 | ts.Nsec = int32(nsec % 1e9)
19 | return
20 | }
21 |
22 | func NsecToTimeval(nsec int64) (tv Timeval) {
23 | nsec += 999 // round up to microsecond
24 | tv.Usec = int32(nsec % 1e9 / 1e3)
25 | tv.Sec = int32(nsec / 1e9)
26 | return
27 | }
28 |
29 | //sysnb gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
30 | func Gettimeofday(tv *Timeval) (err error) {
31 | // The tv passed to gettimeofday must be non-nil
32 | // but is otherwise unused. The answers come back
33 | // in the two registers.
34 | sec, usec, err := gettimeofday(tv)
35 | tv.Sec = int32(sec)
36 | tv.Usec = int32(usec)
37 | return err
38 | }
39 |
40 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
41 | k.Ident = uint32(fd)
42 | k.Filter = int16(mode)
43 | k.Flags = uint16(flags)
44 | }
45 |
46 | func (iov *Iovec) SetLen(length int) {
47 | iov.Len = uint32(length)
48 | }
49 |
50 | func (msghdr *Msghdr) SetControllen(length int) {
51 | msghdr.Controllen = uint32(length)
52 | }
53 |
54 | func (cmsg *Cmsghdr) SetLen(length int) {
55 | cmsg.Len = uint32(length)
56 | }
57 |
58 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
59 | var length = uint64(count)
60 |
61 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(*offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
62 |
63 | written = int(length)
64 |
65 | if e1 != 0 {
66 | err = e1
67 | }
68 | return
69 | }
70 |
71 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
72 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build arm64,darwin
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func Getpagesize() int { return 16384 }
15 |
16 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
17 |
18 | func NsecToTimespec(nsec int64) (ts Timespec) {
19 | ts.Sec = nsec / 1e9
20 | ts.Nsec = nsec % 1e9
21 | return
22 | }
23 |
24 | func NsecToTimeval(nsec int64) (tv Timeval) {
25 | nsec += 999 // round up to microsecond
26 | tv.Usec = int32(nsec % 1e9 / 1e3)
27 | tv.Sec = int64(nsec / 1e9)
28 | return
29 | }
30 |
31 | //sysnb gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
32 | func Gettimeofday(tv *Timeval) (err error) {
33 | // The tv passed to gettimeofday must be non-nil
34 | // but is otherwise unused. The answers come back
35 | // in the two registers.
36 | sec, usec, err := gettimeofday(tv)
37 | tv.Sec = sec
38 | tv.Usec = usec
39 | return err
40 | }
41 |
42 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
43 | k.Ident = uint64(fd)
44 | k.Filter = int16(mode)
45 | k.Flags = uint16(flags)
46 | }
47 |
48 | func (iov *Iovec) SetLen(length int) {
49 | iov.Len = uint64(length)
50 | }
51 |
52 | func (msghdr *Msghdr) SetControllen(length int) {
53 | msghdr.Controllen = uint32(length)
54 | }
55 |
56 | func (cmsg *Cmsghdr) SetLen(length int) {
57 | cmsg.Len = uint32(length)
58 | }
59 |
60 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
61 | var length = uint64(count)
62 |
63 | _, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
64 |
65 | written = int(length)
66 |
67 | if e1 != 0 {
68 | err = e1
69 | }
70 | return
71 | }
72 |
73 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
74 |
75 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
76 | // of darwin/arm64 the syscall is called sysctl instead of __sysctl.
77 | const SYS___SYSCTL = SYS_SYSCTL
78 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_dragonfly_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,dragonfly
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func Getpagesize() int { return 4096 }
15 |
16 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
17 |
18 | func NsecToTimespec(nsec int64) (ts Timespec) {
19 | ts.Sec = nsec / 1e9
20 | ts.Nsec = nsec % 1e9
21 | return
22 | }
23 |
24 | func NsecToTimeval(nsec int64) (tv Timeval) {
25 | nsec += 999 // round up to microsecond
26 | tv.Usec = nsec % 1e9 / 1e3
27 | tv.Sec = int64(nsec / 1e9)
28 | return
29 | }
30 |
31 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
32 | k.Ident = uint64(fd)
33 | k.Filter = int16(mode)
34 | k.Flags = uint16(flags)
35 | }
36 |
37 | func (iov *Iovec) SetLen(length int) {
38 | iov.Len = uint64(length)
39 | }
40 |
41 | func (msghdr *Msghdr) SetControllen(length int) {
42 | msghdr.Controllen = uint32(length)
43 | }
44 |
45 | func (cmsg *Cmsghdr) SetLen(length int) {
46 | cmsg.Len = uint32(length)
47 | }
48 |
49 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
50 | var writtenOut uint64 = 0
51 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0, 0)
52 |
53 | written = int(writtenOut)
54 |
55 | if e1 != 0 {
56 | err = e1
57 | }
58 | return
59 | }
60 |
61 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
62 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_freebsd_386.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build 386,freebsd
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func Getpagesize() int { return 4096 }
15 |
16 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
17 |
18 | func NsecToTimespec(nsec int64) (ts Timespec) {
19 | ts.Sec = int32(nsec / 1e9)
20 | ts.Nsec = int32(nsec % 1e9)
21 | return
22 | }
23 |
24 | func NsecToTimeval(nsec int64) (tv Timeval) {
25 | nsec += 999 // round up to microsecond
26 | tv.Usec = int32(nsec % 1e9 / 1e3)
27 | tv.Sec = int32(nsec / 1e9)
28 | return
29 | }
30 |
31 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
32 | k.Ident = uint32(fd)
33 | k.Filter = int16(mode)
34 | k.Flags = uint16(flags)
35 | }
36 |
37 | func (iov *Iovec) SetLen(length int) {
38 | iov.Len = uint32(length)
39 | }
40 |
41 | func (msghdr *Msghdr) SetControllen(length int) {
42 | msghdr.Controllen = uint32(length)
43 | }
44 |
45 | func (cmsg *Cmsghdr) SetLen(length int) {
46 | cmsg.Len = uint32(length)
47 | }
48 |
49 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
50 | var writtenOut uint64 = 0
51 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr((*offset)>>32), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0)
52 |
53 | written = int(writtenOut)
54 |
55 | if e1 != 0 {
56 | err = e1
57 | }
58 | return
59 | }
60 |
61 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
62 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_freebsd_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,freebsd
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func Getpagesize() int { return 4096 }
15 |
16 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
17 |
18 | func NsecToTimespec(nsec int64) (ts Timespec) {
19 | ts.Sec = nsec / 1e9
20 | ts.Nsec = nsec % 1e9
21 | return
22 | }
23 |
24 | func NsecToTimeval(nsec int64) (tv Timeval) {
25 | nsec += 999 // round up to microsecond
26 | tv.Usec = nsec % 1e9 / 1e3
27 | tv.Sec = int64(nsec / 1e9)
28 | return
29 | }
30 |
31 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
32 | k.Ident = uint64(fd)
33 | k.Filter = int16(mode)
34 | k.Flags = uint16(flags)
35 | }
36 |
37 | func (iov *Iovec) SetLen(length int) {
38 | iov.Len = uint64(length)
39 | }
40 |
41 | func (msghdr *Msghdr) SetControllen(length int) {
42 | msghdr.Controllen = uint32(length)
43 | }
44 |
45 | func (cmsg *Cmsghdr) SetLen(length int) {
46 | cmsg.Len = uint32(length)
47 | }
48 |
49 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
50 | var writtenOut uint64 = 0
51 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0, 0)
52 |
53 | written = int(writtenOut)
54 |
55 | if e1 != 0 {
56 | err = e1
57 | }
58 | return
59 | }
60 |
61 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
62 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_freebsd_arm.go:
--------------------------------------------------------------------------------
1 | // Copyright 2012 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build arm,freebsd
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func Getpagesize() int { return 4096 }
15 |
16 | func TimespecToNsec(ts Timespec) int64 { return ts.Sec*1e9 + int64(ts.Nsec) }
17 |
18 | func NsecToTimespec(nsec int64) (ts Timespec) {
19 | ts.Sec = nsec / 1e9
20 | ts.Nsec = int32(nsec % 1e9)
21 | return
22 | }
23 |
24 | func NsecToTimeval(nsec int64) (tv Timeval) {
25 | nsec += 999 // round up to microsecond
26 | tv.Usec = int32(nsec % 1e9 / 1e3)
27 | tv.Sec = nsec / 1e9
28 | return
29 | }
30 |
31 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
32 | k.Ident = uint32(fd)
33 | k.Filter = int16(mode)
34 | k.Flags = uint16(flags)
35 | }
36 |
37 | func (iov *Iovec) SetLen(length int) {
38 | iov.Len = uint32(length)
39 | }
40 |
41 | func (msghdr *Msghdr) SetControllen(length int) {
42 | msghdr.Controllen = uint32(length)
43 | }
44 |
45 | func (cmsg *Cmsghdr) SetLen(length int) {
46 | cmsg.Len = uint32(length)
47 | }
48 |
49 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
50 | var writtenOut uint64 = 0
51 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr((*offset)>>32), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0)
52 |
53 | written = int(writtenOut)
54 |
55 | if e1 != 0 {
56 | err = e1
57 | }
58 | return
59 | }
60 |
61 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
62 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,linux
6 | // +build !gccgo
7 |
8 | package unix
9 |
10 | import "syscall"
11 |
12 | //go:noescape
13 | func gettimeofday(tv *Timeval) (err syscall.Errno)
14 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_netbsd_386.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build 386,netbsd
6 |
7 | package unix
8 |
9 | func Getpagesize() int { return 4096 }
10 |
11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
12 |
13 | func NsecToTimespec(nsec int64) (ts Timespec) {
14 | ts.Sec = int64(nsec / 1e9)
15 | ts.Nsec = int32(nsec % 1e9)
16 | return
17 | }
18 |
19 | func NsecToTimeval(nsec int64) (tv Timeval) {
20 | nsec += 999 // round up to microsecond
21 | tv.Usec = int32(nsec % 1e9 / 1e3)
22 | tv.Sec = int64(nsec / 1e9)
23 | return
24 | }
25 |
26 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
27 | k.Ident = uint32(fd)
28 | k.Filter = uint32(mode)
29 | k.Flags = uint32(flags)
30 | }
31 |
32 | func (iov *Iovec) SetLen(length int) {
33 | iov.Len = uint32(length)
34 | }
35 |
36 | func (msghdr *Msghdr) SetControllen(length int) {
37 | msghdr.Controllen = uint32(length)
38 | }
39 |
40 | func (cmsg *Cmsghdr) SetLen(length int) {
41 | cmsg.Len = uint32(length)
42 | }
43 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,netbsd
6 |
7 | package unix
8 |
9 | func Getpagesize() int { return 4096 }
10 |
11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
12 |
13 | func NsecToTimespec(nsec int64) (ts Timespec) {
14 | ts.Sec = int64(nsec / 1e9)
15 | ts.Nsec = int64(nsec % 1e9)
16 | return
17 | }
18 |
19 | func NsecToTimeval(nsec int64) (tv Timeval) {
20 | nsec += 999 // round up to microsecond
21 | tv.Usec = int32(nsec % 1e9 / 1e3)
22 | tv.Sec = int64(nsec / 1e9)
23 | return
24 | }
25 |
26 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
27 | k.Ident = uint64(fd)
28 | k.Filter = uint32(mode)
29 | k.Flags = uint32(flags)
30 | }
31 |
32 | func (iov *Iovec) SetLen(length int) {
33 | iov.Len = uint64(length)
34 | }
35 |
36 | func (msghdr *Msghdr) SetControllen(length int) {
37 | msghdr.Controllen = uint32(length)
38 | }
39 |
40 | func (cmsg *Cmsghdr) SetLen(length int) {
41 | cmsg.Len = uint32(length)
42 | }
43 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build arm,netbsd
6 |
7 | package unix
8 |
9 | func Getpagesize() int { return 4096 }
10 |
11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
12 |
13 | func NsecToTimespec(nsec int64) (ts Timespec) {
14 | ts.Sec = int64(nsec / 1e9)
15 | ts.Nsec = int32(nsec % 1e9)
16 | return
17 | }
18 |
19 | func NsecToTimeval(nsec int64) (tv Timeval) {
20 | nsec += 999 // round up to microsecond
21 | tv.Usec = int32(nsec % 1e9 / 1e3)
22 | tv.Sec = int64(nsec / 1e9)
23 | return
24 | }
25 |
26 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
27 | k.Ident = uint32(fd)
28 | k.Filter = uint32(mode)
29 | k.Flags = uint32(flags)
30 | }
31 |
32 | func (iov *Iovec) SetLen(length int) {
33 | iov.Len = uint32(length)
34 | }
35 |
36 | func (msghdr *Msghdr) SetControllen(length int) {
37 | msghdr.Controllen = uint32(length)
38 | }
39 |
40 | func (cmsg *Cmsghdr) SetLen(length int) {
41 | cmsg.Len = uint32(length)
42 | }
43 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_no_getwd.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build dragonfly freebsd netbsd openbsd
6 |
7 | package unix
8 |
9 | const ImplementsGetwd = false
10 |
11 | func Getwd() (string, error) { return "", ENOTSUP }
12 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_openbsd_386.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build 386,openbsd
6 |
7 | package unix
8 |
9 | func Getpagesize() int { return 4096 }
10 |
11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
12 |
13 | func NsecToTimespec(nsec int64) (ts Timespec) {
14 | ts.Sec = int64(nsec / 1e9)
15 | ts.Nsec = int32(nsec % 1e9)
16 | return
17 | }
18 |
19 | func NsecToTimeval(nsec int64) (tv Timeval) {
20 | nsec += 999 // round up to microsecond
21 | tv.Usec = int32(nsec % 1e9 / 1e3)
22 | tv.Sec = int64(nsec / 1e9)
23 | return
24 | }
25 |
26 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
27 | k.Ident = uint32(fd)
28 | k.Filter = int16(mode)
29 | k.Flags = uint16(flags)
30 | }
31 |
32 | func (iov *Iovec) SetLen(length int) {
33 | iov.Len = uint32(length)
34 | }
35 |
36 | func (msghdr *Msghdr) SetControllen(length int) {
37 | msghdr.Controllen = uint32(length)
38 | }
39 |
40 | func (cmsg *Cmsghdr) SetLen(length int) {
41 | cmsg.Len = uint32(length)
42 | }
43 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,openbsd
6 |
7 | package unix
8 |
9 | func Getpagesize() int { return 4096 }
10 |
11 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
12 |
13 | func NsecToTimespec(nsec int64) (ts Timespec) {
14 | ts.Sec = nsec / 1e9
15 | ts.Nsec = nsec % 1e9
16 | return
17 | }
18 |
19 | func NsecToTimeval(nsec int64) (tv Timeval) {
20 | nsec += 999 // round up to microsecond
21 | tv.Usec = nsec % 1e9 / 1e3
22 | tv.Sec = nsec / 1e9
23 | return
24 | }
25 |
26 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
27 | k.Ident = uint64(fd)
28 | k.Filter = int16(mode)
29 | k.Flags = uint16(flags)
30 | }
31 |
32 | func (iov *Iovec) SetLen(length int) {
33 | iov.Len = uint64(length)
34 | }
35 |
36 | func (msghdr *Msghdr) SetControllen(length int) {
37 | msghdr.Controllen = uint32(length)
38 | }
39 |
40 | func (cmsg *Cmsghdr) SetLen(length int) {
41 | cmsg.Len = uint32(length)
42 | }
43 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,solaris
6 |
7 | package unix
8 |
9 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
10 |
11 | func NsecToTimespec(nsec int64) (ts Timespec) {
12 | ts.Sec = nsec / 1e9
13 | ts.Nsec = nsec % 1e9
14 | return
15 | }
16 |
17 | func NsecToTimeval(nsec int64) (tv Timeval) {
18 | nsec += 999 // round up to microsecond
19 | tv.Usec = nsec % 1e9 / 1e3
20 | tv.Sec = int64(nsec / 1e9)
21 | return
22 | }
23 |
24 | func (iov *Iovec) SetLen(length int) {
25 | iov.Len = uint64(length)
26 | }
27 |
28 | func (cmsg *Cmsghdr) SetLen(length int) {
29 | cmsg.Len = uint32(length)
30 | }
31 |
32 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
33 | // TODO(aram): implement this, see issue 5847.
34 | panic("unimplemented")
35 | }
36 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_unix_gc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2016 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris
6 | // +build !gccgo
7 |
8 | package unix
9 |
10 | import "syscall"
11 |
12 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)
13 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
14 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)
15 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
16 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zsysnum_solaris_amd64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build amd64,solaris
6 |
7 | package unix
8 |
9 | // TODO(aram): remove these before Go 1.3.
10 | const (
11 | SYS_EXECVE = 59
12 | SYS_FCNTL = 62
13 | )
14 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/text/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2009 The Go Authors. All rights reserved.
2 |
3 | Redistribution and use in source and binary forms, with or without
4 | modification, are permitted provided that the following conditions are
5 | met:
6 |
7 | * Redistributions of source code must retain the above copyright
8 | notice, this list of conditions and the following disclaimer.
9 | * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 | * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/text/PATENTS:
--------------------------------------------------------------------------------
1 | Additional IP Rights Grant (Patents)
2 |
3 | "This implementation" means the copyrightable works distributed by
4 | Google as part of the Go project.
5 |
6 | Google hereby grants to You a perpetual, worldwide, non-exclusive,
7 | no-charge, royalty-free, irrevocable (except as stated in this section)
8 | patent license to make, have made, use, offer to sell, sell, import,
9 | transfer and otherwise run, modify and propagate the contents of this
10 | implementation of Go, where such license applies only to those patent
11 | claims, both currently owned or controlled by Google and acquired in
12 | the future, licensable by Google that are necessarily infringed by this
13 | implementation of Go. This grant does not include claims that would be
14 | infringed only as a consequence of further modification of this
15 | implementation. If you or your agent or exclusive licensee institute or
16 | order or agree to the institution of patent litigation against any
17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging
18 | that this implementation of Go or any code incorporated within this
19 | implementation of Go constitutes direct or contributory patent
20 | infringement, or inducement of patent infringement, then any patent
21 | rights granted to you under this License for this implementation of Go
22 | shall terminate as of the date such litigation is filed.
23 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/text/unicode/bidi/gen_ranges.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build ignore
6 |
7 | package main
8 |
9 | import (
10 | "unicode"
11 |
12 | "golang.org/x/text/internal/gen"
13 | "golang.org/x/text/internal/ucd"
14 | "golang.org/x/text/unicode/rangetable"
15 | )
16 |
17 | // These tables are hand-extracted from:
18 | // http://www.unicode.org/Public/8.0.0/ucd/extracted/DerivedBidiClass.txt
19 | func visitDefaults(fn func(r rune, c Class)) {
20 | // first write default values for ranges listed above.
21 | visitRunes(fn, AL, []rune{
22 | 0x0600, 0x07BF, // Arabic
23 | 0x08A0, 0x08FF, // Arabic Extended-A
24 | 0xFB50, 0xFDCF, // Arabic Presentation Forms
25 | 0xFDF0, 0xFDFF,
26 | 0xFE70, 0xFEFF,
27 | 0x0001EE00, 0x0001EEFF, // Arabic Mathematical Alpha Symbols
28 | })
29 | visitRunes(fn, R, []rune{
30 | 0x0590, 0x05FF, // Hebrew
31 | 0x07C0, 0x089F, // Nko et al.
32 | 0xFB1D, 0xFB4F,
33 | 0x00010800, 0x00010FFF, // Cypriot Syllabary et. al.
34 | 0x0001E800, 0x0001EDFF,
35 | 0x0001EF00, 0x0001EFFF,
36 | })
37 | visitRunes(fn, ET, []rune{ // European Terminator
38 | 0x20A0, 0x20Cf, // Currency symbols
39 | })
40 | rangetable.Visit(unicode.Noncharacter_Code_Point, func(r rune) {
41 | fn(r, BN) // Boundary Neutral
42 | })
43 | ucd.Parse(gen.OpenUCDFile("DerivedCoreProperties.txt"), func(p *ucd.Parser) {
44 | if p.String(1) == "Default_Ignorable_Code_Point" {
45 | fn(p.Rune(0), BN) // Boundary Neutral
46 | }
47 | })
48 | }
49 |
50 | func visitRunes(fn func(r rune, c Class), c Class, runes []rune) {
51 | for i := 0; i < len(runes); i += 2 {
52 | lo, hi := runes[i], runes[i+1]
53 | for j := lo; j <= hi; j++ {
54 | fn(j, c)
55 | }
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/text/unicode/bidi/gen_trieval.go:
--------------------------------------------------------------------------------
1 | // Copyright 2015 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | // +build ignore
6 |
7 | package main
8 |
9 | // Class is the Unicode BiDi class. Each rune has a single class.
10 | type Class uint
11 |
12 | const (
13 | L Class = iota // LeftToRight
14 | R // RightToLeft
15 | EN // EuropeanNumber
16 | ES // EuropeanSeparator
17 | ET // EuropeanTerminator
18 | AN // ArabicNumber
19 | CS // CommonSeparator
20 | B // ParagraphSeparator
21 | S // SegmentSeparator
22 | WS // WhiteSpace
23 | ON // OtherNeutral
24 | BN // BoundaryNeutral
25 | NSM // NonspacingMark
26 | AL // ArabicLetter
27 | Control // Control LRO - PDI
28 |
29 | numClass
30 |
31 | LRO // LeftToRightOverride
32 | RLO // RightToLeftOverride
33 | LRE // LeftToRightEmbedding
34 | RLE // RightToLeftEmbedding
35 | PDF // PopDirectionalFormat
36 | LRI // LeftToRightIsolate
37 | RLI // RightToLeftIsolate
38 | FSI // FirstStrongIsolate
39 | PDI // PopDirectionalIsolate
40 |
41 | unknownClass = ^Class(0)
42 | )
43 |
44 | var controlToClass = map[rune]Class{
45 | 0x202D: LRO, // LeftToRightOverride,
46 | 0x202E: RLO, // RightToLeftOverride,
47 | 0x202A: LRE, // LeftToRightEmbedding,
48 | 0x202B: RLE, // RightToLeftEmbedding,
49 | 0x202C: PDF, // PopDirectionalFormat,
50 | 0x2066: LRI, // LeftToRightIsolate,
51 | 0x2067: RLI, // RightToLeftIsolate,
52 | 0x2068: FSI, // FirstStrongIsolate,
53 | 0x2069: PDI, // PopDirectionalIsolate,
54 | }
55 |
56 | // A trie entry has the following bits:
57 | // 7..5 XOR mask for brackets
58 | // 4 1: Bracket open, 0: Bracket close
59 | // 3..0 Class type
60 |
61 | const (
62 | openMask = 0x10
63 | xorMaskShift = 5
64 | )
65 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/text/unicode/bidi/trieval.go:
--------------------------------------------------------------------------------
1 | // This file was generated by go generate; DO NOT EDIT
2 |
3 | package bidi
4 |
5 | // Class is the Unicode BiDi class. Each rune has a single class.
6 | type Class uint
7 |
8 | const (
9 | L Class = iota // LeftToRight
10 | R // RightToLeft
11 | EN // EuropeanNumber
12 | ES // EuropeanSeparator
13 | ET // EuropeanTerminator
14 | AN // ArabicNumber
15 | CS // CommonSeparator
16 | B // ParagraphSeparator
17 | S // SegmentSeparator
18 | WS // WhiteSpace
19 | ON // OtherNeutral
20 | BN // BoundaryNeutral
21 | NSM // NonspacingMark
22 | AL // ArabicLetter
23 | Control // Control LRO - PDI
24 |
25 | numClass
26 |
27 | LRO // LeftToRightOverride
28 | RLO // RightToLeftOverride
29 | LRE // LeftToRightEmbedding
30 | RLE // RightToLeftEmbedding
31 | PDF // PopDirectionalFormat
32 | LRI // LeftToRightIsolate
33 | RLI // RightToLeftIsolate
34 | FSI // FirstStrongIsolate
35 | PDI // PopDirectionalIsolate
36 |
37 | unknownClass = ^Class(0)
38 | )
39 |
40 | var controlToClass = map[rune]Class{
41 | 0x202D: LRO, // LeftToRightOverride,
42 | 0x202E: RLO, // RightToLeftOverride,
43 | 0x202A: LRE, // LeftToRightEmbedding,
44 | 0x202B: RLE, // RightToLeftEmbedding,
45 | 0x202C: PDF, // PopDirectionalFormat,
46 | 0x2066: LRI, // LeftToRightIsolate,
47 | 0x2067: RLI, // RightToLeftIsolate,
48 | 0x2068: FSI, // FirstStrongIsolate,
49 | 0x2069: PDI, // PopDirectionalIsolate,
50 | }
51 |
52 | // A trie entry has the following bits:
53 | // 7..5 XOR mask for brackets
54 | // 4 1: Bracket open, 0: Bracket close
55 | // 3..0 Class type
56 |
57 | const (
58 | openMask = 0x10
59 | xorMaskShift = 5
60 | )
61 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/text/unicode/norm/trie.go:
--------------------------------------------------------------------------------
1 | // Copyright 2011 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 |
5 | package norm
6 |
7 | type valueRange struct {
8 | value uint16 // header: value:stride
9 | lo, hi byte // header: lo:n
10 | }
11 |
12 | type sparseBlocks struct {
13 | values []valueRange
14 | offset []uint16
15 | }
16 |
17 | var nfcSparse = sparseBlocks{
18 | values: nfcSparseValues[:],
19 | offset: nfcSparseOffset[:],
20 | }
21 |
22 | var nfkcSparse = sparseBlocks{
23 | values: nfkcSparseValues[:],
24 | offset: nfkcSparseOffset[:],
25 | }
26 |
27 | var (
28 | nfcData = newNfcTrie(0)
29 | nfkcData = newNfkcTrie(0)
30 | )
31 |
32 | // lookupValue determines the type of block n and looks up the value for b.
33 | // For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
34 | // is a list of ranges with an accompanying value. Given a matching range r,
35 | // the value for b is by r.value + (b - r.lo) * stride.
36 | func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
37 | offset := t.offset[n]
38 | header := t.values[offset]
39 | lo := offset + 1
40 | hi := lo + uint16(header.lo)
41 | for lo < hi {
42 | m := lo + (hi-lo)/2
43 | r := t.values[m]
44 | if r.lo <= b && b <= r.hi {
45 | return r.value + uint16(b-r.lo)*header.value
46 | }
47 | if b < r.lo {
48 | hi = m
49 | } else {
50 | lo = m + 1
51 | }
52 | }
53 | return 0
54 | }
55 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/AUTHORS:
--------------------------------------------------------------------------------
1 | Google Inc.
2 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # How to contribute
2 |
3 | We definitely welcome your patches and contributions to gRPC!
4 |
5 | If you are new to github, please start by reading [Pull Request howto](https://help.github.com/articles/about-pull-requests/)
6 |
7 | ## Legal requirements
8 |
9 | In order to protect both you and ourselves, you will need to sign the
10 | [Contributor License Agreement](https://identity.linuxfoundation.org/projects/cncf).
11 |
12 | ## Guidelines for Pull Requests
13 | How to get your contributions merged smoothly and quickly.
14 |
15 | - Create **small PRs** that are narrowly focused on **addressing a single concern**. We often times receive PRs that are trying to fix several things at a time, but only one fix is considered acceptable, nothing gets merged and both author's & review's time is wasted. Create more PRs to address different concerns and everyone will be happy.
16 |
17 | - For speculative changes, consider opening an issue and discussing it first. If you are suggesting a behavioral or API change, consider starting with a [gRFC proposal](https://github.com/grpc/proposal).
18 |
19 | - Provide a good **PR description** as a record of **what** change is being made and **why** it was made. Link to a github issue if it exists.
20 |
21 | - Don't fix code style and formatting unless you are already changing that line to address an issue. PRs with irrelevant changes won't be merged. If you do want to fix formatting or style, do that in a separate PR.
22 |
23 | - Unless your PR is trivial, you should expect there will be reviewer comments that you'll need to address before merging. We expect you to be reasonably responsive to those comments, otherwise the PR will be closed after 2-3 weeks of inactivity.
24 |
25 | - Maintain **clean commit history** and use **meaningful commit messages**. PRs with messy commit history are difficult to review and won't be merged. Use `rebase -i upstream/master` to curate your commit history and/or to bring in latest changes from master (but avoid rebasing in the middle of a code review).
26 |
27 | - Keep your PR up to date with upstream/master (if there are merge conflicts, we can't really merge your change).
28 |
29 | - **All tests need to be passing** before your change can be merged. We recommend you **run tests locally** before creating your PR to catch breakages early on.
30 |
31 | - Exceptions to the rules can be made if there's a compelling reason for doing so.
32 |
33 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/Makefile:
--------------------------------------------------------------------------------
1 | all: test testrace
2 |
3 | deps:
4 | go get -d -v google.golang.org/grpc/...
5 |
6 | updatedeps:
7 | go get -d -v -u -f google.golang.org/grpc/...
8 |
9 | testdeps:
10 | go get -d -v -t google.golang.org/grpc/...
11 |
12 | updatetestdeps:
13 | go get -d -v -t -u -f google.golang.org/grpc/...
14 |
15 | build: deps
16 | go build google.golang.org/grpc/...
17 |
18 | proto:
19 | @ if ! which protoc > /dev/null; then \
20 | echo "error: protoc not installed" >&2; \
21 | exit 1; \
22 | fi
23 | go generate google.golang.org/grpc/...
24 |
25 | test: testdeps
26 | go test -cpu 1,4 -timeout 5m google.golang.org/grpc/...
27 |
28 | testrace: testdeps
29 | go test -race -cpu 1,4 -timeout 7m google.golang.org/grpc/...
30 |
31 | clean:
32 | go clean -i google.golang.org/grpc/...
33 |
34 | .PHONY: \
35 | all \
36 | deps \
37 | updatedeps \
38 | testdeps \
39 | updatetestdeps \
40 | build \
41 | proto \
42 | test \
43 | testrace \
44 | clean \
45 | coverage
46 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/README.md:
--------------------------------------------------------------------------------
1 | # gRPC-Go
2 |
3 | [](https://travis-ci.org/grpc/grpc-go) [](https://godoc.org/google.golang.org/grpc) [](https://goreportcard.com/report/github.com/grpc/grpc-go)
4 |
5 | The Go implementation of [gRPC](https://grpc.io/): A high performance, open source, general RPC framework that puts mobile and HTTP/2 first. For more information see the [gRPC Quick Start: Go](https://grpc.io/docs/quickstart/go.html) guide.
6 |
7 | Installation
8 | ------------
9 |
10 | To install this package, you need to install Go and setup your Go workspace on your computer. The simplest way to install the library is to run:
11 |
12 | ```
13 | $ go get -u google.golang.org/grpc
14 | ```
15 |
16 | Prerequisites
17 | -------------
18 |
19 | This requires Go 1.6 or later. Go 1.7 will be required as of the next gRPC-Go
20 | release (1.8).
21 |
22 | Constraints
23 | -----------
24 | The grpc package should only depend on standard Go packages and a small number of exceptions. If your contribution introduces new dependencies which are NOT in the [list](http://godoc.org/google.golang.org/grpc?imports), you need a discussion with gRPC-Go authors and consultants.
25 |
26 | Documentation
27 | -------------
28 | See [API documentation](https://godoc.org/google.golang.org/grpc) for package and API descriptions and find examples in the [examples directory](examples/).
29 |
30 | Performance
31 | -----------
32 | See the current benchmarks for some of the languages supported in [this dashboard](https://performance-dot-grpc-testing.appspot.com/explore?dashboard=5652536396611584&widget=490377658&container=1286539696).
33 |
34 | Status
35 | ------
36 | General Availability [Google Cloud Platform Launch Stages](https://cloud.google.com/terms/launch-stages).
37 |
38 | FAQ
39 | ---
40 |
41 | #### Compiling error, undefined: grpc.SupportPackageIsVersion
42 |
43 | Please update proto package, gRPC package and rebuild the proto files:
44 | - `go get -u github.com/golang/protobuf/{proto,protoc-gen-go}`
45 | - `go get -u google.golang.org/grpc`
46 | - `protoc --go_out=plugins=grpc:. *.proto`
47 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/balancer/base/base.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2017 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | // Package base defines a balancer base that can be used to build balancers with
20 | // different picking algorithms.
21 | //
22 | // The base balancer creates a new SubConn for each resolved address. The
23 | // provided picker will only be notified about READY SubConns.
24 | //
25 | // This package is the base of round_robin balancer, its purpose is to be used
26 | // to build round_robin like balancers with complex picking algorithms.
27 | // Balancers with more complicated logic should try to implement a balancer
28 | // builder from scratch.
29 | //
30 | // All APIs in this package are experimental.
31 | package base
32 |
33 | import (
34 | "google.golang.org/grpc/balancer"
35 | "google.golang.org/grpc/resolver"
36 | )
37 |
38 | // PickerBuilder creates balancer.Picker.
39 | type PickerBuilder interface {
40 | // Build takes a slice of ready SubConns, and returns a picker that will be
41 | // used by gRPC to pick a SubConn.
42 | Build(readySCs map[resolver.Address]balancer.SubConn) balancer.Picker
43 | }
44 |
45 | // NewBalancerBuilder returns a balancer builder. The balancers
46 | // built by this builder will use the picker builder to build pickers.
47 | func NewBalancerBuilder(name string, pb PickerBuilder) balancer.Builder {
48 | return &baseBuilder{
49 | name: name,
50 | pickerBuilder: pb,
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/codegen.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | # This script serves as an example to demonstrate how to generate the gRPC-Go
4 | # interface and the related messages from .proto file.
5 | #
6 | # It assumes the installation of i) Google proto buffer compiler at
7 | # https://github.com/google/protobuf (after v2.6.1) and ii) the Go codegen
8 | # plugin at https://github.com/golang/protobuf (after 2015-02-20). If you have
9 | # not, please install them first.
10 | #
11 | # We recommend running this script at $GOPATH/src.
12 | #
13 | # If this is not what you need, feel free to make your own scripts. Again, this
14 | # script is for demonstration purpose.
15 | #
16 | proto=$1
17 | protoc --go_out=plugins=grpc:. $proto
18 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/codes/code_string.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2017 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | package codes
20 |
21 | import "strconv"
22 |
23 | func (c Code) String() string {
24 | switch c {
25 | case OK:
26 | return "OK"
27 | case Canceled:
28 | return "Canceled"
29 | case Unknown:
30 | return "Unknown"
31 | case InvalidArgument:
32 | return "InvalidArgument"
33 | case DeadlineExceeded:
34 | return "DeadlineExceeded"
35 | case NotFound:
36 | return "NotFound"
37 | case AlreadyExists:
38 | return "AlreadyExists"
39 | case PermissionDenied:
40 | return "PermissionDenied"
41 | case ResourceExhausted:
42 | return "ResourceExhausted"
43 | case FailedPrecondition:
44 | return "FailedPrecondition"
45 | case Aborted:
46 | return "Aborted"
47 | case OutOfRange:
48 | return "OutOfRange"
49 | case Unimplemented:
50 | return "Unimplemented"
51 | case Internal:
52 | return "Internal"
53 | case Unavailable:
54 | return "Unavailable"
55 | case DataLoss:
56 | return "DataLoss"
57 | case Unauthenticated:
58 | return "Unauthenticated"
59 | default:
60 | return "Code(" + strconv.FormatInt(int64(c), 10) + ")"
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/connectivity/connectivity.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2017 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | // Package connectivity defines connectivity semantics.
20 | // For details, see https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md.
21 | // All APIs in this package are experimental.
22 | package connectivity
23 |
24 | import (
25 | "golang.org/x/net/context"
26 | "google.golang.org/grpc/grpclog"
27 | )
28 |
29 | // State indicates the state of connectivity.
30 | // It can be the state of a ClientConn or SubConn.
31 | type State int
32 |
33 | func (s State) String() string {
34 | switch s {
35 | case Idle:
36 | return "IDLE"
37 | case Connecting:
38 | return "CONNECTING"
39 | case Ready:
40 | return "READY"
41 | case TransientFailure:
42 | return "TRANSIENT_FAILURE"
43 | case Shutdown:
44 | return "SHUTDOWN"
45 | default:
46 | grpclog.Errorf("unknown connectivity state: %d", s)
47 | return "Invalid-State"
48 | }
49 | }
50 |
51 | const (
52 | // Idle indicates the ClientConn is idle.
53 | Idle State = iota
54 | // Connecting indicates the ClienConn is connecting.
55 | Connecting
56 | // Ready indicates the ClientConn is ready for work.
57 | Ready
58 | // TransientFailure indicates the ClientConn has seen a failure but expects to recover.
59 | TransientFailure
60 | // Shutdown indicates the ClientConn has started shutting down.
61 | Shutdown
62 | )
63 |
64 | // Reporter reports the connectivity states.
65 | type Reporter interface {
66 | // CurrentState returns the current state of the reporter.
67 | CurrentState() State
68 | // WaitForStateChange blocks until the reporter's state is different from the given state,
69 | // and returns true.
70 | // It returns false if <-ctx.Done() can proceed (ctx got timeout or got canceled).
71 | WaitForStateChange(context.Context, State) bool
72 | }
73 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/credentials/credentials_util_go17.go:
--------------------------------------------------------------------------------
1 | // +build go1.7
2 | // +build !go1.8
3 |
4 | /*
5 | *
6 | * Copyright 2016 gRPC authors.
7 | *
8 | * Licensed under the Apache License, Version 2.0 (the "License");
9 | * you may not use this file except in compliance with the License.
10 | * You may obtain a copy of the License at
11 | *
12 | * http://www.apache.org/licenses/LICENSE-2.0
13 | *
14 | * Unless required by applicable law or agreed to in writing, software
15 | * distributed under the License is distributed on an "AS IS" BASIS,
16 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 | * See the License for the specific language governing permissions and
18 | * limitations under the License.
19 | *
20 | */
21 |
22 | package credentials
23 |
24 | import (
25 | "crypto/tls"
26 | )
27 |
28 | // cloneTLSConfig returns a shallow clone of the exported
29 | // fields of cfg, ignoring the unexported sync.Once, which
30 | // contains a mutex and must not be copied.
31 | //
32 | // If cfg is nil, a new zero tls.Config is returned.
33 | func cloneTLSConfig(cfg *tls.Config) *tls.Config {
34 | if cfg == nil {
35 | return &tls.Config{}
36 | }
37 | return &tls.Config{
38 | Rand: cfg.Rand,
39 | Time: cfg.Time,
40 | Certificates: cfg.Certificates,
41 | NameToCertificate: cfg.NameToCertificate,
42 | GetCertificate: cfg.GetCertificate,
43 | RootCAs: cfg.RootCAs,
44 | NextProtos: cfg.NextProtos,
45 | ServerName: cfg.ServerName,
46 | ClientAuth: cfg.ClientAuth,
47 | ClientCAs: cfg.ClientCAs,
48 | InsecureSkipVerify: cfg.InsecureSkipVerify,
49 | CipherSuites: cfg.CipherSuites,
50 | PreferServerCipherSuites: cfg.PreferServerCipherSuites,
51 | SessionTicketsDisabled: cfg.SessionTicketsDisabled,
52 | SessionTicketKey: cfg.SessionTicketKey,
53 | ClientSessionCache: cfg.ClientSessionCache,
54 | MinVersion: cfg.MinVersion,
55 | MaxVersion: cfg.MaxVersion,
56 | CurvePreferences: cfg.CurvePreferences,
57 | DynamicRecordSizingDisabled: cfg.DynamicRecordSizingDisabled,
58 | Renegotiation: cfg.Renegotiation,
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/credentials/credentials_util_go18.go:
--------------------------------------------------------------------------------
1 | // +build go1.8
2 |
3 | /*
4 | *
5 | * Copyright 2017 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package credentials
22 |
23 | import (
24 | "crypto/tls"
25 | )
26 |
27 | // cloneTLSConfig returns a shallow clone of the exported
28 | // fields of cfg, ignoring the unexported sync.Once, which
29 | // contains a mutex and must not be copied.
30 | //
31 | // If cfg is nil, a new zero tls.Config is returned.
32 | func cloneTLSConfig(cfg *tls.Config) *tls.Config {
33 | if cfg == nil {
34 | return &tls.Config{}
35 | }
36 |
37 | return cfg.Clone()
38 | }
39 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/credentials/credentials_util_pre_go17.go:
--------------------------------------------------------------------------------
1 | // +build !go1.7
2 |
3 | /*
4 | *
5 | * Copyright 2016 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package credentials
22 |
23 | import (
24 | "crypto/tls"
25 | )
26 |
27 | // cloneTLSConfig returns a shallow clone of the exported
28 | // fields of cfg, ignoring the unexported sync.Once, which
29 | // contains a mutex and must not be copied.
30 | //
31 | // If cfg is nil, a new zero tls.Config is returned.
32 | func cloneTLSConfig(cfg *tls.Config) *tls.Config {
33 | if cfg == nil {
34 | return &tls.Config{}
35 | }
36 | return &tls.Config{
37 | Rand: cfg.Rand,
38 | Time: cfg.Time,
39 | Certificates: cfg.Certificates,
40 | NameToCertificate: cfg.NameToCertificate,
41 | GetCertificate: cfg.GetCertificate,
42 | RootCAs: cfg.RootCAs,
43 | NextProtos: cfg.NextProtos,
44 | ServerName: cfg.ServerName,
45 | ClientAuth: cfg.ClientAuth,
46 | ClientCAs: cfg.ClientCAs,
47 | InsecureSkipVerify: cfg.InsecureSkipVerify,
48 | CipherSuites: cfg.CipherSuites,
49 | PreferServerCipherSuites: cfg.PreferServerCipherSuites,
50 | SessionTicketsDisabled: cfg.SessionTicketsDisabled,
51 | SessionTicketKey: cfg.SessionTicketKey,
52 | ClientSessionCache: cfg.ClientSessionCache,
53 | MinVersion: cfg.MinVersion,
54 | MaxVersion: cfg.MaxVersion,
55 | CurvePreferences: cfg.CurvePreferences,
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/doc.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2015 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | /*
20 | Package grpc implements an RPC system called gRPC.
21 |
22 | See grpc.io for more information about gRPC.
23 | */
24 | package grpc // import "google.golang.org/grpc"
25 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto:
--------------------------------------------------------------------------------
1 | // Copyright 2017 gRPC authors.
2 | //
3 | // Licensed under the Apache License, Version 2.0 (the "License");
4 | // you may not use this file except in compliance with the License.
5 | // You may obtain a copy of the License at
6 | //
7 | // http://www.apache.org/licenses/LICENSE-2.0
8 | //
9 | // Unless required by applicable law or agreed to in writing, software
10 | // distributed under the License is distributed on an "AS IS" BASIS,
11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | // See the License for the specific language governing permissions and
13 | // limitations under the License.
14 |
15 | syntax = "proto3";
16 |
17 | package grpc.health.v1;
18 |
19 | message HealthCheckRequest {
20 | string service = 1;
21 | }
22 |
23 | message HealthCheckResponse {
24 | enum ServingStatus {
25 | UNKNOWN = 0;
26 | SERVING = 1;
27 | NOT_SERVING = 2;
28 | }
29 | ServingStatus status = 1;
30 | }
31 |
32 | service Health{
33 | rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
34 | }
35 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/internal/internal.go:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2016 gRPC authors.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | *
16 | */
17 |
18 | // Package internal contains gRPC-internal code for testing, to avoid polluting
19 | // the godoc of the top-level grpc package.
20 | package internal
21 |
22 | // TestingUseHandlerImpl enables the http.Handler-based server implementation.
23 | // It must be called before Serve and requires TLS credentials.
24 | //
25 | // The provided grpcServer must be of type *grpc.Server. It is untyped
26 | // for circular dependency reasons.
27 | var TestingUseHandlerImpl func(grpcServer interface{})
28 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/naming/go17.go:
--------------------------------------------------------------------------------
1 | // +build go1.6,!go1.8
2 |
3 | /*
4 | *
5 | * Copyright 2017 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package naming
22 |
23 | import (
24 | "net"
25 |
26 | "golang.org/x/net/context"
27 | )
28 |
29 | var (
30 | lookupHost = func(ctx context.Context, host string) ([]string, error) { return net.LookupHost(host) }
31 | lookupSRV = func(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
32 | return net.LookupSRV(service, proto, name)
33 | }
34 | )
35 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/naming/go18.go:
--------------------------------------------------------------------------------
1 | // +build go1.8
2 |
3 | /*
4 | *
5 | * Copyright 2017 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package naming
22 |
23 | import "net"
24 |
25 | var (
26 | lookupHost = net.DefaultResolver.LookupHost
27 | lookupSRV = net.DefaultResolver.LookupSRV
28 | )
29 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/naming/naming.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2014 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | // Package naming defines the naming API and related data structures for gRPC.
20 | // The interface is EXPERIMENTAL and may be suject to change.
21 | package naming
22 |
23 | // Operation defines the corresponding operations for a name resolution change.
24 | type Operation uint8
25 |
26 | const (
27 | // Add indicates a new address is added.
28 | Add Operation = iota
29 | // Delete indicates an exisiting address is deleted.
30 | Delete
31 | )
32 |
33 | // Update defines a name resolution update. Notice that it is not valid having both
34 | // empty string Addr and nil Metadata in an Update.
35 | type Update struct {
36 | // Op indicates the operation of the update.
37 | Op Operation
38 | // Addr is the updated address. It is empty string if there is no address update.
39 | Addr string
40 | // Metadata is the updated metadata. It is nil if there is no metadata update.
41 | // Metadata is not required for a custom naming implementation.
42 | Metadata interface{}
43 | }
44 |
45 | // Resolver creates a Watcher for a target to track its resolution changes.
46 | type Resolver interface {
47 | // Resolve creates a Watcher for target.
48 | Resolve(target string) (Watcher, error)
49 | }
50 |
51 | // Watcher watches for the updates on the specified target.
52 | type Watcher interface {
53 | // Next blocks until an update or error happens. It may return one or more
54 | // updates. The first call should get the full set of the results. It should
55 | // return an error if and only if Watcher cannot recover.
56 | Next() ([]*Update, error)
57 | // Close closes the Watcher.
58 | Close()
59 | }
60 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/peer/peer.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2014 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | // Package peer defines various peer information associated with RPCs and
20 | // corresponding utils.
21 | package peer
22 |
23 | import (
24 | "net"
25 |
26 | "golang.org/x/net/context"
27 | "google.golang.org/grpc/credentials"
28 | )
29 |
30 | // Peer contains the information of the peer for an RPC, such as the address
31 | // and authentication information.
32 | type Peer struct {
33 | // Addr is the peer address.
34 | Addr net.Addr
35 | // AuthInfo is the authentication information of the transport.
36 | // It is nil if there is no transport security being used.
37 | AuthInfo credentials.AuthInfo
38 | }
39 |
40 | type peerKey struct{}
41 |
42 | // NewContext creates a new context with peer information attached.
43 | func NewContext(ctx context.Context, p *Peer) context.Context {
44 | return context.WithValue(ctx, peerKey{}, p)
45 | }
46 |
47 | // FromContext returns the peer information in ctx if it exists.
48 | func FromContext(ctx context.Context) (p *Peer, ok bool) {
49 | p, ok = ctx.Value(peerKey{}).(*Peer)
50 | return
51 | }
52 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/resolver/dns/go17.go:
--------------------------------------------------------------------------------
1 | // +build go1.6, !go1.8
2 |
3 | /*
4 | *
5 | * Copyright 2017 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package dns
22 |
23 | import (
24 | "net"
25 |
26 | "golang.org/x/net/context"
27 | )
28 |
29 | var (
30 | lookupHost = func(ctx context.Context, host string) ([]string, error) { return net.LookupHost(host) }
31 | lookupSRV = func(ctx context.Context, service, proto, name string) (string, []*net.SRV, error) {
32 | return net.LookupSRV(service, proto, name)
33 | }
34 | lookupTXT = func(ctx context.Context, name string) ([]string, error) { return net.LookupTXT(name) }
35 | )
36 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/resolver/dns/go18.go:
--------------------------------------------------------------------------------
1 | // +build go1.8
2 |
3 | /*
4 | *
5 | * Copyright 2017 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package dns
22 |
23 | import "net"
24 |
25 | var (
26 | lookupHost = net.DefaultResolver.LookupHost
27 | lookupSRV = net.DefaultResolver.LookupSRV
28 | lookupTXT = net.DefaultResolver.LookupTXT
29 | )
30 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/resolver/passthrough/passthrough.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2017 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | // Package passthrough implements a pass-through resolver. It sends the target
20 | // name without scheme back to gRPC as resolved address.
21 | package passthrough
22 |
23 | import "google.golang.org/grpc/resolver"
24 |
25 | const scheme = "passthrough"
26 |
27 | type passthroughBuilder struct{}
28 |
29 | func (*passthroughBuilder) Build(target resolver.Target, cc resolver.ClientConn, opts resolver.BuildOption) (resolver.Resolver, error) {
30 | r := &passthroughResolver{
31 | target: target,
32 | cc: cc,
33 | }
34 | r.start()
35 | return r, nil
36 | }
37 |
38 | func (*passthroughBuilder) Scheme() string {
39 | return scheme
40 | }
41 |
42 | type passthroughResolver struct {
43 | target resolver.Target
44 | cc resolver.ClientConn
45 | }
46 |
47 | func (r *passthroughResolver) start() {
48 | r.cc.NewAddress([]resolver.Address{{Addr: r.target.Endpoint}})
49 | }
50 |
51 | func (*passthroughResolver) ResolveNow(o resolver.ResolveNowOption) {}
52 |
53 | func (*passthroughResolver) Close() {}
54 |
55 | func init() {
56 | resolver.Register(&passthroughBuilder{})
57 | }
58 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/tap/tap.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2016 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | // Package tap defines the function handles which are executed on the transport
20 | // layer of gRPC-Go and related information. Everything here is EXPERIMENTAL.
21 | package tap
22 |
23 | import (
24 | "golang.org/x/net/context"
25 | )
26 |
27 | // Info defines the relevant information needed by the handles.
28 | type Info struct {
29 | // FullMethodName is the string of grpc method (in the format of
30 | // /package.service/method).
31 | FullMethodName string
32 | // TODO: More to be added.
33 | }
34 |
35 | // ServerInHandle defines the function which runs before a new stream is created
36 | // on the server side. If it returns a non-nil error, the stream will not be
37 | // created and a RST_STREAM will be sent back to the client with REFUSED_STREAM.
38 | // The client will receive an RPC error "code = Unavailable, desc = stream
39 | // terminated by RST_STREAM with error code: REFUSED_STREAM".
40 | //
41 | // It's intended to be used in situations where you don't want to waste the
42 | // resources to accept the new stream (e.g. rate-limiting). And the content of
43 | // the error will be ignored and won't be sent back to the client. For other
44 | // general usages, please use interceptors.
45 | //
46 | // Note that it is executed in the per-connection I/O goroutine(s) instead of
47 | // per-RPC goroutine. Therefore, users should NOT have any
48 | // blocking/time-consuming work in this handle. Otherwise all the RPCs would
49 | // slow down. Also, for the same reason, this handle won't be called
50 | // concurrently by gRPC.
51 | type ServerInHandle func(ctx context.Context, info *Info) (context.Context, error)
52 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/transport/go16.go:
--------------------------------------------------------------------------------
1 | // +build go1.6,!go1.7
2 |
3 | /*
4 | *
5 | * Copyright 2016 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package transport
22 |
23 | import (
24 | "net"
25 | "net/http"
26 |
27 | "google.golang.org/grpc/codes"
28 |
29 | "golang.org/x/net/context"
30 | )
31 |
32 | // dialContext connects to the address on the named network.
33 | func dialContext(ctx context.Context, network, address string) (net.Conn, error) {
34 | return (&net.Dialer{Cancel: ctx.Done()}).Dial(network, address)
35 | }
36 |
37 | // ContextErr converts the error from context package into a StreamError.
38 | func ContextErr(err error) StreamError {
39 | switch err {
40 | case context.DeadlineExceeded:
41 | return streamErrorf(codes.DeadlineExceeded, "%v", err)
42 | case context.Canceled:
43 | return streamErrorf(codes.Canceled, "%v", err)
44 | }
45 | return streamErrorf(codes.Internal, "Unexpected error from context packet: %v", err)
46 | }
47 |
48 | // contextFromRequest returns a background context.
49 | func contextFromRequest(r *http.Request) context.Context {
50 | return context.Background()
51 | }
52 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/transport/go17.go:
--------------------------------------------------------------------------------
1 | // +build go1.7
2 |
3 | /*
4 | *
5 | * Copyright 2016 gRPC authors.
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | *
19 | */
20 |
21 | package transport
22 |
23 | import (
24 | "context"
25 | "net"
26 | "net/http"
27 |
28 | "google.golang.org/grpc/codes"
29 |
30 | netctx "golang.org/x/net/context"
31 | )
32 |
33 | // dialContext connects to the address on the named network.
34 | func dialContext(ctx context.Context, network, address string) (net.Conn, error) {
35 | return (&net.Dialer{}).DialContext(ctx, network, address)
36 | }
37 |
38 | // ContextErr converts the error from context package into a StreamError.
39 | func ContextErr(err error) StreamError {
40 | switch err {
41 | case context.DeadlineExceeded, netctx.DeadlineExceeded:
42 | return streamErrorf(codes.DeadlineExceeded, "%v", err)
43 | case context.Canceled, netctx.Canceled:
44 | return streamErrorf(codes.Canceled, "%v", err)
45 | }
46 | return streamErrorf(codes.Internal, "Unexpected error from context packet: %v", err)
47 | }
48 |
49 | // contextFromRequest returns a context from the HTTP Request.
50 | func contextFromRequest(r *http.Request) context.Context {
51 | return r.Context()
52 | }
53 |
--------------------------------------------------------------------------------
/vendor/google.golang.org/grpc/transport/log.go:
--------------------------------------------------------------------------------
1 | /*
2 | *
3 | * Copyright 2017 gRPC authors.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | *
17 | */
18 |
19 | // This file contains wrappers for grpclog functions.
20 | // The transport package only logs to verbose level 2 by default.
21 |
22 | package transport
23 |
24 | import "google.golang.org/grpc/grpclog"
25 |
26 | const logLevel = 2
27 |
28 | func infof(format string, args ...interface{}) {
29 | if grpclog.V(logLevel) {
30 | grpclog.Infof(format, args...)
31 | }
32 | }
33 |
34 | func warningf(format string, args ...interface{}) {
35 | if grpclog.V(logLevel) {
36 | grpclog.Warningf(format, args...)
37 | }
38 | }
39 |
40 | func errorf(format string, args ...interface{}) {
41 | if grpclog.V(logLevel) {
42 | grpclog.Errorf(format, args...)
43 | }
44 | }
45 |
46 | func fatalf(format string, args ...interface{}) {
47 | if grpclog.V(logLevel) {
48 | grpclog.Fatalf(format, args...)
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
4 | 
49 |
--------------------------------------------------------------------------------
/backend/backend.go:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import (
4 | "net/http"
5 | "github.com/gorilla/mux"
6 | "github.com/ringtail/lucas/backend/handlers"
7 | "golang.org/x/net/context"
8 | "github.com/ringtail/lucas/backend/types"
9 | log "github.com/Sirupsen/logrus"
10 | )
11 |
12 | type LucasServer struct {
13 | Handler *mux.Router
14 | }
15 |
16 | func (ls *LucasServer) Start(opts *types.Opts) {
17 | mux := http.NewServeMux()
18 | mux.HandleFunc("/", handlers.IndexHandler)
19 | mux.HandleFunc("/store", handlers.StoreHandler)
20 | contextMux := ls.Middleware(opts,mux)
21 | log.Fatal(http.ListenAndServe(":8080", contextMux))
22 | }
23 |
24 |
25 | func (ls *LucasServer) Middleware(opts *types.Opts, next http.Handler) http.Handler {
26 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
27 | ctx := context.WithValue(r.Context(), "opts", opts)
28 | next.ServeHTTP(w, r.WithContext(ctx))
29 | })
30 | }
31 |
--------------------------------------------------------------------------------
/backend/handlers/indexHandler.go:
--------------------------------------------------------------------------------
1 | package handlers
2 |
3 | import (
4 | "net/http"
5 | "github.com/ringtail/lucas/frontend"
6 | )
7 |
8 | func IndexHandler(w http.ResponseWriter, r *http.Request) {
9 | w.Write([]byte(frontend.HOME_PAGE))
10 | }
11 |
--------------------------------------------------------------------------------
/backend/handlers/storeHandler.go:
--------------------------------------------------------------------------------
1 | package handlers
2 |
3 | import (
4 | "net/http"
5 | "github.com/ringtail/lucas/backend/services"
6 | "encoding/json"
7 | "github.com/ringtail/lucas/backend/types"
8 | log "github.com/Sirupsen/logrus"
9 | )
10 |
11 | func StoreHandler(w http.ResponseWriter, r *http.Request) {
12 | var options *types.Opts
13 | var store *services.Store
14 | var err error
15 | if opts := r.Context().Value("opts"); opts != nil {
16 | options = opts.(*types.Opts)
17 | } else {
18 | w.WriteHeader(http.StatusBadGateway)
19 | return
20 | }
21 | if options.Key == "" || options.Cert == "" || options.Ca == "" {
22 | store, err = services.NewWithOutTLS(options.Endpoints)
23 | } else {
24 | store, err = services.New(options.Endpoints, options.Ca, options.Key, options.Cert)
25 | }
26 | if err != nil {
27 | log.Errorf("Failed to init etcd client because of %s", err.Error())
28 | w.WriteHeader(http.StatusBadGateway)
29 | return
30 | }
31 |
32 | if r.Method == http.MethodGet {
33 | key := r.URL.Query().Get("key")
34 | tree := store.ListByPath(key)
35 | bytes, err := json.Marshal(tree)
36 | if err != nil {
37 | log.Errorf("Failed to list etcd keys because of %s", err.Error())
38 | w.WriteHeader(http.StatusBadGateway)
39 | return
40 | }
41 | w.Write(bytes)
42 | }
43 |
44 | if r.Method == http.MethodPost {
45 | r.ParseForm()
46 | key := r.FormValue("key")
47 | value := r.FormValue("value")
48 | if key == "" {
49 | w.WriteHeader(http.StatusBadRequest)
50 | return
51 | }
52 | err := store.Put(key, value)
53 | if err != nil {
54 | log.Errorf("Failed to update value because of %s", err.Error())
55 | w.WriteHeader(http.StatusBadGateway)
56 | return
57 | }
58 | w.WriteHeader(http.StatusOK)
59 | }
60 |
61 | if r.Method == http.MethodDelete {
62 | key := r.URL.Query().Get("key")
63 | if key == "" {
64 | w.WriteHeader(http.StatusBadRequest)
65 | return
66 | }
67 | err := store.Delete(key)
68 | if err != nil {
69 | log.Errorf("Failed to delete value because of %s", err.Error())
70 | w.WriteHeader(http.StatusBadGateway)
71 | return
72 | }
73 | w.WriteHeader(http.StatusOK)
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/backend/services/store_test.go:
--------------------------------------------------------------------------------
1 | package services
2 |
3 | import (
4 | "testing"
5 | )
6 |
7 | var store *Store
8 |
9 | func init() {
10 | store, _ = NewWithOutTLS("http://127.0.0.1:2379")
11 | }
12 |
13 | func Test_Store_List(t *testing.T) {
14 | }
15 |
16 | func Test_Store_Put(t *testing.T) {
17 |
18 | }
19 |
20 | func Test_Store_Update(t *testing.T) {
21 |
22 | }
23 |
24 | func Test_Store_Delete(t *testing.T) {
25 |
26 | }
27 |
--------------------------------------------------------------------------------
/backend/types/types.go:
--------------------------------------------------------------------------------
1 | package types
2 |
3 | type Opts struct {
4 | DebugMode bool
5 | Endpoints string
6 | Cert string
7 | Key string
8 | Ca string
9 | }
10 |
--------------------------------------------------------------------------------
/cmd/cmd.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | log "github.com/Sirupsen/logrus"
5 | "github.com/ringtail/lucas/backend"
6 | "github.com/ringtail/lucas/backend/types"
7 | )
8 |
9 | type CommandLine struct {
10 | Opts *types.Opts
11 | }
12 |
13 | func (cl *CommandLine) Run() {
14 | if &cl.Opts != nil && cl.Opts.DebugMode == true {
15 | log.SetLevel(log.DebugLevel)
16 | }
17 | lbe := &backend.LucasServer{}
18 | lbe.Start(cl.Opts)
19 | }
20 |
--------------------------------------------------------------------------------
/derrick_conf:
--------------------------------------------------------------------------------
1 | {"platform": "Golang", "rigging_name": "GolangRigging", "config_file": "/Users/zhongweilzw/go/src/github.com/ringtail/lucas/derrick_conf"}
--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: "2"
2 | services:
3 | web:
4 | build:
5 | context: .
6 | image: registry.cn-hangzhou.aliyuncs.com/ringtail/lucas:0.0.2
7 | environment:
8 | - CA_FILE=""
9 | - KEY_FILE=""
10 | - CERT_FILE=""
11 | - ENDPOINTS=""
12 | ports:
13 | - 8080
14 | restart: always
--------------------------------------------------------------------------------
/frontend/index.go:
--------------------------------------------------------------------------------
1 | package frontend
2 |
3 | const HOME_PAGE = `
4 |
5 |
6 |
7 |
8 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |