Module: Arango::Server::Administration

Included in:
Arango::Server
Defined in:
lib/arango/server/administration.rb

Overview

Arango Server Administration

Instance Method Summary collapse

Instance Method Details

#agent? ⇒ Boolean

Check if server role is AGENT.



155
156
157
 
# File 'lib/arango/server/administration.rb', line 155

def agent?
  role == 'AGENT'
end

#available? ⇒ Boolean

Check availability of the server.



10
11
12
 
# File 'lib/arango/server/administration.rb', line 10

def available?
  200 == Arango::Requests::Administration::Availability.execute(server: self).response_code
end

#cluster_endpoints ⇒ Array<String>

Returns information about all coordinator endpoints (cluster only).



16
17
18
19
20
21
 
# File 'lib/arango/server/administration.rb', line 16

def cluster_endpoints
  if in_cluster?
    result = Arango::Requests::Administration::ClusterEndpoints.execute(server: self)
    result.endpoints.map { |e| e[:endpoint] }
  end
end

#coordinator? ⇒ Boolean

Check if server role is COORDINATOR.



161
162
163
 
# File 'lib/arango/server/administration.rb', line 161

def coordinator?
  role == 'COORDINATOR'
end

#detailed_version ⇒ Arango::Result

Return server version details. The response will contain a details attribute with additional information about included components and their versions. The attribute names and internals of the details object may vary depending on platform and ArangoDB version.



229
230
231
 
# File 'lib/arango/server/administration.rb', line 229

def detailed_version
  Arango::Requests::Administration::Version.execute(server: self, params: {details: true})
end

#echo(request_hash) ⇒ Hash

Send back what was sent in, headers, post body etc.



33
34
35
 
# File 'lib/arango/server/administration.rb', line 33

def echo(request_hash)
  Arango::Requests::Administration::Echo.execute(server: self, body: request_hash)
end

#endpoints ⇒ Array<String>

Returns information about all server endpoints.



25
26
27
28
 
# File 'lib/arango/server/administration.rb', line 25

def endpoints
  result = Arango::Requests::Administration::Endpoints.execute(server: self)
  result.map { |e| e[:endpoint] }
end

#engine ⇒ Arango::Result

Return server database engine information



39
40
41
 
# File 'lib/arango/server/administration.rb', line 39

def engine
  @engine ||= Arango::Requests::Administration::Engine.execute(server: self)
end

#enterprise? ⇒ Boolean

Check if the server has the enterprise license.



215
216
217
 
# File 'lib/arango/server/administration.rb', line 215

def enterprise?
  @enterprise ||= (status.license == 'enterprise')
end

#flush_wal(wait_for_sync: false, wait_for_collector: false) ⇒ Object

Flushes the write-ahead log. By flushing the currently active write-ahead logfile, the data in it can be transferred to collection journals and datafiles. This is useful to ensure that all data for a collection is present in the collection journals and datafiles, for example, when dumping the data of a collection.



257
258
259
260
261
262
263
 
# File 'lib/arango/server/administration.rb', line 257

def flush_wal(wait_for_sync: false, wait_for_collector: false)
  params = {
    waitForSync: wait_for_sync,
    waitForCollector: wait_for_collector
  }
  200 == Arango::Requests::Wal::Flush.execute(server: self, params: params).response_code
end

#in_cluster? ⇒ Boolean

Check if server is part of a cluster.



185
186
187
 
# File 'lib/arango/server/administration.rb', line 185

def in_cluster?
  coordinator? || primary? || agent? || secondary?
end

#log(upto: nil, level: nil, start: nil, size: nil, offset: nil, search: nil, sort: nil) ⇒ Arango::Result

Read global logs from the server. Log levels for the upto and level params:

  • fatal or 0

  • error or 1

  • warning or 2

  • info or 3

  • debug or 4

The parameters upto and level are mutually exclusive. All params are optional.



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/arango/server/administration.rb', line 72

def log(upto: nil, level: nil, start: nil, size: nil, offset: nil, search: nil, sort: nil)
  sort = sort.to_s if sort
  satisfy_category?(sort, [nil, "asc", "desc"])
  query = Hash.new
  query[:start] = start if start
  query[:size] = size if size
  query[:offset] = offset if offset
  query[:search] = search if search
  query[:sort] = sort if sort
  if upto
    upto = upto.to_s
    satisfy_category?(upto, [nil, "fatal", 0, "error", 1, "warning", 2, "info", 3, "debug", 4])
    query[:upto] = upto
  elsif level
    level = level.to_s
    satisfy_category?(level, [nil, "fatal", 0, "error", 1, "warning", 2, "info", 3, "debug", 4])
    query[:level] = level
  end
  Arango::Requests::Administration::Log.execute(server: self, params: query)
end

#log_level ⇒ Arango::Result

Returns the current log level settings



95
96
97
 
# File 'lib/arango/server/administration.rb', line 95

def log_level
  Arango::Requests::Administration::GetLogLevel.execute(server: self)
end

#log_level=(log_level_object) ⇒ Object

Modifies the current log level settings



103
104
105
106
107
108
109
110
 
# File 'lib/arango/server/administration.rb', line 103

def log_level=(log_level_object)
  body = if log_level_object.class == Arango::Result
           log_level_object.to_h
         else
           log_level_object
         end
  Arango::Requests::Administration::SetLogLevel.execute(server: self, body: body)
end

#mmfiles? ⇒ Boolean

Return true if the server uses the mmfiles engine.



45
46
47
 
# File 'lib/arango/server/administration.rb', line 45

def mmfiles?
  'mmfiles' == engine.name
end

#mode ⇒ Symbol

Return mode information about a server.



114
115
116
 
# File 'lib/arango/server/administration.rb', line 114

def mode
  Arango::Requests::Administration::GetMode.execute(server: self).mode.to_sym
end

#mode=(mode) ⇒ Symbol

Set server mode.



121
122
123
124
125
 
# File 'lib/arango/server/administration.rb', line 121

def mode=(mode)
  satisfy_category?(mode, ["default", "readonly", :default, :readonly])
  body = { mode: mode.to_s }
  Arango::Requests::Administration::SetMode.execute(server: self, body: body).mode.to_sym
end

#primary? ⇒ Boolean

Check if server role is PRIMARY.



167
168
169
 
# File 'lib/arango/server/administration.rb', line 167

def primary?
  role == 'PRIMARY'
end

#read_only? ⇒ Boolean

Check if server is read only.



129
130
131
 
# File 'lib/arango/server/administration.rb', line 129

def read_only?
  :readonly == mode
end

#reload_routing ⇒ Object

Reloads the routing information from the collection routing.



135
136
137
138
 
# File 'lib/arango/server/administration.rb', line 135

def reload_routing
  Arango::Requests::Administration::ReloadRouting.execute(server: self)
  true
end

#rocksdb? ⇒ Boolean

Return true if the server uses the rocksdb engine.



51
52
53
 
# File 'lib/arango/server/administration.rb', line 51

def rocksdb?
  'rocksdb' == engine.name
end

#role ⇒ String

Returns the role of a server in a cluster. SINGLE: the server is a standalone server without clustering COORDINATOR: the server is a Coordinator in a cluster PRIMARY: the server is a DBServer in a cluster SECONDARY: this role is not used anymore AGENT: the server is an Agency node in a cluster UNDEFINED: in a cluster, UNDEFINED is returned if the server role cannot be determined.



149
150
151
 
# File 'lib/arango/server/administration.rb', line 149

def role
  @role ||= Arango::Requests::Administration::Role.execute(server: self).role
end

#secondary? ⇒ Boolean

Check if server role is SECONDARY.



173
174
175
 
# File 'lib/arango/server/administration.rb', line 173

def secondary?
  role == 'SECONDARY'
end

#server_id ⇒ Boolean

Returns the id of a server in a cluster.



191
192
193
 
# File 'lib/arango/server/administration.rb', line 191

def server_id
  request(get: "_admin/server/id").serverId if in_cluster?
end

#shutdown ⇒ Boolean

Shutdown the server.



299
300
301
 
# File 'lib/arango/server/administration.rb', line 299

def shutdown
  200 == request(delete: "_admin/shutdown").response_code
end

#single? ⇒ Boolean

Check if server role is SINGLE.



179
180
181
 
# File 'lib/arango/server/administration.rb', line 179

def single?
  role == 'SINGLE'
end

#statistics ⇒ Arango::Result

Returns the statistics information.



197
198
199
 
# File 'lib/arango/server/administration.rb', line 197

def statistics
  Arango::Requests::Administration::Statistics.execute(server: self)
end

#statistics_description ⇒ Arango::Result

Returns a description of the statistics returned by /_admin/statistics.



203
204
205
 
# File 'lib/arango/server/administration.rb', line 203

def statistics_description
  Arango::Requests::Administration::StatisticsDescription.execute(server: self)
end

#status ⇒ Arango::Result

Returns status information about the server.



209
210
211
 
# File 'lib/arango/server/administration.rb', line 209

def status
  Arango::Requests::Administration::Status.execute(server: self)
end

#target_version ⇒ String

Returns the database version that this server requires.



242
243
244
 
# File 'lib/arango/server/administration.rb', line 242

def target_version
  Arango::Requests::Administration::TargetVersion.execute(server: self).version
end

#time ⇒ Float

The servers current system time as a Unix timestamp with microsecond precision of the server



221
222
223
 
# File 'lib/arango/server/administration.rb', line 221

def time
  Arango::Requests::Administration::Time.execute(server: self).time
end

#version ⇒ String

The server version string. The string has the format “major.minor.sub”. major and minor will be numeric, and sub may contain a number or a textual version.



236
237
238
 
# File 'lib/arango/server/administration.rb', line 236

def version
  Arango::Requests::Administration::Version.execute(server: self).version
end

#wal_properties ⇒ Object

Retrieves the configuration of the write-ahead log. Properties:

  • allow_oversize_entries: whether or not operations that are bigger than a single logfile can be executed and stored

  • log_file_size: the size of each write-ahead logfile

  • historic_logfiles: the maximum number of historic logfiles to keep

  • reserve_logfiles: the maximum number of reserve logfiles that ArangoDB allocates in the background

  • throttle_wait: the maximum wait time that operations will wait before they get aborted if case of write-throttling (in milliseconds)

  • throttle_when_pending: the number of unprocessed garbage-collection operations that, when reached, will activate write-throttling.

    A value of 0 means that write-throttling will not be triggered.

return [Arango::Result]



274
275
276
277
278
 
# File 'lib/arango/server/administration.rb', line 274

def wal_properties
  result = Arango::Requests::Wal::GetProperties.execute(server: self)
  raise "WAL properties not available." if result.response_code >= 500
  result
end

#wal_properties=(properties_object) ⇒ Object

Configures the behavior of the write-ahead log.



283
284
285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/arango/server/administration.rb', line 283

def wal_properties=(properties_object)
  body = {
    allowOversizeEntries: properties_object.allow_oversize_entries,
    logfileSize: properties_object.logfile_size,
    historicLogfiles: properties_object.historic_logfiles,
    reserveLogfiles: properties_object.reserve_logfiles,
    throttleWait: properties_object.throttle_wait,
    throttleWhenPending: properties_object.throttle_when_pending
  }
  result = request(put: "_admin/wal/properties", body: body)
  raise "WAL properties not available." if result.response_code >= 500
  result
end