scottk/vault
1
0
Fork 0
mirror of https://github.com/optim-enterprises-bv/vault.git synced 2025-11-19 03:14:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Bump deps.

Browse Source
This commit is contained in:
Jeff Mitchell
2016-05-02 20:11:05 -04:00
parent 5f47acad1c
commit e2091c34e7
30 changed files with 1206 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
Godeps/Godeps.json generated
View File

@@ -26,153 +26,153 @@
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws", "ImportPath": "github.com/aws/aws-sdk-go/aws",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/awserr", "ImportPath": "github.com/aws/aws-sdk-go/aws/awserr",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/awsutil", "ImportPath": "github.com/aws/aws-sdk-go/aws/awsutil",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/client", "ImportPath": "github.com/aws/aws-sdk-go/aws/client",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/client/metadata", "ImportPath": "github.com/aws/aws-sdk-go/aws/client/metadata",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/corehandlers", "ImportPath": "github.com/aws/aws-sdk-go/aws/corehandlers",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials", "ImportPath": "github.com/aws/aws-sdk-go/aws/credentials",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds", "ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/defaults", "ImportPath": "github.com/aws/aws-sdk-go/aws/defaults",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/ec2metadata", "ImportPath": "github.com/aws/aws-sdk-go/aws/ec2metadata",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/request", "ImportPath": "github.com/aws/aws-sdk-go/aws/request",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/aws/session", "ImportPath": "github.com/aws/aws-sdk-go/aws/session",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/endpoints", "ImportPath": "github.com/aws/aws-sdk-go/private/endpoints",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/ec2query", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/ec2query",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/jsonrpc", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/jsonrpc",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/rest", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/rest",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/restxml", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/restxml",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil", "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/signer/v4", "ImportPath": "github.com/aws/aws-sdk-go/private/signer/v4",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/private/waiter", "ImportPath": "github.com/aws/aws-sdk-go/private/waiter",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/service/dynamodb", "ImportPath": "github.com/aws/aws-sdk-go/service/dynamodb",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute", "ImportPath": "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/service/ec2", "ImportPath": "github.com/aws/aws-sdk-go/service/ec2",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/service/iam", "ImportPath": "github.com/aws/aws-sdk-go/service/iam",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/service/s3", "ImportPath": "github.com/aws/aws-sdk-go/service/s3",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/aws/aws-sdk-go/service/sts", "ImportPath": "github.com/aws/aws-sdk-go/service/sts",
"Comment": "v1.1.20-13-gd6f37f6", "Comment": "v1.1.22-3-g1915858",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db" "Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
}, },
{ {
"ImportPath": "github.com/bgentry/speakeasy", "ImportPath": "github.com/bgentry/speakeasy",
@@ -180,32 +180,32 @@
}, },
{ {
"ImportPath": "github.com/cloudfoundry-incubator/candiedyaml", "ImportPath": "github.com/cloudfoundry-incubator/candiedyaml",
"Rev": "5cef21e2e4f0fd147973b558d4db7395176bcd95" "Rev": "99c3df83b51532e3615f851d8c2dbb638f5313bf"
}, },
{ {
"ImportPath": "github.com/coreos/etcd/client", "ImportPath": "github.com/coreos/etcd/client",
"Comment": "v2.3.0-556-g7161eee", "Comment": "v2.3.0-644-gfee71b1",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb" "Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
}, },
{ {
"ImportPath": "github.com/coreos/etcd/pkg/pathutil", "ImportPath": "github.com/coreos/etcd/pkg/pathutil",
"Comment": "v2.3.0-556-g7161eee", "Comment": "v2.3.0-644-gfee71b1",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb" "Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
}, },
{ {
"ImportPath": "github.com/coreos/etcd/pkg/tlsutil", "ImportPath": "github.com/coreos/etcd/pkg/tlsutil",
"Comment": "v2.3.0-556-g7161eee", "Comment": "v2.3.0-644-gfee71b1",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb" "Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
}, },
{ {
"ImportPath": "github.com/coreos/etcd/pkg/transport", "ImportPath": "github.com/coreos/etcd/pkg/transport",
"Comment": "v2.3.0-556-g7161eee", "Comment": "v2.3.0-644-gfee71b1",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb" "Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
}, },
{ {
"ImportPath": "github.com/coreos/etcd/pkg/types", "ImportPath": "github.com/coreos/etcd/pkg/types",
"Comment": "v2.3.0-556-g7161eee", "Comment": "v2.3.0-644-gfee71b1",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb" "Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
}, },
{ {
"ImportPath": "github.com/denisenkom/go-mssqldb", "ImportPath": "github.com/denisenkom/go-mssqldb",
@@ -234,7 +234,7 @@
}, },
{ {
"ImportPath": "github.com/go-ldap/ldap", "ImportPath": "github.com/go-ldap/ldap",
"Comment": "v2.2.2-3-g0e7db8e", "Comment": "v2.3.0",
"Rev": "0e7db8eb77695b5a952f0e5d78df9ab160050c73" "Rev": "0e7db8eb77695b5a952f0e5d78df9ab160050c73"
}, },
{ {
@@ -244,27 +244,27 @@
}, },
{ {
"ImportPath": "github.com/gocql/gocql", "ImportPath": "github.com/gocql/gocql",
"Comment": "pre-node-events-267-g1440c60", "Comment": "pre-node-events-293-g2e0390b",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3" "Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
}, },
{ {
"ImportPath": "github.com/gocql/gocql/internal/lru", "ImportPath": "github.com/gocql/gocql/internal/lru",
"Comment": "pre-node-events-267-g1440c60", "Comment": "pre-node-events-293-g2e0390b",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3" "Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
}, },
{ {
"ImportPath": "github.com/gocql/gocql/internal/murmur", "ImportPath": "github.com/gocql/gocql/internal/murmur",
"Comment": "pre-node-events-267-g1440c60", "Comment": "pre-node-events-293-g2e0390b",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3" "Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
}, },
{ {
"ImportPath": "github.com/gocql/gocql/internal/streams", "ImportPath": "github.com/gocql/gocql/internal/streams",
"Comment": "pre-node-events-267-g1440c60", "Comment": "pre-node-events-293-g2e0390b",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3" "Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
}, },
{ {
"ImportPath": "github.com/golang/snappy", "ImportPath": "github.com/golang/snappy",
"Rev": "ec642410cd033af63620b66a91ccbd3c69c2c59a" "Rev": "43fea289edce21979658cbbdb3925390890aa86e"
}, },
{ {
"ImportPath": "github.com/google/go-github/github", "ImportPath": "github.com/google/go-github/github",
@@ -280,8 +280,13 @@
}, },
{ {
"ImportPath": "github.com/hashicorp/consul/api", "ImportPath": "github.com/hashicorp/consul/api",
"Comment": "v0.6.4-256-gadcf935", "Comment": "v0.6.4-268-g9f272b0",
"Rev": "adcf93535058234780f9aaffb40497ba194f60a0" "Rev": "9f272b088131af951ea1f77594905ceae83fd2c1"
},
{
"ImportPath": "github.com/hashicorp/consul/lib",
"Comment": "v0.6.4-268-g9f272b0",
"Rev": "9f272b088131af951ea1f77594905ceae83fd2c1"
}, },
{ {
"ImportPath": "github.com/hashicorp/errwrap", "ImportPath": "github.com/hashicorp/errwrap",
@@ -313,39 +318,39 @@
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl", "ImportPath": "github.com/hashicorp/hcl",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/hcl/ast", "ImportPath": "github.com/hashicorp/hcl/hcl/ast",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/hcl/parser", "ImportPath": "github.com/hashicorp/hcl/hcl/parser",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/hcl/scanner", "ImportPath": "github.com/hashicorp/hcl/hcl/scanner",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/hcl/strconv", "ImportPath": "github.com/hashicorp/hcl/hcl/strconv",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/hcl/token", "ImportPath": "github.com/hashicorp/hcl/hcl/token",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/json/parser", "ImportPath": "github.com/hashicorp/hcl/json/parser",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/json/scanner", "ImportPath": "github.com/hashicorp/hcl/json/scanner",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/hcl/json/token", "ImportPath": "github.com/hashicorp/hcl/json/token",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4" "Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
}, },
{ {
"ImportPath": "github.com/hashicorp/logutils", "ImportPath": "github.com/hashicorp/logutils",
@@ -353,8 +358,8 @@
}, },
{ {
"ImportPath": "github.com/hashicorp/serf/coordinate", "ImportPath": "github.com/hashicorp/serf/coordinate",
"Comment": "v0.7.0-56-ga876af0", "Comment": "v0.7.0-58-gdefb069",
"Rev": "a876af06863abed3e31252a913bad976aeff61df" "Rev": "defb069b1bad9f7cdebc647810cb6ae398a1b617"
}, },
{ {
"ImportPath": "github.com/jmespath/go-jmespath", "ImportPath": "github.com/jmespath/go-jmespath",
@@ -363,13 +368,13 @@
}, },
{ {
"ImportPath": "github.com/lib/pq", "ImportPath": "github.com/lib/pq",
"Comment": "go1.0-cutoff-84-g3cd0097", "Comment": "go1.0-cutoff-86-gdd3290b",
"Rev": "3cd0097429be7d611bb644ef85b42bfb102ceea4" "Rev": "dd3290b2f71a8b30bee8e4e75a337a825263d26f"
}, },
{ {
"ImportPath": "github.com/lib/pq/oid", "ImportPath": "github.com/lib/pq/oid",
"Comment": "go1.0-cutoff-84-g3cd0097", "Comment": "go1.0-cutoff-86-gdd3290b",
"Rev": "3cd0097429be7d611bb644ef85b42bfb102ceea4" "Rev": "dd3290b2f71a8b30bee8e4e75a337a825263d26f"
}, },
{ {
"ImportPath": "github.com/mattn/go-isatty", "ImportPath": "github.com/mattn/go-isatty",
@@ -410,75 +415,75 @@
}, },
{ {
"ImportPath": "golang.org/x/crypto/bcrypt", "ImportPath": "golang.org/x/crypto/bcrypt",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/blowfish", "ImportPath": "golang.org/x/crypto/blowfish",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/cast5", "ImportPath": "golang.org/x/crypto/cast5",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/curve25519", "ImportPath": "golang.org/x/crypto/curve25519",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/md4", "ImportPath": "golang.org/x/crypto/md4",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/openpgp", "ImportPath": "golang.org/x/crypto/openpgp",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/openpgp/armor", "ImportPath": "golang.org/x/crypto/openpgp/armor",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/openpgp/elgamal", "ImportPath": "golang.org/x/crypto/openpgp/elgamal",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/openpgp/errors", "ImportPath": "golang.org/x/crypto/openpgp/errors",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/openpgp/packet", "ImportPath": "golang.org/x/crypto/openpgp/packet",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/openpgp/s2k", "ImportPath": "golang.org/x/crypto/openpgp/s2k",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/ssh", "ImportPath": "golang.org/x/crypto/ssh",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/ssh/agent", "ImportPath": "golang.org/x/crypto/ssh/agent",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/crypto/ssh/terminal", "ImportPath": "golang.org/x/crypto/ssh/terminal",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065" "Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
}, },
{ {
"ImportPath": "golang.org/x/net/context", "ImportPath": "golang.org/x/net/context",
"Rev": "b797637b7aeeed133049c7281bfa31dcc9ca42d6" "Rev": "35ec611a141ee705590b9eb64d673f9e6dfeb1ac"
}, },
{ {
"ImportPath": "golang.org/x/oauth2", "ImportPath": "golang.org/x/oauth2",
"Rev": "7e9cd5d59563851383f8f81a7fbb01213709387c" "Rev": "9ef2eddcc6774e42f998940fe1167216d36a7424"
}, },
{ {
"ImportPath": "golang.org/x/oauth2/internal", "ImportPath": "golang.org/x/oauth2/internal",
"Rev": "7e9cd5d59563851383f8f81a7fbb01213709387c" "Rev": "9ef2eddcc6774e42f998940fe1167216d36a7424"
}, },
{ {
"ImportPath": "golang.org/x/sys/unix", "ImportPath": "golang.org/x/sys/unix",
"Rev": "f64b50fbea64174967a8882830d621a18ee1548e" "Rev": "b776ec39b3e54652e09028aaaaac9757f4f8211a"
}, },
{ {
"ImportPath": "gopkg.in/asn1-ber.v1", "ImportPath": "gopkg.in/asn1-ber.v1",

7
vendor/github.com/aws/aws-sdk-go/aws/request/request.go generated vendored
View File

@@ -221,6 +221,13 @@ func (r *Request) Sign() error {
// //
// Send will sign the request prior to sending. All Send Handlers will // Send will sign the request prior to sending. All Send Handlers will
// be executed in the order they were set. // be executed in the order they were set.
//
// Canceling a request is non-deterministic. If a request has been canceled,
// then the transport will choose, randomly, one of the state channels during
// reads or getting the connection.
//
// readLoop() and getConn(req *Request, cm connectMethod)
// https://github.com/golang/go/blob/master/src/net/http/transport.go
func (r *Request) Send() error { func (r *Request) Send() error {
for { for {
if aws.BoolValue(r.Retryable) { if aws.BoolValue(r.Retryable) {

2
vendor/github.com/aws/aws-sdk-go/aws/version.go generated vendored
View File

@@ -5,4 +5,4 @@ package aws
const SDKName = "aws-sdk-go" const SDKName = "aws-sdk-go"
// SDKVersion is the version of this SDK // SDKVersion is the version of this SDK
const SDKVersion = "1.1.20" const SDKVersion = "1.1.22"

7
vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go generated vendored
View File

@@ -120,7 +120,8 @@ func buildStruct(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag)
name = locName name = locName
} }
fmt.Fprintf(buf, "%q:", name) writeString(name, buf)
buf.WriteString(`:`)
err := buildAny(member, buf, field.Tag) err := buildAny(member, buf, field.Tag)
if err != nil { if err != nil {
@@ -167,7 +168,9 @@ func buildMap(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) err
buf.WriteByte(',') buf.WriteByte(',')
} }
fmt.Fprintf(buf, "%q:", k) writeString(k.String(), buf)
buf.WriteString(`:`)
buildAny(value.MapIndex(k), buf, "") buildAny(value.MapIndex(k), buf, "")
} }

330
vendor/github.com/aws/aws-sdk-go/service/ec2/api.go generated vendored
View File

@@ -1777,6 +1777,11 @@ func (c *EC2) CreateVpcRequest(input *CreateVpcInput) (req *request.Request, out
// which includes only a default DNS server that we provide (AmazonProvidedDNS). // which includes only a default DNS server that we provide (AmazonProvidedDNS).
// For more information about DHCP options, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html) // For more information about DHCP options, see DHCP Options Sets (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_DHCP_Options.html)
// in the Amazon Virtual Private Cloud User Guide. // in the Amazon Virtual Private Cloud User Guide.
//
// You can specify the instance tenancy value for the VPC when you create it.
// You can't change this value for the VPC after you create it. For more information,
// see Dedicated Instances (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/dedicated-instance.html.html)
// in the Amazon Virtual Private Cloud User Guide.
func (c *EC2) CreateVpc(input *CreateVpcInput) (*CreateVpcOutput, error) { func (c *EC2) CreateVpc(input *CreateVpcInput) (*CreateVpcOutput, error) {
req, out := c.CreateVpcRequest(input) req, out := c.CreateVpcRequest(input)
err := req.Send() err := req.Send()
@@ -1887,6 +1892,9 @@ func (c *EC2) CreateVpnConnectionRequest(input *CreateVpnConnectionInput) (req *
// create a new VPN connection, you must reconfigure your customer gateway with // create a new VPN connection, you must reconfigure your customer gateway with
// the new information returned from this call. // the new information returned from this call.
// //
// This is an idempotent operation. If you perform the operation more than
// once, Amazon EC2 doesn't return an error.
//
// For more information about VPN connections, see Adding a Hardware Virtual // For more information about VPN connections, see Adding a Hardware Virtual
// Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html) // Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
// in the Amazon Virtual Private Cloud User Guide. // in the Amazon Virtual Private Cloud User Guide.
@@ -3130,7 +3138,8 @@ func (c *EC2) DescribeIdFormatRequest(input *DescribeIdFormatInput) (req *reques
// request only returns information about resource types whose ID formats can // request only returns information about resource types whose ID formats can
// be modified; it does not return information about other resource types. // be modified; it does not return information about other resource types.
// //
// The following resource types support longer IDs: instance | reservation. // The following resource types support longer IDs: instance | reservation
// | snapshot | volume.
// //
// These settings apply to the IAM user who makes the request; they do not // These settings apply to the IAM user who makes the request; they do not
// apply to the entire AWS account. By default, an IAM user defaults to the // apply to the entire AWS account. By default, an IAM user defaults to the
@@ -3318,7 +3327,8 @@ func (c *EC2) DescribeInstanceStatusRequest(input *DescribeInstanceStatusInput)
return return
} }
// Describes the status of one or more instances. // Describes the status of one or more instances. By default, only running instances
// are described, unless specified otherwise.
// //
// Instance status includes the following components: // Instance status includes the following components:
// //
@@ -3328,7 +3338,7 @@ func (c *EC2) DescribeInstanceStatusRequest(input *DescribeInstanceStatusInput)
// and Troubleshooting Instances with Failed Status Checks (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstances.html) // and Troubleshooting Instances with Failed Status Checks (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstances.html)
// in the Amazon Elastic Compute Cloud User Guide. // in the Amazon Elastic Compute Cloud User Guide.
// //
// Scheduled events - Amazon EC2 can schedule events (such as reboot, stop, // Scheduled events - Amazon EC2 can schedule events (such as reboot, stop,
// or terminate) for your instances related to hardware issues, software updates, // or terminate) for your instances related to hardware issues, software updates,
// or system maintenance. For more information, see Scheduled Events for Your // or system maintenance. For more information, see Scheduled Events for Your
// Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) // Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html)
@@ -5559,7 +5569,7 @@ func (c *EC2) ModifyIdFormatRequest(input *ModifyIdFormatInput) (req *request.Re
// Modifies the ID format for the specified resource on a per-region basis. // Modifies the ID format for the specified resource on a per-region basis.
// You can specify that resources should receive longer IDs (17-character IDs) // You can specify that resources should receive longer IDs (17-character IDs)
// when they are created. The following resource types support longer IDs: instance // when they are created. The following resource types support longer IDs: instance
// | reservation. // | reservation | snapshot | volume.
// //
// This setting applies to the IAM user who makes the request; it does not // This setting applies to the IAM user who makes the request; it does not
// apply to the entire AWS account. By default, an IAM user defaults to the // apply to the entire AWS account. By default, an IAM user defaults to the
@@ -5964,6 +5974,49 @@ func (c *EC2) ModifyVpcEndpoint(input *ModifyVpcEndpointInput) (*ModifyVpcEndpoi
return out, err return out, err
} }
const opModifyVpcPeeringConnectionOptions = "ModifyVpcPeeringConnectionOptions"
// ModifyVpcPeeringConnectionOptionsRequest generates a request for the ModifyVpcPeeringConnectionOptions operation.
func (c *EC2) ModifyVpcPeeringConnectionOptionsRequest(input *ModifyVpcPeeringConnectionOptionsInput) (req *request.Request, output *ModifyVpcPeeringConnectionOptionsOutput) {
op := &request.Operation{
Name: opModifyVpcPeeringConnectionOptions,
HTTPMethod: "POST",
HTTPPath: "/",
}
if input == nil {
input = &ModifyVpcPeeringConnectionOptionsInput{}
}
req = c.newRequest(op, input, output)
output = &ModifyVpcPeeringConnectionOptionsOutput{}
req.Data = output
return
}
// Modifies the VPC peering connection options on one side of a VPC peering
// connection. You can do the following:
//
// Enable/disable communication over the peering connection between an EC2-Classic
// instance that's linked to your VPC (using ClassicLink) and instances in the
// peer VPC.
//
// Enable/disable communication over the peering connection between instances
// in your VPC and an EC2-Classic instance that's linked to the peer VPC.
//
// If the peered VPCs are in different accounts, each owner must initiate
// a separate request to enable or disable communication in either direction,
// depending on whether their VPC was the requester or accepter for the VPC
// peering connection. If the peered VPCs are in the same account, you can modify
// the requester and accepter options in the same request. To confirm which
// VPC is the accepter and requester for a VPC peering connection, use the DescribeVpcPeeringConnections
// command.
func (c *EC2) ModifyVpcPeeringConnectionOptions(input *ModifyVpcPeeringConnectionOptionsInput) (*ModifyVpcPeeringConnectionOptionsOutput, error) {
req, out := c.ModifyVpcPeeringConnectionOptionsRequest(input)
err := req.Send()
return out, err
}
const opMonitorInstances = "MonitorInstances" const opMonitorInstances = "MonitorInstances"
// MonitorInstancesRequest generates a request for the MonitorInstances operation. // MonitorInstancesRequest generates a request for the MonitorInstances operation.
@@ -6091,7 +6144,11 @@ func (c *EC2) PurchaseScheduledInstancesRequest(input *PurchaseScheduledInstance
// Scheduled Instances enable you to purchase Amazon EC2 compute capacity by // Scheduled Instances enable you to purchase Amazon EC2 compute capacity by
// the hour for a one-year term. Before you can purchase a Scheduled Instance, // the hour for a one-year term. Before you can purchase a Scheduled Instance,
// you must call DescribeScheduledInstanceAvailability to check for available // you must call DescribeScheduledInstanceAvailability to check for available
// schedules and obtain a purchase token. // schedules and obtain a purchase token. After you purchase a Scheduled Instance,
// you must call RunScheduledInstances during each scheduled time period.
//
// After you purchase a Scheduled Instance, you can't cancel, modify, or resell
// your purchase.
func (c *EC2) PurchaseScheduledInstances(input *PurchaseScheduledInstancesInput) (*PurchaseScheduledInstancesOutput, error) { func (c *EC2) PurchaseScheduledInstances(input *PurchaseScheduledInstancesInput) (*PurchaseScheduledInstancesOutput, error) {
req, out := c.PurchaseScheduledInstancesRequest(input) req, out := c.PurchaseScheduledInstancesRequest(input)
err := req.Send() err := req.Send()
@@ -6125,8 +6182,8 @@ func (c *EC2) RebootInstancesRequest(input *RebootInstancesInput) (req *request.
// succeeds if the instances are valid and belong to you. Requests to reboot // succeeds if the instances are valid and belong to you. Requests to reboot
// terminated instances are ignored. // terminated instances are ignored.
// //
// If a Linux/Unix instance does not cleanly shut down within four minutes, // If an instance does not cleanly shut down within four minutes, Amazon EC2
// Amazon EC2 performs a hard reboot. // performs a hard reboot.
// //
// For more information about troubleshooting, see Getting Console Output and // For more information about troubleshooting, see Getting Console Output and
// Rebooting Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html) // Rebooting Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-console.html)
@@ -6887,7 +6944,9 @@ func (c *EC2) RunScheduledInstancesRequest(input *RunScheduledInstancesInput) (r
// You must launch a Scheduled Instance during its scheduled time period. You // You must launch a Scheduled Instance during its scheduled time period. You
// can't stop or reboot a Scheduled Instance, but you can terminate it as needed. // can't stop or reboot a Scheduled Instance, but you can terminate it as needed.
// If you terminate a Scheduled Instance before the current scheduled time period // If you terminate a Scheduled Instance before the current scheduled time period
// ends, you can launch it again after a few minutes. // ends, you can launch it again after a few minutes. For more information,
// see Scheduled Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-scheduled-instances.html)
// in the Amazon Elastic Compute Cloud User Guide.
func (c *EC2) RunScheduledInstances(input *RunScheduledInstancesInput) (*RunScheduledInstancesOutput, error) { func (c *EC2) RunScheduledInstances(input *RunScheduledInstancesInput) (*RunScheduledInstancesOutput, error) {
req, out := c.RunScheduledInstancesRequest(input) req, out := c.RunScheduledInstancesRequest(input)
err := req.Send() err := req.Send()
@@ -6959,32 +7018,29 @@ func (c *EC2) StopInstancesRequest(input *StopInstancesInput) (req *request.Requ
return return
} }
// Stops an Amazon EBS-backed instance. Each time you transition an instance // Stops an Amazon EBS-backed instance.
// from stopped to started, Amazon EC2 charges a full instance hour, even if
// transitions happen multiple times within a single hour.
// //
// You can't start or stop Spot instances. // We don't charge hourly usage for a stopped instance, or data transfer fees;
// however, your root partition Amazon EBS volume remains, continues to persist
// your data, and you are charged for Amazon EBS volume usage. Each time you
// transition an instance from stopped to started, Amazon EC2 charges a full
// instance hour, even if transitions happen multiple times within a single
// hour.
// //
// Instances that use Amazon EBS volumes as their root devices can be quickly // You can't start or stop Spot instances, and you can't stop instance store-backed
// stopped and started. When an instance is stopped, the compute resources are // instances.
// released and you are not billed for hourly instance usage. However, your
// root partition Amazon EBS volume remains, continues to persist your data,
// and you are charged for Amazon EBS volume usage. You can restart your instance
// at any time.
// //
// Before stopping an instance, make sure it is in a state from which it can // When you stop an instance, we shut it down. You can restart your instance
// be restarted. Stopping an instance does not preserve data stored in RAM. // at any time. Before stopping an instance, make sure it is in a state from
// which it can be restarted. Stopping an instance does not preserve data stored
// in RAM.
// //
// Performing this operation on an instance that uses an instance store as // Stopping an instance is different to rebooting or terminating it. For example,
// its root device returns an error. // when you stop an instance, the root device and any other devices attached
// // to the instance persist. When you terminate an instance, the root device
// You can stop, start, and terminate EBS-backed instances. You can only terminate // and any other devices attached during the instance launch are automatically
// instance store-backed instances. What happens to an instance differs if you // deleted. For more information about the differences between rebooting, stopping,
// stop it or terminate it. For example, when you stop an instance, the root // and terminating instances, see Instance Lifecycle (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html)
// device and any other devices attached to the instance persist. When you terminate
// an instance, the root device and any other devices attached during the instance
// launch are automatically deleted. For more information about the differences
// between stopping and terminating instances, see Instance Lifecycle (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-lifecycle.html)
// in the Amazon Elastic Compute Cloud User Guide. // in the Amazon Elastic Compute Cloud User Guide.
// //
// For more information about troubleshooting, see Troubleshooting Stopping // For more information about troubleshooting, see Troubleshooting Stopping
@@ -9450,11 +9506,10 @@ type CreateImageInput struct {
// at-signs (@), or underscores(_) // at-signs (@), or underscores(_)
Name *string `locationName:"name" type:"string" required:"true"` Name *string `locationName:"name" type:"string" required:"true"`
// By default, this parameter is set to false, which means Amazon EC2 attempts // By default, Amazon EC2 attempts to shut down and reboot the instance before
// to shut down the instance cleanly before image creation and then reboots // creating the image. If the 'No Reboot' option is set, Amazon EC2 doesn't
// the instance. When the parameter is set to true, Amazon EC2 doesn't shut // shut down the instance before creating the image. When this option is used,
// down the instance before creating the image. When this option is used, file // file system integrity on the created image can't be guaranteed.
// system integrity on the created image can't be guaranteed.
NoReboot *bool `locationName:"noReboot" type:"boolean"` NoReboot *bool `locationName:"noReboot" type:"boolean"`
} }
@@ -10755,11 +10810,11 @@ type CreateVpcInput struct {
// it is UnauthorizedOperation. // it is UnauthorizedOperation.
DryRun *bool `locationName:"dryRun" type:"boolean"` DryRun *bool `locationName:"dryRun" type:"boolean"`
// The supported tenancy options for instances launched into the VPC. A value // The tenancy options for instances launched into the VPC. For default, instances
// of default means that instances can be launched with any tenancy; a value // are launched with shared tenancy by default. You can launch instances with
// of dedicated means all instances launched into the VPC are launched as dedicated // any tenancy into a shared tenancy VPC. For dedicated, instances are launched
// tenancy instances regardless of the tenancy assigned to the instance at launch. // as dedicated tenancy instances by default. You can only launch instances
// Dedicated tenancy instances run on single-tenant hardware. // with a tenancy of dedicated or host into a dedicated tenancy VPC.
// //
// Important: The host value cannot be used with this parameter. Use the default // Important: The host value cannot be used with this parameter. Use the default
// or dedicated values only. // or dedicated values only.
@@ -13282,7 +13337,8 @@ type DescribeImportImageTasksInput struct {
// it is UnauthorizedOperation. // it is UnauthorizedOperation.
DryRun *bool `type:"boolean"` DryRun *bool `type:"boolean"`
// One or more filters. // Filter tasks using the task-state filter and one of the following values:
// active, completed, deleting, deleted.
Filters []*Filter `locationNameList:"Filter" type:"list"` Filters []*Filter `locationNameList:"Filter" type:"list"`
// A list of import image task IDs. // A list of import image task IDs.
@@ -21159,6 +21215,78 @@ func (s ModifyVpcEndpointOutput) GoString() string {
return s.String() return s.String()
} }
type ModifyVpcPeeringConnectionOptionsInput struct {
_ struct{} `type:"structure"`
// The VPC peering connection options for the accepter VPC.
AccepterPeeringConnectionOptions *PeeringConnectionOptionsRequest `type:"structure"`
// Checks whether you have the required permissions for the operation, without
// actually making the request, and provides an error response. If you have
// the required permissions, the error response is DryRunOperation. Otherwise,
// it is UnauthorizedOperation.
DryRun *bool `type:"boolean"`
// The VPC peering connection options for the requester VPC.
RequesterPeeringConnectionOptions *PeeringConnectionOptionsRequest `type:"structure"`
// The ID of the VPC peering connection.
VpcPeeringConnectionId *string `type:"string" required:"true"`
}
// String returns the string representation
func (s ModifyVpcPeeringConnectionOptionsInput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ModifyVpcPeeringConnectionOptionsInput) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *ModifyVpcPeeringConnectionOptionsInput) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "ModifyVpcPeeringConnectionOptionsInput"}
if s.VpcPeeringConnectionId == nil {
invalidParams.Add(request.NewErrParamRequired("VpcPeeringConnectionId"))
}
if s.AccepterPeeringConnectionOptions != nil {
if err := s.AccepterPeeringConnectionOptions.Validate(); err != nil {
invalidParams.AddNested("AccepterPeeringConnectionOptions", err.(request.ErrInvalidParams))
}
}
if s.RequesterPeeringConnectionOptions != nil {
if err := s.RequesterPeeringConnectionOptions.Validate(); err != nil {
invalidParams.AddNested("RequesterPeeringConnectionOptions", err.(request.ErrInvalidParams))
}
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
type ModifyVpcPeeringConnectionOptionsOutput struct {
_ struct{} `type:"structure"`
// Information about the VPC peering connection options for the accepter VPC.
AccepterPeeringConnectionOptions *PeeringConnectionOptions `locationName:"accepterPeeringConnectionOptions" type:"structure"`
// Information about the VPC peering connection options for the requester VPC.
RequesterPeeringConnectionOptions *PeeringConnectionOptions `locationName:"requesterPeeringConnectionOptions" type:"structure"`
}
// String returns the string representation
func (s ModifyVpcPeeringConnectionOptionsOutput) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s ModifyVpcPeeringConnectionOptionsOutput) GoString() string {
return s.String()
}
// Contains the parameters for MonitorInstances. // Contains the parameters for MonitorInstances.
type MonitorInstancesInput struct { type MonitorInstancesInput struct {
_ struct{} `type:"structure"` _ struct{} `type:"structure"`
@@ -21706,6 +21834,68 @@ func (s NewDhcpConfiguration) GoString() string {
return s.String() return s.String()
} }
// Describes the VPC peering connection options.
type PeeringConnectionOptions struct {
_ struct{} `type:"structure"`
// If true, enables outbound communication from an EC2-Classic instance that's
// linked to a local VPC via ClassicLink to instances in a peer VPC.
AllowEgressFromLocalClassicLinkToRemoteVpc *bool `locationName:"allowEgressFromLocalClassicLinkToRemoteVpc" type:"boolean"`
// If true, enables outbound communication from instances in a local VPC to
// an EC2-Classic instance that's linked to a peer VPC via ClassicLink.
AllowEgressFromLocalVpcToRemoteClassicLink *bool `locationName:"allowEgressFromLocalVpcToRemoteClassicLink" type:"boolean"`
}
// String returns the string representation
func (s PeeringConnectionOptions) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s PeeringConnectionOptions) GoString() string {
return s.String()
}
// The VPC peering connection options.
type PeeringConnectionOptionsRequest struct {
_ struct{} `type:"structure"`
// If true, enables outbound communication from an EC2-Classic instance that's
// linked to a local VPC via ClassicLink to instances in a peer VPC.
AllowEgressFromLocalClassicLinkToRemoteVpc *bool `type:"boolean" required:"true"`
// If true, enables outbound communication from instances in a local VPC to
// an EC2-Classic instance that's linked to a peer VPC via ClassicLink.
AllowEgressFromLocalVpcToRemoteClassicLink *bool `type:"boolean" required:"true"`
}
// String returns the string representation
func (s PeeringConnectionOptionsRequest) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s PeeringConnectionOptionsRequest) GoString() string {
return s.String()
}
// Validate inspects the fields of the type to determine if they are valid.
func (s *PeeringConnectionOptionsRequest) Validate() error {
invalidParams := request.ErrInvalidParams{Context: "PeeringConnectionOptionsRequest"}
if s.AllowEgressFromLocalClassicLinkToRemoteVpc == nil {
invalidParams.Add(request.NewErrParamRequired("AllowEgressFromLocalClassicLinkToRemoteVpc"))
}
if s.AllowEgressFromLocalVpcToRemoteClassicLink == nil {
invalidParams.Add(request.NewErrParamRequired("AllowEgressFromLocalVpcToRemoteClassicLink"))
}
if invalidParams.Len() > 0 {
return invalidParams
}
return nil
}
// Describes the placement for the instance. // Describes the placement for the instance.
type Placement struct { type Placement struct {
_ struct{} `type:"structure"` _ struct{} `type:"structure"`
@@ -25698,29 +25888,28 @@ type StateReason struct {
// The message for the state change. // The message for the state change.
// //
// Server.SpotInstanceTermination: A Spot instance was terminated due to // Server.SpotInstanceTermination: A Spot instance was terminated due to an
// an increase in the market price. // increase in the market price.
// //
// Server.InternalError: An internal error occurred during instance launch, // Server.InternalError: An internal error occurred during instance launch,
// resulting in termination. // resulting in termination.
// //
// Server.InsufficientInstanceCapacity: There was insufficient instance capacity // Server.InsufficientInstanceCapacity: There was insufficient instance capacity
// to satisfy the launch request. // to satisfy the launch request.
// //
// Client.InternalError: A client error caused the instance to terminate // Client.InternalError: A client error caused the instance to terminate on
// on launch. // launch.
// //
// Client.InstanceInitiatedShutdown: The instance was shut down using the // Client.InstanceInitiatedShutdown: The instance was shut down using the shutdown
// shutdown -h command from the instance. // -h command from the instance.
// //
// Client.UserInitiatedShutdown: The instance was shut down using the Amazon // Client.UserInitiatedShutdown: The instance was shut down using the Amazon
// EC2 API. // EC2 API.
// //
// Client.VolumeLimitExceeded: The limit on the number of EBS volumes or // Client.VolumeLimitExceeded: The limit on the number of EBS volumes or total
// total storage was exceeded. Decrease usage or request an increase in your // storage was exceeded. Decrease usage or request an increase in your limits.
// limits.
// //
// Client.InvalidSnapshot.NotFound: The specified snapshot was not found. // Client.InvalidSnapshot.NotFound: The specified snapshot was not found.
Message *string `locationName:"message" type:"string"` Message *string `locationName:"message" type:"string"`
} }
@@ -26627,13 +26816,15 @@ func (s VpcEndpoint) GoString() string {
type VpcPeeringConnection struct { type VpcPeeringConnection struct {
_ struct{} `type:"structure"` _ struct{} `type:"structure"`
// The information of the peer VPC. // Information about the peer VPC. CIDR block information is not returned when
// creating a VPC peering connection, or when describing a VPC peering connection
// that's in the initiating-request or pending-acceptance state.
AccepterVpcInfo *VpcPeeringConnectionVpcInfo `locationName:"accepterVpcInfo" type:"structure"` AccepterVpcInfo *VpcPeeringConnectionVpcInfo `locationName:"accepterVpcInfo" type:"structure"`
// The time that an unaccepted VPC peering connection will expire. // The time that an unaccepted VPC peering connection will expire.
ExpirationTime *time.Time `locationName:"expirationTime" type:"timestamp" timestampFormat:"iso8601"` ExpirationTime *time.Time `locationName:"expirationTime" type:"timestamp" timestampFormat:"iso8601"`
// The information of the requester VPC. // Information about the requester VPC.
RequesterVpcInfo *VpcPeeringConnectionVpcInfo `locationName:"requesterVpcInfo" type:"structure"` RequesterVpcInfo *VpcPeeringConnectionVpcInfo `locationName:"requesterVpcInfo" type:"structure"`
// The status of the VPC peering connection. // The status of the VPC peering connection.
@@ -26656,6 +26847,29 @@ func (s VpcPeeringConnection) GoString() string {
return s.String() return s.String()
} }
// Describes the VPC peering connection options.
type VpcPeeringConnectionOptionsDescription struct {
_ struct{} `type:"structure"`
// Indicates whether a local ClassicLink connection can communicate with the
// peer VPC over the VPC peering connection.
AllowEgressFromLocalClassicLinkToRemoteVpc *bool `locationName:"allowEgressFromLocalClassicLinkToRemoteVpc" type:"boolean"`
// Indicates whether a local VPC can communicate with a ClassicLink connection
// in the peer VPC over the VPC peering connection.
AllowEgressFromLocalVpcToRemoteClassicLink *bool `locationName:"allowEgressFromLocalVpcToRemoteClassicLink" type:"boolean"`
}
// String returns the string representation
func (s VpcPeeringConnectionOptionsDescription) String() string {
return awsutil.Prettify(s)
}
// GoString returns the string representation
func (s VpcPeeringConnectionOptionsDescription) GoString() string {
return s.String()
}
// Describes the status of a VPC peering connection. // Describes the status of a VPC peering connection.
type VpcPeeringConnectionStateReason struct { type VpcPeeringConnectionStateReason struct {
_ struct{} `type:"structure"` _ struct{} `type:"structure"`
@@ -26687,6 +26901,10 @@ type VpcPeeringConnectionVpcInfo struct {
// The AWS account ID of the VPC owner. // The AWS account ID of the VPC owner.
OwnerId *string `locationName:"ownerId" type:"string"` OwnerId *string `locationName:"ownerId" type:"string"`
// Information about the VPC peering connection options for the accepter or
// requester VPC.
PeeringOptions *VpcPeeringConnectionOptionsDescription `locationName:"peeringOptions" type:"structure"`
// The ID of the VPC. // The ID of the VPC.
VpcId *string `locationName:"vpcId" type:"string"` VpcId *string `locationName:"vpcId" type:"string"`
} }

207
vendor/github.com/aws/aws-sdk-go/service/sts/api.go generated vendored
View File

@@ -39,7 +39,7 @@ func (c *STS) AssumeRoleRequest(input *AssumeRoleInput) (req *request.Request, o
// and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison) // and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison)
// in the IAM User Guide. // in the IAM User Guide.
// //
// Important: You cannot call AssumeRole by using AWS root account credentials; // Important: You cannot call AssumeRole by using AWS root account credentials;
// access is denied. You must use IAM user credentials or temporary security // access is denied. You must use IAM user credentials or temporary security
// credentials to call AssumeRole. // credentials to call AssumeRole.
// //
@@ -78,8 +78,8 @@ func (c *STS) AssumeRoleRequest(input *AssumeRoleInput) (req *request.Request, o
// policy of the role that is being assumed. If you pass a policy to this operation, // policy of the role that is being assumed. If you pass a policy to this operation,
// the temporary security credentials that are returned by the operation have // the temporary security credentials that are returned by the operation have
// the permissions that are allowed by both the access policy of the role that // the permissions that are allowed by both the access policy of the role that
// is being assumed, and the policy that you pass. This gives you a way to further // is being assumed, and the policy that you pass. This gives you a way to
// restrict the permissions for the resulting temporary security credentials. // further restrict the permissions for the resulting temporary security credentials.
// You cannot use the passed policy to grant permissions that are in excess // You cannot use the passed policy to grant permissions that are in excess
// of those allowed by the access policy of the role that is being assumed. // of those allowed by the access policy of the role that is being assumed.
// For more information, see Permissions for AssumeRole, AssumeRoleWithSAML, // For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,
@@ -174,8 +174,8 @@ func (c *STS) AssumeRoleWithSAMLRequest(input *AssumeRoleWithSAMLInput) (req *re
// policy of the role that is being assumed. If you pass a policy to this operation, // policy of the role that is being assumed. If you pass a policy to this operation,
// the temporary security credentials that are returned by the operation have // the temporary security credentials that are returned by the operation have
// the permissions that are allowed by both the access policy of the role that // the permissions that are allowed by both the access policy of the role that
// is being assumed, and the policy that you pass. This gives you a way to further // is being assumed, and the policy that you pass. This gives you a way to
// restrict the permissions for the resulting temporary security credentials. // further restrict the permissions for the resulting temporary security credentials.
// You cannot use the passed policy to grant permissions that are in excess // You cannot use the passed policy to grant permissions that are in excess
// of those allowed by the access policy of the role that is being assumed. // of those allowed by the access policy of the role that is being assumed.
// For more information, see Permissions for AssumeRole, AssumeRoleWithSAML, // For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,
@@ -192,12 +192,24 @@ func (c *STS) AssumeRoleWithSAMLRequest(input *AssumeRoleWithSAMLInput) (req *re
// The identity of the caller is validated by using keys in the metadata document // The identity of the caller is validated by using keys in the metadata document
// that is uploaded for the SAML provider entity for your identity provider. // that is uploaded for the SAML provider entity for your identity provider.
// //
// For more information, see the following resources: // Calling AssumeRoleWithSAML can result in an entry in your AWS CloudTrail
// logs. The entry includes the value in the NameID element of the SAML assertion.
// We recommend that you use a NameIDType that is not associated with any personally
// identifiable information (PII). For example, you could instead use the Persistent
// Identifier (urn:oasis:names:tc:SAML:2.0:nameid-format:persistent).
// //
// About SAML 2.0-based Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html) // For more information, see the following resources:
// in the IAM User Guide. Creating SAML Identity Providers (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html) //
// in the IAM User Guide. Configuring a Relying Party and Claims (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html) // About SAML 2.0-based Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html)
// in the IAM User Guide. Creating a Role for SAML 2.0 Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html) // in the IAM User Guide.
//
// Creating SAML Identity Providers (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml.html)
// in the IAM User Guide.
//
// Configuring a Relying Party and Claims (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_saml_relying-party.html)
// in the IAM User Guide.
//
// Creating a Role for SAML 2.0 Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_saml.html)
// in the IAM User Guide. // in the IAM User Guide.
func (c *STS) AssumeRoleWithSAML(input *AssumeRoleWithSAMLInput) (*AssumeRoleWithSAMLOutput, error) { func (c *STS) AssumeRoleWithSAML(input *AssumeRoleWithSAMLInput) (*AssumeRoleWithSAMLOutput, error) {
req, out := c.AssumeRoleWithSAMLRequest(input) req, out := c.AssumeRoleWithSAMLRequest(input)
@@ -270,8 +282,8 @@ func (c *STS) AssumeRoleWithWebIdentityRequest(input *AssumeRoleWithWebIdentityI
// policy of the role that is being assumed. If you pass a policy to this operation, // policy of the role that is being assumed. If you pass a policy to this operation,
// the temporary security credentials that are returned by the operation have // the temporary security credentials that are returned by the operation have
// the permissions that are allowed by both the access policy of the role that // the permissions that are allowed by both the access policy of the role that
// is being assumed, and the policy that you pass. This gives you a way to further // is being assumed, and the policy that you pass. This gives you a way to
// restrict the permissions for the resulting temporary security credentials. // further restrict the permissions for the resulting temporary security credentials.
// You cannot use the passed policy to grant permissions that are in excess // You cannot use the passed policy to grant permissions that are in excess
// of those allowed by the access policy of the role that is being assumed. // of those allowed by the access policy of the role that is being assumed.
// For more information, see Permissions for AssumeRole, AssumeRoleWithSAML, // For more information, see Permissions for AssumeRole, AssumeRoleWithSAML,
@@ -284,19 +296,30 @@ func (c *STS) AssumeRoleWithWebIdentityRequest(input *AssumeRoleWithWebIdentityI
// the identity provider that is associated with the identity token. In other // the identity provider that is associated with the identity token. In other
// words, the identity provider must be specified in the role's trust policy. // words, the identity provider must be specified in the role's trust policy.
// //
// For more information about how to use web identity federation and the AssumeRoleWithWebIdentity // Calling AssumeRoleWithWebIdentity can result in an entry in your AWS CloudTrail
// logs. The entry includes the Subject (http://openid.net/specs/openid-connect-core-1_0.html#Claims)
// of the provided Web Identity Token. We recommend that you avoid using any
// personally identifiable information (PII) in this field. For example, you
// could instead use a GUID or a pairwise identifier, as suggested in the OIDC
// specification (http://openid.net/specs/openid-connect-core-1_0.html#SubjectIDTypes).
//
// For more information about how to use web identity federation and the AssumeRoleWithWebIdentity
// API, see the following resources: // API, see the following resources:
// //
// Using Web Identity Federation APIs for Mobile Apps (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_manual) // Using Web Identity Federation APIs for Mobile Apps (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_manual)
// and Federation Through a Web-based Identity Provider (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity). // and Federation Through a Web-based Identity Provider (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity).
// Web Identity Federation Playground (https://web-identity-federation-playground.s3.amazonaws.com/index.html). //
// Web Identity Federation Playground (https://web-identity-federation-playground.s3.amazonaws.com/index.html).
// This interactive website lets you walk through the process of authenticating // This interactive website lets you walk through the process of authenticating
// via Login with Amazon, Facebook, or Google, getting temporary security credentials, // via Login with Amazon, Facebook, or Google, getting temporary security credentials,
// and then using those credentials to make a request to AWS. AWS SDK for iOS // and then using those credentials to make a request to AWS.
// (http://aws.amazon.com/sdkforios/) and AWS SDK for Android (http://aws.amazon.com/sdkforandroid/). //
// These toolkits contain sample apps that show how to invoke the identity providers, // AWS SDK for iOS (http://aws.amazon.com/sdkforios/) and AWS SDK for Android
// and then how to use the information from these providers to get and use temporary // (http://aws.amazon.com/sdkforandroid/). These toolkits contain sample apps
// security credentials. Web Identity Federation with Mobile Applications (http://aws.amazon.com/articles/4617974389850313). // that show how to invoke the identity providers, and then how to use the information
// from these providers to get and use temporary security credentials.
//
// Web Identity Federation with Mobile Applications (http://aws.amazon.com/articles/4617974389850313).
// This article discusses web identity federation and shows an example of how // This article discusses web identity federation and shows an example of how
// to use web identity federation to get access to content in Amazon S3. // to use web identity federation to get access to content in Amazon S3.
func (c *STS) AssumeRoleWithWebIdentity(input *AssumeRoleWithWebIdentityInput) (*AssumeRoleWithWebIdentityOutput, error) { func (c *STS) AssumeRoleWithWebIdentity(input *AssumeRoleWithWebIdentityInput) (*AssumeRoleWithWebIdentityOutput, error) {
@@ -335,20 +358,28 @@ func (c *STS) DecodeAuthorizationMessageRequest(input *DecodeAuthorizationMessag
// //
// Only certain AWS actions return an encoded authorization message. The documentation // Only certain AWS actions return an encoded authorization message. The documentation
// for an individual action indicates whether that action returns an encoded // for an individual action indicates whether that action returns an encoded
// message in addition to returning an HTTP code. The message is encoded because // message in addition to returning an HTTP code.
// the details of the authorization status can constitute privileged information //
// that the user who requested the action should not see. To decode an authorization // The message is encoded because the details of the authorization status
// status message, a user must be granted permissions via an IAM policy to request // can constitute privileged information that the user who requested the action
// the DecodeAuthorizationMessage (sts:DecodeAuthorizationMessage) action. // should not see. To decode an authorization status message, a user must be
// granted permissions via an IAM policy to request the DecodeAuthorizationMessage
// (sts:DecodeAuthorizationMessage) action.
// //
// The decoded message includes the following type of information: // The decoded message includes the following type of information:
// //
// Whether the request was denied due to an explicit deny or due to the absence // Whether the request was denied due to an explicit deny or due to the absence
// of an explicit allow. For more information, see Determining Whether a Request // of an explicit allow. For more information, see Determining Whether a Request
// is Allowed or Denied (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-denyallow) // is Allowed or Denied (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html#policy-eval-denyallow)
// in the IAM User Guide. The principal who made the request. The requested // in the IAM User Guide.
// action. The requested resource. The values of condition keys in the context //
// of the user's request. // The principal who made the request.
//
// The requested action.
//
// The requested resource.
//
// The values of condition keys in the context of the user's request.
func (c *STS) DecodeAuthorizationMessage(input *DecodeAuthorizationMessageInput) (*DecodeAuthorizationMessageOutput, error) { func (c *STS) DecodeAuthorizationMessage(input *DecodeAuthorizationMessageInput) (*DecodeAuthorizationMessageOutput, error) {
req, out := c.DecodeAuthorizationMessageRequest(input) req, out := c.DecodeAuthorizationMessageRequest(input)
err := req.Send() err := req.Send()
@@ -449,17 +480,20 @@ func (c *STS) GetFederationTokenRequest(input *GetFederationTokenInput) (req *re
// The permissions for the temporary security credentials returned by GetFederationToken // The permissions for the temporary security credentials returned by GetFederationToken
// are determined by a combination of the following: // are determined by a combination of the following:
// //
// The policy or policies that are attached to the IAM user whose credentials // The policy or policies that are attached to the IAM user whose credentials
// are used to call GetFederationToken. The policy that is passed as a parameter // are used to call GetFederationToken.
// in the call. The passed policy is attached to the temporary security credentials //
// that result from the GetFederationToken API call--that is, to the federated // The policy that is passed as a parameter in the call.
// user. When the federated user makes an AWS request, AWS evaluates the policy //
// attached to the federated user in combination with the policy or policies // The passed policy is attached to the temporary security credentials that
// attached to the IAM user whose credentials were used to call GetFederationToken. // result from the GetFederationToken API call--that is, to the federated user.
// AWS allows the federated user's request only when both the federated user // When the federated user makes an AWS request, AWS evaluates the policy attached
// and the IAM user are explicitly allowed to perform the requested action. // to the federated user in combination with the policy or policies attached
// The passed policy cannot grant more permissions than those that are defined // to the IAM user whose credentials were used to call GetFederationToken. AWS
// in the IAM user policy. // allows the federated user's request only when both the federated user and
// the IAM user are explicitly allowed to perform the requested action. The
// passed policy cannot grant more permissions than those that are defined in
// the IAM user policy.
// //
// A typical use case is that the permissions of the IAM user whose credentials // A typical use case is that the permissions of the IAM user whose credentials
// are used to call GetFederationToken are designed to allow access to all the // are used to call GetFederationToken are designed to allow access to all the
@@ -573,6 +607,10 @@ type AssumeRoleInput struct {
// created it. For more information about the external ID, see How to Use an // created it. For more information about the external ID, see How to Use an
// External ID When Granting Access to Your AWS Resources to a Third Party (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) // External ID When Granting Access to Your AWS Resources to a Third Party (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html)
// in the IAM User Guide. // in the IAM User Guide.
//
// The format for this parameter, as described by its regex pattern, is a string
// of characters consisting of upper- and lower-case alphanumeric characters
// with no spaces. You can also include any of the following characters: =,.@:\/-
ExternalId *string `min:"2" type:"string"` ExternalId *string `min:"2" type:"string"`
// An IAM policy in JSON format. // An IAM policy in JSON format.
@@ -588,7 +626,13 @@ type AssumeRoleInput struct {
// and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html) // and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
// in the IAM User Guide. // in the IAM User Guide.
// //
// The policy plain text must be 2048 bytes or shorter. However, an internal // The format for this parameter, as described by its regex pattern, is a string
// of characters up to 2048 characters in length. The characters can be any
// ASCII character from the space character to the end of the valid character
// list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
// and carriage return (\u000D) characters.
//
// The policy plain text must be 2048 bytes or shorter. However, an internal
// conversion compresses it into a packed binary format with a separate limit. // conversion compresses it into a packed binary format with a separate limit.
// The PackedPolicySize response element indicates by percentage how close to // The PackedPolicySize response element indicates by percentage how close to
// the upper size limit the policy is, with 100% equaling the maximum allowed // the upper size limit the policy is, with 100% equaling the maximum allowed
@@ -607,6 +651,10 @@ type AssumeRoleInput struct {
// of the assumed role principal. This means that subsequent cross-account API // of the assumed role principal. This means that subsequent cross-account API
// requests using the temporary security credentials will expose the role session // requests using the temporary security credentials will expose the role session
// name to the external account in their CloudTrail logs. // name to the external account in their CloudTrail logs.
//
// The format for this parameter, as described by its regex pattern, is a string
// of characters consisting of upper- and lower-case alphanumeric characters
// with no spaces. You can also include any of the following characters: =,.@-
RoleSessionName *string `min:"2" type:"string" required:"true"` RoleSessionName *string `min:"2" type:"string" required:"true"`
// The identification number of the MFA device that is associated with the user // The identification number of the MFA device that is associated with the user
@@ -614,12 +662,19 @@ type AssumeRoleInput struct {
// of the role being assumed includes a condition that requires MFA authentication. // of the role being assumed includes a condition that requires MFA authentication.
// The value is either the serial number for a hardware device (such as GAHT12345678) // The value is either the serial number for a hardware device (such as GAHT12345678)
// or an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user). // or an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).
//
// The format for this parameter, as described by its regex pattern, is a string
// of characters consisting of upper- and lower-case alphanumeric characters
// with no spaces. You can also include any of the following characters: =,.@-
SerialNumber *string `min:"9" type:"string"` SerialNumber *string `min:"9" type:"string"`
// The value provided by the MFA device, if the trust policy of the role being // The value provided by the MFA device, if the trust policy of the role being
// assumed requires MFA (that is, if the policy includes a condition that tests // assumed requires MFA (that is, if the policy includes a condition that tests
// for MFA). If the role being assumed requires MFA and if the TokenCode value // for MFA). If the role being assumed requires MFA and if the TokenCode value
// is missing or expired, the AssumeRole call returns an "access denied" error. // is missing or expired, the AssumeRole call returns an "access denied" error.
//
// The format for this parameter, as described by its regex pattern, is a sequence
// of six numeric digits.
TokenCode *string `min:"6" type:"string"` TokenCode *string `min:"6" type:"string"`
} }
@@ -685,7 +740,7 @@ type AssumeRoleOutput struct {
// The temporary security credentials, which include an access key ID, a secret // The temporary security credentials, which include an access key ID, a secret
// access key, and a security (or session) token. // access key, and a security (or session) token.
// //
// Note: The size of the security token that STS APIs return is not fixed. // Note: The size of the security token that STS APIs return is not fixed.
// We strongly recommend that you make no assumptions about the maximum size. // We strongly recommend that you make no assumptions about the maximum size.
// As of this writing, the typical size is less than 4096 bytes, but that can // As of this writing, the typical size is less than 4096 bytes, but that can
// vary. Also, future updates to AWS might require larger sizes. // vary. Also, future updates to AWS might require larger sizes.
@@ -716,8 +771,8 @@ type AssumeRoleWithSAMLInput struct {
// response's SessionNotOnOrAfter value. The actual expiration time is whichever // response's SessionNotOnOrAfter value. The actual expiration time is whichever
// value is shorter. // value is shorter.
// //
// The maximum duration for a session is 1 hour, and the minimum duration is // The maximum duration for a session is 1 hour, and the minimum duration
// 15 minutes, even if values outside this range are specified. // is 15 minutes, even if values outside this range are specified.
DurationSeconds *int64 `min:"900" type:"integer"` DurationSeconds *int64 `min:"900" type:"integer"`
// An IAM policy in JSON format. // An IAM policy in JSON format.
@@ -725,15 +780,21 @@ type AssumeRoleWithSAMLInput struct {
// The policy parameter is optional. If you pass a policy, the temporary security // The policy parameter is optional. If you pass a policy, the temporary security
// credentials that are returned by the operation have the permissions that // credentials that are returned by the operation have the permissions that
// are allowed by both the access policy of the role that is being assumed, // are allowed by both the access policy of the role that is being assumed,
// and the policy that you pass. This gives you a way to further restrict the // and the policy that you pass. This gives you a way to further restrict
// permissions for the resulting temporary security credentials. You cannot // the permissions for the resulting temporary security credentials. You cannot
// use the passed policy to grant permissions that are in excess of those allowed // use the passed policy to grant permissions that are in excess of those allowed
// by the access policy of the role that is being assumed. For more information, // by the access policy of the role that is being assumed. For more information,
// Permissions for AssumeRole, AssumeRoleWithSAML, and AssumeRoleWithWebIdentity // Permissions for AssumeRole, AssumeRoleWithSAML, and AssumeRoleWithWebIdentity
// (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html) // (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
// in the IAM User Guide. // in the IAM User Guide.
// //
// The policy plain text must be 2048 bytes or shorter. However, an internal // The format for this parameter, as described by its regex pattern, is a string
// of characters up to 2048 characters in length. The characters can be any
// ASCII character from the space character to the end of the valid character
// list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
// and carriage return (\u000D) characters.
//
// The policy plain text must be 2048 bytes or shorter. However, an internal
// conversion compresses it into a packed binary format with a separate limit. // conversion compresses it into a packed binary format with a separate limit.
// The PackedPolicySize response element indicates by percentage how close to // The PackedPolicySize response element indicates by percentage how close to
// the upper size limit the policy is, with 100% equaling the maximum allowed // the upper size limit the policy is, with 100% equaling the maximum allowed
@@ -815,7 +876,7 @@ type AssumeRoleWithSAMLOutput struct {
// The temporary security credentials, which include an access key ID, a secret // The temporary security credentials, which include an access key ID, a secret
// access key, and a security (or session) token. // access key, and a security (or session) token.
// //
// Note: The size of the security token that STS APIs return is not fixed. // Note: The size of the security token that STS APIs return is not fixed.
// We strongly recommend that you make no assumptions about the maximum size. // We strongly recommend that you make no assumptions about the maximum size.
// As of this writing, the typical size is less than 4096 bytes, but that can // As of this writing, the typical size is less than 4096 bytes, but that can
// vary. Also, future updates to AWS might require larger sizes. // vary. Also, future updates to AWS might require larger sizes.
@@ -877,14 +938,20 @@ type AssumeRoleWithWebIdentityInput struct {
// The policy parameter is optional. If you pass a policy, the temporary security // The policy parameter is optional. If you pass a policy, the temporary security
// credentials that are returned by the operation have the permissions that // credentials that are returned by the operation have the permissions that
// are allowed by both the access policy of the role that is being assumed, // are allowed by both the access policy of the role that is being assumed,
// and the policy that you pass. This gives you a way to further restrict the // and the policy that you pass. This gives you a way to further restrict
// permissions for the resulting temporary security credentials. You cannot // the permissions for the resulting temporary security credentials. You cannot
// use the passed policy to grant permissions that are in excess of those allowed // use the passed policy to grant permissions that are in excess of those allowed
// by the access policy of the role that is being assumed. For more information, // by the access policy of the role that is being assumed. For more information,
// see Permissions for AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html) // see Permissions for AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
// in the IAM User Guide. // in the IAM User Guide.
// //
// The policy plain text must be 2048 bytes or shorter. However, an internal // The format for this parameter, as described by its regex pattern, is a string
// of characters up to 2048 characters in length. The characters can be any
// ASCII character from the space character to the end of the valid character
// list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
// and carriage return (\u000D) characters.
//
// The policy plain text must be 2048 bytes or shorter. However, an internal
// conversion compresses it into a packed binary format with a separate limit. // conversion compresses it into a packed binary format with a separate limit.
// The PackedPolicySize response element indicates by percentage how close to // The PackedPolicySize response element indicates by percentage how close to
// the upper size limit the policy is, with 100% equaling the maximum allowed // the upper size limit the policy is, with 100% equaling the maximum allowed
@@ -908,6 +975,10 @@ type AssumeRoleWithWebIdentityInput struct {
// That way, the temporary security credentials that your application will use // That way, the temporary security credentials that your application will use
// are associated with that user. This session name is included as part of the // are associated with that user. This session name is included as part of the
// ARN and assumed role ID in the AssumedRoleUser response element. // ARN and assumed role ID in the AssumedRoleUser response element.
//
// The format for this parameter, as described by its regex pattern, is a string
// of characters consisting of upper- and lower-case alphanumeric characters
// with no spaces. You can also include any of the following characters: =,.@-
RoleSessionName *string `min:"2" type:"string" required:"true"` RoleSessionName *string `min:"2" type:"string" required:"true"`
// The OAuth 2.0 access token or OpenID Connect ID token that is provided by // The OAuth 2.0 access token or OpenID Connect ID token that is provided by
@@ -984,7 +1055,7 @@ type AssumeRoleWithWebIdentityOutput struct {
// The temporary security credentials, which include an access key ID, a secret // The temporary security credentials, which include an access key ID, a secret
// access key, and a security token. // access key, and a security token.
// //
// Note: The size of the security token that STS APIs return is not fixed. // Note: The size of the security token that STS APIs return is not fixed.
// We strongly recommend that you make no assumptions about the maximum size. // We strongly recommend that you make no assumptions about the maximum size.
// As of this writing, the typical size is less than 4096 bytes, but that can // As of this writing, the typical size is less than 4096 bytes, but that can
// vary. Also, future updates to AWS might require larger sizes. // vary. Also, future updates to AWS might require larger sizes.
@@ -1113,8 +1184,7 @@ func (s *DecodeAuthorizationMessageInput) Validate() error {
type DecodeAuthorizationMessageOutput struct { type DecodeAuthorizationMessageOutput struct {
_ struct{} `type:"structure"` _ struct{} `type:"structure"`
// An XML document that contains the decoded message. For more information, // An XML document that contains the decoded message.
// see DecodeAuthorizationMessage.
DecodedMessage *string `type:"string"` DecodedMessage *string `type:"string"`
} }
@@ -1212,6 +1282,10 @@ type GetFederationTokenInput struct {
// temporary security credentials (such as Bob). For example, you can reference // temporary security credentials (such as Bob). For example, you can reference
// the federated user name in a resource-based policy, such as in an Amazon // the federated user name in a resource-based policy, such as in an Amazon
// S3 bucket policy. // S3 bucket policy.
//
// The format for this parameter, as described by its regex pattern, is a string
// of characters consisting of upper- and lower-case alphanumeric characters
// with no spaces. You can also include any of the following characters: =,.@-
Name *string `min:"2" type:"string" required:"true"` Name *string `min:"2" type:"string" required:"true"`
// An IAM policy in JSON format that is passed with the GetFederationToken call // An IAM policy in JSON format that is passed with the GetFederationToken call
@@ -1229,12 +1303,20 @@ type GetFederationTokenInput struct {
// credentials are used to access a resource that has a resource-based policy // credentials are used to access a resource that has a resource-based policy
// that specifically allows the federated user to access the resource. // that specifically allows the federated user to access the resource.
// //
// The policy plain text must be 2048 bytes or shorter. However, an internal // The format for this parameter, as described by its regex pattern, is a string
// of characters up to 2048 characters in length. The characters can be any
// ASCII character from the space character to the end of the valid character
// list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A),
// and carriage return (\u000D) characters.
//
// The policy plain text must be 2048 bytes or shorter. However, an internal
// conversion compresses it into a packed binary format with a separate limit. // conversion compresses it into a packed binary format with a separate limit.
// The PackedPolicySize response element indicates by percentage how close to // The PackedPolicySize response element indicates by percentage how close to
// the upper size limit the policy is, with 100% equaling the maximum allowed // the upper size limit the policy is, with 100% equaling the maximum allowed
// size. For more information about how permissions work, see Permissions for // size.
// GetFederationToken (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html). //
// For more information about how permissions work, see Permissions for GetFederationToken
// (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html).
Policy *string `min:"1" type:"string"` Policy *string `min:"1" type:"string"`
} }
@@ -1278,7 +1360,7 @@ type GetFederationTokenOutput struct {
// The temporary security credentials, which include an access key ID, a secret // The temporary security credentials, which include an access key ID, a secret
// access key, and a security (or session) token. // access key, and a security (or session) token.
// //
// Note: The size of the security token that STS APIs return is not fixed. // Note: The size of the security token that STS APIs return is not fixed.
// We strongly recommend that you make no assumptions about the maximum size. // We strongly recommend that you make no assumptions about the maximum size.
// As of this writing, the typical size is less than 4096 bytes, but that can // As of this writing, the typical size is less than 4096 bytes, but that can
// vary. Also, future updates to AWS might require larger sizes. // vary. Also, future updates to AWS might require larger sizes.
@@ -1324,6 +1406,10 @@ type GetSessionTokenInput struct {
// Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user). // Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user).
// You can find the device for an IAM user by going to the AWS Management Console // You can find the device for an IAM user by going to the AWS Management Console
// and viewing the user's security credentials. // and viewing the user's security credentials.
//
// The format for this parameter, as described by its regex pattern, is a string
// of characters consisting of upper- and lower-case alphanumeric characters
// with no spaces. You can also include any of the following characters: =,.@-
SerialNumber *string `min:"9" type:"string"` SerialNumber *string `min:"9" type:"string"`
// The value provided by the MFA device, if MFA is required. If any policy requires // The value provided by the MFA device, if MFA is required. If any policy requires
@@ -1331,6 +1417,9 @@ type GetSessionTokenInput struct {
// is required, and the user does not provide a code when requesting a set of // is required, and the user does not provide a code when requesting a set of
// temporary security credentials, the user will receive an "access denied" // temporary security credentials, the user will receive an "access denied"
// response when requesting resources that require MFA authentication. // response when requesting resources that require MFA authentication.
//
// The format for this parameter, as described by its regex pattern, is a sequence
// of six numeric digits.
TokenCode *string `min:"6" type:"string"` TokenCode *string `min:"6" type:"string"`
} }
@@ -1371,7 +1460,7 @@ type GetSessionTokenOutput struct {
// The temporary security credentials, which include an access key ID, a secret // The temporary security credentials, which include an access key ID, a secret
// access key, and a security (or session) token. // access key, and a security (or session) token.
// //
// Note: The size of the security token that STS APIs return is not fixed. // Note: The size of the security token that STS APIs return is not fixed.
// We strongly recommend that you make no assumptions about the maximum size. // We strongly recommend that you make no assumptions about the maximum size.
// As of this writing, the typical size is less than 4096 bytes, but that can // As of this writing, the typical size is less than 4096 bytes, but that can
// vary. Also, future updates to AWS might require larger sizes. // vary. Also, future updates to AWS might require larger sizes.

15
vendor/github.com/aws/aws-sdk-go/service/sts/service.go generated vendored
View File

@@ -17,24 +17,25 @@ import (
// This guide provides descriptions of the STS API. For more detailed information // This guide provides descriptions of the STS API. For more detailed information
// about using this service, go to Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html). // about using this service, go to Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html).
// //
// As an alternative to using the API, you can use one of the AWS SDKs, which // As an alternative to using the API, you can use one of the AWS SDKs, which
// consist of libraries and sample code for various programming languages and // consist of libraries and sample code for various programming languages and
// platforms (Java, Ruby, .NET, iOS, Android, etc.). The SDKs provide a convenient // platforms (Java, Ruby, .NET, iOS, Android, etc.). The SDKs provide a convenient
// way to create programmatic access to STS. For example, the SDKs take care // way to create programmatic access to STS. For example, the SDKs take care
// of cryptographically signing requests, managing errors, and retrying requests // of cryptographically signing requests, managing errors, and retrying requests
// automatically. For information about the AWS SDKs, including how to download // automatically. For information about the AWS SDKs, including how to download
// and install them, see the Tools for Amazon Web Services page (http://aws.amazon.com/tools/). // and install them, see the Tools for Amazon Web Services page (http://aws.amazon.com/tools/).
//
// For information about setting up signatures and authorization through the // For information about setting up signatures and authorization through the
// API, go to Signing AWS API Requests (http://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html" // API, go to Signing AWS API Requests (http://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)
// target="_blank) in the AWS General Reference. For general information about // in the AWS General Reference. For general information about the Query API,
// the Query API, go to Making Query Requests (http://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html" // go to Making Query Requests (http://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
// target="_blank) in Using IAM. For information about using security tokens // in Using IAM. For information about using security tokens with other AWS
// with other AWS products, go to AWS Services That Work with IAM (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) // products, go to AWS Services That Work with IAM (http://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html)
// in the IAM User Guide. // in the IAM User Guide.
// //
// If you're new to AWS and need additional technical information about a specific // If you're new to AWS and need additional technical information about a specific
// AWS product, you can find the product's technical documentation at http://aws.amazon.com/documentation/ // AWS product, you can find the product's technical documentation at http://aws.amazon.com/documentation/
// (http://aws.amazon.com/documentation/" target="_blank). // (http://aws.amazon.com/documentation/).
// //
// Endpoints // Endpoints
// //

2
vendor/github.com/cloudfoundry-incubator/candiedyaml/README.md generated vendored
View File

@@ -1,4 +1,6 @@
[![Build Status](https://travis-ci.org/cloudfoundry-incubator/candiedyaml.svg)](https://travis-ci.org/cloudfoundry-incubator/candiedyaml) [![Build Status](https://travis-ci.org/cloudfoundry-incubator/candiedyaml.svg)](https://travis-ci.org/cloudfoundry-incubator/candiedyaml)
[![GoDoc](https://godoc.org/github.com/cloudfoundry-incubator/candiedyaml?status.svg)](https://godoc.org/github.com/cloudfoundry-incubator/candiedyaml)
candiedyaml candiedyaml
=========== ===========

3
vendor/github.com/gocql/gocql/.travis.yml generated vendored
View File

@@ -1,6 +1,7 @@
language: go language: go
sudo: false sudo: required
dist: trusty
cache: cache:
directories: directories:

1
vendor/github.com/gocql/gocql/AUTHORS generated vendored
View File

@@ -67,3 +67,4 @@ nikandfor <nikandfor@gmail.com>
Anthony Woods <awoods@raintank.io> Anthony Woods <awoods@raintank.io>
Alexander Inozemtsev <alexander.inozemtsev@gmail.com> Alexander Inozemtsev <alexander.inozemtsev@gmail.com>
Rob McColl <rob@robmccoll.com>; <rmccoll@ionicsecurity.com> Rob McColl <rob@robmccoll.com>; <rmccoll@ionicsecurity.com>
Viktor Tönköl <viktor.toenkoel@motionlogic.de>

4
vendor/github.com/gocql/gocql/cluster.go generated vendored
View File

@@ -72,6 +72,9 @@ type ClusterConfig struct {
Discovery DiscoveryConfig Discovery DiscoveryConfig
// If not zero, gocql attempt to reconnect known DOWN nodes in every ReconnectSleep.
ReconnectInterval time.Duration
// The maximum amount of time to wait for schema agreement in a cluster after // The maximum amount of time to wait for schema agreement in a cluster after
// receiving a schema change frame. (deault: 60s) // receiving a schema change frame. (deault: 60s)
MaxWaitSchemaAgreement time.Duration MaxWaitSchemaAgreement time.Duration
@@ -126,6 +129,7 @@ func NewCluster(hosts ...string) *ClusterConfig {
PageSize: 5000, PageSize: 5000,
DefaultTimestamp: true, DefaultTimestamp: true,
MaxWaitSchemaAgreement: 60 * time.Second, MaxWaitSchemaAgreement: 60 * time.Second,
ReconnectInterval: 60 * time.Second,
} }
return cfg return cfg
} }

79
vendor/github.com/gocql/gocql/conn.go generated vendored
View File

@@ -9,7 +9,6 @@ import (
"crypto/tls" "crypto/tls"
"errors" "errors"
"fmt" "fmt"
"golang.org/x/net/context"
"io" "io"
"io/ioutil" "io/ioutil"
"log" "log"
@@ -20,6 +19,8 @@ import (
"sync/atomic" "sync/atomic"
"time" "time"
"golang.org/x/net/context"
"github.com/gocql/gocql/internal/lru" "github.com/gocql/gocql/internal/lru"
"github.com/gocql/gocql/internal/streams" "github.com/gocql/gocql/internal/streams"
@@ -127,7 +128,7 @@ type Conn struct {
timeout time.Duration timeout time.Duration
cfg *ConnConfig cfg *ConnConfig
headerBuf []byte headerBuf [maxFrameHeaderSize]byte
streams *streams.IDGenerator streams *streams.IDGenerator
mu sync.RWMutex mu sync.RWMutex
@@ -175,17 +176,6 @@ func Connect(host *HostInfo, addr string, cfg *ConnConfig,
return nil, err return nil, err
} }
// going to default to proto 2
if cfg.ProtoVersion < protoVersion1 || cfg.ProtoVersion > protoVersion4 {
log.Printf("unsupported protocol version: %d using 2\n", cfg.ProtoVersion)
cfg.ProtoVersion = 2
}
headerSize := 8
if cfg.ProtoVersion > protoVersion2 {
headerSize = 9
}
c := &Conn{ c := &Conn{
conn: conn, conn: conn,
r: bufio.NewReader(conn), r: bufio.NewReader(conn),
@@ -197,7 +187,6 @@ func Connect(host *HostInfo, addr string, cfg *ConnConfig,
errorHandler: errorHandler, errorHandler: errorHandler,
compressor: cfg.Compressor, compressor: cfg.Compressor,
auth: cfg.Authenticator, auth: cfg.Authenticator,
headerBuf: make([]byte, headerSize),
quit: make(chan struct{}), quit: make(chan struct{}),
session: session, session: session,
streams: streams.New(cfg.ProtoVersion), streams: streams.New(cfg.ProtoVersion),
@@ -208,33 +197,49 @@ func Connect(host *HostInfo, addr string, cfg *ConnConfig,
c.setKeepalive(cfg.Keepalive) c.setKeepalive(cfg.Keepalive)
} }
var (
ctx context.Context
cancel func()
)
if c.timeout > 0 {
ctx, cancel = context.WithTimeout(context.Background(), c.timeout)
} else {
ctx, cancel = context.WithCancel(context.Background())
}
defer cancel()
frameTicker := make(chan struct{}, 1) frameTicker := make(chan struct{}, 1)
startupErr := make(chan error, 1) startupErr := make(chan error)
go func() { go func() {
for range frameTicker { for range frameTicker {
err := c.recv() err := c.recv()
startupErr <- err
if err != nil { if err != nil {
select {
case startupErr <- err:
case <-ctx.Done():
}
return return
} }
} }
}() }()
err = c.startup(frameTicker) go func() {
close(frameTicker) defer close(frameTicker)
if err != nil { err := c.startup(ctx, frameTicker)
conn.Close() select {
return nil, err case startupErr <- err:
} case <-ctx.Done():
}
}()
select { select {
case err := <-startupErr: case err := <-startupErr:
if err != nil { if err != nil {
log.Println(err)
c.Close() c.Close()
return nil, err return nil, err
} }
case <-time.After(c.timeout): case <-ctx.Done():
c.Close() c.Close()
return nil, errors.New("gocql: no response to connection startup within timeout") return nil, errors.New("gocql: no response to connection startup within timeout")
} }
@@ -275,7 +280,7 @@ func (c *Conn) Read(p []byte) (n int, err error) {
return return
} }
func (c *Conn) startup(frameTicker chan struct{}) error { func (c *Conn) startup(ctx context.Context, frameTicker chan struct{}) error {
m := map[string]string{ m := map[string]string{
"CQL_VERSION": c.cfg.CQLVersion, "CQL_VERSION": c.cfg.CQLVersion,
} }
@@ -284,8 +289,13 @@ func (c *Conn) startup(frameTicker chan struct{}) error {
m["COMPRESSION"] = c.compressor.Name() m["COMPRESSION"] = c.compressor.Name()
} }
frameTicker <- struct{}{} select {
framer, err := c.exec(context.Background(), &writeStartupFrame{opts: m}, nil) case frameTicker <- struct{}{}:
case <-ctx.Done():
return ctx.Err()
}
framer, err := c.exec(ctx, &writeStartupFrame{opts: m}, nil)
if err != nil { if err != nil {
return err return err
} }
@@ -301,13 +311,13 @@ func (c *Conn) startup(frameTicker chan struct{}) error {
case *readyFrame: case *readyFrame:
return nil return nil
case *authenticateFrame: case *authenticateFrame:
return c.authenticateHandshake(v, frameTicker) return c.authenticateHandshake(ctx, v, frameTicker)
default: default:
return NewErrProtocol("Unknown type of response to startup frame: %s", v) return NewErrProtocol("Unknown type of response to startup frame: %s", v)
} }
} }
func (c *Conn) authenticateHandshake(authFrame *authenticateFrame, frameTicker chan struct{}) error { func (c *Conn) authenticateHandshake(ctx context.Context, authFrame *authenticateFrame, frameTicker chan struct{}) error {
if c.auth == nil { if c.auth == nil {
return fmt.Errorf("authentication required (using %q)", authFrame.class) return fmt.Errorf("authentication required (using %q)", authFrame.class)
} }
@@ -320,8 +330,13 @@ func (c *Conn) authenticateHandshake(authFrame *authenticateFrame, frameTicker c
req := &writeAuthResponseFrame{data: resp} req := &writeAuthResponseFrame{data: resp}
for { for {
frameTicker <- struct{}{} select {
framer, err := c.exec(context.Background(), req, nil) case frameTicker <- struct{}{}:
case <-ctx.Done():
return ctx.Err()
}
framer, err := c.exec(ctx, req, nil)
if err != nil { if err != nil {
return err return err
} }
@@ -425,7 +440,7 @@ func (c *Conn) recv() error {
} }
// were just reading headers over and over and copy bodies // were just reading headers over and over and copy bodies
head, err := readHeader(c.r, c.headerBuf) head, err := readHeader(c.r, c.headerBuf[:])
if err != nil { if err != nil {
return err return err
} }

43
vendor/github.com/gocql/gocql/control.go generated vendored
View File

@@ -89,6 +89,22 @@ func (c *controlConn) heartBeat() {
} }
} }
func hostInfo(addr string, defaultPort int) (*HostInfo, error) {
var port int
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
host = addr
port = defaultPort
} else {
port, err = strconv.Atoi(portStr)
if err != nil {
return nil, err
}
}
return &HostInfo{peer: host, port: port}, nil
}
func (c *controlConn) shuffleDial(endpoints []string) (conn *Conn, err error) { func (c *controlConn) shuffleDial(endpoints []string) (conn *Conn, err error) {
perm := randr.Perm(len(endpoints)) perm := randr.Perm(len(endpoints))
shuffled := make([]string, len(endpoints)) shuffled := make([]string, len(endpoints))
@@ -101,24 +117,19 @@ func (c *controlConn) shuffleDial(endpoints []string) (conn *Conn, err error) {
// node. // node.
for _, addr := range shuffled { for _, addr := range shuffled {
if addr == "" { if addr == "" {
return nil, fmt.Errorf("control: invalid address: %q", addr) return nil, fmt.Errorf("invalid address: %q", addr)
} }
port := c.session.cfg.Port port := c.session.cfg.Port
addr = JoinHostPort(addr, port) addr = JoinHostPort(addr, port)
host, portStr, err := net.SplitHostPort(addr)
var host *HostInfo
host, err = hostInfo(addr, port)
if err != nil { if err != nil {
host = addr return nil, fmt.Errorf("invalid address: %q: %v", addr, err)
port = c.session.cfg.Port
err = nil
} else {
port, err = strconv.Atoi(portStr)
if err != nil {
return nil, err
}
} }
hostInfo, _ := c.session.ring.addHostIfMissing(&HostInfo{peer: host, port: port}) hostInfo, _ := c.session.ring.addHostIfMissing(host)
conn, err = c.session.connect(addr, c, hostInfo) conn, err = c.session.connect(addr, c, hostInfo)
if err == nil { if err == nil {
return conn, err return conn, err
@@ -127,7 +138,11 @@ func (c *controlConn) shuffleDial(endpoints []string) (conn *Conn, err error) {
log.Printf("gocql: unable to dial control conn %v: %v\n", addr, err) log.Printf("gocql: unable to dial control conn %v: %v\n", addr, err)
} }
return if err != nil {
return nil, err
}
return conn, nil
} }
func (c *controlConn) connect(endpoints []string) error { func (c *controlConn) connect(endpoints []string) error {
@@ -137,9 +152,7 @@ func (c *controlConn) connect(endpoints []string) error {
conn, err := c.shuffleDial(endpoints) conn, err := c.shuffleDial(endpoints)
if err != nil { if err != nil {
return fmt.Errorf("control: unable to connect: %v", err) return fmt.Errorf("control: unable to connect to initial hosts: %v", err)
} else if conn == nil {
return errors.New("control: unable to connect to initial endpoints")
} }
if err := c.setupConn(conn); err != nil { if err := c.setupConn(conn); err != nil {

10
vendor/github.com/gocql/gocql/errors.go generated vendored
View File

@@ -14,6 +14,7 @@ const (
errReadTimeout = 0x1200 errReadTimeout = 0x1200
errReadFailure = 0x1300 errReadFailure = 0x1300
errFunctionFailure = 0x1400 errFunctionFailure = 0x1400
errWriteFailure = 0x1500
errSyntax = 0x2000 errSyntax = 0x2000
errUnauthorized = 0x2100 errUnauthorized = 0x2100
errInvalid = 0x2200 errInvalid = 0x2200
@@ -70,6 +71,15 @@ type RequestErrWriteTimeout struct {
WriteType string WriteType string
} }
type RequestErrWriteFailure struct {
errorFrame
Consistency Consistency
Received int
BlockFor int
NumFailures int
WriteType string
}
type RequestErrReadTimeout struct { type RequestErrReadTimeout struct {
errorFrame errorFrame
Consistency Consistency Consistency Consistency

17
vendor/github.com/gocql/gocql/events.go generated vendored
View File

@@ -107,6 +107,17 @@ func (s *Session) handleEvent(framer *framer) {
} }
func (s *Session) handleSchemaEvent(frames []frame) { func (s *Session) handleSchemaEvent(frames []frame) {
if s.schemaDescriber == nil {
return
}
for _, frame := range frames {
switch f := frame.(type) {
case *schemaChangeKeyspace:
s.schemaDescriber.clearSchema(f.keyspace)
case *schemaChangeTable:
s.schemaDescriber.clearSchema(f.keyspace)
}
}
} }
func (s *Session) handleNodeEvent(frames []frame) { func (s *Session) handleNodeEvent(frames []frame) {
@@ -233,6 +244,9 @@ func (s *Session) handleRemovedNode(ip net.IP, port int) {
} }
func (s *Session) handleNodeUp(ip net.IP, port int, waitForBinary bool) { func (s *Session) handleNodeUp(ip net.IP, port int, waitForBinary bool) {
if gocqlDebug {
log.Printf("gocql: Session.handleNodeUp: %s:%d\n", ip.String(), port)
}
addr := ip.String() addr := ip.String()
host := s.ring.getHost(addr) host := s.ring.getHost(addr)
if host != nil { if host != nil {
@@ -264,6 +278,9 @@ func (s *Session) handleNodeUp(ip net.IP, port int, waitForBinary bool) {
} }
func (s *Session) handleNodeDown(ip net.IP, port int) { func (s *Session) handleNodeDown(ip net.IP, port int) {
if gocqlDebug {
log.Printf("gocql: Session.handleNodeDown: %s:%d\n", ip.String(), port)
}
addr := ip.String() addr := ip.String()
host := s.ring.getHost(addr) host := s.ring.getHost(addr)
if host == nil { if host == nil {

47
vendor/github.com/gocql/gocql/frame.go generated vendored
View File

@@ -231,6 +231,8 @@ var (
ErrFrameTooBig = errors.New("frame length is bigger than the maximum allowed") ErrFrameTooBig = errors.New("frame length is bigger than the maximum allowed")
) )
const maxFrameHeaderSize = 9
func writeInt(p []byte, n int32) { func writeInt(p []byte, n int32) {
p[0] = byte(n >> 24) p[0] = byte(n >> 24)
p[1] = byte(n >> 16) p[1] = byte(n >> 16)
@@ -339,23 +341,34 @@ type frame interface {
} }
func readHeader(r io.Reader, p []byte) (head frameHeader, err error) { func readHeader(r io.Reader, p []byte) (head frameHeader, err error) {
_, err = io.ReadFull(r, p) _, err = io.ReadFull(r, p[:1])
if err != nil { if err != nil {
return return frameHeader{}, err
} }
version := p[0] & protoVersionMask version := p[0] & protoVersionMask
if version < protoVersion1 || version > protoVersion4 { if version < protoVersion1 || version > protoVersion4 {
err = fmt.Errorf("gocql: invalid version: %d", version) return frameHeader{}, fmt.Errorf("gocql: unsupported response version: %d", version)
return
} }
headSize := 9
if version < protoVersion3 {
headSize = 8
}
_, err = io.ReadFull(r, p[1:headSize])
if err != nil {
return frameHeader{}, err
}
p = p[:headSize]
head.version = protoVersion(p[0]) head.version = protoVersion(p[0])
head.flags = p[1] head.flags = p[1]
if version > protoVersion2 { if version > protoVersion2 {
if len(p) < 9 { if len(p) != 9 {
return frameHeader{}, fmt.Errorf("not enough bytes to read header require 9 got: %d", len(p)) return frameHeader{}, fmt.Errorf("not enough bytes to read header require 9 got: %d", len(p))
} }
@@ -363,7 +376,7 @@ func readHeader(r io.Reader, p []byte) (head frameHeader, err error) {
head.op = frameOp(p[4]) head.op = frameOp(p[4])
head.length = int(readInt(p[5:])) head.length = int(readInt(p[5:]))
} else { } else {
if len(p) < 8 { if len(p) != 8 {
return frameHeader{}, fmt.Errorf("not enough bytes to read header require 8 got: %d", len(p)) return frameHeader{}, fmt.Errorf("not enough bytes to read header require 8 got: %d", len(p))
} }
@@ -372,7 +385,7 @@ func readHeader(r io.Reader, p []byte) (head frameHeader, err error) {
head.length = int(readInt(p[4:])) head.length = int(readInt(p[4:]))
} }
return return head, nil
} }
// explicitly enables tracing for the framers outgoing requests // explicitly enables tracing for the framers outgoing requests
@@ -401,9 +414,9 @@ func (f *framer) readFrame(head *frameHeader) error {
} }
// assume the underlying reader takes care of timeouts and retries // assume the underlying reader takes care of timeouts and retries
_, err := io.ReadFull(f.r, f.rbuf) n, err := io.ReadFull(f.r, f.rbuf)
if err != nil { if err != nil {
return err return fmt.Errorf("unable to read frame body: read %d/%d bytes: %v", n, head.length, err)
} }
if head.flags&flagCompress == flagCompress { if head.flags&flagCompress == flagCompress {
@@ -544,6 +557,16 @@ func (f *framer) parseErrorFrame() frame {
res.BlockFor = f.readInt() res.BlockFor = f.readInt()
res.DataPresent = f.readByte() != 0 res.DataPresent = f.readByte() != 0
return res return res
case errWriteFailure:
res := &RequestErrWriteFailure{
errorFrame: errD,
}
res.Consistency = f.readConsistency()
res.Received = f.readInt()
res.BlockFor = f.readInt()
res.NumFailures = f.readInt()
res.WriteType = f.readString()
return res
case errFunctionFailure: case errFunctionFailure:
res := RequestErrFunctionFailure{ res := RequestErrFunctionFailure{
errorFrame: errD, errorFrame: errD,
@@ -552,8 +575,12 @@ func (f *framer) parseErrorFrame() frame {
res.Function = f.readString() res.Function = f.readString()
res.ArgTypes = f.readStringList() res.ArgTypes = f.readStringList()
return res return res
case errInvalid, errBootstrapping, errConfig, errCredentials, errOverloaded,
errProtocol, errServer, errSyntax, errTruncate, errUnauthorized:
// TODO(zariel): we should have some distinct types for these errors
return errD
default: default:
return &errD panic(fmt.Errorf("unknown error code: 0x%x", errD.code))
} }
} }

10
vendor/github.com/gocql/gocql/metadata.go generated vendored
View File

@@ -105,8 +105,6 @@ func (s *schemaDescriber) getSchema(keyspaceName string) (*KeyspaceMetadata, err
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
// TODO handle schema change events
metadata, found := s.cache[keyspaceName] metadata, found := s.cache[keyspaceName]
if !found { if !found {
// refresh the cache for this keyspace // refresh the cache for this keyspace
@@ -121,6 +119,14 @@ func (s *schemaDescriber) getSchema(keyspaceName string) (*KeyspaceMetadata, err
return metadata, nil return metadata, nil
} }
// clears the already cached keyspace metadata
func (s *schemaDescriber) clearSchema(keyspaceName string) {
s.mu.Lock()
defer s.mu.Unlock()
delete(s.cache, keyspaceName)
}
// forcibly updates the current KeyspaceMetadata held by the schema describer // forcibly updates the current KeyspaceMetadata held by the schema describer
// for a given named keyspace. // for a given named keyspace.
func (s *schemaDescriber) refreshSchema(keyspaceName string) error { func (s *schemaDescriber) refreshSchema(keyspaceName string) error {

32
vendor/github.com/gocql/gocql/session.go generated vendored
View File

@@ -9,8 +9,8 @@ import (
"encoding/binary" "encoding/binary"
"errors" "errors"
"fmt" "fmt"
"golang.org/x/net/context"
"io" "io"
"log"
"net" "net"
"strconv" "strconv"
"strings" "strings"
@@ -19,6 +19,8 @@ import (
"time" "time"
"unicode" "unicode"
"golang.org/x/net/context"
"github.com/gocql/gocql/internal/lru" "github.com/gocql/gocql/internal/lru"
) )
@@ -175,6 +177,10 @@ func NewSession(cfg ClusterConfig) (*Session, error) {
} }
} }
if cfg.ReconnectInterval > 0 {
go s.reconnectDownedHosts(cfg.ReconnectInterval)
}
// TODO(zariel): we probably dont need this any more as we verify that we // TODO(zariel): we probably dont need this any more as we verify that we
// can connect to one of the endpoints supplied by using the control conn. // can connect to one of the endpoints supplied by using the control conn.
// See if there are any connections in the pool // See if there are any connections in the pool
@@ -188,6 +194,30 @@ func NewSession(cfg ClusterConfig) (*Session, error) {
return s, nil return s, nil
} }
func (s *Session) reconnectDownedHosts(intv time.Duration) {
for !s.Closed() {
time.Sleep(intv)
hosts := s.ring.allHosts()
// Print session.ring for debug.
if gocqlDebug {
buf := bytes.NewBufferString("Session.ring:")
for _, h := range hosts {
buf.WriteString("[" + h.Peer() + ":" + h.State().String() + "]")
}
log.Println(buf.String())
}
for _, h := range hosts {
if h.IsUp() {
continue
}
s.handleNodeUp(net.ParseIP(h.Peer()), h.Port(), true)
}
}
}
// SetConsistency sets the default consistency level for this session. This // SetConsistency sets the default consistency level for this session. This
// setting can also be changed on a per-query basis and the default value // setting can also be changed on a per-query basis and the default value
// is Quorum. // is Quorum.

100
vendor/github.com/golang/snappy/README generated vendored
View File

@@ -5,3 +5,103 @@ $ go get github.com/golang/snappy
Unless otherwise noted, the Snappy-Go source files are distributed Unless otherwise noted, the Snappy-Go source files are distributed
under the BSD-style license found in the LICENSE file. under the BSD-style license found in the LICENSE file.
Benchmarks.
The golang/snappy benchmarks include compressing (Z) and decompressing (U) ten
or so files, the same set used by the C++ Snappy code (github.com/google/snappy
and note the "google", not "golang"). On an "Intel(R) Core(TM) i7-3770 CPU @
3.40GHz", Go's GOARCH=amd64 numbers as of 2016-04-29:
"go test -test.bench=."
_UFlat0-8 2.23GB/s ± 1% html
_UFlat1-8 1.43GB/s ± 0% urls
_UFlat2-8 23.7GB/s ± 1% jpg
_UFlat3-8 1.93GB/s ± 0% jpg_200
_UFlat4-8 13.9GB/s ± 2% pdf
_UFlat5-8 2.00GB/s ± 0% html4
_UFlat6-8 829MB/s ± 0% txt1
_UFlat7-8 799MB/s ± 0% txt2
_UFlat8-8 871MB/s ± 0% txt3
_UFlat9-8 730MB/s ± 0% txt4
_UFlat10-8 2.87GB/s ± 0% pb
_UFlat11-8 1.07GB/s ± 0% gaviota
_ZFlat0-8 1.04GB/s ± 0% html
_ZFlat1-8 536MB/s ± 0% urls
_ZFlat2-8 16.3GB/s ± 2% jpg
_ZFlat3-8 762MB/s ± 0% jpg_200
_ZFlat4-8 9.48GB/s ± 1% pdf
_ZFlat5-8 990MB/s ± 0% html4
_ZFlat6-8 381MB/s ± 0% txt1
_ZFlat7-8 353MB/s ± 0% txt2
_ZFlat8-8 398MB/s ± 0% txt3
_ZFlat9-8 329MB/s ± 0% txt4
_ZFlat10-8 1.35GB/s ± 1% pb
_ZFlat11-8 608MB/s ± 0% gaviota
"go test -test.bench=. -tags=noasm"
_UFlat0-8 637MB/s ± 0% html
_UFlat1-8 506MB/s ± 0% urls
_UFlat2-8 23.0GB/s ± 5% jpg
_UFlat3-8 1.17GB/s ± 0% jpg_200
_UFlat4-8 4.44GB/s ± 1% pdf
_UFlat5-8 623MB/s ± 0% html4
_UFlat6-8 300MB/s ± 1% txt1
_UFlat7-8 293MB/s ± 0% txt2
_UFlat8-8 316MB/s ± 0% txt3
_UFlat9-8 285MB/s ± 0% txt4
_UFlat10-8 768MB/s ± 0% pb
_UFlat11-8 406MB/s ± 1% gaviota
_ZFlat0-8 411MB/s ± 1% html
_ZFlat1-8 250MB/s ± 1% urls
_ZFlat2-8 12.7GB/s ± 1% jpg
_ZFlat3-8 157MB/s ± 0% jpg_200
_ZFlat4-8 2.95GB/s ± 0% pdf
_ZFlat5-8 406MB/s ± 0% html4
_ZFlat6-8 182MB/s ± 0% txt1
_ZFlat7-8 173MB/s ± 1% txt2
_ZFlat8-8 191MB/s ± 0% txt3
_ZFlat9-8 166MB/s ± 0% txt4
_ZFlat10-8 480MB/s ± 0% pb
_ZFlat11-8 272MB/s ± 0% gaviota
For comparison (Go's encoded output is byte-for-byte identical to C++'s), here
are the numbers from C++ Snappy's
make CXXFLAGS="-O2 -DNDEBUG -g" clean snappy_unittest.log && cat snappy_unittest.log
BM_UFlat/0 2.4GB/s html
BM_UFlat/1 1.4GB/s urls
BM_UFlat/2 21.8GB/s jpg
BM_UFlat/3 1.5GB/s jpg_200
BM_UFlat/4 13.3GB/s pdf
BM_UFlat/5 2.1GB/s html4
BM_UFlat/6 1.0GB/s txt1
BM_UFlat/7 959.4MB/s txt2
BM_UFlat/8 1.0GB/s txt3
BM_UFlat/9 864.5MB/s txt4
BM_UFlat/10 2.9GB/s pb
BM_UFlat/11 1.2GB/s gaviota
BM_ZFlat/0 944.3MB/s html (22.31 %)
BM_ZFlat/1 501.6MB/s urls (47.78 %)
BM_ZFlat/2 14.3GB/s jpg (99.95 %)
BM_ZFlat/3 538.3MB/s jpg_200 (73.00 %)
BM_ZFlat/4 8.3GB/s pdf (83.30 %)
BM_ZFlat/5 903.5MB/s html4 (22.52 %)
BM_ZFlat/6 336.0MB/s txt1 (57.88 %)
BM_ZFlat/7 312.3MB/s txt2 (61.91 %)
BM_ZFlat/8 353.1MB/s txt3 (54.99 %)
BM_ZFlat/9 289.9MB/s txt4 (66.26 %)
BM_ZFlat/10 1.2GB/s pb (19.68 %)
BM_ZFlat/11 527.4MB/s gaviota (37.72 %)

380
vendor/github.com/golang/snappy/encode_amd64.s generated vendored
View File

@@ -8,10 +8,17 @@
#include "textflag.h" #include "textflag.h"
// TODO: figure out why the XXX lines compile with Go 1.4 and Go tip but not // The XXX lines assemble on Go 1.4, 1.5 and 1.7, but not 1.6, due to a
// Go 1.6. // Go toolchain regression. See https://github.com/golang/go/issues/15426 and
// https://github.com/golang/snappy/issues/29
// //
// This is https://github.com/golang/snappy/issues/29 // As a workaround, the package was built with a known good assembler, and
// those instructions were disassembled by "objdump -d" to yield the
// 4e 0f b7 7c 5c 78 movzwq 0x78(%rsp,%r11,2),%r15
// style comments, in AT&T asm syntax. Note that rsp here is a physical
// register, not Go/asm's SP pseudo-register (see https://golang.org/doc/asm).
// The instructions were then encoded as "BYTE $0x.." sequences, which assemble
// fine on Go 1.6.
// The asm code generally follows the pure Go code in encode_other.go, except // The asm code generally follows the pure Go code in encode_other.go, except
// where marked with a "!!!". // where marked with a "!!!".
@@ -21,19 +28,23 @@
// func emitLiteral(dst, lit []byte) int // func emitLiteral(dst, lit []byte) int
// //
// All local variables fit into registers. The register allocation: // All local variables fit into registers. The register allocation:
// - AX return value // - AX len(lit)
// - BX n // - BX n
// - CX len(lit) // - DX return value
// - SI &lit[0]
// - DI &dst[i] // - DI &dst[i]
// - R10 &lit[0]
// //
// The 24 bytes of stack space is to call runtime·memmove. // The 24 bytes of stack space is to call runtime·memmove.
//
// The unusual register allocation of local variables, such as R10 for the
// source pointer, matches the allocation used at the call site in encodeBlock,
// which makes it easier to manually inline this function.
TEXT ·emitLiteral(SB), NOSPLIT, $24-56 TEXT ·emitLiteral(SB), NOSPLIT, $24-56
MOVQ dst_base+0(FP), DI MOVQ dst_base+0(FP), DI
MOVQ lit_base+24(FP), SI MOVQ lit_base+24(FP), R10
MOVQ lit_len+32(FP), CX MOVQ lit_len+32(FP), AX
MOVQ CX, AX MOVQ AX, DX
MOVL CX, BX MOVL AX, BX
SUBL $1, BX SUBL $1, BX
CMPL BX, $60 CMPL BX, $60
@@ -45,32 +56,32 @@ threeBytes:
MOVB $0xf4, 0(DI) MOVB $0xf4, 0(DI)
MOVW BX, 1(DI) MOVW BX, 1(DI)
ADDQ $3, DI ADDQ $3, DI
ADDQ $3, AX ADDQ $3, DX
JMP emitLiteralEnd JMP memmove
twoBytes: twoBytes:
MOVB $0xf0, 0(DI) MOVB $0xf0, 0(DI)
MOVB BX, 1(DI) MOVB BX, 1(DI)
ADDQ $2, DI ADDQ $2, DI
ADDQ $2, AX ADDQ $2, DX
JMP emitLiteralEnd JMP memmove
oneByte: oneByte:
SHLB $2, BX SHLB $2, BX
MOVB BX, 0(DI) MOVB BX, 0(DI)
ADDQ $1, DI ADDQ $1, DI
ADDQ $1, AX ADDQ $1, DX
emitLiteralEnd: memmove:
MOVQ AX, ret+48(FP) MOVQ DX, ret+48(FP)
// copy(dst[i:], lit) // copy(dst[i:], lit)
// //
// This means calling runtime·memmove(&dst[i], &lit[0], len(lit)), so we push // This means calling runtime·memmove(&dst[i], &lit[0], len(lit)), so we push
// DI, SI and CX as arguments. // DI, R10 and AX as arguments.
MOVQ DI, 0(SP) MOVQ DI, 0(SP)
MOVQ SI, 8(SP) MOVQ R10, 8(SP)
MOVQ CX, 16(SP) MOVQ AX, 16(SP)
CALL runtime·memmove(SB) CALL runtime·memmove(SB)
RET RET
@@ -79,55 +90,59 @@ emitLiteralEnd:
// func emitCopy(dst []byte, offset, length int) int // func emitCopy(dst []byte, offset, length int) int
// //
// All local variables fit into registers. The register allocation: // All local variables fit into registers. The register allocation:
// - BX offset // - AX length
// - CX length
// - SI &dst[0] // - SI &dst[0]
// - DI &dst[i] // - DI &dst[i]
// - R11 offset
//
// The unusual register allocation of local variables, such as R11 for the
// offset, matches the allocation used at the call site in encodeBlock, which
// makes it easier to manually inline this function.
TEXT ·emitCopy(SB), NOSPLIT, $0-48 TEXT ·emitCopy(SB), NOSPLIT, $0-48
MOVQ dst_base+0(FP), DI MOVQ dst_base+0(FP), DI
MOVQ DI, SI MOVQ DI, SI
MOVQ offset+24(FP), BX MOVQ offset+24(FP), R11
MOVQ length+32(FP), CX MOVQ length+32(FP), AX
loop0: loop0:
// for length >= 68 { etc } // for length >= 68 { etc }
CMPL CX, $68 CMPL AX, $68
JLT step1 JLT step1
// Emit a length 64 copy, encoded as 3 bytes. // Emit a length 64 copy, encoded as 3 bytes.
MOVB $0xfe, 0(DI) MOVB $0xfe, 0(DI)
MOVW BX, 1(DI) MOVW R11, 1(DI)
ADDQ $3, DI ADDQ $3, DI
SUBL $64, CX SUBL $64, AX
JMP loop0 JMP loop0
step1: step1:
// if length > 64 { etc } // if length > 64 { etc }
CMPL CX, $64 CMPL AX, $64
JLE step2 JLE step2
// Emit a length 60 copy, encoded as 3 bytes. // Emit a length 60 copy, encoded as 3 bytes.
MOVB $0xee, 0(DI) MOVB $0xee, 0(DI)
MOVW BX, 1(DI) MOVW R11, 1(DI)
ADDQ $3, DI ADDQ $3, DI
SUBL $60, CX SUBL $60, AX
step2: step2:
// if length >= 12 || offset >= 2048 { goto step3 } // if length >= 12 || offset >= 2048 { goto step3 }
CMPL CX, $12 CMPL AX, $12
JGE step3 JGE step3
CMPL BX, $2048 CMPL R11, $2048
JGE step3 JGE step3
// Emit the remaining copy, encoded as 2 bytes. // Emit the remaining copy, encoded as 2 bytes.
MOVB BX, 1(DI) MOVB R11, 1(DI)
SHRL $8, BX SHRL $8, R11
SHLB $5, BX SHLB $5, R11
SUBB $4, CX SUBB $4, AX
SHLB $2, CX SHLB $2, AX
ORB CX, BX ORB AX, R11
ORB $1, BX ORB $1, R11
MOVB BX, 0(DI) MOVB R11, 0(DI)
ADDQ $2, DI ADDQ $2, DI
// Return the number of bytes written. // Return the number of bytes written.
@@ -137,11 +152,11 @@ step2:
step3: step3:
// Emit the remaining copy, encoded as 3 bytes. // Emit the remaining copy, encoded as 3 bytes.
SUBL $1, CX SUBL $1, AX
SHLB $2, CX SHLB $2, AX
ORB $2, CX ORB $2, AX
MOVB CX, 0(DI) MOVB AX, 0(DI)
MOVW BX, 1(DI) MOVW R11, 1(DI)
ADDQ $3, DI ADDQ $3, DI
// Return the number of bytes written. // Return the number of bytes written.
@@ -154,33 +169,37 @@ step3:
// func extendMatch(src []byte, i, j int) int // func extendMatch(src []byte, i, j int) int
// //
// All local variables fit into registers. The register allocation: // All local variables fit into registers. The register allocation:
// - CX &src[0] // - DX &src[0]
// - DX &src[len(src)] // - SI &src[j]
// - SI &src[i] // - R13 &src[len(src) - 8]
// - DI &src[j] // - R14 &src[len(src)]
// - R9 &src[len(src) - 8] // - R15 &src[i]
//
// The unusual register allocation of local variables, such as R15 for a source
// pointer, matches the allocation used at the call site in encodeBlock, which
// makes it easier to manually inline this function.
TEXT ·extendMatch(SB), NOSPLIT, $0-48 TEXT ·extendMatch(SB), NOSPLIT, $0-48
MOVQ src_base+0(FP), CX MOVQ src_base+0(FP), DX
MOVQ src_len+8(FP), DX MOVQ src_len+8(FP), R14
MOVQ i+24(FP), SI MOVQ i+24(FP), R15
MOVQ j+32(FP), DI MOVQ j+32(FP), SI
ADDQ CX, DX ADDQ DX, R14
ADDQ CX, SI ADDQ DX, R15
ADDQ CX, DI ADDQ DX, SI
MOVQ DX, R9 MOVQ R14, R13
SUBQ $8, R9 SUBQ $8, R13
cmp8: cmp8:
// As long as we are 8 or more bytes before the end of src, we can load and // As long as we are 8 or more bytes before the end of src, we can load and
// compare 8 bytes at a time. If those 8 bytes are equal, repeat. // compare 8 bytes at a time. If those 8 bytes are equal, repeat.
CMPQ DI, R9 CMPQ SI, R13
JA cmp1 JA cmp1
MOVQ (SI), AX MOVQ (R15), AX
MOVQ (DI), BX MOVQ (SI), BX
CMPQ AX, BX CMPQ AX, BX
JNE bsf JNE bsf
ADDQ $8, R15
ADDQ $8, SI ADDQ $8, SI
ADDQ $8, DI
JMP cmp8 JMP cmp8
bsf: bsf:
@@ -191,29 +210,29 @@ bsf:
XORQ AX, BX XORQ AX, BX
BSFQ BX, BX BSFQ BX, BX
SHRQ $3, BX SHRQ $3, BX
ADDQ BX, DI ADDQ BX, SI
// Convert from &src[ret] to ret. // Convert from &src[ret] to ret.
SUBQ CX, DI SUBQ DX, SI
MOVQ DI, ret+40(FP) MOVQ SI, ret+40(FP)
RET RET
cmp1: cmp1:
// In src's tail, compare 1 byte at a time. // In src's tail, compare 1 byte at a time.
CMPQ DI, DX CMPQ SI, R14
JAE extendMatchEnd JAE extendMatchEnd
MOVB (SI), AX MOVB (R15), AX
MOVB (DI), BX MOVB (SI), BX
CMPB AX, BX CMPB AX, BX
JNE extendMatchEnd JNE extendMatchEnd
ADDQ $1, R15
ADDQ $1, SI ADDQ $1, SI
ADDQ $1, DI
JMP cmp1 JMP cmp1
extendMatchEnd: extendMatchEnd:
// Convert from &src[ret] to ret. // Convert from &src[ret] to ret.
SUBQ CX, DI SUBQ DX, SI
MOVQ DI, ret+40(FP) MOVQ SI, ret+40(FP)
RET RET
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -232,8 +251,8 @@ extendMatchEnd:
// - R10 . &src[nextEmit] // - R10 . &src[nextEmit]
// - R11 96 prevHash, currHash, nextHash, offset // - R11 96 prevHash, currHash, nextHash, offset
// - R12 104 &src[base], skip // - R12 104 &src[base], skip
// - R13 . &src[nextS] // - R13 . &src[nextS], &src[len(src) - 8]
// - R14 . len(src), bytesBetweenHashLookups, x // - R14 . len(src), bytesBetweenHashLookups, &src[len(src)], x
// - R15 112 candidate // - R15 112 candidate
// //
// The second column (56, 64, etc) is the stack offset to spill the registers // The second column (56, 64, etc) is the stack offset to spill the registers
@@ -352,6 +371,7 @@ inner0:
// table[nextHash] = uint16(s) // table[nextHash] = uint16(s)
MOVQ SI, AX MOVQ SI, AX
SUBQ DX, AX SUBQ DX, AX
// XXX: MOVW AX, table-32768(SP)(R11*2) // XXX: MOVW AX, table-32768(SP)(R11*2)
// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2) // XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
BYTE $0x66 BYTE $0x66
@@ -384,32 +404,63 @@ fourByteMatch:
CMPQ AX, $16 CMPQ AX, $16
JLE emitLiteralFastPath JLE emitLiteralFastPath
// d += emitLiteral(dst[d:], src[nextEmit:s]) // ----------------------------------------
// Begin inline of the emitLiteral call.
// //
// Push args. // d += emitLiteral(dst[d:], src[nextEmit:s])
MOVQ DI, 0(SP)
MOVQ $0, 8(SP) // Unnecessary, as the callee ignores it, but conservative.
MOVQ $0, 16(SP) // Unnecessary, as the callee ignores it, but conservative.
MOVQ R10, 24(SP)
MOVQ AX, 32(SP)
MOVQ AX, 40(SP) // Unnecessary, as the callee ignores it, but conservative.
MOVL AX, BX
SUBL $1, BX
CMPL BX, $60
JLT inlineEmitLiteralOneByte
CMPL BX, $256
JLT inlineEmitLiteralTwoBytes
inlineEmitLiteralThreeBytes:
MOVB $0xf4, 0(DI)
MOVW BX, 1(DI)
ADDQ $3, DI
JMP inlineEmitLiteralMemmove
inlineEmitLiteralTwoBytes:
MOVB $0xf0, 0(DI)
MOVB BX, 1(DI)
ADDQ $2, DI
JMP inlineEmitLiteralMemmove
inlineEmitLiteralOneByte:
SHLB $2, BX
MOVB BX, 0(DI)
ADDQ $1, DI
inlineEmitLiteralMemmove:
// Spill local variables (registers) onto the stack; call; unspill. // Spill local variables (registers) onto the stack; call; unspill.
//
// copy(dst[i:], lit)
//
// This means calling runtime·memmove(&dst[i], &lit[0], len(lit)), so we push
// DI, R10 and AX as arguments.
MOVQ DI, 0(SP)
MOVQ R10, 8(SP)
MOVQ AX, 16(SP)
ADDQ AX, DI // Finish the "d +=" part of "d += emitLiteral(etc)".
MOVQ SI, 72(SP) MOVQ SI, 72(SP)
MOVQ DI, 80(SP) MOVQ DI, 80(SP)
MOVQ R15, 112(SP) MOVQ R15, 112(SP)
CALL ·emitLiteral(SB) CALL runtime·memmove(SB)
MOVQ 56(SP), CX MOVQ 56(SP), CX
MOVQ 64(SP), DX MOVQ 64(SP), DX
MOVQ 72(SP), SI MOVQ 72(SP), SI
MOVQ 80(SP), DI MOVQ 80(SP), DI
MOVQ 88(SP), R9 MOVQ 88(SP), R9
MOVQ 112(SP), R15 MOVQ 112(SP), R15
// Finish the "d +=" part of "d += emitLiteral(etc)".
ADDQ 48(SP), DI
JMP inner1 JMP inner1
inlineEmitLiteralEnd:
// End inline of the emitLiteral call.
// ----------------------------------------
emitLiteralFastPath: emitLiteralFastPath:
// !!! Emit the 1-byte encoding "uint8(len(lit)-1)<<2". // !!! Emit the 1-byte encoding "uint8(len(lit)-1)<<2".
MOVB AX, BX MOVB AX, BX
@@ -442,60 +493,129 @@ inner1:
SUBQ R15, R11 SUBQ R15, R11
SUBQ DX, R11 SUBQ DX, R11
// ----------------------------------------
// Begin inline of the extendMatch call.
//
// s = extendMatch(src, candidate+4, s+4) // s = extendMatch(src, candidate+4, s+4)
//
// Push args. // !!! R14 = &src[len(src)]
MOVQ DX, 0(SP)
MOVQ src_len+32(FP), R14 MOVQ src_len+32(FP), R14
MOVQ R14, 8(SP) ADDQ DX, R14
MOVQ R14, 16(SP) // Unnecessary, as the callee ignores it, but conservative.
// !!! R13 = &src[len(src) - 8]
MOVQ R14, R13
SUBQ $8, R13
// !!! R15 = &src[candidate + 4]
ADDQ $4, R15 ADDQ $4, R15
MOVQ R15, 24(SP) ADDQ DX, R15
// !!! s += 4
ADDQ $4, SI ADDQ $4, SI
SUBQ DX, SI
MOVQ SI, 32(SP)
// Spill local variables (registers) onto the stack; call; unspill. inlineExtendMatchCmp8:
// As long as we are 8 or more bytes before the end of src, we can load and
// compare 8 bytes at a time. If those 8 bytes are equal, repeat.
CMPQ SI, R13
JA inlineExtendMatchCmp1
MOVQ (R15), AX
MOVQ (SI), BX
CMPQ AX, BX
JNE inlineExtendMatchBSF
ADDQ $8, R15
ADDQ $8, SI
JMP inlineExtendMatchCmp8
inlineExtendMatchBSF:
// If those 8 bytes were not equal, XOR the two 8 byte values, and return
// the index of the first byte that differs. The BSF instruction finds the
// least significant 1 bit, the amd64 architecture is little-endian, and
// the shift by 3 converts a bit index to a byte index.
XORQ AX, BX
BSFQ BX, BX
SHRQ $3, BX
ADDQ BX, SI
JMP inlineExtendMatchEnd
inlineExtendMatchCmp1:
// In src's tail, compare 1 byte at a time.
CMPQ SI, R14
JAE inlineExtendMatchEnd
MOVB (R15), AX
MOVB (SI), BX
CMPB AX, BX
JNE inlineExtendMatchEnd
ADDQ $1, R15
ADDQ $1, SI
JMP inlineExtendMatchCmp1
inlineExtendMatchEnd:
// End inline of the extendMatch call.
// ----------------------------------------
// ----------------------------------------
// Begin inline of the emitCopy call.
// //
// We don't need to unspill CX or R9 as we are just about to call another
// function.
MOVQ DI, 80(SP)
MOVQ R11, 96(SP)
MOVQ R12, 104(SP)
CALL ·extendMatch(SB)
MOVQ 64(SP), DX
MOVQ 80(SP), DI
MOVQ 96(SP), R11
MOVQ 104(SP), R12
// Finish the "s =" part of "s = extendMatch(etc)", remembering that the SI
// register holds &src[s], not s.
MOVQ 40(SP), SI
ADDQ DX, SI
// d += emitCopy(dst[d:], base-candidate, s-base) // d += emitCopy(dst[d:], base-candidate, s-base)
//
// Push args. // !!! length := s - base
MOVQ DI, 0(SP)
MOVQ $0, 8(SP) // Unnecessary, as the callee ignores it, but conservative.
MOVQ $0, 16(SP) // Unnecessary, as the callee ignores it, but conservative.
MOVQ R11, 24(SP)
MOVQ SI, AX MOVQ SI, AX
SUBQ R12, AX SUBQ R12, AX
MOVQ AX, 32(SP)
// Spill local variables (registers) onto the stack; call; unspill. inlineEmitCopyLoop0:
MOVQ SI, 72(SP) // for length >= 68 { etc }
MOVQ DI, 80(SP) CMPL AX, $68
CALL ·emitCopy(SB) JLT inlineEmitCopyStep1
MOVQ 56(SP), CX
MOVQ 64(SP), DX
MOVQ 72(SP), SI
MOVQ 80(SP), DI
MOVQ 88(SP), R9
// Finish the "d +=" part of "d += emitCopy(etc)". // Emit a length 64 copy, encoded as 3 bytes.
ADDQ 40(SP), DI MOVB $0xfe, 0(DI)
MOVW R11, 1(DI)
ADDQ $3, DI
SUBL $64, AX
JMP inlineEmitCopyLoop0
inlineEmitCopyStep1:
// if length > 64 { etc }
CMPL AX, $64
JLE inlineEmitCopyStep2
// Emit a length 60 copy, encoded as 3 bytes.
MOVB $0xee, 0(DI)
MOVW R11, 1(DI)
ADDQ $3, DI
SUBL $60, AX
inlineEmitCopyStep2:
// if length >= 12 || offset >= 2048 { goto inlineEmitCopyStep3 }
CMPL AX, $12
JGE inlineEmitCopyStep3
CMPL R11, $2048
JGE inlineEmitCopyStep3
// Emit the remaining copy, encoded as 2 bytes.
MOVB R11, 1(DI)
SHRL $8, R11
SHLB $5, R11
SUBB $4, AX
SHLB $2, AX
ORB AX, R11
ORB $1, R11
MOVB R11, 0(DI)
ADDQ $2, DI
JMP inlineEmitCopyEnd
inlineEmitCopyStep3:
// Emit the remaining copy, encoded as 3 bytes.
SUBL $1, AX
SHLB $2, AX
ORB $2, AX
MOVB AX, 0(DI)
MOVW R11, 1(DI)
ADDQ $3, DI
inlineEmitCopyEnd:
// End inline of the emitCopy call.
// ----------------------------------------
// nextEmit = s // nextEmit = s
MOVQ SI, R10 MOVQ SI, R10
@@ -522,6 +642,7 @@ inner1:
MOVQ SI, AX MOVQ SI, AX
SUBQ DX, AX SUBQ DX, AX
SUBQ $1, AX SUBQ $1, AX
// XXX: MOVW AX, table-32768(SP)(R11*2) // XXX: MOVW AX, table-32768(SP)(R11*2)
// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2) // XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
BYTE $0x66 BYTE $0x66
@@ -549,6 +670,7 @@ inner1:
// table[currHash] = uint16(s) // table[currHash] = uint16(s)
ADDQ $1, AX ADDQ $1, AX
// XXX: MOVW AX, table-32768(SP)(R11*2) // XXX: MOVW AX, table-32768(SP)(R11*2)
// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2) // XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
BYTE $0x66 BYTE $0x66

2
vendor/github.com/lib/pq/user_posix.go generated vendored
View File

@@ -1,6 +1,6 @@
// Package pq is a pure Go Postgres driver for the database/sql package. // Package pq is a pure Go Postgres driver for the database/sql package.
// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris // +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris rumprun
package pq package pq

2
vendor/golang.org/x/crypto/ssh/handshake.go generated vendored
View File

@@ -370,8 +370,8 @@ func (t *handshakeTransport) enterKeyExchangeLocked(otherInitPacket []byte) erro
if t.sessionID == nil { if t.sessionID == nil {
t.sessionID = result.H t.sessionID = result.H
result.SessionID = result.H
} }
result.SessionID = t.sessionID
t.conn.prepareKeyChange(algs, result) t.conn.prepareKeyChange(algs, result)
if err = t.conn.writePacket([]byte{msgNewKeys}); err != nil { if err = t.conn.writePacket([]byte{msgNewKeys}); err != nil {

2
vendor/golang.org/x/net/context/context.go generated vendored
View File

@@ -61,7 +61,7 @@ type Context interface {
// //
// // Stream generates values with DoSomething and sends them to out // // Stream generates values with DoSomething and sends them to out
// // until DoSomething returns an error or ctx.Done is closed. // // until DoSomething returns an error or ctx.Done is closed.
// func Stream(ctx context.Context, out <-chan Value) error { // func Stream(ctx context.Context, out chan<- Value) error {
// for { // for {
// v, err := DoSomething(ctx) // v, err := DoSomething(ctx)
// if err != nil { // if err != nil {

2
vendor/golang.org/x/sys/unix/sockcmsg_unix.go generated vendored
View File

@@ -62,7 +62,7 @@ func ParseSocketControlMessage(b []byte) ([]SocketControlMessage, error) {
func socketControlMessageHeaderAndData(b []byte) (*Cmsghdr, []byte, error) { func socketControlMessageHeaderAndData(b []byte) (*Cmsghdr, []byte, error) {
h := (*Cmsghdr)(unsafe.Pointer(&b[0])) h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
if h.Len < SizeofCmsghdr || int(h.Len) > len(b) { if h.Len < SizeofCmsghdr || uint64(h.Len) > uint64(len(b)) {
return nil, nil, EINVAL return nil, nil, EINVAL
} }
return h, b[cmsgAlignOf(SizeofCmsghdr):h.Len], nil return h, b[cmsgAlignOf(SizeofCmsghdr):h.Len], nil

27
vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go generated vendored
View File

@@ -18,6 +18,7 @@ package unix
//sysnb Getgid() (gid int) //sysnb Getgid() (gid int)
//sysnb Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_UGETRLIMIT //sysnb Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_UGETRLIMIT
//sysnb Getuid() (uid int) //sysnb Getuid() (uid int)
//sysnb InotifyInit() (fd int, err error)
//sys Ioperm(from int, num int, on int) (err error) //sys Ioperm(from int, num int, on int) (err error)
//sys Iopl(level int) (err error) //sys Iopl(level int) (err error)
//sys Lchown(path string, uid int, gid int) (err error) //sys Lchown(path string, uid int, gid int) (err error)
@@ -97,3 +98,29 @@ func (msghdr *Msghdr) SetControllen(length int) {
func (cmsg *Cmsghdr) SetLen(length int) { func (cmsg *Cmsghdr) SetLen(length int) {
cmsg.Len = uint64(length) cmsg.Len = uint64(length)
} }
//sysnb pipe(p *[2]_C_int) (err error)
func Pipe(p []int) (err error) {
if len(p) != 2 {
return EINVAL
}
var pp [2]_C_int
err = pipe(&pp)
p[0] = int(pp[0])
p[1] = int(pp[1])
return
}
//sysnb pipe2(p *[2]_C_int, flags int) (err error)
func Pipe2(p []int, flags int) (err error) {
if len(p) != 2 {
return EINVAL
}
var pp [2]_C_int
err = pipe2(&pp, flags)
p[0] = int(pp[0])
p[1] = int(pp[1])
return
}

3
vendor/golang.org/x/sys/unix/types_linux.go generated vendored
View File

@@ -113,6 +113,9 @@ struct my_epoll_event {
// padding is not specified in linux/eventpoll.h but added to conform to the // padding is not specified in linux/eventpoll.h but added to conform to the
// alignment requirements of EABI // alignment requirements of EABI
int32_t padFd; int32_t padFd;
#endif
#ifdef __powerpc64__
int32_t _padFd;
#endif #endif
int32_t fd; int32_t fd;
int32_t pad; int32_t pad;

31
vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go generated vendored
View File

@@ -1298,6 +1298,17 @@ func Getuid() (uid int) {
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func InotifyInit() (fd int, err error) {
r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0)
fd = int(r0)
if e1 != 0 {
err = errnoErr(e1)
}
return
}
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func Ioperm(from int, num int, on int) (err error) { func Ioperm(from int, num int, on int) (err error) {
_, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on))
if e1 != 0 { if e1 != 0 {
@@ -1810,3 +1821,23 @@ func Utime(path string, buf *Utimbuf) (err error) {
} }
return return
} }
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func pipe(p *[2]_C_int) (err error) {
_, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
if e1 != 0 {
err = errnoErr(e1)
}
return
}
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func pipe2(p *[2]_C_int, flags int) (err error) {
_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
if e1 != 0 {
err = errnoErr(e1)
}
return
}

31
vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go generated vendored
View File

@@ -1298,6 +1298,17 @@ func Getuid() (uid int) {
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func InotifyInit() (fd int, err error) {
r0, _, e1 := RawSyscall(SYS_INOTIFY_INIT, 0, 0, 0)
fd = int(r0)
if e1 != 0 {
err = errnoErr(e1)
}
return
}
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func Ioperm(from int, num int, on int) (err error) { func Ioperm(from int, num int, on int) (err error) {
_, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on)) _, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on))
if e1 != 0 { if e1 != 0 {
@@ -1810,3 +1821,23 @@ func Utime(path string, buf *Utimbuf) (err error) {
} }
return return
} }
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func pipe(p *[2]_C_int) (err error) {
_, _, e1 := RawSyscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
if e1 != 0 {
err = errnoErr(e1)
}
return
}
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
func pipe2(p *[2]_C_int, flags int) (err error) {
_, _, e1 := RawSyscall(SYS_PIPE2, uintptr(unsafe.Pointer(p)), uintptr(flags), 0)
if e1 != 0 {
err = errnoErr(e1)
}
return
}

7
vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go generated vendored
View File

@@ -589,9 +589,10 @@ type Ustat_t struct {
} }
type EpollEvent struct { type EpollEvent struct {
Events uint32 Events uint32
Fd int32 X_padFd int32
Pad int32 Fd int32
Pad int32
} }
const ( const (

7
vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go generated vendored
View File

@@ -589,9 +589,10 @@ type Ustat_t struct {
} }
type EpollEvent struct { type EpollEvent struct {
Events uint32 Events uint32
Fd int32 X_padFd int32
Pad int32 Fd int32
Pad int32
} }
const ( const (