Class: Riak::Client

133
134
135
136
137
138

# File 'lib/riak/client.rb', line 133

def basic_auth=(auth)
  @nodes.each do |node|
    node.basic_auth = auth
  end
  auth
end

145
146
147
148
149
150
151
152
153

# File 'lib/riak/client.rb', line 145

def bucket(name, options={})
  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

160
161
162
163
164
165

# File 'lib/riak/client.rb', line 160

def buckets
  warn(t('list_buckets', :backtrace => caller.join("\n    "))) unless Riak.disable_list_keys_warnings
  backend do |b|
    b.list_buckets.map {|name| Bucket.new(self, name) }
  end
end

169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

# File 'lib/riak/client.rb', line 169

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

217
218
219
220
221
222

# File 'lib/riak/client.rb', line 217

def delete_file(filename)
  http do |h|
    h.delete_file(filename)
  end
  true
end

225
226
227
228
229

# File 'lib/riak/client.rb', line 225

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

234
235
236
237
238

# File 'lib/riak/client.rb', line 234

def file_exists?(key)
  http do |h|
    h.file_exists?(key)
  end
end

242
243
244
245
246

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

def get_bucket_props(bucket)
  backend do |b|
    b.get_bucket_props bucket
  end
end

259
260
261
262
263

# File 'lib/riak/client.rb', line 259

def get_file(filename, &block)
  http do |h|
    h.get_file(filename, &block)
  end
end

266
267
268
269
270

# File 'lib/riak/client.rb', line 266

def get_index(bucket, index, query)
  backend do |b|
    b.get_index bucket, index, query
  end
end

273
274
275
276
277

# File 'lib/riak/client.rb', line 273

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

280
281
282

# File 'lib/riak/client.rb', line 280

def http(&block)
  recover_from @http_pool, &block
end

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

# File 'lib/riak/client/search.rb', line 38

def index(*args)
  index = args.shift if String === args.first # Documents must be hashes of fields
  raise ArgumentError.new(t("search_docs_require_id")) unless args.all? {|d| d.key?("id") || d.key?(:id) }
  xml = Builder::XmlMarkup.new
  xml.add do
    args.each do |doc|
      xml.doc do
        doc.each do |k,v|
          xml.field('name' => k.to_s) { xml.text!(v.to_s) }
        end
      end
    end
  end
  http do |h|
    h.update_search_index(index, xml.target!)
  end
  true
end

293
294
295

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

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

298
299
300
301
302

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

def link_walk(object, specs)
  http do |h|
    h.link_walk object, specs
  end
end

305
306
307
308
309
310
311
312
313
314
315

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

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

318
319
320
321
322

# File 'lib/riak/client.rb', line 318

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

326
327
328
329
330
331
332
333
334
335
336
337
338
339

# File 'lib/riak/client.rb', line 326

def new_http_backend
  klass = self.class.const_get("#{@http_backend}Backend")
  if klass.configured?
    node = choose_node(
      @nodes.select do |n|
        n.http?
      end
    )

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

344
345
346
347
348
349
350
351
352
353
354
355
356
357

# File 'lib/riak/client.rb', line 344

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

360
361
362

# File 'lib/riak/client.rb', line 360

def node
  nodes[rand nodes.size]
end

366
367
368
369
370

# File 'lib/riak/client.rb', line 366

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

373
374
375

# File 'lib/riak/client.rb', line 373

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

412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447

# File 'lib/riak/client.rb', line 412

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

450
451
452
453
454

# File 'lib/riak/client.rb', line 450

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

67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

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

def remove(*args)
  index = args.shift if String === args.first
  raise ArgumentError.new(t("search_remove_requires_id_or_query")) unless args.all? { |s|
    s.include? :id or
    s.include? 'id' or
    s.include? :query or
    s.include? 'query'
  }
  xml = Builder::XmlMarkup.new
  xml.delete do
    args.each do |spec|
      spec.each do |k,v|
        xml.tag!(k.to_sym, v)
      end
    end
  end
  http do |h|
    h.update_search_index(index, xml.target!)
  end
  true
end

20
21
22
23
24
25
26

# File 'lib/riak/client/search.rb', line 20

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

457
458
459
460
461
462
463

# File 'lib/riak/client.rb', line 457

def set_bucket_props(bucket, properties)
  # A bug in Beefcake is still giving us trouble with default booleans.
  # Until it is resolved, we'll use the HTTP backend.
  http do |b|
    b.set_bucket_props(bucket, properties)
  end
end

466
467
468
469
470
471
472
473
474
475
476
477

# File 'lib/riak/client.rb', line 466

def ssl=(value)
  @nodes.each do |node|
    node.ssl = value
  end

  if value
    @protocol = 'https'
  else
    @protocol = 'http'
  end
  value
end

483
484
485

# File 'lib/riak/client.rb', line 483

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

498
499
500
501
502

# File 'lib/riak/client.rb', line 498

def store_file(*args)
  http do |h|
    h.store_file(*args)
  end
end

505
506
507
508
509
510

# File 'lib/riak/client.rb', line 505

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