// Multi GET API allows to get multiple documents based on an index, type (optional) and id (and possibly routing).
// The response includes a docs array with all the fetched documents, each element similar in structure to a document
// provided by the get API.
// see http://www.elasticsearch.org/guide/reference/api/multi-get.html
func MGet(pretty bool, index string, _type string, mgetRequest MGetRequestContainer) (MGetResponseContainer, error) {
var url string
var retval MGetResponseContainer
if len(index) <= 0 {
url = fmt.Sprintf("/_mget?%s", api.Pretty(pretty))
}
if len(_type) > 0 && len(index) > 0 {
url = fmt.Sprintf("/%s/%s/_mget?%s", index, _type, api.Pretty(pretty))
} else if len(index) > 0 {
url = fmt.Sprintf("/%s/_mget?%s", index, api.Pretty(pretty))
}
body, err := api.DoCommand("GET", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
// The index API adds or updates a typed JSON document in a specific index, making it searchable.
// http://www.elasticsearch.org/guide/reference/api/index_.html
func Index(pretty bool, index string, _type string, id string, data interface{}) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
url = fmt.Sprintf("/%s/%s/%s?%s", index, _type, id, api.Pretty(pretty))
var method string
if id == "" {
method = "POST"
} else {
method = "PUT"
}
body, err := api.DoCommand(method, url, data)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
//fmt.Println(body)
return retval, err
}
// Performs a very basic search on an index via the request URI API.
//
// params:
// @pretty: bool for pretty reply or not, a parameter to elasticsearch
// @index: the elasticsearch index
// @_type: optional ("" if not used) search specific type in this index
// @query: this can be one of 3 types:
// 1) string value that is valid elasticsearch
// 2) io.Reader that can be set in body (also valid elasticsearch string syntax..)
// 3) other type marshalable to json (also valid elasticsearch json)
//
// out, err := SearchRequest(true, "github","",qryType ,"")
//
// http://www.elasticsearch.org/guide/reference/api/search/uri-request.html
func SearchRequest(pretty bool, index string, _type string, query interface{}, scroll string) (SearchResult, error) {
var uriVal string
var retval SearchResult
if len(_type) > 0 && _type != "*" {
uriVal = fmt.Sprintf("/%s/%s/_search?%s%s", index, _type, api.Pretty(pretty), api.Scroll(scroll))
} else {
uriVal = fmt.Sprintf("/%s/_search?%s%s", index, api.Pretty(pretty), api.Scroll(scroll))
}
log.Println(uriVal)
body, err := api.DoCommand("POST", uriVal, query)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal([]byte(body), &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
return retval, err
}
// The cluster health API allows to get a very simple status on the health of the cluster.
// see http://www.elasticsearch.org/guide/reference/api/admin-cluster-health.html
// TODO: implement wait_for_status, timeout, wait_for_relocating_shards, wait_for_nodes
// TODO: implement level (Can be one of cluster, indices or shards. Controls the details level of the health
// information returned. Defaults to cluster.)
func Health(pretty bool, indices ...string) (ClusterHealthResponse, error) {
var url string
var retval ClusterHealthResponse
if len(indices) > 0 {
url = fmt.Sprintf("/_cluster/health/%s?%s", strings.Join(indices, ","), api.Pretty(pretty))
} else {
url = fmt.Sprintf("/_cluster/health?%s", api.Pretty(pretty))
}
body, err := api.DoCommand("GET", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
//fmt.Println(body)
return retval, err
}
// The explain api computes a score explanation for a query and a specific document.
// This can give useful feedback whether a document matches or didn’t match a specific query.
// This feature is available from version 0.19.9 and up.
// see http://www.elasticsearch.org/guide/reference/api/explain.html
func Explain(pretty bool, index string, _type string, id string, query string) (api.Match, error) {
var url string
var retval api.Match
if len(_type) > 0 {
url = fmt.Sprintf("/%s/%s/_explain?%s", index, _type, api.Pretty(pretty))
} else {
url = fmt.Sprintf("/%s/_explain?%s", index, api.Pretty(pretty))
}
body, err := api.DoCommand("GET", url, query)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
// The API also allows to check for the existance of a document using HEAD
// This appears to be broken in the current version of elasticsearch 0.19.10, currently
// returning nothing
func Exists(pretty bool, index string, _type string, id string) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
if len(_type) > 0 {
url = fmt.Sprintf("/%s/%s/%s?%s", index, _type, id, api.Pretty(pretty))
} else {
url = fmt.Sprintf("/%s/%s?%s", index, id, api.Pretty(pretty))
}
body, err := api.DoCommand("HEAD", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
//fmt.Println(body)
return retval, err
}
// Lists status details of all indices or the specified index.
// http://www.elasticsearch.org/guide/reference/api/admin-indices-status.html
func Status(pretty bool, indices ...string) (api.BaseResponse, error) {
var retval api.BaseResponse
var url string
if len(indices) > 0 {
url = fmt.Sprintf("/%s/_status?%s", strings.Join(indices, ","), api.Pretty(pretty))
} else {
url = fmt.Sprintf("/_status?%s", api.Pretty(pretty))
}
body, err := api.DoCommand("GET", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
func Percolate(pretty bool, index string, _type string, name string, doc string) (api.Match, error) {
var url string
var retval api.Match
url = fmt.Sprintf("/%s/%s/_percolate?%s", index, _type, api.Pretty(pretty))
body, err := api.DoCommand("GET", url, doc)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
// The more like this (mlt) API allows to get documents that are “like” a specified document.
// http://www.elasticsearch.org/guide/reference/api/more-like-this.html
func MoreLikeThis(pretty bool, index string, _type string, id string, query MoreLikeThisQuery) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
url = fmt.Sprintf("/%s/%s/%s/_mlt?%s", index, _type, id, api.Pretty(pretty))
body, err := api.DoCommand("GET", url, query)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
// The update API allows to update a document based on a script provided. The operation gets the document
// (collocated with the shard) from the index, runs the script (with optional script language and parameters),
// and index back the result (also allows to delete, or ignore the operation). It uses versioning to make sure
// no updates have happened during the “get” and “reindex”. (available from 0.19 onwards).
// Note, this operation still means full reindex of the document, it just removes some network roundtrips
// and reduces chances of version conflicts between the get and the index. The _source field need to be enabled
// for this feature to work.
//
// http://www.elasticsearch.org/guide/reference/api/update.html
// TODO: finish this, it's fairly complex
func Update(pretty bool, index string, _type string, id string) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
url = fmt.Sprintf("/%s/%s/%s/_update?%s", index, _type, id, api.Pretty(pretty))
body, err := api.DoCommand("POST", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
// The count API allows to easily execute a query and get the number of matches for that query.
// It can be executed across one or more indices and across one or more types.
// The query can either be provided using a simple query string as a parameter,
//or using the Query DSL defined within the request body.
// http://www.elasticsearch.org/guide/reference/api/count.html
// TODO: take parameters.
// currently not working against 0.19.10
func Count(pretty bool, index string, _type string) (CountResponse, error) {
var url string
var retval CountResponse
url = fmt.Sprintf("/%s/%s/_count?%s", index, _type, api.Pretty(pretty))
body, err := api.DoCommand("GET", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
//fmt.Println(body)
return retval, err
}
// The delete API allows to delete a typed JSON document from a specific index based on its id.
// http://www.elasticsearch.org/guide/reference/api/delete.html
// todo: add routing and versioning support
func Delete(pretty bool, index string, _type string, id string, version int, routing string) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
url = fmt.Sprintf("/%s/%s/%s?%s", index, _type, id, api.Pretty(pretty))
body, err := api.DoCommand("DELETE", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
//fmt.Println(body)
return retval, err
}
// The percolator allows to register queries against an index, and then send percolate requests which include a doc, and
// getting back the queries that match on that doc out of the set of registered queries.
// Think of it as the reverse operation of indexing and then searching. Instead of sending docs, indexing them,
// and then running queries. One sends queries, registers them, and then sends docs and finds out which queries
// match that doc.
// see http://www.elasticsearch.org/guide/reference/api/percolate.html
func RegisterPercolate(pretty bool, index string, name string, query api.Query) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
url = fmt.Sprintf("/_percolator/%s/%s?%s", index, name, api.Pretty(pretty))
body, err := api.DoCommand("PUT", url, query)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
func Scroll(pretty bool, scroll_id string, scroll string) (SearchResult, error) {
var url string
var retval SearchResult
url = fmt.Sprintf("/_search/scroll?%s%s", api.Pretty(pretty), api.Scroll(scroll))
body, err := api.DoCommand("POST", url, scroll_id)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal([]byte(body), &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
return retval, err
}
// The cluster health API allows to get a very simple status on the health of the cluster.
// see http://www.elasticsearch.org/guide/reference/api/admin-cluster-health.html
// TODO: implement wait_for_status, timeout, wait_for_relocating_shards, wait_for_nodes
// TODO: implement level (Can be one of cluster, indices or shards. Controls the details level of the health
// information returned. Defaults to cluster.)
func Reroute(pretty bool, dryRun bool, commands Commands) (ClusterHealthResponse, error) {
var url string
var retval ClusterHealthResponse
if len(commands.Commands) > 0 {
url = fmt.Sprintf("/_cluster/reroute%s&%s", api.Pretty(pretty), dryRunOption(dryRun))
} else {
return retval, errors.New("Must pass at least one command")
}
body, err := api.DoCommand("POST", url, commands)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
// The validate API allows a user to validate a potentially expensive query without executing it.
// see http://www.elasticsearch.org/guide/reference/api/validate.html
func Validate(pretty bool, index string, _type string, query string, explain bool) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
if len(_type) > 0 {
url = fmt.Sprintf("/%s/%s/_validate/query?q=%s&%s&explain=%s", index, _type, query, api.Pretty(pretty), explain)
} else {
url = fmt.Sprintf("/%s/_validate/query?q=%s&%s&explain=%s", index, query, api.Pretty(pretty), explain)
}
body, err := api.DoCommand("GET", url, nil)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}
// The delete by query API allows to delete documents from one or more indices and one or more types based on a query.
// The query can either be provided using a simple query string as a parameter, or using the Query DSL defined within
// the request body.
// see: http://www.elasticsearch.org/guide/reference/api/delete-by-query.html
func DeleteByQuery(pretty bool, indices []string, types []string, query interface{}) (api.BaseResponse, error) {
var url string
var retval api.BaseResponse
if len(indices) > 0 && len(types) > 0 {
url = fmt.Sprintf("http://localhost:9200/%s/%s/_query?%s&%s", strings.Join(indices, ","), strings.Join(types, ","), buildQuery, api.Pretty(pretty))
} else if len(indices) > 0 {
url = fmt.Sprintf("http://localhost:9200/%s/_query?%s&%s", strings.Join(indices, ","), buildQuery, api.Pretty(pretty))
}
body, err := api.DoCommand("DELETE", url, query)
if err != nil {
return retval, err
}
if err == nil {
// marshall into json
jsonErr := json.Unmarshal(body, &retval)
if jsonErr != nil {
return retval, jsonErr
}
}
fmt.Println(body)
return retval, err
}