Class: Gossiperl::Client::OverlayWorker

Inherits:
Resolution
  • Object
show all
Defined in:
lib/gossiperl_client/headers.rb,
lib/gossiperl_client/overlay_worker.rb

Constant Summary

Constants inherited from Resolution

Resolution::UNDEFINED_VALUE

Instance Method Summary collapse

Methods inherited from Resolution

field

Constructor Details

#initialize(supervisor, options, block) ⇒ OverlayWorker

Returns a new instance of OverlayWorker.

Raises:

  • (ArgumentError) 


14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 14

def initialize supervisor, options, block
  raise ArgumentError.new('Supervisor must be of type Supervisor.') unless supervisor.is_a?(::Gossiperl::Client::Supervisor)
  raise ArgumentError.new('Callback must be a Proc / block.') unless block.nil? or block.is_a?(Proc)
  ::Gossiperl::Client::Util::Validation.validate_connect( options )
  self.supervisor = supervisor
  self.options = options
  self.working = true
  @callback_block = block
  if options.has_key?(:logger)
    self.logger - options[:logger]
  else
    self.logger = Logger.new(STDOUT)
    self.logger.level = Logger::DEBUG
  end
end

Instance Method Details

#current_state ⇒ Object 



45
46
47
48
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 45

def current_state
  return :connected if self.state.connected
  return :disconnected
end

#process_event(event) ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 50

def process_event event
  unless @callback_block.nil?
    self.instance_exec event.merge( { :options => self.options } ), &@callback_block
  else
    self.logger.info("[#{self.options[:client_name]}] Processing event: #{event}.")
  end
end

#send(digest_type, digest_data) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 66

def send digest_type, digest_data
  begin
    serialized = self.messaging.transport.serializer.serialize_arbitrary( digest_type, digest_data )
    self.messaging.send serialized
  rescue ArgumentError => e
    process_event( { :event => :failed,
                     :error => { :serialize_arbitrary => e } } )
  rescue StandardError => e2
    process_event( { :event => :failed,
                     :error => { :serialize_arbitrary => e2 } } )
  end
end

#start ⇒ Object 



30
31
32
33
34
35
36
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 30

def start
  self.messaging = Gossiperl::Client::Messaging.new(self)
  self.state     = Gossiperl::Client::State.new(self)
  [self.messaging.start, self.state.start].each {|worker|
    worker.join
  }
end

#stop ⇒ Object 



38
39
40
41
42
43
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 38

def stop
  self.messaging.digest_exit
  while self.state.connected
    sleep 0.1
  end
end

#subscribe(event_types) ⇒ Object 



58
59
60
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 58

def subscribe event_types
  self.state.subscribe event_types
end

#unsubscribe(event_types) ⇒ Object 



62
63
64
 
# File 'lib/gossiperl_client/overlay_worker.rb', line 62

def unsubscribe event_types
  self.state.unsubscribe event_types
end