jerbil 1.3.3 → 1.4.5

data/lib/jerbil/monitor.rb

@@ -0,0 +1,134 @@
+#
+# Author:: Robert Sharp
+# Copyright:: Copyright (c) 2014 Robert Sharp
+# License:: Open Software Licence v3.0
+#
+# This software is licensed for use under the Open Software Licence v. 3.0
+# The terms of this licence can be found at http://www.opensource.org/licenses/osl-3.0.php
+# and in the file copyright.txt. Under the terms of this licence, all derivative works
+# must themselves be licensed under the Open Software Licence v. 3.0
+# 
+#
+
+
+module Jerbil
+  # 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.
+  class Monitor
+    
+    # create the monitor object 
+    #
+    # @params options [Hash] options hash as for the Jerbil Server
+    # @params jkey [String] jerbil servers private key
+    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
+    
+    # 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 {Jerbil::Config})
+    #
+    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
+    
+    
+  end
+end

data/lib/jerbil/service.rb

@@ -32,6 +32,10 @@ module Jerbil
     # Note that the callback parameters do not really need to be considered
     # if you are using {JerbilService::Base}
     #
+    # Warning - if your hostname is not fully qualified this may not work as expected
+    # if you DNS server does not provide expected reverse lookup. Consider using
+    # `hostname -f` although *nix dependent.
+    #
     # @param [Symbol] name identifying the service - needs to match /etc/services
     #  or create fails with the exception InvalidService
     # @param [Symbol] env identify the service's environment. Allows multiple
@@ -42,7 +46,13 @@ module Jerbil
     # @return [ServiceRecord] of course
     # @raise [InvalidService] if the service is not registered through /etc/services
     def initialize(name, env, verify_callback=:verify_callback, stop_callback=nil)
+      
+      # gethostname may npt provide the fqdn
       @host = Socket.gethostname
+      if @host.split('.').length == 1 then
+        # no domain name
+        @host = Socket.gethostbyname(@host).first
+      end
       @name = name
       begin
         @port = Socket.getservbyname(@name.to_s)

data/lib/jerbil/support.rb

@@ -32,14 +32,14 @@ module Jerbil
     # @param [String] pid_dir path to directory where pid file is to be written
     # @return [String] the pid
     # @raise [Jerbil::ServiceConfigError] if the pid file cannot be written to
-    def Support.write_pid_file(name, env, pid_dir)
-      pid = Process.pid.to_s
+    def Support.write_pid_file(name, env, pid_dir, pid=Process.pid)
+      #pid = Process.pid.to_s
       pid_file = "#{pid_dir}/#{name.to_s}-#{env}.pid"
       FileUtils.rm_f(pid_file) if File.exists?(pid_file) # avoid permissions probs
       File.open(pid_file, "w") do |pfile|
-        pfile.puts pid
+        pfile.puts pid.to_s
       end
-      return pid
+      return pid.to_s
     rescue Errno::ENOENT
       # failed to write pid to file
       raise Jerbil::ServiceConfigError, "Cannot write pid file: #{pid_file}"

data/lib/jerbil/version.rb

@@ -1,13 +1,14 @@
 # Created by Jevoom
 #
-# 03-Sep-2013
-#   Ensure jerbil methods are called on the server and not the server record.
+# 17-Oct-2014
+#   Add server version to 'jerbil remotes -V' and add system logging for start and
+#   end of monitor process.
 
 module Jerbil
-  # version set to 1.3.3
-  Version = '1.3.3'
-  # date set to 03-Sep-2013
-  Version_Date = '03-Sep-2013'
-  #ident string set to: jerbil-1.3.3 03-Sep-2013
-  Ident = 'jerbil-1.3.3 03-Sep-2013'
+  # version set to 1.4.5
+  Version = '1.4.5'
+  # date set to 17-Oct-2014
+  Version_Date = '17-Oct-2014'
+  #ident string set to: jerbil-1.4.5 17-Oct-2014
+  Ident = 'jerbil-1.4.5 17-Oct-2014'
 end

data/sbin/jerbil-stop

@@ -136,4 +136,15 @@ rescue DRb::DRbConnError
 end
 
 puts "Stopped Jerbil Server" if verbose
+
+# puts "Stopping Monitor process" if verbose
+# 
+# mpid = Jerbil::Support.get_pid_and_delete_file(:jmonitor, server_env, options[:pid_dir])
+# if mpid then
+#   puts "Obtained a pid for monitor: #{mpid}" if verbose
+#   Process.kill "SIGKILL", mpid.to_i
+# else
+#   puts "No mpid was found!" if verbose
+# end
+
 exit 0

data/sbin/jerbild

@@ -21,6 +21,7 @@ require 'jerbil/servers'
 require 'jerbil/config'
 require 'jerbil/version'
 require 'jerbil/support'
+require 'jerbil/monitor'
 
 require 'jellog'
 require 'jeckyl'
@@ -157,9 +158,12 @@ end
 
 
 
-logger.puts "Logging started for Jerbil Daemon"
+logger.puts "Logging started for Jerbil Daemon" if verbose
 logger.puts "Daemonized" if verbose && daemonize
 
+# will only output messages to screen if not daemonised and therefore safe to
+# assume verbose anyway.
+
 my_self = Jerbil::Servers.create_local_server(config[:environment], pkey)
 
 logger.puts "Created local server: #{my_self.ident}"
@@ -168,14 +172,31 @@ jerbild = Jerbil::Broker.new(config, pkey)
 
 logger.puts "Started Broker"
 
+logger.puts "Starting Monitor"
+
+# create a separate process to look for other servers
+# and log them to this one
+mon_pid = fork do
+  
+  monitor = Jerbil::Monitor.new(config, pkey)
+  
+  # exits automatically 
+  
+end
+
 DRb.start_service(my_self.drb_address, jerbild)
 
 logger.puts "Started DRb"
 
-# now create the pid file
-Jerbil::Support.write_pid_file(:jerbil, config[:environment], config[:pid_dir])
 
-logger.puts "Written pid #{Process.pid} to pid file"
+# now create the pid files
+jer_pid = Jerbil::Support.write_pid_file(:jerbil, config[:environment], config[:pid_dir])
+
+logger.puts "Written Jerbil pid #{jer_pid} to pid file"
+
+# Jerbil::Support.write_pid_file(:jmonitor, config[:environment], config[:pid_dir], mon_pid)
+# 
+# logger.puts "Written Monitor pid #{mon_pid} to pid file"
 
 $0 = "jerbild-#{config[:environment]}"
 

data/spec/jerbil_client_spec.rb

@@ -33,28 +33,28 @@ describe "Test Jerbil Client Interface" do
   it "should respond to the old connect method" do
     client_opts = {:local=>true, :config_file=>config_file, :quiet=>true, :jerbil_env=>:test}
     JerbilService::Client.connect(RubyTest, client_opts) do |rubytest|
-      rubytest.action.should == 'Hello'
-      rubytest.host.should == localhost
+      expect(rubytest.action).to eq('Hello')
+      expect(rubytest.host).to eq(localhost)
     end
   end
 
   it "should respond to the new find_services method" do
     JerbilService::Client.find_services(:first, RubyTest, @client_opts) do |rubytest|
-      rubytest.action.should == 'Hello'
-      rubytest.host.should == localhost
+      expect(rubytest.action).to eq('Hello')
+      expect(rubytest.host).to eq(localhost)
     end
   end
 
   it "should respond to the new find_services method with local service" do
     JerbilService::Client.find_services(:local, RubyTest, @client_opts) do |rubytest|
-      rubytest.action.should == 'Hello'
-      rubytest.host.should == localhost
+      expect(rubytest.action).to eq('Hello')
+      expect(rubytest.host).to eq(localhost)
     end
   end
 
   it "should work with multiple client call" do
     JerbilService::Client.find_services(:all, RubyTest, @client_opts) do |rubytest|
-      rubytest.action.should == 'Hello'
+      expect(rubytest.action).to eq('Hello')
     end
   end
 
@@ -66,26 +66,26 @@ describe "Test Jerbil Client Interface" do
     options[:output] = log_file
     options[:quiet] = false
     JerbilService::Client.find_services(:local, RubyTest, options) do |rubytest|
-      rubytest.action.should == 'Hello'
+      expect(rubytest.action).to eq('Hello')
     end
     log_file.close
     log = File.readlines(log_filename)
-    log[0].should match(/^Welcome/)
+    expect(log[0]).to match(/^Welcome/)
   end
 
   it "should not respond to an unknown method" do
     JerbilService::Client.find_services(:first, RubyTest, @client_opts) do |rubytest|
-      lambda{rubytest.unlikely_method}.should raise_error(NoMethodError)
+      expect {rubytest.unlikely_method}.to raise_error(NoMethodError)
     end
   end
 
   it "should not respond to an unknown search key" do
-    lambda{JerbilService::Client.find_services(:last, RubyTest, @client_opts)}.should raise_error(ArgumentError)
+    expect {JerbilService::Client.find_services(:last, RubyTest, @client_opts)}.to raise_error(ArgumentError)
   end
 
   it "should not allow the stop_callback to be called" do
     JerbilService::Client.find_services(:first, RubyTest, @client_opts) do |rubytest|
-      lambda{rubytest.stop_callback}.should raise_error(Jerbil::UnauthorizedMethod)
+      expect {rubytest.stop_callback}.to raise_error(Jerbil::UnauthorizedMethod)
     end
   end
 
@@ -97,18 +97,18 @@ describe "Jerbil Clients that do different things" do
   end
 
   it "should not find an invalid service" do
-    lambda{JerbilService::Client.connect(Blabla)}.should raise_error(NameError)
+    expect {JerbilService::Client.connect(Blabla)}.to raise_error(NameError)
   end
 
   it "should find a local service" do
     JerbilService::Client.connect(RubyTest, @client_opts) do |client|
-      client.action.should == 'Hello'
+      expect(client.action).to eq('Hello')
     end
   end
 
   it "should not find a local service if it thinks it is somewhere else" do
-    Socket.stub(:gethostname).and_return('germanicus.osburn-sharp.ath.cx', 'lucius.osburn-sharp.ath.cx')
-    lambda{JerbilService::Client.connect(RubyTest, @client_opts)}.should raise_error(Jerbil::ServiceNotFound)
+    allow(Socket).to receive_message_chain(:gethostname).and_return('germanicus.osburn-sharp.ath.cx', 'lucius.osburn-sharp.ath.cx')
+    expect {JerbilService::Client.connect(RubyTest, @client_opts)}.to raise_error(Jerbil::ServiceNotFound)
   end
 
 end

data/spec/jerbil_daemonised/jerbil_local_spec.rb

@@ -32,7 +32,6 @@ describe "A local Jerbil Session running under a daemon" do
   end
 
   before(:each) do
-
     my_conf = Jerbil::Config.new(conf_file)
     test_server = Jerbil::Servers.get_local_server(my_conf[:environment])
     @my_session = test_server.connect
@@ -44,21 +43,21 @@ describe "A local Jerbil Session running under a daemon" do
 
 
   it "should be easily created" do
-    @my_session.started.should be_true
-    @my_session.registrations.should == @registrations
-    @my_session.service_count.should == @start_count
-    @my_session.get_all.should == []
+    expect(@my_session.started).to be_kind_of(Time)
+    expect(@my_session.registrations).to eq(@registrations)
+    expect(@my_session.service_count).to eq(@start_count)
+    expect(@my_session.get_all).to eq([])
   end
 
   it "should be easy to add a service" do
     @my_session.register(@my_service)
-    @my_session.registrations.should == @registrations + 1
-    @my_session.service_count.should == @start_count + 1
+    expect(@my_session.registrations).to eq(@registrations + 1)
+    expect(@my_session.service_count).to eq(@start_count + 1)
     services = @my_session.get_all(:ignore_access => true)
-    services[0].should == @my_service
+    expect(services[0]).to eq(@my_service)
     service = @my_session.get_local(:ignore_access => true)
-    service.should == @my_service
-    @my_session.find(:name=>'Another', :ignore_access => true).should == []
+    expect(service).to eq(@my_service)
+    expect(@my_session.find(:name=>'Another', :ignore_access => true)).to eq([])
     @my_session.remove(@my_service)
   end
 
@@ -67,13 +66,13 @@ describe "A local Jerbil Session running under a daemon" do
   it "should be easy to remove a service" do
     @my_session.register(@my_service)
     @my_session.remove(@my_service)
-    @my_session.service_count.should == @start_count
+    expect(@my_session.service_count).to eq(@start_count)
   end
 
   it "should do nothing if you remove an unregistered service" do
     @my_session.register(@my_service)
     @my_session.remove(@a_service)
-    @my_session.service_count.should == @start_count + 1
+    expect(@my_session.service_count).to eq(@start_count + 1)
     @my_session.remove(@my_service)
   end
 

data/spec/jerbil_local_spec.rb

@@ -13,7 +13,7 @@
 # The purpose of these tests is to check the local interface to a Jerbil Broker only
 # 
 require 'rubygems'
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 require 'jerbil/servers'
 require 'jerbil/service'
 require 'jerbil/config'
@@ -21,7 +21,7 @@ require 'jerbil'
 require 'jellog'
 
 
-conf_file = File.expand_path(File.dirname(__FILE__) + '/../test/conf.d/jerbil_local.rb')
+conf_file = File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), 'test', 'conf.d','jerbil_local.rb'))
 
 
 describe "A local Jerbil Session" do
@@ -45,45 +45,45 @@ describe "A local Jerbil Session" do
   end
 
   it "should be easily created" do
-    @my_session.started.should be_true
-    @my_session.registrations.should == 0
-    @my_session.service_count.should == 0
-    @my_session.local_service_count.should == 0
-    @my_session.remote_service_count.should == 0
-    @my_session.get_all.should == []
+    expect(@my_session.started).to be_kind_of(Time)
+    expect(@my_session.registrations).to eq(0)
+    expect(@my_session.service_count).to eq(0)
+    expect(@my_session.local_service_count).to eq(0)
+    expect(@my_session.remote_service_count).to eq(0)
+    expect(@my_session.get_all).to eq([])
   end
 
   it "should be easy to add a service" do
     @my_session.register(@my_service)
-    @my_session.registrations.should == 1
-    @my_session.service_count.should == 1
-    @my_session.local_service_count.should == 1
-    @my_session.remote_service_count.should == 0
+    expect(@my_session.registrations).to eq(1)
+    expect(@my_session.service_count).to eq(1)
+    expect(@my_session.local_service_count).to eq(1)
+    expect(@my_session.remote_service_count).to eq(0)
     services = @my_session.get_all(:ignore_access => true)
-    services[0].should == @my_service
+    expect(services[0]).to eq(@my_service)
     service = @my_session.get_local(:ignore_access => true)
-    service.should == @my_service
-    @my_session.find(:name=>'Another', :ignore_access => true).should == []
+    expect(service).to eq(@my_service)
+    expect(@my_session.find(:name=>'Another', :ignore_access => true)).to eq([])
     @my_session.remove(@my_service)
   end
 
   it "should not be possible to register the same service twice" do
-    @my_service.should_receive(:connect).and_return(true) # make it appear the service is live
+    allow(@my_service).to receive_messages(connect:true) # make it appear the service is live
     @my_session.register(@my_service)
-    lambda{@my_session.register(@my_service)}.should raise_error{Jerbil::ServiceAlreadyRegistered}
+    expect {@my_session.register(@my_service)}.to raise_error{Jerbil::ServiceAlreadyRegistered}
     @my_session.remove(@my_service)
   end
 
   it "should be easy to remove a service" do
     @my_session.register(@my_service)
     @my_session.remove(@my_service)
-    @my_session.service_count.should == 0
+    expect(@my_session.service_count).to eq(0)
   end
 
   it "should do nothing if you remove an unregistered service" do
     @my_session.register(@my_service)
     @my_session.remove(@a_service)
-    @my_session.service_count.should == 1
+    expect(@my_session.service_count).to eq(1)
 
   end