Remove EventMachine from nats package

packages/nats/packaging

@@ -22,11 +22,6 @@ pushd bosh-nats-sync/ > /dev/null
   mv *.gem ../vendor/cache
 popd > /dev/null
 
-pushd vendor/cache/eventmachine-* > /dev/null
-  gem build eventmachine.gemspec
-  mv *.gem ../
-popd > /dev/null
-
 if [ "`uname -m`" == "ppc64le" ]; then
     bundle config build.nokogiri '--use-system-libraries'
 fi

packages/nats/spec

@@ -8,5 +8,4 @@ files:
 - nats/nats-server-v*-linux-amd64.tar.gz
 - bosh-nats-sync/**/*
 - vendor/cache/*.gem
-- vendor/cache/eventmachine-*/**
 - vendor/cache/extensions/**

src/Gemfile.lock

@@ -90,14 +90,10 @@ PATH
   specs:
     bosh-nats-sync (0.0.0)
       cf-uaa-lib (~> 3.2.1)
-      em-http-request
-      eventmachine (~> 1.3.0.dev.1)
       logging (~> 2.2.2)
-      nats-pure
       openssl (>= 3.2.0)
       rest-client
-      sinatra (~> 2.2.0)
-      thin
+      rufus-scheduler
 
 PATH
   remote: bosh-template

src/bosh-nats-sync/bosh-nats-sync.gemspec

@@ -19,12 +19,8 @@ Gem::Specification.new do |spec|
   spec.executables << 'bosh-nats-sync'
 
   spec.add_dependency 'cf-uaa-lib',  '~>3.2.1'
-  spec.add_dependency 'eventmachine',    '~>1.3.0.dev.1'
   spec.add_dependency 'logging',         '~>2.2.2'
-  spec.add_dependency 'em-http-request'
-  spec.add_dependency 'nats-pure'
   spec.add_dependency 'openssl', '>=3.2.0'
-  spec.add_dependency 'thin'
-  spec.add_dependency 'sinatra',   '~>2.2.0'
+  spec.add_dependency 'rufus-scheduler'
   spec.add_dependency 'rest-client'
 end

src/bosh-nats-sync/lib/nats_sync.rb

@@ -9,6 +9,5 @@ module NATSSync
 require 'nats_sync/nats_auth_config'
 require 'nats_sync/auth_provider'
 
-require 'eventmachine'
 require 'json'
 require 'yaml'

src/bosh-nats-sync/lib/nats_sync/runner.rb

@@ -1,3 +1,5 @@
+require 'rufus-scheduler'
+
 module NATSSync
   class Runner
     include YamlHelper
@@ -10,38 +12,38 @@ def initialize(config_file)
       @nats_config_file_path = config['nats']['config_file_path']
       @nats_server_executable = config['nats']['nats_server_executable']
       @nats_server_pid_file = config['nats']['nats_server_pid_file']
+
+      @scheduler = Rufus::Scheduler.new
     end
 
     def run
       NATSSync.logger.info('Nats Sync starting...')
-      EM.error_handler { |e| handle_em_error(e) }
-      EM.run do
-        UsersSync.reload_nats_server_config(@nats_server_executable, @nats_server_pid_file)
-        setup_timers
+
+      UsersSync.reload_nats_server_config(@nats_server_executable, @nats_server_pid_file)
+
+      # Rufus Scheduler does not have a way to inject an error handler, and in fact recommends
+      # in the readme to redefine the on_error method if you need custom behavior.
+      def @scheduler.on_error(job, err)
+        NATSSync.logger.fatal(err.message.to_s)
+        NATSSync.logger.fatal(err.backtrace.join("\n")) if err.respond_to?(:backtrace) && err.backtrace.respond_to?(:join)
+        shutdown
+      end
+
+      @scheduler.interval "#{@poll_user_sync}s" do
+        sync_nats_users
       end
+
+      @scheduler.join
     end
 
     def stop
-      EM.stop_event_loop
+      @scheduler.shutdown
     end
 
     private
 
-    def setup_timers
-      EM.schedule do
-        EM.add_periodic_timer(@poll_user_sync) { sync_nats_users }
-      end
-    end
-
     def sync_nats_users
       UsersSync.new(@nats_config_file_path, @bosh_config, @nats_server_executable, @nats_server_pid_file).execute_users_sync
     end
-
-    def handle_em_error(err)
-      @shutting_down = true
-      NATSSync.logger.fatal(err.message.to_s)
-      NATSSync.logger.fatal(err.backtrace.join("\n")) if err.respond_to?(:backtrace) && err.backtrace.respond_to?(:join)
-      stop
-    end
   end
 end

src/bosh-nats-sync/spec/nats_sync/runner_spec.rb

@@ -4,9 +4,12 @@
   subject { NATSSync::Runner.new(sample_config) }
   let(:user_sync_class) { class_double('NATSSync::UsersSync').as_stubbed_const }
   let(:user_sync_instance) { instance_double(NATSSync::UsersSync) }
+  let(:scheduler) { Rufus::Scheduler.new }
   before do
     allow(NATSSync).to receive(:logger).and_return(logger)
     allow(logger).to receive :info
+    allow(Rufus::Scheduler).to receive(:new).and_return(scheduler)
+    allow(scheduler).to receive(:shutdown).and_call_original
   end
 
   let(:logger) { spy('Logger') }
@@ -49,9 +52,8 @@
 
   describe 'exception handling' do
     before do
-      error = StandardError.new('EM event loop exception')
+      error = StandardError.new('exception')
       error.set_backtrace(['backtrace'])
-      allow(EM).to receive(:stop_event_loop)
 
       allow(user_sync_instance).to receive(:execute_users_sync).and_raise(error)
       allow(user_sync_class).to receive(:reload_nats_server_config)
@@ -62,10 +64,10 @@
       sleep(2)
     end
 
-    context 'when EM loop error occurs' do
-      it 'stops the EM loop and logs the error' do
-        expect(EM).to have_received(:stop_event_loop)
-        expect(logger).to have_received(:fatal).with('EM event loop exception')
+    context 'when an error occurs' do
+      it 'stops the scheduler and logs the error' do
+        expect(scheduler).to have_received(:shutdown)
+        expect(logger).to have_received(:fatal).with('exception')
         expect(logger).to have_received(:fatal).with('backtrace')
       end
     end