Add dependencies

Signed-off-by: Knut Ahlers <knut@ahlers.me>

Gopkg.lock

@@ -0,0 +1,105 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/Luzifer/rconfig"
+  packages = ["."]
+  revision = "7aef1d393c1e2d0758901853b59981c7adc67c7e"
+  version = "v1.2.0"
+
+[[projects]]
+  name = "github.com/elastic/beats"
+  packages = ["libbeat/common/dtfmt"]
+  revision = "f96db18b0c64d8eb432db6b5dd5b1a2e50d2ebc6"
+  version = "v6.2.3"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mailru/easyjson"
+  packages = [
+    ".",
+    "buffer",
+    "jlexer",
+    "jwriter"
+  ]
+  revision = "8b799c424f57fa123fc63a99d6383bc6e4c02578"
+
+[[projects]]
+  name = "github.com/olivere/elastic"
+  packages = [
+    ".",
+    "config",
+    "uritemplates"
+  ]
+  revision = "d6362604399c7af560b54f048b4fcfbdd6eff293"
+  version = "v6.1.14"
+
+[[projects]]
+  name = "github.com/pkg/errors"
+  packages = ["."]
+  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
+  version = "v0.8.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/robfig/cron"
+  packages = ["."]
+  revision = "2315d5715e36303a941d907f038da7f7c44c773b"
+
+[[projects]]
+  name = "github.com/sirupsen/logrus"
+  packages = ["."]
+  revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
+  version = "v1.0.5"
+
+[[projects]]
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  revision = "583c0c0531f06d5278b7d917446061adc344b5cd"
+  version = "v1.0.1"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/crypto"
+  packages = ["ssh/terminal"]
+  revision = "d6449816ce06963d9d136eee5a56fca5b0616e7e"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/net"
+  packages = ["context"]
+  revision = "61147c48b25b599e5b561d2e9c4f3e1ef489ca41"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows"
+  ]
+  revision = "2281fa97ef7b0c26324634d5a22f04babdac8713"
+
+[[projects]]
+  branch = "v3"
+  name = "gopkg.in/sohlich/elogrus.v3"
+  packages = ["."]
+  revision = "1fa29e2f2009c129693c7079e5f6361bfbd34080"
+
+[[projects]]
+  branch = "v2"
+  name = "gopkg.in/validator.v2"
+  packages = ["."]
+  revision = "59c90c7046f643cbe0d4e7c8776c42a84ce75910"
+
+[[projects]]
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+  version = "v2.2.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "57ef91098241abc720c170776c37412d23027754a0718761d1bdc5b614d3f3a6"
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,62 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/Luzifer/rconfig"
+  version = "1.2.0"
+
+[[constraint]]
+  name = "github.com/elastic/beats"
+  version = "6.2.3"
+
+[[constraint]]
+  name = "github.com/olivere/elastic"
+  version = "6.1.14"
+
+[[constraint]]
+  name = "github.com/robfig/cron"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/sirupsen/logrus"
+  version = "1.0.5"
+
+[[constraint]]
+  branch = "master"
+  name = "golang.org/x/net"
+
+[[constraint]]
+  branch = "v3"
+  name = "gopkg.in/sohlich/elogrus.v3"
+
+[[constraint]]
+  name = "gopkg.in/yaml.v2"
+  version = "2.2.1"
+
+[prune]
+  go-tests = true
+  unused-packages = true

README.md

@@ -2,6 +2,8 @@
 
 This project is a quick and dirty replacement for running a cron daemon inside docker containers while logging into an elasticsearch instance.
 
+The code is basically a fork of the [rsyslog\_cron](https://github.com/Luzifer/rsyslog_cron) repo modified to log into elasticsearch.
+
 ## Advantages
 
 - It logs the output of the jobs into an elasticsearch instance

vendor/github.com/Luzifer/rconfig/.travis.yml

@@ -0,0 +1,8 @@
+language: go
+
+go:
+  - 1.6
+  - 1.7
+  - tip
+
+script: go test -v -race -cover ./...

vendor/github.com/Luzifer/rconfig/History.md

@@ -0,0 +1,9 @@
+# 1.2.0 / 2017-06-19
+
+  * Add ParseAndValidate method
+
+# 1.1.0 / 2016-06-28
+
+  * Support time.Duration config parameters
+  * Added goreportcard badge
+  * Added testcase for using bool with ENV and default

vendor/github.com/Luzifer/rconfig/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2015 Knut Ahlers <knut@ahlers.me>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/Luzifer/rconfig/README.md

@@ -0,0 +1,87 @@
+[![Build Status](https://travis-ci.org/Luzifer/rconfig.svg?branch=master)](https://travis-ci.org/Luzifer/rconfig)
+[![License: Apache v2.0](https://badge.luzifer.io/v1/badge?color=5d79b5&title=license&text=Apache+v2.0)](http://www.apache.org/licenses/LICENSE-2.0)
+[![Documentation](https://badge.luzifer.io/v1/badge?title=godoc&text=reference)](https://godoc.org/github.com/Luzifer/rconfig)
+[![Go Report](http://goreportcard.com/badge/Luzifer/rconfig)](http://goreportcard.com/report/Luzifer/rconfig)
+
+## Description
+
+> Package rconfig implements a CLI configuration reader with struct-embedded defaults, environment variables and posix compatible flag parsing using the [pflag](https://github.com/spf13/pflag) library.
+
+## Installation
+
+Install by running:
+
+```
+go get -u github.com/Luzifer/rconfig
+```
+
+OR fetch a specific version:
+
+```
+go get -u gopkg.in/luzifer/rconfig.v1
+```
+
+Run tests by running:
+
+```
+go test -v -race -cover github.com/Luzifer/rconfig
+```
+
+## Usage
+
+A very simple usecase is to just configure a struct inside the vars section of your `main.go` and to parse the commandline flags from the `main()` function:
+
+```go
+package main
+
+import (
+  "fmt"
+  "github.com/Luzifer/rconfig"
+)
+
+var (
+  cfg = struct {
+    Username string `default:"unknown" flag:"user" description:"Your name"`
+    Details  struct {
+      Age int `default:"25" flag:"age" env:"age" description:"Your age"`
+    }
+  }{}
+)
+
+func main() {
+  rconfig.Parse(&cfg)
+
+  fmt.Printf("Hello %s, happy birthday for your %dth birthday.",
+    cfg.Username,
+    cfg.Details.Age)
+}
+```
+
+### Provide variable defaults by using a file
+
+Given you have a file `~/.myapp.yml` containing some secrets or usernames (for the example below username is assumed to be "luzifer") as a default configuration for your application you can use this source code to load the defaults from that file using the `vardefault` tag in your configuration struct.
+
+The order of the directives (lower number = higher precedence):
+
+1. Flags provided in command line
+1. Environment variables
+1. Variable defaults (`vardefault` tag in the struct)
+1. `default` tag in the struct
+
+```go
+var cfg = struct {
+  Username string `vardefault:"username" flag:"username" description:"Your username"`
+}
+
+func main() {
+  rconfig.SetVariableDefaults(rconfig.VarDefaultsFromYAMLFile("~/.myapp.yml"))
+  rconfig.Parse(&cfg)
+
+  fmt.Printf("Username = %s", cfg.Username)
+  // Output: Username = luzifer
+}
+```
+
+## More info
+
+You can see the full reference documentation of the rconfig package [at godoc.org](https://godoc.org/github.com/Luzifer/rconfig), or through go's standard documentation system by running `godoc -http=:6060` and browsing to [http://localhost:6060/pkg/github.com/Luzifer/rconfig](http://localhost:6060/pkg/github.com/Luzifer/rconfig) after installation.

vendor/github.com/Luzifer/rconfig/config.go

@@ -0,0 +1,356 @@
+// Package rconfig implements a CLI configuration reader with struct-embedded
+// defaults, environment variables and posix compatible flag parsing using
+// the pflag library.
+package rconfig
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/spf13/pflag"
+	validator "gopkg.in/validator.v2"
+)
+
+var (
+	fs               *pflag.FlagSet
+	variableDefaults map[string]string
+)
+
+func init() {
+	variableDefaults = make(map[string]string)
+}
+
+// Parse takes the pointer to a struct filled with variables which should be read
+// from ENV, default or flag. The precedence in this is flag > ENV > default. So
+// if a flag is specified on the CLI it will overwrite the ENV and otherwise ENV
+// overwrites the default specified.
+//
+// For your configuration struct you can use the following struct-tags to control
+// the behavior of rconfig:
+//
+//     default: Set a default value
+//     vardefault: Read the default value from the variable defaults
+//     env: Read the value from this environment variable
+//     flag: Flag to read in format "long,short" (for example "listen,l")
+//     description: A help text for Usage output to guide your users
+//
+// The format you need to specify those values you can see in the example to this
+// function.
+//
+func Parse(config interface{}) error {
+	return parse(config, nil)
+}
+
+// ParseAndValidate works exactly like Parse but implements an additional run of
+// the go-validator package on the configuration struct. Therefore additonal struct
+// tags are supported like described in the readme file of the go-validator package:
+//
+// https://github.com/go-validator/validator/tree/v2#usage
+func ParseAndValidate(config interface{}) error {
+	return parseAndValidate(config, nil)
+}
+
+// Args returns the non-flag command-line arguments.
+func Args() []string {
+	return fs.Args()
+}
+
+// Usage prints a basic usage with the corresponding defaults for the flags to
+// os.Stdout. The defaults are derived from the `default` struct-tag and the ENV.
+func Usage() {
+	if fs != nil && fs.Parsed() {
+		fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+		fs.PrintDefaults()
+	}
+}
+
+// SetVariableDefaults presets the parser with a map of default values to be used
+// when specifying the vardefault tag
+func SetVariableDefaults(defaults map[string]string) {
+	variableDefaults = defaults
+}
+
+func parseAndValidate(in interface{}, args []string) error {
+	if err := parse(in, args); err != nil {
+		return err
+	}
+
+	return validator.Validate(in)
+}
+
+func parse(in interface{}, args []string) error {
+	if args == nil {
+		args = os.Args
+	}
+
+	fs = pflag.NewFlagSet(os.Args[0], pflag.ExitOnError)
+	if err := execTags(in, fs); err != nil {
+		return err
+	}
+
+	return fs.Parse(args)
+}
+
+func execTags(in interface{}, fs *pflag.FlagSet) error {
+	if reflect.TypeOf(in).Kind() != reflect.Ptr {
+		return errors.New("Calling parser with non-pointer")
+	}
+
+	if reflect.ValueOf(in).Elem().Kind() != reflect.Struct {
+		return errors.New("Calling parser with pointer to non-struct")
+	}
+
+	st := reflect.ValueOf(in).Elem()
+	for i := 0; i < st.NumField(); i++ {
+		valField := st.Field(i)
+		typeField := st.Type().Field(i)
+
+		if typeField.Tag.Get("default") == "" && typeField.Tag.Get("env") == "" && typeField.Tag.Get("flag") == "" && typeField.Type.Kind() != reflect.Struct {
+			// None of our supported tags is present and it's not a sub-struct
+			continue
+		}
+
+		value := varDefault(typeField.Tag.Get("vardefault"), typeField.Tag.Get("default"))
+		value = envDefault(typeField.Tag.Get("env"), value)
+		parts := strings.Split(typeField.Tag.Get("flag"), ",")
+
+		switch typeField.Type {
+		case reflect.TypeOf(time.Duration(0)):
+			v, err := time.ParseDuration(value)
+			if err != nil {
+				if value == "" {
+					v = time.Duration(0)
+				} else {
+					return err
+				}
+			}
+
+			if typeField.Tag.Get("flag") != "" {
+				if len(parts) == 1 {
+					fs.DurationVar(valField.Addr().Interface().(*time.Duration), parts[0], v, typeField.Tag.Get("description"))
+				} else {
+					fs.DurationVarP(valField.Addr().Interface().(*time.Duration), parts[0], parts[1], v, typeField.Tag.Get("description"))
+				}
+			} else {
+				valField.Set(reflect.ValueOf(v))
+			}
+			continue
+		}
+
+		switch typeField.Type.Kind() {
+		case reflect.String:
+			if typeField.Tag.Get("flag") != "" {
+				if len(parts) == 1 {
+					fs.StringVar(valField.Addr().Interface().(*string), parts[0], value, typeField.Tag.Get("description"))
+				} else {
+					fs.StringVarP(valField.Addr().Interface().(*string), parts[0], parts[1], value, typeField.Tag.Get("description"))
+				}
+			} else {
+				valField.SetString(value)
+			}
+
+		case reflect.Bool:
+			v := value == "true"
+			if typeField.Tag.Get("flag") != "" {
+				if len(parts) == 1 {
+					fs.BoolVar(valField.Addr().Interface().(*bool), parts[0], v, typeField.Tag.Get("description"))
+				} else {
+					fs.BoolVarP(valField.Addr().Interface().(*bool), parts[0], parts[1], v, typeField.Tag.Get("description"))
+				}
+			} else {
+				valField.SetBool(v)
+			}
+
+		case reflect.Int, reflect.Int8, reflect.Int32, reflect.Int64:
+			vt, err := strconv.ParseInt(value, 10, 64)
+			if err != nil {
+				if value == "" {
+					vt = 0
+				} else {
+					return err
+				}
+			}
+			if typeField.Tag.Get("flag") != "" {
+				registerFlagInt(typeField.Type.Kind(), fs, valField.Addr().Interface(), parts, vt, typeField.Tag.Get("description"))
+			} else {
+				valField.SetInt(vt)
+			}
+
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			vt, err := strconv.ParseUint(value, 10, 64)
+			if err != nil {
+				if value == "" {
+					vt = 0
+				} else {
+					return err
+				}
+			}
+			if typeField.Tag.Get("flag") != "" {
+				registerFlagUint(typeField.Type.Kind(), fs, valField.Addr().Interface(), parts, vt, typeField.Tag.Get("description"))
+			} else {
+				valField.SetUint(vt)
+			}
+
+		case reflect.Float32, reflect.Float64:
+			vt, err := strconv.ParseFloat(value, 64)
+			if err != nil {
+				if value == "" {
+					vt = 0.0
+				} else {
+					return err
+				}
+			}
+			if typeField.Tag.Get("flag") != "" {
+				registerFlagFloat(typeField.Type.Kind(), fs, valField.Addr().Interface(), parts, vt, typeField.Tag.Get("description"))
+			} else {
+				valField.SetFloat(vt)
+			}
+
+		case reflect.Struct:
+			if err := execTags(valField.Addr().Interface(), fs); err != nil {
+				return err
+			}
+
+		case reflect.Slice:
+			switch typeField.Type.Elem().Kind() {
+			case reflect.Int:
+				def := []int{}
+				for _, v := range strings.Split(value, ",") {
+					it, err := strconv.ParseInt(strings.TrimSpace(v), 10, 64)
+					if err != nil {
+						return err
+					}
+					def = append(def, int(it))
+				}
+				if len(parts) == 1 {
+					fs.IntSliceVar(valField.Addr().Interface().(*[]int), parts[0], def, typeField.Tag.Get("description"))
+				} else {
+					fs.IntSliceVarP(valField.Addr().Interface().(*[]int), parts[0], parts[1], def, typeField.Tag.Get("description"))
+				}
+			case reflect.String:
+				del := typeField.Tag.Get("delimiter")
+				if len(del) == 0 {
+					del = ","
+				}
+				def := strings.Split(value, del)
+				if len(parts) == 1 {
+					fs.StringSliceVar(valField.Addr().Interface().(*[]string), parts[0], def, typeField.Tag.Get("description"))
+				} else {
+					fs.StringSliceVarP(valField.Addr().Interface().(*[]string), parts[0], parts[1], def, typeField.Tag.Get("description"))
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func registerFlagFloat(t reflect.Kind, fs *pflag.FlagSet, field interface{}, parts []string, vt float64, desc string) {
+	switch t {
+	case reflect.Float32:
+		if len(parts) == 1 {
+			fs.Float32Var(field.(*float32), parts[0], float32(vt), desc)
+		} else {
+			fs.Float32VarP(field.(*float32), parts[0], parts[1], float32(vt), desc)
+		}
+	case reflect.Float64:
+		if len(parts) == 1 {
+			fs.Float64Var(field.(*float64), parts[0], float64(vt), desc)
+		} else {
+			fs.Float64VarP(field.(*float64), parts[0], parts[1], float64(vt), desc)
+		}
+	}
+}
+
+func registerFlagInt(t reflect.Kind, fs *pflag.FlagSet, field interface{}, parts []string, vt int64, desc string) {
+	switch t {
+	case reflect.Int:
+		if len(parts) == 1 {
+			fs.IntVar(field.(*int), parts[0], int(vt), desc)
+		} else {
+			fs.IntVarP(field.(*int), parts[0], parts[1], int(vt), desc)
+		}
+	case reflect.Int8:
+		if len(parts) == 1 {
+			fs.Int8Var(field.(*int8), parts[0], int8(vt), desc)
+		} else {
+			fs.Int8VarP(field.(*int8), parts[0], parts[1], int8(vt), desc)
+		}
+	case reflect.Int32:
+		if len(parts) == 1 {
+			fs.Int32Var(field.(*int32), parts[0], int32(vt), desc)
+		} else {
+			fs.Int32VarP(field.(*int32), parts[0], parts[1], int32(vt), desc)
+		}
+	case reflect.Int64:
+		if len(parts) == 1 {
+			fs.Int64Var(field.(*int64), parts[0], int64(vt), desc)
+		} else {
+			fs.Int64VarP(field.(*int64), parts[0], parts[1], int64(vt), desc)
+		}
+	}
+}
+
+func registerFlagUint(t reflect.Kind, fs *pflag.FlagSet, field interface{}, parts []string, vt uint64, desc string) {
+	switch t {
+	case reflect.Uint:
+		if len(parts) == 1 {
+			fs.UintVar(field.(*uint), parts[0], uint(vt), desc)
+		} else {
+			fs.UintVarP(field.(*uint), parts[0], parts[1], uint(vt), desc)
+		}
+	case reflect.Uint8:
+		if len(parts) == 1 {
+			fs.Uint8Var(field.(*uint8), parts[0], uint8(vt), desc)
+		} else {
+			fs.Uint8VarP(field.(*uint8), parts[0], parts[1], uint8(vt), desc)
+		}
+	case reflect.Uint16:
+		if len(parts) == 1 {
+			fs.Uint16Var(field.(*uint16), parts[0], uint16(vt), desc)
+		} else {
+			fs.Uint16VarP(field.(*uint16), parts[0], parts[1], uint16(vt), desc)
+		}
+	case reflect.Uint32:
+		if len(parts) == 1 {
+			fs.Uint32Var(field.(*uint32), parts[0], uint32(vt), desc)
+		} else {
+			fs.Uint32VarP(field.(*uint32), parts[0], parts[1], uint32(vt), desc)
+		}
+	case reflect.Uint64:
+		if len(parts) == 1 {
+			fs.Uint64Var(field.(*uint64), parts[0], uint64(vt), desc)
+		} else {
+			fs.Uint64VarP(field.(*uint64), parts[0], parts[1], uint64(vt), desc)
+		}
+	}
+}
+
+func envDefault(env, def string) string {
+	value := def
+
+	if env != "" {
+		if e := os.Getenv(env); e != "" {
+			value = e
+		}
+	}
+
+	return value
+}
+
+func varDefault(name, def string) string {
+	value := def
+
+	if name != "" {
+		if v, ok := variableDefaults[name]; ok {
+			value = v
+		}
+	}
+
+	return value
+}

vendor/github.com/Luzifer/rconfig/vardefault_providers.go

@@ -0,0 +1,27 @@
+package rconfig
+
+import (
+	"io/ioutil"
+
+	"gopkg.in/yaml.v2"
+)
+
+// VarDefaultsFromYAMLFile reads contents of a file and calls VarDefaultsFromYAML
+func VarDefaultsFromYAMLFile(filename string) map[string]string {
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return make(map[string]string)
+	}
+
+	return VarDefaultsFromYAML(data)
+}
+
+// VarDefaultsFromYAML creates a vardefaults map from YAML raw data
+func VarDefaultsFromYAML(in []byte) map[string]string {
+	out := make(map[string]string)
+	err := yaml.Unmarshal(in, &out)
+	if err != nil {
+		return make(map[string]string)
+	}
+	return out
+}

vendor/github.com/elastic/beats/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2012–2017 Elastic <http://www.elastic.co>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/elastic/beats/dev-tools/generate_notice.py

@@ -0,0 +1,279 @@
+from __future__ import print_function
+
+import glob
+import os
+import datetime
+import argparse
+import json
+import csv
+import re
+
+
+def read_file(filename):
+
+    if not os.path.isfile(filename):
+        print("File not found {}".format(filename))
+        return ""
+
+    try:
+        with open(filename, 'r') as f:
+            return f.read()
+    except UnicodeDecodeError:
+        # try latin-1
+        with open(filename, 'r', encoding="ISO-8859-1") as f:
+            return f.read()
+
+
+def get_library_path(license):
+    """
+    Get the contents up to the vendor folder.
+    """
+    split = license.split(os.sep)
+    for i, word in reversed(list(enumerate(split))):
+        if word == "vendor":
+            return "/".join(split[i + 1:])
+    return "/".join(split)
+
+
+def read_versions(vendor):
+    libs = []
+    with open(os.path.join(vendor, "vendor.json")) as f:
+        govendor = json.load(f)
+        for package in govendor["package"]:
+            libs.append(package)
+    return libs
+
+
+def gather_dependencies(vendor_dirs):
+    dependencies = {}   # lib_path -> [array of lib]
+    for vendor in vendor_dirs:
+        libs = read_versions(vendor)
+
+        # walk looking for LICENSE files
+        for root, dirs, filenames in os.walk(vendor):
+            for filename in sorted(filenames):
+                if filename.startswith("LICENSE"):
+                    lib_path = get_library_path(root)
+                    lib_search = [l for l in libs if l["path"].startswith(lib_path)]
+                    if len(lib_search) == 0:
+                        print("WARNING: No version information found for: {}".format(lib_path))
+                        lib = {"path": lib_path}
+                    else:
+                        lib = lib_search[0]
+                    lib["license_file"] = os.path.join(root, filename)
+
+                    lib["license_contents"] = read_file(lib["license_file"])
+                    lib["license_summary"] = detect_license_summary(lib["license_contents"])
+                    if lib["license_summary"] == "UNKNOWN":
+                        print("WARNING: Unknown license for: {}".format(lib_path))
+
+                    if lib_path not in dependencies:
+                        dependencies[lib_path] = [lib]
+                    else:
+                        dependencies[lib_path].append(lib)
+
+            # don't walk down into another vendor dir
+            if "vendor" in dirs:
+                dirs.remove("vendor")
+    return dependencies
+
+
+def write_notice_file(f, beat, copyright, dependencies):
+
+    now = datetime.datetime.now()
+
+    # Add header
+    f.write("{}\n".format(beat))
+    f.write("Copyright 2014-{0} {1}\n".format(now.year, copyright))
+    f.write("\n")
+    f.write("This product includes software developed by The Apache Software \n" +
+            "Foundation (http://www.apache.org/).\n\n")
+
+    # Add licenses for 3rd party libraries
+    f.write("==========================================================================\n")
+    f.write("Third party libraries used by the {} project:\n".format(beat))
+    f.write("==========================================================================\n\n")
+
+    # Sort licenses by package path, ignore upper / lower case
+    for key in sorted(dependencies, key=str.lower):
+        for lib in dependencies[key]:
+            f.write("\n--------------------------------------------------------------------\n")
+            f.write("Dependency: {}\n".format(key))
+            if "version" in lib:
+                f.write("Version: {}\n".format(lib["version"]))
+            if "revision" in lib:
+                f.write("Revision: {}\n".format(lib["revision"]))
+            f.write("License type (autodetected): {}\n".format(lib["license_summary"]))
+            f.write("{}:\n".format(lib["license_file"]))
+            f.write("--------------------------------------------------------------------\n")
+            if lib["license_summary"] != "Apache-2.0":
+                f.write(lib["license_contents"])
+            else:
+                # it's an Apache License, so include only the NOTICE file
+                f.write("Apache License 2.0\n\n")
+
+                # Skip NOTICE files which are not needed
+                if os.path.join(os.path.dirname(lib["license_file"])) in SKIP_NOTICE:
+                    continue
+
+                for notice_file in glob.glob(os.path.join(os.path.dirname(lib["license_file"]), "NOTICE*")):
+                    notice_file_hdr = "-------{}-----\n".format(os.path.basename(notice_file))
+                    f.write(notice_file_hdr)
+                    f.write(read_file(notice_file))
+
+
+def write_csv_file(csvwriter, dependencies):
+    csvwriter.writerow(["name", "url", "version", "revision", "license"])
+    for key in sorted(dependencies, key=str.lower):
+        for lib in dependencies[key]:
+            csvwriter.writerow([key, get_url(key), lib.get("version", ""), lib.get("revision", ""),
+                                lib["license_summary"]])
+
+
+def get_url(repo):
+    words = repo.split("/")
+    if words[0] != "github.com":
+        return repo
+    return "https://github.com/{}/{}".format(words[1], words[2])
+
+
+def create_notice(filename, beat, copyright, vendor_dirs, csvfile):
+    dependencies = gather_dependencies(vendor_dirs)
+    if not csvfile:
+        with open(filename, "w+") as f:
+            write_notice_file(f, beat, copyright, dependencies)
+    else:
+        with open(csvfile, "wb") as f:
+            csvwriter = csv.writer(f)
+            write_csv_file(csvwriter, dependencies)
+
+
+APACHE2_LICENSE_TITLES = [
+    "Apache License Version 2.0",
+    "Apache License, Version 2.0"
+]
+
+MIT_LICENSES = [
+    re.sub(r"\s+", " ", """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.
+    """),
+    re.sub(r"\s+", " ", """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.""")
+]
+
+BSD_LICENSE_CONTENTS = [
+    re.sub(r"\s+", " ", """Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:"""),
+    re.sub(r"\s+", " ", """Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer."""),
+    re.sub(r"\s+", " ", """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.
+""")]
+
+BSD_LICENSE_3_CLAUSE = [
+    re.sub(r"\s+", " ", """Neither the name of"""),
+    re.sub(r"\s+", " ", """nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.""")
+]
+
+BSD_LICENSE_4_CLAUSE = [
+    re.sub(r"\s+", " ", """All advertising materials mentioning features or use of this software
+   must display the following acknowledgement"""),
+]
+
+CC_SA_4_LICENSE_TITLE = [
+    "Creative Commons Attribution-ShareAlike 4.0 International"
+]
+
+LGPL_3_LICENSE_TITLE = [
+    "GNU LESSER GENERAL PUBLIC LICENSE Version 3"
+]
+
+MPL_LICENSE_TITLES = [
+    "Mozilla Public License Version 2.0",
+    "Mozilla Public License, version 2.0"
+]
+
+
+# return SPDX identifiers from https://spdx.org/licenses/
+def detect_license_summary(content):
+    # replace all white spaces with a single space
+    content = re.sub(r"\s+", ' ', content)
+    if any(sentence in content[0:1000] for sentence in APACHE2_LICENSE_TITLES):
+        return "Apache-2.0"
+    if any(sentence in content[0:1000] for sentence in MIT_LICENSES):
+        return "MIT"
+    if all(sentence in content[0:1000] for sentence in BSD_LICENSE_CONTENTS):
+        if all(sentence in content[0:1000] for sentence in BSD_LICENSE_3_CLAUSE):
+            if all(sentence in content[0:1000] for sentence in BSD_LICENSE_4_CLAUSE):
+                return "BSD-4-Clause"
+            return "BSD-3-Clause"
+        else:
+            return "BSD-2-Clause"
+    if any(sentence in content[0:300] for sentence in MPL_LICENSE_TITLES):
+        return "MPL-2.0"
+    if any(sentence in content[0:3000] for sentence in CC_SA_4_LICENSE_TITLE):
+        return "CC-BY-SA-4.0"
+    if any(sentence in content[0:3000] for sentence in LGPL_3_LICENSE_TITLE):
+        return "LGPL-3.0"
+
+    return "UNKNOWN"
+
+
+SKIP_NOTICE = []
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(
+        description="Generate the NOTICE file from all vendor directories available in a given directory")
+    parser.add_argument("vendor",
+                        help="directory where to search for vendor directories")
+    parser.add_argument("-b", "--beat", default="Elastic Beats",
+                        help="Beat name")
+    parser.add_argument("-c", "--copyright", default="Elasticsearch BV",
+                        help="copyright owner")
+    parser.add_argument("--csv", dest="csvfile",
+                        help="Output to a csv file")
+    parser.add_argument("-e", "--excludes", default=["dev-tools", "build"],
+                        help="List of top directories to exclude")
+    parser.add_argument("-s", "--skip-notice", default=[],
+                        help="List of NOTICE files to skip")
+    args = parser.parse_args()
+
+    cwd = os.getcwd()
+    notice = os.path.join(cwd, "NOTICE.txt")
+    vendor_dirs = []
+
+    excludes = args.excludes
+    if not isinstance(excludes, list):
+        excludes = [excludes]
+    SKIP_NOTICE = args.skip_notice
+
+    for root, dirs, files in os.walk(args.vendor):
+
+        # Skips all hidden paths like ".git"
+        if '/.' in root:
+            continue
+
+        if 'vendor' in dirs:
+            vendor_dirs.append(os.path.join(root, 'vendor'))
+            dirs.remove('vendor')   # don't walk down into sub-vendors
+
+        for exclude in excludes:
+            if exclude in dirs:
+                dirs.remove(exclude)
+
+    print("Get the licenses available from {}".format(vendor_dirs))
+    create_notice(notice, args.beat, args.copyright, vendor_dirs, args.csvfile)
+
+    print("Available at {}".format(notice))

vendor/github.com/elastic/beats/generator/beat/{beat}/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2017 {full_name}
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/elastic/beats/generator/beat/{beat}/NOTICE

@@ -0,0 +1,5 @@
+{beat}
+Copyright 2017 {full_name}
+
+This product includes software developed by The Apache Software
+Foundation (http://www.apache.org/).

vendor/github.com/elastic/beats/generator/metricbeat/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2012–2016 Elasticsearch <http://www.elastic.co>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/elastic/beats/generator/metricbeat/{beat}/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2017 {full_name}
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/elastic/beats/generator/metricbeat/{beat}/NOTICE

@@ -0,0 +1,5 @@
+{beat}
+Copyright 2017 {full_name}
+
+This product includes software developed by The Apache Software
+Foundation (http://www.apache.org/).

vendor/github.com/elastic/beats/libbeat/common/dtfmt/builder.go

@@ -0,0 +1,243 @@
+package dtfmt
+
+type builder struct {
+	elements []element
+}
+
+func newBuilder() *builder {
+	return &builder{}
+}
+
+func (b *builder) estimateSize() int {
+	sz := 0
+	for _, e := range b.elements {
+		sz += e.estimateSize()
+	}
+	return sz
+}
+
+func (b *builder) createConfig() (ctxConfig, error) {
+	cfg := ctxConfig{}
+	for _, e := range b.elements {
+		if err := e.requires(&cfg); err != nil {
+			return ctxConfig{}, err
+		}
+	}
+	return cfg, nil
+}
+
+func (b *builder) compile() (prog, error) {
+	p := prog{}
+
+	for _, e := range b.elements {
+		tmp, err := e.compile()
+		if err != nil {
+			return prog{}, err
+		}
+
+		p.p = append(p.p, tmp.p...)
+	}
+	return p, nil
+}
+
+func (b *builder) optimize() {
+	if len(b.elements) == 0 {
+		return
+	}
+
+	// combine rune/string literals
+	el := b.elements[:1]
+	for _, e := range b.elements[1:] {
+		last := el[len(el)-1]
+		if r, ok := e.(runeLiteral); ok {
+			if l, ok := last.(runeLiteral); ok {
+				el[len(el)-1] = stringLiteral{
+					append(append([]byte{}, string(l.r)...), string(r.r)...),
+				}
+			} else if l, ok := last.(stringLiteral); ok {
+				el[len(el)-1] = stringLiteral{append(l.s, string(r.r)...)}
+			} else {
+				el = append(el, e)
+			}
+		} else if s, ok := e.(stringLiteral); ok {
+			if l, ok := last.(runeLiteral); ok {
+				el[len(el)-1] = stringLiteral{
+					append(append([]byte{}, string(l.r)...), s.s...),
+				}
+			} else if l, ok := last.(stringLiteral); ok {
+				el[len(el)-1] = stringLiteral{append(l.s, s.s...)}
+			} else {
+				el = append(el, e)
+			}
+		} else {
+			el = append(el, e)
+		}
+	}
+	b.elements = el
+}
+
+func (b *builder) add(e element) {
+	b.elements = append(b.elements, e)
+}
+
+func (b *builder) millisOfSecond(digits int) {
+	if digits <= 0 {
+		return
+	}
+
+	switch digits {
+	case 1:
+		b.appendExtDecimal(ftMillisOfSecond, 100, 1, 1)
+	case 2:
+		b.appendExtDecimal(ftMillisOfSecond, 10, 2, 2)
+	case 3:
+		b.appendExtDecimal(ftMillisOfSecond, 0, 3, 3)
+	default:
+		b.appendExtDecimal(ftMillisOfSecond, 0, 3, 3)
+		b.appendZeros(digits - 3)
+	}
+}
+
+func (b *builder) millisOfDay(digits int) {
+	b.appendDecimal(ftMillisOfDay, digits, 8)
+}
+
+func (b *builder) secondOfMinute(digits int) {
+	b.appendDecimal(ftSecondOfMinute, digits, 2)
+}
+
+func (b *builder) secondOfDay(digits int) {
+	b.appendDecimal(ftSecondOfDay, digits, 5)
+}
+
+func (b *builder) minuteOfHour(digits int) {
+	b.appendDecimal(ftMinuteOfHour, digits, 2)
+}
+
+func (b *builder) minuteOfDay(digits int) {
+	b.appendDecimal(ftMinuteOfDay, digits, 4)
+}
+
+func (b *builder) hourOfDay(digits int) {
+	b.appendDecimal(ftHourOfDay, digits, 2)
+}
+
+func (b *builder) clockhourOfDay(digits int) {
+	b.appendDecimal(ftClockhourOfDay, digits, 2)
+}
+
+func (b *builder) hourOfHalfday(digits int) {
+	b.appendDecimal(ftHourOfHalfday, digits, 2)
+}
+
+func (b *builder) clockhourOfHalfday(digits int) {
+	b.appendDecimal(ftClockhourOfHalfday, digits, 2)
+}
+
+func (b *builder) dayOfWeek(digits int) {
+	b.appendDecimal(ftDayOfWeek, digits, 1)
+}
+
+func (b *builder) dayOfMonth(digits int) {
+	b.appendDecimal(ftDayOfMonth, digits, 2)
+}
+
+func (b *builder) dayOfYear(digits int) {
+	b.appendDecimal(ftDayOfYear, digits, 3)
+}
+
+func (b *builder) weekOfWeekyear(digits int) {
+	b.appendDecimal(ftWeekOfWeekyear, digits, 2)
+}
+
+func (b *builder) weekyear(minDigits, maxDigits int) {
+	b.appendDecimal(ftWeekyear, minDigits, maxDigits)
+}
+
+func (b *builder) monthOfYear(digits int) {
+	b.appendDecimal(ftMonthOfYear, digits, 2)
+}
+
+func (b *builder) year(minDigits, maxDigits int) {
+	b.appendSigned(ftYear, minDigits, maxDigits)
+}
+
+func (b *builder) twoDigitYear() {
+	b.add(twoDigitYear{ftYear})
+}
+
+func (b *builder) twoDigitWeekYear() {
+	b.add(twoDigitYear{ftWeekyear})
+}
+
+func (b *builder) halfdayOfDayText() {
+	b.appendText(ftHalfdayOfDay)
+}
+
+func (b *builder) dayOfWeekText() {
+	b.appendText(ftDayOfWeek)
+}
+
+func (b *builder) dayOfWeekShortText() {
+	b.appendShortText(ftDayOfWeek)
+}
+
+func (b *builder) monthOfYearText() {
+	b.appendText(ftMonthOfYear)
+}
+
+func (b *builder) monthOfYearShortText() {
+	b.appendShortText(ftMonthOfYear)
+}
+
+// TODO: add timezone support
+
+func (b *builder) appendRune(r rune) {
+	b.add(runeLiteral{r})
+}
+
+func (b *builder) appendLiteral(l string) {
+	switch len(l) {
+	case 0:
+	case 1:
+		b.add(runeLiteral{rune(l[0])})
+	default:
+		b.add(stringLiteral{[]byte(l)})
+	}
+}
+
+func (b *builder) appendDecimalValue(ft fieldType, minDigits, maxDigits int, signed bool) {
+	if maxDigits < minDigits {
+		maxDigits = minDigits
+	}
+
+	if minDigits <= 1 {
+		b.add(unpaddedNumber{ft, maxDigits, signed})
+	} else {
+		b.add(paddedNumber{ft, 0, minDigits, maxDigits, signed})
+	}
+}
+
+func (b *builder) appendExtDecimal(ft fieldType, div, minDigits, maxDigits int) {
+	b.add(paddedNumber{ft, div, minDigits, maxDigits, false})
+}
+
+func (b *builder) appendDecimal(ft fieldType, minDigits, maxDigits int) {
+	b.appendDecimalValue(ft, minDigits, maxDigits, false)
+}
+
+func (b *builder) appendSigned(ft fieldType, minDigits, maxDigits int) {
+	b.appendDecimalValue(ft, minDigits, maxDigits, true)
+}
+
+func (b *builder) appendZeros(count int) {
+	b.add(paddingZeros{count})
+}
+
+func (b *builder) appendText(ft fieldType) {
+	b.add(textField{ft, false})
+}
+
+func (b *builder) appendShortText(ft fieldType) {
+	b.add(textField{ft, true})
+}

vendor/github.com/elastic/beats/libbeat/common/dtfmt/ctx.go

@@ -0,0 +1,81 @@
+package dtfmt
+
+import (
+	"time"
+)
+
+// ctx stores pre-computed time fields used by the formatter.
+type ctx struct {
+	year             int
+	month            time.Month
+	day              int
+	weekday          time.Weekday
+	yearday          int
+	isoWeek, isoYear int
+
+	hour, min, sec int
+	millis         int
+
+	buf []byte
+}
+
+type ctxConfig struct {
+	date    bool
+	clock   bool
+	weekday bool
+	yearday bool
+	millis  bool
+	iso     bool
+}
+
+func (c *ctx) initTime(config *ctxConfig, t time.Time) {
+	if config.date {
+		c.year, c.month, c.day = t.Date()
+	}
+	if config.clock {
+		c.hour, c.min, c.sec = t.Clock()
+	}
+	if config.iso {
+		c.isoYear, c.isoWeek = t.ISOWeek()
+	}
+
+	if config.millis {
+		c.millis = t.Nanosecond() / 1000000
+	}
+
+	if config.yearday {
+		c.yearday = t.YearDay()
+	}
+
+	if config.weekday {
+		c.weekday = t.Weekday()
+	}
+}
+
+func (c *ctxConfig) enableDate() {
+	c.date = true
+}
+
+func (c *ctxConfig) enableClock() {
+	c.clock = true
+}
+
+func (c *ctxConfig) enableMillis() {
+	c.millis = true
+}
+
+func (c *ctxConfig) enableWeekday() {
+	c.weekday = true
+}
+
+func (c *ctxConfig) enableYearday() {
+	c.yearday = true
+}
+
+func (c *ctxConfig) enableISO() {
+	c.iso = true
+}
+
+func isLeap(year int) bool {
+	return year%4 == 0 && (year%100 != 0 || year%400 == 0)
+}

vendor/github.com/elastic/beats/libbeat/common/dtfmt/doc.go

@@ -0,0 +1,64 @@
+// Package dtfmt provides time formatter support with pattern syntax mostly
+// similar to joda DateTimeFormat. The pattern syntax supported is a subset
+// (mostly compatible) with joda DateTimeFormat.
+//
+//
+//  Symbol  Meaning                      Type     Supported Examples
+//  ------  -------                      -------  --------- -------
+//  G       era                          text      no       AD
+//  C       century of era (>=0)      number    no       20
+//  Y       year of era (>=0)         year      yes      1996
+//
+//  x       weekyear                     year      yes      1996
+//  w       week of weekyear             number    yes      27
+//  e       day of week                  number    yes      2
+//  E       day of week                  text      yes      Tuesday; Tue
+//
+//  y       year                         year      yes      1996
+//  D       day of year                  number    yes      189
+//  M       month of year                month     yes      July; Jul; 07
+//  d       day of month                 number    yes      10
+//
+//  a       halfday of day               text      yes      PM
+//  K       hour of halfday (0~11)       number    yes      0
+//  h       clockhour of halfday (1~12)  number    yes      12
+//
+//  H       hour of day (0~23)           number    yes      0
+//  k       clockhour of day (1~24)      number    yes      24
+//  m       minute of hour               number    yes      30
+//  s       second of minute             number    yes      55
+//  S       fraction of second           millis    no       978
+//
+//  z       time zone                    text      no       Pacific Standard Time; PST
+//  Z       time zone offset/id          zone      no       -0800; -08:00; America/Los_Angeles
+//
+//  '       escape for text              delimiter
+//  ''      single quote                 literal
+//
+// The format is based on pattern letter count. Any character not in the range
+// [a-z][A-Z] is interpreted as literal and copied into final string as is.
+// Arbitrary Literals can also be written using single quotes `'`
+//
+//  Types:          Notes:
+//  ------          ------
+//   text           Use full form if number of letters is >= 4.
+//                  Otherwise a short form is used (if available).
+//
+//   number         Minimum number of digits depends on number of letters.
+//                  Shorter numbers are zero-padded.
+//
+//   year           mostly like number. If Pattern length is 2,
+//                  the year will be displayed as zero-based year
+//                  of the century (modulo 100)
+//
+//   month          If pattern length >= 3, formatting is according to
+//                  text type. Otherwise number type
+//                  formatting rules are applied.
+//
+//   millis         Not yet supported
+//
+//   zone           Not yet supported
+//
+//   literal        Literals are copied as is into formatted string
+//
+package dtfmt

vendor/github.com/elastic/beats/libbeat/common/dtfmt/dtfmt.go

@@ -0,0 +1,15 @@
+package dtfmt
+
+import (
+	"time"
+)
+
+// Format applies the format-pattern to the given timestamp.
+// Returns the formatted string or an error if pattern is invalid.
+func Format(t time.Time, pattern string) (string, error) {
+	f, err := NewFormatter(pattern)
+	if err != nil {
+		return "", err
+	}
+	return f.Format(t)
+}

vendor/github.com/elastic/beats/libbeat/common/dtfmt/elems.go

@@ -0,0 +1,194 @@
+package dtfmt
+
+import (
+	"errors"
+	"fmt"
+	"unicode/utf8"
+)
+
+type element interface {
+	requires(c *ctxConfig) error
+	estimateSize() int
+	compile() (prog, error)
+}
+
+type runeLiteral struct {
+	r rune
+}
+
+type stringLiteral struct {
+	s []byte
+}
+
+type unpaddedNumber struct {
+	ft        fieldType
+	maxDigits int
+	signed    bool
+}
+
+type paddedNumber struct {
+	ft                   fieldType
+	div                  int
+	minDigits, maxDigits int
+	signed               bool
+}
+
+type textField struct {
+	ft    fieldType
+	short bool
+}
+
+type twoDigitYear struct {
+	ft fieldType
+}
+
+type paddingZeros struct {
+	count int
+}
+
+func (runeLiteral) requires(*ctxConfig) error { return nil }
+func (runeLiteral) estimateSize() int         { return 1 }
+
+func (stringLiteral) requires(*ctxConfig) error { return nil }
+func (s stringLiteral) estimateSize() int       { return len(s.s) }
+
+func (n unpaddedNumber) requires(c *ctxConfig) error {
+	return numRequires(c, n.ft)
+}
+
+func (n unpaddedNumber) estimateSize() int {
+	return numSize(n.maxDigits, n.signed)
+}
+
+func (n paddedNumber) requires(c *ctxConfig) error {
+	return numRequires(c, n.ft)
+}
+
+func (n paddedNumber) estimateSize() int {
+	return numSize(n.maxDigits, n.signed)
+}
+
+func (n twoDigitYear) requires(c *ctxConfig) error {
+	return numRequires(c, n.ft)
+}
+
+func (twoDigitYear) estimateSize() int { return 2 }
+
+func numSize(digits int, signed bool) int {
+	if signed {
+		return digits + 1
+	}
+	return digits
+}
+
+func numRequires(c *ctxConfig, ft fieldType) error {
+	switch ft {
+	case ftYear, ftMonthOfYear, ftDayOfMonth:
+		c.enableDate()
+
+	case ftWeekyear, ftWeekOfWeekyear:
+		c.enableISO()
+
+	case ftDayOfYear:
+		c.enableYearday()
+
+	case ftDayOfWeek:
+		c.enableWeekday()
+
+	case ftHalfdayOfDay,
+		ftHourOfHalfday,
+		ftClockhourOfHalfday,
+		ftClockhourOfDay,
+		ftHourOfDay,
+		ftMinuteOfDay,
+		ftMinuteOfHour,
+		ftSecondOfDay,
+		ftSecondOfMinute:
+		c.enableClock()
+
+	case ftMillisOfDay:
+		c.enableClock()
+		c.enableMillis()
+
+	case ftMillisOfSecond:
+		c.enableMillis()
+	}
+
+	return nil
+}
+
+func (f textField) requires(c *ctxConfig) error {
+	switch f.ft {
+	case ftHalfdayOfDay:
+		c.enableClock()
+	case ftMonthOfYear:
+		c.enableDate()
+	case ftDayOfWeek:
+		c.enableWeekday()
+	default:
+		return fmt.Errorf("time field %v not supported by text", f.ft)
+	}
+	return nil
+}
+
+func (f textField) estimateSize() int {
+	switch f.ft {
+	case ftHalfdayOfDay:
+		return 2
+	case ftDayOfWeek:
+		if f.short {
+			return 3
+		}
+		return 9 // max(weekday) = len(Wednesday)
+	case ftMonthOfYear:
+		if f.short {
+			return 6
+		}
+		return 9 // max(month) = len(September)
+	default:
+		return 0
+	}
+}
+
+func (r runeLiteral) compile() (prog, error) {
+	switch utf8.RuneLen(r.r) {
+	case -1:
+		return prog{}, errors.New("invalid rune")
+	}
+
+	var tmp [8]byte
+	l := utf8.EncodeRune(tmp[:], r.r)
+	return makeCopy(tmp[:l])
+}
+
+func (s stringLiteral) compile() (prog, error) {
+	return makeCopy([]byte(s.s))
+}
+
+func (n unpaddedNumber) compile() (prog, error) {
+	return makeProg(opNum, byte(n.ft))
+}
+
+func (n paddedNumber) compile() (prog, error) {
+	if n.div == 0 {
+		return makeProg(opNumPadded, byte(n.ft), byte(n.maxDigits))
+	}
+	return makeProg(opExtNumPadded, byte(n.ft), byte(n.div), byte(n.maxDigits))
+}
+
+func (n twoDigitYear) compile() (prog, error) {
+	return makeProg(opTwoDigit, byte(n.ft))
+}
+
+func (f textField) compile() (prog, error) {
+	if f.short {
+		return makeProg(opTextShort, byte(f.ft))
+	}
+	return makeProg(opTextLong, byte(f.ft))
+}
+
+func (p paddingZeros) requires(c *ctxConfig) error { return nil }
+func (p paddingZeros) estimateSize() int           { return p.count }
+func (p paddingZeros) compile() (prog, error) {
+	return makeProg(opZeros, byte(p.count))
+}

vendor/github.com/elastic/beats/libbeat/common/dtfmt/fields.go

@@ -0,0 +1,130 @@
+package dtfmt
+
+import (
+	"errors"
+	"time"
+)
+
+type fieldType uint8
+
+const (
+	ftYear fieldType = iota
+	ftDayOfYear
+	ftMonthOfYear
+	ftDayOfMonth
+	ftWeekyear
+	ftWeekOfWeekyear
+	ftDayOfWeek
+	ftHalfdayOfDay
+	ftHourOfHalfday
+	ftClockhourOfHalfday
+	ftClockhourOfDay
+	ftHourOfDay
+	ftMinuteOfDay
+	ftMinuteOfHour
+	ftSecondOfDay
+	ftSecondOfMinute
+	ftMillisOfDay
+	ftMillisOfSecond
+)
+
+func getIntField(ft fieldType, ctx *ctx, t time.Time) (int, error) {
+	switch ft {
+	case ftYear:
+		return ctx.year, nil
+
+	case ftDayOfYear:
+		return ctx.yearday, nil
+
+	case ftMonthOfYear:
+		return int(ctx.month), nil
+
+	case ftDayOfMonth:
+		return ctx.day, nil
+
+	case ftWeekyear:
+		return ctx.isoYear, nil
+
+	case ftWeekOfWeekyear:
+		return ctx.isoWeek, nil
+
+	case ftDayOfWeek:
+		return int(ctx.weekday), nil
+
+	case ftHalfdayOfDay:
+		if ctx.hour < 12 {
+			return 0, nil // AM
+		}
+		return 1, nil // PM
+
+	case ftHourOfHalfday:
+		if ctx.hour < 12 {
+			return ctx.hour, nil
+		}
+		return ctx.hour - 12, nil
+
+	case ftClockhourOfHalfday:
+		if ctx.hour < 12 {
+			return ctx.hour + 1, nil
+		}
+		return ctx.hour - 12 + 1, nil
+
+	case ftClockhourOfDay:
+		return ctx.hour + 1, nil
+
+	case ftHourOfDay:
+		return ctx.hour, nil
+
+	case ftMinuteOfDay:
+		return ctx.hour*60 + ctx.min, nil
+
+	case ftMinuteOfHour:
+		return ctx.min, nil
+
+	case ftSecondOfDay:
+		return (ctx.hour*60+ctx.min)*60 + ctx.sec, nil
+
+	case ftSecondOfMinute:
+		return ctx.sec, nil
+
+	case ftMillisOfDay:
+		return ((ctx.hour*60+ctx.min)*60+ctx.sec)*1000 + ctx.millis, nil
+
+	case ftMillisOfSecond:
+		return ctx.millis, nil
+	}
+
+	return 0, nil
+}
+
+func getTextField(ft fieldType, ctx *ctx, t time.Time) (string, error) {
+	switch ft {
+	case ftHalfdayOfDay:
+		if ctx.hour < 12 {
+			return "AM", nil
+		}
+		return "PM", nil
+	case ftDayOfWeek:
+		return ctx.weekday.String(), nil
+	case ftMonthOfYear:
+		return ctx.month.String(), nil
+	default:
+		return "", errors.New("no text field")
+	}
+}
+
+func getTextFieldShort(ft fieldType, ctx *ctx, t time.Time) (string, error) {
+	switch ft {
+	case ftHalfdayOfDay:
+		if ctx.hour < 12 {
+			return "AM", nil
+		}
+		return "PM", nil
+	case ftDayOfWeek:
+		return ctx.weekday.String()[:3], nil
+	case ftMonthOfYear:
+		return ctx.month.String()[:3], nil
+	default:
+		return "", errors.New("no text field")
+	}
+}

vendor/github.com/elastic/beats/libbeat/common/dtfmt/fmt.go

@@ -0,0 +1,261 @@
+package dtfmt
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+	"sync"
+	"time"
+	"unicode/utf8"
+)
+
+// Formatter will format time values into strings, based on pattern used to
+// create the Formatter.
+type Formatter struct {
+	prog   prog
+	sz     int
+	config ctxConfig
+}
+
+var ctxPool = &sync.Pool{
+	New: func() interface{} { return &ctx{} },
+}
+
+func newCtx() *ctx {
+	return ctxPool.Get().(*ctx)
+}
+
+func newCtxWithSize(sz int) *ctx {
+	ctx := newCtx()
+	if ctx.buf == nil || cap(ctx.buf) < sz {
+		ctx.buf = make([]byte, 0, sz)
+	}
+	return ctx
+}
+
+func releaseCtx(c *ctx) {
+	ctxPool.Put(c)
+}
+
+// NewFormatter creates a new time formatter based on provided pattern.
+// If pattern is invalid an error is returned.
+func NewFormatter(pattern string) (*Formatter, error) {
+	b := newBuilder()
+
+	err := parsePatternTo(b, pattern)
+	if err != nil {
+		return nil, err
+	}
+
+	b.optimize()
+
+	cfg, err := b.createConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	prog, err := b.compile()
+	if err != nil {
+		return nil, err
+	}
+
+	sz := b.estimateSize()
+	f := &Formatter{
+		prog:   prog,
+		sz:     sz,
+		config: cfg,
+	}
+	return f, nil
+}
+
+// EstimateSize estimates the required buffer size required to hold
+// the formatted time string. Estimated size gives no exact guarantees.
+// Estimated size might still be too low or too big.
+func (f *Formatter) EstimateSize() int {
+	return f.sz
+}
+
+func (f *Formatter) appendTo(ctx *ctx, b []byte, t time.Time) ([]byte, error) {
+	ctx.initTime(&f.config, t)
+	return f.prog.eval(b, ctx, t)
+}
+
+// AppendTo appends the formatted time value to the given byte buffer.
+func (f *Formatter) AppendTo(b []byte, t time.Time) ([]byte, error) {
+	ctx := newCtx()
+	defer releaseCtx(ctx)
+	return f.appendTo(ctx, b, t)
+}
+
+// Write writes the formatted time value to the given writer. Returns
+// number of bytes written or error if formatter or writer fails.
+func (f *Formatter) Write(w io.Writer, t time.Time) (int, error) {
+	var err error
+
+	ctx := newCtxWithSize(f.sz)
+	defer releaseCtx(ctx)
+
+	ctx.buf, err = f.appendTo(ctx, ctx.buf[:0], t)
+	if err != nil {
+		return 0, err
+	}
+	return w.Write(ctx.buf)
+}
+
+// Format formats the given time value into a new string.
+func (f *Formatter) Format(t time.Time) (string, error) {
+	var err error
+
+	ctx := newCtxWithSize(f.sz)
+	defer releaseCtx(ctx)
+
+	ctx.buf, err = f.appendTo(ctx, ctx.buf[:0], t)
+	if err != nil {
+		return "", err
+	}
+	return string(ctx.buf), nil
+}
+
+func parsePatternTo(b *builder, pattern string) error {
+	for i := 0; i < len(pattern); {
+		tok, tokText, err := parseToken(pattern, &i)
+		if err != nil {
+			return err
+		}
+
+		tokLen := len(tokText)
+		switch tok {
+		case 'x': // weekyear (year)
+			if tokLen == 2 {
+				b.twoDigitWeekYear()
+			} else {
+				b.weekyear(tokLen, 4)
+			}
+
+		case 'y', 'Y': // year and year of era (year) == 'y'
+			if tokLen == 2 {
+				b.twoDigitYear()
+			} else {
+				b.year(tokLen, 4)
+			}
+
+		case 'w': // week of weekyear (num)
+			b.weekOfWeekyear(tokLen)
+
+		case 'e': // day of week (num)
+			b.dayOfWeek(tokLen)
+
+		case 'E': // day of week (text)
+			if tokLen >= 4 {
+				b.dayOfWeekText()
+			} else {
+				b.dayOfWeekShortText()
+			}
+
+		case 'D': // day of year (number)
+			b.dayOfYear(tokLen)
+
+		case 'M': // month of year (month)
+			if tokLen >= 3 {
+				if tokLen >= 4 {
+					b.monthOfYearText()
+				} else {
+					b.monthOfYearShortText()
+				}
+			} else {
+				b.monthOfYear(tokLen)
+			}
+
+		case 'd': //day of month (number)
+			b.dayOfMonth(tokLen)
+
+		case 'a': // half of day (text) 'AM/PM'
+			b.halfdayOfDayText()
+
+		case 'K': // hour of half day (number) (0 - 11)
+			b.hourOfHalfday(tokLen)
+
+		case 'h': // clock hour of half day (number) (1 - 12)
+			b.clockhourOfHalfday(tokLen)
+
+		case 'H': // hour of day (number) (0 - 23)
+			b.hourOfDay(tokLen)
+
+		case 'k': // clock hour of half day (number) (1 - 24)
+			b.clockhourOfDay(tokLen)
+
+		case 'm': // minute of hour
+			b.minuteOfHour(tokLen)
+
+		case 's': // second of minute
+			b.secondOfMinute(tokLen)
+
+		case 'S': // fraction of second
+			b.millisOfSecond(tokLen)
+
+		case '\'': // literal
+			if tokLen == 1 {
+				b.appendRune(rune(tokText[0]))
+			} else {
+				b.appendLiteral(tokText)
+			}
+
+		default:
+			return fmt.Errorf("unsupport format '%c'", tok)
+
+		}
+	}
+
+	return nil
+}
+
+func parseToken(pattern string, i *int) (rune, string, error) {
+	start := *i
+	idx := start
+	length := len(pattern)
+
+	r, w := utf8.DecodeRuneInString(pattern[idx:])
+	idx += w
+	if ('A' <= r && r <= 'Z') || ('a' <= r && r <= 'z') {
+		// Scan a run of the same character, which indicates a time pattern.
+
+		for idx < length {
+			peek, w := utf8.DecodeRuneInString(pattern[idx:])
+			if peek != r {
+				break
+			}
+
+			idx += w
+		}
+
+		*i = idx
+		return r, pattern[start:idx], nil
+	}
+
+	if r != '\'' { // single character, no escaped string
+		*i = idx
+		return '\'', pattern[start:idx], nil
+	}
+
+	start = idx // skip ' character
+	iEnd := strings.IndexRune(pattern[start:], '\'')
+	if iEnd < 0 {
+		return r, "", errors.New("missing closing '")
+	}
+
+	if iEnd == 0 {
+		// escape single quote literal
+		*i = idx + 1
+		return r, pattern[start : idx+1], nil
+	}
+
+	iEnd += start
+
+	*i = iEnd + 1 // point after '
+	if len(pattern) > iEnd+1 && pattern[iEnd+1] == '\'' {
+		return r, pattern[start : iEnd+1], nil
+	}
+
+	return r, pattern[start:iEnd], nil
+}

vendor/github.com/elastic/beats/libbeat/common/dtfmt/prog.go

@@ -0,0 +1,150 @@
+package dtfmt
+
+import (
+	"errors"
+	"time"
+)
+
+type prog struct {
+	p []byte
+}
+
+const (
+	opNone         byte = iota
+	opCopy1             // copy next byte
+	opCopy2             // copy next 2 bytes
+	opCopy3             // copy next 3 bytes
+	opCopy4             // copy next 4 bytes
+	opCopyShort         // [op, len, content[len]]
+	opCopyLong          // [op, len1, len, content[len1<<8 + len]]
+	opNum               // [op, ft]
+	opNumPadded         // [op, ft, digits]
+	opExtNumPadded      // [op, ft, div, digits]
+	opZeros             // [op, count]
+	opTwoDigit          // [op, ft]
+	opTextShort         // [op, ft]
+	opTextLong          // [op, ft]
+)
+
+func (p prog) eval(bytes []byte, ctx *ctx, t time.Time) ([]byte, error) {
+	for i := 0; i < len(p.p); {
+		op := p.p[i]
+		i++
+
+		switch op {
+		case opNone:
+
+		case opCopy1:
+			bytes = append(bytes, p.p[i])
+			i++
+		case opCopy2:
+			bytes = append(bytes, p.p[i], p.p[i+1])
+			i += 2
+		case opCopy3:
+			bytes = append(bytes, p.p[i], p.p[i+1], p.p[i+2])
+			i += 3
+		case opCopy4:
+			bytes = append(bytes, p.p[i], p.p[i+1], p.p[i+2], p.p[i+3])
+			i += 4
+		case opCopyShort:
+			l := int(p.p[i])
+			i++
+			bytes = append(bytes, p.p[i:i+l]...)
+			i += l
+		case opCopyLong:
+			l := int(p.p[i])<<8 | int(p.p[i+1])
+			i += 2
+			bytes = append(bytes, p.p[i:i+l]...)
+			i += l
+		case opNum:
+			ft := fieldType(p.p[i])
+			i++
+			v, err := getIntField(ft, ctx, t)
+			if err != nil {
+				return bytes, err
+			}
+			bytes = appendUnpadded(bytes, v)
+		case opNumPadded:
+			ft, digits := fieldType(p.p[i]), int(p.p[i+1])
+			i += 2
+			v, err := getIntField(ft, ctx, t)
+			if err != nil {
+				return bytes, err
+			}
+			bytes = appendPadded(bytes, v, digits)
+		case opExtNumPadded:
+			ft, div, digits := fieldType(p.p[i]), int(p.p[i+1]), int(p.p[i+2])
+			i += 3
+			v, err := getIntField(ft, ctx, t)
+			if err != nil {
+				return bytes, err
+			}
+			bytes = appendPadded(bytes, v/div, digits)
+		case opZeros:
+			digits := int(p.p[i])
+			i++
+			for x := 0; x < digits; x++ {
+				bytes = append(bytes, '0')
+			}
+		case opTwoDigit:
+			ft := fieldType(p.p[i])
+			i++
+			v, err := getIntField(ft, ctx, t)
+			if err != nil {
+				return bytes, err
+			}
+			bytes = appendPadded(bytes, v%100, 2)
+		case opTextShort:
+			ft := fieldType(p.p[i])
+			i++
+			s, err := getTextFieldShort(ft, ctx, t)
+			if err != nil {
+				return bytes, err
+			}
+			bytes = append(bytes, s...)
+		case opTextLong:
+			ft := fieldType(p.p[i])
+			i++
+			s, err := getTextField(ft, ctx, t)
+			if err != nil {
+				return bytes, err
+			}
+			bytes = append(bytes, s...)
+		default:
+			return bytes, errors.New("unknown opcode")
+		}
+	}
+
+	return bytes, nil
+}
+
+func makeProg(b ...byte) (prog, error) {
+	return prog{b}, nil
+}
+
+func makeCopy(b []byte) (prog, error) {
+	l := len(b)
+	switch l {
+	case 0:
+		return prog{}, nil
+	case 1:
+		return makeProg(opCopy1, b[0])
+	case 2:
+		return makeProg(opCopy2, b[0], b[1])
+	case 3:
+		return makeProg(opCopy2, b[0], b[1], b[2])
+	case 4:
+		return makeProg(opCopy2, b[0], b[1], b[2], b[3])
+	}
+
+	if l < 256 {
+		return prog{append([]byte{opCopyShort, byte(l)}, b...)}, nil
+	}
+	if l < (1 << 16) {
+		l1 := byte(l >> 8)
+		l2 := byte(l)
+		return prog{append([]byte{opCopyLong, l1, l2}, b...)}, nil
+	}
+
+	return prog{}, errors.New("literal too long")
+}

vendor/github.com/elastic/beats/libbeat/common/dtfmt/util.go

@@ -0,0 +1,44 @@
+package dtfmt
+
+import (
+	"math"
+	"strconv"
+)
+
+func appendUnpadded(bs []byte, i int) []byte {
+	return strconv.AppendInt(bs, int64(i), 10)
+}
+
+func appendPadded(bs []byte, i, sz int) []byte {
+	if i < 0 {
+		bs = append(bs, '-')
+		i = -i
+	}
+
+	if i < 10 {
+		for ; sz > 1; sz-- {
+			bs = append(bs, '0')
+		}
+		return append(bs, byte(i)+'0')
+	}
+	if i < 100 {
+		for ; sz > 2; sz-- {
+			bs = append(bs, '0')
+		}
+		return strconv.AppendInt(bs, int64(i), 10)
+	}
+
+	digits := 0
+	if i < 1000 {
+		digits = 3
+	} else if i < 10000 {
+		digits = 4
+	} else {
+		digits = int(math.Log10(float64(i))) + 1
+	}
+	for ; sz > digits; sz-- {
+		bs = append(bs, '0')
+	}
+
+	return strconv.AppendInt(bs, int64(i), 10)
+}

vendor/github.com/elastic/beats/packetbeat/protos/cassandra/internal/gocql/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2016 The gocql Authors. 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 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.

vendor/github.com/mailru/easyjson/.gitignore

@@ -0,0 +1,4 @@
+.root
+*_easyjson.go
+*.iml
+.idea

vendor/github.com/mailru/easyjson/.travis.yml

@@ -0,0 +1,9 @@
+language: go
+
+go:
+  - tip
+install:
+  - go get github.com/ugorji/go/codec
+  - go get github.com/pquerna/ffjson/fflib/v1
+  - go get github.com/json-iterator/go
+  - go get github.com/golang/lint/golint

vendor/github.com/mailru/easyjson/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2016 Mail.Ru Group
+
+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.

vendor/github.com/mailru/easyjson/Makefile

@@ -0,0 +1,60 @@
+PKG=github.com/mailru/easyjson
+GOPATH:=$(PWD)/.root:$(GOPATH)
+export GOPATH
+
+all: test
+
+.root/src/$(PKG):
+	mkdir -p $@
+	for i in $$PWD/* ; do ln -s $$i $@/`basename $$i` ; done 
+
+root: .root/src/$(PKG)
+
+clean:
+	rm -rf .root
+	rm -rf tests/*_easyjson.go
+
+build:
+	go build -i -o .root/bin/easyjson $(PKG)/easyjson
+
+generate: root build
+	.root/bin/easyjson -stubs \
+		.root/src/$(PKG)/tests/snake.go \
+		.root/src/$(PKG)/tests/data.go \
+		.root/src/$(PKG)/tests/omitempty.go \
+		.root/src/$(PKG)/tests/nothing.go \
+		.root/src/$(PKG)/tests/named_type.go \
+		.root/src/$(PKG)/tests/custom_map_key_type.go \
+		.root/src/$(PKG)/tests/embedded_type.go
+
+	.root/bin/easyjson -all .root/src/$(PKG)/tests/data.go 
+	.root/bin/easyjson -all .root/src/$(PKG)/tests/nothing.go
+	.root/bin/easyjson -all .root/src/$(PKG)/tests/errors.go
+	.root/bin/easyjson -snake_case .root/src/$(PKG)/tests/snake.go
+	.root/bin/easyjson -omit_empty .root/src/$(PKG)/tests/omitempty.go
+	.root/bin/easyjson -build_tags=use_easyjson .root/src/$(PKG)/benchmark/data.go
+	.root/bin/easyjson .root/src/$(PKG)/tests/nested_easy.go
+	.root/bin/easyjson .root/src/$(PKG)/tests/named_type.go
+	.root/bin/easyjson .root/src/$(PKG)/tests/custom_map_key_type.go
+	.root/bin/easyjson .root/src/$(PKG)/tests/embedded_type.go
+
+test: generate root
+	go test \
+		$(PKG)/tests \
+		$(PKG)/jlexer \
+		$(PKG)/gen \
+		$(PKG)/buffer
+	go test -benchmem -tags use_easyjson -bench . $(PKG)/benchmark
+	golint -set_exit_status .root/src/$(PKG)/tests/*_easyjson.go
+
+bench-other: generate root
+	@go test -benchmem -bench . $(PKG)/benchmark
+	@go test -benchmem -tags use_ffjson -bench . $(PKG)/benchmark
+	@go test -benchmem -tags use_jsoniter -bench . $(PKG)/benchmark
+	@go test -benchmem -tags use_codec -bench . $(PKG)/benchmark
+
+bench-python:
+	benchmark/ujson.sh
+
+
+.PHONY: root clean generate test build

vendor/github.com/mailru/easyjson/README.md

@@ -0,0 +1,331 @@
+# easyjson [![Build Status](https://travis-ci.org/mailru/easyjson.svg?branch=master)](https://travis-ci.org/mailru/easyjson) [![Go Report Card](https://goreportcard.com/badge/github.com/mailru/easyjson)](https://goreportcard.com/report/github.com/mailru/easyjson)
+
+Package easyjson provides a fast and easy way to marshal/unmarshal Go structs
+to/from JSON without the use of reflection. In performance tests, easyjson
+outperforms the standard `encoding/json` package by a factor of 4-5x, and other
+JSON encoding packages by a factor of 2-3x.
+
+easyjson aims to keep generated Go code simple enough so that it can be easily
+optimized or fixed. Another goal is to provide users with the ability to
+customize the generated code by providing options not available with the
+standard `encoding/json` package, such as generating "snake_case" names or
+enabling `omitempty` behavior by default.
+
+## Usage
+```sh
+# install
+go get -u github.com/mailru/easyjson/...
+
+# run
+easyjson -all <file>.go
+```
+
+The above will generate `<file>_easyjson.go` containing the appropriate marshaler and
+unmarshaler funcs for all structs contained in `<file>.go`.
+
+Please note that easyjson requires a full Go build environment and the `GOPATH`
+environment variable to be set. This is because easyjson code generation
+invokes `go run` on a temporary file (an approach to code generation borrowed
+from [ffjson](https://github.com/pquerna/ffjson)).
+
+## Options
+```txt
+Usage of easyjson:
+  -all
+    	generate marshaler/unmarshalers for all structs in a file
+  -build_tags string
+    	build tags to add to generated file
+  -leave_temps
+    	do not delete temporary files
+  -no_std_marshalers
+    	don't generate MarshalJSON/UnmarshalJSON funcs
+  -noformat
+    	do not run 'gofmt -w' on output file
+  -omit_empty
+    	omit empty fields by default
+  -output_filename string
+    	specify the filename of the output
+  -pkg
+    	process the whole package instead of just the given file
+  -snake_case
+    	use snake_case names instead of CamelCase by default
+  -lower_camel_case
+        use lowerCamelCase instead of CamelCase by default
+  -stubs
+    	only generate stubs for marshaler/unmarshaler funcs
+```
+
+Using `-all` will generate marshalers/unmarshalers for all Go structs in the
+file. If `-all` is not provided, then only those structs whose preceding
+comment starts with `easyjson:json` will have marshalers/unmarshalers
+generated. For example:
+
+```go
+//easyjson:json
+type A struct {}
+```
+
+Additional option notes:
+
+* `-snake_case` tells easyjson to generate snake\_case field names by default
+  (unless overridden by a field tag). The CamelCase to snake\_case conversion
+  algorithm should work in most cases (ie, HTTPVersion will be converted to
+  "http_version").
+
+* `-build_tags` will add the specified build tags to generated Go sources.
+
+## Generated Marshaler/Unmarshaler Funcs
+
+For Go struct types, easyjson generates the funcs `MarshalEasyJSON` /
+`UnmarshalEasyJSON` for marshaling/unmarshaling JSON. In turn, these satisify
+the `easyjson.Marshaler` and `easyjson.Unmarshaler` interfaces and when used in
+conjunction with `easyjson.Marshal` / `easyjson.Unmarshal` avoid unnecessary
+reflection / type assertions during marshaling/unmarshaling to/from JSON for Go
+structs.
+
+easyjson also generates `MarshalJSON` and `UnmarshalJSON` funcs for Go struct
+types compatible with the standard `json.Marshaler` and `json.Unmarshaler`
+interfaces. Please be aware that using the standard `json.Marshal` /
+`json.Unmarshal` for marshaling/unmarshaling will incur a significant
+performance penalty when compared to using `easyjson.Marshal` /
+`easyjson.Unmarshal`.
+
+Additionally, easyjson exposes utility funcs that use the `MarshalEasyJSON` and
+`UnmarshalEasyJSON` for marshaling/unmarshaling to and from standard readers
+and writers. For example, easyjson provides `easyjson.MarshalToHTTPResponseWriter`
+which marshals to the standard `http.ResponseWriter`. Please see the [GoDoc
+listing](https://godoc.org/github.com/mailru/easyjson) for the full listing of
+utility funcs that are available.
+
+## Controlling easyjson Marshaling and Unmarshaling Behavior
+
+Go types can provide their own `MarshalEasyJSON` and `UnmarshalEasyJSON` funcs
+that satisify the `easyjson.Marshaler` / `easyjson.Unmarshaler` interfaces.
+These will be used by `easyjson.Marshal` and `easyjson.Unmarshal` when defined
+for a Go type.
+
+Go types can also satisify the `easyjson.Optional` interface, which allows the
+type to define its own `omitempty` logic.
+
+## Type Wrappers
+
+easyjson provides additional type wrappers defined in the `easyjson/opt`
+package. These wrap the standard Go primitives and in turn satisify the
+easyjson interfaces.
+
+The `easyjson/opt` type wrappers are useful when needing to distinguish between
+a missing value and/or when needing to specifying a default value. Type
+wrappers allow easyjson to avoid additional pointers and heap allocations and
+can significantly increase performance when used properly.
+
+## Memory Pooling
+
+easyjson uses a buffer pool that allocates data in increasing chunks from 128
+to 32768 bytes. Chunks of 512 bytes and larger will be reused with the help of
+`sync.Pool`. The maximum size of a chunk is bounded to reduce redundant memory
+allocation and to allow larger reusable buffers.
+
+easyjson's custom allocation buffer pool is defined in the `easyjson/buffer`
+package, and the default behavior pool behavior can be modified (if necessary)
+through a call to `buffer.Init()` prior to any marshaling or unmarshaling.
+Please see the [GoDoc listing](https://godoc.org/github.com/mailru/easyjson/buffer)
+for more information.
+
+## Issues, Notes, and Limitations
+
+* easyjson is still early in its development. As such, there are likely to be
+  bugs and missing features when compared to `encoding/json`. In the case of a
+  missing feature or bug, please create a GitHub issue. Pull requests are
+  welcome!
+
+* Unlike `encoding/json`, object keys are case-sensitive. Case-insensitive
+  matching is not currently provided due to the significant performance hit
+  when doing case-insensitive key matching. In the future, case-insensitive
+  object key matching may be provided via an option to the generator.
+
+* easyjson makes use of `unsafe`, which simplifies the code and
+  provides significant performance benefits by allowing no-copy
+  conversion from `[]byte` to `string`. That said, `unsafe` is used
+  only when unmarshaling and parsing JSON, and any `unsafe` operations
+  / memory allocations done will be safely deallocated by
+  easyjson. Set the build tag `easyjson_nounsafe` to compile it
+  without `unsafe`.
+
+* easyjson is compatible with Google App Engine. The `appengine` build
+  tag (set by App Engine's environment) will automatically disable the
+  use of `unsafe`, which is not allowed in App Engine's Standard
+  Environment. Note that the use with App Engine is still experimental.
+
+* Floats are formatted using the default precision from Go's `strconv` package.
+  As such, easyjson will not correctly handle high precision floats when
+  marshaling/unmarshaling JSON. Note, however, that there are very few/limited
+  uses where this behavior is not sufficient for general use. That said, a
+  different package may be needed if precise marshaling/unmarshaling of high
+  precision floats to/from JSON is required.
+
+* While unmarshaling, the JSON parser does the minimal amount of work needed to
+  skip over unmatching parens, and as such full validation is not done for the
+  entire JSON value being unmarshaled/parsed.
+
+* Currently there is no true streaming support for encoding/decoding as
+  typically for many uses/protocols the final, marshaled length of the JSON
+  needs to be known prior to sending the data. Currently this is not possible
+  with easyjson's architecture.
+
+## Benchmarks
+
+Most benchmarks were done using the example
+[13kB example JSON](https://dev.twitter.com/rest/reference/get/search/tweets)
+(9k after eliminating whitespace). This example is similar to real-world data,
+is well-structured, and contains a healthy variety of different types, making
+it ideal for JSON serialization benchmarks.
+
+Note:
+
+* For small request benchmarks, an 80 byte portion of the above example was
+  used.
+
+* For large request marshaling benchmarks, a struct containing 50 regular
+  samples was used, making a ~500kB output JSON.
+
+* Benchmarks are showing the results of easyjson's default behaviour,
+  which makes use of `unsafe`.
+
+Benchmarks are available in the repository and can be run by invoking `make`.
+
+### easyjson vs. encoding/json
+
+easyjson is roughly 5-6 times faster than the standard `encoding/json` for
+unmarshaling, and 3-4 times faster for non-concurrent marshaling. Concurrent
+marshaling is 6-7x faster if marshaling to a writer.
+
+### easyjson vs. ffjson
+
+easyjson uses the same approach for JSON marshaling as
+[ffjson](https://github.com/pquerna/ffjson), but takes a significantly
+different approach to lexing and parsing JSON during unmarshaling. This means
+easyjson is roughly 2-3x faster for unmarshaling and 1.5-2x faster for
+non-concurrent unmarshaling.
+
+As of this writing, `ffjson` seems to have issues when used concurrently:
+specifically, large request pooling hurts `ffjson`'s performance and causes
+scalability issues. These issues with `ffjson` can likely be fixed, but as of
+writing remain outstanding/known issues with `ffjson`.
+
+easyjson and `ffjson` have similar performance for small requests, however
+easyjson outperforms `ffjson` by roughly 2-5x times for large requests when
+used with a writer.
+
+### easyjson vs. go/codec
+
+[go/codec](https://github.com/ugorji/go) provides
+compile-time helpers for JSON generation. In this case, helpers do not work
+like marshalers as they are encoding-independent.
+
+easyjson is generally 2x faster than `go/codec` for non-concurrent benchmarks
+and about 3x faster for concurrent encoding (without marshaling to a writer).
+
+In an attempt to measure marshaling performance of `go/codec` (as opposed to
+allocations/memcpy/writer interface invocations), a benchmark was done with
+resetting length of a byte slice rather than resetting the whole slice to nil.
+However, the optimization in this exact form may not be applicable in practice,
+since the memory is not freed between marshaling operations.
+
+### easyjson vs 'ujson' python module
+
+[ujson](https://github.com/esnme/ultrajson) is using C code for parsing, so it
+is interesting to see how plain golang compares to that. It is imporant to note
+that the resulting object for python is slower to access, since the library
+parses JSON object into dictionaries.
+
+easyjson is slightly faster for unmarshaling and 2-3x faster than `ujson` for
+marshaling.
+
+### Benchmark Results
+
+`ffjson` results are from February 4th, 2016, using the latest `ffjson` and go1.6.
+`go/codec` results are from March 4th, 2016, using the latest `go/codec` and go1.6.
+
+#### Unmarshaling
+
+| lib      | json size | MB/s | allocs/op | B/op  |
+|:---------|:----------|-----:|----------:|------:|
+| standard | regular   | 22   | 218       | 10229 |
+| standard | small     | 9.7  | 14        | 720   |
+|          |           |      |           |       |
+| easyjson | regular   | 125  | 128       | 9794  |
+| easyjson | small     | 67   | 3         | 128   |
+|          |           |      |           |       |
+| ffjson   | regular   | 66   | 141       | 9985  |
+| ffjson   | small     | 17.6 | 10        | 488   |
+|          |           |      |           |       |
+| codec    | regular   | 55   | 434       | 19299 |
+| codec    | small     | 29   | 7         | 336   |
+|          |           |      |           |       |
+| ujson    | regular   | 103  | N/A       | N/A   |
+
+#### Marshaling, one goroutine.
+
+| lib       | json size | MB/s | allocs/op | B/op  |
+|:----------|:----------|-----:|----------:|------:|
+| standard  | regular   | 75   | 9         | 23256 |
+| standard  | small     | 32   | 3         | 328   |
+| standard  | large     | 80   | 17        | 1.2M  |
+|           |           |      |           |       |
+| easyjson  | regular   | 213  | 9         | 10260 |
+| easyjson* | regular   | 263  | 8         | 742   |
+| easyjson  | small     | 125  | 1         | 128   |
+| easyjson  | large     | 212  | 33        | 490k  |
+| easyjson* | large     | 262  | 25        | 2879  |
+|           |           |      |           |       |
+| ffjson    | regular   | 122  | 153       | 21340 |
+| ffjson**  | regular   | 146  | 152       | 4897  |
+| ffjson    | small     | 36   | 5         | 384   |
+| ffjson**  | small     | 64   | 4         | 128   |
+| ffjson    | large     | 134  | 7317      | 818k  |
+| ffjson**  | large     | 125  | 7320      | 827k  |
+|           |           |      |           |       |
+| codec     | regular   | 80   | 17        | 33601 |
+| codec***  | regular   | 108  | 9         | 1153  |
+| codec     | small     | 42   | 3         | 304   |
+| codec***  | small     | 56   | 1         | 48    |
+| codec     | large     | 73   | 483       | 2.5M  |
+| codec***  | large     | 103  | 451       | 66007 |
+|           |           |      |           |       |
+| ujson     | regular   | 92   | N/A       | N/A   |
+
+\* marshaling to a writer,
+\*\* using `ffjson.Pool()`,
+\*\*\* reusing output slice instead of resetting it to nil
+
+#### Marshaling, concurrent.
+
+| lib       | json size | MB/s | allocs/op | B/op  |
+|:----------|:----------|-----:|----------:|------:|
+| standard  | regular   | 252  | 9         | 23257 |
+| standard  | small     | 124  | 3         | 328   |
+| standard  | large     | 289  | 17        | 1.2M  |
+|           |           |      |           |       |
+| easyjson  | regular   | 792  | 9         | 10597 |
+| easyjson* | regular   | 1748 | 8         | 779   |
+| easyjson  | small     | 333  | 1         | 128   |
+| easyjson  | large     | 718  | 36        | 548k  |
+| easyjson* | large     | 2134 | 25        | 4957  |
+|           |           |      |           |       |
+| ffjson    | regular   | 301  | 153       | 21629 |
+| ffjson**  | regular   | 707  | 152       | 5148  |
+| ffjson    | small     | 62   | 5         | 384   |
+| ffjson**  | small     | 282  | 4         | 128   |
+| ffjson    | large     | 438  | 7330      | 1.0M  |
+| ffjson**  | large     | 131  | 7319      | 820k  |
+|           |           |      |           |       |
+| codec     | regular   | 183  | 17        | 33603 |
+| codec***  | regular   | 671  | 9         | 1157  |
+| codec     | small     | 147  | 3         | 304   |
+| codec***  | small     | 299  | 1         | 48    |
+| codec     | large     | 190  | 483       | 2.5M  |
+| codec***  | large     | 752  | 451       | 77574 |
+
+\* marshaling to a writer,
+\*\* using `ffjson.Pool()`,
+\*\*\* reusing output slice instead of resetting it to nil

vendor/github.com/mailru/easyjson/buffer/pool.go

@@ -0,0 +1,270 @@
+// Package buffer implements a buffer for serialization, consisting of a chain of []byte-s to
+// reduce copying and to allow reuse of individual chunks.
+package buffer
+
+import (
+	"io"
+	"sync"
+)
+
+// PoolConfig contains configuration for the allocation and reuse strategy.
+type PoolConfig struct {
+	StartSize  int // Minimum chunk size that is allocated.
+	PooledSize int // Minimum chunk size that is reused, reusing chunks too small will result in overhead.
+	MaxSize    int // Maximum chunk size that will be allocated.
+}
+
+var config = PoolConfig{
+	StartSize:  128,
+	PooledSize: 512,
+	MaxSize:    32768,
+}
+
+// Reuse pool: chunk size -> pool.
+var buffers = map[int]*sync.Pool{}
+
+func initBuffers() {
+	for l := config.PooledSize; l <= config.MaxSize; l *= 2 {
+		buffers[l] = new(sync.Pool)
+	}
+}
+
+func init() {
+	initBuffers()
+}
+
+// Init sets up a non-default pooling and allocation strategy. Should be run before serialization is done.
+func Init(cfg PoolConfig) {
+	config = cfg
+	initBuffers()
+}
+
+// putBuf puts a chunk to reuse pool if it can be reused.
+func putBuf(buf []byte) {
+	size := cap(buf)
+	if size < config.PooledSize {
+		return
+	}
+	if c := buffers[size]; c != nil {
+		c.Put(buf[:0])
+	}
+}
+
+// getBuf gets a chunk from reuse pool or creates a new one if reuse failed.
+func getBuf(size int) []byte {
+	if size < config.PooledSize {
+		return make([]byte, 0, size)
+	}
+
+	if c := buffers[size]; c != nil {
+		v := c.Get()
+		if v != nil {
+			return v.([]byte)
+		}
+	}
+	return make([]byte, 0, size)
+}
+
+// Buffer is a buffer optimized for serialization without extra copying.
+type Buffer struct {
+
+	// Buf is the current chunk that can be used for serialization.
+	Buf []byte
+
+	toPool []byte
+	bufs   [][]byte
+}
+
+// EnsureSpace makes sure that the current chunk contains at least s free bytes,
+// possibly creating a new chunk.
+func (b *Buffer) EnsureSpace(s int) {
+	if cap(b.Buf)-len(b.Buf) >= s {
+		return
+	}
+	l := len(b.Buf)
+	if l > 0 {
+		if cap(b.toPool) != cap(b.Buf) {
+			// Chunk was reallocated, toPool can be pooled.
+			putBuf(b.toPool)
+		}
+		if cap(b.bufs) == 0 {
+			b.bufs = make([][]byte, 0, 8)
+		}
+		b.bufs = append(b.bufs, b.Buf)
+		l = cap(b.toPool) * 2
+	} else {
+		l = config.StartSize
+	}
+
+	if l > config.MaxSize {
+		l = config.MaxSize
+	}
+	b.Buf = getBuf(l)
+	b.toPool = b.Buf
+}
+
+// AppendByte appends a single byte to buffer.
+func (b *Buffer) AppendByte(data byte) {
+	if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
+		b.EnsureSpace(1)
+	}
+	b.Buf = append(b.Buf, data)
+}
+
+// AppendBytes appends a byte slice to buffer.
+func (b *Buffer) AppendBytes(data []byte) {
+	for len(data) > 0 {
+		if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
+			b.EnsureSpace(1)
+		}
+
+		sz := cap(b.Buf) - len(b.Buf)
+		if sz > len(data) {
+			sz = len(data)
+		}
+
+		b.Buf = append(b.Buf, data[:sz]...)
+		data = data[sz:]
+	}
+}
+
+// AppendBytes appends a string to buffer.
+func (b *Buffer) AppendString(data string) {
+	for len(data) > 0 {
+		if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
+			b.EnsureSpace(1)
+		}
+
+		sz := cap(b.Buf) - len(b.Buf)
+		if sz > len(data) {
+			sz = len(data)
+		}
+
+		b.Buf = append(b.Buf, data[:sz]...)
+		data = data[sz:]
+	}
+}
+
+// Size computes the size of a buffer by adding sizes of every chunk.
+func (b *Buffer) Size() int {
+	size := len(b.Buf)
+	for _, buf := range b.bufs {
+		size += len(buf)
+	}
+	return size
+}
+
+// DumpTo outputs the contents of a buffer to a writer and resets the buffer.
+func (b *Buffer) DumpTo(w io.Writer) (written int, err error) {
+	var n int
+	for _, buf := range b.bufs {
+		if err == nil {
+			n, err = w.Write(buf)
+			written += n
+		}
+		putBuf(buf)
+	}
+
+	if err == nil {
+		n, err = w.Write(b.Buf)
+		written += n
+	}
+	putBuf(b.toPool)
+
+	b.bufs = nil
+	b.Buf = nil
+	b.toPool = nil
+
+	return
+}
+
+// BuildBytes creates a single byte slice with all the contents of the buffer. Data is
+// copied if it does not fit in a single chunk. You can optionally provide one byte
+// slice as argument that it will try to reuse.
+func (b *Buffer) BuildBytes(reuse ...[]byte) []byte {
+	if len(b.bufs) == 0 {
+		ret := b.Buf
+		b.toPool = nil
+		b.Buf = nil
+		return ret
+	}
+
+	var ret []byte
+	size := b.Size()
+
+	// If we got a buffer as argument and it is big enought, reuse it.
+	if len(reuse) == 1 && cap(reuse[0]) >= size {
+		ret = reuse[0][:0]
+	} else {
+		ret = make([]byte, 0, size)
+	}
+	for _, buf := range b.bufs {
+		ret = append(ret, buf...)
+		putBuf(buf)
+	}
+
+	ret = append(ret, b.Buf...)
+	putBuf(b.toPool)
+
+	b.bufs = nil
+	b.toPool = nil
+	b.Buf = nil
+
+	return ret
+}
+
+type readCloser struct {
+	offset int
+	bufs   [][]byte
+}
+
+func (r *readCloser) Read(p []byte) (n int, err error) {
+	for _, buf := range r.bufs {
+		// Copy as much as we can.
+		x := copy(p[n:], buf[r.offset:])
+		n += x // Increment how much we filled.
+
+		// Did we empty the whole buffer?
+		if r.offset+x == len(buf) {
+			// On to the next buffer.
+			r.offset = 0
+			r.bufs = r.bufs[1:]
+
+			// We can release this buffer.
+			putBuf(buf)
+		} else {
+			r.offset += x
+		}
+
+		if n == len(p) {
+			break
+		}
+	}
+	// No buffers left or nothing read?
+	if len(r.bufs) == 0 {
+		err = io.EOF
+	}
+	return
+}
+
+func (r *readCloser) Close() error {
+	// Release all remaining buffers.
+	for _, buf := range r.bufs {
+		putBuf(buf)
+	}
+	// In case Close gets called multiple times.
+	r.bufs = nil
+
+	return nil
+}
+
+// ReadCloser creates an io.ReadCloser with all the contents of the buffer.
+func (b *Buffer) ReadCloser() io.ReadCloser {
+	ret := &readCloser{0, append(b.bufs, b.Buf)}
+
+	b.bufs = nil
+	b.toPool = nil
+	b.Buf = nil
+
+	return ret
+}

vendor/github.com/mailru/easyjson/helpers.go

@@ -0,0 +1,78 @@
+// Package easyjson contains marshaler/unmarshaler interfaces and helper functions.
+package easyjson
+
+import (
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strconv"
+
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// Marshaler is an easyjson-compatible marshaler interface.
+type Marshaler interface {
+	MarshalEasyJSON(w *jwriter.Writer)
+}
+
+// Marshaler is an easyjson-compatible unmarshaler interface.
+type Unmarshaler interface {
+	UnmarshalEasyJSON(w *jlexer.Lexer)
+}
+
+// Optional defines an undefined-test method for a type to integrate with 'omitempty' logic.
+type Optional interface {
+	IsDefined() bool
+}
+
+// Marshal returns data as a single byte slice. Method is suboptimal as the data is likely to be copied
+// from a chain of smaller chunks.
+func Marshal(v Marshaler) ([]byte, error) {
+	w := jwriter.Writer{}
+	v.MarshalEasyJSON(&w)
+	return w.BuildBytes()
+}
+
+// MarshalToWriter marshals the data to an io.Writer.
+func MarshalToWriter(v Marshaler, w io.Writer) (written int, err error) {
+	jw := jwriter.Writer{}
+	v.MarshalEasyJSON(&jw)
+	return jw.DumpTo(w)
+}
+
+// MarshalToHTTPResponseWriter sets Content-Length and Content-Type headers for the
+// http.ResponseWriter, and send the data to the writer. started will be equal to
+// false if an error occurred before any http.ResponseWriter methods were actually
+// invoked (in this case a 500 reply is possible).
+func MarshalToHTTPResponseWriter(v Marshaler, w http.ResponseWriter) (started bool, written int, err error) {
+	jw := jwriter.Writer{}
+	v.MarshalEasyJSON(&jw)
+	if jw.Error != nil {
+		return false, 0, jw.Error
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Content-Length", strconv.Itoa(jw.Size()))
+
+	started = true
+	written, err = jw.DumpTo(w)
+	return
+}
+
+// Unmarshal decodes the JSON in data into the object.
+func Unmarshal(data []byte, v Unmarshaler) error {
+	l := jlexer.Lexer{Data: data}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}
+
+// UnmarshalFromReader reads all the data in the reader and decodes as JSON into the object.
+func UnmarshalFromReader(r io.Reader, v Unmarshaler) error {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return err
+	}
+	l := jlexer.Lexer{Data: data}
+	v.UnmarshalEasyJSON(&l)
+	return l.Error()
+}

vendor/github.com/mailru/easyjson/jlexer/bytestostr.go

@@ -0,0 +1,24 @@
+// This file will only be included to the build if neither
+// easyjson_nounsafe nor appengine build tag is set. See README notes
+// for more details.
+
+//+build !easyjson_nounsafe
+//+build !appengine
+
+package jlexer
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// bytesToStr creates a string pointing at the slice to avoid copying.
+//
+// Warning: the string returned by the function should be used with care, as the whole input data
+// chunk may be either blocked from being freed by GC because of a single string or the buffer.Data
+// may be garbage-collected even when the string exists.
+func bytesToStr(data []byte) string {
+	h := (*reflect.SliceHeader)(unsafe.Pointer(&data))
+	shdr := reflect.StringHeader{Data: h.Data, Len: h.Len}
+	return *(*string)(unsafe.Pointer(&shdr))
+}

vendor/github.com/mailru/easyjson/jlexer/bytestostr_nounsafe.go

@@ -0,0 +1,13 @@
+// This file is included to the build if any of the buildtags below
+// are defined. Refer to README notes for more details.
+
+//+build easyjson_nounsafe appengine
+
+package jlexer
+
+// bytesToStr creates a string normally from []byte
+//
+// Note that this method is roughly 1.5x slower than using the 'unsafe' method.
+func bytesToStr(data []byte) string {
+	return string(data)
+}

vendor/github.com/mailru/easyjson/jlexer/error.go

@@ -0,0 +1,15 @@
+package jlexer
+
+import "fmt"
+
+// LexerError implements the error interface and represents all possible errors that can be
+// generated during parsing the JSON data.
+type LexerError struct {
+	Reason string
+	Offset int
+	Data   string
+}
+
+func (l *LexerError) Error() string {
+	return fmt.Sprintf("parse error: %s near offset %d of '%s'", l.Reason, l.Offset, l.Data)
+}

vendor/github.com/mailru/easyjson/jwriter/writer.go

@@ -0,0 +1,390 @@
+// Package jwriter contains a JSON writer.
+package jwriter
+
+import (
+	"io"
+	"strconv"
+	"unicode/utf8"
+
+	"github.com/mailru/easyjson/buffer"
+)
+
+// Flags describe various encoding options. The behavior may be actually implemented in the encoder, but
+// Flags field in Writer is used to set and pass them around.
+type Flags int
+
+const (
+	NilMapAsEmpty   Flags = 1 << iota // Encode nil map as '{}' rather than 'null'.
+	NilSliceAsEmpty                   // Encode nil slice as '[]' rather than 'null'.
+)
+
+// Writer is a JSON writer.
+type Writer struct {
+	Flags Flags
+
+	Error        error
+	Buffer       buffer.Buffer
+	NoEscapeHTML bool
+}
+
+// Size returns the size of the data that was written out.
+func (w *Writer) Size() int {
+	return w.Buffer.Size()
+}
+
+// DumpTo outputs the data to given io.Writer, resetting the buffer.
+func (w *Writer) DumpTo(out io.Writer) (written int, err error) {
+	return w.Buffer.DumpTo(out)
+}
+
+// BuildBytes returns writer data as a single byte slice. You can optionally provide one byte slice
+// as argument that it will try to reuse.
+func (w *Writer) BuildBytes(reuse ...[]byte) ([]byte, error) {
+	if w.Error != nil {
+		return nil, w.Error
+	}
+
+	return w.Buffer.BuildBytes(reuse...), nil
+}
+
+// ReadCloser returns an io.ReadCloser that can be used to read the data.
+// ReadCloser also resets the buffer.
+func (w *Writer) ReadCloser() (io.ReadCloser, error) {
+	if w.Error != nil {
+		return nil, w.Error
+	}
+
+	return w.Buffer.ReadCloser(), nil
+}
+
+// RawByte appends raw binary data to the buffer.
+func (w *Writer) RawByte(c byte) {
+	w.Buffer.AppendByte(c)
+}
+
+// RawByte appends raw binary data to the buffer.
+func (w *Writer) RawString(s string) {
+	w.Buffer.AppendString(s)
+}
+
+// Raw appends raw binary data to the buffer or sets the error if it is given. Useful for
+// calling with results of MarshalJSON-like functions.
+func (w *Writer) Raw(data []byte, err error) {
+	switch {
+	case w.Error != nil:
+		return
+	case err != nil:
+		w.Error = err
+	case len(data) > 0:
+		w.Buffer.AppendBytes(data)
+	default:
+		w.RawString("null")
+	}
+}
+
+// RawText encloses raw binary data in quotes and appends in to the buffer.
+// Useful for calling with results of MarshalText-like functions.
+func (w *Writer) RawText(data []byte, err error) {
+	switch {
+	case w.Error != nil:
+		return
+	case err != nil:
+		w.Error = err
+	case len(data) > 0:
+		w.String(string(data))
+	default:
+		w.RawString("null")
+	}
+}
+
+// Base64Bytes appends data to the buffer after base64 encoding it
+func (w *Writer) Base64Bytes(data []byte) {
+	if data == nil {
+		w.Buffer.AppendString("null")
+		return
+	}
+	w.Buffer.AppendByte('"')
+	w.base64(data)
+	w.Buffer.AppendByte('"')
+}
+
+func (w *Writer) Uint8(n uint8) {
+	w.Buffer.EnsureSpace(3)
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+}
+
+func (w *Writer) Uint16(n uint16) {
+	w.Buffer.EnsureSpace(5)
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+}
+
+func (w *Writer) Uint32(n uint32) {
+	w.Buffer.EnsureSpace(10)
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+}
+
+func (w *Writer) Uint(n uint) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+}
+
+func (w *Writer) Uint64(n uint64) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, n, 10)
+}
+
+func (w *Writer) Int8(n int8) {
+	w.Buffer.EnsureSpace(4)
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+}
+
+func (w *Writer) Int16(n int16) {
+	w.Buffer.EnsureSpace(6)
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+}
+
+func (w *Writer) Int32(n int32) {
+	w.Buffer.EnsureSpace(11)
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+}
+
+func (w *Writer) Int(n int) {
+	w.Buffer.EnsureSpace(21)
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+}
+
+func (w *Writer) Int64(n int64) {
+	w.Buffer.EnsureSpace(21)
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, n, 10)
+}
+
+func (w *Writer) Uint8Str(n uint8) {
+	w.Buffer.EnsureSpace(3)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Uint16Str(n uint16) {
+	w.Buffer.EnsureSpace(5)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Uint32Str(n uint32) {
+	w.Buffer.EnsureSpace(10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) UintStr(n uint) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Uint64Str(n uint64) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, n, 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) UintptrStr(n uintptr) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Int8Str(n int8) {
+	w.Buffer.EnsureSpace(4)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Int16Str(n int16) {
+	w.Buffer.EnsureSpace(6)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Int32Str(n int32) {
+	w.Buffer.EnsureSpace(11)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) IntStr(n int) {
+	w.Buffer.EnsureSpace(21)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Int64Str(n int64) {
+	w.Buffer.EnsureSpace(21)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, n, 10)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Float32(n float32) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = strconv.AppendFloat(w.Buffer.Buf, float64(n), 'g', -1, 32)
+}
+
+func (w *Writer) Float32Str(n float32) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendFloat(w.Buffer.Buf, float64(n), 'g', -1, 32)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Float64(n float64) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = strconv.AppendFloat(w.Buffer.Buf, n, 'g', -1, 64)
+}
+
+func (w *Writer) Float64Str(n float64) {
+	w.Buffer.EnsureSpace(20)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+	w.Buffer.Buf = strconv.AppendFloat(w.Buffer.Buf, float64(n), 'g', -1, 64)
+	w.Buffer.Buf = append(w.Buffer.Buf, '"')
+}
+
+func (w *Writer) Bool(v bool) {
+	w.Buffer.EnsureSpace(5)
+	if v {
+		w.Buffer.Buf = append(w.Buffer.Buf, "true"...)
+	} else {
+		w.Buffer.Buf = append(w.Buffer.Buf, "false"...)
+	}
+}
+
+const chars = "0123456789abcdef"
+
+func isNotEscapedSingleChar(c byte, escapeHTML bool) bool {
+	// Note: might make sense to use a table if there are more chars to escape. With 4 chars
+	// it benchmarks the same.
+	if escapeHTML {
+		return c != '<' && c != '>' && c != '&' && c != '\\' && c != '"' && c >= 0x20 && c < utf8.RuneSelf
+	} else {
+		return c != '\\' && c != '"' && c >= 0x20 && c < utf8.RuneSelf
+	}
+}
+
+func (w *Writer) String(s string) {
+	w.Buffer.AppendByte('"')
+
+	// Portions of the string that contain no escapes are appended as
+	// byte slices.
+
+	p := 0 // last non-escape symbol
+
+	for i := 0; i < len(s); {
+		c := s[i]
+
+		if isNotEscapedSingleChar(c, !w.NoEscapeHTML) {
+			// single-width character, no escaping is required
+			i++
+			continue
+		} else if c < utf8.RuneSelf {
+			// single-with character, need to escape
+			w.Buffer.AppendString(s[p:i])
+			switch c {
+			case '\t':
+				w.Buffer.AppendString(`\t`)
+			case '\r':
+				w.Buffer.AppendString(`\r`)
+			case '\n':
+				w.Buffer.AppendString(`\n`)
+			case '\\':
+				w.Buffer.AppendString(`\\`)
+			case '"':
+				w.Buffer.AppendString(`\"`)
+			default:
+				w.Buffer.AppendString(`\u00`)
+				w.Buffer.AppendByte(chars[c>>4])
+				w.Buffer.AppendByte(chars[c&0xf])
+			}
+
+			i++
+			p = i
+			continue
+		}
+
+		// broken utf
+		runeValue, runeWidth := utf8.DecodeRuneInString(s[i:])
+		if runeValue == utf8.RuneError && runeWidth == 1 {
+			w.Buffer.AppendString(s[p:i])
+			w.Buffer.AppendString(`\ufffd`)
+			i++
+			p = i
+			continue
+		}
+
+		// jsonp stuff - tab separator and line separator
+		if runeValue == '\u2028' || runeValue == '\u2029' {
+			w.Buffer.AppendString(s[p:i])
+			w.Buffer.AppendString(`\u202`)
+			w.Buffer.AppendByte(chars[runeValue&0xf])
+			i += runeWidth
+			p = i
+			continue
+		}
+		i += runeWidth
+	}
+	w.Buffer.AppendString(s[p:])
+	w.Buffer.AppendByte('"')
+}
+
+const encode = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+const padChar = '='
+
+func (w *Writer) base64(in []byte) {
+
+	if len(in) == 0 {
+		return
+	}
+
+	w.Buffer.EnsureSpace(((len(in)-1)/3 + 1) * 4)
+
+	si := 0
+	n := (len(in) / 3) * 3
+
+	for si < n {
+		// Convert 3x 8bit source bytes into 4 bytes
+		val := uint(in[si+0])<<16 | uint(in[si+1])<<8 | uint(in[si+2])
+
+		w.Buffer.Buf = append(w.Buffer.Buf, encode[val>>18&0x3F], encode[val>>12&0x3F], encode[val>>6&0x3F], encode[val&0x3F])
+
+		si += 3
+	}
+
+	remain := len(in) - si
+	if remain == 0 {
+		return
+	}
+
+	// Add the remaining small block
+	val := uint(in[si+0]) << 16
+	if remain == 2 {
+		val |= uint(in[si+1]) << 8
+	}
+
+	w.Buffer.Buf = append(w.Buffer.Buf, encode[val>>18&0x3F], encode[val>>12&0x3F])
+
+	switch remain {
+	case 2:
+		w.Buffer.Buf = append(w.Buffer.Buf, encode[val>>6&0x3F], byte(padChar))
+	case 1:
+		w.Buffer.Buf = append(w.Buffer.Buf, byte(padChar), byte(padChar))
+	}
+}

vendor/github.com/mailru/easyjson/raw.go

@@ -0,0 +1,45 @@
+package easyjson
+
+import (
+	"github.com/mailru/easyjson/jlexer"
+	"github.com/mailru/easyjson/jwriter"
+)
+
+// RawMessage is a raw piece of JSON (number, string, bool, object, array or
+// null) that is extracted without parsing and output as is during marshaling.
+type RawMessage []byte
+
+// MarshalEasyJSON does JSON marshaling using easyjson interface.
+func (v *RawMessage) MarshalEasyJSON(w *jwriter.Writer) {
+	if len(*v) == 0 {
+		w.RawString("null")
+	} else {
+		w.Raw(*v, nil)
+	}
+}
+
+// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface.
+func (v *RawMessage) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	*v = RawMessage(l.Raw())
+}
+
+// UnmarshalJSON implements encoding/json.Unmarshaler interface.
+func (v *RawMessage) UnmarshalJSON(data []byte) error {
+	*v = data
+	return nil
+}
+
+var nullBytes = []byte("null")
+
+// MarshalJSON implements encoding/json.Marshaler interface.
+func (v RawMessage) MarshalJSON() ([]byte, error) {
+	if len(v) == 0 {
+		return nullBytes, nil
+	}
+	return v, nil
+}
+
+// IsDefined is required for integration with omitempty easyjson logic.
+func (v *RawMessage) IsDefined() bool {
+	return len(*v) > 0
+}

vendor/github.com/olivere/elastic/.gitignore

@@ -0,0 +1,33 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+
+/.vscode/
+/debug.test
+/generator
+/cluster-test/cluster-test
+/cluster-test/*.log
+/cluster-test/es-chaos-monkey
+/spec
+/tmp
+/CHANGELOG-3.0.html
+

vendor/github.com/olivere/elastic/.gometalinter.json

@@ -0,0 +1,37 @@
+{
+  "Vendor": false,
+  "Deadline": "2m",
+  "Sort": ["linter", "severity", "path", "line"],
+  "DisableAll": true,
+  "Enable": [
+    "deadcode",
+    "dupl",
+    "gocyclo",
+    "gofmt",
+    "goimports",
+    "golint",
+    "gosimple",
+    "ineffassign",
+    "interfacer",
+    "lll",
+    "megacheck",
+    "misspell",
+    "nakedret",
+    "structcheck",
+    "unconvert",
+    "unparam",
+    "unused",
+    "varcheck",
+    "vet"
+  ],
+  "EnableGC": true,
+  "WarnUnmatchedDirective": true,
+  "Cyclo": 24,
+  "LineLength": 200,
+  "Exclude": [
+    "generator",
+    "spec",
+    "tmp",
+    ".*_easyjson.go"
+  ]
+}

vendor/github.com/olivere/elastic/.travis.yml

@@ -0,0 +1,15 @@
+sudo: required
+language: go
+script: go test -race -v . ./config
+go:
+  - "1.9.x"
+  - "1.10.x"
+  # - tip
+matrix:
+  allow_failures:
+    - go: tip
+services:
+  - docker
+before_install:
+  - sudo sysctl -w vm.max_map_count=262144
+  - docker run -d --rm -p 9200:9200  -e "http.host=0.0.0.0" -e "transport.host=127.0.0.1" -e "bootstrap.memory_lock=true" -e "ES_JAVA_OPTS=-Xms1g -Xmx1g" docker.elastic.co/elasticsearch/elasticsearch-oss:6.2.3 elasticsearch -Enetwork.host=_local_,_site_ -Enetwork.publish_host=_local_

vendor/github.com/olivere/elastic/CHANGELOG-3.0.md

@@ -0,0 +1,363 @@
+# Elastic 3.0
+
+Elasticsearch 2.0 comes with some [breaking changes](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/breaking-changes-2.0.html). You will probably need to upgrade your application and/or rewrite part of it due to those changes.
+
+We use that window of opportunity to also update Elastic (the Go client) from version 2.0 to 3.0. This will introduce both changes due to the Elasticsearch 2.0 update as well as changes that make Elastic cleaner by removing some old cruft.
+
+So, to summarize:
+
+1. Elastic 2.0 is compatible with Elasticsearch 1.7+ and is still actively maintained.
+2. Elastic 3.0 is compatible with Elasticsearch 2.0+ and will soon become the new master branch.
+
+The rest of the document is a list of all changes in Elastic 3.0.
+
+## Pointer types
+
+All types have changed to be pointer types, not value types. This not only is cleaner but also simplifies the API as illustrated by the following example:
+
+Example for Elastic 2.0 (old):
+
+```go
+q := elastic.NewMatchAllQuery()
+res, err := elastic.Search("one").Query(&q).Do()  // notice the & here
+```
+
+Example for Elastic 3.0 (new):
+
+```go
+q := elastic.NewMatchAllQuery()
+res, err := elastic.Search("one").Query(q).Do()   // no more &
+// ... which can be simplified as:
+res, err := elastic.Search("one").Query(elastic.NewMatchAllQuery()).Do()
+```
+
+It also helps to prevent [subtle issues](https://github.com/olivere/elastic/issues/115#issuecomment-130753046).
+
+## Query/filter merge
+
+One of the biggest changes in Elasticsearch 2.0 is the [merge of queries and filters](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_query_dsl_changes.html#_queries_and_filters_merged). In Elasticsearch 1.x, you had a whole range of queries and filters that were basically identical (e.g. `term_query` and `term_filter`).
+
+The practical aspect of the merge is that you can now basically use queries where once you had to use filters instead. For Elastic 3.0 this means: We could remove a whole bunch of files. Yay!
+
+Notice that some methods still come by "filter", e.g. `PostFilter`. However, they accept a `Query` now when they used to accept a `Filter` before.
+
+Example for Elastic 2.0 (old):
+
+```go
+q := elastic.NewMatchAllQuery()
+f := elastic.NewTermFilter("tag", "important")
+res, err := elastic.Search().Index("one").Query(&q).PostFilter(f)
+```
+
+Example for Elastic 3.0 (new):
+
+```go
+q := elastic.NewMatchAllQuery()
+f := elastic.NewTermQuery("tag", "important") // it's a query now!
+res, err := elastic.Search().Index("one").Query(q).PostFilter(f)
+```
+
+## Facets are removed
+
+[Facets have been removed](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_removed_features.html#_facets_have_been_removed) in Elasticsearch 2.0. You need to use aggregations now.
+
+## Errors
+
+Elasticsearch 2.0 returns more information about an error in the HTTP response body. Elastic 3.0 now reads this information and makes it accessible by the consumer.
+
+Errors and all its details are now returned in [`Error`](https://github.com/olivere/elastic/blob/release-branch.v3/errors.go#L59).
+
+### HTTP Status 404 (Not Found)
+
+When Elasticsearch does not find an entity or an index, it generally returns HTTP status code 404. In Elastic 2.0 this was a valid result and didn't raise an error from the `Do` functions. This has now changed in Elastic 3.0.
+
+Starting with Elastic 3.0, there are only two types of responses considered successful. First, responses with HTTP status codes [200..299]. Second, HEAD requests which return HTTP status 404. The latter is used by Elasticsearch to e.g. check for existence of indices or documents. All other responses will return an error.
+
+To check for HTTP Status 404 (with non-HEAD requests), e.g. when trying to get or delete a missing document, you can use the [`IsNotFound`](https://github.com/olivere/elastic/blob/release-branch.v3/errors.go#L84) helper (see below).
+
+The following example illustrates how to check for a missing document in Elastic 2.0 and what has changed in 3.0.
+
+Example for Elastic 2.0 (old):
+
+```go
+res, err = client.Get().Index("one").Type("tweet").Id("no-such-id").Do()
+if err != nil {
+  // Something else went wrong (but 404 is NOT an error in Elastic 2.0)
+}
+if !res.Found {
+	// Document has not been found
+}
+```
+
+Example for Elastic 3.0 (new):
+
+```go
+res, err = client.Get().Index("one").Type("tweet").Id("no-such-id").Do()
+if err != nil {
+  if elastic.IsNotFound(err) {
+    // Document has not been found
+  } else {
+    // Something else went wrong
+  }
+}
+```
+
+### HTTP Status 408 (Timeouts)
+
+Elasticsearch now responds with HTTP status code 408 (Timeout) when a request fails due to a timeout. E.g. if you specify a timeout with the Cluster Health API, the HTTP response status will be 408 if the timeout is raised. See [here](https://github.com/elastic/elasticsearch/commit/fe3179d9cccb569784434b2135ca9ae13d5158d3) for the specific commit to the Cluster Health API.
+
+To check for HTTP Status 408, we introduced the [`IsTimeout`](https://github.com/olivere/elastic/blob/release-branch.v3/errors.go#L101) helper.
+
+Example for Elastic 2.0 (old):
+
+```go
+health, err := client.ClusterHealth().WaitForStatus("yellow").Timeout("1s").Do()
+if err != nil {
+  // ...
+}
+if health.TimedOut {
+  // We have a timeout
+}
+```
+
+Example for Elastic 3.0 (new):
+
+```go
+health, err := client.ClusterHealth().WaitForStatus("yellow").Timeout("1s").Do()
+if elastic.IsTimeout(err) {
+  // We have a timeout
+}
+```
+
+### Bulk Errors
+
+The error response of a bulk operation used to be a simple string in Elasticsearch 1.x.
+In Elasticsearch 2.0, it returns a structured JSON object with a lot more details about the error.
+These errors are now captured in an object of type [`ErrorDetails`](https://github.com/olivere/elastic/blob/release-branch.v3/errors.go#L59) which is used in [`BulkResponseItem`](https://github.com/olivere/elastic/blob/release-branch.v3/bulk.go#L206).
+
+### Removed specific Elastic errors
+
+The specific error types `ErrMissingIndex`, `ErrMissingType`, and `ErrMissingId` have been removed. They were only used by `DeleteService` and are replaced by a generic error message.
+
+## Numeric types
+
+Elastic 3.0 has settled to use `float64` everywhere. It used to be a mix of `float32` and `float64` in Elastic 2.0. E.g. all boostable queries in Elastic 3.0 now have a boost type of `float64` where it used to be `float32`.
+
+## Pluralization
+
+Some services accept zero, one or more indices or types to operate on.
+E.g. in the `SearchService` accepts a list of zero, one, or more indices to
+search and therefor had a func called `Index(index string)` and a func
+called `Indices(indices ...string)`.
+
+Elastic 3.0 now only uses the singular form that, when applicable, accepts a
+variadic type. E.g. in the case of the `SearchService`, you now only have
+one func with the following signature: `Index(indices ...string)`.
+
+Notice this is only limited to `Index(...)` and `Type(...)`. There are other
+services with variadic functions. These have not been changed.
+
+## Multiple calls to variadic functions
+
+Some services with variadic functions have cleared the underlying slice when
+called while other services just add to the existing slice. This has now been
+normalized to always add to the underlying slice.
+
+Example for Elastic 2.0 (old):
+
+```go
+// Would only cleared scroll id "two"
+// because ScrollId cleared the values when called multiple times
+client.ClearScroll().ScrollId("one").ScrollId("two").Do()
+```
+
+Example for Elastic 3.0 (new):
+
+```go
+// Now (correctly) clears both scroll id "one" and "two"
+// because ScrollId no longer clears the values when called multiple times
+client.ClearScroll().ScrollId("one").ScrollId("two").Do()
+```
+
+## Ping service requires URL
+
+The `Ping` service raised some issues because it is different from all
+other services. If not explicitly given a URL, it always pings `127.0.0.1:9200`.
+
+Users expected to ping the cluster, but that is not possible as the cluster
+can be a set of many nodes: So which node do we ping then?
+
+To make it more clear, the `Ping` function on the client now requires users
+to explicitly set the URL of the node to ping.
+
+## Meta fields
+
+Many of the meta fields e.g. `_parent` or `_routing` are now
+[part of the top-level of a document](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_mapping_changes.html#migration-meta-fields)
+and are no longer returned as parts of the `fields` object. We had to change
+larger parts of e.g. the `Reindexer` to get it to work seamlessly with Elasticsearch 2.0.
+
+Notice that all stored meta-fields are now [returned by default](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_crud_and_routing_changes.html#_all_stored_meta_fields_returned_by_default).
+
+## HasParentQuery / HasChildQuery
+
+`NewHasParentQuery` and `NewHasChildQuery` must now include both parent/child type and query. It is now in line with the Java API.
+
+Example for Elastic 2.0 (old):
+
+```go
+allQ := elastic.NewMatchAllQuery()
+q := elastic.NewHasChildFilter("tweet").Query(&allQ)
+```
+
+Example for Elastic 3.0 (new):
+
+```go
+q := elastic.NewHasChildQuery("tweet", elastic.NewMatchAllQuery())
+```
+
+## SetBasicAuth client option
+
+You can now tell Elastic to pass HTTP Basic Auth credentials with each request. In previous versions of Elastic you had to set up your own `http.Transport` to do this. This should make it more convenient to use Elastic in combination with [Shield](https://www.elastic.co/products/shield) in its [basic setup](https://www.elastic.co/guide/en/shield/current/enable-basic-auth.html).
+
+Example:
+
+```go
+client, err := elastic.NewClient(elastic.SetBasicAuth("user", "secret"))
+if err != nil {
+  log.Fatal(err)
+}
+```
+
+## Delete-by-Query API
+
+The Delete-by-Query API is [a plugin now](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_removed_features.html#_delete_by_query_is_now_a_plugin). It is no longer core part of Elasticsearch. You can [install it as a plugin as described here](https://www.elastic.co/guide/en/elasticsearch/plugins/2.0/plugins-delete-by-query.html).
+
+Elastic 3.0 still contains the `DeleteByQueryService`, but you need to install the plugin first. If you don't install it and use `DeleteByQueryService` you will most probably get a 404.
+
+An older version of this document stated the following:
+
+> Elastic 3.0 still contains the `DeleteByQueryService` but it will fail with `ErrPluginNotFound` when the plugin is not installed.
+>
+> Example for Elastic 3.0 (new):
+>
+> ```go
+> _, err := client.DeleteByQuery().Query(elastic.NewTermQuery("client", "1")).Do()
+> if err == elastic.ErrPluginNotFound {
+> 	// Delete By Query API is not available
+> }
+> ```
+
+I have decided that this is not a good way to handle the case of a missing plugin. The main reason is that with this logic, you'd always have to check if the plugin is missing in case of an error. This is not only slow, but it also puts logic into a service where it should really be just opaque and return the response of Elasticsearch.
+
+If you rely on certain plugins to be installed, you should check on startup. That's where the following two helpers come into play.
+
+## HasPlugin and SetRequiredPlugins
+
+Some of the core functionality of Elasticsearch has now been moved into plugins. E.g. the Delete-by-Query API is [a plugin now](https://www.elastic.co/guide/en/elasticsearch/plugins/2.0/plugins-delete-by-query.html).
+
+You need to make sure to add these plugins to your Elasticsearch installation to still be able to use the `DeleteByQueryService`. You can test this now with the `HasPlugin(name string)` helper in the client.
+
+Example for Elastic 3.0 (new):
+
+```go
+err, found := client.HasPlugin("delete-by-query")
+if err == nil && found {
+	// ... Delete By Query API is available
+}
+```
+
+To simplify this process, there is now a `SetRequiredPlugins` helper that can be passed as an option func when creating a new client. If the plugin is not installed, the client wouldn't be created in the first place.
+
+```go
+// Will raise an error if the "delete-by-query" plugin is NOT installed
+client, err := elastic.NewClient(elastic.SetRequiredPlugins("delete-by-query"))
+if err != nil {
+  log.Fatal(err)
+}
+```
+
+Notice that there also is a way to define [mandatory plugins](https://www.elastic.co/guide/en/elasticsearch/reference/current/modules-plugins.html#_mandatory_plugins) in the Elasticsearch configuration file.
+
+## Common Query has been renamed to Common Terms Query
+
+The `CommonQuery` has been renamed to `CommonTermsQuery` to be in line with the [Java API](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_java_api_changes.html#_query_filter_refactoring).
+
+## Remove `MoreLikeThis` and `MoreLikeThisField`
+
+The More Like This API and the More Like This Field query [have been removed](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_query_dsl_changes.html#_more_like_this) and replaced with the `MoreLikeThisQuery`.
+
+## Remove Filtered Query
+
+With the merge of queries and filters, the [filtered query became deprecated](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_query_dsl_changes.html#_literal_filtered_literal_query_and_literal_query_literal_filter_deprecated). While it is only deprecated and therefore still available in Elasticsearch 2.0, we have decided to remove it from Elastic 3.0. Why? Because we think that when you're already forced to rewrite many of your application code, it might be a good chance to get rid of things that are deprecated as well. So you might simply change your filtered query with a boolean query as [described here](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_query_dsl_changes.html#_literal_filtered_literal_query_and_literal_query_literal_filter_deprecated).
+
+## Remove FuzzyLikeThis and FuzzyLikeThisField
+
+Both have been removed from Elasticsearch 2.0 as well.
+
+## Remove LimitFilter
+
+The `limit` filter is [deprecated in Elasticsearch 2.0](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_query_dsl_changes.html#_literal_limit_literal_filter_deprecated) and becomes a no-op. Now is a good chance to remove it from your application as well. Use the `terminate_after` parameter in your search [as described here](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/search-request-body.html) to achieve similar effects.
+
+## Remove `_cache` and `_cache_key` from filters
+
+Both have been [removed from Elasticsearch 2.0 as well](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_query_dsl_changes.html#_filter_auto_caching).
+
+## Partial fields are gone
+
+Partial fields are [removed in Elasticsearch 2.0](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/_search_changes.html#_partial_fields) in favor of [source filtering](https://www.elastic.co/guide/en/elasticsearch/reference/2.0/search-request-source-filtering.html).
+
+## Scripting
+
+A [`Script`](https://github.com/olivere/elastic/blob/release-branch.v3/script.go) type has been added to Elastic 3.0. In Elastic 2.0, there were various places (e.g. aggregations) where you could just add the script as a string, specify the scripting language, add parameters etc. With Elastic 3.0, you should now always use the `Script` type.
+
+Example for Elastic 2.0 (old):
+
+```go
+update, err := client.Update().Index("twitter").Type("tweet").Id("1").
+	Script("ctx._source.retweets += num").
+	ScriptParams(map[string]interface{}{"num": 1}).
+	Upsert(map[string]interface{}{"retweets": 0}).
+	Do()
+```
+
+Example for Elastic 3.0 (new):
+
+```go
+update, err := client.Update().Index("twitter").Type("tweet").Id("1").
+	Script(elastic.NewScript("ctx._source.retweets += num").Param("num", 1)).
+	Upsert(map[string]interface{}{"retweets": 0}).
+	Do()
+```
+
+## Cluster State
+
+The combination of `Metric(string)` and `Metrics(...string)` has been replaced by a single func with the signature `Metric(...string)`.
+
+## Unexported structs in response
+
+Services generally return a typed response from a `Do` func. Those structs are exported so that they can be passed around in your own application. In Elastic 3.0 however, we changed that (most) sub-structs are now unexported, meaning: You can only pass around the whole response, not sub-structures of it. This makes it easier for restructuring responses according to the Elasticsearch API. See [`ClusterStateResponse`](https://github.com/olivere/elastic/blob/release-branch.v3/cluster_state.go#L182) as an example.
+
+## Add offset to Histogram aggregation
+
+Histogram aggregations now have an [offset](https://github.com/elastic/elasticsearch/pull/9505) option.
+
+## Services
+
+### REST API specification
+
+As you might know, Elasticsearch comes with a REST API specification. The specification describes the endpoints in a JSON structure.
+
+Most services in Elastic predated the REST API specification. We are in the process of bringing all these services in line with the specification. Services can be generated by `go generate` (not 100% automatic though). This is an ongoing process.
+
+This probably doesn't mean a lot to you. However, you can now be more confident that Elastic supports all features that the REST API specification describes.
+
+At the same time, the file names of the services are renamed to match the REST API specification naming.
+
+### REST API Test Suite
+
+The REST API specification of Elasticsearch comes along with a test suite that official clients typically use to test for conformance. Up until now, Elastic didn't run this test suite. However, we are in the process of setting up infrastructure and tests to match this suite as well.
+
+This process in not completed though.
+
+

vendor/github.com/olivere/elastic/CHANGELOG-5.0.md

@@ -0,0 +1,195 @@
+# Changes in Elastic 5.0
+
+## Enforce context.Context in PerformRequest and Do
+
+We enforce the usage of `context.Context` everywhere you execute a request.
+You need to change all your `Do()` calls to pass a context: `Do(ctx)`.
+This enables automatic request cancelation and many other patterns.
+
+If you don't need this, simply pass `context.TODO()` or `context.Background()`.
+
+## Warmers removed
+
+Warmers are no longer necessary and have been [removed in ES 5.0](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_index_apis.html#_warmers).
+
+## Optimize removed
+
+Optimize was deprecated in ES 2.0 and has been [removed in ES 5.0](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_rest_api_changes.html#_literal__optimize_literal_endpoint_removed).
+Use [Force Merge](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-forcemerge.html) instead.
+
+## Missing Query removed
+
+The `missing` query has been [removed](https://www.elastic.co/guide/en/elasticsearch/reference/master/query-dsl-exists-query.html#_literal_missing_literal_query).
+Use `exists` query with `must_not` in `bool` query instead.
+
+## And Query removed
+
+The `and` query has been [removed](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_search_changes.html#_deprecated_queries_removed).
+Use `must` clauses in a `bool` query instead.
+
+## Not Query removed
+
+TODO Is it removed?
+
+## Or Query removed
+
+The `or` query has been [removed](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_search_changes.html#_deprecated_queries_removed).
+Use `should` clauses in a `bool` query instead.
+
+## Filtered Query removed
+
+The `filtered` query has been [removed](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_search_changes.html#_deprecated_queries_removed).
+Use `bool` query instead, which supports `filter` clauses too.
+
+## Limit Query removed
+
+The `limit` query has been [removed](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_search_changes.html#_deprecated_queries_removed).
+Use the `terminate_after` parameter instead.
+
+# Template Query removed
+
+The `template` query has been [deprecated](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/query-dsl-template-query.html). You should use
+Search Templates instead.
+
+We remove it from Elastic 5.0 as the 5.0 update is already a good opportunity
+to get rid of old stuff.
+
+## `_timestamp` and `_ttl` removed
+
+Both of these fields were deprecated and are now [removed](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_mapping_changes.html#_literal__timestamp_literal_and_literal__ttl_literal).
+
+## Search template Put/Delete API returns `acknowledged` only
+
+The response type for Put/Delete search templates has changed.
+It only returns a single `acknowledged` flag now.
+
+## Fields has been renamed to Stored Fields
+
+The `fields` parameter has been renamed to `stored_fields`.
+See [here](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/breaking_50_search_changes.html#_literal_fields_literal_parameter).
+
+## Fielddatafields has been renamed to Docvaluefields
+
+The `fielddata_fields` parameter [has been renamed](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/breaking_50_search_changes.html#_literal_fielddata_fields_literal_parameter)
+to `docvalue_fields`.
+
+## Type exists endpoint changed
+
+The endpoint for checking whether a type exists has been changed from
+`HEAD {index}/{type}` to `HEAD {index}/_mapping/{type}`.
+See [here](https://www.elastic.co/guide/en/elasticsearch/reference/5.0/breaking_50_rest_api_changes.html#_literal_head_index_type_literal_replaced_with_literal_head_index__mapping_type_literal).
+
+## Refresh parameter changed
+
+The `?refresh` parameter previously could be a boolean value. It indicated
+whether changes made by a request (e.g. by the Bulk API) should be immediately
+visible in search, or not. Using `refresh=true` had the positive effect of
+immediately seeing the changes when searching; the negative effect is that
+it is a rather big performance hit.
+
+With 5.0, you now have the choice between these 3 values.
+
+* `"true"` - Refresh immediately
+* `"false"` - Do not refresh (the default value)
+* `"wait_for"` - Wait until ES made the document visible in search
+
+See [?refresh](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-refresh.html) in the documentation.
+
+Notice that `true` and `false` (the boolean values) are no longer available
+now in Elastic. You must use a string instead, with one of the above values.
+
+## ReindexerService removed
+
+The `ReindexerService` was a custom solution that was started in the ES 1.x era
+to automate reindexing data, from one index to another or even between clusters.
+
+ES 2.3 introduced its own [Reindex API](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html)
+so we're going to remove our custom solution and ask you to use the native reindexer.
+
+The `ReindexService` is available via `client.Reindex()` (which used to point
+to the custom reindexer).
+
+## Delete By Query back in core
+
+The [Delete By Query API](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-delete-by-query.html)
+was moved into a plugin in 2.0. Now its back in core with a complete rewrite based on the Bulk API.
+
+It has it's own endpoint at `/_delete_by_query`.
+
+Delete By Query, Reindex, and Update By Query are very similar under the hood.
+
+## Reindex, Delete By Query, and Update By Query response changed
+
+The response from the above APIs changed a bit. E.g. the `retries` value
+used to be an `int64` and returns separate values for `bulk` and `search` now:
+
+```
+// Old
+{
+    ...
+    "retries": 123,
+    ...
+}
+```
+
+```
+// New
+{
+    ...
+    "retries": {
+        "bulk": 123,
+        "search": 0
+    },
+    ...
+}
+```
+
+## ScanService removed
+
+The `ScanService` is removed. Use the (new) `ScrollService` instead.
+
+## New ScrollService
+
+There was confusion around `ScanService` and `ScrollService` doing basically
+the same. One was returning slices and didn't support all query details, the
+other returned one document after another and wasn't safe for concurrent use.
+So we merged the two and merged it into a new `ScrollService` that
+removes all the problems with the older services.
+
+In other words:
+If you used `ScanService`, switch to `ScrollService`.
+If you used the old `ScrollService`, you might need to fix some things but
+overall it should just work.
+
+Changes:
+- We replaced `elastic.EOS` with `io.EOF` to indicate the "end of scroll".
+
+TODO Not implemented yet
+
+## Suggesters
+
+They have been [completely rewritten in ES 5.0](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_suggester.html).
+
+Some changes:
+- Suggesters no longer have an [output](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking_50_suggester.html#_simpler_completion_indexing).
+
+TODO Fix all structural changes in suggesters
+
+## Percolator
+
+Percolator has [changed considerably](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/breaking_50_percolator.html).
+
+Elastic 5.0 adds the new
+[Percolator Query](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/query-dsl-percolate-query.html)
+which can be used in combination with the new
+[Percolator type](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/percolator.html).
+
+The Percolate service is removed from Elastic 5.0.
+
+## Remove Consistency, add WaitForActiveShards
+
+The `consistency` parameter has been removed in a lot of places, e.g. the Bulk,
+Index, Delete, Delete-by-Query, Reindex, Update, and Update-by-Query API.
+
+It has been replaced by a somewhat similar `wait_for_active_shards` parameter.
+See https://github.com/elastic/elasticsearch/pull/19454.

vendor/github.com/olivere/elastic/CHANGELOG-6.0.md

@@ -0,0 +1,18 @@
+# Changes from 5.0 to 6.0
+
+See [breaking changes](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking-changes-6.0.html).
+
+## _all removed
+
+6.0 has removed support for the `_all` field.
+
+## Boolean values coerced
+
+Only use `true` or `false` for boolean values, not `0` or `1` or `on` or `off`.
+
+## Single Type Indices
+
+Notice that 6.0 and future versions will default to single type indices, i.e. you may not use multiple types when e.g. adding an index with a mapping.
+
+See [here for details](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/removal-of-types.html#_what_are_mapping_types).
+

vendor/github.com/olivere/elastic/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at oliver@eilhard.net. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

vendor/github.com/olivere/elastic/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# How to contribute
+
+Elastic is an open-source project and we are looking forward to each
+contribution.
+
+Notice that while the [official Elasticsearch documentation](https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html) is rather good, it is a high-level
+overview of the features of Elasticsearch. However, Elastic tries to resemble
+the Java API of Elasticsearch which you can find [on GitHub](https://github.com/elastic/elasticsearch).
+
+This explains why you might think that some options are strange or missing
+in Elastic, while often they're just different. Please check the Java API first.
+
+Having said that: Elasticsearch is moving fast and it might be very likely
+that we missed some features or changes. Feel free to change that.
+
+## Your Pull Request
+
+To make it easy to review and understand your changes, please keep the
+following things in mind before submitting your pull request:
+
+* You compared the existing implemenation with the Java API, did you?
+* Please work on the latest possible state of `olivere/elastic`.
+  Use `release-branch.v2` for targeting Elasticsearch 1.x and
+  `release-branch.v3` for targeting 2.x.
+* Create a branch dedicated to your change.
+* If possible, write a test case which confirms your change.
+* Make sure your changes and your tests work with all recent versions of
+  Elasticsearch. We currently support Elasticsearch 1.7.x in the
+  release-branch.v2 and Elasticsearch 2.x in the release-branch.v3.
+* Test your changes before creating a pull request (`go test ./...`).
+* Don't mix several features or bug fixes in one pull request.
+* Create a meaningful commit message.
+* Explain your change, e.g. provide a link to the issue you are fixing and
+  probably a link to the Elasticsearch documentation and/or source code.
+* Format your source with `go fmt`.
+
+## Additional Resources
+
+* [GitHub documentation](http://help.github.com/)
+* [GitHub pull request documentation](http://help.github.com/send-pull-requests/)

vendor/github.com/olivere/elastic/CONTRIBUTORS

@@ -0,0 +1,132 @@
+# This is a list of people who have contributed code
+# to the Elastic repository.
+#
+# It is just my small "thank you" to all those that helped
+# making Elastic what it is.
+#
+# Please keep this list sorted.
+
+0x6875790d0a [@huydx](https://github.com/huydx)
+Adam Alix [@adamalix](https://github.com/adamalix)
+Adam Weiner [@adamweiner](https://github.com/adamweiner)
+Adrian Lungu [@AdrianLungu](https://github.com/AdrianLungu)
+alehano [@alehano](https://github.com/alehano)
+Alex [@akotlar](https://github.com/akotlar)
+Alexander Sack [@asac](https://github.com/asac)
+Alexandre Olivier [@aliphen](https://github.com/aliphen)
+Alexey Sharov [@nizsheanez](https://github.com/nizsheanez)
+AndreKR [@AndreKR](https://github.com/AndreKR)
+André Bierlein [@ligustah](https://github.com/ligustah)
+Andrew Dunham [@andrew-d](https://github.com/andrew-d)
+Andrew Gaul [@andrewgaul](https://github.com/andrewgaul)
+Andy Walker [@alaska](https://github.com/alaska)
+Arquivei [@arquivei](https://github.com/arquivei)
+arthurgustin [@arthurgustin](https://github.com/arthurgustin)
+Benjamin Fernandes [@LotharSee](https://github.com/LotharSee)
+Benjamin Zarzycki [@kf6nux](https://github.com/kf6nux)
+Boris Popovschi [@Zyqsempai](https://github.com/Zyqsempai)
+Braden Bassingthwaite [@bbassingthwaite-va](https://github.com/bbassingthwaite-va)
+Brady Love [@bradylove](https://github.com/bradylove)
+Bryan Conklin [@bmconklin](https://github.com/bmconklin)
+Bruce Zhou [@brucez-isell](https://github.com/brucez-isell)
+cforbes [@cforbes](https://github.com/cforbes)
+Chris M [@tebriel](https://github.com/tebriel)
+Chris Rice [@donutmonger](https://github.com/donutmonger)
+Claudiu Olteanu [@claudiuolteanu](https://github.com/claudiuolteanu)
+Christophe Courtaut [@kri5](https://github.com/kri5)
+Connor Peet [@connor4312](https://github.com/connor4312)
+Conrad Pankoff [@deoxxa](https://github.com/deoxxa)
+Corey Scott [@corsc](https://github.com/corsc)
+Daniel Barrett [@shendaras](https://github.com/shendaras)
+Daniel Heckrath [@DanielHeckrath](https://github.com/DanielHeckrath)
+Daniel Imfeld [@dimfeld](https://github.com/dimfeld)
+Dwayne Schultz [@myshkin5](https://github.com/myshkin5)
+Ellison Leão [@ellisonleao](https://github.com/ellisonleao)
+Erwin [@eticzon](https://github.com/eticzon)
+Eugene Egorov [@EugeneEgorov](https://github.com/EugeneEgorov)
+Evan Shaw [@edsrzf](https://github.com/edsrzf)
+Fanfan [@wenpos](https://github.com/wenpos)
+Faolan C-P [@fcheslack](https://github.com/fcheslack)
+Filip Tepper [@filiptepper](https://github.com/filiptepper)
+Gaspard Douady [@plopik](https://github.com/plopik)
+Gaylord Aulke [@blafasel42](https://github.com/blafasel42)
+Gerhard Häring [@ghaering](https://github.com/ghaering)
+Guilherme Silveira [@guilherme-santos](https://github.com/guilherme-santos)
+Guillaume J. Charmes [@creack](https://github.com/creack)
+Guiseppe [@gm42](https://github.com/gm42)
+Han Yu [@MoonighT](https://github.com/MoonighT)
+Harmen [@alicebob](https://github.com/alicebob)
+Harrison Wright [@wright8191](https://github.com/wright8191)
+Henry Clifford [@hcliff](https://github.com/hcliff)
+Igor Dubinskiy [@idubinskiy](https://github.com/idubinskiy)
+initialcontext [@initialcontext](https://github.com/initialcontext)
+Isaac Saldana [@isaldana](https://github.com/isaldana)
+Jack Lindamood [@cep21](https://github.com/cep21)
+Jacob [@jdelgad](https://github.com/jdelgad)
+Jayme Rotsaert [@jrots](https://github.com/jrots)
+Jeremy Canady [@jrmycanady](https://github.com/jrmycanady)
+Jim Berlage [@jimberlage](https://github.com/jimberlage)
+Joe Buck [@four2five](https://github.com/four2five)
+John Barker [@j16r](https://github.com/j16r)
+John Goodall [@jgoodall](https://github.com/jgoodall)
+John Stanford [@jxstanford](https://github.com/jxstanford)
+Jonas Groenaas Drange [@semafor](https://github.com/semafor)
+Josef Fröhle [@Dexus](https://github.com/Dexus)
+Josh Chorlton [@jchorl](https://github.com/jchorl)
+jun [@coseyo](https://github.com/coseyo)
+Junpei Tsuji [@jun06t](https://github.com/jun06t)
+kartlee [@kartlee](https://github.com/kartlee)
+Keith Hatton [@khatton-ft](https://github.com/khatton-ft)
+kel [@liketic](https://github.com/liketic)
+Kenta SUZUKI [@suzuken](https://github.com/suzuken)
+Kevin Mulvey [@kmulvey](https://github.com/kmulvey)
+Kyle Brandt [@kylebrandt](https://github.com/kylebrandt)
+Leandro Piccilli [@lpic10](https://github.com/lpic10)
+M. Zulfa Achsani [@misterciput](https://github.com/misterciput)
+Maciej Lisiewski [@c2h5oh](https://github.com/c2h5oh)
+Mara Kim [@autochthe](https://github.com/autochthe)
+Marcy Buccellato [@marcybuccellato](https://github.com/marcybuccellato)
+Mark Costello [@mcos](https://github.com/mcos)
+Martin Häger [@protomouse](https://github.com/protomouse)
+Medhi Bechina [@mdzor](https://github.com/mdzor)
+mmfrb [@mmfrb](https://github.com/mmfrb)
+mnpritula [@mnpritula](https://github.com/mnpritula)
+mosa [@mosasiru](https://github.com/mosasiru)
+naimulhaider [@naimulhaider](https://github.com/naimulhaider)
+Naoya Yoshizawa [@azihsoyn](https://github.com/azihsoyn)
+navins [@ishare](https://github.com/ishare)
+Naoya Tsutsumi [@tutuming](https://github.com/tutuming)
+Nicholas Wolff [@nwolff](https://github.com/nwolff)
+Nick K [@utrack](https://github.com/utrack)
+Nick Whyte [@nickw444](https://github.com/nickw444)
+Nicolae Vartolomei [@nvartolomei](https://github.com/nvartolomei)
+Orne Brocaar [@brocaar](https://github.com/brocaar)
+Paul [@eyeamera](https://github.com/eyeamera)
+Pete C [@peteclark-ft](https://github.com/peteclark-ft)
+Radoslaw Wesolowski [r--w](https://github.com/r--w)
+Roman Colohanin [@zuzmic](https://github.com/zuzmic)
+Ryan Schmukler [@rschmukler](https://github.com/rschmukler)
+Ryan Wynn [@rwynn](https://github.com/rwynn)
+Sacheendra talluri [@sacheendra](https://github.com/sacheendra)
+Sean DuBois [@Sean-Der](https://github.com/Sean-Der)
+Shalin LK [@shalinlk](https://github.com/shalinlk)
+singham [@zhaochenxiao90](https://github.com/zhaochenxiao90)
+Stephen Kubovic [@stephenkubovic](https://github.com/stephenkubovic)
+Stuart Warren [@Woz](https://github.com/stuart-warren)
+Sulaiman [@salajlan](https://github.com/salajlan)
+Sundar [@sundarv85](https://github.com/sundarv85)
+Swarlston [@Swarlston](https://github.com/Swarlston)
+Take [ww24](https://github.com/ww24)
+Tetsuya Morimoto [@t2y](https://github.com/t2y)
+TimeEmit [@TimeEmit](https://github.com/timeemit)
+TusharM [@tusharm](https://github.com/tusharm)
+wangtuo [@wangtuo](https://github.com/wangtuo)
+Wédney Yuri [@wedneyyuri](https://github.com/wedneyyuri)
+wolfkdy [@wolfkdy](https://github.com/wolfkdy)
+Wyndham Blanton [@wyndhblb](https://github.com/wyndhblb)
+Yarden Bar [@ayashjorden](https://github.com/ayashjorden)
+zakthomas [@zakthomas](https://github.com/zakthomas)
+Yuya Kusakabe [@higebu](https://github.com/higebu)
+Zach [@snowzach](https://github.com/snowzach)
+zhangxin [@visaxin](https://github.com/visaxin)
+@林 [@zplzpl](https://github.com/zplzpl)

vendor/github.com/olivere/elastic/ISSUE_TEMPLATE.md

@@ -0,0 +1,18 @@
+Please use the following questions as a guideline to help me answer
+your issue/question without further inquiry. Thank you.
+
+### Which version of Elastic are you using?
+
+[ ] elastic.v2 (for Elasticsearch 1.x)
+[ ] elastic.v3 (for Elasticsearch 2.x)
+[ ] elastic.v5 (for Elasticsearch 5.x)
+[ ] elastic.v6 (for Elasticsearch 6.x)
+
+### Please describe the expected behavior
+
+
+### Please describe the actual behavior
+
+
+### Any steps to reproduce the behavior?
+

vendor/github.com/olivere/elastic/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright © 2012-2015 Oliver Eilhard
+
+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.

vendor/github.com/olivere/elastic/README.md

@@ -0,0 +1,396 @@
+# Elastic
+
+**This is a development branch that is actively being worked on. DO NOT USE IN PRODUCTION! If you want to use stable versions of Elastic, please use a dependency manager like [dep](https://github.com/golang/dep).**
+
+Elastic is an [Elasticsearch](http://www.elasticsearch.org/) client for the
+[Go](http://www.golang.org/) programming language.
+
+[![Build Status](https://travis-ci.org/olivere/elastic.svg?branch=release-branch.v6)](https://travis-ci.org/olivere/elastic)
+[![Godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](http://godoc.org/github.com/olivere/elastic)
+[![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/olivere/elastic/master/LICENSE)
+
+See the [wiki](https://github.com/olivere/elastic/wiki) for additional information about Elastic.
+
+<a href="https://www.buymeacoffee.com/Bjd96U8fm" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 41px !important;width: 174px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
+
+
+## Releases
+
+**The release branches (e.g. [`release-branch.v6`](https://github.com/olivere/elastic/tree/release-branch.v6))
+are actively being worked on and can break at any time.
+If you want to use stable versions of Elastic, please use a dependency manager like [dep](https://github.com/golang/dep).**
+
+Here's the version matrix:
+
+Elasticsearch version | Elastic version  | Package URL | Remarks |
+----------------------|------------------|-------------|---------|
+6.x                   | 6.0              | [`github.com/olivere/elastic`](https://github.com/olivere/elastic) ([source](https://github.com/olivere/elastic/tree/release-branch.v6) [doc](http://godoc.org/github.com/olivere/elastic)) | Use a dependency manager (see below).
+5.x                   | 5.0              | [`gopkg.in/olivere/elastic.v5`](https://gopkg.in/olivere/elastic.v5) ([source](https://github.com/olivere/elastic/tree/release-branch.v5) [doc](http://godoc.org/gopkg.in/olivere/elastic.v5)) | Actively maintained.
+2.x                   | 3.0              | [`gopkg.in/olivere/elastic.v3`](https://gopkg.in/olivere/elastic.v3) ([source](https://github.com/olivere/elastic/tree/release-branch.v3) [doc](http://godoc.org/gopkg.in/olivere/elastic.v3)) | Deprecated. Please update.
+1.x                   | 2.0              | [`gopkg.in/olivere/elastic.v2`](https://gopkg.in/olivere/elastic.v2) ([source](https://github.com/olivere/elastic/tree/release-branch.v2) [doc](http://godoc.org/gopkg.in/olivere/elastic.v2)) | Deprecated. Please update.
+0.9-1.3               | 1.0              | [`gopkg.in/olivere/elastic.v1`](https://gopkg.in/olivere/elastic.v1) ([source](https://github.com/olivere/elastic/tree/release-branch.v1) [doc](http://godoc.org/gopkg.in/olivere/elastic.v1)) | Deprecated. Please update.
+
+**Example:**
+
+You have installed Elasticsearch 6.0.0 and want to use Elastic.
+As listed above, you should use Elastic 6.0.
+
+To use the required version of Elastic in your application, it is strongly
+advised to use a tool like
+[dep](https://github.com/golang/dep)
+or
+[Glide](https://glide.sh/)
+to manage that dependency. Make sure to use a version such as `^6.0.0`.
+
+To use Elastic, simply import:
+
+```go
+import "github.com/olivere/elastic"
+```
+
+### Elastic 6.0
+
+Elastic 6.0 targets Elasticsearch 6.x which was [released on 14th November 2017](https://www.elastic.co/blog/elasticsearch-6-0-0-released).
+
+Notice that there are will be a lot of [breaking changes in Elasticsearch 6.0](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/breaking-changes-6.0.html)
+and we used this as an opportunity to [clean up and refactor Elastic](https://github.com/olivere/elastic/blob/release-branch.v6/CHANGELOG-6.0.md)
+as we did in the transition from earlier versions of Elastic.
+
+### Elastic 5.0
+
+Elastic 5.0 targets Elasticsearch 5.0.0 and later. Elasticsearch 5.0.0 was
+[released on 26th October 2016](https://www.elastic.co/blog/elasticsearch-5-0-0-released).
+
+Notice that there are will be a lot of [breaking changes in Elasticsearch 5.0](https://www.elastic.co/guide/en/elasticsearch/reference/5.0/breaking-changes-5.0.html)
+and we used this as an opportunity to [clean up and refactor Elastic](https://github.com/olivere/elastic/blob/release-branch.v5/CHANGELOG-5.0.md)
+as we did in the transition from Elastic 2.0 (for Elasticsearch 1.x) to Elastic 3.0 (for Elasticsearch 2.x).
+
+Furthermore, the jump in version numbers will give us a chance to be in sync with the Elastic Stack.
+
+### Elastic 3.0
+
+Elastic 3.0 targets Elasticsearch 2.x and is published via [`gopkg.in/olivere/elastic.v3`](https://gopkg.in/olivere/elastic.v3).
+
+Elastic 3.0 will only get critical bug fixes. You should update to a recent version.
+
+### Elastic 2.0
+
+Elastic 2.0 targets Elasticsearch 1.x and is published via [`gopkg.in/olivere/elastic.v2`](https://gopkg.in/olivere/elastic.v2).
+
+Elastic 2.0 will only get critical bug fixes. You should update to a recent version.
+
+### Elastic 1.0
+
+Elastic 1.0 is deprecated. You should really update Elasticsearch and Elastic
+to a recent version.
+
+However, if you cannot update for some reason, don't worry. Version 1.0 is
+still available. All you need to do is go-get it and change your import path
+as described above.
+
+
+## Status
+
+We use Elastic in production since 2012. Elastic is stable but the API changes
+now and then. We strive for API compatibility.
+However, Elasticsearch sometimes introduces [breaking changes](https://www.elastic.co/guide/en/elasticsearch/reference/master/breaking-changes.html)
+and we sometimes have to adapt.
+
+Having said that, there have been no big API changes that required you
+to rewrite your application big time. More often than not it's renaming APIs
+and adding/removing features so that Elastic is in sync with Elasticsearch.
+
+Elastic has been used in production with the following Elasticsearch versions:
+0.90, 1.0-1.7, and 2.0-2.4.1. Furthermore, we use [Travis CI](https://travis-ci.org/)
+to test Elastic with the most recent versions of Elasticsearch and Go.
+See the [.travis.yml](https://github.com/olivere/elastic/blob/master/.travis.yml)
+file for the exact matrix and [Travis](https://travis-ci.org/olivere/elastic)
+for the results.
+
+Elasticsearch has quite a few features. Most of them are implemented
+by Elastic. I add features and APIs as required. It's straightforward
+to implement missing pieces. I'm accepting pull requests :-)
+
+Having said that, I hope you find the project useful.
+
+
+## Getting Started
+
+The first thing you do is to create a [Client](https://github.com/olivere/elastic/blob/master/client.go).
+The client connects to Elasticsearch on `http://127.0.0.1:9200` by default.
+
+You typically create one client for your app. Here's a complete example of
+creating a client, creating an index, adding a document, executing a search etc.
+
+An example is available [here](https://olivere.github.io/elastic/).
+
+Here's a [link to a complete working example for v6](https://gist.github.com/olivere/e4a376b4783c0914e44ea4f745ce2ebf).
+
+See the [wiki](https://github.com/olivere/elastic/wiki) for more details.
+
+There are also [some recipes](https://github.com/olivere/elastic/tree/release-branch.v6/recipes) for bulk indexing, scrolling through documents in indices etc.
+
+## API Status
+
+### Document APIs
+
+- [x] Index API
+- [x] Get API
+- [x] Delete API
+- [x] Delete By Query API
+- [x] Update API
+- [x] Update By Query API
+- [x] Multi Get API
+- [x] Bulk API
+- [x] Reindex API
+- [x] Term Vectors
+- [x] Multi termvectors API
+
+### Search APIs
+
+- [x] Search
+- [x] Search Template
+- [ ] Multi Search Template
+- [x] Search Shards API
+- [x] Suggesters
+  - [x] Term Suggester
+  - [x] Phrase Suggester
+  - [x] Completion Suggester
+  - [x] Context Suggester
+- [x] Multi Search API
+- [x] Count API
+- [x] Validate API
+- [x] Explain API
+- [x] Profile API
+- [x] Field Capabilities API
+
+### Aggregations
+
+- Metrics Aggregations
+  - [x] Avg
+  - [x] Cardinality
+  - [x] Extended Stats
+  - [x] Geo Bounds
+  - [x] Geo Centroid
+  - [x] Max
+  - [x] Min
+  - [x] Percentiles
+  - [x] Percentile Ranks
+  - [ ] Scripted Metric
+  - [x] Stats
+  - [x] Sum
+  - [x] Top Hits
+  - [x] Value Count
+- Bucket Aggregations
+  - [x] Adjacency Matrix
+  - [x] Children
+  - [x] Date Histogram
+  - [x] Date Range
+  - [x] Diversified Sampler
+  - [x] Filter
+  - [x] Filters
+  - [x] Geo Distance
+  - [ ] GeoHash Grid
+  - [x] Global
+  - [x] Histogram
+  - [x] IP Range
+  - [x] Missing
+  - [x] Nested
+  - [x] Range
+  - [x] Reverse Nested
+  - [x] Sampler
+  - [x] Significant Terms
+  - [x] Significant Text
+  - [x] Terms
+  - [x] Composite
+- Pipeline Aggregations
+  - [x] Avg Bucket
+  - [x] Derivative
+  - [x] Max Bucket
+  - [x] Min Bucket
+  - [x] Sum Bucket
+  - [x] Stats Bucket
+  - [ ] Extended Stats Bucket
+  - [x] Percentiles Bucket
+  - [x] Moving Average
+  - [x] Cumulative Sum
+  - [x] Bucket Script
+  - [x] Bucket Selector
+  - [x] Bucket Sort
+  - [x] Serial Differencing
+- [x] Matrix Aggregations
+  - [x] Matrix Stats
+- [x] Aggregation Metadata
+
+### Indices APIs
+
+- [x] Create Index
+- [x] Delete Index
+- [x] Get Index
+- [x] Indices Exists
+- [x] Open / Close Index
+- [x] Shrink Index
+- [x] Rollover Index
+- [x] Put Mapping
+- [x] Get Mapping
+- [x] Get Field Mapping
+- [x] Types Exists
+- [x] Index Aliases
+- [x] Update Indices Settings
+- [x] Get Settings
+- [x] Analyze
+  - [x] Explain Analyze
+- [x] Index Templates
+- [x] Indices Stats
+- [x] Indices Segments
+- [ ] Indices Recovery
+- [ ] Indices Shard Stores
+- [ ] Clear Cache
+- [x] Flush
+  - [x] Synced Flush
+- [x] Refresh
+- [x] Force Merge
+
+### cat APIs
+
+The cat APIs are not implemented as of now. We think they are better suited for operating with Elasticsearch on the command line.
+
+- [ ] cat aliases
+- [ ] cat allocation
+- [ ] cat count
+- [ ] cat fielddata
+- [ ] cat health
+- [ ] cat indices
+- [ ] cat master
+- [ ] cat nodeattrs
+- [ ] cat nodes
+- [ ] cat pending tasks
+- [ ] cat plugins
+- [ ] cat recovery
+- [ ] cat repositories
+- [ ] cat thread pool
+- [ ] cat shards
+- [ ] cat segments
+- [ ] cat snapshots
+- [ ] cat templates
+
+### Cluster APIs
+
+- [x] Cluster Health
+- [x] Cluster State
+- [x] Cluster Stats
+- [ ] Pending Cluster Tasks
+- [ ] Cluster Reroute
+- [ ] Cluster Update Settings
+- [x] Nodes Stats
+- [x] Nodes Info
+- [ ] Nodes Feature Usage
+- [ ] Remote Cluster Info
+- [x] Task Management API
+- [ ] Nodes hot_threads
+- [ ] Cluster Allocation Explain API
+
+### Query DSL
+
+- [x] Match All Query
+- [x] Inner hits
+- Full text queries
+  - [x] Match Query
+  - [x] Match Phrase Query
+  - [x] Match Phrase Prefix Query
+  - [x] Multi Match Query
+  - [x] Common Terms Query
+  - [x] Query String Query
+  - [x] Simple Query String Query
+- Term level queries
+  - [x] Term Query
+  - [x] Terms Query
+  - [x] Terms Set Query
+  - [x] Range Query
+  - [x] Exists Query
+  - [x] Prefix Query
+  - [x] Wildcard Query
+  - [x] Regexp Query
+  - [x] Fuzzy Query
+  - [x] Type Query
+  - [x] Ids Query
+- Compound queries
+  - [x] Constant Score Query
+  - [x] Bool Query
+  - [x] Dis Max Query
+  - [x] Function Score Query
+  - [x] Boosting Query
+- Joining queries
+  - [x] Nested Query
+  - [x] Has Child Query
+  - [x] Has Parent Query
+  - [x] Parent Id Query
+- Geo queries
+  - [ ] GeoShape Query
+  - [x] Geo Bounding Box Query
+  - [x] Geo Distance Query
+  - [x] Geo Polygon Query
+- Specialized queries
+  - [x] More Like This Query
+  - [x] Script Query
+  - [x] Percolate Query
+- Span queries
+  - [ ] Span Term Query
+  - [ ] Span Multi Term Query
+  - [ ] Span First Query
+  - [ ] Span Near Query
+  - [ ] Span Or Query
+  - [ ] Span Not Query
+  - [ ] Span Containing Query
+  - [ ] Span Within Query
+  - [ ] Span Field Masking Query
+- [ ] Minimum Should Match
+- [ ] Multi Term Query Rewrite
+
+### Modules
+
+- Snapshot and Restore
+  - [x] Repositories
+  - [x] Snapshot
+  - [ ] Restore
+  - [ ] Snapshot status
+  - [ ] Monitoring snapshot/restore status
+  - [ ] Stopping currently running snapshot and restore
+
+### Sorting
+
+- [x] Sort by score
+- [x] Sort by field
+- [x] Sort by geo distance
+- [x] Sort by script
+- [x] Sort by doc
+
+### Scrolling
+
+Scrolling is supported via a  `ScrollService`. It supports an iterator-like interface.
+The `ClearScroll` API is implemented as well.
+
+A pattern for [efficiently scrolling in parallel](https://github.com/olivere/elastic/wiki/ScrollParallel)
+is described in the [Wiki](https://github.com/olivere/elastic/wiki).
+
+## How to contribute
+
+Read [the contribution guidelines](https://github.com/olivere/elastic/blob/master/CONTRIBUTING.md).
+
+## Credits
+
+Thanks a lot for the great folks working hard on
+[Elasticsearch](https://www.elastic.co/products/elasticsearch)
+and
+[Go](https://golang.org/).
+
+Elastic uses portions of the
+[uritemplates](https://github.com/jtacoma/uritemplates) library
+by Joshua Tacoma,
+[backoff](https://github.com/cenkalti/backoff) by Cenk Altı and
+[leaktest](https://github.com/fortytw2/leaktest) by Ian Chiles.
+
+## LICENSE
+
+MIT-LICENSE. See [LICENSE](http://olivere.mit-license.org/)
+or the LICENSE file provided in the repository for details.

vendor/github.com/olivere/elastic/acknowledged_response.go

@@ -0,0 +1,13 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+// AcknowledgedResponse is returned from various APIs. It simply indicates
+// whether the operation is ack'd or not.
+type AcknowledgedResponse struct {
+	Acknowledged       bool   `json:"acknowledged"`
+	ShardsAcknowledged bool   `json:"shards_acknowledged"`
+	Index              string `json:"index,omitempty"`
+}

vendor/github.com/olivere/elastic/backoff.go

@@ -0,0 +1,148 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"math"
+	"math/rand"
+	"sync"
+	"time"
+)
+
+// BackoffFunc specifies the signature of a function that returns the
+// time to wait before the next call to a resource. To stop retrying
+// return false in the 2nd return value.
+type BackoffFunc func(retry int) (time.Duration, bool)
+
+// Backoff allows callers to implement their own Backoff strategy.
+type Backoff interface {
+	// Next implements a BackoffFunc.
+	Next(retry int) (time.Duration, bool)
+}
+
+// -- ZeroBackoff --
+
+// ZeroBackoff is a fixed backoff policy whose backoff time is always zero,
+// meaning that the operation is retried immediately without waiting,
+// indefinitely.
+type ZeroBackoff struct{}
+
+// Next implements BackoffFunc for ZeroBackoff.
+func (b ZeroBackoff) Next(retry int) (time.Duration, bool) {
+	return 0, true
+}
+
+// -- StopBackoff --
+
+// StopBackoff is a fixed backoff policy that always returns false for
+// Next(), meaning that the operation should never be retried.
+type StopBackoff struct{}
+
+// Next implements BackoffFunc for StopBackoff.
+func (b StopBackoff) Next(retry int) (time.Duration, bool) {
+	return 0, false
+}
+
+// -- ConstantBackoff --
+
+// ConstantBackoff is a backoff policy that always returns the same delay.
+type ConstantBackoff struct {
+	interval time.Duration
+}
+
+// NewConstantBackoff returns a new ConstantBackoff.
+func NewConstantBackoff(interval time.Duration) *ConstantBackoff {
+	return &ConstantBackoff{interval: interval}
+}
+
+// Next implements BackoffFunc for ConstantBackoff.
+func (b *ConstantBackoff) Next(retry int) (time.Duration, bool) {
+	return b.interval, true
+}
+
+// -- Exponential --
+
+// ExponentialBackoff implements the simple exponential backoff described by
+// Douglas Thain at http://dthain.blogspot.de/2009/02/exponential-backoff-in-distributed.html.
+type ExponentialBackoff struct {
+	t float64 // initial timeout (in msec)
+	f float64 // exponential factor (e.g. 2)
+	m float64 // maximum timeout (in msec)
+}
+
+// NewExponentialBackoff returns a ExponentialBackoff backoff policy.
+// Use initialTimeout to set the first/minimal interval
+// and maxTimeout to set the maximum wait interval.
+func NewExponentialBackoff(initialTimeout, maxTimeout time.Duration) *ExponentialBackoff {
+	return &ExponentialBackoff{
+		t: float64(int64(initialTimeout / time.Millisecond)),
+		f: 2.0,
+		m: float64(int64(maxTimeout / time.Millisecond)),
+	}
+}
+
+// Next implements BackoffFunc for ExponentialBackoff.
+func (b *ExponentialBackoff) Next(retry int) (time.Duration, bool) {
+	r := 1.0 + rand.Float64() // random number in [1..2]
+	m := math.Min(r*b.t*math.Pow(b.f, float64(retry)), b.m)
+	if m >= b.m {
+		return 0, false
+	}
+	d := time.Duration(int64(m)) * time.Millisecond
+	return d, true
+}
+
+// -- Simple Backoff --
+
+// SimpleBackoff takes a list of fixed values for backoff intervals.
+// Each call to Next returns the next value from that fixed list.
+// After each value is returned, subsequent calls to Next will only return
+// the last element. The values are optionally "jittered" (off by default).
+type SimpleBackoff struct {
+	sync.Mutex
+	ticks  []int
+	jitter bool
+}
+
+// NewSimpleBackoff creates a SimpleBackoff algorithm with the specified
+// list of fixed intervals in milliseconds.
+func NewSimpleBackoff(ticks ...int) *SimpleBackoff {
+	return &SimpleBackoff{
+		ticks:  ticks,
+		jitter: false,
+	}
+}
+
+// Jitter enables or disables jittering values.
+func (b *SimpleBackoff) Jitter(flag bool) *SimpleBackoff {
+	b.Lock()
+	b.jitter = flag
+	b.Unlock()
+	return b
+}
+
+// jitter randomizes the interval to return a value of [0.5*millis .. 1.5*millis].
+func jitter(millis int) int {
+	if millis <= 0 {
+		return 0
+	}
+	return millis/2 + rand.Intn(millis)
+}
+
+// Next implements BackoffFunc for SimpleBackoff.
+func (b *SimpleBackoff) Next(retry int) (time.Duration, bool) {
+	b.Lock()
+	defer b.Unlock()
+
+	if retry >= len(b.ticks) {
+		return 0, false
+	}
+
+	ms := b.ticks[retry]
+	if b.jitter {
+		ms = jitter(ms)
+	}
+	return time.Duration(ms) * time.Millisecond, true
+}

vendor/github.com/olivere/elastic/bulk.go

@@ -0,0 +1,420 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// BulkService allows for batching bulk requests and sending them to
+// Elasticsearch in one roundtrip. Use the Add method with BulkIndexRequest,
+// BulkUpdateRequest, and BulkDeleteRequest to add bulk requests to a batch,
+// then use Do to send them to Elasticsearch.
+//
+// BulkService will be reset after each Do call. In other words, you can
+// reuse BulkService to send many batches. You do not have to create a new
+// BulkService for each batch.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html
+// for more details.
+type BulkService struct {
+	client  *Client
+	retrier Retrier
+
+	index               string
+	typ                 string
+	requests            []BulkableRequest
+	pipeline            string
+	timeout             string
+	refresh             string
+	routing             string
+	waitForActiveShards string
+	pretty              bool
+
+	// estimated bulk size in bytes, up to the request index sizeInBytesCursor
+	sizeInBytes       int64
+	sizeInBytesCursor int
+}
+
+// NewBulkService initializes a new BulkService.
+func NewBulkService(client *Client) *BulkService {
+	builder := &BulkService{
+		client: client,
+	}
+	return builder
+}
+
+func (s *BulkService) reset() {
+	s.requests = make([]BulkableRequest, 0)
+	s.sizeInBytes = 0
+	s.sizeInBytesCursor = 0
+}
+
+// Retrier allows to set specific retry logic for this BulkService.
+// If not specified, it will use the client's default retrier.
+func (s *BulkService) Retrier(retrier Retrier) *BulkService {
+	s.retrier = retrier
+	return s
+}
+
+// Index specifies the index to use for all batches. You may also leave
+// this blank and specify the index in the individual bulk requests.
+func (s *BulkService) Index(index string) *BulkService {
+	s.index = index
+	return s
+}
+
+// Type specifies the type to use for all batches. You may also leave
+// this blank and specify the type in the individual bulk requests.
+func (s *BulkService) Type(typ string) *BulkService {
+	s.typ = typ
+	return s
+}
+
+// Timeout is a global timeout for processing bulk requests. This is a
+// server-side timeout, i.e. it tells Elasticsearch the time after which
+// it should stop processing.
+func (s *BulkService) Timeout(timeout string) *BulkService {
+	s.timeout = timeout
+	return s
+}
+
+// Refresh controls when changes made by this request are made visible
+// to search. The allowed values are: "true" (refresh the relevant
+// primary and replica shards immediately), "wait_for" (wait for the
+// changes to be made visible by a refresh before reying), or "false"
+// (no refresh related actions). The default value is "false".
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-refresh.html
+// for details.
+func (s *BulkService) Refresh(refresh string) *BulkService {
+	s.refresh = refresh
+	return s
+}
+
+// Routing specifies the routing value.
+func (s *BulkService) Routing(routing string) *BulkService {
+	s.routing = routing
+	return s
+}
+
+// Pipeline specifies the pipeline id to preprocess incoming documents with.
+func (s *BulkService) Pipeline(pipeline string) *BulkService {
+	s.pipeline = pipeline
+	return s
+}
+
+// WaitForActiveShards sets the number of shard copies that must be active
+// before proceeding with the bulk operation. Defaults to 1, meaning the
+// primary shard only. Set to `all` for all shard copies, otherwise set to
+// any non-negative value less than or equal to the total number of copies
+// for the shard (number of replicas + 1).
+func (s *BulkService) WaitForActiveShards(waitForActiveShards string) *BulkService {
+	s.waitForActiveShards = waitForActiveShards
+	return s
+}
+
+// Pretty tells Elasticsearch whether to return a formatted JSON response.
+func (s *BulkService) Pretty(pretty bool) *BulkService {
+	s.pretty = pretty
+	return s
+}
+
+// Add adds bulkable requests, i.e. BulkIndexRequest, BulkUpdateRequest,
+// and/or BulkDeleteRequest.
+func (s *BulkService) Add(requests ...BulkableRequest) *BulkService {
+	for _, r := range requests {
+		s.requests = append(s.requests, r)
+	}
+	return s
+}
+
+// EstimatedSizeInBytes returns the estimated size of all bulkable
+// requests added via Add.
+func (s *BulkService) EstimatedSizeInBytes() int64 {
+	if s.sizeInBytesCursor == len(s.requests) {
+		return s.sizeInBytes
+	}
+	for _, r := range s.requests[s.sizeInBytesCursor:] {
+		s.sizeInBytes += s.estimateSizeInBytes(r)
+		s.sizeInBytesCursor++
+	}
+	return s.sizeInBytes
+}
+
+// estimateSizeInBytes returns the estimates size of the given
+// bulkable request, i.e. BulkIndexRequest, BulkUpdateRequest, and
+// BulkDeleteRequest.
+func (s *BulkService) estimateSizeInBytes(r BulkableRequest) int64 {
+	lines, _ := r.Source()
+	size := 0
+	for _, line := range lines {
+		// +1 for the \n
+		size += len(line) + 1
+	}
+	return int64(size)
+}
+
+// NumberOfActions returns the number of bulkable requests that need to
+// be sent to Elasticsearch on the next batch.
+func (s *BulkService) NumberOfActions() int {
+	return len(s.requests)
+}
+
+func (s *BulkService) bodyAsString() (string, error) {
+	// Pre-allocate to reduce allocs
+	buf := bytes.NewBuffer(make([]byte, 0, s.EstimatedSizeInBytes()))
+
+	for _, req := range s.requests {
+		source, err := req.Source()
+		if err != nil {
+			return "", err
+		}
+		for _, line := range source {
+			buf.WriteString(line)
+			buf.WriteByte('\n')
+		}
+	}
+
+	return buf.String(), nil
+}
+
+// Do sends the batched requests to Elasticsearch. Note that, when successful,
+// you can reuse the BulkService for the next batch as the list of bulk
+// requests is cleared on success.
+func (s *BulkService) Do(ctx context.Context) (*BulkResponse, error) {
+	// No actions?
+	if s.NumberOfActions() == 0 {
+		return nil, errors.New("elastic: No bulk actions to commit")
+	}
+
+	// Get body
+	body, err := s.bodyAsString()
+	if err != nil {
+		return nil, err
+	}
+
+	// Build url
+	path := "/"
+	if len(s.index) > 0 {
+		index, err := uritemplates.Expand("{index}", map[string]string{
+			"index": s.index,
+		})
+		if err != nil {
+			return nil, err
+		}
+		path += index + "/"
+	}
+	if len(s.typ) > 0 {
+		typ, err := uritemplates.Expand("{type}", map[string]string{
+			"type": s.typ,
+		})
+		if err != nil {
+			return nil, err
+		}
+		path += typ + "/"
+	}
+	path += "_bulk"
+
+	// Parameters
+	params := make(url.Values)
+	if s.pretty {
+		params.Set("pretty", fmt.Sprintf("%v", s.pretty))
+	}
+	if s.pipeline != "" {
+		params.Set("pipeline", s.pipeline)
+	}
+	if s.refresh != "" {
+		params.Set("refresh", s.refresh)
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.waitForActiveShards != "" {
+		params.Set("wait_for_active_shards", s.waitForActiveShards)
+	}
+
+	// Get response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method:      "POST",
+		Path:        path,
+		Params:      params,
+		Body:        body,
+		ContentType: "application/x-ndjson",
+		Retrier:     s.retrier,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return results
+	ret := new(BulkResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+
+	// Reset so the request can be reused
+	s.reset()
+
+	return ret, nil
+}
+
+// BulkResponse is a response to a bulk execution.
+//
+// Example:
+// {
+//   "took":3,
+//   "errors":false,
+//   "items":[{
+//     "index":{
+//       "_index":"index1",
+//       "_type":"tweet",
+//       "_id":"1",
+//       "_version":3,
+//       "status":201
+//     }
+//   },{
+//     "index":{
+//       "_index":"index2",
+//       "_type":"tweet",
+//       "_id":"2",
+//       "_version":3,
+//       "status":200
+//     }
+//   },{
+//     "delete":{
+//       "_index":"index1",
+//       "_type":"tweet",
+//       "_id":"1",
+//       "_version":4,
+//       "status":200,
+//       "found":true
+//     }
+//   },{
+//     "update":{
+//       "_index":"index2",
+//       "_type":"tweet",
+//       "_id":"2",
+//       "_version":4,
+//       "status":200
+//     }
+//   }]
+// }
+type BulkResponse struct {
+	Took   int                            `json:"took,omitempty"`
+	Errors bool                           `json:"errors,omitempty"`
+	Items  []map[string]*BulkResponseItem `json:"items,omitempty"`
+}
+
+// BulkResponseItem is the result of a single bulk request.
+type BulkResponseItem struct {
+	Index         string        `json:"_index,omitempty"`
+	Type          string        `json:"_type,omitempty"`
+	Id            string        `json:"_id,omitempty"`
+	Version       int64         `json:"_version,omitempty"`
+	Result        string        `json:"result,omitempty"`
+	Shards        *shardsInfo   `json:"_shards,omitempty"`
+	SeqNo         int64         `json:"_seq_no,omitempty"`
+	PrimaryTerm   int64         `json:"_primary_term,omitempty"`
+	Status        int           `json:"status,omitempty"`
+	ForcedRefresh bool          `json:"forced_refresh,omitempty"`
+	Error         *ErrorDetails `json:"error,omitempty"`
+	GetResult     *GetResult    `json:"get,omitempty"`
+}
+
+// Indexed returns all bulk request results of "index" actions.
+func (r *BulkResponse) Indexed() []*BulkResponseItem {
+	return r.ByAction("index")
+}
+
+// Created returns all bulk request results of "create" actions.
+func (r *BulkResponse) Created() []*BulkResponseItem {
+	return r.ByAction("create")
+}
+
+// Updated returns all bulk request results of "update" actions.
+func (r *BulkResponse) Updated() []*BulkResponseItem {
+	return r.ByAction("update")
+}
+
+// Deleted returns all bulk request results of "delete" actions.
+func (r *BulkResponse) Deleted() []*BulkResponseItem {
+	return r.ByAction("delete")
+}
+
+// ByAction returns all bulk request results of a certain action,
+// e.g. "index" or "delete".
+func (r *BulkResponse) ByAction(action string) []*BulkResponseItem {
+	if r.Items == nil {
+		return nil
+	}
+	var items []*BulkResponseItem
+	for _, item := range r.Items {
+		if result, found := item[action]; found {
+			items = append(items, result)
+		}
+	}
+	return items
+}
+
+// ById returns all bulk request results of a given document id,
+// regardless of the action ("index", "delete" etc.).
+func (r *BulkResponse) ById(id string) []*BulkResponseItem {
+	if r.Items == nil {
+		return nil
+	}
+	var items []*BulkResponseItem
+	for _, item := range r.Items {
+		for _, result := range item {
+			if result.Id == id {
+				items = append(items, result)
+			}
+		}
+	}
+	return items
+}
+
+// Failed returns those items of a bulk response that have errors,
+// i.e. those that don't have a status code between 200 and 299.
+func (r *BulkResponse) Failed() []*BulkResponseItem {
+	if r.Items == nil {
+		return nil
+	}
+	var errors []*BulkResponseItem
+	for _, item := range r.Items {
+		for _, result := range item {
+			if !(result.Status >= 200 && result.Status <= 299) {
+				errors = append(errors, result)
+			}
+		}
+	}
+	return errors
+}
+
+// Succeeded returns those items of a bulk response that have no errors,
+// i.e. those have a status code between 200 and 299.
+func (r *BulkResponse) Succeeded() []*BulkResponseItem {
+	if r.Items == nil {
+		return nil
+	}
+	var succeeded []*BulkResponseItem
+	for _, item := range r.Items {
+		for _, result := range item {
+			if result.Status >= 200 && result.Status <= 299 {
+				succeeded = append(succeeded, result)
+			}
+		}
+	}
+	return succeeded
+}

vendor/github.com/olivere/elastic/bulk_delete_request.go

@@ -0,0 +1,166 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+//go:generate easyjson bulk_delete_request.go
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// -- Bulk delete request --
+
+// BulkDeleteRequest is a request to remove a document from Elasticsearch.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html
+// for details.
+type BulkDeleteRequest struct {
+	BulkableRequest
+	index       string
+	typ         string
+	id          string
+	parent      string
+	routing     string
+	version     int64  // default is MATCH_ANY
+	versionType string // default is "internal"
+
+	source []string
+
+	useEasyJSON bool
+}
+
+//easyjson:json
+type bulkDeleteRequestCommand map[string]bulkDeleteRequestCommandOp
+
+//easyjson:json
+type bulkDeleteRequestCommandOp struct {
+	Index       string `json:"_index,omitempty"`
+	Type        string `json:"_type,omitempty"`
+	Id          string `json:"_id,omitempty"`
+	Parent      string `json:"parent,omitempty"`
+	Routing     string `json:"routing,omitempty"`
+	Version     int64  `json:"version,omitempty"`
+	VersionType string `json:"version_type,omitempty"`
+}
+
+// NewBulkDeleteRequest returns a new BulkDeleteRequest.
+func NewBulkDeleteRequest() *BulkDeleteRequest {
+	return &BulkDeleteRequest{}
+}
+
+// UseEasyJSON is an experimental setting that enables serialization
+// with github.com/mailru/easyjson, which should in faster serialization
+// time and less allocations, but removed compatibility with encoding/json,
+// usage of unsafe etc. See https://github.com/mailru/easyjson#issues-notes-and-limitations
+// for details. This setting is disabled by default.
+func (r *BulkDeleteRequest) UseEasyJSON(enable bool) *BulkDeleteRequest {
+	r.useEasyJSON = enable
+	return r
+}
+
+// Index specifies the Elasticsearch index to use for this delete request.
+// If unspecified, the index set on the BulkService will be used.
+func (r *BulkDeleteRequest) Index(index string) *BulkDeleteRequest {
+	r.index = index
+	r.source = nil
+	return r
+}
+
+// Type specifies the Elasticsearch type to use for this delete request.
+// If unspecified, the type set on the BulkService will be used.
+func (r *BulkDeleteRequest) Type(typ string) *BulkDeleteRequest {
+	r.typ = typ
+	r.source = nil
+	return r
+}
+
+// Id specifies the identifier of the document to delete.
+func (r *BulkDeleteRequest) Id(id string) *BulkDeleteRequest {
+	r.id = id
+	r.source = nil
+	return r
+}
+
+// Parent specifies the parent of the request, which is used in parent/child
+// mappings.
+func (r *BulkDeleteRequest) Parent(parent string) *BulkDeleteRequest {
+	r.parent = parent
+	r.source = nil
+	return r
+}
+
+// Routing specifies a routing value for the request.
+func (r *BulkDeleteRequest) Routing(routing string) *BulkDeleteRequest {
+	r.routing = routing
+	r.source = nil
+	return r
+}
+
+// Version indicates the version to be deleted as part of an optimistic
+// concurrency model.
+func (r *BulkDeleteRequest) Version(version int64) *BulkDeleteRequest {
+	r.version = version
+	r.source = nil
+	return r
+}
+
+// VersionType can be "internal" (default), "external", "external_gte",
+// or "external_gt".
+func (r *BulkDeleteRequest) VersionType(versionType string) *BulkDeleteRequest {
+	r.versionType = versionType
+	r.source = nil
+	return r
+}
+
+// String returns the on-wire representation of the delete request,
+// concatenated as a single string.
+func (r *BulkDeleteRequest) String() string {
+	lines, err := r.Source()
+	if err != nil {
+		return fmt.Sprintf("error: %v", err)
+	}
+	return strings.Join(lines, "\n")
+}
+
+// Source returns the on-wire representation of the delete request,
+// split into an action-and-meta-data line and an (optional) source line.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html
+// for details.
+func (r *BulkDeleteRequest) Source() ([]string, error) {
+	if r.source != nil {
+		return r.source, nil
+	}
+	command := bulkDeleteRequestCommand{
+		"delete": bulkDeleteRequestCommandOp{
+			Index:       r.index,
+			Type:        r.typ,
+			Id:          r.id,
+			Routing:     r.routing,
+			Parent:      r.parent,
+			Version:     r.version,
+			VersionType: r.versionType,
+		},
+	}
+
+	var err error
+	var body []byte
+	if r.useEasyJSON {
+		// easyjson
+		body, err = command.MarshalJSON()
+	} else {
+		// encoding/json
+		body, err = json.Marshal(command)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	lines := []string{string(body)}
+	r.source = lines
+
+	return lines, nil
+}

vendor/github.com/olivere/elastic/bulk_delete_request_easyjson.go

@@ -0,0 +1,230 @@
+// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.
+
+package elastic
+
+import (
+	json "encoding/json"
+	easyjson "github.com/mailru/easyjson"
+	jlexer "github.com/mailru/easyjson/jlexer"
+	jwriter "github.com/mailru/easyjson/jwriter"
+)
+
+// suppress unused package warning
+var (
+	_ *json.RawMessage
+	_ *jlexer.Lexer
+	_ *jwriter.Writer
+	_ easyjson.Marshaler
+)
+
+func easyjson8092efb6DecodeGithubComOlivereElastic(in *jlexer.Lexer, out *bulkDeleteRequestCommandOp) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		if isTopLevel {
+			in.Consumed()
+		}
+		in.Skip()
+		return
+	}
+	in.Delim('{')
+	for !in.IsDelim('}') {
+		key := in.UnsafeString()
+		in.WantColon()
+		if in.IsNull() {
+			in.Skip()
+			in.WantComma()
+			continue
+		}
+		switch key {
+		case "_index":
+			out.Index = string(in.String())
+		case "_type":
+			out.Type = string(in.String())
+		case "_id":
+			out.Id = string(in.String())
+		case "parent":
+			out.Parent = string(in.String())
+		case "routing":
+			out.Routing = string(in.String())
+		case "version":
+			out.Version = int64(in.Int64())
+		case "version_type":
+			out.VersionType = string(in.String())
+		default:
+			in.SkipRecursive()
+		}
+		in.WantComma()
+	}
+	in.Delim('}')
+	if isTopLevel {
+		in.Consumed()
+	}
+}
+func easyjson8092efb6EncodeGithubComOlivereElastic(out *jwriter.Writer, in bulkDeleteRequestCommandOp) {
+	out.RawByte('{')
+	first := true
+	_ = first
+	if in.Index != "" {
+		const prefix string = ",\"_index\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Index))
+	}
+	if in.Type != "" {
+		const prefix string = ",\"_type\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Type))
+	}
+	if in.Id != "" {
+		const prefix string = ",\"_id\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Id))
+	}
+	if in.Parent != "" {
+		const prefix string = ",\"parent\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Parent))
+	}
+	if in.Routing != "" {
+		const prefix string = ",\"routing\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Routing))
+	}
+	if in.Version != 0 {
+		const prefix string = ",\"version\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Int64(int64(in.Version))
+	}
+	if in.VersionType != "" {
+		const prefix string = ",\"version_type\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.VersionType))
+	}
+	out.RawByte('}')
+}
+
+// MarshalJSON supports json.Marshaler interface
+func (v bulkDeleteRequestCommandOp) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	easyjson8092efb6EncodeGithubComOlivereElastic(&w, v)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// MarshalEasyJSON supports easyjson.Marshaler interface
+func (v bulkDeleteRequestCommandOp) MarshalEasyJSON(w *jwriter.Writer) {
+	easyjson8092efb6EncodeGithubComOlivereElastic(w, v)
+}
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (v *bulkDeleteRequestCommandOp) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	easyjson8092efb6DecodeGithubComOlivereElastic(&r, v)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (v *bulkDeleteRequestCommandOp) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	easyjson8092efb6DecodeGithubComOlivereElastic(l, v)
+}
+func easyjson8092efb6DecodeGithubComOlivereElastic1(in *jlexer.Lexer, out *bulkDeleteRequestCommand) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		in.Skip()
+	} else {
+		in.Delim('{')
+		if !in.IsDelim('}') {
+			*out = make(bulkDeleteRequestCommand)
+		} else {
+			*out = nil
+		}
+		for !in.IsDelim('}') {
+			key := string(in.String())
+			in.WantColon()
+			var v1 bulkDeleteRequestCommandOp
+			(v1).UnmarshalEasyJSON(in)
+			(*out)[key] = v1
+			in.WantComma()
+		}
+		in.Delim('}')
+	}
+	if isTopLevel {
+		in.Consumed()
+	}
+}
+func easyjson8092efb6EncodeGithubComOlivereElastic1(out *jwriter.Writer, in bulkDeleteRequestCommand) {
+	if in == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
+		out.RawString(`null`)
+	} else {
+		out.RawByte('{')
+		v2First := true
+		for v2Name, v2Value := range in {
+			if v2First {
+				v2First = false
+			} else {
+				out.RawByte(',')
+			}
+			out.String(string(v2Name))
+			out.RawByte(':')
+			(v2Value).MarshalEasyJSON(out)
+		}
+		out.RawByte('}')
+	}
+}
+
+// MarshalJSON supports json.Marshaler interface
+func (v bulkDeleteRequestCommand) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	easyjson8092efb6EncodeGithubComOlivereElastic1(&w, v)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// MarshalEasyJSON supports easyjson.Marshaler interface
+func (v bulkDeleteRequestCommand) MarshalEasyJSON(w *jwriter.Writer) {
+	easyjson8092efb6EncodeGithubComOlivereElastic1(w, v)
+}
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (v *bulkDeleteRequestCommand) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	easyjson8092efb6DecodeGithubComOlivereElastic1(&r, v)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (v *bulkDeleteRequestCommand) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	easyjson8092efb6DecodeGithubComOlivereElastic1(l, v)
+}

vendor/github.com/olivere/elastic/bulk_index_request.go

@@ -0,0 +1,239 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+//go:generate easyjson bulk_index_request.go
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// BulkIndexRequest is a request to add a document to Elasticsearch.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html
+// for details.
+type BulkIndexRequest struct {
+	BulkableRequest
+	index           string
+	typ             string
+	id              string
+	opType          string
+	routing         string
+	parent          string
+	version         int64  // default is MATCH_ANY
+	versionType     string // default is "internal"
+	doc             interface{}
+	pipeline        string
+	retryOnConflict *int
+
+	source []string
+
+	useEasyJSON bool
+}
+
+//easyjson:json
+type bulkIndexRequestCommand map[string]bulkIndexRequestCommandOp
+
+//easyjson:json
+type bulkIndexRequestCommandOp struct {
+	Index  string `json:"_index,omitempty"`
+	Id     string `json:"_id,omitempty"`
+	Type   string `json:"_type,omitempty"`
+	Parent string `json:"parent,omitempty"`
+	// RetryOnConflict is "_retry_on_conflict" for 6.0 and "retry_on_conflict" for 6.1+.
+	RetryOnConflict *int   `json:"retry_on_conflict,omitempty"`
+	Routing         string `json:"routing,omitempty"`
+	Version         int64  `json:"version,omitempty"`
+	VersionType     string `json:"version_type,omitempty"`
+	Pipeline        string `json:"pipeline,omitempty"`
+}
+
+// NewBulkIndexRequest returns a new BulkIndexRequest.
+// The operation type is "index" by default.
+func NewBulkIndexRequest() *BulkIndexRequest {
+	return &BulkIndexRequest{
+		opType: "index",
+	}
+}
+
+// UseEasyJSON is an experimental setting that enables serialization
+// with github.com/mailru/easyjson, which should in faster serialization
+// time and less allocations, but removed compatibility with encoding/json,
+// usage of unsafe etc. See https://github.com/mailru/easyjson#issues-notes-and-limitations
+// for details. This setting is disabled by default.
+func (r *BulkIndexRequest) UseEasyJSON(enable bool) *BulkIndexRequest {
+	r.useEasyJSON = enable
+	return r
+}
+
+// Index specifies the Elasticsearch index to use for this index request.
+// If unspecified, the index set on the BulkService will be used.
+func (r *BulkIndexRequest) Index(index string) *BulkIndexRequest {
+	r.index = index
+	r.source = nil
+	return r
+}
+
+// Type specifies the Elasticsearch type to use for this index request.
+// If unspecified, the type set on the BulkService will be used.
+func (r *BulkIndexRequest) Type(typ string) *BulkIndexRequest {
+	r.typ = typ
+	r.source = nil
+	return r
+}
+
+// Id specifies the identifier of the document to index.
+func (r *BulkIndexRequest) Id(id string) *BulkIndexRequest {
+	r.id = id
+	r.source = nil
+	return r
+}
+
+// OpType specifies if this request should follow create-only or upsert
+// behavior. This follows the OpType of the standard document index API.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-index_.html#operation-type
+// for details.
+func (r *BulkIndexRequest) OpType(opType string) *BulkIndexRequest {
+	r.opType = opType
+	r.source = nil
+	return r
+}
+
+// Routing specifies a routing value for the request.
+func (r *BulkIndexRequest) Routing(routing string) *BulkIndexRequest {
+	r.routing = routing
+	r.source = nil
+	return r
+}
+
+// Parent specifies the identifier of the parent document (if available).
+func (r *BulkIndexRequest) Parent(parent string) *BulkIndexRequest {
+	r.parent = parent
+	r.source = nil
+	return r
+}
+
+// Version indicates the version of the document as part of an optimistic
+// concurrency model.
+func (r *BulkIndexRequest) Version(version int64) *BulkIndexRequest {
+	r.version = version
+	r.source = nil
+	return r
+}
+
+// VersionType specifies how versions are created. It can be e.g. internal,
+// external, external_gte, or force.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-index_.html#index-versioning
+// for details.
+func (r *BulkIndexRequest) VersionType(versionType string) *BulkIndexRequest {
+	r.versionType = versionType
+	r.source = nil
+	return r
+}
+
+// Doc specifies the document to index.
+func (r *BulkIndexRequest) Doc(doc interface{}) *BulkIndexRequest {
+	r.doc = doc
+	r.source = nil
+	return r
+}
+
+// RetryOnConflict specifies how often to retry in case of a version conflict.
+func (r *BulkIndexRequest) RetryOnConflict(retryOnConflict int) *BulkIndexRequest {
+	r.retryOnConflict = &retryOnConflict
+	r.source = nil
+	return r
+}
+
+// Pipeline to use while processing the request.
+func (r *BulkIndexRequest) Pipeline(pipeline string) *BulkIndexRequest {
+	r.pipeline = pipeline
+	r.source = nil
+	return r
+}
+
+// String returns the on-wire representation of the index request,
+// concatenated as a single string.
+func (r *BulkIndexRequest) String() string {
+	lines, err := r.Source()
+	if err != nil {
+		return fmt.Sprintf("error: %v", err)
+	}
+	return strings.Join(lines, "\n")
+}
+
+// Source returns the on-wire representation of the index request,
+// split into an action-and-meta-data line and an (optional) source line.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html
+// for details.
+func (r *BulkIndexRequest) Source() ([]string, error) {
+	// { "index" : { "_index" : "test", "_type" : "type1", "_id" : "1" } }
+	// { "field1" : "value1" }
+
+	if r.source != nil {
+		return r.source, nil
+	}
+
+	lines := make([]string, 2)
+
+	// "index" ...
+	indexCommand := bulkIndexRequestCommandOp{
+		Index:           r.index,
+		Type:            r.typ,
+		Id:              r.id,
+		Routing:         r.routing,
+		Parent:          r.parent,
+		Version:         r.version,
+		VersionType:     r.versionType,
+		RetryOnConflict: r.retryOnConflict,
+		Pipeline:        r.pipeline,
+	}
+	command := bulkIndexRequestCommand{
+		r.opType: indexCommand,
+	}
+
+	var err error
+	var body []byte
+	if r.useEasyJSON {
+		// easyjson
+		body, err = command.MarshalJSON()
+	} else {
+		// encoding/json
+		body, err = json.Marshal(command)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	lines[0] = string(body)
+
+	// "field1" ...
+	if r.doc != nil {
+		switch t := r.doc.(type) {
+		default:
+			body, err := json.Marshal(r.doc)
+			if err != nil {
+				return nil, err
+			}
+			lines[1] = string(body)
+		case json.RawMessage:
+			lines[1] = string(t)
+		case *json.RawMessage:
+			lines[1] = string(*t)
+		case string:
+			lines[1] = t
+		case *string:
+			lines[1] = *t
+		}
+	} else {
+		lines[1] = "{}"
+	}
+
+	r.source = lines
+	return lines, nil
+}

vendor/github.com/olivere/elastic/bulk_index_request_easyjson.go

@@ -0,0 +1,262 @@
+// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.
+
+package elastic
+
+import (
+	json "encoding/json"
+	easyjson "github.com/mailru/easyjson"
+	jlexer "github.com/mailru/easyjson/jlexer"
+	jwriter "github.com/mailru/easyjson/jwriter"
+)
+
+// suppress unused package warning
+var (
+	_ *json.RawMessage
+	_ *jlexer.Lexer
+	_ *jwriter.Writer
+	_ easyjson.Marshaler
+)
+
+func easyjson9de0fcbfDecodeGithubComOlivereElastic(in *jlexer.Lexer, out *bulkIndexRequestCommandOp) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		if isTopLevel {
+			in.Consumed()
+		}
+		in.Skip()
+		return
+	}
+	in.Delim('{')
+	for !in.IsDelim('}') {
+		key := in.UnsafeString()
+		in.WantColon()
+		if in.IsNull() {
+			in.Skip()
+			in.WantComma()
+			continue
+		}
+		switch key {
+		case "_index":
+			out.Index = string(in.String())
+		case "_id":
+			out.Id = string(in.String())
+		case "_type":
+			out.Type = string(in.String())
+		case "parent":
+			out.Parent = string(in.String())
+		case "retry_on_conflict":
+			if in.IsNull() {
+				in.Skip()
+				out.RetryOnConflict = nil
+			} else {
+				if out.RetryOnConflict == nil {
+					out.RetryOnConflict = new(int)
+				}
+				*out.RetryOnConflict = int(in.Int())
+			}
+		case "routing":
+			out.Routing = string(in.String())
+		case "version":
+			out.Version = int64(in.Int64())
+		case "version_type":
+			out.VersionType = string(in.String())
+		case "pipeline":
+			out.Pipeline = string(in.String())
+		default:
+			in.SkipRecursive()
+		}
+		in.WantComma()
+	}
+	in.Delim('}')
+	if isTopLevel {
+		in.Consumed()
+	}
+}
+func easyjson9de0fcbfEncodeGithubComOlivereElastic(out *jwriter.Writer, in bulkIndexRequestCommandOp) {
+	out.RawByte('{')
+	first := true
+	_ = first
+	if in.Index != "" {
+		const prefix string = ",\"_index\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Index))
+	}
+	if in.Id != "" {
+		const prefix string = ",\"_id\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Id))
+	}
+	if in.Type != "" {
+		const prefix string = ",\"_type\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Type))
+	}
+	if in.Parent != "" {
+		const prefix string = ",\"parent\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Parent))
+	}
+	if in.RetryOnConflict != nil {
+		const prefix string = ",\"retry_on_conflict\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Int(int(*in.RetryOnConflict))
+	}
+	if in.Routing != "" {
+		const prefix string = ",\"routing\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Routing))
+	}
+	if in.Version != 0 {
+		const prefix string = ",\"version\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Int64(int64(in.Version))
+	}
+	if in.VersionType != "" {
+		const prefix string = ",\"version_type\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.VersionType))
+	}
+	if in.Pipeline != "" {
+		const prefix string = ",\"pipeline\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Pipeline))
+	}
+	out.RawByte('}')
+}
+
+// MarshalJSON supports json.Marshaler interface
+func (v bulkIndexRequestCommandOp) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	easyjson9de0fcbfEncodeGithubComOlivereElastic(&w, v)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// MarshalEasyJSON supports easyjson.Marshaler interface
+func (v bulkIndexRequestCommandOp) MarshalEasyJSON(w *jwriter.Writer) {
+	easyjson9de0fcbfEncodeGithubComOlivereElastic(w, v)
+}
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (v *bulkIndexRequestCommandOp) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	easyjson9de0fcbfDecodeGithubComOlivereElastic(&r, v)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (v *bulkIndexRequestCommandOp) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	easyjson9de0fcbfDecodeGithubComOlivereElastic(l, v)
+}
+func easyjson9de0fcbfDecodeGithubComOlivereElastic1(in *jlexer.Lexer, out *bulkIndexRequestCommand) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		in.Skip()
+	} else {
+		in.Delim('{')
+		if !in.IsDelim('}') {
+			*out = make(bulkIndexRequestCommand)
+		} else {
+			*out = nil
+		}
+		for !in.IsDelim('}') {
+			key := string(in.String())
+			in.WantColon()
+			var v1 bulkIndexRequestCommandOp
+			(v1).UnmarshalEasyJSON(in)
+			(*out)[key] = v1
+			in.WantComma()
+		}
+		in.Delim('}')
+	}
+	if isTopLevel {
+		in.Consumed()
+	}
+}
+func easyjson9de0fcbfEncodeGithubComOlivereElastic1(out *jwriter.Writer, in bulkIndexRequestCommand) {
+	if in == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
+		out.RawString(`null`)
+	} else {
+		out.RawByte('{')
+		v2First := true
+		for v2Name, v2Value := range in {
+			if v2First {
+				v2First = false
+			} else {
+				out.RawByte(',')
+			}
+			out.String(string(v2Name))
+			out.RawByte(':')
+			(v2Value).MarshalEasyJSON(out)
+		}
+		out.RawByte('}')
+	}
+}
+
+// MarshalJSON supports json.Marshaler interface
+func (v bulkIndexRequestCommand) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	easyjson9de0fcbfEncodeGithubComOlivereElastic1(&w, v)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// MarshalEasyJSON supports easyjson.Marshaler interface
+func (v bulkIndexRequestCommand) MarshalEasyJSON(w *jwriter.Writer) {
+	easyjson9de0fcbfEncodeGithubComOlivereElastic1(w, v)
+}
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (v *bulkIndexRequestCommand) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	easyjson9de0fcbfDecodeGithubComOlivereElastic1(&r, v)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (v *bulkIndexRequestCommand) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	easyjson9de0fcbfDecodeGithubComOlivereElastic1(l, v)
+}

vendor/github.com/olivere/elastic/bulk_processor.go

@@ -0,0 +1,600 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// BulkProcessorService allows to easily process bulk requests. It allows setting
+// policies when to flush new bulk requests, e.g. based on a number of actions,
+// on the size of the actions, and/or to flush periodically. It also allows
+// to control the number of concurrent bulk requests allowed to be executed
+// in parallel.
+//
+// BulkProcessorService, by default, commits either every 1000 requests or when the
+// (estimated) size of the bulk requests exceeds 5 MB. However, it does not
+// commit periodically. BulkProcessorService also does retry by default, using
+// an exponential backoff algorithm.
+//
+// The caller is responsible for setting the index and type on every
+// bulk request added to BulkProcessorService.
+//
+// BulkProcessorService takes ideas from the BulkProcessor of the
+// Elasticsearch Java API as documented in
+// https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-docs-bulk-processor.html.
+type BulkProcessorService struct {
+	c             *Client
+	beforeFn      BulkBeforeFunc
+	afterFn       BulkAfterFunc
+	name          string        // name of processor
+	numWorkers    int           // # of workers (>= 1)
+	bulkActions   int           // # of requests after which to commit
+	bulkSize      int           // # of bytes after which to commit
+	flushInterval time.Duration // periodic flush interval
+	wantStats     bool          // indicates whether to gather statistics
+	backoff       Backoff       // a custom Backoff to use for errors
+}
+
+// NewBulkProcessorService creates a new BulkProcessorService.
+func NewBulkProcessorService(client *Client) *BulkProcessorService {
+	return &BulkProcessorService{
+		c:           client,
+		numWorkers:  1,
+		bulkActions: 1000,
+		bulkSize:    5 << 20, // 5 MB
+		backoff: NewExponentialBackoff(
+			time.Duration(200)*time.Millisecond,
+			time.Duration(10000)*time.Millisecond,
+		),
+	}
+}
+
+// BulkBeforeFunc defines the signature of callbacks that are executed
+// before a commit to Elasticsearch.
+type BulkBeforeFunc func(executionId int64, requests []BulkableRequest)
+
+// BulkAfterFunc defines the signature of callbacks that are executed
+// after a commit to Elasticsearch. The err parameter signals an error.
+type BulkAfterFunc func(executionId int64, requests []BulkableRequest, response *BulkResponse, err error)
+
+// Before specifies a function to be executed before bulk requests get comitted
+// to Elasticsearch.
+func (s *BulkProcessorService) Before(fn BulkBeforeFunc) *BulkProcessorService {
+	s.beforeFn = fn
+	return s
+}
+
+// After specifies a function to be executed when bulk requests have been
+// comitted to Elasticsearch. The After callback executes both when the
+// commit was successful as well as on failures.
+func (s *BulkProcessorService) After(fn BulkAfterFunc) *BulkProcessorService {
+	s.afterFn = fn
+	return s
+}
+
+// Name is an optional name to identify this bulk processor.
+func (s *BulkProcessorService) Name(name string) *BulkProcessorService {
+	s.name = name
+	return s
+}
+
+// Workers is the number of concurrent workers allowed to be
+// executed. Defaults to 1 and must be greater or equal to 1.
+func (s *BulkProcessorService) Workers(num int) *BulkProcessorService {
+	s.numWorkers = num
+	return s
+}
+
+// BulkActions specifies when to flush based on the number of actions
+// currently added. Defaults to 1000 and can be set to -1 to be disabled.
+func (s *BulkProcessorService) BulkActions(bulkActions int) *BulkProcessorService {
+	s.bulkActions = bulkActions
+	return s
+}
+
+// BulkSize specifies when to flush based on the size (in bytes) of the actions
+// currently added. Defaults to 5 MB and can be set to -1 to be disabled.
+func (s *BulkProcessorService) BulkSize(bulkSize int) *BulkProcessorService {
+	s.bulkSize = bulkSize
+	return s
+}
+
+// FlushInterval specifies when to flush at the end of the given interval.
+// This is disabled by default. If you want the bulk processor to
+// operate completely asynchronously, set both BulkActions and BulkSize to
+// -1 and set the FlushInterval to a meaningful interval.
+func (s *BulkProcessorService) FlushInterval(interval time.Duration) *BulkProcessorService {
+	s.flushInterval = interval
+	return s
+}
+
+// Stats tells bulk processor to gather stats while running.
+// Use Stats to return the stats. This is disabled by default.
+func (s *BulkProcessorService) Stats(wantStats bool) *BulkProcessorService {
+	s.wantStats = wantStats
+	return s
+}
+
+// Backoff sets the backoff strategy to use for errors.
+func (s *BulkProcessorService) Backoff(backoff Backoff) *BulkProcessorService {
+	s.backoff = backoff
+	return s
+}
+
+// Do creates a new BulkProcessor and starts it.
+// Consider the BulkProcessor as a running instance that accepts bulk requests
+// and commits them to Elasticsearch, spreading the work across one or more
+// workers.
+//
+// You can interoperate with the BulkProcessor returned by Do, e.g. Start and
+// Stop (or Close) it.
+//
+// Context is an optional context that is passed into the bulk request
+// service calls. In contrast to other operations, this context is used in
+// a long running process. You could use it to pass e.g. loggers, but you
+// shouldn't use it for cancellation.
+//
+// Calling Do several times returns new BulkProcessors. You probably don't
+// want to do this. BulkProcessorService implements just a builder pattern.
+func (s *BulkProcessorService) Do(ctx context.Context) (*BulkProcessor, error) {
+	p := newBulkProcessor(
+		s.c,
+		s.beforeFn,
+		s.afterFn,
+		s.name,
+		s.numWorkers,
+		s.bulkActions,
+		s.bulkSize,
+		s.flushInterval,
+		s.wantStats,
+		s.backoff)
+
+	err := p.Start(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return p, nil
+}
+
+// -- Bulk Processor Statistics --
+
+// BulkProcessorStats contains various statistics of a bulk processor
+// while it is running. Use the Stats func to return it while running.
+type BulkProcessorStats struct {
+	Flushed   int64 // number of times the flush interval has been invoked
+	Committed int64 // # of times workers committed bulk requests
+	Indexed   int64 // # of requests indexed
+	Created   int64 // # of requests that ES reported as creates (201)
+	Updated   int64 // # of requests that ES reported as updates
+	Deleted   int64 // # of requests that ES reported as deletes
+	Succeeded int64 // # of requests that ES reported as successful
+	Failed    int64 // # of requests that ES reported as failed
+
+	Workers []*BulkProcessorWorkerStats // stats for each worker
+}
+
+// BulkProcessorWorkerStats represents per-worker statistics.
+type BulkProcessorWorkerStats struct {
+	Queued       int64         // # of requests queued in this worker
+	LastDuration time.Duration // duration of last commit
+}
+
+// newBulkProcessorStats initializes and returns a BulkProcessorStats struct.
+func newBulkProcessorStats(workers int) *BulkProcessorStats {
+	stats := &BulkProcessorStats{
+		Workers: make([]*BulkProcessorWorkerStats, workers),
+	}
+	for i := 0; i < workers; i++ {
+		stats.Workers[i] = &BulkProcessorWorkerStats{}
+	}
+	return stats
+}
+
+func (st *BulkProcessorStats) dup() *BulkProcessorStats {
+	dst := new(BulkProcessorStats)
+	dst.Flushed = st.Flushed
+	dst.Committed = st.Committed
+	dst.Indexed = st.Indexed
+	dst.Created = st.Created
+	dst.Updated = st.Updated
+	dst.Deleted = st.Deleted
+	dst.Succeeded = st.Succeeded
+	dst.Failed = st.Failed
+	for _, src := range st.Workers {
+		dst.Workers = append(dst.Workers, src.dup())
+	}
+	return dst
+}
+
+func (st *BulkProcessorWorkerStats) dup() *BulkProcessorWorkerStats {
+	dst := new(BulkProcessorWorkerStats)
+	dst.Queued = st.Queued
+	dst.LastDuration = st.LastDuration
+	return dst
+}
+
+// -- Bulk Processor --
+
+// BulkProcessor encapsulates a task that accepts bulk requests and
+// orchestrates committing them to Elasticsearch via one or more workers.
+//
+// BulkProcessor is returned by setting up a BulkProcessorService and
+// calling the Do method.
+type BulkProcessor struct {
+	c             *Client
+	beforeFn      BulkBeforeFunc
+	afterFn       BulkAfterFunc
+	name          string
+	bulkActions   int
+	bulkSize      int
+	numWorkers    int
+	executionId   int64
+	requestsC     chan BulkableRequest
+	workerWg      sync.WaitGroup
+	workers       []*bulkWorker
+	flushInterval time.Duration
+	flusherStopC  chan struct{}
+	wantStats     bool
+	backoff       Backoff
+
+	startedMu sync.Mutex // guards the following block
+	started   bool
+
+	statsMu sync.Mutex // guards the following block
+	stats   *BulkProcessorStats
+
+	stopReconnC chan struct{} // channel to signal stop reconnection attempts
+}
+
+func newBulkProcessor(
+	client *Client,
+	beforeFn BulkBeforeFunc,
+	afterFn BulkAfterFunc,
+	name string,
+	numWorkers int,
+	bulkActions int,
+	bulkSize int,
+	flushInterval time.Duration,
+	wantStats bool,
+	backoff Backoff) *BulkProcessor {
+	return &BulkProcessor{
+		c:             client,
+		beforeFn:      beforeFn,
+		afterFn:       afterFn,
+		name:          name,
+		numWorkers:    numWorkers,
+		bulkActions:   bulkActions,
+		bulkSize:      bulkSize,
+		flushInterval: flushInterval,
+		wantStats:     wantStats,
+		backoff:       backoff,
+	}
+}
+
+// Start starts the bulk processor. If the processor is already started,
+// nil is returned.
+func (p *BulkProcessor) Start(ctx context.Context) error {
+	p.startedMu.Lock()
+	defer p.startedMu.Unlock()
+
+	if p.started {
+		return nil
+	}
+
+	// We must have at least one worker.
+	if p.numWorkers < 1 {
+		p.numWorkers = 1
+	}
+
+	p.requestsC = make(chan BulkableRequest)
+	p.executionId = 0
+	p.stats = newBulkProcessorStats(p.numWorkers)
+	p.stopReconnC = make(chan struct{})
+
+	// Create and start up workers.
+	p.workers = make([]*bulkWorker, p.numWorkers)
+	for i := 0; i < p.numWorkers; i++ {
+		p.workerWg.Add(1)
+		p.workers[i] = newBulkWorker(p, i)
+		go p.workers[i].work(ctx)
+	}
+
+	// Start the ticker for flush (if enabled)
+	if int64(p.flushInterval) > 0 {
+		p.flusherStopC = make(chan struct{})
+		go p.flusher(p.flushInterval)
+	}
+
+	p.started = true
+
+	return nil
+}
+
+// Stop is an alias for Close.
+func (p *BulkProcessor) Stop() error {
+	return p.Close()
+}
+
+// Close stops the bulk processor previously started with Do.
+// If it is already stopped, this is a no-op and nil is returned.
+//
+// By implementing Close, BulkProcessor implements the io.Closer interface.
+func (p *BulkProcessor) Close() error {
+	p.startedMu.Lock()
+	defer p.startedMu.Unlock()
+
+	// Already stopped? Do nothing.
+	if !p.started {
+		return nil
+	}
+
+	// Tell connection checkers to stop
+	if p.stopReconnC != nil {
+		close(p.stopReconnC)
+		p.stopReconnC = nil
+	}
+
+	// Stop flusher (if enabled)
+	if p.flusherStopC != nil {
+		p.flusherStopC <- struct{}{}
+		<-p.flusherStopC
+		close(p.flusherStopC)
+		p.flusherStopC = nil
+	}
+
+	// Stop all workers.
+	close(p.requestsC)
+	p.workerWg.Wait()
+
+	p.started = false
+
+	return nil
+}
+
+// Stats returns the latest bulk processor statistics.
+// Collecting stats must be enabled first by calling Stats(true) on
+// the service that created this processor.
+func (p *BulkProcessor) Stats() BulkProcessorStats {
+	p.statsMu.Lock()
+	defer p.statsMu.Unlock()
+	return *p.stats.dup()
+}
+
+// Add adds a single request to commit by the BulkProcessorService.
+//
+// The caller is responsible for setting the index and type on the request.
+func (p *BulkProcessor) Add(request BulkableRequest) {
+	p.requestsC <- request
+}
+
+// Flush manually asks all workers to commit their outstanding requests.
+// It returns only when all workers acknowledge completion.
+func (p *BulkProcessor) Flush() error {
+	p.statsMu.Lock()
+	p.stats.Flushed++
+	p.statsMu.Unlock()
+
+	for _, w := range p.workers {
+		w.flushC <- struct{}{}
+		<-w.flushAckC // wait for completion
+	}
+	return nil
+}
+
+// flusher is a single goroutine that periodically asks all workers to
+// commit their outstanding bulk requests. It is only started if
+// FlushInterval is greater than 0.
+func (p *BulkProcessor) flusher(interval time.Duration) {
+	ticker := time.NewTicker(interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C: // Periodic flush
+			p.Flush() // TODO swallow errors here?
+
+		case <-p.flusherStopC:
+			p.flusherStopC <- struct{}{}
+			return
+		}
+	}
+}
+
+// -- Bulk Worker --
+
+// bulkWorker encapsulates a single worker, running in a goroutine,
+// receiving bulk requests and eventually committing them to Elasticsearch.
+// It is strongly bound to a BulkProcessor.
+type bulkWorker struct {
+	p           *BulkProcessor
+	i           int
+	bulkActions int
+	bulkSize    int
+	service     *BulkService
+	flushC      chan struct{}
+	flushAckC   chan struct{}
+}
+
+// newBulkWorker creates a new bulkWorker instance.
+func newBulkWorker(p *BulkProcessor, i int) *bulkWorker {
+	return &bulkWorker{
+		p:           p,
+		i:           i,
+		bulkActions: p.bulkActions,
+		bulkSize:    p.bulkSize,
+		service:     NewBulkService(p.c),
+		flushC:      make(chan struct{}),
+		flushAckC:   make(chan struct{}),
+	}
+}
+
+// work waits for bulk requests and manual flush calls on the respective
+// channels and is invoked as a goroutine when the bulk processor is started.
+func (w *bulkWorker) work(ctx context.Context) {
+	defer func() {
+		w.p.workerWg.Done()
+		close(w.flushAckC)
+		close(w.flushC)
+	}()
+
+	var stop bool
+	for !stop {
+		var err error
+		select {
+		case req, open := <-w.p.requestsC:
+			if open {
+				// Received a new request
+				w.service.Add(req)
+				if w.commitRequired() {
+					err = w.commit(ctx)
+				}
+			} else {
+				// Channel closed: Stop.
+				stop = true
+				if w.service.NumberOfActions() > 0 {
+					err = w.commit(ctx)
+				}
+			}
+
+		case <-w.flushC:
+			// Commit outstanding requests
+			if w.service.NumberOfActions() > 0 {
+				err = w.commit(ctx)
+			}
+			w.flushAckC <- struct{}{}
+		}
+		if !stop && err != nil {
+			waitForActive := func() {
+				// Add back pressure to prevent Add calls from filling up the request queue
+				ready := make(chan struct{})
+				go w.waitForActiveConnection(ready)
+				<-ready
+			}
+			if _, ok := err.(net.Error); ok {
+				waitForActive()
+			} else if IsConnErr(err) {
+				waitForActive()
+			}
+		}
+	}
+}
+
+// commit commits the bulk requests in the given service,
+// invoking callbacks as specified.
+func (w *bulkWorker) commit(ctx context.Context) error {
+	var res *BulkResponse
+
+	// commitFunc will commit bulk requests and, on failure, be retried
+	// via exponential backoff
+	commitFunc := func() error {
+		var err error
+		res, err = w.service.Do(ctx)
+		return err
+	}
+	// notifyFunc will be called if retry fails
+	notifyFunc := func(err error) {
+		w.p.c.errorf("elastic: bulk processor %q failed but may retry: %v", w.p.name, err)
+	}
+
+	id := atomic.AddInt64(&w.p.executionId, 1)
+
+	// Update # documents in queue before eventual retries
+	w.p.statsMu.Lock()
+	if w.p.wantStats {
+		w.p.stats.Workers[w.i].Queued = int64(len(w.service.requests))
+	}
+	w.p.statsMu.Unlock()
+
+	// Save requests because they will be reset in commitFunc
+	reqs := w.service.requests
+
+	// Invoke before callback
+	if w.p.beforeFn != nil {
+		w.p.beforeFn(id, reqs)
+	}
+
+	// Commit bulk requests
+	err := RetryNotify(commitFunc, w.p.backoff, notifyFunc)
+	w.updateStats(res)
+	if err != nil {
+		w.p.c.errorf("elastic: bulk processor %q failed: %v", w.p.name, err)
+	}
+
+	// Invoke after callback
+	if w.p.afterFn != nil {
+		w.p.afterFn(id, reqs, res, err)
+	}
+
+	return err
+}
+
+func (w *bulkWorker) waitForActiveConnection(ready chan<- struct{}) {
+	defer close(ready)
+
+	t := time.NewTicker(5 * time.Second)
+	defer t.Stop()
+
+	client := w.p.c
+	stopReconnC := w.p.stopReconnC
+	w.p.c.errorf("elastic: bulk processor %q is waiting for an active connection", w.p.name)
+
+	// loop until a health check finds at least 1 active connection or the reconnection channel is closed
+	for {
+		select {
+		case _, ok := <-stopReconnC:
+			if !ok {
+				w.p.c.errorf("elastic: bulk processor %q active connection check interrupted", w.p.name)
+				return
+			}
+		case <-t.C:
+			client.healthcheck(time.Duration(3)*time.Second, true)
+			if client.mustActiveConn() == nil {
+				// found an active connection
+				// exit and signal done to the WaitGroup
+				return
+			}
+		}
+	}
+}
+
+func (w *bulkWorker) updateStats(res *BulkResponse) {
+	// Update stats
+	if res != nil {
+		w.p.statsMu.Lock()
+		if w.p.wantStats {
+			w.p.stats.Committed++
+			if res != nil {
+				w.p.stats.Indexed += int64(len(res.Indexed()))
+				w.p.stats.Created += int64(len(res.Created()))
+				w.p.stats.Updated += int64(len(res.Updated()))
+				w.p.stats.Deleted += int64(len(res.Deleted()))
+				w.p.stats.Succeeded += int64(len(res.Succeeded()))
+				w.p.stats.Failed += int64(len(res.Failed()))
+			}
+			w.p.stats.Workers[w.i].Queued = int64(len(w.service.requests))
+			w.p.stats.Workers[w.i].LastDuration = time.Duration(int64(res.Took)) * time.Millisecond
+		}
+		w.p.statsMu.Unlock()
+	}
+}
+
+// commitRequired returns true if the service has to commit its
+// bulk requests. This can be either because the number of actions
+// or the estimated size in bytes is larger than specified in the
+// BulkProcessorService.
+func (w *bulkWorker) commitRequired() bool {
+	if w.bulkActions >= 0 && w.service.NumberOfActions() >= w.bulkActions {
+		return true
+	}
+	if w.bulkSize >= 0 && w.service.EstimatedSizeInBytes() >= int64(w.bulkSize) {
+		return true
+	}
+	return false
+}

vendor/github.com/olivere/elastic/bulk_request.go

@@ -0,0 +1,17 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"fmt"
+)
+
+// -- Bulkable request (index/update/delete) --
+
+// BulkableRequest is a generic interface to bulkable requests.
+type BulkableRequest interface {
+	fmt.Stringer
+	Source() ([]string, error)
+}

vendor/github.com/olivere/elastic/bulk_update_request.go

@@ -0,0 +1,298 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+//go:generate easyjson bulk_update_request.go
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// BulkUpdateRequest is a request to update a document in Elasticsearch.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html
+// for details.
+type BulkUpdateRequest struct {
+	BulkableRequest
+	index string
+	typ   string
+	id    string
+
+	routing         string
+	parent          string
+	script          *Script
+	scriptedUpsert  *bool
+	version         int64  // default is MATCH_ANY
+	versionType     string // default is "internal"
+	retryOnConflict *int
+	upsert          interface{}
+	docAsUpsert     *bool
+	detectNoop      *bool
+	doc             interface{}
+	returnSource    *bool
+
+	source []string
+
+	useEasyJSON bool
+}
+
+//easyjson:json
+type bulkUpdateRequestCommand map[string]bulkUpdateRequestCommandOp
+
+//easyjson:json
+type bulkUpdateRequestCommandOp struct {
+	Index  string `json:"_index,omitempty"`
+	Type   string `json:"_type,omitempty"`
+	Id     string `json:"_id,omitempty"`
+	Parent string `json:"parent,omitempty"`
+	// RetryOnConflict is "_retry_on_conflict" for 6.0 and "retry_on_conflict" for 6.1+.
+	RetryOnConflict *int   `json:"retry_on_conflict,omitempty"`
+	Routing         string `json:"routing,omitempty"`
+	Version         int64  `json:"version,omitempty"`
+	VersionType     string `json:"version_type,omitempty"`
+}
+
+//easyjson:json
+type bulkUpdateRequestCommandData struct {
+	DetectNoop     *bool       `json:"detect_noop,omitempty"`
+	Doc            interface{} `json:"doc,omitempty"`
+	DocAsUpsert    *bool       `json:"doc_as_upsert,omitempty"`
+	Script         interface{} `json:"script,omitempty"`
+	ScriptedUpsert *bool       `json:"scripted_upsert,omitempty"`
+	Upsert         interface{} `json:"upsert,omitempty"`
+	Source         *bool       `json:"_source,omitempty"`
+}
+
+// NewBulkUpdateRequest returns a new BulkUpdateRequest.
+func NewBulkUpdateRequest() *BulkUpdateRequest {
+	return &BulkUpdateRequest{}
+}
+
+// UseEasyJSON is an experimental setting that enables serialization
+// with github.com/mailru/easyjson, which should in faster serialization
+// time and less allocations, but removed compatibility with encoding/json,
+// usage of unsafe etc. See https://github.com/mailru/easyjson#issues-notes-and-limitations
+// for details. This setting is disabled by default.
+func (r *BulkUpdateRequest) UseEasyJSON(enable bool) *BulkUpdateRequest {
+	r.useEasyJSON = enable
+	return r
+}
+
+// Index specifies the Elasticsearch index to use for this update request.
+// If unspecified, the index set on the BulkService will be used.
+func (r *BulkUpdateRequest) Index(index string) *BulkUpdateRequest {
+	r.index = index
+	r.source = nil
+	return r
+}
+
+// Type specifies the Elasticsearch type to use for this update request.
+// If unspecified, the type set on the BulkService will be used.
+func (r *BulkUpdateRequest) Type(typ string) *BulkUpdateRequest {
+	r.typ = typ
+	r.source = nil
+	return r
+}
+
+// Id specifies the identifier of the document to update.
+func (r *BulkUpdateRequest) Id(id string) *BulkUpdateRequest {
+	r.id = id
+	r.source = nil
+	return r
+}
+
+// Routing specifies a routing value for the request.
+func (r *BulkUpdateRequest) Routing(routing string) *BulkUpdateRequest {
+	r.routing = routing
+	r.source = nil
+	return r
+}
+
+// Parent specifies the identifier of the parent document (if available).
+func (r *BulkUpdateRequest) Parent(parent string) *BulkUpdateRequest {
+	r.parent = parent
+	r.source = nil
+	return r
+}
+
+// Script specifies an update script.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html#bulk-update
+// and https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-scripting.html
+// for details.
+func (r *BulkUpdateRequest) Script(script *Script) *BulkUpdateRequest {
+	r.script = script
+	r.source = nil
+	return r
+}
+
+// ScripedUpsert specifies if your script will run regardless of
+// whether the document exists or not.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-update.html#_literal_scripted_upsert_literal
+func (r *BulkUpdateRequest) ScriptedUpsert(upsert bool) *BulkUpdateRequest {
+	r.scriptedUpsert = &upsert
+	r.source = nil
+	return r
+}
+
+// RetryOnConflict specifies how often to retry in case of a version conflict.
+func (r *BulkUpdateRequest) RetryOnConflict(retryOnConflict int) *BulkUpdateRequest {
+	r.retryOnConflict = &retryOnConflict
+	r.source = nil
+	return r
+}
+
+// Version indicates the version of the document as part of an optimistic
+// concurrency model.
+func (r *BulkUpdateRequest) Version(version int64) *BulkUpdateRequest {
+	r.version = version
+	r.source = nil
+	return r
+}
+
+// VersionType can be "internal" (default), "external", "external_gte",
+// or "external_gt".
+func (r *BulkUpdateRequest) VersionType(versionType string) *BulkUpdateRequest {
+	r.versionType = versionType
+	r.source = nil
+	return r
+}
+
+// Doc specifies the updated document.
+func (r *BulkUpdateRequest) Doc(doc interface{}) *BulkUpdateRequest {
+	r.doc = doc
+	r.source = nil
+	return r
+}
+
+// DocAsUpsert indicates whether the contents of Doc should be used as
+// the Upsert value.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-update.html#_literal_doc_as_upsert_literal
+// for details.
+func (r *BulkUpdateRequest) DocAsUpsert(docAsUpsert bool) *BulkUpdateRequest {
+	r.docAsUpsert = &docAsUpsert
+	r.source = nil
+	return r
+}
+
+// DetectNoop specifies whether changes that don't affect the document
+// should be ignored (true) or unignored (false). This is enabled by default
+// in Elasticsearch.
+func (r *BulkUpdateRequest) DetectNoop(detectNoop bool) *BulkUpdateRequest {
+	r.detectNoop = &detectNoop
+	r.source = nil
+	return r
+}
+
+// Upsert specifies the document to use for upserts. It will be used for
+// create if the original document does not exist.
+func (r *BulkUpdateRequest) Upsert(doc interface{}) *BulkUpdateRequest {
+	r.upsert = doc
+	r.source = nil
+	return r
+}
+
+// ReturnSource specifies whether Elasticsearch should return the source
+// after the update. In the request, this responds to the `_source` field.
+// It is false by default.
+func (r *BulkUpdateRequest) ReturnSource(source bool) *BulkUpdateRequest {
+	r.returnSource = &source
+	r.source = nil
+	return r
+}
+
+// String returns the on-wire representation of the update request,
+// concatenated as a single string.
+func (r *BulkUpdateRequest) String() string {
+	lines, err := r.Source()
+	if err != nil {
+		return fmt.Sprintf("error: %v", err)
+	}
+	return strings.Join(lines, "\n")
+}
+
+// Source returns the on-wire representation of the update request,
+// split into an action-and-meta-data line and an (optional) source line.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html
+// for details.
+func (r *BulkUpdateRequest) Source() ([]string, error) {
+	// { "update" : { "_index" : "test", "_type" : "type1", "_id" : "1", ... } }
+	// { "doc" : { "field1" : "value1", ... } }
+	// or
+	// { "update" : { "_index" : "test", "_type" : "type1", "_id" : "1", ... } }
+	// { "script" : { ... } }
+
+	if r.source != nil {
+		return r.source, nil
+	}
+
+	lines := make([]string, 2)
+
+	// "update" ...
+	updateCommand := bulkUpdateRequestCommandOp{
+		Index:           r.index,
+		Type:            r.typ,
+		Id:              r.id,
+		Routing:         r.routing,
+		Parent:          r.parent,
+		Version:         r.version,
+		VersionType:     r.versionType,
+		RetryOnConflict: r.retryOnConflict,
+	}
+	command := bulkUpdateRequestCommand{
+		"update": updateCommand,
+	}
+
+	var err error
+	var body []byte
+	if r.useEasyJSON {
+		// easyjson
+		body, err = command.MarshalJSON()
+	} else {
+		// encoding/json
+		body, err = json.Marshal(command)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	lines[0] = string(body)
+
+	// 2nd line: {"doc" : { ... }} or {"script": {...}}
+	data := bulkUpdateRequestCommandData{
+		DocAsUpsert:    r.docAsUpsert,
+		DetectNoop:     r.detectNoop,
+		Upsert:         r.upsert,
+		ScriptedUpsert: r.scriptedUpsert,
+		Doc:            r.doc,
+		Source:         r.returnSource,
+	}
+	if r.script != nil {
+		script, err := r.script.Source()
+		if err != nil {
+			return nil, err
+		}
+		data.Script = script
+	}
+
+	if r.useEasyJSON {
+		// easyjson
+		body, err = data.MarshalJSON()
+	} else {
+		// encoding/json
+		body, err = json.Marshal(data)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	lines[1] = string(body)
+
+	r.source = lines
+	return lines, nil
+}

vendor/github.com/olivere/elastic/bulk_update_request_easyjson.go

@@ -0,0 +1,461 @@
+// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.
+
+package elastic
+
+import (
+	json "encoding/json"
+	easyjson "github.com/mailru/easyjson"
+	jlexer "github.com/mailru/easyjson/jlexer"
+	jwriter "github.com/mailru/easyjson/jwriter"
+)
+
+// suppress unused package warning
+var (
+	_ *json.RawMessage
+	_ *jlexer.Lexer
+	_ *jwriter.Writer
+	_ easyjson.Marshaler
+)
+
+func easyjson1ed00e60DecodeGithubComOlivereElastic(in *jlexer.Lexer, out *bulkUpdateRequestCommandOp) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		if isTopLevel {
+			in.Consumed()
+		}
+		in.Skip()
+		return
+	}
+	in.Delim('{')
+	for !in.IsDelim('}') {
+		key := in.UnsafeString()
+		in.WantColon()
+		if in.IsNull() {
+			in.Skip()
+			in.WantComma()
+			continue
+		}
+		switch key {
+		case "_index":
+			out.Index = string(in.String())
+		case "_type":
+			out.Type = string(in.String())
+		case "_id":
+			out.Id = string(in.String())
+		case "parent":
+			out.Parent = string(in.String())
+		case "retry_on_conflict":
+			if in.IsNull() {
+				in.Skip()
+				out.RetryOnConflict = nil
+			} else {
+				if out.RetryOnConflict == nil {
+					out.RetryOnConflict = new(int)
+				}
+				*out.RetryOnConflict = int(in.Int())
+			}
+		case "routing":
+			out.Routing = string(in.String())
+		case "version":
+			out.Version = int64(in.Int64())
+		case "version_type":
+			out.VersionType = string(in.String())
+		default:
+			in.SkipRecursive()
+		}
+		in.WantComma()
+	}
+	in.Delim('}')
+	if isTopLevel {
+		in.Consumed()
+	}
+}
+func easyjson1ed00e60EncodeGithubComOlivereElastic(out *jwriter.Writer, in bulkUpdateRequestCommandOp) {
+	out.RawByte('{')
+	first := true
+	_ = first
+	if in.Index != "" {
+		const prefix string = ",\"_index\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Index))
+	}
+	if in.Type != "" {
+		const prefix string = ",\"_type\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Type))
+	}
+	if in.Id != "" {
+		const prefix string = ",\"_id\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Id))
+	}
+	if in.Parent != "" {
+		const prefix string = ",\"parent\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Parent))
+	}
+	if in.RetryOnConflict != nil {
+		const prefix string = ",\"retry_on_conflict\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Int(int(*in.RetryOnConflict))
+	}
+	if in.Routing != "" {
+		const prefix string = ",\"routing\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.Routing))
+	}
+	if in.Version != 0 {
+		const prefix string = ",\"version\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Int64(int64(in.Version))
+	}
+	if in.VersionType != "" {
+		const prefix string = ",\"version_type\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.String(string(in.VersionType))
+	}
+	out.RawByte('}')
+}
+
+// MarshalJSON supports json.Marshaler interface
+func (v bulkUpdateRequestCommandOp) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	easyjson1ed00e60EncodeGithubComOlivereElastic(&w, v)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// MarshalEasyJSON supports easyjson.Marshaler interface
+func (v bulkUpdateRequestCommandOp) MarshalEasyJSON(w *jwriter.Writer) {
+	easyjson1ed00e60EncodeGithubComOlivereElastic(w, v)
+}
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (v *bulkUpdateRequestCommandOp) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	easyjson1ed00e60DecodeGithubComOlivereElastic(&r, v)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (v *bulkUpdateRequestCommandOp) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	easyjson1ed00e60DecodeGithubComOlivereElastic(l, v)
+}
+func easyjson1ed00e60DecodeGithubComOlivereElastic1(in *jlexer.Lexer, out *bulkUpdateRequestCommandData) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		if isTopLevel {
+			in.Consumed()
+		}
+		in.Skip()
+		return
+	}
+	in.Delim('{')
+	for !in.IsDelim('}') {
+		key := in.UnsafeString()
+		in.WantColon()
+		if in.IsNull() {
+			in.Skip()
+			in.WantComma()
+			continue
+		}
+		switch key {
+		case "detect_noop":
+			if in.IsNull() {
+				in.Skip()
+				out.DetectNoop = nil
+			} else {
+				if out.DetectNoop == nil {
+					out.DetectNoop = new(bool)
+				}
+				*out.DetectNoop = bool(in.Bool())
+			}
+		case "doc":
+			if m, ok := out.Doc.(easyjson.Unmarshaler); ok {
+				m.UnmarshalEasyJSON(in)
+			} else if m, ok := out.Doc.(json.Unmarshaler); ok {
+				_ = m.UnmarshalJSON(in.Raw())
+			} else {
+				out.Doc = in.Interface()
+			}
+		case "doc_as_upsert":
+			if in.IsNull() {
+				in.Skip()
+				out.DocAsUpsert = nil
+			} else {
+				if out.DocAsUpsert == nil {
+					out.DocAsUpsert = new(bool)
+				}
+				*out.DocAsUpsert = bool(in.Bool())
+			}
+		case "script":
+			if m, ok := out.Script.(easyjson.Unmarshaler); ok {
+				m.UnmarshalEasyJSON(in)
+			} else if m, ok := out.Script.(json.Unmarshaler); ok {
+				_ = m.UnmarshalJSON(in.Raw())
+			} else {
+				out.Script = in.Interface()
+			}
+		case "scripted_upsert":
+			if in.IsNull() {
+				in.Skip()
+				out.ScriptedUpsert = nil
+			} else {
+				if out.ScriptedUpsert == nil {
+					out.ScriptedUpsert = new(bool)
+				}
+				*out.ScriptedUpsert = bool(in.Bool())
+			}
+		case "upsert":
+			if m, ok := out.Upsert.(easyjson.Unmarshaler); ok {
+				m.UnmarshalEasyJSON(in)
+			} else if m, ok := out.Upsert.(json.Unmarshaler); ok {
+				_ = m.UnmarshalJSON(in.Raw())
+			} else {
+				out.Upsert = in.Interface()
+			}
+		case "_source":
+			if in.IsNull() {
+				in.Skip()
+				out.Source = nil
+			} else {
+				if out.Source == nil {
+					out.Source = new(bool)
+				}
+				*out.Source = bool(in.Bool())
+			}
+		default:
+			in.SkipRecursive()
+		}
+		in.WantComma()
+	}
+	in.Delim('}')
+	if isTopLevel {
+		in.Consumed()
+	}
+}
+func easyjson1ed00e60EncodeGithubComOlivereElastic1(out *jwriter.Writer, in bulkUpdateRequestCommandData) {
+	out.RawByte('{')
+	first := true
+	_ = first
+	if in.DetectNoop != nil {
+		const prefix string = ",\"detect_noop\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Bool(bool(*in.DetectNoop))
+	}
+	if in.Doc != nil {
+		const prefix string = ",\"doc\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		if m, ok := in.Doc.(easyjson.Marshaler); ok {
+			m.MarshalEasyJSON(out)
+		} else if m, ok := in.Doc.(json.Marshaler); ok {
+			out.Raw(m.MarshalJSON())
+		} else {
+			out.Raw(json.Marshal(in.Doc))
+		}
+	}
+	if in.DocAsUpsert != nil {
+		const prefix string = ",\"doc_as_upsert\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Bool(bool(*in.DocAsUpsert))
+	}
+	if in.Script != nil {
+		const prefix string = ",\"script\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		if m, ok := in.Script.(easyjson.Marshaler); ok {
+			m.MarshalEasyJSON(out)
+		} else if m, ok := in.Script.(json.Marshaler); ok {
+			out.Raw(m.MarshalJSON())
+		} else {
+			out.Raw(json.Marshal(in.Script))
+		}
+	}
+	if in.ScriptedUpsert != nil {
+		const prefix string = ",\"scripted_upsert\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Bool(bool(*in.ScriptedUpsert))
+	}
+	if in.Upsert != nil {
+		const prefix string = ",\"upsert\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		if m, ok := in.Upsert.(easyjson.Marshaler); ok {
+			m.MarshalEasyJSON(out)
+		} else if m, ok := in.Upsert.(json.Marshaler); ok {
+			out.Raw(m.MarshalJSON())
+		} else {
+			out.Raw(json.Marshal(in.Upsert))
+		}
+	}
+	if in.Source != nil {
+		const prefix string = ",\"_source\":"
+		if first {
+			first = false
+			out.RawString(prefix[1:])
+		} else {
+			out.RawString(prefix)
+		}
+		out.Bool(bool(*in.Source))
+	}
+	out.RawByte('}')
+}
+
+// MarshalJSON supports json.Marshaler interface
+func (v bulkUpdateRequestCommandData) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	easyjson1ed00e60EncodeGithubComOlivereElastic1(&w, v)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// MarshalEasyJSON supports easyjson.Marshaler interface
+func (v bulkUpdateRequestCommandData) MarshalEasyJSON(w *jwriter.Writer) {
+	easyjson1ed00e60EncodeGithubComOlivereElastic1(w, v)
+}
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (v *bulkUpdateRequestCommandData) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	easyjson1ed00e60DecodeGithubComOlivereElastic1(&r, v)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (v *bulkUpdateRequestCommandData) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	easyjson1ed00e60DecodeGithubComOlivereElastic1(l, v)
+}
+func easyjson1ed00e60DecodeGithubComOlivereElastic2(in *jlexer.Lexer, out *bulkUpdateRequestCommand) {
+	isTopLevel := in.IsStart()
+	if in.IsNull() {
+		in.Skip()
+	} else {
+		in.Delim('{')
+		if !in.IsDelim('}') {
+			*out = make(bulkUpdateRequestCommand)
+		} else {
+			*out = nil
+		}
+		for !in.IsDelim('}') {
+			key := string(in.String())
+			in.WantColon()
+			var v1 bulkUpdateRequestCommandOp
+			(v1).UnmarshalEasyJSON(in)
+			(*out)[key] = v1
+			in.WantComma()
+		}
+		in.Delim('}')
+	}
+	if isTopLevel {
+		in.Consumed()
+	}
+}
+func easyjson1ed00e60EncodeGithubComOlivereElastic2(out *jwriter.Writer, in bulkUpdateRequestCommand) {
+	if in == nil && (out.Flags&jwriter.NilMapAsEmpty) == 0 {
+		out.RawString(`null`)
+	} else {
+		out.RawByte('{')
+		v2First := true
+		for v2Name, v2Value := range in {
+			if v2First {
+				v2First = false
+			} else {
+				out.RawByte(',')
+			}
+			out.String(string(v2Name))
+			out.RawByte(':')
+			(v2Value).MarshalEasyJSON(out)
+		}
+		out.RawByte('}')
+	}
+}
+
+// MarshalJSON supports json.Marshaler interface
+func (v bulkUpdateRequestCommand) MarshalJSON() ([]byte, error) {
+	w := jwriter.Writer{}
+	easyjson1ed00e60EncodeGithubComOlivereElastic2(&w, v)
+	return w.Buffer.BuildBytes(), w.Error
+}
+
+// MarshalEasyJSON supports easyjson.Marshaler interface
+func (v bulkUpdateRequestCommand) MarshalEasyJSON(w *jwriter.Writer) {
+	easyjson1ed00e60EncodeGithubComOlivereElastic2(w, v)
+}
+
+// UnmarshalJSON supports json.Unmarshaler interface
+func (v *bulkUpdateRequestCommand) UnmarshalJSON(data []byte) error {
+	r := jlexer.Lexer{Data: data}
+	easyjson1ed00e60DecodeGithubComOlivereElastic2(&r, v)
+	return r.Error()
+}
+
+// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
+func (v *bulkUpdateRequestCommand) UnmarshalEasyJSON(l *jlexer.Lexer) {
+	easyjson1ed00e60DecodeGithubComOlivereElastic2(l, v)
+}

vendor/github.com/olivere/elastic/canonicalize.go

@@ -0,0 +1,34 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import "net/url"
+
+// canonicalize takes a list of URLs and returns its canonicalized form, i.e.
+// remove anything but scheme, userinfo, host, path, and port.
+// It also removes all trailing slashes. Invalid URLs or URLs that do not
+// use protocol http or https are skipped.
+//
+// Example:
+// http://127.0.0.1:9200/?query=1 -> http://127.0.0.1:9200
+// http://127.0.0.1:9200/db1/ -> http://127.0.0.1:9200/db1
+func canonicalize(rawurls ...string) []string {
+	var canonicalized []string
+	for _, rawurl := range rawurls {
+		u, err := url.Parse(rawurl)
+		if err == nil {
+			if u.Scheme == "http" || u.Scheme == "https" {
+				// Trim trailing slashes
+				for len(u.Path) > 0 && u.Path[len(u.Path)-1] == '/' {
+					u.Path = u.Path[0 : len(u.Path)-1]
+				}
+				u.Fragment = ""
+				u.RawQuery = ""
+				canonicalized = append(canonicalized, u.String())
+			}
+		}
+	}
+	return canonicalized
+}

vendor/github.com/olivere/elastic/clear_scroll.go

@@ -0,0 +1,108 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+)
+
+// ClearScrollService clears one or more scroll contexts by their ids.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-request-scroll.html#_clear_scroll_api
+// for details.
+type ClearScrollService struct {
+	client   *Client
+	pretty   bool
+	scrollId []string
+}
+
+// NewClearScrollService creates a new ClearScrollService.
+func NewClearScrollService(client *Client) *ClearScrollService {
+	return &ClearScrollService{
+		client:   client,
+		scrollId: make([]string, 0),
+	}
+}
+
+// ScrollId is a list of scroll IDs to clear.
+// Use _all to clear all search contexts.
+func (s *ClearScrollService) ScrollId(scrollIds ...string) *ClearScrollService {
+	s.scrollId = append(s.scrollId, scrollIds...)
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *ClearScrollService) Pretty(pretty bool) *ClearScrollService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *ClearScrollService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path := "/_search/scroll/"
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *ClearScrollService) Validate() error {
+	var invalid []string
+	if len(s.scrollId) == 0 {
+		invalid = append(invalid, "ScrollId")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *ClearScrollService) Do(ctx context.Context) (*ClearScrollResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Setup HTTP request body
+	body := map[string][]string{
+		"scroll_id": s.scrollId,
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "DELETE",
+		Path:   path,
+		Params: params,
+		Body:   body,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(ClearScrollResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// ClearScrollResponse is the response of ClearScrollService.Do.
+type ClearScrollResponse struct {
+}

vendor/github.com/olivere/elastic/cluster_health.go

@@ -0,0 +1,248 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// ClusterHealthService allows to get a very simple status on the health of the cluster.
+//
+// See http://www.elastic.co/guide/en/elasticsearch/reference/5.2/cluster-health.html
+// for details.
+type ClusterHealthService struct {
+	client                    *Client
+	pretty                    bool
+	indices                   []string
+	level                     string
+	local                     *bool
+	masterTimeout             string
+	timeout                   string
+	waitForActiveShards       *int
+	waitForNodes              string
+	waitForNoRelocatingShards *bool
+	waitForStatus             string
+}
+
+// NewClusterHealthService creates a new ClusterHealthService.
+func NewClusterHealthService(client *Client) *ClusterHealthService {
+	return &ClusterHealthService{
+		client:  client,
+		indices: make([]string, 0),
+	}
+}
+
+// Index limits the information returned to specific indices.
+func (s *ClusterHealthService) Index(indices ...string) *ClusterHealthService {
+	s.indices = append(s.indices, indices...)
+	return s
+}
+
+// Level specifies the level of detail for returned information.
+func (s *ClusterHealthService) Level(level string) *ClusterHealthService {
+	s.level = level
+	return s
+}
+
+// Local indicates whether to return local information. If it is true,
+// we do not retrieve the state from master node (default: false).
+func (s *ClusterHealthService) Local(local bool) *ClusterHealthService {
+	s.local = &local
+	return s
+}
+
+// MasterTimeout specifies an explicit operation timeout for connection to master node.
+func (s *ClusterHealthService) MasterTimeout(masterTimeout string) *ClusterHealthService {
+	s.masterTimeout = masterTimeout
+	return s
+}
+
+// Timeout specifies an explicit operation timeout.
+func (s *ClusterHealthService) Timeout(timeout string) *ClusterHealthService {
+	s.timeout = timeout
+	return s
+}
+
+// WaitForActiveShards can be used to wait until the specified number of shards are active.
+func (s *ClusterHealthService) WaitForActiveShards(waitForActiveShards int) *ClusterHealthService {
+	s.waitForActiveShards = &waitForActiveShards
+	return s
+}
+
+// WaitForNodes can be used to wait until the specified number of nodes are available.
+// Example: "12" to wait for exact values, ">12" and "<12" for ranges.
+func (s *ClusterHealthService) WaitForNodes(waitForNodes string) *ClusterHealthService {
+	s.waitForNodes = waitForNodes
+	return s
+}
+
+// WaitForNoRelocatingShards can be used to wait until all shard relocations are finished.
+func (s *ClusterHealthService) WaitForNoRelocatingShards(waitForNoRelocatingShards bool) *ClusterHealthService {
+	s.waitForNoRelocatingShards = &waitForNoRelocatingShards
+	return s
+}
+
+// WaitForStatus can be used to wait until the cluster is in a specific state.
+// Valid values are: green, yellow, or red.
+func (s *ClusterHealthService) WaitForStatus(waitForStatus string) *ClusterHealthService {
+	s.waitForStatus = waitForStatus
+	return s
+}
+
+// WaitForGreenStatus will wait for the "green" state.
+func (s *ClusterHealthService) WaitForGreenStatus() *ClusterHealthService {
+	return s.WaitForStatus("green")
+}
+
+// WaitForYellowStatus will wait for the "yellow" state.
+func (s *ClusterHealthService) WaitForYellowStatus() *ClusterHealthService {
+	return s.WaitForStatus("yellow")
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *ClusterHealthService) Pretty(pretty bool) *ClusterHealthService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *ClusterHealthService) buildURL() (string, url.Values, error) {
+	// Build URL
+	var err error
+	var path string
+	if len(s.indices) > 0 {
+		path, err = uritemplates.Expand("/_cluster/health/{index}", map[string]string{
+			"index": strings.Join(s.indices, ","),
+		})
+	} else {
+		path = "/_cluster/health"
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.level != "" {
+		params.Set("level", s.level)
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	if s.masterTimeout != "" {
+		params.Set("master_timeout", s.masterTimeout)
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.waitForActiveShards != nil {
+		params.Set("wait_for_active_shards", fmt.Sprintf("%v", s.waitForActiveShards))
+	}
+	if s.waitForNodes != "" {
+		params.Set("wait_for_nodes", s.waitForNodes)
+	}
+	if s.waitForNoRelocatingShards != nil {
+		params.Set("wait_for_no_relocating_shards", fmt.Sprintf("%v", *s.waitForNoRelocatingShards))
+	}
+	if s.waitForStatus != "" {
+		params.Set("wait_for_status", s.waitForStatus)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *ClusterHealthService) Validate() error {
+	return nil
+}
+
+// Do executes the operation.
+func (s *ClusterHealthService) Do(ctx context.Context) (*ClusterHealthResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(ClusterHealthResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// ClusterHealthResponse is the response of ClusterHealthService.Do.
+type ClusterHealthResponse struct {
+	ClusterName                    string  `json:"cluster_name"`
+	Status                         string  `json:"status"`
+	TimedOut                       bool    `json:"timed_out"`
+	NumberOfNodes                  int     `json:"number_of_nodes"`
+	NumberOfDataNodes              int     `json:"number_of_data_nodes"`
+	ActivePrimaryShards            int     `json:"active_primary_shards"`
+	ActiveShards                   int     `json:"active_shards"`
+	RelocatingShards               int     `json:"relocating_shards"`
+	InitializingShards             int     `json:"initializing_shards"`
+	UnassignedShards               int     `json:"unassigned_shards"`
+	DelayedUnassignedShards        int     `json:"delayed_unassigned_shards"`
+	NumberOfPendingTasks           int     `json:"number_of_pending_tasks"`
+	NumberOfInFlightFetch          int     `json:"number_of_in_flight_fetch"`
+	TaskMaxWaitTimeInQueueInMillis int     `json:"task_max_waiting_in_queue_millis"`
+	ActiveShardsPercentAsNumber    float64 `json:"active_shards_percent_as_number"`
+
+	// Validation failures -> index name -> array of validation failures
+	ValidationFailures []map[string][]string `json:"validation_failures"`
+
+	// Index name -> index health
+	Indices map[string]*ClusterIndexHealth `json:"indices"`
+}
+
+// ClusterIndexHealth will be returned as part of ClusterHealthResponse.
+type ClusterIndexHealth struct {
+	Status              string `json:"status"`
+	NumberOfShards      int    `json:"number_of_shards"`
+	NumberOfReplicas    int    `json:"number_of_replicas"`
+	ActivePrimaryShards int    `json:"active_primary_shards"`
+	ActiveShards        int    `json:"active_shards"`
+	RelocatingShards    int    `json:"relocating_shards"`
+	InitializingShards  int    `json:"initializing_shards"`
+	UnassignedShards    int    `json:"unassigned_shards"`
+	// Validation failures
+	ValidationFailures []string `json:"validation_failures"`
+	// Shards by id, e.g. "0" or "1"
+	Shards map[string]*ClusterShardHealth `json:"shards"`
+}
+
+// ClusterShardHealth will be returned as part of ClusterHealthResponse.
+type ClusterShardHealth struct {
+	Status             string `json:"status"`
+	PrimaryActive      bool   `json:"primary_active"`
+	ActiveShards       int    `json:"active_shards"`
+	RelocatingShards   int    `json:"relocating_shards"`
+	InitializingShards int    `json:"initializing_shards"`
+	UnassignedShards   int    `json:"unassigned_shards"`
+}

vendor/github.com/olivere/elastic/cluster_state.go

@@ -0,0 +1,288 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// ClusterStateService allows to get a comprehensive state information of the whole cluster.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-state.html
+// for details.
+type ClusterStateService struct {
+	client            *Client
+	pretty            bool
+	indices           []string
+	metrics           []string
+	allowNoIndices    *bool
+	expandWildcards   string
+	flatSettings      *bool
+	ignoreUnavailable *bool
+	local             *bool
+	masterTimeout     string
+}
+
+// NewClusterStateService creates a new ClusterStateService.
+func NewClusterStateService(client *Client) *ClusterStateService {
+	return &ClusterStateService{
+		client:  client,
+		indices: make([]string, 0),
+		metrics: make([]string, 0),
+	}
+}
+
+// Index is a list of index names. Use _all or an empty string to
+// perform the operation on all indices.
+func (s *ClusterStateService) Index(indices ...string) *ClusterStateService {
+	s.indices = append(s.indices, indices...)
+	return s
+}
+
+// Metric limits the information returned to the specified metric.
+// It can be one of: version, master_node, nodes, routing_table, metadata,
+// blocks, or customs.
+func (s *ClusterStateService) Metric(metrics ...string) *ClusterStateService {
+	s.metrics = append(s.metrics, metrics...)
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices.
+// (This includes `_all` string or when no indices have been specified).
+func (s *ClusterStateService) AllowNoIndices(allowNoIndices bool) *ClusterStateService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both..
+func (s *ClusterStateService) ExpandWildcards(expandWildcards string) *ClusterStateService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// FlatSettings, when set, returns settings in flat format (default: false).
+func (s *ClusterStateService) FlatSettings(flatSettings bool) *ClusterStateService {
+	s.flatSettings = &flatSettings
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *ClusterStateService) IgnoreUnavailable(ignoreUnavailable bool) *ClusterStateService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// Local indicates whether to return local information. When set, it does not
+// retrieve the state from master node (default: false).
+func (s *ClusterStateService) Local(local bool) *ClusterStateService {
+	s.local = &local
+	return s
+}
+
+// MasterTimeout specifies timeout for connection to master.
+func (s *ClusterStateService) MasterTimeout(masterTimeout string) *ClusterStateService {
+	s.masterTimeout = masterTimeout
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *ClusterStateService) Pretty(pretty bool) *ClusterStateService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *ClusterStateService) buildURL() (string, url.Values, error) {
+	// Build URL
+	metrics := strings.Join(s.metrics, ",")
+	if metrics == "" {
+		metrics = "_all"
+	}
+	indices := strings.Join(s.indices, ",")
+	if indices == "" {
+		indices = "_all"
+	}
+	path, err := uritemplates.Expand("/_cluster/state/{metrics}/{indices}", map[string]string{
+		"metrics": metrics,
+		"indices": indices,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.flatSettings != nil {
+		params.Set("flat_settings", fmt.Sprintf("%v", *s.flatSettings))
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	if s.masterTimeout != "" {
+		params.Set("master_timeout", s.masterTimeout)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *ClusterStateService) Validate() error {
+	return nil
+}
+
+// Do executes the operation.
+func (s *ClusterStateService) Do(ctx context.Context) (*ClusterStateResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(ClusterStateResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// ClusterStateResponse is the response of ClusterStateService.Do.
+type ClusterStateResponse struct {
+	ClusterName  string                               `json:"cluster_name"`
+	Version      int64                                `json:"version"`
+	StateUUID    string                               `json:"state_uuid"`
+	MasterNode   string                               `json:"master_node"`
+	Blocks       map[string]*clusterBlocks            `json:"blocks"`
+	Nodes        map[string]*discoveryNode            `json:"nodes"`
+	Metadata     *clusterStateMetadata                `json:"metadata"`
+	RoutingTable map[string]*clusterStateRoutingTable `json:"routing_table"`
+	RoutingNodes *clusterStateRoutingNode             `json:"routing_nodes"`
+	Customs      map[string]interface{}               `json:"customs"`
+}
+
+type clusterBlocks struct {
+	Global  map[string]*clusterBlock `json:"global"`  // id -> cluster block
+	Indices map[string]*clusterBlock `json:"indices"` // index name -> cluster block
+}
+
+type clusterBlock struct {
+	Description             string   `json:"description"`
+	Retryable               bool     `json:"retryable"`
+	DisableStatePersistence bool     `json:"disable_state_persistence"`
+	Levels                  []string `json:"levels"`
+}
+
+type clusterStateMetadata struct {
+	ClusterUUID  string                            `json:"cluster_uuid"`
+	Templates    map[string]*indexTemplateMetaData `json:"templates"` // template name -> index template metadata
+	Indices      map[string]*indexMetaData         `json:"indices"`   // index name _> meta data
+	RoutingTable struct {
+		Indices map[string]*indexRoutingTable `json:"indices"` // index name -> routing table
+	} `json:"routing_table"`
+	RoutingNodes struct {
+		Unassigned []*shardRouting `json:"unassigned"`
+		Nodes      []*shardRouting `json:"nodes"`
+	} `json:"routing_nodes"`
+	Customs map[string]interface{} `json:"customs"`
+}
+
+type discoveryNode struct {
+	Name             string                 `json:"name"`              // server name, e.g. "es1"
+	TransportAddress string                 `json:"transport_address"` // e.g. inet[/1.2.3.4:9300]
+	Attributes       map[string]interface{} `json:"attributes"`        // e.g. { "data": true, "master": true }
+}
+
+type clusterStateRoutingTable struct {
+	Indices map[string]interface{} `json:"indices"`
+}
+
+type clusterStateRoutingNode struct {
+	Unassigned []*shardRouting `json:"unassigned"`
+	// Node Id -> shardRouting
+	Nodes map[string][]*shardRouting `json:"nodes"`
+}
+
+type indexTemplateMetaData struct {
+	IndexPatterns []string               `json:"index_patterns"` // e.g. ["store-*"]
+	Order         int                    `json:"order"`
+	Settings      map[string]interface{} `json:"settings"` // index settings
+	Mappings      map[string]interface{} `json:"mappings"` // type name -> mapping
+}
+
+type indexMetaData struct {
+	State    string                 `json:"state"`
+	Settings map[string]interface{} `json:"settings"`
+	Mappings map[string]interface{} `json:"mappings"`
+	Aliases  []string               `json:"aliases"` // e.g. [ "alias1", "alias2" ]
+}
+
+type indexRoutingTable struct {
+	Shards map[string]*shardRouting `json:"shards"`
+}
+
+type shardRouting struct {
+	State          string          `json:"state"`
+	Primary        bool            `json:"primary"`
+	Node           string          `json:"node"`
+	RelocatingNode string          `json:"relocating_node"`
+	Shard          int             `json:"shard"`
+	Index          string          `json:"index"`
+	Version        int64           `json:"version"`
+	RestoreSource  *RestoreSource  `json:"restore_source"`
+	AllocationId   *allocationId   `json:"allocation_id"`
+	UnassignedInfo *unassignedInfo `json:"unassigned_info"`
+}
+
+type RestoreSource struct {
+	Repository string `json:"repository"`
+	Snapshot   string `json:"snapshot"`
+	Version    string `json:"version"`
+	Index      string `json:"index"`
+}
+
+type allocationId struct {
+	Id           string `json:"id"`
+	RelocationId string `json:"relocation_id"`
+}
+
+type unassignedInfo struct {
+	Reason  string `json:"reason"`
+	At      string `json:"at"`
+	Details string `json:"details"`
+}

vendor/github.com/olivere/elastic/cluster_stats.go

@@ -0,0 +1,352 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// ClusterStatsService is documented at
+// https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-stats.html.
+type ClusterStatsService struct {
+	client       *Client
+	pretty       bool
+	nodeId       []string
+	flatSettings *bool
+	human        *bool
+}
+
+// NewClusterStatsService creates a new ClusterStatsService.
+func NewClusterStatsService(client *Client) *ClusterStatsService {
+	return &ClusterStatsService{
+		client: client,
+		nodeId: make([]string, 0),
+	}
+}
+
+// NodeId is documented as: A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes.
+func (s *ClusterStatsService) NodeId(nodeId []string) *ClusterStatsService {
+	s.nodeId = nodeId
+	return s
+}
+
+// FlatSettings is documented as: Return settings in flat format (default: false).
+func (s *ClusterStatsService) FlatSettings(flatSettings bool) *ClusterStatsService {
+	s.flatSettings = &flatSettings
+	return s
+}
+
+// Human is documented as: Whether to return time and byte values in human-readable format..
+func (s *ClusterStatsService) Human(human bool) *ClusterStatsService {
+	s.human = &human
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *ClusterStatsService) Pretty(pretty bool) *ClusterStatsService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *ClusterStatsService) buildURL() (string, url.Values, error) {
+	// Build URL
+	var err error
+	var path string
+
+	if len(s.nodeId) > 0 {
+		path, err = uritemplates.Expand("/_cluster/stats/nodes/{node_id}", map[string]string{
+			"node_id": strings.Join(s.nodeId, ","),
+		})
+		if err != nil {
+			return "", url.Values{}, err
+		}
+	} else {
+		path, err = uritemplates.Expand("/_cluster/stats", map[string]string{})
+		if err != nil {
+			return "", url.Values{}, err
+		}
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.flatSettings != nil {
+		params.Set("flat_settings", fmt.Sprintf("%v", *s.flatSettings))
+	}
+	if s.human != nil {
+		params.Set("human", fmt.Sprintf("%v", *s.human))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *ClusterStatsService) Validate() error {
+	return nil
+}
+
+// Do executes the operation.
+func (s *ClusterStatsService) Do(ctx context.Context) (*ClusterStatsResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(ClusterStatsResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// ClusterStatsResponse is the response of ClusterStatsService.Do.
+type ClusterStatsResponse struct {
+	Timestamp   int64                `json:"timestamp"`
+	ClusterName string               `json:"cluster_name"`
+	ClusterUUID string               `json:"uuid"`
+	Status      string               `json:"status"`
+	Indices     *ClusterStatsIndices `json:"indices"`
+	Nodes       *ClusterStatsNodes   `json:"nodes"`
+}
+
+type ClusterStatsIndices struct {
+	Count       int                             `json:"count"`
+	Shards      *ClusterStatsIndicesShards      `json:"shards"`
+	Docs        *ClusterStatsIndicesDocs        `json:"docs"`
+	Store       *ClusterStatsIndicesStore       `json:"store"`
+	FieldData   *ClusterStatsIndicesFieldData   `json:"fielddata"`
+	FilterCache *ClusterStatsIndicesFilterCache `json:"filter_cache"`
+	IdCache     *ClusterStatsIndicesIdCache     `json:"id_cache"`
+	Completion  *ClusterStatsIndicesCompletion  `json:"completion"`
+	Segments    *ClusterStatsIndicesSegments    `json:"segments"`
+	Percolate   *ClusterStatsIndicesPercolate   `json:"percolate"`
+}
+
+type ClusterStatsIndicesShards struct {
+	Total       int                             `json:"total"`
+	Primaries   int                             `json:"primaries"`
+	Replication float64                         `json:"replication"`
+	Index       *ClusterStatsIndicesShardsIndex `json:"index"`
+}
+
+type ClusterStatsIndicesShardsIndex struct {
+	Shards      *ClusterStatsIndicesShardsIndexIntMinMax     `json:"shards"`
+	Primaries   *ClusterStatsIndicesShardsIndexIntMinMax     `json:"primaries"`
+	Replication *ClusterStatsIndicesShardsIndexFloat64MinMax `json:"replication"`
+}
+
+type ClusterStatsIndicesShardsIndexIntMinMax struct {
+	Min int     `json:"min"`
+	Max int     `json:"max"`
+	Avg float64 `json:"avg"`
+}
+
+type ClusterStatsIndicesShardsIndexFloat64MinMax struct {
+	Min float64 `json:"min"`
+	Max float64 `json:"max"`
+	Avg float64 `json:"avg"`
+}
+
+type ClusterStatsIndicesDocs struct {
+	Count   int `json:"count"`
+	Deleted int `json:"deleted"`
+}
+
+type ClusterStatsIndicesStore struct {
+	Size        string `json:"size"` // e.g. "5.3gb"
+	SizeInBytes int64  `json:"size_in_bytes"`
+}
+
+type ClusterStatsIndicesFieldData struct {
+	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
+	MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
+	Evictions         int64  `json:"evictions"`
+	Fields            map[string]struct {
+		MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
+		MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
+	} `json:"fields"`
+}
+
+type ClusterStatsIndicesFilterCache struct {
+	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
+	MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
+	Evictions         int64  `json:"evictions"`
+}
+
+type ClusterStatsIndicesIdCache struct {
+	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
+	MemorySizeInBytes int64  `json:"memory_size_in_bytes"`
+}
+
+type ClusterStatsIndicesCompletion struct {
+	Size        string `json:"size"` // e.g. "61.3kb"
+	SizeInBytes int64  `json:"size_in_bytes"`
+	Fields      map[string]struct {
+		Size        string `json:"size"` // e.g. "61.3kb"
+		SizeInBytes int64  `json:"size_in_bytes"`
+	} `json:"fields"`
+}
+
+type ClusterStatsIndicesSegments struct {
+	Count                       int64  `json:"count"`
+	Memory                      string `json:"memory"` // e.g. "61.3kb"
+	MemoryInBytes               int64  `json:"memory_in_bytes"`
+	IndexWriterMemory           string `json:"index_writer_memory"` // e.g. "61.3kb"
+	IndexWriterMemoryInBytes    int64  `json:"index_writer_memory_in_bytes"`
+	IndexWriterMaxMemory        string `json:"index_writer_max_memory"` // e.g. "61.3kb"
+	IndexWriterMaxMemoryInBytes int64  `json:"index_writer_max_memory_in_bytes"`
+	VersionMapMemory            string `json:"version_map_memory"` // e.g. "61.3kb"
+	VersionMapMemoryInBytes     int64  `json:"version_map_memory_in_bytes"`
+	FixedBitSet                 string `json:"fixed_bit_set"` // e.g. "61.3kb"
+	FixedBitSetInBytes          int64  `json:"fixed_bit_set_memory_in_bytes"`
+}
+
+type ClusterStatsIndicesPercolate struct {
+	Total int64 `json:"total"`
+	// TODO(oe) The JSON tag here is wrong as of ES 1.5.2 it seems
+	Time              string `json:"get_time"` // e.g. "1s"
+	TimeInBytes       int64  `json:"time_in_millis"`
+	Current           int64  `json:"current"`
+	MemorySize        string `json:"memory_size"` // e.g. "61.3kb"
+	MemorySizeInBytes int64  `json:"memory_sitze_in_bytes"`
+	Queries           int64  `json:"queries"`
+}
+
+// ---
+
+type ClusterStatsNodes struct {
+	Count    *ClusterStatsNodesCount        `json:"count"`
+	Versions []string                       `json:"versions"`
+	OS       *ClusterStatsNodesOsStats      `json:"os"`
+	Process  *ClusterStatsNodesProcessStats `json:"process"`
+	JVM      *ClusterStatsNodesJvmStats     `json:"jvm"`
+	FS       *ClusterStatsNodesFsStats      `json:"fs"`
+	Plugins  []*ClusterStatsNodesPlugin     `json:"plugins"`
+}
+
+type ClusterStatsNodesCount struct {
+	Total            int `json:"total"`
+	Data             int `json:"data"`
+	CoordinatingOnly int `json:"coordinating_only"`
+	Master           int `json:"master"`
+	Ingest           int `json:"ingest"`
+}
+
+type ClusterStatsNodesOsStats struct {
+	AvailableProcessors int                            `json:"available_processors"`
+	Mem                 *ClusterStatsNodesOsStatsMem   `json:"mem"`
+	CPU                 []*ClusterStatsNodesOsStatsCPU `json:"cpu"`
+}
+
+type ClusterStatsNodesOsStatsMem struct {
+	Total        string `json:"total"` // e.g. "16gb"
+	TotalInBytes int64  `json:"total_in_bytes"`
+}
+
+type ClusterStatsNodesOsStatsCPU struct {
+	Vendor           string `json:"vendor"`
+	Model            string `json:"model"`
+	MHz              int    `json:"mhz"`
+	TotalCores       int    `json:"total_cores"`
+	TotalSockets     int    `json:"total_sockets"`
+	CoresPerSocket   int    `json:"cores_per_socket"`
+	CacheSize        string `json:"cache_size"` // e.g. "256b"
+	CacheSizeInBytes int64  `json:"cache_size_in_bytes"`
+	Count            int    `json:"count"`
+}
+
+type ClusterStatsNodesProcessStats struct {
+	CPU                 *ClusterStatsNodesProcessStatsCPU                 `json:"cpu"`
+	OpenFileDescriptors *ClusterStatsNodesProcessStatsOpenFileDescriptors `json:"open_file_descriptors"`
+}
+
+type ClusterStatsNodesProcessStatsCPU struct {
+	Percent float64 `json:"percent"`
+}
+
+type ClusterStatsNodesProcessStatsOpenFileDescriptors struct {
+	Min int64 `json:"min"`
+	Max int64 `json:"max"`
+	Avg int64 `json:"avg"`
+}
+
+type ClusterStatsNodesJvmStats struct {
+	MaxUptime         string                              `json:"max_uptime"` // e.g. "5h"
+	MaxUptimeInMillis int64                               `json:"max_uptime_in_millis"`
+	Versions          []*ClusterStatsNodesJvmStatsVersion `json:"versions"`
+	Mem               *ClusterStatsNodesJvmStatsMem       `json:"mem"`
+	Threads           int64                               `json:"threads"`
+}
+
+type ClusterStatsNodesJvmStatsVersion struct {
+	Version   string `json:"version"`    // e.g. "1.8.0_45"
+	VMName    string `json:"vm_name"`    // e.g. "Java HotSpot(TM) 64-Bit Server VM"
+	VMVersion string `json:"vm_version"` // e.g. "25.45-b02"
+	VMVendor  string `json:"vm_vendor"`  // e.g. "Oracle Corporation"
+	Count     int    `json:"count"`
+}
+
+type ClusterStatsNodesJvmStatsMem struct {
+	HeapUsed        string `json:"heap_used"`
+	HeapUsedInBytes int64  `json:"heap_used_in_bytes"`
+	HeapMax         string `json:"heap_max"`
+	HeapMaxInBytes  int64  `json:"heap_max_in_bytes"`
+}
+
+type ClusterStatsNodesFsStats struct {
+	Path                 string `json:"path"`
+	Mount                string `json:"mount"`
+	Dev                  string `json:"dev"`
+	Total                string `json:"total"` // e.g. "930.7gb"`
+	TotalInBytes         int64  `json:"total_in_bytes"`
+	Free                 string `json:"free"` // e.g. "930.7gb"`
+	FreeInBytes          int64  `json:"free_in_bytes"`
+	Available            string `json:"available"` // e.g. "930.7gb"`
+	AvailableInBytes     int64  `json:"available_in_bytes"`
+	DiskReads            int64  `json:"disk_reads"`
+	DiskWrites           int64  `json:"disk_writes"`
+	DiskIOOp             int64  `json:"disk_io_op"`
+	DiskReadSize         string `json:"disk_read_size"` // e.g. "0b"`
+	DiskReadSizeInBytes  int64  `json:"disk_read_size_in_bytes"`
+	DiskWriteSize        string `json:"disk_write_size"` // e.g. "0b"`
+	DiskWriteSizeInBytes int64  `json:"disk_write_size_in_bytes"`
+	DiskIOSize           string `json:"disk_io_size"` // e.g. "0b"`
+	DiskIOSizeInBytes    int64  `json:"disk_io_size_in_bytes"`
+	DiskQueue            string `json:"disk_queue"`
+	DiskServiceTime      string `json:"disk_service_time"`
+}
+
+type ClusterStatsNodesPlugin struct {
+	Name        string `json:"name"`
+	Version     string `json:"version"`
+	Description string `json:"description"`
+	URL         string `json:"url"`
+	JVM         bool   `json:"jvm"`
+	Site        bool   `json:"site"`
+}

vendor/github.com/olivere/elastic/config/config.go

@@ -0,0 +1,81 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package config
+
+import (
+	"fmt"
+	"net/url"
+	"strconv"
+	"strings"
+)
+
+// Config represents an Elasticsearch configuration.
+type Config struct {
+	URL      string
+	Index    string
+	Username string
+	Password string
+	Shards   int
+	Replicas int
+	Sniff    *bool
+	Infolog  string
+	Errorlog string
+	Tracelog string
+}
+
+// Parse returns the Elasticsearch configuration by extracting it
+// from the URL, its path, and its query string.
+//
+// Example:
+//   http://127.0.0.1:9200/store-blobs?shards=1&replicas=0&sniff=false&tracelog=elastic.trace.log
+//
+// The code above will return a URL of http://127.0.0.1:9200, an index name
+// of store-blobs, and the related settings from the query string.
+func Parse(elasticURL string) (*Config, error) {
+	cfg := &Config{
+		Shards:   1,
+		Replicas: 0,
+		Sniff:    nil,
+	}
+
+	uri, err := url.Parse(elasticURL)
+	if err != nil {
+		return nil, fmt.Errorf("error parsing elastic parameter %q: %v", elasticURL, err)
+	}
+	index := strings.TrimSuffix(strings.TrimPrefix(uri.Path, "/"), "/")
+	if uri.User != nil {
+		cfg.Username = uri.User.Username()
+		cfg.Password, _ = uri.User.Password()
+	}
+	uri.User = nil
+
+	if i, err := strconv.Atoi(uri.Query().Get("shards")); err == nil {
+		cfg.Shards = i
+	}
+	if i, err := strconv.Atoi(uri.Query().Get("replicas")); err == nil {
+		cfg.Replicas = i
+	}
+	if s := uri.Query().Get("sniff"); s != "" {
+		if b, err := strconv.ParseBool(s); err == nil {
+			cfg.Sniff = &b
+		}
+	}
+	if s := uri.Query().Get("infolog"); s != "" {
+		cfg.Infolog = s
+	}
+	if s := uri.Query().Get("errorlog"); s != "" {
+		cfg.Errorlog = s
+	}
+	if s := uri.Query().Get("tracelog"); s != "" {
+		cfg.Tracelog = s
+	}
+
+	uri.Path = ""
+	uri.RawQuery = ""
+	cfg.URL = uri.String()
+	cfg.Index = index
+
+	return cfg, nil
+}

vendor/github.com/olivere/elastic/config/doc.go

@@ -0,0 +1,9 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+/*
+Package config allows parsing a configuration for Elasticsearch
+from a URL.
+*/
+package config

vendor/github.com/olivere/elastic/connection.go

@@ -0,0 +1,90 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"fmt"
+	"sync"
+	"time"
+)
+
+// conn represents a single connection to a node in a cluster.
+type conn struct {
+	sync.RWMutex
+	nodeID    string // node ID
+	url       string
+	failures  int
+	dead      bool
+	deadSince *time.Time
+}
+
+// newConn creates a new connection to the given URL.
+func newConn(nodeID, url string) *conn {
+	c := &conn{
+		nodeID: nodeID,
+		url:    url,
+	}
+	return c
+}
+
+// String returns a representation of the connection status.
+func (c *conn) String() string {
+	c.RLock()
+	defer c.RUnlock()
+	return fmt.Sprintf("%s [dead=%v,failures=%d,deadSince=%v]", c.url, c.dead, c.failures, c.deadSince)
+}
+
+// NodeID returns the ID of the node of this connection.
+func (c *conn) NodeID() string {
+	c.RLock()
+	defer c.RUnlock()
+	return c.nodeID
+}
+
+// URL returns the URL of this connection.
+func (c *conn) URL() string {
+	c.RLock()
+	defer c.RUnlock()
+	return c.url
+}
+
+// IsDead returns true if this connection is marked as dead, i.e. a previous
+// request to the URL has been unsuccessful.
+func (c *conn) IsDead() bool {
+	c.RLock()
+	defer c.RUnlock()
+	return c.dead
+}
+
+// MarkAsDead marks this connection as dead, increments the failures
+// counter and stores the current time in dead since.
+func (c *conn) MarkAsDead() {
+	c.Lock()
+	c.dead = true
+	if c.deadSince == nil {
+		utcNow := time.Now().UTC()
+		c.deadSince = &utcNow
+	}
+	c.failures += 1
+	c.Unlock()
+}
+
+// MarkAsAlive marks this connection as eligible to be returned from the
+// pool of connections by the selector.
+func (c *conn) MarkAsAlive() {
+	c.Lock()
+	c.dead = false
+	c.Unlock()
+}
+
+// MarkAsHealthy marks this connection as healthy, i.e. a request has been
+// successfully performed with it.
+func (c *conn) MarkAsHealthy() {
+	c.Lock()
+	c.dead = false
+	c.deadSince = nil
+	c.failures = 0
+	c.Unlock()
+}

vendor/github.com/olivere/elastic/count.go

@@ -0,0 +1,326 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// CountService is a convenient service for determining the
+// number of documents in an index. Use SearchService with
+// a SearchType of count for counting with queries etc.
+type CountService struct {
+	client                 *Client
+	pretty                 bool
+	index                  []string
+	typ                    []string
+	allowNoIndices         *bool
+	analyzeWildcard        *bool
+	analyzer               string
+	defaultOperator        string
+	df                     string
+	expandWildcards        string
+	ignoreUnavailable      *bool
+	lenient                *bool
+	lowercaseExpandedTerms *bool
+	minScore               interface{}
+	preference             string
+	q                      string
+	query                  Query
+	routing                string
+	terminateAfter         *int
+	bodyJson               interface{}
+	bodyString             string
+}
+
+// NewCountService creates a new CountService.
+func NewCountService(client *Client) *CountService {
+	return &CountService{
+		client: client,
+	}
+}
+
+// Index sets the names of the indices to restrict the results.
+func (s *CountService) Index(index ...string) *CountService {
+	if s.index == nil {
+		s.index = make([]string, 0)
+	}
+	s.index = append(s.index, index...)
+	return s
+}
+
+// Type sets the types to use to restrict the results.
+func (s *CountService) Type(typ ...string) *CountService {
+	if s.typ == nil {
+		s.typ = make([]string, 0)
+	}
+	s.typ = append(s.typ, typ...)
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices. (This includes "_all" string
+// or when no indices have been specified).
+func (s *CountService) AllowNoIndices(allowNoIndices bool) *CountService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// AnalyzeWildcard specifies whether wildcard and prefix queries should be
+// analyzed (default: false).
+func (s *CountService) AnalyzeWildcard(analyzeWildcard bool) *CountService {
+	s.analyzeWildcard = &analyzeWildcard
+	return s
+}
+
+// Analyzer specifies the analyzer to use for the query string.
+func (s *CountService) Analyzer(analyzer string) *CountService {
+	s.analyzer = analyzer
+	return s
+}
+
+// DefaultOperator specifies the default operator for query string query (AND or OR).
+func (s *CountService) DefaultOperator(defaultOperator string) *CountService {
+	s.defaultOperator = defaultOperator
+	return s
+}
+
+// Df specifies the field to use as default where no field prefix is given
+// in the query string.
+func (s *CountService) Df(df string) *CountService {
+	s.df = df
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both.
+func (s *CountService) ExpandWildcards(expandWildcards string) *CountService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *CountService) IgnoreUnavailable(ignoreUnavailable bool) *CountService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// Lenient specifies whether format-based query failures (such as
+// providing text to a numeric field) should be ignored.
+func (s *CountService) Lenient(lenient bool) *CountService {
+	s.lenient = &lenient
+	return s
+}
+
+// LowercaseExpandedTerms specifies whether query terms should be lowercased.
+func (s *CountService) LowercaseExpandedTerms(lowercaseExpandedTerms bool) *CountService {
+	s.lowercaseExpandedTerms = &lowercaseExpandedTerms
+	return s
+}
+
+// MinScore indicates to include only documents with a specific `_score`
+// value in the result.
+func (s *CountService) MinScore(minScore interface{}) *CountService {
+	s.minScore = minScore
+	return s
+}
+
+// Preference specifies the node or shard the operation should be
+// performed on (default: random).
+func (s *CountService) Preference(preference string) *CountService {
+	s.preference = preference
+	return s
+}
+
+// Q in the Lucene query string syntax. You can also use Query to pass
+// a Query struct.
+func (s *CountService) Q(q string) *CountService {
+	s.q = q
+	return s
+}
+
+// Query specifies the query to pass. You can also pass a query string with Q.
+func (s *CountService) Query(query Query) *CountService {
+	s.query = query
+	return s
+}
+
+// Routing specifies the routing value.
+func (s *CountService) Routing(routing string) *CountService {
+	s.routing = routing
+	return s
+}
+
+// TerminateAfter indicates the maximum count for each shard, upon reaching
+// which the query execution will terminate early.
+func (s *CountService) TerminateAfter(terminateAfter int) *CountService {
+	s.terminateAfter = &terminateAfter
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *CountService) Pretty(pretty bool) *CountService {
+	s.pretty = pretty
+	return s
+}
+
+// BodyJson specifies the query to restrict the results specified with the
+// Query DSL (optional). The interface{} will be serialized to a JSON document,
+// so use a map[string]interface{}.
+func (s *CountService) BodyJson(body interface{}) *CountService {
+	s.bodyJson = body
+	return s
+}
+
+// Body specifies a query to restrict the results specified with
+// the Query DSL (optional).
+func (s *CountService) BodyString(body string) *CountService {
+	s.bodyString = body
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *CountService) buildURL() (string, url.Values, error) {
+	var err error
+	var path string
+
+	if len(s.index) > 0 && len(s.typ) > 0 {
+		path, err = uritemplates.Expand("/{index}/{type}/_count", map[string]string{
+			"index": strings.Join(s.index, ","),
+			"type":  strings.Join(s.typ, ","),
+		})
+	} else if len(s.index) > 0 {
+		path, err = uritemplates.Expand("/{index}/_count", map[string]string{
+			"index": strings.Join(s.index, ","),
+		})
+	} else if len(s.typ) > 0 {
+		path, err = uritemplates.Expand("/_all/{type}/_count", map[string]string{
+			"type": strings.Join(s.typ, ","),
+		})
+	} else {
+		path = "/_all/_count"
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.analyzeWildcard != nil {
+		params.Set("analyze_wildcard", fmt.Sprintf("%v", *s.analyzeWildcard))
+	}
+	if s.analyzer != "" {
+		params.Set("analyzer", s.analyzer)
+	}
+	if s.defaultOperator != "" {
+		params.Set("default_operator", s.defaultOperator)
+	}
+	if s.df != "" {
+		params.Set("df", s.df)
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.lenient != nil {
+		params.Set("lenient", fmt.Sprintf("%v", *s.lenient))
+	}
+	if s.lowercaseExpandedTerms != nil {
+		params.Set("lowercase_expanded_terms", fmt.Sprintf("%v", *s.lowercaseExpandedTerms))
+	}
+	if s.minScore != nil {
+		params.Set("min_score", fmt.Sprintf("%v", s.minScore))
+	}
+	if s.preference != "" {
+		params.Set("preference", s.preference)
+	}
+	if s.q != "" {
+		params.Set("q", s.q)
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	if s.terminateAfter != nil {
+		params.Set("terminate_after", fmt.Sprintf("%v", *s.terminateAfter))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *CountService) Validate() error {
+	return nil
+}
+
+// Do executes the operation.
+func (s *CountService) Do(ctx context.Context) (int64, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return 0, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return 0, err
+	}
+
+	// Setup HTTP request body
+	var body interface{}
+	if s.query != nil {
+		src, err := s.query.Source()
+		if err != nil {
+			return 0, err
+		}
+		query := make(map[string]interface{})
+		query["query"] = src
+		body = query
+	} else if s.bodyJson != nil {
+		body = s.bodyJson
+	} else if s.bodyString != "" {
+		body = s.bodyString
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "POST",
+		Path:   path,
+		Params: params,
+		Body:   body,
+	})
+	if err != nil {
+		return 0, err
+	}
+
+	// Return result
+	ret := new(CountResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return 0, err
+	}
+	if ret != nil {
+		return ret.Count, nil
+	}
+
+	return int64(0), nil
+}
+
+// CountResponse is the response of using the Count API.
+type CountResponse struct {
+	Count  int64      `json:"count"`
+	Shards shardsInfo `json:"_shards,omitempty"`
+}

vendor/github.com/olivere/elastic/decoder.go

@@ -0,0 +1,26 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"encoding/json"
+)
+
+// Decoder is used to decode responses from Elasticsearch.
+// Users of elastic can implement their own marshaler for advanced purposes
+// and set them per Client (see SetDecoder). If none is specified,
+// DefaultDecoder is used.
+type Decoder interface {
+	Decode(data []byte, v interface{}) error
+}
+
+// DefaultDecoder uses json.Unmarshal from the Go standard library
+// to decode JSON data.
+type DefaultDecoder struct{}
+
+// Decode decodes with json.Unmarshal from the Go standard library.
+func (u *DefaultDecoder) Decode(data []byte, v interface{}) error {
+	return json.Unmarshal(data, v)
+}

vendor/github.com/olivere/elastic/delete.go

@@ -0,0 +1,229 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// DeleteService allows to delete a typed JSON document from a specified
+// index based on its id.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-delete.html
+// for details.
+type DeleteService struct {
+	client              *Client
+	pretty              bool
+	id                  string
+	index               string
+	typ                 string
+	routing             string
+	timeout             string
+	version             interface{}
+	versionType         string
+	waitForActiveShards string
+	parent              string
+	refresh             string
+}
+
+// NewDeleteService creates a new DeleteService.
+func NewDeleteService(client *Client) *DeleteService {
+	return &DeleteService{
+		client: client,
+	}
+}
+
+// Type is the type of the document.
+func (s *DeleteService) Type(typ string) *DeleteService {
+	s.typ = typ
+	return s
+}
+
+// Id is the document ID.
+func (s *DeleteService) Id(id string) *DeleteService {
+	s.id = id
+	return s
+}
+
+// Index is the name of the index.
+func (s *DeleteService) Index(index string) *DeleteService {
+	s.index = index
+	return s
+}
+
+// Routing is a specific routing value.
+func (s *DeleteService) Routing(routing string) *DeleteService {
+	s.routing = routing
+	return s
+}
+
+// Timeout is an explicit operation timeout.
+func (s *DeleteService) Timeout(timeout string) *DeleteService {
+	s.timeout = timeout
+	return s
+}
+
+// Version is an explicit version number for concurrency control.
+func (s *DeleteService) Version(version interface{}) *DeleteService {
+	s.version = version
+	return s
+}
+
+// VersionType is a specific version type.
+func (s *DeleteService) VersionType(versionType string) *DeleteService {
+	s.versionType = versionType
+	return s
+}
+
+// WaitForActiveShards sets the number of shard copies that must be active
+// before proceeding with the delete operation. Defaults to 1, meaning the
+// primary shard only. Set to `all` for all shard copies, otherwise set to
+// any non-negative value less than or equal to the total number of copies
+// for the shard (number of replicas + 1).
+func (s *DeleteService) WaitForActiveShards(waitForActiveShards string) *DeleteService {
+	s.waitForActiveShards = waitForActiveShards
+	return s
+}
+
+// Parent is the ID of parent document.
+func (s *DeleteService) Parent(parent string) *DeleteService {
+	s.parent = parent
+	return s
+}
+
+// Refresh the index after performing the operation.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-refresh.html
+// for details.
+func (s *DeleteService) Refresh(refresh string) *DeleteService {
+	s.refresh = refresh
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *DeleteService) Pretty(pretty bool) *DeleteService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *DeleteService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/{type}/{id}", map[string]string{
+		"index": s.index,
+		"type":  s.typ,
+		"id":    s.id,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.refresh != "" {
+		params.Set("refresh", s.refresh)
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.version != nil {
+		params.Set("version", fmt.Sprintf("%v", s.version))
+	}
+	if s.versionType != "" {
+		params.Set("version_type", s.versionType)
+	}
+	if s.waitForActiveShards != "" {
+		params.Set("wait_for_active_shards", s.waitForActiveShards)
+	}
+	if s.parent != "" {
+		params.Set("parent", s.parent)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *DeleteService) Validate() error {
+	var invalid []string
+	if s.typ == "" {
+		invalid = append(invalid, "Type")
+	}
+	if s.id == "" {
+		invalid = append(invalid, "Id")
+	}
+	if s.index == "" {
+		invalid = append(invalid, "Index")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation. If the document is not found (404), Elasticsearch will
+// still return a response. This response is serialized and returned as well. In other
+// words, for HTTP status code 404, both an error and a response might be returned.
+func (s *DeleteService) Do(ctx context.Context) (*DeleteResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method:       "DELETE",
+		Path:         path,
+		Params:       params,
+		IgnoreErrors: []int{http.StatusNotFound},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(DeleteResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+
+	// If we have a 404, we return both a result and an error, just like ES does
+	if res.StatusCode == http.StatusNotFound {
+		return ret, &Error{Status: http.StatusNotFound}
+	}
+
+	return ret, nil
+}
+
+// -- Result of a delete request.
+
+// DeleteResponse is the outcome of running DeleteService.Do.
+type DeleteResponse struct {
+	Index         string      `json:"_index,omitempty"`
+	Type          string      `json:"_type,omitempty"`
+	Id            string      `json:"_id,omitempty"`
+	Version       int64       `json:"_version,omitempty"`
+	Result        string      `json:"result,omitempty"`
+	Shards        *shardsInfo `json:"_shards,omitempty"`
+	SeqNo         int64       `json:"_seq_no,omitempty"`
+	PrimaryTerm   int64       `json:"_primary_term,omitempty"`
+	Status        int         `json:"status,omitempty"`
+	ForcedRefresh bool        `json:"forced_refresh,omitempty"`
+}

vendor/github.com/olivere/elastic/delete_by_query.go

@@ -0,0 +1,657 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// DeleteByQueryService deletes documents that match a query.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-delete-by-query.html.
+type DeleteByQueryService struct {
+	client                 *Client
+	index                  []string
+	typ                    []string
+	query                  Query
+	body                   interface{}
+	xSource                []string
+	xSourceExclude         []string
+	xSourceInclude         []string
+	analyzer               string
+	analyzeWildcard        *bool
+	allowNoIndices         *bool
+	conflicts              string
+	defaultOperator        string
+	df                     string
+	docvalueFields         []string
+	expandWildcards        string
+	explain                *bool
+	from                   *int
+	ignoreUnavailable      *bool
+	lenient                *bool
+	lowercaseExpandedTerms *bool
+	preference             string
+	q                      string
+	refresh                string
+	requestCache           *bool
+	requestsPerSecond      *int
+	routing                []string
+	scroll                 string
+	scrollSize             *int
+	searchTimeout          string
+	searchType             string
+	size                   *int
+	sort                   []string
+	stats                  []string
+	storedFields           []string
+	suggestField           string
+	suggestMode            string
+	suggestSize            *int
+	suggestText            string
+	terminateAfter         *int
+	timeout                string
+	trackScores            *bool
+	version                *bool
+	waitForActiveShards    string
+	waitForCompletion      *bool
+	pretty                 bool
+}
+
+// NewDeleteByQueryService creates a new DeleteByQueryService.
+// You typically use the client's DeleteByQuery to get a reference to
+// the service.
+func NewDeleteByQueryService(client *Client) *DeleteByQueryService {
+	builder := &DeleteByQueryService{
+		client: client,
+	}
+	return builder
+}
+
+// Index sets the indices on which to perform the delete operation.
+func (s *DeleteByQueryService) Index(index ...string) *DeleteByQueryService {
+	s.index = append(s.index, index...)
+	return s
+}
+
+// Type limits the delete operation to the given types.
+func (s *DeleteByQueryService) Type(typ ...string) *DeleteByQueryService {
+	s.typ = append(s.typ, typ...)
+	return s
+}
+
+// XSource is true or false to return the _source field or not,
+// or a list of fields to return.
+func (s *DeleteByQueryService) XSource(xSource ...string) *DeleteByQueryService {
+	s.xSource = append(s.xSource, xSource...)
+	return s
+}
+
+// XSourceExclude represents a list of fields to exclude from the returned _source field.
+func (s *DeleteByQueryService) XSourceExclude(xSourceExclude ...string) *DeleteByQueryService {
+	s.xSourceExclude = append(s.xSourceExclude, xSourceExclude...)
+	return s
+}
+
+// XSourceInclude represents a list of fields to extract and return from the _source field.
+func (s *DeleteByQueryService) XSourceInclude(xSourceInclude ...string) *DeleteByQueryService {
+	s.xSourceInclude = append(s.xSourceInclude, xSourceInclude...)
+	return s
+}
+
+// Analyzer to use for the query string.
+func (s *DeleteByQueryService) Analyzer(analyzer string) *DeleteByQueryService {
+	s.analyzer = analyzer
+	return s
+}
+
+// AnalyzeWildcard specifies whether wildcard and prefix queries should be
+// analyzed (default: false).
+func (s *DeleteByQueryService) AnalyzeWildcard(analyzeWildcard bool) *DeleteByQueryService {
+	s.analyzeWildcard = &analyzeWildcard
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices (including the _all string
+// or when no indices have been specified).
+func (s *DeleteByQueryService) AllowNoIndices(allow bool) *DeleteByQueryService {
+	s.allowNoIndices = &allow
+	return s
+}
+
+// Conflicts indicates what to do when the process detects version conflicts.
+// Possible values are "proceed" and "abort".
+func (s *DeleteByQueryService) Conflicts(conflicts string) *DeleteByQueryService {
+	s.conflicts = conflicts
+	return s
+}
+
+// AbortOnVersionConflict aborts the request on version conflicts.
+// It is an alias to setting Conflicts("abort").
+func (s *DeleteByQueryService) AbortOnVersionConflict() *DeleteByQueryService {
+	s.conflicts = "abort"
+	return s
+}
+
+// ProceedOnVersionConflict aborts the request on version conflicts.
+// It is an alias to setting Conflicts("proceed").
+func (s *DeleteByQueryService) ProceedOnVersionConflict() *DeleteByQueryService {
+	s.conflicts = "proceed"
+	return s
+}
+
+// DefaultOperator for query string query (AND or OR).
+func (s *DeleteByQueryService) DefaultOperator(defaultOperator string) *DeleteByQueryService {
+	s.defaultOperator = defaultOperator
+	return s
+}
+
+// DF is the field to use as default where no field prefix is given in the query string.
+func (s *DeleteByQueryService) DF(defaultField string) *DeleteByQueryService {
+	s.df = defaultField
+	return s
+}
+
+// DefaultField is the field to use as default where no field prefix is given in the query string.
+// It is an alias to the DF func.
+func (s *DeleteByQueryService) DefaultField(defaultField string) *DeleteByQueryService {
+	s.df = defaultField
+	return s
+}
+
+// DocvalueFields specifies the list of fields to return as the docvalue representation of a field for each hit.
+func (s *DeleteByQueryService) DocvalueFields(docvalueFields ...string) *DeleteByQueryService {
+	s.docvalueFields = docvalueFields
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both. It can be "open" or "closed".
+func (s *DeleteByQueryService) ExpandWildcards(expand string) *DeleteByQueryService {
+	s.expandWildcards = expand
+	return s
+}
+
+// Explain specifies whether to return detailed information about score
+// computation as part of a hit.
+func (s *DeleteByQueryService) Explain(explain bool) *DeleteByQueryService {
+	s.explain = &explain
+	return s
+}
+
+// From is the starting offset (default: 0).
+func (s *DeleteByQueryService) From(from int) *DeleteByQueryService {
+	s.from = &from
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *DeleteByQueryService) IgnoreUnavailable(ignore bool) *DeleteByQueryService {
+	s.ignoreUnavailable = &ignore
+	return s
+}
+
+// Lenient specifies whether format-based query failures
+// (such as providing text to a numeric field) should be ignored.
+func (s *DeleteByQueryService) Lenient(lenient bool) *DeleteByQueryService {
+	s.lenient = &lenient
+	return s
+}
+
+// LowercaseExpandedTerms specifies whether query terms should be lowercased.
+func (s *DeleteByQueryService) LowercaseExpandedTerms(lowercaseExpandedTerms bool) *DeleteByQueryService {
+	s.lowercaseExpandedTerms = &lowercaseExpandedTerms
+	return s
+}
+
+// Preference specifies the node or shard the operation should be performed on
+// (default: random).
+func (s *DeleteByQueryService) Preference(preference string) *DeleteByQueryService {
+	s.preference = preference
+	return s
+}
+
+// Q specifies the query in Lucene query string syntax. You can also use
+// Query to programmatically specify the query.
+func (s *DeleteByQueryService) Q(query string) *DeleteByQueryService {
+	s.q = query
+	return s
+}
+
+// QueryString is an alias to Q. Notice that you can also use Query to
+// programmatically set the query.
+func (s *DeleteByQueryService) QueryString(query string) *DeleteByQueryService {
+	s.q = query
+	return s
+}
+
+// Query sets the query programmatically.
+func (s *DeleteByQueryService) Query(query Query) *DeleteByQueryService {
+	s.query = query
+	return s
+}
+
+// Refresh indicates whether the effected indexes should be refreshed.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-refresh.html
+// for details.
+func (s *DeleteByQueryService) Refresh(refresh string) *DeleteByQueryService {
+	s.refresh = refresh
+	return s
+}
+
+// RequestCache specifies if request cache should be used for this request
+// or not, defaults to index level setting.
+func (s *DeleteByQueryService) RequestCache(requestCache bool) *DeleteByQueryService {
+	s.requestCache = &requestCache
+	return s
+}
+
+// RequestsPerSecond sets the throttle on this request in sub-requests per second.
+// -1 means set no throttle as does "unlimited" which is the only non-float this accepts.
+func (s *DeleteByQueryService) RequestsPerSecond(requestsPerSecond int) *DeleteByQueryService {
+	s.requestsPerSecond = &requestsPerSecond
+	return s
+}
+
+// Routing is a list of specific routing values.
+func (s *DeleteByQueryService) Routing(routing ...string) *DeleteByQueryService {
+	s.routing = append(s.routing, routing...)
+	return s
+}
+
+// Scroll specifies how long a consistent view of the index should be maintained
+// for scrolled search.
+func (s *DeleteByQueryService) Scroll(scroll string) *DeleteByQueryService {
+	s.scroll = scroll
+	return s
+}
+
+// ScrollSize is the size on the scroll request powering the update_by_query.
+func (s *DeleteByQueryService) ScrollSize(scrollSize int) *DeleteByQueryService {
+	s.scrollSize = &scrollSize
+	return s
+}
+
+// SearchTimeout defines an explicit timeout for each search request.
+// Defaults to no timeout.
+func (s *DeleteByQueryService) SearchTimeout(searchTimeout string) *DeleteByQueryService {
+	s.searchTimeout = searchTimeout
+	return s
+}
+
+// SearchType is the search operation type. Possible values are
+// "query_then_fetch" and "dfs_query_then_fetch".
+func (s *DeleteByQueryService) SearchType(searchType string) *DeleteByQueryService {
+	s.searchType = searchType
+	return s
+}
+
+// Size represents the number of hits to return (default: 10).
+func (s *DeleteByQueryService) Size(size int) *DeleteByQueryService {
+	s.size = &size
+	return s
+}
+
+// Sort is a list of <field>:<direction> pairs.
+func (s *DeleteByQueryService) Sort(sort ...string) *DeleteByQueryService {
+	s.sort = append(s.sort, sort...)
+	return s
+}
+
+// SortByField adds a sort order.
+func (s *DeleteByQueryService) SortByField(field string, ascending bool) *DeleteByQueryService {
+	if ascending {
+		s.sort = append(s.sort, fmt.Sprintf("%s:asc", field))
+	} else {
+		s.sort = append(s.sort, fmt.Sprintf("%s:desc", field))
+	}
+	return s
+}
+
+// Stats specifies specific tag(s) of the request for logging and statistical purposes.
+func (s *DeleteByQueryService) Stats(stats ...string) *DeleteByQueryService {
+	s.stats = append(s.stats, stats...)
+	return s
+}
+
+// StoredFields specifies the list of stored fields to return as part of a hit.
+func (s *DeleteByQueryService) StoredFields(storedFields ...string) *DeleteByQueryService {
+	s.storedFields = storedFields
+	return s
+}
+
+// SuggestField specifies which field to use for suggestions.
+func (s *DeleteByQueryService) SuggestField(suggestField string) *DeleteByQueryService {
+	s.suggestField = suggestField
+	return s
+}
+
+// SuggestMode specifies the suggest mode. Possible values are
+// "missing", "popular", and "always".
+func (s *DeleteByQueryService) SuggestMode(suggestMode string) *DeleteByQueryService {
+	s.suggestMode = suggestMode
+	return s
+}
+
+// SuggestSize specifies how many suggestions to return in response.
+func (s *DeleteByQueryService) SuggestSize(suggestSize int) *DeleteByQueryService {
+	s.suggestSize = &suggestSize
+	return s
+}
+
+// SuggestText specifies the source text for which the suggestions should be returned.
+func (s *DeleteByQueryService) SuggestText(suggestText string) *DeleteByQueryService {
+	s.suggestText = suggestText
+	return s
+}
+
+// TerminateAfter indicates the maximum number of documents to collect
+// for each shard, upon reaching which the query execution will terminate early.
+func (s *DeleteByQueryService) TerminateAfter(terminateAfter int) *DeleteByQueryService {
+	s.terminateAfter = &terminateAfter
+	return s
+}
+
+// Timeout is the time each individual bulk request should wait for shards
+// that are unavailable.
+func (s *DeleteByQueryService) Timeout(timeout string) *DeleteByQueryService {
+	s.timeout = timeout
+	return s
+}
+
+// TimeoutInMillis sets the timeout in milliseconds.
+func (s *DeleteByQueryService) TimeoutInMillis(timeoutInMillis int) *DeleteByQueryService {
+	s.timeout = fmt.Sprintf("%dms", timeoutInMillis)
+	return s
+}
+
+// TrackScores indicates whether to calculate and return scores even if
+// they are not used for sorting.
+func (s *DeleteByQueryService) TrackScores(trackScores bool) *DeleteByQueryService {
+	s.trackScores = &trackScores
+	return s
+}
+
+// Version specifies whether to return document version as part of a hit.
+func (s *DeleteByQueryService) Version(version bool) *DeleteByQueryService {
+	s.version = &version
+	return s
+}
+
+// WaitForActiveShards sets the number of shard copies that must be active before proceeding
+// with the update by query operation. Defaults to 1, meaning the primary shard only.
+// Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal
+// to the total number of copies for the shard (number of replicas + 1).
+func (s *DeleteByQueryService) WaitForActiveShards(waitForActiveShards string) *DeleteByQueryService {
+	s.waitForActiveShards = waitForActiveShards
+	return s
+}
+
+// WaitForCompletion indicates if the request should block until the reindex is complete.
+func (s *DeleteByQueryService) WaitForCompletion(waitForCompletion bool) *DeleteByQueryService {
+	s.waitForCompletion = &waitForCompletion
+	return s
+}
+
+// Pretty indents the JSON output from Elasticsearch.
+func (s *DeleteByQueryService) Pretty(pretty bool) *DeleteByQueryService {
+	s.pretty = pretty
+	return s
+}
+
+// Body specifies the body of the request. It overrides data being specified via SearchService.
+func (s *DeleteByQueryService) Body(body string) *DeleteByQueryService {
+	s.body = body
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *DeleteByQueryService) buildURL() (string, url.Values, error) {
+	// Build URL
+	var err error
+	var path string
+	if len(s.typ) > 0 {
+		path, err = uritemplates.Expand("/{index}/{type}/_delete_by_query", map[string]string{
+			"index": strings.Join(s.index, ","),
+			"type":  strings.Join(s.typ, ","),
+		})
+	} else {
+		path, err = uritemplates.Expand("/{index}/_delete_by_query", map[string]string{
+			"index": strings.Join(s.index, ","),
+		})
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if len(s.xSource) > 0 {
+		params.Set("_source", strings.Join(s.xSource, ","))
+	}
+	if len(s.xSourceExclude) > 0 {
+		params.Set("_source_exclude", strings.Join(s.xSourceExclude, ","))
+	}
+	if len(s.xSourceInclude) > 0 {
+		params.Set("_source_include", strings.Join(s.xSourceInclude, ","))
+	}
+	if s.analyzer != "" {
+		params.Set("analyzer", s.analyzer)
+	}
+	if s.analyzeWildcard != nil {
+		params.Set("analyze_wildcard", fmt.Sprintf("%v", *s.analyzeWildcard))
+	}
+	if s.defaultOperator != "" {
+		params.Set("default_operator", s.defaultOperator)
+	}
+	if s.df != "" {
+		params.Set("df", s.df)
+	}
+	if s.explain != nil {
+		params.Set("explain", fmt.Sprintf("%v", *s.explain))
+	}
+	if len(s.storedFields) > 0 {
+		params.Set("stored_fields", strings.Join(s.storedFields, ","))
+	}
+	if len(s.docvalueFields) > 0 {
+		params.Set("docvalue_fields", strings.Join(s.docvalueFields, ","))
+	}
+	if s.from != nil {
+		params.Set("from", fmt.Sprintf("%d", *s.from))
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.conflicts != "" {
+		params.Set("conflicts", s.conflicts)
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.lenient != nil {
+		params.Set("lenient", fmt.Sprintf("%v", *s.lenient))
+	}
+	if s.lowercaseExpandedTerms != nil {
+		params.Set("lowercase_expanded_terms", fmt.Sprintf("%v", *s.lowercaseExpandedTerms))
+	}
+	if s.preference != "" {
+		params.Set("preference", s.preference)
+	}
+	if s.q != "" {
+		params.Set("q", s.q)
+	}
+	if len(s.routing) > 0 {
+		params.Set("routing", strings.Join(s.routing, ","))
+	}
+	if s.scroll != "" {
+		params.Set("scroll", s.scroll)
+	}
+	if s.searchType != "" {
+		params.Set("search_type", s.searchType)
+	}
+	if s.searchTimeout != "" {
+		params.Set("search_timeout", s.searchTimeout)
+	}
+	if s.size != nil {
+		params.Set("size", fmt.Sprintf("%d", *s.size))
+	}
+	if len(s.sort) > 0 {
+		params.Set("sort", strings.Join(s.sort, ","))
+	}
+	if s.terminateAfter != nil {
+		params.Set("terminate_after", fmt.Sprintf("%v", *s.terminateAfter))
+	}
+	if len(s.stats) > 0 {
+		params.Set("stats", strings.Join(s.stats, ","))
+	}
+	if s.suggestField != "" {
+		params.Set("suggest_field", s.suggestField)
+	}
+	if s.suggestMode != "" {
+		params.Set("suggest_mode", s.suggestMode)
+	}
+	if s.suggestSize != nil {
+		params.Set("suggest_size", fmt.Sprintf("%v", *s.suggestSize))
+	}
+	if s.suggestText != "" {
+		params.Set("suggest_text", s.suggestText)
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.trackScores != nil {
+		params.Set("track_scores", fmt.Sprintf("%v", *s.trackScores))
+	}
+	if s.version != nil {
+		params.Set("version", fmt.Sprintf("%v", *s.version))
+	}
+	if s.requestCache != nil {
+		params.Set("request_cache", fmt.Sprintf("%v", *s.requestCache))
+	}
+	if s.refresh != "" {
+		params.Set("refresh", s.refresh)
+	}
+	if s.waitForActiveShards != "" {
+		params.Set("wait_for_active_shards", s.waitForActiveShards)
+	}
+	if s.scrollSize != nil {
+		params.Set("scroll_size", fmt.Sprintf("%d", *s.scrollSize))
+	}
+	if s.waitForCompletion != nil {
+		params.Set("wait_for_completion", fmt.Sprintf("%v", *s.waitForCompletion))
+	}
+	if s.requestsPerSecond != nil {
+		params.Set("requests_per_second", fmt.Sprintf("%v", *s.requestsPerSecond))
+	}
+	if s.pretty {
+		params.Set("pretty", fmt.Sprintf("%v", s.pretty))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *DeleteByQueryService) Validate() error {
+	var invalid []string
+	if len(s.index) == 0 {
+		invalid = append(invalid, "Index")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the delete-by-query operation.
+func (s *DeleteByQueryService) Do(ctx context.Context) (*BulkIndexByScrollResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Set body if there is a query set
+	var body interface{}
+	if s.body != nil {
+		body = s.body
+	} else if s.query != nil {
+		src, err := s.query.Source()
+		if err != nil {
+			return nil, err
+		}
+		body = map[string]interface{}{
+			"query": src,
+		}
+	}
+
+	// Get response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "POST",
+		Path:   path,
+		Params: params,
+		Body:   body,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return result
+	ret := new(BulkIndexByScrollResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// BulkIndexByScrollResponse is the outcome of executing Do with
+// DeleteByQueryService and UpdateByQueryService.
+type BulkIndexByScrollResponse struct {
+	Took             int64  `json:"took"`
+	SliceId          *int64 `json:"slice_id,omitempty"`
+	TimedOut         bool   `json:"timed_out"`
+	Total            int64  `json:"total"`
+	Updated          int64  `json:"updated,omitempty"`
+	Created          int64  `json:"created,omitempty"`
+	Deleted          int64  `json:"deleted"`
+	Batches          int64  `json:"batches"`
+	VersionConflicts int64  `json:"version_conflicts"`
+	Noops            int64  `json:"noops"`
+	Retries          struct {
+		Bulk   int64 `json:"bulk"`
+		Search int64 `json:"search"`
+	} `json:"retries,omitempty"`
+	Throttled            string                             `json:"throttled"`
+	ThrottledMillis      int64                              `json:"throttled_millis"`
+	RequestsPerSecond    float64                            `json:"requests_per_second"`
+	Canceled             string                             `json:"canceled,omitempty"`
+	ThrottledUntil       string                             `json:"throttled_until"`
+	ThrottledUntilMillis int64                              `json:"throttled_until_millis"`
+	Failures             []bulkIndexByScrollResponseFailure `json:"failures"`
+}
+
+type bulkIndexByScrollResponseFailure struct {
+	Index  string `json:"index,omitempty"`
+	Type   string `json:"type,omitempty"`
+	Id     string `json:"id,omitempty"`
+	Status int    `json:"status,omitempty"`
+	Shard  int    `json:"shard,omitempty"`
+	Node   int    `json:"node,omitempty"`
+	// TOOD "cause" contains exception details
+	// TOOD "reason" contains exception details
+}

vendor/github.com/olivere/elastic/doc.go

@@ -0,0 +1,51 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+/*
+Package elastic provides an interface to the Elasticsearch server
+(https://www.elastic.co/products/elasticsearch).
+
+The first thing you do is to create a Client. If you have Elasticsearch
+installed and running with its default settings
+(i.e. available at http://127.0.0.1:9200), all you need to do is:
+
+	client, err := elastic.NewClient()
+	if err != nil {
+		// Handle error
+	}
+
+If your Elasticsearch server is running on a different IP and/or port,
+just provide a URL to NewClient:
+
+  // Create a client and connect to http://192.168.2.10:9201
+  client, err := elastic.NewClient(elastic.SetURL("http://192.168.2.10:9201"))
+  if err != nil {
+    // Handle error
+  }
+
+You can pass many more configuration parameters to NewClient. Review the
+documentation of NewClient for more information.
+
+If no Elasticsearch server is available, services will fail when creating
+a new request and will return ErrNoClient.
+
+A Client provides services. The services usually come with a variety of
+methods to prepare the query and a Do function to execute it against the
+Elasticsearch REST interface and return a response. Here is an example
+of the IndexExists service that checks if a given index already exists.
+
+	exists, err := client.IndexExists("twitter").Do(context.Background())
+	if err != nil {
+		// Handle error
+	}
+	if !exists {
+		// Index does not exist yet.
+	}
+
+Look up the documentation for Client to get an idea of the services provided
+and what kinds of responses you get when executing the Do function of a service.
+Also see the wiki on Github for more details.
+
+*/
+package elastic

vendor/github.com/olivere/elastic/errors.go

@@ -0,0 +1,155 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	"github.com/pkg/errors"
+)
+
+// checkResponse will return an error if the request/response indicates
+// an error returned from Elasticsearch.
+//
+// HTTP status codes between in the range [200..299] are considered successful.
+// All other errors are considered errors except they are specified in
+// ignoreErrors. This is necessary because for some services, HTTP status 404
+// is a valid response from Elasticsearch (e.g. the Exists service).
+//
+// The func tries to parse error details as returned from Elasticsearch
+// and encapsulates them in type elastic.Error.
+func checkResponse(req *http.Request, res *http.Response, ignoreErrors ...int) error {
+	// 200-299 are valid status codes
+	if res.StatusCode >= 200 && res.StatusCode <= 299 {
+		return nil
+	}
+	// Ignore certain errors?
+	for _, code := range ignoreErrors {
+		if code == res.StatusCode {
+			return nil
+		}
+	}
+	return createResponseError(res)
+}
+
+// createResponseError creates an Error structure from the HTTP response,
+// its status code and the error information sent by Elasticsearch.
+func createResponseError(res *http.Response) error {
+	if res.Body == nil {
+		return &Error{Status: res.StatusCode}
+	}
+	data, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return &Error{Status: res.StatusCode}
+	}
+	errReply := new(Error)
+	err = json.Unmarshal(data, errReply)
+	if err != nil {
+		return &Error{Status: res.StatusCode}
+	}
+	if errReply != nil {
+		if errReply.Status == 0 {
+			errReply.Status = res.StatusCode
+		}
+		return errReply
+	}
+	return &Error{Status: res.StatusCode}
+}
+
+// Error encapsulates error details as returned from Elasticsearch.
+type Error struct {
+	Status  int           `json:"status"`
+	Details *ErrorDetails `json:"error,omitempty"`
+}
+
+// ErrorDetails encapsulate error details from Elasticsearch.
+// It is used in e.g. elastic.Error and elastic.BulkResponseItem.
+type ErrorDetails struct {
+	Type         string                   `json:"type"`
+	Reason       string                   `json:"reason"`
+	ResourceType string                   `json:"resource.type,omitempty"`
+	ResourceId   string                   `json:"resource.id,omitempty"`
+	Index        string                   `json:"index,omitempty"`
+	Phase        string                   `json:"phase,omitempty"`
+	Grouped      bool                     `json:"grouped,omitempty"`
+	CausedBy     map[string]interface{}   `json:"caused_by,omitempty"`
+	RootCause    []*ErrorDetails          `json:"root_cause,omitempty"`
+	FailedShards []map[string]interface{} `json:"failed_shards,omitempty"`
+}
+
+// Error returns a string representation of the error.
+func (e *Error) Error() string {
+	if e.Details != nil && e.Details.Reason != "" {
+		return fmt.Sprintf("elastic: Error %d (%s): %s [type=%s]", e.Status, http.StatusText(e.Status), e.Details.Reason, e.Details.Type)
+	} else {
+		return fmt.Sprintf("elastic: Error %d (%s)", e.Status, http.StatusText(e.Status))
+	}
+}
+
+// IsConnErr returns true if the error indicates that Elastic could not
+// find an Elasticsearch host to connect to.
+func IsConnErr(err error) bool {
+	return err == ErrNoClient || errors.Cause(err) == ErrNoClient
+}
+
+// IsNotFound returns true if the given error indicates that Elasticsearch
+// returned HTTP status 404. The err parameter can be of type *elastic.Error,
+// elastic.Error, *http.Response or int (indicating the HTTP status code).
+func IsNotFound(err interface{}) bool {
+	return IsStatusCode(err, http.StatusNotFound)
+}
+
+// IsTimeout returns true if the given error indicates that Elasticsearch
+// returned HTTP status 408. The err parameter can be of type *elastic.Error,
+// elastic.Error, *http.Response or int (indicating the HTTP status code).
+func IsTimeout(err interface{}) bool {
+	return IsStatusCode(err, http.StatusRequestTimeout)
+}
+
+// IsConflict returns true if the given error indicates that the Elasticsearch
+// operation resulted in a version conflict. This can occur in operations like
+// `update` or `index` with `op_type=create`. The err parameter can be of
+// type *elastic.Error, elastic.Error, *http.Response or int (indicating the
+// HTTP status code).
+func IsConflict(err interface{}) bool {
+	return IsStatusCode(err, http.StatusConflict)
+}
+
+// IsStatusCode returns true if the given error indicates that the Elasticsearch
+// operation returned the specified HTTP status code. The err parameter can be of
+// type *http.Response, *Error, Error, or int (indicating the HTTP status code).
+func IsStatusCode(err interface{}, code int) bool {
+	switch e := err.(type) {
+	case *http.Response:
+		return e.StatusCode == code
+	case *Error:
+		return e.Status == code
+	case Error:
+		return e.Status == code
+	case int:
+		return e == code
+	}
+	return false
+}
+
+// -- General errors --
+
+// shardsInfo represents information from a shard.
+type shardsInfo struct {
+	Total      int `json:"total"`
+	Successful int `json:"successful"`
+	Failed     int `json:"failed"`
+}
+
+// shardOperationFailure represents a shard failure.
+type shardOperationFailure struct {
+	Shard  int    `json:"shard"`
+	Index  string `json:"index"`
+	Status string `json:"status"`
+	// "reason"
+}

vendor/github.com/olivere/elastic/exists.go

@@ -0,0 +1,184 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// ExistsService checks for the existence of a document using HEAD.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-get.html
+// for details.
+type ExistsService struct {
+	client     *Client
+	pretty     bool
+	id         string
+	index      string
+	typ        string
+	preference string
+	realtime   *bool
+	refresh    string
+	routing    string
+	parent     string
+}
+
+// NewExistsService creates a new ExistsService.
+func NewExistsService(client *Client) *ExistsService {
+	return &ExistsService{
+		client: client,
+	}
+}
+
+// Id is the document ID.
+func (s *ExistsService) Id(id string) *ExistsService {
+	s.id = id
+	return s
+}
+
+// Index is the name of the index.
+func (s *ExistsService) Index(index string) *ExistsService {
+	s.index = index
+	return s
+}
+
+// Type is the type of the document (use `_all` to fetch the first document
+// matching the ID across all types).
+func (s *ExistsService) Type(typ string) *ExistsService {
+	s.typ = typ
+	return s
+}
+
+// Preference specifies the node or shard the operation should be performed on (default: random).
+func (s *ExistsService) Preference(preference string) *ExistsService {
+	s.preference = preference
+	return s
+}
+
+// Realtime specifies whether to perform the operation in realtime or search mode.
+func (s *ExistsService) Realtime(realtime bool) *ExistsService {
+	s.realtime = &realtime
+	return s
+}
+
+// Refresh the shard containing the document before performing the operation.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-refresh.html
+// for details.
+func (s *ExistsService) Refresh(refresh string) *ExistsService {
+	s.refresh = refresh
+	return s
+}
+
+// Routing is a specific routing value.
+func (s *ExistsService) Routing(routing string) *ExistsService {
+	s.routing = routing
+	return s
+}
+
+// Parent is the ID of the parent document.
+func (s *ExistsService) Parent(parent string) *ExistsService {
+	s.parent = parent
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *ExistsService) Pretty(pretty bool) *ExistsService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *ExistsService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/{type}/{id}", map[string]string{
+		"id":    s.id,
+		"index": s.index,
+		"type":  s.typ,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.realtime != nil {
+		params.Set("realtime", fmt.Sprintf("%v", *s.realtime))
+	}
+	if s.refresh != "" {
+		params.Set("refresh", s.refresh)
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	if s.parent != "" {
+		params.Set("parent", s.parent)
+	}
+	if s.preference != "" {
+		params.Set("preference", s.preference)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *ExistsService) Validate() error {
+	var invalid []string
+	if s.id == "" {
+		invalid = append(invalid, "Id")
+	}
+	if s.index == "" {
+		invalid = append(invalid, "Index")
+	}
+	if s.typ == "" {
+		invalid = append(invalid, "Type")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *ExistsService) Do(ctx context.Context) (bool, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return false, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return false, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method:       "HEAD",
+		Path:         path,
+		Params:       params,
+		IgnoreErrors: []int{404},
+	})
+	if err != nil {
+		return false, err
+	}
+
+	// Return operation response
+	switch res.StatusCode {
+	case http.StatusOK:
+		return true, nil
+	case http.StatusNotFound:
+		return false, nil
+	default:
+		return false, fmt.Errorf("elastic: got HTTP code %d when it should have been either 200 or 404", res.StatusCode)
+	}
+}

vendor/github.com/olivere/elastic/explain.go

@@ -0,0 +1,326 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// ExplainService computes a score explanation for a query and
+// a specific document.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-explain.html.
+type ExplainService struct {
+	client                 *Client
+	pretty                 bool
+	id                     string
+	index                  string
+	typ                    string
+	q                      string
+	routing                string
+	lenient                *bool
+	analyzer               string
+	df                     string
+	fields                 []string
+	lowercaseExpandedTerms *bool
+	xSourceInclude         []string
+	analyzeWildcard        *bool
+	parent                 string
+	preference             string
+	xSource                []string
+	defaultOperator        string
+	xSourceExclude         []string
+	source                 string
+	bodyJson               interface{}
+	bodyString             string
+}
+
+// NewExplainService creates a new ExplainService.
+func NewExplainService(client *Client) *ExplainService {
+	return &ExplainService{
+		client:         client,
+		xSource:        make([]string, 0),
+		xSourceExclude: make([]string, 0),
+		fields:         make([]string, 0),
+		xSourceInclude: make([]string, 0),
+	}
+}
+
+// Id is the document ID.
+func (s *ExplainService) Id(id string) *ExplainService {
+	s.id = id
+	return s
+}
+
+// Index is the name of the index.
+func (s *ExplainService) Index(index string) *ExplainService {
+	s.index = index
+	return s
+}
+
+// Type is the type of the document.
+func (s *ExplainService) Type(typ string) *ExplainService {
+	s.typ = typ
+	return s
+}
+
+// Source is the URL-encoded query definition (instead of using the request body).
+func (s *ExplainService) Source(source string) *ExplainService {
+	s.source = source
+	return s
+}
+
+// XSourceExclude is a list of fields to exclude from the returned _source field.
+func (s *ExplainService) XSourceExclude(xSourceExclude ...string) *ExplainService {
+	s.xSourceExclude = append(s.xSourceExclude, xSourceExclude...)
+	return s
+}
+
+// Lenient specifies whether format-based query failures
+// (such as providing text to a numeric field) should be ignored.
+func (s *ExplainService) Lenient(lenient bool) *ExplainService {
+	s.lenient = &lenient
+	return s
+}
+
+// Query in the Lucene query string syntax.
+func (s *ExplainService) Q(q string) *ExplainService {
+	s.q = q
+	return s
+}
+
+// Routing sets a specific routing value.
+func (s *ExplainService) Routing(routing string) *ExplainService {
+	s.routing = routing
+	return s
+}
+
+// AnalyzeWildcard specifies whether wildcards and prefix queries
+// in the query string query should be analyzed (default: false).
+func (s *ExplainService) AnalyzeWildcard(analyzeWildcard bool) *ExplainService {
+	s.analyzeWildcard = &analyzeWildcard
+	return s
+}
+
+// Analyzer is the analyzer for the query string query.
+func (s *ExplainService) Analyzer(analyzer string) *ExplainService {
+	s.analyzer = analyzer
+	return s
+}
+
+// Df is the default field for query string query (default: _all).
+func (s *ExplainService) Df(df string) *ExplainService {
+	s.df = df
+	return s
+}
+
+// Fields is a list of fields to return in the response.
+func (s *ExplainService) Fields(fields ...string) *ExplainService {
+	s.fields = append(s.fields, fields...)
+	return s
+}
+
+// LowercaseExpandedTerms specifies whether query terms should be lowercased.
+func (s *ExplainService) LowercaseExpandedTerms(lowercaseExpandedTerms bool) *ExplainService {
+	s.lowercaseExpandedTerms = &lowercaseExpandedTerms
+	return s
+}
+
+// XSourceInclude is a list of fields to extract and return from the _source field.
+func (s *ExplainService) XSourceInclude(xSourceInclude ...string) *ExplainService {
+	s.xSourceInclude = append(s.xSourceInclude, xSourceInclude...)
+	return s
+}
+
+// DefaultOperator is the default operator for query string query (AND or OR).
+func (s *ExplainService) DefaultOperator(defaultOperator string) *ExplainService {
+	s.defaultOperator = defaultOperator
+	return s
+}
+
+// Parent is the ID of the parent document.
+func (s *ExplainService) Parent(parent string) *ExplainService {
+	s.parent = parent
+	return s
+}
+
+// Preference specifies the node or shard the operation should be performed on (default: random).
+func (s *ExplainService) Preference(preference string) *ExplainService {
+	s.preference = preference
+	return s
+}
+
+// XSource is true or false to return the _source field or not, or a list of fields to return.
+func (s *ExplainService) XSource(xSource ...string) *ExplainService {
+	s.xSource = append(s.xSource, xSource...)
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *ExplainService) Pretty(pretty bool) *ExplainService {
+	s.pretty = pretty
+	return s
+}
+
+// Query sets a query definition using the Query DSL.
+func (s *ExplainService) Query(query Query) *ExplainService {
+	src, err := query.Source()
+	if err != nil {
+		// Do nothing in case of an error
+		return s
+	}
+	body := make(map[string]interface{})
+	body["query"] = src
+	s.bodyJson = body
+	return s
+}
+
+// BodyJson sets the query definition using the Query DSL.
+func (s *ExplainService) BodyJson(body interface{}) *ExplainService {
+	s.bodyJson = body
+	return s
+}
+
+// BodyString sets the query definition using the Query DSL as a string.
+func (s *ExplainService) BodyString(body string) *ExplainService {
+	s.bodyString = body
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *ExplainService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/{type}/{id}/_explain", map[string]string{
+		"id":    s.id,
+		"index": s.index,
+		"type":  s.typ,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if len(s.xSource) > 0 {
+		params.Set("_source", strings.Join(s.xSource, ","))
+	}
+	if s.defaultOperator != "" {
+		params.Set("default_operator", s.defaultOperator)
+	}
+	if s.parent != "" {
+		params.Set("parent", s.parent)
+	}
+	if s.preference != "" {
+		params.Set("preference", s.preference)
+	}
+	if s.source != "" {
+		params.Set("source", s.source)
+	}
+	if len(s.xSourceExclude) > 0 {
+		params.Set("_source_exclude", strings.Join(s.xSourceExclude, ","))
+	}
+	if s.lenient != nil {
+		params.Set("lenient", fmt.Sprintf("%v", *s.lenient))
+	}
+	if s.q != "" {
+		params.Set("q", s.q)
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	if len(s.fields) > 0 {
+		params.Set("fields", strings.Join(s.fields, ","))
+	}
+	if s.lowercaseExpandedTerms != nil {
+		params.Set("lowercase_expanded_terms", fmt.Sprintf("%v", *s.lowercaseExpandedTerms))
+	}
+	if len(s.xSourceInclude) > 0 {
+		params.Set("_source_include", strings.Join(s.xSourceInclude, ","))
+	}
+	if s.analyzeWildcard != nil {
+		params.Set("analyze_wildcard", fmt.Sprintf("%v", *s.analyzeWildcard))
+	}
+	if s.analyzer != "" {
+		params.Set("analyzer", s.analyzer)
+	}
+	if s.df != "" {
+		params.Set("df", s.df)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *ExplainService) Validate() error {
+	var invalid []string
+	if s.index == "" {
+		invalid = append(invalid, "Index")
+	}
+	if s.typ == "" {
+		invalid = append(invalid, "Type")
+	}
+	if s.id == "" {
+		invalid = append(invalid, "Id")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *ExplainService) Do(ctx context.Context) (*ExplainResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Setup HTTP request body
+	var body interface{}
+	if s.bodyJson != nil {
+		body = s.bodyJson
+	} else {
+		body = s.bodyString
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+		Body:   body,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(ExplainResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// ExplainResponse is the response of ExplainService.Do.
+type ExplainResponse struct {
+	Index       string                 `json:"_index"`
+	Type        string                 `json:"_type"`
+	Id          string                 `json:"_id"`
+	Matched     bool                   `json:"matched"`
+	Explanation map[string]interface{} `json:"explanation"`
+}

vendor/github.com/olivere/elastic/fetch_source_context.go

@@ -0,0 +1,90 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"net/url"
+	"strings"
+)
+
+// FetchSourceContext enables source filtering, i.e. it allows control
+// over how the _source field is returned with every hit. It is used
+// with various endpoints, e.g. when searching for documents, retrieving
+// individual documents, or even updating documents.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-request-source-filtering.html
+// for details.
+type FetchSourceContext struct {
+	fetchSource bool
+	includes    []string
+	excludes    []string
+}
+
+// NewFetchSourceContext returns a new FetchSourceContext.
+func NewFetchSourceContext(fetchSource bool) *FetchSourceContext {
+	return &FetchSourceContext{
+		fetchSource: fetchSource,
+		includes:    make([]string, 0),
+		excludes:    make([]string, 0),
+	}
+}
+
+// FetchSource indicates whether to return the _source.
+func (fsc *FetchSourceContext) FetchSource() bool {
+	return fsc.fetchSource
+}
+
+// SetFetchSource specifies whether to return the _source.
+func (fsc *FetchSourceContext) SetFetchSource(fetchSource bool) {
+	fsc.fetchSource = fetchSource
+}
+
+// Include indicates to return specific parts of the _source.
+// Wildcards are allowed here.
+func (fsc *FetchSourceContext) Include(includes ...string) *FetchSourceContext {
+	fsc.includes = append(fsc.includes, includes...)
+	return fsc
+}
+
+// Exclude indicates to exclude specific parts of the _source.
+// Wildcards are allowed here.
+func (fsc *FetchSourceContext) Exclude(excludes ...string) *FetchSourceContext {
+	fsc.excludes = append(fsc.excludes, excludes...)
+	return fsc
+}
+
+// Source returns the JSON-serializable data to be used in a body.
+func (fsc *FetchSourceContext) Source() (interface{}, error) {
+	if !fsc.fetchSource {
+		return false, nil
+	}
+	if len(fsc.includes) == 0 && len(fsc.excludes) == 0 {
+		return true, nil
+	}
+	src := make(map[string]interface{})
+	if len(fsc.includes) > 0 {
+		src["includes"] = fsc.includes
+	}
+	if len(fsc.excludes) > 0 {
+		src["excludes"] = fsc.excludes
+	}
+	return src, nil
+}
+
+// Query returns the parameters in a form suitable for a URL query string.
+func (fsc *FetchSourceContext) Query() url.Values {
+	params := url.Values{}
+	if fsc.fetchSource {
+		if len(fsc.includes) > 0 {
+			params.Add("_source_include", strings.Join(fsc.includes, ","))
+		}
+		if len(fsc.excludes) > 0 {
+			params.Add("_source_exclude", strings.Join(fsc.excludes, ","))
+		}
+	} else {
+		params.Add("_source", "false")
+	}
+	return params
+}

vendor/github.com/olivere/elastic/field_caps.go

@@ -0,0 +1,202 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// FieldCapsService allows retrieving the capabilities of fields among multiple indices.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-field-caps.html
+// for details
+type FieldCapsService struct {
+	client            *Client
+	pretty            bool
+	index             []string
+	allowNoIndices    *bool
+	expandWildcards   string
+	fields            []string
+	ignoreUnavailable *bool
+	bodyJson          interface{}
+	bodyString        string
+}
+
+// NewFieldCapsService creates a new FieldCapsService
+func NewFieldCapsService(client *Client) *FieldCapsService {
+	return &FieldCapsService{
+		client: client,
+	}
+}
+
+// Index is a list of index names; use `_all` or empty string to perform
+// the operation on all indices.
+func (s *FieldCapsService) Index(index ...string) *FieldCapsService {
+	s.index = append(s.index, index...)
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices expression
+// resolves into no concrete indices.
+// (This includes `_all` string or when no indices have been specified).
+func (s *FieldCapsService) AllowNoIndices(allowNoIndices bool) *FieldCapsService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both.
+func (s *FieldCapsService) ExpandWildcards(expandWildcards string) *FieldCapsService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Fields is a list of fields for to get field capabilities.
+func (s *FieldCapsService) Fields(fields ...string) *FieldCapsService {
+	s.fields = append(s.fields, fields...)
+	return s
+}
+
+// IgnoreUnavailable is documented as: Whether specified concrete indices should be ignored when unavailable (missing or closed).
+func (s *FieldCapsService) IgnoreUnavailable(ignoreUnavailable bool) *FieldCapsService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *FieldCapsService) Pretty(pretty bool) *FieldCapsService {
+	s.pretty = pretty
+	return s
+}
+
+// BodyJson is documented as: Field json objects containing the name and optionally a range to filter out indices result, that have results outside the defined bounds.
+func (s *FieldCapsService) BodyJson(body interface{}) *FieldCapsService {
+	s.bodyJson = body
+	return s
+}
+
+// BodyString is documented as: Field json objects containing the name and optionally a range to filter out indices result, that have results outside the defined bounds.
+func (s *FieldCapsService) BodyString(body string) *FieldCapsService {
+	s.bodyString = body
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *FieldCapsService) buildURL() (string, url.Values, error) {
+	// Build URL
+	var err error
+	var path string
+	if len(s.index) > 0 {
+		path, err = uritemplates.Expand("/{index}/_field_caps", map[string]string{
+			"index": strings.Join(s.index, ","),
+		})
+	} else {
+		path = "/_field_caps"
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if len(s.fields) > 0 {
+		params.Set("fields", strings.Join(s.fields, ","))
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *FieldCapsService) Validate() error {
+	return nil
+}
+
+// Do executes the operation.
+func (s *FieldCapsService) Do(ctx context.Context) (*FieldCapsResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Setup HTTP request body
+	var body interface{}
+	if s.bodyJson != nil {
+		body = s.bodyJson
+	} else {
+		body = s.bodyString
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method:       "POST",
+		Path:         path,
+		Params:       params,
+		Body:         body,
+		IgnoreErrors: []int{http.StatusNotFound},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO(oe): Is 404 really a valid response here?
+	if res.StatusCode == http.StatusNotFound {
+		return &FieldCapsResponse{}, nil
+	}
+
+	// Return operation response
+	ret := new(FieldCapsResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// -- Request --
+
+// FieldCapsRequest can be used to set up the body to be used in the
+// Field Capabilities API.
+type FieldCapsRequest struct {
+	Fields []string `json:"fields"`
+}
+
+// -- Response --
+
+// FieldCapsResponse contains field capabilities.
+type FieldCapsResponse struct {
+	Fields map[string]FieldCaps `json:"fields,omitempty"`
+}
+
+// FieldCaps contains capabilities of an individual field.
+type FieldCaps struct {
+	Type                   string   `json:"type"`
+	Searchable             bool     `json:"searchable"`
+	Aggregatable           bool     `json:"aggregatable"`
+	Indices                []string `json:"indices,omitempty"`
+	NonSearchableIndices   []string `json:"non_searchable_indices,omitempty"`
+	NonAggregatableIndices []string `json:"non_aggregatable_indices,omitempty"`
+}

vendor/github.com/olivere/elastic/geo_point.go

@@ -0,0 +1,48 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// GeoPoint is a geographic position described via latitude and longitude.
+type GeoPoint struct {
+	Lat float64 `json:"lat"`
+	Lon float64 `json:"lon"`
+}
+
+// Source returns the object to be serialized in Elasticsearch DSL.
+func (pt *GeoPoint) Source() map[string]float64 {
+	return map[string]float64{
+		"lat": pt.Lat,
+		"lon": pt.Lon,
+	}
+}
+
+// GeoPointFromLatLon initializes a new GeoPoint by latitude and longitude.
+func GeoPointFromLatLon(lat, lon float64) *GeoPoint {
+	return &GeoPoint{Lat: lat, Lon: lon}
+}
+
+// GeoPointFromString initializes a new GeoPoint by a string that is
+// formatted as "{latitude},{longitude}", e.g. "40.10210,-70.12091".
+func GeoPointFromString(latLon string) (*GeoPoint, error) {
+	latlon := strings.SplitN(latLon, ",", 2)
+	if len(latlon) != 2 {
+		return nil, fmt.Errorf("elastic: %s is not a valid geo point string", latLon)
+	}
+	lat, err := strconv.ParseFloat(latlon[0], 64)
+	if err != nil {
+		return nil, err
+	}
+	lon, err := strconv.ParseFloat(latlon[1], 64)
+	if err != nil {
+		return nil, err
+	}
+	return &GeoPoint{Lat: lat, Lon: lon}, nil
+}

vendor/github.com/olivere/elastic/get.go

@@ -0,0 +1,263 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// GetService allows to get a typed JSON document from the index based
+// on its id.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-get.html
+// for details.
+type GetService struct {
+	client                        *Client
+	pretty                        bool
+	index                         string
+	typ                           string
+	id                            string
+	routing                       string
+	preference                    string
+	storedFields                  []string
+	refresh                       string
+	realtime                      *bool
+	fsc                           *FetchSourceContext
+	version                       interface{}
+	versionType                   string
+	parent                        string
+	ignoreErrorsOnGeneratedFields *bool
+}
+
+// NewGetService creates a new GetService.
+func NewGetService(client *Client) *GetService {
+	return &GetService{
+		client: client,
+		typ:    "_all",
+	}
+}
+
+// Index is the name of the index.
+func (s *GetService) Index(index string) *GetService {
+	s.index = index
+	return s
+}
+
+// Type is the type of the document (use `_all` to fetch the first document
+// matching the ID across all types).
+func (s *GetService) Type(typ string) *GetService {
+	s.typ = typ
+	return s
+}
+
+// Id is the document ID.
+func (s *GetService) Id(id string) *GetService {
+	s.id = id
+	return s
+}
+
+// Parent is the ID of the parent document.
+func (s *GetService) Parent(parent string) *GetService {
+	s.parent = parent
+	return s
+}
+
+// Routing is the specific routing value.
+func (s *GetService) Routing(routing string) *GetService {
+	s.routing = routing
+	return s
+}
+
+// Preference specifies the node or shard the operation should be performed on (default: random).
+func (s *GetService) Preference(preference string) *GetService {
+	s.preference = preference
+	return s
+}
+
+// StoredFields is a list of fields to return in the response.
+func (s *GetService) StoredFields(storedFields ...string) *GetService {
+	s.storedFields = append(s.storedFields, storedFields...)
+	return s
+}
+
+func (s *GetService) FetchSource(fetchSource bool) *GetService {
+	if s.fsc == nil {
+		s.fsc = NewFetchSourceContext(fetchSource)
+	} else {
+		s.fsc.SetFetchSource(fetchSource)
+	}
+	return s
+}
+
+func (s *GetService) FetchSourceContext(fetchSourceContext *FetchSourceContext) *GetService {
+	s.fsc = fetchSourceContext
+	return s
+}
+
+// Refresh the shard containing the document before performing the operation.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-refresh.html
+// for details.
+func (s *GetService) Refresh(refresh string) *GetService {
+	s.refresh = refresh
+	return s
+}
+
+// Realtime specifies whether to perform the operation in realtime or search mode.
+func (s *GetService) Realtime(realtime bool) *GetService {
+	s.realtime = &realtime
+	return s
+}
+
+// VersionType is the specific version type.
+func (s *GetService) VersionType(versionType string) *GetService {
+	s.versionType = versionType
+	return s
+}
+
+// Version is an explicit version number for concurrency control.
+func (s *GetService) Version(version interface{}) *GetService {
+	s.version = version
+	return s
+}
+
+// IgnoreErrorsOnGeneratedFields indicates whether to ignore fields that
+// are generated if the transaction log is accessed.
+func (s *GetService) IgnoreErrorsOnGeneratedFields(ignore bool) *GetService {
+	s.ignoreErrorsOnGeneratedFields = &ignore
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *GetService) Pretty(pretty bool) *GetService {
+	s.pretty = pretty
+	return s
+}
+
+// Validate checks if the operation is valid.
+func (s *GetService) Validate() error {
+	var invalid []string
+	if s.id == "" {
+		invalid = append(invalid, "Id")
+	}
+	if s.index == "" {
+		invalid = append(invalid, "Index")
+	}
+	if s.typ == "" {
+		invalid = append(invalid, "Type")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// buildURL builds the URL for the operation.
+func (s *GetService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/{type}/{id}", map[string]string{
+		"id":    s.id,
+		"index": s.index,
+		"type":  s.typ,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	if s.parent != "" {
+		params.Set("parent", s.parent)
+	}
+	if s.preference != "" {
+		params.Set("preference", s.preference)
+	}
+	if len(s.storedFields) > 0 {
+		params.Set("stored_fields", strings.Join(s.storedFields, ","))
+	}
+	if s.refresh != "" {
+		params.Set("refresh", s.refresh)
+	}
+	if s.version != nil {
+		params.Set("version", fmt.Sprintf("%v", s.version))
+	}
+	if s.versionType != "" {
+		params.Set("version_type", s.versionType)
+	}
+	if s.realtime != nil {
+		params.Set("realtime", fmt.Sprintf("%v", *s.realtime))
+	}
+	if s.ignoreErrorsOnGeneratedFields != nil {
+		params.Add("ignore_errors_on_generated_fields", fmt.Sprintf("%v", *s.ignoreErrorsOnGeneratedFields))
+	}
+	if s.fsc != nil {
+		for k, values := range s.fsc.Query() {
+			params.Add(k, strings.Join(values, ","))
+		}
+	}
+	return path, params, nil
+}
+
+// Do executes the operation.
+func (s *GetService) Do(ctx context.Context) (*GetResult, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(GetResult)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// -- Result of a get request.
+
+// GetResult is the outcome of GetService.Do.
+type GetResult struct {
+	Index   string                 `json:"_index"`   // index meta field
+	Type    string                 `json:"_type"`    // type meta field
+	Id      string                 `json:"_id"`      // id meta field
+	Uid     string                 `json:"_uid"`     // uid meta field (see MapperService.java for all meta fields)
+	Routing string                 `json:"_routing"` // routing meta field
+	Parent  string                 `json:"_parent"`  // parent meta field
+	Version *int64                 `json:"_version"` // version number, when Version is set to true in SearchService
+	Source  *json.RawMessage       `json:"_source,omitempty"`
+	Found   bool                   `json:"found,omitempty"`
+	Fields  map[string]interface{} `json:"fields,omitempty"`
+	//Error     string                 `json:"error,omitempty"` // used only in MultiGet
+	// TODO double-check that MultiGet now returns details error information
+	Error *ErrorDetails `json:"error,omitempty"` // only used in MultiGet
+}

vendor/github.com/olivere/elastic/highlight.go

@@ -0,0 +1,469 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+// Highlight allows highlighting search results on one or more fields.
+// For details, see:
+// https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-request-highlighting.html
+type Highlight struct {
+	fields                []*HighlighterField
+	tagsSchema            *string
+	highlightFilter       *bool
+	fragmentSize          *int
+	numOfFragments        *int
+	preTags               []string
+	postTags              []string
+	order                 *string
+	encoder               *string
+	requireFieldMatch     *bool
+	boundaryMaxScan       *int
+	boundaryChars         *string
+	boundaryScannerType   *string
+	boundaryScannerLocale *string
+	highlighterType       *string
+	fragmenter            *string
+	highlightQuery        Query
+	noMatchSize           *int
+	phraseLimit           *int
+	options               map[string]interface{}
+	forceSource           *bool
+	useExplicitFieldOrder bool
+}
+
+func NewHighlight() *Highlight {
+	hl := &Highlight{
+		options: make(map[string]interface{}),
+	}
+	return hl
+}
+
+func (hl *Highlight) Fields(fields ...*HighlighterField) *Highlight {
+	hl.fields = append(hl.fields, fields...)
+	return hl
+}
+
+func (hl *Highlight) Field(name string) *Highlight {
+	field := NewHighlighterField(name)
+	hl.fields = append(hl.fields, field)
+	return hl
+}
+
+func (hl *Highlight) TagsSchema(schemaName string) *Highlight {
+	hl.tagsSchema = &schemaName
+	return hl
+}
+
+func (hl *Highlight) HighlightFilter(highlightFilter bool) *Highlight {
+	hl.highlightFilter = &highlightFilter
+	return hl
+}
+
+func (hl *Highlight) FragmentSize(fragmentSize int) *Highlight {
+	hl.fragmentSize = &fragmentSize
+	return hl
+}
+
+func (hl *Highlight) NumOfFragments(numOfFragments int) *Highlight {
+	hl.numOfFragments = &numOfFragments
+	return hl
+}
+
+func (hl *Highlight) Encoder(encoder string) *Highlight {
+	hl.encoder = &encoder
+	return hl
+}
+
+func (hl *Highlight) PreTags(preTags ...string) *Highlight {
+	hl.preTags = append(hl.preTags, preTags...)
+	return hl
+}
+
+func (hl *Highlight) PostTags(postTags ...string) *Highlight {
+	hl.postTags = append(hl.postTags, postTags...)
+	return hl
+}
+
+func (hl *Highlight) Order(order string) *Highlight {
+	hl.order = &order
+	return hl
+}
+
+func (hl *Highlight) RequireFieldMatch(requireFieldMatch bool) *Highlight {
+	hl.requireFieldMatch = &requireFieldMatch
+	return hl
+}
+
+func (hl *Highlight) BoundaryMaxScan(boundaryMaxScan int) *Highlight {
+	hl.boundaryMaxScan = &boundaryMaxScan
+	return hl
+}
+
+func (hl *Highlight) BoundaryChars(boundaryChars string) *Highlight {
+	hl.boundaryChars = &boundaryChars
+	return hl
+}
+
+func (hl *Highlight) BoundaryScannerType(boundaryScannerType string) *Highlight {
+	hl.boundaryScannerType = &boundaryScannerType
+	return hl
+}
+
+func (hl *Highlight) BoundaryScannerLocale(boundaryScannerLocale string) *Highlight {
+	hl.boundaryScannerLocale = &boundaryScannerLocale
+	return hl
+}
+
+func (hl *Highlight) HighlighterType(highlighterType string) *Highlight {
+	hl.highlighterType = &highlighterType
+	return hl
+}
+
+func (hl *Highlight) Fragmenter(fragmenter string) *Highlight {
+	hl.fragmenter = &fragmenter
+	return hl
+}
+
+func (hl *Highlight) HighlighQuery(highlightQuery Query) *Highlight {
+	hl.highlightQuery = highlightQuery
+	return hl
+}
+
+func (hl *Highlight) NoMatchSize(noMatchSize int) *Highlight {
+	hl.noMatchSize = &noMatchSize
+	return hl
+}
+
+func (hl *Highlight) Options(options map[string]interface{}) *Highlight {
+	hl.options = options
+	return hl
+}
+
+func (hl *Highlight) ForceSource(forceSource bool) *Highlight {
+	hl.forceSource = &forceSource
+	return hl
+}
+
+func (hl *Highlight) UseExplicitFieldOrder(useExplicitFieldOrder bool) *Highlight {
+	hl.useExplicitFieldOrder = useExplicitFieldOrder
+	return hl
+}
+
+// Creates the query source for the bool query.
+func (hl *Highlight) Source() (interface{}, error) {
+	// Returns the map inside of "highlight":
+	// "highlight":{
+	//   ... this ...
+	// }
+	source := make(map[string]interface{})
+	if hl.tagsSchema != nil {
+		source["tags_schema"] = *hl.tagsSchema
+	}
+	if hl.preTags != nil && len(hl.preTags) > 0 {
+		source["pre_tags"] = hl.preTags
+	}
+	if hl.postTags != nil && len(hl.postTags) > 0 {
+		source["post_tags"] = hl.postTags
+	}
+	if hl.order != nil {
+		source["order"] = *hl.order
+	}
+	if hl.highlightFilter != nil {
+		source["highlight_filter"] = *hl.highlightFilter
+	}
+	if hl.fragmentSize != nil {
+		source["fragment_size"] = *hl.fragmentSize
+	}
+	if hl.numOfFragments != nil {
+		source["number_of_fragments"] = *hl.numOfFragments
+	}
+	if hl.encoder != nil {
+		source["encoder"] = *hl.encoder
+	}
+	if hl.requireFieldMatch != nil {
+		source["require_field_match"] = *hl.requireFieldMatch
+	}
+	if hl.boundaryMaxScan != nil {
+		source["boundary_max_scan"] = *hl.boundaryMaxScan
+	}
+	if hl.boundaryChars != nil {
+		source["boundary_chars"] = *hl.boundaryChars
+	}
+	if hl.boundaryScannerType != nil {
+		source["boundary_scanner"] = *hl.boundaryScannerType
+	}
+	if hl.boundaryScannerLocale != nil {
+		source["boundary_scanner_locale"] = *hl.boundaryScannerLocale
+	}
+	if hl.highlighterType != nil {
+		source["type"] = *hl.highlighterType
+	}
+	if hl.fragmenter != nil {
+		source["fragmenter"] = *hl.fragmenter
+	}
+	if hl.highlightQuery != nil {
+		src, err := hl.highlightQuery.Source()
+		if err != nil {
+			return nil, err
+		}
+		source["highlight_query"] = src
+	}
+	if hl.noMatchSize != nil {
+		source["no_match_size"] = *hl.noMatchSize
+	}
+	if hl.phraseLimit != nil {
+		source["phrase_limit"] = *hl.phraseLimit
+	}
+	if hl.options != nil && len(hl.options) > 0 {
+		source["options"] = hl.options
+	}
+	if hl.forceSource != nil {
+		source["force_source"] = *hl.forceSource
+	}
+
+	if hl.fields != nil && len(hl.fields) > 0 {
+		if hl.useExplicitFieldOrder {
+			// Use a slice for the fields
+			var fields []map[string]interface{}
+			for _, field := range hl.fields {
+				src, err := field.Source()
+				if err != nil {
+					return nil, err
+				}
+				fmap := make(map[string]interface{})
+				fmap[field.Name] = src
+				fields = append(fields, fmap)
+			}
+			source["fields"] = fields
+		} else {
+			// Use a map for the fields
+			fields := make(map[string]interface{}, 0)
+			for _, field := range hl.fields {
+				src, err := field.Source()
+				if err != nil {
+					return nil, err
+				}
+				fields[field.Name] = src
+			}
+			source["fields"] = fields
+		}
+	}
+
+	return source, nil
+}
+
+// HighlighterField specifies a highlighted field.
+type HighlighterField struct {
+	Name string
+
+	preTags           []string
+	postTags          []string
+	fragmentSize      int
+	fragmentOffset    int
+	numOfFragments    int
+	highlightFilter   *bool
+	order             *string
+	requireFieldMatch *bool
+	boundaryMaxScan   int
+	boundaryChars     []rune
+	highlighterType   *string
+	fragmenter        *string
+	highlightQuery    Query
+	noMatchSize       *int
+	matchedFields     []string
+	phraseLimit       *int
+	options           map[string]interface{}
+	forceSource       *bool
+
+	/*
+		Name              string
+		preTags           []string
+		postTags          []string
+		fragmentSize      int
+		numOfFragments    int
+		fragmentOffset    int
+		highlightFilter   *bool
+		order             string
+		requireFieldMatch *bool
+		boundaryMaxScan   int
+		boundaryChars     []rune
+		highlighterType   string
+		fragmenter        string
+		highlightQuery    Query
+		noMatchSize       *int
+		matchedFields     []string
+		options           map[string]interface{}
+		forceSource       *bool
+	*/
+}
+
+func NewHighlighterField(name string) *HighlighterField {
+	return &HighlighterField{
+		Name:            name,
+		preTags:         make([]string, 0),
+		postTags:        make([]string, 0),
+		fragmentSize:    -1,
+		fragmentOffset:  -1,
+		numOfFragments:  -1,
+		boundaryMaxScan: -1,
+		boundaryChars:   make([]rune, 0),
+		matchedFields:   make([]string, 0),
+		options:         make(map[string]interface{}),
+	}
+}
+
+func (f *HighlighterField) PreTags(preTags ...string) *HighlighterField {
+	f.preTags = append(f.preTags, preTags...)
+	return f
+}
+
+func (f *HighlighterField) PostTags(postTags ...string) *HighlighterField {
+	f.postTags = append(f.postTags, postTags...)
+	return f
+}
+
+func (f *HighlighterField) FragmentSize(fragmentSize int) *HighlighterField {
+	f.fragmentSize = fragmentSize
+	return f
+}
+
+func (f *HighlighterField) FragmentOffset(fragmentOffset int) *HighlighterField {
+	f.fragmentOffset = fragmentOffset
+	return f
+}
+
+func (f *HighlighterField) NumOfFragments(numOfFragments int) *HighlighterField {
+	f.numOfFragments = numOfFragments
+	return f
+}
+
+func (f *HighlighterField) HighlightFilter(highlightFilter bool) *HighlighterField {
+	f.highlightFilter = &highlightFilter
+	return f
+}
+
+func (f *HighlighterField) Order(order string) *HighlighterField {
+	f.order = &order
+	return f
+}
+
+func (f *HighlighterField) RequireFieldMatch(requireFieldMatch bool) *HighlighterField {
+	f.requireFieldMatch = &requireFieldMatch
+	return f
+}
+
+func (f *HighlighterField) BoundaryMaxScan(boundaryMaxScan int) *HighlighterField {
+	f.boundaryMaxScan = boundaryMaxScan
+	return f
+}
+
+func (f *HighlighterField) BoundaryChars(boundaryChars ...rune) *HighlighterField {
+	f.boundaryChars = append(f.boundaryChars, boundaryChars...)
+	return f
+}
+
+func (f *HighlighterField) HighlighterType(highlighterType string) *HighlighterField {
+	f.highlighterType = &highlighterType
+	return f
+}
+
+func (f *HighlighterField) Fragmenter(fragmenter string) *HighlighterField {
+	f.fragmenter = &fragmenter
+	return f
+}
+
+func (f *HighlighterField) HighlightQuery(highlightQuery Query) *HighlighterField {
+	f.highlightQuery = highlightQuery
+	return f
+}
+
+func (f *HighlighterField) NoMatchSize(noMatchSize int) *HighlighterField {
+	f.noMatchSize = &noMatchSize
+	return f
+}
+
+func (f *HighlighterField) Options(options map[string]interface{}) *HighlighterField {
+	f.options = options
+	return f
+}
+
+func (f *HighlighterField) MatchedFields(matchedFields ...string) *HighlighterField {
+	f.matchedFields = append(f.matchedFields, matchedFields...)
+	return f
+}
+
+func (f *HighlighterField) PhraseLimit(phraseLimit int) *HighlighterField {
+	f.phraseLimit = &phraseLimit
+	return f
+}
+
+func (f *HighlighterField) ForceSource(forceSource bool) *HighlighterField {
+	f.forceSource = &forceSource
+	return f
+}
+
+func (f *HighlighterField) Source() (interface{}, error) {
+	source := make(map[string]interface{})
+
+	if f.preTags != nil && len(f.preTags) > 0 {
+		source["pre_tags"] = f.preTags
+	}
+	if f.postTags != nil && len(f.postTags) > 0 {
+		source["post_tags"] = f.postTags
+	}
+	if f.fragmentSize != -1 {
+		source["fragment_size"] = f.fragmentSize
+	}
+	if f.numOfFragments != -1 {
+		source["number_of_fragments"] = f.numOfFragments
+	}
+	if f.fragmentOffset != -1 {
+		source["fragment_offset"] = f.fragmentOffset
+	}
+	if f.highlightFilter != nil {
+		source["highlight_filter"] = *f.highlightFilter
+	}
+	if f.order != nil {
+		source["order"] = *f.order
+	}
+	if f.requireFieldMatch != nil {
+		source["require_field_match"] = *f.requireFieldMatch
+	}
+	if f.boundaryMaxScan != -1 {
+		source["boundary_max_scan"] = f.boundaryMaxScan
+	}
+	if f.boundaryChars != nil && len(f.boundaryChars) > 0 {
+		source["boundary_chars"] = f.boundaryChars
+	}
+	if f.highlighterType != nil {
+		source["type"] = *f.highlighterType
+	}
+	if f.fragmenter != nil {
+		source["fragmenter"] = *f.fragmenter
+	}
+	if f.highlightQuery != nil {
+		src, err := f.highlightQuery.Source()
+		if err != nil {
+			return nil, err
+		}
+		source["highlight_query"] = src
+	}
+	if f.noMatchSize != nil {
+		source["no_match_size"] = *f.noMatchSize
+	}
+	if f.matchedFields != nil && len(f.matchedFields) > 0 {
+		source["matched_fields"] = f.matchedFields
+	}
+	if f.phraseLimit != nil {
+		source["phrase_limit"] = *f.phraseLimit
+	}
+	if f.options != nil && len(f.options) > 0 {
+		source["options"] = f.options
+	}
+	if f.forceSource != nil {
+		source["force_source"] = *f.forceSource
+	}
+
+	return source, nil
+}

vendor/github.com/olivere/elastic/index.go

@@ -0,0 +1,300 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndexService adds or updates a typed JSON document in a specified index,
+// making it searchable.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-index_.html
+// for details.
+type IndexService struct {
+	client              *Client
+	pretty              bool
+	id                  string
+	index               string
+	typ                 string
+	parent              string
+	routing             string
+	timeout             string
+	timestamp           string
+	ttl                 string
+	version             interface{}
+	opType              string
+	versionType         string
+	refresh             string
+	waitForActiveShards string
+	pipeline            string
+	bodyJson            interface{}
+	bodyString          string
+}
+
+// NewIndexService creates a new IndexService.
+func NewIndexService(client *Client) *IndexService {
+	return &IndexService{
+		client: client,
+	}
+}
+
+// Id is the document ID.
+func (s *IndexService) Id(id string) *IndexService {
+	s.id = id
+	return s
+}
+
+// Index is the name of the index.
+func (s *IndexService) Index(index string) *IndexService {
+	s.index = index
+	return s
+}
+
+// Type is the type of the document.
+func (s *IndexService) Type(typ string) *IndexService {
+	s.typ = typ
+	return s
+}
+
+// WaitForActiveShards sets the number of shard copies that must be active
+// before proceeding with the index operation. Defaults to 1, meaning the
+// primary shard only. Set to `all` for all shard copies, otherwise set to
+// any non-negative value less than or equal to the total number of copies
+// for the shard (number of replicas + 1).
+func (s *IndexService) WaitForActiveShards(waitForActiveShards string) *IndexService {
+	s.waitForActiveShards = waitForActiveShards
+	return s
+}
+
+// Pipeline specifies the pipeline id to preprocess incoming documents with.
+func (s *IndexService) Pipeline(pipeline string) *IndexService {
+	s.pipeline = pipeline
+	return s
+}
+
+// Refresh the index after performing the operation.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-refresh.html
+// for details.
+func (s *IndexService) Refresh(refresh string) *IndexService {
+	s.refresh = refresh
+	return s
+}
+
+// Ttl is an expiration time for the document.
+func (s *IndexService) Ttl(ttl string) *IndexService {
+	s.ttl = ttl
+	return s
+}
+
+// TTL is an expiration time for the document (alias for Ttl).
+func (s *IndexService) TTL(ttl string) *IndexService {
+	s.ttl = ttl
+	return s
+}
+
+// Version is an explicit version number for concurrency control.
+func (s *IndexService) Version(version interface{}) *IndexService {
+	s.version = version
+	return s
+}
+
+// OpType is an explicit operation type, i.e. "create" or "index" (default).
+func (s *IndexService) OpType(opType string) *IndexService {
+	s.opType = opType
+	return s
+}
+
+// Parent is the ID of the parent document.
+func (s *IndexService) Parent(parent string) *IndexService {
+	s.parent = parent
+	return s
+}
+
+// Routing is a specific routing value.
+func (s *IndexService) Routing(routing string) *IndexService {
+	s.routing = routing
+	return s
+}
+
+// Timeout is an explicit operation timeout.
+func (s *IndexService) Timeout(timeout string) *IndexService {
+	s.timeout = timeout
+	return s
+}
+
+// Timestamp is an explicit timestamp for the document.
+func (s *IndexService) Timestamp(timestamp string) *IndexService {
+	s.timestamp = timestamp
+	return s
+}
+
+// VersionType is a specific version type.
+func (s *IndexService) VersionType(versionType string) *IndexService {
+	s.versionType = versionType
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndexService) Pretty(pretty bool) *IndexService {
+	s.pretty = pretty
+	return s
+}
+
+// BodyJson is the document as a serializable JSON interface.
+func (s *IndexService) BodyJson(body interface{}) *IndexService {
+	s.bodyJson = body
+	return s
+}
+
+// BodyString is the document encoded as a string.
+func (s *IndexService) BodyString(body string) *IndexService {
+	s.bodyString = body
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndexService) buildURL() (string, string, url.Values, error) {
+	var err error
+	var method, path string
+
+	if s.id != "" {
+		// Create document with manual id
+		method = "PUT"
+		path, err = uritemplates.Expand("/{index}/{type}/{id}", map[string]string{
+			"id":    s.id,
+			"index": s.index,
+			"type":  s.typ,
+		})
+	} else {
+		// Automatic ID generation
+		// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-index_.html#index-creation
+		method = "POST"
+		path, err = uritemplates.Expand("/{index}/{type}/", map[string]string{
+			"index": s.index,
+			"type":  s.typ,
+		})
+	}
+	if err != nil {
+		return "", "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.waitForActiveShards != "" {
+		params.Set("wait_for_active_shards", s.waitForActiveShards)
+	}
+	if s.refresh != "" {
+		params.Set("refresh", s.refresh)
+	}
+	if s.opType != "" {
+		params.Set("op_type", s.opType)
+	}
+	if s.parent != "" {
+		params.Set("parent", s.parent)
+	}
+	if s.pipeline != "" {
+		params.Set("pipeline", s.pipeline)
+	}
+	if s.routing != "" {
+		params.Set("routing", s.routing)
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.timestamp != "" {
+		params.Set("timestamp", s.timestamp)
+	}
+	if s.ttl != "" {
+		params.Set("ttl", s.ttl)
+	}
+	if s.version != nil {
+		params.Set("version", fmt.Sprintf("%v", s.version))
+	}
+	if s.versionType != "" {
+		params.Set("version_type", s.versionType)
+	}
+	return method, path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndexService) Validate() error {
+	var invalid []string
+	if s.index == "" {
+		invalid = append(invalid, "Index")
+	}
+	if s.typ == "" {
+		invalid = append(invalid, "Type")
+	}
+	if s.bodyString == "" && s.bodyJson == nil {
+		invalid = append(invalid, "BodyJson")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndexService) Do(ctx context.Context) (*IndexResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	method, path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Setup HTTP request body
+	var body interface{}
+	if s.bodyJson != nil {
+		body = s.bodyJson
+	} else {
+		body = s.bodyString
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: method,
+		Path:   path,
+		Params: params,
+		Body:   body,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(IndexResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// IndexResponse is the result of indexing a document in Elasticsearch.
+type IndexResponse struct {
+	Index         string      `json:"_index,omitempty"`
+	Type          string      `json:"_type,omitempty"`
+	Id            string      `json:"_id,omitempty"`
+	Version       int64       `json:"_version,omitempty"`
+	Result        string      `json:"result,omitempty"`
+	Shards        *shardsInfo `json:"_shards,omitempty"`
+	SeqNo         int64       `json:"_seq_no,omitempty"`
+	PrimaryTerm   int64       `json:"_primary_term,omitempty"`
+	Status        int         `json:"status,omitempty"`
+	ForcedRefresh bool        `json:"forced_refresh,omitempty"`
+}

vendor/github.com/olivere/elastic/indices_analyze.go

@@ -0,0 +1,284 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesAnalyzeService performs the analysis process on a text and returns
+// the tokens breakdown of the text.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-analyze.html
+// for detail.
+type IndicesAnalyzeService struct {
+	client      *Client
+	pretty      bool
+	index       string
+	request     *IndicesAnalyzeRequest
+	format      string
+	preferLocal *bool
+	bodyJson    interface{}
+	bodyString  string
+}
+
+// NewIndicesAnalyzeService creates a new IndicesAnalyzeService.
+func NewIndicesAnalyzeService(client *Client) *IndicesAnalyzeService {
+	return &IndicesAnalyzeService{
+		client:  client,
+		request: new(IndicesAnalyzeRequest),
+	}
+}
+
+// Index is the name of the index to scope the operation.
+func (s *IndicesAnalyzeService) Index(index string) *IndicesAnalyzeService {
+	s.index = index
+	return s
+}
+
+// Format of the output.
+func (s *IndicesAnalyzeService) Format(format string) *IndicesAnalyzeService {
+	s.format = format
+	return s
+}
+
+// PreferLocal, when true, specifies that a local shard should be used
+// if available. When false, a random shard is used (default: true).
+func (s *IndicesAnalyzeService) PreferLocal(preferLocal bool) *IndicesAnalyzeService {
+	s.preferLocal = &preferLocal
+	return s
+}
+
+// Request passes the analyze request to use.
+func (s *IndicesAnalyzeService) Request(request *IndicesAnalyzeRequest) *IndicesAnalyzeService {
+	if request == nil {
+		s.request = new(IndicesAnalyzeRequest)
+	} else {
+		s.request = request
+	}
+	return s
+}
+
+// Analyzer is the name of the analyzer to use.
+func (s *IndicesAnalyzeService) Analyzer(analyzer string) *IndicesAnalyzeService {
+	s.request.Analyzer = analyzer
+	return s
+}
+
+// Attributes is a list of token attributes to output; this parameter works
+// only with explain=true.
+func (s *IndicesAnalyzeService) Attributes(attributes ...string) *IndicesAnalyzeService {
+	s.request.Attributes = attributes
+	return s
+}
+
+// CharFilter is a list of character filters to use for the analysis.
+func (s *IndicesAnalyzeService) CharFilter(charFilter ...string) *IndicesAnalyzeService {
+	s.request.CharFilter = charFilter
+	return s
+}
+
+// Explain, when true, outputs more advanced details (default: false).
+func (s *IndicesAnalyzeService) Explain(explain bool) *IndicesAnalyzeService {
+	s.request.Explain = explain
+	return s
+}
+
+// Field specifies to use a specific analyzer configured for this field (instead of passing the analyzer name).
+func (s *IndicesAnalyzeService) Field(field string) *IndicesAnalyzeService {
+	s.request.Field = field
+	return s
+}
+
+// Filter is a list of filters to use for the analysis.
+func (s *IndicesAnalyzeService) Filter(filter ...string) *IndicesAnalyzeService {
+	s.request.Filter = filter
+	return s
+}
+
+// Text is the text on which the analysis should be performed (when request body is not used).
+func (s *IndicesAnalyzeService) Text(text ...string) *IndicesAnalyzeService {
+	s.request.Text = text
+	return s
+}
+
+// Tokenizer is the name of the tokenizer to use for the analysis.
+func (s *IndicesAnalyzeService) Tokenizer(tokenizer string) *IndicesAnalyzeService {
+	s.request.Tokenizer = tokenizer
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesAnalyzeService) Pretty(pretty bool) *IndicesAnalyzeService {
+	s.pretty = pretty
+	return s
+}
+
+// BodyJson is the text on which the analysis should be performed.
+func (s *IndicesAnalyzeService) BodyJson(body interface{}) *IndicesAnalyzeService {
+	s.bodyJson = body
+	return s
+}
+
+// BodyString is the text on which the analysis should be performed.
+func (s *IndicesAnalyzeService) BodyString(body string) *IndicesAnalyzeService {
+	s.bodyString = body
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesAnalyzeService) buildURL() (string, url.Values, error) {
+	// Build URL
+	var err error
+	var path string
+
+	if s.index == "" {
+		path = "/_analyze"
+	} else {
+		path, err = uritemplates.Expand("/{index}/_analyze", map[string]string{
+			"index": s.index,
+		})
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.format != "" {
+		params.Set("format", s.format)
+	}
+	if s.preferLocal != nil {
+		params.Set("prefer_local", fmt.Sprintf("%v", *s.preferLocal))
+	}
+
+	return path, params, nil
+}
+
+// Do will execute the request with the given context.
+func (s *IndicesAnalyzeService) Do(ctx context.Context) (*IndicesAnalyzeResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Setup HTTP request body
+	var body interface{}
+	if s.bodyJson != nil {
+		body = s.bodyJson
+	} else if s.bodyString != "" {
+		body = s.bodyString
+	} else {
+		// Request parameters are deprecated in 5.1.1, and we must use a JSON
+		// structure in the body to pass the parameters.
+		// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-analyze.html
+		body = s.request
+	}
+
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "POST",
+		Path:   path,
+		Params: params,
+		Body:   body,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	ret := new(IndicesAnalyzeResponse)
+	if err = s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+
+	return ret, nil
+}
+
+func (s *IndicesAnalyzeService) Validate() error {
+	var invalid []string
+	if s.bodyJson == nil && s.bodyString == "" {
+		if len(s.request.Text) == 0 {
+			invalid = append(invalid, "Text")
+		}
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// IndicesAnalyzeRequest specifies the parameters of the analyze request.
+type IndicesAnalyzeRequest struct {
+	Text       []string `json:"text,omitempty"`
+	Analyzer   string   `json:"analyzer,omitempty"`
+	Tokenizer  string   `json:"tokenizer,omitempty"`
+	Filter     []string `json:"filter,omitempty"`
+	CharFilter []string `json:"char_filter,omitempty"`
+	Field      string   `json:"field,omitempty"`
+	Explain    bool     `json:"explain,omitempty"`
+	Attributes []string `json:"attributes,omitempty"`
+}
+
+type IndicesAnalyzeResponse struct {
+	Tokens []IndicesAnalyzeResponseToken `json:"tokens"` // json part for normal message
+	Detail IndicesAnalyzeResponseDetail  `json:"detail"` // json part for verbose message of explain request
+}
+
+type IndicesAnalyzeResponseToken struct {
+	Token       string `json:"token"`
+	StartOffset int    `json:"start_offset"`
+	EndOffset   int    `json:"end_offset"`
+	Type        string `json:"type"`
+	Position    int    `json:"position"`
+}
+
+type IndicesAnalyzeResponseDetail struct {
+	CustomAnalyzer bool          `json:"custom_analyzer"`
+	Charfilters    []interface{} `json:"charfilters"`
+	Analyzer       struct {
+		Name   string `json:"name"`
+		Tokens []struct {
+			Token          string `json:"token"`
+			StartOffset    int    `json:"start_offset"`
+			EndOffset      int    `json:"end_offset"`
+			Type           string `json:"type"`
+			Position       int    `json:"position"`
+			Bytes          string `json:"bytes"`
+			PositionLength int    `json:"positionLength"`
+		} `json:"tokens"`
+	} `json:"analyzer"`
+	Tokenizer struct {
+		Name   string `json:"name"`
+		Tokens []struct {
+			Token       string `json:"token"`
+			StartOffset int    `json:"start_offset"`
+			EndOffset   int    `json:"end_offset"`
+			Type        string `json:"type"`
+			Position    int    `json:"position"`
+		} `json:"tokens"`
+	} `json:"tokenizer"`
+	Tokenfilters []struct {
+		Name   string `json:"name"`
+		Tokens []struct {
+			Token       string `json:"token"`
+			StartOffset int    `json:"start_offset"`
+			EndOffset   int    `json:"end_offset"`
+			Type        string `json:"type"`
+			Position    int    `json:"position"`
+			Keyword     bool   `json:"keyword"`
+		} `json:"tokens"`
+	} `json:"tokenfilters"`
+}

vendor/github.com/olivere/elastic/indices_close.go

@@ -0,0 +1,159 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesCloseService closes an index.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-open-close.html
+// for details.
+type IndicesCloseService struct {
+	client            *Client
+	pretty            bool
+	index             string
+	timeout           string
+	masterTimeout     string
+	ignoreUnavailable *bool
+	allowNoIndices    *bool
+	expandWildcards   string
+}
+
+// NewIndicesCloseService creates and initializes a new IndicesCloseService.
+func NewIndicesCloseService(client *Client) *IndicesCloseService {
+	return &IndicesCloseService{client: client}
+}
+
+// Index is the name of the index to close.
+func (s *IndicesCloseService) Index(index string) *IndicesCloseService {
+	s.index = index
+	return s
+}
+
+// Timeout is an explicit operation timeout.
+func (s *IndicesCloseService) Timeout(timeout string) *IndicesCloseService {
+	s.timeout = timeout
+	return s
+}
+
+// MasterTimeout specifies the timeout for connection to master.
+func (s *IndicesCloseService) MasterTimeout(masterTimeout string) *IndicesCloseService {
+	s.masterTimeout = masterTimeout
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *IndicesCloseService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesCloseService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified).
+func (s *IndicesCloseService) AllowNoIndices(allowNoIndices bool) *IndicesCloseService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both.
+func (s *IndicesCloseService) ExpandWildcards(expandWildcards string) *IndicesCloseService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesCloseService) Pretty(pretty bool) *IndicesCloseService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesCloseService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/_close", map[string]string{
+		"index": s.index,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.masterTimeout != "" {
+		params.Set("master_timeout", s.masterTimeout)
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesCloseService) Validate() error {
+	var invalid []string
+	if s.index == "" {
+		invalid = append(invalid, "Index")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesCloseService) Do(ctx context.Context) (*IndicesCloseResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "POST",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(IndicesCloseResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// IndicesCloseResponse is the response of IndicesCloseService.Do.
+type IndicesCloseResponse struct {
+	Acknowledged       bool   `json:"acknowledged"`
+	ShardsAcknowledged bool   `json:"shards_acknowledged"`
+	Index              string `json:"index,omitempty"`
+}

vendor/github.com/olivere/elastic/indices_create.go

@@ -0,0 +1,136 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"errors"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesCreateService creates a new index.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-create-index.html
+// for details.
+type IndicesCreateService struct {
+	client        *Client
+	pretty        bool
+	index         string
+	timeout       string
+	masterTimeout string
+	bodyJson      interface{}
+	bodyString    string
+}
+
+// NewIndicesCreateService returns a new IndicesCreateService.
+func NewIndicesCreateService(client *Client) *IndicesCreateService {
+	return &IndicesCreateService{client: client}
+}
+
+// Index is the name of the index to create.
+func (b *IndicesCreateService) Index(index string) *IndicesCreateService {
+	b.index = index
+	return b
+}
+
+// Timeout the explicit operation timeout, e.g. "5s".
+func (s *IndicesCreateService) Timeout(timeout string) *IndicesCreateService {
+	s.timeout = timeout
+	return s
+}
+
+// MasterTimeout specifies the timeout for connection to master.
+func (s *IndicesCreateService) MasterTimeout(masterTimeout string) *IndicesCreateService {
+	s.masterTimeout = masterTimeout
+	return s
+}
+
+// Body specifies the configuration of the index as a string.
+// It is an alias for BodyString.
+func (b *IndicesCreateService) Body(body string) *IndicesCreateService {
+	b.bodyString = body
+	return b
+}
+
+// BodyString specifies the configuration of the index as a string.
+func (b *IndicesCreateService) BodyString(body string) *IndicesCreateService {
+	b.bodyString = body
+	return b
+}
+
+// BodyJson specifies the configuration of the index. The interface{} will
+// be serializes as a JSON document, so use a map[string]interface{}.
+func (b *IndicesCreateService) BodyJson(body interface{}) *IndicesCreateService {
+	b.bodyJson = body
+	return b
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (b *IndicesCreateService) Pretty(pretty bool) *IndicesCreateService {
+	b.pretty = pretty
+	return b
+}
+
+// Do executes the operation.
+func (b *IndicesCreateService) Do(ctx context.Context) (*IndicesCreateResult, error) {
+	if b.index == "" {
+		return nil, errors.New("missing index name")
+	}
+
+	// Build url
+	path, err := uritemplates.Expand("/{index}", map[string]string{
+		"index": b.index,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	params := make(url.Values)
+	if b.pretty {
+		params.Set("pretty", "true")
+	}
+	if b.masterTimeout != "" {
+		params.Set("master_timeout", b.masterTimeout)
+	}
+	if b.timeout != "" {
+		params.Set("timeout", b.timeout)
+	}
+
+	// Setup HTTP request body
+	var body interface{}
+	if b.bodyJson != nil {
+		body = b.bodyJson
+	} else {
+		body = b.bodyString
+	}
+
+	// Get response
+	res, err := b.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "PUT",
+		Path:   path,
+		Params: params,
+		Body:   body,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	ret := new(IndicesCreateResult)
+	if err := b.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// -- Result of a create index request.
+
+// IndicesCreateResult is the outcome of creating a new index.
+type IndicesCreateResult struct {
+	Acknowledged       bool   `json:"acknowledged"`
+	ShardsAcknowledged bool   `json:"shards_acknowledged"`
+	Index              string `json:"index,omitempty"`
+}

vendor/github.com/olivere/elastic/indices_delete.go

@@ -0,0 +1,133 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesDeleteService allows to delete existing indices.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-delete-index.html
+// for details.
+type IndicesDeleteService struct {
+	client        *Client
+	pretty        bool
+	index         []string
+	timeout       string
+	masterTimeout string
+}
+
+// NewIndicesDeleteService creates and initializes a new IndicesDeleteService.
+func NewIndicesDeleteService(client *Client) *IndicesDeleteService {
+	return &IndicesDeleteService{
+		client: client,
+		index:  make([]string, 0),
+	}
+}
+
+// Index adds the list of indices to delete.
+// Use `_all` or `*` string to delete all indices.
+func (s *IndicesDeleteService) Index(index []string) *IndicesDeleteService {
+	s.index = index
+	return s
+}
+
+// Timeout is an explicit operation timeout.
+func (s *IndicesDeleteService) Timeout(timeout string) *IndicesDeleteService {
+	s.timeout = timeout
+	return s
+}
+
+// MasterTimeout specifies the timeout for connection to master.
+func (s *IndicesDeleteService) MasterTimeout(masterTimeout string) *IndicesDeleteService {
+	s.masterTimeout = masterTimeout
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesDeleteService) Pretty(pretty bool) *IndicesDeleteService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesDeleteService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}", map[string]string{
+		"index": strings.Join(s.index, ","),
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.masterTimeout != "" {
+		params.Set("master_timeout", s.masterTimeout)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesDeleteService) Validate() error {
+	var invalid []string
+	if len(s.index) == 0 {
+		invalid = append(invalid, "Index")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesDeleteService) Do(ctx context.Context) (*IndicesDeleteResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "DELETE",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(IndicesDeleteResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// -- Result of a delete index request.
+
+// IndicesDeleteResponse is the response of IndicesDeleteService.Do.
+type IndicesDeleteResponse struct {
+	Acknowledged bool `json:"acknowledged"`
+}

vendor/github.com/olivere/elastic/indices_delete_template.go

@@ -0,0 +1,128 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesDeleteTemplateService deletes index templates.
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-templates.html.
+type IndicesDeleteTemplateService struct {
+	client        *Client
+	pretty        bool
+	name          string
+	timeout       string
+	masterTimeout string
+}
+
+// NewIndicesDeleteTemplateService creates a new IndicesDeleteTemplateService.
+func NewIndicesDeleteTemplateService(client *Client) *IndicesDeleteTemplateService {
+	return &IndicesDeleteTemplateService{
+		client: client,
+	}
+}
+
+// Name is the name of the template.
+func (s *IndicesDeleteTemplateService) Name(name string) *IndicesDeleteTemplateService {
+	s.name = name
+	return s
+}
+
+// Timeout is an explicit operation timeout.
+func (s *IndicesDeleteTemplateService) Timeout(timeout string) *IndicesDeleteTemplateService {
+	s.timeout = timeout
+	return s
+}
+
+// MasterTimeout specifies the timeout for connection to master.
+func (s *IndicesDeleteTemplateService) MasterTimeout(masterTimeout string) *IndicesDeleteTemplateService {
+	s.masterTimeout = masterTimeout
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesDeleteTemplateService) Pretty(pretty bool) *IndicesDeleteTemplateService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesDeleteTemplateService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/_template/{name}", map[string]string{
+		"name": s.name,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.timeout != "" {
+		params.Set("timeout", s.timeout)
+	}
+	if s.masterTimeout != "" {
+		params.Set("master_timeout", s.masterTimeout)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesDeleteTemplateService) Validate() error {
+	var invalid []string
+	if s.name == "" {
+		invalid = append(invalid, "Name")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesDeleteTemplateService) Do(ctx context.Context) (*IndicesDeleteTemplateResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "DELETE",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(IndicesDeleteTemplateResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// IndicesDeleteTemplateResponse is the response of IndicesDeleteTemplateService.Do.
+type IndicesDeleteTemplateResponse struct {
+	Acknowledged       bool   `json:"acknowledged"`
+	ShardsAcknowledged bool   `json:"shards_acknowledged"`
+	Index              string `json:"index,omitempty"`
+}

vendor/github.com/olivere/elastic/indices_exists.go

@@ -0,0 +1,155 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesExistsService checks if an index or indices exist or not.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-exists.html
+// for details.
+type IndicesExistsService struct {
+	client            *Client
+	pretty            bool
+	index             []string
+	ignoreUnavailable *bool
+	allowNoIndices    *bool
+	expandWildcards   string
+	local             *bool
+}
+
+// NewIndicesExistsService creates and initializes a new IndicesExistsService.
+func NewIndicesExistsService(client *Client) *IndicesExistsService {
+	return &IndicesExistsService{
+		client: client,
+		index:  make([]string, 0),
+	}
+}
+
+// Index is a list of one or more indices to check.
+func (s *IndicesExistsService) Index(index []string) *IndicesExistsService {
+	s.index = index
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices expression
+// resolves into no concrete indices. (This includes `_all` string or
+// when no indices have been specified).
+func (s *IndicesExistsService) AllowNoIndices(allowNoIndices bool) *IndicesExistsService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both.
+func (s *IndicesExistsService) ExpandWildcards(expandWildcards string) *IndicesExistsService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Local, when set, returns local information and does not retrieve the state
+// from master node (default: false).
+func (s *IndicesExistsService) Local(local bool) *IndicesExistsService {
+	s.local = &local
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *IndicesExistsService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesExistsService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesExistsService) Pretty(pretty bool) *IndicesExistsService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesExistsService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}", map[string]string{
+		"index": strings.Join(s.index, ","),
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesExistsService) Validate() error {
+	var invalid []string
+	if len(s.index) == 0 {
+		invalid = append(invalid, "Index")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesExistsService) Do(ctx context.Context) (bool, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return false, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return false, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method:       "HEAD",
+		Path:         path,
+		Params:       params,
+		IgnoreErrors: []int{404},
+	})
+	if err != nil {
+		return false, err
+	}
+
+	// Return operation response
+	switch res.StatusCode {
+	case http.StatusOK:
+		return true, nil
+	case http.StatusNotFound:
+		return false, nil
+	default:
+		return false, fmt.Errorf("elastic: got HTTP code %d when it should have been either 200 or 404", res.StatusCode)
+	}
+}

vendor/github.com/olivere/elastic/indices_exists_template.go

@@ -0,0 +1,118 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesExistsTemplateService checks if a given template exists.
+// See http://www.elastic.co/guide/en/elasticsearch/reference/5.2/indices-templates.html#indices-templates-exists
+// for documentation.
+type IndicesExistsTemplateService struct {
+	client *Client
+	pretty bool
+	name   string
+	local  *bool
+}
+
+// NewIndicesExistsTemplateService creates a new IndicesExistsTemplateService.
+func NewIndicesExistsTemplateService(client *Client) *IndicesExistsTemplateService {
+	return &IndicesExistsTemplateService{
+		client: client,
+	}
+}
+
+// Name is the name of the template.
+func (s *IndicesExistsTemplateService) Name(name string) *IndicesExistsTemplateService {
+	s.name = name
+	return s
+}
+
+// Local indicates whether to return local information, i.e. do not retrieve
+// the state from master node (default: false).
+func (s *IndicesExistsTemplateService) Local(local bool) *IndicesExistsTemplateService {
+	s.local = &local
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesExistsTemplateService) Pretty(pretty bool) *IndicesExistsTemplateService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesExistsTemplateService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/_template/{name}", map[string]string{
+		"name": s.name,
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesExistsTemplateService) Validate() error {
+	var invalid []string
+	if s.name == "" {
+		invalid = append(invalid, "Name")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesExistsTemplateService) Do(ctx context.Context) (bool, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return false, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return false, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method:       "HEAD",
+		Path:         path,
+		Params:       params,
+		IgnoreErrors: []int{404},
+	})
+	if err != nil {
+		return false, err
+	}
+
+	// Return operation response
+	switch res.StatusCode {
+	case http.StatusOK:
+		return true, nil
+	case http.StatusNotFound:
+		return false, nil
+	default:
+		return false, fmt.Errorf("elastic: got HTTP code %d when it should have been either 200 or 404", res.StatusCode)
+	}
+}

vendor/github.com/olivere/elastic/indices_exists_type.go

@@ -0,0 +1,165 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesExistsTypeService checks if one or more types exist in one or more indices.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-types-exists.html
+// for details.
+type IndicesExistsTypeService struct {
+	client            *Client
+	pretty            bool
+	typ               []string
+	index             []string
+	expandWildcards   string
+	local             *bool
+	ignoreUnavailable *bool
+	allowNoIndices    *bool
+}
+
+// NewIndicesExistsTypeService creates a new IndicesExistsTypeService.
+func NewIndicesExistsTypeService(client *Client) *IndicesExistsTypeService {
+	return &IndicesExistsTypeService{
+		client: client,
+	}
+}
+
+// Index is a list of index names; use `_all` to check the types across all indices.
+func (s *IndicesExistsTypeService) Index(indices ...string) *IndicesExistsTypeService {
+	s.index = append(s.index, indices...)
+	return s
+}
+
+// Type is a list of document types to check.
+func (s *IndicesExistsTypeService) Type(types ...string) *IndicesExistsTypeService {
+	s.typ = append(s.typ, types...)
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *IndicesExistsTypeService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesExistsTypeService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices.
+// (This includes `_all` string or when no indices have been specified).
+func (s *IndicesExistsTypeService) AllowNoIndices(allowNoIndices bool) *IndicesExistsTypeService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both.
+func (s *IndicesExistsTypeService) ExpandWildcards(expandWildcards string) *IndicesExistsTypeService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Local specifies whether to return local information, i.e. do not retrieve
+// the state from master node (default: false).
+func (s *IndicesExistsTypeService) Local(local bool) *IndicesExistsTypeService {
+	s.local = &local
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesExistsTypeService) Pretty(pretty bool) *IndicesExistsTypeService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesExistsTypeService) buildURL() (string, url.Values, error) {
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/_mapping/{type}", map[string]string{
+		"index": strings.Join(s.index, ","),
+		"type":  strings.Join(s.typ, ","),
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesExistsTypeService) Validate() error {
+	var invalid []string
+	if len(s.index) == 0 {
+		invalid = append(invalid, "Index")
+	}
+	if len(s.typ) == 0 {
+		invalid = append(invalid, "Type")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesExistsTypeService) Do(ctx context.Context) (bool, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return false, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return false, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method:       "HEAD",
+		Path:         path,
+		Params:       params,
+		IgnoreErrors: []int{404},
+	})
+	if err != nil {
+		return false, err
+	}
+
+	// Return operation response
+	switch res.StatusCode {
+	case http.StatusOK:
+		return true, nil
+	case http.StatusNotFound:
+		return false, nil
+	default:
+		return false, fmt.Errorf("elastic: got HTTP code %d when it should have been either 200 or 404", res.StatusCode)
+	}
+}

vendor/github.com/olivere/elastic/indices_flush.go

@@ -0,0 +1,173 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// Flush allows to flush one or more indices. The flush process of an index
+// basically frees memory from the index by flushing data to the index
+// storage and clearing the internal transaction log.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-flush.html
+// for details.
+type IndicesFlushService struct {
+	client            *Client
+	pretty            bool
+	index             []string
+	force             *bool
+	waitIfOngoing     *bool
+	ignoreUnavailable *bool
+	allowNoIndices    *bool
+	expandWildcards   string
+}
+
+// NewIndicesFlushService creates a new IndicesFlushService.
+func NewIndicesFlushService(client *Client) *IndicesFlushService {
+	return &IndicesFlushService{
+		client: client,
+		index:  make([]string, 0),
+	}
+}
+
+// Index is a list of index names; use `_all` or empty string for all indices.
+func (s *IndicesFlushService) Index(indices ...string) *IndicesFlushService {
+	s.index = append(s.index, indices...)
+	return s
+}
+
+// Force indicates whether a flush should be forced even if it is not
+// necessarily needed ie. if no changes will be committed to the index.
+// This is useful if transaction log IDs should be incremented even if
+// no uncommitted changes are present. (This setting can be considered as internal).
+func (s *IndicesFlushService) Force(force bool) *IndicesFlushService {
+	s.force = &force
+	return s
+}
+
+// WaitIfOngoing, if set to true, indicates that the flush operation will
+// block until the flush can be executed if another flush operation is
+// already executing. The default is false and will cause an exception
+// to be thrown on the shard level if another flush operation is already running..
+func (s *IndicesFlushService) WaitIfOngoing(waitIfOngoing bool) *IndicesFlushService {
+	s.waitIfOngoing = &waitIfOngoing
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *IndicesFlushService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesFlushService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices expression
+// resolves into no concrete indices. (This includes `_all` string or when
+// no indices have been specified).
+func (s *IndicesFlushService) AllowNoIndices(allowNoIndices bool) *IndicesFlushService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards specifies whether to expand wildcard expression to
+// concrete indices that are open, closed or both..
+func (s *IndicesFlushService) ExpandWildcards(expandWildcards string) *IndicesFlushService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesFlushService) Pretty(pretty bool) *IndicesFlushService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesFlushService) buildURL() (string, url.Values, error) {
+	// Build URL
+	var err error
+	var path string
+
+	if len(s.index) > 0 {
+		path, err = uritemplates.Expand("/{index}/_flush", map[string]string{
+			"index": strings.Join(s.index, ","),
+		})
+	} else {
+		path = "/_flush"
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.force != nil {
+		params.Set("force", fmt.Sprintf("%v", *s.force))
+	}
+	if s.waitIfOngoing != nil {
+		params.Set("wait_if_ongoing", fmt.Sprintf("%v", *s.waitIfOngoing))
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesFlushService) Validate() error {
+	return nil
+}
+
+// Do executes the service.
+func (s *IndicesFlushService) Do(ctx context.Context) (*IndicesFlushResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "POST",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(IndicesFlushResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// -- Result of a flush request.
+
+type IndicesFlushResponse struct {
+	Shards shardsInfo `json:"_shards"`
+}

vendor/github.com/olivere/elastic/indices_forcemerge.go

@@ -0,0 +1,193 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesForcemergeService allows to force merging of one or more indices.
+// The merge relates to the number of segments a Lucene index holds
+// within each shard. The force merge operation allows to reduce the number
+// of segments by merging them.
+//
+// See http://www.elastic.co/guide/en/elasticsearch/reference/5.2/indices-forcemerge.html
+// for more information.
+type IndicesForcemergeService struct {
+	client             *Client
+	pretty             bool
+	index              []string
+	allowNoIndices     *bool
+	expandWildcards    string
+	flush              *bool
+	ignoreUnavailable  *bool
+	maxNumSegments     interface{}
+	onlyExpungeDeletes *bool
+	operationThreading interface{}
+}
+
+// NewIndicesForcemergeService creates a new IndicesForcemergeService.
+func NewIndicesForcemergeService(client *Client) *IndicesForcemergeService {
+	return &IndicesForcemergeService{
+		client: client,
+		index:  make([]string, 0),
+	}
+}
+
+// Index is a list of index names; use `_all` or empty string to perform
+// the operation on all indices.
+func (s *IndicesForcemergeService) Index(index ...string) *IndicesForcemergeService {
+	if s.index == nil {
+		s.index = make([]string, 0)
+	}
+	s.index = append(s.index, index...)
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices.
+// (This includes `_all` string or when no indices have been specified).
+func (s *IndicesForcemergeService) AllowNoIndices(allowNoIndices bool) *IndicesForcemergeService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both..
+func (s *IndicesForcemergeService) ExpandWildcards(expandWildcards string) *IndicesForcemergeService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Flush specifies whether the index should be flushed after performing
+// the operation (default: true).
+func (s *IndicesForcemergeService) Flush(flush bool) *IndicesForcemergeService {
+	s.flush = &flush
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should
+// be ignored when unavailable (missing or closed).
+func (s *IndicesForcemergeService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesForcemergeService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// MaxNumSegments specifies the number of segments the index should be
+// merged into (default: dynamic).
+func (s *IndicesForcemergeService) MaxNumSegments(maxNumSegments interface{}) *IndicesForcemergeService {
+	s.maxNumSegments = maxNumSegments
+	return s
+}
+
+// OnlyExpungeDeletes specifies whether the operation should only expunge
+// deleted documents.
+func (s *IndicesForcemergeService) OnlyExpungeDeletes(onlyExpungeDeletes bool) *IndicesForcemergeService {
+	s.onlyExpungeDeletes = &onlyExpungeDeletes
+	return s
+}
+
+func (s *IndicesForcemergeService) OperationThreading(operationThreading interface{}) *IndicesForcemergeService {
+	s.operationThreading = operationThreading
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesForcemergeService) Pretty(pretty bool) *IndicesForcemergeService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesForcemergeService) buildURL() (string, url.Values, error) {
+	var err error
+	var path string
+
+	// Build URL
+	if len(s.index) > 0 {
+		path, err = uritemplates.Expand("/{index}/_forcemerge", map[string]string{
+			"index": strings.Join(s.index, ","),
+		})
+	} else {
+		path = "/_forcemerge"
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.flush != nil {
+		params.Set("flush", fmt.Sprintf("%v", *s.flush))
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.maxNumSegments != nil {
+		params.Set("max_num_segments", fmt.Sprintf("%v", s.maxNumSegments))
+	}
+	if s.onlyExpungeDeletes != nil {
+		params.Set("only_expunge_deletes", fmt.Sprintf("%v", *s.onlyExpungeDeletes))
+	}
+	if s.operationThreading != nil {
+		params.Set("operation_threading", fmt.Sprintf("%v", s.operationThreading))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesForcemergeService) Validate() error {
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesForcemergeService) Do(ctx context.Context) (*IndicesForcemergeResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "POST",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	ret := new(IndicesForcemergeResponse)
+	if err := s.client.decoder.Decode(res.Body, ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// IndicesForcemergeResponse is the response of IndicesForcemergeService.Do.
+type IndicesForcemergeResponse struct {
+	Shards shardsInfo `json:"_shards"`
+}

vendor/github.com/olivere/elastic/indices_get.go

@@ -0,0 +1,206 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesGetService retrieves information about one or more indices.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-index.html
+// for more details.
+type IndicesGetService struct {
+	client            *Client
+	pretty            bool
+	index             []string
+	feature           []string
+	local             *bool
+	ignoreUnavailable *bool
+	allowNoIndices    *bool
+	expandWildcards   string
+	flatSettings      *bool
+	human             *bool
+}
+
+// NewIndicesGetService creates a new IndicesGetService.
+func NewIndicesGetService(client *Client) *IndicesGetService {
+	return &IndicesGetService{
+		client:  client,
+		index:   make([]string, 0),
+		feature: make([]string, 0),
+	}
+}
+
+// Index is a list of index names.
+func (s *IndicesGetService) Index(indices ...string) *IndicesGetService {
+	s.index = append(s.index, indices...)
+	return s
+}
+
+// Feature is a list of features.
+func (s *IndicesGetService) Feature(features ...string) *IndicesGetService {
+	s.feature = append(s.feature, features...)
+	return s
+}
+
+// Local indicates whether to return local information, i.e. do not retrieve
+// the state from master node (default: false).
+func (s *IndicesGetService) Local(local bool) *IndicesGetService {
+	s.local = &local
+	return s
+}
+
+// IgnoreUnavailable indicates whether to ignore unavailable indexes (default: false).
+func (s *IndicesGetService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesGetService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard expression
+// resolves to no concrete indices (default: false).
+func (s *IndicesGetService) AllowNoIndices(allowNoIndices bool) *IndicesGetService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether wildcard expressions should get
+// expanded to open or closed indices (default: open).
+func (s *IndicesGetService) ExpandWildcards(expandWildcards string) *IndicesGetService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+/* Disabled because serialization would fail in that case. */
+/*
+// FlatSettings make the service return settings in flat format (default: false).
+func (s *IndicesGetService) FlatSettings(flatSettings bool) *IndicesGetService {
+	s.flatSettings = &flatSettings
+	return s
+}
+*/
+
+// Human indicates whether to return version and creation date values
+// in human-readable format (default: false).
+func (s *IndicesGetService) Human(human bool) *IndicesGetService {
+	s.human = &human
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesGetService) Pretty(pretty bool) *IndicesGetService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesGetService) buildURL() (string, url.Values, error) {
+	var err error
+	var path string
+	var index []string
+
+	if len(s.index) > 0 {
+		index = s.index
+	} else {
+		index = []string{"_all"}
+	}
+
+	if len(s.feature) > 0 {
+		// Build URL
+		path, err = uritemplates.Expand("/{index}/{feature}", map[string]string{
+			"index":   strings.Join(index, ","),
+			"feature": strings.Join(s.feature, ","),
+		})
+	} else {
+		// Build URL
+		path, err = uritemplates.Expand("/{index}", map[string]string{
+			"index": strings.Join(index, ","),
+		})
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.flatSettings != nil {
+		params.Set("flat_settings", fmt.Sprintf("%v", *s.flatSettings))
+	}
+	if s.human != nil {
+		params.Set("human", fmt.Sprintf("%v", *s.human))
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesGetService) Validate() error {
+	var invalid []string
+	if len(s.index) == 0 {
+		invalid = append(invalid, "Index")
+	}
+	if len(invalid) > 0 {
+		return fmt.Errorf("missing required fields: %v", invalid)
+	}
+	return nil
+}
+
+// Do executes the operation.
+func (s *IndicesGetService) Do(ctx context.Context) (map[string]*IndicesGetResponse, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	var ret map[string]*IndicesGetResponse
+	if err := s.client.decoder.Decode(res.Body, &ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+// IndicesGetResponse is part of the response of IndicesGetService.Do.
+type IndicesGetResponse struct {
+	Aliases  map[string]interface{} `json:"aliases"`
+	Mappings map[string]interface{} `json:"mappings"`
+	Settings map[string]interface{} `json:"settings"`
+	Warmers  map[string]interface{} `json:"warmers"`
+}

vendor/github.com/olivere/elastic/indices_get_aliases.go

@@ -0,0 +1,161 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// AliasesService returns the aliases associated with one or more indices.
+// See http://www.elastic.co/guide/en/elasticsearch/reference/5.2/indices-aliases.html.
+type AliasesService struct {
+	client *Client
+	index  []string
+	pretty bool
+}
+
+// NewAliasesService instantiates a new AliasesService.
+func NewAliasesService(client *Client) *AliasesService {
+	builder := &AliasesService{
+		client: client,
+	}
+	return builder
+}
+
+// Pretty asks Elasticsearch to indent the returned JSON.
+func (s *AliasesService) Pretty(pretty bool) *AliasesService {
+	s.pretty = pretty
+	return s
+}
+
+// Index adds one or more indices.
+func (s *AliasesService) Index(index ...string) *AliasesService {
+	s.index = append(s.index, index...)
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *AliasesService) buildURL() (string, url.Values, error) {
+	var err error
+	var path string
+
+	if len(s.index) > 0 {
+		path, err = uritemplates.Expand("/{index}/_alias", map[string]string{
+			"index": strings.Join(s.index, ","),
+		})
+	} else {
+		path = "/_alias"
+	}
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", fmt.Sprintf("%v", s.pretty))
+	}
+	return path, params, nil
+}
+
+func (s *AliasesService) Do(ctx context.Context) (*AliasesResult, error) {
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// {
+	//   "indexName" : {
+	//     "aliases" : {
+	//       "alias1" : { },
+	//       "alias2" : { }
+	//     }
+	//   },
+	//   "indexName2" : {
+	//     ...
+	//   },
+	// }
+	indexMap := make(map[string]interface{})
+	if err := s.client.decoder.Decode(res.Body, &indexMap); err != nil {
+		return nil, err
+	}
+
+	// Each (indexName, _)
+	ret := &AliasesResult{
+		Indices: make(map[string]indexResult),
+	}
+	for indexName, indexData := range indexMap {
+		indexOut, found := ret.Indices[indexName]
+		if !found {
+			indexOut = indexResult{Aliases: make([]aliasResult, 0)}
+		}
+
+		// { "aliases" : { ... } }
+		indexDataMap, ok := indexData.(map[string]interface{})
+		if ok {
+			aliasesData, ok := indexDataMap["aliases"].(map[string]interface{})
+			if ok {
+				for aliasName, _ := range aliasesData {
+					aliasRes := aliasResult{AliasName: aliasName}
+					indexOut.Aliases = append(indexOut.Aliases, aliasRes)
+				}
+			}
+		}
+
+		ret.Indices[indexName] = indexOut
+	}
+
+	return ret, nil
+}
+
+// -- Result of an alias request.
+
+type AliasesResult struct {
+	Indices map[string]indexResult
+}
+
+type indexResult struct {
+	Aliases []aliasResult
+}
+
+type aliasResult struct {
+	AliasName string
+}
+
+func (ar AliasesResult) IndicesByAlias(aliasName string) []string {
+	var indices []string
+	for indexName, indexInfo := range ar.Indices {
+		for _, aliasInfo := range indexInfo.Aliases {
+			if aliasInfo.AliasName == aliasName {
+				indices = append(indices, indexName)
+			}
+		}
+	}
+	return indices
+}
+
+func (ir indexResult) HasAlias(aliasName string) bool {
+	for _, alias := range ir.Aliases {
+		if alias.AliasName == aliasName {
+			return true
+		}
+	}
+	return false
+}

vendor/github.com/olivere/elastic/indices_get_field_mapping.go

@@ -0,0 +1,187 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesGetFieldMappingService retrieves the mapping definitions for the fields in an index
+//  or index/type.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-field-mapping.html
+// for details.
+type IndicesGetFieldMappingService struct {
+	client            *Client
+	pretty            bool
+	index             []string
+	typ               []string
+	field             []string
+	local             *bool
+	ignoreUnavailable *bool
+	allowNoIndices    *bool
+	expandWildcards   string
+}
+
+// NewGetFieldMappingService is an alias for NewIndicesGetFieldMappingService.
+// Use NewIndicesGetFieldMappingService.
+func NewGetFieldMappingService(client *Client) *IndicesGetFieldMappingService {
+	return NewIndicesGetFieldMappingService(client)
+}
+
+// NewIndicesGetFieldMappingService creates a new IndicesGetFieldMappingService.
+func NewIndicesGetFieldMappingService(client *Client) *IndicesGetFieldMappingService {
+	return &IndicesGetFieldMappingService{
+		client: client,
+	}
+}
+
+// Index is a list of index names.
+func (s *IndicesGetFieldMappingService) Index(indices ...string) *IndicesGetFieldMappingService {
+	s.index = append(s.index, indices...)
+	return s
+}
+
+// Type is a list of document types.
+func (s *IndicesGetFieldMappingService) Type(types ...string) *IndicesGetFieldMappingService {
+	s.typ = append(s.typ, types...)
+	return s
+}
+
+// Field is a list of fields.
+func (s *IndicesGetFieldMappingService) Field(fields ...string) *IndicesGetFieldMappingService {
+	s.field = append(s.field, fields...)
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices.
+// This includes `_all` string or when no indices have been specified.
+func (s *IndicesGetFieldMappingService) AllowNoIndices(allowNoIndices bool) *IndicesGetFieldMappingService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both..
+func (s *IndicesGetFieldMappingService) ExpandWildcards(expandWildcards string) *IndicesGetFieldMappingService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Local indicates whether to return local information, do not retrieve
+// the state from master node (default: false).
+func (s *IndicesGetFieldMappingService) Local(local bool) *IndicesGetFieldMappingService {
+	s.local = &local
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *IndicesGetFieldMappingService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesGetFieldMappingService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesGetFieldMappingService) Pretty(pretty bool) *IndicesGetFieldMappingService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesGetFieldMappingService) buildURL() (string, url.Values, error) {
+	var index, typ, field []string
+
+	if len(s.index) > 0 {
+		index = s.index
+	} else {
+		index = []string{"_all"}
+	}
+
+	if len(s.typ) > 0 {
+		typ = s.typ
+	} else {
+		typ = []string{"_all"}
+	}
+
+	if len(s.field) > 0 {
+		field = s.field
+	} else {
+		field = []string{"*"}
+	}
+
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/_mapping/{type}/field/{field}", map[string]string{
+		"index": strings.Join(index, ","),
+		"type":  strings.Join(typ, ","),
+		"field": strings.Join(field, ","),
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesGetFieldMappingService) Validate() error {
+	return nil
+}
+
+// Do executes the operation. It returns mapping definitions for an index
+// or index/type.
+func (s *IndicesGetFieldMappingService) Do(ctx context.Context) (map[string]interface{}, error) {
+	var ret map[string]interface{}
+
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	if err := s.client.decoder.Decode(res.Body, &ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}

vendor/github.com/olivere/elastic/indices_get_mapping.go

@@ -0,0 +1,174 @@
+// Copyright 2012-present Oliver Eilhard. All rights reserved.
+// Use of this source code is governed by a MIT-license.
+// See http://olivere.mit-license.org/license.txt for details.
+
+package elastic
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	"github.com/olivere/elastic/uritemplates"
+)
+
+// IndicesGetMappingService retrieves the mapping definitions for an index or
+// index/type.
+//
+// See https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-mapping.html
+// for details.
+type IndicesGetMappingService struct {
+	client            *Client
+	pretty            bool
+	index             []string
+	typ               []string
+	local             *bool
+	ignoreUnavailable *bool
+	allowNoIndices    *bool
+	expandWildcards   string
+}
+
+// NewGetMappingService is an alias for NewIndicesGetMappingService.
+// Use NewIndicesGetMappingService.
+func NewGetMappingService(client *Client) *IndicesGetMappingService {
+	return NewIndicesGetMappingService(client)
+}
+
+// NewIndicesGetMappingService creates a new IndicesGetMappingService.
+func NewIndicesGetMappingService(client *Client) *IndicesGetMappingService {
+	return &IndicesGetMappingService{
+		client: client,
+		index:  make([]string, 0),
+		typ:    make([]string, 0),
+	}
+}
+
+// Index is a list of index names.
+func (s *IndicesGetMappingService) Index(indices ...string) *IndicesGetMappingService {
+	s.index = append(s.index, indices...)
+	return s
+}
+
+// Type is a list of document types.
+func (s *IndicesGetMappingService) Type(types ...string) *IndicesGetMappingService {
+	s.typ = append(s.typ, types...)
+	return s
+}
+
+// AllowNoIndices indicates whether to ignore if a wildcard indices
+// expression resolves into no concrete indices.
+// This includes `_all` string or when no indices have been specified.
+func (s *IndicesGetMappingService) AllowNoIndices(allowNoIndices bool) *IndicesGetMappingService {
+	s.allowNoIndices = &allowNoIndices
+	return s
+}
+
+// ExpandWildcards indicates whether to expand wildcard expression to
+// concrete indices that are open, closed or both..
+func (s *IndicesGetMappingService) ExpandWildcards(expandWildcards string) *IndicesGetMappingService {
+	s.expandWildcards = expandWildcards
+	return s
+}
+
+// Local indicates whether to return local information, do not retrieve
+// the state from master node (default: false).
+func (s *IndicesGetMappingService) Local(local bool) *IndicesGetMappingService {
+	s.local = &local
+	return s
+}
+
+// IgnoreUnavailable indicates whether specified concrete indices should be
+// ignored when unavailable (missing or closed).
+func (s *IndicesGetMappingService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesGetMappingService {
+	s.ignoreUnavailable = &ignoreUnavailable
+	return s
+}
+
+// Pretty indicates that the JSON response be indented and human readable.
+func (s *IndicesGetMappingService) Pretty(pretty bool) *IndicesGetMappingService {
+	s.pretty = pretty
+	return s
+}
+
+// buildURL builds the URL for the operation.
+func (s *IndicesGetMappingService) buildURL() (string, url.Values, error) {
+	var index, typ []string
+
+	if len(s.index) > 0 {
+		index = s.index
+	} else {
+		index = []string{"_all"}
+	}
+
+	if len(s.typ) > 0 {
+		typ = s.typ
+	} else {
+		typ = []string{"_all"}
+	}
+
+	// Build URL
+	path, err := uritemplates.Expand("/{index}/_mapping/{type}", map[string]string{
+		"index": strings.Join(index, ","),
+		"type":  strings.Join(typ, ","),
+	})
+	if err != nil {
+		return "", url.Values{}, err
+	}
+
+	// Add query string parameters
+	params := url.Values{}
+	if s.pretty {
+		params.Set("pretty", "true")
+	}
+	if s.ignoreUnavailable != nil {
+		params.Set("ignore_unavailable", fmt.Sprintf("%v", *s.ignoreUnavailable))
+	}
+	if s.allowNoIndices != nil {
+		params.Set("allow_no_indices", fmt.Sprintf("%v", *s.allowNoIndices))
+	}
+	if s.expandWildcards != "" {
+		params.Set("expand_wildcards", s.expandWildcards)
+	}
+	if s.local != nil {
+		params.Set("local", fmt.Sprintf("%v", *s.local))
+	}
+	return path, params, nil
+}
+
+// Validate checks if the operation is valid.
+func (s *IndicesGetMappingService) Validate() error {
+	return nil
+}
+
+// Do executes the operation. It returns mapping definitions for an index
+// or index/type.
+func (s *IndicesGetMappingService) Do(ctx context.Context) (map[string]interface{}, error) {
+	// Check pre-conditions
+	if err := s.Validate(); err != nil {
+		return nil, err
+	}
+
+	// Get URL for request
+	path, params, err := s.buildURL()
+	if err != nil {
+		return nil, err
+	}
+
+	// Get HTTP response
+	res, err := s.client.PerformRequest(ctx, PerformRequestOptions{
+		Method: "GET",
+		Path:   path,
+		Params: params,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Return operation response
+	var ret map[string]interface{}
+	if err := s.client.decoder.Decode(res.Body, &ret); err != nil {
+		return nil, err
+	}
+	return ret, nil
+}