flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/coordinator.rb

@@ -1,172 +1,125 @@
 #!/usr/bin/env ruby
 
-require 'eventmachine'
-require 'em-synchrony'
-
+require 'monitor'
 require 'syslog'
 
+require 'zermelo'
+
 require 'flapjack/configuration'
 require 'flapjack/patches'
-require 'flapjack/redis_pool'
 
-require 'flapjack/logger'
+require 'flapjack/redis_proxy'
+
 require 'flapjack/pikelet'
 
+require 'flapjack/data/condition'
+
 module Flapjack
 
   class Coordinator
 
-    def initialize(config)
-      @config = config
-      @redis_options = config.for_redis
-      @pikelets = []
-
-      @received_signals = []
-
-      @logger = Flapjack::Logger.new("flapjack-coordinator", @config.all['logger'])
-    end
+    # states: :starting, :running, :reloading, :stopped
 
-    def start(options = {})
-      @boot_time = Time.now
+    def initialize(config)
+      Thread.abort_on_exception = true
 
-      EM.synchrony do
-        setup_signals if options[:signals]
+      ActiveSupport.use_standard_json_time_format = true
+      ActiveSupport.time_precision = 0
 
-        redis = Flapjack::RedisPool.new(:config => @redis_options, :size => 1, :logger => @logger)
-        ['entity', 'check'].each do |type|
-          discovered = redis.keys("#{type}_tag:*")
-          redis.sadd("known_tags:#{type}_tag", discovered) unless discovered.empty?
-        end
+      @exit_value = nil
 
-        begin
-          add_pikelets(pikelets(@config.all))
-          loop do
-            while sig = @received_signals.shift do
-              case sig
-              when 'INT', 'TERM'
-                @exit_value = Signal.list[sig] + 128
-                raise Interrupt
-              when 'HUP'
-                reload
-              end
-            end
-            EM::Synchrony.sleep 0.25
-          end
-        rescue Exception => e
-          unless e.is_a?(Interrupt)
-            trace = e.backtrace.join("\n")
-            @logger.fatal "#{e.class.name}\n#{e.message}\n#{trace}"
-            @exit_value = 1
-          end
-          remove_pikelets(@pikelets)
-          EM.stop
-        end
-      end
+      @config   = config
+      @pikelets = []
 
-      Syslog.close if Syslog.opened?
+      @received_signals = []
 
-      @exit_value
+      @state = :starting
+      @monitor = Monitor.new
+      @monitor_cond = @monitor.new_cond
+
+      # needs to be done per-thread
+      cfg = @config.all
+      Flapjack.configure_log('flapjack-coordinator', cfg.nil? ? {} : cfg['logger'])
+
+      @reload = proc {
+        @monitor.synchronize {
+          @monitor_cond.wait_until { :running.eql?(@state) }
+          @state = :reloading
+          @monitor_cond.signal
+        }
+      }
+
+      @shutdown = proc { |exit_val|
+        @monitor.synchronize {
+          @monitor_cond.wait_until { :running.eql?(@state) }
+          @state = :stopping
+          @exit_value = exit_val
+          @monitor_cond.signal
+        }
+      }
     end
 
-    private
-
-    def reload
-      prev_pikelet_cfg = pikelets(@config.all)
-
-      removed = []
-      added = []
-      ask_running = []
+    def start(opts = {})
+      # we can't block on the main thread, as signals interrupt that
+      Thread.new do
+        # needs to be done per-thread
+        cfg = @config.all
+        Flapjack.configure_log('flapjack-coordinator', cfg.nil? ? {} : cfg['logger'])
 
-      cfg_filename = @config.filename
-      @config = Flapjack::Configuration.new
-      @config.load(cfg_filename)
+        @boot_time = Time.now
 
-      enabled_pikelet_cfg = pikelets(@config.all)
+        Flapjack::RedisProxy.config = @config.for_redis
 
-      (prev_pikelet_cfg.keys + enabled_pikelet_cfg.keys).each do |type|
+        pikelet_defs = pikelet_definitions(cfg)
+        return if pikelet_defs.empty?
 
-        if prev_pikelet_cfg.keys.include?(type)
-          if enabled_pikelet_cfg.keys.include?(type)
-            ask_running << type
-          else
-            removed << type
-          end
-        elsif enabled_pikelet_cfg.keys.include?(type)
-          added << type
+        create_pikelets(pikelet_defs).each do |pik|
+          @pikelets << pik
         end
 
-      end
-
-      @pikelets.select {|pik| ask_running.include?(pik.type) }.each do |pik|
-        # for sections previously there and still there, ask them
-        # to make the config change; they will if they can, or will signal
-        # restart is needed if not
-
-        # reload() returns trinary value here; true means the change was made, false
-        # means the pikelet needs to be restarted, nil means no change
-        # was required
-        next unless pik.reload(enabled_pikelet_cfg[pik.type]).is_a?(FalseClass)
-        removed << pik.type
-        added << pik.type
-      end
-
-      removed_pikelets = @pikelets.select {|pik| removed.include?(pik.type) }
+        @pikelets.each do |pik|
+          pik.start
+        end
 
-      remove_pikelets(removed_pikelets)
+        setup_signals if opts[:signals]
+
+        # block this thread until 'stop' has been called, and
+        # all pikelets have been stopped
+        @monitor.synchronize {
+          @state = :running
+          @monitor_cond.wait_until { !(:running.eql?(@state)) }
+          case @state
+          when :reloading
+            reload
+            @state = :running
+            @monitor_cond.signal
+          when :stopping
+            @pikelets.map(&:stop)
+            @pikelets.clear
+            @state = :stopped
+            @monitor_cond.signal
+          end
+        }
 
-      # is there a nicer way to only keep the parts of the hash with matching keys?
-      added_pikelets = enabled_pikelet_cfg.select {|k, v| added.include?(k) }
+      end.join
 
-      add_pikelets(added_pikelets)
+      @exit_value
     end
 
+  private
+
     # the global nature of this seems at odds with it calling stop
     # within a single coordinator instance. Coordinator is essentially
     # a singleton anyway...
     def setup_signals
-      Kernel.trap('INT')    { @received_signals << 'INT' unless @received_signals.include?('INT') }
-      Kernel.trap('TERM')   { @received_signals << 'TERM' unless @received_signals.include?('TERM') }
+      Kernel.trap('INT')    { Thread.new { @shutdown.call(Signal.list['INT']) }.join }
+      Kernel.trap('TERM')   { Thread.new { @shutdown.call(Signal.list['TERM']) }.join }
       unless RbConfig::CONFIG['host_os'] =~ /mswin|windows|cygwin/i
-        Kernel.trap('HUP')  { @received_signals << 'HUP' unless @received_signals.include?('HUP') }
-      end
-    end
-
-    # passed a hash with {PIKELET_TYPE => PIKELET_CFG, ...}
-    def add_pikelets(pikelets_data = {})
-      pikelets_data.each_pair do |type, cfg|
-        next unless pikelet = Flapjack::Pikelet.create(type,
-          :config => cfg, :redis_config => @redis_options,
-          :boot_time => @boot_time)
-
-        @pikelets << pikelet
-        pikelet.start
-      end
-    end
-
-    def remove_pikelets(piks, opts = {})
-      piks.map(&:stop)
-
-      loop do
-        # only prints state changes, otherwise pikelets not closing promptly can
-        # cause everything else to be spammy
-        piks.each do |pik|
-          old_status = pik.status
-          pik.update_status
-          status = pik.status
-          next if old_status.eql?(status)
-          @logger.info "#{pik.type}: #{old_status} -> #{status}"
-        end
-
-        if piks.any? {|p| p.status == 'stopping' }
-          EM::Synchrony.sleep 0.25
-        else
-          @pikelets -= piks
-          break
-        end
+        Kernel.trap('HUP')  { Thread.new { @reload.call }.join }
       end
     end
 
-    def pikelets(config_env)
+    def pikelet_definitions(config_env)
       config = {}
       return config unless config_env
 
@@ -197,6 +150,62 @@ module Flapjack
       } )
     end
 
+    # passed a hash with {PIKELET_TYPE => PIKELET_CFG, ...}
+    # returns unstarted pikelet instances.
+    def create_pikelets(pikelets_data = {})
+      pikelets_data.inject([]) do |memo, (type, cfg)|
+        pikelets = Flapjack::Pikelet.create(type, @shutdown, :config => cfg,
+                                            :boot_time => @boot_time)
+        memo += pikelets
+        memo
+      end
+    end
+
+    # NB: global config options (e.g. daemonize, pidfile,
+    # logfile, redis options) won't be checked on reload.
+    # should we do a full restart if some of these change?
+    def reload
+      # TODO refactor cfg load and key retrieval, consolidate with initial load
+      prev_pikelet_cfg = pikelet_definitions(@config.all)
+
+      @config.reload
+
+      current_pikelet_cfg = pikelet_definitions(@config.all)
+
+      prev_keys    = prev_pikelet_cfg.keys
+      current_keys = current_pikelet_cfg.keys
+
+      removed     = prev_keys - current_keys
+      added       = current_keys - prev_keys
+      ask_running = current_keys - (added + removed)
+
+      # for sections previously there and still there, ask them
+      # to make the config change; they will if they can, or will signal
+      # restart is needed if not
+      # reload() returns trinary value here; true means the change was made, false
+      # means the pikelet needs to be restarted, nil means no change
+      # was required.
+      ask_running.each do |ask_key|
+        next unless pikelet = @pikelets.detect {|pik| ask_key == pik.type}
+
+        if pikelet.reload(current_pikelet_cfg[pikelet.type]).is_a?(FalseClass)
+          removed << pikelet.type
+          added << pikelet.type
+        end
+      end
+
+      pikelets_to_remove = @pikelets.select{|pik| removed.include?(pik.type) }
+      pikelets_to_remove.map(&:stop)
+      @pikelets -= pikelets_to_remove
+
+      added_defs = current_pikelet_cfg.select {|k, v| added.include?(k) }
+
+      create_pikelets(added_defs).each do |pik|
+        @pikelets << pik
+        pik.start
+      end
+    end
+
   end
 
 end

data/lib/flapjack/data/acknowledgement.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+require 'securerandom'
+
+require 'active_model'
+require 'swagger/blocks'
+
+require 'zermelo/records/stub'
+
+require 'flapjack/data/extensions/associations'
+require 'flapjack/data/extensions/short_name'
+
+require 'flapjack/data/event'
+
+module Flapjack
+  module Data
+    class Acknowledgement
+
+      include Swagger::Blocks
+
+      include Zermelo::Records::Stub
+      include ActiveModel::Serializers::JSON
+      self.include_root_in_json = false
+
+      include Flapjack::Data::Extensions::Associations
+      include Flapjack::Data::Extensions::ShortName
+
+      define_attributes :duration => :integer,
+                        :summary => :string
+
+      attr_accessor :queue
+
+      def save!
+        @id ||= SecureRandom.uuid
+        @duration ||= (4 * 60 * 60)
+        @saved = true
+      end
+
+      def persisted?
+        !@id.nil? && @saved.is_a?(TrueClass)
+      end
+
+      def check=(c)
+        raise "Acknowledgement not saved" unless persisted?
+        raise "Acknowledgement queue not set" if @queue.nil? || @queue.empty?
+        raise "Acknowledgement already sent" if @sent
+
+        if c.failing && c.enabled
+          @checks = [c]
+          Flapjack::Data::Event.create_acknowledgements(
+            @queue, @checks, :duration => self.duration, :summary => self.summary
+          )
+        end
+
+        @sent = true
+      end
+
+      def tag=(t)
+        raise "Acknowledgement not saved" unless persisted?
+        raise "Acknowledgement queue not set" if @queue.nil? || @queue.empty?
+        raise "Acknowledgement already sent" if @sent
+
+        checks = t.checks.intersect(:failing => true, :enabled => true)
+
+        unless checks.empty?
+          @checks = checks.all
+          Flapjack::Data::Event.create_acknowledgements(
+            @queue, @checks, :duration => self.duration, :summary => self.summary
+          )
+        end
+
+        @sent = true
+      end
+
+      swagger_schema :Acknowledgement do
+        key :required, [:id, :type]
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::Acknowledgement.short_model_name.singular]
+        end
+        property :duration do
+          key :type, :integer
+        end
+        property :summary do
+          key :type, :string
+        end
+        property :relationships do
+          key :"$ref", :AcknowledgementLinks
+        end
+      end
+
+      swagger_schema :AcknowledgementLinks do
+        # create (and response) must have one (and only one) of these set
+        property :check do
+          key :"$ref", :CheckLinkage
+        end
+        property :tag do
+          key :"$ref", :TagLinkage
+        end
+      end
+
+      swagger_schema :AcknowledgementCreate do
+        key :required, [:type]
+        property :id do
+          key :type, :string
+          key :format, :uuid
+        end
+        property :type do
+          key :type, :string
+          key :enum, [Flapjack::Data::Acknowledgement.short_model_name.singular]
+        end
+        property :duration do
+          key :type, :integer
+        end
+        property :summary do
+          key :type, :string
+        end
+        property :relationships do
+          key :"$ref", :AcknowledgementCreateLinks
+        end
+      end
+
+      swagger_schema :AcknowledgementCreateLinks do
+        # create (and response) must have one (and only one) of these set
+        # key :required, [:check, :tag]
+        property :check do
+          key :"$ref", :data_CheckReference
+        end
+        property :tag do
+          key :"$ref", :data_TagReference
+        end
+      end
+
+      def self.swagger_included_classes
+        # hack -- hardcoding for now
+        []
+      end
+
+      def self.jsonapi_methods
+        @jsonapi_methods ||= {
+          :post => Flapjack::Gateways::JSONAPI::Data::MethodDescriptor.new(
+            :attributes => [:duration, :summary],
+            :descriptions => {
+              :singular => "Acknowledge a check, or acknowledge all checks linked to a tag.",
+              :multiple => "Acknowledge multiple checks, or checks linked to different tags."
+            }
+          )
+        }
+      end
+
+      def self.jsonapi_associations
+        unless instance_variable_defined?('@jsonapi_associations')
+          @jsonapi_associations = {
+            :check => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :post => true,
+              :number => :singular, :link => false, :includable => false,
+              :type => 'check',
+              :klass => Flapjack::Data::Check
+            ),
+            :tag => Flapjack::Gateways::JSONAPI::Data::JoinDescriptor.new(
+              :post => true,
+              :number => :singular, :link => false, :includable => false,
+              :type => 'tag',
+              :klass => Flapjack::Data::Tag
+            )
+          }
+          populate_association_data(@jsonapi_associations)
+        end
+        @jsonapi_associations
+      end
+    end
+  end
+end