├── Dockerfile
├── Gopkg.lock
├── Gopkg.toml
├── LICENSE
├── Makefile
├── README.md
├── actions
├── html_email.go
├── rebrandly.go
└── type.go
├── cmd
├── config.go
└── root.go
├── event
├── github
│ └── impl.go
├── interface.go
└── queue.go
├── main.go
├── operator
└── runtime.go
├── scripts
├── check-header.sh
├── ci-checks.sh
└── headers.sh
└── vendor
├── github.com
├── SparkPost
│ └── gosparkpost
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── AUTHORS.rst
│ │ ├── CONTRIBUTING.md
│ │ ├── LICENSE
│ │ ├── README.rst
│ │ ├── common.go
│ │ ├── del_metrics.go
│ │ ├── event_docs.go
│ │ ├── events
│ │ ├── events.go
│ │ ├── generation.go
│ │ ├── message.go
│ │ ├── relay.go
│ │ ├── sample-events.json
│ │ ├── sample-webhook-validation.json
│ │ ├── track.go
│ │ └── unsubscribe.go
│ │ ├── message_events.go
│ │ ├── recipient_lists.go
│ │ ├── subaccounts.go
│ │ ├── suppression_list.go
│ │ ├── templates.go
│ │ ├── transmissions.go
│ │ └── webhooks.go
├── fatih
│ └── color
│ │ ├── .travis.yml
│ │ ├── Gopkg.lock
│ │ ├── Gopkg.toml
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── color.go
│ │ └── doc.go
├── google
│ ├── go-github
│ │ ├── AUTHORS
│ │ ├── LICENSE
│ │ └── github
│ │ │ ├── activity.go
│ │ │ ├── activity_events.go
│ │ │ ├── activity_notifications.go
│ │ │ ├── activity_star.go
│ │ │ ├── activity_watching.go
│ │ │ ├── admin.go
│ │ │ ├── admin_stats.go
│ │ │ ├── apps.go
│ │ │ ├── apps_installation.go
│ │ │ ├── apps_marketplace.go
│ │ │ ├── authorizations.go
│ │ │ ├── checks.go
│ │ │ ├── doc.go
│ │ │ ├── event_types.go
│ │ │ ├── gen-accessors.go
│ │ │ ├── gists.go
│ │ │ ├── gists_comments.go
│ │ │ ├── git.go
│ │ │ ├── git_blobs.go
│ │ │ ├── git_commits.go
│ │ │ ├── git_refs.go
│ │ │ ├── git_tags.go
│ │ │ ├── git_trees.go
│ │ │ ├── github-accessors.go
│ │ │ ├── github.go
│ │ │ ├── gitignore.go
│ │ │ ├── issues.go
│ │ │ ├── issues_assignees.go
│ │ │ ├── issues_comments.go
│ │ │ ├── issues_events.go
│ │ │ ├── issues_labels.go
│ │ │ ├── issues_milestones.go
│ │ │ ├── issues_timeline.go
│ │ │ ├── licenses.go
│ │ │ ├── messages.go
│ │ │ ├── migrations.go
│ │ │ ├── migrations_source_import.go
│ │ │ ├── migrations_user.go
│ │ │ ├── misc.go
│ │ │ ├── orgs.go
│ │ │ ├── orgs_hooks.go
│ │ │ ├── orgs_members.go
│ │ │ ├── orgs_outside_collaborators.go
│ │ │ ├── orgs_projects.go
│ │ │ ├── orgs_users_blocking.go
│ │ │ ├── projects.go
│ │ │ ├── pulls.go
│ │ │ ├── pulls_comments.go
│ │ │ ├── pulls_reviewers.go
│ │ │ ├── pulls_reviews.go
│ │ │ ├── reactions.go
│ │ │ ├── repos.go
│ │ │ ├── repos_collaborators.go
│ │ │ ├── repos_comments.go
│ │ │ ├── repos_commits.go
│ │ │ ├── repos_community_health.go
│ │ │ ├── repos_contents.go
│ │ │ ├── repos_deployments.go
│ │ │ ├── repos_forks.go
│ │ │ ├── repos_hooks.go
│ │ │ ├── repos_invitations.go
│ │ │ ├── repos_keys.go
│ │ │ ├── repos_merging.go
│ │ │ ├── repos_pages.go
│ │ │ ├── repos_prereceive_hooks.go
│ │ │ ├── repos_projects.go
│ │ │ ├── repos_releases.go
│ │ │ ├── repos_stats.go
│ │ │ ├── repos_statuses.go
│ │ │ ├── repos_traffic.go
│ │ │ ├── search.go
│ │ │ ├── strings.go
│ │ │ ├── teams.go
│ │ │ ├── teams_discussion_comments.go
│ │ │ ├── teams_discussions.go
│ │ │ ├── teams_members.go
│ │ │ ├── timestamp.go
│ │ │ ├── users.go
│ │ │ ├── users_administration.go
│ │ │ ├── users_blocking.go
│ │ │ ├── users_emails.go
│ │ │ ├── users_followers.go
│ │ │ ├── users_gpg_keys.go
│ │ │ ├── users_keys.go
│ │ │ ├── with_appengine.go
│ │ │ └── without_appengine.go
│ └── go-querystring
│ │ ├── LICENSE
│ │ └── query
│ │ └── encode.go
├── inconshreveable
│ └── mousetrap
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── trap_others.go
│ │ ├── trap_windows.go
│ │ └── trap_windows_1.4.go
├── kris-nova
│ ├── lolgopher
│ │ ├── Gopkg.lock
│ │ ├── Gopkg.toml
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── color.go
│ │ ├── color_0.go
│ │ ├── color_256.go
│ │ ├── color_truecolor.go
│ │ ├── output.go
│ │ ├── output_windows.go
│ │ ├── print.go
│ │ └── writer.go
│ └── rebrandly-go-sdk
│ │ ├── README.md
│ │ ├── account.go
│ │ ├── client.go
│ │ ├── domains.go
│ │ ├── links.go
│ │ ├── request.go
│ │ └── response.go
├── kubicorn
│ └── kubicorn
│ │ ├── AUTHORS
│ │ ├── LICENSE
│ │ ├── docs
│ │ └── LICENSE.txt
│ │ └── pkg
│ │ └── logger
│ │ └── logger.go
├── mattn
│ ├── go-colorable
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── colorable_appengine.go
│ │ ├── colorable_others.go
│ │ ├── colorable_windows.go
│ │ └── noncolorable.go
│ └── go-isatty
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── doc.go
│ │ ├── isatty_appengine.go
│ │ ├── isatty_bsd.go
│ │ ├── isatty_linux.go
│ │ ├── isatty_linux_ppc64x.go
│ │ ├── isatty_others.go
│ │ ├── isatty_solaris.go
│ │ └── isatty_windows.go
├── pkg
│ └── errors
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── appveyor.yml
│ │ ├── errors.go
│ │ └── stack.go
└── spf13
│ ├── cobra
│ ├── .gitignore
│ ├── .mailmap
│ ├── .travis.yml
│ ├── LICENSE.txt
│ ├── README.md
│ ├── args.go
│ ├── bash_completions.go
│ ├── bash_completions.md
│ ├── cobra.go
│ ├── cobra
│ │ └── cmd
│ │ │ ├── license_agpl.go
│ │ │ ├── license_apache_2.go
│ │ │ ├── license_bsd_clause_2.go
│ │ │ ├── license_bsd_clause_3.go
│ │ │ ├── license_gpl_2.go
│ │ │ ├── license_gpl_3.go
│ │ │ ├── license_lgpl.go
│ │ │ ├── license_mit.go
│ │ │ ├── licenses.go
│ │ │ └── testdata
│ │ │ └── LICENSE.golden
│ ├── command.go
│ ├── command_notwin.go
│ ├── command_win.go
│ └── zsh_completions.go
│ └── pflag
│ ├── .gitignore
│ ├── .travis.yml
│ ├── LICENSE
│ ├── README.md
│ ├── bool.go
│ ├── bool_slice.go
│ ├── bytes.go
│ ├── count.go
│ ├── duration.go
│ ├── duration_slice.go
│ ├── flag.go
│ ├── float32.go
│ ├── float64.go
│ ├── golangflag.go
│ ├── int.go
│ ├── int16.go
│ ├── int32.go
│ ├── int64.go
│ ├── int8.go
│ ├── int_slice.go
│ ├── ip.go
│ ├── ip_slice.go
│ ├── ipmask.go
│ ├── ipnet.go
│ ├── string.go
│ ├── string_array.go
│ ├── string_slice.go
│ ├── uint.go
│ ├── uint16.go
│ ├── uint32.go
│ ├── uint64.go
│ ├── uint8.go
│ └── uint_slice.go
└── golang.org
└── x
└── sys
├── AUTHORS
├── CONTRIBUTORS
├── LICENSE
├── PATENTS
└── unix
├── .gitignore
├── README.md
├── affinity_linux.go
├── aliases.go
├── asm_darwin_386.s
├── asm_darwin_amd64.s
├── asm_darwin_arm.s
├── asm_darwin_arm64.s
├── asm_dragonfly_amd64.s
├── asm_freebsd_386.s
├── asm_freebsd_amd64.s
├── asm_freebsd_arm.s
├── asm_linux_386.s
├── asm_linux_amd64.s
├── asm_linux_arm.s
├── asm_linux_arm64.s
├── asm_linux_mips64x.s
├── asm_linux_mipsx.s
├── asm_linux_ppc64x.s
├── asm_linux_s390x.s
├── asm_netbsd_386.s
├── asm_netbsd_amd64.s
├── asm_netbsd_arm.s
├── asm_openbsd_386.s
├── asm_openbsd_amd64.s
├── asm_openbsd_arm.s
├── asm_solaris_amd64.s
├── bluetooth_linux.go
├── cap_freebsd.go
├── constants.go
├── dev_darwin.go
├── dev_dragonfly.go
├── dev_freebsd.go
├── dev_linux.go
├── dev_netbsd.go
├── dev_openbsd.go
├── dirent.go
├── endian_big.go
├── endian_little.go
├── env_unix.go
├── errors_freebsd_386.go
├── errors_freebsd_amd64.go
├── errors_freebsd_arm.go
├── fcntl.go
├── fcntl_linux_32bit.go
├── gccgo.go
├── gccgo_c.c
├── gccgo_linux_amd64.go
├── ioctl.go
├── mkall.sh
├── mkerrors.sh
├── mkpost.go
├── mksyscall.pl
├── mksyscall_solaris.pl
├── mksysctl_openbsd.pl
├── mksysnum_darwin.pl
├── mksysnum_dragonfly.pl
├── mksysnum_freebsd.pl
├── mksysnum_netbsd.pl
├── mksysnum_openbsd.pl
├── openbsd_pledge.go
├── pagesize_unix.go
├── race.go
├── race0.go
├── sockcmsg_linux.go
├── sockcmsg_unix.go
├── str.go
├── syscall.go
├── syscall_bsd.go
├── syscall_darwin.go
├── syscall_darwin_386.go
├── syscall_darwin_amd64.go
├── syscall_darwin_arm.go
├── syscall_darwin_arm64.go
├── syscall_dragonfly.go
├── syscall_dragonfly_amd64.go
├── syscall_freebsd.go
├── syscall_freebsd_386.go
├── syscall_freebsd_amd64.go
├── syscall_freebsd_arm.go
├── syscall_linux.go
├── syscall_linux_386.go
├── syscall_linux_amd64.go
├── syscall_linux_amd64_gc.go
├── syscall_linux_arm.go
├── syscall_linux_arm64.go
├── syscall_linux_gc.go
├── syscall_linux_gc_386.go
├── syscall_linux_gccgo_386.go
├── syscall_linux_gccgo_arm.go
├── syscall_linux_mips64x.go
├── syscall_linux_mipsx.go
├── syscall_linux_ppc64x.go
├── syscall_linux_s390x.go
├── syscall_linux_sparc64.go
├── syscall_netbsd.go
├── syscall_netbsd_386.go
├── syscall_netbsd_amd64.go
├── syscall_netbsd_arm.go
├── syscall_openbsd.go
├── syscall_openbsd_386.go
├── syscall_openbsd_amd64.go
├── syscall_openbsd_arm.go
├── syscall_solaris.go
├── syscall_solaris_amd64.go
├── syscall_unix.go
├── syscall_unix_gc.go
├── timestruct.go
├── types_darwin.go
├── types_dragonfly.go
├── types_freebsd.go
├── types_netbsd.go
├── types_openbsd.go
├── types_solaris.go
├── xattr_bsd.go
├── zerrors_darwin_386.go
├── zerrors_darwin_amd64.go
├── zerrors_darwin_arm.go
├── zerrors_darwin_arm64.go
├── zerrors_dragonfly_amd64.go
├── zerrors_freebsd_386.go
├── zerrors_freebsd_amd64.go
├── zerrors_freebsd_arm.go
├── zerrors_linux_386.go
├── zerrors_linux_amd64.go
├── zerrors_linux_arm.go
├── zerrors_linux_arm64.go
├── zerrors_linux_mips.go
├── zerrors_linux_mips64.go
├── zerrors_linux_mips64le.go
├── zerrors_linux_mipsle.go
├── zerrors_linux_ppc64.go
├── zerrors_linux_ppc64le.go
├── zerrors_linux_s390x.go
├── zerrors_linux_sparc64.go
├── zerrors_netbsd_386.go
├── zerrors_netbsd_amd64.go
├── zerrors_netbsd_arm.go
├── zerrors_openbsd_386.go
├── zerrors_openbsd_amd64.go
├── zerrors_openbsd_arm.go
├── zerrors_solaris_amd64.go
├── zptrace386_linux.go
├── zptracearm_linux.go
├── zptracemips_linux.go
├── zptracemipsle_linux.go
├── zsyscall_darwin_386.go
├── zsyscall_darwin_amd64.go
├── zsyscall_darwin_arm.go
├── zsyscall_darwin_arm64.go
├── zsyscall_dragonfly_amd64.go
├── zsyscall_freebsd_386.go
├── zsyscall_freebsd_amd64.go
├── zsyscall_freebsd_arm.go
├── zsyscall_linux_386.go
├── zsyscall_linux_amd64.go
├── zsyscall_linux_arm.go
├── zsyscall_linux_arm64.go
├── zsyscall_linux_mips.go
├── zsyscall_linux_mips64.go
├── zsyscall_linux_mips64le.go
├── zsyscall_linux_mipsle.go
├── zsyscall_linux_ppc64.go
├── zsyscall_linux_ppc64le.go
├── zsyscall_linux_s390x.go
├── zsyscall_linux_sparc64.go
├── zsyscall_netbsd_386.go
├── zsyscall_netbsd_amd64.go
├── zsyscall_netbsd_arm.go
├── zsyscall_openbsd_386.go
├── zsyscall_openbsd_amd64.go
├── zsyscall_openbsd_arm.go
├── zsyscall_solaris_amd64.go
├── zsysctl_openbsd_386.go
├── zsysctl_openbsd_amd64.go
├── zsysctl_openbsd_arm.go
├── zsysnum_darwin_386.go
├── zsysnum_darwin_amd64.go
├── zsysnum_darwin_arm.go
├── zsysnum_darwin_arm64.go
├── zsysnum_dragonfly_amd64.go
├── zsysnum_freebsd_386.go
├── zsysnum_freebsd_amd64.go
├── zsysnum_freebsd_arm.go
├── zsysnum_linux_386.go
├── zsysnum_linux_amd64.go
├── zsysnum_linux_arm.go
├── zsysnum_linux_arm64.go
├── zsysnum_linux_mips.go
├── zsysnum_linux_mips64.go
├── zsysnum_linux_mips64le.go
├── zsysnum_linux_mipsle.go
├── zsysnum_linux_ppc64.go
├── zsysnum_linux_ppc64le.go
├── zsysnum_linux_s390x.go
├── zsysnum_linux_sparc64.go
├── zsysnum_netbsd_386.go
├── zsysnum_netbsd_amd64.go
├── zsysnum_netbsd_arm.go
├── zsysnum_openbsd_386.go
├── zsysnum_openbsd_amd64.go
├── zsysnum_openbsd_arm.go
├── ztypes_darwin_386.go
├── ztypes_darwin_amd64.go
├── ztypes_darwin_arm.go
├── ztypes_darwin_arm64.go
├── ztypes_dragonfly_amd64.go
├── ztypes_freebsd_386.go
├── ztypes_freebsd_amd64.go
├── ztypes_freebsd_arm.go
├── ztypes_linux_386.go
├── ztypes_linux_amd64.go
├── ztypes_linux_arm.go
├── ztypes_linux_arm64.go
├── ztypes_linux_mips.go
├── ztypes_linux_mips64.go
├── ztypes_linux_mips64le.go
├── ztypes_linux_mipsle.go
├── ztypes_linux_ppc64.go
├── ztypes_linux_ppc64le.go
├── ztypes_linux_s390x.go
├── ztypes_linux_sparc64.go
├── ztypes_netbsd_386.go
├── ztypes_netbsd_amd64.go
├── ztypes_netbsd_arm.go
├── ztypes_openbsd_386.go
├── ztypes_openbsd_amd64.go
├── ztypes_openbsd_arm.go
└── ztypes_solaris_amd64.go
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM jguyomard/hugo-builder
2 | ADD . /go/src/github.com/heptio/advocacy
3 | WORKDIR /go/src/github.com/heptio/advocacy
4 | CMD ["hugo"]
5 |
6 |
7 | FROM golang:latest
8 | MAINTAINER Kris Nova "knova@heptio.com"
9 | RUN mkdir -p /go/src/github.com/heptiolabs/git-events-operator
10 | ADD . /go/src/github.com/heptiolabs/git-events-operator
11 | WORKDIR /go/src/github.com/heptiolabs/git-events-operator
12 | RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o git-events-operator .
13 |
14 | FROM alpine:latest
15 | RUN mkdir -p /go/src/github.com/heptiolabs/git-events-operator
16 | WORKDIR /go/src/github.com/heptiolabs/git-events-operator
17 | COPY --from=0 /go/src/github.com/heptiolabs/git-events-operator/git-events-operator .
18 | CMD ["./git-events-operator"]
--------------------------------------------------------------------------------
/Gopkg.lock:
--------------------------------------------------------------------------------
1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
2 |
3 |
4 | [[projects]]
5 | name = "github.com/SparkPost/gosparkpost"
6 | packages = [
7 | ".",
8 | "events"
9 | ]
10 | revision = "4c6d2a3be65810be883c869868a74e677df2881b"
11 | version = "0.1.0"
12 |
13 | [[projects]]
14 | name = "github.com/fatih/color"
15 | packages = ["."]
16 | revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
17 | version = "v1.7.0"
18 |
19 | [[projects]]
20 | name = "github.com/google/go-github"
21 | packages = ["github"]
22 | revision = "747f93dd9b489bd56f7442b3c42bfea12800a75b"
23 | version = "v17.0.0"
24 |
25 | [[projects]]
26 | branch = "master"
27 | name = "github.com/google/go-querystring"
28 | packages = ["query"]
29 | revision = "53e6ce116135b80d037921a7fdd5138cf32d7a8a"
30 |
31 | [[projects]]
32 | name = "github.com/inconshreveable/mousetrap"
33 | packages = ["."]
34 | revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
35 | version = "v1.0"
36 |
37 | [[projects]]
38 | branch = "master"
39 | name = "github.com/kris-nova/lolgopher"
40 | packages = ["."]
41 | revision = "14d43f83481a37e992f5899de8581727b9ba7702"
42 |
43 | [[projects]]
44 | branch = "master"
45 | name = "github.com/kris-nova/rebrandly-go-sdk"
46 | packages = ["."]
47 | revision = "2dd68f242790b59cec08cfb7d4cfd81406c6b74a"
48 |
49 | [[projects]]
50 | branch = "master"
51 | name = "github.com/kubicorn/kubicorn"
52 | packages = ["pkg/logger"]
53 | revision = "2d658597ca19b7a64bba2f281e434559e3128aba"
54 |
55 | [[projects]]
56 | name = "github.com/mattn/go-colorable"
57 | packages = ["."]
58 | revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
59 | version = "v0.0.9"
60 |
61 | [[projects]]
62 | name = "github.com/mattn/go-isatty"
63 | packages = ["."]
64 | revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
65 | version = "v0.0.3"
66 |
67 | [[projects]]
68 | name = "github.com/pkg/errors"
69 | packages = ["."]
70 | revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
71 | version = "v0.8.0"
72 |
73 | [[projects]]
74 | name = "github.com/spf13/cobra"
75 | packages = ["."]
76 | revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
77 | version = "v0.0.3"
78 |
79 | [[projects]]
80 | name = "github.com/spf13/pflag"
81 | packages = ["."]
82 | revision = "9a97c102cda95a86cec2345a6f09f55a939babf5"
83 | version = "v1.0.2"
84 |
85 | [[projects]]
86 | branch = "master"
87 | name = "golang.org/x/sys"
88 | packages = ["unix"]
89 | revision = "4e1fef5609515ec7a2cee7b5de30ba6d9b438cbf"
90 |
91 | [solve-meta]
92 | analyzer-name = "dep"
93 | analyzer-version = 1
94 | inputs-digest = "86b89d0feda016277e958c07992ba780ab5cc9ad2ae07ecc029c7bf06fec0890"
95 | solver-name = "gps-cdcl"
96 | solver-version = 1
97 |
--------------------------------------------------------------------------------
/Gopkg.toml:
--------------------------------------------------------------------------------
1 | # Gopkg.toml example
2 | #
3 | # Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
4 | # for detailed Gopkg.toml documentation.
5 | #
6 | # required = ["github.com/user/thing/cmd/thing"]
7 | # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
8 | #
9 | # [[constraint]]
10 | # name = "github.com/user/project"
11 | # version = "1.0.0"
12 | #
13 | # [[constraint]]
14 | # name = "github.com/user/project2"
15 | # branch = "dev"
16 | # source = "github.com/myfork/project2"
17 | #
18 | # [[override]]
19 | # name = "github.com/x/y"
20 | # version = "2.4.0"
21 | #
22 | # [prune]
23 | # non-go = false
24 | # go-tests = true
25 | # unused-packages = true
26 |
27 |
28 | [[constraint]]
29 | branch = "master"
30 | name = "github.com/kubicorn/kubicorn"
31 |
32 | [[constraint]]
33 | name = "github.com/spf13/cobra"
34 | version = "0.0.3"
35 |
36 | [prune]
37 | go-tests = true
38 | unused-packages = true
39 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | ifndef VERBOSE
2 | MAKEFLAGS += --silent
3 | endif
4 |
5 |
6 | TARGET = git-events-operator
7 | GOTARGET = github.com/heptiolabs/$(TARGET)
8 | REGISTRY ?= gcr.io/heptio-prod
9 | IMAGE = $(REGISTRY)/$(TARGET)
10 | DIR := ${CURDIR}
11 | DOCKER ?= docker
12 |
13 | GIT_VERSION ?= $(shell git describe --always --dirty)
14 | IMAGE_VERSION ?= $(shell git describe --always --dirty)
15 | IMAGE_BRANCH ?= $(shell git rev-parse --abbrev-ref HEAD | sed 's/\///g')
16 | GIT_REF = $(shell git rev-parse --short=8 --verify HEAD)
17 |
18 | FMT_PKGS=$(shell go list -f {{.Dir}} ./... | grep -v vendor | tail -n +2)
19 |
20 | default: container
21 |
22 | push: ## Push to the docker registry
23 | $(DOCKER) push $(REGISTRY)/$(TARGET):$(GIT_REF)
24 | $(DOCKER) push $(REGISTRY)/$(TARGET):latest
25 |
26 | clean: ## Clean the docker images
27 | rm -f $(TARGET)
28 | $(DOCKER) rmi $(REGISTRY)/$(TARGET) || true
29 |
30 | container: ## Build the docker container
31 | $(DOCKER) build \
32 | -t $(REGISTRY)/$(TARGET):$(GIT_REF) \
33 | -t $(REGISTRY)/$(TARGET):latest \
34 | .
35 |
36 | run: ## Run the controller in a container
37 | $(DOCKER) run $(REGISTRY)/$(TARGET):$(IMAGE_VERSION)
38 |
39 | update-headers: ## Update the headers in the repository. Required for all new files.
40 | ./scripts/headers.sh
41 |
42 | gofmt: install-tools ## Go fmt your code
43 | echo "Fixing format of go files..."; \
44 | for package in $(FMT_PKGS); \
45 | do \
46 | gofmt -w $$package ; \
47 | goimports -l -w $$package ; \
48 | done
49 |
50 | check-headers: ## Check if the headers are valid. This is ran in CI.
51 | ./scripts/check-header.sh
52 |
53 | .PHONY: check-code
54 | check-code: install-tools ## Run code checks
55 | PKGS="${FMT_PKGS}" GOFMT="gofmt" GOLINT="golint" ./scripts/ci-checks.sh
56 |
57 | .PHONY: help
58 | help: ## Show help messages for make targets
59 | @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[32m%-30s\033[0m %s\n", $$1, $$2}'
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # git-events-operator
2 |
3 | This is an operator (or more of a framework) that allows users to build their own specific flavor
4 | of an operator and deploy to Kubernetes.
5 |
6 | The framework makes it easy to trigger on arbitrary events and map them to arbitrary actions.
7 |
8 | In the case of our first example we map a merge to master, to a rebrandly link
9 |
10 | # Building
11 |
12 | ```bash
13 | make container push
14 | ```
15 |
16 | More information
17 |
18 | ```bash
19 | make help
20 | ```
21 |
22 | # Brokers
23 |
24 | ### GitHub
25 |
26 | Required environmental variables
27 |
28 | ```
29 | export GITHUB_USER="myuser"
30 | export GITHUB_PASS="mypass"
31 | ```
32 |
33 | # Actions
34 |
35 | ### Rebrandly
36 |
37 | ```
38 | export REBRANDLY_API_KEY="mykey"
39 | ```
40 |
41 | ### Sparkpost
42 |
43 | ```
44 | export SPARKPOST_API_KEY="mykey"
45 | ```
--------------------------------------------------------------------------------
/actions/html_email.go:
--------------------------------------------------------------------------------
1 | // Copyright © 2017 Heptio
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 action
16 |
17 | import "fmt"
18 |
19 | func getHTMLEmail(name, filename, link string) string {
20 | return fmt.Sprintf(`
21 |
22 |
25 |
26 | Hi there %s,
27 |
28 |
29 |
30 | Thank you for creating a new event page (%s) for the Heptio advocacy site. Because you created a new page, we automatically generated a link for you.
31 |
32 |
33 |
34 | Please use this link on social media, and during your presentation to share meta information about the event.
35 |
36 |
37 |
38 | %s
39 |
40 |
41 |
42 | How to use your link:
43 |
44 | Feel free to edit your event page (the markdown file) as often as you like (you will always keep this same link, and we will stop emailing you).
45 |
46 | This page is now the single landing page for your event! Use it on twitter, put it in your slides, whatever.
47 | We can now easily track clicks through your event! You will never be measured on the amount of clicks you get, we just use the data to show that advocacy works.
48 |
49 | Common links that folks add to their event page include:
50 |
51 |
52 | - Your Twitter.
53 | - Your LinkedIn.
54 | - Your GitHub.
55 | - Your Personal blog.
56 | - Your slides from the event.
57 | - A link to the event page about your talk.
58 | - Links to any resources you mention: books, repositories, videos, etc
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 | For more information please reach out to Heptio advocacy at team-advocacy@heptio.com
67 |
68 |
69 | 
70 |
71 | `, name, filename, link, link)
72 |
73 | }
74 |
--------------------------------------------------------------------------------
/actions/type.go:
--------------------------------------------------------------------------------
1 | // Copyright © 2017 Heptio
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 | // Copyright © 2017 The Kubicorn Authors
16 | //
17 | // Licensed under the Apache License, Version 2.0 (the "License");
18 | // you may not use this file except in compliance with the License.
19 | // You may obtain a copy of the License at
20 | //
21 | // http://www.apache.org/licenses/LICENSE-2.0
22 | //
23 | // Unless required by applicable law or agreed to in writing, software
24 | // distributed under the License is distributed on an "AS IS" BASIS,
25 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
26 | // See the License for the specific language governing permissions and
27 | // limitations under the License.
28 |
29 | package action
30 |
31 | import "github.com/heptiolabs/git-events-operator/event"
32 |
33 | type ActionFunc func(event event.Event, queue *event.Queue) error
34 |
--------------------------------------------------------------------------------
/event/interface.go:
--------------------------------------------------------------------------------
1 | // Copyright © 2017 Heptio
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 | // Copyright © 2017 The Kubicorn Authors
16 | //
17 | // Licensed under the Apache License, Version 2.0 (the "License");
18 | // you may not use this file except in compliance with the License.
19 | // You may obtain a copy of the License at
20 | //
21 | // http://www.apache.org/licenses/LICENSE-2.0
22 | //
23 | // Unless required by applicable law or agreed to in writing, software
24 | // distributed under the License is distributed on an "AS IS" BASIS,
25 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
26 | // See the License for the specific language governing permissions and
27 | // limitations under the License.
28 |
29 | package event
30 |
31 | type EventKind string
32 | type ImplementationType string
33 |
34 | const (
35 |
36 | // NewFile is whenever a new file is created in a given directory
37 | NewFile EventKind = "NewFile"
38 | )
39 |
40 | type Event interface {
41 | Kind() EventKind
42 | Type() ImplementationType
43 | }
44 |
45 | type Broker interface {
46 | ConcurrentWatch(queue *Queue) chan error
47 | Auth() error
48 | }
49 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | // Copyright © 2017 Heptio
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 | // Copyright © 2017 The Kubicorn Authors
16 | //
17 | // Licensed under the Apache License, Version 2.0 (the "License");
18 | // you may not use this file except in compliance with the License.
19 | // You may obtain a copy of the License at
20 | //
21 | // http://www.apache.org/licenses/LICENSE-2.0
22 | //
23 | // Unless required by applicable law or agreed to in writing, software
24 | // distributed under the License is distributed on an "AS IS" BASIS,
25 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
26 | // See the License for the specific language governing permissions and
27 | // limitations under the License.
28 |
29 | // Copyright © 2018 NAME HERE
30 | //
31 | // Licensed under the Apache License, Version 2.0 (the "License");
32 | // you may not use this file except in compliance with the License.
33 | // You may obtain a copy of the License at
34 | //
35 | // http://www.apache.org/licenses/LICENSE-2.0
36 | //
37 | // Unless required by applicable law or agreed to in writing, software
38 | // distributed under the License is distributed on an "AS IS" BASIS,
39 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
40 | // See the License for the specific language governing permissions and
41 | // limitations under the License.
42 |
43 | package main
44 |
45 | import "github.com/heptiolabs/git-events-operator/cmd"
46 |
47 | func main() {
48 | cmd.Execute()
49 | }
50 |
--------------------------------------------------------------------------------
/scripts/check-header.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | # Copyright © 2017 Heptio
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 | read -r -d '' EXPECTED < $FILE
38 | fi
39 | done
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/.gitignore:
--------------------------------------------------------------------------------
1 | **/.*.swp
2 | .vscode
3 |
4 | **/*.test
5 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | sudo: false
3 | go:
4 | - 1.7
5 | before_install:
6 | go get github.com/mattn/goveralls
7 | script:
8 | - $HOME/gopath/bin/goveralls -service=travis-ci -ignore 'cmd/*/*.go,examples/*/*.go,helpers/*/*.go'
9 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/AUTHORS.rst:
--------------------------------------------------------------------------------
1 | Core contributors
2 | -----------------
3 |
4 | - Dave Gray `@yargevad `_
5 |
6 | Patches and suggestions
7 | -----------------------
8 |
9 | - Jeff Macdonald `@macfisherman `_
10 | - Chris Wilson `@yepher `_
11 | ADD YOURSELF HERE (and link to your github page)
12 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing to gosparkpost
2 |
3 | Transparency is one of our core values, and we encourage developers to contribute and become part of the SparkPost developer community.
4 |
5 | The following is a set of guidelines for contributing to gosparkpost,
6 | which is hosted in the [SparkPost Organization](https://github.com/sparkpost) on GitHub.
7 | These are just guidelines, not rules, use your best judgment and feel free to
8 | propose changes to this document in a pull request.
9 |
10 | ## Submitting Issues
11 |
12 | * You can create an issue [here](https://github.com/sparkpost/gosparkpost/issues/new), but
13 | before doing that please read the notes below on debugging and submitting issues,
14 | and include as many details as possible with your report.
15 | * Include the version of gosparkpost you are using.
16 | * Perform a [cursory search](https://github.com/issues?utf8=%E2%9C%93&q=is%3Aissue+user%3Asparkpost+repo%3Agosparkpost)
17 | to see if a similar issue has already been submitted.
18 |
19 | ## Local development
20 |
21 | * Fork this repository
22 | * Clone the _original source_ using ``go get https://github.com/SparkPost/gosparkpost``
23 | * `cd $GOPATH/src/github.com/SparkPost/gosparkpost`
24 | * Add a remote pointing to your fork - ``git remote add fork https://github.com/YOUR_ID/gosparkpost``
25 | * Create a branch - ``git checkout -b fix-or-feature``
26 | * Write code!
27 | * Commit code!
28 | * Push code with - ``git push fork HEAD``
29 |
30 | ## Contribution Steps
31 |
32 | ### Guidelines
33 |
34 | - Provide [documentation](http://blog.golang.org/godoc-documenting-go-code) for any newly added code.
35 | - Provide [tests](https://golang.org/doc/code.html#Testing) for any newly added code.
36 | - Run ``go fmt`` before submitting.
37 |
38 | 1. Create a new branch named after the issue you’ll be fixing (include the issue number as the branch name, example: Issue in GitHub is #8 then the branch name should be ISSUE-8))
39 | 2. Write corresponding tests and code (only what is needed to satisfy the issue and tests please)
40 | * Include your tests in the corresponding package directory in an appropriately-named test file
41 | * Write code to satisfy the tests
42 | 3. Ensure automated tests pass
43 | 4. Submit a new Pull Request applying your feature/fix branch to the develop branch
44 |
45 | ## Testing
46 |
47 | Once you are set up for local development:
48 |
49 | * Run ``go test`` to test against your current Go environment
50 |
51 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright 2015 Message Systems, Inc. or its affiliates. All Rights Reserved.
2 |
3 | Licensed under the Apache License, Version 2.0 (the "License").
4 | You may not use this software except in compliance with the License.
5 |
6 | A copy of the License is located at
7 |
8 | http://www.apache.org/licenses/LICENSE-2.0.html
9 |
10 | or in the "license" file accompanying this software. This file is
11 | distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
12 | ANY KIND, either express or implied. See the License for the specific
13 | language governing permissions and limitations under the License.
14 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/event_docs.go:
--------------------------------------------------------------------------------
1 | package gosparkpost
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 |
8 | "github.com/pkg/errors"
9 | )
10 |
11 | var EventDocumentationFormat = "/api/v%d/webhooks/events/documentation"
12 |
13 | type EventGroup struct {
14 | Name string
15 | Events map[string]EventMeta `json:"events"`
16 | Description string `json:"description"`
17 | DisplayName string `json:"display_name"`
18 | }
19 |
20 | type EventMeta struct {
21 | Name string
22 | Fields map[string]EventField `json:"event"`
23 | Description string `json:"description"`
24 | DisplayName string `json:"display_name"`
25 | }
26 |
27 | type EventField struct {
28 | Description string `json:"description"`
29 | SampleValue interface{} `json:"sampleValue"`
30 | }
31 |
32 | func (c *Client) EventDocumentation() (g map[string]*EventGroup, res *Response, err error) {
33 | return c.EventDocumentationContext(context.Background())
34 | }
35 |
36 | func (c *Client) EventDocumentationContext(ctx context.Context) (groups map[string]*EventGroup, res *Response, err error) {
37 | path := fmt.Sprintf(EventDocumentationFormat, c.Config.ApiVersion)
38 | res, err = c.HttpGet(ctx, c.Config.BaseUrl+path)
39 | if err != nil {
40 | return
41 | }
42 |
43 | if err = res.AssertJson(); err != nil {
44 | return
45 | }
46 |
47 | if Is2XX(res.HTTP.StatusCode) {
48 | var body []byte
49 | var ok bool
50 | body, err = res.ReadBody()
51 | if err != nil {
52 | return
53 | }
54 |
55 | var results map[string]map[string]*EventGroup
56 | if err = json.Unmarshal(body, &results); err != nil {
57 | } else if groups, ok = results["results"]; ok {
58 | // Success!
59 | } else {
60 | err = errors.New("Unexpected response format (results)")
61 | }
62 | } else {
63 | if err = res.ParseResponse(); err == nil {
64 | err = res.HTTPError()
65 | }
66 | }
67 | return
68 | }
69 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/events/generation.go:
--------------------------------------------------------------------------------
1 | package events
2 |
3 | import "fmt"
4 |
5 | type GenerationFailure struct {
6 | EventCommon
7 | Binding string `json:"binding"`
8 | BindingGroup string `json:"binding_group"`
9 | CampaignID string `json:"campaign_id"`
10 | CustomerID string `json:"customer_id"`
11 | ErrorCode string `json:"error_code"`
12 | Metadata interface{} `json:"rcpt_meta"`
13 | SubstitutionData interface{} `json:"rcpt_subs"`
14 | Tags []string `json:"rcpt_tags"`
15 | Recipient string `json:"rcpt_to"`
16 | RawReason string `json:"raw_reason"`
17 | Reason string `json:"reason"`
18 | ReceiveProtocol string `json:"recv_method"`
19 | RoutingDomain string `json:"routing_domain"`
20 | TemplateID string `json:"template_id"`
21 | TemplateVersion string `json:"template_version"`
22 | Timestamp Timestamp `json:"timestamp"`
23 | TransmissionID string `json:"transmission_id"`
24 | }
25 |
26 | // String returns a brief summary of a GenerationFailure event
27 | func (g *GenerationFailure) String() string {
28 | return fmt.Sprintf("%s GF %s %s => %s %s: %s",
29 | g.Timestamp, g.TransmissionID, g.Binding, g.Recipient,
30 | g.ErrorCode, g.RawReason)
31 | }
32 |
33 | type GenerationRejection GenerationFailure
34 |
35 | // String returns a brief summary of a GenerationFailure event
36 | func (g *GenerationRejection) String() string {
37 | return fmt.Sprintf("%s GR %s %s => %s %s: %s",
38 | g.Timestamp, g.TransmissionID, g.Binding, g.Recipient,
39 | g.ErrorCode, g.RawReason)
40 | }
41 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/events/sample-webhook-validation.json:
--------------------------------------------------------------------------------
1 | [{"msys":{}}]
2 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/events/track.go:
--------------------------------------------------------------------------------
1 | package events
2 |
3 | import "fmt"
4 |
5 | type Click struct {
6 | EventCommon
7 | CampaignID string `json:"campaign_id"`
8 | CustomerID string `json:"customer_id"`
9 | DeliveryMethod string `json:"delv_method"`
10 | GeoIP *GeoIP `json:"geo_ip"`
11 | IPAddress string `json:"ip_address"`
12 | MessageID string `json:"message_id"`
13 | Metadata interface{} `json:"rcpt_meta"`
14 | Tags []string `json:"rcpt_tags"`
15 | Recipient string `json:"rcpt_to"`
16 | RecipientType string `json:"rcpt_type"`
17 | TargetLinkName string `json:"target_link_name"`
18 | TargetLinkURL string `json:"target_link_url"`
19 | TemplateID string `json:"template_id"`
20 | TemplateVersion string `json:"template_version"`
21 | Timestamp Timestamp `json:"timestamp"`
22 | TransmissionID string `json:"transmission_id"`
23 | UserAgent string `json:"user_agent"`
24 | }
25 |
26 | // String returns a brief summary of a Click event
27 | func (c *Click) String() string {
28 | return fmt.Sprintf("%s C %s %s => %s",
29 | c.Timestamp, c.TransmissionID, c.Recipient, c.TargetLinkURL)
30 | }
31 |
32 | type Open struct {
33 | EventCommon
34 | CampaignID string `json:"campaign_id"`
35 | CustomerID string `json:"customer_id"`
36 | DeliveryMethod string `json:"delv_method"`
37 | GeoIP *GeoIP `json:"geo_ip"`
38 | IPAddress string `json:"ip_address"`
39 | MessageID string `json:"message_id"`
40 | Metadata interface{} `json:"rcpt_meta"`
41 | Tags []string `json:"rcpt_tags"`
42 | Recipient string `json:"rcpt_to"`
43 | RecipientType string `json:"rcpt_type"`
44 | TemplateID string `json:"template_id"`
45 | TemplateVersion string `json:"template_version"`
46 | Timestamp Timestamp `json:"timestamp"`
47 | TransmissionID string `json:"transmission_id"`
48 | UserAgent string `json:"user_agent"`
49 | }
50 |
51 | // String returns a brief summary of an Open event
52 | func (o *Open) String() string {
53 | return fmt.Sprintf("%s O %s %s",
54 | o.Timestamp, o.TransmissionID, o.Recipient)
55 | }
56 |
--------------------------------------------------------------------------------
/vendor/github.com/SparkPost/gosparkpost/events/unsubscribe.go:
--------------------------------------------------------------------------------
1 | package events
2 |
3 | import "fmt"
4 |
5 | type ListUnsubscribe struct {
6 | EventCommon
7 | CampaignID string `json:"campaign_id"`
8 | CustomerID string `json:"customer_id"`
9 | MessageFrom string `json:"mailfrom"`
10 | MessageID string `json:"message_id"`
11 | Metadata interface{} `json:"rcpt_meta"`
12 | Tags []string `json:"rcpt_tags"`
13 | Recipient string `json:"rcpt_to"`
14 | RecipientType string `json:"rcpt_type"`
15 | TemplateID string `json:"template_id"`
16 | TemplateVersion string `json:"template_version"`
17 | Timestamp Timestamp `json:"timestamp"`
18 | TransmissionID string `json:"transmission_id"`
19 | }
20 |
21 | // String returns a brief summary of a ListUnsubscribe event
22 | func (l *ListUnsubscribe) String() string {
23 | return fmt.Sprintf("%s U %s %s: [%s]",
24 | l.Timestamp, l.TransmissionID, l.Recipient, l.CampaignID)
25 | }
26 |
27 | type LinkUnsubscribe struct {
28 | EventCommon
29 | ListUnsubscribe
30 | UserAgent string `json:"user_agent"`
31 | }
32 |
33 | // String returns a brief summary of a ListUnsubscribe event
34 | func (l *LinkUnsubscribe) String() string {
35 | return fmt.Sprintf("%s LU %s %s: [%s]",
36 | l.Timestamp, l.TransmissionID, l.Recipient, l.CampaignID)
37 | }
38 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/color/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go:
3 | - 1.8.x
4 | - tip
5 |
6 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/color/Gopkg.lock:
--------------------------------------------------------------------------------
1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
2 |
3 |
4 | [[projects]]
5 | name = "github.com/mattn/go-colorable"
6 | packages = ["."]
7 | revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
8 | version = "v0.0.9"
9 |
10 | [[projects]]
11 | name = "github.com/mattn/go-isatty"
12 | packages = ["."]
13 | revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
14 | version = "v0.0.3"
15 |
16 | [[projects]]
17 | branch = "master"
18 | name = "golang.org/x/sys"
19 | packages = ["unix"]
20 | revision = "37707fdb30a5b38865cfb95e5aab41707daec7fd"
21 |
22 | [solve-meta]
23 | analyzer-name = "dep"
24 | analyzer-version = 1
25 | inputs-digest = "e8a50671c3cb93ea935bf210b1cd20702876b9d9226129be581ef646d1565cdc"
26 | solver-name = "gps-cdcl"
27 | solver-version = 1
28 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/color/Gopkg.toml:
--------------------------------------------------------------------------------
1 |
2 | # Gopkg.toml example
3 | #
4 | # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
5 | # for detailed Gopkg.toml documentation.
6 | #
7 | # required = ["github.com/user/thing/cmd/thing"]
8 | # ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
9 | #
10 | # [[constraint]]
11 | # name = "github.com/user/project"
12 | # version = "1.0.0"
13 | #
14 | # [[constraint]]
15 | # name = "github.com/user/project2"
16 | # branch = "dev"
17 | # source = "github.com/myfork/project2"
18 | #
19 | # [[override]]
20 | # name = "github.com/x/y"
21 | # version = "2.4.0"
22 |
23 |
24 | [[constraint]]
25 | name = "github.com/mattn/go-colorable"
26 | version = "0.0.9"
27 |
28 | [[constraint]]
29 | name = "github.com/mattn/go-isatty"
30 | version = "0.0.3"
31 |
--------------------------------------------------------------------------------
/vendor/github.com/fatih/color/LICENSE.md:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2013 Fatih Arslan
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
6 | this software and associated documentation files (the "Software"), to deal in
7 | the Software without restriction, including without limitation the rights to
8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | 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, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2013 The go-github 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/github.com/google/go-github/github/git.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | // GitService handles communication with the git data related
9 | // methods of the GitHub API.
10 | //
11 | // GitHub API docs: https://developer.github.com/v3/git/
12 | type GitService service
13 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/git_blobs.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "bytes"
10 | "context"
11 | "fmt"
12 | )
13 |
14 | // Blob represents a blob object.
15 | type Blob struct {
16 | Content *string `json:"content,omitempty"`
17 | Encoding *string `json:"encoding,omitempty"`
18 | SHA *string `json:"sha,omitempty"`
19 | Size *int `json:"size,omitempty"`
20 | URL *string `json:"url,omitempty"`
21 | NodeID *string `json:"node_id,omitempty"`
22 | }
23 |
24 | // GetBlob fetches a blob from a repo given a SHA.
25 | //
26 | // GitHub API docs: https://developer.github.com/v3/git/blobs/#get-a-blob
27 | func (s *GitService) GetBlob(ctx context.Context, owner string, repo string, sha string) (*Blob, *Response, error) {
28 | u := fmt.Sprintf("repos/%v/%v/git/blobs/%v", owner, repo, sha)
29 | req, err := s.client.NewRequest("GET", u, nil)
30 | if err != nil {
31 | return nil, nil, err
32 | }
33 |
34 | blob := new(Blob)
35 | resp, err := s.client.Do(ctx, req, blob)
36 | return blob, resp, err
37 | }
38 |
39 | // GetBlobRaw fetches a blob's contents from a repo.
40 | // Unlike GetBlob, it returns the raw bytes rather than the base64-encoded data.
41 | //
42 | // GitHub API docs: https://developer.github.com/v3/git/blobs/#get-a-blob
43 | func (s *GitService) GetBlobRaw(ctx context.Context, owner, repo, sha string) ([]byte, *Response, error) {
44 | u := fmt.Sprintf("repos/%v/%v/git/blobs/%v", owner, repo, sha)
45 | req, err := s.client.NewRequest("GET", u, nil)
46 | if err != nil {
47 | return nil, nil, err
48 | }
49 | req.Header.Set("Accept", "application/vnd.github.v3.raw")
50 |
51 | var buf bytes.Buffer
52 | resp, err := s.client.Do(ctx, req, &buf)
53 | return buf.Bytes(), resp, err
54 | }
55 |
56 | // CreateBlob creates a blob object.
57 | //
58 | // GitHub API docs: https://developer.github.com/v3/git/blobs/#create-a-blob
59 | func (s *GitService) CreateBlob(ctx context.Context, owner string, repo string, blob *Blob) (*Blob, *Response, error) {
60 | u := fmt.Sprintf("repos/%v/%v/git/blobs", owner, repo)
61 | req, err := s.client.NewRequest("POST", u, blob)
62 | if err != nil {
63 | return nil, nil, err
64 | }
65 |
66 | t := new(Blob)
67 | resp, err := s.client.Do(ctx, req, t)
68 | return t, resp, err
69 | }
70 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/git_tags.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | )
12 |
13 | // Tag represents a tag object.
14 | type Tag struct {
15 | Tag *string `json:"tag,omitempty"`
16 | SHA *string `json:"sha,omitempty"`
17 | URL *string `json:"url,omitempty"`
18 | Message *string `json:"message,omitempty"`
19 | Tagger *CommitAuthor `json:"tagger,omitempty"`
20 | Object *GitObject `json:"object,omitempty"`
21 | Verification *SignatureVerification `json:"verification,omitempty"`
22 | NodeID *string `json:"node_id,omitempty"`
23 | }
24 |
25 | // createTagRequest represents the body of a CreateTag request. This is mostly
26 | // identical to Tag with the exception that the object SHA and Type are
27 | // top-level fields, rather than being nested inside a JSON object.
28 | type createTagRequest struct {
29 | Tag *string `json:"tag,omitempty"`
30 | Message *string `json:"message,omitempty"`
31 | Object *string `json:"object,omitempty"`
32 | Type *string `json:"type,omitempty"`
33 | Tagger *CommitAuthor `json:"tagger,omitempty"`
34 | }
35 |
36 | // GetTag fetchs a tag from a repo given a SHA.
37 | //
38 | // GitHub API docs: https://developer.github.com/v3/git/tags/#get-a-tag
39 | func (s *GitService) GetTag(ctx context.Context, owner string, repo string, sha string) (*Tag, *Response, error) {
40 | u := fmt.Sprintf("repos/%v/%v/git/tags/%v", owner, repo, sha)
41 | req, err := s.client.NewRequest("GET", u, nil)
42 | if err != nil {
43 | return nil, nil, err
44 | }
45 |
46 | // TODO: remove custom Accept headers when APIs fully launch.
47 | req.Header.Set("Accept", mediaTypeGitSigningPreview)
48 |
49 | tag := new(Tag)
50 | resp, err := s.client.Do(ctx, req, tag)
51 | return tag, resp, err
52 | }
53 |
54 | // CreateTag creates a tag object.
55 | //
56 | // GitHub API docs: https://developer.github.com/v3/git/tags/#create-a-tag-object
57 | func (s *GitService) CreateTag(ctx context.Context, owner string, repo string, tag *Tag) (*Tag, *Response, error) {
58 | u := fmt.Sprintf("repos/%v/%v/git/tags", owner, repo)
59 |
60 | // convert Tag into a createTagRequest
61 | tagRequest := &createTagRequest{
62 | Tag: tag.Tag,
63 | Message: tag.Message,
64 | Tagger: tag.Tagger,
65 | }
66 | if tag.Object != nil {
67 | tagRequest.Object = tag.Object.SHA
68 | tagRequest.Type = tag.Object.Type
69 | }
70 |
71 | req, err := s.client.NewRequest("POST", u, tagRequest)
72 | if err != nil {
73 | return nil, nil, err
74 | }
75 |
76 | t := new(Tag)
77 | resp, err := s.client.Do(ctx, req, t)
78 | return t, resp, err
79 | }
80 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/gitignore.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | )
12 |
13 | // GitignoresService provides access to the gitignore related functions in the
14 | // GitHub API.
15 | //
16 | // GitHub API docs: https://developer.github.com/v3/gitignore/
17 | type GitignoresService service
18 |
19 | // Gitignore represents a .gitignore file as returned by the GitHub API.
20 | type Gitignore struct {
21 | Name *string `json:"name,omitempty"`
22 | Source *string `json:"source,omitempty"`
23 | }
24 |
25 | func (g Gitignore) String() string {
26 | return Stringify(g)
27 | }
28 |
29 | // List all available Gitignore templates.
30 | //
31 | // GitHub API docs: https://developer.github.com/v3/gitignore/#listing-available-templates
32 | func (s GitignoresService) List(ctx context.Context) ([]string, *Response, error) {
33 | req, err := s.client.NewRequest("GET", "gitignore/templates", nil)
34 | if err != nil {
35 | return nil, nil, err
36 | }
37 |
38 | var availableTemplates []string
39 | resp, err := s.client.Do(ctx, req, &availableTemplates)
40 | if err != nil {
41 | return nil, resp, err
42 | }
43 |
44 | return availableTemplates, resp, nil
45 | }
46 |
47 | // Get a Gitignore by name.
48 | //
49 | // GitHub API docs: https://developer.github.com/v3/gitignore/#get-a-single-template
50 | func (s GitignoresService) Get(ctx context.Context, name string) (*Gitignore, *Response, error) {
51 | u := fmt.Sprintf("gitignore/templates/%v", name)
52 | req, err := s.client.NewRequest("GET", u, nil)
53 | if err != nil {
54 | return nil, nil, err
55 | }
56 |
57 | gitignore := new(Gitignore)
58 | resp, err := s.client.Do(ctx, req, gitignore)
59 | if err != nil {
60 | return nil, resp, err
61 | }
62 |
63 | return gitignore, resp, nil
64 | }
65 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/orgs_projects.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | )
12 |
13 | // ListProjects lists the projects for an organization.
14 | //
15 | // GitHub API docs: https://developer.github.com/v3/projects/#list-organization-projects
16 | func (s *OrganizationsService) ListProjects(ctx context.Context, org string, opt *ProjectListOptions) ([]*Project, *Response, error) {
17 | u := fmt.Sprintf("orgs/%v/projects", org)
18 | u, err := addOptions(u, opt)
19 | if err != nil {
20 | return nil, nil, err
21 | }
22 |
23 | req, err := s.client.NewRequest("GET", u, nil)
24 | if err != nil {
25 | return nil, nil, err
26 | }
27 |
28 | // TODO: remove custom Accept header when this API fully launches.
29 | req.Header.Set("Accept", mediaTypeProjectsPreview)
30 |
31 | var projects []*Project
32 | resp, err := s.client.Do(ctx, req, &projects)
33 | if err != nil {
34 | return nil, resp, err
35 | }
36 |
37 | return projects, resp, nil
38 | }
39 |
40 | // CreateProject creates a GitHub Project for the specified organization.
41 | //
42 | // GitHub API docs: https://developer.github.com/v3/projects/#create-an-organization-project
43 | func (s *OrganizationsService) CreateProject(ctx context.Context, org string, opt *ProjectOptions) (*Project, *Response, error) {
44 | u := fmt.Sprintf("orgs/%v/projects", org)
45 | req, err := s.client.NewRequest("POST", u, opt)
46 | if err != nil {
47 | return nil, nil, err
48 | }
49 |
50 | // TODO: remove custom Accept header when this API fully launches.
51 | req.Header.Set("Accept", mediaTypeProjectsPreview)
52 |
53 | project := &Project{}
54 | resp, err := s.client.Do(ctx, req, project)
55 | if err != nil {
56 | return nil, resp, err
57 | }
58 |
59 | return project, resp, nil
60 | }
61 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/pulls_reviewers.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | )
12 |
13 | // ReviewersRequest specifies users and teams for a pull request review request.
14 | type ReviewersRequest struct {
15 | Reviewers []string `json:"reviewers,omitempty"`
16 | TeamReviewers []string `json:"team_reviewers,omitempty"`
17 | }
18 |
19 | // Reviewers represents reviewers of a pull request.
20 | type Reviewers struct {
21 | Users []*User `json:"users,omitempty"`
22 | Teams []*Team `json:"teams,omitempty"`
23 | }
24 |
25 | // RequestReviewers creates a review request for the provided reviewers for the specified pull request.
26 | //
27 | // GitHub API docs: https://developer.github.com/v3/pulls/review_requests/#create-a-review-request
28 | func (s *PullRequestsService) RequestReviewers(ctx context.Context, owner, repo string, number int, reviewers ReviewersRequest) (*PullRequest, *Response, error) {
29 | u := fmt.Sprintf("repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, number)
30 | req, err := s.client.NewRequest("POST", u, &reviewers)
31 | if err != nil {
32 | return nil, nil, err
33 | }
34 |
35 | r := new(PullRequest)
36 | resp, err := s.client.Do(ctx, req, r)
37 | if err != nil {
38 | return nil, resp, err
39 | }
40 |
41 | return r, resp, nil
42 | }
43 |
44 | // ListReviewers lists reviewers whose reviews have been requested on the specified pull request.
45 | //
46 | // GitHub API docs: https://developer.github.com/v3/pulls/review_requests/#list-review-requests
47 | func (s *PullRequestsService) ListReviewers(ctx context.Context, owner, repo string, number int, opt *ListOptions) (*Reviewers, *Response, error) {
48 | u := fmt.Sprintf("repos/%v/%v/pulls/%d/requested_reviewers", owner, repo, number)
49 | u, err := addOptions(u, opt)
50 | if err != nil {
51 | return nil, nil, err
52 | }
53 |
54 | req, err := s.client.NewRequest("GET", u, nil)
55 | if err != nil {
56 | return nil, nil, err
57 | }
58 |
59 | reviewers := new(Reviewers)
60 | resp, err := s.client.Do(ctx, req, reviewers)
61 | if err != nil {
62 | return nil, resp, err
63 | }
64 |
65 | return reviewers, resp, nil
66 | }
67 |
68 | // RemoveReviewers removes the review request for the provided reviewers for the specified pull request.
69 | //
70 | // GitHub API docs: https://developer.github.com/v3/pulls/review_requests/#delete-a-review-request
71 | func (s *PullRequestsService) RemoveReviewers(ctx context.Context, owner, repo string, number int, reviewers ReviewersRequest) (*Response, error) {
72 | u := fmt.Sprintf("repos/%s/%s/pulls/%d/requested_reviewers", owner, repo, number)
73 | req, err := s.client.NewRequest("DELETE", u, &reviewers)
74 | if err != nil {
75 | return nil, err
76 | }
77 |
78 | return s.client.Do(ctx, req, nil)
79 | }
80 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/repos_community_health.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | "time"
12 | )
13 |
14 | // Metric represents the different fields for one file in community health files.
15 | type Metric struct {
16 | Name *string `json:"name"`
17 | Key *string `json:"key"`
18 | URL *string `json:"url"`
19 | HTMLURL *string `json:"html_url"`
20 | }
21 |
22 | // CommunityHealthFiles represents the different files in the community health metrics response.
23 | type CommunityHealthFiles struct {
24 | CodeOfConduct *Metric `json:"code_of_conduct"`
25 | Contributing *Metric `json:"contributing"`
26 | IssueTemplate *Metric `json:"issue_template"`
27 | PullRequestTemplate *Metric `json:"pull_request_template"`
28 | License *Metric `json:"license"`
29 | Readme *Metric `json:"readme"`
30 | }
31 |
32 | // CommunityHealthMetrics represents a response containing the community metrics of a repository.
33 | type CommunityHealthMetrics struct {
34 | HealthPercentage *int `json:"health_percentage"`
35 | Files *CommunityHealthFiles `json:"files"`
36 | UpdatedAt *time.Time `json:"updated_at"`
37 | }
38 |
39 | // GetCommunityHealthMetrics retrieves all the community health metrics for a repository.
40 | //
41 | // GitHub API docs: https://developer.github.com/v3/repos/community/#retrieve-community-health-metrics
42 | func (s *RepositoriesService) GetCommunityHealthMetrics(ctx context.Context, owner, repo string) (*CommunityHealthMetrics, *Response, error) {
43 | u := fmt.Sprintf("repos/%v/%v/community/profile", owner, repo)
44 | req, err := s.client.NewRequest("GET", u, nil)
45 | if err != nil {
46 | return nil, nil, err
47 | }
48 |
49 | // TODO: remove custom Accept header when this API fully launches.
50 | req.Header.Set("Accept", mediaTypeRepositoryCommunityHealthMetricsPreview)
51 |
52 | metrics := &CommunityHealthMetrics{}
53 | resp, err := s.client.Do(ctx, req, metrics)
54 | if err != nil {
55 | return nil, resp, err
56 | }
57 |
58 | return metrics, resp, nil
59 | }
60 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/repos_merging.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | )
12 |
13 | // RepositoryMergeRequest represents a request to merge a branch in a
14 | // repository.
15 | type RepositoryMergeRequest struct {
16 | Base *string `json:"base,omitempty"`
17 | Head *string `json:"head,omitempty"`
18 | CommitMessage *string `json:"commit_message,omitempty"`
19 | }
20 |
21 | // Merge a branch in the specified repository.
22 | //
23 | // GitHub API docs: https://developer.github.com/v3/repos/merging/#perform-a-merge
24 | func (s *RepositoriesService) Merge(ctx context.Context, owner, repo string, request *RepositoryMergeRequest) (*RepositoryCommit, *Response, error) {
25 | u := fmt.Sprintf("repos/%v/%v/merges", owner, repo)
26 | req, err := s.client.NewRequest("POST", u, request)
27 | if err != nil {
28 | return nil, nil, err
29 | }
30 |
31 | commit := new(RepositoryCommit)
32 | resp, err := s.client.Do(ctx, req, commit)
33 | if err != nil {
34 | return nil, resp, err
35 | }
36 |
37 | return commit, resp, nil
38 | }
39 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/repos_projects.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | )
12 |
13 | // ProjectListOptions specifies the optional parameters to the
14 | // OrganizationsService.ListProjects and RepositoriesService.ListProjects methods.
15 | type ProjectListOptions struct {
16 | // Indicates the state of the projects to return. Can be either open, closed, or all. Default: open
17 | State string `url:"state,omitempty"`
18 |
19 | ListOptions
20 | }
21 |
22 | // ListProjects lists the projects for a repo.
23 | //
24 | // GitHub API docs: https://developer.github.com/v3/projects/#list-repository-projects
25 | func (s *RepositoriesService) ListProjects(ctx context.Context, owner, repo string, opt *ProjectListOptions) ([]*Project, *Response, error) {
26 | u := fmt.Sprintf("repos/%v/%v/projects", owner, repo)
27 | u, err := addOptions(u, opt)
28 | if err != nil {
29 | return nil, nil, err
30 | }
31 |
32 | req, err := s.client.NewRequest("GET", u, nil)
33 | if err != nil {
34 | return nil, nil, err
35 | }
36 |
37 | // TODO: remove custom Accept headers when APIs fully launch.
38 | req.Header.Set("Accept", mediaTypeProjectsPreview)
39 |
40 | var projects []*Project
41 | resp, err := s.client.Do(ctx, req, &projects)
42 | if err != nil {
43 | return nil, resp, err
44 | }
45 |
46 | return projects, resp, nil
47 | }
48 |
49 | // CreateProject creates a GitHub Project for the specified repository.
50 | //
51 | // GitHub API docs: https://developer.github.com/v3/projects/#create-a-repository-project
52 | func (s *RepositoriesService) CreateProject(ctx context.Context, owner, repo string, opt *ProjectOptions) (*Project, *Response, error) {
53 | u := fmt.Sprintf("repos/%v/%v/projects", owner, repo)
54 | req, err := s.client.NewRequest("POST", u, opt)
55 | if err != nil {
56 | return nil, nil, err
57 | }
58 |
59 | // TODO: remove custom Accept headers when APIs fully launch.
60 | req.Header.Set("Accept", mediaTypeProjectsPreview)
61 |
62 | project := &Project{}
63 | resp, err := s.client.Do(ctx, req, project)
64 | if err != nil {
65 | return nil, resp, err
66 | }
67 |
68 | return project, resp, nil
69 | }
70 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/strings.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "bytes"
10 | "fmt"
11 | "io"
12 |
13 | "reflect"
14 | )
15 |
16 | var timestampType = reflect.TypeOf(Timestamp{})
17 |
18 | // Stringify attempts to create a reasonable string representation of types in
19 | // the GitHub library. It does things like resolve pointers to their values
20 | // and omits struct fields with nil values.
21 | func Stringify(message interface{}) string {
22 | var buf bytes.Buffer
23 | v := reflect.ValueOf(message)
24 | stringifyValue(&buf, v)
25 | return buf.String()
26 | }
27 |
28 | // stringifyValue was heavily inspired by the goprotobuf library.
29 |
30 | func stringifyValue(w io.Writer, val reflect.Value) {
31 | if val.Kind() == reflect.Ptr && val.IsNil() {
32 | w.Write([]byte(""))
33 | return
34 | }
35 |
36 | v := reflect.Indirect(val)
37 |
38 | switch v.Kind() {
39 | case reflect.String:
40 | fmt.Fprintf(w, `"%s"`, v)
41 | case reflect.Slice:
42 | w.Write([]byte{'['})
43 | for i := 0; i < v.Len(); i++ {
44 | if i > 0 {
45 | w.Write([]byte{' '})
46 | }
47 |
48 | stringifyValue(w, v.Index(i))
49 | }
50 |
51 | w.Write([]byte{']'})
52 | return
53 | case reflect.Struct:
54 | if v.Type().Name() != "" {
55 | w.Write([]byte(v.Type().String()))
56 | }
57 |
58 | // special handling of Timestamp values
59 | if v.Type() == timestampType {
60 | fmt.Fprintf(w, "{%s}", v.Interface())
61 | return
62 | }
63 |
64 | w.Write([]byte{'{'})
65 |
66 | var sep bool
67 | for i := 0; i < v.NumField(); i++ {
68 | fv := v.Field(i)
69 | if fv.Kind() == reflect.Ptr && fv.IsNil() {
70 | continue
71 | }
72 | if fv.Kind() == reflect.Slice && fv.IsNil() {
73 | continue
74 | }
75 |
76 | if sep {
77 | w.Write([]byte(", "))
78 | } else {
79 | sep = true
80 | }
81 |
82 | w.Write([]byte(v.Type().Field(i).Name))
83 | w.Write([]byte{':'})
84 | stringifyValue(w, fv)
85 | }
86 |
87 | w.Write([]byte{'}'})
88 | default:
89 | if v.CanInterface() {
90 | fmt.Fprint(w, v.Interface())
91 | }
92 | }
93 | }
94 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/timestamp.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "strconv"
10 | "time"
11 | )
12 |
13 | // Timestamp represents a time that can be unmarshalled from a JSON string
14 | // formatted as either an RFC3339 or Unix timestamp. This is necessary for some
15 | // fields since the GitHub API is inconsistent in how it represents times. All
16 | // exported methods of time.Time can be called on Timestamp.
17 | type Timestamp struct {
18 | time.Time
19 | }
20 |
21 | func (t Timestamp) String() string {
22 | return t.Time.String()
23 | }
24 |
25 | // UnmarshalJSON implements the json.Unmarshaler interface.
26 | // Time is expected in RFC3339 or Unix format.
27 | func (t *Timestamp) UnmarshalJSON(data []byte) (err error) {
28 | str := string(data)
29 | i, err := strconv.ParseInt(str, 10, 64)
30 | if err == nil {
31 | t.Time = time.Unix(i, 0)
32 | } else {
33 | t.Time, err = time.Parse(`"`+time.RFC3339+`"`, str)
34 | }
35 | return
36 | }
37 |
38 | // Equal reports whether t and u are equal based on time.Equal
39 | func (t Timestamp) Equal(u Timestamp) bool {
40 | return t.Time.Equal(u.Time)
41 | }
42 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/users_administration.go:
--------------------------------------------------------------------------------
1 | // Copyright 2014 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import (
9 | "context"
10 | "fmt"
11 | )
12 |
13 | // PromoteSiteAdmin promotes a user to a site administrator of a GitHub Enterprise instance.
14 | //
15 | // GitHub API docs: https://developer.github.com/v3/users/administration/#promote-an-ordinary-user-to-a-site-administrator
16 | func (s *UsersService) PromoteSiteAdmin(ctx context.Context, user string) (*Response, error) {
17 | u := fmt.Sprintf("users/%v/site_admin", user)
18 |
19 | req, err := s.client.NewRequest("PUT", u, nil)
20 | if err != nil {
21 | return nil, err
22 | }
23 |
24 | return s.client.Do(ctx, req, nil)
25 | }
26 |
27 | // DemoteSiteAdmin demotes a user from site administrator of a GitHub Enterprise instance.
28 | //
29 | // GitHub API docs: https://developer.github.com/v3/users/administration/#demote-a-site-administrator-to-an-ordinary-user
30 | func (s *UsersService) DemoteSiteAdmin(ctx context.Context, user string) (*Response, error) {
31 | u := fmt.Sprintf("users/%v/site_admin", user)
32 |
33 | req, err := s.client.NewRequest("DELETE", u, nil)
34 | if err != nil {
35 | return nil, err
36 | }
37 |
38 | return s.client.Do(ctx, req, nil)
39 | }
40 |
41 | // Suspend a user on a GitHub Enterprise instance.
42 | //
43 | // GitHub API docs: https://developer.github.com/v3/users/administration/#suspend-a-user
44 | func (s *UsersService) Suspend(ctx context.Context, user string) (*Response, error) {
45 | u := fmt.Sprintf("users/%v/suspended", user)
46 |
47 | req, err := s.client.NewRequest("PUT", u, nil)
48 | if err != nil {
49 | return nil, err
50 | }
51 |
52 | return s.client.Do(ctx, req, nil)
53 | }
54 |
55 | // Unsuspend a user on a GitHub Enterprise instance.
56 | //
57 | // GitHub API docs: https://developer.github.com/v3/users/administration/#unsuspend-a-user
58 | func (s *UsersService) Unsuspend(ctx context.Context, user string) (*Response, error) {
59 | u := fmt.Sprintf("users/%v/suspended", user)
60 |
61 | req, err := s.client.NewRequest("DELETE", u, nil)
62 | if err != nil {
63 | return nil, err
64 | }
65 |
66 | return s.client.Do(ctx, req, nil)
67 | }
68 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/users_emails.go:
--------------------------------------------------------------------------------
1 | // Copyright 2013 The go-github AUTHORS. All rights reserved.
2 | //
3 | // Use of this source code is governed by a BSD-style
4 | // license that can be found in the LICENSE file.
5 |
6 | package github
7 |
8 | import "context"
9 |
10 | // UserEmail represents user's email address
11 | type UserEmail struct {
12 | Email *string `json:"email,omitempty"`
13 | Primary *bool `json:"primary,omitempty"`
14 | Verified *bool `json:"verified,omitempty"`
15 | }
16 |
17 | // ListEmails lists all email addresses for the authenticated user.
18 | //
19 | // GitHub API docs: https://developer.github.com/v3/users/emails/#list-email-addresses-for-a-user
20 | func (s *UsersService) ListEmails(ctx context.Context, opt *ListOptions) ([]*UserEmail, *Response, error) {
21 | u := "user/emails"
22 | u, err := addOptions(u, opt)
23 | if err != nil {
24 | return nil, nil, err
25 | }
26 |
27 | req, err := s.client.NewRequest("GET", u, nil)
28 | if err != nil {
29 | return nil, nil, err
30 | }
31 |
32 | var emails []*UserEmail
33 | resp, err := s.client.Do(ctx, req, &emails)
34 | if err != nil {
35 | return nil, resp, err
36 | }
37 |
38 | return emails, resp, nil
39 | }
40 |
41 | // AddEmails adds email addresses of the authenticated user.
42 | //
43 | // GitHub API docs: https://developer.github.com/v3/users/emails/#add-email-addresses
44 | func (s *UsersService) AddEmails(ctx context.Context, emails []string) ([]*UserEmail, *Response, error) {
45 | u := "user/emails"
46 | req, err := s.client.NewRequest("POST", u, emails)
47 | if err != nil {
48 | return nil, nil, err
49 | }
50 |
51 | var e []*UserEmail
52 | resp, err := s.client.Do(ctx, req, &e)
53 | if err != nil {
54 | return nil, resp, err
55 | }
56 |
57 | return e, resp, nil
58 | }
59 |
60 | // DeleteEmails deletes email addresses from authenticated user.
61 | //
62 | // GitHub API docs: https://developer.github.com/v3/users/emails/#delete-email-addresses
63 | func (s *UsersService) DeleteEmails(ctx context.Context, emails []string) (*Response, error) {
64 | u := "user/emails"
65 | req, err := s.client.NewRequest("DELETE", u, emails)
66 | if err != nil {
67 | return nil, err
68 | }
69 |
70 | return s.client.Do(ctx, req, nil)
71 | }
72 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/with_appengine.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The go-github AUTHORS. All rights reserved.
2 | //
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 | // This file provides glue for making github work on App Engine.
9 |
10 | package github
11 |
12 | import (
13 | "context"
14 | "net/http"
15 | )
16 |
17 | func withContext(ctx context.Context, req *http.Request) *http.Request {
18 | // No-op because App Engine adds context to a request differently.
19 | return req
20 | }
21 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-github/github/without_appengine.go:
--------------------------------------------------------------------------------
1 | // Copyright 2017 The go-github AUTHORS. All rights reserved.
2 | //
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 | // This file provides glue for making github work without App Engine.
9 |
10 | package github
11 |
12 | import (
13 | "context"
14 | "net/http"
15 | )
16 |
17 | func withContext(ctx context.Context, req *http.Request) *http.Request {
18 | return req.WithContext(ctx)
19 | }
20 |
--------------------------------------------------------------------------------
/vendor/github.com/google/go-querystring/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2013 Google. 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/inconshreveable/mousetrap/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright 2014 Alan Shreve
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 |
--------------------------------------------------------------------------------
/vendor/github.com/inconshreveable/mousetrap/README.md:
--------------------------------------------------------------------------------
1 | # mousetrap
2 |
3 | mousetrap is a tiny library that answers a single question.
4 |
5 | On a Windows machine, was the process invoked by someone double clicking on
6 | the executable file while browsing in explorer?
7 |
8 | ### Motivation
9 |
10 | Windows developers unfamiliar with command line tools will often "double-click"
11 | the executable for a tool. Because most CLI tools print the help and then exit
12 | when invoked without arguments, this is often very frustrating for those users.
13 |
14 | mousetrap provides a way to detect these invocations so that you can provide
15 | more helpful behavior and instructions on how to run the CLI tool. To see what
16 | this looks like, both from an organizational and a technical perspective, see
17 | https://inconshreveable.com/09-09-2014/sweat-the-small-stuff/
18 |
19 | ### The interface
20 |
21 | The library exposes a single interface:
22 |
23 | func StartedByExplorer() (bool)
24 |
--------------------------------------------------------------------------------
/vendor/github.com/inconshreveable/mousetrap/trap_others.go:
--------------------------------------------------------------------------------
1 | // +build !windows
2 |
3 | package mousetrap
4 |
5 | // StartedByExplorer returns true if the program was invoked by the user
6 | // double-clicking on the executable from explorer.exe
7 | //
8 | // It is conservative and returns false if any of the internal calls fail.
9 | // It does not guarantee that the program was run from a terminal. It only can tell you
10 | // whether it was launched from explorer.exe
11 | //
12 | // On non-Windows platforms, it always returns false.
13 | func StartedByExplorer() bool {
14 | return false
15 | }
16 |
--------------------------------------------------------------------------------
/vendor/github.com/inconshreveable/mousetrap/trap_windows.go:
--------------------------------------------------------------------------------
1 | // +build windows
2 | // +build !go1.4
3 |
4 | package mousetrap
5 |
6 | import (
7 | "fmt"
8 | "os"
9 | "syscall"
10 | "unsafe"
11 | )
12 |
13 | const (
14 | // defined by the Win32 API
15 | th32cs_snapprocess uintptr = 0x2
16 | )
17 |
18 | var (
19 | kernel = syscall.MustLoadDLL("kernel32.dll")
20 | CreateToolhelp32Snapshot = kernel.MustFindProc("CreateToolhelp32Snapshot")
21 | Process32First = kernel.MustFindProc("Process32FirstW")
22 | Process32Next = kernel.MustFindProc("Process32NextW")
23 | )
24 |
25 | // ProcessEntry32 structure defined by the Win32 API
26 | type processEntry32 struct {
27 | dwSize uint32
28 | cntUsage uint32
29 | th32ProcessID uint32
30 | th32DefaultHeapID int
31 | th32ModuleID uint32
32 | cntThreads uint32
33 | th32ParentProcessID uint32
34 | pcPriClassBase int32
35 | dwFlags uint32
36 | szExeFile [syscall.MAX_PATH]uint16
37 | }
38 |
39 | func getProcessEntry(pid int) (pe *processEntry32, err error) {
40 | snapshot, _, e1 := CreateToolhelp32Snapshot.Call(th32cs_snapprocess, uintptr(0))
41 | if snapshot == uintptr(syscall.InvalidHandle) {
42 | err = fmt.Errorf("CreateToolhelp32Snapshot: %v", e1)
43 | return
44 | }
45 | defer syscall.CloseHandle(syscall.Handle(snapshot))
46 |
47 | var processEntry processEntry32
48 | processEntry.dwSize = uint32(unsafe.Sizeof(processEntry))
49 | ok, _, e1 := Process32First.Call(snapshot, uintptr(unsafe.Pointer(&processEntry)))
50 | if ok == 0 {
51 | err = fmt.Errorf("Process32First: %v", e1)
52 | return
53 | }
54 |
55 | for {
56 | if processEntry.th32ProcessID == uint32(pid) {
57 | pe = &processEntry
58 | return
59 | }
60 |
61 | ok, _, e1 = Process32Next.Call(snapshot, uintptr(unsafe.Pointer(&processEntry)))
62 | if ok == 0 {
63 | err = fmt.Errorf("Process32Next: %v", e1)
64 | return
65 | }
66 | }
67 | }
68 |
69 | func getppid() (pid int, err error) {
70 | pe, err := getProcessEntry(os.Getpid())
71 | if err != nil {
72 | return
73 | }
74 |
75 | pid = int(pe.th32ParentProcessID)
76 | return
77 | }
78 |
79 | // StartedByExplorer returns true if the program was invoked by the user double-clicking
80 | // on the executable from explorer.exe
81 | //
82 | // It is conservative and returns false if any of the internal calls fail.
83 | // It does not guarantee that the program was run from a terminal. It only can tell you
84 | // whether it was launched from explorer.exe
85 | func StartedByExplorer() bool {
86 | ppid, err := getppid()
87 | if err != nil {
88 | return false
89 | }
90 |
91 | pe, err := getProcessEntry(ppid)
92 | if err != nil {
93 | return false
94 | }
95 |
96 | name := syscall.UTF16ToString(pe.szExeFile[:])
97 | return name == "explorer.exe"
98 | }
99 |
--------------------------------------------------------------------------------
/vendor/github.com/inconshreveable/mousetrap/trap_windows_1.4.go:
--------------------------------------------------------------------------------
1 | // +build windows
2 | // +build go1.4
3 |
4 | package mousetrap
5 |
6 | import (
7 | "os"
8 | "syscall"
9 | "unsafe"
10 | )
11 |
12 | func getProcessEntry(pid int) (*syscall.ProcessEntry32, error) {
13 | snapshot, err := syscall.CreateToolhelp32Snapshot(syscall.TH32CS_SNAPPROCESS, 0)
14 | if err != nil {
15 | return nil, err
16 | }
17 | defer syscall.CloseHandle(snapshot)
18 | var procEntry syscall.ProcessEntry32
19 | procEntry.Size = uint32(unsafe.Sizeof(procEntry))
20 | if err = syscall.Process32First(snapshot, &procEntry); err != nil {
21 | return nil, err
22 | }
23 | for {
24 | if procEntry.ProcessID == uint32(pid) {
25 | return &procEntry, nil
26 | }
27 | err = syscall.Process32Next(snapshot, &procEntry)
28 | if err != nil {
29 | return nil, err
30 | }
31 | }
32 | }
33 |
34 | // StartedByExplorer returns true if the program was invoked by the user double-clicking
35 | // on the executable from explorer.exe
36 | //
37 | // It is conservative and returns false if any of the internal calls fail.
38 | // It does not guarantee that the program was run from a terminal. It only can tell you
39 | // whether it was launched from explorer.exe
40 | func StartedByExplorer() bool {
41 | pe, err := getProcessEntry(os.Getppid())
42 | if err != nil {
43 | return false
44 | }
45 | return "explorer.exe" == syscall.UTF16ToString(pe.ExeFile[:])
46 | }
47 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/Gopkg.lock:
--------------------------------------------------------------------------------
1 | # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
2 |
3 |
4 | [[projects]]
5 | branch = "master"
6 | name = "github.com/CrowdSurge/banner"
7 | packages = [".","fonts"]
8 | revision = "8c0e79dc5ff70fb2919f0d662f44fd72ccdf9be2"
9 |
10 | [[projects]]
11 | name = "github.com/mattn/go-colorable"
12 | packages = ["."]
13 | revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
14 | version = "v0.0.9"
15 |
16 | [[projects]]
17 | name = "github.com/mattn/go-isatty"
18 | packages = ["."]
19 | revision = "fc9e8d8ef48496124e79ae0df75490096eccf6fe"
20 | version = "v0.0.2"
21 |
22 | [[projects]]
23 | branch = "master"
24 | name = "golang.org/x/sys"
25 | packages = ["unix"]
26 | revision = "e42485b6e20ae7d2304ec72e535b103ed350cc02"
27 |
28 | [solve-meta]
29 | analyzer-name = "dep"
30 | analyzer-version = 1
31 | inputs-digest = "62e505d253abb5182341a550e55ec60aa59bfd5411fd080c9cc4852a14cd5ef7"
32 | solver-name = "gps-cdcl"
33 | solver-version = 1
34 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/README.md:
--------------------------------------------------------------------------------
1 | # lolgopher
2 |
3 | 
4 |
5 | Rainbow Writer implementation for Golang
6 |
7 | Based on https://github.com/busyloop/lolcat.
8 |
9 | 
Proudly packaged with Golang [dep](https://github.com/golang/dep)
10 |
11 | ## Installing
12 |
13 | ```
14 | $ go get github.com/kris-nova/lolgopher
15 | ```
16 |
17 | ##### From Source
18 |
19 | ```
20 | cd $GOPATH/src/github.com/kris-nova/lolgopher
21 | go install .
22 | ```
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/color.go:
--------------------------------------------------------------------------------
1 | package lol
2 |
3 | // colorer is an interface that can be used to colorize an io.Writer. Each
4 | // colorer is designed to support a specific terminal color schema (256, 0, etc).
5 | type colorer interface {
6 |
7 | // Rainbow will calculate the current color spectrum for RGB colors only.
8 | // Each implementation other than truecolor will need to implement rainbow
9 | // and handle it accordingly.
10 | rainbow(freq float64, i float64)
11 |
12 | // Return the ASCII escape code for this color for this particular byte
13 | format() []byte
14 |
15 | // Reset the most recent ASCII code opened
16 | reset() []byte
17 | }
18 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/color_0.go:
--------------------------------------------------------------------------------
1 | package lol
2 |
3 | type color0 struct {
4 | R, G, B uint8
5 | }
6 |
7 | func (c *color0) rainbow(freq float64, i float64) {
8 | // No calculation for no color support
9 | }
10 |
11 | func (c *color0) format() []byte {
12 | return []byte("")
13 | }
14 |
15 | func (c *color0) reset() []byte {
16 | return []byte("")
17 | }
18 |
19 | func New0Colorer() colorer {
20 | return &color0{}
21 | }
22 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/color_256.go:
--------------------------------------------------------------------------------
1 | package lol
2 |
3 | import (
4 | "fmt"
5 | "math"
6 | )
7 |
8 | type color256 struct {
9 | R, G, B uint8
10 | }
11 |
12 | func (c *color256) rainbow(freq float64, i float64) {
13 | c.R = uint8(math.Floor(math.Sin(freq*i+0)*127)) + 128
14 | c.G = uint8(math.Floor(math.Sin(freq*i+2.0*math.Pi/3.0)*127)) + 128
15 | c.B = uint8(math.Floor(math.Sin(freq*i+4.0*math.Pi/3.0)*127)) + 128
16 | }
17 |
18 | func (c *color256) format() []byte {
19 |
20 | // Support for grayscale colors
21 | if c.R == c.G && c.G == c.B && int(c.R) > 232 {
22 | return []byte(fmt.Sprintf("\x1b[38;5;%dm", int(c.R)))
23 | }
24 |
25 | // Math for 256: We use the closest value possible
26 | r6 := (uint16(c.R) * 3) / 255
27 | g6 := (uint16(c.G) * 3) / 255
28 | b6 := (uint16(c.B) * 3) / 255
29 | i := 36*r6 + 6*g6 + b6
30 | return []byte(fmt.Sprintf("\x1b[38;5;%dm", i))
31 | }
32 |
33 | func (c *color256) reset() []byte {
34 | return []byte("\x1b[0m")
35 | }
36 |
37 | func New256Colorer() colorer {
38 | return &color256{}
39 | }
40 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/color_truecolor.go:
--------------------------------------------------------------------------------
1 | package lol
2 |
3 | import (
4 | "fmt"
5 | "math"
6 | )
7 |
8 | type truecolor struct {
9 | R, G, B uint8
10 | }
11 |
12 | func (c *truecolor) rainbow(freq float64, i float64) {
13 | c.R = uint8(math.Floor(math.Sin(freq*i+0)*127)) + 128
14 | c.G = uint8(math.Floor(math.Sin(freq*i+2.0*math.Pi/3.0)*127)) + 128
15 | c.B = uint8(math.Floor(math.Sin(freq*i+4.0*math.Pi/3.0)*127)) + 128
16 | }
17 |
18 | func (c *truecolor) format() []byte {
19 | return []byte(fmt.Sprintf("\x1b[38;2;%d;%d;%dm", c.R, c.G, c.B))
20 | }
21 |
22 | func (c *truecolor) reset() []byte {
23 | return []byte("\x1b[0m")
24 | }
25 |
26 | func newTruecolorColorer() colorer {
27 | return &truecolor{}
28 | }
29 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/output.go:
--------------------------------------------------------------------------------
1 | // +build !windows
2 |
3 | package lol
4 |
5 | import "os"
6 |
7 | var stdout = os.Stdout
8 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/output_windows.go:
--------------------------------------------------------------------------------
1 | // +build windows
2 |
3 | package lol
4 |
5 | import colorable "github.com/mattn/go-colorable"
6 |
7 | var stdout = colorable.NewColorableStdout()
8 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/lolgopher/print.go:
--------------------------------------------------------------------------------
1 | package lol
2 |
3 | import (
4 | "fmt"
5 | )
6 |
7 | var w = &Writer{Output: stdout, ColorMode: ColorMode256}
8 |
9 | func Println(a ...interface{}) (n int, err error) {
10 | return fmt.Fprintln(w, a...)
11 | }
12 |
13 | func Printf(format string, a ...interface{}) (n int, err error) {
14 | return fmt.Fprintf(w, format, a...)
15 | }
16 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/rebrandly-go-sdk/README.md:
--------------------------------------------------------------------------------
1 | # rebrandly-go-sdk
2 |
3 | A Go SDK for the Rebrandly API
4 |
5 |
6 | # Authenticating
7 |
8 | Create a new API key from the Rebrandly dashboard, and export as the environmental variable `REBRANDLY_API_KEY`
9 |
10 | ```bash
11 |
12 | export REBRANDLY_API_KEY="YOUR_API_KEY"
13 | ```
14 |
15 | # Status
16 |
17 | Right now only basic endpoints are baked into the SDK, but the framework is in place that makes it extremely easy to add other endpoints.
18 |
19 | If there is an endpoint you need, just ping me (Kris Nova) or just open a PR.
20 |
21 | # Parameters
22 |
23 | Some of the SDK functions accept `params` which maps to the accepted to parameters in the Rebrandly documentation [here](https://developers.rebrandly.com/docs)
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/rebrandly-go-sdk/account.go:
--------------------------------------------------------------------------------
1 | package rebrandly_go_sdk
2 |
3 | func (c *rebrandlyClient) GetAccount() (*rebrandlyResponse, error) {
4 | req := &rebrandlyRequest{
5 | method: GET,
6 | endpoint: "/v1/account",
7 | apiKey: c.apiKey,
8 | }
9 | resp, err := req.execute()
10 | if err != nil {
11 | return nil, err
12 | }
13 | return &rebrandlyResponse{
14 | Response: resp,
15 | }, nil
16 | }
17 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/rebrandly-go-sdk/client.go:
--------------------------------------------------------------------------------
1 | package rebrandly_go_sdk
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | )
7 |
8 | const (
9 | REBRANDLY_API_KEY_VARIABLE_NAME = "REBRANDLY_API_KEY"
10 | )
11 |
12 | type rebrandlyClient struct {
13 | apiKey string
14 | }
15 |
16 | // NewRebrandlyClient authenticates a new Rebrandly client. This
17 | // function expects the environmental variable `REBRANDLY_API_KEY`
18 | // to be set, or will error.
19 | func NewRebrandlyClient() (*rebrandlyClient, error) {
20 |
21 | apiKey := os.Getenv(REBRANDLY_API_KEY_VARIABLE_NAME)
22 | if apiKey == "" {
23 | return nil, fmt.Errorf("empty api key, please set REBRANDLY_API_KEY")
24 | }
25 | if len(apiKey) != 32 {
26 | return nil, fmt.Errorf("invalid api key, key must be 32 characters long")
27 | }
28 | return &rebrandlyClient{
29 | apiKey: apiKey,
30 | }, nil
31 | }
32 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/rebrandly-go-sdk/domains.go:
--------------------------------------------------------------------------------
1 | package rebrandly_go_sdk
2 |
3 | import "fmt"
4 |
5 | func (c *rebrandlyClient) ListDomains() (*rebrandlyResponse, error) {
6 | req := &rebrandlyRequest{
7 | method: GET,
8 | endpoint: "/v1/domains",
9 | apiKey: c.apiKey,
10 | }
11 | resp, err := req.execute()
12 | if err != nil {
13 | return nil, err
14 | }
15 | return &rebrandlyResponse{
16 | Response: resp,
17 | }, nil
18 | }
19 |
20 | func (c *rebrandlyClient) GetDomain(params rebrandlyParamters) (*rebrandlyResponse, error) {
21 | req := &rebrandlyRequest{
22 | method: GET,
23 | endpoint: fmt.Sprintf("/v1/domains"),
24 | apiKey: c.apiKey,
25 | params: params,
26 | }
27 | resp, err := req.execute()
28 | if err != nil {
29 | return nil, err
30 | }
31 | return &rebrandlyResponse{
32 | Response: resp,
33 | }, nil
34 | }
35 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/rebrandly-go-sdk/links.go:
--------------------------------------------------------------------------------
1 | package rebrandly_go_sdk
2 |
3 | import "fmt"
4 |
5 | func (c *rebrandlyClient) CreateLink(params rebrandlyParamters) (*rebrandlyResponse, error) {
6 | req := &rebrandlyRequest{
7 | method: POST,
8 | endpoint: fmt.Sprintf("/v1/links/"),
9 | apiKey: c.apiKey,
10 | params: params,
11 | }
12 | resp, err := req.execute()
13 | if err != nil {
14 | return nil, err
15 | }
16 | return &rebrandlyResponse{
17 | Response: resp,
18 | }, nil
19 | }
20 |
21 | func (c *rebrandlyClient) ListLinks(params rebrandlyParamters) (*rebrandlyResponse, error) {
22 | req := &rebrandlyRequest{
23 | method: GET,
24 | endpoint: fmt.Sprintf("/v1/links/"),
25 | apiKey: c.apiKey,
26 | params: params,
27 | }
28 | resp, err := req.execute()
29 | if err != nil {
30 | return nil, err
31 | }
32 | return &rebrandlyResponse{
33 | Response: resp,
34 | }, nil
35 | }
36 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/rebrandly-go-sdk/request.go:
--------------------------------------------------------------------------------
1 | package rebrandly_go_sdk
2 |
3 | import (
4 | "fmt"
5 | "net/http"
6 |
7 | "bytes"
8 | "encoding/json"
9 |
10 | "github.com/kubicorn/kubicorn/pkg/logger"
11 | )
12 |
13 | type rebrandlyHTTPMethod string
14 |
15 | const (
16 | GET rebrandlyHTTPMethod = "get"
17 | POST rebrandlyHTTPMethod = "post"
18 | rebrandlyAPI = "https://api.rebrandly.com"
19 | )
20 |
21 | type rebrandlyRequest struct {
22 | method rebrandlyHTTPMethod
23 | endpoint string
24 | apiKey string
25 | params rebrandlyParamters
26 | }
27 |
28 | type rebrandlyParamters map[string]interface{}
29 |
30 | // execute is the core of the SDK request engine. Here we hard
31 | // code a lot of logic that is specific to rebrandly.
32 | func (res *rebrandlyRequest) execute() (*http.Response, error) {
33 | if res.method == "" {
34 | return nil, fmt.Errorf("empty method for request")
35 | }
36 | if res.endpoint == "" {
37 | return nil, fmt.Errorf("empty endpoint for request")
38 | }
39 | if res.apiKey == "" {
40 | return nil, fmt.Errorf("empty apiKey for request")
41 | }
42 |
43 | // URI is the formatted resolvable uri for the request.
44 | // Use this in your request.
45 | // TODO: @kris-nova can we use a proper Join() here instead of Sprintf()
46 | uri := fmt.Sprintf("%s%s", rebrandlyAPI, res.endpoint)
47 | logger.Info("path: %s", uri)
48 | switch res.method {
49 |
50 | // GET will send a GET request, here we hard code Content-Type and apiKey headers.
51 | case GET:
52 |
53 | // Create the body string, we hard code JSON
54 | jsonBodyBytes, err := json.Marshal(res.params)
55 | if err != nil {
56 | return nil, fmt.Errorf("unable to marshal JSON body: %v", err)
57 | }
58 |
59 | // Build the request
60 | client := &http.Client{}
61 | bodyBuffer := &bytes.Buffer{}
62 | bodyBuffer.Write(jsonBodyBytes)
63 |
64 | req, err := http.NewRequest("get", uri, nil)
65 | if err != nil {
66 | return nil, fmt.Errorf("unable to create new GET request: %v", err)
67 | }
68 | req.Header.Set("Content-Type", "application/json")
69 | req.Header.Set("apiKey", res.apiKey)
70 | return client.Do(req)
71 | case POST:
72 |
73 | // Create the body string, we hard code JSON
74 | jsonBodyBytes, err := json.Marshal(res.params)
75 | if err != nil {
76 | return nil, fmt.Errorf("unable to marshal JSON body: %v", err)
77 | }
78 |
79 | // Build the request
80 | client := &http.Client{}
81 | bodyBuffer := &bytes.Buffer{}
82 | bodyBuffer.Write(jsonBodyBytes)
83 | req, err := http.NewRequest("post", uri, bodyBuffer)
84 | if err != nil {
85 | return nil, fmt.Errorf("unable to create new POST request: %v", err)
86 | }
87 | req.Header.Set("Content-Type", "application/json")
88 | req.Header.Set("apiKey", res.apiKey)
89 | return client.Do(req)
90 | default:
91 | return nil, fmt.Errorf("missing or invalid method for request")
92 | }
93 |
94 | return nil, nil
95 |
96 | }
97 |
--------------------------------------------------------------------------------
/vendor/github.com/kris-nova/rebrandly-go-sdk/response.go:
--------------------------------------------------------------------------------
1 | package rebrandly_go_sdk
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "fmt"
7 | "io/ioutil"
8 | "net/http"
9 | )
10 |
11 | type rebrandlyResponse struct {
12 | Response *http.Response
13 | }
14 |
15 | func (r *rebrandlyResponse) Body() (string, error) {
16 | bodyData, err := ioutil.ReadAll(r.Response.Body)
17 | if err != nil {
18 | return "", fmt.Errorf("unable to parse body; %v", err)
19 | }
20 | return string(bodyData), nil
21 | }
22 |
23 | func (r *rebrandlyResponse) Pretty() (string, error) {
24 | bodyData, err := ioutil.ReadAll(r.Response.Body)
25 | if err != nil {
26 | return "", fmt.Errorf("unable to parse body; %v", err)
27 | }
28 | var out bytes.Buffer
29 | err = json.Indent(&out, bodyData, "", " ")
30 | if err != nil {
31 | return "", fmt.Errorf("unable to json ident: %v", err)
32 | }
33 | formattedBytes := out.Bytes()
34 | return string(formattedBytes), nil
35 | }
36 |
--------------------------------------------------------------------------------
/vendor/github.com/kubicorn/kubicorn/AUTHORS:
--------------------------------------------------------------------------------
1 | Ajit Kumar
2 | Alejandro Escobar
3 | Alex Tasioulis
4 | Andrés Alvarez
5 | Andy Goldstein
6 | Ann Hill
7 | Arpit Mohan
8 | Ashish Amarnath
9 | Avi Deitcher
10 | Balint Molnar
11 | Bo Ingram
12 | Brad Pinter
13 | Carolyn Van Slyck
14 | Curtis
15 | Darron Froese
16 | David E Watson
17 | Ellen Körbes
18 | Eric Hole
19 | Federico Minzoni
20 | Gar Morley
21 | Igor Vuk
22 | Jacopo Nardiello
23 | Jason DeTiberus
24 | Joe Beda
25 | Jonathan Frederickson
26 | Joshua Carp
27 | Kris Nova
28 | Lachlan Evenson
29 | Lakshman Ganesh Rajamani
30 | Lorenzo Fontana
31 | Mansour Rahimi
32 | Manuel de Brito Fontes
33 | Marcel
34 | Marcel
35 | Mario Mazo
36 | Mario Mazo
37 | Mark Ayers
38 | Marko Mudrinić
39 | Martin Etmajer
40 | Michael Hausenblas
41 | Michael Zamot
42 | Nolan Brubaker
43 | Nyah Check
44 | Paul Czarkowski
45 | Peter Smeets
46 | Prateek Gogia
47 | Prateek Gogia
48 | Robert Bailey
49 | S.Çağlar Onur
50 | Stefan Majer
51 | Steven Klassen
52 | Ted Wood
53 | Ulrich Schreiner
54 | William Stewart
55 | Xavier Lucas
56 | c-bata
57 | ellenkorbes
58 | fabriziopandini
59 | leigh schrandt
60 | liz
61 | matyix
62 | matyix
63 | name
64 | robjloranger
65 |
--------------------------------------------------------------------------------
/vendor/github.com/kubicorn/kubicorn/docs/LICENSE.txt:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2016 Parker Moore
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/mattn/go-colorable/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go:
3 | - tip
4 |
5 | before_install:
6 | - go get github.com/mattn/goveralls
7 | - go get golang.org/x/tools/cmd/cover
8 | script:
9 | - $HOME/gopath/bin/goveralls -repotoken xnXqRGwgW3SXIguzxf90ZSK1GPYZPaGrw
10 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-colorable/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2016 Yasuhiro Matsumoto
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 all
13 | 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 THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-colorable/README.md:
--------------------------------------------------------------------------------
1 | # go-colorable
2 |
3 | [](http://godoc.org/github.com/mattn/go-colorable)
4 | [](https://travis-ci.org/mattn/go-colorable)
5 | [](https://coveralls.io/github/mattn/go-colorable?branch=master)
6 | [](https://goreportcard.com/report/mattn/go-colorable)
7 |
8 | Colorable writer for windows.
9 |
10 | For example, most of logger packages doesn't show colors on windows. (I know we can do it with ansicon. But I don't want.)
11 | This package is possible to handle escape sequence for ansi color on windows.
12 |
13 | ## Too Bad!
14 |
15 | 
16 |
17 |
18 | ## So Good!
19 |
20 | 
21 |
22 | ## Usage
23 |
24 | ```go
25 | logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true})
26 | logrus.SetOutput(colorable.NewColorableStdout())
27 |
28 | logrus.Info("succeeded")
29 | logrus.Warn("not correct")
30 | logrus.Error("something error")
31 | logrus.Fatal("panic")
32 | ```
33 |
34 | You can compile above code on non-windows OSs.
35 |
36 | ## Installation
37 |
38 | ```
39 | $ go get github.com/mattn/go-colorable
40 | ```
41 |
42 | # License
43 |
44 | MIT
45 |
46 | # Author
47 |
48 | Yasuhiro Matsumoto (a.k.a mattn)
49 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-colorable/colorable_appengine.go:
--------------------------------------------------------------------------------
1 | // +build appengine
2 |
3 | package colorable
4 |
5 | import (
6 | "io"
7 | "os"
8 |
9 | _ "github.com/mattn/go-isatty"
10 | )
11 |
12 | // NewColorable return new instance of Writer which handle escape sequence.
13 | func NewColorable(file *os.File) io.Writer {
14 | if file == nil {
15 | panic("nil passed instead of *os.File to NewColorable()")
16 | }
17 |
18 | return file
19 | }
20 |
21 | // NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
22 | func NewColorableStdout() io.Writer {
23 | return os.Stdout
24 | }
25 |
26 | // NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
27 | func NewColorableStderr() io.Writer {
28 | return os.Stderr
29 | }
30 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-colorable/colorable_others.go:
--------------------------------------------------------------------------------
1 | // +build !windows
2 | // +build !appengine
3 |
4 | package colorable
5 |
6 | import (
7 | "io"
8 | "os"
9 |
10 | _ "github.com/mattn/go-isatty"
11 | )
12 |
13 | // NewColorable return new instance of Writer which handle escape sequence.
14 | func NewColorable(file *os.File) io.Writer {
15 | if file == nil {
16 | panic("nil passed instead of *os.File to NewColorable()")
17 | }
18 |
19 | return file
20 | }
21 |
22 | // NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
23 | func NewColorableStdout() io.Writer {
24 | return os.Stdout
25 | }
26 |
27 | // NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
28 | func NewColorableStderr() io.Writer {
29 | return os.Stderr
30 | }
31 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-colorable/noncolorable.go:
--------------------------------------------------------------------------------
1 | package colorable
2 |
3 | import (
4 | "bytes"
5 | "io"
6 | )
7 |
8 | // NonColorable hold writer but remove escape sequence.
9 | type NonColorable struct {
10 | out io.Writer
11 | }
12 |
13 | // NewNonColorable return new instance of Writer which remove escape sequence from Writer.
14 | func NewNonColorable(w io.Writer) io.Writer {
15 | return &NonColorable{out: w}
16 | }
17 |
18 | // Write write data on console
19 | func (w *NonColorable) Write(data []byte) (n int, err error) {
20 | er := bytes.NewReader(data)
21 | var bw [1]byte
22 | loop:
23 | for {
24 | c1, err := er.ReadByte()
25 | if err != nil {
26 | break loop
27 | }
28 | if c1 != 0x1b {
29 | bw[0] = c1
30 | w.out.Write(bw[:])
31 | continue
32 | }
33 | c2, err := er.ReadByte()
34 | if err != nil {
35 | break loop
36 | }
37 | if c2 != 0x5b {
38 | continue
39 | }
40 |
41 | var buf bytes.Buffer
42 | for {
43 | c, err := er.ReadByte()
44 | if err != nil {
45 | break loop
46 | }
47 | if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
48 | break
49 | }
50 | buf.Write([]byte(string(c)))
51 | }
52 | }
53 |
54 | return len(data), nil
55 | }
56 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go:
3 | - tip
4 |
5 | before_install:
6 | - go get github.com/mattn/goveralls
7 | - go get golang.org/x/tools/cmd/cover
8 | script:
9 | - $HOME/gopath/bin/goveralls -repotoken 3gHdORO5k5ziZcWMBxnd9LrMZaJs8m9x5
10 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) Yasuhiro MATSUMOTO
2 |
3 | MIT License (Expat)
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
6 |
7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
8 |
9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/README.md:
--------------------------------------------------------------------------------
1 | # go-isatty
2 |
3 | [](http://godoc.org/github.com/mattn/go-isatty)
4 | [](https://travis-ci.org/mattn/go-isatty)
5 | [](https://coveralls.io/github/mattn/go-isatty?branch=master)
6 | [](https://goreportcard.com/report/mattn/go-isatty)
7 |
8 | isatty for golang
9 |
10 | ## Usage
11 |
12 | ```go
13 | package main
14 |
15 | import (
16 | "fmt"
17 | "github.com/mattn/go-isatty"
18 | "os"
19 | )
20 |
21 | func main() {
22 | if isatty.IsTerminal(os.Stdout.Fd()) {
23 | fmt.Println("Is Terminal")
24 | } else if isatty.IsCygwinTerminal(os.Stdout.Fd()) {
25 | fmt.Println("Is Cygwin/MSYS2 Terminal")
26 | } else {
27 | fmt.Println("Is Not Terminal")
28 | }
29 | }
30 | ```
31 |
32 | ## Installation
33 |
34 | ```
35 | $ go get github.com/mattn/go-isatty
36 | ```
37 |
38 | ## License
39 |
40 | MIT
41 |
42 | ## Author
43 |
44 | Yasuhiro Matsumoto (a.k.a mattn)
45 |
46 | ## Thanks
47 |
48 | * k-takata: base idea for IsCygwinTerminal
49 |
50 | https://github.com/k-takata/go-iscygpty
51 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/doc.go:
--------------------------------------------------------------------------------
1 | // Package isatty implements interface to isatty
2 | package isatty
3 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/isatty_appengine.go:
--------------------------------------------------------------------------------
1 | // +build appengine
2 |
3 | package isatty
4 |
5 | // IsTerminal returns true if the file descriptor is terminal which
6 | // is always false on on appengine classic which is a sandboxed PaaS.
7 | func IsTerminal(fd uintptr) bool {
8 | return false
9 | }
10 |
11 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
12 | // terminal. This is also always false on this environment.
13 | func IsCygwinTerminal(fd uintptr) bool {
14 | return false
15 | }
16 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/isatty_bsd.go:
--------------------------------------------------------------------------------
1 | // +build darwin freebsd openbsd netbsd dragonfly
2 | // +build !appengine
3 |
4 | package isatty
5 |
6 | import (
7 | "syscall"
8 | "unsafe"
9 | )
10 |
11 | const ioctlReadTermios = syscall.TIOCGETA
12 |
13 | // IsTerminal return true if the file descriptor is terminal.
14 | func IsTerminal(fd uintptr) bool {
15 | var termios syscall.Termios
16 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
17 | return err == 0
18 | }
19 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/isatty_linux.go:
--------------------------------------------------------------------------------
1 | // +build linux
2 | // +build !appengine,!ppc64,!ppc64le
3 |
4 | package isatty
5 |
6 | import (
7 | "syscall"
8 | "unsafe"
9 | )
10 |
11 | const ioctlReadTermios = syscall.TCGETS
12 |
13 | // IsTerminal return true if the file descriptor is terminal.
14 | func IsTerminal(fd uintptr) bool {
15 | var termios syscall.Termios
16 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
17 | return err == 0
18 | }
19 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/isatty_linux_ppc64x.go:
--------------------------------------------------------------------------------
1 | // +build linux
2 | // +build ppc64 ppc64le
3 |
4 | package isatty
5 |
6 | import (
7 | "unsafe"
8 |
9 | syscall "golang.org/x/sys/unix"
10 | )
11 |
12 | const ioctlReadTermios = syscall.TCGETS
13 |
14 | // IsTerminal return true if the file descriptor is terminal.
15 | func IsTerminal(fd uintptr) bool {
16 | var termios syscall.Termios
17 | _, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
18 | return err == 0
19 | }
20 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/isatty_others.go:
--------------------------------------------------------------------------------
1 | // +build !windows
2 | // +build !appengine
3 |
4 | package isatty
5 |
6 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
7 | // terminal. This is also always false on this environment.
8 | func IsCygwinTerminal(fd uintptr) bool {
9 | return false
10 | }
11 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/isatty_solaris.go:
--------------------------------------------------------------------------------
1 | // +build solaris
2 | // +build !appengine
3 |
4 | package isatty
5 |
6 | import (
7 | "golang.org/x/sys/unix"
8 | )
9 |
10 | // IsTerminal returns true if the given file descriptor is a terminal.
11 | // see: http://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libbc/libc/gen/common/isatty.c
12 | func IsTerminal(fd uintptr) bool {
13 | var termio unix.Termio
14 | err := unix.IoctlSetTermio(int(fd), unix.TCGETA, &termio)
15 | return err == nil
16 | }
17 |
--------------------------------------------------------------------------------
/vendor/github.com/mattn/go-isatty/isatty_windows.go:
--------------------------------------------------------------------------------
1 | // +build windows
2 | // +build !appengine
3 |
4 | package isatty
5 |
6 | import (
7 | "strings"
8 | "syscall"
9 | "unicode/utf16"
10 | "unsafe"
11 | )
12 |
13 | const (
14 | fileNameInfo uintptr = 2
15 | fileTypePipe = 3
16 | )
17 |
18 | var (
19 | kernel32 = syscall.NewLazyDLL("kernel32.dll")
20 | procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
21 | procGetFileInformationByHandleEx = kernel32.NewProc("GetFileInformationByHandleEx")
22 | procGetFileType = kernel32.NewProc("GetFileType")
23 | )
24 |
25 | func init() {
26 | // Check if GetFileInformationByHandleEx is available.
27 | if procGetFileInformationByHandleEx.Find() != nil {
28 | procGetFileInformationByHandleEx = nil
29 | }
30 | }
31 |
32 | // IsTerminal return true if the file descriptor is terminal.
33 | func IsTerminal(fd uintptr) bool {
34 | var st uint32
35 | r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fd, uintptr(unsafe.Pointer(&st)), 0)
36 | return r != 0 && e == 0
37 | }
38 |
39 | // Check pipe name is used for cygwin/msys2 pty.
40 | // Cygwin/MSYS2 PTY has a name like:
41 | // \{cygwin,msys}-XXXXXXXXXXXXXXXX-ptyN-{from,to}-master
42 | func isCygwinPipeName(name string) bool {
43 | token := strings.Split(name, "-")
44 | if len(token) < 5 {
45 | return false
46 | }
47 |
48 | if token[0] != `\msys` && token[0] != `\cygwin` {
49 | return false
50 | }
51 |
52 | if token[1] == "" {
53 | return false
54 | }
55 |
56 | if !strings.HasPrefix(token[2], "pty") {
57 | return false
58 | }
59 |
60 | if token[3] != `from` && token[3] != `to` {
61 | return false
62 | }
63 |
64 | if token[4] != "master" {
65 | return false
66 | }
67 |
68 | return true
69 | }
70 |
71 | // IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
72 | // terminal.
73 | func IsCygwinTerminal(fd uintptr) bool {
74 | if procGetFileInformationByHandleEx == nil {
75 | return false
76 | }
77 |
78 | // Cygwin/msys's pty is a pipe.
79 | ft, _, e := syscall.Syscall(procGetFileType.Addr(), 1, fd, 0, 0)
80 | if ft != fileTypePipe || e != 0 {
81 | return false
82 | }
83 |
84 | var buf [2 + syscall.MAX_PATH]uint16
85 | r, _, e := syscall.Syscall6(procGetFileInformationByHandleEx.Addr(),
86 | 4, fd, fileNameInfo, uintptr(unsafe.Pointer(&buf)),
87 | uintptr(len(buf)*2), 0, 0)
88 | if r == 0 || e != 0 {
89 | return false
90 | }
91 |
92 | l := *(*uint32)(unsafe.Pointer(&buf))
93 | return isCygwinPipeName(string(utf16.Decode(buf[2 : 2+l/2])))
94 | }
95 |
--------------------------------------------------------------------------------
/vendor/github.com/pkg/errors/.gitignore:
--------------------------------------------------------------------------------
1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
2 | *.o
3 | *.a
4 | *.so
5 |
6 | # Folders
7 | _obj
8 | _test
9 |
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 |
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 |
20 | _testmain.go
21 |
22 | *.exe
23 | *.test
24 | *.prof
25 |
--------------------------------------------------------------------------------
/vendor/github.com/pkg/errors/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 | go_import_path: github.com/pkg/errors
3 | go:
4 | - 1.4.3
5 | - 1.5.4
6 | - 1.6.2
7 | - 1.7.1
8 | - tip
9 |
10 | script:
11 | - go test -v ./...
12 |
--------------------------------------------------------------------------------
/vendor/github.com/pkg/errors/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2015, Dave Cheney
2 | All rights reserved.
3 |
4 | Redistribution and use in source and binary forms, with or without
5 | modification, are permitted provided that the following conditions are met:
6 |
7 | * Redistributions of source code must retain the above copyright notice, this
8 | list of conditions and the following disclaimer.
9 |
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 | this list of conditions and the following disclaimer in the documentation
12 | and/or other materials provided with the distribution.
13 |
14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
18 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
20 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
21 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 |
--------------------------------------------------------------------------------
/vendor/github.com/pkg/errors/README.md:
--------------------------------------------------------------------------------
1 | # errors [](https://travis-ci.org/pkg/errors) [](https://ci.appveyor.com/project/davecheney/errors/branch/master) [](http://godoc.org/github.com/pkg/errors) [](https://goreportcard.com/report/github.com/pkg/errors)
2 |
3 | Package errors provides simple error handling primitives.
4 |
5 | `go get github.com/pkg/errors`
6 |
7 | The traditional error handling idiom in Go is roughly akin to
8 | ```go
9 | if err != nil {
10 | return err
11 | }
12 | ```
13 | which applied recursively up the call stack results in error reports without context or debugging information. The errors package allows programmers to add context to the failure path in their code in a way that does not destroy the original value of the error.
14 |
15 | ## Adding context to an error
16 |
17 | The errors.Wrap function returns a new error that adds context to the original error. For example
18 | ```go
19 | _, err := ioutil.ReadAll(r)
20 | if err != nil {
21 | return errors.Wrap(err, "read failed")
22 | }
23 | ```
24 | ## Retrieving the cause of an error
25 |
26 | Using `errors.Wrap` constructs a stack of errors, adding context to the preceding error. Depending on the nature of the error it may be necessary to reverse the operation of errors.Wrap to retrieve the original error for inspection. Any error value which implements this interface can be inspected by `errors.Cause`.
27 | ```go
28 | type causer interface {
29 | Cause() error
30 | }
31 | ```
32 | `errors.Cause` will recursively retrieve the topmost error which does not implement `causer`, which is assumed to be the original cause. For example:
33 | ```go
34 | switch err := errors.Cause(err).(type) {
35 | case *MyError:
36 | // handle specifically
37 | default:
38 | // unknown error
39 | }
40 | ```
41 |
42 | [Read the package documentation for more information](https://godoc.org/github.com/pkg/errors).
43 |
44 | ## Contributing
45 |
46 | We welcome pull requests, bug fixes and issue reports. With that said, the bar for adding new symbols to this package is intentionally set high.
47 |
48 | Before proposing a change, please discuss your change by raising an issue.
49 |
50 | ## Licence
51 |
52 | BSD-2-Clause
53 |
--------------------------------------------------------------------------------
/vendor/github.com/pkg/errors/appveyor.yml:
--------------------------------------------------------------------------------
1 | version: build-{build}.{branch}
2 |
3 | clone_folder: C:\gopath\src\github.com\pkg\errors
4 | shallow_clone: true # for startup speed
5 |
6 | environment:
7 | GOPATH: C:\gopath
8 |
9 | platform:
10 | - x64
11 |
12 | # http://www.appveyor.com/docs/installed-software
13 | install:
14 | # some helpful output for debugging builds
15 | - go version
16 | - go env
17 | # pre-installed MinGW at C:\MinGW is 32bit only
18 | # but MSYS2 at C:\msys64 has mingw64
19 | - set PATH=C:\msys64\mingw64\bin;%PATH%
20 | - gcc --version
21 | - g++ --version
22 |
23 | build_script:
24 | - go install -v ./...
25 |
26 | test_script:
27 | - set PATH=C:\gopath\bin;%PATH%
28 | - go test -v ./...
29 |
30 | #artifacts:
31 | # - path: '%GOPATH%\bin\*.exe'
32 | deploy: off
33 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/cobra/.gitignore:
--------------------------------------------------------------------------------
1 | # Compiled Object files, Static and Dynamic libs (Shared Objects)
2 | *.o
3 | *.a
4 | *.so
5 |
6 | # Folders
7 | _obj
8 | _test
9 |
10 | # Architecture specific extensions/prefixes
11 | *.[568vq]
12 | [568vq].out
13 |
14 | *.cgo1.go
15 | *.cgo2.c
16 | _cgo_defun.c
17 | _cgo_gotypes.go
18 | _cgo_export.*
19 |
20 | _testmain.go
21 |
22 | # Vim files https://github.com/github/gitignore/blob/master/Global/Vim.gitignore
23 | # swap
24 | [._]*.s[a-w][a-z]
25 | [._]s[a-w][a-z]
26 | # session
27 | Session.vim
28 | # temporary
29 | .netrwhist
30 | *~
31 | # auto-generated tag files
32 | tags
33 |
34 | *.exe
35 |
36 | cobra.test
37 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/cobra/.mailmap:
--------------------------------------------------------------------------------
1 | Steve Francia
2 | Bjørn Erik Pedersen
3 | Fabiano Franz
4 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/cobra/.travis.yml:
--------------------------------------------------------------------------------
1 | language: go
2 |
3 | matrix:
4 | include:
5 | - go: 1.9.4
6 | - go: 1.10.0
7 | - go: tip
8 | allow_failures:
9 | - go: tip
10 |
11 | before_install:
12 | - mkdir -p bin
13 | - curl -Lso bin/shellcheck https://github.com/caarlos0/shellcheck-docker/releases/download/v0.4.3/shellcheck
14 | - chmod +x bin/shellcheck
15 | script:
16 | - PATH=$PATH:$PWD/bin go test -v ./...
17 | - go build
18 | - diff -u <(echo -n) <(gofmt -d -s .)
19 | - if [ -z $NOVET ]; then
20 | diff -u <(echo -n) <(go tool vet . 2>&1 | grep -vE 'ExampleCommand|bash_completions.*Fprint');
21 | fi
22 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/cobra/args.go:
--------------------------------------------------------------------------------
1 | package cobra
2 |
3 | import (
4 | "fmt"
5 | )
6 |
7 | type PositionalArgs func(cmd *Command, args []string) error
8 |
9 | // Legacy arg validation has the following behaviour:
10 | // - root commands with no subcommands can take arbitrary arguments
11 | // - root commands with subcommands will do subcommand validity checking
12 | // - subcommands will always accept arbitrary arguments
13 | func legacyArgs(cmd *Command, args []string) error {
14 | // no subcommand, always take args
15 | if !cmd.HasSubCommands() {
16 | return nil
17 | }
18 |
19 | // root command with subcommands, do subcommand checking.
20 | if !cmd.HasParent() && len(args) > 0 {
21 | return fmt.Errorf("unknown command %q for %q%s", args[0], cmd.CommandPath(), cmd.findSuggestions(args[0]))
22 | }
23 | return nil
24 | }
25 |
26 | // NoArgs returns an error if any args are included.
27 | func NoArgs(cmd *Command, args []string) error {
28 | if len(args) > 0 {
29 | return fmt.Errorf("unknown command %q for %q", args[0], cmd.CommandPath())
30 | }
31 | return nil
32 | }
33 |
34 | // OnlyValidArgs returns an error if any args are not in the list of ValidArgs.
35 | func OnlyValidArgs(cmd *Command, args []string) error {
36 | if len(cmd.ValidArgs) > 0 {
37 | for _, v := range args {
38 | if !stringInSlice(v, cmd.ValidArgs) {
39 | return fmt.Errorf("invalid argument %q for %q%s", v, cmd.CommandPath(), cmd.findSuggestions(args[0]))
40 | }
41 | }
42 | }
43 | return nil
44 | }
45 |
46 | // ArbitraryArgs never returns an error.
47 | func ArbitraryArgs(cmd *Command, args []string) error {
48 | return nil
49 | }
50 |
51 | // MinimumNArgs returns an error if there is not at least N args.
52 | func MinimumNArgs(n int) PositionalArgs {
53 | return func(cmd *Command, args []string) error {
54 | if len(args) < n {
55 | return fmt.Errorf("requires at least %d arg(s), only received %d", n, len(args))
56 | }
57 | return nil
58 | }
59 | }
60 |
61 | // MaximumNArgs returns an error if there are more than N args.
62 | func MaximumNArgs(n int) PositionalArgs {
63 | return func(cmd *Command, args []string) error {
64 | if len(args) > n {
65 | return fmt.Errorf("accepts at most %d arg(s), received %d", n, len(args))
66 | }
67 | return nil
68 | }
69 | }
70 |
71 | // ExactArgs returns an error if there are not exactly n args.
72 | func ExactArgs(n int) PositionalArgs {
73 | return func(cmd *Command, args []string) error {
74 | if len(args) != n {
75 | return fmt.Errorf("accepts %d arg(s), received %d", n, len(args))
76 | }
77 | return nil
78 | }
79 | }
80 |
81 | // RangeArgs returns an error if the number of args is not within the expected range.
82 | func RangeArgs(min int, max int) PositionalArgs {
83 | return func(cmd *Command, args []string) error {
84 | if len(args) < min || len(args) > max {
85 | return fmt.Errorf("accepts between %d and %d arg(s), received %d", min, max, len(args))
86 | }
87 | return nil
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/cobra/command_notwin.go:
--------------------------------------------------------------------------------
1 | // +build !windows
2 |
3 | package cobra
4 |
5 | var preExecHookFn func(*Command)
6 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/cobra/command_win.go:
--------------------------------------------------------------------------------
1 | // +build windows
2 |
3 | package cobra
4 |
5 | import (
6 | "os"
7 | "time"
8 |
9 | "github.com/inconshreveable/mousetrap"
10 | )
11 |
12 | var preExecHookFn = preExecHook
13 |
14 | func preExecHook(c *Command) {
15 | if MousetrapHelpText != "" && mousetrap.StartedByExplorer() {
16 | c.Print(MousetrapHelpText)
17 | time.Sleep(5 * time.Second)
18 | os.Exit(1)
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/pflag/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/*
2 |
3 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/pflag/.travis.yml:
--------------------------------------------------------------------------------
1 | sudo: false
2 |
3 | language: go
4 |
5 | go:
6 | - 1.7.3
7 | - 1.8.1
8 | - tip
9 |
10 | matrix:
11 | allow_failures:
12 | - go: tip
13 |
14 | install:
15 | - go get github.com/golang/lint/golint
16 | - export PATH=$GOPATH/bin:$PATH
17 | - go install ./...
18 |
19 | script:
20 | - verify/all.sh -v
21 | - go test ./...
22 |
--------------------------------------------------------------------------------
/vendor/github.com/spf13/pflag/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2012 Alex Ogier. All rights reserved.
2 | Copyright (c) 2012 The Go Authors. All rights reserved.
3 |
4 | Redistribution and use in source and binary forms, with or without
5 | modification, are permitted provided that the following conditions are
6 | met:
7 |
8 | * Redistributions of source code must retain the above copyright
9 | notice, this list of conditions and the following disclaimer.
10 | * Redistributions in binary form must reproduce the above
11 | copyright notice, this list of conditions and the following disclaimer
12 | in the documentation and/or other materials provided with the
13 | distribution.
14 | * Neither the name of Google Inc. nor the names of its
15 | contributors may be used to endorse or promote products derived from
16 | this software without specific prior written permission.
17 |
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/AUTHORS:
--------------------------------------------------------------------------------
1 | # This source code refers to The Go Authors for copyright purposes.
2 | # The master list of authors is in the main Go distribution,
3 | # visible at http://tip.golang.org/AUTHORS.
4 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/CONTRIBUTORS:
--------------------------------------------------------------------------------
1 | # This source code was written by the Go contributors.
2 | # The master list of contributors is in the main Go distribution,
3 | # visible at http://tip.golang.org/CONTRIBUTORS.
4 |
--------------------------------------------------------------------------------
/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/.gitignore:
--------------------------------------------------------------------------------
1 | _obj/
2 | unix.test
3 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/aliases.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 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 go1.9
7 |
8 | package unix
9 |
10 | import "syscall"
11 |
12 | type Signal = syscall.Signal
13 | type Errno = syscall.Errno
14 | type SysProcAttr = syscall.SysProcAttr
15 |
--------------------------------------------------------------------------------
/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-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_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 | // See ../runtime/sys_linux_386.s for the reason why we always use int 0x80
14 | // instead of the glibc-specific "CALL 0x10(GS)".
15 | #define INVOKE_SYSCALL INT $0x80
16 |
17 | // Just jump to package syscall's implementation for all these functions.
18 | // The runtime may know about them.
19 |
20 | TEXT ·Syscall(SB),NOSPLIT,$0-28
21 | JMP syscall·Syscall(SB)
22 |
23 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
24 | JMP syscall·Syscall6(SB)
25 |
26 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
27 | CALL runtime·entersyscall(SB)
28 | MOVL trap+0(FP), AX // syscall entry
29 | MOVL a1+4(FP), BX
30 | MOVL a2+8(FP), CX
31 | MOVL a3+12(FP), DX
32 | MOVL $0, SI
33 | MOVL $0, DI
34 | INVOKE_SYSCALL
35 | MOVL AX, r1+16(FP)
36 | MOVL DX, r2+20(FP)
37 | CALL runtime·exitsyscall(SB)
38 | RET
39 |
40 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
41 | JMP syscall·RawSyscall(SB)
42 |
43 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
44 | JMP syscall·RawSyscall6(SB)
45 |
46 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
47 | MOVL trap+0(FP), AX // syscall entry
48 | MOVL a1+4(FP), BX
49 | MOVL a2+8(FP), CX
50 | MOVL a3+12(FP), DX
51 | MOVL $0, SI
52 | MOVL $0, DI
53 | INVOKE_SYSCALL
54 | MOVL AX, r1+16(FP)
55 | MOVL DX, r2+20(FP)
56 | RET
57 |
58 | TEXT ·socketcall(SB),NOSPLIT,$0-36
59 | JMP syscall·socketcall(SB)
60 |
61 | TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
62 | JMP syscall·rawsocketcall(SB)
63 |
64 | TEXT ·seek(SB),NOSPLIT,$0-28
65 | JMP syscall·seek(SB)
66 |
--------------------------------------------------------------------------------
/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 ·SyscallNoError(SB),NOSPLIT,$0-48
23 | CALL runtime·entersyscall(SB)
24 | MOVQ a1+8(FP), DI
25 | MOVQ a2+16(FP), SI
26 | MOVQ a3+24(FP), DX
27 | MOVQ $0, R10
28 | MOVQ $0, R8
29 | MOVQ $0, R9
30 | MOVQ trap+0(FP), AX // syscall entry
31 | SYSCALL
32 | MOVQ AX, r1+32(FP)
33 | MOVQ DX, r2+40(FP)
34 | CALL runtime·exitsyscall(SB)
35 | RET
36 |
37 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
38 | JMP syscall·RawSyscall(SB)
39 |
40 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
41 | JMP syscall·RawSyscall6(SB)
42 |
43 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
44 | MOVQ a1+8(FP), DI
45 | MOVQ a2+16(FP), SI
46 | MOVQ a3+24(FP), DX
47 | MOVQ $0, R10
48 | MOVQ $0, R8
49 | MOVQ $0, R9
50 | MOVQ trap+0(FP), AX // syscall entry
51 | SYSCALL
52 | MOVQ AX, r1+32(FP)
53 | MOVQ DX, r2+40(FP)
54 | RET
55 |
56 | TEXT ·gettimeofday(SB),NOSPLIT,$0-16
57 | JMP syscall·gettimeofday(SB)
58 |
--------------------------------------------------------------------------------
/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 ·SyscallNoError(SB),NOSPLIT,$0-24
23 | BL runtime·entersyscall(SB)
24 | MOVW trap+0(FP), R7
25 | MOVW a1+4(FP), R0
26 | MOVW a2+8(FP), R1
27 | MOVW a3+12(FP), R2
28 | MOVW $0, R3
29 | MOVW $0, R4
30 | MOVW $0, R5
31 | SWI $0
32 | MOVW R0, r1+16(FP)
33 | MOVW $0, R0
34 | MOVW R0, r2+20(FP)
35 | BL runtime·exitsyscall(SB)
36 | RET
37 |
38 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
39 | B syscall·RawSyscall(SB)
40 |
41 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
42 | B syscall·RawSyscall6(SB)
43 |
44 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
45 | MOVW trap+0(FP), R7 // syscall entry
46 | MOVW a1+4(FP), R0
47 | MOVW a2+8(FP), R1
48 | MOVW a3+12(FP), R2
49 | SWI $0
50 | MOVW R0, r1+16(FP)
51 | MOVW $0, R0
52 | MOVW R0, r2+20(FP)
53 | RET
54 |
55 | TEXT ·seek(SB),NOSPLIT,$0-28
56 | B syscall·seek(SB)
57 |
--------------------------------------------------------------------------------
/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 ·SyscallNoError(SB),NOSPLIT,$0-48
21 | BL runtime·entersyscall(SB)
22 | MOVD a1+8(FP), R0
23 | MOVD a2+16(FP), R1
24 | MOVD a3+24(FP), R2
25 | MOVD $0, R3
26 | MOVD $0, R4
27 | MOVD $0, R5
28 | MOVD trap+0(FP), R8 // syscall entry
29 | SVC
30 | MOVD R0, r1+32(FP) // r1
31 | MOVD R1, r2+40(FP) // r2
32 | BL runtime·exitsyscall(SB)
33 | RET
34 |
35 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
36 | B syscall·RawSyscall(SB)
37 |
38 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
39 | B syscall·RawSyscall6(SB)
40 |
41 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
42 | MOVD a1+8(FP), R0
43 | MOVD a2+16(FP), R1
44 | MOVD a3+24(FP), R2
45 | MOVD $0, R3
46 | MOVD $0, R4
47 | MOVD $0, R5
48 | MOVD trap+0(FP), R8 // syscall entry
49 | SVC
50 | MOVD R0, r1+32(FP)
51 | MOVD R1, r2+40(FP)
52 | RET
53 |
--------------------------------------------------------------------------------
/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 ·SyscallNoError(SB),NOSPLIT,$0-48
25 | JAL runtime·entersyscall(SB)
26 | MOVV a1+8(FP), R4
27 | MOVV a2+16(FP), R5
28 | MOVV a3+24(FP), R6
29 | MOVV R0, R7
30 | MOVV R0, R8
31 | MOVV R0, R9
32 | MOVV trap+0(FP), R2 // syscall entry
33 | SYSCALL
34 | MOVV R2, r1+32(FP)
35 | MOVV R3, r2+40(FP)
36 | JAL runtime·exitsyscall(SB)
37 | RET
38 |
39 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
40 | JMP syscall·RawSyscall(SB)
41 |
42 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
43 | JMP syscall·RawSyscall6(SB)
44 |
45 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
46 | MOVV a1+8(FP), R4
47 | MOVV a2+16(FP), R5
48 | MOVV a3+24(FP), R6
49 | MOVV R0, R7
50 | MOVV R0, R8
51 | MOVV R0, R9
52 | MOVV trap+0(FP), R2 // syscall entry
53 | SYSCALL
54 | MOVV R2, r1+32(FP)
55 | MOVV R3, r2+40(FP)
56 | RET
57 |
--------------------------------------------------------------------------------
/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 ·SyscallNoError(SB),NOSPLIT,$0-24
28 | JAL runtime·entersyscall(SB)
29 | MOVW a1+4(FP), R4
30 | MOVW a2+8(FP), R5
31 | MOVW a3+12(FP), R6
32 | MOVW R0, R7
33 | MOVW trap+0(FP), R2 // syscall entry
34 | SYSCALL
35 | MOVW R2, r1+16(FP) // r1
36 | MOVW R3, r2+20(FP) // r2
37 | JAL runtime·exitsyscall(SB)
38 | RET
39 |
40 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
41 | JMP syscall·RawSyscall(SB)
42 |
43 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
44 | JMP syscall·RawSyscall6(SB)
45 |
46 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
47 | MOVW a1+4(FP), R4
48 | MOVW a2+8(FP), R5
49 | MOVW a3+12(FP), R6
50 | MOVW trap+0(FP), R2 // syscall entry
51 | SYSCALL
52 | MOVW R2, r1+16(FP)
53 | MOVW R3, r2+20(FP)
54 | RET
55 |
--------------------------------------------------------------------------------
/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 ·SyscallNoError(SB),NOSPLIT,$0-48
25 | BL runtime·entersyscall(SB)
26 | MOVD a1+8(FP), R3
27 | MOVD a2+16(FP), R4
28 | MOVD a3+24(FP), R5
29 | MOVD R0, R6
30 | MOVD R0, R7
31 | MOVD R0, R8
32 | MOVD trap+0(FP), R9 // syscall entry
33 | SYSCALL R9
34 | MOVD R3, r1+32(FP)
35 | MOVD R4, r2+40(FP)
36 | BL runtime·exitsyscall(SB)
37 | RET
38 |
39 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
40 | BR syscall·RawSyscall(SB)
41 |
42 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
43 | BR syscall·RawSyscall6(SB)
44 |
45 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
46 | MOVD a1+8(FP), R3
47 | MOVD a2+16(FP), R4
48 | MOVD a3+24(FP), R5
49 | MOVD R0, R6
50 | MOVD R0, R7
51 | MOVD R0, R8
52 | MOVD trap+0(FP), R9 // syscall entry
53 | SYSCALL R9
54 | MOVD R3, r1+32(FP)
55 | MOVD R4, r2+40(FP)
56 | RET
57 |
--------------------------------------------------------------------------------
/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 ·SyscallNoError(SB),NOSPLIT,$0-48
25 | BL runtime·entersyscall(SB)
26 | MOVD a1+8(FP), R2
27 | MOVD a2+16(FP), R3
28 | MOVD a3+24(FP), R4
29 | MOVD $0, R5
30 | MOVD $0, R6
31 | MOVD $0, R7
32 | MOVD trap+0(FP), R1 // syscall entry
33 | SYSCALL
34 | MOVD R2, r1+32(FP)
35 | MOVD R3, r2+40(FP)
36 | BL runtime·exitsyscall(SB)
37 | RET
38 |
39 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
40 | BR syscall·RawSyscall(SB)
41 |
42 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
43 | BR syscall·RawSyscall6(SB)
44 |
45 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
46 | MOVD a1+8(FP), R2
47 | MOVD a2+16(FP), R3
48 | MOVD a3+24(FP), R4
49 | MOVD $0, R5
50 | MOVD $0, R6
51 | MOVD $0, R7
52 | MOVD trap+0(FP), R1 // syscall entry
53 | SYSCALL
54 | MOVD R2, r1+32(FP)
55 | MOVD R3, r2+40(FP)
56 | RET
57 |
--------------------------------------------------------------------------------
/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_openbsd_arm.s:
--------------------------------------------------------------------------------
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 !gccgo
6 |
7 | #include "textflag.h"
8 |
9 | //
10 | // System call support for ARM, 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 | 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_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/dev_darwin.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 | // Functions to access/create device major and minor numbers matching the
6 | // encoding used in Darwin's sys/types.h header.
7 |
8 | package unix
9 |
10 | // Major returns the major component of a Darwin device number.
11 | func Major(dev uint64) uint32 {
12 | return uint32((dev >> 24) & 0xff)
13 | }
14 |
15 | // Minor returns the minor component of a Darwin device number.
16 | func Minor(dev uint64) uint32 {
17 | return uint32(dev & 0xffffff)
18 | }
19 |
20 | // Mkdev returns a Darwin device number generated from the given major and minor
21 | // components.
22 | func Mkdev(major, minor uint32) uint64 {
23 | return (uint64(major) << 24) | uint64(minor)
24 | }
25 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_dragonfly.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 | // Functions to access/create device major and minor numbers matching the
6 | // encoding used in Dragonfly's sys/types.h header.
7 | //
8 | // The information below is extracted and adapted from sys/types.h:
9 | //
10 | // Minor gives a cookie instead of an index since in order to avoid changing the
11 | // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
12 | // devices that don't use them.
13 |
14 | package unix
15 |
16 | // Major returns the major component of a DragonFlyBSD device number.
17 | func Major(dev uint64) uint32 {
18 | return uint32((dev >> 8) & 0xff)
19 | }
20 |
21 | // Minor returns the minor component of a DragonFlyBSD device number.
22 | func Minor(dev uint64) uint32 {
23 | return uint32(dev & 0xffff00ff)
24 | }
25 |
26 | // Mkdev returns a DragonFlyBSD device number generated from the given major and
27 | // minor components.
28 | func Mkdev(major, minor uint32) uint64 {
29 | return (uint64(major) << 8) | uint64(minor)
30 | }
31 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_freebsd.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 | // Functions to access/create device major and minor numbers matching the
6 | // encoding used in FreeBSD's sys/types.h header.
7 | //
8 | // The information below is extracted and adapted from sys/types.h:
9 | //
10 | // Minor gives a cookie instead of an index since in order to avoid changing the
11 | // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
12 | // devices that don't use them.
13 |
14 | package unix
15 |
16 | // Major returns the major component of a FreeBSD device number.
17 | func Major(dev uint64) uint32 {
18 | return uint32((dev >> 8) & 0xff)
19 | }
20 |
21 | // Minor returns the minor component of a FreeBSD device number.
22 | func Minor(dev uint64) uint32 {
23 | return uint32(dev & 0xffff00ff)
24 | }
25 |
26 | // Mkdev returns a FreeBSD device number generated from the given major and
27 | // minor components.
28 | func Mkdev(major, minor uint32) uint64 {
29 | return (uint64(major) << 8) | uint64(minor)
30 | }
31 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_linux.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 | // Functions to access/create device major and minor numbers matching the
6 | // encoding used by the Linux kernel and glibc.
7 | //
8 | // The information below is extracted and adapted from bits/sysmacros.h in the
9 | // glibc sources:
10 | //
11 | // dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
12 | // default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
13 | // number and m is a hex digit of the minor number. This is backward compatible
14 | // with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
15 | // backward compatible with the Linux kernel, which for some architectures uses
16 | // 32-bit dev_t, encoded as mmmM MMmm.
17 |
18 | package unix
19 |
20 | // Major returns the major component of a Linux device number.
21 | func Major(dev uint64) uint32 {
22 | major := uint32((dev & 0x00000000000fff00) >> 8)
23 | major |= uint32((dev & 0xfffff00000000000) >> 32)
24 | return major
25 | }
26 |
27 | // Minor returns the minor component of a Linux device number.
28 | func Minor(dev uint64) uint32 {
29 | minor := uint32((dev & 0x00000000000000ff) >> 0)
30 | minor |= uint32((dev & 0x00000ffffff00000) >> 12)
31 | return minor
32 | }
33 |
34 | // Mkdev returns a Linux device number generated from the given major and minor
35 | // components.
36 | func Mkdev(major, minor uint32) uint64 {
37 | dev := (uint64(major) & 0x00000fff) << 8
38 | dev |= (uint64(major) & 0xfffff000) << 32
39 | dev |= (uint64(minor) & 0x000000ff) << 0
40 | dev |= (uint64(minor) & 0xffffff00) << 12
41 | return dev
42 | }
43 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_netbsd.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 | // Functions to access/create device major and minor numbers matching the
6 | // encoding used in NetBSD's sys/types.h header.
7 |
8 | package unix
9 |
10 | // Major returns the major component of a NetBSD device number.
11 | func Major(dev uint64) uint32 {
12 | return uint32((dev & 0x000fff00) >> 8)
13 | }
14 |
15 | // Minor returns the minor component of a NetBSD device number.
16 | func Minor(dev uint64) uint32 {
17 | minor := uint32((dev & 0x000000ff) >> 0)
18 | minor |= uint32((dev & 0xfff00000) >> 12)
19 | return minor
20 | }
21 |
22 | // Mkdev returns a NetBSD device number generated from the given major and minor
23 | // components.
24 | func Mkdev(major, minor uint32) uint64 {
25 | dev := (uint64(major) << 8) & 0x000fff00
26 | dev |= (uint64(minor) << 12) & 0xfff00000
27 | dev |= (uint64(minor) << 0) & 0x000000ff
28 | return dev
29 | }
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_openbsd.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 | // Functions to access/create device major and minor numbers matching the
6 | // encoding used in OpenBSD's sys/types.h header.
7 |
8 | package unix
9 |
10 | // Major returns the major component of an OpenBSD device number.
11 | func Major(dev uint64) uint32 {
12 | return uint32((dev & 0x0000ff00) >> 8)
13 | }
14 |
15 | // Minor returns the minor component of an OpenBSD device number.
16 | func Minor(dev uint64) uint32 {
17 | minor := uint32((dev & 0x000000ff) >> 0)
18 | minor |= uint32((dev & 0xffff0000) >> 8)
19 | return minor
20 | }
21 |
22 | // Mkdev returns an OpenBSD device number generated from the given major and minor
23 | // components.
24 | func Mkdev(major, minor uint32) uint64 {
25 | dev := (uint64(major) << 8) & 0x0000ff00
26 | dev |= (uint64(minor) << 8) & 0xffff0000
27 | dev |= (uint64(minor) << 0) & 0x000000ff
28 | return dev
29 | }
30 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dirent.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 darwin dragonfly freebsd linux nacl netbsd openbsd solaris
6 |
7 | package unix
8 |
9 | import "syscall"
10 |
11 | // ParseDirent parses up to max directory entries in buf,
12 | // appending the names to names. It returns the number of
13 | // bytes consumed from buf, the number of entries added
14 | // to names, and the new names slice.
15 | func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
16 | return syscall.ParseDirent(buf, max, names)
17 | }
18 |
--------------------------------------------------------------------------------
/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 |
29 | func Unsetenv(key string) error {
30 | return syscall.Unsetenv(key)
31 | }
32 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/fcntl.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 darwin dragonfly freebsd linux netbsd openbsd
6 |
7 | package unix
8 |
9 | import "unsafe"
10 |
11 | // fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux
12 | // systems by flock_linux_32bit.go to be SYS_FCNTL64.
13 | var fcntl64Syscall uintptr = SYS_FCNTL
14 |
15 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument.
16 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
17 | valptr, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(arg))
18 | var err error
19 | if errno != 0 {
20 | err = errno
21 | }
22 | return int(valptr), err
23 | }
24 |
25 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
26 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
27 | _, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))
28 | if errno == 0 {
29 | return nil
30 | }
31 | return errno
32 | }
33 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/fcntl_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 gccgoRealSyscallNoError
15 | func realSyscallNoError(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r uintptr)
16 |
17 | //extern gccgoRealSyscall
18 | func realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r, errno uintptr)
19 |
20 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {
21 | syscall.Entersyscall()
22 | r := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
23 | syscall.Exitsyscall()
24 | return r, 0
25 | }
26 |
27 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
28 | syscall.Entersyscall()
29 | r, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
30 | syscall.Exitsyscall()
31 | return r, 0, syscall.Errno(errno)
32 | }
33 |
34 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
35 | syscall.Entersyscall()
36 | r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
37 | syscall.Exitsyscall()
38 | return r, 0, syscall.Errno(errno)
39 | }
40 |
41 | func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) {
42 | syscall.Entersyscall()
43 | r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)
44 | syscall.Exitsyscall()
45 | return r, 0, syscall.Errno(errno)
46 | }
47 |
48 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {
49 | r := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
50 | return r, 0
51 | }
52 |
53 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
54 | r, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
55 | return r, 0, syscall.Errno(errno)
56 | }
57 |
58 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
59 | r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
60 | return r, 0, syscall.Errno(errno)
61 | }
62 |
--------------------------------------------------------------------------------
/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 | uintptr_t
35 | gccgoRealSyscallNoError(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)
36 | {
37 | return syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);
38 | }
39 |
--------------------------------------------------------------------------------
/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/ioctl.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 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 | import "runtime"
10 |
11 | // IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.
12 | //
13 | // To change fd's window size, the req argument should be TIOCSWINSZ.
14 | func IoctlSetWinsize(fd int, req uint, value *Winsize) error {
15 | // TODO: if we get the chance, remove the req parameter and
16 | // hardcode TIOCSWINSZ.
17 | err := ioctlSetWinsize(fd, req, value)
18 | runtime.KeepAlive(value)
19 | return err
20 | }
21 |
22 | // IoctlSetTermios performs an ioctl on fd with a *Termios.
23 | //
24 | // The req value will usually be TCSETA or TIOCSETA.
25 | func IoctlSetTermios(fd int, req uint, value *Termios) error {
26 | // TODO: if we get the chance, remove the req parameter.
27 | err := ioctlSetTermios(fd, req, value)
28 | runtime.KeepAlive(value)
29 | return err
30 | }
31 |
--------------------------------------------------------------------------------
/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 |
44 | print " $name = $num; // $proto\n";
45 | }
46 | }
47 |
48 | 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 '13' || $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 < 6.2, pass execpromises to the syscall.
58 | if maj > 6 || (maj == 6 && min > 2) {
59 | exptr, err := syscall.BytePtrFromString(execpromises)
60 | if err != nil {
61 | return err
62 | }
63 | expr = unsafe.Pointer(exptr)
64 | }
65 |
66 | _, _, e := syscall.Syscall(_SYS_PLEDGE, uintptr(unsafe.Pointer(pptr)), uintptr(expr), 0)
67 | if e != 0 {
68 | return e
69 | }
70 |
71 | return nil
72 | }
73 |
74 | // majmin returns major and minor version number for an OpenBSD system.
75 | func majmin() (major int, minor int, err error) {
76 | var v Utsname
77 | err = Uname(&v)
78 | if err != nil {
79 | return
80 | }
81 |
82 | major, err = strconv.Atoi(string(v.Release[0]))
83 | if err != nil {
84 | err = errors.New("cannot parse major version number returned by uname")
85 | return
86 | }
87 |
88 | minor, err = strconv.Atoi(string(v.Release[2]))
89 | if err != nil {
90 | err = errors.New("cannot parse minor version number returned by uname")
91 | return
92 | }
93 |
94 | return
95 | }
96 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/pagesize_unix.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 darwin dragonfly freebsd linux netbsd openbsd solaris
6 |
7 | // For Unix, get the pagesize from the runtime.
8 |
9 | package unix
10 |
11 | import "syscall"
12 |
13 | func Getpagesize() int {
14 | return syscall.Getpagesize()
15 | }
16 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/race.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 darwin,race linux,race freebsd,race
6 |
7 | package unix
8 |
9 | import (
10 | "runtime"
11 | "unsafe"
12 | )
13 |
14 | const raceenabled = true
15 |
16 | func raceAcquire(addr unsafe.Pointer) {
17 | runtime.RaceAcquire(addr)
18 | }
19 |
20 | func raceReleaseMerge(addr unsafe.Pointer) {
21 | runtime.RaceReleaseMerge(addr)
22 | }
23 |
24 | func raceReadRange(addr unsafe.Pointer, len int) {
25 | runtime.RaceReadRange(addr, len)
26 | }
27 |
28 | func raceWriteRange(addr unsafe.Pointer, len int) {
29 | runtime.RaceWriteRange(addr, len)
30 | }
31 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/race0.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 darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly
6 |
7 | package unix
8 |
9 | import (
10 | "unsafe"
11 | )
12 |
13 | const raceenabled = false
14 |
15 | func raceAcquire(addr unsafe.Pointer) {
16 | }
17 |
18 | func raceReleaseMerge(addr unsafe.Pointer) {
19 | }
20 |
21 | func raceReadRange(addr unsafe.Pointer, len int) {
22 | }
23 |
24 | func raceWriteRange(addr unsafe.Pointer, len int) {
25 | }
26 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/sockcmsg_linux.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 | // Socket control messages
6 |
7 | package unix
8 |
9 | import "unsafe"
10 |
11 | // UnixCredentials encodes credentials into a socket control message
12 | // for sending to another process. This can be used for
13 | // authentication.
14 | func UnixCredentials(ucred *Ucred) []byte {
15 | b := make([]byte, CmsgSpace(SizeofUcred))
16 | h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
17 | h.Level = SOL_SOCKET
18 | h.Type = SCM_CREDENTIALS
19 | h.SetLen(CmsgLen(SizeofUcred))
20 | *((*Ucred)(cmsgData(h))) = *ucred
21 | return b
22 | }
23 |
24 | // ParseUnixCredentials decodes a socket control message that contains
25 | // credentials in a Ucred structure. To receive such a message, the
26 | // SO_PASSCRED option must be enabled on the socket.
27 | func ParseUnixCredentials(m *SocketControlMessage) (*Ucred, error) {
28 | if m.Header.Level != SOL_SOCKET {
29 | return nil, EINVAL
30 | }
31 | if m.Header.Type != SCM_CREDENTIALS {
32 | return nil, EINVAL
33 | }
34 | ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0]))
35 | return &ucred, nil
36 | }
37 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/str.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 darwin dragonfly freebsd linux netbsd openbsd solaris
6 |
7 | package unix
8 |
9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency
10 | if val < 0 {
11 | return "-" + uitoa(uint(-val))
12 | }
13 | return uitoa(uint(val))
14 | }
15 |
16 | func uitoa(val uint) string {
17 | var buf [32]byte // big enough for int64
18 | i := len(buf) - 1
19 | for val >= 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.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 darwin dragonfly freebsd linux netbsd openbsd solaris
6 |
7 | // Package unix contains an interface to the low-level operating system
8 | // primitives. OS details vary depending on the underlying system, and
9 | // by default, godoc will display OS-specific documentation for the current
10 | // system. If you want godoc to display OS documentation for another
11 | // system, set $GOOS and $GOARCH to the desired system. For example, if
12 | // you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
13 | // to freebsd and $GOARCH to arm.
14 | //
15 | // The primary use of this package is inside other packages that provide a more
16 | // portable interface to the system, such as "os", "time" and "net". Use
17 | // those packages rather than this one if you can.
18 | //
19 | // For details of the functions and data types in this package consult
20 | // the manuals for the appropriate operating system.
21 | //
22 | // These calls return err == nil to indicate success; otherwise
23 | // err represents an operating system error describing the failure and
24 | // holds a value of type syscall.Errno.
25 | package unix // import "golang.org/x/sys/unix"
26 |
27 | import "strings"
28 |
29 | // ByteSliceFromString returns a NUL-terminated slice of bytes
30 | // containing the text of s. If s contains a NUL byte at any
31 | // location, it returns (nil, EINVAL).
32 | func ByteSliceFromString(s string) ([]byte, error) {
33 | if strings.IndexByte(s, 0) != -1 {
34 | return nil, EINVAL
35 | }
36 | a := make([]byte, len(s)+1)
37 | copy(a, s)
38 | return a, nil
39 | }
40 |
41 | // BytePtrFromString returns a pointer to a NUL-terminated array of
42 | // bytes containing the text of s. If s contains a NUL byte at any
43 | // location, it returns (nil, EINVAL).
44 | func BytePtrFromString(s string) (*byte, error) {
45 | a, err := ByteSliceFromString(s)
46 | if err != nil {
47 | return nil, err
48 | }
49 | return &a[0], nil
50 | }
51 |
52 | // Single-word zero for use when we need a valid pointer to 0 bytes.
53 | // See mkunix.pl.
54 | var _zero uintptr
55 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
15 | return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
16 | }
17 |
18 | func setTimeval(sec, usec int64) Timeval {
19 | return Timeval{Sec: int32(sec), Usec: int32(usec)}
20 | }
21 |
22 | //sysnb gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
23 | func Gettimeofday(tv *Timeval) (err error) {
24 | // The tv passed to gettimeofday must be non-nil
25 | // but is otherwise unused. The answers come back
26 | // in the two registers.
27 | sec, usec, err := gettimeofday(tv)
28 | tv.Sec = int32(sec)
29 | tv.Usec = int32(usec)
30 | return err
31 | }
32 |
33 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
34 | k.Ident = uint32(fd)
35 | k.Filter = int16(mode)
36 | k.Flags = uint16(flags)
37 | }
38 |
39 | func (iov *Iovec) SetLen(length int) {
40 | iov.Len = uint32(length)
41 | }
42 |
43 | func (msghdr *Msghdr) SetControllen(length int) {
44 | msghdr.Controllen = uint32(length)
45 | }
46 |
47 | func (cmsg *Cmsghdr) SetLen(length int) {
48 | cmsg.Len = uint32(length)
49 | }
50 |
51 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
52 | var length = uint64(count)
53 |
54 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(*offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
55 |
56 | written = int(length)
57 |
58 | if e1 != 0 {
59 | err = e1
60 | }
61 | return
62 | }
63 |
64 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
65 |
66 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
67 | // of darwin/386 the syscall is called sysctl instead of __sysctl.
68 | const SYS___SYSCTL = SYS_SYSCTL
69 |
--------------------------------------------------------------------------------
/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 | func setTimespec(sec, nsec int64) Timespec {
15 | return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 |
18 | func setTimeval(sec, usec int64) Timeval {
19 | return Timeval{Sec: sec, Usec: int32(usec)}
20 | }
21 |
22 | //sysnb gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
23 | func Gettimeofday(tv *Timeval) (err error) {
24 | // The tv passed to gettimeofday must be non-nil
25 | // but is otherwise unused. The answers come back
26 | // in the two registers.
27 | sec, usec, err := gettimeofday(tv)
28 | tv.Sec = sec
29 | tv.Usec = usec
30 | return err
31 | }
32 |
33 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
34 | k.Ident = uint64(fd)
35 | k.Filter = int16(mode)
36 | k.Flags = uint16(flags)
37 | }
38 |
39 | func (iov *Iovec) SetLen(length int) {
40 | iov.Len = uint64(length)
41 | }
42 |
43 | func (msghdr *Msghdr) SetControllen(length int) {
44 | msghdr.Controllen = uint32(length)
45 | }
46 |
47 | func (cmsg *Cmsghdr) SetLen(length int) {
48 | cmsg.Len = uint32(length)
49 | }
50 |
51 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
52 | var length = uint64(count)
53 |
54 | _, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
55 |
56 | written = int(length)
57 |
58 | if e1 != 0 {
59 | err = e1
60 | }
61 | return
62 | }
63 |
64 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
65 |
66 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
67 | // of darwin/amd64 the syscall is called sysctl instead of __sysctl.
68 | const SYS___SYSCTL = SYS_SYSCTL
69 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
13 | return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
14 | }
15 |
16 | func setTimeval(sec, usec int64) Timeval {
17 | return Timeval{Sec: int32(sec), Usec: int32(usec)}
18 | }
19 |
20 | //sysnb gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
21 | func Gettimeofday(tv *Timeval) (err error) {
22 | // The tv passed to gettimeofday must be non-nil
23 | // but is otherwise unused. The answers come back
24 | // in the two registers.
25 | sec, usec, err := gettimeofday(tv)
26 | tv.Sec = int32(sec)
27 | tv.Usec = int32(usec)
28 | return err
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 length = uint64(count)
51 |
52 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(*offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
53 |
54 | written = int(length)
55 |
56 | if e1 != 0 {
57 | err = e1
58 | }
59 | return
60 | }
61 |
62 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
63 |
64 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
65 | // of darwin/arm the syscall is called sysctl instead of __sysctl.
66 | const SYS___SYSCTL = SYS_SYSCTL
67 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
15 | return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 |
18 | func setTimeval(sec, usec int64) Timeval {
19 | return Timeval{Sec: sec, Usec: int32(usec)}
20 | }
21 |
22 | //sysnb gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
23 | func Gettimeofday(tv *Timeval) (err error) {
24 | // The tv passed to gettimeofday must be non-nil
25 | // but is otherwise unused. The answers come back
26 | // in the two registers.
27 | sec, usec, err := gettimeofday(tv)
28 | tv.Sec = sec
29 | tv.Usec = usec
30 | return err
31 | }
32 |
33 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
34 | k.Ident = uint64(fd)
35 | k.Filter = int16(mode)
36 | k.Flags = uint16(flags)
37 | }
38 |
39 | func (iov *Iovec) SetLen(length int) {
40 | iov.Len = uint64(length)
41 | }
42 |
43 | func (msghdr *Msghdr) SetControllen(length int) {
44 | msghdr.Controllen = uint32(length)
45 | }
46 |
47 | func (cmsg *Cmsghdr) SetLen(length int) {
48 | cmsg.Len = uint32(length)
49 | }
50 |
51 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
52 | var length = uint64(count)
53 |
54 | _, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
55 |
56 | written = int(length)
57 |
58 | if e1 != 0 {
59 | err = e1
60 | }
61 | return
62 | }
63 |
64 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
65 |
66 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
67 | // of darwin/arm64 the syscall is called sysctl instead of __sysctl.
68 | const SYS___SYSCTL = SYS_SYSCTL
69 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
15 | return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 |
18 | func setTimeval(sec, usec int64) Timeval {
19 | return Timeval{Sec: sec, Usec: usec}
20 | }
21 |
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | k.Ident = uint64(fd)
24 | k.Filter = int16(mode)
25 | k.Flags = uint16(flags)
26 | }
27 |
28 | func (iov *Iovec) SetLen(length int) {
29 | iov.Len = uint64(length)
30 | }
31 |
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | msghdr.Controllen = uint32(length)
34 | }
35 |
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | cmsg.Len = uint32(length)
38 | }
39 |
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | var writtenOut uint64 = 0
42 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0, 0)
43 |
44 | written = int(writtenOut)
45 |
46 | if e1 != 0 {
47 | err = e1
48 | }
49 | return
50 | }
51 |
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
15 | return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
16 | }
17 |
18 | func setTimeval(sec, usec int64) Timeval {
19 | return Timeval{Sec: int32(sec), Usec: int32(usec)}
20 | }
21 |
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | k.Ident = uint32(fd)
24 | k.Filter = int16(mode)
25 | k.Flags = uint16(flags)
26 | }
27 |
28 | func (iov *Iovec) SetLen(length int) {
29 | iov.Len = uint32(length)
30 | }
31 |
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | msghdr.Controllen = uint32(length)
34 | }
35 |
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | cmsg.Len = uint32(length)
38 | }
39 |
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | var writtenOut uint64 = 0
42 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr((*offset)>>32), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0)
43 |
44 | written = int(writtenOut)
45 |
46 | if e1 != 0 {
47 | err = e1
48 | }
49 | return
50 | }
51 |
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
15 | return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 |
18 | func setTimeval(sec, usec int64) Timeval {
19 | return Timeval{Sec: sec, Usec: usec}
20 | }
21 |
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | k.Ident = uint64(fd)
24 | k.Filter = int16(mode)
25 | k.Flags = uint16(flags)
26 | }
27 |
28 | func (iov *Iovec) SetLen(length int) {
29 | iov.Len = uint64(length)
30 | }
31 |
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | msghdr.Controllen = uint32(length)
34 | }
35 |
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | cmsg.Len = uint32(length)
38 | }
39 |
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | var writtenOut uint64 = 0
42 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0, 0)
43 |
44 | written = int(writtenOut)
45 |
46 | if e1 != 0 {
47 | err = e1
48 | }
49 | return
50 | }
51 |
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
15 | return Timespec{Sec: sec, Nsec: int32(nsec)}
16 | }
17 |
18 | func setTimeval(sec, usec int64) Timeval {
19 | return Timeval{Sec: sec, Usec: int32(usec)}
20 | }
21 |
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | k.Ident = uint32(fd)
24 | k.Filter = int16(mode)
25 | k.Flags = uint16(flags)
26 | }
27 |
28 | func (iov *Iovec) SetLen(length int) {
29 | iov.Len = uint32(length)
30 | }
31 |
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | msghdr.Controllen = uint32(length)
34 | }
35 |
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | cmsg.Len = uint32(length)
38 | }
39 |
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | var writtenOut uint64 = 0
42 | _, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr((*offset)>>32), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0)
43 |
44 | written = int(writtenOut)
45 |
46 | if e1 != 0 {
47 | err = e1
48 | }
49 | return
50 | }
51 |
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 |
--------------------------------------------------------------------------------
/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_linux_gc.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 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,!gccgo
6 |
7 | package unix
8 |
9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail.
10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
11 |
12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't
13 | // fail.
14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
15 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 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,!gccgo,386
6 |
7 | package unix
8 |
9 | import "syscall"
10 |
11 | // Underlying system call writes to newoffset via pointer.
12 | // Implemented in assembly to avoid allocation.
13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno)
14 |
15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)
16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)
17 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 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,gccgo,386
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
15 | var newoffset int64
16 | offsetLow := uint32(offset & 0xffffffff)
17 | offsetHigh := uint32((offset >> 32) & 0xffffffff)
18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0)
19 | return newoffset, err
20 | }
21 |
22 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) {
23 | fd, _, err := Syscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0)
24 | return int(fd), err
25 | }
26 |
27 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) {
28 | fd, _, err := RawSyscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0)
29 | return int(fd), err
30 | }
31 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 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,gccgo,arm
6 |
7 | package unix
8 |
9 | import (
10 | "syscall"
11 | "unsafe"
12 | )
13 |
14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
15 | var newoffset int64
16 | offsetLow := uint32(offset & 0xffffffff)
17 | offsetHigh := uint32((offset >> 32) & 0xffffffff)
18 | _, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0)
19 | return newoffset, err
20 | }
21 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
10 | return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 |
13 | func setTimeval(sec, usec int64) Timeval {
14 | return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 |
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | k.Ident = uint32(fd)
19 | k.Filter = uint32(mode)
20 | k.Flags = uint32(flags)
21 | }
22 |
23 | func (iov *Iovec) SetLen(length int) {
24 | iov.Len = uint32(length)
25 | }
26 |
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | msghdr.Controllen = uint32(length)
29 | }
30 |
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | cmsg.Len = uint32(length)
33 | }
34 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
10 | return Timespec{Sec: sec, Nsec: nsec}
11 | }
12 |
13 | func setTimeval(sec, usec int64) Timeval {
14 | return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 |
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | k.Ident = uint64(fd)
19 | k.Filter = uint32(mode)
20 | k.Flags = uint32(flags)
21 | }
22 |
23 | func (iov *Iovec) SetLen(length int) {
24 | iov.Len = uint64(length)
25 | }
26 |
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | msghdr.Controllen = uint32(length)
29 | }
30 |
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | cmsg.Len = uint32(length)
33 | }
34 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
10 | return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 |
13 | func setTimeval(sec, usec int64) Timeval {
14 | return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 |
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | k.Ident = uint32(fd)
19 | k.Filter = uint32(mode)
20 | k.Flags = uint32(flags)
21 | }
22 |
23 | func (iov *Iovec) SetLen(length int) {
24 | iov.Len = uint32(length)
25 | }
26 |
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | msghdr.Controllen = uint32(length)
29 | }
30 |
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | cmsg.Len = uint32(length)
33 | }
34 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
10 | return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 |
13 | func setTimeval(sec, usec int64) Timeval {
14 | return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 |
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | k.Ident = uint32(fd)
19 | k.Filter = int16(mode)
20 | k.Flags = uint16(flags)
21 | }
22 |
23 | func (iov *Iovec) SetLen(length int) {
24 | iov.Len = uint32(length)
25 | }
26 |
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | msghdr.Controllen = uint32(length)
29 | }
30 |
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | cmsg.Len = uint32(length)
33 | }
34 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
10 | return Timespec{Sec: sec, Nsec: nsec}
11 | }
12 |
13 | func setTimeval(sec, usec int64) Timeval {
14 | return Timeval{Sec: sec, Usec: usec}
15 | }
16 |
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | k.Ident = uint64(fd)
19 | k.Filter = int16(mode)
20 | k.Flags = uint16(flags)
21 | }
22 |
23 | func (iov *Iovec) SetLen(length int) {
24 | iov.Len = uint64(length)
25 | }
26 |
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | msghdr.Controllen = uint32(length)
29 | }
30 |
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | cmsg.Len = uint32(length)
33 | }
34 |
35 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
36 | // of openbsd/amd64 the syscall is called sysctl instead of __sysctl.
37 | const SYS___SYSCTL = SYS_SYSCTL
38 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.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 arm,openbsd
6 |
7 | package unix
8 |
9 | func setTimespec(sec, nsec int64) Timespec {
10 | return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 |
13 | func setTimeval(sec, usec int64) Timeval {
14 | return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 |
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | k.Ident = uint32(fd)
19 | k.Filter = int16(mode)
20 | k.Flags = uint16(flags)
21 | }
22 |
23 | func (iov *Iovec) SetLen(length int) {
24 | iov.Len = uint32(length)
25 | }
26 |
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | msghdr.Controllen = uint32(length)
29 | }
30 |
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | cmsg.Len = uint32(length)
33 | }
34 |
--------------------------------------------------------------------------------
/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 setTimespec(sec, nsec int64) Timespec {
10 | return Timespec{Sec: sec, Nsec: nsec}
11 | }
12 |
13 | func setTimeval(sec, usec int64) Timeval {
14 | return Timeval{Sec: sec, Usec: usec}
15 | }
16 |
17 | func (iov *Iovec) SetLen(length int) {
18 | iov.Len = uint64(length)
19 | }
20 |
21 | func (cmsg *Cmsghdr) SetLen(length int) {
22 | cmsg.Len = uint32(length)
23 | }
24 |
--------------------------------------------------------------------------------
/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/timestruct.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 darwin dragonfly freebsd linux netbsd openbsd solaris
6 |
7 | package unix
8 |
9 | import "time"
10 |
11 | // TimespecToNsec converts a Timespec value into a number of
12 | // nanoseconds since the Unix epoch.
13 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
14 |
15 | // NsecToTimespec takes a number of nanoseconds since the Unix epoch
16 | // and returns the corresponding Timespec value.
17 | func NsecToTimespec(nsec int64) Timespec {
18 | sec := nsec / 1e9
19 | nsec = nsec % 1e9
20 | if nsec < 0 {
21 | nsec += 1e9
22 | sec--
23 | }
24 | return setTimespec(sec, nsec)
25 | }
26 |
27 | // TimeToTimespec converts t into a Timespec.
28 | // On some 32-bit systems the range of valid Timespec values are smaller
29 | // than that of time.Time values. So if t is out of the valid range of
30 | // Timespec, it returns a zero Timespec and ERANGE.
31 | func TimeToTimespec(t time.Time) (Timespec, error) {
32 | sec := t.Unix()
33 | nsec := int64(t.Nanosecond())
34 | ts := setTimespec(sec, nsec)
35 |
36 | // Currently all targets have either int32 or int64 for Timespec.Sec.
37 | // If there were a new target with floating point type for it, we have
38 | // to consider the rounding error.
39 | if int64(ts.Sec) != sec {
40 | return Timespec{}, ERANGE
41 | }
42 | return ts, nil
43 | }
44 |
45 | // TimevalToNsec converts a Timeval value into a number of nanoseconds
46 | // since the Unix epoch.
47 | func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
48 |
49 | // NsecToTimeval takes a number of nanoseconds since the Unix epoch
50 | // and returns the corresponding Timeval value.
51 | func NsecToTimeval(nsec int64) Timeval {
52 | nsec += 999 // round up to microsecond
53 | usec := nsec % 1e9 / 1e3
54 | sec := nsec / 1e9
55 | if usec < 0 {
56 | usec += 1e6
57 | sec--
58 | }
59 | return setTimeval(sec, usec)
60 | }
61 |
62 | // Unix returns ts as the number of seconds and nanoseconds elapsed since the
63 | // Unix epoch.
64 | func (ts *Timespec) Unix() (sec int64, nsec int64) {
65 | return int64(ts.Sec), int64(ts.Nsec)
66 | }
67 |
68 | // Unix returns tv as the number of seconds and nanoseconds elapsed since the
69 | // Unix epoch.
70 | func (tv *Timeval) Unix() (sec int64, nsec int64) {
71 | return int64(tv.Sec), int64(tv.Usec) * 1000
72 | }
73 |
74 | // Nano returns ts as the number of nanoseconds elapsed since the Unix epoch.
75 | func (ts *Timespec) Nano() int64 {
76 | return int64(ts.Sec)*1e9 + int64(ts.Nsec)
77 | }
78 |
79 | // Nano returns tv as the number of nanoseconds elapsed since the Unix epoch.
80 | func (tv *Timeval) Nano() int64 {
81 | return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
82 | }
83 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptrace386_linux.go:
--------------------------------------------------------------------------------
1 | // Code generated by linux/mkall.go generatePtracePair(386, amd64). DO NOT EDIT.
2 |
3 | // +build linux
4 | // +build 386 amd64
5 |
6 | package unix
7 |
8 | import "unsafe"
9 |
10 | // PtraceRegs386 is the registers used by 386 binaries.
11 | type PtraceRegs386 struct {
12 | Ebx int32
13 | Ecx int32
14 | Edx int32
15 | Esi int32
16 | Edi int32
17 | Ebp int32
18 | Eax int32
19 | Xds int32
20 | Xes int32
21 | Xfs int32
22 | Xgs int32
23 | Orig_eax int32
24 | Eip int32
25 | Xcs int32
26 | Eflags int32
27 | Esp int32
28 | Xss int32
29 | }
30 |
31 | // PtraceGetRegs386 fetches the registers used by 386 binaries.
32 | func PtraceGetRegs386(pid int, regsout *PtraceRegs386) error {
33 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
34 | }
35 |
36 | // PtraceSetRegs386 sets the registers used by 386 binaries.
37 | func PtraceSetRegs386(pid int, regs *PtraceRegs386) error {
38 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
39 | }
40 |
41 | // PtraceRegsAmd64 is the registers used by amd64 binaries.
42 | type PtraceRegsAmd64 struct {
43 | R15 uint64
44 | R14 uint64
45 | R13 uint64
46 | R12 uint64
47 | Rbp uint64
48 | Rbx uint64
49 | R11 uint64
50 | R10 uint64
51 | R9 uint64
52 | R8 uint64
53 | Rax uint64
54 | Rcx uint64
55 | Rdx uint64
56 | Rsi uint64
57 | Rdi uint64
58 | Orig_rax uint64
59 | Rip uint64
60 | Cs uint64
61 | Eflags uint64
62 | Rsp uint64
63 | Ss uint64
64 | Fs_base uint64
65 | Gs_base uint64
66 | Ds uint64
67 | Es uint64
68 | Fs uint64
69 | Gs uint64
70 | }
71 |
72 | // PtraceGetRegsAmd64 fetches the registers used by amd64 binaries.
73 | func PtraceGetRegsAmd64(pid int, regsout *PtraceRegsAmd64) error {
74 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
75 | }
76 |
77 | // PtraceSetRegsAmd64 sets the registers used by amd64 binaries.
78 | func PtraceSetRegsAmd64(pid int, regs *PtraceRegsAmd64) error {
79 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
80 | }
81 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptracearm_linux.go:
--------------------------------------------------------------------------------
1 | // Code generated by linux/mkall.go generatePtracePair(arm, arm64). DO NOT EDIT.
2 |
3 | // +build linux
4 | // +build arm arm64
5 |
6 | package unix
7 |
8 | import "unsafe"
9 |
10 | // PtraceRegsArm is the registers used by arm binaries.
11 | type PtraceRegsArm struct {
12 | Uregs [18]uint32
13 | }
14 |
15 | // PtraceGetRegsArm fetches the registers used by arm binaries.
16 | func PtraceGetRegsArm(pid int, regsout *PtraceRegsArm) error {
17 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
18 | }
19 |
20 | // PtraceSetRegsArm sets the registers used by arm binaries.
21 | func PtraceSetRegsArm(pid int, regs *PtraceRegsArm) error {
22 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
23 | }
24 |
25 | // PtraceRegsArm64 is the registers used by arm64 binaries.
26 | type PtraceRegsArm64 struct {
27 | Regs [31]uint64
28 | Sp uint64
29 | Pc uint64
30 | Pstate uint64
31 | }
32 |
33 | // PtraceGetRegsArm64 fetches the registers used by arm64 binaries.
34 | func PtraceGetRegsArm64(pid int, regsout *PtraceRegsArm64) error {
35 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
36 | }
37 |
38 | // PtraceSetRegsArm64 sets the registers used by arm64 binaries.
39 | func PtraceSetRegsArm64(pid int, regs *PtraceRegsArm64) error {
40 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
41 | }
42 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptracemips_linux.go:
--------------------------------------------------------------------------------
1 | // Code generated by linux/mkall.go generatePtracePair(mips, mips64). DO NOT EDIT.
2 |
3 | // +build linux
4 | // +build mips mips64
5 |
6 | package unix
7 |
8 | import "unsafe"
9 |
10 | // PtraceRegsMips is the registers used by mips binaries.
11 | type PtraceRegsMips struct {
12 | Regs [32]uint64
13 | Lo uint64
14 | Hi uint64
15 | Epc uint64
16 | Badvaddr uint64
17 | Status uint64
18 | Cause uint64
19 | }
20 |
21 | // PtraceGetRegsMips fetches the registers used by mips binaries.
22 | func PtraceGetRegsMips(pid int, regsout *PtraceRegsMips) error {
23 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
24 | }
25 |
26 | // PtraceSetRegsMips sets the registers used by mips binaries.
27 | func PtraceSetRegsMips(pid int, regs *PtraceRegsMips) error {
28 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
29 | }
30 |
31 | // PtraceRegsMips64 is the registers used by mips64 binaries.
32 | type PtraceRegsMips64 struct {
33 | Regs [32]uint64
34 | Lo uint64
35 | Hi uint64
36 | Epc uint64
37 | Badvaddr uint64
38 | Status uint64
39 | Cause uint64
40 | }
41 |
42 | // PtraceGetRegsMips64 fetches the registers used by mips64 binaries.
43 | func PtraceGetRegsMips64(pid int, regsout *PtraceRegsMips64) error {
44 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
45 | }
46 |
47 | // PtraceSetRegsMips64 sets the registers used by mips64 binaries.
48 | func PtraceSetRegsMips64(pid int, regs *PtraceRegsMips64) error {
49 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
50 | }
51 |
--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptracemipsle_linux.go:
--------------------------------------------------------------------------------
1 | // Code generated by linux/mkall.go generatePtracePair(mipsle, mips64le). DO NOT EDIT.
2 |
3 | // +build linux
4 | // +build mipsle mips64le
5 |
6 | package unix
7 |
8 | import "unsafe"
9 |
10 | // PtraceRegsMipsle is the registers used by mipsle binaries.
11 | type PtraceRegsMipsle struct {
12 | Regs [32]uint64
13 | Lo uint64
14 | Hi uint64
15 | Epc uint64
16 | Badvaddr uint64
17 | Status uint64
18 | Cause uint64
19 | }
20 |
21 | // PtraceGetRegsMipsle fetches the registers used by mipsle binaries.
22 | func PtraceGetRegsMipsle(pid int, regsout *PtraceRegsMipsle) error {
23 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
24 | }
25 |
26 | // PtraceSetRegsMipsle sets the registers used by mipsle binaries.
27 | func PtraceSetRegsMipsle(pid int, regs *PtraceRegsMipsle) error {
28 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
29 | }
30 |
31 | // PtraceRegsMips64le is the registers used by mips64le binaries.
32 | type PtraceRegsMips64le struct {
33 | Regs [32]uint64
34 | Lo uint64
35 | Hi uint64
36 | Epc uint64
37 | Badvaddr uint64
38 | Status uint64
39 | Cause uint64
40 | }
41 |
42 | // PtraceGetRegsMips64le fetches the registers used by mips64le binaries.
43 | func PtraceGetRegsMips64le(pid int, regsout *PtraceRegsMips64le) error {
44 | return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
45 | }
46 |
47 | // PtraceSetRegsMips64le sets the registers used by mips64le binaries.
48 | func PtraceSetRegsMips64le(pid int, regs *PtraceRegsMips64le) error {
49 | return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
50 | }
51 |
--------------------------------------------------------------------------------