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

Included in:
ClusterClient
Defined in:
lib/elasticsearch/api/namespace/cluster.rb,
lib/elasticsearch/api/actions/cluster/info.rb,
lib/elasticsearch/api/actions/cluster/state.rb,
lib/elasticsearch/api/actions/cluster/stats.rb,
lib/elasticsearch/api/actions/cluster/health.rb,
lib/elasticsearch/api/actions/cluster/reroute.rb,
lib/elasticsearch/api/actions/cluster/remote_info.rb,
lib/elasticsearch/api/actions/cluster/get_settings.rb,
lib/elasticsearch/api/actions/cluster/put_settings.rb,
lib/elasticsearch/api/actions/cluster/pending_tasks.rb,
lib/elasticsearch/api/actions/cluster/allocation_explain.rb,
lib/elasticsearch/api/actions/cluster/get_component_template.rb,
lib/elasticsearch/api/actions/cluster/put_component_template.rb,
lib/elasticsearch/api/actions/cluster/delete_component_template.rb,
lib/elasticsearch/api/actions/cluster/exists_component_template.rb,
lib/elasticsearch/api/actions/cluster/post_voting_config_exclusions.rb,
lib/elasticsearch/api/actions/cluster/delete_voting_config_exclusions.rb

Instance Method Summary collapse

Instance Method Details

#allocation_explain(arguments = {}) ⇒ Object

Provides explanations for shard allocations in the cluster.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :include_yes_decisions (Boolean) —

    Return ‘YES’ decisions in explanation (default: false)

  • :include_disk_info (Boolean) —

    Return information about disk usage and shard sizes (default: false)

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The index, shard, and primary flag to explain. Empty means ‘explain a randomly-chosen unassigned shard’

See Also:



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

def allocation_explain(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.allocation_explain' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = arguments.delete(:body)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = '_cluster/allocation/explain'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_component_template(arguments = {}) ⇒ Object

Deletes a component template

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :name (String) —

    The name of the template

  • :timeout (Time) —

    Explicit operation timeout

  • :master_timeout (Time) —

    Specify timeout for connection to master

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



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
 
# File 'lib/elasticsearch/api/actions/cluster/delete_component_template.rb', line 34

def delete_component_template(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.delete_component_template' }

  defined_params = [:name].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'name' missing" unless arguments[:name]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _name = arguments.delete(:name)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_component_template/#{Utils.__listify(_name)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_voting_config_exclusions(arguments = {}) ⇒ Object

Clears cluster voting config exclusions.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :wait_for_removal (Boolean) —

    Specifies whether to wait for all excluded nodes to be removed from the cluster before clearing the voting configuration exclusions list.

  • :master_timeout (Time) —

    Timeout for submitting request to master

  • :headers (Hash) —

    Custom HTTP headers

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/elasticsearch/api/actions/cluster/delete_voting_config_exclusions.rb', line 33

def delete_voting_config_exclusions(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.delete_voting_config_exclusions' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  method = Elasticsearch::API::HTTP_DELETE
  path   = '_cluster/voting_config_exclusions'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#exists_component_template(arguments = {}) ⇒ Object Also known as: exists_component_template?

Returns information about whether a particular component template exist

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :name (String) —

    The name of the template

  • :master_timeout (Time) —

    Explicit operation timeout for connection to master node

  • :local (Boolean) —

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

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



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
 
# File 'lib/elasticsearch/api/actions/cluster/exists_component_template.rb', line 34

def exists_component_template(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.exists_component_template' }

  defined_params = [:name].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'name' missing" unless arguments[:name]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _name = arguments.delete(:name)

  method = Elasticsearch::API::HTTP_HEAD
  path   = "_component_template/#{Utils.__listify(_name)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_component_template(arguments = {}) ⇒ Object

Returns one or more component templates

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :name (List) —

    The comma separated names of the component templates

  • :master_timeout (Time) —

    Explicit operation timeout for connection to master node

  • :local (Boolean) —

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

  • :include_defaults (Boolean) —

    Return all default configurations for the component template (default: false)

  • :headers (Hash) —

    Custom HTTP headers

See Also:



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
 
# File 'lib/elasticsearch/api/actions/cluster/get_component_template.rb', line 35

def get_component_template(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.get_component_template' }

  defined_params = [:name].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _name = arguments.delete(:name)

  method = Elasticsearch::API::HTTP_GET
  path   = if _name
             "_component_template/#{Utils.__listify(_name)}"
           else
             '_component_template'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_settings(arguments = {}) ⇒ Object

Returns cluster settings.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :flat_settings (Boolean) —

    Return settings in flat format (default: false)

  • :master_timeout (Time) —

    Explicit operation timeout for connection to master node

  • :timeout (Time) —

    Explicit operation timeout

  • :include_defaults (Boolean) —

    Whether to return all default clusters setting.

  • :headers (Hash) —

    Custom HTTP headers

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/elasticsearch/api/actions/cluster/get_settings.rb', line 35

def get_settings(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.get_settings' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  method = Elasticsearch::API::HTTP_GET
  path   = '_cluster/settings'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#health(arguments = {}) ⇒ Object

Returns basic information about the health of the cluster.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :index (List) —

    Limit the information returned to a specific index

  • :expand_wildcards (String) —

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all)

  • :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 (String) —

    Wait until the specified number of shards is active

  • :wait_for_nodes (String) —

    Wait until the specified number of nodes is available

  • :wait_for_events (String) —

    Wait until all currently queued events with the given priority are processed (options: immediate, urgent, high, normal, low, languid)

  • :wait_for_no_relocating_shards (Boolean) —

    Whether to wait until there are no relocating shards in the cluster

  • :wait_for_no_initializing_shards (Boolean) —

    Whether to wait until there are no initializing shards in the cluster

  • :wait_for_status (String) —

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

  • :headers (Hash) —

    Custom HTTP headers

See Also:



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
 
# File 'lib/elasticsearch/api/actions/cluster/health.rb', line 43

def health(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.health' }

  defined_params = [:index].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  _index = arguments.delete(:index)

  method = Elasticsearch::API::HTTP_GET
  path   = if _index
             "_cluster/health/#{Utils.__listify(_index)}"
           else
             '_cluster/health'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#info(arguments = {}) ⇒ Object

Returns different information about the cluster.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :target (List) —

    Limit the information returned to the specified target. (options: _all, http, ingest, thread_pool, script)

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



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

def info(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.info' }

  defined_params = [:target].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'target' missing" unless arguments[:target]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _target = arguments.delete(:target)

  method = Elasticsearch::API::HTTP_GET
  path   = "_info/#{Utils.__listify(_target)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
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.

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

  • :headers (Hash) —

    Custom HTTP headers

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/elasticsearch/api/actions/cluster/pending_tasks.rb', line 34

def pending_tasks(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.pending_tasks' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  method = Elasticsearch::API::HTTP_GET
  path   = '_cluster/pending_tasks'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#post_voting_config_exclusions(arguments = {}) ⇒ Object

Updates the cluster voting config exclusions by node ids or node names.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :node_ids (String) —

    A comma-separated list of the persistent ids of the nodes to exclude from the voting configuration. If specified, you may not also specify ?node_names.

  • :node_names (String) —

    A comma-separated list of the names of the nodes to exclude from the voting configuration. If specified, you may not also specify ?node_ids.

  • :timeout (Time) —

    Explicit operation timeout

  • :master_timeout (Time) —

    Timeout for submitting request to master

  • :headers (Hash) —

    Custom HTTP headers

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/elasticsearch/api/actions/cluster/post_voting_config_exclusions.rb', line 35

def post_voting_config_exclusions(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.post_voting_config_exclusions' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  method = Elasticsearch::API::HTTP_POST
  path   = '_cluster/voting_config_exclusions'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_component_template(arguments = {}) ⇒ Object

Creates or updates a component template

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :name (String) —

    The name of the template

  • :create (Boolean) —

    Whether the index template should only be added if new or can also replace an existing one

  • :timeout (Time) —

    Explicit operation timeout

  • :master_timeout (Time) —

    Specify timeout for connection to master

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The template definition (Required)

Raises:

  • (ArgumentError)

See Also:



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
 
# File 'lib/elasticsearch/api/actions/cluster/put_component_template.rb', line 36

def put_component_template(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.put_component_template' }

  defined_params = [:name].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'name' missing" unless arguments[:name]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _name = arguments.delete(:name)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_component_template/#{Utils.__listify(_name)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_settings(arguments = {}) ⇒ Object

Updates the cluster settings.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :flat_settings (Boolean) —

    Return settings in flat format (default: false)

  • :master_timeout (Time) —

    Explicit operation timeout for connection to master node

  • :timeout (Time) —

    Explicit operation timeout

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

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

Raises:

  • (ArgumentError)

See Also:



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

def put_settings(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.put_settings' }

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body) || {}

  method = Elasticsearch::API::HTTP_PUT
  path   = '_cluster/settings'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#remote_info(arguments = {}) ⇒ Object

Returns the information about configured remote clusters.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :headers (Hash) —

    Custom HTTP headers

See Also:



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

def remote_info(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.remote_info' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  method = Elasticsearch::API::HTTP_GET
  path   = '_remote/info'
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#reroute(arguments = {}) ⇒ Object

Allows to manually change the allocation of individual shards in the cluster.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :dry_run (Boolean) —

    Simulate the operation only and return the resulting state

  • :explain (Boolean) —

    Return an explanation of why the commands can or cannot be executed

  • :retry_failed (Boolean) —

    Retries allocation of shards that are blocked due to too many subsequent allocation failures

  • :metric (List) —

    Limit the information returned to the specified metrics. Defaults to all but metadata (options: _all, blocks, metadata, nodes, none, routing_table, master_node, version)

  • :master_timeout (Time) —

    Explicit operation timeout for connection to master node

  • :timeout (Time) —

    Explicit operation timeout

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

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

See Also:



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/elasticsearch/api/actions/cluster/reroute.rb', line 38

def reroute(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.reroute' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body) || {}

  method = Elasticsearch::API::HTTP_POST
  path   = '_cluster/reroute'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#state(arguments = {}) ⇒ Object

Returns a comprehensive information about the state of the cluster.

Parameters:

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

    a customizable set of options

Options Hash (arguments):

  • :metric (List) —

    Limit the information returned to the specified metrics (options: _all, blocks, metadata, nodes, routing_table, routing_nodes, master_node, version)

  • :index (List) —

    A comma-separated list of index names; use ‘_all` or empty string to perform the operation on all indices

  • :local (Boolean) —

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

  • :master_timeout (Time) —

    Specify timeout for connection to master

  • :flat_settings (Boolean) —

    Return settings in flat format (default: false)

  • :wait_for_metadata_version (Number) —

    Wait for the metadata version to be equal or greater than the specified metadata version

  • :wait_for_timeout (Time) —

    The maximum time to wait for wait_for_metadata_version before timing out

  • :ignore_unavailable (Boolean) —

    Whether specified concrete indices should be ignored when unavailable (missing or closed)

  • :allow_no_indices (Boolean) —

    Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes ‘_all` string or when no indices have been specified)

  • :expand_wildcards (String) —

    Whether to expand wildcard expression to concrete indices that are open, closed or both. (options: open, closed, hidden, none, all)

  • :headers (Hash) —

    Custom HTTP headers

See Also:



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/state.rb', line 41

def state(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.state' }

  defined_params = %i[metric index].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _metric = arguments.delete(:metric)

  _index = arguments.delete(:index)

  method = Elasticsearch::API::HTTP_GET
  path   = if _metric && _index
             "_cluster/state/#{Utils.__listify(_metric)}/#{Utils.__listify(_index)}"
           elsif _metric
             "_cluster/state/#{Utils.__listify(_metric)}"
           else
             '_cluster/state'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#stats(arguments = {}) ⇒ Object

Returns high-level overview of cluster statistics.

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

  • :flat_settings (Boolean) —

    Return settings in flat format (default: false)

  • :timeout (Time) —

    Explicit operation timeout

  • :headers (Hash) —

    Custom HTTP headers

See Also:



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
 
# File 'lib/elasticsearch/api/actions/cluster/stats.rb', line 34

def stats(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'cluster.stats' }

  defined_params = [:node_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _node_id = arguments.delete(:node_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _node_id
             "_cluster/stats/nodes/#{Utils.__listify(_node_id)}"
           else
             '_cluster/stats'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end