Class: Rinda::RingFinger

Inherits:
Object
  • Object
show all
Defined in:
lib/rinda/ring.rb

Overview

RingFinger is used by RingServer clients to discover the RingServer’s TupleSpace. Typically, all a client needs to do is call RingFinger.primary to retrieve the remote TupleSpace, which it can then begin using.

To find the first available remote TupleSpace:

Rinda::RingFinger.primary

To create a RingFinger that broadcasts to a custom list:

rf = Rinda::RingFinger.new  ['localhost', '192.0.2.1']
rf.primary

Rinda::RingFinger also understands multicast addresses and sets them up properly. This allows you to run multiple RingServers on the same host:

rf = Rinda::RingFinger.new ['239.0.0.1']
rf.primary

You can set the hop count (or TTL) for multicast searches using #multicast_hops.

If you use IPv6 multicast you may need to set both an address and the outbound interface index:

rf = Rinda::RingFinger.new ['ff02::1']
rf.multicast_interface = 1
rf.primary

At this time there is no easy way to get an interface index by name.

Constant Summary collapse

@@broadcast_list = 
['<broadcast>', 'localhost']
@@finger = 
nil

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(broadcast_list = @@broadcast_list, port = Ring_PORT) ⇒ RingFinger

Creates a new RingFinger that will look for RingServers at port on the addresses in broadcast_list.

If broadcast_list contains a multicast address then multicast queries will be made using the given multicast_hops and multicast_interface.



338
339
340
341
342
343
344
345
346
 
# File 'lib/rinda/ring.rb', line 338

def initialize(broadcast_list=@@broadcast_list, port=Ring_PORT)
  @broadcast_list = broadcast_list || ['localhost']
  @port = port
  @primary = nil
  @rings = []

  @multicast_hops = 1
  @multicast_interface = 0
end

Instance Attribute Details

#broadcast_list ⇒ Object

The list of addresses where RingFinger will send query packets.



307
308
309
 
# File 'lib/rinda/ring.rb', line 307

def broadcast_list
  @broadcast_list
end

#multicast_hops ⇒ Object

Maximum number of hops for sent multicast packets (if using a multicast address in the broadcast list). The default is 1 (same as UDP broadcast).



314
315
316
 
# File 'lib/rinda/ring.rb', line 314

def multicast_hops
  @multicast_hops
end

#multicast_interface ⇒ Object

The interface index to send IPv6 multicast packets from.



319
320
321
 
# File 'lib/rinda/ring.rb', line 319

def multicast_interface
  @multicast_interface
end

#port ⇒ Object

The port that RingFinger will send query packets to.



324
325
326
 
# File 'lib/rinda/ring.rb', line 324

def port
  @port
end

#primary ⇒ Object

Contain the first advertised TupleSpace after lookup_ring_any is called.



329
330
331
 
# File 'lib/rinda/ring.rb', line 329

def primary
  @primary
end

Class Method Details

.finger ⇒ Object

Creates a singleton RingFinger and looks for a RingServer. Returns the created RingFinger.



282
283
284
285
286
287
288
 
# File 'lib/rinda/ring.rb', line 282

def self.finger
  unless @@finger
    @@finger = self.new
    @@finger.lookup_ring_any
  end
  @@finger
end

.primary ⇒ Object

Returns the first advertised TupleSpace.



293
294
295
 
# File 'lib/rinda/ring.rb', line 293

def self.primary
  finger.primary
end

.to_a ⇒ Object

Contains all discovered TupleSpaces except for the primary.



300
301
302
 
# File 'lib/rinda/ring.rb', line 300

def self.to_a
  finger.to_a
end

Instance Method Details

#each {|@primary| ... } ⇒ Object

Iterates over all discovered TupleSpaces starting with the primary.

Yields:



358
359
360
361
362
363
 
# File 'lib/rinda/ring.rb', line 358

def each
  lookup_ring_any unless @primary
  return unless @primary
  yield(@primary)
  @rings.each { |x| yield(x) }
end

#lookup_ring(timeout = 5, &block) ⇒ Object

Looks up RingServers waiting timeout seconds. RingServers will be given block as a callback, which will be called with the remote TupleSpace.



370
371
372
373
374
375
376
377
378
 
# File 'lib/rinda/ring.rb', line 370

def lookup_ring(timeout=5, &block)
  return lookup_ring_any(timeout) unless block_given?

  msg = Marshal.dump([[:lookup_ring, DRbObject.new(block)], timeout])
  @broadcast_list.each do |it|
    send_message(it, msg)
  end
  sleep(timeout)
end

#lookup_ring_any(timeout = 5) ⇒ Object

Returns the first found remote TupleSpace. Any further recovered TupleSpaces can be found by calling to_a.



384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
 
# File 'lib/rinda/ring.rb', line 384

def lookup_ring_any(timeout=5)
  queue = Queue.new

  Thread.new do
    self.lookup_ring(timeout) do |ts|
      queue.push(ts)
    end
    queue.push(nil)
  end

  @primary = queue.pop
  raise('RingNotFound') if @primary.nil?

  Thread.new do
    while it = queue.pop
      @rings.push(it)
    end
  end

  @primary
end

#make_socket(address) ⇒ Object

Creates a socket for address with the appropriate multicast options for multicast addresses.



410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
 
# File 'lib/rinda/ring.rb', line 410

def make_socket(address) # :nodoc:
  addrinfo = Addrinfo.udp(address, @port)

  soc = Socket.new(addrinfo.pfamily, addrinfo.socktype, addrinfo.protocol)

  if addrinfo.ipv4_multicast? then
    soc.setsockopt(Socket::Option.ipv4_multicast_loop(1))
    soc.setsockopt(Socket::Option.ipv4_multicast_ttl(@multicast_hops))
  elsif addrinfo.ipv6_multicast? then
    soc.setsockopt(:IPPROTO_IPV6, :IPV6_MULTICAST_LOOP, true)
    soc.setsockopt(:IPPROTO_IPV6, :IPV6_MULTICAST_HOPS,
                   [@multicast_hops].pack('I'))
    soc.setsockopt(:IPPROTO_IPV6, :IPV6_MULTICAST_IF,
                   [@multicast_interface].pack('I'))
  else
    soc.setsockopt(:SOL_SOCKET, :SO_BROADCAST, true)
  end

  soc.connect(addrinfo)

  soc
end

#send_message(address, message) ⇒ Object

:nodoc:



433
434
435
436
437
438
439
440
441
 
# File 'lib/rinda/ring.rb', line 433

def send_message(address, message) # :nodoc:
  soc = make_socket(address)

  soc.send(message, 0)
rescue
  nil
ensure
  soc.close if soc
end

#to_a ⇒ Object

Contains all discovered TupleSpaces except for the primary.



351
352
353
 
# File 'lib/rinda/ring.rb', line 351

def to_a
  @rings
end