Class: Riak::Client

Inherits:
Object show all
Includes:
Instrumentable, Util::Escape, Util::Translation
Defined in:
lib/riak/client.rb,
lib/riak/client/node.rb,
lib/riak/client/search.rb,
lib/riak/client/decaying.rb,
lib/riak/client/yokozuna.rb,
lib/riak/client/beefcake/socket.rb,
lib/riak/client/instrumentation.rb,
lib/riak/client/beefcake/messages.rb,
lib/riak/client/beefcake/protocol.rb,
lib/riak/client/feature_detection.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

#initialize(options = {}) ⇒ Client

Creates a client connection to Riak

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



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
109
110
# File 'lib/riak/client.rb', line 84

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

#authenticationHash (readonly)



70
71
72
# File 'lib/riak/client.rb', line 70

def authentication
  @authentication
end

#client_idString



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

def client_id
  @client_id
end

#multiget_threadsInteger



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

def multiget_threads
  @multiget_threads
end

#nodesArray



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

def nodes
  @nodes
end

#protobuffs_backendSymbol



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

def protobuffs_backend
  @protobuffs_backend
end

#protobuffs_poolClient::Pool (readonly)



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

def protobuffs_pool
  @protobuffs_pool
end

Instance Method Details

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

Retrieves a bucket from Riak.

Options Hash (options):

  • :props (Boolean) — default: false

    whether to retreive the bucket properties

Raises:

  • (ArgumentError)


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

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

#bucket_type(name) ⇒ Object



135
136
137
# File 'lib/riak/client.rb', line 135

def bucket_type(name)
  BucketType.new self, name
end

#buckets(options = {}, &block) ⇒ Array<Bucket> 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.



143
144
145
146
147
148
149
150
151
# File 'lib/riak/client.rb', line 143

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

#choose_node(nodes = self.nodes) ⇒ Object

Choose a node from a set.



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
# File 'lib/riak/client.rb', line 155

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

#clear_bucket_props(bucket, options = { }) ⇒ Object

Clears the properties on a bucket. See Bucket#clear_props



377
378
379
380
381
# File 'lib/riak/client.rb', line 377

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

#create_search_index(name, schema = nil, n_val = nil) ⇒ Object

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

#create_search_schema(name, content) ⇒ Object

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

#delete_object(bucket, key, options = {}) ⇒ Object

Delete an object. See Bucket#delete



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

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

#delete_search_index(name) ⇒ Object

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

#get_bucket_props(bucket, options = { }) ⇒ Object

Bucket properties. See Bucket#props



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

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

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

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



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

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

#get_many(pairs) ⇒ Object

Get multiple objects in parallel.



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

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

#get_object(bucket, key, options = {}) ⇒ Object

Get an object. See Bucket#get

Raises:

  • (ArgumentError)


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

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

#get_search_index(name) ⇒ Object

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

#get_search_schema(name) ⇒ Object

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

#inspectString



254
255
256
# File 'lib/riak/client.rb', line 254

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

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

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



259
260
261
262
263
264
265
266
267
268
269
# File 'lib/riak/client.rb', line 259

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

#list_search_indexesObject



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

#mapred(mr, &block) ⇒ Object

Executes a mapreduce request. See MapReduce#run



272
273
274
275
276
# File 'lib/riak/client.rb', line 272

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

#new_protobuffs_backendProtobuffsBackend

Creates a new protocol buffers backend.



281
282
283
284
285
286
287
288
289
290
291
292
293
294
# File 'lib/riak/client.rb', line 281

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 BackendCreationError.new @protobuffs_backend
  end
end

#nodeNode



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

def node
  nodes[rand nodes.size]
end

#pingtrue, false

Pings the Riak cluster to check for liveness.



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

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

#protobuffs(&block) ⇒ Object Also known as: backend

Yields a protocol buffers backend.



310
311
312
# File 'lib/riak/client.rb', line 310

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

#recover_from(pool) ⇒ Object

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



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
355
356
357
358
359
360
# File 'lib/riak/client.rb', line 325

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

#reload_object(object, options = {}) ⇒ Object

Reloads the object from Riak.



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

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

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

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

Overloads:

  • #search(query, options = {}) ⇒ Hash

    Queries the default index



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

#security?Boolean

Is security enabled?



114
115
116
# File 'lib/riak/client.rb', line 114

def security?
  !!authentication
end

#set_bucket_props(bucket, properties, type = nil) ⇒ Object

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



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

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

#stampStamp

Exposes a Stamp object for use in generating unique identifiers.

See Also:



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

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

#store_object(object, options = {}) ⇒ Object

Stores an object in Riak.



393
394
395
396
397
398
# File 'lib/riak/client.rb', line 393

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