Class: Jerbil::Monitor

Inherits:
Object
  • Object
show all
Defined in:
lib/jerbil/monitor.rb

Overview

Monitors the network for Jerbil servers and reports to the local server

Provides a way to decouple the interactions between the jerbil server and other servers on the network to prevent race conditions or holding up start-up while other servers are discovered

The Monitor object is intended to be used in a subprocess after creating the main jerbil server. It scans the LAN for other servers and keeps a record of known servers. When a new server is found, it registers it with the local server and also registers each of its services. If a known server disappears, then it also removes that server (and its services) from the network. If the server left in an orderly manner then it may have already done this, but the server can cope!

The subprocess needs to be cleaned up afterwards - does not seem to be possible to either link it with the server’s process or tidy up on kill.

Instance Method Summary collapse

Constructor Details

#initialize(options, jkey) ⇒ Monitor

create the monitor object



37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/jerbil/monitor.rb', line 37

def initialize(options, jkey)
  @options = options
  @env = @options[:environment]
  @jerbil_key = jkey
  @local_server = Jerbil::Servers.create_local_server(@env, @jerbil_key)
  @servers = Hash.new
  @servers[@local_server.fqdn] = @local_server
  @log_opts = Jellog::Logger.get_options(options)
  log_opts = @log_opts.dup
  @logger = Jellog::Logger.new('jerbil-monitor', log_opts)
  @logger.system "Started the Jerbil Monitor"
  self.monitor
end

Instance Method Details

#monitor ⇒ Object

start the monitor loop to find and register existing servers

Loops round to see what servers are up and adds any that are not already known about. It does this “check_count” times in case it misses a server (the TCP check may not have a long timeout). See

It does one loop every :monitor_loop_time seconds (see Config)



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
# File 'lib/jerbil/monitor.rb', line 59

def monitor
  # create a monitor thread
  loop_time = @options[:loop_time]
  # loop forever
  ljerbil = @local_server.connect
  
  check_count = @options[:check_count]
  
  check_count.times do |c|
    @logger.info "Starting jerbil server monitor loop: #{c}"
    # set the time until the next loop
    time_to_next_loop = Time.now + loop_time
    # scan the LAN for other monitors
    network_servers = Jerbil::Servers.find_servers(@env, 
      @options[:net_address], 
      @options[:net_mask], 
      @options[:scan_timeout])
    scanned = Array.new
    
    # for each discovered server
    network_servers.each do |nserver|
      
      scanned << nserver.fqdn
      # skip if already known
      next if @servers.has_key? nserver.fqdn
      
      # its new so register with servers
  
      rjerbil = nserver.connect
      unless rjerbil.nil?
        begin
          # register local with remote
          rkey = rjerbil.register_server(@local_server, @options[:secret], @env)
          nserver.set_key(rkey)
          
          # and register remote with local
          ljerbil.register_server(nserver, @options[:secret], @env)
          
          @logger.info "Found server: #{nserver.fqdn}"
          
          # Add to local record - could use jerbil itself?
          @servers[nserver.fqdn] = nserver
          
          
          # now tell my server about these services
          
          rjerbil.get_local_services(rkey).each do |rservice|
            ljerbil.register_remote(@jerbil_key, rservice)
          end
          
        rescue Jerbil::JerbilAuthenticationError
          @logger.fatal "Invalid Secret key registering with #{nserver.fqdn}"
          @servers[nserver.fqdn] = nserver # save it anyway to stop repeated logging
        end
      end
    end
    
    if time_to_next_loop > Time.now then
      @logger.debug "Taking a nap"
      sleep(time_to_next_loop - Time.now)
    end
  
  end # loop

  
rescue => e
  @logger.exception e
ensure
  @logger.system "Jerbil Monitor complete and closing down"
  @logger.close
  Process.exit!
end