Module: Elasticsearch::API::Cluster::Actions

Included in:
ClusterClient
Defined in:
lib/elasticsearch/api/namespace/cluster.rb,
lib/elasticsearch/api/actions/cluster/state.rb,
lib/elasticsearch/api/actions/cluster/health.rb,
lib/elasticsearch/api/actions/cluster/reroute.rb,
lib/elasticsearch/api/actions/cluster/node_info.rb,
lib/elasticsearch/api/actions/cluster/node_stats.rb,
lib/elasticsearch/api/actions/cluster/get_settings.rb,
lib/elasticsearch/api/actions/cluster/put_settings.rb,
lib/elasticsearch/api/actions/cluster/node_shutdown.rb,
lib/elasticsearch/api/actions/cluster/pending_tasks.rb,
lib/elasticsearch/api/actions/cluster/node_hot_threads.rb

Instance Method Summary collapse

Instance Method Details

#get_settings(arguments = {}) ⇒ Object

Get the cluster settings (previously set with #put_settings)

Examples:

Get cluster settings


client.cluster.get_settings

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :flat_settings (Boolean) —

    Return settings in flat format (default: false)

See Also:



16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/elasticsearch/api/actions/cluster/get_settings.rb', line 16

def get_settings(arguments={})
  valid_params = [
    :flat_settings
  ]

  method = 'GET'
  path   = "_cluster/settings"
  params = Utils.__validate_and_extract_params arguments, valid_params
  body   = nil

  perform_request(method, path, params, body).body
end

#health(arguments = {}) ⇒ Object

Returns information about cluster “health”.

Examples:


client.cluster.health

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :index (String) —

    Limit the information returned to a specific index

  • :level (String) —

    Specify the level of detail for returned information (options: cluster, indices, shards)

  • :local (Boolean) —

    Return local information, do not retrieve the state from master node (default: false)

  • :master_timeout (Time) —

    Explicit operation timeout for connection to master node

  • :timeout (Time) —

    Explicit operation timeout

  • :wait_for_active_shards (Number) —

    Wait until the specified number of shards is active

  • :wait_for_nodes (Number) —

    Wait until the specified number of nodes is available

  • :wait_for_relocating_shards (Number) —

    Wait until the specified number of relocating shards is finished

  • :wait_for_status (String) —

    Wait until cluster is in a specific state (options: green, yellow, red)

See Also:



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/elasticsearch/api/actions/cluster/health.rb', line 28

def health(arguments={})
  valid_params = [
    :level,
    :local,
    :master_timeout,
    :timeout,
    :wait_for_active_shards,
    :wait_for_nodes,
    :wait_for_relocating_shards,
    :wait_for_status ]

  method = 'GET'
  path   = "_cluster/health"

  params = Utils.__validate_and_extract_params arguments, valid_params
  body = nil

  perform_request(method, path, params, body).body
end

#node_hot_threads(arguments = {}) ⇒ String

Returns information about the hottest threads in the cluster or on a specific node as a String.

The information is returned as text, and allows you to understand what are currently the most taxing operations happening in the cluster, for debugging or monitoring purposes.

Examples:

Return 10 hottest threads


client.cluster.node_hot_threads threads: 10

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :node_id (List) —

    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

  • :interval (Time) —

    The interval for the second sampling of threads

  • :snapshots (Number) —

    Number of samples of thread stacktrace (default: 10)

  • :threads (Number) —

    Specify the number of threads to provide information for (default: 3)

  • :type (String) —

    The type to sample (default: cpu) (options: cpu, wait, block)

Returns:

  • (String)

See Also:



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/elasticsearch/api/actions/cluster/node_hot_threads.rb', line 28

def node_hot_threads(arguments={})
  valid_params = [
    :interval,
    :snapshots,
    :threads,
    :type ]

  method = 'GET'
  path   = Utils.__pathify '_nodes', Utils.__listify(arguments[:node_id]), 'hot_threads'

  params = Utils.__validate_and_extract_params arguments, valid_params
  body = nil

  perform_request(method, path, params, body).body
end

#node_info(arguments = {}) ⇒ Object

Returns information about nodes in the cluster (cluster settings, JVM version, etc).

Use the ‘all` option to return all available settings, or limit the information returned to a specific type (eg. `http`).

Use the ‘node_id` option to limit information to specific node(s).

Examples:

Return information about JVM


client.cluster.node_info jvm: true

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :node_id (List) —

    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

  • :all (Boolean) —

    Return all available information

  • :clear (Boolean) —

    Reset the default settings

  • :http (Boolean) —

    Return information about HTTP

  • :jvm (Boolean) —

    Return information about the JVM

  • :network (Boolean) —

    Return information about network

  • :os (Boolean) —

    Return information about the operating system

  • :plugin (Boolean) —

    Return information about plugins

  • :process (Boolean) —

    Return information about the Elasticsearch process

  • :settings (Boolean) —

    Return information about node settings

  • :thread_pool (Boolean) —

    Return information about the thread pool

  • :transport (Boolean) —

    Return information about transport

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/elasticsearch/api/actions/cluster/node_info.rb', line 34

def node_info(arguments={})
  valid_params = [
    :all,
    :clear,
    :http,
    :jvm,
    :network,
    :os,
    :plugin,
    :process,
    :settings,
    :thread_pool,
    :transport ]

  method = 'GET'
  path   = Utils.__pathify '_nodes', Utils.__listify(arguments[:node_id])

  params = Utils.__validate_and_extract_params arguments, valid_params
  body = nil

  perform_request(method, path, params, body).body
end

#node_shutdown(arguments = {}) ⇒ Object

Shutdown one or all nodes

Examples:

Shut down node named Bloke


client.cluster.node_shutdown node_id: 'Bloke'

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :node_id (List) —

    A comma-separated list of node IDs or names to perform the operation on; use ‘_local` to shutdown the node you’re connected to, leave empty to shutdown all nodes

  • :delay (Time) —

    Set the delay for the operation (default: 1s)

  • :exit (Boolean) —

    Exit the JVM as well (default: true)

See Also:



20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/elasticsearch/api/actions/cluster/node_shutdown.rb', line 20

def node_shutdown(arguments={})
  valid_params = [
    :delay,
    :exit ]

  method = 'POST'
  path   = Utils.__pathify '_nodes', Utils.__listify(arguments[:node_id]), '_shutdown'

  params = Utils.__validate_and_extract_params arguments, valid_params
  body   = nil

  perform_request(method, path, params, body).body
end

#node_stats(arguments = {}) ⇒ Object

Returns statistical information about nodes in the cluster.

Examples:

Return statistics about JVM


client.cluster.node_stats clear: true, jvm: true

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :metric (List) —

    Limit the information returned for ‘indices` family to a specific metric (options: docs, fielddata, filter_cache, flush, get, id_cache, indexing, merges, refresh, search, store, warmer)

  • :node_id (List) —

    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

  • :all (Boolean) —

    Return all available information

  • :clear (Boolean) —

    Reset the default level of detail

  • :fields (List) —

    A comma-separated list of fields for ‘fielddata` metric (supports wildcards)

  • :fs (Boolean) —

    Return information about the filesystem

  • :http (Boolean) —

    Return information about HTTP

  • :indices (Boolean) —

    Return information about indices

  • :jvm (Boolean) —

    Return information about the JVM

  • :network (Boolean) —

    Return information about network

  • :os (Boolean) —

    Return information about the operating system

  • :process (Boolean) —

    Return information about the Elasticsearch process

  • :thread_pool (Boolean) —

    Return information about the thread pool

  • :transport (Boolean) —

    Return information about transport

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/elasticsearch/api/actions/cluster/node_stats.rb', line 33

def node_stats(arguments={})
  valid_params = [
    :all,
    :clear,
    :fields,
    :fs,
    :http,
    :indices,
    :jvm,
    :network,
    :os,
    :process,
    :thread_pool,
    :transport ]

  method = 'GET'

  case
    # Field data metric for the `indices` metric family
    when arguments[:indices] && arguments[:metric] == 'fielddata'
      path   = Utils.__pathify '_nodes', Utils.__listify(arguments[:node_id]), 'stats/indices/fielddata'
      params = { :fields => Utils.__listify(arguments[:fields]) }

    # `indices` metric family incl. a metric
    when arguments[:indices] && arguments[:metric]
      path   = Utils.__pathify( '_nodes', Utils.__listify(arguments[:node_id]), 'stats/indices', arguments[:metric] )
      params = {}

    else
      path   = Utils.__pathify( '_nodes', Utils.__listify(arguments[:node_id]), 'stats' )

      params = Utils.__validate_and_extract_params arguments, valid_params
      params[:fields] = Utils.__listify(params[:fields]) if params[:fields]
  end

  body = nil

  perform_request(method, path, params, body).body
end

#pending_tasks(arguments = {}) ⇒ Object

Returns a list of any cluster-level changes (e.g. create index, update mapping, allocate or fail shard) which have not yet been executed and are queued up.

Examples:

Get a list of currently queued up tasks in the cluster


client.cluster.pending_tasks

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :local (Boolean) —

    Return local information, do not retrieve the state from master node (default: false)

  • :master_timeout (Time) —

    Specify timeout for connection to master

See Also:



19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/elasticsearch/api/actions/cluster/pending_tasks.rb', line 19

def pending_tasks(arguments={})
  valid_params = [
    :local,
    :master_timeout ]
  method = 'GET'
  path   = "/_cluster/pending_tasks"
  params = Utils.__validate_and_extract_params arguments, valid_params
  body   = nil

  perform_request(method, path, params, body).body
end

#put_settings(arguments = {}) ⇒ Object

Update cluster settings.

Examples:

Disable shard allocation in the cluster until restart


client.cluster.put_settings body: { transient: { 'cluster.routing.allocation.disable_allocation' => true } }

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :body (Hash) —

    The settings to be updated. Can be either ‘transient` or `persistent` (survives cluster restart).

See Also:



17
18
19
20
21
22
23
24
 
# File 'lib/elasticsearch/api/actions/cluster/put_settings.rb', line 17

def put_settings(arguments={})
  method = 'PUT'
  path   = "_cluster/settings"
  params = {}
  body   = arguments[:body] || {}

  perform_request(method, path, params, body).body
end

#reroute(arguments = {}) ⇒ Object

Note:

If you want to explicitely set the shard allocation to a certain node, you might want to look at the ‘allocation.*` cluster settings.

Perform manual shard allocation in the cluster.

Pass the operations you want to perform in the ‘:body` option. Use the `dry_run` option to evaluate the result of operations without actually performing them.

Examples:

Move shard ‘0` of index `myindex` from node named Node1 to node named Node2


client.cluster.reroute body: {
  commands: [
    { move: { index: 'myindex', shard: 0, from_node: 'Node1', to_node: 'Node2' } }
  ]
}

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :body (Hash) —

    The definition of ‘commands` to perform (`move`, `cancel`, `allocate`)

  • :dry_run (Boolean) —

    Simulate the operation only and return the resulting state

  • :filter_metadata (Boolean) —

    Don’t return cluster state metadata (default: false)

See Also:



28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/elasticsearch/api/actions/cluster/reroute.rb', line 28

def reroute(arguments={})
  valid_params = [ :dry_run, :filter_metadata ]

  method = 'POST'
  path   = "_cluster/reroute"

  params = Utils.__validate_and_extract_params arguments, valid_params
  body   = arguments[:body] || {}

  perform_request(method, path, params, body).body
end

#state(arguments = {}) ⇒ Object

Get information about the cluster state (indices settings, allocations, etc)

Examples:


client.cluster.state

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :filter_blocks (Boolean) —

    Do not return information about blocks

  • :filter_index_templates (Boolean) —

    Do not return information about index templates

  • :filter_indices (List) —

    Limit returned metadata information to specific indices

  • :filter_metadata (Boolean) —

    Do not return information about indices metadata

  • :filter_nodes (Boolean) —

    Do not return information about nodes

  • :filter_routing_table (Boolean) —

    Do not return information about shard allocation (‘routing_table` and `routing_nodes`)

  • :local (Boolean) —

    Return local information, do not retrieve the state from master node (default: false)

  • :master_timeout (Time) —

    Specify timeout for connection to master

See Also:



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/elasticsearch/api/actions/cluster/state.rb', line 25

def state(arguments={})
  valid_params = [
    :filter_blocks,
    :filter_index_templates,
    :filter_indices,
    :filter_metadata,
    :filter_nodes,
    :filter_routing_table,
    :local,
    :master_timeout ]

  method = 'GET'
  path   = "_cluster/state"

  params = Utils.__validate_and_extract_params arguments, valid_params
  body = nil

  perform_request(method, path, params, body).body
end