flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/cli/server.rb

@@ -1,7 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'dante'
-
 require 'flapjack/coordinator'
 
 module Flapjack
@@ -22,171 +20,16 @@ module Flapjack
         @config_env = @config.all
 
         if @config_env.nil? || @config_env.empty?
-          exit_now! "No config data for environment '#{FLAPJACK_ENV}' found in '#{global_options[:config]}'"
-        end
-
-        @pidfile = case
-        when !@options[:pidfile].nil?
-          @options[:pidfile]
-        when !@config_env['pid_dir'].nil?
-          File.join(@config_env['pid_dir'], 'flapjack.pid')
-        else
-          "/var/run/flapjack/flapjack.pid"
-        end
-
-        @logfile = case
-        when !@options[:logfile].nil?
-          @options[:logfile]
-        when !@config_env['log_dir'].nil?
-          File.join(@config_env['log_dir'], 'flapjack.log')
-        else
-          "/var/run/flapjack/flapjack.log"
-        end
-
-        if options[:rbtrace]
-          require 'rbtrace'
+          exit_now! "No config data found in '#{global_options[:config]}'"
         end
       end
 
       def start
-        if runner.daemon_running?
-          puts "Flapjack is already running."
-        else
-          print "Flapjack starting..."
-          main_umask = nil
-          if @options[:daemonize]
-            main_umask = File.umask
-          else
-            print "\n"
-          end
-          return_value = nil
-          runner.execute(:daemonize => @options[:daemonize]) {
-            File.umask(main_umask) if @options[:daemonize]
-            return_value = start_server
-          }
-          puts " done."
-          unless return_value.nil? || [Signal.list['INT'] + 128,
-                                       Signal.list['TERM'] + 128].include?(return_value)
-            exit_now!(return_value)
-          end
-        end
-      end
-
-      def stop
-        pid = get_pid
-        if runner.daemon_running?
-          print "Flapjack stopping..."
-          runner.execute(:kill => true)
-          puts " done."
-        else
-          puts "Flapjack is not running."
-        end
-        exit_now! "Failed to stop Flapjack #{pid}" unless wait_pid_gone(pid)
-      end
-
-      def restart
-        pid = get_pid
-        if runner.daemon_running?
-          print "Flapjack stopping..."
-          runner.execute(:kill => true)
-          puts " done."
-        end
-        exit_now! "Failed to stop Flapjack #{pid}" unless wait_pid_gone(pid)
-
-        @runner = nil
-
-        print "Flapjack starting..."
-
-        main_umask = File.umask
-        runner.execute(:daemonize => true) {
-          File.umask(main_umask)
-          start_server
-        }
-        puts " done."
-      end
-
-      def reload
-        if runner.daemon_running?
-          pid = get_pid
-          print "Reloading Flapjack configuration..."
-          begin
-            Process.kill('HUP', pid)
-            puts " sent HUP to pid #{pid}."
-          rescue => e
-            puts " couldn't send HUP to pid '#{pid}'."
-          end
-        else
-          exit_now! "Flapjack is not running daemonized."
-        end
-      end
-
-      def status
-        if runner.daemon_running?
-          pid = get_pid
-          uptime = Time.now - File.stat(@pidfile).ctime
-          puts "Flapjack is running: pid #{pid}, uptime #{uptime}"
-        else
-          exit_now! "Flapjack is not running"
-        end
-      end
-
-      private
-
-      def runner
-        return @runner if @runner
-
-        self.class.skip_dante_traps
-
-        @runner = Dante::Runner.new('flapjack', :pid_path => @pidfile,
-          :log_path => @logfile)
-        @runner
-      end
-
-      def self.skip_dante_traps
-        return if Dante::Runner.respond_to?(:orig_start)
-        Dante::Runner.send(:alias_method, :orig_start, :start)
-        Dante::Runner.send(:define_method, :start) do
-          if log_path = options[:log_path] && options[:daemonize].nil?
-             redirect_output!
-          end
-
-          # skip signal traps
-          @startup_command.call(self.options) if @startup_command
-        end
-      end
-
-      def start_server
+        puts "Flapjack starting..."
         @coordinator = Flapjack::Coordinator.new(@config)
-        @coordinator.start(:signals => true)
-      end
-
-      def process_exists(pid)
-        return unless pid
-        begin
-          Process.kill(0, pid)
-          return true
-        rescue Errno::ESRCH
-          return false
-        end
-      end
-
-      # wait until the specified pid no longer exists, or until a timeout is reached
-      def wait_pid_gone(pid, timeout = 30)
-        print "waiting for a max of #{timeout} seconds for process #{pid} to exit" if process_exists(pid)
-        started_at = Time.now.to_i
-        while process_exists(pid)
-          break unless (Time.now.to_i - started_at < timeout)
-          print '.'
-          sleep 1
-        end
-        puts ''
-        !process_exists(pid)
-      end
-
-      def get_pid
-        IO.read(@pidfile).chomp.to_i
-      rescue StandardError
-        pid = nil
+        return_value = @coordinator.start(:signals => true)
+        puts " done."
+        exit_now!(return_value) unless return_value.nil?
       end
 
     end
@@ -195,78 +38,8 @@ end
 
 desc 'Server for running components (e.g. processor, notifier, gateways)'
 command :server do |server|
-
-  server.desc 'Start the server'
-
-  server.command :start do |start|
-
-    start.switch [:d, 'daemonize'], :desc => 'Daemonize',
-      :default_value => true
-
-    start.flag   [:p, 'pidfile'],   :desc => 'PATH of the pidfile to write to'
-
-    start.flag   [:l, 'logfile'],   :desc => 'PATH of the logfile to write to'
-
-    start.flag   [:r, 'rbtrace'],   :desc => 'Enable rbtrace profiling'
-
-    start.action do |global_options,options,args|
-      server = Flapjack::CLI::Server.new(global_options, options)
-      server.start
-    end
-  end
-
-  server.desc 'Stop the server'
-  server.command :stop do |stop|
-
-    stop.flag   [:p, 'pidfile'],   :desc => 'PATH of the pidfile to write to'
-
-    stop.flag   [:l, 'logfile'],   :desc => 'PATH of the logfile to write to'
-
-    stop.action do |global_options,options,args|
-      server = Flapjack::CLI::Server.new(global_options, options)
-      server.stop
-    end
+  server.action do |global_options,options,args|
+    cli_server = Flapjack::CLI::Server.new(global_options, options)
+    cli_server.start
   end
-
-  server.desc 'Restart the server'
-  server.command :restart do |restart|
-
-    restart.flag   [:p, 'pidfile'],   :desc => 'PATH of the pidfile to write to'
-
-    restart.flag   [:l, 'logfile'],   :desc => 'PATH of the logfile to write to'
-
-    restart.flag   [:r, 'rbtrace'],   :desc => 'Enable rbtrace profiling'
-
-    restart.action do |global_options,options,args|
-      server = Flapjack::CLI::Server.new(global_options, options)
-      server.restart
-    end
-  end
-
-  server.desc 'Reload the server configuration'
-  server.command :reload do |reload|
-
-    reload.flag   [:p, 'pidfile'],   :desc => 'PATH of the pidfile to write to'
-
-    reload.flag   [:l, 'logfile'],   :desc => 'PATH of the logfile to write to'
-
-    reload.action do |global_options,options,args|
-      server = Flapjack::CLI::Server.new(global_options, options)
-      server.reload
-    end
-  end
-
-  server.desc 'Get server status'
-  server.command :status do |status|
-
-    status.flag   [:p, 'pidfile'],   :desc => 'PATH of the pidfile to write to'
-
-    status.flag   [:l, 'logfile'],   :desc => 'PATH of the logfile to write to'
-
-    status.action do |global_options,options,args|
-      server = Flapjack::CLI::Server.new(global_options, options)
-      server.status
-    end
-  end
-
 end

data/lib/flapjack/cli/simulate.rb

@@ -1,13 +1,9 @@
 #!/usr/bin/env ruby
 
-require 'eventmachine'
-require 'em-synchrony'
 require 'redis'
-require 'redis/connection/synchrony'
 
 require 'flapjack/configuration'
 require 'flapjack/data/event'
-require 'flapjack/data/migration'
 
 module Flapjack
   module CLI
@@ -27,83 +23,81 @@ module Flapjack
         @config_env = config.all
 
         if @config_env.nil? || @config_env.empty?
-          exit_now! "No config data for environment '#{FLAPJACK_ENV}' found in '#{global_options[:config]}'"
+          exit_now! "No config data found in '#{global_options[:config]}'"
         end
 
-        @redis_options = config.for_redis
+        Flapjack::RedisProxy.config = config.for_redis
+        Zermelo.redis = Flapjack.redis
       end
 
       def _fail
         events(:state => @options[:state], :recover => false,
-          :entity => @options[:entity], :check => @options[:check],
-          :tags => @options[:tags],
-          :minutes => @options[:time].to_f, :interval => @options[:interval].to_f)
+          :check => @options[:check], :minutes => @options[:time].to_f,
+          :interval => @options[:interval].to_f)
       end
 
       def fail_and_recover
         events(:state => @options[:state], :recover => true,
-          :entity => @options[:entity], :check => @options[:check],
-          :tags => @options[:tags],
-          :minutes => @options[:time].to_f, :interval => @options[:interval].to_f)
+          :check => @options[:check], :minutes => @options[:time].to_f,
+          :interval => @options[:interval].to_f)
       end
 
       def ok
         events(:state => 'ok', :recover => false,
-          :entity => @options[:entity], :check => @options[:check],
-          :tags => @options[:tags],
-          :minutes => @options[:time].to_f, :interval => @options[:interval].to_f)
+          :check => @options[:check], :minutes => @options[:time].to_f,
+          :interval => @options[:interval].to_f)
       end
 
       private
 
-      def redis
-        return @redis unless @redis.nil?
-        @redis = Redis.new(@redis_options)
-        Flapjack::Data::Migration.migrate_entity_check_data_if_required(:redis => @redis)
-        Flapjack::Data::Migration.clear_orphaned_entity_ids(:redis => @redis)
-        @redis
-      end
-
       def events(opts = {})
         stop_after = (opts[:minutes] * 60).to_i
         recover = opts[:recover]
         state = opts[:state] || 'critical'
         event = {
-          'entity' => opts[:entity] || 'foo-app-01',
-          'check'  => opts[:check]  || 'HTTP',
-          'tags'   => opts[:tags]   || [],
+          'check'  => opts[:check] || 'HTTP',
           'type'   => 'service'
         }
         failure  = event.merge('state' => state, 'summary' => 'Simulated check output (test by operator)')
-        recovery = event.merge('state' => 'ok',  'summary' => 'Simulated check output (test by operator)')
-        key = "#{event['entity']}:#{event['check']}"
-
-        EM.synchrony do
-
-          puts "#{Time.now}: sending failure event (#{state}) for #{key}"
-          Flapjack::Data::Event.add(failure, :redis => redis)
-
-          EM.add_timer(stop_after) do
-            puts "#{Time.now}: stopping"
-            if recover
-              EM.synchrony do
-                puts "#{Time.now}: sending recovery event for #{key}"
-                Flapjack::Data::Event.add(recovery.merge('time' => Time.now.to_i),
-                  :redis => redis)
+        recovery = event.merge('state' => 'ok', 'summary' => 'Simulated check output (test by operator)')
+        key = event['check']
+
+        lock = Monitor.new
+        stop_cond = lock.new_cond
+        @finish = false
+
+        failer = Thread.new do
+          fin = nil
+
+          loop do
+            lock.synchronize do
+              unless fin = @finish
+                puts "#{Time.now}: sending failure event (#{state}) for #{key}"
+                Flapjack::Data::Event.push('events', failure.merge('time' => Time.now.to_i))
+                stop_cond.wait(opts[:interval])
               end
             end
-            EM.stop
+            break if fin
           end
+        end
 
-          EM.add_periodic_timer(opts[:interval]) do
-            EM.synchrony do
-              puts "#{Time.now}: sending failure event (#{state}) for #{key}"
-              Flapjack::Data::Event.add(failure.merge('time' => Time.now.to_i),
-                :redis => redis)
+        stopper = Thread.new do
+          sleep stop_after
+          lock.synchronize do
+            puts "#{Time.now}: stopping"
+            if recover
+              puts "#{Time.now}: sending recovery event for #{key}"
+              Flapjack::Data::Event.push('events', recovery.merge('time' => Time.now.to_i))
             end
+            @finish = true
+            stop_cond.signal
           end
-
         end
+
+        stopper.join
+        failer.join
+
+        Flapjack.redis.quit
       end
 
     end
@@ -124,9 +118,6 @@ command :simulate do |simulate|
     _fail.flag [:i, 'interval'], :desc => "SECONDS between events, can be decimal eg 0.1 (10)",
       :default_value => 10
 
-    _fail.flag [:e, 'entity'],   :desc => "ENTITY to generate failure events for ('foo-app-01')",
-      :default_value => 'foo-app-01'
-
     _fail.flag [:k, 'check'],    :desc => "CHECK to generate failure events for ('HTTP')",
       :default_value => 'HTTP'
 
@@ -151,9 +142,6 @@ command :simulate do |simulate|
     fail_and_recover.flag [:i, 'interval'], :desc => "SECONDS between events, can be decimal eg 0.1 (10)",
       :default_value => 10
 
-    fail_and_recover.flag [:e, 'entity'],   :desc => "ENTITY to generate failure events for ('foo-app-01')",
-      :default_value => 'foo-app-01'
-
     fail_and_recover.flag [:k, 'check'],    :desc => "CHECK to generate failure events for ('HTTP')",
       :default_value => 'HTTP'
 
@@ -178,9 +166,6 @@ command :simulate do |simulate|
     ok.flag [:i, 'interval'], :desc => "SECONDS between events, can be decimal eg 0.1 (10)",
       :default_value => 10
 
-    ok.flag [:e, 'entity'],   :desc => "ENTITY to generate ok events for ('foo-app-01')",
-      :default_value => 'foo-app-01'
-
     ok.flag [:k, 'check'],    :desc => "CHECK to generate ok events for ('HTTP')",
       :default_value => 'HTTP'
 

data/lib/flapjack/configuration.rb

@@ -1,44 +1,37 @@
 #!/usr/bin/env ruby
 
-require 'yaml'
-require 'logger'
+require 'toml'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module Flapjack
-
   class Configuration
 
-    DEFAULT_CONFIG_PATH = '/etc/flapjack/flapjack_config.yaml'
-
     attr_reader :filename
 
-    def initialize(opts = {})
-      @logger = opts[:logger]
-    end
-
     def all
-      @config_env
+      @config
     end
 
     def for_redis
-      return unless @config_env
+      return unless @config
 
-      redis_defaults = {'host' => 'localhost',
-                        'port' => 6379,
-                        'path' => nil,
-                        'db'   => 0}
+      redis_defaults = {'host'   => '127.0.0.1',
+                        'port'   => 6379,
+                        'path'   => nil,
+                        'db'     => 0}
 
-      @config_env['redis'] = {} unless @config_env.has_key?('redis')
+      @config['redis'] = {} unless @config.has_key?('redis')
 
-      redis = @config_env['redis']
+      redis = @config['redis']
       redis_defaults.each_pair do |k,v|
-        next if redis.has_key?(k) && redis[k] &&
+        next if redis.has_key?(k) && !redis[k].nil? &&
           !(redis[k].is_a?(String) && redis[k].empty?)
         redis[k] = v
       end
 
       redis_path = (redis['path'] || nil)
-      base_opts = {:db => (redis['db'] || 0)}
-      base_opts[:driver] = redis['driver'] if redis['driver']
+      base_opts = HashWithIndifferentAccess.new({ :db => (redis['db'] || 0) })
+      base_opts[:driver] = redis['driver'] unless redis['driver'].nil?
       redis_config = base_opts.merge(
         (redis_path ? { :path => redis_path } :
                       { :host => (redis['host'] || '127.0.0.1'),
@@ -50,37 +43,58 @@ module Flapjack
       redis_config
     end
 
-    def load(filename)
-      @filename = nil
-      @config_env = nil
+    def load(file_pattern)
+      @file_pattern = nil
+      @config = nil
+
+      config_file_names = Dir.glob(file_pattern)
 
-      unless File.file?(filename)
-        @logger.error "Could not find file '#{filename}'" if @logger
+      if config_file_names.nil?
+        Flapjack.logger.error {
+          "Could not load config files using file_pattern '#{file_pattern}'"
+        }
         return
       end
 
-      unless defined?(FLAPJACK_ENV)
-        @logger.error "Environment variable 'FLAPJACK_ENV' is not set" if @logger
-        return
+      yaml_file = config_file_names.detect {|f| f.end_with?('.yaml') }
+
+      unless yaml_file.nil?
+        raise "#{yaml_file} looks like a YAML file. Flapjack v2 config files are now in TOML, " +
+          "see flapjack.io/docs/2.x/configuration"
       end
 
-      config = YAML::load_file(filename)
+      config = config_file_names.inject({}) do |config, file_name|
+        config.merge!(TOML.load_file(file_name)) do |key, old_val, new_val|
+          if old_val != new_val
+            Flapjack.logger.error {
+              "Duplicate configuration setting #{key} in #{file_name}"
+            }
+            break
+          else
+            new_val
+          end
+        end
+      end
 
-      if config.nil?
-        @logger.error "Could not load config file '#{filename}'" if @logger
+      if config.nil? || config.empty?
+        Flapjack.logger.error {
+          "Could not load config files using file_pattern '#{file_pattern}'"
+        }
         return
       end
 
-      @config_env = config[FLAPJACK_ENV]
+      @config = HashWithIndifferentAccess.new(config)
+
+      @file_pattern = file_pattern
+    end
 
-      if @config_env.nil?
-        @logger.error "No config data for environment '#{FLAPJACK_ENV}' found in '#{filename}'" if @logger
+    def reload
+      if @file_pattern.nil?
+        Flapjack.logger.error "Cannot reload, config file_pattern not set."
         return
       end
 
-      @filename = filename
+      load(@file_pattern)
     end
-
   end
-
 end