From 1172f6bc1225e45c963110b7eba59dccbfd8a9d7 Mon Sep 17 00:00:00 2001 From: Dieter Plaetinck Date: Wed, 8 Feb 2017 17:51:05 +0100 Subject: [PATCH 1/7] add KafkaMdm route also : split off some common stuff in reusable fashion --- docs/grafana-net.md | 2 +- imperatives/imperatives.go | 124 ++++++++++++++++++- route/grafananet.go | 63 +--------- route/kafkamdm.go | 240 +++++++++++++++++++++++++++++++++++++ route/schemas.go | 78 ++++++++++++ 5 files changed, 446 insertions(+), 61 deletions(-) create mode 100644 route/kafkamdm.go create mode 100644 route/schemas.go diff --git a/docs/grafana-net.md b/docs/grafana-net.md index f534faec..279d84a8 100644 --- a/docs/grafana-net.md +++ b/docs/grafana-net.md @@ -18,7 +18,7 @@ notes: * by specifying a prefix, sub or regex you can only send a subset of your metrics to grafana.net hosted metrics ``` -addRoute GrafanaNet key [prefix/sub/regex] addr apiKey schemasFile [spool=true/false sslverify=true/false bufSize=int flushMaxNum=int flushMaxWait=int timeout=int]") +addRoute grafanaNet key [prefix/sub/regex] addr apiKey schemasFile [spool=true/false sslverify=true/false bufSize=int flushMaxNum=int flushMaxWait=int timeout=int]") ``` diff --git a/imperatives/imperatives.go b/imperatives/imperatives.go index d6ad98e6..64e9a81d 100644 --- a/imperatives/imperatives.go +++ b/imperatives/imperatives.go @@ -23,6 +23,7 @@ const ( addRouteSendFirstMatch addRouteConsistentHashing addRouteGrafanaNet + addRouteKafkaMdm addDest addRewriter delRoute @@ -63,6 +64,7 @@ var tokens = []toki.Def{ {Token: addRouteSendFirstMatch, Pattern: "addRoute sendFirstMatch"}, {Token: addRouteConsistentHashing, Pattern: "addRoute consistentHashing"}, {Token: addRouteGrafanaNet, Pattern: "addRoute grafanaNet"}, + {Token: addRouteKafkaMdm, Pattern: "addRoute kafkaMdm"}, {Token: addDest, Pattern: "addDest"}, {Token: addRewriter, Pattern: "addRewriter"}, {Token: delRoute, Pattern: "delRoute"}, @@ -98,7 +100,8 @@ var tokens = []toki.Def{ var errFmtAddBlack = errors.New("addBlack ") var errFmtAddAgg = errors.New("addAgg ") var errFmtAddRoute = errors.New("addRoute [prefix/sub/regex=,..] [[...]] where is [prefix/sub,regex,flush,reconn,pickle,spool=...]") // note flush and reconn are ints, pickle and spool are true/false. other options are strings -var errFmtAddRouteGrafanaNet = errors.New("addRoute GrafanaNet key [prefix/sub/regex] addr apiKey schemasFile [spool=true/false sslverify=true/false bufSize=int flushMaxNum=int flushMaxWait=int timeout=int concurrency=int orgId=int]") +var errFmtAddRouteGrafanaNet = errors.New("addRoute grafanaNet key [prefix/sub/regex] addr apiKey schemasFile [spool=true/false sslverify=true/false bufSize=int flushMaxNum=int flushMaxWait=int timeout=int concurrency=int orgId=int]") +var errFmtAddRouteKafkaMdm = errors.New("addRoute kafkaMdm key [prefix/sub/regex] broker topic codec schemasFile partitionBy orgId [bufSize=int flushMaxNum=int flushMaxWait=int timeout=int]") var errFmtAddDest = errors.New("addDest ") // not implemented yet var errFmtAddRewriter = errors.New("addRewriter ") var errFmtModDest = errors.New("modDest ") // one or more can be specified at once @@ -123,6 +126,8 @@ func Apply(table *tbl.Table, cmd string) error { return readAddRouteConsistentHashing(s, table) case addRouteGrafanaNet: return readAddRouteGrafanaNet(s, table) + case addRouteKafkaMdm: + return readAddRouteKafkaMdm(s, table) case addRewriter: return readAddRewriter(s, table) case delRoute: @@ -403,6 +408,123 @@ func readAddRouteGrafanaNet(s *toki.Scanner, table *tbl.Table) error { table.AddRoute(route) return nil } +func readAddRouteKafkaMdm(s *toki.Scanner, table *tbl.Table) error { + t := s.Next() + if t.Token != word { + return errFmtAddRouteKafkaMdm + } + key := string(t.Value) + + prefix, sub, regex, err := readRouteOpts(s) + if err != nil { + return err + } + + t = s.Next() + if t.Token != word { + return errFmtAddRouteKafkaMdm + } + broker := string(t.Value) + + t = s.Next() + if t.Token != word { + return errFmtAddRouteKafkaMdm + } + topic := string(t.Value) + + t = s.Next() + if t.Token != word { + return errFmtAddRouteKafkaMdm + } + codec := string(t.Value) + if codec != "none" && codec != "gzip" && codec != "snappy" { + return errFmtAddRouteKafkaMdm + } + + t = s.Next() + if t.Token != word { + return errFmtAddRouteKafkaMdm + } + schemasFile := string(t.Value) + + t = s.Next() + if t.Token != word { + return errFmtAddRouteKafkaMdm + } + partitionBy := string(t.Value) + if partitionBy != "byOrg" && partitionBy != "bySeries" { + return errFmtAddRouteKafkaMdm + } + + t = s.Next() + if t.Token != word { + return errFmtAddRouteKafkaMdm + } + orgId, err := strconv.Atoi(strings.TrimSpace(string(t.Value))) + if err != nil { + return errFmtAddRouteKafkaMdm + } + + var bufSize = int(1e7) // since a message is typically around 100B this is 1GB + var flushMaxNum = 10000 // number of metrics + var flushMaxWait = 500 // in ms + var timeout = 2000 // in ms + + t = s.Next() + for ; t.Token != toki.EOF; t = s.Next() { + switch t.Token { + case optBufSize: + t = s.Next() + if t.Token == num { + bufSize, err = strconv.Atoi(strings.TrimSpace(string(t.Value))) + if err != nil { + return err + } + } else { + return errFmtAddRouteKafkaMdm + } + case optFlushMaxNum: + t = s.Next() + if t.Token == num { + flushMaxNum, err = strconv.Atoi(strings.TrimSpace(string(t.Value))) + if err != nil { + return err + } + } else { + return errFmtAddRouteKafkaMdm + } + case optFlushMaxWait: + t = s.Next() + if t.Token == num { + flushMaxWait, err = strconv.Atoi(strings.TrimSpace(string(t.Value))) + if err != nil { + return err + } + } else { + return errFmtAddRouteKafkaMdm + } + case optTimeout: + t = s.Next() + if t.Token == num { + timeout, err = strconv.Atoi(strings.TrimSpace(string(t.Value))) + if err != nil { + return err + } + } else { + return errFmtAddRouteKafkaMdm + } + default: + return fmt.Errorf("unexpected token %d %q", t.Token, t.Value) + } + } + + route, err := route.NewKafkaMdm(key, prefix, sub, regex, broker, topic, codec, schemasFile, partitionBy, bufSize, orgId, flushMaxNum, flushMaxWait, timeout) + if err != nil { + return err + } + table.AddRoute(route) + return nil +} func readAddRewriter(s *toki.Scanner, table *tbl.Table) error { var t *toki.Result diff --git a/route/grafananet.go b/route/grafananet.go index 3b91f3d7..6d92f9b3 100644 --- a/route/grafananet.go +++ b/route/grafananet.go @@ -3,12 +3,9 @@ package route import ( "bytes" "crypto/tls" - "fmt" "hash/fnv" "net" "net/http" - "strconv" - "strings" "sync" "sync/atomic" "time" @@ -62,24 +59,10 @@ func NewGrafanaNet(key, prefix, sub, regex, addr, apiKey, schemasFile string, sp if err != nil { return nil, err } - schemas, err := persister.ReadWhisperSchemas(schemasFile) + schemas, err := getSchemas(schemasFile) if err != nil { return nil, err } - var defaultFound bool - for _, schema := range schemas { - if schema.Pattern.String() == ".*" { - defaultFound = true - } - if len(schema.Retentions) == 0 { - return nil, fmt.Errorf("retention setting cannot be empty") - } - } - if !defaultFound { - // good graphite health (not sure what graphite does if there's no .* - // but we definitely need to always be able to determine which interval to use - return nil, fmt.Errorf("storage-conf does not have a default '.*' pattern") - } cleanAddr := util.AddrToPath(addr) @@ -170,8 +153,9 @@ func (route *GrafanaNet) run() { select { case buf := <-route.buf: route.numBuffered.Dec(1) - md := parseMetric(buf, route.schemas, route.orgId) - if md == nil { + md, err := parseMetric(buf, route.schemas, route.orgId) + if err != nil { + log.Error("RouteGrafanaNet: %s", err) continue } md.SetId() @@ -249,45 +233,6 @@ func (route *GrafanaNet) flush(shard int) { route.wg.Done() } -func parseMetric(buf []byte, schemas persister.WhisperSchemas, orgId int) *schema.MetricData { - msg := strings.TrimSpace(string(buf)) - - elements := strings.Fields(msg) - if len(elements) != 3 { - log.Error("RouteGrafanaNet: %q error: need 3 fields", msg) - return nil - } - name := elements[0] - val, err := strconv.ParseFloat(elements[1], 64) - if err != nil { - log.Error("RouteGrafanaNet: %q error: %s", msg, err.Error()) - return nil - } - timestamp, err := strconv.ParseUint(elements[2], 10, 32) - if err != nil { - log.Error("RouteGrafanaNet: %q error: %s", msg, err.Error()) - return nil - } - - s, ok := schemas.Match(name) - if !ok { - panic(fmt.Errorf("couldn't find a schema for %q - this is impossible since we asserted there was a default with patt .*", name)) - } - - md := schema.MetricData{ - Name: name, - Metric: name, - Interval: s.Retentions[0].SecondsPerPoint(), - Value: val, - Unit: "unknown", - Time: int64(timestamp), - Mtype: "gauge", - Tags: []string{}, - OrgId: orgId, // This may be overwritten by the TSDB-GW if it does not match the orgId of the apiKey used - } - return &md -} - func (route *GrafanaNet) Dispatch(buf []byte) { //conf := route.config.Load().(Config) // should return as quickly as possible diff --git a/route/kafkamdm.go b/route/kafkamdm.go new file mode 100644 index 00000000..37bfabd9 --- /dev/null +++ b/route/kafkamdm.go @@ -0,0 +1,240 @@ +package route + +import ( + "fmt" + "sync" + "sync/atomic" + "time" + + "github.com/Dieterbe/go-metrics" + dest "github.com/graphite-ng/carbon-relay-ng/destination" + "github.com/graphite-ng/carbon-relay-ng/matcher" + "github.com/graphite-ng/carbon-relay-ng/stats" + "github.com/graphite-ng/carbon-relay-ng/util" + + "github.com/Shopify/sarama" + "github.com/lomik/go-carbon/persister" + "github.com/raintank/metrictank/cluster" + "gopkg.in/raintank/schema.v1" +) + +type KafkaMdm struct { + baseRoute + saramaCfg *sarama.Config + producer sarama.SyncProducer + topic string + broker string + buf chan []byte + partitioner *cluster.KafkaPartitioner + schemas persister.WhisperSchemas + + orgId int // organisation to publish data under + + bufSize int // amount of messages we can buffer up before providing backpressure. each message is about 100B. so 1e7 is about 1GB. + flushMaxNum int + flushMaxWait time.Duration + + numErrFlush metrics.Counter + numOut metrics.Counter // metrics successfully written to kafka + durationTickFlush metrics.Timer // only updated after successful flush + durationManuFlush metrics.Timer // only updated after successful flush. not implemented yet + tickFlushSize metrics.Histogram // only updated after successful flush + manuFlushSize metrics.Histogram // only updated after successful flush. not implemented yet + numBuffered metrics.Gauge +} + +// NewKafkaMdm creates a special route that writes to a grafana.net datastore +// We will automatically run the route and the destination +func NewKafkaMdm(key, prefix, sub, regex, broker, topic, codec, schemasFile, partitionBy string, bufSize, orgId, flushMaxNum, flushMaxWait, timeout int) (Route, error) { + m, err := matcher.New(prefix, sub, regex) + if err != nil { + return nil, err + } + schemas, err := getSchemas(schemasFile) + if err != nil { + return nil, err + } + + cleanAddr := util.AddrToPath(broker) + + r := &KafkaMdm{ + baseRoute: baseRoute{sync.Mutex{}, atomic.Value{}, key}, + topic: topic, + broker: broker, + buf: make(chan []byte, bufSize), + schemas: schemas, + orgId: orgId, + + bufSize: bufSize, + flushMaxNum: flushMaxNum, + flushMaxWait: time.Duration(flushMaxWait) * time.Millisecond, + + numErrFlush: stats.Counter("dest=" + cleanAddr + ".unit=Err.type=flush"), + numOut: stats.Counter("dest=" + cleanAddr + ".unit=Metric.direction=out"), + durationTickFlush: stats.Timer("dest=" + cleanAddr + ".what=durationFlush.type=ticker"), + durationManuFlush: stats.Timer("dest=" + cleanAddr + ".what=durationFlush.type=manual"), + tickFlushSize: stats.Histogram("dest=" + cleanAddr + ".unit=B.what=FlushSize.type=ticker"), + manuFlushSize: stats.Histogram("dest=" + cleanAddr + ".unit=B.what=FlushSize.type=manual"), + numBuffered: stats.Gauge("dest=" + cleanAddr + ".unit=Metric.what=numBuffered"), + } + + r.partitioner, err = cluster.NewKafkaPartitioner(partitionBy) + if err != nil { + log.Fatal(4, "kafkaMdm %q: failed to initialize partitioner. %s", r.Key, err) + } + + // We are looking for strong consistency semantics. + // Because we don't change the flush settings, sarama will try to produce messages + // as fast as possible to keep latency low. + config := sarama.NewConfig() + config.Producer.RequiredAcks = sarama.WaitForAll // Wait for all in-sync replicas to ack the message + config.Producer.Retry.Max = 10 // Retry up to 10 times to produce the message + config.Producer.Compression, err = getCompression(codec) + if err != nil { + log.Fatal(5, "kafkaMdm %q: %s", r.key, err) + } + config.Producer.Return.Successes = true + config.Producer.Timeout = time.Duration(timeout) * time.Millisecond + err = config.Validate() + if err != nil { + log.Fatal(4, "kafkaMdm %q: failed to validate kafka config. %s", r.Key, err) + } + r.saramaCfg = config + + r.config.Store(baseConfig{*m, make([]*dest.Destination, 0)}) + go r.run() + return r, nil +} + +func (r *KafkaMdm) run() { + metrics := make([]*schema.MetricData, 0, r.flushMaxNum) + ticker := time.NewTicker(r.flushMaxWait) + brokers := []string{r.broker} + + connect := func() { + var err error + r.producer, err = sarama.NewSyncProducer(brokers, r.saramaCfg) + if err == sarama.ErrOutOfBrokers { + log.Warning("kafkaMdm %q: %s", r.key, err) + } else if err != nil { + log.Fatal(4, "kafkaMdm %q: failed to initialize kafka producer. %s", r.key, err) + } else { + log.Notice("kafkaMdm %q: now connected to kafka", r.key) + } + } + + // flushes the data to kafka and resets buffer. blocks until it succeeds + flush := func() { + for r.producer == nil { + connect() + time.Sleep(time.Second) + } + for { + pre := time.Now() + var err error + size := 0 + + payload := make([]*sarama.ProducerMessage, len(metrics)) + + for i, metric := range metrics { + var data []byte + data, err = metric.MarshalMsg(data[:]) + if err != nil { + panic(err) + } + size += len(data) + + key, err := r.partitioner.GetPartitionKey(metric, nil) + if err != nil { + panic(err) + } + payload[i] = &sarama.ProducerMessage{ + Key: sarama.ByteEncoder(key), + Topic: r.topic, + Value: sarama.ByteEncoder(data), + } + } + err = r.producer.SendMessages(payload) + + diff := time.Since(pre) + if err == nil { + log.Info("KafkaMdm %q: sent %d metrics in %s - msg size %d", r.key, len(metrics), diff, size) + r.numOut.Inc(int64(len(metrics))) + r.tickFlushSize.Update(int64(size)) + r.durationTickFlush.Update(diff) + metrics = metrics[:0] + break + } + r.numErrFlush.Inc(1) + log.Warning("KafkaMdm %q: failed to submit data: %s will try again in %s (this attempt took %s)", r.key, err, diff) + + time.Sleep(100 * time.Millisecond) + } + } + for { + select { + case buf, ok := <-r.buf: + if !ok { + if len(metrics) != 0 { + flush() + } + return + } + r.numBuffered.Dec(1) + md, err := parseMetric(buf, r.schemas, r.orgId) + if err != nil { + log.Error("KafkaMdm %q: %s", r.key, err) + continue + } + md.SetId() + metrics = append(metrics, md) + if len(metrics) == r.flushMaxNum { + flush() + } + case <-ticker.C: + if len(metrics) != 0 { + flush() + } else if r.producer == nil { + connect() + } + } + } +} + +func (r *KafkaMdm) Dispatch(buf []byte) { + log.Info("kafkaMdm %q: sending to dest %s: %s", r.key, r.broker, buf) + r.numBuffered.Inc(1) + // either write to buffer, or if it's full discard the data + select { + case r.buf <- buf: + default: + } +} + +func (r *KafkaMdm) Flush() error { + //conf := r.config.Load().(Config) + // no-op. Flush() is currently not called by anything. + return nil +} + +func (r *KafkaMdm) Shutdown() error { + //conf := r.config.Load().(Config) + close(r.buf) + return nil +} + +func (r *KafkaMdm) Snapshot() Snapshot { + return makeSnapshot(&r.baseRoute, "KafkaMdm") +} + +func getCompression(codec string) (sarama.CompressionCodec, error) { + switch codec { + case "none": + return sarama.CompressionNone, nil + case "gzip": + return sarama.CompressionGZIP, nil + case "snappy": + return sarama.CompressionSnappy, nil + } + return 0, fmt.Errorf("unknown compression codec %q", codec) +} diff --git a/route/schemas.go b/route/schemas.go new file mode 100644 index 00000000..b0067cd4 --- /dev/null +++ b/route/schemas.go @@ -0,0 +1,78 @@ +package route + +import ( + "fmt" + "strconv" + "strings" + + "github.com/lomik/go-carbon/persister" + "gopkg.in/raintank/schema.v1" +) + +func getSchemas(file string) (persister.WhisperSchemas, error) { + schemas, err := persister.ReadWhisperSchemas(file) + if err != nil { + return nil, err + } + var defaultFound bool + for _, schema := range schemas { + if schema.Pattern.String() == ".*" { + defaultFound = true + } + if len(schema.Retentions) == 0 { + return nil, fmt.Errorf("retention setting cannot be empty") + } + } + if !defaultFound { + // good graphite health (not sure what graphite does if there's no .* + // but we definitely need to always be able to determine which interval to use + return nil, fmt.Errorf("storage-conf does not have a default '.*' pattern") + } + return schemas, nil +} + +// parseMetric parses a buffer into a MetricData message, using the schemas to deduce the interval of the data. +// The given orgId will be applied to the MetricData, but note: +// * when sending to api endpoint for hosted metrics (grafanaNet route), tsdb-gw will adjust orgId based on the apiKey used for authentication. Unless it runs in admin mode. +// * kafka-mdm route doesn't authenticate and just uses whatever OrgId is specified +func parseMetric(buf []byte, schemas persister.WhisperSchemas, orgId int) (*schema.MetricData, error) { + errFmt3Fields := "%q: need 3 fields" + errFmt := "%q: %s" + + msg := strings.TrimSpace(string(buf)) + + elements := strings.Fields(msg) + if len(elements) != 3 { + return nil, fmt.Errorf(errFmt3Fields, msg) + } + + name := elements[0] + + val, err := strconv.ParseFloat(elements[1], 64) + if err != nil { + return nil, fmt.Errorf(errFmt, msg, err) + } + + timestamp, err := strconv.ParseUint(elements[2], 10, 32) + if err != nil { + return nil, fmt.Errorf(errFmt, msg, err) + } + + s, ok := schemas.Match(name) + if !ok { + panic(fmt.Errorf("couldn't find a schema for %q - this is impossible since we asserted there was a default with patt .*", name)) + } + + md := schema.MetricData{ + Name: name, + Metric: name, + Interval: s.Retentions[0].SecondsPerPoint(), + Value: val, + Unit: "unknown", + Time: int64(timestamp), + Mtype: "gauge", + Tags: []string{}, + OrgId: orgId, + } + return &md, nil +} From 249e66d9782d2fe79c99b68094061c28e702f9bb Mon Sep 17 00:00:00 2001 From: Dieter Plaetinck Date: Thu, 9 Feb 2017 13:19:58 +0100 Subject: [PATCH 2/7] aggregator support min/max --- README.md | 2 +- aggregator/aggregator.go | 28 ++++++++++++++++++++++++++++ imperatives/imperatives.go | 14 +++++++++----- 3 files changed, 38 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index fe8e6640..6c58aea6 100644 --- a/README.md +++ b/README.md @@ -184,7 +184,7 @@ Note: if you set the interval to the period between each incoming packet of a given key, and the fmt yields the same key for different input metric keys - aggregation of individual metrics, i.e. packets for the same key, with different timestamps. For example if you receive values for the same key every second, you can aggregate into minutely buckets by setting interval to 60, and have the fmt yield a unique key for every input metric key. (~ graphite rollups) - the combination: compute aggregates from values seen with different keys, and at multiple points in time. -* functions currently available: avg and sum +* functions currently available: avg, sum, min, max * aggregation output is routed via the routing table just like all other metrics. Note that aggregation output will never go back into aggregators (to prevent loops) and also bypasses the validation and blacklist. * see the included ini for examples diff --git a/aggregator/aggregator.go b/aggregator/aggregator.go index 957b7764..a2a092a8 100644 --- a/aggregator/aggregator.go +++ b/aggregator/aggregator.go @@ -25,9 +25,37 @@ func Avg(in []float64) float64 { return Sum(in) / float64(len(in)) } +func Max(in []float64) float64 { + if len(in) == 0 { + panic("max() called in aggregator with 0 terms") + } + max := in[0] + for _, val := range in { + if val > max { + max = val + } + } + return max +} + +func Min(in []float64) float64 { + if len(in) == 0 { + panic("min() called in aggregator with 0 terms") + } + min := in[0] + for _, val := range in { + if val < min { + min = val + } + } + return min +} + var Funcs = map[string]Func{ "sum": Sum, "avg": Avg, + "max": Max, + "min": Min, } type Aggregator struct { diff --git a/imperatives/imperatives.go b/imperatives/imperatives.go index 64e9a81d..1987a8b6 100644 --- a/imperatives/imperatives.go +++ b/imperatives/imperatives.go @@ -31,8 +31,10 @@ const ( modRoute str sep - sumFn avgFn + maxFn + minFn + sumFn num optPrefix optAddr @@ -89,8 +91,10 @@ var tokens = []toki.Def{ {Token: optOrgId, Pattern: "orgId="}, {Token: str, Pattern: "\".*\""}, {Token: sep, Pattern: "##"}, - {Token: sumFn, Pattern: "sum"}, {Token: avgFn, Pattern: "avg"}, + {Token: maxFn, Pattern: "max"}, + {Token: minFn, Pattern: "min"}, + {Token: sumFn, Pattern: "sum"}, {Token: num, Pattern: "[0-9]+( |$)"}, // unfortunately we need the 2nd piece cause otherwise it would match the first of ip addresses etc. this means we need to TrimSpace later {Token: word, Pattern: "[^ ]+"}, } @@ -98,7 +102,7 @@ var tokens = []toki.Def{ // note the two spaces between a route and endpoints // match options can't have spaces for now. sorry var errFmtAddBlack = errors.New("addBlack ") -var errFmtAddAgg = errors.New("addAgg ") +var errFmtAddAgg = errors.New("addAgg ") var errFmtAddRoute = errors.New("addRoute [prefix/sub/regex=,..] [[...]] where is [prefix/sub,regex,flush,reconn,pickle,spool=...]") // note flush and reconn are ints, pickle and spool are true/false. other options are strings var errFmtAddRouteGrafanaNet = errors.New("addRoute grafanaNet key [prefix/sub/regex] addr apiKey schemasFile [spool=true/false sslverify=true/false bufSize=int flushMaxNum=int flushMaxWait=int timeout=int concurrency=int orgId=int]") var errFmtAddRouteKafkaMdm = errors.New("addRoute kafkaMdm key [prefix/sub/regex] broker topic codec schemasFile partitionBy orgId [bufSize=int flushMaxNum=int flushMaxWait=int timeout=int]") @@ -143,8 +147,8 @@ func Apply(table *tbl.Table, cmd string) error { func readAddAgg(s *toki.Scanner, table *tbl.Table) error { t := s.Next() - if t.Token != sumFn && t.Token != avgFn { - return errors.New("invalid function. need sum/avg") + if t.Token != sumFn && t.Token != avgFn && t.Token != minFn && t.Token != maxFn { + return errors.New("invalid function. need avg/max/min/sum") } fun := string(t.Value) From 0aaae50246222a737d4bdae2356e4fdbf95dab35 Mon Sep 17 00:00:00 2001 From: Dieter Plaetinck Date: Sat, 11 Feb 2017 12:27:11 +0100 Subject: [PATCH 3/7] add logging for aggregator --- aggregator/aggregator.go | 1 + aggregator/init.go | 9 +++++++++ cmd/carbon-relay-ng/carbon-relay-ng.go | 2 ++ 3 files changed, 12 insertions(+) create mode 100644 aggregator/init.go diff --git a/aggregator/aggregator.go b/aggregator/aggregator.go index a2a092a8..7a345337 100644 --- a/aggregator/aggregator.go +++ b/aggregator/aggregator.go @@ -160,6 +160,7 @@ func (a *Aggregator) Flush(ts uint) { if agg.ts < ts { result := a.fn(agg.values) metric := fmt.Sprintf("%s %f %d", string(agg.key), result, agg.ts) + log.Debug("aggregator emitting %q", metric) a.out <- []byte(metric) } else { aggregations2 = append(aggregations2, agg) diff --git a/aggregator/init.go b/aggregator/init.go new file mode 100644 index 00000000..05c23f78 --- /dev/null +++ b/aggregator/init.go @@ -0,0 +1,9 @@ +package aggregator + +import logging "github.com/op/go-logging" + +var log = logging.MustGetLogger("aggregator") // for tests. overridden by main + +func SetLogger(l *logging.Logger) { + log = l +} diff --git a/cmd/carbon-relay-ng/carbon-relay-ng.go b/cmd/carbon-relay-ng/carbon-relay-ng.go index ea7445eb..b6a81344 100644 --- a/cmd/carbon-relay-ng/carbon-relay-ng.go +++ b/cmd/carbon-relay-ng/carbon-relay-ng.go @@ -14,6 +14,7 @@ import ( "github.com/BurntSushi/toml" "github.com/Dieterbe/go-metrics" + "github.com/graphite-ng/carbon-relay-ng/aggregator" "github.com/graphite-ng/carbon-relay-ng/badmetrics" "github.com/graphite-ng/carbon-relay-ng/cfg" "github.com/graphite-ng/carbon-relay-ng/destination" @@ -57,6 +58,7 @@ func init() { destination.SetLogger(log) telnet.SetLogger(log) web.SetLogger(log) + aggregator.SetLogger(log) } func usage() { From b66e99418ff53d46bd15565da4cd3a203cbdda54 Mon Sep 17 00:00:00 2001 From: Dieter Plaetinck Date: Sat, 11 Feb 2017 12:39:59 +0100 Subject: [PATCH 4/7] govendor add dependencies * latest sarama, looks stable * MT cluster partitioner just after 0.7 see https://github.com/raintank/metrictank/pull/526 and the dependencies of sarama itself: * github.com/eapache/go-resiliency/breaker * github.com/davecgh/go-spew/spew * github.com/rcrowley/go-metrics * github.com/klauspost/crc32 * github.com/eapache/queue * github.com/pierrec/lz4 (which pulls in github.com/pierrec/xxHash/xxHash32 ) * github.com/eapache/go-xerial-snappy (which pulls in github.com/golang/snappy) --- route/kafkamdm.go | 6 +- vendor/github.com/Shopify/sarama/CHANGELOG.md | 355 +++++++ vendor/github.com/Shopify/sarama/LICENSE | 20 + vendor/github.com/Shopify/sarama/Makefile | 21 + vendor/github.com/Shopify/sarama/README.md | 36 + vendor/github.com/Shopify/sarama/Vagrantfile | 20 + .../Shopify/sarama/api_versions_request.go | 24 + .../Shopify/sarama/api_versions_response.go | 87 ++ .../Shopify/sarama/async_producer.go | 905 ++++++++++++++++++ vendor/github.com/Shopify/sarama/broker.go | 674 +++++++++++++ vendor/github.com/Shopify/sarama/client.go | 749 +++++++++++++++ vendor/github.com/Shopify/sarama/config.go | 417 ++++++++ vendor/github.com/Shopify/sarama/consumer.go | 735 ++++++++++++++ .../Shopify/sarama/consumer_group_members.go | 94 ++ .../sarama/consumer_metadata_request.go | 26 + .../sarama/consumer_metadata_response.go | 85 ++ .../github.com/Shopify/sarama/crc32_field.go | 36 + .../Shopify/sarama/describe_groups_request.go | 30 + .../sarama/describe_groups_response.go | 187 ++++ vendor/github.com/Shopify/sarama/dev.yml | 13 + .../Shopify/sarama/encoder_decoder.go | 89 ++ vendor/github.com/Shopify/sarama/errors.go | 197 ++++ .../Shopify/sarama/fetch_request.go | 136 +++ .../Shopify/sarama/fetch_response.go | 210 ++++ .../Shopify/sarama/heartbeat_request.go | 47 + .../Shopify/sarama/heartbeat_response.go | 32 + .../Shopify/sarama/join_group_request.go | 108 +++ .../Shopify/sarama/join_group_response.go | 115 +++ .../Shopify/sarama/leave_group_request.go | 40 + .../Shopify/sarama/leave_group_response.go | 32 + .../github.com/Shopify/sarama/length_field.go | 29 + .../Shopify/sarama/list_groups_request.go | 24 + .../Shopify/sarama/list_groups_response.go | 69 ++ vendor/github.com/Shopify/sarama/message.go | 196 ++++ .../github.com/Shopify/sarama/message_set.go | 89 ++ .../Shopify/sarama/metadata_request.go | 52 + .../Shopify/sarama/metadata_response.go | 239 +++++ vendor/github.com/Shopify/sarama/metrics.go | 51 + .../github.com/Shopify/sarama/mockbroker.go | 324 +++++++ .../Shopify/sarama/mockresponses.go | 455 +++++++++ .../Shopify/sarama/offset_commit_request.go | 190 ++++ .../Shopify/sarama/offset_commit_response.go | 85 ++ .../Shopify/sarama/offset_fetch_request.go | 81 ++ .../Shopify/sarama/offset_fetch_response.go | 143 +++ .../Shopify/sarama/offset_manager.go | 542 +++++++++++ .../Shopify/sarama/offset_request.go | 132 +++ .../Shopify/sarama/offset_response.go | 174 ++++ .../Shopify/sarama/packet_decoder.go | 45 + .../Shopify/sarama/packet_encoder.go | 50 + .../github.com/Shopify/sarama/partitioner.go | 123 +++ .../github.com/Shopify/sarama/prep_encoder.go | 121 +++ .../Shopify/sarama/produce_request.go | 209 ++++ .../Shopify/sarama/produce_response.go | 159 +++ .../github.com/Shopify/sarama/produce_set.go | 176 ++++ .../github.com/Shopify/sarama/real_decoder.go | 260 +++++ .../github.com/Shopify/sarama/real_encoder.go | 129 +++ vendor/github.com/Shopify/sarama/request.go | 119 +++ .../Shopify/sarama/response_header.go | 21 + vendor/github.com/Shopify/sarama/sarama.go | 99 ++ .../Shopify/sarama/sasl_handshake_request.go | 33 + .../Shopify/sarama/sasl_handshake_response.go | 38 + .../Shopify/sarama/sync_group_request.go | 100 ++ .../Shopify/sarama/sync_group_response.go | 41 + .../Shopify/sarama/sync_producer.go | 164 ++++ vendor/github.com/Shopify/sarama/utils.go | 152 +++ vendor/github.com/davecgh/go-spew/LICENSE | 13 + .../github.com/davecgh/go-spew/spew/bypass.go | 136 +++ .../davecgh/go-spew/spew/bypasssafe.go | 37 + .../github.com/davecgh/go-spew/spew/common.go | 341 +++++++ .../github.com/davecgh/go-spew/spew/config.go | 297 ++++++ vendor/github.com/davecgh/go-spew/spew/doc.go | 202 ++++ .../github.com/davecgh/go-spew/spew/dump.go | 511 ++++++++++ .../github.com/davecgh/go-spew/spew/format.go | 419 ++++++++ .../github.com/davecgh/go-spew/spew/spew.go | 148 +++ .../github.com/eapache/go-resiliency/LICENSE | 22 + .../eapache/go-resiliency/breaker/README.md | 34 + .../eapache/go-resiliency/breaker/breaker.go | 161 ++++ .../eapache/go-xerial-snappy/LICENSE | 21 + .../eapache/go-xerial-snappy/README.md | 13 + .../eapache/go-xerial-snappy/snappy.go | 43 + vendor/github.com/eapache/queue/LICENSE | 21 + vendor/github.com/eapache/queue/README.md | 16 + vendor/github.com/eapache/queue/queue.go | 88 ++ .../github.com/golang/snappy/encode_amd64.go | 2 +- vendor/github.com/klauspost/crc32/LICENSE | 28 + vendor/github.com/klauspost/crc32/README.md | 84 ++ vendor/github.com/klauspost/crc32/crc32.go | 182 ++++ .../github.com/klauspost/crc32/crc32_amd64.go | 62 ++ .../github.com/klauspost/crc32/crc32_amd64.s | 237 +++++ .../klauspost/crc32/crc32_amd64p32.go | 39 + .../klauspost/crc32/crc32_amd64p32.s | 67 ++ .../klauspost/crc32/crc32_generic.go | 28 + vendor/github.com/pierrec/lz4/LICENSE | 28 + vendor/github.com/pierrec/lz4/README.md | 31 + vendor/github.com/pierrec/lz4/block.go | 474 +++++++++ vendor/github.com/pierrec/lz4/lz4.go | 118 +++ vendor/github.com/pierrec/lz4/reader.go | 364 +++++++ vendor/github.com/pierrec/lz4/writer.go | 383 ++++++++ vendor/github.com/pierrec/xxHash/LICENSE | 28 + .../pierrec/xxHash/xxHash32/xxHash32.go | 205 ++++ vendor/github.com/raintank/metrictank/LICENSE | 661 +++++++++++++ vendor/github.com/raintank/metrictank/NOTICE | 15 + .../cluster/partitioner/partitioner.go | 52 + vendor/github.com/rcrowley/go-metrics/LICENSE | 29 + .../github.com/rcrowley/go-metrics/README.md | 117 +++ .../github.com/rcrowley/go-metrics/counter.go | 112 +++ .../github.com/rcrowley/go-metrics/debug.go | 76 ++ vendor/github.com/rcrowley/go-metrics/ewma.go | 118 +++ .../github.com/rcrowley/go-metrics/gauge.go | 84 ++ .../rcrowley/go-metrics/gauge_float64.go | 91 ++ .../rcrowley/go-metrics/go-metrics.test | Bin 0 -> 4296056 bytes .../rcrowley/go-metrics/graphite.go | 111 +++ .../rcrowley/go-metrics/healthcheck.go | 61 ++ .../rcrowley/go-metrics/histogram.go | 202 ++++ vendor/github.com/rcrowley/go-metrics/json.go | 83 ++ vendor/github.com/rcrowley/go-metrics/log.go | 70 ++ .../github.com/rcrowley/go-metrics/memory.md | 285 ++++++ .../github.com/rcrowley/go-metrics/meter.go | 233 +++++ .../github.com/rcrowley/go-metrics/metrics.go | 13 + .../rcrowley/go-metrics/opentsdb.go | 119 +++ .../rcrowley/go-metrics/registry.go | 180 ++++ .../github.com/rcrowley/go-metrics/runtime.go | 200 ++++ .../rcrowley/go-metrics/runtime_cgo.go | 10 + .../rcrowley/go-metrics/runtime_no_cgo.go | 7 + .../github.com/rcrowley/go-metrics/sample.go | 602 ++++++++++++ .../github.com/rcrowley/go-metrics/syslog.go | 78 ++ .../github.com/rcrowley/go-metrics/timer.go | 311 ++++++ .../github.com/rcrowley/go-metrics/writer.go | 100 ++ vendor/vendor.json | 66 +- 129 files changed, 19402 insertions(+), 7 deletions(-) create mode 100644 vendor/github.com/Shopify/sarama/CHANGELOG.md create mode 100644 vendor/github.com/Shopify/sarama/LICENSE create mode 100644 vendor/github.com/Shopify/sarama/Makefile create mode 100644 vendor/github.com/Shopify/sarama/README.md create mode 100644 vendor/github.com/Shopify/sarama/Vagrantfile create mode 100644 vendor/github.com/Shopify/sarama/api_versions_request.go create mode 100644 vendor/github.com/Shopify/sarama/api_versions_response.go create mode 100644 vendor/github.com/Shopify/sarama/async_producer.go create mode 100644 vendor/github.com/Shopify/sarama/broker.go create mode 100644 vendor/github.com/Shopify/sarama/client.go create mode 100644 vendor/github.com/Shopify/sarama/config.go create mode 100644 vendor/github.com/Shopify/sarama/consumer.go create mode 100644 vendor/github.com/Shopify/sarama/consumer_group_members.go create mode 100644 vendor/github.com/Shopify/sarama/consumer_metadata_request.go create mode 100644 vendor/github.com/Shopify/sarama/consumer_metadata_response.go create mode 100644 vendor/github.com/Shopify/sarama/crc32_field.go create mode 100644 vendor/github.com/Shopify/sarama/describe_groups_request.go create mode 100644 vendor/github.com/Shopify/sarama/describe_groups_response.go create mode 100644 vendor/github.com/Shopify/sarama/dev.yml create mode 100644 vendor/github.com/Shopify/sarama/encoder_decoder.go create mode 100644 vendor/github.com/Shopify/sarama/errors.go create mode 100644 vendor/github.com/Shopify/sarama/fetch_request.go create mode 100644 vendor/github.com/Shopify/sarama/fetch_response.go create mode 100644 vendor/github.com/Shopify/sarama/heartbeat_request.go create mode 100644 vendor/github.com/Shopify/sarama/heartbeat_response.go create mode 100644 vendor/github.com/Shopify/sarama/join_group_request.go create mode 100644 vendor/github.com/Shopify/sarama/join_group_response.go create mode 100644 vendor/github.com/Shopify/sarama/leave_group_request.go create mode 100644 vendor/github.com/Shopify/sarama/leave_group_response.go create mode 100644 vendor/github.com/Shopify/sarama/length_field.go create mode 100644 vendor/github.com/Shopify/sarama/list_groups_request.go create mode 100644 vendor/github.com/Shopify/sarama/list_groups_response.go create mode 100644 vendor/github.com/Shopify/sarama/message.go create mode 100644 vendor/github.com/Shopify/sarama/message_set.go create mode 100644 vendor/github.com/Shopify/sarama/metadata_request.go create mode 100644 vendor/github.com/Shopify/sarama/metadata_response.go create mode 100644 vendor/github.com/Shopify/sarama/metrics.go create mode 100644 vendor/github.com/Shopify/sarama/mockbroker.go create mode 100644 vendor/github.com/Shopify/sarama/mockresponses.go create mode 100644 vendor/github.com/Shopify/sarama/offset_commit_request.go create mode 100644 vendor/github.com/Shopify/sarama/offset_commit_response.go create mode 100644 vendor/github.com/Shopify/sarama/offset_fetch_request.go create mode 100644 vendor/github.com/Shopify/sarama/offset_fetch_response.go create mode 100644 vendor/github.com/Shopify/sarama/offset_manager.go create mode 100644 vendor/github.com/Shopify/sarama/offset_request.go create mode 100644 vendor/github.com/Shopify/sarama/offset_response.go create mode 100644 vendor/github.com/Shopify/sarama/packet_decoder.go create mode 100644 vendor/github.com/Shopify/sarama/packet_encoder.go create mode 100644 vendor/github.com/Shopify/sarama/partitioner.go create mode 100644 vendor/github.com/Shopify/sarama/prep_encoder.go create mode 100644 vendor/github.com/Shopify/sarama/produce_request.go create mode 100644 vendor/github.com/Shopify/sarama/produce_response.go create mode 100644 vendor/github.com/Shopify/sarama/produce_set.go create mode 100644 vendor/github.com/Shopify/sarama/real_decoder.go create mode 100644 vendor/github.com/Shopify/sarama/real_encoder.go create mode 100644 vendor/github.com/Shopify/sarama/request.go create mode 100644 vendor/github.com/Shopify/sarama/response_header.go create mode 100644 vendor/github.com/Shopify/sarama/sarama.go create mode 100644 vendor/github.com/Shopify/sarama/sasl_handshake_request.go create mode 100644 vendor/github.com/Shopify/sarama/sasl_handshake_response.go create mode 100644 vendor/github.com/Shopify/sarama/sync_group_request.go create mode 100644 vendor/github.com/Shopify/sarama/sync_group_response.go create mode 100644 vendor/github.com/Shopify/sarama/sync_producer.go create mode 100644 vendor/github.com/Shopify/sarama/utils.go create mode 100644 vendor/github.com/davecgh/go-spew/LICENSE create mode 100644 vendor/github.com/davecgh/go-spew/spew/bypass.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/bypasssafe.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/common.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/config.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/doc.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/dump.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/format.go create mode 100644 vendor/github.com/davecgh/go-spew/spew/spew.go create mode 100644 vendor/github.com/eapache/go-resiliency/LICENSE create mode 100644 vendor/github.com/eapache/go-resiliency/breaker/README.md create mode 100644 vendor/github.com/eapache/go-resiliency/breaker/breaker.go create mode 100644 vendor/github.com/eapache/go-xerial-snappy/LICENSE create mode 100644 vendor/github.com/eapache/go-xerial-snappy/README.md create mode 100644 vendor/github.com/eapache/go-xerial-snappy/snappy.go create mode 100644 vendor/github.com/eapache/queue/LICENSE create mode 100644 vendor/github.com/eapache/queue/README.md create mode 100644 vendor/github.com/eapache/queue/queue.go create mode 100644 vendor/github.com/klauspost/crc32/LICENSE create mode 100644 vendor/github.com/klauspost/crc32/README.md create mode 100644 vendor/github.com/klauspost/crc32/crc32.go create mode 100644 vendor/github.com/klauspost/crc32/crc32_amd64.go create mode 100644 vendor/github.com/klauspost/crc32/crc32_amd64.s create mode 100644 vendor/github.com/klauspost/crc32/crc32_amd64p32.go create mode 100644 vendor/github.com/klauspost/crc32/crc32_amd64p32.s create mode 100644 vendor/github.com/klauspost/crc32/crc32_generic.go create mode 100644 vendor/github.com/pierrec/lz4/LICENSE create mode 100644 vendor/github.com/pierrec/lz4/README.md create mode 100644 vendor/github.com/pierrec/lz4/block.go create mode 100644 vendor/github.com/pierrec/lz4/lz4.go create mode 100644 vendor/github.com/pierrec/lz4/reader.go create mode 100644 vendor/github.com/pierrec/lz4/writer.go create mode 100644 vendor/github.com/pierrec/xxHash/LICENSE create mode 100644 vendor/github.com/pierrec/xxHash/xxHash32/xxHash32.go create mode 100644 vendor/github.com/raintank/metrictank/LICENSE create mode 100644 vendor/github.com/raintank/metrictank/NOTICE create mode 100644 vendor/github.com/raintank/metrictank/cluster/partitioner/partitioner.go create mode 100644 vendor/github.com/rcrowley/go-metrics/LICENSE create mode 100644 vendor/github.com/rcrowley/go-metrics/README.md create mode 100644 vendor/github.com/rcrowley/go-metrics/counter.go create mode 100644 vendor/github.com/rcrowley/go-metrics/debug.go create mode 100644 vendor/github.com/rcrowley/go-metrics/ewma.go create mode 100644 vendor/github.com/rcrowley/go-metrics/gauge.go create mode 100644 vendor/github.com/rcrowley/go-metrics/gauge_float64.go create mode 100755 vendor/github.com/rcrowley/go-metrics/go-metrics.test create mode 100644 vendor/github.com/rcrowley/go-metrics/graphite.go create mode 100644 vendor/github.com/rcrowley/go-metrics/healthcheck.go create mode 100644 vendor/github.com/rcrowley/go-metrics/histogram.go create mode 100644 vendor/github.com/rcrowley/go-metrics/json.go create mode 100644 vendor/github.com/rcrowley/go-metrics/log.go create mode 100644 vendor/github.com/rcrowley/go-metrics/memory.md create mode 100644 vendor/github.com/rcrowley/go-metrics/meter.go create mode 100644 vendor/github.com/rcrowley/go-metrics/metrics.go create mode 100644 vendor/github.com/rcrowley/go-metrics/opentsdb.go create mode 100644 vendor/github.com/rcrowley/go-metrics/registry.go create mode 100644 vendor/github.com/rcrowley/go-metrics/runtime.go create mode 100644 vendor/github.com/rcrowley/go-metrics/runtime_cgo.go create mode 100644 vendor/github.com/rcrowley/go-metrics/runtime_no_cgo.go create mode 100644 vendor/github.com/rcrowley/go-metrics/sample.go create mode 100644 vendor/github.com/rcrowley/go-metrics/syslog.go create mode 100644 vendor/github.com/rcrowley/go-metrics/timer.go create mode 100644 vendor/github.com/rcrowley/go-metrics/writer.go diff --git a/route/kafkamdm.go b/route/kafkamdm.go index 37bfabd9..f0de0f6f 100644 --- a/route/kafkamdm.go +++ b/route/kafkamdm.go @@ -14,7 +14,7 @@ import ( "github.com/Shopify/sarama" "github.com/lomik/go-carbon/persister" - "github.com/raintank/metrictank/cluster" + "github.com/raintank/metrictank/cluster/partitioner" "gopkg.in/raintank/schema.v1" ) @@ -25,7 +25,7 @@ type KafkaMdm struct { topic string broker string buf chan []byte - partitioner *cluster.KafkaPartitioner + partitioner *partitioner.Kafka schemas persister.WhisperSchemas orgId int // organisation to publish data under @@ -78,7 +78,7 @@ func NewKafkaMdm(key, prefix, sub, regex, broker, topic, codec, schemasFile, par numBuffered: stats.Gauge("dest=" + cleanAddr + ".unit=Metric.what=numBuffered"), } - r.partitioner, err = cluster.NewKafkaPartitioner(partitionBy) + r.partitioner, err = partitioner.NewKafka(partitionBy) if err != nil { log.Fatal(4, "kafkaMdm %q: failed to initialize partitioner. %s", r.Key, err) } diff --git a/vendor/github.com/Shopify/sarama/CHANGELOG.md b/vendor/github.com/Shopify/sarama/CHANGELOG.md new file mode 100644 index 00000000..5fb51203 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/CHANGELOG.md @@ -0,0 +1,355 @@ +# Changelog + +#### Version 1.11.0 (2016-12-20) + +_Important:_ As of Sarama 1.11 it is necessary to set the config value of +`Producer.Return.Successes` to true in order to use the SyncProducer. Previous +versions would silently override this value when instantiating a SyncProducer +which led to unexpected values and data races. + +New Features: + - Metrics! Thanks to Sébastien Launay for all his work on this feature + ([#701](https://github.com/Shopify/sarama/pull/701), + [#746](https://github.com/Shopify/sarama/pull/746), + [#766](https://github.com/Shopify/sarama/pull/766)). + - Add support for LZ4 compression + ([#786](https://github.com/Shopify/sarama/pull/786)). + - Add support for ListOffsetRequest v1 and Kafka 0.10.1 + ([#775](https://github.com/Shopify/sarama/pull/775)). + - Added a `HighWaterMarks` method to the Consumer which aggregates the + `HighWaterMarkOffset` values of its child topic/partitions + ([#769](https://github.com/Shopify/sarama/pull/769)). + +Bug Fixes: + - Fixed producing when using timestamps, compression and Kafka 0.10 + ([#759](https://github.com/Shopify/sarama/pull/759)). + - Added missing decoder methods to DescribeGroups response + ([#756](https://github.com/Shopify/sarama/pull/756)). + - Fix producer shutdown when `Return.Errors` is disabled + ([#787](https://github.com/Shopify/sarama/pull/787)). + - Don't mutate configuration in SyncProducer + ([#790](https://github.com/Shopify/sarama/pull/790)). + - Fix crash on SASL initialization failure + ([#795](https://github.com/Shopify/sarama/pull/795)). + +#### Version 1.10.1 (2016-08-30) + +Bug Fixes: + - Fix the documentation for `HashPartitioner` which was incorrect + ([#717](https://github.com/Shopify/sarama/pull/717)). + - Permit client creation even when it is limited by ACLs + ([#722](https://github.com/Shopify/sarama/pull/722)). + - Several fixes to the consumer timer optimization code, regressions introduced + in v1.10.0. Go's timers are finicky + ([#730](https://github.com/Shopify/sarama/pull/730), + [#733](https://github.com/Shopify/sarama/pull/733), + [#734](https://github.com/Shopify/sarama/pull/734)). + - Handle consuming compressed relative offsets with Kafka 0.10 + ([#735](https://github.com/Shopify/sarama/pull/735)). + +#### Version 1.10.0 (2016-08-02) + +_Important:_ As of Sarama 1.10 it is necessary to tell Sarama the version of +Kafka you are running against (via the `config.Version` value) in order to use +features that may not be compatible with old Kafka versions. If you don't +specify this value it will default to 0.8.2 (the minimum supported), and trying +to use more recent features (like the offset manager) will fail with an error. + +_Also:_ The offset-manager's behaviour has been changed to match the upstream +java consumer (see [#705](https://github.com/Shopify/sarama/pull/705) and +[#713](https://github.com/Shopify/sarama/pull/713)). If you use the +offset-manager, please ensure that you are committing one *greater* than the +last consumed message offset or else you may end up consuming duplicate +messages. + +New Features: + - Support for Kafka 0.10 + ([#672](https://github.com/Shopify/sarama/pull/672), + [#678](https://github.com/Shopify/sarama/pull/678), + [#681](https://github.com/Shopify/sarama/pull/681), and others). + - Support for configuring the target Kafka version + ([#676](https://github.com/Shopify/sarama/pull/676)). + - Batch producing support in the SyncProducer + ([#677](https://github.com/Shopify/sarama/pull/677)). + - Extend producer mock to allow setting expectations on message contents + ([#667](https://github.com/Shopify/sarama/pull/667)). + +Improvements: + - Support `nil` compressed messages for deleting in compacted topics + ([#634](https://github.com/Shopify/sarama/pull/634)). + - Pre-allocate decoding errors, greatly reducing heap usage and GC time against + misbehaving brokers ([#690](https://github.com/Shopify/sarama/pull/690)). + - Re-use consumer expiry timers, removing one allocation per consumed message + ([#707](https://github.com/Shopify/sarama/pull/707)). + +Bug Fixes: + - Actually default the client ID to "sarama" like we say we do + ([#664](https://github.com/Shopify/sarama/pull/664)). + - Fix a rare issue where `Client.Leader` could return the wrong error + ([#685](https://github.com/Shopify/sarama/pull/685)). + - Fix a possible tight loop in the consumer + ([#693](https://github.com/Shopify/sarama/pull/693)). + - Match upstream's offset-tracking behaviour + ([#705](https://github.com/Shopify/sarama/pull/705)). + - Report UnknownTopicOrPartition errors from the offset manager + ([#706](https://github.com/Shopify/sarama/pull/706)). + - Fix possible negative partition value from the HashPartitioner + ([#709](https://github.com/Shopify/sarama/pull/709)). + +#### Version 1.9.0 (2016-05-16) + +New Features: + - Add support for custom offset manager retention durations + ([#602](https://github.com/Shopify/sarama/pull/602)). + - Publish low-level mocks to enable testing of third-party producer/consumer + implementations ([#570](https://github.com/Shopify/sarama/pull/570)). + - Declare support for Golang 1.6 + ([#611](https://github.com/Shopify/sarama/pull/611)). + - Support for SASL plain-text auth + ([#648](https://github.com/Shopify/sarama/pull/648)). + +Improvements: + - Simplified broker locking scheme slightly + ([#604](https://github.com/Shopify/sarama/pull/604)). + - Documentation cleanup + ([#605](https://github.com/Shopify/sarama/pull/605), + [#621](https://github.com/Shopify/sarama/pull/621), + [#654](https://github.com/Shopify/sarama/pull/654)). + +Bug Fixes: + - Fix race condition shutting down the OffsetManager + ([#658](https://github.com/Shopify/sarama/pull/658)). + +#### Version 1.8.0 (2016-02-01) + +New Features: + - Full support for Kafka 0.9: + - All protocol messages and fields + ([#586](https://github.com/Shopify/sarama/pull/586), + [#588](https://github.com/Shopify/sarama/pull/588), + [#590](https://github.com/Shopify/sarama/pull/590)). + - Verified that TLS support works + ([#581](https://github.com/Shopify/sarama/pull/581)). + - Fixed the OffsetManager compatibility + ([#585](https://github.com/Shopify/sarama/pull/585)). + +Improvements: + - Optimize for fewer system calls when reading from the network + ([#584](https://github.com/Shopify/sarama/pull/584)). + - Automatically retry `InvalidMessage` errors to match upstream behaviour + ([#589](https://github.com/Shopify/sarama/pull/589)). + +#### Version 1.7.0 (2015-12-11) + +New Features: + - Preliminary support for Kafka 0.9 + ([#572](https://github.com/Shopify/sarama/pull/572)). This comes with several + caveats: + - Protocol-layer support is mostly in place + ([#577](https://github.com/Shopify/sarama/pull/577)), however Kafka 0.9 + renamed some messages and fields, which we did not in order to preserve API + compatibility. + - The producer and consumer work against 0.9, but the offset manager does + not ([#573](https://github.com/Shopify/sarama/pull/573)). + - TLS support may or may not work + ([#581](https://github.com/Shopify/sarama/pull/581)). + +Improvements: + - Don't wait for request timeouts on dead brokers, greatly speeding recovery + when the TCP connection is left hanging + ([#548](https://github.com/Shopify/sarama/pull/548)). + - Refactored part of the producer. The new version provides a much more elegant + solution to [#449](https://github.com/Shopify/sarama/pull/449). It is also + slightly more efficient, and much more precise in calculating batch sizes + when compression is used + ([#549](https://github.com/Shopify/sarama/pull/549), + [#550](https://github.com/Shopify/sarama/pull/550), + [#551](https://github.com/Shopify/sarama/pull/551)). + +Bug Fixes: + - Fix race condition in consumer test mock + ([#553](https://github.com/Shopify/sarama/pull/553)). + +#### Version 1.6.1 (2015-09-25) + +Bug Fixes: + - Fix panic that could occur if a user-supplied message value failed to encode + ([#449](https://github.com/Shopify/sarama/pull/449)). + +#### Version 1.6.0 (2015-09-04) + +New Features: + - Implementation of a consumer offset manager using the APIs introduced in + Kafka 0.8.2. The API is designed mainly for integration into a future + high-level consumer, not for direct use, although it is *possible* to use it + directly. + ([#461](https://github.com/Shopify/sarama/pull/461)). + +Improvements: + - CRC32 calculation is much faster on machines with SSE4.2 instructions, + removing a major hotspot from most profiles + ([#255](https://github.com/Shopify/sarama/pull/255)). + +Bug Fixes: + - Make protocol decoding more robust against some malformed packets generated + by go-fuzz ([#523](https://github.com/Shopify/sarama/pull/523), + [#525](https://github.com/Shopify/sarama/pull/525)) or found in other ways + ([#528](https://github.com/Shopify/sarama/pull/528)). + - Fix a potential race condition panic in the consumer on shutdown + ([#529](https://github.com/Shopify/sarama/pull/529)). + +#### Version 1.5.0 (2015-08-17) + +New Features: + - TLS-encrypted network connections are now supported. This feature is subject + to change when Kafka releases built-in TLS support, but for now this is + enough to work with TLS-terminating proxies + ([#154](https://github.com/Shopify/sarama/pull/154)). + +Improvements: + - The consumer will not block if a single partition is not drained by the user; + all other partitions will continue to consume normally + ([#485](https://github.com/Shopify/sarama/pull/485)). + - Formatting of error strings has been much improved + ([#495](https://github.com/Shopify/sarama/pull/495)). + - Internal refactoring of the producer for code cleanliness and to enable + future work ([#300](https://github.com/Shopify/sarama/pull/300)). + +Bug Fixes: + - Fix a potential deadlock in the consumer on shutdown + ([#475](https://github.com/Shopify/sarama/pull/475)). + +#### Version 1.4.3 (2015-07-21) + +Bug Fixes: + - Don't include the partitioner in the producer's "fetch partitions" + circuit-breaker ([#466](https://github.com/Shopify/sarama/pull/466)). + - Don't retry messages until the broker is closed when abandoning a broker in + the producer ([#468](https://github.com/Shopify/sarama/pull/468)). + - Update the import path for snappy-go, it has moved again and the API has + changed slightly ([#486](https://github.com/Shopify/sarama/pull/486)). + +#### Version 1.4.2 (2015-05-27) + +Bug Fixes: + - Update the import path for snappy-go, it has moved from google code to github + ([#456](https://github.com/Shopify/sarama/pull/456)). + +#### Version 1.4.1 (2015-05-25) + +Improvements: + - Optimizations when decoding snappy messages, thanks to John Potocny + ([#446](https://github.com/Shopify/sarama/pull/446)). + +Bug Fixes: + - Fix hypothetical race conditions on producer shutdown + ([#450](https://github.com/Shopify/sarama/pull/450), + [#451](https://github.com/Shopify/sarama/pull/451)). + +#### Version 1.4.0 (2015-05-01) + +New Features: + - The consumer now implements `Topics()` and `Partitions()` methods to enable + users to dynamically choose what topics/partitions to consume without + instantiating a full client + ([#431](https://github.com/Shopify/sarama/pull/431)). + - The partition-consumer now exposes the high water mark offset value returned + by the broker via the `HighWaterMarkOffset()` method ([#339](https://github.com/Shopify/sarama/pull/339)). + - Added a `kafka-console-consumer` tool capable of handling multiple + partitions, and deprecated the now-obsolete `kafka-console-partitionConsumer` + ([#439](https://github.com/Shopify/sarama/pull/439), + [#442](https://github.com/Shopify/sarama/pull/442)). + +Improvements: + - The producer's logging during retry scenarios is more consistent, more + useful, and slightly less verbose + ([#429](https://github.com/Shopify/sarama/pull/429)). + - The client now shuffles its initial list of seed brokers in order to prevent + thundering herd on the first broker in the list + ([#441](https://github.com/Shopify/sarama/pull/441)). + +Bug Fixes: + - The producer now correctly manages its state if retries occur when it is + shutting down, fixing several instances of confusing behaviour and at least + one potential deadlock ([#419](https://github.com/Shopify/sarama/pull/419)). + - The consumer now handles messages for different partitions asynchronously, + making it much more resilient to specific user code ordering + ([#325](https://github.com/Shopify/sarama/pull/325)). + +#### Version 1.3.0 (2015-04-16) + +New Features: + - The client now tracks consumer group coordinators using + ConsumerMetadataRequests similar to how it tracks partition leadership using + regular MetadataRequests ([#411](https://github.com/Shopify/sarama/pull/411)). + This adds two methods to the client API: + - `Coordinator(consumerGroup string) (*Broker, error)` + - `RefreshCoordinator(consumerGroup string) error` + +Improvements: + - ConsumerMetadataResponses now automatically create a Broker object out of the + ID/address/port combination for the Coordinator; accessing the fields + individually has been deprecated + ([#413](https://github.com/Shopify/sarama/pull/413)). + - Much improved handling of `OffsetOutOfRange` errors in the consumer. + Consumers will fail to start if the provided offset is out of range + ([#418](https://github.com/Shopify/sarama/pull/418)) + and they will automatically shut down if the offset falls out of range + ([#424](https://github.com/Shopify/sarama/pull/424)). + - Small performance improvement in encoding and decoding protocol messages + ([#427](https://github.com/Shopify/sarama/pull/427)). + +Bug Fixes: + - Fix a rare race condition in the client's background metadata refresher if + it happens to be activated while the client is being closed + ([#422](https://github.com/Shopify/sarama/pull/422)). + +#### Version 1.2.0 (2015-04-07) + +Improvements: + - The producer's behaviour when `Flush.Frequency` is set is now more intuitive + ([#389](https://github.com/Shopify/sarama/pull/389)). + - The producer is now somewhat more memory-efficient during and after retrying + messages due to an improved queue implementation + ([#396](https://github.com/Shopify/sarama/pull/396)). + - The consumer produces much more useful logging output when leadership + changes ([#385](https://github.com/Shopify/sarama/pull/385)). + - The client's `GetOffset` method will now automatically refresh metadata and + retry once in the event of stale information or similar + ([#394](https://github.com/Shopify/sarama/pull/394)). + - Broker connections now have support for using TCP keepalives + ([#407](https://github.com/Shopify/sarama/issues/407)). + +Bug Fixes: + - The OffsetCommitRequest message now correctly implements all three possible + API versions ([#390](https://github.com/Shopify/sarama/pull/390), + [#400](https://github.com/Shopify/sarama/pull/400)). + +#### Version 1.1.0 (2015-03-20) + +Improvements: + - Wrap the producer's partitioner call in a circuit-breaker so that repeatedly + broken topics don't choke throughput + ([#373](https://github.com/Shopify/sarama/pull/373)). + +Bug Fixes: + - Fix the producer's internal reference counting in certain unusual scenarios + ([#367](https://github.com/Shopify/sarama/pull/367)). + - Fix the consumer's internal reference counting in certain unusual scenarios + ([#369](https://github.com/Shopify/sarama/pull/369)). + - Fix a condition where the producer's internal control messages could have + gotten stuck ([#368](https://github.com/Shopify/sarama/pull/368)). + - Fix an issue where invalid partition lists would be cached when asking for + metadata for a non-existant topic ([#372](https://github.com/Shopify/sarama/pull/372)). + + +#### Version 1.0.0 (2015-03-17) + +Version 1.0.0 is the first tagged version, and is almost a complete rewrite. The primary differences with previous untagged versions are: + +- The producer has been rewritten; there is now a `SyncProducer` with a blocking API, and an `AsyncProducer` that is non-blocking. +- The consumer has been rewritten to only open one connection per broker instead of one connection per partition. +- The main types of Sarama are now interfaces to make depedency injection easy; mock implementations for `Consumer`, `SyncProducer` and `AsyncProducer` are provided in the `github.com/Shopify/sarama/mocks` package. +- For most uses cases, it is no longer necessary to open a `Client`; this will be done for you. +- All the configuration values have been unified in the `Config` struct. +- Much improved test suite. diff --git a/vendor/github.com/Shopify/sarama/LICENSE b/vendor/github.com/Shopify/sarama/LICENSE new file mode 100644 index 00000000..8121b63b --- /dev/null +++ b/vendor/github.com/Shopify/sarama/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2013 Evan Huus + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/Shopify/sarama/Makefile b/vendor/github.com/Shopify/sarama/Makefile new file mode 100644 index 00000000..626b09a5 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/Makefile @@ -0,0 +1,21 @@ +default: fmt vet errcheck test + +test: + go test -v -timeout 60s -race ./... + +vet: + go vet ./... + +errcheck: + errcheck github.com/Shopify/sarama/... + +fmt: + @if [ -n "$$(go fmt ./...)" ]; then echo 'Please run go fmt on your code.' && exit 1; fi + +install_dependencies: install_errcheck get + +install_errcheck: + go get github.com/kisielk/errcheck + +get: + go get -t diff --git a/vendor/github.com/Shopify/sarama/README.md b/vendor/github.com/Shopify/sarama/README.md new file mode 100644 index 00000000..a95571a7 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/README.md @@ -0,0 +1,36 @@ +sarama +====== + +[![GoDoc](https://godoc.org/github.com/Shopify/sarama?status.png)](https://godoc.org/github.com/Shopify/sarama) +[![Build Status](https://travis-ci.org/Shopify/sarama.svg?branch=master)](https://travis-ci.org/Shopify/sarama) + +Sarama is an MIT-licensed Go client library for [Apache Kafka](https://kafka.apache.org/) version 0.8 (and later). + +### Getting started + +- API documentation and examples are available via [godoc](https://godoc.org/github.com/Shopify/sarama). +- Mocks for testing are available in the [mocks](./mocks) subpackage. +- The [examples](./examples) directory contains more elaborate example applications. +- The [tools](./tools) directory contains command line tools that can be useful for testing, diagnostics, and instrumentation. + +### Compatibility and API stability + +Sarama provides a "2 releases + 2 months" compatibility guarantee: we support +the two latest stable releases of Kafka and Go, and we provide a two month +grace period for older releases. This means we currently officially support +Go 1.7 and 1.6, and Kafka 0.10.0 and 0.9.0, although older releases are +still likely to work. + +Sarama follows semantic versioning and provides API stability via the gopkg.in service. +You can import a version with a guaranteed stable API via http://gopkg.in/Shopify/sarama.v1. +A changelog is available [here](CHANGELOG.md). + +### Contributing + +* Get started by checking our [contribution guidelines](https://github.com/Shopify/sarama/blob/master/.github/CONTRIBUTING.md). +* Read the [Sarama wiki](https://github.com/Shopify/sarama/wiki) for more + technical and design details. +* The [Kafka Protocol Specification](https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol) + contains a wealth of useful information. +* For more general issues, there is [a google group](https://groups.google.com/forum/#!forum/kafka-clients) for Kafka client developers. +* If you have any questions, just ask! diff --git a/vendor/github.com/Shopify/sarama/Vagrantfile b/vendor/github.com/Shopify/sarama/Vagrantfile new file mode 100644 index 00000000..f4b848a3 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/Vagrantfile @@ -0,0 +1,20 @@ +# -*- mode: ruby -*- +# vi: set ft=ruby : + +# Vagrantfile API/syntax version. Don't touch unless you know what you're doing! +VAGRANTFILE_API_VERSION = "2" + +# We have 5 * 192MB ZK processes and 5 * 320MB Kafka processes => 2560MB +MEMORY = 3072 + +Vagrant.configure(VAGRANTFILE_API_VERSION) do |config| + config.vm.box = "ubuntu/trusty64" + + config.vm.provision :shell, path: "vagrant/provision.sh" + + config.vm.network "private_network", ip: "192.168.100.67" + + config.vm.provider "virtualbox" do |v| + v.memory = MEMORY + end +end diff --git a/vendor/github.com/Shopify/sarama/api_versions_request.go b/vendor/github.com/Shopify/sarama/api_versions_request.go new file mode 100644 index 00000000..ab65f01c --- /dev/null +++ b/vendor/github.com/Shopify/sarama/api_versions_request.go @@ -0,0 +1,24 @@ +package sarama + +type ApiVersionsRequest struct { +} + +func (r *ApiVersionsRequest) encode(pe packetEncoder) error { + return nil +} + +func (r *ApiVersionsRequest) decode(pd packetDecoder, version int16) (err error) { + return nil +} + +func (r *ApiVersionsRequest) key() int16 { + return 18 +} + +func (r *ApiVersionsRequest) version() int16 { + return 0 +} + +func (r *ApiVersionsRequest) requiredVersion() KafkaVersion { + return V0_10_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/api_versions_response.go b/vendor/github.com/Shopify/sarama/api_versions_response.go new file mode 100644 index 00000000..23bc326e --- /dev/null +++ b/vendor/github.com/Shopify/sarama/api_versions_response.go @@ -0,0 +1,87 @@ +package sarama + +type ApiVersionsResponseBlock struct { + ApiKey int16 + MinVersion int16 + MaxVersion int16 +} + +func (b *ApiVersionsResponseBlock) encode(pe packetEncoder) error { + pe.putInt16(b.ApiKey) + pe.putInt16(b.MinVersion) + pe.putInt16(b.MaxVersion) + return nil +} + +func (b *ApiVersionsResponseBlock) decode(pd packetDecoder) error { + var err error + + if b.ApiKey, err = pd.getInt16(); err != nil { + return err + } + + if b.MinVersion, err = pd.getInt16(); err != nil { + return err + } + + if b.MaxVersion, err = pd.getInt16(); err != nil { + return err + } + + return nil +} + +type ApiVersionsResponse struct { + Err KError + ApiVersions []*ApiVersionsResponseBlock +} + +func (r *ApiVersionsResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + if err := pe.putArrayLength(len(r.ApiVersions)); err != nil { + return err + } + for _, apiVersion := range r.ApiVersions { + if err := apiVersion.encode(pe); err != nil { + return err + } + } + return nil +} + +func (r *ApiVersionsResponse) decode(pd packetDecoder, version int16) error { + kerr, err := pd.getInt16() + if err != nil { + return err + } + + r.Err = KError(kerr) + + numBlocks, err := pd.getArrayLength() + if err != nil { + return err + } + + r.ApiVersions = make([]*ApiVersionsResponseBlock, numBlocks) + for i := 0; i < numBlocks; i++ { + block := new(ApiVersionsResponseBlock) + if err := block.decode(pd); err != nil { + return err + } + r.ApiVersions[i] = block + } + + return nil +} + +func (r *ApiVersionsResponse) key() int16 { + return 18 +} + +func (r *ApiVersionsResponse) version() int16 { + return 0 +} + +func (r *ApiVersionsResponse) requiredVersion() KafkaVersion { + return V0_10_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/async_producer.go b/vendor/github.com/Shopify/sarama/async_producer.go new file mode 100644 index 00000000..25429748 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/async_producer.go @@ -0,0 +1,905 @@ +package sarama + +import ( + "fmt" + "sync" + "time" + + "github.com/eapache/go-resiliency/breaker" + "github.com/eapache/queue" +) + +// AsyncProducer publishes Kafka messages using a non-blocking API. It routes messages +// to the correct broker for the provided topic-partition, refreshing metadata as appropriate, +// and parses responses for errors. You must read from the Errors() channel or the +// producer will deadlock. You must call Close() or AsyncClose() on a producer to avoid +// leaks: it will not be garbage-collected automatically when it passes out of +// scope. +type AsyncProducer interface { + + // AsyncClose triggers a shutdown of the producer, flushing any messages it may + // have buffered. The shutdown has completed when both the Errors and Successes + // channels have been closed. When calling AsyncClose, you *must* continue to + // read from those channels in order to drain the results of any messages in + // flight. + AsyncClose() + + // Close shuts down the producer and flushes any messages it may have buffered. + // You must call this function before a producer object passes out of scope, as + // it may otherwise leak memory. You must call this before calling Close on the + // underlying client. + Close() error + + // Input is the input channel for the user to write messages to that they + // wish to send. + Input() chan<- *ProducerMessage + + // Successes is the success output channel back to the user when AckSuccesses is + // enabled. If Return.Successes is true, you MUST read from this channel or the + // Producer will deadlock. It is suggested that you send and read messages + // together in a single select statement. + Successes() <-chan *ProducerMessage + + // Errors is the error output channel back to the user. You MUST read from this + // channel or the Producer will deadlock when the channel is full. Alternatively, + // you can set Producer.Return.Errors in your config to false, which prevents + // errors to be returned. + Errors() <-chan *ProducerError +} + +type asyncProducer struct { + client Client + conf *Config + ownClient bool + + errors chan *ProducerError + input, successes, retries chan *ProducerMessage + inFlight sync.WaitGroup + + brokers map[*Broker]chan<- *ProducerMessage + brokerRefs map[chan<- *ProducerMessage]int + brokerLock sync.Mutex +} + +// NewAsyncProducer creates a new AsyncProducer using the given broker addresses and configuration. +func NewAsyncProducer(addrs []string, conf *Config) (AsyncProducer, error) { + client, err := NewClient(addrs, conf) + if err != nil { + return nil, err + } + + p, err := NewAsyncProducerFromClient(client) + if err != nil { + return nil, err + } + p.(*asyncProducer).ownClient = true + return p, nil +} + +// NewAsyncProducerFromClient creates a new Producer using the given client. It is still +// necessary to call Close() on the underlying client when shutting down this producer. +func NewAsyncProducerFromClient(client Client) (AsyncProducer, error) { + // Check that we are not dealing with a closed Client before processing any other arguments + if client.Closed() { + return nil, ErrClosedClient + } + + p := &asyncProducer{ + client: client, + conf: client.Config(), + errors: make(chan *ProducerError), + input: make(chan *ProducerMessage), + successes: make(chan *ProducerMessage), + retries: make(chan *ProducerMessage), + brokers: make(map[*Broker]chan<- *ProducerMessage), + brokerRefs: make(map[chan<- *ProducerMessage]int), + } + + // launch our singleton dispatchers + go withRecover(p.dispatcher) + go withRecover(p.retryHandler) + + return p, nil +} + +type flagSet int8 + +const ( + syn flagSet = 1 << iota // first message from partitionProducer to brokerProducer + fin // final message from partitionProducer to brokerProducer and back + shutdown // start the shutdown process +) + +// ProducerMessage is the collection of elements passed to the Producer in order to send a message. +type ProducerMessage struct { + Topic string // The Kafka topic for this message. + // The partitioning key for this message. Pre-existing Encoders include + // StringEncoder and ByteEncoder. + Key Encoder + // The actual message to store in Kafka. Pre-existing Encoders include + // StringEncoder and ByteEncoder. + Value Encoder + + // This field is used to hold arbitrary data you wish to include so it + // will be available when receiving on the Successes and Errors channels. + // Sarama completely ignores this field and is only to be used for + // pass-through data. + Metadata interface{} + + // Below this point are filled in by the producer as the message is processed + + // Offset is the offset of the message stored on the broker. This is only + // guaranteed to be defined if the message was successfully delivered and + // RequiredAcks is not NoResponse. + Offset int64 + // Partition is the partition that the message was sent to. This is only + // guaranteed to be defined if the message was successfully delivered. + Partition int32 + // Timestamp is the timestamp assigned to the message by the broker. This + // is only guaranteed to be defined if the message was successfully + // delivered, RequiredAcks is not NoResponse, and the Kafka broker is at + // least version 0.10.0. + Timestamp time.Time + + retries int + flags flagSet +} + +const producerMessageOverhead = 26 // the metadata overhead of CRC, flags, etc. + +func (m *ProducerMessage) byteSize() int { + size := producerMessageOverhead + if m.Key != nil { + size += m.Key.Length() + } + if m.Value != nil { + size += m.Value.Length() + } + return size +} + +func (m *ProducerMessage) clear() { + m.flags = 0 + m.retries = 0 +} + +// ProducerError is the type of error generated when the producer fails to deliver a message. +// It contains the original ProducerMessage as well as the actual error value. +type ProducerError struct { + Msg *ProducerMessage + Err error +} + +func (pe ProducerError) Error() string { + return fmt.Sprintf("kafka: Failed to produce message to topic %s: %s", pe.Msg.Topic, pe.Err) +} + +// ProducerErrors is a type that wraps a batch of "ProducerError"s and implements the Error interface. +// It can be returned from the Producer's Close method to avoid the need to manually drain the Errors channel +// when closing a producer. +type ProducerErrors []*ProducerError + +func (pe ProducerErrors) Error() string { + return fmt.Sprintf("kafka: Failed to deliver %d messages.", len(pe)) +} + +func (p *asyncProducer) Errors() <-chan *ProducerError { + return p.errors +} + +func (p *asyncProducer) Successes() <-chan *ProducerMessage { + return p.successes +} + +func (p *asyncProducer) Input() chan<- *ProducerMessage { + return p.input +} + +func (p *asyncProducer) Close() error { + p.AsyncClose() + + if p.conf.Producer.Return.Successes { + go withRecover(func() { + for range p.successes { + } + }) + } + + var errors ProducerErrors + if p.conf.Producer.Return.Errors { + for event := range p.errors { + errors = append(errors, event) + } + } else { + <-p.errors + } + + if len(errors) > 0 { + return errors + } + return nil +} + +func (p *asyncProducer) AsyncClose() { + go withRecover(p.shutdown) +} + +// singleton +// dispatches messages by topic +func (p *asyncProducer) dispatcher() { + handlers := make(map[string]chan<- *ProducerMessage) + shuttingDown := false + + for msg := range p.input { + if msg == nil { + Logger.Println("Something tried to send a nil message, it was ignored.") + continue + } + + if msg.flags&shutdown != 0 { + shuttingDown = true + p.inFlight.Done() + continue + } else if msg.retries == 0 { + if shuttingDown { + // we can't just call returnError here because that decrements the wait group, + // which hasn't been incremented yet for this message, and shouldn't be + pErr := &ProducerError{Msg: msg, Err: ErrShuttingDown} + if p.conf.Producer.Return.Errors { + p.errors <- pErr + } else { + Logger.Println(pErr) + } + continue + } + p.inFlight.Add(1) + } + + if msg.byteSize() > p.conf.Producer.MaxMessageBytes { + p.returnError(msg, ErrMessageSizeTooLarge) + continue + } + + handler := handlers[msg.Topic] + if handler == nil { + handler = p.newTopicProducer(msg.Topic) + handlers[msg.Topic] = handler + } + + handler <- msg + } + + for _, handler := range handlers { + close(handler) + } +} + +// one per topic +// partitions messages, then dispatches them by partition +type topicProducer struct { + parent *asyncProducer + topic string + input <-chan *ProducerMessage + + breaker *breaker.Breaker + handlers map[int32]chan<- *ProducerMessage + partitioner Partitioner +} + +func (p *asyncProducer) newTopicProducer(topic string) chan<- *ProducerMessage { + input := make(chan *ProducerMessage, p.conf.ChannelBufferSize) + tp := &topicProducer{ + parent: p, + topic: topic, + input: input, + breaker: breaker.New(3, 1, 10*time.Second), + handlers: make(map[int32]chan<- *ProducerMessage), + partitioner: p.conf.Producer.Partitioner(topic), + } + go withRecover(tp.dispatch) + return input +} + +func (tp *topicProducer) dispatch() { + for msg := range tp.input { + if msg.retries == 0 { + if err := tp.partitionMessage(msg); err != nil { + tp.parent.returnError(msg, err) + continue + } + } + + handler := tp.handlers[msg.Partition] + if handler == nil { + handler = tp.parent.newPartitionProducer(msg.Topic, msg.Partition) + tp.handlers[msg.Partition] = handler + } + + handler <- msg + } + + for _, handler := range tp.handlers { + close(handler) + } +} + +func (tp *topicProducer) partitionMessage(msg *ProducerMessage) error { + var partitions []int32 + + err := tp.breaker.Run(func() (err error) { + if tp.partitioner.RequiresConsistency() { + partitions, err = tp.parent.client.Partitions(msg.Topic) + } else { + partitions, err = tp.parent.client.WritablePartitions(msg.Topic) + } + return + }) + + if err != nil { + return err + } + + numPartitions := int32(len(partitions)) + + if numPartitions == 0 { + return ErrLeaderNotAvailable + } + + choice, err := tp.partitioner.Partition(msg, numPartitions) + + if err != nil { + return err + } else if choice < 0 || choice >= numPartitions { + return ErrInvalidPartition + } + + msg.Partition = partitions[choice] + + return nil +} + +// one per partition per topic +// dispatches messages to the appropriate broker +// also responsible for maintaining message order during retries +type partitionProducer struct { + parent *asyncProducer + topic string + partition int32 + input <-chan *ProducerMessage + + leader *Broker + breaker *breaker.Breaker + output chan<- *ProducerMessage + + // highWatermark tracks the "current" retry level, which is the only one where we actually let messages through, + // all other messages get buffered in retryState[msg.retries].buf to preserve ordering + // retryState[msg.retries].expectChaser simply tracks whether we've seen a fin message for a given level (and + // therefore whether our buffer is complete and safe to flush) + highWatermark int + retryState []partitionRetryState +} + +type partitionRetryState struct { + buf []*ProducerMessage + expectChaser bool +} + +func (p *asyncProducer) newPartitionProducer(topic string, partition int32) chan<- *ProducerMessage { + input := make(chan *ProducerMessage, p.conf.ChannelBufferSize) + pp := &partitionProducer{ + parent: p, + topic: topic, + partition: partition, + input: input, + + breaker: breaker.New(3, 1, 10*time.Second), + retryState: make([]partitionRetryState, p.conf.Producer.Retry.Max+1), + } + go withRecover(pp.dispatch) + return input +} + +func (pp *partitionProducer) dispatch() { + // try to prefetch the leader; if this doesn't work, we'll do a proper call to `updateLeader` + // on the first message + pp.leader, _ = pp.parent.client.Leader(pp.topic, pp.partition) + if pp.leader != nil { + pp.output = pp.parent.getBrokerProducer(pp.leader) + pp.parent.inFlight.Add(1) // we're generating a syn message; track it so we don't shut down while it's still inflight + pp.output <- &ProducerMessage{Topic: pp.topic, Partition: pp.partition, flags: syn} + } + + for msg := range pp.input { + if msg.retries > pp.highWatermark { + // a new, higher, retry level; handle it and then back off + pp.newHighWatermark(msg.retries) + time.Sleep(pp.parent.conf.Producer.Retry.Backoff) + } else if pp.highWatermark > 0 { + // we are retrying something (else highWatermark would be 0) but this message is not a *new* retry level + if msg.retries < pp.highWatermark { + // in fact this message is not even the current retry level, so buffer it for now (unless it's a just a fin) + if msg.flags&fin == fin { + pp.retryState[msg.retries].expectChaser = false + pp.parent.inFlight.Done() // this fin is now handled and will be garbage collected + } else { + pp.retryState[msg.retries].buf = append(pp.retryState[msg.retries].buf, msg) + } + continue + } else if msg.flags&fin == fin { + // this message is of the current retry level (msg.retries == highWatermark) and the fin flag is set, + // meaning this retry level is done and we can go down (at least) one level and flush that + pp.retryState[pp.highWatermark].expectChaser = false + pp.flushRetryBuffers() + pp.parent.inFlight.Done() // this fin is now handled and will be garbage collected + continue + } + } + + // if we made it this far then the current msg contains real data, and can be sent to the next goroutine + // without breaking any of our ordering guarantees + + if pp.output == nil { + if err := pp.updateLeader(); err != nil { + pp.parent.returnError(msg, err) + time.Sleep(pp.parent.conf.Producer.Retry.Backoff) + continue + } + Logger.Printf("producer/leader/%s/%d selected broker %d\n", pp.topic, pp.partition, pp.leader.ID()) + } + + pp.output <- msg + } + + if pp.output != nil { + pp.parent.unrefBrokerProducer(pp.leader, pp.output) + } +} + +func (pp *partitionProducer) newHighWatermark(hwm int) { + Logger.Printf("producer/leader/%s/%d state change to [retrying-%d]\n", pp.topic, pp.partition, hwm) + pp.highWatermark = hwm + + // send off a fin so that we know when everything "in between" has made it + // back to us and we can safely flush the backlog (otherwise we risk re-ordering messages) + pp.retryState[pp.highWatermark].expectChaser = true + pp.parent.inFlight.Add(1) // we're generating a fin message; track it so we don't shut down while it's still inflight + pp.output <- &ProducerMessage{Topic: pp.topic, Partition: pp.partition, flags: fin, retries: pp.highWatermark - 1} + + // a new HWM means that our current broker selection is out of date + Logger.Printf("producer/leader/%s/%d abandoning broker %d\n", pp.topic, pp.partition, pp.leader.ID()) + pp.parent.unrefBrokerProducer(pp.leader, pp.output) + pp.output = nil +} + +func (pp *partitionProducer) flushRetryBuffers() { + Logger.Printf("producer/leader/%s/%d state change to [flushing-%d]\n", pp.topic, pp.partition, pp.highWatermark) + for { + pp.highWatermark-- + + if pp.output == nil { + if err := pp.updateLeader(); err != nil { + pp.parent.returnErrors(pp.retryState[pp.highWatermark].buf, err) + goto flushDone + } + Logger.Printf("producer/leader/%s/%d selected broker %d\n", pp.topic, pp.partition, pp.leader.ID()) + } + + for _, msg := range pp.retryState[pp.highWatermark].buf { + pp.output <- msg + } + + flushDone: + pp.retryState[pp.highWatermark].buf = nil + if pp.retryState[pp.highWatermark].expectChaser { + Logger.Printf("producer/leader/%s/%d state change to [retrying-%d]\n", pp.topic, pp.partition, pp.highWatermark) + break + } else if pp.highWatermark == 0 { + Logger.Printf("producer/leader/%s/%d state change to [normal]\n", pp.topic, pp.partition) + break + } + } +} + +func (pp *partitionProducer) updateLeader() error { + return pp.breaker.Run(func() (err error) { + if err = pp.parent.client.RefreshMetadata(pp.topic); err != nil { + return err + } + + if pp.leader, err = pp.parent.client.Leader(pp.topic, pp.partition); err != nil { + return err + } + + pp.output = pp.parent.getBrokerProducer(pp.leader) + pp.parent.inFlight.Add(1) // we're generating a syn message; track it so we don't shut down while it's still inflight + pp.output <- &ProducerMessage{Topic: pp.topic, Partition: pp.partition, flags: syn} + + return nil + }) +} + +// one per broker; also constructs an associated flusher +func (p *asyncProducer) newBrokerProducer(broker *Broker) chan<- *ProducerMessage { + var ( + input = make(chan *ProducerMessage) + bridge = make(chan *produceSet) + responses = make(chan *brokerProducerResponse) + ) + + bp := &brokerProducer{ + parent: p, + broker: broker, + input: input, + output: bridge, + responses: responses, + buffer: newProduceSet(p), + currentRetries: make(map[string]map[int32]error), + } + go withRecover(bp.run) + + // minimal bridge to make the network response `select`able + go withRecover(func() { + for set := range bridge { + request := set.buildRequest() + + response, err := broker.Produce(request) + + responses <- &brokerProducerResponse{ + set: set, + err: err, + res: response, + } + } + close(responses) + }) + + return input +} + +type brokerProducerResponse struct { + set *produceSet + err error + res *ProduceResponse +} + +// groups messages together into appropriately-sized batches for sending to the broker +// handles state related to retries etc +type brokerProducer struct { + parent *asyncProducer + broker *Broker + + input <-chan *ProducerMessage + output chan<- *produceSet + responses <-chan *brokerProducerResponse + + buffer *produceSet + timer <-chan time.Time + timerFired bool + + closing error + currentRetries map[string]map[int32]error +} + +func (bp *brokerProducer) run() { + var output chan<- *produceSet + Logger.Printf("producer/broker/%d starting up\n", bp.broker.ID()) + + for { + select { + case msg := <-bp.input: + if msg == nil { + bp.shutdown() + return + } + + if msg.flags&syn == syn { + Logger.Printf("producer/broker/%d state change to [open] on %s/%d\n", + bp.broker.ID(), msg.Topic, msg.Partition) + if bp.currentRetries[msg.Topic] == nil { + bp.currentRetries[msg.Topic] = make(map[int32]error) + } + bp.currentRetries[msg.Topic][msg.Partition] = nil + bp.parent.inFlight.Done() + continue + } + + if reason := bp.needsRetry(msg); reason != nil { + bp.parent.retryMessage(msg, reason) + + if bp.closing == nil && msg.flags&fin == fin { + // we were retrying this partition but we can start processing again + delete(bp.currentRetries[msg.Topic], msg.Partition) + Logger.Printf("producer/broker/%d state change to [closed] on %s/%d\n", + bp.broker.ID(), msg.Topic, msg.Partition) + } + + continue + } + + if bp.buffer.wouldOverflow(msg) { + if err := bp.waitForSpace(msg); err != nil { + bp.parent.retryMessage(msg, err) + continue + } + } + + if err := bp.buffer.add(msg); err != nil { + bp.parent.returnError(msg, err) + continue + } + + if bp.parent.conf.Producer.Flush.Frequency > 0 && bp.timer == nil { + bp.timer = time.After(bp.parent.conf.Producer.Flush.Frequency) + } + case <-bp.timer: + bp.timerFired = true + case output <- bp.buffer: + bp.rollOver() + case response := <-bp.responses: + bp.handleResponse(response) + } + + if bp.timerFired || bp.buffer.readyToFlush() { + output = bp.output + } else { + output = nil + } + } +} + +func (bp *brokerProducer) shutdown() { + for !bp.buffer.empty() { + select { + case response := <-bp.responses: + bp.handleResponse(response) + case bp.output <- bp.buffer: + bp.rollOver() + } + } + close(bp.output) + for response := range bp.responses { + bp.handleResponse(response) + } + + Logger.Printf("producer/broker/%d shut down\n", bp.broker.ID()) +} + +func (bp *brokerProducer) needsRetry(msg *ProducerMessage) error { + if bp.closing != nil { + return bp.closing + } + + return bp.currentRetries[msg.Topic][msg.Partition] +} + +func (bp *brokerProducer) waitForSpace(msg *ProducerMessage) error { + Logger.Printf("producer/broker/%d maximum request accumulated, waiting for space\n", bp.broker.ID()) + + for { + select { + case response := <-bp.responses: + bp.handleResponse(response) + // handling a response can change our state, so re-check some things + if reason := bp.needsRetry(msg); reason != nil { + return reason + } else if !bp.buffer.wouldOverflow(msg) { + return nil + } + case bp.output <- bp.buffer: + bp.rollOver() + return nil + } + } +} + +func (bp *brokerProducer) rollOver() { + bp.timer = nil + bp.timerFired = false + bp.buffer = newProduceSet(bp.parent) +} + +func (bp *brokerProducer) handleResponse(response *brokerProducerResponse) { + if response.err != nil { + bp.handleError(response.set, response.err) + } else { + bp.handleSuccess(response.set, response.res) + } + + if bp.buffer.empty() { + bp.rollOver() // this can happen if the response invalidated our buffer + } +} + +func (bp *brokerProducer) handleSuccess(sent *produceSet, response *ProduceResponse) { + // we iterate through the blocks in the request set, not the response, so that we notice + // if the response is missing a block completely + sent.eachPartition(func(topic string, partition int32, msgs []*ProducerMessage) { + if response == nil { + // this only happens when RequiredAcks is NoResponse, so we have to assume success + bp.parent.returnSuccesses(msgs) + return + } + + block := response.GetBlock(topic, partition) + if block == nil { + bp.parent.returnErrors(msgs, ErrIncompleteResponse) + return + } + + switch block.Err { + // Success + case ErrNoError: + if bp.parent.conf.Version.IsAtLeast(V0_10_0_0) && !block.Timestamp.IsZero() { + for _, msg := range msgs { + msg.Timestamp = block.Timestamp + } + } + for i, msg := range msgs { + msg.Offset = block.Offset + int64(i) + } + bp.parent.returnSuccesses(msgs) + // Retriable errors + case ErrInvalidMessage, ErrUnknownTopicOrPartition, ErrLeaderNotAvailable, ErrNotLeaderForPartition, + ErrRequestTimedOut, ErrNotEnoughReplicas, ErrNotEnoughReplicasAfterAppend: + Logger.Printf("producer/broker/%d state change to [retrying] on %s/%d because %v\n", + bp.broker.ID(), topic, partition, block.Err) + bp.currentRetries[topic][partition] = block.Err + bp.parent.retryMessages(msgs, block.Err) + bp.parent.retryMessages(bp.buffer.dropPartition(topic, partition), block.Err) + // Other non-retriable errors + default: + bp.parent.returnErrors(msgs, block.Err) + } + }) +} + +func (bp *brokerProducer) handleError(sent *produceSet, err error) { + switch err.(type) { + case PacketEncodingError: + sent.eachPartition(func(topic string, partition int32, msgs []*ProducerMessage) { + bp.parent.returnErrors(msgs, err) + }) + default: + Logger.Printf("producer/broker/%d state change to [closing] because %s\n", bp.broker.ID(), err) + bp.parent.abandonBrokerConnection(bp.broker) + _ = bp.broker.Close() + bp.closing = err + sent.eachPartition(func(topic string, partition int32, msgs []*ProducerMessage) { + bp.parent.retryMessages(msgs, err) + }) + bp.buffer.eachPartition(func(topic string, partition int32, msgs []*ProducerMessage) { + bp.parent.retryMessages(msgs, err) + }) + bp.rollOver() + } +} + +// singleton +// effectively a "bridge" between the flushers and the dispatcher in order to avoid deadlock +// based on https://godoc.org/github.com/eapache/channels#InfiniteChannel +func (p *asyncProducer) retryHandler() { + var msg *ProducerMessage + buf := queue.New() + + for { + if buf.Length() == 0 { + msg = <-p.retries + } else { + select { + case msg = <-p.retries: + case p.input <- buf.Peek().(*ProducerMessage): + buf.Remove() + continue + } + } + + if msg == nil { + return + } + + buf.Add(msg) + } +} + +// utility functions + +func (p *asyncProducer) shutdown() { + Logger.Println("Producer shutting down.") + p.inFlight.Add(1) + p.input <- &ProducerMessage{flags: shutdown} + + p.inFlight.Wait() + + if p.ownClient { + err := p.client.Close() + if err != nil { + Logger.Println("producer/shutdown failed to close the embedded client:", err) + } + } + + close(p.input) + close(p.retries) + close(p.errors) + close(p.successes) +} + +func (p *asyncProducer) returnError(msg *ProducerMessage, err error) { + msg.clear() + pErr := &ProducerError{Msg: msg, Err: err} + if p.conf.Producer.Return.Errors { + p.errors <- pErr + } else { + Logger.Println(pErr) + } + p.inFlight.Done() +} + +func (p *asyncProducer) returnErrors(batch []*ProducerMessage, err error) { + for _, msg := range batch { + p.returnError(msg, err) + } +} + +func (p *asyncProducer) returnSuccesses(batch []*ProducerMessage) { + for _, msg := range batch { + if p.conf.Producer.Return.Successes { + msg.clear() + p.successes <- msg + } + p.inFlight.Done() + } +} + +func (p *asyncProducer) retryMessage(msg *ProducerMessage, err error) { + if msg.retries >= p.conf.Producer.Retry.Max { + p.returnError(msg, err) + } else { + msg.retries++ + p.retries <- msg + } +} + +func (p *asyncProducer) retryMessages(batch []*ProducerMessage, err error) { + for _, msg := range batch { + p.retryMessage(msg, err) + } +} + +func (p *asyncProducer) getBrokerProducer(broker *Broker) chan<- *ProducerMessage { + p.brokerLock.Lock() + defer p.brokerLock.Unlock() + + bp := p.brokers[broker] + + if bp == nil { + bp = p.newBrokerProducer(broker) + p.brokers[broker] = bp + p.brokerRefs[bp] = 0 + } + + p.brokerRefs[bp]++ + + return bp +} + +func (p *asyncProducer) unrefBrokerProducer(broker *Broker, bp chan<- *ProducerMessage) { + p.brokerLock.Lock() + defer p.brokerLock.Unlock() + + p.brokerRefs[bp]-- + if p.brokerRefs[bp] == 0 { + close(bp) + delete(p.brokerRefs, bp) + + if p.brokers[broker] == bp { + delete(p.brokers, broker) + } + } +} + +func (p *asyncProducer) abandonBrokerConnection(broker *Broker) { + p.brokerLock.Lock() + defer p.brokerLock.Unlock() + + delete(p.brokers, broker) +} diff --git a/vendor/github.com/Shopify/sarama/broker.go b/vendor/github.com/Shopify/sarama/broker.go new file mode 100644 index 00000000..ff066b8d --- /dev/null +++ b/vendor/github.com/Shopify/sarama/broker.go @@ -0,0 +1,674 @@ +package sarama + +import ( + "crypto/tls" + "encoding/binary" + "fmt" + "io" + "net" + "strconv" + "sync" + "sync/atomic" + "time" + + "github.com/rcrowley/go-metrics" +) + +// Broker represents a single Kafka broker connection. All operations on this object are entirely concurrency-safe. +type Broker struct { + id int32 + addr string + + conf *Config + correlationID int32 + conn net.Conn + connErr error + lock sync.Mutex + opened int32 + + responses chan responsePromise + done chan bool + + incomingByteRate metrics.Meter + requestRate metrics.Meter + requestSize metrics.Histogram + requestLatency metrics.Histogram + outgoingByteRate metrics.Meter + responseRate metrics.Meter + responseSize metrics.Histogram + brokerIncomingByteRate metrics.Meter + brokerRequestRate metrics.Meter + brokerRequestSize metrics.Histogram + brokerRequestLatency metrics.Histogram + brokerOutgoingByteRate metrics.Meter + brokerResponseRate metrics.Meter + brokerResponseSize metrics.Histogram +} + +type responsePromise struct { + requestTime time.Time + correlationID int32 + packets chan []byte + errors chan error +} + +// NewBroker creates and returns a Broker targeting the given host:port address. +// This does not attempt to actually connect, you have to call Open() for that. +func NewBroker(addr string) *Broker { + return &Broker{id: -1, addr: addr} +} + +// Open tries to connect to the Broker if it is not already connected or connecting, but does not block +// waiting for the connection to complete. This means that any subsequent operations on the broker will +// block waiting for the connection to succeed or fail. To get the effect of a fully synchronous Open call, +// follow it by a call to Connected(). The only errors Open will return directly are ConfigurationError or +// AlreadyConnected. If conf is nil, the result of NewConfig() is used. +func (b *Broker) Open(conf *Config) error { + if !atomic.CompareAndSwapInt32(&b.opened, 0, 1) { + return ErrAlreadyConnected + } + + if conf == nil { + conf = NewConfig() + } + + err := conf.Validate() + if err != nil { + return err + } + + b.lock.Lock() + + go withRecover(func() { + defer b.lock.Unlock() + + dialer := net.Dialer{ + Timeout: conf.Net.DialTimeout, + KeepAlive: conf.Net.KeepAlive, + } + + if conf.Net.TLS.Enable { + b.conn, b.connErr = tls.DialWithDialer(&dialer, "tcp", b.addr, conf.Net.TLS.Config) + } else { + b.conn, b.connErr = dialer.Dial("tcp", b.addr) + } + if b.connErr != nil { + Logger.Printf("Failed to connect to broker %s: %s\n", b.addr, b.connErr) + b.conn = nil + atomic.StoreInt32(&b.opened, 0) + return + } + b.conn = newBufConn(b.conn) + + b.conf = conf + + // Create or reuse the global metrics shared between brokers + b.incomingByteRate = metrics.GetOrRegisterMeter("incoming-byte-rate", conf.MetricRegistry) + b.requestRate = metrics.GetOrRegisterMeter("request-rate", conf.MetricRegistry) + b.requestSize = getOrRegisterHistogram("request-size", conf.MetricRegistry) + b.requestLatency = getOrRegisterHistogram("request-latency-in-ms", conf.MetricRegistry) + b.outgoingByteRate = metrics.GetOrRegisterMeter("outgoing-byte-rate", conf.MetricRegistry) + b.responseRate = metrics.GetOrRegisterMeter("response-rate", conf.MetricRegistry) + b.responseSize = getOrRegisterHistogram("response-size", conf.MetricRegistry) + // Do not gather metrics for seeded broker (only used during bootstrap) because they share + // the same id (-1) and are already exposed through the global metrics above + if b.id >= 0 { + b.brokerIncomingByteRate = getOrRegisterBrokerMeter("incoming-byte-rate", b, conf.MetricRegistry) + b.brokerRequestRate = getOrRegisterBrokerMeter("request-rate", b, conf.MetricRegistry) + b.brokerRequestSize = getOrRegisterBrokerHistogram("request-size", b, conf.MetricRegistry) + b.brokerRequestLatency = getOrRegisterBrokerHistogram("request-latency-in-ms", b, conf.MetricRegistry) + b.brokerOutgoingByteRate = getOrRegisterBrokerMeter("outgoing-byte-rate", b, conf.MetricRegistry) + b.brokerResponseRate = getOrRegisterBrokerMeter("response-rate", b, conf.MetricRegistry) + b.brokerResponseSize = getOrRegisterBrokerHistogram("response-size", b, conf.MetricRegistry) + } + + if conf.Net.SASL.Enable { + b.connErr = b.sendAndReceiveSASLPlainAuth() + if b.connErr != nil { + err = b.conn.Close() + if err == nil { + Logger.Printf("Closed connection to broker %s\n", b.addr) + } else { + Logger.Printf("Error while closing connection to broker %s: %s\n", b.addr, err) + } + b.conn = nil + atomic.StoreInt32(&b.opened, 0) + return + } + } + + b.done = make(chan bool) + b.responses = make(chan responsePromise, b.conf.Net.MaxOpenRequests-1) + + if b.id >= 0 { + Logger.Printf("Connected to broker at %s (registered as #%d)\n", b.addr, b.id) + } else { + Logger.Printf("Connected to broker at %s (unregistered)\n", b.addr) + } + go withRecover(b.responseReceiver) + }) + + return nil +} + +// Connected returns true if the broker is connected and false otherwise. If the broker is not +// connected but it had tried to connect, the error from that connection attempt is also returned. +func (b *Broker) Connected() (bool, error) { + b.lock.Lock() + defer b.lock.Unlock() + + return b.conn != nil, b.connErr +} + +func (b *Broker) Close() error { + b.lock.Lock() + defer b.lock.Unlock() + + if b.conn == nil { + return ErrNotConnected + } + + close(b.responses) + <-b.done + + err := b.conn.Close() + + b.conn = nil + b.connErr = nil + b.done = nil + b.responses = nil + + if err == nil { + Logger.Printf("Closed connection to broker %s\n", b.addr) + } else { + Logger.Printf("Error while closing connection to broker %s: %s\n", b.addr, err) + } + + atomic.StoreInt32(&b.opened, 0) + + return err +} + +// ID returns the broker ID retrieved from Kafka's metadata, or -1 if that is not known. +func (b *Broker) ID() int32 { + return b.id +} + +// Addr returns the broker address as either retrieved from Kafka's metadata or passed to NewBroker. +func (b *Broker) Addr() string { + return b.addr +} + +func (b *Broker) GetMetadata(request *MetadataRequest) (*MetadataResponse, error) { + response := new(MetadataResponse) + + err := b.sendAndReceive(request, response) + + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) GetConsumerMetadata(request *ConsumerMetadataRequest) (*ConsumerMetadataResponse, error) { + response := new(ConsumerMetadataResponse) + + err := b.sendAndReceive(request, response) + + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) GetAvailableOffsets(request *OffsetRequest) (*OffsetResponse, error) { + response := new(OffsetResponse) + + err := b.sendAndReceive(request, response) + + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) Produce(request *ProduceRequest) (*ProduceResponse, error) { + var response *ProduceResponse + var err error + + if request.RequiredAcks == NoResponse { + err = b.sendAndReceive(request, nil) + } else { + response = new(ProduceResponse) + err = b.sendAndReceive(request, response) + } + + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) Fetch(request *FetchRequest) (*FetchResponse, error) { + response := new(FetchResponse) + + err := b.sendAndReceive(request, response) + + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) CommitOffset(request *OffsetCommitRequest) (*OffsetCommitResponse, error) { + response := new(OffsetCommitResponse) + + err := b.sendAndReceive(request, response) + + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) FetchOffset(request *OffsetFetchRequest) (*OffsetFetchResponse, error) { + response := new(OffsetFetchResponse) + + err := b.sendAndReceive(request, response) + + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) JoinGroup(request *JoinGroupRequest) (*JoinGroupResponse, error) { + response := new(JoinGroupResponse) + + err := b.sendAndReceive(request, response) + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) SyncGroup(request *SyncGroupRequest) (*SyncGroupResponse, error) { + response := new(SyncGroupResponse) + + err := b.sendAndReceive(request, response) + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) LeaveGroup(request *LeaveGroupRequest) (*LeaveGroupResponse, error) { + response := new(LeaveGroupResponse) + + err := b.sendAndReceive(request, response) + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) Heartbeat(request *HeartbeatRequest) (*HeartbeatResponse, error) { + response := new(HeartbeatResponse) + + err := b.sendAndReceive(request, response) + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) ListGroups(request *ListGroupsRequest) (*ListGroupsResponse, error) { + response := new(ListGroupsResponse) + + err := b.sendAndReceive(request, response) + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) DescribeGroups(request *DescribeGroupsRequest) (*DescribeGroupsResponse, error) { + response := new(DescribeGroupsResponse) + + err := b.sendAndReceive(request, response) + if err != nil { + return nil, err + } + + return response, nil +} + +func (b *Broker) send(rb protocolBody, promiseResponse bool) (*responsePromise, error) { + b.lock.Lock() + defer b.lock.Unlock() + + if b.conn == nil { + if b.connErr != nil { + return nil, b.connErr + } + return nil, ErrNotConnected + } + + if !b.conf.Version.IsAtLeast(rb.requiredVersion()) { + return nil, ErrUnsupportedVersion + } + + req := &request{correlationID: b.correlationID, clientID: b.conf.ClientID, body: rb} + buf, err := encode(req, b.conf.MetricRegistry) + if err != nil { + return nil, err + } + + err = b.conn.SetWriteDeadline(time.Now().Add(b.conf.Net.WriteTimeout)) + if err != nil { + return nil, err + } + + requestTime := time.Now() + bytes, err := b.conn.Write(buf) + b.updateOutgoingCommunicationMetrics(bytes) + if err != nil { + return nil, err + } + b.correlationID++ + + if !promiseResponse { + // Record request latency without the response + b.updateRequestLatencyMetrics(time.Since(requestTime)) + return nil, nil + } + + promise := responsePromise{requestTime, req.correlationID, make(chan []byte), make(chan error)} + b.responses <- promise + + return &promise, nil +} + +func (b *Broker) sendAndReceive(req protocolBody, res versionedDecoder) error { + promise, err := b.send(req, res != nil) + + if err != nil { + return err + } + + if promise == nil { + return nil + } + + select { + case buf := <-promise.packets: + return versionedDecode(buf, res, req.version()) + case err = <-promise.errors: + return err + } +} + +func (b *Broker) decode(pd packetDecoder) (err error) { + b.id, err = pd.getInt32() + if err != nil { + return err + } + + host, err := pd.getString() + if err != nil { + return err + } + + port, err := pd.getInt32() + if err != nil { + return err + } + + b.addr = net.JoinHostPort(host, fmt.Sprint(port)) + if _, _, err := net.SplitHostPort(b.addr); err != nil { + return err + } + + return nil +} + +func (b *Broker) encode(pe packetEncoder) (err error) { + + host, portstr, err := net.SplitHostPort(b.addr) + if err != nil { + return err + } + port, err := strconv.Atoi(portstr) + if err != nil { + return err + } + + pe.putInt32(b.id) + + err = pe.putString(host) + if err != nil { + return err + } + + pe.putInt32(int32(port)) + + return nil +} + +func (b *Broker) responseReceiver() { + var dead error + header := make([]byte, 8) + for response := range b.responses { + if dead != nil { + response.errors <- dead + continue + } + + err := b.conn.SetReadDeadline(time.Now().Add(b.conf.Net.ReadTimeout)) + if err != nil { + dead = err + response.errors <- err + continue + } + + bytesReadHeader, err := io.ReadFull(b.conn, header) + requestLatency := time.Since(response.requestTime) + if err != nil { + b.updateIncomingCommunicationMetrics(bytesReadHeader, requestLatency) + dead = err + response.errors <- err + continue + } + + decodedHeader := responseHeader{} + err = decode(header, &decodedHeader) + if err != nil { + b.updateIncomingCommunicationMetrics(bytesReadHeader, requestLatency) + dead = err + response.errors <- err + continue + } + if decodedHeader.correlationID != response.correlationID { + b.updateIncomingCommunicationMetrics(bytesReadHeader, requestLatency) + // TODO if decoded ID < cur ID, discard until we catch up + // TODO if decoded ID > cur ID, save it so when cur ID catches up we have a response + dead = PacketDecodingError{fmt.Sprintf("correlation ID didn't match, wanted %d, got %d", response.correlationID, decodedHeader.correlationID)} + response.errors <- dead + continue + } + + buf := make([]byte, decodedHeader.length-4) + bytesReadBody, err := io.ReadFull(b.conn, buf) + b.updateIncomingCommunicationMetrics(bytesReadHeader+bytesReadBody, requestLatency) + if err != nil { + dead = err + response.errors <- err + continue + } + + response.packets <- buf + } + close(b.done) +} + +func (b *Broker) sendAndReceiveSASLPlainHandshake() error { + rb := &SaslHandshakeRequest{"PLAIN"} + req := &request{correlationID: b.correlationID, clientID: b.conf.ClientID, body: rb} + buf, err := encode(req, b.conf.MetricRegistry) + if err != nil { + return err + } + + err = b.conn.SetWriteDeadline(time.Now().Add(b.conf.Net.WriteTimeout)) + if err != nil { + return err + } + + requestTime := time.Now() + bytes, err := b.conn.Write(buf) + b.updateOutgoingCommunicationMetrics(bytes) + if err != nil { + Logger.Printf("Failed to send SASL handshake %s: %s\n", b.addr, err.Error()) + return err + } + b.correlationID++ + //wait for the response + header := make([]byte, 8) // response header + _, err = io.ReadFull(b.conn, header) + if err != nil { + Logger.Printf("Failed to read SASL handshake header : %s\n", err.Error()) + return err + } + length := binary.BigEndian.Uint32(header[:4]) + payload := make([]byte, length-4) + n, err := io.ReadFull(b.conn, payload) + if err != nil { + Logger.Printf("Failed to read SASL handshake payload : %s\n", err.Error()) + return err + } + b.updateIncomingCommunicationMetrics(n+8, time.Since(requestTime)) + res := &SaslHandshakeResponse{} + err = versionedDecode(payload, res, 0) + if err != nil { + Logger.Printf("Failed to parse SASL handshake : %s\n", err.Error()) + return err + } + if res.Err != ErrNoError { + Logger.Printf("Invalid SASL Mechanism : %s\n", res.Err.Error()) + return res.Err + } + Logger.Print("Successful SASL handshake") + return nil +} + +// Kafka 0.10.0 plans to support SASL Plain and Kerberos as per PR #812 (KIP-43)/(JIRA KAFKA-3149) +// Some hosted kafka services such as IBM Message Hub already offer SASL/PLAIN auth with Kafka 0.9 +// +// In SASL Plain, Kafka expects the auth header to be in the following format +// Message format (from https://tools.ietf.org/html/rfc4616): +// +// message = [authzid] UTF8NUL authcid UTF8NUL passwd +// authcid = 1*SAFE ; MUST accept up to 255 octets +// authzid = 1*SAFE ; MUST accept up to 255 octets +// passwd = 1*SAFE ; MUST accept up to 255 octets +// UTF8NUL = %x00 ; UTF-8 encoded NUL character +// +// SAFE = UTF1 / UTF2 / UTF3 / UTF4 +// ;; any UTF-8 encoded Unicode character except NUL +// +// When credentials are valid, Kafka returns a 4 byte array of null characters. +// When credentials are invalid, Kafka closes the connection. This does not seem to be the ideal way +// of responding to bad credentials but thats how its being done today. +func (b *Broker) sendAndReceiveSASLPlainAuth() error { + if b.conf.Net.SASL.Handshake { + handshakeErr := b.sendAndReceiveSASLPlainHandshake() + if handshakeErr != nil { + Logger.Printf("Error while performing SASL handshake %s\n", b.addr) + return handshakeErr + } + } + length := 1 + len(b.conf.Net.SASL.User) + 1 + len(b.conf.Net.SASL.Password) + authBytes := make([]byte, length+4) //4 byte length header + auth data + binary.BigEndian.PutUint32(authBytes, uint32(length)) + copy(authBytes[4:], []byte("\x00"+b.conf.Net.SASL.User+"\x00"+b.conf.Net.SASL.Password)) + + err := b.conn.SetWriteDeadline(time.Now().Add(b.conf.Net.WriteTimeout)) + if err != nil { + Logger.Printf("Failed to set write deadline when doing SASL auth with broker %s: %s\n", b.addr, err.Error()) + return err + } + + requestTime := time.Now() + bytesWritten, err := b.conn.Write(authBytes) + b.updateOutgoingCommunicationMetrics(bytesWritten) + if err != nil { + Logger.Printf("Failed to write SASL auth header to broker %s: %s\n", b.addr, err.Error()) + return err + } + + header := make([]byte, 4) + n, err := io.ReadFull(b.conn, header) + b.updateIncomingCommunicationMetrics(n, time.Since(requestTime)) + // If the credentials are valid, we would get a 4 byte response filled with null characters. + // Otherwise, the broker closes the connection and we get an EOF + if err != nil { + Logger.Printf("Failed to read response while authenticating with SASL to broker %s: %s\n", b.addr, err.Error()) + return err + } + + Logger.Printf("SASL authentication successful with broker %s:%v - %v\n", b.addr, n, header) + return nil +} + +func (b *Broker) updateIncomingCommunicationMetrics(bytes int, requestLatency time.Duration) { + b.updateRequestLatencyMetrics(requestLatency) + b.responseRate.Mark(1) + if b.brokerResponseRate != nil { + b.brokerResponseRate.Mark(1) + } + responseSize := int64(bytes) + b.incomingByteRate.Mark(responseSize) + if b.brokerIncomingByteRate != nil { + b.brokerIncomingByteRate.Mark(responseSize) + } + b.responseSize.Update(responseSize) + if b.brokerResponseSize != nil { + b.brokerResponseSize.Update(responseSize) + } +} + +func (b *Broker) updateRequestLatencyMetrics(requestLatency time.Duration) { + requestLatencyInMs := int64(requestLatency / time.Millisecond) + b.requestLatency.Update(requestLatencyInMs) + if b.brokerRequestLatency != nil { + b.brokerRequestLatency.Update(requestLatencyInMs) + } +} + +func (b *Broker) updateOutgoingCommunicationMetrics(bytes int) { + b.requestRate.Mark(1) + if b.brokerRequestRate != nil { + b.brokerRequestRate.Mark(1) + } + requestSize := int64(bytes) + b.outgoingByteRate.Mark(requestSize) + if b.brokerOutgoingByteRate != nil { + b.brokerOutgoingByteRate.Mark(requestSize) + } + b.requestSize.Update(requestSize) + if b.brokerRequestSize != nil { + b.brokerRequestSize.Update(requestSize) + } +} diff --git a/vendor/github.com/Shopify/sarama/client.go b/vendor/github.com/Shopify/sarama/client.go new file mode 100644 index 00000000..210dd9a3 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/client.go @@ -0,0 +1,749 @@ +package sarama + +import ( + "math/rand" + "sort" + "sync" + "time" +) + +// Client is a generic Kafka client. It manages connections to one or more Kafka brokers. +// You MUST call Close() on a client to avoid leaks, it will not be garbage-collected +// automatically when it passes out of scope. It is safe to share a client amongst many +// users, however Kafka will process requests from a single client strictly in serial, +// so it is generally more efficient to use the default one client per producer/consumer. +type Client interface { + // Config returns the Config struct of the client. This struct should not be + // altered after it has been created. + Config() *Config + + // Brokers returns the current set of active brokers as retrieved from cluster metadata. + Brokers() []*Broker + + // Topics returns the set of available topics as retrieved from cluster metadata. + Topics() ([]string, error) + + // Partitions returns the sorted list of all partition IDs for the given topic. + Partitions(topic string) ([]int32, error) + + // WritablePartitions returns the sorted list of all writable partition IDs for + // the given topic, where "writable" means "having a valid leader accepting + // writes". + WritablePartitions(topic string) ([]int32, error) + + // Leader returns the broker object that is the leader of the current + // topic/partition, as determined by querying the cluster metadata. + Leader(topic string, partitionID int32) (*Broker, error) + + // Replicas returns the set of all replica IDs for the given partition. + Replicas(topic string, partitionID int32) ([]int32, error) + + // RefreshMetadata takes a list of topics and queries the cluster to refresh the + // available metadata for those topics. If no topics are provided, it will refresh + // metadata for all topics. + RefreshMetadata(topics ...string) error + + // GetOffset queries the cluster to get the most recent available offset at the + // given time on the topic/partition combination. Time should be OffsetOldest for + // the earliest available offset, OffsetNewest for the offset of the message that + // will be produced next, or a time. + GetOffset(topic string, partitionID int32, time int64) (int64, error) + + // Coordinator returns the coordinating broker for a consumer group. It will + // return a locally cached value if it's available. You can call + // RefreshCoordinator to update the cached value. This function only works on + // Kafka 0.8.2 and higher. + Coordinator(consumerGroup string) (*Broker, error) + + // RefreshCoordinator retrieves the coordinator for a consumer group and stores it + // in local cache. This function only works on Kafka 0.8.2 and higher. + RefreshCoordinator(consumerGroup string) error + + // Close shuts down all broker connections managed by this client. It is required + // to call this function before a client object passes out of scope, as it will + // otherwise leak memory. You must close any Producers or Consumers using a client + // before you close the client. + Close() error + + // Closed returns true if the client has already had Close called on it + Closed() bool +} + +const ( + // OffsetNewest stands for the log head offset, i.e. the offset that will be + // assigned to the next message that will be produced to the partition. You + // can send this to a client's GetOffset method to get this offset, or when + // calling ConsumePartition to start consuming new messages. + OffsetNewest int64 = -1 + // OffsetOldest stands for the oldest offset available on the broker for a + // partition. You can send this to a client's GetOffset method to get this + // offset, or when calling ConsumePartition to start consuming from the + // oldest offset that is still available on the broker. + OffsetOldest int64 = -2 +) + +type client struct { + conf *Config + closer, closed chan none // for shutting down background metadata updater + + // the broker addresses given to us through the constructor are not guaranteed to be returned in + // the cluster metadata (I *think* it only returns brokers who are currently leading partitions?) + // so we store them separately + seedBrokers []*Broker + deadSeeds []*Broker + + brokers map[int32]*Broker // maps broker ids to brokers + metadata map[string]map[int32]*PartitionMetadata // maps topics to partition ids to metadata + coordinators map[string]int32 // Maps consumer group names to coordinating broker IDs + + // If the number of partitions is large, we can get some churn calling cachedPartitions, + // so the result is cached. It is important to update this value whenever metadata is changed + cachedPartitionsResults map[string][maxPartitionIndex][]int32 + + lock sync.RWMutex // protects access to the maps that hold cluster state. +} + +// NewClient creates a new Client. It connects to one of the given broker addresses +// and uses that broker to automatically fetch metadata on the rest of the kafka cluster. If metadata cannot +// be retrieved from any of the given broker addresses, the client is not created. +func NewClient(addrs []string, conf *Config) (Client, error) { + Logger.Println("Initializing new client") + + if conf == nil { + conf = NewConfig() + } + + if err := conf.Validate(); err != nil { + return nil, err + } + + if len(addrs) < 1 { + return nil, ConfigurationError("You must provide at least one broker address") + } + + client := &client{ + conf: conf, + closer: make(chan none), + closed: make(chan none), + brokers: make(map[int32]*Broker), + metadata: make(map[string]map[int32]*PartitionMetadata), + cachedPartitionsResults: make(map[string][maxPartitionIndex][]int32), + coordinators: make(map[string]int32), + } + + random := rand.New(rand.NewSource(time.Now().UnixNano())) + for _, index := range random.Perm(len(addrs)) { + client.seedBrokers = append(client.seedBrokers, NewBroker(addrs[index])) + } + + // do an initial fetch of all cluster metadata by specifying an empty list of topics + err := client.RefreshMetadata() + switch err { + case nil: + break + case ErrLeaderNotAvailable, ErrReplicaNotAvailable, ErrTopicAuthorizationFailed, ErrClusterAuthorizationFailed: + // indicates that maybe part of the cluster is down, but is not fatal to creating the client + Logger.Println(err) + default: + close(client.closed) // we haven't started the background updater yet, so we have to do this manually + _ = client.Close() + return nil, err + } + go withRecover(client.backgroundMetadataUpdater) + + Logger.Println("Successfully initialized new client") + + return client, nil +} + +func (client *client) Config() *Config { + return client.conf +} + +func (client *client) Brokers() []*Broker { + client.lock.RLock() + defer client.lock.RUnlock() + brokers := make([]*Broker, 0) + for _, broker := range client.brokers { + brokers = append(brokers, broker) + } + return brokers +} + +func (client *client) Close() error { + if client.Closed() { + // Chances are this is being called from a defer() and the error will go unobserved + // so we go ahead and log the event in this case. + Logger.Printf("Close() called on already closed client") + return ErrClosedClient + } + + // shutdown and wait for the background thread before we take the lock, to avoid races + close(client.closer) + <-client.closed + + client.lock.Lock() + defer client.lock.Unlock() + Logger.Println("Closing Client") + + for _, broker := range client.brokers { + safeAsyncClose(broker) + } + + for _, broker := range client.seedBrokers { + safeAsyncClose(broker) + } + + client.brokers = nil + client.metadata = nil + + return nil +} + +func (client *client) Closed() bool { + return client.brokers == nil +} + +func (client *client) Topics() ([]string, error) { + if client.Closed() { + return nil, ErrClosedClient + } + + client.lock.RLock() + defer client.lock.RUnlock() + + ret := make([]string, 0, len(client.metadata)) + for topic := range client.metadata { + ret = append(ret, topic) + } + + return ret, nil +} + +func (client *client) Partitions(topic string) ([]int32, error) { + if client.Closed() { + return nil, ErrClosedClient + } + + partitions := client.cachedPartitions(topic, allPartitions) + + if len(partitions) == 0 { + err := client.RefreshMetadata(topic) + if err != nil { + return nil, err + } + partitions = client.cachedPartitions(topic, allPartitions) + } + + if partitions == nil { + return nil, ErrUnknownTopicOrPartition + } + + return partitions, nil +} + +func (client *client) WritablePartitions(topic string) ([]int32, error) { + if client.Closed() { + return nil, ErrClosedClient + } + + partitions := client.cachedPartitions(topic, writablePartitions) + + // len==0 catches when it's nil (no such topic) and the odd case when every single + // partition is undergoing leader election simultaneously. Callers have to be able to handle + // this function returning an empty slice (which is a valid return value) but catching it + // here the first time (note we *don't* catch it below where we return ErrUnknownTopicOrPartition) triggers + // a metadata refresh as a nicety so callers can just try again and don't have to manually + // trigger a refresh (otherwise they'd just keep getting a stale cached copy). + if len(partitions) == 0 { + err := client.RefreshMetadata(topic) + if err != nil { + return nil, err + } + partitions = client.cachedPartitions(topic, writablePartitions) + } + + if partitions == nil { + return nil, ErrUnknownTopicOrPartition + } + + return partitions, nil +} + +func (client *client) Replicas(topic string, partitionID int32) ([]int32, error) { + if client.Closed() { + return nil, ErrClosedClient + } + + metadata := client.cachedMetadata(topic, partitionID) + + if metadata == nil { + err := client.RefreshMetadata(topic) + if err != nil { + return nil, err + } + metadata = client.cachedMetadata(topic, partitionID) + } + + if metadata == nil { + return nil, ErrUnknownTopicOrPartition + } + + if metadata.Err == ErrReplicaNotAvailable { + return nil, metadata.Err + } + return dupeAndSort(metadata.Replicas), nil +} + +func (client *client) Leader(topic string, partitionID int32) (*Broker, error) { + if client.Closed() { + return nil, ErrClosedClient + } + + leader, err := client.cachedLeader(topic, partitionID) + + if leader == nil { + err = client.RefreshMetadata(topic) + if err != nil { + return nil, err + } + leader, err = client.cachedLeader(topic, partitionID) + } + + return leader, err +} + +func (client *client) RefreshMetadata(topics ...string) error { + if client.Closed() { + return ErrClosedClient + } + + // Prior to 0.8.2, Kafka will throw exceptions on an empty topic and not return a proper + // error. This handles the case by returning an error instead of sending it + // off to Kafka. See: https://github.com/Shopify/sarama/pull/38#issuecomment-26362310 + for _, topic := range topics { + if len(topic) == 0 { + return ErrInvalidTopic // this is the error that 0.8.2 and later correctly return + } + } + + return client.tryRefreshMetadata(topics, client.conf.Metadata.Retry.Max) +} + +func (client *client) GetOffset(topic string, partitionID int32, time int64) (int64, error) { + if client.Closed() { + return -1, ErrClosedClient + } + + offset, err := client.getOffset(topic, partitionID, time) + + if err != nil { + if err := client.RefreshMetadata(topic); err != nil { + return -1, err + } + return client.getOffset(topic, partitionID, time) + } + + return offset, err +} + +func (client *client) Coordinator(consumerGroup string) (*Broker, error) { + if client.Closed() { + return nil, ErrClosedClient + } + + coordinator := client.cachedCoordinator(consumerGroup) + + if coordinator == nil { + if err := client.RefreshCoordinator(consumerGroup); err != nil { + return nil, err + } + coordinator = client.cachedCoordinator(consumerGroup) + } + + if coordinator == nil { + return nil, ErrConsumerCoordinatorNotAvailable + } + + _ = coordinator.Open(client.conf) + return coordinator, nil +} + +func (client *client) RefreshCoordinator(consumerGroup string) error { + if client.Closed() { + return ErrClosedClient + } + + response, err := client.getConsumerMetadata(consumerGroup, client.conf.Metadata.Retry.Max) + if err != nil { + return err + } + + client.lock.Lock() + defer client.lock.Unlock() + client.registerBroker(response.Coordinator) + client.coordinators[consumerGroup] = response.Coordinator.ID() + return nil +} + +// private broker management helpers + +// registerBroker makes sure a broker received by a Metadata or Coordinator request is registered +// in the brokers map. It returns the broker that is registered, which may be the provided broker, +// or a previously registered Broker instance. You must hold the write lock before calling this function. +func (client *client) registerBroker(broker *Broker) { + if client.brokers[broker.ID()] == nil { + client.brokers[broker.ID()] = broker + Logger.Printf("client/brokers registered new broker #%d at %s", broker.ID(), broker.Addr()) + } else if broker.Addr() != client.brokers[broker.ID()].Addr() { + safeAsyncClose(client.brokers[broker.ID()]) + client.brokers[broker.ID()] = broker + Logger.Printf("client/brokers replaced registered broker #%d with %s", broker.ID(), broker.Addr()) + } +} + +// deregisterBroker removes a broker from the seedsBroker list, and if it's +// not the seedbroker, removes it from brokers map completely. +func (client *client) deregisterBroker(broker *Broker) { + client.lock.Lock() + defer client.lock.Unlock() + + if len(client.seedBrokers) > 0 && broker == client.seedBrokers[0] { + client.deadSeeds = append(client.deadSeeds, broker) + client.seedBrokers = client.seedBrokers[1:] + } else { + // we do this so that our loop in `tryRefreshMetadata` doesn't go on forever, + // but we really shouldn't have to; once that loop is made better this case can be + // removed, and the function generally can be renamed from `deregisterBroker` to + // `nextSeedBroker` or something + Logger.Printf("client/brokers deregistered broker #%d at %s", broker.ID(), broker.Addr()) + delete(client.brokers, broker.ID()) + } +} + +func (client *client) resurrectDeadBrokers() { + client.lock.Lock() + defer client.lock.Unlock() + + Logger.Printf("client/brokers resurrecting %d dead seed brokers", len(client.deadSeeds)) + client.seedBrokers = append(client.seedBrokers, client.deadSeeds...) + client.deadSeeds = nil +} + +func (client *client) any() *Broker { + client.lock.RLock() + defer client.lock.RUnlock() + + if len(client.seedBrokers) > 0 { + _ = client.seedBrokers[0].Open(client.conf) + return client.seedBrokers[0] + } + + // not guaranteed to be random *or* deterministic + for _, broker := range client.brokers { + _ = broker.Open(client.conf) + return broker + } + + return nil +} + +// private caching/lazy metadata helpers + +type partitionType int + +const ( + allPartitions partitionType = iota + writablePartitions + // If you add any more types, update the partition cache in update() + + // Ensure this is the last partition type value + maxPartitionIndex +) + +func (client *client) cachedMetadata(topic string, partitionID int32) *PartitionMetadata { + client.lock.RLock() + defer client.lock.RUnlock() + + partitions := client.metadata[topic] + if partitions != nil { + return partitions[partitionID] + } + + return nil +} + +func (client *client) cachedPartitions(topic string, partitionSet partitionType) []int32 { + client.lock.RLock() + defer client.lock.RUnlock() + + partitions, exists := client.cachedPartitionsResults[topic] + + if !exists { + return nil + } + return partitions[partitionSet] +} + +func (client *client) setPartitionCache(topic string, partitionSet partitionType) []int32 { + partitions := client.metadata[topic] + + if partitions == nil { + return nil + } + + ret := make([]int32, 0, len(partitions)) + for _, partition := range partitions { + if partitionSet == writablePartitions && partition.Err == ErrLeaderNotAvailable { + continue + } + ret = append(ret, partition.ID) + } + + sort.Sort(int32Slice(ret)) + return ret +} + +func (client *client) cachedLeader(topic string, partitionID int32) (*Broker, error) { + client.lock.RLock() + defer client.lock.RUnlock() + + partitions := client.metadata[topic] + if partitions != nil { + metadata, ok := partitions[partitionID] + if ok { + if metadata.Err == ErrLeaderNotAvailable { + return nil, ErrLeaderNotAvailable + } + b := client.brokers[metadata.Leader] + if b == nil { + return nil, ErrLeaderNotAvailable + } + _ = b.Open(client.conf) + return b, nil + } + } + + return nil, ErrUnknownTopicOrPartition +} + +func (client *client) getOffset(topic string, partitionID int32, time int64) (int64, error) { + broker, err := client.Leader(topic, partitionID) + if err != nil { + return -1, err + } + + request := &OffsetRequest{} + if client.conf.Version.IsAtLeast(V0_10_1_0) { + request.Version = 1 + } + request.AddBlock(topic, partitionID, time, 1) + + response, err := broker.GetAvailableOffsets(request) + if err != nil { + _ = broker.Close() + return -1, err + } + + block := response.GetBlock(topic, partitionID) + if block == nil { + _ = broker.Close() + return -1, ErrIncompleteResponse + } + if block.Err != ErrNoError { + return -1, block.Err + } + if len(block.Offsets) != 1 { + return -1, ErrOffsetOutOfRange + } + + return block.Offsets[0], nil +} + +// core metadata update logic + +func (client *client) backgroundMetadataUpdater() { + defer close(client.closed) + + if client.conf.Metadata.RefreshFrequency == time.Duration(0) { + return + } + + ticker := time.NewTicker(client.conf.Metadata.RefreshFrequency) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + if err := client.RefreshMetadata(); err != nil { + Logger.Println("Client background metadata update:", err) + } + case <-client.closer: + return + } + } +} + +func (client *client) tryRefreshMetadata(topics []string, attemptsRemaining int) error { + retry := func(err error) error { + if attemptsRemaining > 0 { + Logger.Printf("client/metadata retrying after %dms... (%d attempts remaining)\n", client.conf.Metadata.Retry.Backoff/time.Millisecond, attemptsRemaining) + time.Sleep(client.conf.Metadata.Retry.Backoff) + return client.tryRefreshMetadata(topics, attemptsRemaining-1) + } + return err + } + + for broker := client.any(); broker != nil; broker = client.any() { + if len(topics) > 0 { + Logger.Printf("client/metadata fetching metadata for %v from broker %s\n", topics, broker.addr) + } else { + Logger.Printf("client/metadata fetching metadata for all topics from broker %s\n", broker.addr) + } + response, err := broker.GetMetadata(&MetadataRequest{Topics: topics}) + + switch err.(type) { + case nil: + // valid response, use it + shouldRetry, err := client.updateMetadata(response) + if shouldRetry { + Logger.Println("client/metadata found some partitions to be leaderless") + return retry(err) // note: err can be nil + } + return err + + case PacketEncodingError: + // didn't even send, return the error + return err + default: + // some other error, remove that broker and try again + Logger.Println("client/metadata got error from broker while fetching metadata:", err) + _ = broker.Close() + client.deregisterBroker(broker) + } + } + + Logger.Println("client/metadata no available broker to send metadata request to") + client.resurrectDeadBrokers() + return retry(ErrOutOfBrokers) +} + +// if no fatal error, returns a list of topics that need retrying due to ErrLeaderNotAvailable +func (client *client) updateMetadata(data *MetadataResponse) (retry bool, err error) { + client.lock.Lock() + defer client.lock.Unlock() + + // For all the brokers we received: + // - if it is a new ID, save it + // - if it is an existing ID, but the address we have is stale, discard the old one and save it + // - otherwise ignore it, replacing our existing one would just bounce the connection + for _, broker := range data.Brokers { + client.registerBroker(broker) + } + + for _, topic := range data.Topics { + delete(client.metadata, topic.Name) + delete(client.cachedPartitionsResults, topic.Name) + + switch topic.Err { + case ErrNoError: + break + case ErrInvalidTopic, ErrTopicAuthorizationFailed: // don't retry, don't store partial results + err = topic.Err + continue + case ErrUnknownTopicOrPartition: // retry, do not store partial partition results + err = topic.Err + retry = true + continue + case ErrLeaderNotAvailable: // retry, but store partial partition results + retry = true + break + default: // don't retry, don't store partial results + Logger.Printf("Unexpected topic-level metadata error: %s", topic.Err) + err = topic.Err + continue + } + + client.metadata[topic.Name] = make(map[int32]*PartitionMetadata, len(topic.Partitions)) + for _, partition := range topic.Partitions { + client.metadata[topic.Name][partition.ID] = partition + if partition.Err == ErrLeaderNotAvailable { + retry = true + } + } + + var partitionCache [maxPartitionIndex][]int32 + partitionCache[allPartitions] = client.setPartitionCache(topic.Name, allPartitions) + partitionCache[writablePartitions] = client.setPartitionCache(topic.Name, writablePartitions) + client.cachedPartitionsResults[topic.Name] = partitionCache + } + + return +} + +func (client *client) cachedCoordinator(consumerGroup string) *Broker { + client.lock.RLock() + defer client.lock.RUnlock() + if coordinatorID, ok := client.coordinators[consumerGroup]; ok { + return client.brokers[coordinatorID] + } + return nil +} + +func (client *client) getConsumerMetadata(consumerGroup string, attemptsRemaining int) (*ConsumerMetadataResponse, error) { + retry := func(err error) (*ConsumerMetadataResponse, error) { + if attemptsRemaining > 0 { + Logger.Printf("client/coordinator retrying after %dms... (%d attempts remaining)\n", client.conf.Metadata.Retry.Backoff/time.Millisecond, attemptsRemaining) + time.Sleep(client.conf.Metadata.Retry.Backoff) + return client.getConsumerMetadata(consumerGroup, attemptsRemaining-1) + } + return nil, err + } + + for broker := client.any(); broker != nil; broker = client.any() { + Logger.Printf("client/coordinator requesting coordinator for consumergroup %s from %s\n", consumerGroup, broker.Addr()) + + request := new(ConsumerMetadataRequest) + request.ConsumerGroup = consumerGroup + + response, err := broker.GetConsumerMetadata(request) + + if err != nil { + Logger.Printf("client/coordinator request to broker %s failed: %s\n", broker.Addr(), err) + + switch err.(type) { + case PacketEncodingError: + return nil, err + default: + _ = broker.Close() + client.deregisterBroker(broker) + continue + } + } + + switch response.Err { + case ErrNoError: + Logger.Printf("client/coordinator coordinator for consumergroup %s is #%d (%s)\n", consumerGroup, response.Coordinator.ID(), response.Coordinator.Addr()) + return response, nil + + case ErrConsumerCoordinatorNotAvailable: + Logger.Printf("client/coordinator coordinator for consumer group %s is not available\n", consumerGroup) + + // This is very ugly, but this scenario will only happen once per cluster. + // The __consumer_offsets topic only has to be created one time. + // The number of partitions not configurable, but partition 0 should always exist. + if _, err := client.Leader("__consumer_offsets", 0); err != nil { + Logger.Printf("client/coordinator the __consumer_offsets topic is not initialized completely yet. Waiting 2 seconds...\n") + time.Sleep(2 * time.Second) + } + + return retry(ErrConsumerCoordinatorNotAvailable) + default: + return nil, response.Err + } + } + + Logger.Println("client/coordinator no available broker to send consumer metadata request to") + client.resurrectDeadBrokers() + return retry(ErrOutOfBrokers) +} diff --git a/vendor/github.com/Shopify/sarama/config.go b/vendor/github.com/Shopify/sarama/config.go new file mode 100644 index 00000000..a417a38b --- /dev/null +++ b/vendor/github.com/Shopify/sarama/config.go @@ -0,0 +1,417 @@ +package sarama + +import ( + "crypto/tls" + "regexp" + "time" + + "github.com/rcrowley/go-metrics" +) + +const defaultClientID = "sarama" + +var validID = regexp.MustCompile(`\A[A-Za-z0-9._-]+\z`) + +// Config is used to pass multiple configuration options to Sarama's constructors. +type Config struct { + // Net is the namespace for network-level properties used by the Broker, and + // shared by the Client/Producer/Consumer. + Net struct { + // How many outstanding requests a connection is allowed to have before + // sending on it blocks (default 5). + MaxOpenRequests int + + // All three of the below configurations are similar to the + // `socket.timeout.ms` setting in JVM kafka. All of them default + // to 30 seconds. + DialTimeout time.Duration // How long to wait for the initial connection. + ReadTimeout time.Duration // How long to wait for a response. + WriteTimeout time.Duration // How long to wait for a transmit. + + TLS struct { + // Whether or not to use TLS when connecting to the broker + // (defaults to false). + Enable bool + // The TLS configuration to use for secure connections if + // enabled (defaults to nil). + Config *tls.Config + } + + // SASL based authentication with broker. While there are multiple SASL authentication methods + // the current implementation is limited to plaintext (SASL/PLAIN) authentication + SASL struct { + // Whether or not to use SASL authentication when connecting to the broker + // (defaults to false). + Enable bool + // Whether or not to send the Kafka SASL handshake first if enabled + // (defaults to true). You should only set this to false if you're using + // a non-Kafka SASL proxy. + Handshake bool + //username and password for SASL/PLAIN authentication + User string + Password string + } + + // KeepAlive specifies the keep-alive period for an active network connection. + // If zero, keep-alives are disabled. (default is 0: disabled). + KeepAlive time.Duration + } + + // Metadata is the namespace for metadata management properties used by the + // Client, and shared by the Producer/Consumer. + Metadata struct { + Retry struct { + // The total number of times to retry a metadata request when the + // cluster is in the middle of a leader election (default 3). + Max int + // How long to wait for leader election to occur before retrying + // (default 250ms). Similar to the JVM's `retry.backoff.ms`. + Backoff time.Duration + } + // How frequently to refresh the cluster metadata in the background. + // Defaults to 10 minutes. Set to 0 to disable. Similar to + // `topic.metadata.refresh.interval.ms` in the JVM version. + RefreshFrequency time.Duration + } + + // Producer is the namespace for configuration related to producing messages, + // used by the Producer. + Producer struct { + // The maximum permitted size of a message (defaults to 1000000). Should be + // set equal to or smaller than the broker's `message.max.bytes`. + MaxMessageBytes int + // The level of acknowledgement reliability needed from the broker (defaults + // to WaitForLocal). Equivalent to the `request.required.acks` setting of the + // JVM producer. + RequiredAcks RequiredAcks + // The maximum duration the broker will wait the receipt of the number of + // RequiredAcks (defaults to 10 seconds). This is only relevant when + // RequiredAcks is set to WaitForAll or a number > 1. Only supports + // millisecond resolution, nanoseconds will be truncated. Equivalent to + // the JVM producer's `request.timeout.ms` setting. + Timeout time.Duration + // The type of compression to use on messages (defaults to no compression). + // Similar to `compression.codec` setting of the JVM producer. + Compression CompressionCodec + // Generates partitioners for choosing the partition to send messages to + // (defaults to hashing the message key). Similar to the `partitioner.class` + // setting for the JVM producer. + Partitioner PartitionerConstructor + + // Return specifies what channels will be populated. If they are set to true, + // you must read from the respective channels to prevent deadlock. + Return struct { + // If enabled, successfully delivered messages will be returned on the + // Successes channel (default disabled). + Successes bool + + // If enabled, messages that failed to deliver will be returned on the + // Errors channel, including error (default enabled). + Errors bool + } + + // The following config options control how often messages are batched up and + // sent to the broker. By default, messages are sent as fast as possible, and + // all messages received while the current batch is in-flight are placed + // into the subsequent batch. + Flush struct { + // The best-effort number of bytes needed to trigger a flush. Use the + // global sarama.MaxRequestSize to set a hard upper limit. + Bytes int + // The best-effort number of messages needed to trigger a flush. Use + // `MaxMessages` to set a hard upper limit. + Messages int + // The best-effort frequency of flushes. Equivalent to + // `queue.buffering.max.ms` setting of JVM producer. + Frequency time.Duration + // The maximum number of messages the producer will send in a single + // broker request. Defaults to 0 for unlimited. Similar to + // `queue.buffering.max.messages` in the JVM producer. + MaxMessages int + } + + Retry struct { + // The total number of times to retry sending a message (default 3). + // Similar to the `message.send.max.retries` setting of the JVM producer. + Max int + // How long to wait for the cluster to settle between retries + // (default 100ms). Similar to the `retry.backoff.ms` setting of the + // JVM producer. + Backoff time.Duration + } + } + + // Consumer is the namespace for configuration related to consuming messages, + // used by the Consumer. + // + // Note that Sarama's Consumer type does not currently support automatic + // consumer-group rebalancing and offset tracking. For Zookeeper-based + // tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka + // library builds on Sarama to add this support. For Kafka-based tracking + // (Kafka 0.9 and later), the https://github.com/bsm/sarama-cluster library + // builds on Sarama to add this support. + Consumer struct { + Retry struct { + // How long to wait after a failing to read from a partition before + // trying again (default 2s). + Backoff time.Duration + } + + // Fetch is the namespace for controlling how many bytes are retrieved by any + // given request. + Fetch struct { + // The minimum number of message bytes to fetch in a request - the broker + // will wait until at least this many are available. The default is 1, + // as 0 causes the consumer to spin when no messages are available. + // Equivalent to the JVM's `fetch.min.bytes`. + Min int32 + // The default number of message bytes to fetch from the broker in each + // request (default 32768). This should be larger than the majority of + // your messages, or else the consumer will spend a lot of time + // negotiating sizes and not actually consuming. Similar to the JVM's + // `fetch.message.max.bytes`. + Default int32 + // The maximum number of message bytes to fetch from the broker in a + // single request. Messages larger than this will return + // ErrMessageTooLarge and will not be consumable, so you must be sure + // this is at least as large as your largest message. Defaults to 0 + // (no limit). Similar to the JVM's `fetch.message.max.bytes`. The + // global `sarama.MaxResponseSize` still applies. + Max int32 + } + // The maximum amount of time the broker will wait for Consumer.Fetch.Min + // bytes to become available before it returns fewer than that anyways. The + // default is 250ms, since 0 causes the consumer to spin when no events are + // available. 100-500ms is a reasonable range for most cases. Kafka only + // supports precision up to milliseconds; nanoseconds will be truncated. + // Equivalent to the JVM's `fetch.wait.max.ms`. + MaxWaitTime time.Duration + + // The maximum amount of time the consumer expects a message takes to process + // for the user. If writing to the Messages channel takes longer than this, + // that partition will stop fetching more messages until it can proceed again. + // Note that, since the Messages channel is buffered, the actual grace time is + // (MaxProcessingTime * ChanneBufferSize). Defaults to 100ms. + MaxProcessingTime time.Duration + + // Return specifies what channels will be populated. If they are set to true, + // you must read from them to prevent deadlock. + Return struct { + // If enabled, any errors that occurred while consuming are returned on + // the Errors channel (default disabled). + Errors bool + } + + // Offsets specifies configuration for how and when to commit consumed + // offsets. This currently requires the manual use of an OffsetManager + // but will eventually be automated. + Offsets struct { + // How frequently to commit updated offsets. Defaults to 1s. + CommitInterval time.Duration + + // The initial offset to use if no offset was previously committed. + // Should be OffsetNewest or OffsetOldest. Defaults to OffsetNewest. + Initial int64 + + // The retention duration for committed offsets. If zero, disabled + // (in which case the `offsets.retention.minutes` option on the + // broker will be used). Kafka only supports precision up to + // milliseconds; nanoseconds will be truncated. Requires Kafka + // broker version 0.9.0 or later. + // (default is 0: disabled). + Retention time.Duration + } + } + + // A user-provided string sent with every request to the brokers for logging, + // debugging, and auditing purposes. Defaults to "sarama", but you should + // probably set it to something specific to your application. + ClientID string + // The number of events to buffer in internal and external channels. This + // permits the producer and consumer to continue processing some messages + // in the background while user code is working, greatly improving throughput. + // Defaults to 256. + ChannelBufferSize int + // The version of Kafka that Sarama will assume it is running against. + // Defaults to the oldest supported stable version. Since Kafka provides + // backwards-compatibility, setting it to a version older than you have + // will not break anything, although it may prevent you from using the + // latest features. Setting it to a version greater than you are actually + // running may lead to random breakage. + Version KafkaVersion + // The registry to define metrics into. + // Defaults to a local registry. + // If you want to disable metrics gathering, set "metrics.UseNilMetrics" to "true" + // prior to starting Sarama. + // See Examples on how to use the metrics registry + MetricRegistry metrics.Registry +} + +// NewConfig returns a new configuration instance with sane defaults. +func NewConfig() *Config { + c := &Config{} + + c.Net.MaxOpenRequests = 5 + c.Net.DialTimeout = 30 * time.Second + c.Net.ReadTimeout = 30 * time.Second + c.Net.WriteTimeout = 30 * time.Second + c.Net.SASL.Handshake = true + + c.Metadata.Retry.Max = 3 + c.Metadata.Retry.Backoff = 250 * time.Millisecond + c.Metadata.RefreshFrequency = 10 * time.Minute + + c.Producer.MaxMessageBytes = 1000000 + c.Producer.RequiredAcks = WaitForLocal + c.Producer.Timeout = 10 * time.Second + c.Producer.Partitioner = NewHashPartitioner + c.Producer.Retry.Max = 3 + c.Producer.Retry.Backoff = 100 * time.Millisecond + c.Producer.Return.Errors = true + + c.Consumer.Fetch.Min = 1 + c.Consumer.Fetch.Default = 32768 + c.Consumer.Retry.Backoff = 2 * time.Second + c.Consumer.MaxWaitTime = 250 * time.Millisecond + c.Consumer.MaxProcessingTime = 100 * time.Millisecond + c.Consumer.Return.Errors = false + c.Consumer.Offsets.CommitInterval = 1 * time.Second + c.Consumer.Offsets.Initial = OffsetNewest + + c.ClientID = defaultClientID + c.ChannelBufferSize = 256 + c.Version = minVersion + c.MetricRegistry = metrics.NewRegistry() + + return c +} + +// Validate checks a Config instance. It will return a +// ConfigurationError if the specified values don't make sense. +func (c *Config) Validate() error { + // some configuration values should be warned on but not fail completely, do those first + if c.Net.TLS.Enable == false && c.Net.TLS.Config != nil { + Logger.Println("Net.TLS is disabled but a non-nil configuration was provided.") + } + if c.Net.SASL.Enable == false { + if c.Net.SASL.User != "" { + Logger.Println("Net.SASL is disabled but a non-empty username was provided.") + } + if c.Net.SASL.Password != "" { + Logger.Println("Net.SASL is disabled but a non-empty password was provided.") + } + } + if c.Producer.RequiredAcks > 1 { + Logger.Println("Producer.RequiredAcks > 1 is deprecated and will raise an exception with kafka >= 0.8.2.0.") + } + if c.Producer.MaxMessageBytes >= int(MaxRequestSize) { + Logger.Println("Producer.MaxMessageBytes is larger than MaxRequestSize; it will be ignored.") + } + if c.Producer.Flush.Bytes >= int(MaxRequestSize) { + Logger.Println("Producer.Flush.Bytes is larger than MaxRequestSize; it will be ignored.") + } + if c.Producer.Timeout%time.Millisecond != 0 { + Logger.Println("Producer.Timeout only supports millisecond resolution; nanoseconds will be truncated.") + } + if c.Consumer.MaxWaitTime < 100*time.Millisecond { + Logger.Println("Consumer.MaxWaitTime is very low, which can cause high CPU and network usage. See documentation for details.") + } + if c.Consumer.MaxWaitTime%time.Millisecond != 0 { + Logger.Println("Consumer.MaxWaitTime only supports millisecond precision; nanoseconds will be truncated.") + } + if c.Consumer.Offsets.Retention%time.Millisecond != 0 { + Logger.Println("Consumer.Offsets.Retention only supports millisecond precision; nanoseconds will be truncated.") + } + if c.ClientID == defaultClientID { + Logger.Println("ClientID is the default of 'sarama', you should consider setting it to something application-specific.") + } + + // validate Net values + switch { + case c.Net.MaxOpenRequests <= 0: + return ConfigurationError("Net.MaxOpenRequests must be > 0") + case c.Net.DialTimeout <= 0: + return ConfigurationError("Net.DialTimeout must be > 0") + case c.Net.ReadTimeout <= 0: + return ConfigurationError("Net.ReadTimeout must be > 0") + case c.Net.WriteTimeout <= 0: + return ConfigurationError("Net.WriteTimeout must be > 0") + case c.Net.KeepAlive < 0: + return ConfigurationError("Net.KeepAlive must be >= 0") + case c.Net.SASL.Enable == true && c.Net.SASL.User == "": + return ConfigurationError("Net.SASL.User must not be empty when SASL is enabled") + case c.Net.SASL.Enable == true && c.Net.SASL.Password == "": + return ConfigurationError("Net.SASL.Password must not be empty when SASL is enabled") + } + + // validate the Metadata values + switch { + case c.Metadata.Retry.Max < 0: + return ConfigurationError("Metadata.Retry.Max must be >= 0") + case c.Metadata.Retry.Backoff < 0: + return ConfigurationError("Metadata.Retry.Backoff must be >= 0") + case c.Metadata.RefreshFrequency < 0: + return ConfigurationError("Metadata.RefreshFrequency must be >= 0") + } + + // validate the Producer values + switch { + case c.Producer.MaxMessageBytes <= 0: + return ConfigurationError("Producer.MaxMessageBytes must be > 0") + case c.Producer.RequiredAcks < -1: + return ConfigurationError("Producer.RequiredAcks must be >= -1") + case c.Producer.Timeout <= 0: + return ConfigurationError("Producer.Timeout must be > 0") + case c.Producer.Partitioner == nil: + return ConfigurationError("Producer.Partitioner must not be nil") + case c.Producer.Flush.Bytes < 0: + return ConfigurationError("Producer.Flush.Bytes must be >= 0") + case c.Producer.Flush.Messages < 0: + return ConfigurationError("Producer.Flush.Messages must be >= 0") + case c.Producer.Flush.Frequency < 0: + return ConfigurationError("Producer.Flush.Frequency must be >= 0") + case c.Producer.Flush.MaxMessages < 0: + return ConfigurationError("Producer.Flush.MaxMessages must be >= 0") + case c.Producer.Flush.MaxMessages > 0 && c.Producer.Flush.MaxMessages < c.Producer.Flush.Messages: + return ConfigurationError("Producer.Flush.MaxMessages must be >= Producer.Flush.Messages when set") + case c.Producer.Retry.Max < 0: + return ConfigurationError("Producer.Retry.Max must be >= 0") + case c.Producer.Retry.Backoff < 0: + return ConfigurationError("Producer.Retry.Backoff must be >= 0") + } + + if c.Producer.Compression == CompressionLZ4 && !c.Version.IsAtLeast(V0_10_0_0) { + return ConfigurationError("lz4 compression requires Version >= V0_10_0_0") + } + + // validate the Consumer values + switch { + case c.Consumer.Fetch.Min <= 0: + return ConfigurationError("Consumer.Fetch.Min must be > 0") + case c.Consumer.Fetch.Default <= 0: + return ConfigurationError("Consumer.Fetch.Default must be > 0") + case c.Consumer.Fetch.Max < 0: + return ConfigurationError("Consumer.Fetch.Max must be >= 0") + case c.Consumer.MaxWaitTime < 1*time.Millisecond: + return ConfigurationError("Consumer.MaxWaitTime must be >= 1ms") + case c.Consumer.MaxProcessingTime <= 0: + return ConfigurationError("Consumer.MaxProcessingTime must be > 0") + case c.Consumer.Retry.Backoff < 0: + return ConfigurationError("Consumer.Retry.Backoff must be >= 0") + case c.Consumer.Offsets.CommitInterval <= 0: + return ConfigurationError("Consumer.Offsets.CommitInterval must be > 0") + case c.Consumer.Offsets.Initial != OffsetOldest && c.Consumer.Offsets.Initial != OffsetNewest: + return ConfigurationError("Consumer.Offsets.Initial must be OffsetOldest or OffsetNewest") + + } + + // validate misc shared values + switch { + case c.ChannelBufferSize < 0: + return ConfigurationError("ChannelBufferSize must be >= 0") + case !validID.MatchString(c.ClientID): + return ConfigurationError("ClientID is invalid") + } + + return nil +} diff --git a/vendor/github.com/Shopify/sarama/consumer.go b/vendor/github.com/Shopify/sarama/consumer.go new file mode 100644 index 00000000..50a909a6 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/consumer.go @@ -0,0 +1,735 @@ +package sarama + +import ( + "errors" + "fmt" + "sync" + "sync/atomic" + "time" +) + +// ConsumerMessage encapsulates a Kafka message returned by the consumer. +type ConsumerMessage struct { + Key, Value []byte + Topic string + Partition int32 + Offset int64 + Timestamp time.Time // only set if kafka is version 0.10+ +} + +// ConsumerError is what is provided to the user when an error occurs. +// It wraps an error and includes the topic and partition. +type ConsumerError struct { + Topic string + Partition int32 + Err error +} + +func (ce ConsumerError) Error() string { + return fmt.Sprintf("kafka: error while consuming %s/%d: %s", ce.Topic, ce.Partition, ce.Err) +} + +// ConsumerErrors is a type that wraps a batch of errors and implements the Error interface. +// It can be returned from the PartitionConsumer's Close methods to avoid the need to manually drain errors +// when stopping. +type ConsumerErrors []*ConsumerError + +func (ce ConsumerErrors) Error() string { + return fmt.Sprintf("kafka: %d errors while consuming", len(ce)) +} + +// Consumer manages PartitionConsumers which process Kafka messages from brokers. You MUST call Close() +// on a consumer to avoid leaks, it will not be garbage-collected automatically when it passes out of +// scope. +// +// Sarama's Consumer type does not currently support automatic consumer-group rebalancing and offset tracking. +// For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the https://github.com/wvanbergen/kafka library +// builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 and later), the +// https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. +type Consumer interface { + + // Topics returns the set of available topics as retrieved from the cluster + // metadata. This method is the same as Client.Topics(), and is provided for + // convenience. + Topics() ([]string, error) + + // Partitions returns the sorted list of all partition IDs for the given topic. + // This method is the same as Client.Partitions(), and is provided for convenience. + Partitions(topic string) ([]int32, error) + + // ConsumePartition creates a PartitionConsumer on the given topic/partition with + // the given offset. It will return an error if this Consumer is already consuming + // on the given topic/partition. Offset can be a literal offset, or OffsetNewest + // or OffsetOldest + ConsumePartition(topic string, partition int32, offset int64) (PartitionConsumer, error) + + // HighWaterMarks returns the current high water marks for each topic and partition. + // Consistency between partitions is not guaranteed since high water marks are updated separately. + HighWaterMarks() map[string]map[int32]int64 + + // Close shuts down the consumer. It must be called after all child + // PartitionConsumers have already been closed. + Close() error +} + +type consumer struct { + client Client + conf *Config + ownClient bool + + lock sync.Mutex + children map[string]map[int32]*partitionConsumer + brokerConsumers map[*Broker]*brokerConsumer +} + +// NewConsumer creates a new consumer using the given broker addresses and configuration. +func NewConsumer(addrs []string, config *Config) (Consumer, error) { + client, err := NewClient(addrs, config) + if err != nil { + return nil, err + } + + c, err := NewConsumerFromClient(client) + if err != nil { + return nil, err + } + c.(*consumer).ownClient = true + return c, nil +} + +// NewConsumerFromClient creates a new consumer using the given client. It is still +// necessary to call Close() on the underlying client when shutting down this consumer. +func NewConsumerFromClient(client Client) (Consumer, error) { + // Check that we are not dealing with a closed Client before processing any other arguments + if client.Closed() { + return nil, ErrClosedClient + } + + c := &consumer{ + client: client, + conf: client.Config(), + children: make(map[string]map[int32]*partitionConsumer), + brokerConsumers: make(map[*Broker]*brokerConsumer), + } + + return c, nil +} + +func (c *consumer) Close() error { + if c.ownClient { + return c.client.Close() + } + return nil +} + +func (c *consumer) Topics() ([]string, error) { + return c.client.Topics() +} + +func (c *consumer) Partitions(topic string) ([]int32, error) { + return c.client.Partitions(topic) +} + +func (c *consumer) ConsumePartition(topic string, partition int32, offset int64) (PartitionConsumer, error) { + child := &partitionConsumer{ + consumer: c, + conf: c.conf, + topic: topic, + partition: partition, + messages: make(chan *ConsumerMessage, c.conf.ChannelBufferSize), + errors: make(chan *ConsumerError, c.conf.ChannelBufferSize), + feeder: make(chan *FetchResponse, 1), + trigger: make(chan none, 1), + dying: make(chan none), + fetchSize: c.conf.Consumer.Fetch.Default, + } + + if err := child.chooseStartingOffset(offset); err != nil { + return nil, err + } + + var leader *Broker + var err error + if leader, err = c.client.Leader(child.topic, child.partition); err != nil { + return nil, err + } + + if err := c.addChild(child); err != nil { + return nil, err + } + + go withRecover(child.dispatcher) + go withRecover(child.responseFeeder) + + child.broker = c.refBrokerConsumer(leader) + child.broker.input <- child + + return child, nil +} + +func (c *consumer) HighWaterMarks() map[string]map[int32]int64 { + c.lock.Lock() + defer c.lock.Unlock() + + hwms := make(map[string]map[int32]int64) + for topic, p := range c.children { + hwm := make(map[int32]int64, len(p)) + for partition, pc := range p { + hwm[partition] = pc.HighWaterMarkOffset() + } + hwms[topic] = hwm + } + + return hwms +} + +func (c *consumer) addChild(child *partitionConsumer) error { + c.lock.Lock() + defer c.lock.Unlock() + + topicChildren := c.children[child.topic] + if topicChildren == nil { + topicChildren = make(map[int32]*partitionConsumer) + c.children[child.topic] = topicChildren + } + + if topicChildren[child.partition] != nil { + return ConfigurationError("That topic/partition is already being consumed") + } + + topicChildren[child.partition] = child + return nil +} + +func (c *consumer) removeChild(child *partitionConsumer) { + c.lock.Lock() + defer c.lock.Unlock() + + delete(c.children[child.topic], child.partition) +} + +func (c *consumer) refBrokerConsumer(broker *Broker) *brokerConsumer { + c.lock.Lock() + defer c.lock.Unlock() + + bc := c.brokerConsumers[broker] + if bc == nil { + bc = c.newBrokerConsumer(broker) + c.brokerConsumers[broker] = bc + } + + bc.refs++ + + return bc +} + +func (c *consumer) unrefBrokerConsumer(brokerWorker *brokerConsumer) { + c.lock.Lock() + defer c.lock.Unlock() + + brokerWorker.refs-- + + if brokerWorker.refs == 0 { + close(brokerWorker.input) + if c.brokerConsumers[brokerWorker.broker] == brokerWorker { + delete(c.brokerConsumers, brokerWorker.broker) + } + } +} + +func (c *consumer) abandonBrokerConsumer(brokerWorker *brokerConsumer) { + c.lock.Lock() + defer c.lock.Unlock() + + delete(c.brokerConsumers, brokerWorker.broker) +} + +// PartitionConsumer + +// PartitionConsumer processes Kafka messages from a given topic and partition. You MUST call Close() +// or AsyncClose() on a PartitionConsumer to avoid leaks, it will not be garbage-collected automatically +// when it passes out of scope. +// +// The simplest way of using a PartitionConsumer is to loop over its Messages channel using a for/range +// loop. The PartitionConsumer will only stop itself in one case: when the offset being consumed is reported +// as out of range by the brokers. In this case you should decide what you want to do (try a different offset, +// notify a human, etc) and handle it appropriately. For all other error cases, it will just keep retrying. +// By default, it logs these errors to sarama.Logger; if you want to be notified directly of all errors, set +// your config's Consumer.Return.Errors to true and read from the Errors channel, using a select statement +// or a separate goroutine. Check out the Consumer examples to see implementations of these different approaches. +type PartitionConsumer interface { + + // AsyncClose initiates a shutdown of the PartitionConsumer. This method will + // return immediately, after which you should wait until the 'messages' and + // 'errors' channel are drained. It is required to call this function, or + // Close before a consumer object passes out of scope, as it will otherwise + // leak memory. You must call this before calling Close on the underlying client. + AsyncClose() + + // Close stops the PartitionConsumer from fetching messages. It is required to + // call this function (or AsyncClose) before a consumer object passes out of + // scope, as it will otherwise leak memory. You must call this before calling + // Close on the underlying client. + Close() error + + // Messages returns the read channel for the messages that are returned by + // the broker. + Messages() <-chan *ConsumerMessage + + // Errors returns a read channel of errors that occurred during consuming, if + // enabled. By default, errors are logged and not returned over this channel. + // If you want to implement any custom error handling, set your config's + // Consumer.Return.Errors setting to true, and read from this channel. + Errors() <-chan *ConsumerError + + // HighWaterMarkOffset returns the high water mark offset of the partition, + // i.e. the offset that will be used for the next message that will be produced. + // You can use this to determine how far behind the processing is. + HighWaterMarkOffset() int64 +} + +type partitionConsumer struct { + consumer *consumer + conf *Config + topic string + partition int32 + + broker *brokerConsumer + messages chan *ConsumerMessage + errors chan *ConsumerError + feeder chan *FetchResponse + + trigger, dying chan none + responseResult error + + fetchSize int32 + offset int64 + highWaterMarkOffset int64 +} + +var errTimedOut = errors.New("timed out feeding messages to the user") // not user-facing + +func (child *partitionConsumer) sendError(err error) { + cErr := &ConsumerError{ + Topic: child.topic, + Partition: child.partition, + Err: err, + } + + if child.conf.Consumer.Return.Errors { + child.errors <- cErr + } else { + Logger.Println(cErr) + } +} + +func (child *partitionConsumer) dispatcher() { + for range child.trigger { + select { + case <-child.dying: + close(child.trigger) + case <-time.After(child.conf.Consumer.Retry.Backoff): + if child.broker != nil { + child.consumer.unrefBrokerConsumer(child.broker) + child.broker = nil + } + + Logger.Printf("consumer/%s/%d finding new broker\n", child.topic, child.partition) + if err := child.dispatch(); err != nil { + child.sendError(err) + child.trigger <- none{} + } + } + } + + if child.broker != nil { + child.consumer.unrefBrokerConsumer(child.broker) + } + child.consumer.removeChild(child) + close(child.feeder) +} + +func (child *partitionConsumer) dispatch() error { + if err := child.consumer.client.RefreshMetadata(child.topic); err != nil { + return err + } + + var leader *Broker + var err error + if leader, err = child.consumer.client.Leader(child.topic, child.partition); err != nil { + return err + } + + child.broker = child.consumer.refBrokerConsumer(leader) + + child.broker.input <- child + + return nil +} + +func (child *partitionConsumer) chooseStartingOffset(offset int64) error { + newestOffset, err := child.consumer.client.GetOffset(child.topic, child.partition, OffsetNewest) + if err != nil { + return err + } + oldestOffset, err := child.consumer.client.GetOffset(child.topic, child.partition, OffsetOldest) + if err != nil { + return err + } + + switch { + case offset == OffsetNewest: + child.offset = newestOffset + case offset == OffsetOldest: + child.offset = oldestOffset + case offset >= oldestOffset && offset <= newestOffset: + child.offset = offset + default: + return ErrOffsetOutOfRange + } + + return nil +} + +func (child *partitionConsumer) Messages() <-chan *ConsumerMessage { + return child.messages +} + +func (child *partitionConsumer) Errors() <-chan *ConsumerError { + return child.errors +} + +func (child *partitionConsumer) AsyncClose() { + // this triggers whatever broker owns this child to abandon it and close its trigger channel, which causes + // the dispatcher to exit its loop, which removes it from the consumer then closes its 'messages' and + // 'errors' channel (alternatively, if the child is already at the dispatcher for some reason, that will + // also just close itself) + close(child.dying) +} + +func (child *partitionConsumer) Close() error { + child.AsyncClose() + + go withRecover(func() { + for range child.messages { + // drain + } + }) + + var errors ConsumerErrors + for err := range child.errors { + errors = append(errors, err) + } + + if len(errors) > 0 { + return errors + } + return nil +} + +func (child *partitionConsumer) HighWaterMarkOffset() int64 { + return atomic.LoadInt64(&child.highWaterMarkOffset) +} + +func (child *partitionConsumer) responseFeeder() { + var msgs []*ConsumerMessage + expiryTimer := time.NewTimer(child.conf.Consumer.MaxProcessingTime) + expireTimedOut := false + +feederLoop: + for response := range child.feeder { + msgs, child.responseResult = child.parseResponse(response) + + for i, msg := range msgs { + if !expiryTimer.Stop() && !expireTimedOut { + // expiryTimer was expired; clear out the waiting msg + <-expiryTimer.C + } + expiryTimer.Reset(child.conf.Consumer.MaxProcessingTime) + expireTimedOut = false + + select { + case child.messages <- msg: + case <-expiryTimer.C: + expireTimedOut = true + child.responseResult = errTimedOut + child.broker.acks.Done() + for _, msg = range msgs[i:] { + child.messages <- msg + } + child.broker.input <- child + continue feederLoop + } + } + + child.broker.acks.Done() + } + + close(child.messages) + close(child.errors) +} + +func (child *partitionConsumer) parseResponse(response *FetchResponse) ([]*ConsumerMessage, error) { + block := response.GetBlock(child.topic, child.partition) + if block == nil { + return nil, ErrIncompleteResponse + } + + if block.Err != ErrNoError { + return nil, block.Err + } + + if len(block.MsgSet.Messages) == 0 { + // We got no messages. If we got a trailing one then we need to ask for more data. + // Otherwise we just poll again and wait for one to be produced... + if block.MsgSet.PartialTrailingMessage { + if child.conf.Consumer.Fetch.Max > 0 && child.fetchSize == child.conf.Consumer.Fetch.Max { + // we can't ask for more data, we've hit the configured limit + child.sendError(ErrMessageTooLarge) + child.offset++ // skip this one so we can keep processing future messages + } else { + child.fetchSize *= 2 + if child.conf.Consumer.Fetch.Max > 0 && child.fetchSize > child.conf.Consumer.Fetch.Max { + child.fetchSize = child.conf.Consumer.Fetch.Max + } + } + } + + return nil, nil + } + + // we got messages, reset our fetch size in case it was increased for a previous request + child.fetchSize = child.conf.Consumer.Fetch.Default + atomic.StoreInt64(&child.highWaterMarkOffset, block.HighWaterMarkOffset) + + incomplete := false + prelude := true + var messages []*ConsumerMessage + for _, msgBlock := range block.MsgSet.Messages { + + for _, msg := range msgBlock.Messages() { + offset := msg.Offset + if msg.Msg.Version >= 1 { + baseOffset := msgBlock.Offset - msgBlock.Messages()[len(msgBlock.Messages())-1].Offset + offset += baseOffset + } + if prelude && offset < child.offset { + continue + } + prelude = false + + if offset >= child.offset { + messages = append(messages, &ConsumerMessage{ + Topic: child.topic, + Partition: child.partition, + Key: msg.Msg.Key, + Value: msg.Msg.Value, + Offset: offset, + Timestamp: msg.Msg.Timestamp, + }) + child.offset = offset + 1 + } else { + incomplete = true + } + } + + } + + if incomplete || len(messages) == 0 { + return nil, ErrIncompleteResponse + } + return messages, nil +} + +// brokerConsumer + +type brokerConsumer struct { + consumer *consumer + broker *Broker + input chan *partitionConsumer + newSubscriptions chan []*partitionConsumer + wait chan none + subscriptions map[*partitionConsumer]none + acks sync.WaitGroup + refs int +} + +func (c *consumer) newBrokerConsumer(broker *Broker) *brokerConsumer { + bc := &brokerConsumer{ + consumer: c, + broker: broker, + input: make(chan *partitionConsumer), + newSubscriptions: make(chan []*partitionConsumer), + wait: make(chan none), + subscriptions: make(map[*partitionConsumer]none), + refs: 0, + } + + go withRecover(bc.subscriptionManager) + go withRecover(bc.subscriptionConsumer) + + return bc +} + +func (bc *brokerConsumer) subscriptionManager() { + var buffer []*partitionConsumer + + // The subscriptionManager constantly accepts new subscriptions on `input` (even when the main subscriptionConsumer + // goroutine is in the middle of a network request) and batches it up. The main worker goroutine picks + // up a batch of new subscriptions between every network request by reading from `newSubscriptions`, so we give + // it nil if no new subscriptions are available. We also write to `wait` only when new subscriptions is available, + // so the main goroutine can block waiting for work if it has none. + for { + if len(buffer) > 0 { + select { + case event, ok := <-bc.input: + if !ok { + goto done + } + buffer = append(buffer, event) + case bc.newSubscriptions <- buffer: + buffer = nil + case bc.wait <- none{}: + } + } else { + select { + case event, ok := <-bc.input: + if !ok { + goto done + } + buffer = append(buffer, event) + case bc.newSubscriptions <- nil: + } + } + } + +done: + close(bc.wait) + if len(buffer) > 0 { + bc.newSubscriptions <- buffer + } + close(bc.newSubscriptions) +} + +func (bc *brokerConsumer) subscriptionConsumer() { + <-bc.wait // wait for our first piece of work + + // the subscriptionConsumer ensures we will get nil right away if no new subscriptions is available + for newSubscriptions := range bc.newSubscriptions { + bc.updateSubscriptions(newSubscriptions) + + if len(bc.subscriptions) == 0 { + // We're about to be shut down or we're about to receive more subscriptions. + // Either way, the signal just hasn't propagated to our goroutine yet. + <-bc.wait + continue + } + + response, err := bc.fetchNewMessages() + + if err != nil { + Logger.Printf("consumer/broker/%d disconnecting due to error processing FetchRequest: %s\n", bc.broker.ID(), err) + bc.abort(err) + return + } + + bc.acks.Add(len(bc.subscriptions)) + for child := range bc.subscriptions { + child.feeder <- response + } + bc.acks.Wait() + bc.handleResponses() + } +} + +func (bc *brokerConsumer) updateSubscriptions(newSubscriptions []*partitionConsumer) { + for _, child := range newSubscriptions { + bc.subscriptions[child] = none{} + Logger.Printf("consumer/broker/%d added subscription to %s/%d\n", bc.broker.ID(), child.topic, child.partition) + } + + for child := range bc.subscriptions { + select { + case <-child.dying: + Logger.Printf("consumer/broker/%d closed dead subscription to %s/%d\n", bc.broker.ID(), child.topic, child.partition) + close(child.trigger) + delete(bc.subscriptions, child) + default: + break + } + } +} + +func (bc *brokerConsumer) handleResponses() { + // handles the response codes left for us by our subscriptions, and abandons ones that have been closed + for child := range bc.subscriptions { + result := child.responseResult + child.responseResult = nil + + switch result { + case nil: + break + case errTimedOut: + Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because consuming was taking too long\n", + bc.broker.ID(), child.topic, child.partition) + delete(bc.subscriptions, child) + case ErrOffsetOutOfRange: + // there's no point in retrying this it will just fail the same way again + // shut it down and force the user to choose what to do + child.sendError(result) + Logger.Printf("consumer/%s/%d shutting down because %s\n", child.topic, child.partition, result) + close(child.trigger) + delete(bc.subscriptions, child) + case ErrUnknownTopicOrPartition, ErrNotLeaderForPartition, ErrLeaderNotAvailable, ErrReplicaNotAvailable: + // not an error, but does need redispatching + Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because %s\n", + bc.broker.ID(), child.topic, child.partition, result) + child.trigger <- none{} + delete(bc.subscriptions, child) + default: + // dunno, tell the user and try redispatching + child.sendError(result) + Logger.Printf("consumer/broker/%d abandoned subscription to %s/%d because %s\n", + bc.broker.ID(), child.topic, child.partition, result) + child.trigger <- none{} + delete(bc.subscriptions, child) + } + } +} + +func (bc *brokerConsumer) abort(err error) { + bc.consumer.abandonBrokerConsumer(bc) + _ = bc.broker.Close() // we don't care about the error this might return, we already have one + + for child := range bc.subscriptions { + child.sendError(err) + child.trigger <- none{} + } + + for newSubscriptions := range bc.newSubscriptions { + if len(newSubscriptions) == 0 { + <-bc.wait + continue + } + for _, child := range newSubscriptions { + child.sendError(err) + child.trigger <- none{} + } + } +} + +func (bc *brokerConsumer) fetchNewMessages() (*FetchResponse, error) { + request := &FetchRequest{ + MinBytes: bc.consumer.conf.Consumer.Fetch.Min, + MaxWaitTime: int32(bc.consumer.conf.Consumer.MaxWaitTime / time.Millisecond), + } + if bc.consumer.conf.Version.IsAtLeast(V0_10_0_0) { + request.Version = 2 + } + + for child := range bc.subscriptions { + request.AddBlock(child.topic, child.partition, child.offset, child.fetchSize) + } + + return bc.broker.Fetch(request) +} diff --git a/vendor/github.com/Shopify/sarama/consumer_group_members.go b/vendor/github.com/Shopify/sarama/consumer_group_members.go new file mode 100644 index 00000000..9d92d350 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/consumer_group_members.go @@ -0,0 +1,94 @@ +package sarama + +type ConsumerGroupMemberMetadata struct { + Version int16 + Topics []string + UserData []byte +} + +func (m *ConsumerGroupMemberMetadata) encode(pe packetEncoder) error { + pe.putInt16(m.Version) + + if err := pe.putStringArray(m.Topics); err != nil { + return err + } + + if err := pe.putBytes(m.UserData); err != nil { + return err + } + + return nil +} + +func (m *ConsumerGroupMemberMetadata) decode(pd packetDecoder) (err error) { + if m.Version, err = pd.getInt16(); err != nil { + return + } + + if m.Topics, err = pd.getStringArray(); err != nil { + return + } + + if m.UserData, err = pd.getBytes(); err != nil { + return + } + + return nil +} + +type ConsumerGroupMemberAssignment struct { + Version int16 + Topics map[string][]int32 + UserData []byte +} + +func (m *ConsumerGroupMemberAssignment) encode(pe packetEncoder) error { + pe.putInt16(m.Version) + + if err := pe.putArrayLength(len(m.Topics)); err != nil { + return err + } + + for topic, partitions := range m.Topics { + if err := pe.putString(topic); err != nil { + return err + } + if err := pe.putInt32Array(partitions); err != nil { + return err + } + } + + if err := pe.putBytes(m.UserData); err != nil { + return err + } + + return nil +} + +func (m *ConsumerGroupMemberAssignment) decode(pd packetDecoder) (err error) { + if m.Version, err = pd.getInt16(); err != nil { + return + } + + var topicLen int + if topicLen, err = pd.getArrayLength(); err != nil { + return + } + + m.Topics = make(map[string][]int32, topicLen) + for i := 0; i < topicLen; i++ { + var topic string + if topic, err = pd.getString(); err != nil { + return + } + if m.Topics[topic], err = pd.getInt32Array(); err != nil { + return + } + } + + if m.UserData, err = pd.getBytes(); err != nil { + return + } + + return nil +} diff --git a/vendor/github.com/Shopify/sarama/consumer_metadata_request.go b/vendor/github.com/Shopify/sarama/consumer_metadata_request.go new file mode 100644 index 00000000..483be335 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/consumer_metadata_request.go @@ -0,0 +1,26 @@ +package sarama + +type ConsumerMetadataRequest struct { + ConsumerGroup string +} + +func (r *ConsumerMetadataRequest) encode(pe packetEncoder) error { + return pe.putString(r.ConsumerGroup) +} + +func (r *ConsumerMetadataRequest) decode(pd packetDecoder, version int16) (err error) { + r.ConsumerGroup, err = pd.getString() + return err +} + +func (r *ConsumerMetadataRequest) key() int16 { + return 10 +} + +func (r *ConsumerMetadataRequest) version() int16 { + return 0 +} + +func (r *ConsumerMetadataRequest) requiredVersion() KafkaVersion { + return V0_8_2_0 +} diff --git a/vendor/github.com/Shopify/sarama/consumer_metadata_response.go b/vendor/github.com/Shopify/sarama/consumer_metadata_response.go new file mode 100644 index 00000000..6b9632bb --- /dev/null +++ b/vendor/github.com/Shopify/sarama/consumer_metadata_response.go @@ -0,0 +1,85 @@ +package sarama + +import ( + "net" + "strconv" +) + +type ConsumerMetadataResponse struct { + Err KError + Coordinator *Broker + CoordinatorID int32 // deprecated: use Coordinator.ID() + CoordinatorHost string // deprecated: use Coordinator.Addr() + CoordinatorPort int32 // deprecated: use Coordinator.Addr() +} + +func (r *ConsumerMetadataResponse) decode(pd packetDecoder, version int16) (err error) { + tmp, err := pd.getInt16() + if err != nil { + return err + } + r.Err = KError(tmp) + + coordinator := new(Broker) + if err := coordinator.decode(pd); err != nil { + return err + } + if coordinator.addr == ":0" { + return nil + } + r.Coordinator = coordinator + + // this can all go away in 2.0, but we have to fill in deprecated fields to maintain + // backwards compatibility + host, portstr, err := net.SplitHostPort(r.Coordinator.Addr()) + if err != nil { + return err + } + port, err := strconv.ParseInt(portstr, 10, 32) + if err != nil { + return err + } + r.CoordinatorID = r.Coordinator.ID() + r.CoordinatorHost = host + r.CoordinatorPort = int32(port) + + return nil +} + +func (r *ConsumerMetadataResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + if r.Coordinator != nil { + host, portstr, err := net.SplitHostPort(r.Coordinator.Addr()) + if err != nil { + return err + } + port, err := strconv.ParseInt(portstr, 10, 32) + if err != nil { + return err + } + pe.putInt32(r.Coordinator.ID()) + if err := pe.putString(host); err != nil { + return err + } + pe.putInt32(int32(port)) + return nil + } + pe.putInt32(r.CoordinatorID) + if err := pe.putString(r.CoordinatorHost); err != nil { + return err + } + pe.putInt32(r.CoordinatorPort) + return nil +} + +func (r *ConsumerMetadataResponse) key() int16 { + return 10 +} + +func (r *ConsumerMetadataResponse) version() int16 { + return 0 +} + +func (r *ConsumerMetadataResponse) requiredVersion() KafkaVersion { + return V0_8_2_0 +} diff --git a/vendor/github.com/Shopify/sarama/crc32_field.go b/vendor/github.com/Shopify/sarama/crc32_field.go new file mode 100644 index 00000000..5c286079 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/crc32_field.go @@ -0,0 +1,36 @@ +package sarama + +import ( + "encoding/binary" + + "github.com/klauspost/crc32" +) + +// crc32Field implements the pushEncoder and pushDecoder interfaces for calculating CRC32s. +type crc32Field struct { + startOffset int +} + +func (c *crc32Field) saveOffset(in int) { + c.startOffset = in +} + +func (c *crc32Field) reserveLength() int { + return 4 +} + +func (c *crc32Field) run(curOffset int, buf []byte) error { + crc := crc32.ChecksumIEEE(buf[c.startOffset+4 : curOffset]) + binary.BigEndian.PutUint32(buf[c.startOffset:], crc) + return nil +} + +func (c *crc32Field) check(curOffset int, buf []byte) error { + crc := crc32.ChecksumIEEE(buf[c.startOffset+4 : curOffset]) + + if crc != binary.BigEndian.Uint32(buf[c.startOffset:]) { + return PacketDecodingError{"CRC didn't match"} + } + + return nil +} diff --git a/vendor/github.com/Shopify/sarama/describe_groups_request.go b/vendor/github.com/Shopify/sarama/describe_groups_request.go new file mode 100644 index 00000000..1fb35677 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/describe_groups_request.go @@ -0,0 +1,30 @@ +package sarama + +type DescribeGroupsRequest struct { + Groups []string +} + +func (r *DescribeGroupsRequest) encode(pe packetEncoder) error { + return pe.putStringArray(r.Groups) +} + +func (r *DescribeGroupsRequest) decode(pd packetDecoder, version int16) (err error) { + r.Groups, err = pd.getStringArray() + return +} + +func (r *DescribeGroupsRequest) key() int16 { + return 15 +} + +func (r *DescribeGroupsRequest) version() int16 { + return 0 +} + +func (r *DescribeGroupsRequest) requiredVersion() KafkaVersion { + return V0_9_0_0 +} + +func (r *DescribeGroupsRequest) AddGroup(group string) { + r.Groups = append(r.Groups, group) +} diff --git a/vendor/github.com/Shopify/sarama/describe_groups_response.go b/vendor/github.com/Shopify/sarama/describe_groups_response.go new file mode 100644 index 00000000..542b3a97 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/describe_groups_response.go @@ -0,0 +1,187 @@ +package sarama + +type DescribeGroupsResponse struct { + Groups []*GroupDescription +} + +func (r *DescribeGroupsResponse) encode(pe packetEncoder) error { + if err := pe.putArrayLength(len(r.Groups)); err != nil { + return err + } + + for _, groupDescription := range r.Groups { + if err := groupDescription.encode(pe); err != nil { + return err + } + } + + return nil +} + +func (r *DescribeGroupsResponse) decode(pd packetDecoder, version int16) (err error) { + n, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Groups = make([]*GroupDescription, n) + for i := 0; i < n; i++ { + r.Groups[i] = new(GroupDescription) + if err := r.Groups[i].decode(pd); err != nil { + return err + } + } + + return nil +} + +func (r *DescribeGroupsResponse) key() int16 { + return 15 +} + +func (r *DescribeGroupsResponse) version() int16 { + return 0 +} + +func (r *DescribeGroupsResponse) requiredVersion() KafkaVersion { + return V0_9_0_0 +} + +type GroupDescription struct { + Err KError + GroupId string + State string + ProtocolType string + Protocol string + Members map[string]*GroupMemberDescription +} + +func (gd *GroupDescription) encode(pe packetEncoder) error { + pe.putInt16(int16(gd.Err)) + + if err := pe.putString(gd.GroupId); err != nil { + return err + } + if err := pe.putString(gd.State); err != nil { + return err + } + if err := pe.putString(gd.ProtocolType); err != nil { + return err + } + if err := pe.putString(gd.Protocol); err != nil { + return err + } + + if err := pe.putArrayLength(len(gd.Members)); err != nil { + return err + } + + for memberId, groupMemberDescription := range gd.Members { + if err := pe.putString(memberId); err != nil { + return err + } + if err := groupMemberDescription.encode(pe); err != nil { + return err + } + } + + return nil +} + +func (gd *GroupDescription) decode(pd packetDecoder) (err error) { + kerr, err := pd.getInt16() + if err != nil { + return err + } + + gd.Err = KError(kerr) + + if gd.GroupId, err = pd.getString(); err != nil { + return + } + if gd.State, err = pd.getString(); err != nil { + return + } + if gd.ProtocolType, err = pd.getString(); err != nil { + return + } + if gd.Protocol, err = pd.getString(); err != nil { + return + } + + n, err := pd.getArrayLength() + if err != nil { + return err + } + if n == 0 { + return nil + } + + gd.Members = make(map[string]*GroupMemberDescription) + for i := 0; i < n; i++ { + memberId, err := pd.getString() + if err != nil { + return err + } + + gd.Members[memberId] = new(GroupMemberDescription) + if err := gd.Members[memberId].decode(pd); err != nil { + return err + } + } + + return nil +} + +type GroupMemberDescription struct { + ClientId string + ClientHost string + MemberMetadata []byte + MemberAssignment []byte +} + +func (gmd *GroupMemberDescription) encode(pe packetEncoder) error { + if err := pe.putString(gmd.ClientId); err != nil { + return err + } + if err := pe.putString(gmd.ClientHost); err != nil { + return err + } + if err := pe.putBytes(gmd.MemberMetadata); err != nil { + return err + } + if err := pe.putBytes(gmd.MemberAssignment); err != nil { + return err + } + + return nil +} + +func (gmd *GroupMemberDescription) decode(pd packetDecoder) (err error) { + if gmd.ClientId, err = pd.getString(); err != nil { + return + } + if gmd.ClientHost, err = pd.getString(); err != nil { + return + } + if gmd.MemberMetadata, err = pd.getBytes(); err != nil { + return + } + if gmd.MemberAssignment, err = pd.getBytes(); err != nil { + return + } + + return nil +} + +func (gmd *GroupMemberDescription) GetMemberAssignment() (*ConsumerGroupMemberAssignment, error) { + assignment := new(ConsumerGroupMemberAssignment) + err := decode(gmd.MemberAssignment, assignment) + return assignment, err +} + +func (gmd *GroupMemberDescription) GetMemberMetadata() (*ConsumerGroupMemberMetadata, error) { + metadata := new(ConsumerGroupMemberMetadata) + err := decode(gmd.MemberMetadata, metadata) + return metadata, err +} diff --git a/vendor/github.com/Shopify/sarama/dev.yml b/vendor/github.com/Shopify/sarama/dev.yml new file mode 100644 index 00000000..e014316f --- /dev/null +++ b/vendor/github.com/Shopify/sarama/dev.yml @@ -0,0 +1,13 @@ +name: sarama + +up: + - go: 1.7.3 + +commands: + test: + run: make test + desc: 'run unit tests' + +packages: + - git@github.com:Shopify/dev-shopify.git + diff --git a/vendor/github.com/Shopify/sarama/encoder_decoder.go b/vendor/github.com/Shopify/sarama/encoder_decoder.go new file mode 100644 index 00000000..7ce3bc0f --- /dev/null +++ b/vendor/github.com/Shopify/sarama/encoder_decoder.go @@ -0,0 +1,89 @@ +package sarama + +import ( + "fmt" + + "github.com/rcrowley/go-metrics" +) + +// Encoder is the interface that wraps the basic Encode method. +// Anything implementing Encoder can be turned into bytes using Kafka's encoding rules. +type encoder interface { + encode(pe packetEncoder) error +} + +// Encode takes an Encoder and turns it into bytes while potentially recording metrics. +func encode(e encoder, metricRegistry metrics.Registry) ([]byte, error) { + if e == nil { + return nil, nil + } + + var prepEnc prepEncoder + var realEnc realEncoder + + err := e.encode(&prepEnc) + if err != nil { + return nil, err + } + + if prepEnc.length < 0 || prepEnc.length > int(MaxRequestSize) { + return nil, PacketEncodingError{fmt.Sprintf("invalid request size (%d)", prepEnc.length)} + } + + realEnc.raw = make([]byte, prepEnc.length) + realEnc.registry = metricRegistry + err = e.encode(&realEnc) + if err != nil { + return nil, err + } + + return realEnc.raw, nil +} + +// Decoder is the interface that wraps the basic Decode method. +// Anything implementing Decoder can be extracted from bytes using Kafka's encoding rules. +type decoder interface { + decode(pd packetDecoder) error +} + +type versionedDecoder interface { + decode(pd packetDecoder, version int16) error +} + +// Decode takes bytes and a Decoder and fills the fields of the decoder from the bytes, +// interpreted using Kafka's encoding rules. +func decode(buf []byte, in decoder) error { + if buf == nil { + return nil + } + + helper := realDecoder{raw: buf} + err := in.decode(&helper) + if err != nil { + return err + } + + if helper.off != len(buf) { + return PacketDecodingError{"invalid length"} + } + + return nil +} + +func versionedDecode(buf []byte, in versionedDecoder, version int16) error { + if buf == nil { + return nil + } + + helper := realDecoder{raw: buf} + err := in.decode(&helper, version) + if err != nil { + return err + } + + if helper.off != len(buf) { + return PacketDecodingError{"invalid length"} + } + + return nil +} diff --git a/vendor/github.com/Shopify/sarama/errors.go b/vendor/github.com/Shopify/sarama/errors.go new file mode 100644 index 00000000..cc3f623d --- /dev/null +++ b/vendor/github.com/Shopify/sarama/errors.go @@ -0,0 +1,197 @@ +package sarama + +import ( + "errors" + "fmt" +) + +// ErrOutOfBrokers is the error returned when the client has run out of brokers to talk to because all of them errored +// or otherwise failed to respond. +var ErrOutOfBrokers = errors.New("kafka: client has run out of available brokers to talk to (Is your cluster reachable?)") + +// ErrClosedClient is the error returned when a method is called on a client that has been closed. +var ErrClosedClient = errors.New("kafka: tried to use a client that was closed") + +// ErrIncompleteResponse is the error returned when the server returns a syntactically valid response, but it does +// not contain the expected information. +var ErrIncompleteResponse = errors.New("kafka: response did not contain all the expected topic/partition blocks") + +// ErrInvalidPartition is the error returned when a partitioner returns an invalid partition index +// (meaning one outside of the range [0...numPartitions-1]). +var ErrInvalidPartition = errors.New("kafka: partitioner returned an invalid partition index") + +// ErrAlreadyConnected is the error returned when calling Open() on a Broker that is already connected or connecting. +var ErrAlreadyConnected = errors.New("kafka: broker connection already initiated") + +// ErrNotConnected is the error returned when trying to send or call Close() on a Broker that is not connected. +var ErrNotConnected = errors.New("kafka: broker not connected") + +// ErrInsufficientData is returned when decoding and the packet is truncated. This can be expected +// when requesting messages, since as an optimization the server is allowed to return a partial message at the end +// of the message set. +var ErrInsufficientData = errors.New("kafka: insufficient data to decode packet, more bytes expected") + +// ErrShuttingDown is returned when a producer receives a message during shutdown. +var ErrShuttingDown = errors.New("kafka: message received by producer in process of shutting down") + +// ErrMessageTooLarge is returned when the next message to consume is larger than the configured Consumer.Fetch.Max +var ErrMessageTooLarge = errors.New("kafka: message is larger than Consumer.Fetch.Max") + +// PacketEncodingError is returned from a failure while encoding a Kafka packet. This can happen, for example, +// if you try to encode a string over 2^15 characters in length, since Kafka's encoding rules do not permit that. +type PacketEncodingError struct { + Info string +} + +func (err PacketEncodingError) Error() string { + return fmt.Sprintf("kafka: error encoding packet: %s", err.Info) +} + +// PacketDecodingError is returned when there was an error (other than truncated data) decoding the Kafka broker's response. +// This can be a bad CRC or length field, or any other invalid value. +type PacketDecodingError struct { + Info string +} + +func (err PacketDecodingError) Error() string { + return fmt.Sprintf("kafka: error decoding packet: %s", err.Info) +} + +// ConfigurationError is the type of error returned from a constructor (e.g. NewClient, or NewConsumer) +// when the specified configuration is invalid. +type ConfigurationError string + +func (err ConfigurationError) Error() string { + return "kafka: invalid configuration (" + string(err) + ")" +} + +// KError is the type of error that can be returned directly by the Kafka broker. +// See https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol#AGuideToTheKafkaProtocol-ErrorCodes +type KError int16 + +// Numeric error codes returned by the Kafka server. +const ( + ErrNoError KError = 0 + ErrUnknown KError = -1 + ErrOffsetOutOfRange KError = 1 + ErrInvalidMessage KError = 2 + ErrUnknownTopicOrPartition KError = 3 + ErrInvalidMessageSize KError = 4 + ErrLeaderNotAvailable KError = 5 + ErrNotLeaderForPartition KError = 6 + ErrRequestTimedOut KError = 7 + ErrBrokerNotAvailable KError = 8 + ErrReplicaNotAvailable KError = 9 + ErrMessageSizeTooLarge KError = 10 + ErrStaleControllerEpochCode KError = 11 + ErrOffsetMetadataTooLarge KError = 12 + ErrNetworkException KError = 13 + ErrOffsetsLoadInProgress KError = 14 + ErrConsumerCoordinatorNotAvailable KError = 15 + ErrNotCoordinatorForConsumer KError = 16 + ErrInvalidTopic KError = 17 + ErrMessageSetSizeTooLarge KError = 18 + ErrNotEnoughReplicas KError = 19 + ErrNotEnoughReplicasAfterAppend KError = 20 + ErrInvalidRequiredAcks KError = 21 + ErrIllegalGeneration KError = 22 + ErrInconsistentGroupProtocol KError = 23 + ErrInvalidGroupId KError = 24 + ErrUnknownMemberId KError = 25 + ErrInvalidSessionTimeout KError = 26 + ErrRebalanceInProgress KError = 27 + ErrInvalidCommitOffsetSize KError = 28 + ErrTopicAuthorizationFailed KError = 29 + ErrGroupAuthorizationFailed KError = 30 + ErrClusterAuthorizationFailed KError = 31 + ErrInvalidTimestamp KError = 32 + ErrUnsupportedSASLMechanism KError = 33 + ErrIllegalSASLState KError = 34 + ErrUnsupportedVersion KError = 35 + ErrUnsupportedForMessageFormat KError = 43 +) + +func (err KError) Error() string { + // Error messages stolen/adapted from + // https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol + switch err { + case ErrNoError: + return "kafka server: Not an error, why are you printing me?" + case ErrUnknown: + return "kafka server: Unexpected (unknown?) server error." + case ErrOffsetOutOfRange: + return "kafka server: The requested offset is outside the range of offsets maintained by the server for the given topic/partition." + case ErrInvalidMessage: + return "kafka server: Message contents does not match its CRC." + case ErrUnknownTopicOrPartition: + return "kafka server: Request was for a topic or partition that does not exist on this broker." + case ErrInvalidMessageSize: + return "kafka server: The message has a negative size." + case ErrLeaderNotAvailable: + return "kafka server: In the middle of a leadership election, there is currently no leader for this partition and hence it is unavailable for writes." + case ErrNotLeaderForPartition: + return "kafka server: Tried to send a message to a replica that is not the leader for some partition. Your metadata is out of date." + case ErrRequestTimedOut: + return "kafka server: Request exceeded the user-specified time limit in the request." + case ErrBrokerNotAvailable: + return "kafka server: Broker not available. Not a client facing error, we should never receive this!!!" + case ErrReplicaNotAvailable: + return "kafka server: Replica information not available, one or more brokers are down." + case ErrMessageSizeTooLarge: + return "kafka server: Message was too large, server rejected it to avoid allocation error." + case ErrStaleControllerEpochCode: + return "kafka server: StaleControllerEpochCode (internal error code for broker-to-broker communication)." + case ErrOffsetMetadataTooLarge: + return "kafka server: Specified a string larger than the configured maximum for offset metadata." + case ErrNetworkException: + return "kafka server: The server disconnected before a response was received." + case ErrOffsetsLoadInProgress: + return "kafka server: The broker is still loading offsets after a leader change for that offset's topic partition." + case ErrConsumerCoordinatorNotAvailable: + return "kafka server: Offset's topic has not yet been created." + case ErrNotCoordinatorForConsumer: + return "kafka server: Request was for a consumer group that is not coordinated by this broker." + case ErrInvalidTopic: + return "kafka server: The request attempted to perform an operation on an invalid topic." + case ErrMessageSetSizeTooLarge: + return "kafka server: The request included message batch larger than the configured segment size on the server." + case ErrNotEnoughReplicas: + return "kafka server: Messages are rejected since there are fewer in-sync replicas than required." + case ErrNotEnoughReplicasAfterAppend: + return "kafka server: Messages are written to the log, but to fewer in-sync replicas than required." + case ErrInvalidRequiredAcks: + return "kafka server: The number of required acks is invalid (should be either -1, 0, or 1)." + case ErrIllegalGeneration: + return "kafka server: The provided generation id is not the current generation." + case ErrInconsistentGroupProtocol: + return "kafka server: The provider group protocol type is incompatible with the other members." + case ErrInvalidGroupId: + return "kafka server: The provided group id was empty." + case ErrUnknownMemberId: + return "kafka server: The provided member is not known in the current generation." + case ErrInvalidSessionTimeout: + return "kafka server: The provided session timeout is outside the allowed range." + case ErrRebalanceInProgress: + return "kafka server: A rebalance for the group is in progress. Please re-join the group." + case ErrInvalidCommitOffsetSize: + return "kafka server: The provided commit metadata was too large." + case ErrTopicAuthorizationFailed: + return "kafka server: The client is not authorized to access this topic." + case ErrGroupAuthorizationFailed: + return "kafka server: The client is not authorized to access this group." + case ErrClusterAuthorizationFailed: + return "kafka server: The client is not authorized to send this request type." + case ErrInvalidTimestamp: + return "kafka server: The timestamp of the message is out of acceptable range." + case ErrUnsupportedSASLMechanism: + return "kafka server: The broker does not support the requested SASL mechanism." + case ErrIllegalSASLState: + return "kafka server: Request is not valid given the current SASL state." + case ErrUnsupportedVersion: + return "kafka server: The version of API is not supported." + case ErrUnsupportedForMessageFormat: + return "kafka server: The requested operation is not supported by the message format version." + } + + return fmt.Sprintf("Unknown error, how did this happen? Error code = %d", err) +} diff --git a/vendor/github.com/Shopify/sarama/fetch_request.go b/vendor/github.com/Shopify/sarama/fetch_request.go new file mode 100644 index 00000000..ab817a06 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/fetch_request.go @@ -0,0 +1,136 @@ +package sarama + +type fetchRequestBlock struct { + fetchOffset int64 + maxBytes int32 +} + +func (b *fetchRequestBlock) encode(pe packetEncoder) error { + pe.putInt64(b.fetchOffset) + pe.putInt32(b.maxBytes) + return nil +} + +func (b *fetchRequestBlock) decode(pd packetDecoder) (err error) { + if b.fetchOffset, err = pd.getInt64(); err != nil { + return err + } + if b.maxBytes, err = pd.getInt32(); err != nil { + return err + } + return nil +} + +type FetchRequest struct { + MaxWaitTime int32 + MinBytes int32 + Version int16 + blocks map[string]map[int32]*fetchRequestBlock +} + +func (r *FetchRequest) encode(pe packetEncoder) (err error) { + pe.putInt32(-1) // replica ID is always -1 for clients + pe.putInt32(r.MaxWaitTime) + pe.putInt32(r.MinBytes) + err = pe.putArrayLength(len(r.blocks)) + if err != nil { + return err + } + for topic, blocks := range r.blocks { + err = pe.putString(topic) + if err != nil { + return err + } + err = pe.putArrayLength(len(blocks)) + if err != nil { + return err + } + for partition, block := range blocks { + pe.putInt32(partition) + err = block.encode(pe) + if err != nil { + return err + } + } + } + return nil +} + +func (r *FetchRequest) decode(pd packetDecoder, version int16) (err error) { + r.Version = version + if _, err = pd.getInt32(); err != nil { + return err + } + if r.MaxWaitTime, err = pd.getInt32(); err != nil { + return err + } + if r.MinBytes, err = pd.getInt32(); err != nil { + return err + } + topicCount, err := pd.getArrayLength() + if err != nil { + return err + } + if topicCount == 0 { + return nil + } + r.blocks = make(map[string]map[int32]*fetchRequestBlock) + for i := 0; i < topicCount; i++ { + topic, err := pd.getString() + if err != nil { + return err + } + partitionCount, err := pd.getArrayLength() + if err != nil { + return err + } + r.blocks[topic] = make(map[int32]*fetchRequestBlock) + for j := 0; j < partitionCount; j++ { + partition, err := pd.getInt32() + if err != nil { + return err + } + fetchBlock := &fetchRequestBlock{} + if err = fetchBlock.decode(pd); err != nil { + return err + } + r.blocks[topic][partition] = fetchBlock + } + } + return nil +} + +func (r *FetchRequest) key() int16 { + return 1 +} + +func (r *FetchRequest) version() int16 { + return r.Version +} + +func (r *FetchRequest) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_9_0_0 + case 2: + return V0_10_0_0 + default: + return minVersion + } +} + +func (r *FetchRequest) AddBlock(topic string, partitionID int32, fetchOffset int64, maxBytes int32) { + if r.blocks == nil { + r.blocks = make(map[string]map[int32]*fetchRequestBlock) + } + + if r.blocks[topic] == nil { + r.blocks[topic] = make(map[int32]*fetchRequestBlock) + } + + tmp := new(fetchRequestBlock) + tmp.maxBytes = maxBytes + tmp.fetchOffset = fetchOffset + + r.blocks[topic][partitionID] = tmp +} diff --git a/vendor/github.com/Shopify/sarama/fetch_response.go b/vendor/github.com/Shopify/sarama/fetch_response.go new file mode 100644 index 00000000..b56b166c --- /dev/null +++ b/vendor/github.com/Shopify/sarama/fetch_response.go @@ -0,0 +1,210 @@ +package sarama + +import "time" + +type FetchResponseBlock struct { + Err KError + HighWaterMarkOffset int64 + MsgSet MessageSet +} + +func (b *FetchResponseBlock) decode(pd packetDecoder) (err error) { + tmp, err := pd.getInt16() + if err != nil { + return err + } + b.Err = KError(tmp) + + b.HighWaterMarkOffset, err = pd.getInt64() + if err != nil { + return err + } + + msgSetSize, err := pd.getInt32() + if err != nil { + return err + } + + msgSetDecoder, err := pd.getSubset(int(msgSetSize)) + if err != nil { + return err + } + err = (&b.MsgSet).decode(msgSetDecoder) + + return err +} + +func (b *FetchResponseBlock) encode(pe packetEncoder) (err error) { + pe.putInt16(int16(b.Err)) + + pe.putInt64(b.HighWaterMarkOffset) + + pe.push(&lengthField{}) + err = b.MsgSet.encode(pe) + if err != nil { + return err + } + return pe.pop() +} + +type FetchResponse struct { + Blocks map[string]map[int32]*FetchResponseBlock + ThrottleTime time.Duration + Version int16 // v1 requires 0.9+, v2 requires 0.10+ +} + +func (r *FetchResponse) decode(pd packetDecoder, version int16) (err error) { + r.Version = version + + if r.Version >= 1 { + throttle, err := pd.getInt32() + if err != nil { + return err + } + r.ThrottleTime = time.Duration(throttle) * time.Millisecond + } + + numTopics, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Blocks = make(map[string]map[int32]*FetchResponseBlock, numTopics) + for i := 0; i < numTopics; i++ { + name, err := pd.getString() + if err != nil { + return err + } + + numBlocks, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Blocks[name] = make(map[int32]*FetchResponseBlock, numBlocks) + + for j := 0; j < numBlocks; j++ { + id, err := pd.getInt32() + if err != nil { + return err + } + + block := new(FetchResponseBlock) + err = block.decode(pd) + if err != nil { + return err + } + r.Blocks[name][id] = block + } + } + + return nil +} + +func (r *FetchResponse) encode(pe packetEncoder) (err error) { + if r.Version >= 1 { + pe.putInt32(int32(r.ThrottleTime / time.Millisecond)) + } + + err = pe.putArrayLength(len(r.Blocks)) + if err != nil { + return err + } + + for topic, partitions := range r.Blocks { + err = pe.putString(topic) + if err != nil { + return err + } + + err = pe.putArrayLength(len(partitions)) + if err != nil { + return err + } + + for id, block := range partitions { + pe.putInt32(id) + err = block.encode(pe) + if err != nil { + return err + } + } + + } + return nil +} + +func (r *FetchResponse) key() int16 { + return 1 +} + +func (r *FetchResponse) version() int16 { + return r.Version +} + +func (r *FetchResponse) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_9_0_0 + case 2: + return V0_10_0_0 + default: + return minVersion + } +} + +func (r *FetchResponse) GetBlock(topic string, partition int32) *FetchResponseBlock { + if r.Blocks == nil { + return nil + } + + if r.Blocks[topic] == nil { + return nil + } + + return r.Blocks[topic][partition] +} + +func (r *FetchResponse) AddError(topic string, partition int32, err KError) { + if r.Blocks == nil { + r.Blocks = make(map[string]map[int32]*FetchResponseBlock) + } + partitions, ok := r.Blocks[topic] + if !ok { + partitions = make(map[int32]*FetchResponseBlock) + r.Blocks[topic] = partitions + } + frb, ok := partitions[partition] + if !ok { + frb = new(FetchResponseBlock) + partitions[partition] = frb + } + frb.Err = err +} + +func (r *FetchResponse) AddMessage(topic string, partition int32, key, value Encoder, offset int64) { + if r.Blocks == nil { + r.Blocks = make(map[string]map[int32]*FetchResponseBlock) + } + partitions, ok := r.Blocks[topic] + if !ok { + partitions = make(map[int32]*FetchResponseBlock) + r.Blocks[topic] = partitions + } + frb, ok := partitions[partition] + if !ok { + frb = new(FetchResponseBlock) + partitions[partition] = frb + } + var kb []byte + var vb []byte + if key != nil { + kb, _ = key.Encode() + } + if value != nil { + vb, _ = value.Encode() + } + msg := &Message{Key: kb, Value: vb} + msgBlock := &MessageBlock{Msg: msg, Offset: offset} + frb.MsgSet.Messages = append(frb.MsgSet.Messages, msgBlock) +} diff --git a/vendor/github.com/Shopify/sarama/heartbeat_request.go b/vendor/github.com/Shopify/sarama/heartbeat_request.go new file mode 100644 index 00000000..ce49c473 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/heartbeat_request.go @@ -0,0 +1,47 @@ +package sarama + +type HeartbeatRequest struct { + GroupId string + GenerationId int32 + MemberId string +} + +func (r *HeartbeatRequest) encode(pe packetEncoder) error { + if err := pe.putString(r.GroupId); err != nil { + return err + } + + pe.putInt32(r.GenerationId) + + if err := pe.putString(r.MemberId); err != nil { + return err + } + + return nil +} + +func (r *HeartbeatRequest) decode(pd packetDecoder, version int16) (err error) { + if r.GroupId, err = pd.getString(); err != nil { + return + } + if r.GenerationId, err = pd.getInt32(); err != nil { + return + } + if r.MemberId, err = pd.getString(); err != nil { + return + } + + return nil +} + +func (r *HeartbeatRequest) key() int16 { + return 12 +} + +func (r *HeartbeatRequest) version() int16 { + return 0 +} + +func (r *HeartbeatRequest) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/heartbeat_response.go b/vendor/github.com/Shopify/sarama/heartbeat_response.go new file mode 100644 index 00000000..766f5fde --- /dev/null +++ b/vendor/github.com/Shopify/sarama/heartbeat_response.go @@ -0,0 +1,32 @@ +package sarama + +type HeartbeatResponse struct { + Err KError +} + +func (r *HeartbeatResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + return nil +} + +func (r *HeartbeatResponse) decode(pd packetDecoder, version int16) error { + kerr, err := pd.getInt16() + if err != nil { + return err + } + r.Err = KError(kerr) + + return nil +} + +func (r *HeartbeatResponse) key() int16 { + return 12 +} + +func (r *HeartbeatResponse) version() int16 { + return 0 +} + +func (r *HeartbeatResponse) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/join_group_request.go b/vendor/github.com/Shopify/sarama/join_group_request.go new file mode 100644 index 00000000..656db456 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/join_group_request.go @@ -0,0 +1,108 @@ +package sarama + +type JoinGroupRequest struct { + GroupId string + SessionTimeout int32 + MemberId string + ProtocolType string + GroupProtocols map[string][]byte +} + +func (r *JoinGroupRequest) encode(pe packetEncoder) error { + if err := pe.putString(r.GroupId); err != nil { + return err + } + pe.putInt32(r.SessionTimeout) + if err := pe.putString(r.MemberId); err != nil { + return err + } + if err := pe.putString(r.ProtocolType); err != nil { + return err + } + + if err := pe.putArrayLength(len(r.GroupProtocols)); err != nil { + return err + } + for name, metadata := range r.GroupProtocols { + if err := pe.putString(name); err != nil { + return err + } + if err := pe.putBytes(metadata); err != nil { + return err + } + } + + return nil +} + +func (r *JoinGroupRequest) decode(pd packetDecoder, version int16) (err error) { + if r.GroupId, err = pd.getString(); err != nil { + return + } + + if r.SessionTimeout, err = pd.getInt32(); err != nil { + return + } + + if r.MemberId, err = pd.getString(); err != nil { + return + } + + if r.ProtocolType, err = pd.getString(); err != nil { + return + } + + n, err := pd.getArrayLength() + if err != nil { + return err + } + if n == 0 { + return nil + } + + r.GroupProtocols = make(map[string][]byte) + for i := 0; i < n; i++ { + name, err := pd.getString() + if err != nil { + return err + } + metadata, err := pd.getBytes() + if err != nil { + return err + } + + r.GroupProtocols[name] = metadata + } + + return nil +} + +func (r *JoinGroupRequest) key() int16 { + return 11 +} + +func (r *JoinGroupRequest) version() int16 { + return 0 +} + +func (r *JoinGroupRequest) requiredVersion() KafkaVersion { + return V0_9_0_0 +} + +func (r *JoinGroupRequest) AddGroupProtocol(name string, metadata []byte) { + if r.GroupProtocols == nil { + r.GroupProtocols = make(map[string][]byte) + } + + r.GroupProtocols[name] = metadata +} + +func (r *JoinGroupRequest) AddGroupProtocolMetadata(name string, metadata *ConsumerGroupMemberMetadata) error { + bin, err := encode(metadata, nil) + if err != nil { + return err + } + + r.AddGroupProtocol(name, bin) + return nil +} diff --git a/vendor/github.com/Shopify/sarama/join_group_response.go b/vendor/github.com/Shopify/sarama/join_group_response.go new file mode 100644 index 00000000..6d35fe36 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/join_group_response.go @@ -0,0 +1,115 @@ +package sarama + +type JoinGroupResponse struct { + Err KError + GenerationId int32 + GroupProtocol string + LeaderId string + MemberId string + Members map[string][]byte +} + +func (r *JoinGroupResponse) GetMembers() (map[string]ConsumerGroupMemberMetadata, error) { + members := make(map[string]ConsumerGroupMemberMetadata, len(r.Members)) + for id, bin := range r.Members { + meta := new(ConsumerGroupMemberMetadata) + if err := decode(bin, meta); err != nil { + return nil, err + } + members[id] = *meta + } + return members, nil +} + +func (r *JoinGroupResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + pe.putInt32(r.GenerationId) + + if err := pe.putString(r.GroupProtocol); err != nil { + return err + } + if err := pe.putString(r.LeaderId); err != nil { + return err + } + if err := pe.putString(r.MemberId); err != nil { + return err + } + + if err := pe.putArrayLength(len(r.Members)); err != nil { + return err + } + + for memberId, memberMetadata := range r.Members { + if err := pe.putString(memberId); err != nil { + return err + } + + if err := pe.putBytes(memberMetadata); err != nil { + return err + } + } + + return nil +} + +func (r *JoinGroupResponse) decode(pd packetDecoder, version int16) (err error) { + kerr, err := pd.getInt16() + if err != nil { + return err + } + + r.Err = KError(kerr) + + if r.GenerationId, err = pd.getInt32(); err != nil { + return + } + + if r.GroupProtocol, err = pd.getString(); err != nil { + return + } + + if r.LeaderId, err = pd.getString(); err != nil { + return + } + + if r.MemberId, err = pd.getString(); err != nil { + return + } + + n, err := pd.getArrayLength() + if err != nil { + return err + } + if n == 0 { + return nil + } + + r.Members = make(map[string][]byte) + for i := 0; i < n; i++ { + memberId, err := pd.getString() + if err != nil { + return err + } + + memberMetadata, err := pd.getBytes() + if err != nil { + return err + } + + r.Members[memberId] = memberMetadata + } + + return nil +} + +func (r *JoinGroupResponse) key() int16 { + return 11 +} + +func (r *JoinGroupResponse) version() int16 { + return 0 +} + +func (r *JoinGroupResponse) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/leave_group_request.go b/vendor/github.com/Shopify/sarama/leave_group_request.go new file mode 100644 index 00000000..e1774274 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/leave_group_request.go @@ -0,0 +1,40 @@ +package sarama + +type LeaveGroupRequest struct { + GroupId string + MemberId string +} + +func (r *LeaveGroupRequest) encode(pe packetEncoder) error { + if err := pe.putString(r.GroupId); err != nil { + return err + } + if err := pe.putString(r.MemberId); err != nil { + return err + } + + return nil +} + +func (r *LeaveGroupRequest) decode(pd packetDecoder, version int16) (err error) { + if r.GroupId, err = pd.getString(); err != nil { + return + } + if r.MemberId, err = pd.getString(); err != nil { + return + } + + return nil +} + +func (r *LeaveGroupRequest) key() int16 { + return 13 +} + +func (r *LeaveGroupRequest) version() int16 { + return 0 +} + +func (r *LeaveGroupRequest) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/leave_group_response.go b/vendor/github.com/Shopify/sarama/leave_group_response.go new file mode 100644 index 00000000..d60c626d --- /dev/null +++ b/vendor/github.com/Shopify/sarama/leave_group_response.go @@ -0,0 +1,32 @@ +package sarama + +type LeaveGroupResponse struct { + Err KError +} + +func (r *LeaveGroupResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + return nil +} + +func (r *LeaveGroupResponse) decode(pd packetDecoder, version int16) (err error) { + kerr, err := pd.getInt16() + if err != nil { + return err + } + r.Err = KError(kerr) + + return nil +} + +func (r *LeaveGroupResponse) key() int16 { + return 13 +} + +func (r *LeaveGroupResponse) version() int16 { + return 0 +} + +func (r *LeaveGroupResponse) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/length_field.go b/vendor/github.com/Shopify/sarama/length_field.go new file mode 100644 index 00000000..70078be5 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/length_field.go @@ -0,0 +1,29 @@ +package sarama + +import "encoding/binary" + +// LengthField implements the PushEncoder and PushDecoder interfaces for calculating 4-byte lengths. +type lengthField struct { + startOffset int +} + +func (l *lengthField) saveOffset(in int) { + l.startOffset = in +} + +func (l *lengthField) reserveLength() int { + return 4 +} + +func (l *lengthField) run(curOffset int, buf []byte) error { + binary.BigEndian.PutUint32(buf[l.startOffset:], uint32(curOffset-l.startOffset-4)) + return nil +} + +func (l *lengthField) check(curOffset int, buf []byte) error { + if uint32(curOffset-l.startOffset-4) != binary.BigEndian.Uint32(buf[l.startOffset:]) { + return PacketDecodingError{"length field invalid"} + } + + return nil +} diff --git a/vendor/github.com/Shopify/sarama/list_groups_request.go b/vendor/github.com/Shopify/sarama/list_groups_request.go new file mode 100644 index 00000000..3b16abf7 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/list_groups_request.go @@ -0,0 +1,24 @@ +package sarama + +type ListGroupsRequest struct { +} + +func (r *ListGroupsRequest) encode(pe packetEncoder) error { + return nil +} + +func (r *ListGroupsRequest) decode(pd packetDecoder, version int16) (err error) { + return nil +} + +func (r *ListGroupsRequest) key() int16 { + return 16 +} + +func (r *ListGroupsRequest) version() int16 { + return 0 +} + +func (r *ListGroupsRequest) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/list_groups_response.go b/vendor/github.com/Shopify/sarama/list_groups_response.go new file mode 100644 index 00000000..56115d4c --- /dev/null +++ b/vendor/github.com/Shopify/sarama/list_groups_response.go @@ -0,0 +1,69 @@ +package sarama + +type ListGroupsResponse struct { + Err KError + Groups map[string]string +} + +func (r *ListGroupsResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + + if err := pe.putArrayLength(len(r.Groups)); err != nil { + return err + } + for groupId, protocolType := range r.Groups { + if err := pe.putString(groupId); err != nil { + return err + } + if err := pe.putString(protocolType); err != nil { + return err + } + } + + return nil +} + +func (r *ListGroupsResponse) decode(pd packetDecoder, version int16) error { + kerr, err := pd.getInt16() + if err != nil { + return err + } + + r.Err = KError(kerr) + + n, err := pd.getArrayLength() + if err != nil { + return err + } + if n == 0 { + return nil + } + + r.Groups = make(map[string]string) + for i := 0; i < n; i++ { + groupId, err := pd.getString() + if err != nil { + return err + } + protocolType, err := pd.getString() + if err != nil { + return err + } + + r.Groups[groupId] = protocolType + } + + return nil +} + +func (r *ListGroupsResponse) key() int16 { + return 16 +} + +func (r *ListGroupsResponse) version() int16 { + return 0 +} + +func (r *ListGroupsResponse) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/message.go b/vendor/github.com/Shopify/sarama/message.go new file mode 100644 index 00000000..327c5fa2 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/message.go @@ -0,0 +1,196 @@ +package sarama + +import ( + "bytes" + "compress/gzip" + "fmt" + "io/ioutil" + "time" + + "github.com/eapache/go-xerial-snappy" + "github.com/pierrec/lz4" +) + +// CompressionCodec represents the various compression codecs recognized by Kafka in messages. +type CompressionCodec int8 + +// only the last two bits are really used +const compressionCodecMask int8 = 0x03 + +const ( + CompressionNone CompressionCodec = 0 + CompressionGZIP CompressionCodec = 1 + CompressionSnappy CompressionCodec = 2 + CompressionLZ4 CompressionCodec = 3 +) + +type Message struct { + Codec CompressionCodec // codec used to compress the message contents + Key []byte // the message key, may be nil + Value []byte // the message contents + Set *MessageSet // the message set a message might wrap + Version int8 // v1 requires Kafka 0.10 + Timestamp time.Time // the timestamp of the message (version 1+ only) + + compressedCache []byte + compressedSize int // used for computing the compression ratio metrics +} + +func (m *Message) encode(pe packetEncoder) error { + pe.push(&crc32Field{}) + + pe.putInt8(m.Version) + + attributes := int8(m.Codec) & compressionCodecMask + pe.putInt8(attributes) + + if m.Version >= 1 { + pe.putInt64(m.Timestamp.UnixNano() / int64(time.Millisecond)) + } + + err := pe.putBytes(m.Key) + if err != nil { + return err + } + + var payload []byte + + if m.compressedCache != nil { + payload = m.compressedCache + m.compressedCache = nil + } else if m.Value != nil { + switch m.Codec { + case CompressionNone: + payload = m.Value + case CompressionGZIP: + var buf bytes.Buffer + writer := gzip.NewWriter(&buf) + if _, err = writer.Write(m.Value); err != nil { + return err + } + if err = writer.Close(); err != nil { + return err + } + m.compressedCache = buf.Bytes() + payload = m.compressedCache + case CompressionSnappy: + tmp := snappy.Encode(m.Value) + m.compressedCache = tmp + payload = m.compressedCache + case CompressionLZ4: + var buf bytes.Buffer + writer := lz4.NewWriter(&buf) + if _, err = writer.Write(m.Value); err != nil { + return err + } + if err = writer.Close(); err != nil { + return err + } + m.compressedCache = buf.Bytes() + payload = m.compressedCache + + default: + return PacketEncodingError{fmt.Sprintf("unsupported compression codec (%d)", m.Codec)} + } + // Keep in mind the compressed payload size for metric gathering + m.compressedSize = len(payload) + } + + if err = pe.putBytes(payload); err != nil { + return err + } + + return pe.pop() +} + +func (m *Message) decode(pd packetDecoder) (err error) { + err = pd.push(&crc32Field{}) + if err != nil { + return err + } + + m.Version, err = pd.getInt8() + if err != nil { + return err + } + + attribute, err := pd.getInt8() + if err != nil { + return err + } + m.Codec = CompressionCodec(attribute & compressionCodecMask) + + if m.Version >= 1 { + millis, err := pd.getInt64() + if err != nil { + return err + } + m.Timestamp = time.Unix(millis/1000, (millis%1000)*int64(time.Millisecond)) + } + + m.Key, err = pd.getBytes() + if err != nil { + return err + } + + m.Value, err = pd.getBytes() + if err != nil { + return err + } + + // Required for deep equal assertion during tests but might be useful + // for future metrics about the compression ratio in fetch requests + m.compressedSize = len(m.Value) + + switch m.Codec { + case CompressionNone: + // nothing to do + case CompressionGZIP: + if m.Value == nil { + break + } + reader, err := gzip.NewReader(bytes.NewReader(m.Value)) + if err != nil { + return err + } + if m.Value, err = ioutil.ReadAll(reader); err != nil { + return err + } + if err := m.decodeSet(); err != nil { + return err + } + case CompressionSnappy: + if m.Value == nil { + break + } + if m.Value, err = snappy.Decode(m.Value); err != nil { + return err + } + if err := m.decodeSet(); err != nil { + return err + } + case CompressionLZ4: + if m.Value == nil { + break + } + reader := lz4.NewReader(bytes.NewReader(m.Value)) + if m.Value, err = ioutil.ReadAll(reader); err != nil { + return err + } + if err := m.decodeSet(); err != nil { + return err + } + + default: + return PacketDecodingError{fmt.Sprintf("invalid compression specified (%d)", m.Codec)} + } + + return pd.pop() +} + +// decodes a message set from a previousy encoded bulk-message +func (m *Message) decodeSet() (err error) { + pd := realDecoder{raw: m.Value} + m.Set = &MessageSet{} + return m.Set.decode(&pd) +} diff --git a/vendor/github.com/Shopify/sarama/message_set.go b/vendor/github.com/Shopify/sarama/message_set.go new file mode 100644 index 00000000..f028784e --- /dev/null +++ b/vendor/github.com/Shopify/sarama/message_set.go @@ -0,0 +1,89 @@ +package sarama + +type MessageBlock struct { + Offset int64 + Msg *Message +} + +// Messages convenience helper which returns either all the +// messages that are wrapped in this block +func (msb *MessageBlock) Messages() []*MessageBlock { + if msb.Msg.Set != nil { + return msb.Msg.Set.Messages + } + return []*MessageBlock{msb} +} + +func (msb *MessageBlock) encode(pe packetEncoder) error { + pe.putInt64(msb.Offset) + pe.push(&lengthField{}) + err := msb.Msg.encode(pe) + if err != nil { + return err + } + return pe.pop() +} + +func (msb *MessageBlock) decode(pd packetDecoder) (err error) { + if msb.Offset, err = pd.getInt64(); err != nil { + return err + } + + if err = pd.push(&lengthField{}); err != nil { + return err + } + + msb.Msg = new(Message) + if err = msb.Msg.decode(pd); err != nil { + return err + } + + if err = pd.pop(); err != nil { + return err + } + + return nil +} + +type MessageSet struct { + PartialTrailingMessage bool // whether the set on the wire contained an incomplete trailing MessageBlock + Messages []*MessageBlock +} + +func (ms *MessageSet) encode(pe packetEncoder) error { + for i := range ms.Messages { + err := ms.Messages[i].encode(pe) + if err != nil { + return err + } + } + return nil +} + +func (ms *MessageSet) decode(pd packetDecoder) (err error) { + ms.Messages = nil + + for pd.remaining() > 0 { + msb := new(MessageBlock) + err = msb.decode(pd) + switch err { + case nil: + ms.Messages = append(ms.Messages, msb) + case ErrInsufficientData: + // As an optimization the server is allowed to return a partial message at the + // end of the message set. Clients should handle this case. So we just ignore such things. + ms.PartialTrailingMessage = true + return nil + default: + return err + } + } + + return nil +} + +func (ms *MessageSet) addMessage(msg *Message) { + block := new(MessageBlock) + block.Msg = msg + ms.Messages = append(ms.Messages, block) +} diff --git a/vendor/github.com/Shopify/sarama/metadata_request.go b/vendor/github.com/Shopify/sarama/metadata_request.go new file mode 100644 index 00000000..9a26b55f --- /dev/null +++ b/vendor/github.com/Shopify/sarama/metadata_request.go @@ -0,0 +1,52 @@ +package sarama + +type MetadataRequest struct { + Topics []string +} + +func (r *MetadataRequest) encode(pe packetEncoder) error { + err := pe.putArrayLength(len(r.Topics)) + if err != nil { + return err + } + + for i := range r.Topics { + err = pe.putString(r.Topics[i]) + if err != nil { + return err + } + } + return nil +} + +func (r *MetadataRequest) decode(pd packetDecoder, version int16) error { + topicCount, err := pd.getArrayLength() + if err != nil { + return err + } + if topicCount == 0 { + return nil + } + + r.Topics = make([]string, topicCount) + for i := range r.Topics { + topic, err := pd.getString() + if err != nil { + return err + } + r.Topics[i] = topic + } + return nil +} + +func (r *MetadataRequest) key() int16 { + return 3 +} + +func (r *MetadataRequest) version() int16 { + return 0 +} + +func (r *MetadataRequest) requiredVersion() KafkaVersion { + return minVersion +} diff --git a/vendor/github.com/Shopify/sarama/metadata_response.go b/vendor/github.com/Shopify/sarama/metadata_response.go new file mode 100644 index 00000000..f9d6a427 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/metadata_response.go @@ -0,0 +1,239 @@ +package sarama + +type PartitionMetadata struct { + Err KError + ID int32 + Leader int32 + Replicas []int32 + Isr []int32 +} + +func (pm *PartitionMetadata) decode(pd packetDecoder) (err error) { + tmp, err := pd.getInt16() + if err != nil { + return err + } + pm.Err = KError(tmp) + + pm.ID, err = pd.getInt32() + if err != nil { + return err + } + + pm.Leader, err = pd.getInt32() + if err != nil { + return err + } + + pm.Replicas, err = pd.getInt32Array() + if err != nil { + return err + } + + pm.Isr, err = pd.getInt32Array() + if err != nil { + return err + } + + return nil +} + +func (pm *PartitionMetadata) encode(pe packetEncoder) (err error) { + pe.putInt16(int16(pm.Err)) + pe.putInt32(pm.ID) + pe.putInt32(pm.Leader) + + err = pe.putInt32Array(pm.Replicas) + if err != nil { + return err + } + + err = pe.putInt32Array(pm.Isr) + if err != nil { + return err + } + + return nil +} + +type TopicMetadata struct { + Err KError + Name string + Partitions []*PartitionMetadata +} + +func (tm *TopicMetadata) decode(pd packetDecoder) (err error) { + tmp, err := pd.getInt16() + if err != nil { + return err + } + tm.Err = KError(tmp) + + tm.Name, err = pd.getString() + if err != nil { + return err + } + + n, err := pd.getArrayLength() + if err != nil { + return err + } + tm.Partitions = make([]*PartitionMetadata, n) + for i := 0; i < n; i++ { + tm.Partitions[i] = new(PartitionMetadata) + err = tm.Partitions[i].decode(pd) + if err != nil { + return err + } + } + + return nil +} + +func (tm *TopicMetadata) encode(pe packetEncoder) (err error) { + pe.putInt16(int16(tm.Err)) + + err = pe.putString(tm.Name) + if err != nil { + return err + } + + err = pe.putArrayLength(len(tm.Partitions)) + if err != nil { + return err + } + + for _, pm := range tm.Partitions { + err = pm.encode(pe) + if err != nil { + return err + } + } + + return nil +} + +type MetadataResponse struct { + Brokers []*Broker + Topics []*TopicMetadata +} + +func (r *MetadataResponse) decode(pd packetDecoder, version int16) (err error) { + n, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Brokers = make([]*Broker, n) + for i := 0; i < n; i++ { + r.Brokers[i] = new(Broker) + err = r.Brokers[i].decode(pd) + if err != nil { + return err + } + } + + n, err = pd.getArrayLength() + if err != nil { + return err + } + + r.Topics = make([]*TopicMetadata, n) + for i := 0; i < n; i++ { + r.Topics[i] = new(TopicMetadata) + err = r.Topics[i].decode(pd) + if err != nil { + return err + } + } + + return nil +} + +func (r *MetadataResponse) encode(pe packetEncoder) error { + err := pe.putArrayLength(len(r.Brokers)) + if err != nil { + return err + } + for _, broker := range r.Brokers { + err = broker.encode(pe) + if err != nil { + return err + } + } + + err = pe.putArrayLength(len(r.Topics)) + if err != nil { + return err + } + for _, tm := range r.Topics { + err = tm.encode(pe) + if err != nil { + return err + } + } + + return nil +} + +func (r *MetadataResponse) key() int16 { + return 3 +} + +func (r *MetadataResponse) version() int16 { + return 0 +} + +func (r *MetadataResponse) requiredVersion() KafkaVersion { + return minVersion +} + +// testing API + +func (r *MetadataResponse) AddBroker(addr string, id int32) { + r.Brokers = append(r.Brokers, &Broker{id: id, addr: addr}) +} + +func (r *MetadataResponse) AddTopic(topic string, err KError) *TopicMetadata { + var tmatch *TopicMetadata + + for _, tm := range r.Topics { + if tm.Name == topic { + tmatch = tm + goto foundTopic + } + } + + tmatch = new(TopicMetadata) + tmatch.Name = topic + r.Topics = append(r.Topics, tmatch) + +foundTopic: + + tmatch.Err = err + return tmatch +} + +func (r *MetadataResponse) AddTopicPartition(topic string, partition, brokerID int32, replicas, isr []int32, err KError) { + tmatch := r.AddTopic(topic, ErrNoError) + var pmatch *PartitionMetadata + + for _, pm := range tmatch.Partitions { + if pm.ID == partition { + pmatch = pm + goto foundPartition + } + } + + pmatch = new(PartitionMetadata) + pmatch.ID = partition + tmatch.Partitions = append(tmatch.Partitions, pmatch) + +foundPartition: + + pmatch.Leader = brokerID + pmatch.Replicas = replicas + pmatch.Isr = isr + pmatch.Err = err + +} diff --git a/vendor/github.com/Shopify/sarama/metrics.go b/vendor/github.com/Shopify/sarama/metrics.go new file mode 100644 index 00000000..4869708e --- /dev/null +++ b/vendor/github.com/Shopify/sarama/metrics.go @@ -0,0 +1,51 @@ +package sarama + +import ( + "fmt" + "strings" + + "github.com/rcrowley/go-metrics" +) + +// Use exponentially decaying reservoir for sampling histograms with the same defaults as the Java library: +// 1028 elements, which offers a 99.9% confidence level with a 5% margin of error assuming a normal distribution, +// and an alpha factor of 0.015, which heavily biases the reservoir to the past 5 minutes of measurements. +// See https://github.com/dropwizard/metrics/blob/v3.1.0/metrics-core/src/main/java/com/codahale/metrics/ExponentiallyDecayingReservoir.java#L38 +const ( + metricsReservoirSize = 1028 + metricsAlphaFactor = 0.015 +) + +func getOrRegisterHistogram(name string, r metrics.Registry) metrics.Histogram { + return r.GetOrRegister(name, func() metrics.Histogram { + return metrics.NewHistogram(metrics.NewExpDecaySample(metricsReservoirSize, metricsAlphaFactor)) + }).(metrics.Histogram) +} + +func getMetricNameForBroker(name string, broker *Broker) string { + // Use broker id like the Java client as it does not contain '.' or ':' characters that + // can be interpreted as special character by monitoring tool (e.g. Graphite) + return fmt.Sprintf(name+"-for-broker-%d", broker.ID()) +} + +func getOrRegisterBrokerMeter(name string, broker *Broker, r metrics.Registry) metrics.Meter { + return metrics.GetOrRegisterMeter(getMetricNameForBroker(name, broker), r) +} + +func getOrRegisterBrokerHistogram(name string, broker *Broker, r metrics.Registry) metrics.Histogram { + return getOrRegisterHistogram(getMetricNameForBroker(name, broker), r) +} + +func getMetricNameForTopic(name string, topic string) string { + // Convert dot to _ since reporters like Graphite typically use dot to represent hierarchy + // cf. KAFKA-1902 and KAFKA-2337 + return fmt.Sprintf(name+"-for-topic-%s", strings.Replace(topic, ".", "_", -1)) +} + +func getOrRegisterTopicMeter(name string, topic string, r metrics.Registry) metrics.Meter { + return metrics.GetOrRegisterMeter(getMetricNameForTopic(name, topic), r) +} + +func getOrRegisterTopicHistogram(name string, topic string, r metrics.Registry) metrics.Histogram { + return getOrRegisterHistogram(getMetricNameForTopic(name, topic), r) +} diff --git a/vendor/github.com/Shopify/sarama/mockbroker.go b/vendor/github.com/Shopify/sarama/mockbroker.go new file mode 100644 index 00000000..0734d34f --- /dev/null +++ b/vendor/github.com/Shopify/sarama/mockbroker.go @@ -0,0 +1,324 @@ +package sarama + +import ( + "bytes" + "encoding/binary" + "fmt" + "io" + "net" + "reflect" + "strconv" + "sync" + "time" + + "github.com/davecgh/go-spew/spew" +) + +const ( + expectationTimeout = 500 * time.Millisecond +) + +type requestHandlerFunc func(req *request) (res encoder) + +// RequestNotifierFunc is invoked when a mock broker processes a request successfully +// and will provides the number of bytes read and written. +type RequestNotifierFunc func(bytesRead, bytesWritten int) + +// MockBroker is a mock Kafka broker that is used in unit tests. It is exposed +// to facilitate testing of higher level or specialized consumers and producers +// built on top of Sarama. Note that it does not 'mimic' the Kafka API protocol, +// but rather provides a facility to do that. It takes care of the TCP +// transport, request unmarshaling, response marshaling, and makes it the test +// writer responsibility to program correct according to the Kafka API protocol +// MockBroker behaviour. +// +// MockBroker is implemented as a TCP server listening on a kernel-selected +// localhost port that can accept many connections. It reads Kafka requests +// from that connection and returns responses programmed by the SetHandlerByMap +// function. If a MockBroker receives a request that it has no programmed +// response for, then it returns nothing and the request times out. +// +// A set of MockRequest builders to define mappings used by MockBroker is +// provided by Sarama. But users can develop MockRequests of their own and use +// them along with or instead of the standard ones. +// +// When running tests with MockBroker it is strongly recommended to specify +// a timeout to `go test` so that if the broker hangs waiting for a response, +// the test panics. +// +// It is not necessary to prefix message length or correlation ID to your +// response bytes, the server does that automatically as a convenience. +type MockBroker struct { + brokerID int32 + port int32 + closing chan none + stopper chan none + expectations chan encoder + listener net.Listener + t TestReporter + latency time.Duration + handler requestHandlerFunc + notifier RequestNotifierFunc + history []RequestResponse + lock sync.Mutex +} + +// RequestResponse represents a Request/Response pair processed by MockBroker. +type RequestResponse struct { + Request protocolBody + Response encoder +} + +// SetLatency makes broker pause for the specified period every time before +// replying. +func (b *MockBroker) SetLatency(latency time.Duration) { + b.latency = latency +} + +// SetHandlerByMap defines mapping of Request types to MockResponses. When a +// request is received by the broker, it looks up the request type in the map +// and uses the found MockResponse instance to generate an appropriate reply. +// If the request type is not found in the map then nothing is sent. +func (b *MockBroker) SetHandlerByMap(handlerMap map[string]MockResponse) { + b.setHandler(func(req *request) (res encoder) { + reqTypeName := reflect.TypeOf(req.body).Elem().Name() + mockResponse := handlerMap[reqTypeName] + if mockResponse == nil { + return nil + } + return mockResponse.For(req.body) + }) +} + +// SetNotifier set a function that will get invoked whenever a request has been +// processed successfully and will provide the number of bytes read and written +func (b *MockBroker) SetNotifier(notifier RequestNotifierFunc) { + b.lock.Lock() + b.notifier = notifier + b.lock.Unlock() +} + +// BrokerID returns broker ID assigned to the broker. +func (b *MockBroker) BrokerID() int32 { + return b.brokerID +} + +// History returns a slice of RequestResponse pairs in the order they were +// processed by the broker. Note that in case of multiple connections to the +// broker the order expected by a test can be different from the order recorded +// in the history, unless some synchronization is implemented in the test. +func (b *MockBroker) History() []RequestResponse { + b.lock.Lock() + history := make([]RequestResponse, len(b.history)) + copy(history, b.history) + b.lock.Unlock() + return history +} + +// Port returns the TCP port number the broker is listening for requests on. +func (b *MockBroker) Port() int32 { + return b.port +} + +// Addr returns the broker connection string in the form "
:". +func (b *MockBroker) Addr() string { + return b.listener.Addr().String() +} + +// Close terminates the broker blocking until it stops internal goroutines and +// releases all resources. +func (b *MockBroker) Close() { + close(b.expectations) + if len(b.expectations) > 0 { + buf := bytes.NewBufferString(fmt.Sprintf("mockbroker/%d: not all expectations were satisfied! Still waiting on:\n", b.BrokerID())) + for e := range b.expectations { + _, _ = buf.WriteString(spew.Sdump(e)) + } + b.t.Error(buf.String()) + } + close(b.closing) + <-b.stopper +} + +// setHandler sets the specified function as the request handler. Whenever +// a mock broker reads a request from the wire it passes the request to the +// function and sends back whatever the handler function returns. +func (b *MockBroker) setHandler(handler requestHandlerFunc) { + b.lock.Lock() + b.handler = handler + b.lock.Unlock() +} + +func (b *MockBroker) serverLoop() { + defer close(b.stopper) + var err error + var conn net.Conn + + go func() { + <-b.closing + err := b.listener.Close() + if err != nil { + b.t.Error(err) + } + }() + + wg := &sync.WaitGroup{} + i := 0 + for conn, err = b.listener.Accept(); err == nil; conn, err = b.listener.Accept() { + wg.Add(1) + go b.handleRequests(conn, i, wg) + i++ + } + wg.Wait() + Logger.Printf("*** mockbroker/%d: listener closed, err=%v", b.BrokerID(), err) +} + +func (b *MockBroker) handleRequests(conn net.Conn, idx int, wg *sync.WaitGroup) { + defer wg.Done() + defer func() { + _ = conn.Close() + }() + Logger.Printf("*** mockbroker/%d/%d: connection opened", b.BrokerID(), idx) + var err error + + abort := make(chan none) + defer close(abort) + go func() { + select { + case <-b.closing: + _ = conn.Close() + case <-abort: + } + }() + + resHeader := make([]byte, 8) + for { + req, bytesRead, err := decodeRequest(conn) + if err != nil { + Logger.Printf("*** mockbroker/%d/%d: invalid request: err=%+v, %+v", b.brokerID, idx, err, spew.Sdump(req)) + b.serverError(err) + break + } + + if b.latency > 0 { + time.Sleep(b.latency) + } + + b.lock.Lock() + res := b.handler(req) + b.history = append(b.history, RequestResponse{req.body, res}) + b.lock.Unlock() + + if res == nil { + Logger.Printf("*** mockbroker/%d/%d: ignored %v", b.brokerID, idx, spew.Sdump(req)) + continue + } + Logger.Printf("*** mockbroker/%d/%d: served %v -> %v", b.brokerID, idx, req, res) + + encodedRes, err := encode(res, nil) + if err != nil { + b.serverError(err) + break + } + if len(encodedRes) == 0 { + b.lock.Lock() + if b.notifier != nil { + b.notifier(bytesRead, 0) + } + b.lock.Unlock() + continue + } + + binary.BigEndian.PutUint32(resHeader, uint32(len(encodedRes)+4)) + binary.BigEndian.PutUint32(resHeader[4:], uint32(req.correlationID)) + if _, err = conn.Write(resHeader); err != nil { + b.serverError(err) + break + } + if _, err = conn.Write(encodedRes); err != nil { + b.serverError(err) + break + } + + b.lock.Lock() + if b.notifier != nil { + b.notifier(bytesRead, len(resHeader)+len(encodedRes)) + } + b.lock.Unlock() + } + Logger.Printf("*** mockbroker/%d/%d: connection closed, err=%v", b.BrokerID(), idx, err) +} + +func (b *MockBroker) defaultRequestHandler(req *request) (res encoder) { + select { + case res, ok := <-b.expectations: + if !ok { + return nil + } + return res + case <-time.After(expectationTimeout): + return nil + } +} + +func (b *MockBroker) serverError(err error) { + isConnectionClosedError := false + if _, ok := err.(*net.OpError); ok { + isConnectionClosedError = true + } else if err == io.EOF { + isConnectionClosedError = true + } else if err.Error() == "use of closed network connection" { + isConnectionClosedError = true + } + + if isConnectionClosedError { + return + } + + b.t.Errorf(err.Error()) +} + +// NewMockBroker launches a fake Kafka broker. It takes a TestReporter as provided by the +// test framework and a channel of responses to use. If an error occurs it is +// simply logged to the TestReporter and the broker exits. +func NewMockBroker(t TestReporter, brokerID int32) *MockBroker { + return NewMockBrokerAddr(t, brokerID, "localhost:0") +} + +// NewMockBrokerAddr behaves like newMockBroker but listens on the address you give +// it rather than just some ephemeral port. +func NewMockBrokerAddr(t TestReporter, brokerID int32, addr string) *MockBroker { + var err error + + broker := &MockBroker{ + closing: make(chan none), + stopper: make(chan none), + t: t, + brokerID: brokerID, + expectations: make(chan encoder, 512), + } + broker.handler = broker.defaultRequestHandler + + broker.listener, err = net.Listen("tcp", addr) + if err != nil { + t.Fatal(err) + } + Logger.Printf("*** mockbroker/%d listening on %s\n", brokerID, broker.listener.Addr().String()) + _, portStr, err := net.SplitHostPort(broker.listener.Addr().String()) + if err != nil { + t.Fatal(err) + } + tmp, err := strconv.ParseInt(portStr, 10, 32) + if err != nil { + t.Fatal(err) + } + broker.port = int32(tmp) + + go broker.serverLoop() + + return broker +} + +func (b *MockBroker) Returns(e encoder) { + b.expectations <- e +} diff --git a/vendor/github.com/Shopify/sarama/mockresponses.go b/vendor/github.com/Shopify/sarama/mockresponses.go new file mode 100644 index 00000000..a2031420 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/mockresponses.go @@ -0,0 +1,455 @@ +package sarama + +import ( + "fmt" +) + +// TestReporter has methods matching go's testing.T to avoid importing +// `testing` in the main part of the library. +type TestReporter interface { + Error(...interface{}) + Errorf(string, ...interface{}) + Fatal(...interface{}) + Fatalf(string, ...interface{}) +} + +// MockResponse is a response builder interface it defines one method that +// allows generating a response based on a request body. MockResponses are used +// to program behavior of MockBroker in tests. +type MockResponse interface { + For(reqBody versionedDecoder) (res encoder) +} + +// MockWrapper is a mock response builder that returns a particular concrete +// response regardless of the actual request passed to the `For` method. +type MockWrapper struct { + res encoder +} + +func (mw *MockWrapper) For(reqBody versionedDecoder) (res encoder) { + return mw.res +} + +func NewMockWrapper(res encoder) *MockWrapper { + return &MockWrapper{res: res} +} + +// MockSequence is a mock response builder that is created from a sequence of +// concrete responses. Every time when a `MockBroker` calls its `For` method +// the next response from the sequence is returned. When the end of the +// sequence is reached the last element from the sequence is returned. +type MockSequence struct { + responses []MockResponse +} + +func NewMockSequence(responses ...interface{}) *MockSequence { + ms := &MockSequence{} + ms.responses = make([]MockResponse, len(responses)) + for i, res := range responses { + switch res := res.(type) { + case MockResponse: + ms.responses[i] = res + case encoder: + ms.responses[i] = NewMockWrapper(res) + default: + panic(fmt.Sprintf("Unexpected response type: %T", res)) + } + } + return ms +} + +func (mc *MockSequence) For(reqBody versionedDecoder) (res encoder) { + res = mc.responses[0].For(reqBody) + if len(mc.responses) > 1 { + mc.responses = mc.responses[1:] + } + return res +} + +// MockMetadataResponse is a `MetadataResponse` builder. +type MockMetadataResponse struct { + leaders map[string]map[int32]int32 + brokers map[string]int32 + t TestReporter +} + +func NewMockMetadataResponse(t TestReporter) *MockMetadataResponse { + return &MockMetadataResponse{ + leaders: make(map[string]map[int32]int32), + brokers: make(map[string]int32), + t: t, + } +} + +func (mmr *MockMetadataResponse) SetLeader(topic string, partition, brokerID int32) *MockMetadataResponse { + partitions := mmr.leaders[topic] + if partitions == nil { + partitions = make(map[int32]int32) + mmr.leaders[topic] = partitions + } + partitions[partition] = brokerID + return mmr +} + +func (mmr *MockMetadataResponse) SetBroker(addr string, brokerID int32) *MockMetadataResponse { + mmr.brokers[addr] = brokerID + return mmr +} + +func (mmr *MockMetadataResponse) For(reqBody versionedDecoder) encoder { + metadataRequest := reqBody.(*MetadataRequest) + metadataResponse := &MetadataResponse{} + for addr, brokerID := range mmr.brokers { + metadataResponse.AddBroker(addr, brokerID) + } + if len(metadataRequest.Topics) == 0 { + for topic, partitions := range mmr.leaders { + for partition, brokerID := range partitions { + metadataResponse.AddTopicPartition(topic, partition, brokerID, nil, nil, ErrNoError) + } + } + return metadataResponse + } + for _, topic := range metadataRequest.Topics { + for partition, brokerID := range mmr.leaders[topic] { + metadataResponse.AddTopicPartition(topic, partition, brokerID, nil, nil, ErrNoError) + } + } + return metadataResponse +} + +// MockOffsetResponse is an `OffsetResponse` builder. +type MockOffsetResponse struct { + offsets map[string]map[int32]map[int64]int64 + t TestReporter +} + +func NewMockOffsetResponse(t TestReporter) *MockOffsetResponse { + return &MockOffsetResponse{ + offsets: make(map[string]map[int32]map[int64]int64), + t: t, + } +} + +func (mor *MockOffsetResponse) SetOffset(topic string, partition int32, time, offset int64) *MockOffsetResponse { + partitions := mor.offsets[topic] + if partitions == nil { + partitions = make(map[int32]map[int64]int64) + mor.offsets[topic] = partitions + } + times := partitions[partition] + if times == nil { + times = make(map[int64]int64) + partitions[partition] = times + } + times[time] = offset + return mor +} + +func (mor *MockOffsetResponse) For(reqBody versionedDecoder) encoder { + offsetRequest := reqBody.(*OffsetRequest) + offsetResponse := &OffsetResponse{} + for topic, partitions := range offsetRequest.blocks { + for partition, block := range partitions { + offset := mor.getOffset(topic, partition, block.time) + offsetResponse.AddTopicPartition(topic, partition, offset) + } + } + return offsetResponse +} + +func (mor *MockOffsetResponse) getOffset(topic string, partition int32, time int64) int64 { + partitions := mor.offsets[topic] + if partitions == nil { + mor.t.Errorf("missing topic: %s", topic) + } + times := partitions[partition] + if times == nil { + mor.t.Errorf("missing partition: %d", partition) + } + offset, ok := times[time] + if !ok { + mor.t.Errorf("missing time: %d", time) + } + return offset +} + +// MockFetchResponse is a `FetchResponse` builder. +type MockFetchResponse struct { + messages map[string]map[int32]map[int64]Encoder + highWaterMarks map[string]map[int32]int64 + t TestReporter + batchSize int +} + +func NewMockFetchResponse(t TestReporter, batchSize int) *MockFetchResponse { + return &MockFetchResponse{ + messages: make(map[string]map[int32]map[int64]Encoder), + highWaterMarks: make(map[string]map[int32]int64), + t: t, + batchSize: batchSize, + } +} + +func (mfr *MockFetchResponse) SetMessage(topic string, partition int32, offset int64, msg Encoder) *MockFetchResponse { + partitions := mfr.messages[topic] + if partitions == nil { + partitions = make(map[int32]map[int64]Encoder) + mfr.messages[topic] = partitions + } + messages := partitions[partition] + if messages == nil { + messages = make(map[int64]Encoder) + partitions[partition] = messages + } + messages[offset] = msg + return mfr +} + +func (mfr *MockFetchResponse) SetHighWaterMark(topic string, partition int32, offset int64) *MockFetchResponse { + partitions := mfr.highWaterMarks[topic] + if partitions == nil { + partitions = make(map[int32]int64) + mfr.highWaterMarks[topic] = partitions + } + partitions[partition] = offset + return mfr +} + +func (mfr *MockFetchResponse) For(reqBody versionedDecoder) encoder { + fetchRequest := reqBody.(*FetchRequest) + res := &FetchResponse{} + for topic, partitions := range fetchRequest.blocks { + for partition, block := range partitions { + initialOffset := block.fetchOffset + offset := initialOffset + maxOffset := initialOffset + int64(mfr.getMessageCount(topic, partition)) + for i := 0; i < mfr.batchSize && offset < maxOffset; { + msg := mfr.getMessage(topic, partition, offset) + if msg != nil { + res.AddMessage(topic, partition, nil, msg, offset) + i++ + } + offset++ + } + fb := res.GetBlock(topic, partition) + if fb == nil { + res.AddError(topic, partition, ErrNoError) + fb = res.GetBlock(topic, partition) + } + fb.HighWaterMarkOffset = mfr.getHighWaterMark(topic, partition) + } + } + return res +} + +func (mfr *MockFetchResponse) getMessage(topic string, partition int32, offset int64) Encoder { + partitions := mfr.messages[topic] + if partitions == nil { + return nil + } + messages := partitions[partition] + if messages == nil { + return nil + } + return messages[offset] +} + +func (mfr *MockFetchResponse) getMessageCount(topic string, partition int32) int { + partitions := mfr.messages[topic] + if partitions == nil { + return 0 + } + messages := partitions[partition] + if messages == nil { + return 0 + } + return len(messages) +} + +func (mfr *MockFetchResponse) getHighWaterMark(topic string, partition int32) int64 { + partitions := mfr.highWaterMarks[topic] + if partitions == nil { + return 0 + } + return partitions[partition] +} + +// MockConsumerMetadataResponse is a `ConsumerMetadataResponse` builder. +type MockConsumerMetadataResponse struct { + coordinators map[string]interface{} + t TestReporter +} + +func NewMockConsumerMetadataResponse(t TestReporter) *MockConsumerMetadataResponse { + return &MockConsumerMetadataResponse{ + coordinators: make(map[string]interface{}), + t: t, + } +} + +func (mr *MockConsumerMetadataResponse) SetCoordinator(group string, broker *MockBroker) *MockConsumerMetadataResponse { + mr.coordinators[group] = broker + return mr +} + +func (mr *MockConsumerMetadataResponse) SetError(group string, kerror KError) *MockConsumerMetadataResponse { + mr.coordinators[group] = kerror + return mr +} + +func (mr *MockConsumerMetadataResponse) For(reqBody versionedDecoder) encoder { + req := reqBody.(*ConsumerMetadataRequest) + group := req.ConsumerGroup + res := &ConsumerMetadataResponse{} + v := mr.coordinators[group] + switch v := v.(type) { + case *MockBroker: + res.Coordinator = &Broker{id: v.BrokerID(), addr: v.Addr()} + case KError: + res.Err = v + } + return res +} + +// MockOffsetCommitResponse is a `OffsetCommitResponse` builder. +type MockOffsetCommitResponse struct { + errors map[string]map[string]map[int32]KError + t TestReporter +} + +func NewMockOffsetCommitResponse(t TestReporter) *MockOffsetCommitResponse { + return &MockOffsetCommitResponse{t: t} +} + +func (mr *MockOffsetCommitResponse) SetError(group, topic string, partition int32, kerror KError) *MockOffsetCommitResponse { + if mr.errors == nil { + mr.errors = make(map[string]map[string]map[int32]KError) + } + topics := mr.errors[group] + if topics == nil { + topics = make(map[string]map[int32]KError) + mr.errors[group] = topics + } + partitions := topics[topic] + if partitions == nil { + partitions = make(map[int32]KError) + topics[topic] = partitions + } + partitions[partition] = kerror + return mr +} + +func (mr *MockOffsetCommitResponse) For(reqBody versionedDecoder) encoder { + req := reqBody.(*OffsetCommitRequest) + group := req.ConsumerGroup + res := &OffsetCommitResponse{} + for topic, partitions := range req.blocks { + for partition := range partitions { + res.AddError(topic, partition, mr.getError(group, topic, partition)) + } + } + return res +} + +func (mr *MockOffsetCommitResponse) getError(group, topic string, partition int32) KError { + topics := mr.errors[group] + if topics == nil { + return ErrNoError + } + partitions := topics[topic] + if partitions == nil { + return ErrNoError + } + kerror, ok := partitions[partition] + if !ok { + return ErrNoError + } + return kerror +} + +// MockProduceResponse is a `ProduceResponse` builder. +type MockProduceResponse struct { + errors map[string]map[int32]KError + t TestReporter +} + +func NewMockProduceResponse(t TestReporter) *MockProduceResponse { + return &MockProduceResponse{t: t} +} + +func (mr *MockProduceResponse) SetError(topic string, partition int32, kerror KError) *MockProduceResponse { + if mr.errors == nil { + mr.errors = make(map[string]map[int32]KError) + } + partitions := mr.errors[topic] + if partitions == nil { + partitions = make(map[int32]KError) + mr.errors[topic] = partitions + } + partitions[partition] = kerror + return mr +} + +func (mr *MockProduceResponse) For(reqBody versionedDecoder) encoder { + req := reqBody.(*ProduceRequest) + res := &ProduceResponse{} + for topic, partitions := range req.msgSets { + for partition := range partitions { + res.AddTopicPartition(topic, partition, mr.getError(topic, partition)) + } + } + return res +} + +func (mr *MockProduceResponse) getError(topic string, partition int32) KError { + partitions := mr.errors[topic] + if partitions == nil { + return ErrNoError + } + kerror, ok := partitions[partition] + if !ok { + return ErrNoError + } + return kerror +} + +// MockOffsetFetchResponse is a `OffsetFetchResponse` builder. +type MockOffsetFetchResponse struct { + offsets map[string]map[string]map[int32]*OffsetFetchResponseBlock + t TestReporter +} + +func NewMockOffsetFetchResponse(t TestReporter) *MockOffsetFetchResponse { + return &MockOffsetFetchResponse{t: t} +} + +func (mr *MockOffsetFetchResponse) SetOffset(group, topic string, partition int32, offset int64, metadata string, kerror KError) *MockOffsetFetchResponse { + if mr.offsets == nil { + mr.offsets = make(map[string]map[string]map[int32]*OffsetFetchResponseBlock) + } + topics := mr.offsets[group] + if topics == nil { + topics = make(map[string]map[int32]*OffsetFetchResponseBlock) + mr.offsets[group] = topics + } + partitions := topics[topic] + if partitions == nil { + partitions = make(map[int32]*OffsetFetchResponseBlock) + topics[topic] = partitions + } + partitions[partition] = &OffsetFetchResponseBlock{offset, metadata, kerror} + return mr +} + +func (mr *MockOffsetFetchResponse) For(reqBody versionedDecoder) encoder { + req := reqBody.(*OffsetFetchRequest) + group := req.ConsumerGroup + res := &OffsetFetchResponse{} + for topic, partitions := range mr.offsets[group] { + for partition, block := range partitions { + res.AddBlock(topic, partition, block) + } + } + return res +} diff --git a/vendor/github.com/Shopify/sarama/offset_commit_request.go b/vendor/github.com/Shopify/sarama/offset_commit_request.go new file mode 100644 index 00000000..b21ea634 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/offset_commit_request.go @@ -0,0 +1,190 @@ +package sarama + +// ReceiveTime is a special value for the timestamp field of Offset Commit Requests which +// tells the broker to set the timestamp to the time at which the request was received. +// The timestamp is only used if message version 1 is used, which requires kafka 0.8.2. +const ReceiveTime int64 = -1 + +// GroupGenerationUndefined is a special value for the group generation field of +// Offset Commit Requests that should be used when a consumer group does not rely +// on Kafka for partition management. +const GroupGenerationUndefined = -1 + +type offsetCommitRequestBlock struct { + offset int64 + timestamp int64 + metadata string +} + +func (b *offsetCommitRequestBlock) encode(pe packetEncoder, version int16) error { + pe.putInt64(b.offset) + if version == 1 { + pe.putInt64(b.timestamp) + } else if b.timestamp != 0 { + Logger.Println("Non-zero timestamp specified for OffsetCommitRequest not v1, it will be ignored") + } + + return pe.putString(b.metadata) +} + +func (b *offsetCommitRequestBlock) decode(pd packetDecoder, version int16) (err error) { + if b.offset, err = pd.getInt64(); err != nil { + return err + } + if version == 1 { + if b.timestamp, err = pd.getInt64(); err != nil { + return err + } + } + b.metadata, err = pd.getString() + return err +} + +type OffsetCommitRequest struct { + ConsumerGroup string + ConsumerGroupGeneration int32 // v1 or later + ConsumerID string // v1 or later + RetentionTime int64 // v2 or later + + // Version can be: + // - 0 (kafka 0.8.1 and later) + // - 1 (kafka 0.8.2 and later) + // - 2 (kafka 0.9.0 and later) + Version int16 + blocks map[string]map[int32]*offsetCommitRequestBlock +} + +func (r *OffsetCommitRequest) encode(pe packetEncoder) error { + if r.Version < 0 || r.Version > 2 { + return PacketEncodingError{"invalid or unsupported OffsetCommitRequest version field"} + } + + if err := pe.putString(r.ConsumerGroup); err != nil { + return err + } + + if r.Version >= 1 { + pe.putInt32(r.ConsumerGroupGeneration) + if err := pe.putString(r.ConsumerID); err != nil { + return err + } + } else { + if r.ConsumerGroupGeneration != 0 { + Logger.Println("Non-zero ConsumerGroupGeneration specified for OffsetCommitRequest v0, it will be ignored") + } + if r.ConsumerID != "" { + Logger.Println("Non-empty ConsumerID specified for OffsetCommitRequest v0, it will be ignored") + } + } + + if r.Version >= 2 { + pe.putInt64(r.RetentionTime) + } else if r.RetentionTime != 0 { + Logger.Println("Non-zero RetentionTime specified for OffsetCommitRequest version <2, it will be ignored") + } + + if err := pe.putArrayLength(len(r.blocks)); err != nil { + return err + } + for topic, partitions := range r.blocks { + if err := pe.putString(topic); err != nil { + return err + } + if err := pe.putArrayLength(len(partitions)); err != nil { + return err + } + for partition, block := range partitions { + pe.putInt32(partition) + if err := block.encode(pe, r.Version); err != nil { + return err + } + } + } + return nil +} + +func (r *OffsetCommitRequest) decode(pd packetDecoder, version int16) (err error) { + r.Version = version + + if r.ConsumerGroup, err = pd.getString(); err != nil { + return err + } + + if r.Version >= 1 { + if r.ConsumerGroupGeneration, err = pd.getInt32(); err != nil { + return err + } + if r.ConsumerID, err = pd.getString(); err != nil { + return err + } + } + + if r.Version >= 2 { + if r.RetentionTime, err = pd.getInt64(); err != nil { + return err + } + } + + topicCount, err := pd.getArrayLength() + if err != nil { + return err + } + if topicCount == 0 { + return nil + } + r.blocks = make(map[string]map[int32]*offsetCommitRequestBlock) + for i := 0; i < topicCount; i++ { + topic, err := pd.getString() + if err != nil { + return err + } + partitionCount, err := pd.getArrayLength() + if err != nil { + return err + } + r.blocks[topic] = make(map[int32]*offsetCommitRequestBlock) + for j := 0; j < partitionCount; j++ { + partition, err := pd.getInt32() + if err != nil { + return err + } + block := &offsetCommitRequestBlock{} + if err := block.decode(pd, r.Version); err != nil { + return err + } + r.blocks[topic][partition] = block + } + } + return nil +} + +func (r *OffsetCommitRequest) key() int16 { + return 8 +} + +func (r *OffsetCommitRequest) version() int16 { + return r.Version +} + +func (r *OffsetCommitRequest) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_8_2_0 + case 2: + return V0_9_0_0 + default: + return minVersion + } +} + +func (r *OffsetCommitRequest) AddBlock(topic string, partitionID int32, offset int64, timestamp int64, metadata string) { + if r.blocks == nil { + r.blocks = make(map[string]map[int32]*offsetCommitRequestBlock) + } + + if r.blocks[topic] == nil { + r.blocks[topic] = make(map[int32]*offsetCommitRequestBlock) + } + + r.blocks[topic][partitionID] = &offsetCommitRequestBlock{offset, timestamp, metadata} +} diff --git a/vendor/github.com/Shopify/sarama/offset_commit_response.go b/vendor/github.com/Shopify/sarama/offset_commit_response.go new file mode 100644 index 00000000..7f277e77 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/offset_commit_response.go @@ -0,0 +1,85 @@ +package sarama + +type OffsetCommitResponse struct { + Errors map[string]map[int32]KError +} + +func (r *OffsetCommitResponse) AddError(topic string, partition int32, kerror KError) { + if r.Errors == nil { + r.Errors = make(map[string]map[int32]KError) + } + partitions := r.Errors[topic] + if partitions == nil { + partitions = make(map[int32]KError) + r.Errors[topic] = partitions + } + partitions[partition] = kerror +} + +func (r *OffsetCommitResponse) encode(pe packetEncoder) error { + if err := pe.putArrayLength(len(r.Errors)); err != nil { + return err + } + for topic, partitions := range r.Errors { + if err := pe.putString(topic); err != nil { + return err + } + if err := pe.putArrayLength(len(partitions)); err != nil { + return err + } + for partition, kerror := range partitions { + pe.putInt32(partition) + pe.putInt16(int16(kerror)) + } + } + return nil +} + +func (r *OffsetCommitResponse) decode(pd packetDecoder, version int16) (err error) { + numTopics, err := pd.getArrayLength() + if err != nil || numTopics == 0 { + return err + } + + r.Errors = make(map[string]map[int32]KError, numTopics) + for i := 0; i < numTopics; i++ { + name, err := pd.getString() + if err != nil { + return err + } + + numErrors, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Errors[name] = make(map[int32]KError, numErrors) + + for j := 0; j < numErrors; j++ { + id, err := pd.getInt32() + if err != nil { + return err + } + + tmp, err := pd.getInt16() + if err != nil { + return err + } + r.Errors[name][id] = KError(tmp) + } + } + + return nil +} + +func (r *OffsetCommitResponse) key() int16 { + return 8 +} + +func (r *OffsetCommitResponse) version() int16 { + return 0 +} + +func (r *OffsetCommitResponse) requiredVersion() KafkaVersion { + return minVersion +} diff --git a/vendor/github.com/Shopify/sarama/offset_fetch_request.go b/vendor/github.com/Shopify/sarama/offset_fetch_request.go new file mode 100644 index 00000000..b19fe79b --- /dev/null +++ b/vendor/github.com/Shopify/sarama/offset_fetch_request.go @@ -0,0 +1,81 @@ +package sarama + +type OffsetFetchRequest struct { + ConsumerGroup string + Version int16 + partitions map[string][]int32 +} + +func (r *OffsetFetchRequest) encode(pe packetEncoder) (err error) { + if r.Version < 0 || r.Version > 1 { + return PacketEncodingError{"invalid or unsupported OffsetFetchRequest version field"} + } + + if err = pe.putString(r.ConsumerGroup); err != nil { + return err + } + if err = pe.putArrayLength(len(r.partitions)); err != nil { + return err + } + for topic, partitions := range r.partitions { + if err = pe.putString(topic); err != nil { + return err + } + if err = pe.putInt32Array(partitions); err != nil { + return err + } + } + return nil +} + +func (r *OffsetFetchRequest) decode(pd packetDecoder, version int16) (err error) { + r.Version = version + if r.ConsumerGroup, err = pd.getString(); err != nil { + return err + } + partitionCount, err := pd.getArrayLength() + if err != nil { + return err + } + if partitionCount == 0 { + return nil + } + r.partitions = make(map[string][]int32) + for i := 0; i < partitionCount; i++ { + topic, err := pd.getString() + if err != nil { + return err + } + partitions, err := pd.getInt32Array() + if err != nil { + return err + } + r.partitions[topic] = partitions + } + return nil +} + +func (r *OffsetFetchRequest) key() int16 { + return 9 +} + +func (r *OffsetFetchRequest) version() int16 { + return r.Version +} + +func (r *OffsetFetchRequest) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_8_2_0 + default: + return minVersion + } +} + +func (r *OffsetFetchRequest) AddPartition(topic string, partitionID int32) { + if r.partitions == nil { + r.partitions = make(map[string][]int32) + } + + r.partitions[topic] = append(r.partitions[topic], partitionID) +} diff --git a/vendor/github.com/Shopify/sarama/offset_fetch_response.go b/vendor/github.com/Shopify/sarama/offset_fetch_response.go new file mode 100644 index 00000000..323220ea --- /dev/null +++ b/vendor/github.com/Shopify/sarama/offset_fetch_response.go @@ -0,0 +1,143 @@ +package sarama + +type OffsetFetchResponseBlock struct { + Offset int64 + Metadata string + Err KError +} + +func (b *OffsetFetchResponseBlock) decode(pd packetDecoder) (err error) { + b.Offset, err = pd.getInt64() + if err != nil { + return err + } + + b.Metadata, err = pd.getString() + if err != nil { + return err + } + + tmp, err := pd.getInt16() + if err != nil { + return err + } + b.Err = KError(tmp) + + return nil +} + +func (b *OffsetFetchResponseBlock) encode(pe packetEncoder) (err error) { + pe.putInt64(b.Offset) + + err = pe.putString(b.Metadata) + if err != nil { + return err + } + + pe.putInt16(int16(b.Err)) + + return nil +} + +type OffsetFetchResponse struct { + Blocks map[string]map[int32]*OffsetFetchResponseBlock +} + +func (r *OffsetFetchResponse) encode(pe packetEncoder) error { + if err := pe.putArrayLength(len(r.Blocks)); err != nil { + return err + } + for topic, partitions := range r.Blocks { + if err := pe.putString(topic); err != nil { + return err + } + if err := pe.putArrayLength(len(partitions)); err != nil { + return err + } + for partition, block := range partitions { + pe.putInt32(partition) + if err := block.encode(pe); err != nil { + return err + } + } + } + return nil +} + +func (r *OffsetFetchResponse) decode(pd packetDecoder, version int16) (err error) { + numTopics, err := pd.getArrayLength() + if err != nil || numTopics == 0 { + return err + } + + r.Blocks = make(map[string]map[int32]*OffsetFetchResponseBlock, numTopics) + for i := 0; i < numTopics; i++ { + name, err := pd.getString() + if err != nil { + return err + } + + numBlocks, err := pd.getArrayLength() + if err != nil { + return err + } + + if numBlocks == 0 { + r.Blocks[name] = nil + continue + } + r.Blocks[name] = make(map[int32]*OffsetFetchResponseBlock, numBlocks) + + for j := 0; j < numBlocks; j++ { + id, err := pd.getInt32() + if err != nil { + return err + } + + block := new(OffsetFetchResponseBlock) + err = block.decode(pd) + if err != nil { + return err + } + r.Blocks[name][id] = block + } + } + + return nil +} + +func (r *OffsetFetchResponse) key() int16 { + return 9 +} + +func (r *OffsetFetchResponse) version() int16 { + return 0 +} + +func (r *OffsetFetchResponse) requiredVersion() KafkaVersion { + return minVersion +} + +func (r *OffsetFetchResponse) GetBlock(topic string, partition int32) *OffsetFetchResponseBlock { + if r.Blocks == nil { + return nil + } + + if r.Blocks[topic] == nil { + return nil + } + + return r.Blocks[topic][partition] +} + +func (r *OffsetFetchResponse) AddBlock(topic string, partition int32, block *OffsetFetchResponseBlock) { + if r.Blocks == nil { + r.Blocks = make(map[string]map[int32]*OffsetFetchResponseBlock) + } + partitions := r.Blocks[topic] + if partitions == nil { + partitions = make(map[int32]*OffsetFetchResponseBlock) + r.Blocks[topic] = partitions + } + partitions[partition] = block +} diff --git a/vendor/github.com/Shopify/sarama/offset_manager.go b/vendor/github.com/Shopify/sarama/offset_manager.go new file mode 100644 index 00000000..5e15cdaf --- /dev/null +++ b/vendor/github.com/Shopify/sarama/offset_manager.go @@ -0,0 +1,542 @@ +package sarama + +import ( + "sync" + "time" +) + +// Offset Manager + +// OffsetManager uses Kafka to store and fetch consumed partition offsets. +type OffsetManager interface { + // ManagePartition creates a PartitionOffsetManager on the given topic/partition. + // It will return an error if this OffsetManager is already managing the given + // topic/partition. + ManagePartition(topic string, partition int32) (PartitionOffsetManager, error) + + // Close stops the OffsetManager from managing offsets. It is required to call + // this function before an OffsetManager object passes out of scope, as it + // will otherwise leak memory. You must call this after all the + // PartitionOffsetManagers are closed. + Close() error +} + +type offsetManager struct { + client Client + conf *Config + group string + + lock sync.Mutex + poms map[string]map[int32]*partitionOffsetManager + boms map[*Broker]*brokerOffsetManager +} + +// NewOffsetManagerFromClient creates a new OffsetManager from the given client. +// It is still necessary to call Close() on the underlying client when finished with the partition manager. +func NewOffsetManagerFromClient(group string, client Client) (OffsetManager, error) { + // Check that we are not dealing with a closed Client before processing any other arguments + if client.Closed() { + return nil, ErrClosedClient + } + + om := &offsetManager{ + client: client, + conf: client.Config(), + group: group, + poms: make(map[string]map[int32]*partitionOffsetManager), + boms: make(map[*Broker]*brokerOffsetManager), + } + + return om, nil +} + +func (om *offsetManager) ManagePartition(topic string, partition int32) (PartitionOffsetManager, error) { + pom, err := om.newPartitionOffsetManager(topic, partition) + if err != nil { + return nil, err + } + + om.lock.Lock() + defer om.lock.Unlock() + + topicManagers := om.poms[topic] + if topicManagers == nil { + topicManagers = make(map[int32]*partitionOffsetManager) + om.poms[topic] = topicManagers + } + + if topicManagers[partition] != nil { + return nil, ConfigurationError("That topic/partition is already being managed") + } + + topicManagers[partition] = pom + return pom, nil +} + +func (om *offsetManager) Close() error { + return nil +} + +func (om *offsetManager) refBrokerOffsetManager(broker *Broker) *brokerOffsetManager { + om.lock.Lock() + defer om.lock.Unlock() + + bom := om.boms[broker] + if bom == nil { + bom = om.newBrokerOffsetManager(broker) + om.boms[broker] = bom + } + + bom.refs++ + + return bom +} + +func (om *offsetManager) unrefBrokerOffsetManager(bom *brokerOffsetManager) { + om.lock.Lock() + defer om.lock.Unlock() + + bom.refs-- + + if bom.refs == 0 { + close(bom.updateSubscriptions) + if om.boms[bom.broker] == bom { + delete(om.boms, bom.broker) + } + } +} + +func (om *offsetManager) abandonBroker(bom *brokerOffsetManager) { + om.lock.Lock() + defer om.lock.Unlock() + + delete(om.boms, bom.broker) +} + +func (om *offsetManager) abandonPartitionOffsetManager(pom *partitionOffsetManager) { + om.lock.Lock() + defer om.lock.Unlock() + + delete(om.poms[pom.topic], pom.partition) + if len(om.poms[pom.topic]) == 0 { + delete(om.poms, pom.topic) + } +} + +// Partition Offset Manager + +// PartitionOffsetManager uses Kafka to store and fetch consumed partition offsets. You MUST call Close() +// on a partition offset manager to avoid leaks, it will not be garbage-collected automatically when it passes +// out of scope. +type PartitionOffsetManager interface { + // NextOffset returns the next offset that should be consumed for the managed + // partition, accompanied by metadata which can be used to reconstruct the state + // of the partition consumer when it resumes. NextOffset() will return + // `config.Consumer.Offsets.Initial` and an empty metadata string if no offset + // was committed for this partition yet. + NextOffset() (int64, string) + + // MarkOffset marks the provided offset, alongside a metadata string + // that represents the state of the partition consumer at that point in time. The + // metadata string can be used by another consumer to restore that state, so it + // can resume consumption. + // + // To follow upstream conventions, you are expected to mark the offset of the + // next message to read, not the last message read. Thus, when calling `MarkOffset` + // you should typically add one to the offset of the last consumed message. + // + // Note: calling MarkOffset does not necessarily commit the offset to the backend + // store immediately for efficiency reasons, and it may never be committed if + // your application crashes. This means that you may end up processing the same + // message twice, and your processing should ideally be idempotent. + MarkOffset(offset int64, metadata string) + + // Errors returns a read channel of errors that occur during offset management, if + // enabled. By default, errors are logged and not returned over this channel. If + // you want to implement any custom error handling, set your config's + // Consumer.Return.Errors setting to true, and read from this channel. + Errors() <-chan *ConsumerError + + // AsyncClose initiates a shutdown of the PartitionOffsetManager. This method will + // return immediately, after which you should wait until the 'errors' channel has + // been drained and closed. It is required to call this function, or Close before + // a consumer object passes out of scope, as it will otherwise leak memory. You + // must call this before calling Close on the underlying client. + AsyncClose() + + // Close stops the PartitionOffsetManager from managing offsets. It is required to + // call this function (or AsyncClose) before a PartitionOffsetManager object + // passes out of scope, as it will otherwise leak memory. You must call this + // before calling Close on the underlying client. + Close() error +} + +type partitionOffsetManager struct { + parent *offsetManager + topic string + partition int32 + + lock sync.Mutex + offset int64 + metadata string + dirty bool + clean sync.Cond + broker *brokerOffsetManager + + errors chan *ConsumerError + rebalance chan none + dying chan none +} + +func (om *offsetManager) newPartitionOffsetManager(topic string, partition int32) (*partitionOffsetManager, error) { + pom := &partitionOffsetManager{ + parent: om, + topic: topic, + partition: partition, + errors: make(chan *ConsumerError, om.conf.ChannelBufferSize), + rebalance: make(chan none, 1), + dying: make(chan none), + } + pom.clean.L = &pom.lock + + if err := pom.selectBroker(); err != nil { + return nil, err + } + + if err := pom.fetchInitialOffset(om.conf.Metadata.Retry.Max); err != nil { + return nil, err + } + + pom.broker.updateSubscriptions <- pom + + go withRecover(pom.mainLoop) + + return pom, nil +} + +func (pom *partitionOffsetManager) mainLoop() { + for { + select { + case <-pom.rebalance: + if err := pom.selectBroker(); err != nil { + pom.handleError(err) + pom.rebalance <- none{} + } else { + pom.broker.updateSubscriptions <- pom + } + case <-pom.dying: + if pom.broker != nil { + select { + case <-pom.rebalance: + case pom.broker.updateSubscriptions <- pom: + } + pom.parent.unrefBrokerOffsetManager(pom.broker) + } + pom.parent.abandonPartitionOffsetManager(pom) + close(pom.errors) + return + } + } +} + +func (pom *partitionOffsetManager) selectBroker() error { + if pom.broker != nil { + pom.parent.unrefBrokerOffsetManager(pom.broker) + pom.broker = nil + } + + var broker *Broker + var err error + + if err = pom.parent.client.RefreshCoordinator(pom.parent.group); err != nil { + return err + } + + if broker, err = pom.parent.client.Coordinator(pom.parent.group); err != nil { + return err + } + + pom.broker = pom.parent.refBrokerOffsetManager(broker) + return nil +} + +func (pom *partitionOffsetManager) fetchInitialOffset(retries int) error { + request := new(OffsetFetchRequest) + request.Version = 1 + request.ConsumerGroup = pom.parent.group + request.AddPartition(pom.topic, pom.partition) + + response, err := pom.broker.broker.FetchOffset(request) + if err != nil { + return err + } + + block := response.GetBlock(pom.topic, pom.partition) + if block == nil { + return ErrIncompleteResponse + } + + switch block.Err { + case ErrNoError: + pom.offset = block.Offset + pom.metadata = block.Metadata + return nil + case ErrNotCoordinatorForConsumer: + if retries <= 0 { + return block.Err + } + if err := pom.selectBroker(); err != nil { + return err + } + return pom.fetchInitialOffset(retries - 1) + case ErrOffsetsLoadInProgress: + if retries <= 0 { + return block.Err + } + time.Sleep(pom.parent.conf.Metadata.Retry.Backoff) + return pom.fetchInitialOffset(retries - 1) + default: + return block.Err + } +} + +func (pom *partitionOffsetManager) handleError(err error) { + cErr := &ConsumerError{ + Topic: pom.topic, + Partition: pom.partition, + Err: err, + } + + if pom.parent.conf.Consumer.Return.Errors { + pom.errors <- cErr + } else { + Logger.Println(cErr) + } +} + +func (pom *partitionOffsetManager) Errors() <-chan *ConsumerError { + return pom.errors +} + +func (pom *partitionOffsetManager) MarkOffset(offset int64, metadata string) { + pom.lock.Lock() + defer pom.lock.Unlock() + + if offset > pom.offset { + pom.offset = offset + pom.metadata = metadata + pom.dirty = true + } +} + +func (pom *partitionOffsetManager) updateCommitted(offset int64, metadata string) { + pom.lock.Lock() + defer pom.lock.Unlock() + + if pom.offset == offset && pom.metadata == metadata { + pom.dirty = false + pom.clean.Signal() + } +} + +func (pom *partitionOffsetManager) NextOffset() (int64, string) { + pom.lock.Lock() + defer pom.lock.Unlock() + + if pom.offset >= 0 { + return pom.offset, pom.metadata + } + + return pom.parent.conf.Consumer.Offsets.Initial, "" +} + +func (pom *partitionOffsetManager) AsyncClose() { + go func() { + pom.lock.Lock() + defer pom.lock.Unlock() + + for pom.dirty { + pom.clean.Wait() + } + + close(pom.dying) + }() +} + +func (pom *partitionOffsetManager) Close() error { + pom.AsyncClose() + + var errors ConsumerErrors + for err := range pom.errors { + errors = append(errors, err) + } + + if len(errors) > 0 { + return errors + } + return nil +} + +// Broker Offset Manager + +type brokerOffsetManager struct { + parent *offsetManager + broker *Broker + timer *time.Ticker + updateSubscriptions chan *partitionOffsetManager + subscriptions map[*partitionOffsetManager]none + refs int +} + +func (om *offsetManager) newBrokerOffsetManager(broker *Broker) *brokerOffsetManager { + bom := &brokerOffsetManager{ + parent: om, + broker: broker, + timer: time.NewTicker(om.conf.Consumer.Offsets.CommitInterval), + updateSubscriptions: make(chan *partitionOffsetManager), + subscriptions: make(map[*partitionOffsetManager]none), + } + + go withRecover(bom.mainLoop) + + return bom +} + +func (bom *brokerOffsetManager) mainLoop() { + for { + select { + case <-bom.timer.C: + if len(bom.subscriptions) > 0 { + bom.flushToBroker() + } + case s, ok := <-bom.updateSubscriptions: + if !ok { + bom.timer.Stop() + return + } + if _, ok := bom.subscriptions[s]; ok { + delete(bom.subscriptions, s) + } else { + bom.subscriptions[s] = none{} + } + } + } +} + +func (bom *brokerOffsetManager) flushToBroker() { + request := bom.constructRequest() + if request == nil { + return + } + + response, err := bom.broker.CommitOffset(request) + + if err != nil { + bom.abort(err) + return + } + + for s := range bom.subscriptions { + if request.blocks[s.topic] == nil || request.blocks[s.topic][s.partition] == nil { + continue + } + + var err KError + var ok bool + + if response.Errors[s.topic] == nil { + s.handleError(ErrIncompleteResponse) + delete(bom.subscriptions, s) + s.rebalance <- none{} + continue + } + if err, ok = response.Errors[s.topic][s.partition]; !ok { + s.handleError(ErrIncompleteResponse) + delete(bom.subscriptions, s) + s.rebalance <- none{} + continue + } + + switch err { + case ErrNoError: + block := request.blocks[s.topic][s.partition] + s.updateCommitted(block.offset, block.metadata) + case ErrNotLeaderForPartition, ErrLeaderNotAvailable, + ErrConsumerCoordinatorNotAvailable, ErrNotCoordinatorForConsumer: + // not a critical error, we just need to redispatch + delete(bom.subscriptions, s) + s.rebalance <- none{} + case ErrOffsetMetadataTooLarge, ErrInvalidCommitOffsetSize: + // nothing we can do about this, just tell the user and carry on + s.handleError(err) + case ErrOffsetsLoadInProgress: + // nothing wrong but we didn't commit, we'll get it next time round + break + case ErrUnknownTopicOrPartition: + // let the user know *and* try redispatching - if topic-auto-create is + // enabled, redispatching should trigger a metadata request and create the + // topic; if not then re-dispatching won't help, but we've let the user + // know and it shouldn't hurt either (see https://github.com/Shopify/sarama/issues/706) + fallthrough + default: + // dunno, tell the user and try redispatching + s.handleError(err) + delete(bom.subscriptions, s) + s.rebalance <- none{} + } + } +} + +func (bom *brokerOffsetManager) constructRequest() *OffsetCommitRequest { + var r *OffsetCommitRequest + var perPartitionTimestamp int64 + if bom.parent.conf.Consumer.Offsets.Retention == 0 { + perPartitionTimestamp = ReceiveTime + r = &OffsetCommitRequest{ + Version: 1, + ConsumerGroup: bom.parent.group, + ConsumerGroupGeneration: GroupGenerationUndefined, + } + } else { + r = &OffsetCommitRequest{ + Version: 2, + RetentionTime: int64(bom.parent.conf.Consumer.Offsets.Retention / time.Millisecond), + ConsumerGroup: bom.parent.group, + ConsumerGroupGeneration: GroupGenerationUndefined, + } + + } + + for s := range bom.subscriptions { + s.lock.Lock() + if s.dirty { + r.AddBlock(s.topic, s.partition, s.offset, perPartitionTimestamp, s.metadata) + } + s.lock.Unlock() + } + + if len(r.blocks) > 0 { + return r + } + + return nil +} + +func (bom *brokerOffsetManager) abort(err error) { + _ = bom.broker.Close() // we don't care about the error this might return, we already have one + bom.parent.abandonBroker(bom) + + for pom := range bom.subscriptions { + pom.handleError(err) + pom.rebalance <- none{} + } + + for s := range bom.updateSubscriptions { + if _, ok := bom.subscriptions[s]; !ok { + s.handleError(err) + s.rebalance <- none{} + } + } + + bom.subscriptions = make(map[*partitionOffsetManager]none) +} diff --git a/vendor/github.com/Shopify/sarama/offset_request.go b/vendor/github.com/Shopify/sarama/offset_request.go new file mode 100644 index 00000000..6c269601 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/offset_request.go @@ -0,0 +1,132 @@ +package sarama + +type offsetRequestBlock struct { + time int64 + maxOffsets int32 // Only used in version 0 +} + +func (b *offsetRequestBlock) encode(pe packetEncoder, version int16) error { + pe.putInt64(int64(b.time)) + if version == 0 { + pe.putInt32(b.maxOffsets) + } + + return nil +} + +func (b *offsetRequestBlock) decode(pd packetDecoder, version int16) (err error) { + if b.time, err = pd.getInt64(); err != nil { + return err + } + if version == 0 { + if b.maxOffsets, err = pd.getInt32(); err != nil { + return err + } + } + return nil +} + +type OffsetRequest struct { + Version int16 + blocks map[string]map[int32]*offsetRequestBlock +} + +func (r *OffsetRequest) encode(pe packetEncoder) error { + pe.putInt32(-1) // replica ID is always -1 for clients + err := pe.putArrayLength(len(r.blocks)) + if err != nil { + return err + } + for topic, partitions := range r.blocks { + err = pe.putString(topic) + if err != nil { + return err + } + err = pe.putArrayLength(len(partitions)) + if err != nil { + return err + } + for partition, block := range partitions { + pe.putInt32(partition) + if err = block.encode(pe, r.Version); err != nil { + return err + } + } + } + return nil +} + +func (r *OffsetRequest) decode(pd packetDecoder, version int16) error { + r.Version = version + + // Ignore replica ID + if _, err := pd.getInt32(); err != nil { + return err + } + blockCount, err := pd.getArrayLength() + if err != nil { + return err + } + if blockCount == 0 { + return nil + } + r.blocks = make(map[string]map[int32]*offsetRequestBlock) + for i := 0; i < blockCount; i++ { + topic, err := pd.getString() + if err != nil { + return err + } + partitionCount, err := pd.getArrayLength() + if err != nil { + return err + } + r.blocks[topic] = make(map[int32]*offsetRequestBlock) + for j := 0; j < partitionCount; j++ { + partition, err := pd.getInt32() + if err != nil { + return err + } + block := &offsetRequestBlock{} + if err := block.decode(pd, version); err != nil { + return err + } + r.blocks[topic][partition] = block + } + } + return nil +} + +func (r *OffsetRequest) key() int16 { + return 2 +} + +func (r *OffsetRequest) version() int16 { + return r.Version +} + +func (r *OffsetRequest) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_10_1_0 + default: + return minVersion + } +} + +func (r *OffsetRequest) AddBlock(topic string, partitionID int32, time int64, maxOffsets int32) { + if r.blocks == nil { + r.blocks = make(map[string]map[int32]*offsetRequestBlock) + } + + if r.blocks[topic] == nil { + r.blocks[topic] = make(map[int32]*offsetRequestBlock) + } + + tmp := new(offsetRequestBlock) + tmp.time = time + if r.Version == 0 { + tmp.maxOffsets = maxOffsets + } + + r.blocks[topic][partitionID] = tmp +} diff --git a/vendor/github.com/Shopify/sarama/offset_response.go b/vendor/github.com/Shopify/sarama/offset_response.go new file mode 100644 index 00000000..9a9cfe96 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/offset_response.go @@ -0,0 +1,174 @@ +package sarama + +type OffsetResponseBlock struct { + Err KError + Offsets []int64 // Version 0 + Offset int64 // Version 1 + Timestamp int64 // Version 1 +} + +func (b *OffsetResponseBlock) decode(pd packetDecoder, version int16) (err error) { + tmp, err := pd.getInt16() + if err != nil { + return err + } + b.Err = KError(tmp) + + if version == 0 { + b.Offsets, err = pd.getInt64Array() + + return err + } + + b.Timestamp, err = pd.getInt64() + if err != nil { + return err + } + + b.Offset, err = pd.getInt64() + if err != nil { + return err + } + + // For backwards compatibility put the offset in the offsets array too + b.Offsets = []int64{b.Offset} + + return nil +} + +func (b *OffsetResponseBlock) encode(pe packetEncoder, version int16) (err error) { + pe.putInt16(int16(b.Err)) + + if version == 0 { + return pe.putInt64Array(b.Offsets) + } + + pe.putInt64(b.Timestamp) + pe.putInt64(b.Offset) + + return nil +} + +type OffsetResponse struct { + Version int16 + Blocks map[string]map[int32]*OffsetResponseBlock +} + +func (r *OffsetResponse) decode(pd packetDecoder, version int16) (err error) { + numTopics, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Blocks = make(map[string]map[int32]*OffsetResponseBlock, numTopics) + for i := 0; i < numTopics; i++ { + name, err := pd.getString() + if err != nil { + return err + } + + numBlocks, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Blocks[name] = make(map[int32]*OffsetResponseBlock, numBlocks) + + for j := 0; j < numBlocks; j++ { + id, err := pd.getInt32() + if err != nil { + return err + } + + block := new(OffsetResponseBlock) + err = block.decode(pd, version) + if err != nil { + return err + } + r.Blocks[name][id] = block + } + } + + return nil +} + +func (r *OffsetResponse) GetBlock(topic string, partition int32) *OffsetResponseBlock { + if r.Blocks == nil { + return nil + } + + if r.Blocks[topic] == nil { + return nil + } + + return r.Blocks[topic][partition] +} + +/* +// [0 0 0 1 ntopics +0 8 109 121 95 116 111 112 105 99 topic +0 0 0 1 npartitions +0 0 0 0 id +0 0 + +0 0 0 1 0 0 0 0 +0 1 1 1 0 0 0 1 +0 8 109 121 95 116 111 112 +105 99 0 0 0 1 0 0 +0 0 0 0 0 0 0 1 +0 0 0 0 0 1 1 1] + +*/ +func (r *OffsetResponse) encode(pe packetEncoder) (err error) { + if err = pe.putArrayLength(len(r.Blocks)); err != nil { + return err + } + + for topic, partitions := range r.Blocks { + if err = pe.putString(topic); err != nil { + return err + } + if err = pe.putArrayLength(len(partitions)); err != nil { + return err + } + for partition, block := range partitions { + pe.putInt32(partition) + if err = block.encode(pe, r.version()); err != nil { + return err + } + } + } + + return nil +} + +func (r *OffsetResponse) key() int16 { + return 2 +} + +func (r *OffsetResponse) version() int16 { + return r.Version +} + +func (r *OffsetResponse) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_10_1_0 + default: + return minVersion + } +} + +// testing API + +func (r *OffsetResponse) AddTopicPartition(topic string, partition int32, offset int64) { + if r.Blocks == nil { + r.Blocks = make(map[string]map[int32]*OffsetResponseBlock) + } + byTopic, ok := r.Blocks[topic] + if !ok { + byTopic = make(map[int32]*OffsetResponseBlock) + r.Blocks[topic] = byTopic + } + byTopic[partition] = &OffsetResponseBlock{Offsets: []int64{offset}, Offset: offset} +} diff --git a/vendor/github.com/Shopify/sarama/packet_decoder.go b/vendor/github.com/Shopify/sarama/packet_decoder.go new file mode 100644 index 00000000..28670c0e --- /dev/null +++ b/vendor/github.com/Shopify/sarama/packet_decoder.go @@ -0,0 +1,45 @@ +package sarama + +// PacketDecoder is the interface providing helpers for reading with Kafka's encoding rules. +// Types implementing Decoder only need to worry about calling methods like GetString, +// not about how a string is represented in Kafka. +type packetDecoder interface { + // Primitives + getInt8() (int8, error) + getInt16() (int16, error) + getInt32() (int32, error) + getInt64() (int64, error) + getArrayLength() (int, error) + + // Collections + getBytes() ([]byte, error) + getString() (string, error) + getInt32Array() ([]int32, error) + getInt64Array() ([]int64, error) + getStringArray() ([]string, error) + + // Subsets + remaining() int + getSubset(length int) (packetDecoder, error) + + // Stacks, see PushDecoder + push(in pushDecoder) error + pop() error +} + +// PushDecoder is the interface for decoding fields like CRCs and lengths where the validity +// of the field depends on what is after it in the packet. Start them with PacketDecoder.Push() where +// the actual value is located in the packet, then PacketDecoder.Pop() them when all the bytes they +// depend upon have been decoded. +type pushDecoder interface { + // Saves the offset into the input buffer as the location to actually read the calculated value when able. + saveOffset(in int) + + // Returns the length of data to reserve for the input of this encoder (eg 4 bytes for a CRC32). + reserveLength() int + + // Indicates that all required data is now available to calculate and check the field. + // SaveOffset is guaranteed to have been called first. The implementation should read ReserveLength() bytes + // of data from the saved offset, and verify it based on the data between the saved offset and curOffset. + check(curOffset int, buf []byte) error +} diff --git a/vendor/github.com/Shopify/sarama/packet_encoder.go b/vendor/github.com/Shopify/sarama/packet_encoder.go new file mode 100644 index 00000000..27a10f6d --- /dev/null +++ b/vendor/github.com/Shopify/sarama/packet_encoder.go @@ -0,0 +1,50 @@ +package sarama + +import "github.com/rcrowley/go-metrics" + +// PacketEncoder is the interface providing helpers for writing with Kafka's encoding rules. +// Types implementing Encoder only need to worry about calling methods like PutString, +// not about how a string is represented in Kafka. +type packetEncoder interface { + // Primitives + putInt8(in int8) + putInt16(in int16) + putInt32(in int32) + putInt64(in int64) + putArrayLength(in int) error + + // Collections + putBytes(in []byte) error + putRawBytes(in []byte) error + putString(in string) error + putStringArray(in []string) error + putInt32Array(in []int32) error + putInt64Array(in []int64) error + + // Provide the current offset to record the batch size metric + offset() int + + // Stacks, see PushEncoder + push(in pushEncoder) + pop() error + + // To record metrics when provided + metricRegistry() metrics.Registry +} + +// PushEncoder is the interface for encoding fields like CRCs and lengths where the value +// of the field depends on what is encoded after it in the packet. Start them with PacketEncoder.Push() where +// the actual value is located in the packet, then PacketEncoder.Pop() them when all the bytes they +// depend upon have been written. +type pushEncoder interface { + // Saves the offset into the input buffer as the location to actually write the calculated value when able. + saveOffset(in int) + + // Returns the length of data to reserve for the output of this encoder (eg 4 bytes for a CRC32). + reserveLength() int + + // Indicates that all required data is now available to calculate and write the field. + // SaveOffset is guaranteed to have been called first. The implementation should write ReserveLength() bytes + // of data to the saved offset, based on the data between the saved offset and curOffset. + run(curOffset int, buf []byte) error +} diff --git a/vendor/github.com/Shopify/sarama/partitioner.go b/vendor/github.com/Shopify/sarama/partitioner.go new file mode 100644 index 00000000..d24199da --- /dev/null +++ b/vendor/github.com/Shopify/sarama/partitioner.go @@ -0,0 +1,123 @@ +package sarama + +import ( + "hash" + "hash/fnv" + "math/rand" + "time" +) + +// Partitioner is anything that, given a Kafka message and a number of partitions indexed [0...numPartitions-1], +// decides to which partition to send the message. RandomPartitioner, RoundRobinPartitioner and HashPartitioner are provided +// as simple default implementations. +type Partitioner interface { + // Partition takes a message and partition count and chooses a partition + Partition(message *ProducerMessage, numPartitions int32) (int32, error) + + // RequiresConsistency indicates to the user of the partitioner whether the + // mapping of key->partition is consistent or not. Specifically, if a + // partitioner requires consistency then it must be allowed to choose from all + // partitions (even ones known to be unavailable), and its choice must be + // respected by the caller. The obvious example is the HashPartitioner. + RequiresConsistency() bool +} + +// PartitionerConstructor is the type for a function capable of constructing new Partitioners. +type PartitionerConstructor func(topic string) Partitioner + +type manualPartitioner struct{} + +// NewManualPartitioner returns a Partitioner which uses the partition manually set in the provided +// ProducerMessage's Partition field as the partition to produce to. +func NewManualPartitioner(topic string) Partitioner { + return new(manualPartitioner) +} + +func (p *manualPartitioner) Partition(message *ProducerMessage, numPartitions int32) (int32, error) { + return message.Partition, nil +} + +func (p *manualPartitioner) RequiresConsistency() bool { + return true +} + +type randomPartitioner struct { + generator *rand.Rand +} + +// NewRandomPartitioner returns a Partitioner which chooses a random partition each time. +func NewRandomPartitioner(topic string) Partitioner { + p := new(randomPartitioner) + p.generator = rand.New(rand.NewSource(time.Now().UTC().UnixNano())) + return p +} + +func (p *randomPartitioner) Partition(message *ProducerMessage, numPartitions int32) (int32, error) { + return int32(p.generator.Intn(int(numPartitions))), nil +} + +func (p *randomPartitioner) RequiresConsistency() bool { + return false +} + +type roundRobinPartitioner struct { + partition int32 +} + +// NewRoundRobinPartitioner returns a Partitioner which walks through the available partitions one at a time. +func NewRoundRobinPartitioner(topic string) Partitioner { + return &roundRobinPartitioner{} +} + +func (p *roundRobinPartitioner) Partition(message *ProducerMessage, numPartitions int32) (int32, error) { + if p.partition >= numPartitions { + p.partition = 0 + } + ret := p.partition + p.partition++ + return ret, nil +} + +func (p *roundRobinPartitioner) RequiresConsistency() bool { + return false +} + +type hashPartitioner struct { + random Partitioner + hasher hash.Hash32 +} + +// NewHashPartitioner returns a Partitioner which behaves as follows. If the message's key is nil then a +// random partition is chosen. Otherwise the FNV-1a hash of the encoded bytes of the message key is used, +// modulus the number of partitions. This ensures that messages with the same key always end up on the +// same partition. +func NewHashPartitioner(topic string) Partitioner { + p := new(hashPartitioner) + p.random = NewRandomPartitioner(topic) + p.hasher = fnv.New32a() + return p +} + +func (p *hashPartitioner) Partition(message *ProducerMessage, numPartitions int32) (int32, error) { + if message.Key == nil { + return p.random.Partition(message, numPartitions) + } + bytes, err := message.Key.Encode() + if err != nil { + return -1, err + } + p.hasher.Reset() + _, err = p.hasher.Write(bytes) + if err != nil { + return -1, err + } + partition := int32(p.hasher.Sum32()) % numPartitions + if partition < 0 { + partition = -partition + } + return partition, nil +} + +func (p *hashPartitioner) RequiresConsistency() bool { + return true +} diff --git a/vendor/github.com/Shopify/sarama/prep_encoder.go b/vendor/github.com/Shopify/sarama/prep_encoder.go new file mode 100644 index 00000000..fd5ea0f9 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/prep_encoder.go @@ -0,0 +1,121 @@ +package sarama + +import ( + "fmt" + "math" + + "github.com/rcrowley/go-metrics" +) + +type prepEncoder struct { + length int +} + +// primitives + +func (pe *prepEncoder) putInt8(in int8) { + pe.length++ +} + +func (pe *prepEncoder) putInt16(in int16) { + pe.length += 2 +} + +func (pe *prepEncoder) putInt32(in int32) { + pe.length += 4 +} + +func (pe *prepEncoder) putInt64(in int64) { + pe.length += 8 +} + +func (pe *prepEncoder) putArrayLength(in int) error { + if in > math.MaxInt32 { + return PacketEncodingError{fmt.Sprintf("array too long (%d)", in)} + } + pe.length += 4 + return nil +} + +// arrays + +func (pe *prepEncoder) putBytes(in []byte) error { + pe.length += 4 + if in == nil { + return nil + } + if len(in) > math.MaxInt32 { + return PacketEncodingError{fmt.Sprintf("byteslice too long (%d)", len(in))} + } + pe.length += len(in) + return nil +} + +func (pe *prepEncoder) putRawBytes(in []byte) error { + if len(in) > math.MaxInt32 { + return PacketEncodingError{fmt.Sprintf("byteslice too long (%d)", len(in))} + } + pe.length += len(in) + return nil +} + +func (pe *prepEncoder) putString(in string) error { + pe.length += 2 + if len(in) > math.MaxInt16 { + return PacketEncodingError{fmt.Sprintf("string too long (%d)", len(in))} + } + pe.length += len(in) + return nil +} + +func (pe *prepEncoder) putStringArray(in []string) error { + err := pe.putArrayLength(len(in)) + if err != nil { + return err + } + + for _, str := range in { + if err := pe.putString(str); err != nil { + return err + } + } + + return nil +} + +func (pe *prepEncoder) putInt32Array(in []int32) error { + err := pe.putArrayLength(len(in)) + if err != nil { + return err + } + pe.length += 4 * len(in) + return nil +} + +func (pe *prepEncoder) putInt64Array(in []int64) error { + err := pe.putArrayLength(len(in)) + if err != nil { + return err + } + pe.length += 8 * len(in) + return nil +} + +func (pe *prepEncoder) offset() int { + return pe.length +} + +// stackable + +func (pe *prepEncoder) push(in pushEncoder) { + pe.length += in.reserveLength() +} + +func (pe *prepEncoder) pop() error { + return nil +} + +// we do not record metrics during the prep encoder pass +func (pe *prepEncoder) metricRegistry() metrics.Registry { + return nil +} diff --git a/vendor/github.com/Shopify/sarama/produce_request.go b/vendor/github.com/Shopify/sarama/produce_request.go new file mode 100644 index 00000000..40dc8015 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/produce_request.go @@ -0,0 +1,209 @@ +package sarama + +import "github.com/rcrowley/go-metrics" + +// RequiredAcks is used in Produce Requests to tell the broker how many replica acknowledgements +// it must see before responding. Any of the constants defined here are valid. On broker versions +// prior to 0.8.2.0 any other positive int16 is also valid (the broker will wait for that many +// acknowledgements) but in 0.8.2.0 and later this will raise an exception (it has been replaced +// by setting the `min.isr` value in the brokers configuration). +type RequiredAcks int16 + +const ( + // NoResponse doesn't send any response, the TCP ACK is all you get. + NoResponse RequiredAcks = 0 + // WaitForLocal waits for only the local commit to succeed before responding. + WaitForLocal RequiredAcks = 1 + // WaitForAll waits for all in-sync replicas to commit before responding. + // The minimum number of in-sync replicas is configured on the broker via + // the `min.insync.replicas` configuration key. + WaitForAll RequiredAcks = -1 +) + +type ProduceRequest struct { + RequiredAcks RequiredAcks + Timeout int32 + Version int16 // v1 requires Kafka 0.9, v2 requires Kafka 0.10 + msgSets map[string]map[int32]*MessageSet +} + +func (r *ProduceRequest) encode(pe packetEncoder) error { + pe.putInt16(int16(r.RequiredAcks)) + pe.putInt32(r.Timeout) + err := pe.putArrayLength(len(r.msgSets)) + if err != nil { + return err + } + metricRegistry := pe.metricRegistry() + var batchSizeMetric metrics.Histogram + var compressionRatioMetric metrics.Histogram + if metricRegistry != nil { + batchSizeMetric = getOrRegisterHistogram("batch-size", metricRegistry) + compressionRatioMetric = getOrRegisterHistogram("compression-ratio", metricRegistry) + } + + totalRecordCount := int64(0) + for topic, partitions := range r.msgSets { + err = pe.putString(topic) + if err != nil { + return err + } + err = pe.putArrayLength(len(partitions)) + if err != nil { + return err + } + topicRecordCount := int64(0) + var topicCompressionRatioMetric metrics.Histogram + if metricRegistry != nil { + topicCompressionRatioMetric = getOrRegisterTopicHistogram("compression-ratio", topic, metricRegistry) + } + for id, msgSet := range partitions { + startOffset := pe.offset() + pe.putInt32(id) + pe.push(&lengthField{}) + err = msgSet.encode(pe) + if err != nil { + return err + } + err = pe.pop() + if err != nil { + return err + } + if metricRegistry != nil { + for _, messageBlock := range msgSet.Messages { + // Is this a fake "message" wrapping real messages? + if messageBlock.Msg.Set != nil { + topicRecordCount += int64(len(messageBlock.Msg.Set.Messages)) + } else { + // A single uncompressed message + topicRecordCount++ + } + // Better be safe than sorry when computing the compression ratio + if messageBlock.Msg.compressedSize != 0 { + compressionRatio := float64(len(messageBlock.Msg.Value)) / + float64(messageBlock.Msg.compressedSize) + // Histogram do not support decimal values, let's multiple it by 100 for better precision + intCompressionRatio := int64(100 * compressionRatio) + compressionRatioMetric.Update(intCompressionRatio) + topicCompressionRatioMetric.Update(intCompressionRatio) + } + } + batchSize := int64(pe.offset() - startOffset) + batchSizeMetric.Update(batchSize) + getOrRegisterTopicHistogram("batch-size", topic, metricRegistry).Update(batchSize) + } + } + if topicRecordCount > 0 { + getOrRegisterTopicMeter("record-send-rate", topic, metricRegistry).Mark(topicRecordCount) + getOrRegisterTopicHistogram("records-per-request", topic, metricRegistry).Update(topicRecordCount) + totalRecordCount += topicRecordCount + } + } + if totalRecordCount > 0 { + metrics.GetOrRegisterMeter("record-send-rate", metricRegistry).Mark(totalRecordCount) + getOrRegisterHistogram("records-per-request", metricRegistry).Update(totalRecordCount) + } + + return nil +} + +func (r *ProduceRequest) decode(pd packetDecoder, version int16) error { + requiredAcks, err := pd.getInt16() + if err != nil { + return err + } + r.RequiredAcks = RequiredAcks(requiredAcks) + if r.Timeout, err = pd.getInt32(); err != nil { + return err + } + topicCount, err := pd.getArrayLength() + if err != nil { + return err + } + if topicCount == 0 { + return nil + } + r.msgSets = make(map[string]map[int32]*MessageSet) + for i := 0; i < topicCount; i++ { + topic, err := pd.getString() + if err != nil { + return err + } + partitionCount, err := pd.getArrayLength() + if err != nil { + return err + } + r.msgSets[topic] = make(map[int32]*MessageSet) + for j := 0; j < partitionCount; j++ { + partition, err := pd.getInt32() + if err != nil { + return err + } + messageSetSize, err := pd.getInt32() + if err != nil { + return err + } + msgSetDecoder, err := pd.getSubset(int(messageSetSize)) + if err != nil { + return err + } + msgSet := &MessageSet{} + err = msgSet.decode(msgSetDecoder) + if err != nil { + return err + } + r.msgSets[topic][partition] = msgSet + } + } + return nil +} + +func (r *ProduceRequest) key() int16 { + return 0 +} + +func (r *ProduceRequest) version() int16 { + return r.Version +} + +func (r *ProduceRequest) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_9_0_0 + case 2: + return V0_10_0_0 + default: + return minVersion + } +} + +func (r *ProduceRequest) AddMessage(topic string, partition int32, msg *Message) { + if r.msgSets == nil { + r.msgSets = make(map[string]map[int32]*MessageSet) + } + + if r.msgSets[topic] == nil { + r.msgSets[topic] = make(map[int32]*MessageSet) + } + + set := r.msgSets[topic][partition] + + if set == nil { + set = new(MessageSet) + r.msgSets[topic][partition] = set + } + + set.addMessage(msg) +} + +func (r *ProduceRequest) AddSet(topic string, partition int32, set *MessageSet) { + if r.msgSets == nil { + r.msgSets = make(map[string]map[int32]*MessageSet) + } + + if r.msgSets[topic] == nil { + r.msgSets[topic] = make(map[int32]*MessageSet) + } + + r.msgSets[topic][partition] = set +} diff --git a/vendor/github.com/Shopify/sarama/produce_response.go b/vendor/github.com/Shopify/sarama/produce_response.go new file mode 100644 index 00000000..3f05dd9f --- /dev/null +++ b/vendor/github.com/Shopify/sarama/produce_response.go @@ -0,0 +1,159 @@ +package sarama + +import "time" + +type ProduceResponseBlock struct { + Err KError + Offset int64 + // only provided if Version >= 2 and the broker is configured with `LogAppendTime` + Timestamp time.Time +} + +func (b *ProduceResponseBlock) decode(pd packetDecoder, version int16) (err error) { + tmp, err := pd.getInt16() + if err != nil { + return err + } + b.Err = KError(tmp) + + b.Offset, err = pd.getInt64() + if err != nil { + return err + } + + if version >= 2 { + if millis, err := pd.getInt64(); err != nil { + return err + } else if millis != -1 { + b.Timestamp = time.Unix(millis/1000, (millis%1000)*int64(time.Millisecond)) + } + } + + return nil +} + +type ProduceResponse struct { + Blocks map[string]map[int32]*ProduceResponseBlock + Version int16 + ThrottleTime time.Duration // only provided if Version >= 1 +} + +func (r *ProduceResponse) decode(pd packetDecoder, version int16) (err error) { + r.Version = version + + numTopics, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Blocks = make(map[string]map[int32]*ProduceResponseBlock, numTopics) + for i := 0; i < numTopics; i++ { + name, err := pd.getString() + if err != nil { + return err + } + + numBlocks, err := pd.getArrayLength() + if err != nil { + return err + } + + r.Blocks[name] = make(map[int32]*ProduceResponseBlock, numBlocks) + + for j := 0; j < numBlocks; j++ { + id, err := pd.getInt32() + if err != nil { + return err + } + + block := new(ProduceResponseBlock) + err = block.decode(pd, version) + if err != nil { + return err + } + r.Blocks[name][id] = block + } + } + + if r.Version >= 1 { + millis, err := pd.getInt32() + if err != nil { + return err + } + + r.ThrottleTime = time.Duration(millis) * time.Millisecond + } + + return nil +} + +func (r *ProduceResponse) encode(pe packetEncoder) error { + err := pe.putArrayLength(len(r.Blocks)) + if err != nil { + return err + } + for topic, partitions := range r.Blocks { + err = pe.putString(topic) + if err != nil { + return err + } + err = pe.putArrayLength(len(partitions)) + if err != nil { + return err + } + for id, prb := range partitions { + pe.putInt32(id) + pe.putInt16(int16(prb.Err)) + pe.putInt64(prb.Offset) + } + } + if r.Version >= 1 { + pe.putInt32(int32(r.ThrottleTime / time.Millisecond)) + } + return nil +} + +func (r *ProduceResponse) key() int16 { + return 0 +} + +func (r *ProduceResponse) version() int16 { + return r.Version +} + +func (r *ProduceResponse) requiredVersion() KafkaVersion { + switch r.Version { + case 1: + return V0_9_0_0 + case 2: + return V0_10_0_0 + default: + return minVersion + } +} + +func (r *ProduceResponse) GetBlock(topic string, partition int32) *ProduceResponseBlock { + if r.Blocks == nil { + return nil + } + + if r.Blocks[topic] == nil { + return nil + } + + return r.Blocks[topic][partition] +} + +// Testing API + +func (r *ProduceResponse) AddTopicPartition(topic string, partition int32, err KError) { + if r.Blocks == nil { + r.Blocks = make(map[string]map[int32]*ProduceResponseBlock) + } + byTopic, ok := r.Blocks[topic] + if !ok { + byTopic = make(map[int32]*ProduceResponseBlock) + r.Blocks[topic] = byTopic + } + byTopic[partition] = &ProduceResponseBlock{Err: err} +} diff --git a/vendor/github.com/Shopify/sarama/produce_set.go b/vendor/github.com/Shopify/sarama/produce_set.go new file mode 100644 index 00000000..158d9c47 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/produce_set.go @@ -0,0 +1,176 @@ +package sarama + +import "time" + +type partitionSet struct { + msgs []*ProducerMessage + setToSend *MessageSet + bufferBytes int +} + +type produceSet struct { + parent *asyncProducer + msgs map[string]map[int32]*partitionSet + + bufferBytes int + bufferCount int +} + +func newProduceSet(parent *asyncProducer) *produceSet { + return &produceSet{ + msgs: make(map[string]map[int32]*partitionSet), + parent: parent, + } +} + +func (ps *produceSet) add(msg *ProducerMessage) error { + var err error + var key, val []byte + + if msg.Key != nil { + if key, err = msg.Key.Encode(); err != nil { + return err + } + } + + if msg.Value != nil { + if val, err = msg.Value.Encode(); err != nil { + return err + } + } + + partitions := ps.msgs[msg.Topic] + if partitions == nil { + partitions = make(map[int32]*partitionSet) + ps.msgs[msg.Topic] = partitions + } + + set := partitions[msg.Partition] + if set == nil { + set = &partitionSet{setToSend: new(MessageSet)} + partitions[msg.Partition] = set + } + + set.msgs = append(set.msgs, msg) + msgToSend := &Message{Codec: CompressionNone, Key: key, Value: val} + if ps.parent.conf.Version.IsAtLeast(V0_10_0_0) { + if msg.Timestamp.IsZero() { + msgToSend.Timestamp = time.Now() + } else { + msgToSend.Timestamp = msg.Timestamp + } + msgToSend.Version = 1 + } + set.setToSend.addMessage(msgToSend) + + size := producerMessageOverhead + len(key) + len(val) + set.bufferBytes += size + ps.bufferBytes += size + ps.bufferCount++ + + return nil +} + +func (ps *produceSet) buildRequest() *ProduceRequest { + req := &ProduceRequest{ + RequiredAcks: ps.parent.conf.Producer.RequiredAcks, + Timeout: int32(ps.parent.conf.Producer.Timeout / time.Millisecond), + } + if ps.parent.conf.Version.IsAtLeast(V0_10_0_0) { + req.Version = 2 + } + + for topic, partitionSet := range ps.msgs { + for partition, set := range partitionSet { + if ps.parent.conf.Producer.Compression == CompressionNone { + req.AddSet(topic, partition, set.setToSend) + } else { + // When compression is enabled, the entire set for each partition is compressed + // and sent as the payload of a single fake "message" with the appropriate codec + // set and no key. When the server sees a message with a compression codec, it + // decompresses the payload and treats the result as its message set. + payload, err := encode(set.setToSend, ps.parent.conf.MetricRegistry) + if err != nil { + Logger.Println(err) // if this happens, it's basically our fault. + panic(err) + } + compMsg := &Message{ + Codec: ps.parent.conf.Producer.Compression, + Key: nil, + Value: payload, + Set: set.setToSend, // Provide the underlying message set for accurate metrics + } + if ps.parent.conf.Version.IsAtLeast(V0_10_0_0) { + compMsg.Version = 1 + compMsg.Timestamp = set.setToSend.Messages[0].Msg.Timestamp + } + req.AddMessage(topic, partition, compMsg) + } + } + } + + return req +} + +func (ps *produceSet) eachPartition(cb func(topic string, partition int32, msgs []*ProducerMessage)) { + for topic, partitionSet := range ps.msgs { + for partition, set := range partitionSet { + cb(topic, partition, set.msgs) + } + } +} + +func (ps *produceSet) dropPartition(topic string, partition int32) []*ProducerMessage { + if ps.msgs[topic] == nil { + return nil + } + set := ps.msgs[topic][partition] + if set == nil { + return nil + } + ps.bufferBytes -= set.bufferBytes + ps.bufferCount -= len(set.msgs) + delete(ps.msgs[topic], partition) + return set.msgs +} + +func (ps *produceSet) wouldOverflow(msg *ProducerMessage) bool { + switch { + // Would we overflow our maximum possible size-on-the-wire? 10KiB is arbitrary overhead for safety. + case ps.bufferBytes+msg.byteSize() >= int(MaxRequestSize-(10*1024)): + return true + // Would we overflow the size-limit of a compressed message-batch for this partition? + case ps.parent.conf.Producer.Compression != CompressionNone && + ps.msgs[msg.Topic] != nil && ps.msgs[msg.Topic][msg.Partition] != nil && + ps.msgs[msg.Topic][msg.Partition].bufferBytes+msg.byteSize() >= ps.parent.conf.Producer.MaxMessageBytes: + return true + // Would we overflow simply in number of messages? + case ps.parent.conf.Producer.Flush.MaxMessages > 0 && ps.bufferCount >= ps.parent.conf.Producer.Flush.MaxMessages: + return true + default: + return false + } +} + +func (ps *produceSet) readyToFlush() bool { + switch { + // If we don't have any messages, nothing else matters + case ps.empty(): + return false + // If all three config values are 0, we always flush as-fast-as-possible + case ps.parent.conf.Producer.Flush.Frequency == 0 && ps.parent.conf.Producer.Flush.Bytes == 0 && ps.parent.conf.Producer.Flush.Messages == 0: + return true + // If we've passed the message trigger-point + case ps.parent.conf.Producer.Flush.Messages > 0 && ps.bufferCount >= ps.parent.conf.Producer.Flush.Messages: + return true + // If we've passed the byte trigger-point + case ps.parent.conf.Producer.Flush.Bytes > 0 && ps.bufferBytes >= ps.parent.conf.Producer.Flush.Bytes: + return true + default: + return false + } +} + +func (ps *produceSet) empty() bool { + return ps.bufferCount == 0 +} diff --git a/vendor/github.com/Shopify/sarama/real_decoder.go b/vendor/github.com/Shopify/sarama/real_decoder.go new file mode 100644 index 00000000..3cf93533 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/real_decoder.go @@ -0,0 +1,260 @@ +package sarama + +import ( + "encoding/binary" + "math" +) + +var errInvalidArrayLength = PacketDecodingError{"invalid array length"} +var errInvalidByteSliceLength = PacketDecodingError{"invalid byteslice length"} +var errInvalidStringLength = PacketDecodingError{"invalid string length"} +var errInvalidSubsetSize = PacketDecodingError{"invalid subset size"} + +type realDecoder struct { + raw []byte + off int + stack []pushDecoder +} + +// primitives + +func (rd *realDecoder) getInt8() (int8, error) { + if rd.remaining() < 1 { + rd.off = len(rd.raw) + return -1, ErrInsufficientData + } + tmp := int8(rd.raw[rd.off]) + rd.off++ + return tmp, nil +} + +func (rd *realDecoder) getInt16() (int16, error) { + if rd.remaining() < 2 { + rd.off = len(rd.raw) + return -1, ErrInsufficientData + } + tmp := int16(binary.BigEndian.Uint16(rd.raw[rd.off:])) + rd.off += 2 + return tmp, nil +} + +func (rd *realDecoder) getInt32() (int32, error) { + if rd.remaining() < 4 { + rd.off = len(rd.raw) + return -1, ErrInsufficientData + } + tmp := int32(binary.BigEndian.Uint32(rd.raw[rd.off:])) + rd.off += 4 + return tmp, nil +} + +func (rd *realDecoder) getInt64() (int64, error) { + if rd.remaining() < 8 { + rd.off = len(rd.raw) + return -1, ErrInsufficientData + } + tmp := int64(binary.BigEndian.Uint64(rd.raw[rd.off:])) + rd.off += 8 + return tmp, nil +} + +func (rd *realDecoder) getArrayLength() (int, error) { + if rd.remaining() < 4 { + rd.off = len(rd.raw) + return -1, ErrInsufficientData + } + tmp := int(binary.BigEndian.Uint32(rd.raw[rd.off:])) + rd.off += 4 + if tmp > rd.remaining() { + rd.off = len(rd.raw) + return -1, ErrInsufficientData + } else if tmp > 2*math.MaxUint16 { + return -1, errInvalidArrayLength + } + return tmp, nil +} + +// collections + +func (rd *realDecoder) getBytes() ([]byte, error) { + tmp, err := rd.getInt32() + + if err != nil { + return nil, err + } + + n := int(tmp) + + switch { + case n < -1: + return nil, errInvalidByteSliceLength + case n == -1: + return nil, nil + case n == 0: + return make([]byte, 0), nil + case n > rd.remaining(): + rd.off = len(rd.raw) + return nil, ErrInsufficientData + } + + tmpStr := rd.raw[rd.off : rd.off+n] + rd.off += n + return tmpStr, nil +} + +func (rd *realDecoder) getString() (string, error) { + tmp, err := rd.getInt16() + + if err != nil { + return "", err + } + + n := int(tmp) + + switch { + case n < -1: + return "", errInvalidStringLength + case n == -1: + return "", nil + case n == 0: + return "", nil + case n > rd.remaining(): + rd.off = len(rd.raw) + return "", ErrInsufficientData + } + + tmpStr := string(rd.raw[rd.off : rd.off+n]) + rd.off += n + return tmpStr, nil +} + +func (rd *realDecoder) getInt32Array() ([]int32, error) { + if rd.remaining() < 4 { + rd.off = len(rd.raw) + return nil, ErrInsufficientData + } + n := int(binary.BigEndian.Uint32(rd.raw[rd.off:])) + rd.off += 4 + + if rd.remaining() < 4*n { + rd.off = len(rd.raw) + return nil, ErrInsufficientData + } + + if n == 0 { + return nil, nil + } + + if n < 0 { + return nil, errInvalidArrayLength + } + + ret := make([]int32, n) + for i := range ret { + ret[i] = int32(binary.BigEndian.Uint32(rd.raw[rd.off:])) + rd.off += 4 + } + return ret, nil +} + +func (rd *realDecoder) getInt64Array() ([]int64, error) { + if rd.remaining() < 4 { + rd.off = len(rd.raw) + return nil, ErrInsufficientData + } + n := int(binary.BigEndian.Uint32(rd.raw[rd.off:])) + rd.off += 4 + + if rd.remaining() < 8*n { + rd.off = len(rd.raw) + return nil, ErrInsufficientData + } + + if n == 0 { + return nil, nil + } + + if n < 0 { + return nil, errInvalidArrayLength + } + + ret := make([]int64, n) + for i := range ret { + ret[i] = int64(binary.BigEndian.Uint64(rd.raw[rd.off:])) + rd.off += 8 + } + return ret, nil +} + +func (rd *realDecoder) getStringArray() ([]string, error) { + if rd.remaining() < 4 { + rd.off = len(rd.raw) + return nil, ErrInsufficientData + } + n := int(binary.BigEndian.Uint32(rd.raw[rd.off:])) + rd.off += 4 + + if n == 0 { + return nil, nil + } + + if n < 0 { + return nil, errInvalidArrayLength + } + + ret := make([]string, n) + for i := range ret { + str, err := rd.getString() + if err != nil { + return nil, err + } + + ret[i] = str + } + return ret, nil +} + +// subsets + +func (rd *realDecoder) remaining() int { + return len(rd.raw) - rd.off +} + +func (rd *realDecoder) getSubset(length int) (packetDecoder, error) { + if length < 0 { + return nil, errInvalidSubsetSize + } else if length > rd.remaining() { + rd.off = len(rd.raw) + return nil, ErrInsufficientData + } + + start := rd.off + rd.off += length + return &realDecoder{raw: rd.raw[start:rd.off]}, nil +} + +// stacks + +func (rd *realDecoder) push(in pushDecoder) error { + in.saveOffset(rd.off) + + reserve := in.reserveLength() + if rd.remaining() < reserve { + rd.off = len(rd.raw) + return ErrInsufficientData + } + + rd.stack = append(rd.stack, in) + + rd.off += reserve + + return nil +} + +func (rd *realDecoder) pop() error { + // this is go's ugly pop pattern (the inverse of append) + in := rd.stack[len(rd.stack)-1] + rd.stack = rd.stack[:len(rd.stack)-1] + + return in.check(rd.off, rd.raw) +} diff --git a/vendor/github.com/Shopify/sarama/real_encoder.go b/vendor/github.com/Shopify/sarama/real_encoder.go new file mode 100644 index 00000000..ced4267c --- /dev/null +++ b/vendor/github.com/Shopify/sarama/real_encoder.go @@ -0,0 +1,129 @@ +package sarama + +import ( + "encoding/binary" + + "github.com/rcrowley/go-metrics" +) + +type realEncoder struct { + raw []byte + off int + stack []pushEncoder + registry metrics.Registry +} + +// primitives + +func (re *realEncoder) putInt8(in int8) { + re.raw[re.off] = byte(in) + re.off++ +} + +func (re *realEncoder) putInt16(in int16) { + binary.BigEndian.PutUint16(re.raw[re.off:], uint16(in)) + re.off += 2 +} + +func (re *realEncoder) putInt32(in int32) { + binary.BigEndian.PutUint32(re.raw[re.off:], uint32(in)) + re.off += 4 +} + +func (re *realEncoder) putInt64(in int64) { + binary.BigEndian.PutUint64(re.raw[re.off:], uint64(in)) + re.off += 8 +} + +func (re *realEncoder) putArrayLength(in int) error { + re.putInt32(int32(in)) + return nil +} + +// collection + +func (re *realEncoder) putRawBytes(in []byte) error { + copy(re.raw[re.off:], in) + re.off += len(in) + return nil +} + +func (re *realEncoder) putBytes(in []byte) error { + if in == nil { + re.putInt32(-1) + return nil + } + re.putInt32(int32(len(in))) + copy(re.raw[re.off:], in) + re.off += len(in) + return nil +} + +func (re *realEncoder) putString(in string) error { + re.putInt16(int16(len(in))) + copy(re.raw[re.off:], in) + re.off += len(in) + return nil +} + +func (re *realEncoder) putStringArray(in []string) error { + err := re.putArrayLength(len(in)) + if err != nil { + return err + } + + for _, val := range in { + if err := re.putString(val); err != nil { + return err + } + } + + return nil +} + +func (re *realEncoder) putInt32Array(in []int32) error { + err := re.putArrayLength(len(in)) + if err != nil { + return err + } + for _, val := range in { + re.putInt32(val) + } + return nil +} + +func (re *realEncoder) putInt64Array(in []int64) error { + err := re.putArrayLength(len(in)) + if err != nil { + return err + } + for _, val := range in { + re.putInt64(val) + } + return nil +} + +func (re *realEncoder) offset() int { + return re.off +} + +// stacks + +func (re *realEncoder) push(in pushEncoder) { + in.saveOffset(re.off) + re.off += in.reserveLength() + re.stack = append(re.stack, in) +} + +func (re *realEncoder) pop() error { + // this is go's ugly pop pattern (the inverse of append) + in := re.stack[len(re.stack)-1] + re.stack = re.stack[:len(re.stack)-1] + + return in.run(re.off, re.raw) +} + +// we do record metrics during the real encoder pass +func (re *realEncoder) metricRegistry() metrics.Registry { + return re.registry +} diff --git a/vendor/github.com/Shopify/sarama/request.go b/vendor/github.com/Shopify/sarama/request.go new file mode 100644 index 00000000..73310ca8 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/request.go @@ -0,0 +1,119 @@ +package sarama + +import ( + "encoding/binary" + "fmt" + "io" +) + +type protocolBody interface { + encoder + versionedDecoder + key() int16 + version() int16 + requiredVersion() KafkaVersion +} + +type request struct { + correlationID int32 + clientID string + body protocolBody +} + +func (r *request) encode(pe packetEncoder) (err error) { + pe.push(&lengthField{}) + pe.putInt16(r.body.key()) + pe.putInt16(r.body.version()) + pe.putInt32(r.correlationID) + err = pe.putString(r.clientID) + if err != nil { + return err + } + err = r.body.encode(pe) + if err != nil { + return err + } + return pe.pop() +} + +func (r *request) decode(pd packetDecoder) (err error) { + var key int16 + if key, err = pd.getInt16(); err != nil { + return err + } + var version int16 + if version, err = pd.getInt16(); err != nil { + return err + } + if r.correlationID, err = pd.getInt32(); err != nil { + return err + } + r.clientID, err = pd.getString() + + r.body = allocateBody(key, version) + if r.body == nil { + return PacketDecodingError{fmt.Sprintf("unknown request key (%d)", key)} + } + return r.body.decode(pd, version) +} + +func decodeRequest(r io.Reader) (req *request, bytesRead int, err error) { + lengthBytes := make([]byte, 4) + if _, err := io.ReadFull(r, lengthBytes); err != nil { + return nil, bytesRead, err + } + bytesRead += len(lengthBytes) + + length := int32(binary.BigEndian.Uint32(lengthBytes)) + if length <= 4 || length > MaxRequestSize { + return nil, bytesRead, PacketDecodingError{fmt.Sprintf("message of length %d too large or too small", length)} + } + + encodedReq := make([]byte, length) + if _, err := io.ReadFull(r, encodedReq); err != nil { + return nil, bytesRead, err + } + bytesRead += len(encodedReq) + + req = &request{} + if err := decode(encodedReq, req); err != nil { + return nil, bytesRead, err + } + return req, bytesRead, nil +} + +func allocateBody(key, version int16) protocolBody { + switch key { + case 0: + return &ProduceRequest{} + case 1: + return &FetchRequest{} + case 2: + return &OffsetRequest{Version: version} + case 3: + return &MetadataRequest{} + case 8: + return &OffsetCommitRequest{Version: version} + case 9: + return &OffsetFetchRequest{} + case 10: + return &ConsumerMetadataRequest{} + case 11: + return &JoinGroupRequest{} + case 12: + return &HeartbeatRequest{} + case 13: + return &LeaveGroupRequest{} + case 14: + return &SyncGroupRequest{} + case 15: + return &DescribeGroupsRequest{} + case 16: + return &ListGroupsRequest{} + case 17: + return &SaslHandshakeRequest{} + case 18: + return &ApiVersionsRequest{} + } + return nil +} diff --git a/vendor/github.com/Shopify/sarama/response_header.go b/vendor/github.com/Shopify/sarama/response_header.go new file mode 100644 index 00000000..f3f4d27d --- /dev/null +++ b/vendor/github.com/Shopify/sarama/response_header.go @@ -0,0 +1,21 @@ +package sarama + +import "fmt" + +type responseHeader struct { + length int32 + correlationID int32 +} + +func (r *responseHeader) decode(pd packetDecoder) (err error) { + r.length, err = pd.getInt32() + if err != nil { + return err + } + if r.length <= 4 || r.length > MaxResponseSize { + return PacketDecodingError{fmt.Sprintf("message of length %d too large or too small", r.length)} + } + + r.correlationID, err = pd.getInt32() + return err +} diff --git a/vendor/github.com/Shopify/sarama/sarama.go b/vendor/github.com/Shopify/sarama/sarama.go new file mode 100644 index 00000000..7d5dc60d --- /dev/null +++ b/vendor/github.com/Shopify/sarama/sarama.go @@ -0,0 +1,99 @@ +/* +Package sarama is a pure Go client library for dealing with Apache Kafka (versions 0.8 and later). It includes a high-level +API for easily producing and consuming messages, and a low-level API for controlling bytes on the wire when the high-level +API is insufficient. Usage examples for the high-level APIs are provided inline with their full documentation. + +To produce messages, use either the AsyncProducer or the SyncProducer. The AsyncProducer accepts messages on a channel +and produces them asynchronously in the background as efficiently as possible; it is preferred in most cases. +The SyncProducer provides a method which will block until Kafka acknowledges the message as produced. This can be +useful but comes with two caveats: it will generally be less efficient, and the actual durability guarantees +depend on the configured value of `Producer.RequiredAcks`. There are configurations where a message acknowledged by the +SyncProducer can still sometimes be lost. + +To consume messages, use the Consumer. Note that Sarama's Consumer implementation does not currently support automatic +consumer-group rebalancing and offset tracking. For Zookeeper-based tracking (Kafka 0.8.2 and earlier), the +https://github.com/wvanbergen/kafka library builds on Sarama to add this support. For Kafka-based tracking (Kafka 0.9 +and later), the https://github.com/bsm/sarama-cluster library builds on Sarama to add this support. + +For lower-level needs, the Broker and Request/Response objects permit precise control over each connection +and message sent on the wire; the Client provides higher-level metadata management that is shared between +the producers and the consumer. The Request/Response objects and properties are mostly undocumented, as they line up +exactly with the protocol fields documented by Kafka at +https://cwiki.apache.org/confluence/display/KAFKA/A+Guide+To+The+Kafka+Protocol + +Metrics are exposed through https://github.com/rcrowley/go-metrics library in a local registry. + +Broker related metrics: + + +----------------------------------------------+------------+---------------------------------------------------------------+ + | Name | Type | Description | + +----------------------------------------------+------------+---------------------------------------------------------------+ + | incoming-byte-rate | meter | Bytes/second read off all brokers | + | incoming-byte-rate-for-broker- | meter | Bytes/second read off a given broker | + | outgoing-byte-rate | meter | Bytes/second written off all brokers | + | outgoing-byte-rate-for-broker- | meter | Bytes/second written off a given broker | + | request-rate | meter | Requests/second sent to all brokers | + | request-rate-for-broker- | meter | Requests/second sent to a given broker | + | request-size | histogram | Distribution of the request size in bytes for all brokers | + | request-size-for-broker- | histogram | Distribution of the request size in bytes for a given broker | + | request-latency-in-ms | histogram | Distribution of the request latency in ms for all brokers | + | request-latency-in-ms-for-broker- | histogram | Distribution of the request latency in ms for a given broker | + | response-rate | meter | Responses/second received from all brokers | + | response-rate-for-broker- | meter | Responses/second received from a given broker | + | response-size | histogram | Distribution of the response size in bytes for all brokers | + | response-size-for-broker- | histogram | Distribution of the response size in bytes for a given broker | + +----------------------------------------------+------------+---------------------------------------------------------------+ + +Note that we do not gather specific metrics for seed brokers but they are part of the "all brokers" metrics. + +Producer related metrics: + + +-------------------------------------------+------------+--------------------------------------------------------------------------------------+ + | Name | Type | Description | + +-------------------------------------------+------------+--------------------------------------------------------------------------------------+ + | batch-size | histogram | Distribution of the number of bytes sent per partition per request for all topics | + | batch-size-for-topic- | histogram | Distribution of the number of bytes sent per partition per request for a given topic | + | record-send-rate | meter | Records/second sent to all topics | + | record-send-rate-for-topic- | meter | Records/second sent to a given topic | + | records-per-request | histogram | Distribution of the number of records sent per request for all topics | + | records-per-request-for-topic- | histogram | Distribution of the number of records sent per request for a given topic | + | compression-ratio | histogram | Distribution of the compression ratio times 100 of record batches for all topics | + | compression-ratio-for-topic- | histogram | Distribution of the compression ratio times 100 of record batches for a given topic | + +-------------------------------------------+------------+--------------------------------------------------------------------------------------+ + +*/ +package sarama + +import ( + "io/ioutil" + "log" +) + +// Logger is the instance of a StdLogger interface that Sarama writes connection +// management events to. By default it is set to discard all log messages via ioutil.Discard, +// but you can set it to redirect wherever you want. +var Logger StdLogger = log.New(ioutil.Discard, "[Sarama] ", log.LstdFlags) + +// StdLogger is used to log error messages. +type StdLogger interface { + Print(v ...interface{}) + Printf(format string, v ...interface{}) + Println(v ...interface{}) +} + +// PanicHandler is called for recovering from panics spawned internally to the library (and thus +// not recoverable by the caller's goroutine). Defaults to nil, which means panics are not recovered. +var PanicHandler func(interface{}) + +// MaxRequestSize is the maximum size (in bytes) of any request that Sarama will attempt to send. Trying +// to send a request larger than this will result in an PacketEncodingError. The default of 100 MiB is aligned +// with Kafka's default `socket.request.max.bytes`, which is the largest request the broker will attempt +// to process. +var MaxRequestSize int32 = 100 * 1024 * 1024 + +// MaxResponseSize is the maximum size (in bytes) of any response that Sarama will attempt to parse. If +// a broker returns a response message larger than this value, Sarama will return a PacketDecodingError to +// protect the client from running out of memory. Please note that brokers do not have any natural limit on +// the size of responses they send. In particular, they can send arbitrarily large fetch responses to consumers +// (see https://issues.apache.org/jira/browse/KAFKA-2063). +var MaxResponseSize int32 = 100 * 1024 * 1024 diff --git a/vendor/github.com/Shopify/sarama/sasl_handshake_request.go b/vendor/github.com/Shopify/sarama/sasl_handshake_request.go new file mode 100644 index 00000000..fbbc8947 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/sasl_handshake_request.go @@ -0,0 +1,33 @@ +package sarama + +type SaslHandshakeRequest struct { + Mechanism string +} + +func (r *SaslHandshakeRequest) encode(pe packetEncoder) error { + if err := pe.putString(r.Mechanism); err != nil { + return err + } + + return nil +} + +func (r *SaslHandshakeRequest) decode(pd packetDecoder, version int16) (err error) { + if r.Mechanism, err = pd.getString(); err != nil { + return err + } + + return nil +} + +func (r *SaslHandshakeRequest) key() int16 { + return 17 +} + +func (r *SaslHandshakeRequest) version() int16 { + return 0 +} + +func (r *SaslHandshakeRequest) requiredVersion() KafkaVersion { + return V0_10_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/sasl_handshake_response.go b/vendor/github.com/Shopify/sarama/sasl_handshake_response.go new file mode 100644 index 00000000..ef290d4b --- /dev/null +++ b/vendor/github.com/Shopify/sarama/sasl_handshake_response.go @@ -0,0 +1,38 @@ +package sarama + +type SaslHandshakeResponse struct { + Err KError + EnabledMechanisms []string +} + +func (r *SaslHandshakeResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + return pe.putStringArray(r.EnabledMechanisms) +} + +func (r *SaslHandshakeResponse) decode(pd packetDecoder, version int16) error { + kerr, err := pd.getInt16() + if err != nil { + return err + } + + r.Err = KError(kerr) + + if r.EnabledMechanisms, err = pd.getStringArray(); err != nil { + return err + } + + return nil +} + +func (r *SaslHandshakeResponse) key() int16 { + return 17 +} + +func (r *SaslHandshakeResponse) version() int16 { + return 0 +} + +func (r *SaslHandshakeResponse) requiredVersion() KafkaVersion { + return V0_10_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/sync_group_request.go b/vendor/github.com/Shopify/sarama/sync_group_request.go new file mode 100644 index 00000000..fe207080 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/sync_group_request.go @@ -0,0 +1,100 @@ +package sarama + +type SyncGroupRequest struct { + GroupId string + GenerationId int32 + MemberId string + GroupAssignments map[string][]byte +} + +func (r *SyncGroupRequest) encode(pe packetEncoder) error { + if err := pe.putString(r.GroupId); err != nil { + return err + } + + pe.putInt32(r.GenerationId) + + if err := pe.putString(r.MemberId); err != nil { + return err + } + + if err := pe.putArrayLength(len(r.GroupAssignments)); err != nil { + return err + } + for memberId, memberAssignment := range r.GroupAssignments { + if err := pe.putString(memberId); err != nil { + return err + } + if err := pe.putBytes(memberAssignment); err != nil { + return err + } + } + + return nil +} + +func (r *SyncGroupRequest) decode(pd packetDecoder, version int16) (err error) { + if r.GroupId, err = pd.getString(); err != nil { + return + } + if r.GenerationId, err = pd.getInt32(); err != nil { + return + } + if r.MemberId, err = pd.getString(); err != nil { + return + } + + n, err := pd.getArrayLength() + if err != nil { + return err + } + if n == 0 { + return nil + } + + r.GroupAssignments = make(map[string][]byte) + for i := 0; i < n; i++ { + memberId, err := pd.getString() + if err != nil { + return err + } + memberAssignment, err := pd.getBytes() + if err != nil { + return err + } + + r.GroupAssignments[memberId] = memberAssignment + } + + return nil +} + +func (r *SyncGroupRequest) key() int16 { + return 14 +} + +func (r *SyncGroupRequest) version() int16 { + return 0 +} + +func (r *SyncGroupRequest) requiredVersion() KafkaVersion { + return V0_9_0_0 +} + +func (r *SyncGroupRequest) AddGroupAssignment(memberId string, memberAssignment []byte) { + if r.GroupAssignments == nil { + r.GroupAssignments = make(map[string][]byte) + } + + r.GroupAssignments[memberId] = memberAssignment +} + +func (r *SyncGroupRequest) AddGroupAssignmentMember(memberId string, memberAssignment *ConsumerGroupMemberAssignment) error { + bin, err := encode(memberAssignment, nil) + if err != nil { + return err + } + + r.AddGroupAssignment(memberId, bin) + return nil +} diff --git a/vendor/github.com/Shopify/sarama/sync_group_response.go b/vendor/github.com/Shopify/sarama/sync_group_response.go new file mode 100644 index 00000000..194b382b --- /dev/null +++ b/vendor/github.com/Shopify/sarama/sync_group_response.go @@ -0,0 +1,41 @@ +package sarama + +type SyncGroupResponse struct { + Err KError + MemberAssignment []byte +} + +func (r *SyncGroupResponse) GetMemberAssignment() (*ConsumerGroupMemberAssignment, error) { + assignment := new(ConsumerGroupMemberAssignment) + err := decode(r.MemberAssignment, assignment) + return assignment, err +} + +func (r *SyncGroupResponse) encode(pe packetEncoder) error { + pe.putInt16(int16(r.Err)) + return pe.putBytes(r.MemberAssignment) +} + +func (r *SyncGroupResponse) decode(pd packetDecoder, version int16) (err error) { + kerr, err := pd.getInt16() + if err != nil { + return err + } + + r.Err = KError(kerr) + + r.MemberAssignment, err = pd.getBytes() + return +} + +func (r *SyncGroupResponse) key() int16 { + return 14 +} + +func (r *SyncGroupResponse) version() int16 { + return 0 +} + +func (r *SyncGroupResponse) requiredVersion() KafkaVersion { + return V0_9_0_0 +} diff --git a/vendor/github.com/Shopify/sarama/sync_producer.go b/vendor/github.com/Shopify/sarama/sync_producer.go new file mode 100644 index 00000000..c77ae314 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/sync_producer.go @@ -0,0 +1,164 @@ +package sarama + +import "sync" + +// SyncProducer publishes Kafka messages, blocking until they have been acknowledged. It routes messages to the correct +// broker, refreshing metadata as appropriate, and parses responses for errors. You must call Close() on a producer +// to avoid leaks, it may not be garbage-collected automatically when it passes out of scope. +// +// The SyncProducer comes with two caveats: it will generally be less efficient than the AsyncProducer, and the actual +// durability guarantee provided when a message is acknowledged depend on the configured value of `Producer.RequiredAcks`. +// There are configurations where a message acknowledged by the SyncProducer can still sometimes be lost. +// +// For implementation reasons, the SyncProducer requires `Producer.Return.Errors` and `Producer.Return.Successes` to +// be set to true in its configuration. +type SyncProducer interface { + + // SendMessage produces a given message, and returns only when it either has + // succeeded or failed to produce. It will return the partition and the offset + // of the produced message, or an error if the message failed to produce. + SendMessage(msg *ProducerMessage) (partition int32, offset int64, err error) + + // SendMessages produces a given set of messages, and returns only when all + // messages in the set have either succeeded or failed. Note that messages + // can succeed and fail individually; if some succeed and some fail, + // SendMessages will return an error. + SendMessages(msgs []*ProducerMessage) error + + // Close shuts down the producer and flushes any messages it may have buffered. + // You must call this function before a producer object passes out of scope, as + // it may otherwise leak memory. You must call this before calling Close on the + // underlying client. + Close() error +} + +type syncProducer struct { + producer *asyncProducer + wg sync.WaitGroup +} + +// NewSyncProducer creates a new SyncProducer using the given broker addresses and configuration. +func NewSyncProducer(addrs []string, config *Config) (SyncProducer, error) { + if config == nil { + config = NewConfig() + config.Producer.Return.Successes = true + } + + if err := verifyProducerConfig(config); err != nil { + return nil, err + } + + p, err := NewAsyncProducer(addrs, config) + if err != nil { + return nil, err + } + return newSyncProducerFromAsyncProducer(p.(*asyncProducer)), nil +} + +// NewSyncProducerFromClient creates a new SyncProducer using the given client. It is still +// necessary to call Close() on the underlying client when shutting down this producer. +func NewSyncProducerFromClient(client Client) (SyncProducer, error) { + if err := verifyProducerConfig(client.Config()); err != nil { + return nil, err + } + + p, err := NewAsyncProducerFromClient(client) + if err != nil { + return nil, err + } + return newSyncProducerFromAsyncProducer(p.(*asyncProducer)), nil +} + +func newSyncProducerFromAsyncProducer(p *asyncProducer) *syncProducer { + sp := &syncProducer{producer: p} + + sp.wg.Add(2) + go withRecover(sp.handleSuccesses) + go withRecover(sp.handleErrors) + + return sp +} + +func verifyProducerConfig(config *Config) error { + if !config.Producer.Return.Errors { + return ConfigurationError("Producer.Return.Errors must be true to be used in a SyncProducer") + } + if !config.Producer.Return.Successes { + return ConfigurationError("Producer.Return.Successes must be true to be used in a SyncProducer") + } + return nil +} + +func (sp *syncProducer) SendMessage(msg *ProducerMessage) (partition int32, offset int64, err error) { + oldMetadata := msg.Metadata + defer func() { + msg.Metadata = oldMetadata + }() + + expectation := make(chan *ProducerError, 1) + msg.Metadata = expectation + sp.producer.Input() <- msg + + if err := <-expectation; err != nil { + return -1, -1, err.Err + } + + return msg.Partition, msg.Offset, nil +} + +func (sp *syncProducer) SendMessages(msgs []*ProducerMessage) error { + savedMetadata := make([]interface{}, len(msgs)) + for i := range msgs { + savedMetadata[i] = msgs[i].Metadata + } + defer func() { + for i := range msgs { + msgs[i].Metadata = savedMetadata[i] + } + }() + + expectations := make(chan chan *ProducerError, len(msgs)) + go func() { + for _, msg := range msgs { + expectation := make(chan *ProducerError, 1) + msg.Metadata = expectation + sp.producer.Input() <- msg + expectations <- expectation + } + close(expectations) + }() + + var errors ProducerErrors + for expectation := range expectations { + if err := <-expectation; err != nil { + errors = append(errors, err) + } + } + + if len(errors) > 0 { + return errors + } + return nil +} + +func (sp *syncProducer) handleSuccesses() { + defer sp.wg.Done() + for msg := range sp.producer.Successes() { + expectation := msg.Metadata.(chan *ProducerError) + expectation <- nil + } +} + +func (sp *syncProducer) handleErrors() { + defer sp.wg.Done() + for err := range sp.producer.Errors() { + expectation := err.Msg.Metadata.(chan *ProducerError) + expectation <- err + } +} + +func (sp *syncProducer) Close() error { + sp.producer.AsyncClose() + sp.wg.Wait() + return nil +} diff --git a/vendor/github.com/Shopify/sarama/utils.go b/vendor/github.com/Shopify/sarama/utils.go new file mode 100644 index 00000000..3cbab2d9 --- /dev/null +++ b/vendor/github.com/Shopify/sarama/utils.go @@ -0,0 +1,152 @@ +package sarama + +import ( + "bufio" + "net" + "sort" +) + +type none struct{} + +// make []int32 sortable so we can sort partition numbers +type int32Slice []int32 + +func (slice int32Slice) Len() int { + return len(slice) +} + +func (slice int32Slice) Less(i, j int) bool { + return slice[i] < slice[j] +} + +func (slice int32Slice) Swap(i, j int) { + slice[i], slice[j] = slice[j], slice[i] +} + +func dupeAndSort(input []int32) []int32 { + ret := make([]int32, 0, len(input)) + for _, val := range input { + ret = append(ret, val) + } + + sort.Sort(int32Slice(ret)) + return ret +} + +func withRecover(fn func()) { + defer func() { + handler := PanicHandler + if handler != nil { + if err := recover(); err != nil { + handler(err) + } + } + }() + + fn() +} + +func safeAsyncClose(b *Broker) { + tmp := b // local var prevents clobbering in goroutine + go withRecover(func() { + if connected, _ := tmp.Connected(); connected { + if err := tmp.Close(); err != nil { + Logger.Println("Error closing broker", tmp.ID(), ":", err) + } + } + }) +} + +// Encoder is a simple interface for any type that can be encoded as an array of bytes +// in order to be sent as the key or value of a Kafka message. Length() is provided as an +// optimization, and must return the same as len() on the result of Encode(). +type Encoder interface { + Encode() ([]byte, error) + Length() int +} + +// make strings and byte slices encodable for convenience so they can be used as keys +// and/or values in kafka messages + +// StringEncoder implements the Encoder interface for Go strings so that they can be used +// as the Key or Value in a ProducerMessage. +type StringEncoder string + +func (s StringEncoder) Encode() ([]byte, error) { + return []byte(s), nil +} + +func (s StringEncoder) Length() int { + return len(s) +} + +// ByteEncoder implements the Encoder interface for Go byte slices so that they can be used +// as the Key or Value in a ProducerMessage. +type ByteEncoder []byte + +func (b ByteEncoder) Encode() ([]byte, error) { + return b, nil +} + +func (b ByteEncoder) Length() int { + return len(b) +} + +// bufConn wraps a net.Conn with a buffer for reads to reduce the number of +// reads that trigger syscalls. +type bufConn struct { + net.Conn + buf *bufio.Reader +} + +func newBufConn(conn net.Conn) *bufConn { + return &bufConn{ + Conn: conn, + buf: bufio.NewReader(conn), + } +} + +func (bc *bufConn) Read(b []byte) (n int, err error) { + return bc.buf.Read(b) +} + +// KafkaVersion instances represent versions of the upstream Kafka broker. +type KafkaVersion struct { + // it's a struct rather than just typing the array directly to make it opaque and stop people + // generating their own arbitrary versions + version [4]uint +} + +func newKafkaVersion(major, minor, veryMinor, patch uint) KafkaVersion { + return KafkaVersion{ + version: [4]uint{major, minor, veryMinor, patch}, + } +} + +// IsAtLeast return true if and only if the version it is called on is +// greater than or equal to the version passed in: +// V1.IsAtLeast(V2) // false +// V2.IsAtLeast(V1) // true +func (v KafkaVersion) IsAtLeast(other KafkaVersion) bool { + for i := range v.version { + if v.version[i] > other.version[i] { + return true + } else if v.version[i] < other.version[i] { + return false + } + } + return true +} + +// Effective constants defining the supported kafka versions. +var ( + V0_8_2_0 = newKafkaVersion(0, 8, 2, 0) + V0_8_2_1 = newKafkaVersion(0, 8, 2, 1) + V0_8_2_2 = newKafkaVersion(0, 8, 2, 2) + V0_9_0_0 = newKafkaVersion(0, 9, 0, 0) + V0_9_0_1 = newKafkaVersion(0, 9, 0, 1) + V0_10_0_0 = newKafkaVersion(0, 10, 0, 0) + V0_10_0_1 = newKafkaVersion(0, 10, 0, 1) + V0_10_1_0 = newKafkaVersion(0, 10, 1, 0) + minVersion = V0_8_2_0 +) diff --git a/vendor/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/davecgh/go-spew/LICENSE new file mode 100644 index 00000000..2a7cfd2b --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/LICENSE @@ -0,0 +1,13 @@ +Copyright (c) 2012-2013 Dave Collins + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go new file mode 100644 index 00000000..a8d27a3f --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/bypass.go @@ -0,0 +1,136 @@ +// Copyright (c) 2015 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when the code is not running on Google App Engine and "-tags disableunsafe" +// is not added to the go build command line. +// +build !appengine,!disableunsafe + +package spew + +import ( + "reflect" + "unsafe" +) + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = false + + // ptrSize is the size of a pointer on the current arch. + ptrSize = unsafe.Sizeof((*byte)(nil)) +) + +var ( + // offsetPtr, offsetScalar, and offsetFlag are the offsets for the + // internal reflect.Value fields. These values are valid before golang + // commit ecccf07e7f9d which changed the format. The are also valid + // after commit 82f48826c6c7 which changed the format again to mirror + // the original format. Code in the init function updates these offsets + // as necessary. + offsetPtr = uintptr(ptrSize) + offsetScalar = uintptr(0) + offsetFlag = uintptr(ptrSize * 2) + + // flagKindWidth and flagKindShift indicate various bits that the + // reflect package uses internally to track kind information. + // + // flagRO indicates whether or not the value field of a reflect.Value is + // read-only. + // + // flagIndir indicates whether the value field of a reflect.Value is + // the actual data or a pointer to the data. + // + // These values are valid before golang commit 90a7c3c86944 which + // changed their positions. Code in the init function updates these + // flags as necessary. + flagKindWidth = uintptr(5) + flagKindShift = uintptr(flagKindWidth - 1) + flagRO = uintptr(1 << 0) + flagIndir = uintptr(1 << 1) +) + +func init() { + // Older versions of reflect.Value stored small integers directly in the + // ptr field (which is named val in the older versions). Versions + // between commits ecccf07e7f9d and 82f48826c6c7 added a new field named + // scalar for this purpose which unfortunately came before the flag + // field, so the offset of the flag field is different for those + // versions. + // + // This code constructs a new reflect.Value from a known small integer + // and checks if the size of the reflect.Value struct indicates it has + // the scalar field. When it does, the offsets are updated accordingly. + vv := reflect.ValueOf(0xf00) + if unsafe.Sizeof(vv) == (ptrSize * 4) { + offsetScalar = ptrSize * 2 + offsetFlag = ptrSize * 3 + } + + // Commit 90a7c3c86944 changed the flag positions such that the low + // order bits are the kind. This code extracts the kind from the flags + // field and ensures it's the correct type. When it's not, the flag + // order has been changed to the newer format, so the flags are updated + // accordingly. + upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag) + upfv := *(*uintptr)(upf) + flagKindMask := uintptr((1<>flagKindShift != uintptr(reflect.Int) { + flagKindShift = 0 + flagRO = 1 << 5 + flagIndir = 1 << 6 + } +} + +// unsafeReflectValue converts the passed reflect.Value into a one that bypasses +// the typical safety restrictions preventing access to unaddressable and +// unexported data. It works by digging the raw pointer to the underlying +// value out of the protected value and generating a new unprotected (unsafe) +// reflect.Value to it. +// +// This allows us to check for implementations of the Stringer and error +// interfaces to be used for pretty printing ordinarily unaddressable and +// inaccessible values such as unexported struct fields. +func unsafeReflectValue(v reflect.Value) (rv reflect.Value) { + indirects := 1 + vt := v.Type() + upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr) + rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag)) + if rvf&flagIndir != 0 { + vt = reflect.PtrTo(v.Type()) + indirects++ + } else if offsetScalar != 0 { + // The value is in the scalar field when it's not one of the + // reference types. + switch vt.Kind() { + case reflect.Uintptr: + case reflect.Chan: + case reflect.Func: + case reflect.Map: + case reflect.Ptr: + case reflect.UnsafePointer: + default: + upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + + offsetScalar) + } + } + + pv := reflect.NewAt(vt, upv) + rv = pv + for i := 0; i < indirects; i++ { + rv = rv.Elem() + } + return rv +} diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go new file mode 100644 index 00000000..457e4123 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go @@ -0,0 +1,37 @@ +// Copyright (c) 2015 Dave Collins +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +// NOTE: Due to the following build constraints, this file will only be compiled +// when either the code is running on Google App Engine or "-tags disableunsafe" +// is added to the go build command line. +// +build appengine disableunsafe + +package spew + +import "reflect" + +const ( + // UnsafeDisabled is a build-time constant which specifies whether or + // not access to the unsafe package is available. + UnsafeDisabled = true +) + +// unsafeReflectValue typically converts the passed reflect.Value into a one +// that bypasses the typical safety restrictions preventing access to +// unaddressable and unexported data. However, doing this relies on access to +// the unsafe package. This is a stub version which simply returns the passed +// reflect.Value when the unsafe package is not available. +func unsafeReflectValue(v reflect.Value) reflect.Value { + return v +} diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go new file mode 100644 index 00000000..14f02dc1 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/common.go @@ -0,0 +1,341 @@ +/* + * Copyright (c) 2013 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "reflect" + "sort" + "strconv" +) + +// Some constants in the form of bytes to avoid string overhead. This mirrors +// the technique used in the fmt package. +var ( + panicBytes = []byte("(PANIC=") + plusBytes = []byte("+") + iBytes = []byte("i") + trueBytes = []byte("true") + falseBytes = []byte("false") + interfaceBytes = []byte("(interface {})") + commaNewlineBytes = []byte(",\n") + newlineBytes = []byte("\n") + openBraceBytes = []byte("{") + openBraceNewlineBytes = []byte("{\n") + closeBraceBytes = []byte("}") + asteriskBytes = []byte("*") + colonBytes = []byte(":") + colonSpaceBytes = []byte(": ") + openParenBytes = []byte("(") + closeParenBytes = []byte(")") + spaceBytes = []byte(" ") + pointerChainBytes = []byte("->") + nilAngleBytes = []byte("") + maxNewlineBytes = []byte("\n") + maxShortBytes = []byte("") + circularBytes = []byte("") + circularShortBytes = []byte("") + invalidAngleBytes = []byte("") + openBracketBytes = []byte("[") + closeBracketBytes = []byte("]") + percentBytes = []byte("%") + precisionBytes = []byte(".") + openAngleBytes = []byte("<") + closeAngleBytes = []byte(">") + openMapBytes = []byte("map[") + closeMapBytes = []byte("]") + lenEqualsBytes = []byte("len=") + capEqualsBytes = []byte("cap=") +) + +// hexDigits is used to map a decimal value to a hex digit. +var hexDigits = "0123456789abcdef" + +// catchPanic handles any panics that might occur during the handleMethods +// calls. +func catchPanic(w io.Writer, v reflect.Value) { + if err := recover(); err != nil { + w.Write(panicBytes) + fmt.Fprintf(w, "%v", err) + w.Write(closeParenBytes) + } +} + +// handleMethods attempts to call the Error and String methods on the underlying +// type the passed reflect.Value represents and outputes the result to Writer w. +// +// It handles panics in any called methods by catching and displaying the error +// as the formatted value. +func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) { + // We need an interface to check if the type implements the error or + // Stringer interface. However, the reflect package won't give us an + // interface on certain things like unexported struct fields in order + // to enforce visibility rules. We use unsafe, when it's available, + // to bypass these restrictions since this package does not mutate the + // values. + if !v.CanInterface() { + if UnsafeDisabled { + return false + } + + v = unsafeReflectValue(v) + } + + // Choose whether or not to do error and Stringer interface lookups against + // the base type or a pointer to the base type depending on settings. + // Technically calling one of these methods with a pointer receiver can + // mutate the value, however, types which choose to satisify an error or + // Stringer interface with a pointer receiver should not be mutating their + // state inside these interface methods. + if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() { + v = unsafeReflectValue(v) + } + if v.CanAddr() { + v = v.Addr() + } + + // Is it an error or Stringer? + switch iface := v.Interface().(type) { + case error: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.Error())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + + w.Write([]byte(iface.Error())) + return true + + case fmt.Stringer: + defer catchPanic(w, v) + if cs.ContinueOnMethod { + w.Write(openParenBytes) + w.Write([]byte(iface.String())) + w.Write(closeParenBytes) + w.Write(spaceBytes) + return false + } + w.Write([]byte(iface.String())) + return true + } + return false +} + +// printBool outputs a boolean value as true or false to Writer w. +func printBool(w io.Writer, val bool) { + if val { + w.Write(trueBytes) + } else { + w.Write(falseBytes) + } +} + +// printInt outputs a signed integer value to Writer w. +func printInt(w io.Writer, val int64, base int) { + w.Write([]byte(strconv.FormatInt(val, base))) +} + +// printUint outputs an unsigned integer value to Writer w. +func printUint(w io.Writer, val uint64, base int) { + w.Write([]byte(strconv.FormatUint(val, base))) +} + +// printFloat outputs a floating point value using the specified precision, +// which is expected to be 32 or 64bit, to Writer w. +func printFloat(w io.Writer, val float64, precision int) { + w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision))) +} + +// printComplex outputs a complex value using the specified float precision +// for the real and imaginary parts to Writer w. +func printComplex(w io.Writer, c complex128, floatPrecision int) { + r := real(c) + w.Write(openParenBytes) + w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision))) + i := imag(c) + if i >= 0 { + w.Write(plusBytes) + } + w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision))) + w.Write(iBytes) + w.Write(closeParenBytes) +} + +// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x' +// prefix to Writer w. +func printHexPtr(w io.Writer, p uintptr) { + // Null pointer. + num := uint64(p) + if num == 0 { + w.Write(nilAngleBytes) + return + } + + // Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix + buf := make([]byte, 18) + + // It's simpler to construct the hex string right to left. + base := uint64(16) + i := len(buf) - 1 + for num >= base { + buf[i] = hexDigits[num%base] + num /= base + i-- + } + buf[i] = hexDigits[num] + + // Add '0x' prefix. + i-- + buf[i] = 'x' + i-- + buf[i] = '0' + + // Strip unused leading bytes. + buf = buf[i:] + w.Write(buf) +} + +// valuesSorter implements sort.Interface to allow a slice of reflect.Value +// elements to be sorted. +type valuesSorter struct { + values []reflect.Value + strings []string // either nil or same len and values + cs *ConfigState +} + +// newValuesSorter initializes a valuesSorter instance, which holds a set of +// surrogate keys on which the data should be sorted. It uses flags in +// ConfigState to decide if and how to populate those surrogate keys. +func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface { + vs := &valuesSorter{values: values, cs: cs} + if canSortSimply(vs.values[0].Kind()) { + return vs + } + if !cs.DisableMethods { + vs.strings = make([]string, len(values)) + for i := range vs.values { + b := bytes.Buffer{} + if !handleMethods(cs, &b, vs.values[i]) { + vs.strings = nil + break + } + vs.strings[i] = b.String() + } + } + if vs.strings == nil && cs.SpewKeys { + vs.strings = make([]string, len(values)) + for i := range vs.values { + vs.strings[i] = Sprintf("%#v", vs.values[i].Interface()) + } + } + return vs +} + +// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted +// directly, or whether it should be considered for sorting by surrogate keys +// (if the ConfigState allows it). +func canSortSimply(kind reflect.Kind) bool { + // This switch parallels valueSortLess, except for the default case. + switch kind { + case reflect.Bool: + return true + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return true + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return true + case reflect.Float32, reflect.Float64: + return true + case reflect.String: + return true + case reflect.Uintptr: + return true + case reflect.Array: + return true + } + return false +} + +// Len returns the number of values in the slice. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Len() int { + return len(s.values) +} + +// Swap swaps the values at the passed indices. It is part of the +// sort.Interface implementation. +func (s *valuesSorter) Swap(i, j int) { + s.values[i], s.values[j] = s.values[j], s.values[i] + if s.strings != nil { + s.strings[i], s.strings[j] = s.strings[j], s.strings[i] + } +} + +// valueSortLess returns whether the first value should sort before the second +// value. It is used by valueSorter.Less as part of the sort.Interface +// implementation. +func valueSortLess(a, b reflect.Value) bool { + switch a.Kind() { + case reflect.Bool: + return !a.Bool() && b.Bool() + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + return a.Int() < b.Int() + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + return a.Uint() < b.Uint() + case reflect.Float32, reflect.Float64: + return a.Float() < b.Float() + case reflect.String: + return a.String() < b.String() + case reflect.Uintptr: + return a.Uint() < b.Uint() + case reflect.Array: + // Compare the contents of both arrays. + l := a.Len() + for i := 0; i < l; i++ { + av := a.Index(i) + bv := b.Index(i) + if av.Interface() == bv.Interface() { + continue + } + return valueSortLess(av, bv) + } + } + return a.String() < b.String() +} + +// Less returns whether the value at index i should sort before the +// value at index j. It is part of the sort.Interface implementation. +func (s *valuesSorter) Less(i, j int) bool { + if s.strings == nil { + return valueSortLess(s.values[i], s.values[j]) + } + return s.strings[i] < s.strings[j] +} + +// sortValues is a sort function that handles both native types and any type that +// can be converted to error or Stringer. Other inputs are sorted according to +// their Value.String() value to ensure display stability. +func sortValues(values []reflect.Value, cs *ConfigState) { + if len(values) == 0 { + return + } + sort.Sort(newValuesSorter(values, cs)) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go new file mode 100644 index 00000000..ee1ab07b --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/config.go @@ -0,0 +1,297 @@ +/* + * Copyright (c) 2013 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "io" + "os" +) + +// ConfigState houses the configuration options used by spew to format and +// display values. There is a global instance, Config, that is used to control +// all top-level Formatter and Dump functionality. Each ConfigState instance +// provides methods equivalent to the top-level functions. +// +// The zero value for ConfigState provides no indentation. You would typically +// want to set it to a space or a tab. +// +// Alternatively, you can use NewDefaultConfig to get a ConfigState instance +// with default settings. See the documentation of NewDefaultConfig for default +// values. +type ConfigState struct { + // Indent specifies the string to use for each indentation level. The + // global config instance that all top-level functions use set this to a + // single space by default. If you would like more indentation, you might + // set this to a tab with "\t" or perhaps two spaces with " ". + Indent string + + // MaxDepth controls the maximum number of levels to descend into nested + // data structures. The default, 0, means there is no limit. + // + // NOTE: Circular data structures are properly detected, so it is not + // necessary to set this value unless you specifically want to limit deeply + // nested data structures. + MaxDepth int + + // DisableMethods specifies whether or not error and Stringer interfaces are + // invoked for types that implement them. + DisableMethods bool + + // DisablePointerMethods specifies whether or not to check for and invoke + // error and Stringer interfaces on types which only accept a pointer + // receiver when the current type is not a pointer. + // + // NOTE: This might be an unsafe action since calling one of these methods + // with a pointer receiver could technically mutate the value, however, + // in practice, types which choose to satisify an error or Stringer + // interface with a pointer receiver should not be mutating their state + // inside these interface methods. As a result, this option relies on + // access to the unsafe package, so it will not have any effect when + // running in environments without access to the unsafe package such as + // Google App Engine or with the "disableunsafe" build tag specified. + DisablePointerMethods bool + + // ContinueOnMethod specifies whether or not recursion should continue once + // a custom error or Stringer interface is invoked. The default, false, + // means it will print the results of invoking the custom error or Stringer + // interface and return immediately instead of continuing to recurse into + // the internals of the data type. + // + // NOTE: This flag does not have any effect if method invocation is disabled + // via the DisableMethods or DisablePointerMethods options. + ContinueOnMethod bool + + // SortKeys specifies map keys should be sorted before being printed. Use + // this to have a more deterministic, diffable output. Note that only + // native types (bool, int, uint, floats, uintptr and string) and types + // that support the error or Stringer interfaces (if methods are + // enabled) are supported, with other types sorted according to the + // reflect.Value.String() output which guarantees display stability. + SortKeys bool + + // SpewKeys specifies that, as a last resort attempt, map keys should + // be spewed to strings and sorted by those strings. This is only + // considered if SortKeys is true. + SpewKeys bool +} + +// Config is the active configuration of the top-level functions. +// The configuration can be changed by modifying the contents of spew.Config. +var Config = ConfigState{Indent: " "} + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the formatted string as a value that satisfies error. See NewFormatter +// for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, c.convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, c.convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, c.convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a Formatter interface returned by c.NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, c.convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Print(a ...interface{}) (n int, err error) { + return fmt.Print(c.convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, c.convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Println(a ...interface{}) (n int, err error) { + return fmt.Println(c.convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprint(a ...interface{}) string { + return fmt.Sprint(c.convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a Formatter interface returned by c.NewFormatter. It returns +// the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, c.convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a Formatter interface returned by c.NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b)) +func (c *ConfigState) Sprintln(a ...interface{}) string { + return fmt.Sprintln(c.convertArgs(a)...) +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +c.Printf, c.Println, or c.Printf. +*/ +func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(c, v) +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) { + fdump(c, w, a...) +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by modifying the public members +of c. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func (c *ConfigState) Dump(a ...interface{}) { + fdump(c, os.Stdout, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func (c *ConfigState) Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(c, &buf, a...) + return buf.String() +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a spew Formatter interface using +// the ConfigState associated with s. +func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = newFormatter(c, arg) + } + return formatters +} + +// NewDefaultConfig returns a ConfigState with the following default settings. +// +// Indent: " " +// MaxDepth: 0 +// DisableMethods: false +// DisablePointerMethods: false +// ContinueOnMethod: false +// SortKeys: false +func NewDefaultConfig() *ConfigState { + return &ConfigState{Indent: " "} +} diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go new file mode 100644 index 00000000..5be0c406 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/doc.go @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2013 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* +Package spew implements a deep pretty printer for Go data structures to aid in +debugging. + +A quick overview of the additional features spew provides over the built-in +printing facilities for Go data types are as follows: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output (only when using + Dump style) + +There are two different approaches spew allows for dumping Go data structures: + + * Dump style which prints with newlines, customizable indentation, + and additional debug information such as types and all pointer addresses + used to indirect to the final value + * A custom Formatter interface that integrates cleanly with the standard fmt + package and replaces %v, %+v, %#v, and %#+v to provide inline printing + similar to the default %v while providing the additional functionality + outlined above and passing unsupported format verbs such as %x and %q + along to fmt + +Quick Start + +This section demonstrates how to quickly get started with spew. See the +sections below for further details on formatting and configuration options. + +To dump a variable with full newlines, indentation, type, and pointer +information use Dump, Fdump, or Sdump: + spew.Dump(myVar1, myVar2, ...) + spew.Fdump(someWriter, myVar1, myVar2, ...) + str := spew.Sdump(myVar1, myVar2, ...) + +Alternatively, if you would prefer to use format strings with a compacted inline +printing style, use the convenience wrappers Printf, Fprintf, etc with +%v (most compact), %+v (adds pointer addresses), %#v (adds types), or +%#+v (adds types and pointer addresses): + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +Configuration Options + +Configuration of spew is handled by fields in the ConfigState type. For +convenience, all of the top-level functions use a global state available +via the spew.Config global. + +It is also possible to create a ConfigState instance that provides methods +equivalent to the top-level functions. This allows concurrent configuration +options. See the ConfigState documentation for more details. + +The following configuration options are available: + * Indent + String to use for each indentation level for Dump functions. + It is a single space by default. A popular alternative is "\t". + + * MaxDepth + Maximum number of levels to descend into nested data structures. + There is no limit by default. + + * DisableMethods + Disables invocation of error and Stringer interface methods. + Method invocation is enabled by default. + + * DisablePointerMethods + Disables invocation of error and Stringer interface methods on types + which only accept pointer receivers from non-pointer variables. + Pointer method invocation is enabled by default. + + * ContinueOnMethod + Enables recursion into types after invoking error and Stringer interface + methods. Recursion after method invocation is disabled by default. + + * SortKeys + Specifies map keys should be sorted before being printed. Use + this to have a more deterministic, diffable output. Note that + only native types (bool, int, uint, floats, uintptr and string) + and types which implement error or Stringer interfaces are + supported with other types sorted according to the + reflect.Value.String() output which guarantees display + stability. Natural map order is used by default. + + * SpewKeys + Specifies that, as a last resort attempt, map keys should be + spewed to strings and sorted by those strings. This is only + considered if SortKeys is true. + +Dump Usage + +Simply call spew.Dump with a list of variables you want to dump: + + spew.Dump(myVar1, myVar2, ...) + +You may also call spew.Fdump if you would prefer to output to an arbitrary +io.Writer. For example, to dump to standard error: + + spew.Fdump(os.Stderr, myVar1, myVar2, ...) + +A third option is to call spew.Sdump to get the formatted output as a string: + + str := spew.Sdump(myVar1, myVar2, ...) + +Sample Dump Output + +See the Dump example for details on the setup of the types and variables being +shown here. + + (main.Foo) { + unexportedField: (*main.Bar)(0xf84002e210)({ + flag: (main.Flag) flagTwo, + data: (uintptr) + }), + ExportedField: (map[interface {}]interface {}) (len=1) { + (string) (len=3) "one": (bool) true + } + } + +Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C +command as shown. + ([]uint8) (len=32 cap=32) { + 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... | + 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0| + 00000020 31 32 |12| + } + +Custom Formatter + +Spew provides a custom formatter that implements the fmt.Formatter interface +so that it integrates cleanly with standard fmt package printing functions. The +formatter is useful for inline printing of smaller data types similar to the +standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Custom Formatter Usage + +The simplest way to make use of the spew custom formatter is to call one of the +convenience functions such as spew.Printf, spew.Println, or spew.Printf. The +functions have syntax you are most likely already familiar with: + + spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + spew.Println(myVar, myVar2) + spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) + spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) + +See the Index for the full list convenience functions. + +Sample Formatter Output + +Double pointer to a uint8: + %v: <**>5 + %+v: <**>(0xf8400420d0->0xf8400420c8)5 + %#v: (**uint8)5 + %#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5 + +Pointer to circular struct with a uint8 field and a pointer to itself: + %v: <*>{1 <*>} + %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)} + %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)} + %#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)} + +See the Printf example for details on the setup of variables being shown +here. + +Errors + +Since it is possible for custom Stringer/error interfaces to panic, spew +detects them and handles them internally by printing the panic information +inline with the output. Since spew is intended to provide deep pretty printing +capabilities on structures, it intentionally does not return any errors. +*/ +package spew diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go new file mode 100644 index 00000000..36a2b6cc --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/dump.go @@ -0,0 +1,511 @@ +/* + * Copyright (c) 2013 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "encoding/hex" + "fmt" + "io" + "os" + "reflect" + "regexp" + "strconv" + "strings" +) + +var ( + // uint8Type is a reflect.Type representing a uint8. It is used to + // convert cgo types to uint8 slices for hexdumping. + uint8Type = reflect.TypeOf(uint8(0)) + + // cCharRE is a regular expression that matches a cgo char. + // It is used to detect character arrays to hexdump them. + cCharRE = regexp.MustCompile("^.*\\._Ctype_char$") + + // cUnsignedCharRE is a regular expression that matches a cgo unsigned + // char. It is used to detect unsigned character arrays to hexdump + // them. + cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$") + + // cUint8tCharRE is a regular expression that matches a cgo uint8_t. + // It is used to detect uint8_t arrays to hexdump them. + cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$") +) + +// dumpState contains information about the state of a dump operation. +type dumpState struct { + w io.Writer + depth int + pointers map[uintptr]int + ignoreNextType bool + ignoreNextIndent bool + cs *ConfigState +} + +// indent performs indentation according to the depth level and cs.Indent +// option. +func (d *dumpState) indent() { + if d.ignoreNextIndent { + d.ignoreNextIndent = false + return + } + d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth)) +} + +// unpackValue returns values inside of non-nil interfaces when possible. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (d *dumpState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface && !v.IsNil() { + v = v.Elem() + } + return v +} + +// dumpPtr handles formatting of pointers by indirecting them as necessary. +func (d *dumpState) dumpPtr(v reflect.Value) { + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range d.pointers { + if depth >= d.depth { + delete(d.pointers, k) + } + } + + // Keep list of all dereferenced pointers to show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by dereferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := d.pointers[addr]; ok && pd < d.depth { + cycleFound = true + indirects-- + break + } + d.pointers[addr] = d.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type information. + d.w.Write(openParenBytes) + d.w.Write(bytes.Repeat(asteriskBytes, indirects)) + d.w.Write([]byte(ve.Type().String())) + d.w.Write(closeParenBytes) + + // Display pointer information. + if len(pointerChain) > 0 { + d.w.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + d.w.Write(pointerChainBytes) + } + printHexPtr(d.w, addr) + } + d.w.Write(closeParenBytes) + } + + // Display dereferenced value. + d.w.Write(openParenBytes) + switch { + case nilFound == true: + d.w.Write(nilAngleBytes) + + case cycleFound == true: + d.w.Write(circularBytes) + + default: + d.ignoreNextType = true + d.dump(ve) + } + d.w.Write(closeParenBytes) +} + +// dumpSlice handles formatting of arrays and slices. Byte (uint8 under +// reflection) arrays and slices are dumped in hexdump -C fashion. +func (d *dumpState) dumpSlice(v reflect.Value) { + // Determine whether this type should be hex dumped or not. Also, + // for types which should be hexdumped, try to use the underlying data + // first, then fall back to trying to convert them to a uint8 slice. + var buf []uint8 + doConvert := false + doHexDump := false + numEntries := v.Len() + if numEntries > 0 { + vt := v.Index(0).Type() + vts := vt.String() + switch { + // C types that need to be converted. + case cCharRE.MatchString(vts): + fallthrough + case cUnsignedCharRE.MatchString(vts): + fallthrough + case cUint8tCharRE.MatchString(vts): + doConvert = true + + // Try to use existing uint8 slices and fall back to converting + // and copying if that fails. + case vt.Kind() == reflect.Uint8: + // TODO(davec): Fix up the disableUnsafe bits... + + // We need an addressable interface to convert the type + // to a byte slice. However, the reflect package won't + // give us an interface on certain things like + // unexported struct fields in order to enforce + // visibility rules. We use unsafe, when available, to + // bypass these restrictions since this package does not + // mutate the values. + vs := v + if !vs.CanInterface() || !vs.CanAddr() { + vs = unsafeReflectValue(vs) + } + if !UnsafeDisabled { + vs = vs.Slice(0, numEntries) + + // Use the existing uint8 slice if it can be + // type asserted. + iface := vs.Interface() + if slice, ok := iface.([]uint8); ok { + buf = slice + doHexDump = true + break + } + } + + // The underlying data needs to be converted if it can't + // be type asserted to a uint8 slice. + doConvert = true + } + + // Copy and convert the underlying type if needed. + if doConvert && vt.ConvertibleTo(uint8Type) { + // Convert and copy each element into a uint8 byte + // slice. + buf = make([]uint8, numEntries) + for i := 0; i < numEntries; i++ { + vv := v.Index(i) + buf[i] = uint8(vv.Convert(uint8Type).Uint()) + } + doHexDump = true + } + } + + // Hexdump the entire slice as needed. + if doHexDump { + indent := strings.Repeat(d.cs.Indent, d.depth) + str := indent + hex.Dump(buf) + str = strings.Replace(str, "\n", "\n"+indent, -1) + str = strings.TrimRight(str, d.cs.Indent) + d.w.Write([]byte(str)) + return + } + + // Recursively call dump for each item. + for i := 0; i < numEntries; i++ { + d.dump(d.unpackValue(v.Index(i))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } +} + +// dump is the main workhorse for dumping a value. It uses the passed reflect +// value to figure out what kind of object we are dealing with and formats it +// appropriately. It is a recursive function, however circular data structures +// are detected and handled properly. +func (d *dumpState) dump(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + d.w.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + d.indent() + d.dumpPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !d.ignoreNextType { + d.indent() + d.w.Write(openParenBytes) + d.w.Write([]byte(v.Type().String())) + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + d.ignoreNextType = false + + // Display length and capacity if the built-in len and cap functions + // work with the value's kind and the len/cap itself is non-zero. + valueLen, valueCap := 0, 0 + switch v.Kind() { + case reflect.Array, reflect.Slice, reflect.Chan: + valueLen, valueCap = v.Len(), v.Cap() + case reflect.Map, reflect.String: + valueLen = v.Len() + } + if valueLen != 0 || valueCap != 0 { + d.w.Write(openParenBytes) + if valueLen != 0 { + d.w.Write(lenEqualsBytes) + printInt(d.w, int64(valueLen), 10) + } + if valueCap != 0 { + if valueLen != 0 { + d.w.Write(spaceBytes) + } + d.w.Write(capEqualsBytes) + printInt(d.w, int64(valueCap), 10) + } + d.w.Write(closeParenBytes) + d.w.Write(spaceBytes) + } + + // Call Stringer/error interfaces if they exist and the handle methods flag + // is enabled + if !d.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(d.cs, d.w, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(d.w, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(d.w, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(d.w, v.Uint(), 10) + + case reflect.Float32: + printFloat(d.w, v.Float(), 32) + + case reflect.Float64: + printFloat(d.w, v.Float(), 64) + + case reflect.Complex64: + printComplex(d.w, v.Complex(), 32) + + case reflect.Complex128: + printComplex(d.w, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + d.dumpSlice(v) + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.String: + d.w.Write([]byte(strconv.Quote(v.String()))) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + d.w.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + d.w.Write(nilAngleBytes) + break + } + + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + numEntries := v.Len() + keys := v.MapKeys() + if d.cs.SortKeys { + sortValues(keys, d.cs) + } + for i, key := range keys { + d.dump(d.unpackValue(key)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.MapIndex(key))) + if i < (numEntries - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Struct: + d.w.Write(openBraceNewlineBytes) + d.depth++ + if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { + d.indent() + d.w.Write(maxNewlineBytes) + } else { + vt := v.Type() + numFields := v.NumField() + for i := 0; i < numFields; i++ { + d.indent() + vtf := vt.Field(i) + d.w.Write([]byte(vtf.Name)) + d.w.Write(colonSpaceBytes) + d.ignoreNextIndent = true + d.dump(d.unpackValue(v.Field(i))) + if i < (numFields - 1) { + d.w.Write(commaNewlineBytes) + } else { + d.w.Write(newlineBytes) + } + } + } + d.depth-- + d.indent() + d.w.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(d.w, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(d.w, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it in case any new + // types are added. + default: + if v.CanInterface() { + fmt.Fprintf(d.w, "%v", v.Interface()) + } else { + fmt.Fprintf(d.w, "%v", v.String()) + } + } +} + +// fdump is a helper function to consolidate the logic from the various public +// methods which take varying writers and config states. +func fdump(cs *ConfigState, w io.Writer, a ...interface{}) { + for _, arg := range a { + if arg == nil { + w.Write(interfaceBytes) + w.Write(spaceBytes) + w.Write(nilAngleBytes) + w.Write(newlineBytes) + continue + } + + d := dumpState{w: w, cs: cs} + d.pointers = make(map[uintptr]int) + d.dump(reflect.ValueOf(arg)) + d.w.Write(newlineBytes) + } +} + +// Fdump formats and displays the passed arguments to io.Writer w. It formats +// exactly the same as Dump. +func Fdump(w io.Writer, a ...interface{}) { + fdump(&Config, w, a...) +} + +// Sdump returns a string with the passed arguments formatted exactly the same +// as Dump. +func Sdump(a ...interface{}) string { + var buf bytes.Buffer + fdump(&Config, &buf, a...) + return buf.String() +} + +/* +Dump displays the passed parameters to standard out with newlines, customizable +indentation, and additional debug information such as complete types and all +pointer addresses used to indirect to the final value. It provides the +following features over the built-in printing facilities provided by the fmt +package: + + * Pointers are dereferenced and followed + * Circular data structures are detected and handled properly + * Custom Stringer/error interfaces are optionally invoked, including + on unexported types + * Custom types which only implement the Stringer/error interfaces via + a pointer receiver are optionally invoked when passing non-pointer + variables + * Byte arrays and slices are dumped like the hexdump -C command which + includes offsets, byte values in hex, and ASCII output + +The configuration options are controlled by an exported package global, +spew.Config. See ConfigState for options documentation. + +See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to +get the formatted result as a string. +*/ +func Dump(a ...interface{}) { + fdump(&Config, os.Stdout, a...) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go new file mode 100644 index 00000000..ecf3b80e --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/format.go @@ -0,0 +1,419 @@ +/* + * Copyright (c) 2013 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "bytes" + "fmt" + "reflect" + "strconv" + "strings" +) + +// supportedFlags is a list of all the character flags supported by fmt package. +const supportedFlags = "0-+# " + +// formatState implements the fmt.Formatter interface and contains information +// about the state of a formatting operation. The NewFormatter function can +// be used to get a new Formatter which can be used directly as arguments +// in standard fmt package printing calls. +type formatState struct { + value interface{} + fs fmt.State + depth int + pointers map[uintptr]int + ignoreNextType bool + cs *ConfigState +} + +// buildDefaultFormat recreates the original format string without precision +// and width information to pass in to fmt.Sprintf in the case of an +// unrecognized type. Unless new types are added to the language, this +// function won't ever be called. +func (f *formatState) buildDefaultFormat() (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + buf.WriteRune('v') + + format = buf.String() + return format +} + +// constructOrigFormat recreates the original format string including precision +// and width information to pass along to the standard fmt package. This allows +// automatic deferral of all format strings this package doesn't support. +func (f *formatState) constructOrigFormat(verb rune) (format string) { + buf := bytes.NewBuffer(percentBytes) + + for _, flag := range supportedFlags { + if f.fs.Flag(int(flag)) { + buf.WriteRune(flag) + } + } + + if width, ok := f.fs.Width(); ok { + buf.WriteString(strconv.Itoa(width)) + } + + if precision, ok := f.fs.Precision(); ok { + buf.Write(precisionBytes) + buf.WriteString(strconv.Itoa(precision)) + } + + buf.WriteRune(verb) + + format = buf.String() + return format +} + +// unpackValue returns values inside of non-nil interfaces when possible and +// ensures that types for values which have been unpacked from an interface +// are displayed when the show types flag is also set. +// This is useful for data types like structs, arrays, slices, and maps which +// can contain varying types packed inside an interface. +func (f *formatState) unpackValue(v reflect.Value) reflect.Value { + if v.Kind() == reflect.Interface { + f.ignoreNextType = false + if !v.IsNil() { + v = v.Elem() + } + } + return v +} + +// formatPtr handles formatting of pointers by indirecting them as necessary. +func (f *formatState) formatPtr(v reflect.Value) { + // Display nil if top level pointer is nil. + showTypes := f.fs.Flag('#') + if v.IsNil() && (!showTypes || f.ignoreNextType) { + f.fs.Write(nilAngleBytes) + return + } + + // Remove pointers at or below the current depth from map used to detect + // circular refs. + for k, depth := range f.pointers { + if depth >= f.depth { + delete(f.pointers, k) + } + } + + // Keep list of all dereferenced pointers to possibly show later. + pointerChain := make([]uintptr, 0) + + // Figure out how many levels of indirection there are by derferencing + // pointers and unpacking interfaces down the chain while detecting circular + // references. + nilFound := false + cycleFound := false + indirects := 0 + ve := v + for ve.Kind() == reflect.Ptr { + if ve.IsNil() { + nilFound = true + break + } + indirects++ + addr := ve.Pointer() + pointerChain = append(pointerChain, addr) + if pd, ok := f.pointers[addr]; ok && pd < f.depth { + cycleFound = true + indirects-- + break + } + f.pointers[addr] = f.depth + + ve = ve.Elem() + if ve.Kind() == reflect.Interface { + if ve.IsNil() { + nilFound = true + break + } + ve = ve.Elem() + } + } + + // Display type or indirection level depending on flags. + if showTypes && !f.ignoreNextType { + f.fs.Write(openParenBytes) + f.fs.Write(bytes.Repeat(asteriskBytes, indirects)) + f.fs.Write([]byte(ve.Type().String())) + f.fs.Write(closeParenBytes) + } else { + if nilFound || cycleFound { + indirects += strings.Count(ve.Type().String(), "*") + } + f.fs.Write(openAngleBytes) + f.fs.Write([]byte(strings.Repeat("*", indirects))) + f.fs.Write(closeAngleBytes) + } + + // Display pointer information depending on flags. + if f.fs.Flag('+') && (len(pointerChain) > 0) { + f.fs.Write(openParenBytes) + for i, addr := range pointerChain { + if i > 0 { + f.fs.Write(pointerChainBytes) + } + printHexPtr(f.fs, addr) + } + f.fs.Write(closeParenBytes) + } + + // Display dereferenced value. + switch { + case nilFound == true: + f.fs.Write(nilAngleBytes) + + case cycleFound == true: + f.fs.Write(circularShortBytes) + + default: + f.ignoreNextType = true + f.format(ve) + } +} + +// format is the main workhorse for providing the Formatter interface. It +// uses the passed reflect value to figure out what kind of object we are +// dealing with and formats it appropriately. It is a recursive function, +// however circular data structures are detected and handled properly. +func (f *formatState) format(v reflect.Value) { + // Handle invalid reflect values immediately. + kind := v.Kind() + if kind == reflect.Invalid { + f.fs.Write(invalidAngleBytes) + return + } + + // Handle pointers specially. + if kind == reflect.Ptr { + f.formatPtr(v) + return + } + + // Print type information unless already handled elsewhere. + if !f.ignoreNextType && f.fs.Flag('#') { + f.fs.Write(openParenBytes) + f.fs.Write([]byte(v.Type().String())) + f.fs.Write(closeParenBytes) + } + f.ignoreNextType = false + + // Call Stringer/error interfaces if they exist and the handle methods + // flag is enabled. + if !f.cs.DisableMethods { + if (kind != reflect.Invalid) && (kind != reflect.Interface) { + if handled := handleMethods(f.cs, f.fs, v); handled { + return + } + } + } + + switch kind { + case reflect.Invalid: + // Do nothing. We should never get here since invalid has already + // been handled above. + + case reflect.Bool: + printBool(f.fs, v.Bool()) + + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: + printInt(f.fs, v.Int(), 10) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: + printUint(f.fs, v.Uint(), 10) + + case reflect.Float32: + printFloat(f.fs, v.Float(), 32) + + case reflect.Float64: + printFloat(f.fs, v.Float(), 64) + + case reflect.Complex64: + printComplex(f.fs, v.Complex(), 32) + + case reflect.Complex128: + printComplex(f.fs, v.Complex(), 64) + + case reflect.Slice: + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + fallthrough + + case reflect.Array: + f.fs.Write(openBracketBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + numEntries := v.Len() + for i := 0; i < numEntries; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(v.Index(i))) + } + } + f.depth-- + f.fs.Write(closeBracketBytes) + + case reflect.String: + f.fs.Write([]byte(v.String())) + + case reflect.Interface: + // The only time we should get here is for nil interfaces due to + // unpackValue calls. + if v.IsNil() { + f.fs.Write(nilAngleBytes) + } + + case reflect.Ptr: + // Do nothing. We should never get here since pointers have already + // been handled above. + + case reflect.Map: + // nil maps should be indicated as different than empty maps + if v.IsNil() { + f.fs.Write(nilAngleBytes) + break + } + + f.fs.Write(openMapBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + keys := v.MapKeys() + if f.cs.SortKeys { + sortValues(keys, f.cs) + } + for i, key := range keys { + if i > 0 { + f.fs.Write(spaceBytes) + } + f.ignoreNextType = true + f.format(f.unpackValue(key)) + f.fs.Write(colonBytes) + f.ignoreNextType = true + f.format(f.unpackValue(v.MapIndex(key))) + } + } + f.depth-- + f.fs.Write(closeMapBytes) + + case reflect.Struct: + numFields := v.NumField() + f.fs.Write(openBraceBytes) + f.depth++ + if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { + f.fs.Write(maxShortBytes) + } else { + vt := v.Type() + for i := 0; i < numFields; i++ { + if i > 0 { + f.fs.Write(spaceBytes) + } + vtf := vt.Field(i) + if f.fs.Flag('+') || f.fs.Flag('#') { + f.fs.Write([]byte(vtf.Name)) + f.fs.Write(colonBytes) + } + f.format(f.unpackValue(v.Field(i))) + } + } + f.depth-- + f.fs.Write(closeBraceBytes) + + case reflect.Uintptr: + printHexPtr(f.fs, uintptr(v.Uint())) + + case reflect.UnsafePointer, reflect.Chan, reflect.Func: + printHexPtr(f.fs, v.Pointer()) + + // There were not any other types at the time this code was written, but + // fall back to letting the default fmt package handle it if any get added. + default: + format := f.buildDefaultFormat() + if v.CanInterface() { + fmt.Fprintf(f.fs, format, v.Interface()) + } else { + fmt.Fprintf(f.fs, format, v.String()) + } + } +} + +// Format satisfies the fmt.Formatter interface. See NewFormatter for usage +// details. +func (f *formatState) Format(fs fmt.State, verb rune) { + f.fs = fs + + // Use standard formatting for verbs that are not v. + if verb != 'v' { + format := f.constructOrigFormat(verb) + fmt.Fprintf(fs, format, f.value) + return + } + + if f.value == nil { + if fs.Flag('#') { + fs.Write(interfaceBytes) + } + fs.Write(nilAngleBytes) + return + } + + f.format(reflect.ValueOf(f.value)) +} + +// newFormatter is a helper function to consolidate the logic from the various +// public methods which take varying config states. +func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter { + fs := &formatState{value: v, cs: cs} + fs.pointers = make(map[uintptr]int) + return fs +} + +/* +NewFormatter returns a custom formatter that satisfies the fmt.Formatter +interface. As a result, it integrates cleanly with standard fmt package +printing functions. The formatter is useful for inline printing of smaller data +types similar to the standard %v format specifier. + +The custom formatter only responds to the %v (most compact), %+v (adds pointer +addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb +combinations. Any other verbs such as %x and %q will be sent to the the +standard fmt package for formatting. In addition, the custom formatter ignores +the width and precision arguments (however they will still work on the format +specifiers not handled by the custom formatter). + +Typically this function shouldn't be called directly. It is much easier to make +use of the custom formatter by calling one of the convenience functions such as +Printf, Println, or Fprintf. +*/ +func NewFormatter(v interface{}) fmt.Formatter { + return newFormatter(&Config, v) +} diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go new file mode 100644 index 00000000..d8233f54 --- /dev/null +++ b/vendor/github.com/davecgh/go-spew/spew/spew.go @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2013 Dave Collins + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package spew + +import ( + "fmt" + "io" +) + +// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the formatted string as a value that satisfies error. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Errorf(format string, a ...interface{}) (err error) { + return fmt.Errorf(format, convertArgs(a)...) +} + +// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprint(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprint(w, convertArgs(a)...) +} + +// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { + return fmt.Fprintf(w, format, convertArgs(a)...) +} + +// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it +// passed with a default Formatter interface returned by NewFormatter. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b)) +func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { + return fmt.Fprintln(w, convertArgs(a)...) +} + +// Print is a wrapper for fmt.Print that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b)) +func Print(a ...interface{}) (n int, err error) { + return fmt.Print(convertArgs(a)...) +} + +// Printf is a wrapper for fmt.Printf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Printf(format string, a ...interface{}) (n int, err error) { + return fmt.Printf(format, convertArgs(a)...) +} + +// Println is a wrapper for fmt.Println that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the number of bytes written and any write error encountered. See +// NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b)) +func Println(a ...interface{}) (n int, err error) { + return fmt.Println(convertArgs(a)...) +} + +// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprint(a ...interface{}) string { + return fmt.Sprint(convertArgs(a)...) +} + +// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were +// passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintf(format string, a ...interface{}) string { + return fmt.Sprintf(format, convertArgs(a)...) +} + +// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it +// were passed with a default Formatter interface returned by NewFormatter. It +// returns the resulting string. See NewFormatter for formatting details. +// +// This function is shorthand for the following syntax: +// +// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b)) +func Sprintln(a ...interface{}) string { + return fmt.Sprintln(convertArgs(a)...) +} + +// convertArgs accepts a slice of arguments and returns a slice of the same +// length with each argument converted to a default spew Formatter interface. +func convertArgs(args []interface{}) (formatters []interface{}) { + formatters = make([]interface{}, len(args)) + for index, arg := range args { + formatters[index] = NewFormatter(arg) + } + return formatters +} diff --git a/vendor/github.com/eapache/go-resiliency/LICENSE b/vendor/github.com/eapache/go-resiliency/LICENSE new file mode 100644 index 00000000..698a3f51 --- /dev/null +++ b/vendor/github.com/eapache/go-resiliency/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2014 Evan Huus + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/vendor/github.com/eapache/go-resiliency/breaker/README.md b/vendor/github.com/eapache/go-resiliency/breaker/README.md new file mode 100644 index 00000000..2d1b3d93 --- /dev/null +++ b/vendor/github.com/eapache/go-resiliency/breaker/README.md @@ -0,0 +1,34 @@ +circuit-breaker +=============== + +[![Build Status](https://travis-ci.org/eapache/go-resiliency.svg?branch=master)](https://travis-ci.org/eapache/go-resiliency) +[![GoDoc](https://godoc.org/github.com/eapache/go-resiliency/breaker?status.svg)](https://godoc.org/github.com/eapache/go-resiliency/breaker) +[![Code of Conduct](https://img.shields.io/badge/code%20of%20conduct-active-blue.svg)](https://eapache.github.io/conduct.html) + +The circuit-breaker resiliency pattern for golang. + +Creating a breaker takes three parameters: +- error threshold (for opening the breaker) +- success threshold (for closing the breaker) +- timeout (how long to keep the breaker open) + +```go +b := breaker.New(3, 1, 5*time.Second) + +for { + result := b.Run(func() error { + // communicate with some external service and + // return an error if the communication failed + return nil + }) + + switch result { + case nil: + // success! + case breaker.ErrBreakerOpen: + // our function wasn't run because the breaker was open + default: + // some other error + } +} +``` diff --git a/vendor/github.com/eapache/go-resiliency/breaker/breaker.go b/vendor/github.com/eapache/go-resiliency/breaker/breaker.go new file mode 100644 index 00000000..f88ca724 --- /dev/null +++ b/vendor/github.com/eapache/go-resiliency/breaker/breaker.go @@ -0,0 +1,161 @@ +// Package breaker implements the circuit-breaker resiliency pattern for Go. +package breaker + +import ( + "errors" + "sync" + "sync/atomic" + "time" +) + +// ErrBreakerOpen is the error returned from Run() when the function is not executed +// because the breaker is currently open. +var ErrBreakerOpen = errors.New("circuit breaker is open") + +const ( + closed uint32 = iota + open + halfOpen +) + +// Breaker implements the circuit-breaker resiliency pattern +type Breaker struct { + errorThreshold, successThreshold int + timeout time.Duration + + lock sync.Mutex + state uint32 + errors, successes int + lastError time.Time +} + +// New constructs a new circuit-breaker that starts closed. +// From closed, the breaker opens if "errorThreshold" errors are seen +// without an error-free period of at least "timeout". From open, the +// breaker half-closes after "timeout". From half-open, the breaker closes +// after "successThreshold" consecutive successes, or opens on a single error. +func New(errorThreshold, successThreshold int, timeout time.Duration) *Breaker { + return &Breaker{ + errorThreshold: errorThreshold, + successThreshold: successThreshold, + timeout: timeout, + } +} + +// Run will either return ErrBreakerOpen immediately if the circuit-breaker is +// already open, or it will run the given function and pass along its return +// value. It is safe to call Run concurrently on the same Breaker. +func (b *Breaker) Run(work func() error) error { + state := atomic.LoadUint32(&b.state) + + if state == open { + return ErrBreakerOpen + } + + return b.doWork(state, work) +} + +// Go will either return ErrBreakerOpen immediately if the circuit-breaker is +// already open, or it will run the given function in a separate goroutine. +// If the function is run, Go will return nil immediately, and will *not* return +// the return value of the function. It is safe to call Go concurrently on the +// same Breaker. +func (b *Breaker) Go(work func() error) error { + state := atomic.LoadUint32(&b.state) + + if state == open { + return ErrBreakerOpen + } + + // errcheck complains about ignoring the error return value, but + // that's on purpose; if you want an error from a goroutine you have to + // get it over a channel or something + go b.doWork(state, work) + + return nil +} + +func (b *Breaker) doWork(state uint32, work func() error) error { + var panicValue interface{} + + result := func() error { + defer func() { + panicValue = recover() + }() + return work() + }() + + if result == nil && panicValue == nil && state == closed { + // short-circuit the normal, success path without contending + // on the lock + return nil + } + + // oh well, I guess we have to contend on the lock + b.processResult(result, panicValue) + + if panicValue != nil { + // as close as Go lets us come to a "rethrow" although unfortunately + // we lose the original panicing location + panic(panicValue) + } + + return result +} + +func (b *Breaker) processResult(result error, panicValue interface{}) { + b.lock.Lock() + defer b.lock.Unlock() + + if result == nil && panicValue == nil { + if b.state == halfOpen { + b.successes++ + if b.successes == b.successThreshold { + b.closeBreaker() + } + } + } else { + if b.errors > 0 { + expiry := b.lastError.Add(b.timeout) + if time.Now().After(expiry) { + b.errors = 0 + } + } + + switch b.state { + case closed: + b.errors++ + if b.errors == b.errorThreshold { + b.openBreaker() + } else { + b.lastError = time.Now() + } + case halfOpen: + b.openBreaker() + } + } +} + +func (b *Breaker) openBreaker() { + b.changeState(open) + go b.timer() +} + +func (b *Breaker) closeBreaker() { + b.changeState(closed) +} + +func (b *Breaker) timer() { + time.Sleep(b.timeout) + + b.lock.Lock() + defer b.lock.Unlock() + + b.changeState(halfOpen) +} + +func (b *Breaker) changeState(newState uint32) { + b.errors = 0 + b.successes = 0 + atomic.StoreUint32(&b.state, newState) +} diff --git a/vendor/github.com/eapache/go-xerial-snappy/LICENSE b/vendor/github.com/eapache/go-xerial-snappy/LICENSE new file mode 100644 index 00000000..5bf3688d --- /dev/null +++ b/vendor/github.com/eapache/go-xerial-snappy/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 Evan Huus + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendor/github.com/eapache/go-xerial-snappy/README.md b/vendor/github.com/eapache/go-xerial-snappy/README.md new file mode 100644 index 00000000..3f2695c7 --- /dev/null +++ b/vendor/github.com/eapache/go-xerial-snappy/README.md @@ -0,0 +1,13 @@ +# go-xerial-snappy + +[![Build Status](https://travis-ci.org/eapache/go-xerial-snappy.svg?branch=master)](https://travis-ci.org/eapache/go-xerial-snappy) + +Xerial-compatible Snappy framing support for golang. + +Packages using Xerial for snappy encoding use a framing format incompatible with +basically everything else in existence. This package wraps Go's built-in snappy +package to support it. + +Apps that use this format include Apache Kafka (see +https://github.com/dpkp/kafka-python/issues/126#issuecomment-35478921 for +details). diff --git a/vendor/github.com/eapache/go-xerial-snappy/snappy.go b/vendor/github.com/eapache/go-xerial-snappy/snappy.go new file mode 100644 index 00000000..b8f8b51f --- /dev/null +++ b/vendor/github.com/eapache/go-xerial-snappy/snappy.go @@ -0,0 +1,43 @@ +package snappy + +import ( + "bytes" + "encoding/binary" + + master "github.com/golang/snappy" +) + +var xerialHeader = []byte{130, 83, 78, 65, 80, 80, 89, 0} + +// Encode encodes data as snappy with no framing header. +func Encode(src []byte) []byte { + return master.Encode(nil, src) +} + +// Decode decodes snappy data whether it is traditional unframed +// or includes the xerial framing format. +func Decode(src []byte) ([]byte, error) { + if !bytes.Equal(src[:8], xerialHeader) { + return master.Decode(nil, src) + } + + var ( + pos = uint32(16) + max = uint32(len(src)) + dst = make([]byte, 0, len(src)) + chunk []byte + err error + ) + for pos < max { + size := binary.BigEndian.Uint32(src[pos : pos+4]) + pos += 4 + + chunk, err = master.Decode(chunk, src[pos:pos+size]) + if err != nil { + return nil, err + } + pos += size + dst = append(dst, chunk...) + } + return dst, nil +} diff --git a/vendor/github.com/eapache/queue/LICENSE b/vendor/github.com/eapache/queue/LICENSE new file mode 100644 index 00000000..d5f36dbc --- /dev/null +++ b/vendor/github.com/eapache/queue/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Evan Huus + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/vendor/github.com/eapache/queue/README.md b/vendor/github.com/eapache/queue/README.md new file mode 100644 index 00000000..8e782335 --- /dev/null +++ b/vendor/github.com/eapache/queue/README.md @@ -0,0 +1,16 @@ +Queue +===== + +[![Build Status](https://travis-ci.org/eapache/queue.svg)](https://travis-ci.org/eapache/queue) +[![GoDoc](https://godoc.org/github.com/eapache/queue?status.png)](https://godoc.org/github.com/eapache/queue) +[![Code of Conduct](https://img.shields.io/badge/code%20of%20conduct-active-blue.svg)](https://eapache.github.io/conduct.html) + +A fast Golang queue using a ring-buffer, based on the version suggested by Dariusz Górecki. +Using this instead of other, simpler, queue implementations (slice+append or linked list) provides +substantial memory and time benefits, and fewer GC pauses. + +The queue implemented here is as fast as it is in part because it is *not* thread-safe. + +Follows semantic versioning using https://gopkg.in/ - import from +[`gopkg.in/eapache/queue.v1`](https://gopkg.in/eapache/queue.v1) +for guaranteed API stability. diff --git a/vendor/github.com/eapache/queue/queue.go b/vendor/github.com/eapache/queue/queue.go new file mode 100644 index 00000000..2dc8d939 --- /dev/null +++ b/vendor/github.com/eapache/queue/queue.go @@ -0,0 +1,88 @@ +/* +Package queue provides a fast, ring-buffer queue based on the version suggested by Dariusz Górecki. +Using this instead of other, simpler, queue implementations (slice+append or linked list) provides +substantial memory and time benefits, and fewer GC pauses. + +The queue implemented here is as fast as it is for an additional reason: it is *not* thread-safe. +*/ +package queue + +const minQueueLen = 16 + +// Queue represents a single instance of the queue data structure. +type Queue struct { + buf []interface{} + head, tail, count int +} + +// New constructs and returns a new Queue. +func New() *Queue { + return &Queue{ + buf: make([]interface{}, minQueueLen), + } +} + +// Length returns the number of elements currently stored in the queue. +func (q *Queue) Length() int { + return q.count +} + +// resizes the queue to fit exactly twice its current contents +// this can result in shrinking if the queue is less than half-full +func (q *Queue) resize() { + newBuf := make([]interface{}, q.count*2) + + if q.tail > q.head { + copy(newBuf, q.buf[q.head:q.tail]) + } else { + n := copy(newBuf, q.buf[q.head:]) + copy(newBuf[n:], q.buf[:q.tail]) + } + + q.head = 0 + q.tail = q.count + q.buf = newBuf +} + +// Add puts an element on the end of the queue. +func (q *Queue) Add(elem interface{}) { + if q.count == len(q.buf) { + q.resize() + } + + q.buf[q.tail] = elem + q.tail = (q.tail + 1) % len(q.buf) + q.count++ +} + +// Peek returns the element at the head of the queue. This call panics +// if the queue is empty. +func (q *Queue) Peek() interface{} { + if q.count <= 0 { + panic("queue: Peek() called on empty queue") + } + return q.buf[q.head] +} + +// Get returns the element at index i in the queue. If the index is +// invalid, the call will panic. +func (q *Queue) Get(i int) interface{} { + if i < 0 || i >= q.count { + panic("queue: Get() called with index out of range") + } + return q.buf[(q.head+i)%len(q.buf)] +} + +// Remove removes the element from the front of the queue. If you actually +// want the element, call Peek first. This call panics if the queue is empty. +func (q *Queue) Remove() { + if q.count <= 0 { + panic("queue: Remove() called on empty queue") + } + q.buf[q.head] = nil + q.head = (q.head + 1) % len(q.buf) + q.count-- + if len(q.buf) > minQueueLen && q.count*4 == len(q.buf) { + q.resize() + } +} diff --git a/vendor/github.com/golang/snappy/encode_amd64.go b/vendor/github.com/golang/snappy/encode_amd64.go index 2a56fb50..150d91bc 100644 --- a/vendor/github.com/golang/snappy/encode_amd64.go +++ b/vendor/github.com/golang/snappy/encode_amd64.go @@ -26,4 +26,4 @@ func extendMatch(src []byte, i, j int) int // encodeBlock has the same semantics as in encode_other.go. // //go:noescape -func encodeBlock(dst, src []byte) (d int) \ No newline at end of file +func encodeBlock(dst, src []byte) (d int) diff --git a/vendor/github.com/klauspost/crc32/LICENSE b/vendor/github.com/klauspost/crc32/LICENSE new file mode 100644 index 00000000..4fd5963e --- /dev/null +++ b/vendor/github.com/klauspost/crc32/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2012 The Go Authors. All rights reserved. +Copyright (c) 2015 Klaus Post + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/klauspost/crc32/README.md b/vendor/github.com/klauspost/crc32/README.md new file mode 100644 index 00000000..440541c7 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/README.md @@ -0,0 +1,84 @@ +# crc32 +CRC32 hash with x64 optimizations + +This package is a drop-in replacement for the standard library `hash/crc32` package, that features SSE 4.2 optimizations on x64 platforms, for a 10x speedup. + +[![Build Status](https://travis-ci.org/klauspost/crc32.svg?branch=master)](https://travis-ci.org/klauspost/crc32) + +# usage + +Install using `go get github.com/klauspost/crc32`. This library is based on Go 1.5 code and requires Go 1.3 or newer. + +Replace `import "hash/crc32"` with `import "github.com/klauspost/crc32"` and you are good to go. + +# changes + +* Dec 4, 2015: Uses the "slice-by-8" trick more extensively, which gives a 1.5 to 2.5x speedup if assembler is unavailable. + + +# performance + +For IEEE tables (the most common), there is approximately a factor 10 speedup with "CLMUL" (Carryless multiplication) instruction: +``` +benchmark old ns/op new ns/op delta +BenchmarkCrc32KB 99955 10258 -89.74% + +benchmark old MB/s new MB/s speedup +BenchmarkCrc32KB 327.83 3194.20 9.74x +``` + +For other tables and "CLMUL" capable machines the performance is the same as the standard library. + +Here are some detailed benchmarks, comparing to go 1.5 standard library with and without assembler enabled. + +``` +Std: Standard Go 1.5 library +Crc: Indicates IEEE type CRC. +40B: Size of each slice encoded. +NoAsm: Assembler was disabled (ie. not an AMD64 or SSE 4.2+ capable machine). +Castagnoli: Castagnoli CRC type. + +BenchmarkStdCrc40B-4 10000000 158 ns/op 252.88 MB/s +BenchmarkCrc40BNoAsm-4 20000000 105 ns/op 377.38 MB/s (slice8) +BenchmarkCrc40B-4 20000000 105 ns/op 378.77 MB/s (slice8) + +BenchmarkStdCrc1KB-4 500000 3604 ns/op 284.10 MB/s +BenchmarkCrc1KBNoAsm-4 1000000 1463 ns/op 699.79 MB/s (slice8) +BenchmarkCrc1KB-4 3000000 396 ns/op 2583.69 MB/s (asm) + +BenchmarkStdCrc8KB-4 200000 11417 ns/op 717.48 MB/s (slice8) +BenchmarkCrc8KBNoAsm-4 200000 11317 ns/op 723.85 MB/s (slice8) +BenchmarkCrc8KB-4 500000 2919 ns/op 2805.73 MB/s (asm) + +BenchmarkStdCrc32KB-4 30000 45749 ns/op 716.24 MB/s (slice8) +BenchmarkCrc32KBNoAsm-4 30000 45109 ns/op 726.42 MB/s (slice8) +BenchmarkCrc32KB-4 100000 11497 ns/op 2850.09 MB/s (asm) + +BenchmarkStdNoAsmCastagnol40B-4 10000000 161 ns/op 246.94 MB/s +BenchmarkStdCastagnoli40B-4 50000000 28.4 ns/op 1410.69 MB/s (asm) +BenchmarkCastagnoli40BNoAsm-4 20000000 100 ns/op 398.01 MB/s (slice8) +BenchmarkCastagnoli40B-4 50000000 28.2 ns/op 1419.54 MB/s (asm) + +BenchmarkStdNoAsmCastagnoli1KB-4 500000 3622 ns/op 282.67 MB/s +BenchmarkStdCastagnoli1KB-4 10000000 144 ns/op 7099.78 MB/s (asm) +BenchmarkCastagnoli1KBNoAsm-4 1000000 1475 ns/op 694.14 MB/s (slice8) +BenchmarkCastagnoli1KB-4 10000000 146 ns/op 6993.35 MB/s (asm) + +BenchmarkStdNoAsmCastagnoli8KB-4 50000 28781 ns/op 284.63 MB/s +BenchmarkStdCastagnoli8KB-4 1000000 1029 ns/op 7957.89 MB/s (asm) +BenchmarkCastagnoli8KBNoAsm-4 200000 11410 ns/op 717.94 MB/s (slice8) +BenchmarkCastagnoli8KB-4 1000000 1000 ns/op 8188.71 MB/s (asm) + +BenchmarkStdNoAsmCastagnoli32KB-4 10000 115426 ns/op 283.89 MB/s +BenchmarkStdCastagnoli32KB-4 300000 4065 ns/op 8059.13 MB/s (asm) +BenchmarkCastagnoli32KBNoAsm-4 30000 45171 ns/op 725.41 MB/s (slice8) +BenchmarkCastagnoli32KB-4 500000 4077 ns/op 8035.89 MB/s (asm) +``` + +The IEEE assembler optimizations has been submitted and will be part of the Go 1.6 standard library. + +However, the improved use of slice-by-8 has not, but will probably be submitted for Go 1.7. + +# license + +Standard Go license. Changes are Copyright (c) 2015 Klaus Post under same conditions. diff --git a/vendor/github.com/klauspost/crc32/crc32.go b/vendor/github.com/klauspost/crc32/crc32.go new file mode 100644 index 00000000..b584e410 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32.go @@ -0,0 +1,182 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package crc32 implements the 32-bit cyclic redundancy check, or CRC-32, +// checksum. See http://en.wikipedia.org/wiki/Cyclic_redundancy_check for +// information. +// +// Polynomials are represented in LSB-first form also known as reversed representation. +// +// See http://en.wikipedia.org/wiki/Mathematics_of_cyclic_redundancy_checks#Reversed_representations_and_reciprocal_polynomials +// for information. +package crc32 + +import ( + "hash" + "sync" +) + +// The size of a CRC-32 checksum in bytes. +const Size = 4 + +// Predefined polynomials. +const ( + // IEEE is by far and away the most common CRC-32 polynomial. + // Used by ethernet (IEEE 802.3), v.42, fddi, gzip, zip, png, ... + IEEE = 0xedb88320 + + // Castagnoli's polynomial, used in iSCSI. + // Has better error detection characteristics than IEEE. + // http://dx.doi.org/10.1109/26.231911 + Castagnoli = 0x82f63b78 + + // Koopman's polynomial. + // Also has better error detection characteristics than IEEE. + // http://dx.doi.org/10.1109/DSN.2002.1028931 + Koopman = 0xeb31d82e +) + +// Table is a 256-word table representing the polynomial for efficient processing. +type Table [256]uint32 + +// castagnoliTable points to a lazily initialized Table for the Castagnoli +// polynomial. MakeTable will always return this value when asked to make a +// Castagnoli table so we can compare against it to find when the caller is +// using this polynomial. +var castagnoliTable *Table +var castagnoliTable8 *slicing8Table +var castagnoliOnce sync.Once + +func castagnoliInit() { + castagnoliTable = makeTable(Castagnoli) + castagnoliTable8 = makeTable8(Castagnoli) +} + +// IEEETable is the table for the IEEE polynomial. +var IEEETable = makeTable(IEEE) + +// slicing8Table is array of 8 Tables +type slicing8Table [8]Table + +// iEEETable8 is the slicing8Table for IEEE +var iEEETable8 *slicing8Table +var iEEETable8Once sync.Once + +// MakeTable returns the Table constructed from the specified polynomial. +func MakeTable(poly uint32) *Table { + switch poly { + case IEEE: + return IEEETable + case Castagnoli: + castagnoliOnce.Do(castagnoliInit) + return castagnoliTable + } + return makeTable(poly) +} + +// makeTable returns the Table constructed from the specified polynomial. +func makeTable(poly uint32) *Table { + t := new(Table) + for i := 0; i < 256; i++ { + crc := uint32(i) + for j := 0; j < 8; j++ { + if crc&1 == 1 { + crc = (crc >> 1) ^ poly + } else { + crc >>= 1 + } + } + t[i] = crc + } + return t +} + +// makeTable8 returns slicing8Table constructed from the specified polynomial. +func makeTable8(poly uint32) *slicing8Table { + t := new(slicing8Table) + t[0] = *makeTable(poly) + for i := 0; i < 256; i++ { + crc := t[0][i] + for j := 1; j < 8; j++ { + crc = t[0][crc&0xFF] ^ (crc >> 8) + t[j][i] = crc + } + } + return t +} + +// digest represents the partial evaluation of a checksum. +type digest struct { + crc uint32 + tab *Table +} + +// New creates a new hash.Hash32 computing the CRC-32 checksum +// using the polynomial represented by the Table. +func New(tab *Table) hash.Hash32 { return &digest{0, tab} } + +// NewIEEE creates a new hash.Hash32 computing the CRC-32 checksum +// using the IEEE polynomial. +func NewIEEE() hash.Hash32 { return New(IEEETable) } + +func (d *digest) Size() int { return Size } + +func (d *digest) BlockSize() int { return 1 } + +func (d *digest) Reset() { d.crc = 0 } + +func update(crc uint32, tab *Table, p []byte) uint32 { + crc = ^crc + for _, v := range p { + crc = tab[byte(crc)^v] ^ (crc >> 8) + } + return ^crc +} + +// updateSlicingBy8 updates CRC using Slicing-by-8 +func updateSlicingBy8(crc uint32, tab *slicing8Table, p []byte) uint32 { + crc = ^crc + for len(p) > 8 { + crc ^= uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24 + crc = tab[0][p[7]] ^ tab[1][p[6]] ^ tab[2][p[5]] ^ tab[3][p[4]] ^ + tab[4][crc>>24] ^ tab[5][(crc>>16)&0xFF] ^ + tab[6][(crc>>8)&0xFF] ^ tab[7][crc&0xFF] + p = p[8:] + } + crc = ^crc + if len(p) == 0 { + return crc + } + return update(crc, &tab[0], p) +} + +// Update returns the result of adding the bytes in p to the crc. +func Update(crc uint32, tab *Table, p []byte) uint32 { + if tab == castagnoliTable { + return updateCastagnoli(crc, p) + } else if tab == IEEETable { + return updateIEEE(crc, p) + } + return update(crc, tab, p) +} + +func (d *digest) Write(p []byte) (n int, err error) { + d.crc = Update(d.crc, d.tab, p) + return len(p), nil +} + +func (d *digest) Sum32() uint32 { return d.crc } + +func (d *digest) Sum(in []byte) []byte { + s := d.Sum32() + return append(in, byte(s>>24), byte(s>>16), byte(s>>8), byte(s)) +} + +// Checksum returns the CRC-32 checksum of data +// using the polynomial represented by the Table. +func Checksum(data []byte, tab *Table) uint32 { return Update(0, tab, data) } + +// ChecksumIEEE returns the CRC-32 checksum of data +// using the IEEE polynomial. +func ChecksumIEEE(data []byte) uint32 { return updateIEEE(0, data) } diff --git a/vendor/github.com/klauspost/crc32/crc32_amd64.go b/vendor/github.com/klauspost/crc32/crc32_amd64.go new file mode 100644 index 00000000..669fe171 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_amd64.go @@ -0,0 +1,62 @@ +//+build !appengine,!gccgo + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package crc32 + +// This file contains the code to call the SSE 4.2 version of the Castagnoli +// and IEEE CRC. + +// haveSSE41/haveSSE42/haveCLMUL are defined in crc_amd64.s and uses +// CPUID to test for SSE 4.1, 4.2 and CLMUL support. +func haveSSE41() bool +func haveSSE42() bool +func haveCLMUL() bool + +// castagnoliSSE42 is defined in crc_amd64.s and uses the SSE4.2 CRC32 +// instruction. +// go:noescape +func castagnoliSSE42(crc uint32, p []byte) uint32 + +// ieeeCLMUL is defined in crc_amd64.s and uses the PCLMULQDQ +// instruction as well as SSE 4.1. +// go:noescape +func ieeeCLMUL(crc uint32, p []byte) uint32 + +var sse42 = haveSSE42() +var useFastIEEE = haveCLMUL() && haveSSE41() + +func updateCastagnoli(crc uint32, p []byte) uint32 { + if sse42 { + return castagnoliSSE42(crc, p) + } + // only use slicing-by-8 when input is >= 16 Bytes + if len(p) >= 16 { + return updateSlicingBy8(crc, castagnoliTable8, p) + } + return update(crc, castagnoliTable, p) +} + +func updateIEEE(crc uint32, p []byte) uint32 { + if useFastIEEE && len(p) >= 64 { + left := len(p) & 15 + do := len(p) - left + crc := ^ieeeCLMUL(^crc, p[:do]) + if left > 0 { + crc = update(crc, IEEETable, p[do:]) + } + return crc + } + + // only use slicing-by-8 when input is >= 16 Bytes + if len(p) >= 16 { + iEEETable8Once.Do(func() { + iEEETable8 = makeTable8(IEEE) + }) + return updateSlicingBy8(crc, iEEETable8, p) + } + + return update(crc, IEEETable, p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_amd64.s b/vendor/github.com/klauspost/crc32/crc32_amd64.s new file mode 100644 index 00000000..1b1cd8b6 --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_amd64.s @@ -0,0 +1,237 @@ +//+build gc + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#define NOSPLIT 4 +#define RODATA 8 + +// func castagnoliSSE42(crc uint32, p []byte) uint32 +TEXT ·castagnoliSSE42(SB), NOSPLIT, $0 + MOVL crc+0(FP), AX // CRC value + MOVQ p+8(FP), SI // data pointer + MOVQ p_len+16(FP), CX // len(p) + + NOTL AX + + // If there's less than 8 bytes to process, we do it byte-by-byte. + CMPQ CX, $8 + JL cleanup + + // Process individual bytes until the input is 8-byte aligned. +startup: + MOVQ SI, BX + ANDQ $7, BX + JZ aligned + + CRC32B (SI), AX + DECQ CX + INCQ SI + JMP startup + +aligned: + // The input is now 8-byte aligned and we can process 8-byte chunks. + CMPQ CX, $8 + JL cleanup + + CRC32Q (SI), AX + ADDQ $8, SI + SUBQ $8, CX + JMP aligned + +cleanup: + // We may have some bytes left over that we process one at a time. + CMPQ CX, $0 + JE done + + CRC32B (SI), AX + INCQ SI + DECQ CX + JMP cleanup + +done: + NOTL AX + MOVL AX, ret+32(FP) + RET + +// func haveSSE42() bool +TEXT ·haveSSE42(SB), NOSPLIT, $0 + XORQ AX, AX + INCL AX + CPUID + SHRQ $20, CX + ANDQ $1, CX + MOVB CX, ret+0(FP) + RET + +// func haveCLMUL() bool +TEXT ·haveCLMUL(SB), NOSPLIT, $0 + XORQ AX, AX + INCL AX + CPUID + SHRQ $1, CX + ANDQ $1, CX + MOVB CX, ret+0(FP) + RET + +// func haveSSE41() bool +TEXT ·haveSSE41(SB), NOSPLIT, $0 + XORQ AX, AX + INCL AX + CPUID + SHRQ $19, CX + ANDQ $1, CX + MOVB CX, ret+0(FP) + RET + +// CRC32 polynomial data +// +// These constants are lifted from the +// Linux kernel, since they avoid the costly +// PSHUFB 16 byte reversal proposed in the +// original Intel paper. +DATA r2r1kp<>+0(SB)/8, $0x154442bd4 +DATA r2r1kp<>+8(SB)/8, $0x1c6e41596 +DATA r4r3kp<>+0(SB)/8, $0x1751997d0 +DATA r4r3kp<>+8(SB)/8, $0x0ccaa009e +DATA rupolykp<>+0(SB)/8, $0x1db710641 +DATA rupolykp<>+8(SB)/8, $0x1f7011641 +DATA r5kp<>+0(SB)/8, $0x163cd6124 + +GLOBL r2r1kp<>(SB), RODATA, $16 +GLOBL r4r3kp<>(SB), RODATA, $16 +GLOBL rupolykp<>(SB), RODATA, $16 +GLOBL r5kp<>(SB), RODATA, $8 + +// Based on http://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf +// len(p) must be at least 64, and must be a multiple of 16. + +// func ieeeCLMUL(crc uint32, p []byte) uint32 +TEXT ·ieeeCLMUL(SB), NOSPLIT, $0 + MOVL crc+0(FP), X0 // Initial CRC value + MOVQ p+8(FP), SI // data pointer + MOVQ p_len+16(FP), CX // len(p) + + MOVOU (SI), X1 + MOVOU 16(SI), X2 + MOVOU 32(SI), X3 + MOVOU 48(SI), X4 + PXOR X0, X1 + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + CMPQ CX, $64 // Less than 64 bytes left + JB remain64 + + MOVOU r2r1kp<>+0(SB), X0 + +loopback64: + MOVOA X1, X5 + MOVOA X2, X6 + MOVOA X3, X7 + MOVOA X4, X8 + + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0, X0, X2 + PCLMULQDQ $0, X0, X3 + PCLMULQDQ $0, X0, X4 + + // Load next early + MOVOU (SI), X11 + MOVOU 16(SI), X12 + MOVOU 32(SI), X13 + MOVOU 48(SI), X14 + + PCLMULQDQ $0x11, X0, X5 + PCLMULQDQ $0x11, X0, X6 + PCLMULQDQ $0x11, X0, X7 + PCLMULQDQ $0x11, X0, X8 + + PXOR X5, X1 + PXOR X6, X2 + PXOR X7, X3 + PXOR X8, X4 + + PXOR X11, X1 + PXOR X12, X2 + PXOR X13, X3 + PXOR X14, X4 + + ADDQ $0x40, DI + ADDQ $64, SI // buf+=64 + SUBQ $64, CX // len-=64 + CMPQ CX, $64 // Less than 64 bytes left? + JGE loopback64 + + // Fold result into a single register (X1) +remain64: + MOVOU r4r3kp<>+0(SB), X0 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X2, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X3, X1 + + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X4, X1 + + // More than 16 bytes left? + CMPQ CX, $16 + JB finish + + // Encode 16 bytes +remain16: + MOVOU (SI), X10 + MOVOA X1, X5 + PCLMULQDQ $0, X0, X1 + PCLMULQDQ $0x11, X0, X5 + PXOR X5, X1 + PXOR X10, X1 + SUBQ $16, CX + ADDQ $16, SI + CMPQ CX, $16 + JGE remain16 + +finish: + // Fold final result into 32 bits and return it + PCMPEQB X3, X3 + PCLMULQDQ $1, X1, X0 + PSRLDQ $8, X1 + PXOR X0, X1 + + MOVOA X1, X2 + MOVQ r5kp<>+0(SB), X0 + + // Creates 32 bit mask. Note that we don't care about upper half. + PSRLQ $32, X3 + + PSRLDQ $4, X2 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + MOVOU rupolykp<>+0(SB), X0 + + MOVOA X1, X2 + PAND X3, X1 + PCLMULQDQ $0x10, X0, X1 + PAND X3, X1 + PCLMULQDQ $0, X0, X1 + PXOR X2, X1 + + // PEXTRD $1, X1, AX (SSE 4.1) + BYTE $0x66; BYTE $0x0f; BYTE $0x3a + BYTE $0x16; BYTE $0xc8; BYTE $0x01 + MOVL AX, ret+32(FP) + + RET diff --git a/vendor/github.com/klauspost/crc32/crc32_amd64p32.go b/vendor/github.com/klauspost/crc32/crc32_amd64p32.go new file mode 100644 index 00000000..64a356fe --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_amd64p32.go @@ -0,0 +1,39 @@ +//+build !appengine,!gccgo + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package crc32 + +// This file contains the code to call the SSE 4.2 version of the Castagnoli +// CRC. + +// haveSSE42 is defined in crc_amd64p32.s and uses CPUID to test for 4.2 +// support. +func haveSSE42() bool + +// castagnoliSSE42 is defined in crc_amd64.s and uses the SSE4.2 CRC32 +// instruction. +func castagnoliSSE42(crc uint32, p []byte) uint32 + +var sse42 = haveSSE42() + +func updateCastagnoli(crc uint32, p []byte) uint32 { + if sse42 { + return castagnoliSSE42(crc, p) + } + return update(crc, castagnoliTable, p) +} + +func updateIEEE(crc uint32, p []byte) uint32 { + // only use slicing-by-8 when input is >= 4KB + if len(p) >= 4096 { + iEEETable8Once.Do(func() { + iEEETable8 = makeTable8(IEEE) + }) + return updateSlicingBy8(crc, iEEETable8, p) + } + + return update(crc, IEEETable, p) +} diff --git a/vendor/github.com/klauspost/crc32/crc32_amd64p32.s b/vendor/github.com/klauspost/crc32/crc32_amd64p32.s new file mode 100644 index 00000000..65944c5a --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_amd64p32.s @@ -0,0 +1,67 @@ +//+build gc + +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#define NOSPLIT 4 +#define RODATA 8 + +// func castagnoliSSE42(crc uint32, p []byte) uint32 +TEXT ·castagnoliSSE42(SB), NOSPLIT, $0 + MOVL crc+0(FP), AX // CRC value + MOVL p+4(FP), SI // data pointer + MOVL p_len+8(FP), CX // len(p) + + NOTL AX + + // If there's less than 8 bytes to process, we do it byte-by-byte. + CMPQ CX, $8 + JL cleanup + + // Process individual bytes until the input is 8-byte aligned. +startup: + MOVQ SI, BX + ANDQ $7, BX + JZ aligned + + CRC32B (SI), AX + DECQ CX + INCQ SI + JMP startup + +aligned: + // The input is now 8-byte aligned and we can process 8-byte chunks. + CMPQ CX, $8 + JL cleanup + + CRC32Q (SI), AX + ADDQ $8, SI + SUBQ $8, CX + JMP aligned + +cleanup: + // We may have some bytes left over that we process one at a time. + CMPQ CX, $0 + JE done + + CRC32B (SI), AX + INCQ SI + DECQ CX + JMP cleanup + +done: + NOTL AX + MOVL AX, ret+16(FP) + RET + +// func haveSSE42() bool +TEXT ·haveSSE42(SB), NOSPLIT, $0 + XORQ AX, AX + INCL AX + CPUID + SHRQ $20, CX + ANDQ $1, CX + MOVB CX, ret+0(FP) + RET + diff --git a/vendor/github.com/klauspost/crc32/crc32_generic.go b/vendor/github.com/klauspost/crc32/crc32_generic.go new file mode 100644 index 00000000..43f5d1dd --- /dev/null +++ b/vendor/github.com/klauspost/crc32/crc32_generic.go @@ -0,0 +1,28 @@ +// Copyright 2011 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// +build 386 arm arm64 ppc64 ppc64le appengine gccgo + +package crc32 + +// The file contains the generic version of updateCastagnoli which does +// slicing-by-8, or uses the fallback for very small sizes. +func updateCastagnoli(crc uint32, p []byte) uint32 { + // only use slicing-by-8 when input is >= 16 Bytes + if len(p) >= 16 { + return updateSlicingBy8(crc, castagnoliTable8, p) + } + return update(crc, castagnoliTable, p) +} + +func updateIEEE(crc uint32, p []byte) uint32 { + // only use slicing-by-8 when input is >= 16 Bytes + if len(p) >= 16 { + iEEETable8Once.Do(func() { + iEEETable8 = makeTable8(IEEE) + }) + return updateSlicingBy8(crc, iEEETable8, p) + } + return update(crc, IEEETable, p) +} diff --git a/vendor/github.com/pierrec/lz4/LICENSE b/vendor/github.com/pierrec/lz4/LICENSE new file mode 100644 index 00000000..bd899d83 --- /dev/null +++ b/vendor/github.com/pierrec/lz4/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2015, Pierre Curto +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of xxHash nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/pierrec/lz4/README.md b/vendor/github.com/pierrec/lz4/README.md new file mode 100644 index 00000000..dd3c9d47 --- /dev/null +++ b/vendor/github.com/pierrec/lz4/README.md @@ -0,0 +1,31 @@ +[![godoc](https://godoc.org/github.com/pierrec/lz4?status.png)](https://godoc.org/github.com/pierrec/lz4) +[![Build Status](https://travis-ci.org/pierrec/lz4.svg?branch=master)](https://travis-ci.org/pierrec/lz4) + +# lz4 +LZ4 compression and decompression in pure Go + +## Usage + +```go +import "github.com/pierrec/lz4" +``` + +## Description + +Package lz4 implements reading and writing lz4 compressed data (a frame), +as specified in http://fastcompression.blogspot.fr/2013/04/lz4-streaming-format-final.html, +using an io.Reader (decompression) and io.Writer (compression). +It is designed to minimize memory usage while maximizing throughput by being able to +[de]compress data concurrently. + +The Reader and the Writer support concurrent processing provided the supplied buffers are +large enough (in multiples of BlockMaxSize) and there is no block dependency. +Reader.WriteTo and Writer.ReadFrom do leverage the concurrency transparently. +The runtime.GOMAXPROCS() value is used to apply concurrency or not. + +Although the block level compression and decompression functions are exposed and are fully compatible +with the lz4 block format definition, they are low level and should not be used directly. +For a complete description of an lz4 compressed block, see: +http://fastcompression.blogspot.fr/2011/05/lz4-explained.html + +See https://github.com/Cyan4973/lz4 for the reference C implementation. diff --git a/vendor/github.com/pierrec/lz4/block.go b/vendor/github.com/pierrec/lz4/block.go new file mode 100644 index 00000000..6884bccd --- /dev/null +++ b/vendor/github.com/pierrec/lz4/block.go @@ -0,0 +1,474 @@ +package lz4 + +import ( + "encoding/binary" + "errors" + "unsafe" +) + +// block represents a frame data block. +// Used when compressing or decompressing frame blocks concurrently. +type block struct { + compressed bool + zdata []byte // compressed data + data []byte // decompressed data + offset int // offset within the data as with block dependency the 64Kb window is prepended to it + checksum uint32 // compressed data checksum + err error // error while [de]compressing +} + +var ( + // ErrInvalidSource is returned by UncompressBlock when a compressed block is corrupted. + ErrInvalidSource = errors.New("lz4: invalid source") + // ErrShortBuffer is returned by UncompressBlock, CompressBlock or CompressBlockHC when + // the supplied buffer for [de]compression is too small. + ErrShortBuffer = errors.New("lz4: short buffer") +) + +// CompressBlockBound returns the maximum size of a given buffer of size n, when not compressible. +func CompressBlockBound(n int) int { + return n + n/255 + 16 +} + +// UncompressBlock decompresses the source buffer into the destination one, +// starting at the di index and returning the decompressed size. +// +// The destination buffer must be sized appropriately. +// +// An error is returned if the source data is invalid or the destination buffer is too small. +func UncompressBlock(src, dst []byte, di int) (int, error) { + si, sn, di0 := 0, len(src), di + if sn == 0 { + return 0, nil + } + + for { + // literals and match lengths (token) + lLen := int(src[si] >> 4) + mLen := int(src[si] & 0xF) + if si++; si == sn { + return di, ErrInvalidSource + } + + // literals + if lLen > 0 { + if lLen == 0xF { + for src[si] == 0xFF { + lLen += 0xFF + if si++; si == sn { + return di - di0, ErrInvalidSource + } + } + lLen += int(src[si]) + if si++; si == sn { + return di - di0, ErrInvalidSource + } + } + if len(dst)-di < lLen || si+lLen > sn { + return di - di0, ErrShortBuffer + } + di += copy(dst[di:], src[si:si+lLen]) + + if si += lLen; si >= sn { + return di - di0, nil + } + } + + if si += 2; si >= sn { + return di, ErrInvalidSource + } + offset := int(src[si-2]) | int(src[si-1])<<8 + if di-offset < 0 || offset == 0 { + return di - di0, ErrInvalidSource + } + + // match + if mLen == 0xF { + for src[si] == 0xFF { + mLen += 0xFF + if si++; si == sn { + return di - di0, ErrInvalidSource + } + } + mLen += int(src[si]) + if si++; si == sn { + return di - di0, ErrInvalidSource + } + } + // minimum match length is 4 + mLen += 4 + if len(dst)-di <= mLen { + return di - di0, ErrShortBuffer + } + + // copy the match (NB. match is at least 4 bytes long) + // NB. past di, copy() would write old bytes instead of + // the ones we just copied, so split the work into the largest chunk. + for ; mLen >= offset; mLen -= offset { + di += copy(dst[di:], dst[di-offset:di]) + } + di += copy(dst[di:], dst[di-offset:di-offset+mLen]) + } +} + +type hashEntry struct { + generation uint + value int +} + +// CompressBlock compresses the source buffer starting at soffet into the destination one. +// This is the fast version of LZ4 compression and also the default one. +// +// The size of the compressed data is returned. If it is 0 and no error, then the data is incompressible. +// +// An error is returned if the destination buffer is too small. +func CompressBlock(src, dst []byte, soffset int) (int, error) { + var hashTable [hashTableSize]hashEntry + return compressGenerationalBlock(src, dst, soffset, 0, hashTable[:]) +} + +// getUint32 is a despicably evil function (well, for Go!) that takes advantage +// of the machine's byte order to save some operations. This may look +// inefficient but it is significantly faster on littleEndian machines, +// which include x84, amd64, and some ARM processors. +func getUint32(b []byte) uint32 { + _ = b[3] + if isLittleEndian { + return *(*uint32)(unsafe.Pointer(&b)) + } + + return uint32(b[0]) | + uint32(b[1])<<8 | + uint32(b[2])<<16 | + uint32(b[3])<<24 +} + +func compressGenerationalBlock(src, dst []byte, soffset int, generation uint, hashTable []hashEntry) (int, error) { + sn, dn := len(src)-mfLimit, len(dst) + if sn <= 0 || dn == 0 || soffset >= sn { + return 0, nil + } + var si, di int + + // fast scan strategy: + // we only need a hash table to store the last sequences (4 bytes) + var hashShift = uint((minMatch * 8) - hashLog) + + // Initialise the hash table with the first 64Kb of the input buffer + // (used when compressing dependent blocks) + for si < soffset { + h := getUint32(src[si:]) * hasher >> hashShift + si++ + hashTable[h] = hashEntry{generation, si} + } + + anchor := si + fma := 1 << skipStrength + for si < sn-minMatch { + // hash the next 4 bytes (sequence)... + h := getUint32(src[si:]) * hasher >> hashShift + if hashTable[h].generation != generation { + hashTable[h] = hashEntry{generation, 0} + } + // -1 to separate existing entries from new ones + ref := hashTable[h].value - 1 + // ...and store the position of the hash in the hash table (+1 to compensate the -1 upon saving) + hashTable[h].value = si + 1 + // no need to check the last 3 bytes in the first literal 4 bytes as + // this guarantees that the next match, if any, is compressed with + // a lower size, since to have some compression we must have: + // ll+ml-overlap > 1 + (ll-15)/255 + (ml-4-15)/255 + 2 (uncompressed size>compressed size) + // => ll+ml>3+2*overlap => ll+ml>= 4+2*overlap + // and by definition we do have: + // ll >= 1, ml >= 4 + // => ll+ml >= 5 + // => so overlap must be 0 + + // the sequence is new, out of bound (64kb) or not valid: try next sequence + if ref < 0 || fma&(1<>winSizeLog > 0 || + src[ref] != src[si] || + src[ref+1] != src[si+1] || + src[ref+2] != src[si+2] || + src[ref+3] != src[si+3] { + // variable step: improves performance on non-compressible data + si += fma >> skipStrength + fma++ + continue + } + // match found + fma = 1 << skipStrength + lLen := si - anchor + offset := si - ref + + // encode match length part 1 + si += minMatch + mLen := si // match length has minMatch already + for si <= sn && src[si] == src[si-offset] { + si++ + } + mLen = si - mLen + if mLen < 0xF { + dst[di] = byte(mLen) + } else { + dst[di] = 0xF + } + + // encode literals length + if lLen < 0xF { + dst[di] |= byte(lLen << 4) + } else { + dst[di] |= 0xF0 + if di++; di == dn { + return di, ErrShortBuffer + } + l := lLen - 0xF + for ; l >= 0xFF; l -= 0xFF { + dst[di] = 0xFF + if di++; di == dn { + return di, ErrShortBuffer + } + } + dst[di] = byte(l) + } + if di++; di == dn { + return di, ErrShortBuffer + } + + // literals + if di+lLen >= dn { + return di, ErrShortBuffer + } + di += copy(dst[di:], src[anchor:anchor+lLen]) + anchor = si + + // encode offset + if di += 2; di >= dn { + return di, ErrShortBuffer + } + dst[di-2], dst[di-1] = byte(offset), byte(offset>>8) + + // encode match length part 2 + if mLen >= 0xF { + for mLen -= 0xF; mLen >= 0xFF; mLen -= 0xFF { + dst[di] = 0xFF + if di++; di == dn { + return di, ErrShortBuffer + } + } + dst[di] = byte(mLen) + if di++; di == dn { + return di, ErrShortBuffer + } + } + } + + if anchor == 0 { + // incompressible + return 0, nil + } + + // last literals + lLen := len(src) - anchor + if lLen < 0xF { + dst[di] = byte(lLen << 4) + } else { + dst[di] = 0xF0 + if di++; di == dn { + return di, ErrShortBuffer + } + lLen -= 0xF + for ; lLen >= 0xFF; lLen -= 0xFF { + dst[di] = 0xFF + if di++; di == dn { + return di, ErrShortBuffer + } + } + dst[di] = byte(lLen) + } + if di++; di == dn { + return di, ErrShortBuffer + } + + // write literals + src = src[anchor:] + switch n := di + len(src); { + case n > dn: + return di, ErrShortBuffer + case n >= sn: + // incompressible + return 0, nil + } + di += copy(dst[di:], src) + return di, nil +} + +// CompressBlockHC compresses the source buffer starting at soffet into the destination one. +// CompressBlockHC compression ratio is better than CompressBlock but it is also slower. +// +// The size of the compressed data is returned. If it is 0 and no error, then the data is not compressible. +// +// An error is returned if the destination buffer is too small. +func CompressBlockHC(src, dst []byte, soffset int) (int, error) { + sn, dn := len(src)-mfLimit, len(dst) + if sn <= 0 || dn == 0 || soffset >= sn { + return 0, nil + } + var si, di int + + // Hash Chain strategy: + // we need a hash table and a chain table + // the chain table cannot contain more entries than the window size (64Kb entries) + var hashTable [1 << hashLog]int + var chainTable [winSize]int + var hashShift = uint((minMatch * 8) - hashLog) + + // Initialise the hash table with the first 64Kb of the input buffer + // (used when compressing dependent blocks) + for si < soffset { + h := binary.LittleEndian.Uint32(src[si:]) * hasher >> hashShift + chainTable[si&winMask] = hashTable[h] + si++ + hashTable[h] = si + } + + anchor := si + for si < sn-minMatch { + // hash the next 4 bytes (sequence)... + h := binary.LittleEndian.Uint32(src[si:]) * hasher >> hashShift + + // follow the chain until out of window and give the longest match + mLen := 0 + offset := 0 + for next := hashTable[h] - 1; next > 0 && next > si-winSize; next = chainTable[next&winMask] - 1 { + // the first (mLen==0) or next byte (mLen>=minMatch) at current match length must match to improve on the match length + if src[next+mLen] == src[si+mLen] { + for ml := 0; ; ml++ { + if src[next+ml] != src[si+ml] || si+ml > sn { + // found a longer match, keep its position and length + if mLen < ml && ml >= minMatch { + mLen = ml + offset = si - next + } + break + } + } + } + } + chainTable[si&winMask] = hashTable[h] + hashTable[h] = si + 1 + + // no match found + if mLen == 0 { + si++ + continue + } + + // match found + // update hash/chain tables with overlaping bytes: + // si already hashed, add everything from si+1 up to the match length + for si, ml := si+1, si+mLen; si < ml; { + h := binary.LittleEndian.Uint32(src[si:]) * hasher >> hashShift + chainTable[si&winMask] = hashTable[h] + si++ + hashTable[h] = si + } + + lLen := si - anchor + si += mLen + mLen -= minMatch // match length does not include minMatch + + if mLen < 0xF { + dst[di] = byte(mLen) + } else { + dst[di] = 0xF + } + + // encode literals length + if lLen < 0xF { + dst[di] |= byte(lLen << 4) + } else { + dst[di] |= 0xF0 + if di++; di == dn { + return di, ErrShortBuffer + } + l := lLen - 0xF + for ; l >= 0xFF; l -= 0xFF { + dst[di] = 0xFF + if di++; di == dn { + return di, ErrShortBuffer + } + } + dst[di] = byte(l) + } + if di++; di == dn { + return di, ErrShortBuffer + } + + // literals + if di+lLen >= dn { + return di, ErrShortBuffer + } + di += copy(dst[di:], src[anchor:anchor+lLen]) + anchor = si + + // encode offset + if di += 2; di >= dn { + return di, ErrShortBuffer + } + dst[di-2], dst[di-1] = byte(offset), byte(offset>>8) + + // encode match length part 2 + if mLen >= 0xF { + for mLen -= 0xF; mLen >= 0xFF; mLen -= 0xFF { + dst[di] = 0xFF + if di++; di == dn { + return di, ErrShortBuffer + } + } + dst[di] = byte(mLen) + if di++; di == dn { + return di, ErrShortBuffer + } + } + } + + if anchor == 0 { + // incompressible + return 0, nil + } + + // last literals + lLen := len(src) - anchor + if lLen < 0xF { + dst[di] = byte(lLen << 4) + } else { + dst[di] = 0xF0 + if di++; di == dn { + return di, ErrShortBuffer + } + lLen -= 0xF + for ; lLen >= 0xFF; lLen -= 0xFF { + dst[di] = 0xFF + if di++; di == dn { + return di, ErrShortBuffer + } + } + dst[di] = byte(lLen) + } + if di++; di == dn { + return di, ErrShortBuffer + } + + // write literals + src = src[anchor:] + switch n := di + len(src); { + case n > dn: + return di, ErrShortBuffer + case n >= sn: + // incompressible + return 0, nil + } + di += copy(dst[di:], src) + return di, nil +} diff --git a/vendor/github.com/pierrec/lz4/lz4.go b/vendor/github.com/pierrec/lz4/lz4.go new file mode 100644 index 00000000..46389243 --- /dev/null +++ b/vendor/github.com/pierrec/lz4/lz4.go @@ -0,0 +1,118 @@ +// Package lz4 implements reading and writing lz4 compressed data (a frame), +// as specified in http://fastcompression.blogspot.fr/2013/04/lz4-streaming-format-final.html, +// using an io.Reader (decompression) and io.Writer (compression). +// It is designed to minimize memory usage while maximizing throughput by being able to +// [de]compress data concurrently. +// +// The Reader and the Writer support concurrent processing provided the supplied buffers are +// large enough (in multiples of BlockMaxSize) and there is no block dependency. +// Reader.WriteTo and Writer.ReadFrom do leverage the concurrency transparently. +// The runtime.GOMAXPROCS() value is used to apply concurrency or not. +// +// Although the block level compression and decompression functions are exposed and are fully compatible +// with the lz4 block format definition, they are low level and should not be used directly. +// For a complete description of an lz4 compressed block, see: +// http://fastcompression.blogspot.fr/2011/05/lz4-explained.html +// +// See https://github.com/Cyan4973/lz4 for the reference C implementation. +package lz4 + +import ( + "hash" + "sync" + "unsafe" + + "github.com/pierrec/xxHash/xxHash32" +) + +const ( + // Extension is the LZ4 frame file name extension + Extension = ".lz4" + // Version is the LZ4 frame format version + Version = 1 + + frameMagic = uint32(0x184D2204) + frameSkipMagic = uint32(0x184D2A50) + + // The following constants are used to setup the compression algorithm. + minMatch = 4 // the minimum size of the match sequence size (4 bytes) + winSizeLog = 16 // LZ4 64Kb window size limit + winSize = 1 << winSizeLog + winMask = winSize - 1 // 64Kb window of previous data for dependent blocks + + // hashLog determines the size of the hash table used to quickly find a previous match position. + // Its value influences the compression speed and memory usage, the lower the faster, + // but at the expense of the compression ratio. + // 16 seems to be the best compromise. + hashLog = 16 + hashTableSize = 1 << hashLog + hashShift = uint((minMatch * 8) - hashLog) + + mfLimit = 8 + minMatch // The last match cannot start within the last 12 bytes. + skipStrength = 6 // variable step for fast scan + + hasher = uint32(2654435761) // prime number used to hash minMatch +) + +// map the block max size id with its value in bytes: 64Kb, 256Kb, 1Mb and 4Mb. +var bsMapID = map[byte]int{4: 64 << 10, 5: 256 << 10, 6: 1 << 20, 7: 4 << 20} +var bsMapValue = map[int]byte{} + +// Reversed. +func init() { + for i, v := range bsMapID { + bsMapValue[v] = i + } +} + +var isLittleEndian = getIsLittleEndian() + +func getIsLittleEndian() (ret bool) { + var i int = 0x1 + bs := (*[1]byte)(unsafe.Pointer(&i)) + if bs[0] == 0 { + return false + } + + return true +} + +// Header describes the various flags that can be set on a Writer or obtained from a Reader. +// The default values match those of the LZ4 frame format definition (http://fastcompression.blogspot.com/2013/04/lz4-streaming-format-final.html). +// +// NB. in a Reader, in case of concatenated frames, the Header values may change between Read() calls. +// It is the caller responsibility to check them if necessary (typically when using the Reader concurrency). +type Header struct { + BlockDependency bool // compressed blocks are dependent (one block depends on the last 64Kb of the previous one) + BlockChecksum bool // compressed blocks are checksumed + NoChecksum bool // frame checksum + BlockMaxSize int // the size of the decompressed data block (one of [64KB, 256KB, 1MB, 4MB]). Default=4MB. + Size uint64 // the frame total size. It is _not_ computed by the Writer. + HighCompression bool // use high compression (only for the Writer) + done bool // whether the descriptor was processed (Read or Write and checked) + // Removed as not supported + // Dict bool // a dictionary id is to be used + // DictID uint32 // the dictionary id read from the frame, if any. +} + +// xxhPool wraps the standard pool for xxHash items. +// Putting items back in the pool automatically resets them. +type xxhPool struct { + sync.Pool +} + +func (p *xxhPool) Get() hash.Hash32 { + return p.Pool.Get().(hash.Hash32) +} + +func (p *xxhPool) Put(h hash.Hash32) { + h.Reset() + p.Pool.Put(h) +} + +// hashPool is used by readers and writers and contains xxHash items. +var hashPool = xxhPool{ + Pool: sync.Pool{ + New: func() interface{} { return xxHash32.New(0) }, + }, +} diff --git a/vendor/github.com/pierrec/lz4/reader.go b/vendor/github.com/pierrec/lz4/reader.go new file mode 100644 index 00000000..9f7fd604 --- /dev/null +++ b/vendor/github.com/pierrec/lz4/reader.go @@ -0,0 +1,364 @@ +package lz4 + +import ( + "encoding/binary" + "errors" + "fmt" + "hash" + "io" + "io/ioutil" + "runtime" + "sync" + "sync/atomic" +) + +// ErrInvalid is returned when the data being read is not an LZ4 archive +// (LZ4 magic number detection failed). +var ErrInvalid = errors.New("invalid lz4 data") + +// errEndOfBlock is returned by readBlock when it has reached the last block of the frame. +// It is not an error. +var errEndOfBlock = errors.New("end of block") + +// Reader implements the LZ4 frame decoder. +// The Header is set after the first call to Read(). +// The Header may change between Read() calls in case of concatenated frames. +type Reader struct { + Pos int64 // position within the source + Header + src io.Reader + checksum hash.Hash32 // frame hash + wg sync.WaitGroup // decompressing go routine wait group + data []byte // buffered decompressed data + window []byte // 64Kb decompressed data window +} + +// NewReader returns a new LZ4 frame decoder. +// No access to the underlying io.Reader is performed. +func NewReader(src io.Reader) *Reader { + return &Reader{ + src: src, + checksum: hashPool.Get(), + } +} + +// readHeader checks the frame magic number and parses the frame descriptoz. +// Skippable frames are supported even as a first frame although the LZ4 +// specifications recommends skippable frames not to be used as first frames. +func (z *Reader) readHeader(first bool) error { + defer z.checksum.Reset() + + for { + var magic uint32 + if err := binary.Read(z.src, binary.LittleEndian, &magic); err != nil { + if !first && err == io.ErrUnexpectedEOF { + return io.EOF + } + return err + } + z.Pos += 4 + if magic>>8 == frameSkipMagic>>8 { + var skipSize uint32 + if err := binary.Read(z.src, binary.LittleEndian, &skipSize); err != nil { + return err + } + z.Pos += 4 + m, err := io.CopyN(ioutil.Discard, z.src, int64(skipSize)) + z.Pos += m + if err != nil { + return err + } + continue + } + if magic != frameMagic { + return ErrInvalid + } + break + } + + // header + var buf [8]byte + if _, err := io.ReadFull(z.src, buf[:2]); err != nil { + return err + } + z.Pos += 2 + + b := buf[0] + if b>>6 != Version { + return fmt.Errorf("lz4.Read: invalid version: got %d expected %d", b>>6, Version) + } + z.BlockDependency = b>>5&1 == 0 + z.BlockChecksum = b>>4&1 > 0 + frameSize := b>>3&1 > 0 + z.NoChecksum = b>>2&1 == 0 + // z.Dict = b&1 > 0 + + bmsID := buf[1] >> 4 & 0x7 + bSize, ok := bsMapID[bmsID] + if !ok { + return fmt.Errorf("lz4.Read: invalid block max size: %d", bmsID) + } + z.BlockMaxSize = bSize + + z.checksum.Write(buf[0:2]) + + if frameSize { + if err := binary.Read(z.src, binary.LittleEndian, &z.Size); err != nil { + return err + } + z.Pos += 8 + binary.LittleEndian.PutUint64(buf[:], z.Size) + z.checksum.Write(buf[0:8]) + } + + // if z.Dict { + // if err := binary.Read(z.src, binary.LittleEndian, &z.DictID); err != nil { + // return err + // } + // z.Pos += 4 + // binary.LittleEndian.PutUint32(buf[:], z.DictID) + // z.checksum.Write(buf[0:4]) + // } + + // header checksum + if _, err := io.ReadFull(z.src, buf[:1]); err != nil { + return err + } + z.Pos++ + if h := byte(z.checksum.Sum32() >> 8 & 0xFF); h != buf[0] { + return fmt.Errorf("lz4.Read: invalid header checksum: got %v expected %v", buf[0], h) + } + + z.Header.done = true + + return nil +} + +// Read decompresses data from the underlying source into the supplied buffer. +// +// Since there can be multiple streams concatenated, Header values may +// change between calls to Read(). If that is the case, no data is actually read from +// the underlying io.Reader, to allow for potential input buffer resizing. +// +// Data is buffered if the input buffer is too small, and exhausted upon successive calls. +// +// If the buffer is large enough (typically in multiples of BlockMaxSize) and there is +// no block dependency, then the data will be decompressed concurrently based on the GOMAXPROCS value. +func (z *Reader) Read(buf []byte) (n int, err error) { + if !z.Header.done { + if err = z.readHeader(true); err != nil { + return + } + } + + if len(buf) == 0 { + return + } + + // exhaust remaining data from previous Read() + if len(z.data) > 0 { + n = copy(buf, z.data) + z.data = z.data[n:] + if len(z.data) == 0 { + z.data = nil + } + return + } + + // Break up the input buffer into BlockMaxSize blocks with at least one block. + // Then decompress into each of them concurrently if possible (no dependency). + // In case of dependency, the first block will be missing the window (except on the + // very first call), the rest will have it already since it comes from the previous block. + wbuf := buf + zn := (len(wbuf) + z.BlockMaxSize - 1) / z.BlockMaxSize + zblocks := make([]block, zn) + for zi, abort := 0, uint32(0); zi < zn && atomic.LoadUint32(&abort) == 0; zi++ { + zb := &zblocks[zi] + // last block may be too small + if len(wbuf) < z.BlockMaxSize+len(z.window) { + wbuf = make([]byte, z.BlockMaxSize+len(z.window)) + } + copy(wbuf, z.window) + if zb.err = z.readBlock(wbuf, zb); zb.err != nil { + break + } + wbuf = wbuf[z.BlockMaxSize:] + if !z.BlockDependency { + z.wg.Add(1) + go z.decompressBlock(zb, &abort) + continue + } + // cannot decompress concurrently when dealing with block dependency + z.decompressBlock(zb, nil) + // the last block may not contain enough data + if len(z.window) == 0 { + z.window = make([]byte, winSize) + } + if len(zb.data) >= winSize { + copy(z.window, zb.data[len(zb.data)-winSize:]) + } else { + copy(z.window, z.window[len(zb.data):]) + copy(z.window[len(zb.data)+1:], zb.data) + } + } + z.wg.Wait() + + // since a block size may be less then BlockMaxSize, trim the decompressed buffers + for _, zb := range zblocks { + if zb.err != nil { + if zb.err == errEndOfBlock { + return n, z.close() + } + return n, zb.err + } + bLen := len(zb.data) + if !z.NoChecksum { + z.checksum.Write(zb.data) + } + m := copy(buf[n:], zb.data) + // buffer the remaining data (this is necessarily the last block) + if m < bLen { + z.data = zb.data[m:] + } + n += m + } + + return +} + +// readBlock reads an entire frame block from the frame. +// The input buffer is the one that will receive the decompressed data. +// If the end of the frame is detected, it returns the errEndOfBlock error. +func (z *Reader) readBlock(buf []byte, b *block) error { + var bLen uint32 + if err := binary.Read(z.src, binary.LittleEndian, &bLen); err != nil { + return err + } + atomic.AddInt64(&z.Pos, 4) + + switch { + case bLen == 0: + return errEndOfBlock + case bLen&(1<<31) == 0: + b.compressed = true + b.data = buf + b.zdata = make([]byte, bLen) + default: + bLen = bLen & (1<<31 - 1) + if int(bLen) > len(buf) { + return fmt.Errorf("lz4.Read: invalid block size: %d", bLen) + } + b.data = buf[:bLen] + b.zdata = buf[:bLen] + } + if _, err := io.ReadFull(z.src, b.zdata); err != nil { + return err + } + + if z.BlockChecksum { + if err := binary.Read(z.src, binary.LittleEndian, &b.checksum); err != nil { + return err + } + xxh := hashPool.Get() + defer hashPool.Put(xxh) + xxh.Write(b.zdata) + if h := xxh.Sum32(); h != b.checksum { + return fmt.Errorf("lz4.Read: invalid block checksum: got %x expected %x", h, b.checksum) + } + } + + return nil +} + +// decompressBlock decompresses a frame block. +// In case of an error, the block err is set with it and abort is set to 1. +func (z *Reader) decompressBlock(b *block, abort *uint32) { + if abort != nil { + defer z.wg.Done() + } + if b.compressed { + n := len(z.window) + m, err := UncompressBlock(b.zdata, b.data, n) + if err != nil { + if abort != nil { + atomic.StoreUint32(abort, 1) + } + b.err = err + return + } + b.data = b.data[n : n+m] + } + atomic.AddInt64(&z.Pos, int64(len(b.data))) +} + +// close validates the frame checksum (if any) and checks the next frame (if any). +func (z *Reader) close() error { + if !z.NoChecksum { + var checksum uint32 + if err := binary.Read(z.src, binary.LittleEndian, &checksum); err != nil { + return err + } + if checksum != z.checksum.Sum32() { + return fmt.Errorf("lz4.Read: invalid frame checksum: got %x expected %x", z.checksum.Sum32(), checksum) + } + } + + // get ready for the next concatenated frame, but do not change the position + pos := z.Pos + z.Reset(z.src) + z.Pos = pos + + // since multiple frames can be concatenated, check for another one + return z.readHeader(false) +} + +// Reset discards the Reader's state and makes it equivalent to the +// result of its original state from NewReader, but reading from r instead. +// This permits reusing a Reader rather than allocating a new one. +func (z *Reader) Reset(r io.Reader) { + z.Header = Header{} + z.Pos = 0 + z.src = r + z.checksum.Reset() + z.data = nil + z.window = nil +} + +// WriteTo decompresses the data from the underlying io.Reader and writes it to the io.Writer. +// Returns the number of bytes written. +func (z *Reader) WriteTo(w io.Writer) (n int64, err error) { + cpus := runtime.GOMAXPROCS(0) + var buf []byte + + // The initial buffer being nil, the first Read will be only read the compressed frame options. + // The buffer can then be sized appropriately to support maximum concurrency decompression. + // If multiple frames are concatenated, Read() will return with no data decompressed but with + // potentially changed options. The buffer will be resized accordingly, always trying to + // maximize concurrency. + for { + nsize := 0 + // the block max size can change if multiple streams are concatenated. + // Check it after every Read(). + if z.BlockDependency { + // in case of dependency, we cannot decompress concurrently, + // so allocate the minimum buffer + window size + nsize = len(z.window) + z.BlockMaxSize + } else { + // if no dependency, allocate a buffer large enough for concurrent decompression + nsize = cpus * z.BlockMaxSize + } + if nsize != len(buf) { + buf = make([]byte, nsize) + } + + m, er := z.Read(buf) + if er != nil && er != io.EOF { + return n, er + } + m, err = w.Write(buf[:m]) + n += int64(m) + if err != nil || er == io.EOF { + return + } + } +} diff --git a/vendor/github.com/pierrec/lz4/writer.go b/vendor/github.com/pierrec/lz4/writer.go new file mode 100644 index 00000000..11082f5a --- /dev/null +++ b/vendor/github.com/pierrec/lz4/writer.go @@ -0,0 +1,383 @@ +package lz4 + +import ( + "encoding/binary" + "fmt" + "hash" + "io" + "runtime" +) + +// Writer implements the LZ4 frame encoder. +type Writer struct { + Header + dst io.Writer + checksum hash.Hash32 // frame checksum + data []byte // data to be compressed, only used when dealing with block dependency as we need 64Kb to work with + window []byte // last 64KB of decompressed data (block dependency) + blockMaxSize buffer + + zbCompressBuf []byte // buffer for compressing lz4 blocks + writeSizeBuf []byte // four-byte slice for writing checksums and sizes in writeblock + hashTable []hashEntry + currentGeneration uint +} + +// NewWriter returns a new LZ4 frame encoder. +// No access to the underlying io.Writer is performed. +// The supplied Header is checked at the first Write. +// It is ok to change it before the first Write but then not until a Reset() is performed. +func NewWriter(dst io.Writer) *Writer { + return &Writer{ + dst: dst, + checksum: hashPool.Get(), + Header: Header{ + BlockMaxSize: 4 << 20, + }, + hashTable: make([]hashEntry, hashTableSize), + writeSizeBuf: make([]byte, 4), + } +} + +// writeHeader builds and writes the header (magic+header) to the underlying io.Writer. +func (z *Writer) writeHeader() error { + // Default to 4Mb if BlockMaxSize is not set + if z.Header.BlockMaxSize == 0 { + z.Header.BlockMaxSize = 4 << 20 + } + // the only option that need to be validated + bSize, ok := bsMapValue[z.Header.BlockMaxSize] + if !ok { + return fmt.Errorf("lz4: invalid block max size: %d", z.Header.BlockMaxSize) + } + + // magic number(4) + header(flags(2)+[Size(8)+DictID(4)]+checksum(1)) does not exceed 19 bytes + // Size and DictID are optional + var buf [19]byte + + // set the fixed size data: magic number, block max size and flags + binary.LittleEndian.PutUint32(buf[0:], frameMagic) + flg := byte(Version << 6) + if !z.Header.BlockDependency { + flg |= 1 << 5 + } + if z.Header.BlockChecksum { + flg |= 1 << 4 + } + if z.Header.Size > 0 { + flg |= 1 << 3 + } + if !z.Header.NoChecksum { + flg |= 1 << 2 + } + // if z.Header.Dict { + // flg |= 1 + // } + buf[4] = flg + buf[5] = bSize << 4 + + // current buffer size: magic(4) + flags(1) + block max size (1) + n := 6 + // optional items + if z.Header.Size > 0 { + binary.LittleEndian.PutUint64(buf[n:], z.Header.Size) + n += 8 + } + // if z.Header.Dict { + // binary.LittleEndian.PutUint32(buf[n:], z.Header.DictID) + // n += 4 + // } + + // header checksum includes the flags, block max size and optional Size and DictID + z.checksum.Write(buf[4:n]) + buf[n] = byte(z.checksum.Sum32() >> 8 & 0xFF) + z.checksum.Reset() + + // header ready, write it out + if _, err := z.dst.Write(buf[0 : n+1]); err != nil { + return err + } + z.Header.done = true + + // initialize buffers dependent on header info + z.zbCompressBuf = make([]byte, winSize+z.BlockMaxSize) + + return nil +} + +// Write compresses data from the supplied buffer into the underlying io.Writer. +// Write does not return until the data has been written. +// +// If the input buffer is large enough (typically in multiples of BlockMaxSize) +// the data will be compressed concurrently. +// +// Write never buffers any data unless in BlockDependency mode where it may +// do so until it has 64Kb of data, after which it never buffers any. +func (z *Writer) Write(buf []byte) (n int, err error) { + if !z.Header.done { + if err = z.writeHeader(); err != nil { + return + } + } + + if len(buf) == 0 { + return + } + + if !z.NoChecksum { + z.checksum.Write(buf) + } + + // with block dependency, require at least 64Kb of data to work with + // not having 64Kb only matters initially to setup the first window + bl := 0 + if z.BlockDependency && len(z.window) == 0 { + bl = len(z.data) + z.data = append(z.data, buf...) + if len(z.data) < winSize { + return len(buf), nil + } + buf = z.data + z.data = nil + } + + // Break up the input buffer into BlockMaxSize blocks, provisioning the left over block. + // Then compress into each of them concurrently if possible (no dependency). + var ( + zb block + wbuf = buf + zn = len(wbuf) / z.BlockMaxSize + zi = 0 + leftover = len(buf) % z.BlockMaxSize + ) + +loop: + for zi < zn { + if z.BlockDependency { + if zi == 0 { + // first block does not have the window + zb.data = append(z.window, wbuf[:z.BlockMaxSize]...) + zb.offset = len(z.window) + wbuf = wbuf[z.BlockMaxSize-winSize:] + } else { + // set the uncompressed data including the window from previous block + zb.data = wbuf[:z.BlockMaxSize+winSize] + zb.offset = winSize + wbuf = wbuf[z.BlockMaxSize:] + } + } else { + zb.data = wbuf[:z.BlockMaxSize] + wbuf = wbuf[z.BlockMaxSize:] + } + + goto write + } + + // left over + if leftover > 0 { + zb = block{data: wbuf} + if z.BlockDependency { + if zn == 0 { + zb.data = append(z.window, zb.data...) + zb.offset = len(z.window) + } else { + zb.offset = winSize + } + } + + leftover = 0 + goto write + } + + if z.BlockDependency { + if len(z.window) == 0 { + z.window = make([]byte, winSize) + } + // last buffer may be shorter than the window + if len(buf) >= winSize { + copy(z.window, buf[len(buf)-winSize:]) + } else { + copy(z.window, z.window[len(buf):]) + copy(z.window[len(buf)+1:], buf) + } + } + + return + +write: + zb = z.compressBlock(zb) + _, err = z.writeBlock(zb) + + written := len(zb.data) + if bl > 0 { + if written >= bl { + written -= bl + bl = 0 + } else { + bl -= written + written = 0 + } + } + + n += written + // remove the window in zb.data + if z.BlockDependency { + if zi == 0 { + n -= len(z.window) + } else { + n -= winSize + } + } + if err != nil { + return + } + zi++ + goto loop +} + +// compressBlock compresses a block. +func (z *Writer) compressBlock(zb block) block { + // compressed block size cannot exceed the input's + var ( + n int + err error + zbuf = z.zbCompressBuf + ) + if z.HighCompression { + n, err = CompressBlockHC(zb.data, zbuf, zb.offset) + } else { + n, err = compressGenerationalBlock(zb.data, zbuf, zb.offset, z.currentGeneration, z.hashTable) + z.currentGeneration++ + if z.currentGeneration == 0 { // wrapped around, reset table + z.hashTable = make([]hashEntry, hashTableSize) + } + } + + // compressible and compressed size smaller than decompressed: ok! + if err == nil && n > 0 && len(zb.zdata) < len(zb.data) { + zb.compressed = true + zb.zdata = zbuf[:n] + } else { + zb.zdata = zb.data[zb.offset:] + } + + if z.BlockChecksum { + xxh := hashPool.Get() + xxh.Write(zb.zdata) + zb.checksum = xxh.Sum32() + hashPool.Put(xxh) + } + + return zb +} + +// writeBlock writes a frame block to the underlying io.Writer (size, data). +func (z *Writer) writeBlock(zb block) (int, error) { + bLen := uint32(len(zb.zdata)) + if !zb.compressed { + bLen |= 1 << 31 + } + + n := 0 + + binary.LittleEndian.PutUint32(z.writeSizeBuf, bLen) + n, err := z.dst.Write(z.writeSizeBuf) + if err != nil { + return n, err + } + + m, err := z.dst.Write(zb.zdata) + n += m + if err != nil { + return n, err + } + + if z.BlockChecksum { + binary.LittleEndian.PutUint32(z.writeSizeBuf, zb.checksum) + m, err := z.dst.Write(z.writeSizeBuf) + n += m + + if err != nil { + return n, err + } + } + + return n, nil +} + +// Flush flushes any pending compressed data to the underlying writer. +// Flush does not return until the data has been written. +// If the underlying writer returns an error, Flush returns that error. +// +// Flush is only required when in BlockDependency mode and the total of +// data written is less than 64Kb. +func (z *Writer) Flush() error { + if len(z.data) == 0 { + return nil + } + + zb := z.compressBlock(block{data: z.data}) + if _, err := z.writeBlock(zb); err != nil { + return err + } + return nil +} + +// Close closes the Writer, flushing any unwritten data to the underlying io.Writer, but does not close the underlying io.Writer. +func (z *Writer) Close() error { + if !z.Header.done { + if err := z.writeHeader(); err != nil { + return err + } + } + + // buffered data for the block dependency window + if z.BlockDependency && len(z.data) > 0 { + zb := block{data: z.data} + if _, err := z.writeBlock(z.compressBlock(zb)); err != nil { + return err + } + } + + if err := binary.Write(z.dst, binary.LittleEndian, uint32(0)); err != nil { + return err + } + if !z.NoChecksum { + if err := binary.Write(z.dst, binary.LittleEndian, z.checksum.Sum32()); err != nil { + return err + } + } + return nil +} + +// Reset clears the state of the Writer z such that it is equivalent to its +// initial state from NewWriter, but instead writing to w. +// No access to the underlying io.Writer is performed. +func (z *Writer) Reset(w io.Writer) { + z.Header = Header{} + z.dst = w + z.checksum.Reset() + z.data = nil + z.window = nil +} + +// ReadFrom compresses the data read from the io.Reader and writes it to the underlying io.Writer. +// Returns the number of bytes read. +// It does not close the Writer. +func (z *Writer) ReadFrom(r io.Reader) (n int64, err error) { + cpus := runtime.GOMAXPROCS(0) + buf := make([]byte, cpus*z.BlockMaxSize) + for { + m, er := io.ReadFull(r, buf) + n += int64(m) + if er == nil || er == io.ErrUnexpectedEOF || er == io.EOF { + if _, err = z.Write(buf[:m]); err != nil { + return + } + if er == nil { + continue + } + return + } + return n, er + } +} diff --git a/vendor/github.com/pierrec/xxHash/LICENSE b/vendor/github.com/pierrec/xxHash/LICENSE new file mode 100644 index 00000000..c1418f3f --- /dev/null +++ b/vendor/github.com/pierrec/xxHash/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2014, Pierre Curto +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of xxHash nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + diff --git a/vendor/github.com/pierrec/xxHash/xxHash32/xxHash32.go b/vendor/github.com/pierrec/xxHash/xxHash32/xxHash32.go new file mode 100644 index 00000000..411504e4 --- /dev/null +++ b/vendor/github.com/pierrec/xxHash/xxHash32/xxHash32.go @@ -0,0 +1,205 @@ +// Package xxHash32 implements the very fast xxHash hashing algorithm (32 bits version). +// (https://github.com/Cyan4973/xxHash/) +package xxHash32 + +import "hash" + +const ( + prime32_1 = 2654435761 + prime32_2 = 2246822519 + prime32_3 = 3266489917 + prime32_4 = 668265263 + prime32_5 = 374761393 +) + +type xxHash struct { + seed uint32 + v1 uint32 + v2 uint32 + v3 uint32 + v4 uint32 + totalLen uint64 + buf [16]byte + bufused int +} + +// New returns a new Hash32 instance. +func New(seed uint32) hash.Hash32 { + xxh := &xxHash{seed: seed} + xxh.Reset() + return xxh +} + +// Sum appends the current hash to b and returns the resulting slice. +// It does not change the underlying hash state. +func (xxh xxHash) Sum(b []byte) []byte { + h32 := xxh.Sum32() + return append(b, byte(h32), byte(h32>>8), byte(h32>>16), byte(h32>>24)) +} + +// Reset resets the Hash to its initial state. +func (xxh *xxHash) Reset() { + xxh.v1 = xxh.seed + prime32_1 + prime32_2 + xxh.v2 = xxh.seed + prime32_2 + xxh.v3 = xxh.seed + xxh.v4 = xxh.seed - prime32_1 + xxh.totalLen = 0 + xxh.bufused = 0 +} + +// Size returns the number of bytes returned by Sum(). +func (xxh *xxHash) Size() int { + return 4 +} + +// BlockSize gives the minimum number of bytes accepted by Write(). +func (xxh *xxHash) BlockSize() int { + return 1 +} + +// Write adds input bytes to the Hash. +// It never returns an error. +func (xxh *xxHash) Write(input []byte) (int, error) { + n := len(input) + m := xxh.bufused + + xxh.totalLen += uint64(n) + + r := len(xxh.buf) - m + if n < r { + copy(xxh.buf[m:], input) + xxh.bufused += len(input) + return n, nil + } + + p := 0 + if m > 0 { + // some data left from previous update + copy(xxh.buf[xxh.bufused:], input[:r]) + xxh.bufused += len(input) - r + + // fast rotl(13) + p32 := xxh.v1 + (uint32(xxh.buf[p+3])<<24|uint32(xxh.buf[p+2])<<16|uint32(xxh.buf[p+1])<<8|uint32(xxh.buf[p]))*prime32_2 + xxh.v1 = (p32<<13 | p32>>19) * prime32_1 + p += 4 + p32 = xxh.v2 + (uint32(xxh.buf[p+3])<<24|uint32(xxh.buf[p+2])<<16|uint32(xxh.buf[p+1])<<8|uint32(xxh.buf[p]))*prime32_2 + xxh.v2 = (p32<<13 | p32>>19) * prime32_1 + p += 4 + p32 = xxh.v3 + (uint32(xxh.buf[p+3])<<24|uint32(xxh.buf[p+2])<<16|uint32(xxh.buf[p+1])<<8|uint32(xxh.buf[p]))*prime32_2 + xxh.v3 = (p32<<13 | p32>>19) * prime32_1 + p += 4 + p32 = xxh.v4 + (uint32(xxh.buf[p+3])<<24|uint32(xxh.buf[p+2])<<16|uint32(xxh.buf[p+1])<<8|uint32(xxh.buf[p]))*prime32_2 + xxh.v4 = (p32<<13 | p32>>19) * prime32_1 + + p = r + xxh.bufused = 0 + } + + for n := n - 16; p <= n; { + p32 := xxh.v1 + (uint32(input[p+3])<<24|uint32(input[p+2])<<16|uint32(input[p+1])<<8|uint32(input[p]))*prime32_2 + xxh.v1 = (p32<<13 | p32>>19) * prime32_1 + p += 4 + p32 = xxh.v2 + (uint32(input[p+3])<<24|uint32(input[p+2])<<16|uint32(input[p+1])<<8|uint32(input[p]))*prime32_2 + xxh.v2 = (p32<<13 | p32>>19) * prime32_1 + p += 4 + p32 = xxh.v3 + (uint32(input[p+3])<<24|uint32(input[p+2])<<16|uint32(input[p+1])<<8|uint32(input[p]))*prime32_2 + xxh.v3 = (p32<<13 | p32>>19) * prime32_1 + p += 4 + p32 = xxh.v4 + (uint32(input[p+3])<<24|uint32(input[p+2])<<16|uint32(input[p+1])<<8|uint32(input[p]))*prime32_2 + xxh.v4 = (p32<<13 | p32>>19) * prime32_1 + p += 4 + } + + copy(xxh.buf[xxh.bufused:], input[p:]) + xxh.bufused += len(input) - p + + return n, nil +} + +// Sum32 returns the 32 bits Hash value. +func (xxh *xxHash) Sum32() uint32 { + h32 := uint32(xxh.totalLen) + if xxh.totalLen >= 16 { + h32 += ((xxh.v1 << 1) | (xxh.v1 >> 31)) + + ((xxh.v2 << 7) | (xxh.v2 >> 25)) + + ((xxh.v3 << 12) | (xxh.v3 >> 20)) + + ((xxh.v4 << 18) | (xxh.v4 >> 14)) + } else { + h32 += xxh.seed + prime32_5 + } + + p := 0 + n := xxh.bufused + for n := n - 4; p <= n; p += 4 { + h32 += (uint32(xxh.buf[p+3])<<24 | uint32(xxh.buf[p+2])<<16 | uint32(xxh.buf[p+1])<<8 | uint32(xxh.buf[p])) * prime32_3 + h32 = ((h32 << 17) | (h32 >> 15)) * prime32_4 + } + for ; p < n; p++ { + h32 += uint32(xxh.buf[p]) * prime32_5 + h32 = ((h32 << 11) | (h32 >> 21)) * prime32_1 + } + + h32 ^= h32 >> 15 + h32 *= prime32_2 + h32 ^= h32 >> 13 + h32 *= prime32_3 + h32 ^= h32 >> 16 + + return h32 +} + +// Checksum returns the 32bits Hash value. +func Checksum(input []byte, seed uint32) uint32 { + n := len(input) + h32 := uint32(n) + + if n < 16 { + h32 += seed + prime32_5 + } else { + v1 := seed + prime32_1 + prime32_2 + v2 := seed + prime32_2 + v3 := seed + v4 := seed - prime32_1 + p := 0 + for p <= n-16 { + v1 += (uint32(input[p+3])<<24 | uint32(input[p+2])<<16 | uint32(input[p+1])<<8 | uint32(input[p])) * prime32_2 + v1 = (v1<<13 | v1>>19) * prime32_1 + p += 4 + v2 += (uint32(input[p+3])<<24 | uint32(input[p+2])<<16 | uint32(input[p+1])<<8 | uint32(input[p])) * prime32_2 + v2 = (v2<<13 | v2>>19) * prime32_1 + p += 4 + v3 += (uint32(input[p+3])<<24 | uint32(input[p+2])<<16 | uint32(input[p+1])<<8 | uint32(input[p])) * prime32_2 + v3 = (v3<<13 | v3>>19) * prime32_1 + p += 4 + v4 += (uint32(input[p+3])<<24 | uint32(input[p+2])<<16 | uint32(input[p+1])<<8 | uint32(input[p])) * prime32_2 + v4 = (v4<<13 | v4>>19) * prime32_1 + p += 4 + } + input = input[p:] + n -= p + h32 += ((v1 << 1) | (v1 >> 31)) + + ((v2 << 7) | (v2 >> 25)) + + ((v3 << 12) | (v3 >> 20)) + + ((v4 << 18) | (v4 >> 14)) + } + + p := 0 + for p <= n-4 { + h32 += (uint32(input[p+3])<<24 | uint32(input[p+2])<<16 | uint32(input[p+1])<<8 | uint32(input[p])) * prime32_3 + h32 = ((h32 << 17) | (h32 >> 15)) * prime32_4 + p += 4 + } + for p < n { + h32 += uint32(input[p]) * prime32_5 + h32 = ((h32 << 11) | (h32 >> 21)) * prime32_1 + p++ + } + + h32 ^= h32 >> 15 + h32 *= prime32_2 + h32 ^= h32 >> 13 + h32 *= prime32_3 + h32 ^= h32 >> 16 + + return h32 +} diff --git a/vendor/github.com/raintank/metrictank/LICENSE b/vendor/github.com/raintank/metrictank/LICENSE new file mode 100644 index 00000000..dba13ed2 --- /dev/null +++ b/vendor/github.com/raintank/metrictank/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU AGPL, see +. diff --git a/vendor/github.com/raintank/metrictank/NOTICE b/vendor/github.com/raintank/metrictank/NOTICE new file mode 100644 index 00000000..8002a802 --- /dev/null +++ b/vendor/github.com/raintank/metrictank/NOTICE @@ -0,0 +1,15 @@ +Copyright 2016 Dieter Plaetinck, Anthony Woods, Jeremy Bingham, Damian Gryski, raintank inc + + +Metrictank is free software: you can redistribute it and/or modify +it under the terms of the GNU Affero General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +metrictank is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU Affero General Public License for more details. + +You should have received a copy of the GNU General Public License +along with metrictank. If not, see . diff --git a/vendor/github.com/raintank/metrictank/cluster/partitioner/partitioner.go b/vendor/github.com/raintank/metrictank/cluster/partitioner/partitioner.go new file mode 100644 index 00000000..75a2329d --- /dev/null +++ b/vendor/github.com/raintank/metrictank/cluster/partitioner/partitioner.go @@ -0,0 +1,52 @@ +package partitioner + +import ( + "fmt" + + "github.com/Shopify/sarama" + "gopkg.in/raintank/schema.v1" +) + +type Partitioner interface { + Partition(schema.PartitionedMetric, int32) (int32, error) +} + +type Kafka struct { + PartitionBy string + Partitioner sarama.Partitioner +} + +func NewKafka(partitionBy string) (*Kafka, error) { + switch partitionBy { + case "byOrg": + case "bySeries": + default: + return nil, fmt.Errorf("partitionBy must be one of 'byOrg|bySeries'. got %s", partitionBy) + } + return &Kafka{ + PartitionBy: partitionBy, + Partitioner: sarama.NewHashPartitioner(""), + }, nil +} + +func (k *Kafka) Partition(m schema.PartitionedMetric, numPartitions int32) (int32, error) { + key, err := k.GetPartitionKey(m, nil) + if err != nil { + return 0, err + } + return k.Partitioner.Partition(&sarama.ProducerMessage{Key: sarama.ByteEncoder(key)}, numPartitions) +} + +func (k *Kafka) GetPartitionKey(m schema.PartitionedMetric, b []byte) ([]byte, error) { + switch k.PartitionBy { + case "byOrg": + // partition by organisation: metrics for the same org should go to the same + // partition/MetricTank (optimize for locality~performance) + return m.KeyByOrgId(b), nil + case "bySeries": + // partition by series: metrics are distrubted across all metrictank instances + // to allow horizontal scalability + return m.KeyBySeries(b), nil + } + return b, fmt.Errorf("unkown partitionBy setting.") +} diff --git a/vendor/github.com/rcrowley/go-metrics/LICENSE b/vendor/github.com/rcrowley/go-metrics/LICENSE new file mode 100644 index 00000000..363fa9ee --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/LICENSE @@ -0,0 +1,29 @@ +Copyright 2012 Richard Crowley. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + +THIS SOFTWARE IS PROVIDED BY RICHARD CROWLEY ``AS IS'' AND ANY EXPRESS +OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL RICHARD CROWLEY OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation +are those of the authors and should not be interpreted as representing +official policies, either expressed or implied, of Richard Crowley. diff --git a/vendor/github.com/rcrowley/go-metrics/README.md b/vendor/github.com/rcrowley/go-metrics/README.md new file mode 100644 index 00000000..d801aa4f --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/README.md @@ -0,0 +1,117 @@ +go-metrics +========== + +Go port of Coda Hale's Metrics library: . + +Documentation: . + +Usage +----- + +Create and update metrics: + +```go +c := metrics.NewCounter() +metrics.Register("foo", c) +c.Inc(47) + +g := metrics.NewGauge() +metrics.Register("bar", g) +g.Update(47) + +s := metrics.NewExpDecaySample(1028, 0.015) // or metrics.NewUniformSample(1028) +h := metrics.NewHistogram(s) +metrics.Register("baz", h) +h.Update(47) + +m := metrics.NewMeter() +metrics.Register("quux", m) +m.Mark(47) + +t := metrics.NewTimer() +metrics.Register("bang", t) +t.Time(func() {}) +t.Update(47) +``` + +Periodically log every metric in human-readable form to standard error: + +```go +go metrics.Log(metrics.DefaultRegistry, 60e9, log.New(os.Stderr, "metrics: ", log.Lmicroseconds)) +``` + +Periodically log every metric in slightly-more-parseable form to syslog: + +```go +w, _ := syslog.Dial("unixgram", "/dev/log", syslog.LOG_INFO, "metrics") +go metrics.Syslog(metrics.DefaultRegistry, 60e9, w) +``` + +Periodically emit every metric to Graphite: + +```go +addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:2003") +go metrics.Graphite(metrics.DefaultRegistry, 10e9, "metrics", addr) +``` + +Periodically emit every metric into InfluxDB: + +```go +import "github.com/rcrowley/go-metrics/influxdb" + +go influxdb.Influxdb(metrics.DefaultRegistry, 10e9, &influxdb.Config{ + Host: "127.0.0.1:8086", + Database: "metrics", + Username: "test", + Password: "test", +}) +``` + +Periodically upload every metric to Librato: + +```go +import "github.com/rcrowley/go-metrics/librato" + +go librato.Librato(metrics.DefaultRegistry, + 10e9, // interval + "example@example.com", // account owner email address + "token", // Librato API token + "hostname", // source + []float64{0.95}, // precentiles to send + time.Millisecond, // time unit +) +``` + +Periodically emit every metric to StatHat: + +```go +import "github.com/rcrowley/go-metrics/stathat" + +go stathat.Stathat(metrics.DefaultRegistry, 10e9, "example@example.com") +``` + +Maintain all metrics along with expvars at `/debug/metrics`: + +This uses the same mechanism as [the official expvar](http://golang.org/pkg/expvar/) +but exposed under `/debug/metrics`, which shows a json representation of all your usual expvars +as well as all your go-metrics. + + +```go +import "github.com/rcrowley/go-metrics/exp" + +exp.Exp(metrics.DefaultRegistry) +``` + +Installation +------------ + +```sh +go get github.com/rcrowley/go-metrics +``` + +StatHat support additionally requires their Go client: + +```sh +go get github.com/stathat/go +``` diff --git a/vendor/github.com/rcrowley/go-metrics/counter.go b/vendor/github.com/rcrowley/go-metrics/counter.go new file mode 100644 index 00000000..bb7b039c --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/counter.go @@ -0,0 +1,112 @@ +package metrics + +import "sync/atomic" + +// Counters hold an int64 value that can be incremented and decremented. +type Counter interface { + Clear() + Count() int64 + Dec(int64) + Inc(int64) + Snapshot() Counter +} + +// GetOrRegisterCounter returns an existing Counter or constructs and registers +// a new StandardCounter. +func GetOrRegisterCounter(name string, r Registry) Counter { + if nil == r { + r = DefaultRegistry + } + return r.GetOrRegister(name, NewCounter).(Counter) +} + +// NewCounter constructs a new StandardCounter. +func NewCounter() Counter { + if UseNilMetrics { + return NilCounter{} + } + return &StandardCounter{0} +} + +// NewRegisteredCounter constructs and registers a new StandardCounter. +func NewRegisteredCounter(name string, r Registry) Counter { + c := NewCounter() + if nil == r { + r = DefaultRegistry + } + r.Register(name, c) + return c +} + +// CounterSnapshot is a read-only copy of another Counter. +type CounterSnapshot int64 + +// Clear panics. +func (CounterSnapshot) Clear() { + panic("Clear called on a CounterSnapshot") +} + +// Count returns the count at the time the snapshot was taken. +func (c CounterSnapshot) Count() int64 { return int64(c) } + +// Dec panics. +func (CounterSnapshot) Dec(int64) { + panic("Dec called on a CounterSnapshot") +} + +// Inc panics. +func (CounterSnapshot) Inc(int64) { + panic("Inc called on a CounterSnapshot") +} + +// Snapshot returns the snapshot. +func (c CounterSnapshot) Snapshot() Counter { return c } + +// NilCounter is a no-op Counter. +type NilCounter struct{} + +// Clear is a no-op. +func (NilCounter) Clear() {} + +// Count is a no-op. +func (NilCounter) Count() int64 { return 0 } + +// Dec is a no-op. +func (NilCounter) Dec(i int64) {} + +// Inc is a no-op. +func (NilCounter) Inc(i int64) {} + +// Snapshot is a no-op. +func (NilCounter) Snapshot() Counter { return NilCounter{} } + +// StandardCounter is the standard implementation of a Counter and uses the +// sync/atomic package to manage a single int64 value. +type StandardCounter struct { + count int64 +} + +// Clear sets the counter to zero. +func (c *StandardCounter) Clear() { + atomic.StoreInt64(&c.count, 0) +} + +// Count returns the current count. +func (c *StandardCounter) Count() int64 { + return atomic.LoadInt64(&c.count) +} + +// Dec decrements the counter by the given amount. +func (c *StandardCounter) Dec(i int64) { + atomic.AddInt64(&c.count, -i) +} + +// Inc increments the counter by the given amount. +func (c *StandardCounter) Inc(i int64) { + atomic.AddInt64(&c.count, i) +} + +// Snapshot returns a read-only copy of the counter. +func (c *StandardCounter) Snapshot() Counter { + return CounterSnapshot(c.Count()) +} diff --git a/vendor/github.com/rcrowley/go-metrics/debug.go b/vendor/github.com/rcrowley/go-metrics/debug.go new file mode 100644 index 00000000..043ccefa --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/debug.go @@ -0,0 +1,76 @@ +package metrics + +import ( + "runtime/debug" + "time" +) + +var ( + debugMetrics struct { + GCStats struct { + LastGC Gauge + NumGC Gauge + Pause Histogram + //PauseQuantiles Histogram + PauseTotal Gauge + } + ReadGCStats Timer + } + gcStats debug.GCStats +) + +// Capture new values for the Go garbage collector statistics exported in +// debug.GCStats. This is designed to be called as a goroutine. +func CaptureDebugGCStats(r Registry, d time.Duration) { + for _ = range time.Tick(d) { + CaptureDebugGCStatsOnce(r) + } +} + +// Capture new values for the Go garbage collector statistics exported in +// debug.GCStats. This is designed to be called in a background goroutine. +// Giving a registry which has not been given to RegisterDebugGCStats will +// panic. +// +// Be careful (but much less so) with this because debug.ReadGCStats calls +// the C function runtime·lock(runtime·mheap) which, while not a stop-the-world +// operation, isn't something you want to be doing all the time. +func CaptureDebugGCStatsOnce(r Registry) { + lastGC := gcStats.LastGC + t := time.Now() + debug.ReadGCStats(&gcStats) + debugMetrics.ReadGCStats.UpdateSince(t) + + debugMetrics.GCStats.LastGC.Update(int64(gcStats.LastGC.UnixNano())) + debugMetrics.GCStats.NumGC.Update(int64(gcStats.NumGC)) + if lastGC != gcStats.LastGC && 0 < len(gcStats.Pause) { + debugMetrics.GCStats.Pause.Update(int64(gcStats.Pause[0])) + } + //debugMetrics.GCStats.PauseQuantiles.Update(gcStats.PauseQuantiles) + debugMetrics.GCStats.PauseTotal.Update(int64(gcStats.PauseTotal)) +} + +// Register metrics for the Go garbage collector statistics exported in +// debug.GCStats. The metrics are named by their fully-qualified Go symbols, +// i.e. debug.GCStats.PauseTotal. +func RegisterDebugGCStats(r Registry) { + debugMetrics.GCStats.LastGC = NewGauge() + debugMetrics.GCStats.NumGC = NewGauge() + debugMetrics.GCStats.Pause = NewHistogram(NewExpDecaySample(1028, 0.015)) + //debugMetrics.GCStats.PauseQuantiles = NewHistogram(NewExpDecaySample(1028, 0.015)) + debugMetrics.GCStats.PauseTotal = NewGauge() + debugMetrics.ReadGCStats = NewTimer() + + r.Register("debug.GCStats.LastGC", debugMetrics.GCStats.LastGC) + r.Register("debug.GCStats.NumGC", debugMetrics.GCStats.NumGC) + r.Register("debug.GCStats.Pause", debugMetrics.GCStats.Pause) + //r.Register("debug.GCStats.PauseQuantiles", debugMetrics.GCStats.PauseQuantiles) + r.Register("debug.GCStats.PauseTotal", debugMetrics.GCStats.PauseTotal) + r.Register("debug.ReadGCStats", debugMetrics.ReadGCStats) +} + +// Allocate an initial slice for gcStats.Pause to avoid allocations during +// normal operation. +func init() { + gcStats.Pause = make([]time.Duration, 11) +} diff --git a/vendor/github.com/rcrowley/go-metrics/ewma.go b/vendor/github.com/rcrowley/go-metrics/ewma.go new file mode 100644 index 00000000..7c152a17 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/ewma.go @@ -0,0 +1,118 @@ +package metrics + +import ( + "math" + "sync" + "sync/atomic" +) + +// EWMAs continuously calculate an exponentially-weighted moving average +// based on an outside source of clock ticks. +type EWMA interface { + Rate() float64 + Snapshot() EWMA + Tick() + Update(int64) +} + +// NewEWMA constructs a new EWMA with the given alpha. +func NewEWMA(alpha float64) EWMA { + if UseNilMetrics { + return NilEWMA{} + } + return &StandardEWMA{alpha: alpha} +} + +// NewEWMA1 constructs a new EWMA for a one-minute moving average. +func NewEWMA1() EWMA { + return NewEWMA(1 - math.Exp(-5.0/60.0/1)) +} + +// NewEWMA5 constructs a new EWMA for a five-minute moving average. +func NewEWMA5() EWMA { + return NewEWMA(1 - math.Exp(-5.0/60.0/5)) +} + +// NewEWMA15 constructs a new EWMA for a fifteen-minute moving average. +func NewEWMA15() EWMA { + return NewEWMA(1 - math.Exp(-5.0/60.0/15)) +} + +// EWMASnapshot is a read-only copy of another EWMA. +type EWMASnapshot float64 + +// Rate returns the rate of events per second at the time the snapshot was +// taken. +func (a EWMASnapshot) Rate() float64 { return float64(a) } + +// Snapshot returns the snapshot. +func (a EWMASnapshot) Snapshot() EWMA { return a } + +// Tick panics. +func (EWMASnapshot) Tick() { + panic("Tick called on an EWMASnapshot") +} + +// Update panics. +func (EWMASnapshot) Update(int64) { + panic("Update called on an EWMASnapshot") +} + +// NilEWMA is a no-op EWMA. +type NilEWMA struct{} + +// Rate is a no-op. +func (NilEWMA) Rate() float64 { return 0.0 } + +// Snapshot is a no-op. +func (NilEWMA) Snapshot() EWMA { return NilEWMA{} } + +// Tick is a no-op. +func (NilEWMA) Tick() {} + +// Update is a no-op. +func (NilEWMA) Update(n int64) {} + +// StandardEWMA is the standard implementation of an EWMA and tracks the number +// of uncounted events and processes them on each tick. It uses the +// sync/atomic package to manage uncounted events. +type StandardEWMA struct { + uncounted int64 // /!\ this should be the first member to ensure 64-bit alignment + alpha float64 + rate float64 + init bool + mutex sync.Mutex +} + +// Rate returns the moving average rate of events per second. +func (a *StandardEWMA) Rate() float64 { + a.mutex.Lock() + defer a.mutex.Unlock() + return a.rate * float64(1e9) +} + +// Snapshot returns a read-only copy of the EWMA. +func (a *StandardEWMA) Snapshot() EWMA { + return EWMASnapshot(a.Rate()) +} + +// Tick ticks the clock to update the moving average. It assumes it is called +// every five seconds. +func (a *StandardEWMA) Tick() { + count := atomic.LoadInt64(&a.uncounted) + atomic.AddInt64(&a.uncounted, -count) + instantRate := float64(count) / float64(5e9) + a.mutex.Lock() + defer a.mutex.Unlock() + if a.init { + a.rate += a.alpha * (instantRate - a.rate) + } else { + a.init = true + a.rate = instantRate + } +} + +// Update adds n uncounted events. +func (a *StandardEWMA) Update(n int64) { + atomic.AddInt64(&a.uncounted, n) +} diff --git a/vendor/github.com/rcrowley/go-metrics/gauge.go b/vendor/github.com/rcrowley/go-metrics/gauge.go new file mode 100644 index 00000000..807638a3 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/gauge.go @@ -0,0 +1,84 @@ +package metrics + +import "sync/atomic" + +// Gauges hold an int64 value that can be set arbitrarily. +type Gauge interface { + Snapshot() Gauge + Update(int64) + Value() int64 +} + +// GetOrRegisterGauge returns an existing Gauge or constructs and registers a +// new StandardGauge. +func GetOrRegisterGauge(name string, r Registry) Gauge { + if nil == r { + r = DefaultRegistry + } + return r.GetOrRegister(name, NewGauge).(Gauge) +} + +// NewGauge constructs a new StandardGauge. +func NewGauge() Gauge { + if UseNilMetrics { + return NilGauge{} + } + return &StandardGauge{0} +} + +// NewRegisteredGauge constructs and registers a new StandardGauge. +func NewRegisteredGauge(name string, r Registry) Gauge { + c := NewGauge() + if nil == r { + r = DefaultRegistry + } + r.Register(name, c) + return c +} + +// GaugeSnapshot is a read-only copy of another Gauge. +type GaugeSnapshot int64 + +// Snapshot returns the snapshot. +func (g GaugeSnapshot) Snapshot() Gauge { return g } + +// Update panics. +func (GaugeSnapshot) Update(int64) { + panic("Update called on a GaugeSnapshot") +} + +// Value returns the value at the time the snapshot was taken. +func (g GaugeSnapshot) Value() int64 { return int64(g) } + +// NilGauge is a no-op Gauge. +type NilGauge struct{} + +// Snapshot is a no-op. +func (NilGauge) Snapshot() Gauge { return NilGauge{} } + +// Update is a no-op. +func (NilGauge) Update(v int64) {} + +// Value is a no-op. +func (NilGauge) Value() int64 { return 0 } + +// StandardGauge is the standard implementation of a Gauge and uses the +// sync/atomic package to manage a single int64 value. +type StandardGauge struct { + value int64 +} + +// Snapshot returns a read-only copy of the gauge. +func (g *StandardGauge) Snapshot() Gauge { + return GaugeSnapshot(g.Value()) +} + +// Update updates the gauge's value. +func (g *StandardGauge) Update(v int64) { + atomic.StoreInt64(&g.value, v) +} + +// Value returns the gauge's current value. +func (g *StandardGauge) Value() int64 { + return atomic.LoadInt64(&g.value) +} diff --git a/vendor/github.com/rcrowley/go-metrics/gauge_float64.go b/vendor/github.com/rcrowley/go-metrics/gauge_float64.go new file mode 100644 index 00000000..47c3566c --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/gauge_float64.go @@ -0,0 +1,91 @@ +package metrics + +import "sync" + +// GaugeFloat64s hold a float64 value that can be set arbitrarily. +type GaugeFloat64 interface { + Snapshot() GaugeFloat64 + Update(float64) + Value() float64 +} + +// GetOrRegisterGaugeFloat64 returns an existing GaugeFloat64 or constructs and registers a +// new StandardGaugeFloat64. +func GetOrRegisterGaugeFloat64(name string, r Registry) GaugeFloat64 { + if nil == r { + r = DefaultRegistry + } + return r.GetOrRegister(name, NewGaugeFloat64()).(GaugeFloat64) +} + +// NewGaugeFloat64 constructs a new StandardGaugeFloat64. +func NewGaugeFloat64() GaugeFloat64 { + if UseNilMetrics { + return NilGaugeFloat64{} + } + return &StandardGaugeFloat64{ + value: 0.0, + } +} + +// NewRegisteredGaugeFloat64 constructs and registers a new StandardGaugeFloat64. +func NewRegisteredGaugeFloat64(name string, r Registry) GaugeFloat64 { + c := NewGaugeFloat64() + if nil == r { + r = DefaultRegistry + } + r.Register(name, c) + return c +} + +// GaugeFloat64Snapshot is a read-only copy of another GaugeFloat64. +type GaugeFloat64Snapshot float64 + +// Snapshot returns the snapshot. +func (g GaugeFloat64Snapshot) Snapshot() GaugeFloat64 { return g } + +// Update panics. +func (GaugeFloat64Snapshot) Update(float64) { + panic("Update called on a GaugeFloat64Snapshot") +} + +// Value returns the value at the time the snapshot was taken. +func (g GaugeFloat64Snapshot) Value() float64 { return float64(g) } + +// NilGauge is a no-op Gauge. +type NilGaugeFloat64 struct{} + +// Snapshot is a no-op. +func (NilGaugeFloat64) Snapshot() GaugeFloat64 { return NilGaugeFloat64{} } + +// Update is a no-op. +func (NilGaugeFloat64) Update(v float64) {} + +// Value is a no-op. +func (NilGaugeFloat64) Value() float64 { return 0.0 } + +// StandardGaugeFloat64 is the standard implementation of a GaugeFloat64 and uses +// sync.Mutex to manage a single float64 value. +type StandardGaugeFloat64 struct { + mutex sync.Mutex + value float64 +} + +// Snapshot returns a read-only copy of the gauge. +func (g *StandardGaugeFloat64) Snapshot() GaugeFloat64 { + return GaugeFloat64Snapshot(g.Value()) +} + +// Update updates the gauge's value. +func (g *StandardGaugeFloat64) Update(v float64) { + g.mutex.Lock() + defer g.mutex.Unlock() + g.value = v +} + +// Value returns the gauge's current value. +func (g *StandardGaugeFloat64) Value() float64 { + g.mutex.Lock() + defer g.mutex.Unlock() + return g.value +} diff --git a/vendor/github.com/rcrowley/go-metrics/go-metrics.test b/vendor/github.com/rcrowley/go-metrics/go-metrics.test new file mode 100755 index 0000000000000000000000000000000000000000..7bf72e85086113fef18af6c700a363c32ae770f0 GIT binary patch literal 4296056 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 z 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

vE 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

)12)v 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�|k6u$&V1FShpo|p_R=txkyts7mfEpmu}^{S32w^ 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 d7XXmip|ks`Rh({?=;nBY!{9?$H(F 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

JvI0OY)uYNku0Q>y>K5Axsh$K%O; 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

(1~EU6=4xkdWmPWL-Gxx6irDw)^c%)#nd5 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 z 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

G0x{5XuuD&J|mFF0;h}qI%FT}q<*MgUnL7b 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
  • vL+#b5`J=D}&n?ggrWk|W8UdGz}Z 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

    %ROAw6O8 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 literal 0 HcmV?d00001 diff --git a/vendor/github.com/rcrowley/go-metrics/graphite.go b/vendor/github.com/rcrowley/go-metrics/graphite.go new file mode 100644 index 00000000..604b26da --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/graphite.go @@ -0,0 +1,111 @@ +package metrics + +import ( + "bufio" + "fmt" + "log" + "net" + "strconv" + "strings" + "time" +) + +// GraphiteConfig provides a container with configuration parameters for +// the Graphite exporter +type GraphiteConfig struct { + Addr *net.TCPAddr // Network address to connect to + Registry Registry // Registry to be exported + FlushInterval time.Duration // Flush interval + DurationUnit time.Duration // Time conversion unit for durations + Prefix string // Prefix to be prepended to metric names + Percentiles []float64 // Percentiles to export from timers and histograms +} + +// Graphite is a blocking exporter function which reports metrics in r +// to a graphite server located at addr, flushing them every d duration +// and prepending metric names with prefix. +func Graphite(r Registry, d time.Duration, prefix string, addr *net.TCPAddr) { + GraphiteWithConfig(GraphiteConfig{ + Addr: addr, + Registry: r, + FlushInterval: d, + DurationUnit: time.Nanosecond, + Prefix: prefix, + Percentiles: []float64{0.5, 0.75, 0.95, 0.99, 0.999}, + }) +} + +// GraphiteWithConfig is a blocking exporter function just like Graphite, +// but it takes a GraphiteConfig instead. +func GraphiteWithConfig(c GraphiteConfig) { + for _ = range time.Tick(c.FlushInterval) { + if err := graphite(&c); nil != err { + log.Println(err) + } + } +} + +// GraphiteOnce performs a single submission to Graphite, returning a +// non-nil error on failed connections. This can be used in a loop +// similar to GraphiteWithConfig for custom error handling. +func GraphiteOnce(c GraphiteConfig) error { + return graphite(&c) +} + +func graphite(c *GraphiteConfig) error { + now := time.Now().Unix() + du := float64(c.DurationUnit) + conn, err := net.DialTCP("tcp", nil, c.Addr) + if nil != err { + return err + } + defer conn.Close() + w := bufio.NewWriter(conn) + c.Registry.Each(func(name string, i interface{}) { + switch metric := i.(type) { + case Counter: + fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, metric.Count(), now) + case Gauge: + fmt.Fprintf(w, "%s.%s.value %d %d\n", c.Prefix, name, metric.Value(), now) + case GaugeFloat64: + fmt.Fprintf(w, "%s.%s.value %f %d\n", c.Prefix, name, metric.Value(), now) + case Histogram: + h := metric.Snapshot() + ps := h.Percentiles(c.Percentiles) + fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, h.Count(), now) + fmt.Fprintf(w, "%s.%s.min %d %d\n", c.Prefix, name, h.Min(), now) + fmt.Fprintf(w, "%s.%s.max %d %d\n", c.Prefix, name, h.Max(), now) + fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", c.Prefix, name, h.Mean(), now) + fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", c.Prefix, name, h.StdDev(), now) + for psIdx, psKey := range c.Percentiles { + key := strings.Replace(strconv.FormatFloat(psKey*100.0, 'f', -1, 64), ".", "", 1) + fmt.Fprintf(w, "%s.%s.%s-percentile %.2f %d\n", c.Prefix, name, key, ps[psIdx], now) + } + case Meter: + m := metric.Snapshot() + fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, m.Count(), now) + fmt.Fprintf(w, "%s.%s.one-minute %.2f %d\n", c.Prefix, name, m.Rate1(), now) + fmt.Fprintf(w, "%s.%s.five-minute %.2f %d\n", c.Prefix, name, m.Rate5(), now) + fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", c.Prefix, name, m.Rate15(), now) + fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", c.Prefix, name, m.RateMean(), now) + case Timer: + t := metric.Snapshot() + ps := t.Percentiles(c.Percentiles) + fmt.Fprintf(w, "%s.%s.count %d %d\n", c.Prefix, name, t.Count(), now) + fmt.Fprintf(w, "%s.%s.min %d %d\n", c.Prefix, name, t.Min()/int64(du), now) + fmt.Fprintf(w, "%s.%s.max %d %d\n", c.Prefix, name, t.Max()/int64(du), now) + fmt.Fprintf(w, "%s.%s.mean %.2f %d\n", c.Prefix, name, t.Mean()/du, now) + fmt.Fprintf(w, "%s.%s.std-dev %.2f %d\n", c.Prefix, name, t.StdDev()/du, now) + for psIdx, psKey := range c.Percentiles { + key := strings.Replace(strconv.FormatFloat(psKey*100.0, 'f', -1, 64), ".", "", 1) + fmt.Fprintf(w, "%s.%s.%s-percentile %.2f %d\n", c.Prefix, name, key, ps[psIdx], now) + } + fmt.Fprintf(w, "%s.%s.one-minute %.2f %d\n", c.Prefix, name, t.Rate1(), now) + fmt.Fprintf(w, "%s.%s.five-minute %.2f %d\n", c.Prefix, name, t.Rate5(), now) + fmt.Fprintf(w, "%s.%s.fifteen-minute %.2f %d\n", c.Prefix, name, t.Rate15(), now) + fmt.Fprintf(w, "%s.%s.mean-rate %.2f %d\n", c.Prefix, name, t.RateMean(), now) + } + w.Flush() + }) + return nil +} diff --git a/vendor/github.com/rcrowley/go-metrics/healthcheck.go b/vendor/github.com/rcrowley/go-metrics/healthcheck.go new file mode 100644 index 00000000..445131ca --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/healthcheck.go @@ -0,0 +1,61 @@ +package metrics + +// Healthchecks hold an error value describing an arbitrary up/down status. +type Healthcheck interface { + Check() + Error() error + Healthy() + Unhealthy(error) +} + +// NewHealthcheck constructs a new Healthcheck which will use the given +// function to update its status. +func NewHealthcheck(f func(Healthcheck)) Healthcheck { + if UseNilMetrics { + return NilHealthcheck{} + } + return &StandardHealthcheck{nil, f} +} + +// NilHealthcheck is a no-op. +type NilHealthcheck struct{} + +// Check is a no-op. +func (NilHealthcheck) Check() {} + +// Error is a no-op. +func (NilHealthcheck) Error() error { return nil } + +// Healthy is a no-op. +func (NilHealthcheck) Healthy() {} + +// Unhealthy is a no-op. +func (NilHealthcheck) Unhealthy(error) {} + +// StandardHealthcheck is the standard implementation of a Healthcheck and +// stores the status and a function to call to update the status. +type StandardHealthcheck struct { + err error + f func(Healthcheck) +} + +// Check runs the healthcheck function to update the healthcheck's status. +func (h *StandardHealthcheck) Check() { + h.f(h) +} + +// Error returns the healthcheck's status, which will be nil if it is healthy. +func (h *StandardHealthcheck) Error() error { + return h.err +} + +// Healthy marks the healthcheck as healthy. +func (h *StandardHealthcheck) Healthy() { + h.err = nil +} + +// Unhealthy marks the healthcheck as unhealthy. The error is stored and +// may be retrieved by the Error method. +func (h *StandardHealthcheck) Unhealthy(err error) { + h.err = err +} diff --git a/vendor/github.com/rcrowley/go-metrics/histogram.go b/vendor/github.com/rcrowley/go-metrics/histogram.go new file mode 100644 index 00000000..dbc837fe --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/histogram.go @@ -0,0 +1,202 @@ +package metrics + +// Histograms calculate distribution statistics from a series of int64 values. +type Histogram interface { + Clear() + Count() int64 + Max() int64 + Mean() float64 + Min() int64 + Percentile(float64) float64 + Percentiles([]float64) []float64 + Sample() Sample + Snapshot() Histogram + StdDev() float64 + Sum() int64 + Update(int64) + Variance() float64 +} + +// GetOrRegisterHistogram returns an existing Histogram or constructs and +// registers a new StandardHistogram. +func GetOrRegisterHistogram(name string, r Registry, s Sample) Histogram { + if nil == r { + r = DefaultRegistry + } + return r.GetOrRegister(name, func() Histogram { return NewHistogram(s) }).(Histogram) +} + +// NewHistogram constructs a new StandardHistogram from a Sample. +func NewHistogram(s Sample) Histogram { + if UseNilMetrics { + return NilHistogram{} + } + return &StandardHistogram{sample: s} +} + +// NewRegisteredHistogram constructs and registers a new StandardHistogram from +// a Sample. +func NewRegisteredHistogram(name string, r Registry, s Sample) Histogram { + c := NewHistogram(s) + if nil == r { + r = DefaultRegistry + } + r.Register(name, c) + return c +} + +// HistogramSnapshot is a read-only copy of another Histogram. +type HistogramSnapshot struct { + sample *SampleSnapshot +} + +// Clear panics. +func (*HistogramSnapshot) Clear() { + panic("Clear called on a HistogramSnapshot") +} + +// Count returns the number of samples recorded at the time the snapshot was +// taken. +func (h *HistogramSnapshot) Count() int64 { return h.sample.Count() } + +// Max returns the maximum value in the sample at the time the snapshot was +// taken. +func (h *HistogramSnapshot) Max() int64 { return h.sample.Max() } + +// Mean returns the mean of the values in the sample at the time the snapshot +// was taken. +func (h *HistogramSnapshot) Mean() float64 { return h.sample.Mean() } + +// Min returns the minimum value in the sample at the time the snapshot was +// taken. +func (h *HistogramSnapshot) Min() int64 { return h.sample.Min() } + +// Percentile returns an arbitrary percentile of values in the sample at the +// time the snapshot was taken. +func (h *HistogramSnapshot) Percentile(p float64) float64 { + return h.sample.Percentile(p) +} + +// Percentiles returns a slice of arbitrary percentiles of values in the sample +// at the time the snapshot was taken. +func (h *HistogramSnapshot) Percentiles(ps []float64) []float64 { + return h.sample.Percentiles(ps) +} + +// Sample returns the Sample underlying the histogram. +func (h *HistogramSnapshot) Sample() Sample { return h.sample } + +// Snapshot returns the snapshot. +func (h *HistogramSnapshot) Snapshot() Histogram { return h } + +// StdDev returns the standard deviation of the values in the sample at the +// time the snapshot was taken. +func (h *HistogramSnapshot) StdDev() float64 { return h.sample.StdDev() } + +// Sum returns the sum in the sample at the time the snapshot was taken. +func (h *HistogramSnapshot) Sum() int64 { return h.sample.Sum() } + +// Update panics. +func (*HistogramSnapshot) Update(int64) { + panic("Update called on a HistogramSnapshot") +} + +// Variance returns the variance of inputs at the time the snapshot was taken. +func (h *HistogramSnapshot) Variance() float64 { return h.sample.Variance() } + +// NilHistogram is a no-op Histogram. +type NilHistogram struct{} + +// Clear is a no-op. +func (NilHistogram) Clear() {} + +// Count is a no-op. +func (NilHistogram) Count() int64 { return 0 } + +// Max is a no-op. +func (NilHistogram) Max() int64 { return 0 } + +// Mean is a no-op. +func (NilHistogram) Mean() float64 { return 0.0 } + +// Min is a no-op. +func (NilHistogram) Min() int64 { return 0 } + +// Percentile is a no-op. +func (NilHistogram) Percentile(p float64) float64 { return 0.0 } + +// Percentiles is a no-op. +func (NilHistogram) Percentiles(ps []float64) []float64 { + return make([]float64, len(ps)) +} + +// Sample is a no-op. +func (NilHistogram) Sample() Sample { return NilSample{} } + +// Snapshot is a no-op. +func (NilHistogram) Snapshot() Histogram { return NilHistogram{} } + +// StdDev is a no-op. +func (NilHistogram) StdDev() float64 { return 0.0 } + +// Sum is a no-op. +func (NilHistogram) Sum() int64 { return 0 } + +// Update is a no-op. +func (NilHistogram) Update(v int64) {} + +// Variance is a no-op. +func (NilHistogram) Variance() float64 { return 0.0 } + +// StandardHistogram is the standard implementation of a Histogram and uses a +// Sample to bound its memory use. +type StandardHistogram struct { + sample Sample +} + +// Clear clears the histogram and its sample. +func (h *StandardHistogram) Clear() { h.sample.Clear() } + +// Count returns the number of samples recorded since the histogram was last +// cleared. +func (h *StandardHistogram) Count() int64 { return h.sample.Count() } + +// Max returns the maximum value in the sample. +func (h *StandardHistogram) Max() int64 { return h.sample.Max() } + +// Mean returns the mean of the values in the sample. +func (h *StandardHistogram) Mean() float64 { return h.sample.Mean() } + +// Min returns the minimum value in the sample. +func (h *StandardHistogram) Min() int64 { return h.sample.Min() } + +// Percentile returns an arbitrary percentile of the values in the sample. +func (h *StandardHistogram) Percentile(p float64) float64 { + return h.sample.Percentile(p) +} + +// Percentiles returns a slice of arbitrary percentiles of the values in the +// sample. +func (h *StandardHistogram) Percentiles(ps []float64) []float64 { + return h.sample.Percentiles(ps) +} + +// Sample returns the Sample underlying the histogram. +func (h *StandardHistogram) Sample() Sample { return h.sample } + +// Snapshot returns a read-only copy of the histogram. +func (h *StandardHistogram) Snapshot() Histogram { + return &HistogramSnapshot{sample: h.sample.Snapshot().(*SampleSnapshot)} +} + +// StdDev returns the standard deviation of the values in the sample. +func (h *StandardHistogram) StdDev() float64 { return h.sample.StdDev() } + +// Sum returns the sum in the sample. +func (h *StandardHistogram) Sum() int64 { return h.sample.Sum() } + +// Update samples a new value. +func (h *StandardHistogram) Update(v int64) { h.sample.Update(v) } + +// Variance returns the variance of the values in the sample. +func (h *StandardHistogram) Variance() float64 { return h.sample.Variance() } diff --git a/vendor/github.com/rcrowley/go-metrics/json.go b/vendor/github.com/rcrowley/go-metrics/json.go new file mode 100644 index 00000000..04a9c919 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/json.go @@ -0,0 +1,83 @@ +package metrics + +import ( + "encoding/json" + "io" + "time" +) + +// MarshalJSON returns a byte slice containing a JSON representation of all +// the metrics in the Registry. +func (r StandardRegistry) MarshalJSON() ([]byte, error) { + data := make(map[string]map[string]interface{}) + r.Each(func(name string, i interface{}) { + values := make(map[string]interface{}) + switch metric := i.(type) { + case Counter: + values["count"] = metric.Count() + case Gauge: + values["value"] = metric.Value() + case GaugeFloat64: + values["value"] = metric.Value() + case Healthcheck: + values["error"] = nil + metric.Check() + if err := metric.Error(); nil != err { + values["error"] = metric.Error().Error() + } + case Histogram: + h := metric.Snapshot() + ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + values["count"] = h.Count() + values["min"] = h.Min() + values["max"] = h.Max() + values["mean"] = h.Mean() + values["stddev"] = h.StdDev() + values["median"] = ps[0] + values["75%"] = ps[1] + values["95%"] = ps[2] + values["99%"] = ps[3] + values["99.9%"] = ps[4] + case Meter: + m := metric.Snapshot() + values["count"] = m.Count() + values["1m.rate"] = m.Rate1() + values["5m.rate"] = m.Rate5() + values["15m.rate"] = m.Rate15() + values["mean.rate"] = m.RateMean() + case Timer: + t := metric.Snapshot() + ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + values["count"] = t.Count() + values["min"] = t.Min() + values["max"] = t.Max() + values["mean"] = t.Mean() + values["stddev"] = t.StdDev() + values["median"] = ps[0] + values["75%"] = ps[1] + values["95%"] = ps[2] + values["99%"] = ps[3] + values["99.9%"] = ps[4] + values["1m.rate"] = t.Rate1() + values["5m.rate"] = t.Rate5() + values["15m.rate"] = t.Rate15() + values["mean.rate"] = t.RateMean() + } + data[name] = values + }) + return json.Marshal(data) +} + +// WriteJSON writes metrics from the given registry periodically to the +// specified io.Writer as JSON. +func WriteJSON(r Registry, d time.Duration, w io.Writer) { + for _ = range time.Tick(d) { + WriteJSONOnce(r, w) + } +} + +// WriteJSONOnce writes metrics from the given registry to the specified +// io.Writer as JSON. +func WriteJSONOnce(r Registry, w io.Writer) { + json.NewEncoder(w).Encode(r) +} diff --git a/vendor/github.com/rcrowley/go-metrics/log.go b/vendor/github.com/rcrowley/go-metrics/log.go new file mode 100644 index 00000000..278a8a44 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/log.go @@ -0,0 +1,70 @@ +package metrics + +import ( + "log" + "time" +) + +// Output each metric in the given registry periodically using the given +// logger. +func Log(r Registry, d time.Duration, l *log.Logger) { + for _ = range time.Tick(d) { + r.Each(func(name string, i interface{}) { + switch metric := i.(type) { + case Counter: + l.Printf("counter %s\n", name) + l.Printf(" count: %9d\n", metric.Count()) + case Gauge: + l.Printf("gauge %s\n", name) + l.Printf(" value: %9d\n", metric.Value()) + case GaugeFloat64: + l.Printf("gauge %s\n", name) + l.Printf(" value: %f\n", metric.Value()) + case Healthcheck: + metric.Check() + l.Printf("healthcheck %s\n", name) + l.Printf(" error: %v\n", metric.Error()) + case Histogram: + h := metric.Snapshot() + ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + l.Printf("histogram %s\n", name) + l.Printf(" count: %9d\n", h.Count()) + l.Printf(" min: %9d\n", h.Min()) + l.Printf(" max: %9d\n", h.Max()) + l.Printf(" mean: %12.2f\n", h.Mean()) + l.Printf(" stddev: %12.2f\n", h.StdDev()) + l.Printf(" median: %12.2f\n", ps[0]) + l.Printf(" 75%%: %12.2f\n", ps[1]) + l.Printf(" 95%%: %12.2f\n", ps[2]) + l.Printf(" 99%%: %12.2f\n", ps[3]) + l.Printf(" 99.9%%: %12.2f\n", ps[4]) + case Meter: + m := metric.Snapshot() + l.Printf("meter %s\n", name) + l.Printf(" count: %9d\n", m.Count()) + l.Printf(" 1-min rate: %12.2f\n", m.Rate1()) + l.Printf(" 5-min rate: %12.2f\n", m.Rate5()) + l.Printf(" 15-min rate: %12.2f\n", m.Rate15()) + l.Printf(" mean rate: %12.2f\n", m.RateMean()) + case Timer: + t := metric.Snapshot() + ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + l.Printf("timer %s\n", name) + l.Printf(" count: %9d\n", t.Count()) + l.Printf(" min: %9d\n", t.Min()) + l.Printf(" max: %9d\n", t.Max()) + l.Printf(" mean: %12.2f\n", t.Mean()) + l.Printf(" stddev: %12.2f\n", t.StdDev()) + l.Printf(" median: %12.2f\n", ps[0]) + l.Printf(" 75%%: %12.2f\n", ps[1]) + l.Printf(" 95%%: %12.2f\n", ps[2]) + l.Printf(" 99%%: %12.2f\n", ps[3]) + l.Printf(" 99.9%%: %12.2f\n", ps[4]) + l.Printf(" 1-min rate: %12.2f\n", t.Rate1()) + l.Printf(" 5-min rate: %12.2f\n", t.Rate5()) + l.Printf(" 15-min rate: %12.2f\n", t.Rate15()) + l.Printf(" mean rate: %12.2f\n", t.RateMean()) + } + }) + } +} diff --git a/vendor/github.com/rcrowley/go-metrics/memory.md b/vendor/github.com/rcrowley/go-metrics/memory.md new file mode 100644 index 00000000..47454f54 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/memory.md @@ -0,0 +1,285 @@ +Memory usage +============ + +(Highly unscientific.) + +Command used to gather static memory usage: + +```sh +grep ^Vm "/proc/$(ps fax | grep [m]etrics-bench | awk '{print $1}')/status" +``` + +Program used to gather baseline memory usage: + +```go +package main + +import "time" + +func main() { + time.Sleep(600e9) +} +``` + +Baseline +-------- + +``` +VmPeak: 42604 kB +VmSize: 42604 kB +VmLck: 0 kB +VmHWM: 1120 kB +VmRSS: 1120 kB +VmData: 35460 kB +VmStk: 136 kB +VmExe: 1020 kB +VmLib: 1848 kB +VmPTE: 36 kB +VmSwap: 0 kB +``` + +Program used to gather metric memory usage (with other metrics being similar): + +```go +package main + +import ( + "fmt" + "metrics" + "time" +) + +func main() { + fmt.Sprintf("foo") + metrics.NewRegistry() + time.Sleep(600e9) +} +``` + +1000 counters registered +------------------------ + +``` +VmPeak: 44016 kB +VmSize: 44016 kB +VmLck: 0 kB +VmHWM: 1928 kB +VmRSS: 1928 kB +VmData: 36868 kB +VmStk: 136 kB +VmExe: 1024 kB +VmLib: 1848 kB +VmPTE: 40 kB +VmSwap: 0 kB +``` + +**1.412 kB virtual, TODO 0.808 kB resident per counter.** + +100000 counters registered +-------------------------- + +``` +VmPeak: 55024 kB +VmSize: 55024 kB +VmLck: 0 kB +VmHWM: 12440 kB +VmRSS: 12440 kB +VmData: 47876 kB +VmStk: 136 kB +VmExe: 1024 kB +VmLib: 1848 kB +VmPTE: 64 kB +VmSwap: 0 kB +``` + +**0.1242 kB virtual, 0.1132 kB resident per counter.** + +1000 gauges registered +---------------------- + +``` +VmPeak: 44012 kB +VmSize: 44012 kB +VmLck: 0 kB +VmHWM: 1928 kB +VmRSS: 1928 kB +VmData: 36868 kB +VmStk: 136 kB +VmExe: 1020 kB +VmLib: 1848 kB +VmPTE: 40 kB +VmSwap: 0 kB +``` + +**1.408 kB virtual, 0.808 kB resident per counter.** + +100000 gauges registered +------------------------ + +``` +VmPeak: 55020 kB +VmSize: 55020 kB +VmLck: 0 kB +VmHWM: 12432 kB +VmRSS: 12432 kB +VmData: 47876 kB +VmStk: 136 kB +VmExe: 1020 kB +VmLib: 1848 kB +VmPTE: 60 kB +VmSwap: 0 kB +``` + +**0.12416 kB virtual, 0.11312 resident per gauge.** + +1000 histograms with a uniform sample size of 1028 +-------------------------------------------------- + +``` +VmPeak: 72272 kB +VmSize: 72272 kB +VmLck: 0 kB +VmHWM: 16204 kB +VmRSS: 16204 kB +VmData: 65100 kB +VmStk: 136 kB +VmExe: 1048 kB +VmLib: 1848 kB +VmPTE: 80 kB +VmSwap: 0 kB +``` + +**29.668 kB virtual, TODO 15.084 resident per histogram.** + +10000 histograms with a uniform sample size of 1028 +--------------------------------------------------- + +``` +VmPeak: 256912 kB +VmSize: 256912 kB +VmLck: 0 kB +VmHWM: 146204 kB +VmRSS: 146204 kB +VmData: 249740 kB +VmStk: 136 kB +VmExe: 1048 kB +VmLib: 1848 kB +VmPTE: 448 kB +VmSwap: 0 kB +``` + +**21.4308 kB virtual, 14.5084 kB resident per histogram.** + +50000 histograms with a uniform sample size of 1028 +--------------------------------------------------- + +``` +VmPeak: 908112 kB +VmSize: 908112 kB +VmLck: 0 kB +VmHWM: 645832 kB +VmRSS: 645588 kB +VmData: 900940 kB +VmStk: 136 kB +VmExe: 1048 kB +VmLib: 1848 kB +VmPTE: 1716 kB +VmSwap: 1544 kB +``` + +**17.31016 kB virtual, 12.88936 kB resident per histogram.** + +1000 histograms with an exponentially-decaying sample size of 1028 and alpha of 0.015 +------------------------------------------------------------------------------------- + +``` +VmPeak: 62480 kB +VmSize: 62480 kB +VmLck: 0 kB +VmHWM: 11572 kB +VmRSS: 11572 kB +VmData: 55308 kB +VmStk: 136 kB +VmExe: 1048 kB +VmLib: 1848 kB +VmPTE: 64 kB +VmSwap: 0 kB +``` + +**19.876 kB virtual, 10.452 kB resident per histogram.** + +10000 histograms with an exponentially-decaying sample size of 1028 and alpha of 0.015 +-------------------------------------------------------------------------------------- + +``` +VmPeak: 153296 kB +VmSize: 153296 kB +VmLck: 0 kB +VmHWM: 101176 kB +VmRSS: 101176 kB +VmData: 146124 kB +VmStk: 136 kB +VmExe: 1048 kB +VmLib: 1848 kB +VmPTE: 240 kB +VmSwap: 0 kB +``` + +**11.0692 kB virtual, 10.0056 kB resident per histogram.** + +50000 histograms with an exponentially-decaying sample size of 1028 and alpha of 0.015 +-------------------------------------------------------------------------------------- + +``` +VmPeak: 557264 kB +VmSize: 557264 kB +VmLck: 0 kB +VmHWM: 501056 kB +VmRSS: 501056 kB +VmData: 550092 kB +VmStk: 136 kB +VmExe: 1048 kB +VmLib: 1848 kB +VmPTE: 1032 kB +VmSwap: 0 kB +``` + +**10.2932 kB virtual, 9.99872 kB resident per histogram.** + +1000 meters +----------- + +``` +VmPeak: 74504 kB +VmSize: 74504 kB +VmLck: 0 kB +VmHWM: 24124 kB +VmRSS: 24124 kB +VmData: 67340 kB +VmStk: 136 kB +VmExe: 1040 kB +VmLib: 1848 kB +VmPTE: 92 kB +VmSwap: 0 kB +``` + +**31.9 kB virtual, 23.004 kB resident per meter.** + +10000 meters +------------ + +``` +VmPeak: 278920 kB +VmSize: 278920 kB +VmLck: 0 kB +VmHWM: 227300 kB +VmRSS: 227300 kB +VmData: 271756 kB +VmStk: 136 kB +VmExe: 1040 kB +VmLib: 1848 kB +VmPTE: 488 kB +VmSwap: 0 kB +``` + +**23.6316 kB virtual, 22.618 kB resident per meter.** diff --git a/vendor/github.com/rcrowley/go-metrics/meter.go b/vendor/github.com/rcrowley/go-metrics/meter.go new file mode 100644 index 00000000..0389ab0b --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/meter.go @@ -0,0 +1,233 @@ +package metrics + +import ( + "sync" + "time" +) + +// Meters count events to produce exponentially-weighted moving average rates +// at one-, five-, and fifteen-minutes and a mean rate. +type Meter interface { + Count() int64 + Mark(int64) + Rate1() float64 + Rate5() float64 + Rate15() float64 + RateMean() float64 + Snapshot() Meter +} + +// GetOrRegisterMeter returns an existing Meter or constructs and registers a +// new StandardMeter. +func GetOrRegisterMeter(name string, r Registry) Meter { + if nil == r { + r = DefaultRegistry + } + return r.GetOrRegister(name, NewMeter).(Meter) +} + +// NewMeter constructs a new StandardMeter and launches a goroutine. +func NewMeter() Meter { + if UseNilMetrics { + return NilMeter{} + } + m := newStandardMeter() + arbiter.Lock() + defer arbiter.Unlock() + arbiter.meters = append(arbiter.meters, m) + if !arbiter.started { + arbiter.started = true + go arbiter.tick() + } + return m +} + +// NewMeter constructs and registers a new StandardMeter and launches a +// goroutine. +func NewRegisteredMeter(name string, r Registry) Meter { + c := NewMeter() + if nil == r { + r = DefaultRegistry + } + r.Register(name, c) + return c +} + +// MeterSnapshot is a read-only copy of another Meter. +type MeterSnapshot struct { + count int64 + rate1, rate5, rate15, rateMean float64 +} + +// Count returns the count of events at the time the snapshot was taken. +func (m *MeterSnapshot) Count() int64 { return m.count } + +// Mark panics. +func (*MeterSnapshot) Mark(n int64) { + panic("Mark called on a MeterSnapshot") +} + +// Rate1 returns the one-minute moving average rate of events per second at the +// time the snapshot was taken. +func (m *MeterSnapshot) Rate1() float64 { return m.rate1 } + +// Rate5 returns the five-minute moving average rate of events per second at +// the time the snapshot was taken. +func (m *MeterSnapshot) Rate5() float64 { return m.rate5 } + +// Rate15 returns the fifteen-minute moving average rate of events per second +// at the time the snapshot was taken. +func (m *MeterSnapshot) Rate15() float64 { return m.rate15 } + +// RateMean returns the meter's mean rate of events per second at the time the +// snapshot was taken. +func (m *MeterSnapshot) RateMean() float64 { return m.rateMean } + +// Snapshot returns the snapshot. +func (m *MeterSnapshot) Snapshot() Meter { return m } + +// NilMeter is a no-op Meter. +type NilMeter struct{} + +// Count is a no-op. +func (NilMeter) Count() int64 { return 0 } + +// Mark is a no-op. +func (NilMeter) Mark(n int64) {} + +// Rate1 is a no-op. +func (NilMeter) Rate1() float64 { return 0.0 } + +// Rate5 is a no-op. +func (NilMeter) Rate5() float64 { return 0.0 } + +// Rate15is a no-op. +func (NilMeter) Rate15() float64 { return 0.0 } + +// RateMean is a no-op. +func (NilMeter) RateMean() float64 { return 0.0 } + +// Snapshot is a no-op. +func (NilMeter) Snapshot() Meter { return NilMeter{} } + +// StandardMeter is the standard implementation of a Meter. +type StandardMeter struct { + lock sync.RWMutex + snapshot *MeterSnapshot + a1, a5, a15 EWMA + startTime time.Time +} + +func newStandardMeter() *StandardMeter { + return &StandardMeter{ + snapshot: &MeterSnapshot{}, + a1: NewEWMA1(), + a5: NewEWMA5(), + a15: NewEWMA15(), + startTime: time.Now(), + } +} + +// Count returns the number of events recorded. +func (m *StandardMeter) Count() int64 { + m.lock.RLock() + count := m.snapshot.count + m.lock.RUnlock() + return count +} + +// Mark records the occurance of n events. +func (m *StandardMeter) Mark(n int64) { + m.lock.Lock() + defer m.lock.Unlock() + m.snapshot.count += n + m.a1.Update(n) + m.a5.Update(n) + m.a15.Update(n) + m.updateSnapshot() +} + +// Rate1 returns the one-minute moving average rate of events per second. +func (m *StandardMeter) Rate1() float64 { + m.lock.RLock() + rate1 := m.snapshot.rate1 + m.lock.RUnlock() + return rate1 +} + +// Rate5 returns the five-minute moving average rate of events per second. +func (m *StandardMeter) Rate5() float64 { + m.lock.RLock() + rate5 := m.snapshot.rate5 + m.lock.RUnlock() + return rate5 +} + +// Rate15 returns the fifteen-minute moving average rate of events per second. +func (m *StandardMeter) Rate15() float64 { + m.lock.RLock() + rate15 := m.snapshot.rate15 + m.lock.RUnlock() + return rate15 +} + +// RateMean returns the meter's mean rate of events per second. +func (m *StandardMeter) RateMean() float64 { + m.lock.RLock() + rateMean := m.snapshot.rateMean + m.lock.RUnlock() + return rateMean +} + +// Snapshot returns a read-only copy of the meter. +func (m *StandardMeter) Snapshot() Meter { + m.lock.RLock() + snapshot := *m.snapshot + m.lock.RUnlock() + return &snapshot +} + +func (m *StandardMeter) updateSnapshot() { + // should run with write lock held on m.lock + snapshot := m.snapshot + snapshot.rate1 = m.a1.Rate() + snapshot.rate5 = m.a5.Rate() + snapshot.rate15 = m.a15.Rate() + snapshot.rateMean = float64(snapshot.count) / time.Since(m.startTime).Seconds() +} + +func (m *StandardMeter) tick() { + m.lock.Lock() + defer m.lock.Unlock() + m.a1.Tick() + m.a5.Tick() + m.a15.Tick() + m.updateSnapshot() +} + +type meterArbiter struct { + sync.RWMutex + started bool + meters []*StandardMeter + ticker *time.Ticker +} + +var arbiter = meterArbiter{ticker: time.NewTicker(5e9)} + +// Ticks meters on the scheduled interval +func (ma *meterArbiter) tick() { + for { + select { + case <-ma.ticker.C: + ma.tickMeters() + } + } +} + +func (ma *meterArbiter) tickMeters() { + ma.RLock() + defer ma.RUnlock() + for _, meter := range ma.meters { + meter.tick() + } +} diff --git a/vendor/github.com/rcrowley/go-metrics/metrics.go b/vendor/github.com/rcrowley/go-metrics/metrics.go new file mode 100644 index 00000000..b97a49ed --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/metrics.go @@ -0,0 +1,13 @@ +// Go port of Coda Hale's Metrics library +// +// +// +// Coda Hale's original work: +package metrics + +// UseNilMetrics is checked by the constructor functions for all of the +// standard metrics. If it is true, the metric returned is a stub. +// +// This global kill-switch helps quantify the observer effect and makes +// for less cluttered pprof profiles. +var UseNilMetrics bool = false diff --git a/vendor/github.com/rcrowley/go-metrics/opentsdb.go b/vendor/github.com/rcrowley/go-metrics/opentsdb.go new file mode 100644 index 00000000..266b6c93 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/opentsdb.go @@ -0,0 +1,119 @@ +package metrics + +import ( + "bufio" + "fmt" + "log" + "net" + "os" + "strings" + "time" +) + +var shortHostName string = "" + +// OpenTSDBConfig provides a container with configuration parameters for +// the OpenTSDB exporter +type OpenTSDBConfig struct { + Addr *net.TCPAddr // Network address to connect to + Registry Registry // Registry to be exported + FlushInterval time.Duration // Flush interval + DurationUnit time.Duration // Time conversion unit for durations + Prefix string // Prefix to be prepended to metric names +} + +// OpenTSDB is a blocking exporter function which reports metrics in r +// to a TSDB server located at addr, flushing them every d duration +// and prepending metric names with prefix. +func OpenTSDB(r Registry, d time.Duration, prefix string, addr *net.TCPAddr) { + OpenTSDBWithConfig(OpenTSDBConfig{ + Addr: addr, + Registry: r, + FlushInterval: d, + DurationUnit: time.Nanosecond, + Prefix: prefix, + }) +} + +// OpenTSDBWithConfig is a blocking exporter function just like OpenTSDB, +// but it takes a OpenTSDBConfig instead. +func OpenTSDBWithConfig(c OpenTSDBConfig) { + for _ = range time.Tick(c.FlushInterval) { + if err := openTSDB(&c); nil != err { + log.Println(err) + } + } +} + +func getShortHostname() string { + if shortHostName == "" { + host, _ := os.Hostname() + if index := strings.Index(host, "."); index > 0 { + shortHostName = host[:index] + } else { + shortHostName = host + } + } + return shortHostName +} + +func openTSDB(c *OpenTSDBConfig) error { + shortHostname := getShortHostname() + now := time.Now().Unix() + du := float64(c.DurationUnit) + conn, err := net.DialTCP("tcp", nil, c.Addr) + if nil != err { + return err + } + defer conn.Close() + w := bufio.NewWriter(conn) + c.Registry.Each(func(name string, i interface{}) { + switch metric := i.(type) { + case Counter: + fmt.Fprintf(w, "put %s.%s.count %d %d host=%s\n", c.Prefix, name, now, metric.Count(), shortHostname) + case Gauge: + fmt.Fprintf(w, "put %s.%s.value %d %d host=%s\n", c.Prefix, name, now, metric.Value(), shortHostname) + case GaugeFloat64: + fmt.Fprintf(w, "put %s.%s.value %d %f host=%s\n", c.Prefix, name, now, metric.Value(), shortHostname) + case Histogram: + h := metric.Snapshot() + ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + fmt.Fprintf(w, "put %s.%s.count %d %d host=%s\n", c.Prefix, name, now, h.Count(), shortHostname) + fmt.Fprintf(w, "put %s.%s.min %d %d host=%s\n", c.Prefix, name, now, h.Min(), shortHostname) + fmt.Fprintf(w, "put %s.%s.max %d %d host=%s\n", c.Prefix, name, now, h.Max(), shortHostname) + fmt.Fprintf(w, "put %s.%s.mean %d %.2f host=%s\n", c.Prefix, name, now, h.Mean(), shortHostname) + fmt.Fprintf(w, "put %s.%s.std-dev %d %.2f host=%s\n", c.Prefix, name, now, h.StdDev(), shortHostname) + fmt.Fprintf(w, "put %s.%s.50-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[0], shortHostname) + fmt.Fprintf(w, "put %s.%s.75-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[1], shortHostname) + fmt.Fprintf(w, "put %s.%s.95-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[2], shortHostname) + fmt.Fprintf(w, "put %s.%s.99-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[3], shortHostname) + fmt.Fprintf(w, "put %s.%s.999-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[4], shortHostname) + case Meter: + m := metric.Snapshot() + fmt.Fprintf(w, "put %s.%s.count %d %d host=%s\n", c.Prefix, name, now, m.Count(), shortHostname) + fmt.Fprintf(w, "put %s.%s.one-minute %d %.2f host=%s\n", c.Prefix, name, now, m.Rate1(), shortHostname) + fmt.Fprintf(w, "put %s.%s.five-minute %d %.2f host=%s\n", c.Prefix, name, now, m.Rate5(), shortHostname) + fmt.Fprintf(w, "put %s.%s.fifteen-minute %d %.2f host=%s\n", c.Prefix, name, now, m.Rate15(), shortHostname) + fmt.Fprintf(w, "put %s.%s.mean %d %.2f host=%s\n", c.Prefix, name, now, m.RateMean(), shortHostname) + case Timer: + t := metric.Snapshot() + ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + fmt.Fprintf(w, "put %s.%s.count %d %d host=%s\n", c.Prefix, name, now, t.Count(), shortHostname) + fmt.Fprintf(w, "put %s.%s.min %d %d host=%s\n", c.Prefix, name, now, t.Min()/int64(du), shortHostname) + fmt.Fprintf(w, "put %s.%s.max %d %d host=%s\n", c.Prefix, name, now, t.Max()/int64(du), shortHostname) + fmt.Fprintf(w, "put %s.%s.mean %d %.2f host=%s\n", c.Prefix, name, now, t.Mean()/du, shortHostname) + fmt.Fprintf(w, "put %s.%s.std-dev %d %.2f host=%s\n", c.Prefix, name, now, t.StdDev()/du, shortHostname) + fmt.Fprintf(w, "put %s.%s.50-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[0]/du, shortHostname) + fmt.Fprintf(w, "put %s.%s.75-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[1]/du, shortHostname) + fmt.Fprintf(w, "put %s.%s.95-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[2]/du, shortHostname) + fmt.Fprintf(w, "put %s.%s.99-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[3]/du, shortHostname) + fmt.Fprintf(w, "put %s.%s.999-percentile %d %.2f host=%s\n", c.Prefix, name, now, ps[4]/du, shortHostname) + fmt.Fprintf(w, "put %s.%s.one-minute %d %.2f host=%s\n", c.Prefix, name, now, t.Rate1(), shortHostname) + fmt.Fprintf(w, "put %s.%s.five-minute %d %.2f host=%s\n", c.Prefix, name, now, t.Rate5(), shortHostname) + fmt.Fprintf(w, "put %s.%s.fifteen-minute %d %.2f host=%s\n", c.Prefix, name, now, t.Rate15(), shortHostname) + fmt.Fprintf(w, "put %s.%s.mean-rate %d %.2f host=%s\n", c.Prefix, name, now, t.RateMean(), shortHostname) + } + w.Flush() + }) + return nil +} diff --git a/vendor/github.com/rcrowley/go-metrics/registry.go b/vendor/github.com/rcrowley/go-metrics/registry.go new file mode 100644 index 00000000..4ac534e1 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/registry.go @@ -0,0 +1,180 @@ +package metrics + +import ( + "fmt" + "reflect" + "sync" +) + +// DuplicateMetric is the error returned by Registry.Register when a metric +// already exists. If you mean to Register that metric you must first +// Unregister the existing metric. +type DuplicateMetric string + +func (err DuplicateMetric) Error() string { + return fmt.Sprintf("duplicate metric: %s", string(err)) +} + +// A Registry holds references to a set of metrics by name and can iterate +// over them, calling callback functions provided by the user. +// +// This is an interface so as to encourage other structs to implement +// the Registry API as appropriate. +type Registry interface { + + // Call the given function for each registered metric. + Each(func(string, interface{})) + + // Get the metric by the given name or nil if none is registered. + Get(string) interface{} + + // Gets an existing metric or registers the given one. + // The interface can be the metric to register if not found in registry, + // or a function returning the metric for lazy instantiation. + GetOrRegister(string, interface{}) interface{} + + // Register the given metric under the given name. + Register(string, interface{}) error + + // Run all registered healthchecks. + RunHealthchecks() + + // Unregister the metric with the given name. + Unregister(string) + + // Unregister all metrics. (Mostly for testing.) + UnregisterAll() +} + +// The standard implementation of a Registry is a mutex-protected map +// of names to metrics. +type StandardRegistry struct { + metrics map[string]interface{} + mutex sync.Mutex +} + +// Create a new registry. +func NewRegistry() Registry { + return &StandardRegistry{metrics: make(map[string]interface{})} +} + +// Call the given function for each registered metric. +func (r *StandardRegistry) Each(f func(string, interface{})) { + for name, i := range r.registered() { + f(name, i) + } +} + +// Get the metric by the given name or nil if none is registered. +func (r *StandardRegistry) Get(name string) interface{} { + r.mutex.Lock() + defer r.mutex.Unlock() + return r.metrics[name] +} + +// Gets an existing metric or creates and registers a new one. Threadsafe +// alternative to calling Get and Register on failure. +// The interface can be the metric to register if not found in registry, +// or a function returning the metric for lazy instantiation. +func (r *StandardRegistry) GetOrRegister(name string, i interface{}) interface{} { + r.mutex.Lock() + defer r.mutex.Unlock() + if metric, ok := r.metrics[name]; ok { + return metric + } + if v := reflect.ValueOf(i); v.Kind() == reflect.Func { + i = v.Call(nil)[0].Interface() + } + r.register(name, i) + return i +} + +// Register the given metric under the given name. Returns a DuplicateMetric +// if a metric by the given name is already registered. +func (r *StandardRegistry) Register(name string, i interface{}) error { + r.mutex.Lock() + defer r.mutex.Unlock() + return r.register(name, i) +} + +// Run all registered healthchecks. +func (r *StandardRegistry) RunHealthchecks() { + r.mutex.Lock() + defer r.mutex.Unlock() + for _, i := range r.metrics { + if h, ok := i.(Healthcheck); ok { + h.Check() + } + } +} + +// Unregister the metric with the given name. +func (r *StandardRegistry) Unregister(name string) { + r.mutex.Lock() + defer r.mutex.Unlock() + delete(r.metrics, name) +} + +// Unregister all metrics. (Mostly for testing.) +func (r *StandardRegistry) UnregisterAll() { + r.mutex.Lock() + defer r.mutex.Unlock() + for name, _ := range r.metrics { + delete(r.metrics, name) + } +} + +func (r *StandardRegistry) register(name string, i interface{}) error { + if _, ok := r.metrics[name]; ok { + return DuplicateMetric(name) + } + switch i.(type) { + case Counter, Gauge, GaugeFloat64, Healthcheck, Histogram, Meter, Timer: + r.metrics[name] = i + } + return nil +} + +func (r *StandardRegistry) registered() map[string]interface{} { + metrics := make(map[string]interface{}, len(r.metrics)) + r.mutex.Lock() + defer r.mutex.Unlock() + for name, i := range r.metrics { + metrics[name] = i + } + return metrics +} + +var DefaultRegistry Registry = NewRegistry() + +// Call the given function for each registered metric. +func Each(f func(string, interface{})) { + DefaultRegistry.Each(f) +} + +// Get the metric by the given name or nil if none is registered. +func Get(name string) interface{} { + return DefaultRegistry.Get(name) +} + +// Gets an existing metric or creates and registers a new one. Threadsafe +// alternative to calling Get and Register on failure. +func GetOrRegister(name string, i interface{}) interface{} { + return DefaultRegistry.GetOrRegister(name, i) +} + +// Register the given metric under the given name. Returns a DuplicateMetric +// if a metric by the given name is already registered. +func Register(name string, i interface{}) error { + return DefaultRegistry.Register(name, i) +} + +// Run all registered healthchecks. +func RunHealthchecks() { + DefaultRegistry.RunHealthchecks() +} + +// Unregister the metric with the given name. +func Unregister(name string) { + DefaultRegistry.Unregister(name) +} diff --git a/vendor/github.com/rcrowley/go-metrics/runtime.go b/vendor/github.com/rcrowley/go-metrics/runtime.go new file mode 100644 index 00000000..82574bf2 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/runtime.go @@ -0,0 +1,200 @@ +package metrics + +import ( + "runtime" + "time" +) + +var ( + memStats runtime.MemStats + runtimeMetrics struct { + MemStats struct { + Alloc Gauge + BuckHashSys Gauge + DebugGC Gauge + EnableGC Gauge + Frees Gauge + HeapAlloc Gauge + HeapIdle Gauge + HeapInuse Gauge + HeapObjects Gauge + HeapReleased Gauge + HeapSys Gauge + LastGC Gauge + Lookups Gauge + Mallocs Gauge + MCacheInuse Gauge + MCacheSys Gauge + MSpanInuse Gauge + MSpanSys Gauge + NextGC Gauge + NumGC Gauge + PauseNs Histogram + PauseTotalNs Gauge + StackInuse Gauge + StackSys Gauge + Sys Gauge + TotalAlloc Gauge + } + NumCgoCall Gauge + NumGoroutine Gauge + ReadMemStats Timer + } + frees uint64 + lookups uint64 + mallocs uint64 + numGC uint32 + numCgoCalls int64 +) + +// Capture new values for the Go runtime statistics exported in +// runtime.MemStats. This is designed to be called as a goroutine. +func CaptureRuntimeMemStats(r Registry, d time.Duration) { + for _ = range time.Tick(d) { + CaptureRuntimeMemStatsOnce(r) + } +} + +// Capture new values for the Go runtime statistics exported in +// runtime.MemStats. This is designed to be called in a background +// goroutine. Giving a registry which has not been given to +// RegisterRuntimeMemStats will panic. +// +// Be very careful with this because runtime.ReadMemStats calls the C +// functions runtime·semacquire(&runtime·worldsema) and runtime·stoptheworld() +// and that last one does what it says on the tin. +func CaptureRuntimeMemStatsOnce(r Registry) { + t := time.Now() + runtime.ReadMemStats(&memStats) // This takes 50-200us. + runtimeMetrics.ReadMemStats.UpdateSince(t) + + runtimeMetrics.MemStats.Alloc.Update(int64(memStats.Alloc)) + runtimeMetrics.MemStats.BuckHashSys.Update(int64(memStats.BuckHashSys)) + if memStats.DebugGC { + runtimeMetrics.MemStats.DebugGC.Update(1) + } else { + runtimeMetrics.MemStats.DebugGC.Update(0) + } + if memStats.EnableGC { + runtimeMetrics.MemStats.EnableGC.Update(1) + } else { + runtimeMetrics.MemStats.EnableGC.Update(0) + } + + runtimeMetrics.MemStats.Frees.Update(int64(memStats.Frees - frees)) + runtimeMetrics.MemStats.HeapAlloc.Update(int64(memStats.HeapAlloc)) + runtimeMetrics.MemStats.HeapIdle.Update(int64(memStats.HeapIdle)) + runtimeMetrics.MemStats.HeapInuse.Update(int64(memStats.HeapInuse)) + runtimeMetrics.MemStats.HeapObjects.Update(int64(memStats.HeapObjects)) + runtimeMetrics.MemStats.HeapReleased.Update(int64(memStats.HeapReleased)) + runtimeMetrics.MemStats.HeapSys.Update(int64(memStats.HeapSys)) + runtimeMetrics.MemStats.LastGC.Update(int64(memStats.LastGC)) + runtimeMetrics.MemStats.Lookups.Update(int64(memStats.Lookups - lookups)) + runtimeMetrics.MemStats.Mallocs.Update(int64(memStats.Mallocs - mallocs)) + runtimeMetrics.MemStats.MCacheInuse.Update(int64(memStats.MCacheInuse)) + runtimeMetrics.MemStats.MCacheSys.Update(int64(memStats.MCacheSys)) + runtimeMetrics.MemStats.MSpanInuse.Update(int64(memStats.MSpanInuse)) + runtimeMetrics.MemStats.MSpanSys.Update(int64(memStats.MSpanSys)) + runtimeMetrics.MemStats.NextGC.Update(int64(memStats.NextGC)) + runtimeMetrics.MemStats.NumGC.Update(int64(memStats.NumGC - numGC)) + + // + i := numGC % uint32(len(memStats.PauseNs)) + ii := memStats.NumGC % uint32(len(memStats.PauseNs)) + if memStats.NumGC-numGC >= uint32(len(memStats.PauseNs)) { + for i = 0; i < uint32(len(memStats.PauseNs)); i++ { + runtimeMetrics.MemStats.PauseNs.Update(int64(memStats.PauseNs[i])) + } + } else { + if i > ii { + for ; i < uint32(len(memStats.PauseNs)); i++ { + runtimeMetrics.MemStats.PauseNs.Update(int64(memStats.PauseNs[i])) + } + i = 0 + } + for ; i < ii; i++ { + runtimeMetrics.MemStats.PauseNs.Update(int64(memStats.PauseNs[i])) + } + } + frees = memStats.Frees + lookups = memStats.Lookups + mallocs = memStats.Mallocs + numGC = memStats.NumGC + + runtimeMetrics.MemStats.PauseTotalNs.Update(int64(memStats.PauseTotalNs)) + runtimeMetrics.MemStats.StackInuse.Update(int64(memStats.StackInuse)) + runtimeMetrics.MemStats.StackSys.Update(int64(memStats.StackSys)) + runtimeMetrics.MemStats.Sys.Update(int64(memStats.Sys)) + runtimeMetrics.MemStats.TotalAlloc.Update(int64(memStats.TotalAlloc)) + + currentNumCgoCalls := numCgoCall() + runtimeMetrics.NumCgoCall.Update(currentNumCgoCalls - numCgoCalls) + numCgoCalls = currentNumCgoCalls + + runtimeMetrics.NumGoroutine.Update(int64(runtime.NumGoroutine())) +} + +// Register runtimeMetrics for the Go runtime statistics exported in runtime and +// specifically runtime.MemStats. The runtimeMetrics are named by their +// fully-qualified Go symbols, i.e. runtime.MemStats.Alloc. +func RegisterRuntimeMemStats(r Registry) { + runtimeMetrics.MemStats.Alloc = NewGauge() + runtimeMetrics.MemStats.BuckHashSys = NewGauge() + runtimeMetrics.MemStats.DebugGC = NewGauge() + runtimeMetrics.MemStats.EnableGC = NewGauge() + runtimeMetrics.MemStats.Frees = NewGauge() + runtimeMetrics.MemStats.HeapAlloc = NewGauge() + runtimeMetrics.MemStats.HeapIdle = NewGauge() + runtimeMetrics.MemStats.HeapInuse = NewGauge() + runtimeMetrics.MemStats.HeapObjects = NewGauge() + runtimeMetrics.MemStats.HeapReleased = NewGauge() + runtimeMetrics.MemStats.HeapSys = NewGauge() + runtimeMetrics.MemStats.LastGC = NewGauge() + runtimeMetrics.MemStats.Lookups = NewGauge() + runtimeMetrics.MemStats.Mallocs = NewGauge() + runtimeMetrics.MemStats.MCacheInuse = NewGauge() + runtimeMetrics.MemStats.MCacheSys = NewGauge() + runtimeMetrics.MemStats.MSpanInuse = NewGauge() + runtimeMetrics.MemStats.MSpanSys = NewGauge() + runtimeMetrics.MemStats.NextGC = NewGauge() + runtimeMetrics.MemStats.NumGC = NewGauge() + runtimeMetrics.MemStats.PauseNs = NewHistogram(NewExpDecaySample(1028, 0.015)) + runtimeMetrics.MemStats.PauseTotalNs = NewGauge() + runtimeMetrics.MemStats.StackInuse = NewGauge() + runtimeMetrics.MemStats.StackSys = NewGauge() + runtimeMetrics.MemStats.Sys = NewGauge() + runtimeMetrics.MemStats.TotalAlloc = NewGauge() + runtimeMetrics.NumCgoCall = NewGauge() + runtimeMetrics.NumGoroutine = NewGauge() + runtimeMetrics.ReadMemStats = NewTimer() + + r.Register("runtime.MemStats.Alloc", runtimeMetrics.MemStats.Alloc) + r.Register("runtime.MemStats.BuckHashSys", runtimeMetrics.MemStats.BuckHashSys) + r.Register("runtime.MemStats.DebugGC", runtimeMetrics.MemStats.DebugGC) + r.Register("runtime.MemStats.EnableGC", runtimeMetrics.MemStats.EnableGC) + r.Register("runtime.MemStats.Frees", runtimeMetrics.MemStats.Frees) + r.Register("runtime.MemStats.HeapAlloc", runtimeMetrics.MemStats.HeapAlloc) + r.Register("runtime.MemStats.HeapIdle", runtimeMetrics.MemStats.HeapIdle) + r.Register("runtime.MemStats.HeapInuse", runtimeMetrics.MemStats.HeapInuse) + r.Register("runtime.MemStats.HeapObjects", runtimeMetrics.MemStats.HeapObjects) + r.Register("runtime.MemStats.HeapReleased", runtimeMetrics.MemStats.HeapReleased) + r.Register("runtime.MemStats.HeapSys", runtimeMetrics.MemStats.HeapSys) + r.Register("runtime.MemStats.LastGC", runtimeMetrics.MemStats.LastGC) + r.Register("runtime.MemStats.Lookups", runtimeMetrics.MemStats.Lookups) + r.Register("runtime.MemStats.Mallocs", runtimeMetrics.MemStats.Mallocs) + r.Register("runtime.MemStats.MCacheInuse", runtimeMetrics.MemStats.MCacheInuse) + r.Register("runtime.MemStats.MCacheSys", runtimeMetrics.MemStats.MCacheSys) + r.Register("runtime.MemStats.MSpanInuse", runtimeMetrics.MemStats.MSpanInuse) + r.Register("runtime.MemStats.MSpanSys", runtimeMetrics.MemStats.MSpanSys) + r.Register("runtime.MemStats.NextGC", runtimeMetrics.MemStats.NextGC) + r.Register("runtime.MemStats.NumGC", runtimeMetrics.MemStats.NumGC) + r.Register("runtime.MemStats.PauseNs", runtimeMetrics.MemStats.PauseNs) + r.Register("runtime.MemStats.PauseTotalNs", runtimeMetrics.MemStats.PauseTotalNs) + r.Register("runtime.MemStats.StackInuse", runtimeMetrics.MemStats.StackInuse) + r.Register("runtime.MemStats.StackSys", runtimeMetrics.MemStats.StackSys) + r.Register("runtime.MemStats.Sys", runtimeMetrics.MemStats.Sys) + r.Register("runtime.MemStats.TotalAlloc", runtimeMetrics.MemStats.TotalAlloc) + r.Register("runtime.NumCgoCall", runtimeMetrics.NumCgoCall) + r.Register("runtime.NumGoroutine", runtimeMetrics.NumGoroutine) + r.Register("runtime.ReadMemStats", runtimeMetrics.ReadMemStats) +} diff --git a/vendor/github.com/rcrowley/go-metrics/runtime_cgo.go b/vendor/github.com/rcrowley/go-metrics/runtime_cgo.go new file mode 100644 index 00000000..e3391f4e --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/runtime_cgo.go @@ -0,0 +1,10 @@ +// +build cgo +// +build !appengine + +package metrics + +import "runtime" + +func numCgoCall() int64 { + return runtime.NumCgoCall() +} diff --git a/vendor/github.com/rcrowley/go-metrics/runtime_no_cgo.go b/vendor/github.com/rcrowley/go-metrics/runtime_no_cgo.go new file mode 100644 index 00000000..616a3b47 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/runtime_no_cgo.go @@ -0,0 +1,7 @@ +// +build !cgo appengine + +package metrics + +func numCgoCall() int64 { + return 0 +} diff --git a/vendor/github.com/rcrowley/go-metrics/sample.go b/vendor/github.com/rcrowley/go-metrics/sample.go new file mode 100644 index 00000000..ee5ebc0c --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/sample.go @@ -0,0 +1,602 @@ +package metrics + +import ( + "math" + "math/rand" + "sort" + "sync" + "time" +) + +const rescaleThreshold = time.Hour + +// Samples maintain a statistically-significant selection of values from +// a stream. +type Sample interface { + Clear() + Count() int64 + Max() int64 + Mean() float64 + Min() int64 + Percentile(float64) float64 + Percentiles([]float64) []float64 + Size() int + Snapshot() Sample + StdDev() float64 + Sum() int64 + Update(int64) + Values() []int64 + Variance() float64 +} + +// ExpDecaySample is an exponentially-decaying sample using a forward-decaying +// priority reservoir. See Cormode et al's "Forward Decay: A Practical Time +// Decay Model for Streaming Systems". +// +// +type ExpDecaySample struct { + alpha float64 + count int64 + mutex sync.Mutex + reservoirSize int + t0, t1 time.Time + values *expDecaySampleHeap +} + +// NewExpDecaySample constructs a new exponentially-decaying sample with the +// given reservoir size and alpha. +func NewExpDecaySample(reservoirSize int, alpha float64) Sample { + if UseNilMetrics { + return NilSample{} + } + s := &ExpDecaySample{ + alpha: alpha, + reservoirSize: reservoirSize, + t0: time.Now(), + values: newExpDecaySampleHeap(reservoirSize), + } + s.t1 = time.Now().Add(rescaleThreshold) + return s +} + +// Clear clears all samples. +func (s *ExpDecaySample) Clear() { + s.mutex.Lock() + defer s.mutex.Unlock() + s.count = 0 + s.t0 = time.Now() + s.t1 = s.t0.Add(rescaleThreshold) + s.values = newExpDecaySampleHeap(s.reservoirSize) +} + +// Count returns the number of samples recorded, which may exceed the +// reservoir size. +func (s *ExpDecaySample) Count() int64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return s.count +} + +// Max returns the maximum value in the sample, which may not be the maximum +// value ever to be part of the sample. +func (s *ExpDecaySample) Max() int64 { + return SampleMax(s.Values()) +} + +// Mean returns the mean of the values in the sample. +func (s *ExpDecaySample) Mean() float64 { + return SampleMean(s.Values()) +} + +// Min returns the minimum value in the sample, which may not be the minimum +// value ever to be part of the sample. +func (s *ExpDecaySample) Min() int64 { + return SampleMin(s.Values()) +} + +// Percentile returns an arbitrary percentile of values in the sample. +func (s *ExpDecaySample) Percentile(p float64) float64 { + return SamplePercentile(s.Values(), p) +} + +// Percentiles returns a slice of arbitrary percentiles of values in the +// sample. +func (s *ExpDecaySample) Percentiles(ps []float64) []float64 { + return SamplePercentiles(s.Values(), ps) +} + +// Size returns the size of the sample, which is at most the reservoir size. +func (s *ExpDecaySample) Size() int { + s.mutex.Lock() + defer s.mutex.Unlock() + return s.values.Size() +} + +// Snapshot returns a read-only copy of the sample. +func (s *ExpDecaySample) Snapshot() Sample { + s.mutex.Lock() + defer s.mutex.Unlock() + vals := s.values.Values() + values := make([]int64, len(vals)) + for i, v := range vals { + values[i] = v.v + } + return &SampleSnapshot{ + count: s.count, + values: values, + } +} + +// StdDev returns the standard deviation of the values in the sample. +func (s *ExpDecaySample) StdDev() float64 { + return SampleStdDev(s.Values()) +} + +// Sum returns the sum of the values in the sample. +func (s *ExpDecaySample) Sum() int64 { + return SampleSum(s.Values()) +} + +// Update samples a new value. +func (s *ExpDecaySample) Update(v int64) { + s.update(time.Now(), v) +} + +// Values returns a copy of the values in the sample. +func (s *ExpDecaySample) Values() []int64 { + s.mutex.Lock() + defer s.mutex.Unlock() + vals := s.values.Values() + values := make([]int64, len(vals)) + for i, v := range vals { + values[i] = v.v + } + return values +} + +// Variance returns the variance of the values in the sample. +func (s *ExpDecaySample) Variance() float64 { + return SampleVariance(s.Values()) +} + +// update samples a new value at a particular timestamp. This is a method all +// its own to facilitate testing. +func (s *ExpDecaySample) update(t time.Time, v int64) { + s.mutex.Lock() + defer s.mutex.Unlock() + s.count++ + if s.values.Size() == s.reservoirSize { + s.values.Pop() + } + s.values.Push(expDecaySample{ + k: math.Exp(t.Sub(s.t0).Seconds()*s.alpha) / rand.Float64(), + v: v, + }) + if t.After(s.t1) { + values := s.values.Values() + t0 := s.t0 + s.values = newExpDecaySampleHeap(s.reservoirSize) + s.t0 = t + s.t1 = s.t0.Add(rescaleThreshold) + for _, v := range values { + v.k = v.k * math.Exp(-s.alpha*float64(s.t0.Sub(t0))) + s.values.Push(v) + } + } +} + +// NilSample is a no-op Sample. +type NilSample struct{} + +// Clear is a no-op. +func (NilSample) Clear() {} + +// Count is a no-op. +func (NilSample) Count() int64 { return 0 } + +// Max is a no-op. +func (NilSample) Max() int64 { return 0 } + +// Mean is a no-op. +func (NilSample) Mean() float64 { return 0.0 } + +// Min is a no-op. +func (NilSample) Min() int64 { return 0 } + +// Percentile is a no-op. +func (NilSample) Percentile(p float64) float64 { return 0.0 } + +// Percentiles is a no-op. +func (NilSample) Percentiles(ps []float64) []float64 { + return make([]float64, len(ps)) +} + +// Size is a no-op. +func (NilSample) Size() int { return 0 } + +// Sample is a no-op. +func (NilSample) Snapshot() Sample { return NilSample{} } + +// StdDev is a no-op. +func (NilSample) StdDev() float64 { return 0.0 } + +// Sum is a no-op. +func (NilSample) Sum() int64 { return 0 } + +// Update is a no-op. +func (NilSample) Update(v int64) {} + +// Values is a no-op. +func (NilSample) Values() []int64 { return []int64{} } + +// Variance is a no-op. +func (NilSample) Variance() float64 { return 0.0 } + +// SampleMax returns the maximum value of the slice of int64. +func SampleMax(values []int64) int64 { + if 0 == len(values) { + return 0 + } + var max int64 = math.MinInt64 + for _, v := range values { + if max < v { + max = v + } + } + return max +} + +// SampleMean returns the mean value of the slice of int64. +func SampleMean(values []int64) float64 { + if 0 == len(values) { + return 0.0 + } + return float64(SampleSum(values)) / float64(len(values)) +} + +// SampleMin returns the minimum value of the slice of int64. +func SampleMin(values []int64) int64 { + if 0 == len(values) { + return 0 + } + var min int64 = math.MaxInt64 + for _, v := range values { + if min > v { + min = v + } + } + return min +} + +// SamplePercentiles returns an arbitrary percentile of the slice of int64. +func SamplePercentile(values int64Slice, p float64) float64 { + return SamplePercentiles(values, []float64{p})[0] +} + +// SamplePercentiles returns a slice of arbitrary percentiles of the slice of +// int64. +func SamplePercentiles(values int64Slice, ps []float64) []float64 { + scores := make([]float64, len(ps)) + size := len(values) + if size > 0 { + sort.Sort(values) + for i, p := range ps { + pos := p * float64(size+1) + if pos < 1.0 { + scores[i] = float64(values[0]) + } else if pos >= float64(size) { + scores[i] = float64(values[size-1]) + } else { + lower := float64(values[int(pos)-1]) + upper := float64(values[int(pos)]) + scores[i] = lower + (pos-math.Floor(pos))*(upper-lower) + } + } + } + return scores +} + +// SampleSnapshot is a read-only copy of another Sample. +type SampleSnapshot struct { + count int64 + values []int64 +} + +// Clear panics. +func (*SampleSnapshot) Clear() { + panic("Clear called on a SampleSnapshot") +} + +// Count returns the count of inputs at the time the snapshot was taken. +func (s *SampleSnapshot) Count() int64 { return s.count } + +// Max returns the maximal value at the time the snapshot was taken. +func (s *SampleSnapshot) Max() int64 { return SampleMax(s.values) } + +// Mean returns the mean value at the time the snapshot was taken. +func (s *SampleSnapshot) Mean() float64 { return SampleMean(s.values) } + +// Min returns the minimal value at the time the snapshot was taken. +func (s *SampleSnapshot) Min() int64 { return SampleMin(s.values) } + +// Percentile returns an arbitrary percentile of values at the time the +// snapshot was taken. +func (s *SampleSnapshot) Percentile(p float64) float64 { + return SamplePercentile(s.values, p) +} + +// Percentiles returns a slice of arbitrary percentiles of values at the time +// the snapshot was taken. +func (s *SampleSnapshot) Percentiles(ps []float64) []float64 { + return SamplePercentiles(s.values, ps) +} + +// Size returns the size of the sample at the time the snapshot was taken. +func (s *SampleSnapshot) Size() int { return len(s.values) } + +// Snapshot returns the snapshot. +func (s *SampleSnapshot) Snapshot() Sample { return s } + +// StdDev returns the standard deviation of values at the time the snapshot was +// taken. +func (s *SampleSnapshot) StdDev() float64 { return SampleStdDev(s.values) } + +// Sum returns the sum of values at the time the snapshot was taken. +func (s *SampleSnapshot) Sum() int64 { return SampleSum(s.values) } + +// Update panics. +func (*SampleSnapshot) Update(int64) { + panic("Update called on a SampleSnapshot") +} + +// Values returns a copy of the values in the sample. +func (s *SampleSnapshot) Values() []int64 { + values := make([]int64, len(s.values)) + copy(values, s.values) + return values +} + +// Variance returns the variance of values at the time the snapshot was taken. +func (s *SampleSnapshot) Variance() float64 { return SampleVariance(s.values) } + +// SampleStdDev returns the standard deviation of the slice of int64. +func SampleStdDev(values []int64) float64 { + return math.Sqrt(SampleVariance(values)) +} + +// SampleSum returns the sum of the slice of int64. +func SampleSum(values []int64) int64 { + var sum int64 + for _, v := range values { + sum += v + } + return sum +} + +// SampleVariance returns the variance of the slice of int64. +func SampleVariance(values []int64) float64 { + if 0 == len(values) { + return 0.0 + } + m := SampleMean(values) + var sum float64 + for _, v := range values { + d := float64(v) - m + sum += d * d + } + return sum / float64(len(values)) +} + +// A uniform sample using Vitter's Algorithm R. +// +// +type UniformSample struct { + count int64 + mutex sync.Mutex + reservoirSize int + values []int64 +} + +// NewUniformSample constructs a new uniform sample with the given reservoir +// size. +func NewUniformSample(reservoirSize int) Sample { + if UseNilMetrics { + return NilSample{} + } + return &UniformSample{ + reservoirSize: reservoirSize, + values: make([]int64, 0, reservoirSize), + } +} + +// Clear clears all samples. +func (s *UniformSample) Clear() { + s.mutex.Lock() + defer s.mutex.Unlock() + s.count = 0 + s.values = make([]int64, 0, s.reservoirSize) +} + +// Count returns the number of samples recorded, which may exceed the +// reservoir size. +func (s *UniformSample) Count() int64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return s.count +} + +// Max returns the maximum value in the sample, which may not be the maximum +// value ever to be part of the sample. +func (s *UniformSample) Max() int64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SampleMax(s.values) +} + +// Mean returns the mean of the values in the sample. +func (s *UniformSample) Mean() float64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SampleMean(s.values) +} + +// Min returns the minimum value in the sample, which may not be the minimum +// value ever to be part of the sample. +func (s *UniformSample) Min() int64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SampleMin(s.values) +} + +// Percentile returns an arbitrary percentile of values in the sample. +func (s *UniformSample) Percentile(p float64) float64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SamplePercentile(s.values, p) +} + +// Percentiles returns a slice of arbitrary percentiles of values in the +// sample. +func (s *UniformSample) Percentiles(ps []float64) []float64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SamplePercentiles(s.values, ps) +} + +// Size returns the size of the sample, which is at most the reservoir size. +func (s *UniformSample) Size() int { + s.mutex.Lock() + defer s.mutex.Unlock() + return len(s.values) +} + +// Snapshot returns a read-only copy of the sample. +func (s *UniformSample) Snapshot() Sample { + s.mutex.Lock() + defer s.mutex.Unlock() + values := make([]int64, len(s.values)) + copy(values, s.values) + return &SampleSnapshot{ + count: s.count, + values: values, + } +} + +// StdDev returns the standard deviation of the values in the sample. +func (s *UniformSample) StdDev() float64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SampleStdDev(s.values) +} + +// Sum returns the sum of the values in the sample. +func (s *UniformSample) Sum() int64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SampleSum(s.values) +} + +// Update samples a new value. +func (s *UniformSample) Update(v int64) { + s.mutex.Lock() + defer s.mutex.Unlock() + s.count++ + if len(s.values) < s.reservoirSize { + s.values = append(s.values, v) + } else { + s.values[rand.Intn(s.reservoirSize)] = v + } +} + +// Values returns a copy of the values in the sample. +func (s *UniformSample) Values() []int64 { + s.mutex.Lock() + defer s.mutex.Unlock() + values := make([]int64, len(s.values)) + copy(values, s.values) + return values +} + +// Variance returns the variance of the values in the sample. +func (s *UniformSample) Variance() float64 { + s.mutex.Lock() + defer s.mutex.Unlock() + return SampleVariance(s.values) +} + +// expDecaySample represents an individual sample in a heap. +type expDecaySample struct { + k float64 + v int64 +} + +func newExpDecaySampleHeap(reservoirSize int) *expDecaySampleHeap { + return &expDecaySampleHeap{make([]expDecaySample, 0, reservoirSize)} +} + +// expDecaySampleHeap is a min-heap of expDecaySamples. +// The internal implementation is copied from the standard library's container/heap +type expDecaySampleHeap struct { + s []expDecaySample +} + +func (h *expDecaySampleHeap) Push(s expDecaySample) { + n := len(h.s) + h.s = h.s[0 : n+1] + h.s[n] = s + h.up(n) +} + +func (h *expDecaySampleHeap) Pop() expDecaySample { + n := len(h.s) - 1 + h.s[0], h.s[n] = h.s[n], h.s[0] + h.down(0, n) + + n = len(h.s) + s := h.s[n-1] + h.s = h.s[0 : n-1] + return s +} + +func (h *expDecaySampleHeap) Size() int { + return len(h.s) +} + +func (h *expDecaySampleHeap) Values() []expDecaySample { + return h.s +} + +func (h *expDecaySampleHeap) up(j int) { + for { + i := (j - 1) / 2 // parent + if i == j || !(h.s[j].k < h.s[i].k) { + break + } + h.s[i], h.s[j] = h.s[j], h.s[i] + j = i + } +} + +func (h *expDecaySampleHeap) down(i, n int) { + for { + j1 := 2*i + 1 + if j1 >= n || j1 < 0 { // j1 < 0 after int overflow + break + } + j := j1 // left child + if j2 := j1 + 1; j2 < n && !(h.s[j1].k < h.s[j2].k) { + j = j2 // = 2*i + 2 // right child + } + if !(h.s[j].k < h.s[i].k) { + break + } + h.s[i], h.s[j] = h.s[j], h.s[i] + i = j + } +} + +type int64Slice []int64 + +func (p int64Slice) Len() int { return len(p) } +func (p int64Slice) Less(i, j int) bool { return p[i] < p[j] } +func (p int64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } diff --git a/vendor/github.com/rcrowley/go-metrics/syslog.go b/vendor/github.com/rcrowley/go-metrics/syslog.go new file mode 100644 index 00000000..693f1908 --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/syslog.go @@ -0,0 +1,78 @@ +// +build !windows + +package metrics + +import ( + "fmt" + "log/syslog" + "time" +) + +// Output each metric in the given registry to syslog periodically using +// the given syslogger. +func Syslog(r Registry, d time.Duration, w *syslog.Writer) { + for _ = range time.Tick(d) { + r.Each(func(name string, i interface{}) { + switch metric := i.(type) { + case Counter: + w.Info(fmt.Sprintf("counter %s: count: %d", name, metric.Count())) + case Gauge: + w.Info(fmt.Sprintf("gauge %s: value: %d", name, metric.Value())) + case GaugeFloat64: + w.Info(fmt.Sprintf("gauge %s: value: %f", name, metric.Value())) + case Healthcheck: + metric.Check() + w.Info(fmt.Sprintf("healthcheck %s: error: %v", name, metric.Error())) + case Histogram: + h := metric.Snapshot() + ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + w.Info(fmt.Sprintf( + "histogram %s: count: %d min: %d max: %d mean: %.2f stddev: %.2f median: %.2f 75%%: %.2f 95%%: %.2f 99%%: %.2f 99.9%%: %.2f", + name, + h.Count(), + h.Min(), + h.Max(), + h.Mean(), + h.StdDev(), + ps[0], + ps[1], + ps[2], + ps[3], + ps[4], + )) + case Meter: + m := metric.Snapshot() + w.Info(fmt.Sprintf( + "meter %s: count: %d 1-min: %.2f 5-min: %.2f 15-min: %.2f mean: %.2f", + name, + m.Count(), + m.Rate1(), + m.Rate5(), + m.Rate15(), + m.RateMean(), + )) + case Timer: + t := metric.Snapshot() + ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + w.Info(fmt.Sprintf( + "timer %s: count: %d min: %d max: %d mean: %.2f stddev: %.2f median: %.2f 75%%: %.2f 95%%: %.2f 99%%: %.2f 99.9%%: %.2f 1-min: %.2f 5-min: %.2f 15-min: %.2f mean-rate: %.2f", + name, + t.Count(), + t.Min(), + t.Max(), + t.Mean(), + t.StdDev(), + ps[0], + ps[1], + ps[2], + ps[3], + ps[4], + t.Rate1(), + t.Rate5(), + t.Rate15(), + t.RateMean(), + )) + } + }) + } +} diff --git a/vendor/github.com/rcrowley/go-metrics/timer.go b/vendor/github.com/rcrowley/go-metrics/timer.go new file mode 100644 index 00000000..17db8f8d --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/timer.go @@ -0,0 +1,311 @@ +package metrics + +import ( + "sync" + "time" +) + +// Timers capture the duration and rate of events. +type Timer interface { + Count() int64 + Max() int64 + Mean() float64 + Min() int64 + Percentile(float64) float64 + Percentiles([]float64) []float64 + Rate1() float64 + Rate5() float64 + Rate15() float64 + RateMean() float64 + Snapshot() Timer + StdDev() float64 + Sum() int64 + Time(func()) + Update(time.Duration) + UpdateSince(time.Time) + Variance() float64 +} + +// GetOrRegisterTimer returns an existing Timer or constructs and registers a +// new StandardTimer. +func GetOrRegisterTimer(name string, r Registry) Timer { + if nil == r { + r = DefaultRegistry + } + return r.GetOrRegister(name, NewTimer).(Timer) +} + +// NewCustomTimer constructs a new StandardTimer from a Histogram and a Meter. +func NewCustomTimer(h Histogram, m Meter) Timer { + if UseNilMetrics { + return NilTimer{} + } + return &StandardTimer{ + histogram: h, + meter: m, + } +} + +// NewRegisteredTimer constructs and registers a new StandardTimer. +func NewRegisteredTimer(name string, r Registry) Timer { + c := NewTimer() + if nil == r { + r = DefaultRegistry + } + r.Register(name, c) + return c +} + +// NewTimer constructs a new StandardTimer using an exponentially-decaying +// sample with the same reservoir size and alpha as UNIX load averages. +func NewTimer() Timer { + if UseNilMetrics { + return NilTimer{} + } + return &StandardTimer{ + histogram: NewHistogram(NewExpDecaySample(1028, 0.015)), + meter: NewMeter(), + } +} + +// NilTimer is a no-op Timer. +type NilTimer struct { + h Histogram + m Meter +} + +// Count is a no-op. +func (NilTimer) Count() int64 { return 0 } + +// Max is a no-op. +func (NilTimer) Max() int64 { return 0 } + +// Mean is a no-op. +func (NilTimer) Mean() float64 { return 0.0 } + +// Min is a no-op. +func (NilTimer) Min() int64 { return 0 } + +// Percentile is a no-op. +func (NilTimer) Percentile(p float64) float64 { return 0.0 } + +// Percentiles is a no-op. +func (NilTimer) Percentiles(ps []float64) []float64 { + return make([]float64, len(ps)) +} + +// Rate1 is a no-op. +func (NilTimer) Rate1() float64 { return 0.0 } + +// Rate5 is a no-op. +func (NilTimer) Rate5() float64 { return 0.0 } + +// Rate15 is a no-op. +func (NilTimer) Rate15() float64 { return 0.0 } + +// RateMean is a no-op. +func (NilTimer) RateMean() float64 { return 0.0 } + +// Snapshot is a no-op. +func (NilTimer) Snapshot() Timer { return NilTimer{} } + +// StdDev is a no-op. +func (NilTimer) StdDev() float64 { return 0.0 } + +// Sum is a no-op. +func (NilTimer) Sum() int64 { return 0 } + +// Time is a no-op. +func (NilTimer) Time(func()) {} + +// Update is a no-op. +func (NilTimer) Update(time.Duration) {} + +// UpdateSince is a no-op. +func (NilTimer) UpdateSince(time.Time) {} + +// Variance is a no-op. +func (NilTimer) Variance() float64 { return 0.0 } + +// StandardTimer is the standard implementation of a Timer and uses a Histogram +// and Meter. +type StandardTimer struct { + histogram Histogram + meter Meter + mutex sync.Mutex +} + +// Count returns the number of events recorded. +func (t *StandardTimer) Count() int64 { + return t.histogram.Count() +} + +// Max returns the maximum value in the sample. +func (t *StandardTimer) Max() int64 { + return t.histogram.Max() +} + +// Mean returns the mean of the values in the sample. +func (t *StandardTimer) Mean() float64 { + return t.histogram.Mean() +} + +// Min returns the minimum value in the sample. +func (t *StandardTimer) Min() int64 { + return t.histogram.Min() +} + +// Percentile returns an arbitrary percentile of the values in the sample. +func (t *StandardTimer) Percentile(p float64) float64 { + return t.histogram.Percentile(p) +} + +// Percentiles returns a slice of arbitrary percentiles of the values in the +// sample. +func (t *StandardTimer) Percentiles(ps []float64) []float64 { + return t.histogram.Percentiles(ps) +} + +// Rate1 returns the one-minute moving average rate of events per second. +func (t *StandardTimer) Rate1() float64 { + return t.meter.Rate1() +} + +// Rate5 returns the five-minute moving average rate of events per second. +func (t *StandardTimer) Rate5() float64 { + return t.meter.Rate5() +} + +// Rate15 returns the fifteen-minute moving average rate of events per second. +func (t *StandardTimer) Rate15() float64 { + return t.meter.Rate15() +} + +// RateMean returns the meter's mean rate of events per second. +func (t *StandardTimer) RateMean() float64 { + return t.meter.RateMean() +} + +// Snapshot returns a read-only copy of the timer. +func (t *StandardTimer) Snapshot() Timer { + t.mutex.Lock() + defer t.mutex.Unlock() + return &TimerSnapshot{ + histogram: t.histogram.Snapshot().(*HistogramSnapshot), + meter: t.meter.Snapshot().(*MeterSnapshot), + } +} + +// StdDev returns the standard deviation of the values in the sample. +func (t *StandardTimer) StdDev() float64 { + return t.histogram.StdDev() +} + +// Sum returns the sum in the sample. +func (t *StandardTimer) Sum() int64 { + return t.histogram.Sum() +} + +// Record the duration of the execution of the given function. +func (t *StandardTimer) Time(f func()) { + ts := time.Now() + f() + t.Update(time.Since(ts)) +} + +// Record the duration of an event. +func (t *StandardTimer) Update(d time.Duration) { + t.mutex.Lock() + defer t.mutex.Unlock() + t.histogram.Update(int64(d)) + t.meter.Mark(1) +} + +// Record the duration of an event that started at a time and ends now. +func (t *StandardTimer) UpdateSince(ts time.Time) { + t.mutex.Lock() + defer t.mutex.Unlock() + t.histogram.Update(int64(time.Since(ts))) + t.meter.Mark(1) +} + +// Variance returns the variance of the values in the sample. +func (t *StandardTimer) Variance() float64 { + return t.histogram.Variance() +} + +// TimerSnapshot is a read-only copy of another Timer. +type TimerSnapshot struct { + histogram *HistogramSnapshot + meter *MeterSnapshot +} + +// Count returns the number of events recorded at the time the snapshot was +// taken. +func (t *TimerSnapshot) Count() int64 { return t.histogram.Count() } + +// Max returns the maximum value at the time the snapshot was taken. +func (t *TimerSnapshot) Max() int64 { return t.histogram.Max() } + +// Mean returns the mean value at the time the snapshot was taken. +func (t *TimerSnapshot) Mean() float64 { return t.histogram.Mean() } + +// Min returns the minimum value at the time the snapshot was taken. +func (t *TimerSnapshot) Min() int64 { return t.histogram.Min() } + +// Percentile returns an arbitrary percentile of sampled values at the time the +// snapshot was taken. +func (t *TimerSnapshot) Percentile(p float64) float64 { + return t.histogram.Percentile(p) +} + +// Percentiles returns a slice of arbitrary percentiles of sampled values at +// the time the snapshot was taken. +func (t *TimerSnapshot) Percentiles(ps []float64) []float64 { + return t.histogram.Percentiles(ps) +} + +// Rate1 returns the one-minute moving average rate of events per second at the +// time the snapshot was taken. +func (t *TimerSnapshot) Rate1() float64 { return t.meter.Rate1() } + +// Rate5 returns the five-minute moving average rate of events per second at +// the time the snapshot was taken. +func (t *TimerSnapshot) Rate5() float64 { return t.meter.Rate5() } + +// Rate15 returns the fifteen-minute moving average rate of events per second +// at the time the snapshot was taken. +func (t *TimerSnapshot) Rate15() float64 { return t.meter.Rate15() } + +// RateMean returns the meter's mean rate of events per second at the time the +// snapshot was taken. +func (t *TimerSnapshot) RateMean() float64 { return t.meter.RateMean() } + +// Snapshot returns the snapshot. +func (t *TimerSnapshot) Snapshot() Timer { return t } + +// StdDev returns the standard deviation of the values at the time the snapshot +// was taken. +func (t *TimerSnapshot) StdDev() float64 { return t.histogram.StdDev() } + +// Sum returns the sum at the time the snapshot was taken. +func (t *TimerSnapshot) Sum() int64 { return t.histogram.Sum() } + +// Time panics. +func (*TimerSnapshot) Time(func()) { + panic("Time called on a TimerSnapshot") +} + +// Update panics. +func (*TimerSnapshot) Update(time.Duration) { + panic("Update called on a TimerSnapshot") +} + +// UpdateSince panics. +func (*TimerSnapshot) UpdateSince(time.Time) { + panic("UpdateSince called on a TimerSnapshot") +} + +// Variance returns the variance of the values at the time the snapshot was +// taken. +func (t *TimerSnapshot) Variance() float64 { return t.histogram.Variance() } diff --git a/vendor/github.com/rcrowley/go-metrics/writer.go b/vendor/github.com/rcrowley/go-metrics/writer.go new file mode 100644 index 00000000..091e971d --- /dev/null +++ b/vendor/github.com/rcrowley/go-metrics/writer.go @@ -0,0 +1,100 @@ +package metrics + +import ( + "fmt" + "io" + "sort" + "time" +) + +// Write sorts writes each metric in the given registry periodically to the +// given io.Writer. +func Write(r Registry, d time.Duration, w io.Writer) { + for _ = range time.Tick(d) { + WriteOnce(r, w) + } +} + +// WriteOnce sorts and writes metrics in the given registry to the given +// io.Writer. +func WriteOnce(r Registry, w io.Writer) { + var namedMetrics namedMetricSlice + r.Each(func(name string, i interface{}) { + namedMetrics = append(namedMetrics, namedMetric{name, i}) + }) + + sort.Sort(namedMetrics) + for _, namedMetric := range namedMetrics { + switch metric := namedMetric.m.(type) { + case Counter: + fmt.Fprintf(w, "counter %s\n", namedMetric.name) + fmt.Fprintf(w, " count: %9d\n", metric.Count()) + case Gauge: + fmt.Fprintf(w, "gauge %s\n", namedMetric.name) + fmt.Fprintf(w, " value: %9d\n", metric.Value()) + case GaugeFloat64: + fmt.Fprintf(w, "gauge %s\n", namedMetric.name) + fmt.Fprintf(w, " value: %f\n", metric.Value()) + case Healthcheck: + metric.Check() + fmt.Fprintf(w, "healthcheck %s\n", namedMetric.name) + fmt.Fprintf(w, " error: %v\n", metric.Error()) + case Histogram: + h := metric.Snapshot() + ps := h.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + fmt.Fprintf(w, "histogram %s\n", namedMetric.name) + fmt.Fprintf(w, " count: %9d\n", h.Count()) + fmt.Fprintf(w, " min: %9d\n", h.Min()) + fmt.Fprintf(w, " max: %9d\n", h.Max()) + fmt.Fprintf(w, " mean: %12.2f\n", h.Mean()) + fmt.Fprintf(w, " stddev: %12.2f\n", h.StdDev()) + fmt.Fprintf(w, " median: %12.2f\n", ps[0]) + fmt.Fprintf(w, " 75%%: %12.2f\n", ps[1]) + fmt.Fprintf(w, " 95%%: %12.2f\n", ps[2]) + fmt.Fprintf(w, " 99%%: %12.2f\n", ps[3]) + fmt.Fprintf(w, " 99.9%%: %12.2f\n", ps[4]) + case Meter: + m := metric.Snapshot() + fmt.Fprintf(w, "meter %s\n", namedMetric.name) + fmt.Fprintf(w, " count: %9d\n", m.Count()) + fmt.Fprintf(w, " 1-min rate: %12.2f\n", m.Rate1()) + fmt.Fprintf(w, " 5-min rate: %12.2f\n", m.Rate5()) + fmt.Fprintf(w, " 15-min rate: %12.2f\n", m.Rate15()) + fmt.Fprintf(w, " mean rate: %12.2f\n", m.RateMean()) + case Timer: + t := metric.Snapshot() + ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999}) + fmt.Fprintf(w, "timer %s\n", namedMetric.name) + fmt.Fprintf(w, " count: %9d\n", t.Count()) + fmt.Fprintf(w, " min: %9d\n", t.Min()) + fmt.Fprintf(w, " max: %9d\n", t.Max()) + fmt.Fprintf(w, " mean: %12.2f\n", t.Mean()) + fmt.Fprintf(w, " stddev: %12.2f\n", t.StdDev()) + fmt.Fprintf(w, " median: %12.2f\n", ps[0]) + fmt.Fprintf(w, " 75%%: %12.2f\n", ps[1]) + fmt.Fprintf(w, " 95%%: %12.2f\n", ps[2]) + fmt.Fprintf(w, " 99%%: %12.2f\n", ps[3]) + fmt.Fprintf(w, " 99.9%%: %12.2f\n", ps[4]) + fmt.Fprintf(w, " 1-min rate: %12.2f\n", t.Rate1()) + fmt.Fprintf(w, " 5-min rate: %12.2f\n", t.Rate5()) + fmt.Fprintf(w, " 15-min rate: %12.2f\n", t.Rate15()) + fmt.Fprintf(w, " mean rate: %12.2f\n", t.RateMean()) + } + } +} + +type namedMetric struct { + name string + m interface{} +} + +// namedMetricSlice is a slice of namedMetrics that implements sort.Interface. +type namedMetricSlice []namedMetric + +func (nms namedMetricSlice) Len() int { return len(nms) } + +func (nms namedMetricSlice) Swap(i, j int) { nms[i], nms[j] = nms[j], nms[i] } + +func (nms namedMetricSlice) Less(i, j int) bool { + return nms[i].name < nms[j].name +} diff --git a/vendor/vendor.json b/vendor/vendor.json index 87833020..4a05d458 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -26,6 +26,12 @@ "revision": "1850ffda9965e5174c6bdada0db130e122a214f1", "revisionTime": "2014-12-09T01:45:55Z" }, + { + "checksumSHA1": "RNby1ZoJbIzrENjgiE2hwjgkswE=", + "path": "github.com/Shopify/sarama", + "revision": "1416bd78f804d523005322194994f08c2a0ad797", + "revisionTime": "2017-02-09T16:01:41Z" + }, { "checksumSHA1": "USQFwXWz6tO69wtZdj3zZDB1MA4=", "path": "github.com/Sirupsen/logrus", @@ -50,6 +56,30 @@ "revision": "952abbca900b023c1a80bc522ff4795db50d9d6c", "revisionTime": "2014-02-08T11:57:53Z" }, + { + "checksumSHA1": "jqSVRDK7dGg6E/NikVq1Kw6gdbA=", + "path": "github.com/davecgh/go-spew/spew", + "revision": "2df174808ee097f90d259e432cc04442cf60be21", + "revisionTime": "2015-06-18T03:34:22Z" + }, + { + "checksumSHA1": "y2Kh4iPlgCPXSGTCcFpzePYdzzg=", + "path": "github.com/eapache/go-resiliency/breaker", + "revision": "b86b1ec0dd4209a588dc1285cdd471e73525c0b3", + "revisionTime": "2016-01-04T19:15:39Z" + }, + { + "checksumSHA1": "WHl96RVZlOOdF4Lb1OOadMpw8ls=", + "path": "github.com/eapache/go-xerial-snappy", + "revision": "bb955e01b9346ac19dc29eb16586c90ded99a98c", + "revisionTime": "2016-06-09T14:24:08Z" + }, + { + "checksumSHA1": "AEGF/lRMFJukJAnRqdCVQ/0I+BY=", + "path": "github.com/eapache/queue", + "revision": "ded5959c0d4e360646dc9e9908cff48666781367", + "revisionTime": "2015-06-06T11:53:03Z" + }, { "checksumSHA1": "5ftkjfUwI9A6xCQ1PwIAd5+qlo0=", "path": "github.com/elazarl/go-bindata-assetfs", @@ -57,10 +87,10 @@ "revisionTime": "2015-12-24T04:54:52Z" }, { - "checksumSHA1": "W+E/2xXcE1GmJ0Qb784ald0Fn6I=", + "checksumSHA1": "P/YMhqTnQl9HbvyC72rBhe/N32I=", "path": "github.com/golang/snappy", - "revision": "d9eb7a3d35ec988b8585d4a0068e462c27d28380", - "revisionTime": "2016-05-29T05:00:41Z" + "revision": "7db9049039a047d955fe8c19b83c8ff5abd765c7", + "revisionTime": "2017-01-19T01:47:23Z" }, { "checksumSHA1": "iIUYZyoanCQQTUaWsu8b+iOSPt4=", @@ -92,6 +122,12 @@ "revision": "28bae785206e71d70d9c770903d06abb87547734", "revisionTime": "2016-01-04T20:53:23Z" }, + { + "checksumSHA1": "7ttJJBMDGKL63tX23fNmW7r7NvQ=", + "path": "github.com/klauspost/crc32", + "revision": "6834731faf32e62a2dd809d99fb24d1e4ae5a92d", + "revisionTime": "2016-01-12T14:50:11Z" + }, { "checksumSHA1": "HIsIO4+e5awXjNSj/UJzbSePEZQ=", "path": "github.com/kr/pretty", @@ -146,6 +182,30 @@ "revision": "92647f2bd94a89b170c19e96e6456dd64ac37e1a", "revisionTime": "2015-11-20T02:40:02Z" }, + { + "checksumSHA1": "BMjSRH5mPFsBz4Z1r9f/MzwVlXA=", + "path": "github.com/pierrec/lz4", + "revision": "5c9560bfa9ace2bf86080bf40d46b34ae44604df", + "revisionTime": "2016-12-06T20:23:05Z" + }, + { + "checksumSHA1": "IT4sX58d+e8osXHV5U6YCSdB/uE=", + "path": "github.com/pierrec/xxHash/xxHash32", + "revision": "5a004441f897722c627870a981d02b29924215fa", + "revisionTime": "2016-01-12T16:53:51Z" + }, + { + "checksumSHA1": "SWV4Uo3QEGMHg1VXehu/hyDTXjk=", + "path": "github.com/raintank/metrictank/cluster/partitioner", + "revision": "c1b3cb1beb4aee2aa66d9d8f3f53a569be73ee73", + "revisionTime": "2017-02-11T18:49:35Z" + }, + { + "checksumSHA1": "smfS7rkFG9ihm9H+Gdn2OPN/oM0=", + "path": "github.com/rcrowley/go-metrics", + "revision": "7da7ed57785040df39407030c3f8f39747383bed", + "revisionTime": "2015-11-30T03:37:52Z" + }, { "checksumSHA1": "PNFiPbDwLwZs7CcqH91LH7gXI5U=", "path": "github.com/streadway/amqp", From a533123c28d03ae80132e5ab04905e04a50c4e21 Mon Sep 17 00:00:00 2001 From: Dieter Plaetinck Date: Tue, 14 Feb 2017 13:36:58 +0100 Subject: [PATCH 5/7] fix: only sleep when connect() errors --- route/kafkamdm.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/route/kafkamdm.go b/route/kafkamdm.go index f0de0f6f..eeaa63bd 100644 --- a/route/kafkamdm.go +++ b/route/kafkamdm.go @@ -111,7 +111,7 @@ func (r *KafkaMdm) run() { ticker := time.NewTicker(r.flushMaxWait) brokers := []string{r.broker} - connect := func() { + connect := func() error { var err error r.producer, err = sarama.NewSyncProducer(brokers, r.saramaCfg) if err == sarama.ErrOutOfBrokers { @@ -121,12 +121,12 @@ func (r *KafkaMdm) run() { } else { log.Notice("kafkaMdm %q: now connected to kafka", r.key) } + return err } // flushes the data to kafka and resets buffer. blocks until it succeeds flush := func() { - for r.producer == nil { - connect() + for r.producer == nil && connect() != nil { time.Sleep(time.Second) } for { From 7851e7a95b2b21a9f2aaee10ea825e7f6398a0ef Mon Sep 17 00:00:00 2001 From: woodsaj Date: Thu, 16 Feb 2017 11:15:00 +0800 Subject: [PATCH 6/7] remove unnecessary connect func literal --- route/kafkamdm.go | 14 ++++---------- 1 file changed, 4 insertions(+), 10 deletions(-) diff --git a/route/kafkamdm.go b/route/kafkamdm.go index eeaa63bd..3689c4c7 100644 --- a/route/kafkamdm.go +++ b/route/kafkamdm.go @@ -111,24 +111,20 @@ func (r *KafkaMdm) run() { ticker := time.NewTicker(r.flushMaxWait) brokers := []string{r.broker} - connect := func() error { - var err error + for r.producer == nil { r.producer, err = sarama.NewSyncProducer(brokers, r.saramaCfg) if err == sarama.ErrOutOfBrokers { log.Warning("kafkaMdm %q: %s", r.key, err) + // sleep before trying to connect again. + time.Sleep(time.Second) } else if err != nil { log.Fatal(4, "kafkaMdm %q: failed to initialize kafka producer. %s", r.key, err) - } else { - log.Notice("kafkaMdm %q: now connected to kafka", r.key) } - return err } + log.Notice("kafkaMdm %q: now connected to kafka", r.key) // flushes the data to kafka and resets buffer. blocks until it succeeds flush := func() { - for r.producer == nil && connect() != nil { - time.Sleep(time.Second) - } for { pre := time.Now() var err error @@ -194,8 +190,6 @@ func (r *KafkaMdm) run() { case <-ticker.C: if len(metrics) != 0 { flush() - } else if r.producer == nil { - connect() } } } From 67efb37d0642a595d12b1b84c577207a5b485234 Mon Sep 17 00:00:00 2001 From: Dieter Plaetinck Date: Thu, 16 Feb 2017 12:37:08 +0100 Subject: [PATCH 7/7] make it build --- route/kafkamdm.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/route/kafkamdm.go b/route/kafkamdm.go index 3689c4c7..be6aa45f 100644 --- a/route/kafkamdm.go +++ b/route/kafkamdm.go @@ -110,6 +110,7 @@ func (r *KafkaMdm) run() { metrics := make([]*schema.MetricData, 0, r.flushMaxNum) ticker := time.NewTicker(r.flushMaxWait) brokers := []string{r.broker} + var err error for r.producer == nil { r.producer, err = sarama.NewSyncProducer(brokers, r.saramaCfg) @@ -127,7 +128,6 @@ func (r *KafkaMdm) run() { flush := func() { for { pre := time.Now() - var err error size := 0 payload := make([]*sarama.ProducerMessage, len(metrics))