diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index f586da90b5..62858eceb7 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -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", diff --git a/vendor/github.com/aws/aws-sdk-go/aws/request/request.go b/vendor/github.com/aws/aws-sdk-go/aws/request/request.go index 2b3329dbc7..2391632f16 100644 --- a/vendor/github.com/aws/aws-sdk-go/aws/request/request.go +++ b/vendor/github.com/aws/aws-sdk-go/aws/request/request.go @@ -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) { diff --git a/vendor/github.com/aws/aws-sdk-go/aws/version.go b/vendor/github.com/aws/aws-sdk-go/aws/version.go index f044144c4f..508b6ae0a8 100644 --- a/vendor/github.com/aws/aws-sdk-go/aws/version.go +++ b/vendor/github.com/aws/aws-sdk-go/aws/version.go @@ -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" diff --git a/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go index 1d552afe45..7ad6742785 100644 --- a/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go +++ b/vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build.go @@ -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, "") } diff --git a/vendor/github.com/aws/aws-sdk-go/service/ec2/api.go b/vendor/github.com/aws/aws-sdk-go/service/ec2/api.go index 5c00ca0537..2b968591b1 100644 --- a/vendor/github.com/aws/aws-sdk-go/service/ec2/api.go +++ b/vendor/github.com/aws/aws-sdk-go/service/ec2/api.go @@ -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: // @@ -3328,7 +3338,7 @@ func (c *EC2) DescribeInstanceStatusRequest(input *DescribeInstanceStatusInput) // and Troubleshooting Instances with Failed Status Checks (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstances.html) // in the Amazon Elastic Compute Cloud User Guide. // -// Scheduled events - Amazon EC2 can schedule events (such as reboot, stop, +// Scheduled events - Amazon EC2 can schedule events (such as reboot, stop, // or terminate) for your instances related to hardware issues, software updates, // or system maintenance. For more information, see Scheduled Events for Your // Instances (http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-instances-status-check_sched.html) @@ -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,29 +25888,28 @@ 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, + // Server.InternalError: An internal error occurred during instance launch, // resulting in termination. // - // Server.InsufficientInstanceCapacity: There was insufficient instance capacity + // 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 + // 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. + // 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"` } diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/api.go b/vendor/github.com/aws/aws-sdk-go/service/sts/api.go index 05a04db4a7..35a0981662 100644 --- a/vendor/github.com/aws/aws-sdk-go/service/sts/api.go +++ b/vendor/github.com/aws/aws-sdk-go/service/sts/api.go @@ -39,7 +39,7 @@ func (c *STS) AssumeRoleRequest(input *AssumeRoleInput) (req *request.Request, o // and Comparing the AWS STS APIs (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#stsapi_comparison) // in the IAM User Guide. // -// Important: You cannot call AssumeRole by using AWS root account credentials; +// Important: You cannot call AssumeRole by using AWS root account credentials; // access is denied. You must use IAM user credentials or temporary security // credentials to call AssumeRole. // @@ -78,8 +78,8 @@ func (c *STS) AssumeRoleRequest(input *AssumeRoleInput) (req *request.Request, o // policy of the role that is being assumed. If you pass a policy to this operation, // 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. // -// For more information, see the following resources: +// Calling AssumeRoleWithSAML can result in an entry in your AWS CloudTrail +// logs. The entry includes the value in the NameID element of the SAML assertion. +// We recommend that you use a NameIDType that is not associated with any personally +// identifiable information (PII). For example, you could instead use the Persistent +// Identifier (urn:oasis:names:tc:SAML:2.0:nameid-format:persistent). // -// About SAML 2.0-based Federation (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html) -// 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) +// 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. 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. // -// For more information about how to use web identity federation and the AssumeRoleWithWebIdentity +// Calling AssumeRoleWithWebIdentity can result in an entry in your AWS CloudTrail +// logs. The entry includes the Subject (http://openid.net/specs/openid-connect-core-1_0.html#Claims) +// of the provided Web Identity Token. We recommend that you avoid using any +// personally identifiable information (PII) in this field. For example, you +// could instead use a GUID or a pairwise identifier, as suggested in the OIDC +// specification (http://openid.net/specs/openid-connect-core-1_0.html#SubjectIDTypes). +// +// For more information about how to use web identity federation and the AssumeRoleWithWebIdentity // API, see the following resources: // -// Using Web Identity Federation APIs for Mobile Apps (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_manual) +// Using Web Identity Federation APIs for Mobile Apps (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_manual) // and Federation Through a Web-based Identity Provider (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity). -// Web Identity Federation Playground (https://web-identity-federation-playground.s3.amazonaws.com/index.html). +// +// Web Identity Federation Playground (https://web-identity-federation-playground.s3.amazonaws.com/index.html). // This interactive website lets you walk through the process of authenticating // 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 +// 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() @@ -449,17 +480,20 @@ func (c *STS) GetFederationTokenRequest(input *GetFederationTokenInput) (req *re // The permissions for the temporary security credentials returned by GetFederationToken // 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. +// 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. // // 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,7 +626,13 @@ 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 policy plain text must be 2048 bytes or shorter. However, an internal + // The format for this parameter, as described by its regex pattern, is a string + // of characters up to 2048 characters in length. The characters can be any + // ASCII character from the space character to the end of the valid character + // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A), + // and carriage return (\u000D) characters. + // + // The policy plain text must be 2048 bytes or shorter. However, an internal // conversion compresses it into a packed binary format with a separate limit. // The PackedPolicySize response element indicates by percentage how close to // the upper size limit the policy is, with 100% equaling the maximum allowed @@ -607,6 +651,10 @@ type AssumeRoleInput struct { // of the assumed role principal. This means that subsequent cross-account API // 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"` } @@ -685,7 +740,7 @@ type AssumeRoleOutput struct { // The temporary security credentials, which include an access key ID, a secret // access key, and a security (or session) token. // - // Note: The size of the security token that STS APIs return is not fixed. + // Note: The size of the security token that STS APIs return is not fixed. // We strongly recommend that you make no assumptions about the maximum size. // As of this writing, the typical size is less than 4096 bytes, but that can // vary. Also, future updates to AWS might require larger sizes. @@ -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,15 +780,21 @@ 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 policy plain text must be 2048 bytes or shorter. However, an internal + // The format for this parameter, as described by its regex pattern, is a string + // of characters up to 2048 characters in length. The characters can be any + // ASCII character from the space character to the end of the valid character + // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A), + // and carriage return (\u000D) characters. + // + // The policy plain text must be 2048 bytes or shorter. However, an internal // conversion compresses it into a packed binary format with a separate limit. // The PackedPolicySize response element indicates by percentage how close to // the upper size limit the policy is, with 100% equaling the maximum allowed @@ -815,7 +876,7 @@ type AssumeRoleWithSAMLOutput struct { // The temporary security credentials, which include an access key ID, a secret // access key, and a security (or session) token. // - // Note: The size of the security token that STS APIs return is not fixed. + // Note: The size of the security token that STS APIs return is not fixed. // We strongly recommend that you make no assumptions about the maximum size. // As of this writing, the typical size is less than 4096 bytes, but that can // vary. Also, future updates to AWS might require larger sizes. @@ -877,14 +938,20 @@ 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 policy plain text must be 2048 bytes or shorter. However, an internal + // The format for this parameter, as described by its regex pattern, is a string + // of characters up to 2048 characters in length. The characters can be any + // ASCII character from the space character to the end of the valid character + // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A), + // and carriage return (\u000D) characters. + // + // The policy plain text must be 2048 bytes or shorter. However, an internal // conversion compresses it into a packed binary format with a separate limit. // The PackedPolicySize response element indicates by percentage how close to // the upper size limit the policy is, with 100% equaling the maximum allowed @@ -908,6 +975,10 @@ type AssumeRoleWithWebIdentityInput struct { // That way, the temporary security credentials that your application will use // 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 @@ -984,7 +1055,7 @@ type AssumeRoleWithWebIdentityOutput struct { // The temporary security credentials, which include an access key ID, a secret // access key, and a security token. // - // Note: The size of the security token that STS APIs return is not fixed. + // Note: The size of the security token that STS APIs return is not fixed. // We strongly recommend that you make no assumptions about the maximum size. // As of this writing, the typical size is less than 4096 bytes, but that can // vary. Also, future updates to AWS might require larger sizes. @@ -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 policy plain text must be 2048 bytes or shorter. However, an internal + // The format for this parameter, as described by its regex pattern, is a string + // of characters up to 2048 characters in length. The characters can be any + // ASCII character from the space character to the end of the valid character + // list (\u0020-\u00FF). It can also include the tab (\u0009), linefeed (\u000A), + // and carriage return (\u000D) characters. + // + // The policy plain text must be 2048 bytes or shorter. However, an internal // conversion compresses it into a packed binary format with a separate limit. // 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"` } @@ -1278,7 +1360,7 @@ type GetFederationTokenOutput struct { // The temporary security credentials, which include an access key ID, a secret // access key, and a security (or session) token. // - // Note: The size of the security token that STS APIs return is not fixed. + // Note: The size of the security token that STS APIs return is not fixed. // We strongly recommend that you make no assumptions about the maximum size. // As of this writing, the typical size is less than 4096 bytes, but that can // vary. Also, future updates to AWS might require larger sizes. @@ -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"` } @@ -1371,7 +1460,7 @@ type GetSessionTokenOutput struct { // The temporary security credentials, which include an access key ID, a secret // access key, and a security (or session) token. // - // Note: The size of the security token that STS APIs return is not fixed. + // Note: The size of the security token that STS APIs return is not fixed. // We strongly recommend that you make no assumptions about the maximum size. // As of this writing, the typical size is less than 4096 bytes, but that can // vary. Also, future updates to AWS might require larger sizes. diff --git a/vendor/github.com/aws/aws-sdk-go/service/sts/service.go b/vendor/github.com/aws/aws-sdk-go/service/sts/service.go index 41de708c7c..fbe3cff33a 100644 --- a/vendor/github.com/aws/aws-sdk-go/service/sts/service.go +++ b/vendor/github.com/aws/aws-sdk-go/service/sts/service.go @@ -17,24 +17,25 @@ import ( // This guide provides descriptions of the STS API. For more detailed information // about using this service, go to Temporary Security Credentials (http://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html). // -// As an alternative to using the API, you can use one of the AWS SDKs, which +// As an alternative to using the API, you can use one of the AWS SDKs, which // consist of libraries and sample code for various programming languages and // platforms (Java, Ruby, .NET, iOS, Android, etc.). The SDKs provide a convenient // way to create programmatic access to STS. For example, the SDKs take care // 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 // diff --git a/vendor/github.com/cloudfoundry-incubator/candiedyaml/README.md b/vendor/github.com/cloudfoundry-incubator/candiedyaml/README.md index 266c28c79b..94077994b7 100644 --- a/vendor/github.com/cloudfoundry-incubator/candiedyaml/README.md +++ b/vendor/github.com/cloudfoundry-incubator/candiedyaml/README.md @@ -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 =========== diff --git a/vendor/github.com/gocql/gocql/.travis.yml b/vendor/github.com/gocql/gocql/.travis.yml index 21c4dd4322..d3fd95d3f8 100644 --- a/vendor/github.com/gocql/gocql/.travis.yml +++ b/vendor/github.com/gocql/gocql/.travis.yml @@ -1,6 +1,7 @@ language: go -sudo: false +sudo: required +dist: trusty cache: directories: diff --git a/vendor/github.com/gocql/gocql/AUTHORS b/vendor/github.com/gocql/gocql/AUTHORS index 6a194cf1e6..b578ca4f74 100644 --- a/vendor/github.com/gocql/gocql/AUTHORS +++ b/vendor/github.com/gocql/gocql/AUTHORS @@ -67,3 +67,4 @@ nikandfor Anthony Woods Alexander Inozemtsev Rob McColl ; +Viktor Tönköl diff --git a/vendor/github.com/gocql/gocql/cluster.go b/vendor/github.com/gocql/gocql/cluster.go index d311f3d40f..c84f376cd4 100644 --- a/vendor/github.com/gocql/gocql/cluster.go +++ b/vendor/github.com/gocql/gocql/cluster.go @@ -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 } diff --git a/vendor/github.com/gocql/gocql/conn.go b/vendor/github.com/gocql/gocql/conn.go index deb76cfd0d..4c6030d402 100644 --- a/vendor/github.com/gocql/gocql/conn.go +++ b/vendor/github.com/gocql/gocql/conn.go @@ -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 } diff --git a/vendor/github.com/gocql/gocql/control.go b/vendor/github.com/gocql/gocql/control.go index e18fc72bfa..8178cf1018 100644 --- a/vendor/github.com/gocql/gocql/control.go +++ b/vendor/github.com/gocql/gocql/control.go @@ -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 { diff --git a/vendor/github.com/gocql/gocql/errors.go b/vendor/github.com/gocql/gocql/errors.go index cd7124e8fa..b87c6fac0b 100644 --- a/vendor/github.com/gocql/gocql/errors.go +++ b/vendor/github.com/gocql/gocql/errors.go @@ -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 diff --git a/vendor/github.com/gocql/gocql/events.go b/vendor/github.com/gocql/gocql/events.go index aa4e975816..8d8a67f441 100644 --- a/vendor/github.com/gocql/gocql/events.go +++ b/vendor/github.com/gocql/gocql/events.go @@ -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 { diff --git a/vendor/github.com/gocql/gocql/frame.go b/vendor/github.com/gocql/gocql/frame.go index 8ff10a97c1..49f0478a4b 100644 --- a/vendor/github.com/gocql/gocql/frame.go +++ b/vendor/github.com/gocql/gocql/frame.go @@ -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)) } } diff --git a/vendor/github.com/gocql/gocql/metadata.go b/vendor/github.com/gocql/gocql/metadata.go index f4b2264a5c..1c85881c2f 100644 --- a/vendor/github.com/gocql/gocql/metadata.go +++ b/vendor/github.com/gocql/gocql/metadata.go @@ -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 { diff --git a/vendor/github.com/gocql/gocql/session.go b/vendor/github.com/gocql/gocql/session.go index a8621881c3..df249e317d 100644 --- a/vendor/github.com/gocql/gocql/session.go +++ b/vendor/github.com/gocql/gocql/session.go @@ -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. diff --git a/vendor/github.com/golang/snappy/README b/vendor/github.com/golang/snappy/README index 5074bbab8d..6b138265c2 100644 --- a/vendor/github.com/golang/snappy/README +++ b/vendor/github.com/golang/snappy/README @@ -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 %) diff --git a/vendor/github.com/golang/snappy/encode_amd64.s b/vendor/github.com/golang/snappy/encode_amd64.s index 0c2a41d73b..adfd979fe2 100644 --- a/vendor/github.com/golang/snappy/encode_amd64.s +++ b/vendor/github.com/golang/snappy/encode_amd64.s @@ -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 diff --git a/vendor/github.com/lib/pq/user_posix.go b/vendor/github.com/lib/pq/user_posix.go index e937d7d087..bf982524f9 100644 --- a/vendor/github.com/lib/pq/user_posix.go +++ b/vendor/github.com/lib/pq/user_posix.go @@ -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 diff --git a/vendor/golang.org/x/crypto/ssh/handshake.go b/vendor/golang.org/x/crypto/ssh/handshake.go index 08abd66a92..8854274f04 100644 --- a/vendor/golang.org/x/crypto/ssh/handshake.go +++ b/vendor/golang.org/x/crypto/ssh/handshake.go @@ -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 { diff --git a/vendor/golang.org/x/net/context/context.go b/vendor/golang.org/x/net/context/context.go index 56efb95b91..ea1a7cd53a 100644 --- a/vendor/golang.org/x/net/context/context.go +++ b/vendor/golang.org/x/net/context/context.go @@ -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 { diff --git a/vendor/golang.org/x/sys/unix/sockcmsg_unix.go b/vendor/golang.org/x/sys/unix/sockcmsg_unix.go index 70af5a728e..f1493a3e6f 100644 --- a/vendor/golang.org/x/sys/unix/sockcmsg_unix.go +++ b/vendor/golang.org/x/sys/unix/sockcmsg_unix.go @@ -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 diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go b/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go index b156d5242a..acd2e1c789 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux_ppc64x.go @@ -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 +} diff --git a/vendor/golang.org/x/sys/unix/types_linux.go b/vendor/golang.org/x/sys/unix/types_linux.go index 974d28c38b..143e767a6c 100644 --- a/vendor/golang.org/x/sys/unix/types_linux.go +++ b/vendor/golang.org/x/sys/unix/types_linux.go @@ -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; diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go index 844ae592f8..4bd18dcee6 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64.go @@ -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 +} diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go index 0e86c9d9ed..fbb43516cc 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_ppc64le.go @@ -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 +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go index 66d99ea7bc..d1105402ec 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go @@ -589,9 +589,10 @@ type Ustat_t struct { } type EpollEvent struct { - Events uint32 - Fd int32 - Pad int32 + Events uint32 + X_padFd int32 + Fd int32 + Pad int32 } const ( diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go index f7c845133b..8e25c9fffc 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go @@ -589,9 +589,10 @@ type Ustat_t struct { } type EpollEvent struct { - Events uint32 - Fd int32 - Pad int32 + Events uint32 + X_padFd int32 + Fd int32 + Pad int32 } const (