Class: Riak::Client

Inherits:
Object show all
Includes:
Util::Escape, Util::Translation
Defined in:
lib/riak/client.rb,
lib/riak/client/node.rb,
lib/riak/client/search.rb,
lib/riak/client/yokozuna.rb,
lib/riak/client/decaying.rb,
lib/riak/client/beefcake/socket.rb,
lib/riak/client/feature_detection.rb,
lib/riak/client/beefcake/protocol.rb,
lib/riak/client/beefcake/messages.rb,
lib/riak/client/protobuffs_backend.rb,
lib/riak/client/beefcake/crdt_loader.rb,
lib/riak/client/beefcake/message_codes.rb,
lib/riak/client/beefcake/crdt_operator.rb,
lib/riak/client/beefcake/object_methods.rb,
lib/riak/client/beefcake/message_overlay.rb,
lib/riak/client/beefcake_protobuffs_backend.rb

Overview

A client connection to Riak.

Defined Under Namespace

Modules: BeefcakeMessageCodes, FeatureDetection Classes: BeefcakeProtobuffsBackend, Decaying, Node, ProtobuffsBackend

Constant Summary

MAX_CLIENT_ID =

When using integer client IDs, the exclusive upper-bound of valid values.

4294967296
HOST_REGEX =

Regexp for validating hostnames, lifted from uri.rb in Ruby 1.8.6

/^(?:(?:(?:[a-zA-Z\d](?:[-a-zA-Z\d]*[a-zA-Z\d])?)\.)*(?:[a-zA-Z](?:[-a-zA-Z\d]*[a-zA-Z\d])?)\.?|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[(?:(?:[a-fA-F\d]{1,4}:)*(?:[a-fA-F\d]{1,4}|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|(?:(?:[a-fA-F\d]{1,4}:)*[a-fA-F\d]{1,4})?::(?:(?:[a-fA-F\d]{1,4}:)*(?:[a-fA-F\d]{1,4}|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))?)\])$/n
VALID_OPTIONS =

Valid constructor options.

[:nodes, :client_id, :protobuffs_backend, :authentication] | Node::VALID_OPTIONS
NETWORK_ERRORS =

Network errors.

[
  EOFError,
  Errno::ECONNABORTED,
  Errno::ECONNREFUSED,
  Errno::ECONNRESET,
  Errno::ENETDOWN,
  Errno::ENETRESET,
  Errno::ENETUNREACH,
  SocketError,
  SystemCallError,
  Riak::ProtobuffsFailedHeader,
]
Pool =
::Innertube::Pool

Instance Attribute Summary (collapse)

Instance Method Summary (collapse)

Methods included from Util::Escape

#escape, #maybe_escape, #maybe_unescape, #unescape

Methods included from Util::Translation

#i18n_scope, #t

Constructor Details

- (Client) initialize(options = {})

Creates a client connection to Riak

Parameters:

  • options (Hash) (defaults to: {})

    configuration options for the client

Options Hash (options):

  • :nodes (Array)

    A list of nodes this client connects to. Each element of the list is a hash which is passed to Node.new, e.g. `'127.0.0.1', pb_port: 1234, …`. If no nodes are given, a single node is constructed from the remaining options given to Client.new.

  • :host (String) — default: '127.0.0.1'

    The host or IP address for the Riak endpoint

  • :pb_port (Fixnum) — default: 8087

    The port of the Riak Protocol Buffers endpoint

  • :client_id (Fixnum, String) — default: rand(MAX_CLIENT_ID)

    The internal client ID used by Riak to route responses

  • :protobuffs_backend (String, Symbol) — default: :Beefcake

    which Protocol Buffers backend to use

Raises:

  • (ArgumentError)

    raised if any invalid options are given



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
# File 'lib/riak/client.rb', line 82

def initialize(options={})
  if options.include? :port
    warn(t('deprecated.port', :backtrace => caller[0..2].join("\n    ")))
  end

  unless (evil = options.keys - VALID_OPTIONS).empty?
    raise ArgumentError, "#{evil.inspect} are not valid options for Client.new"
  end

  @nodes = (options[:nodes] || []).map do |n|
    Client::Node.new self, n
  end
  if @nodes.empty? or options[:host] or options[:pb_port]
    @nodes |= [Client::Node.new(self, options)]
  end

  @protobuffs_pool = Pool.new(
                              method(:new_protobuffs_backend),
                              lambda { |b| b.teardown }
                              )


  self.protobuffs_backend = options[:protobuffs_backend] || :Beefcake
  self.client_id          = options[:client_id]          if options[:client_id]
  self.multiget_threads   = options[:multiget_threads]
  @authentication         = options[:authentication] && options[:authentication].symbolize_keys
end

Instance Attribute Details

- (Hash) authentication (readonly)

Returns The authentication information this client will use.

Returns:

  • (Hash)

    The authentication information this client will use.



68
69
70
# File 'lib/riak/client.rb', line 68

def authentication
  @authentication
end

- (String) client_id

Returns The internal client ID used by Riak to route responses

Returns:

  • (String)

    The internal client ID used by Riak to route responses



56
57
58
# File 'lib/riak/client.rb', line 56

def client_id
  @client_id
end

- (Integer) multiget_threads

Returns The number of threads for multiget requests

Returns:

  • (Integer)

    The number of threads for multiget requests



65
66
67
# File 'lib/riak/client.rb', line 65

def multiget_threads
  @multiget_threads
end

- (Array) nodes

Returns The set of Nodes this client can communicate with.

Returns:

  • (Array)

    The set of Nodes this client can communicate with.



53
54
55
# File 'lib/riak/client.rb', line 53

def nodes
  @nodes
end

- (Symbol) protobuffs_backend

Returns The Protocol Buffers backend/client to use

Returns:

  • (Symbol)

    The Protocol Buffers backend/client to use



59
60
61
# File 'lib/riak/client.rb', line 59

def protobuffs_backend
  @protobuffs_backend
end

- (Client::Pool) protobuffs_pool (readonly)

Returns A pool of protobuffs connections

Returns:



62
63
64
# File 'lib/riak/client.rb', line 62

def protobuffs_pool
  @protobuffs_pool
end

Instance Method Details

- (Bucket) bucket(name, options = {}) Also known as: []

Retrieves a bucket from Riak.

Parameters:

  • name (String)

    the bucket to retrieve

  • options (Hash) (defaults to: {})

    options for retrieving the bucket

Options Hash (options):

  • :props (Boolean) — default: false

    whether to retreive the bucket properties

Returns:

  • (Bucket)

    the requested bucket

Raises:

  • (ArgumentError)


121
122
123
124
125
126
127
128
129
130
# File 'lib/riak/client.rb', line 121

def bucket(name, options={})
  raise ArgumentError, t('zero_length_bucket') if name == ''
  unless (options.keys - [:props]).empty?
    raise ArgumentError, "invalid options"
  end
  @bucket_cache ||= {}
  (@bucket_cache[name] ||= Bucket.new(self, name)).tap do |b|
    b.props if options[:props]
  end
end

- (Array<Bucket>) buckets(options = {}, &block) Also known as: list_buckets

Note:

This is an expensive operation and should be used only in development.

Lists buckets which have keys stored in them.

Returns:



137
138
139
140
141
142
143
144
145
# File 'lib/riak/client.rb', line 137

def buckets(options={}, &block)
  warn(t('list_buckets', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings

  return ListBuckets.new self, options, block if block_given?

  backend do |b|
    b.list_buckets(options).map {|name| Bucket.new(self, name) }
  end
end

- (Object) choose_node(nodes = self.nodes)

Choose a node from a set.



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
# File 'lib/riak/client.rb', line 149

def choose_node(nodes = self.nodes)
  # Prefer nodes which have gone a reasonable time without errors.
  s = nodes.select do |node|
    node.error_rate.value < 0.1
  end

  if s.empty?
    # Fall back to minimally broken node.
    nodes.min_by do |node|
      node.error_rate.value
    end
  else
    s[rand(s.size)]
  end
end

- (Object) clear_bucket_props(bucket)

Clears the properties on a bucket. See Bucket#clear_props



371
372
373
374
375
# File 'lib/riak/client.rb', line 371

def clear_bucket_props(bucket)
  backend do |b|
    b.reset_bucket_props(bucket)
  end
end

- (Object) create_search_index(name, schema = nil, n_val = nil)

Raises:

  • (ArgumentError)


3
4
5
6
7
8
9
# File 'lib/riak/client/yokozuna.rb', line 3

def create_search_index(name, schema=nil, n_val=nil)
  raise ArgumentError, t("zero_length_index") if name.nil? || name.empty?
  backend do |b|
    b.create_search_index(name, schema, n_val)
  end
  true
end

- (Object) create_search_schema(name, content)

Raises:

  • (ArgumentError)


36
37
38
39
40
41
42
43
# File 'lib/riak/client/yokozuna.rb', line 36

def create_search_schema(name, content)
  raise ArgumentError, t("zero_length_schema") if name.nil? || name.empty?
  raise ArgumentError, t("zero_length_content") if content.nil? || content.empty?
  backend do |b|
    b.create_search_schema(name, content)
  end
  true
end

- (Object) delete_object(bucket, key, options = {})

Delete an object. See Bucket#delete



214
215
216
217
218
# File 'lib/riak/client.rb', line 214

def delete_object(bucket, key, options = {})
  backend do |b|
    b.delete_object(bucket, key, options)
  end
end

- (Object) delete_search_index(name)

Raises:

  • (ArgumentError)


28
29
30
31
32
33
34
# File 'lib/riak/client/yokozuna.rb', line 28

def delete_search_index(name)
  raise ArgumentError, t("zero_length_index") if name.nil? || name.empty?
  backend do |b|
    b.delete_search_index(name)
  end
  true
end

- (Object) get_bucket_props(bucket, options = { })

Bucket properties. See Bucket#props



221
222
223
224
225
# File 'lib/riak/client.rb', line 221

def get_bucket_props(bucket, options={  })
  backend do |b|
    b.get_bucket_props bucket, options
  end
end

- (Object) get_index(bucket, index, query, options = {})

Queries a secondary index on a bucket. See Bucket#get_index



228
229
230
231
232
# File 'lib/riak/client.rb', line 228

def get_index(bucket, index, query, options={})
  backend do |b|
    b.get_index bucket, index, query, options
  end
end

- (Object) get_many(pairs)

Get multiple objects in parallel.



235
236
237
# File 'lib/riak/client.rb', line 235

def get_many(pairs)
  Multiget.get_all self, pairs
end

- (Object) get_object(bucket, key, options = {})

Get an object. See Bucket#get

Raises:

  • (ArgumentError)


240
241
242
243
244
245
# File 'lib/riak/client.rb', line 240

def get_object(bucket, key, options = {})
  raise ArgumentError, t("zero_length_key") if key == ''
  backend do |b|
    b.fetch_object(bucket, key, options)
  end
end

- (Object) get_search_index(name)

Raises:

  • (ArgumentError)


11
12
13
14
15
16
17
18
# File 'lib/riak/client/yokozuna.rb', line 11

def get_search_index(name)
  raise ArgumentError, t("zero_length_index") if name.nil? || name.empty?
  resp = []
  backend do |b|
    resp = b.get_search_index(name)
  end
  resp.index && Array === resp.index ? resp.index.first : resp
end

- (Object) get_search_schema(name)

Raises:

  • (ArgumentError)


45
46
47
48
49
50
# File 'lib/riak/client/yokozuna.rb', line 45

def get_search_schema(name)
  raise ArgumentError, t("zero_length_schema") if name.nil? || name.empty?
  backend do |b|
    return b.get_search_schema(name)
  end
end

- (String) inspect

Returns A representation suitable for IRB and debugging output.

Returns:

  • (String)

    A representation suitable for IRB and debugging output.



248
249
250
# File 'lib/riak/client.rb', line 248

def inspect
  "#<Riak::Client #{nodes.inspect}>"
end

- (Object) list_keys(bucket, options = {}, &block)

Retrieves a list of keys in the given bucket. See Bucket#keys



253
254
255
256
257
258
259
260
261
262
263
# File 'lib/riak/client.rb', line 253

def list_keys(bucket, options={}, &block)
  if block_given?
    backend do |b|
      b.list_keys bucket, options, &block
    end
  else
    backend do |b|
      b.list_keys bucket, options
    end
  end
end

- (Object) list_search_indexes



20
21
22
23
24
25
26
# File 'lib/riak/client/yokozuna.rb', line 20

def list_search_indexes()
  resp = []
  backend do |b|
    resp = b.get_search_index(nil)
  end
  resp.index ? resp.index : resp
end

- (Object) mapred(mr, &block)

Executes a mapreduce request. See MapReduce#run



266
267
268
269
270
# File 'lib/riak/client.rb', line 266

def mapred(mr, &block)
  backend do |b|
    b.mapred(mr, &block)
  end
end

- (ProtobuffsBackend) new_protobuffs_backend

Creates a new protocol buffers backend.

Returns:



275
276
277
278
279
280
281
282
283
284
285
286
287
288
# File 'lib/riak/client.rb', line 275

def new_protobuffs_backend
  klass = self.class.const_get("#{@protobuffs_backend}ProtobuffsBackend")
  if klass.configured?
    node = choose_node(
      @nodes.select do |n|
        n.protobuffs?
      end
    )

    klass.new(self, node)
  else
    raise t('protobuffs_configuration', :backend => @protobuffs_backend)
  end
end

- (Node) node

Returns An arbitrary Node.

Returns:

  • (Node)

    An arbitrary Node.



291
292
293
# File 'lib/riak/client.rb', line 291

def node
  nodes[rand nodes.size]
end

- (true, false) ping

Pings the Riak cluster to check for liveness.

Returns:

  • (true, false)

    whether the Riak cluster is alive and reachable



297
298
299
300
301
# File 'lib/riak/client.rb', line 297

def ping
  backend do |b|
    b.ping
  end
end

- (Object) protobuffs(&block) Also known as: backend

Yields a protocol buffers backend.



304
305
306
# File 'lib/riak/client.rb', line 304

def protobuffs(&block)
  recover_from @protobuffs_pool, &block
end

- (Object) recover_from(pool)

Takes a pool. Acquires a backend from the pool and yields it with node-specific error recovery.



319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
# File 'lib/riak/client.rb', line 319

def recover_from(pool)
  skip_nodes = []
  take_opts = {}
  tries = 3

  begin
    # Only select nodes which we haven't used before.
    unless skip_nodes.empty?
      take_opts[:filter] = lambda do |backend|
        not skip_nodes.include? backend.node
      end
    end

    # Acquire a backend
    pool.take(take_opts) do |backend|
      begin
        yield backend
      rescue *NETWORK_ERRORS => e
        # Network error.
        tries -= 1

        # Notify the node that a request against it failed.
        backend.node.error_rate << 1

        # Skip this node next time.
        skip_nodes << backend.node

        # And delete this connection.
        raise Pool::BadResource, e
      end
    end
  rescue Pool::BadResource => e
    retry if tries > 0
    raise e.message
  end
end

- (Object) reload_object(object, options = {})

Reloads the object from Riak.



357
358
359
360
361
# File 'lib/riak/client.rb', line 357

def reload_object(object, options = {})
  backend do |b|
    b.reload_object(object, options)
  end
end

- (Hash) search(index, query, options = {}) - (Hash) search(query, options = {}) Also known as: select

(Riak Search) Performs a search via the Solr interface.

Overloads:

  • - (Hash) search(index, query, options = {})

    Parameters:

    • index (String)

      the index to query on

    • query (String)

      a Lucene query string

  • - (Hash) search(query, options = {})

    Queries the default index

    Parameters:

    • query (String)

      a Lucene query string

Parameters:

  • options (Hash)

    extra options for the Solr query

Returns:

  • (Hash)

    the query result, containing the 'responseHeaders' and 'response' keys



18
19
20
21
22
23
24
# File 'lib/riak/client/search.rb', line 18

def search(*args)
  options = args.extract_options!
  index, query = args[-2], args[-1]  # Allows nil index, while keeping it as firstargument
  backend do |b|
    b.search(index, query, options)
  end
end

- (Boolean) security?

Is security enabled?

Returns:

  • (Boolean)

    whether or not a secure connection is being used



112
113
114
# File 'lib/riak/client.rb', line 112

def security?
  !!authentication
end

- (Object) set_bucket_props(bucket, properties, type = nil)

Sets the properties on a bucket. See Bucket#props=



364
365
366
367
368
# File 'lib/riak/client.rb', line 364

def set_bucket_props(bucket, properties, type=nil)
  backend do |b|
    b.set_bucket_props(bucket, properties, type)
  end
end

- (Stamp) stamp

Exposes a Stamp object for use in generating unique identifiers.

Returns:

  • (Stamp)

    an ID generator

See Also:



381
382
383
# File 'lib/riak/client.rb', line 381

def stamp
  @stamp ||= Riak::Stamp.new(self)
end

- (Object) store_object(object, options = {})

Stores an object in Riak.



387
388
389
390
391
392
# File 'lib/riak/client.rb', line 387

def store_object(object, options = {})
  params = {:returnbody => true}.merge(options)
  backend do |b|
    b.store_object(object, params)
  end
end