scottk/vault
1
0
Fork 0
mirror of https://github.com/optim-enterprises-bv/vault.git synced 2025-11-03 12:07: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",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/awserr",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/awsutil",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/client",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/client/metadata",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/corehandlers",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/defaults",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/ec2metadata",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/request",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/aws/session",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/endpoints",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/ec2query",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/jsonrpc",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/rest",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/restxml",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/signer/v4",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/private/waiter",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/service/dynamodb",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/service/ec2",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/service/iam",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/service/s3",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/aws/aws-sdk-go/service/sts",
"Comment": "v1.1.20-13-gd6f37f6",
"Rev": "d6f37f6686a9207f3688d440733c4d20301273db"
"Comment": "v1.1.22-3-g1915858",
"Rev": "1915858199be30d43264f86f9b9b469b7f2c8340"
},
{
"ImportPath": "github.com/bgentry/speakeasy",
@@ -180,32 +180,32 @@
},
{
"ImportPath": "github.com/cloudfoundry-incubator/candiedyaml",
"Rev": "5cef21e2e4f0fd147973b558d4db7395176bcd95"
"Rev": "99c3df83b51532e3615f851d8c2dbb638f5313bf"
},
{
"ImportPath": "github.com/coreos/etcd/client",
"Comment": "v2.3.0-556-g7161eee",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb"
"Comment": "v2.3.0-644-gfee71b1",
"Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
},
{
"ImportPath": "github.com/coreos/etcd/pkg/pathutil",
"Comment": "v2.3.0-556-g7161eee",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb"
"Comment": "v2.3.0-644-gfee71b1",
"Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
},
{
"ImportPath": "github.com/coreos/etcd/pkg/tlsutil",
"Comment": "v2.3.0-556-g7161eee",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb"
"Comment": "v2.3.0-644-gfee71b1",
"Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
},
{
"ImportPath": "github.com/coreos/etcd/pkg/transport",
"Comment": "v2.3.0-556-g7161eee",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb"
"Comment": "v2.3.0-644-gfee71b1",
"Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
},
{
"ImportPath": "github.com/coreos/etcd/pkg/types",
"Comment": "v2.3.0-556-g7161eee",
"Rev": "7161eeed8b7fa59551f8ad8ec71251be8579d5eb"
"Comment": "v2.3.0-644-gfee71b1",
"Rev": "fee71b18a3093223b41a592e19373f01a44e227f"
},
{
"ImportPath": "github.com/denisenkom/go-mssqldb",
@@ -234,7 +234,7 @@
},
{
"ImportPath": "github.com/go-ldap/ldap",
"Comment": "v2.2.2-3-g0e7db8e",
"Comment": "v2.3.0",
"Rev": "0e7db8eb77695b5a952f0e5d78df9ab160050c73"
},
{
@@ -244,27 +244,27 @@
},
{
"ImportPath": "github.com/gocql/gocql",
"Comment": "pre-node-events-267-g1440c60",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3"
"Comment": "pre-node-events-293-g2e0390b",
"Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
},
{
"ImportPath": "github.com/gocql/gocql/internal/lru",
"Comment": "pre-node-events-267-g1440c60",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3"
"Comment": "pre-node-events-293-g2e0390b",
"Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
},
{
"ImportPath": "github.com/gocql/gocql/internal/murmur",
"Comment": "pre-node-events-267-g1440c60",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3"
"Comment": "pre-node-events-293-g2e0390b",
"Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
},
{
"ImportPath": "github.com/gocql/gocql/internal/streams",
"Comment": "pre-node-events-267-g1440c60",
"Rev": "1440c609669494bcb31b1e300e8d2ef51e205dd3"
"Comment": "pre-node-events-293-g2e0390b",
"Rev": "2e0390b6fbe023664fcdaa9767f0f83fbe78956d"
},
{
"ImportPath": "github.com/golang/snappy",
"Rev": "ec642410cd033af63620b66a91ccbd3c69c2c59a"
"Rev": "43fea289edce21979658cbbdb3925390890aa86e"
},
{
"ImportPath": "github.com/google/go-github/github",
@@ -280,8 +280,13 @@
},
{
"ImportPath": "github.com/hashicorp/consul/api",
"Comment": "v0.6.4-256-gadcf935",
"Rev": "adcf93535058234780f9aaffb40497ba194f60a0"
"Comment": "v0.6.4-268-g9f272b0",
"Rev": "9f272b088131af951ea1f77594905ceae83fd2c1"
},
{
"ImportPath": "github.com/hashicorp/consul/lib",
"Comment": "v0.6.4-268-g9f272b0",
"Rev": "9f272b088131af951ea1f77594905ceae83fd2c1"
},
{
"ImportPath": "github.com/hashicorp/errwrap",
@@ -313,39 +318,39 @@
},
{
"ImportPath": "github.com/hashicorp/hcl",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/hcl/ast",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/hcl/parser",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/hcl/scanner",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/hcl/strconv",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/hcl/token",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/json/parser",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/json/scanner",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/hcl/json/token",
"Rev": "27a57f2605e04995c111273c263d51cee60d9bc4"
"Rev": "9a905a34e6280ce905da1a32344b25e81011197a"
},
{
"ImportPath": "github.com/hashicorp/logutils",
@@ -353,8 +358,8 @@
},
{
"ImportPath": "github.com/hashicorp/serf/coordinate",
"Comment": "v0.7.0-56-ga876af0",
"Rev": "a876af06863abed3e31252a913bad976aeff61df"
"Comment": "v0.7.0-58-gdefb069",
"Rev": "defb069b1bad9f7cdebc647810cb6ae398a1b617"
},
{
"ImportPath": "github.com/jmespath/go-jmespath",
@@ -363,13 +368,13 @@
},
{
"ImportPath": "github.com/lib/pq",
"Comment": "go1.0-cutoff-84-g3cd0097",
"Rev": "3cd0097429be7d611bb644ef85b42bfb102ceea4"
"Comment": "go1.0-cutoff-86-gdd3290b",
"Rev": "dd3290b2f71a8b30bee8e4e75a337a825263d26f"
},
{
"ImportPath": "github.com/lib/pq/oid",
"Comment": "go1.0-cutoff-84-g3cd0097",
"Rev": "3cd0097429be7d611bb644ef85b42bfb102ceea4"
"Comment": "go1.0-cutoff-86-gdd3290b",
"Rev": "dd3290b2f71a8b30bee8e4e75a337a825263d26f"
},
{
"ImportPath": "github.com/mattn/go-isatty",
@@ -410,75 +415,75 @@
},
{
"ImportPath": "golang.org/x/crypto/bcrypt",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/blowfish",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/cast5",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/curve25519",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/md4",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/openpgp",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/openpgp/armor",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/openpgp/elgamal",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/openpgp/errors",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/openpgp/packet",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/openpgp/s2k",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/ssh",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/ssh/agent",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/crypto/ssh/terminal",
"Rev": "c9aef117f53e16ed3a6cc3d93cd357dbf2005065"
"Rev": "285fb2ed20d1dc450fc743a1b3ff7c36bef372b9"
},
{
"ImportPath": "golang.org/x/net/context",
"Rev": "b797637b7aeeed133049c7281bfa31dcc9ca42d6"
"Rev": "35ec611a141ee705590b9eb64d673f9e6dfeb1ac"
},
{
"ImportPath": "golang.org/x/oauth2",
"Rev": "7e9cd5d59563851383f8f81a7fbb01213709387c"
"Rev": "9ef2eddcc6774e42f998940fe1167216d36a7424"
},
{
"ImportPath": "golang.org/x/oauth2/internal",
"Rev": "7e9cd5d59563851383f8f81a7fbb01213709387c"
"Rev": "9ef2eddcc6774e42f998940fe1167216d36a7424"
},
{
"ImportPath": "golang.org/x/sys/unix",
"Rev": "f64b50fbea64174967a8882830d621a18ee1548e"
"Rev": "b776ec39b3e54652e09028aaaaac9757f4f8211a"
},
{
"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
// 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 {
for {
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"
// 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
}
fmt.Fprintf(buf, "%q:", name)
writeString(name, buf)
buf.WriteString(`:`)
err := buildAny(member, buf, field.Tag)
if err != nil {
@@ -167,7 +168,9 @@ func buildMap(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) err
buf.WriteByte(',')
}
fmt.Fprintf(buf, "%q:", k)
writeString(k.String(), buf)
buf.WriteString(`:`)
buildAny(value.MapIndex(k), buf, "")
}

320
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).
// 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.
//
// 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) {
req, out := c.CreateVpcRequest(input)
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
// 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
// Private Gateway to Your VPC (http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_VPN.html)
// 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
// 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
// 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
}
// 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:
//
@@ -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.
// You can specify that resources should receive longer IDs (17-character IDs)
// 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
// 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
}
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"
// 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
// the hour for a one-year term. Before you can purchase a Scheduled Instance,
// 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) {
req, out := c.PurchaseScheduledInstancesRequest(input)
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
// terminated instances are ignored.
//
// If a Linux/Unix instance does not cleanly shut down within four minutes,
// Amazon EC2 performs a hard reboot.
// If an instance does not cleanly shut down within four minutes, Amazon EC2
// performs a hard reboot.
//
// For more information about troubleshooting, see Getting Console Output and
// 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
// 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
// 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) {
req, out := c.RunScheduledInstancesRequest(input)
err := req.Send()
@@ -6959,32 +7018,29 @@ func (c *EC2) StopInstancesRequest(input *StopInstancesInput) (req *request.Requ
return
}
// Stops an Amazon EBS-backed instance. 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.
// Stops an Amazon EBS-backed instance.
//
// 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
// stopped and started. When an instance is stopped, the compute resources are
// 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.
// You can't start or stop Spot instances, and you can't stop instance store-backed
// instances.
//
// 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.
// When you stop an instance, we shut it down. You can restart your instance
// 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
// its root device returns an error.
//
// You can stop, start, and terminate EBS-backed instances. You can only terminate
// instance store-backed instances. What happens to an instance differs if you
// stop it or terminate it. For example, 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 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)
// Stopping an instance is different to rebooting or terminating it. For example,
// 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
// and any other devices attached during the instance launch are automatically
// deleted. For more information about the differences between rebooting, 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.
//
// For more information about troubleshooting, see Troubleshooting Stopping
@@ -9450,11 +9506,10 @@ type CreateImageInput struct {
// at-signs (@), or underscores(_)
Name *string `locationName:"name" type:"string" required:"true"`
// By default, this parameter is set to false, which means Amazon EC2 attempts
// to shut down the instance cleanly before image creation and then reboots
// the instance. When the parameter is set to true, Amazon EC2 doesn't shut
// down the instance before creating the image. When this option is used, file
// system integrity on the created image can't be guaranteed.
// By default, Amazon EC2 attempts to shut down and reboot the instance before
// creating the image. If the 'No Reboot' option is set, Amazon EC2 doesn't
// shut down the instance before creating the image. When this option is used,
// file system integrity on the created image can't be guaranteed.
NoReboot *bool `locationName:"noReboot" type:"boolean"`
}
@@ -10755,11 +10810,11 @@ type CreateVpcInput struct {
// it is UnauthorizedOperation.
DryRun *bool `locationName:"dryRun" type:"boolean"`
// The supported tenancy options for instances launched into the VPC. A value
// of default means that instances can be launched with any tenancy; a value
// of dedicated means all instances launched into the VPC are launched as dedicated
// tenancy instances regardless of the tenancy assigned to the instance at launch.
// Dedicated tenancy instances run on single-tenant hardware.
// The tenancy options for instances launched into the VPC. For default, instances
// are launched with shared tenancy by default. You can launch instances with
// any tenancy into a shared tenancy VPC. For dedicated, instances are launched
// as dedicated tenancy instances by default. You can only launch instances
// 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
// or dedicated values only.
@@ -13282,7 +13337,8 @@ type DescribeImportImageTasksInput struct {
// it is UnauthorizedOperation.
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"`
// A list of import image task IDs.
@@ -21159,6 +21215,78 @@ func (s ModifyVpcEndpointOutput) GoString() 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.
type MonitorInstancesInput struct {
_ struct{} `type:"structure"`
@@ -21706,6 +21834,68 @@ func (s NewDhcpConfiguration) GoString() 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.
type Placement struct {
_ struct{} `type:"structure"`
@@ -25698,8 +25888,8 @@ type StateReason struct {
// The message for the state change.
//
// Server.SpotInstanceTermination: A Spot instance was terminated due to
// an increase in the market price.
// Server.SpotInstanceTermination: A Spot instance was terminated due to an
// increase in the market price.
//
// Server.InternalError: An internal error occurred during instance launch,
// resulting in termination.
@@ -25707,18 +25897,17 @@ type StateReason struct {
// Server.InsufficientInstanceCapacity: There was insufficient instance capacity
// to satisfy the launch request.
//
// Client.InternalError: A client error caused the instance to terminate
// on launch.
// Client.InternalError: A client error caused the instance to terminate on
// launch.
//
// Client.InstanceInitiatedShutdown: The instance was shut down using the
// shutdown -h command from the instance.
// Client.InstanceInitiatedShutdown: The instance was shut down using the shutdown
// -h command from the instance.
//
// Client.UserInitiatedShutdown: The instance was shut down using the Amazon
// EC2 API.
//
// Client.VolumeLimitExceeded: The limit on the number of EBS volumes or
// total storage was exceeded. Decrease usage or request an increase in your
// limits.
// Client.VolumeLimitExceeded: The limit on the number of EBS volumes or total
// storage was exceeded. Decrease usage or request an increase in your limits.
//
// Client.InvalidSnapshot.NotFound: The specified snapshot was not found.
Message *string `locationName:"message" type:"string"`
@@ -26627,13 +26816,15 @@ func (s VpcEndpoint) GoString() string {
type VpcPeeringConnection struct {
_ 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"`
// The time that an unaccepted VPC peering connection will expire.
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"`
// The status of the VPC peering connection.
@@ -26656,6 +26847,29 @@ func (s VpcPeeringConnection) GoString() 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.
type VpcPeeringConnectionStateReason struct {
_ struct{} `type:"structure"`
@@ -26687,6 +26901,10 @@ type VpcPeeringConnectionVpcInfo struct {
// The AWS account ID of the VPC owner.
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.
VpcId *string `locationName:"vpcId" type:"string"`
}

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

@@ -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,
// 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
// is being assumed, and the policy that you pass. This gives you a way to further
// restrict the permissions for the resulting temporary security credentials.
// is being assumed, and the policy that you pass. This gives you a way to
// further restrict the permissions for the resulting temporary security credentials.
// 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.
// 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,
// 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
// is being assumed, and the policy that you pass. This gives you a way to further
// restrict the permissions for the resulting temporary security credentials.
// is being assumed, and the policy that you pass. This gives you a way to
// further restrict the permissions for the resulting temporary security credentials.
// 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.
// 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
// that is uploaded for the SAML provider entity for your identity provider.
//
// 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).
//
// For more information, see the following resources:
//
// 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 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.
//
// 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.
func (c *STS) AssumeRoleWithSAML(input *AssumeRoleWithSAMLInput) (*AssumeRoleWithSAMLOutput, error) {
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,
// 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
// is being assumed, and the policy that you pass. This gives you a way to further
// restrict the permissions for the resulting temporary security credentials.
// is being assumed, and the policy that you pass. This gives you a way to
// further restrict the permissions for the resulting temporary security credentials.
// 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.
// 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
// words, the identity provider must be specified in the role's trust policy.
//
// 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:
//
// 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).
//
// 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
// 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
// (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,
// 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).
// and then using those credentials to make a request to AWS.
//
// AWS SDK for iOS (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, 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
// to use web identity federation to get access to content in Amazon S3.
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
// for an individual action indicates whether that action returns an encoded
// message in addition to returning an HTTP code. The message is encoded because
// the details of the authorization status can constitute privileged information
// that the user who requested the 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.
// message in addition to returning an HTTP code.
//
// The message is encoded because the details of the authorization status
// can constitute privileged information that the user who requested the 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:
//
// 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
// 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
// action. The requested resource. The values of condition keys in the context
// of the user's request.
// in the IAM User Guide.
//
// 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) {
req, out := c.DecodeAuthorizationMessageRequest(input)
err := req.Send()
@@ -450,16 +481,19 @@ func (c *STS) GetFederationTokenRequest(input *GetFederationTokenInput) (req *re
// are determined by a combination of the following:
//
// 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
// 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
// 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
// attached to the IAM user whose credentials were used to call GetFederationToken.
// AWS 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.
// are used to call GetFederationToken.
//
// The policy that is passed as a parameter 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 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 attached
// to the IAM user whose credentials were used to call GetFederationToken. AWS
// 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
// 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
// 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.
//
// 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"`
// An IAM policy in JSON format.
@@ -588,6 +626,12 @@ type AssumeRoleInput struct {
// and AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
// in the IAM User Guide.
//
// 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.
// The PackedPolicySize response element indicates by percentage how close to
@@ -607,6 +651,10 @@ type AssumeRoleInput struct {
// of the assumed role principal. This means that subsequent cross-account API
// requests using the temporary security credentials will expose the role session
// 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"`
// 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.
// 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).
//
// 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"`
// 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
// 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.
//
// The format for this parameter, as described by its regex pattern, is a sequence
// of six numeric digits.
TokenCode *string `min:"6" type:"string"`
}
@@ -716,8 +771,8 @@ type AssumeRoleWithSAMLInput struct {
// response's SessionNotOnOrAfter value. The actual expiration time is whichever
// value is shorter.
//
// The maximum duration for a session is 1 hour, and the minimum duration is
// 15 minutes, even if values outside this range are specified.
// The maximum duration for a session is 1 hour, and the minimum duration
// is 15 minutes, even if values outside this range are specified.
DurationSeconds *int64 `min:"900" type:"integer"`
// An IAM policy in JSON format.
@@ -725,14 +780,20 @@ type AssumeRoleWithSAMLInput struct {
// The policy parameter is optional. If you pass a policy, 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 is being assumed,
// and the policy that you pass. This gives you a way to further restrict the
// permissions for the resulting temporary security credentials. You cannot
// and the policy that you pass. This gives you a way to further restrict
// the permissions for the resulting temporary security credentials. 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. For more information,
// Permissions for AssumeRole, AssumeRoleWithSAML, and AssumeRoleWithWebIdentity
// (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
// in the IAM User Guide.
//
// 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.
// The PackedPolicySize response element indicates by percentage how close to
@@ -877,13 +938,19 @@ type AssumeRoleWithWebIdentityInput struct {
// The policy parameter is optional. If you pass a policy, 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 is being assumed,
// and the policy that you pass. This gives you a way to further restrict the
// permissions for the resulting temporary security credentials. You cannot
// and the policy that you pass. This gives you a way to further restrict
// the permissions for the resulting temporary security credentials. 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. For more information,
// see Permissions for AssumeRoleWithWebIdentity (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_assumerole.html)
// in the IAM User Guide.
//
// 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.
// The PackedPolicySize response element indicates by percentage how close to
@@ -908,6 +975,10 @@ type AssumeRoleWithWebIdentityInput struct {
// 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
// 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"`
// The OAuth 2.0 access token or OpenID Connect ID token that is provided by
@@ -1113,8 +1184,7 @@ func (s *DecodeAuthorizationMessageInput) Validate() error {
type DecodeAuthorizationMessageOutput struct {
_ struct{} `type:"structure"`
// An XML document that contains the decoded message. For more information,
// see DecodeAuthorizationMessage.
// An XML document that contains the decoded message.
DecodedMessage *string `type:"string"`
}
@@ -1212,6 +1282,10 @@ type GetFederationTokenInput struct {
// 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
// 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"`
// 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
// that specifically allows the federated user to access the resource.
//
// 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.
// The PackedPolicySize response element indicates by percentage how close to
// the upper size limit the policy is, with 100% equaling the maximum allowed
// size. 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).
// size.
//
// 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"`
}
@@ -1324,6 +1406,10 @@ type GetSessionTokenInput struct {
// 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
// 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"`
// 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
// temporary security credentials, the user will receive an "access denied"
// 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"`
}

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

@@ -24,17 +24,18 @@ import (
// of cryptographically signing requests, managing errors, and retrying requests
// 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/).
//
// 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"
// target="_blank) in the AWS General Reference. For general information about
// the Query API, 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
// 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)
// API, go to Signing AWS API Requests (http://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html)
// in the AWS General Reference. For general information about the Query API,
// go to Making Query Requests (http://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_UsingQueryAPI.html)
// in Using IAM. For information about using security tokens 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)
// in the IAM User Guide.
//
// 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/
// (http://aws.amazon.com/documentation/" target="_blank).
// (http://aws.amazon.com/documentation/).
//
// 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)
[![GoDoc](https://godoc.org/github.com/cloudfoundry-incubator/candiedyaml?status.svg)](https://godoc.org/github.com/cloudfoundry-incubator/candiedyaml)
candiedyaml
===========

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

@@ -1,6 +1,7 @@
language: go
sudo: false
sudo: required
dist: trusty
cache:
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>
Alexander Inozemtsev <alexander.inozemtsev@gmail.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
// 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
// receiving a schema change frame. (deault: 60s)
MaxWaitSchemaAgreement time.Duration
@@ -126,6 +129,7 @@ func NewCluster(hosts ...string) *ClusterConfig {
PageSize: 5000,
DefaultTimestamp: true,
MaxWaitSchemaAgreement: 60 * time.Second,
ReconnectInterval: 60 * time.Second,
}
return cfg
}

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

@@ -9,7 +9,6 @@ import (
"crypto/tls"
"errors"
"fmt"
"golang.org/x/net/context"
"io"
"io/ioutil"
"log"
@@ -20,6 +19,8 @@ import (
"sync/atomic"
"time"
"golang.org/x/net/context"
"github.com/gocql/gocql/internal/lru"
"github.com/gocql/gocql/internal/streams"
@@ -127,7 +128,7 @@ type Conn struct {
timeout time.Duration
cfg *ConnConfig
headerBuf []byte
headerBuf [maxFrameHeaderSize]byte
streams *streams.IDGenerator
mu sync.RWMutex
@@ -175,17 +176,6 @@ func Connect(host *HostInfo, addr string, cfg *ConnConfig,
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{
conn: conn,
r: bufio.NewReader(conn),
@@ -197,7 +187,6 @@ func Connect(host *HostInfo, addr string, cfg *ConnConfig,
errorHandler: errorHandler,
compressor: cfg.Compressor,
auth: cfg.Authenticator,
headerBuf: make([]byte, headerSize),
quit: make(chan struct{}),
session: session,
streams: streams.New(cfg.ProtoVersion),
@@ -208,33 +197,49 @@ func Connect(host *HostInfo, addr string, cfg *ConnConfig,
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)
startupErr := make(chan error, 1)
startupErr := make(chan error)
go func() {
for range frameTicker {
err := c.recv()
startupErr <- err
if err != nil {
select {
case startupErr <- err:
case <-ctx.Done():
}
return
}
}
}()
err = c.startup(frameTicker)
close(frameTicker)
if err != nil {
conn.Close()
return nil, err
go func() {
defer close(frameTicker)
err := c.startup(ctx, frameTicker)
select {
case startupErr <- err:
case <-ctx.Done():
}
}()
select {
case err := <-startupErr:
if err != nil {
log.Println(err)
c.Close()
return nil, err
}
case <-time.After(c.timeout):
case <-ctx.Done():
c.Close()
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
}
func (c *Conn) startup(frameTicker chan struct{}) error {
func (c *Conn) startup(ctx context.Context, frameTicker chan struct{}) error {
m := map[string]string{
"CQL_VERSION": c.cfg.CQLVersion,
}
@@ -284,8 +289,13 @@ func (c *Conn) startup(frameTicker chan struct{}) error {
m["COMPRESSION"] = c.compressor.Name()
}
frameTicker <- struct{}{}
framer, err := c.exec(context.Background(), &writeStartupFrame{opts: m}, nil)
select {
case frameTicker <- struct{}{}:
case <-ctx.Done():
return ctx.Err()
}
framer, err := c.exec(ctx, &writeStartupFrame{opts: m}, nil)
if err != nil {
return err
}
@@ -301,13 +311,13 @@ func (c *Conn) startup(frameTicker chan struct{}) error {
case *readyFrame:
return nil
case *authenticateFrame:
return c.authenticateHandshake(v, frameTicker)
return c.authenticateHandshake(ctx, v, frameTicker)
default:
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 {
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}
for {
frameTicker <- struct{}{}
framer, err := c.exec(context.Background(), req, nil)
select {
case frameTicker <- struct{}{}:
case <-ctx.Done():
return ctx.Err()
}
framer, err := c.exec(ctx, req, nil)
if err != nil {
return err
}
@@ -425,7 +440,7 @@ func (c *Conn) recv() error {
}
// 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 {
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) {
perm := randr.Perm(len(endpoints))
shuffled := make([]string, len(endpoints))
@@ -101,24 +117,19 @@ func (c *controlConn) shuffleDial(endpoints []string) (conn *Conn, err error) {
// node.
for _, addr := range shuffled {
if addr == "" {
return nil, fmt.Errorf("control: invalid address: %q", addr)
return nil, fmt.Errorf("invalid address: %q", addr)
}
port := c.session.cfg.Port
addr = JoinHostPort(addr, port)
host, portStr, err := net.SplitHostPort(addr)
var host *HostInfo
host, err = hostInfo(addr, port)
if err != nil {
host = addr
port = c.session.cfg.Port
err = nil
} else {
port, err = strconv.Atoi(portStr)
if err != nil {
return nil, err
}
return nil, fmt.Errorf("invalid address: %q: %v", addr, 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)
if err == nil {
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)
}
return
if err != nil {
return nil, err
}
return conn, nil
}
func (c *controlConn) connect(endpoints []string) error {
@@ -137,9 +152,7 @@ func (c *controlConn) connect(endpoints []string) error {
conn, err := c.shuffleDial(endpoints)
if err != nil {
return fmt.Errorf("control: unable to connect: %v", err)
} else if conn == nil {
return errors.New("control: unable to connect to initial endpoints")
return fmt.Errorf("control: unable to connect to initial hosts: %v", err)
}
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
errReadFailure = 0x1300
errFunctionFailure = 0x1400
errWriteFailure = 0x1500
errSyntax = 0x2000
errUnauthorized = 0x2100
errInvalid = 0x2200
@@ -70,6 +71,15 @@ type RequestErrWriteTimeout struct {
WriteType string
}
type RequestErrWriteFailure struct {
errorFrame
Consistency Consistency
Received int
BlockFor int
NumFailures int
WriteType string
}
type RequestErrReadTimeout struct {
errorFrame
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) {
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) {
@@ -233,6 +244,9 @@ func (s *Session) handleRemovedNode(ip net.IP, port int) {
}
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()
host := s.ring.getHost(addr)
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) {
if gocqlDebug {
log.Printf("gocql: Session.handleNodeDown: %s:%d\n", ip.String(), port)
}
addr := ip.String()
host := s.ring.getHost(addr)
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")
)
const maxFrameHeaderSize = 9
func writeInt(p []byte, n int32) {
p[0] = byte(n >> 24)
p[1] = byte(n >> 16)
@@ -339,23 +341,34 @@ type frame interface {
}
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 {
return
return frameHeader{}, err
}
version := p[0] & protoVersionMask
if version < protoVersion1 || version > protoVersion4 {
err = fmt.Errorf("gocql: invalid version: %d", version)
return
return frameHeader{}, fmt.Errorf("gocql: unsupported response version: %d", version)
}
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.flags = p[1]
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))
}
@@ -363,7 +376,7 @@ func readHeader(r io.Reader, p []byte) (head frameHeader, err error) {
head.op = frameOp(p[4])
head.length = int(readInt(p[5:]))
} 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))
}
@@ -372,7 +385,7 @@ func readHeader(r io.Reader, p []byte) (head frameHeader, err error) {
head.length = int(readInt(p[4:]))
}
return
return head, nil
}
// 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
_, err := io.ReadFull(f.r, f.rbuf)
n, err := io.ReadFull(f.r, f.rbuf)
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 {
@@ -544,6 +557,16 @@ func (f *framer) parseErrorFrame() frame {
res.BlockFor = f.readInt()
res.DataPresent = f.readByte() != 0
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:
res := RequestErrFunctionFailure{
errorFrame: errD,
@@ -552,8 +575,12 @@ func (f *framer) parseErrorFrame() frame {
res.Function = f.readString()
res.ArgTypes = f.readStringList()
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:
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()
defer s.mu.Unlock()
// TODO handle schema change events
metadata, found := s.cache[keyspaceName]
if !found {
// refresh the cache for this keyspace
@@ -121,6 +119,14 @@ func (s *schemaDescriber) getSchema(keyspaceName string) (*KeyspaceMetadata, err
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
// for a given named keyspace.
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"
"errors"
"fmt"
"golang.org/x/net/context"
"io"
"log"
"net"
"strconv"
"strings"
@@ -19,6 +19,8 @@ import (
"time"
"unicode"
"golang.org/x/net/context"
"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
// can connect to one of the endpoints supplied by using the control conn.
// See if there are any connections in the pool
@@ -188,6 +194,30 @@ func NewSession(cfg ClusterConfig) (*Session, error) {
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
// setting can also be changed on a per-query basis and the default value
// 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
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"
// TODO: figure out why the XXX lines compile with Go 1.4 and Go tip but not
// Go 1.6.
// The XXX lines assemble on Go 1.4, 1.5 and 1.7, but not 1.6, due to a
// 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
// where marked with a "!!!".
@@ -21,19 +28,23 @@
// func emitLiteral(dst, lit []byte) int
//
// All local variables fit into registers. The register allocation:
// - AX return value
// - AX len(lit)
// - BX n
// - CX len(lit)
// - SI &lit[0]
// - DX return value
// - DI &dst[i]
// - R10 &lit[0]
//
// 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
MOVQ dst_base+0(FP), DI
MOVQ lit_base+24(FP), SI
MOVQ lit_len+32(FP), CX
MOVQ CX, AX
MOVL CX, BX
MOVQ lit_base+24(FP), R10
MOVQ lit_len+32(FP), AX
MOVQ AX, DX
MOVL AX, BX
SUBL $1, BX
CMPL BX, $60
@@ -45,32 +56,32 @@ threeBytes:
MOVB $0xf4, 0(DI)
MOVW BX, 1(DI)
ADDQ $3, DI
ADDQ $3, AX
JMP emitLiteralEnd
ADDQ $3, DX
JMP memmove
twoBytes:
MOVB $0xf0, 0(DI)
MOVB BX, 1(DI)
ADDQ $2, DI
ADDQ $2, AX
JMP emitLiteralEnd
ADDQ $2, DX
JMP memmove
oneByte:
SHLB $2, BX
MOVB BX, 0(DI)
ADDQ $1, DI
ADDQ $1, AX
ADDQ $1, DX
emitLiteralEnd:
MOVQ AX, ret+48(FP)
memmove:
MOVQ DX, ret+48(FP)
// copy(dst[i:], lit)
//
// 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 SI, 8(SP)
MOVQ CX, 16(SP)
MOVQ R10, 8(SP)
MOVQ AX, 16(SP)
CALL runtime·memmove(SB)
RET
@@ -79,55 +90,59 @@ emitLiteralEnd:
// func emitCopy(dst []byte, offset, length int) int
//
// All local variables fit into registers. The register allocation:
// - BX offset
// - CX length
// - AX length
// - SI &dst[0]
// - 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
MOVQ dst_base+0(FP), DI
MOVQ DI, SI
MOVQ offset+24(FP), BX
MOVQ length+32(FP), CX
MOVQ offset+24(FP), R11
MOVQ length+32(FP), AX
loop0:
// for length >= 68 { etc }
CMPL CX, $68
CMPL AX, $68
JLT step1
// Emit a length 64 copy, encoded as 3 bytes.
MOVB $0xfe, 0(DI)
MOVW BX, 1(DI)
MOVW R11, 1(DI)
ADDQ $3, DI
SUBL $64, CX
SUBL $64, AX
JMP loop0
step1:
// if length > 64 { etc }
CMPL CX, $64
CMPL AX, $64
JLE step2
// Emit a length 60 copy, encoded as 3 bytes.
MOVB $0xee, 0(DI)
MOVW BX, 1(DI)
MOVW R11, 1(DI)
ADDQ $3, DI
SUBL $60, CX
SUBL $60, AX
step2:
// if length >= 12 || offset >= 2048 { goto step3 }
CMPL CX, $12
CMPL AX, $12
JGE step3
CMPL BX, $2048
CMPL R11, $2048
JGE step3
// Emit the remaining copy, encoded as 2 bytes.
MOVB BX, 1(DI)
SHRL $8, BX
SHLB $5, BX
SUBB $4, CX
SHLB $2, CX
ORB CX, BX
ORB $1, BX
MOVB BX, 0(DI)
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
// Return the number of bytes written.
@@ -137,11 +152,11 @@ step2:
step3:
// Emit the remaining copy, encoded as 3 bytes.
SUBL $1, CX
SHLB $2, CX
ORB $2, CX
MOVB CX, 0(DI)
MOVW BX, 1(DI)
SUBL $1, AX
SHLB $2, AX
ORB $2, AX
MOVB AX, 0(DI)
MOVW R11, 1(DI)
ADDQ $3, DI
// Return the number of bytes written.
@@ -154,33 +169,37 @@ step3:
// func extendMatch(src []byte, i, j int) int
//
// All local variables fit into registers. The register allocation:
// - CX &src[0]
// - DX &src[len(src)]
// - SI &src[i]
// - DI &src[j]
// - R9 &src[len(src) - 8]
// - DX &src[0]
// - SI &src[j]
// - R13 &src[len(src) - 8]
// - R14 &src[len(src)]
// - 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
MOVQ src_base+0(FP), CX
MOVQ src_len+8(FP), DX
MOVQ i+24(FP), SI
MOVQ j+32(FP), DI
ADDQ CX, DX
ADDQ CX, SI
ADDQ CX, DI
MOVQ DX, R9
SUBQ $8, R9
MOVQ src_base+0(FP), DX
MOVQ src_len+8(FP), R14
MOVQ i+24(FP), R15
MOVQ j+32(FP), SI
ADDQ DX, R14
ADDQ DX, R15
ADDQ DX, SI
MOVQ R14, R13
SUBQ $8, R13
cmp8:
// 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 DI, R9
CMPQ SI, R13
JA cmp1
MOVQ (SI), AX
MOVQ (DI), BX
MOVQ (R15), AX
MOVQ (SI), BX
CMPQ AX, BX
JNE bsf
ADDQ $8, R15
ADDQ $8, SI
ADDQ $8, DI
JMP cmp8
bsf:
@@ -191,29 +210,29 @@ bsf:
XORQ AX, BX
BSFQ BX, BX
SHRQ $3, BX
ADDQ BX, DI
ADDQ BX, SI
// Convert from &src[ret] to ret.
SUBQ CX, DI
MOVQ DI, ret+40(FP)
SUBQ DX, SI
MOVQ SI, ret+40(FP)
RET
cmp1:
// In src's tail, compare 1 byte at a time.
CMPQ DI, DX
CMPQ SI, R14
JAE extendMatchEnd
MOVB (SI), AX
MOVB (DI), BX
MOVB (R15), AX
MOVB (SI), BX
CMPB AX, BX
JNE extendMatchEnd
ADDQ $1, R15
ADDQ $1, SI
ADDQ $1, DI
JMP cmp1
extendMatchEnd:
// Convert from &src[ret] to ret.
SUBQ CX, DI
MOVQ DI, ret+40(FP)
SUBQ DX, SI
MOVQ SI, ret+40(FP)
RET
// ----------------------------------------------------------------------------
@@ -232,8 +251,8 @@ extendMatchEnd:
// - R10 . &src[nextEmit]
// - R11 96 prevHash, currHash, nextHash, offset
// - R12 104 &src[base], skip
// - R13 . &src[nextS]
// - R14 . len(src), bytesBetweenHashLookups, x
// - R13 . &src[nextS], &src[len(src) - 8]
// - R14 . len(src), bytesBetweenHashLookups, &src[len(src)], x
// - R15 112 candidate
//
// The second column (56, 64, etc) is the stack offset to spill the registers
@@ -352,6 +371,7 @@ inner0:
// table[nextHash] = uint16(s)
MOVQ SI, AX
SUBQ DX, AX
// XXX: MOVW AX, table-32768(SP)(R11*2)
// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
BYTE $0x66
@@ -384,32 +404,63 @@ fourByteMatch:
CMPQ AX, $16
JLE emitLiteralFastPath
// d += emitLiteral(dst[d:], src[nextEmit:s])
// ----------------------------------------
// Begin inline of the emitLiteral call.
//
// Push args.
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.
// d += emitLiteral(dst[d:], src[nextEmit:s])
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.
//
// 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 DI, 80(SP)
MOVQ R15, 112(SP)
CALL ·emitLiteral(SB)
CALL runtime·memmove(SB)
MOVQ 56(SP), CX
MOVQ 64(SP), DX
MOVQ 72(SP), SI
MOVQ 80(SP), DI
MOVQ 88(SP), R9
MOVQ 112(SP), R15
// Finish the "d +=" part of "d += emitLiteral(etc)".
ADDQ 48(SP), DI
JMP inner1
inlineEmitLiteralEnd:
// End inline of the emitLiteral call.
// ----------------------------------------
emitLiteralFastPath:
// !!! Emit the 1-byte encoding "uint8(len(lit)-1)<<2".
MOVB AX, BX
@@ -442,60 +493,129 @@ inner1:
SUBQ R15, R11
SUBQ DX, R11
// ----------------------------------------
// Begin inline of the extendMatch call.
//
// s = extendMatch(src, candidate+4, s+4)
//
// Push args.
MOVQ DX, 0(SP)
// !!! R14 = &src[len(src)]
MOVQ src_len+32(FP), R14
MOVQ R14, 8(SP)
MOVQ R14, 16(SP) // Unnecessary, as the callee ignores it, but conservative.
ADDQ DX, R14
// !!! R13 = &src[len(src) - 8]
MOVQ R14, R13
SUBQ $8, R13
// !!! R15 = &src[candidate + 4]
ADDQ $4, R15
MOVQ R15, 24(SP)
ADDQ DX, R15
// !!! s += 4
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)
//
// Push args.
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)
// !!! length := s - base
MOVQ SI, AX
SUBQ R12, AX
MOVQ AX, 32(SP)
// Spill local variables (registers) onto the stack; call; unspill.
MOVQ SI, 72(SP)
MOVQ DI, 80(SP)
CALL ·emitCopy(SB)
MOVQ 56(SP), CX
MOVQ 64(SP), DX
MOVQ 72(SP), SI
MOVQ 80(SP), DI
MOVQ 88(SP), R9
inlineEmitCopyLoop0:
// for length >= 68 { etc }
CMPL AX, $68
JLT inlineEmitCopyStep1
// Finish the "d +=" part of "d += emitCopy(etc)".
ADDQ 40(SP), DI
// Emit a length 64 copy, encoded as 3 bytes.
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
MOVQ SI, R10
@@ -522,6 +642,7 @@ inner1:
MOVQ SI, AX
SUBQ DX, AX
SUBQ $1, AX
// XXX: MOVW AX, table-32768(SP)(R11*2)
// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
BYTE $0x66
@@ -549,6 +670,7 @@ inner1:
// table[currHash] = uint16(s)
ADDQ $1, AX
// XXX: MOVW AX, table-32768(SP)(R11*2)
// XXX: 66 42 89 44 5c 78 mov %ax,0x78(%rsp,%r11,2)
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.
// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris rumprun
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 {
t.sessionID = result.H
result.SessionID = result.H
}
result.SessionID = t.sessionID
t.conn.prepareKeyChange(algs, result)
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
// // 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 {
// v, err := DoSomething(ctx)
// 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) {
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 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 Getrlimit(resource int, rlim *Rlimit) (err error) = SYS_UGETRLIMIT
//sysnb Getuid() (uid int)
//sysnb InotifyInit() (fd int, err error)
//sys Ioperm(from int, num int, on int) (err error)
//sys Iopl(level 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) {
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
// alignment requirements of EABI
int32_t padFd;
#endif
#ifdef __powerpc64__
int32_t _padFd;
#endif
int32_t fd;
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
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) {
_, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on))
if e1 != 0 {
@@ -1810,3 +1821,23 @@ func Utime(path string, buf *Utimbuf) (err error) {
}
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
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) {
_, _, e1 := Syscall(SYS_IOPERM, uintptr(from), uintptr(num), uintptr(on))
if e1 != 0 {
@@ -1810,3 +1821,23 @@ func Utime(path string, buf *Utimbuf) (err error) {
}
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
}

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

@@ -590,6 +590,7 @@ type Ustat_t struct {
type EpollEvent struct {
Events uint32
X_padFd int32
Fd int32
Pad int32
}

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

@@ -590,6 +590,7 @@ type Ustat_t struct {
type EpollEvent struct {
Events uint32
X_padFd int32
Fd int32
Pad int32
}