clj-elasticsearch.client documentation

->ESNodeClient

(->ESNodeClient node client)
Positional factory function for class clj_elasticsearch.client.ESNodeClient.

analyze-request

(analyze-request {:keys [analyzer async? field format index listener operation-threaded? prefer-local? token-filters tokenizer], :as params})(analyze-request client params)
Generated from Class org.elasticsearch.action.admin.indices.analyze.AnalyzeRequest
Params keys:
  :index               => (required) String
  :analyzer            => String
  :async?              => if set to true, the call returns a Future instead of blocking
  :field               => String
  :format              => one of :clj, :json or :java
  :listener            => takes a listener object and makes the call async
  :operation-threaded? => boolean
  :prefer-local?       => boolean
  :token-filters       => seq of Strings
  :tokenizer           => String

atomic-update-from-source

(atomic-update-from-source f client opts)(atomic-update-from-source f opts)
atomically updates a document with an optimistic concurrency control policy.
The provided function will receive the _source field of the doc as param,
or nil if the doc id does not exist. If the function returns a map, it will
become the new value, else nothing will happen. Any additional values you
want to pass to the requests have to be set into the opts param.

build-document

(build-document doc)
returns a string representation of a document suitable for indexing

clear-index-cache

(clear-index-cache {:keys [async? bloom-cache? field-data-cache? fields filter-cache? format id-cache? ignore-indices indices listener operation-threading], :as params})(clear-index-cache client params)
Generated from Class org.elasticsearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :bloom-cache?        => boolean
    :field-data-cache?   => boolean
    :fields              => seq of Strings
    :filter-cache?       => boolean
    :format              => one of :clj, :json or :java
    :id-cache?           => boolean
    :ignore-indices      => one of :default, :none or :missing
    :listener            => takes a listener object and makes the call async
    :operation-threading => one of :no-threads, :single-thread or :thread-per-shard
Response fields expected #{:failed-shards :successful-shards :headers :shard-failures :total-shards}

close

(close this)
closes this Elasticsearch client and any underlying infrastructure

close-index

(close-index {:keys [async? format index listener master-node-timeout timeout], :as params})(close-index client params)
Generated from Class org.elasticsearch.action.admin.indices.close.CloseIndexRequest
Params keys:
  :index               => (required) String
  :async?              => if set to true, the call returns a Future instead of blocking
  :format              => one of :clj, :json or :java
  :listener            => takes a listener object and makes the call async
  :master-node-timeout => String time spec (ex: "5s")
  :timeout             => String time spec (ex: "5s")

cluster-health

(cluster-health {:keys [async? format indices listener master-node-timeout timeout wait-for-active-shards wait-for-nodes wait-for-relocating-shards wait-for-status], :as params})(cluster-health client params)
Generated from Class org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest
  Params keys:
    :indices                    => (required) seq of Strings
    :async?                     => if set to true, the call returns a Future instead of blocking
    :format                     => one of :clj, :json or :java
    :listener                   => takes a listener object and makes the call async
    :master-node-timeout        => String time spec (ex: "5s")
    :timeout                    => String time spec (ex: "5s")
    :wait-for-active-shards     => int
    :wait-for-nodes             => String
    :wait-for-relocating-shards => int
    :wait-for-status            => one of :green, :yellow or :red
Response fields expected #{:status :relocating-shards :unassigned-shards :number-of-nodes :number-of-data-nodes :initializing-shards :all-validation-failures :headers :timed-out? :active-shards :validation-failures :active-primary-shards :indices :cluster-name}

cluster-state

(cluster-state {:keys [async? filter-blocks? filter-meta-data? filter-nodes? filter-routing-table? filtered-index-templates filtered-indices format listener local? master-node-timeout], :as params})(cluster-state client params)
Generated from Class org.elasticsearch.action.admin.cluster.state.ClusterStateRequest
  Params keys:
    :async?                   => if set to true, the call returns a Future instead of blocking
    :filter-blocks?           => boolean
    :filter-meta-data?        => boolean
    :filter-nodes?            => boolean
    :filter-routing-table?    => boolean
    :filtered-index-templates => seq of Strings
    :filtered-indices         => seq of Strings
    :format                   => one of :clj, :json or :java
    :listener                 => takes a listener object and makes the call async
    :local?                   => boolean
    :master-node-timeout      => String time spec (ex: "5s")
Response fields expected #{:state :headers :cluster-name}

compose

(compose this listener)
composes with the given listener, returning a new listener

convert-source

(convert-source this)
convert source to bytes

count-docs

(count-docs {:keys [async? format ignore-indices indices listener min-score operation-threading query query-hint routing types], :as params})(count-docs client params)
Generated from Class org.elasticsearch.action.count.CountRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :ignore-indices      => one of :default, :none or :missing
    :listener            => takes a listener object and makes the call async
    :min-score           => float
    :operation-threading => one of :no-threads, :single-thread or :thread-per-shard
    :query               => HashMap or JSON String or SMILE bytes-array
    :query-hint          => String
    :routing             => String or seq of Strings
    :types               => seq of Strings
Response fields expected #{:count :failed-shards :successful-shards :headers :shard-failures :total-shards}

create-index

(create-index {:keys [async? cause custom format index listener master-node-timeout source timeout tings], :as params})(create-index client params)
Generated from Class org.elasticsearch.action.admin.indices.create.CreateIndexRequest
  Params keys:
    :index               => (required) String
    :async?              => if set to true, the call returns a Future instead of blocking
    :cause               => String
    :custom              => IndexMetaData$Custom
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :source              => HashMap or JSON String or SMILE bytes-array
    :timeout             => String time spec (ex: "5s")
    :tings               => HashMap of Settings
Response fields expected #{:headers :acknowledged?}

delete-by-query

(delete-by-query {:keys [async? consistency-level format indices listener query replication-type routing timeout types], :as params})(delete-by-query client params)
Generated from Class org.elasticsearch.action.deletebyquery.DeleteByQueryRequest
  Params keys:
    :query             => (required) HashMap or JSON String or SMILE bytes-array
    :async?            => if set to true, the call returns a Future instead of blocking
    :consistency-level => one of :default, :one, :quorum or :all
    :format            => one of :clj, :json or :java
    :indices           => seq of Strings
    :listener          => takes a listener object and makes the call async
    :replication-type  => one of :sync, :async or :default
    :routing           => String or seq of Strings
    :timeout           => String time spec (ex: "5s")
    :types             => seq of Strings
Response fields expected #{:headers :indices}

delete-doc

(delete-doc {:keys [async? consistency-level format id index listener operation-threaded? parent refresh? replication-type routing timeout type version version-type], :as params})(delete-doc client params)
Generated from Class org.elasticsearch.action.delete.DeleteRequest
  Params keys:
    :id                  => (required) String
    :index               => (required) String
    :type                => (required) String
    :async?              => if set to true, the call returns a Future instead of blocking
    :consistency-level   => one of :default, :one, :quorum or :all
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :operation-threaded? => boolean
    :parent              => String
    :refresh?            => boolean
    :replication-type    => one of :sync, :async or :default
    :routing             => String
    :timeout             => String time spec (ex: "5s")
    :version             => long
    :version-type        => one of :internal or :external
Response fields expected #{:not-found? :version :headers :type :index :id}

delete-index

(delete-index {:keys [async? format indices listener master-node-timeout timeout], :as params})(delete-index client params)
Generated from Class org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :timeout             => String time spec (ex: "5s")
Response fields expected #{:headers :acknowledged?}

delete-mapping

(delete-mapping {:keys [async? format indices listener master-node-timeout type], :as params})(delete-mapping client params)
Generated from Class org.elasticsearch.action.admin.indices.mapping.delete.DeleteMappingRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :type                => String
Response fields expected #{:headers}

delete-template

(delete-template {:keys [async? format listener master-node-timeout timeout], :as params})(delete-template client params)
Generated from Class org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest
  Params keys:
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :timeout             => String time spec (ex: "5s")
Response fields expected #{:headers :acknowledged?}

exists-index

(exists-index {:keys [async? format listener master-node-timeout], :as params})(exists-index client params)
Generated from Class org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest
  Params keys:
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
Response fields expected #{:exists? :headers}

flush-index

(flush-index {:keys [async? force? format full? ignore-indices indices listener operation-threading refresh?], :as params})(flush-index client params)
Generated from Class org.elasticsearch.action.admin.indices.flush.FlushRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :force?              => boolean
    :format              => one of :clj, :json or :java
    :full?               => boolean
    :ignore-indices      => one of :default, :none or :missing
    :listener            => takes a listener object and makes the call async
    :operation-threading => one of :no-threads, :single-thread or :thread-per-shard
    :refresh?            => boolean
Response fields expected #{:failed-shards :successful-shards :headers :shard-failures :total-shards}

gateway-snapshot

(gateway-snapshot {:keys [async? format ignore-indices indices listener operation-threading], :as params})(gateway-snapshot client params)
Generated from Class org.elasticsearch.action.admin.indices.gateway.snapshot.GatewaySnapshotRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :ignore-indices      => one of :default, :none or :missing
    :listener            => takes a listener object and makes the call async
    :operation-threading => one of :no-threads, :single-thread or :thread-per-shard
Response fields expected #{:failed-shards :successful-shards :headers :shard-failures :total-shards}

get-doc

(get-doc {:keys [async? fields format id index listener operation-threaded? parent preference realtime? refresh? routing type], :as params})(get-doc client params)
Generated from Class org.elasticsearch.action.get.GetRequest
Params keys:
  :id                  => (required) String
  :index               => (required) String
  :async?              => if set to true, the call returns a Future instead of blocking
  :fields              => seq of Strings
  :format              => one of :clj, :json or :java
  :listener            => takes a listener object and makes the call async
  :operation-threaded? => boolean
  :parent              => String
  :preference          => String
  :realtime?           => Boolean
  :refresh?            => boolean
  :routing             => String
  :type                => String

get-mapping

(get-mapping client params)(get-mapping params)
Gets mappings from cluster. Wrapper over cluster-state
Params keys:
  :async?   => if set to true, the call returns a Future instead of blocking
  :indices  => seq of Strings
  :listener => takes a listener object and makes the call async
  :types    => seq of Strings

getClient

(getClient this)
returns a Elasticsearch Client instance

index-doc

(index-doc {:keys [async? consistency-level content-type create? format id index listener op-type operation-threaded? parent percolate refresh? replication-type routing source timeout timestamp ttl type version version-type], :as params})(index-doc client params)
Generated from Class org.elasticsearch.action.index.IndexRequest
  Params keys:
    :index               => (required) String
    :source              => (required) HashMap or JSON String or SMILE bytes-array
    :type                => (required) String
    :async?              => if set to true, the call returns a Future instead of blocking
    :consistency-level   => one of :default, :one, :quorum or :all
    :content-type        => one of :json, :smile or :yaml
    :create?             => boolean
    :format              => one of :clj, :json or :java
    :id                  => String
    :listener            => takes a listener object and makes the call async
    :op-type             => one of :index or :create
    :operation-threaded? => boolean
    :parent              => String
    :percolate           => String
    :refresh?            => boolean
    :replication-type    => one of :sync, :async or :default
    :routing             => String
    :timeout             => String time spec (ex: "5s")
    :timestamp           => String
    :ttl                 => Long
    :version             => long
    :version-type        => one of :internal or :external
Response fields expected #{:matches :version :headers :type :index :id}

index-segments

(index-segments {:keys [async? format ignore-indices indices listener operation-threading], :as params})(index-segments client params)
Generated from Class org.elasticsearch.action.admin.indices.segments.IndicesSegmentsRequest
Params keys:
  :async?              => if set to true, the call returns a Future instead of blocking
  :format              => one of :clj, :json or :java
  :ignore-indices      => one of :default, :none or :missing
  :indices             => seq of Strings
  :listener            => takes a listener object and makes the call async
  :operation-threading => one of :no-threads, :single-thread or :thread-per-shard

index-stats

(index-stats {:keys [async? docs? flush? format get? groups ignore-indices indexing? indices listener merge? operation-threading refresh? search? store? types warmer?], :as params})(index-stats client params)
Generated from Class org.elasticsearch.action.admin.indices.stats.IndicesStatsRequest
Params keys:
  :async?              => if set to true, the call returns a Future instead of blocking
  :docs?               => boolean
  :flush?              => boolean
  :format              => one of :clj, :json or :java
  :get?                => boolean
  :groups              => seq of Strings
  :ignore-indices      => one of :default, :none or :missing
  :indexing?           => boolean
  :indices             => seq of Strings
  :listener            => takes a listener object and makes the call async
  :merge?              => boolean
  :operation-threading => one of :no-threads, :single-thread or :thread-per-shard
  :refresh?            => boolean
  :search?             => boolean
  :store?              => boolean
  :types               => seq of Strings
  :warmer?             => boolean

index-status

(index-status {:keys [async? format ignore-indices indices listener operation-threading recovery? snapshot?], :as params})(index-status client params)
Generated from Class org.elasticsearch.action.admin.indices.status.IndicesStatusRequest
Params keys:
  :async?              => if set to true, the call returns a Future instead of blocking
  :format              => one of :clj, :json or :java
  :ignore-indices      => one of :default, :none or :missing
  :indices             => seq of Strings
  :listener            => takes a listener object and makes the call async
  :operation-threading => one of :no-threads, :single-thread or :thread-per-shard
  :recovery?           => boolean
  :snapshot?           => boolean

make-client

(make-client type spec)
creates a client of given type (:node or :transport) and spec

make-listener

(make-listener {:keys [on-failure on-response format], :or {format :clj, on-failure (fn [e] (binding [*out* *err*] (println "Error in listener") (cst/print-cause-trace e)))}})
makes a listener suitable as a callback for requests

make-node

(make-node {:keys [local-mode client-mode load-config cluster-name settings hosts], :or {client-mode true, load-config false, local-mode false, settings {}}, :as args})
makes a new native elasticsearch node

make-transport-client

(make-transport-client {:keys [load-config cluster-name settings hosts sniff], :or {client-mode true, load-config false, local-mode false, settings {}, sniff true}, :as args})
creates a transport client

map->ESNodeClient

(map->ESNodeClient m__5665__auto__)
Factory function for class clj_elasticsearch.client.ESNodeClient, taking a map of keywords to field values.

more-like-this

(more-like-this {:keys [async? boost-terms fields format id listener listener-threaded? max-doc-freq max-query-terms max-word-len min-doc-freq min-term-freq min-word-len percent-terms-to-match search-from search-indices search-query-hint search-scroll search-size search-source search-type search-types stop-words type], :as params})(more-like-this client params)
Generated from Class org.elasticsearch.action.mlt.MoreLikeThisRequest
Params keys:
  :id                     => (required) String
  :type                   => (required) String
  :async?                 => if set to true, the call returns a Future instead of blocking
  :boost-terms            => float
  :fields                 => seq of Strings
  :format                 => one of :clj, :json or :java
  :listener               => takes a listener object and makes the call async
  :listener-threaded?     => boolean
  :max-doc-freq           => int
  :max-query-terms        => int
  :max-word-len           => int
  :min-doc-freq           => int
  :min-term-freq          => int
  :min-word-len           => int
  :percent-terms-to-match => float
  :search-from            => int
  :search-indices         => seq of Strings
  :search-query-hint      => String
  :search-scroll          => String time spec (ex: "5s")
  :search-size            => int
  :search-source          => HashMap or JSON String or SMILE bytes-array
  :search-type            => one of :dfs-query-then-fetch, :query-then-fetch, :dfs-query-and-fetch, :query-and-fetch, :scan or :count
  :search-types           => seq of Strings
  :stop-words             => seq of Strings

node-info

(node-info {:keys [async? format http? jvm? listener network? nodes-ids os? process? thread-pool? timeout tings? transport?], :as params})(node-info client params)
Generated from Class org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequest
  Params keys:
    :async?       => if set to true, the call returns a Future instead of blocking
    :format       => one of :clj, :json or :java
    :http?        => boolean
    :jvm?         => boolean
    :listener     => takes a listener object and makes the call async
    :network?     => boolean
    :nodes-ids    => seq of Strings
    :os?          => boolean
    :process?     => boolean
    :thread-pool? => boolean
    :timeout      => String time spec (ex: "5s")
    :tings?       => boolean
    :transport?   => boolean
Response fields expected #{:nodes-map :nodes :headers :cluster-name}

node-restart

(node-restart {:keys [async? delay format listener nodes-ids timeout], :as params})(node-restart client params)
Generated from Class org.elasticsearch.action.admin.cluster.node.restart.NodesRestartRequest
  Params keys:
    :nodes-ids => (required) seq of Strings
    :async?    => if set to true, the call returns a Future instead of blocking
    :delay     => String time spec (ex: "5s")
    :format    => one of :clj, :json or :java
    :listener  => takes a listener object and makes the call async
    :timeout   => String time spec (ex: "5s")
Response fields expected #{:nodes-map :nodes :headers :cluster-name}

node-shutdown

(node-shutdown {:keys [async? delay exit? format listener master-node-timeout nodes-ids], :as params})(node-shutdown client params)
Generated from Class org.elasticsearch.action.admin.cluster.node.shutdown.NodesShutdownRequest
  Params keys:
    :nodes-ids           => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :delay               => String time spec (ex: "5s")
    :exit?               => boolean
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
Response fields expected #{:nodes :headers :cluster-name}

nodes-stats

(nodes-stats {:keys [async? format fs? http? indices? jvm? listener network? nodes-ids os? process? thread-pool? timeout transport?], :as params})(nodes-stats client params)
Generated from Class org.elasticsearch.action.admin.cluster.node.stats.NodesStatsRequest
  Params keys:
    :nodes-ids    => (required) seq of Strings
    :async?       => if set to true, the call returns a Future instead of blocking
    :format       => one of :clj, :json or :java
    :fs?          => boolean
    :http?        => boolean
    :indices?     => boolean
    :jvm?         => boolean
    :listener     => takes a listener object and makes the call async
    :network?     => boolean
    :os?          => boolean
    :process?     => boolean
    :thread-pool? => boolean
    :timeout      => String time spec (ex: "5s")
    :transport?   => boolean
Response fields expected #{:nodes-map :nodes :headers :cluster-name}

optimize-index

(optimize-index {:keys [async? flush? format ignore-indices indices listener max-num-segments only-expunge-deletes? operation-threading refresh? wait-for-merge?], :as params})(optimize-index client params)
Generated from Class org.elasticsearch.action.admin.indices.optimize.OptimizeRequest
  Params keys:
    :async?                => if set to true, the call returns a Future instead of blocking
    :flush?                => boolean
    :format                => one of :clj, :json or :java
    :ignore-indices        => one of :default, :none or :missing
    :indices               => seq of Strings
    :listener              => takes a listener object and makes the call async
    :max-num-segments      => int
    :only-expunge-deletes? => boolean
    :operation-threading   => one of :no-threads, :single-thread or :thread-per-shard
    :refresh?              => boolean
    :wait-for-merge?       => boolean
Response fields expected #{:failed-shards :successful-shards :headers :shard-failures :total-shards}

percolate

(percolate {:keys [async? format index listener operation-threaded? prefer-local? source type], :as params})(percolate client params)
Generated from Class org.elasticsearch.action.percolate.PercolateRequest
  Params keys:
    :index               => (required) String
    :source              => (required) HashMap or JSON String or SMILE bytes-array
    :type                => (required) String
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :operation-threaded? => boolean
    :prefer-local?       => boolean
Response fields expected #{:headers}

put-mapping

(put-mapping {:keys [async? format ignore-conflicts? indices listener master-node-timeout source timeout type], :as params})(put-mapping client params)
Generated from Class org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :ignore-conflicts?   => boolean
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :source              => HashMap or JSON String
    :timeout             => String time spec (ex: "5s")
    :type                => String
Response fields expected #{:headers :acknowledged?}

put-template

(put-template {:keys [async? cause create? custom format listener master-node-timeout name order source template timeout tings], :as params})(put-template client params)
Generated from Class org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest
  Params keys:
    :name                => (required) String
    :async?              => if set to true, the call returns a Future instead of blocking
    :cause               => String
    :create?             => boolean
    :custom              => IndexMetaData$Custom
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :order               => int
    :source              => HashMap or JSON String or SMILE bytes-array
    :template            => String
    :timeout             => String time spec (ex: "5s")
    :tings               => HashMap of Settings
Response fields expected #{:headers :acknowledged?}

refresh-index

(refresh-index {:keys [async? format ignore-indices indices listener operation-threading wait-for-operations?], :as params})(refresh-index client params)
Generated from Class org.elasticsearch.action.admin.indices.refresh.RefreshRequest
  Params keys:
    :indices              => (required) seq of Strings
    :async?               => if set to true, the call returns a Future instead of blocking
    :format               => one of :clj, :json or :java
    :ignore-indices       => one of :default, :none or :missing
    :listener             => takes a listener object and makes the call async
    :operation-threading  => one of :no-threads, :single-thread or :thread-per-shard
    :wait-for-operations? => boolean
Response fields expected #{:failed-shards :successful-shards :headers :shard-failures :total-shards}

scroll

(scroll {:keys [async? format listener listener-threaded? operation-threading scroll scroll-id], :as params})(scroll client params)
Generated from Class org.elasticsearch.action.search.SearchScrollRequest
Params keys:
  :scroll-id           => (required) String
  :async?              => if set to true, the call returns a Future instead of blocking
  :format              => one of :clj, :json or :java
  :listener            => takes a listener object and makes the call async
  :listener-threaded?  => boolean
  :operation-threading => one of :no-threads, :single-thread or :thread-per-shard
  :scroll              => String time spec (ex: "5s")

update-cluster-settings

(update-cluster-settings {:keys [async? format listener master-node-timeout persistent-settings transient-settings], :as params})(update-cluster-settings client params)
Generated from Class org.elasticsearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest
  Params keys:
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :persistent-settings => HashMap of Settings
    :transient-settings  => HashMap of Settings
Response fields expected #{:headers}

update-doc

(update-doc {:keys [async? consistency-level doc fields format id index listener parent percolate refresh? replication-type retry-on-conflict routing script script-lang script-params source timeout type upsert], :as params})(update-doc client params)
Generated from Class org.elasticsearch.action.update.UpdateRequest
  Params keys:
    :id                => (required) String
    :index             => (required) String
    :script            => (required) String
    :type              => (required) String
    :async?            => if set to true, the call returns a Future instead of blocking
    :consistency-level => one of :default, :one, :quorum or :all
    :doc               => HashMap or JSON String or SMILE bytes-array
    :fields            => seq of Strings
    :format            => one of :clj, :json or :java
    :listener          => takes a listener object and makes the call async
    :parent            => String
    :percolate         => String
    :refresh?          => boolean
    :replication-type  => one of :sync, :async or :default
    :retry-on-conflict => int
    :routing           => String
    :script-lang       => String
    :script-params     => Map
    :source            => HashMap or JSON String or SMILE bytes-array
    :timeout           => String time spec (ex: "5s")
    :upsert            => HashMap or JSON String or SMILE bytes-array
Response fields expected #{:matches :version :headers :result :type :index :get-result :id}

update-index-settings

(update-index-settings {:keys [async? format indices listener master-node-timeout tings], :as params})(update-index-settings client params)
Generated from Class org.elasticsearch.action.admin.indices.settings.UpdateSettingsRequest
  Params keys:
    :indices             => (required) seq of Strings
    :async?              => if set to true, the call returns a Future instead of blocking
    :format              => one of :clj, :json or :java
    :listener            => takes a listener object and makes the call async
    :master-node-timeout => String time spec (ex: "5s")
    :tings               => HashMap of Settings
Response fields expected #{:headers}

update-settings-builder

(update-settings-builder builder settings)(update-settings-builder settings)
creates or updates a settingsBuilder with the given hash-map

with-client

macro

(with-client client & body)
uses an existing client in the body, does not close it afterward

with-node-client

macro

(with-node-client server-spec & body)
opens a node client with given spec and executes the body before closing it

with-transport-client

macro

(with-transport-client server-spec & body)
opens a transport client with given spec and executes the body before closing it