flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/patches.rb

@@ -1,65 +1,12 @@
 #!/usr/bin/env ruby
 
-require 'thin'
-require 'redis'
-
-# we don't want to stop the entire EM reactor when we stop a web server
-# & @connections data type changed in thin 1.5.1
-module Thin
-
-  # see https://github.com/flapjack/flapjack/issues/169
-  class Request
-    class EqlTempfile < ::Tempfile
-      def eql?(obj)
-        obj.equal?(self) && (obj == self)
-      end
-    end
-
-    def move_body_to_tempfile
-      current_body = @body
-      current_body.rewind
-      @body = Thin::Request::EqlTempfile.new(BODY_TMPFILE)
-      @body.binmode
-      @body << current_body.read
-      @env[RACK_INPUT] = @body
-    end
-  end
-
-  module Backends
-    class Base
-      def stop!
-        @running  = false
-        @stopping = false
-
-        # EventMachine.stop if EventMachine.reactor_running?
-
-        case @connections
-        when Array
-          @connections.each { |connection| connection.close_connection }
-        when Hash
-          @connections.each_value { |connection| connection.close_connection }
-        end
-        close
-      end
-    end
-  end
-end
+require 'gli'
+require 'logger'
 
-# As Redis::Future objects inherit from BasicObject, it's difficult to
-# distinguish between them and other objects in collected data from
-# pipelined queries.
-#
-# (One alternative would be to put other values in Futures ourselves, and
-#  evaluate everything...)
-class Redis
-  class Future
-    def class
-      ::Redis::Future
-    end
-  end
-end
+# fix for webrick's assuming 1.8.7 Logger syntax
+class ::Logger; alias_method :write, :<<; end
 
-module GLI
+module ::GLI
   class Command
     attr_accessor :passthrough
     def _action
@@ -85,12 +32,10 @@ module GLI
           arguments = option_block_parser.parse!(arguments)
 
           parsed_command_options[command] = option_parser_factory.options_hash_with_defaults_set!
-          command_finder                  = CommandFinder.new(command.commands,command.get_default_command)
+          command_finder                  = CommandFinder.new(command.commands, :default_command => command.get_default_command)
           next_command_name               = arguments.shift
 
-          gli_major_version, gli_minor_version = GLI::VERSION.split('.')
-          required_options = [command.flags, parsing_result.command, parsed_command_options[command]]
-          verify_required_options!(*required_options)
+          verify_required_options!(command.flags, command, parsed_command_options[command])
 
           begin
             command = command_finder.find_command(next_command_name)
@@ -99,7 +44,7 @@ module GLI
             break
           rescue UnknownCommand
             arguments.unshift(next_command_name)
-            # Although command finder could certainy know if it should use
+            # Although command finder could certainly know if it should use
             # the default command, it has no way to put the "unknown command"
             # back into the argument stack.  UGH.
             unless command.get_default_command.nil?

data/lib/flapjack/pikelet.rb

@@ -8,206 +8,248 @@
 # with butter, at afternoon tea, but can also be served at morning tea."
 #    from http://en.wikipedia.org/wiki/Pancake
 
-# the redis/synchrony gems need to be required in this particular order, see
-# the redis-rb README for details
-require 'hiredis'
-require 'redis/connection/synchrony'
-require 'redis'
-require 'thin'
+require 'monitor'
+
+require 'puma'
+
+require 'flapjack'
 
 require 'flapjack/notifier'
 require 'flapjack/processor'
+require 'flapjack/gateways/web'
+require 'flapjack/gateways/aws_sns'
+require 'flapjack/gateways/email'
 require 'flapjack/gateways/jsonapi'
 require 'flapjack/gateways/jabber'
 require 'flapjack/gateways/oobetet'
-require 'flapjack/gateways/pagerduty'
-require 'flapjack/gateways/email'
-require 'flapjack/gateways/sms_messagenet'
+require 'flapjack/gateways/pager_duty'
 require 'flapjack/gateways/slack'
-require 'flapjack/gateways/sms_twilio'
+require 'flapjack/gateways/sms_messagenet'
 require 'flapjack/gateways/sms_nexmo'
-require 'flapjack/gateways/aws_sns'
-require 'flapjack/gateways/web'
+require 'flapjack/gateways/sms_twilio'
+require 'flapjack/gateways/sms_aspsms'
 require 'flapjack/logger'
-require 'thin/version'
-
-module Thin
-  # disable Thin's loading of daemons
-  # workaround for https://github.com/flapjack/flapjack/issues/133
-  def self.win?
-    true
-  end
-end
 
 module Flapjack
 
   module Pikelet
 
-    # TODO find a better way of expressing these two methods
-    def self.is_pikelet?(type)
-      type_klass = [Flapjack::Pikelet::Generic,
-        Flapjack::Pikelet::Thin].detect do |kl|
-
-        kl::PIKELET_TYPES[type]
-
-      end
-      !type_klass.nil?
-    end
+    class Base
+      attr_accessor :siblings, :pikelet, :redis
 
-    def self.create(type, opts = {})
-      pikelet = nil
-      [Flapjack::Pikelet::Generic,
-       Flapjack::Pikelet::Thin].each do |kl|
-        next unless kl::PIKELET_TYPES[type]
-        break if pikelet = kl.create(type, opts)
-      end
-      pikelet
-    end
+      def initialize(pikelet_class, shutdown, opts = {})
+        @pikelet_class = pikelet_class
 
-    class Base
-      attr_reader :type, :status
+        @config        = opts[:config]
+        @boot_time     = opts[:boot_time]
+        @logger_name   = opts[:logger_name]
+        @shutdown      = shutdown
 
-      def initialize(type, pikelet_class, opts = {})
-        @type = type
-        @klass = pikelet_class
+        @siblings      = []
 
-        @config = opts[:config] || {}
-        @redis_config = opts[:redis_config] || {}
-        @boot_time = opts[:boot_time]
-        @coordinator = opts[:coordinator]
+        @lock = Monitor.new
+        @stop_condition = @lock.new_cond
 
-        @logger = Flapjack::Logger.new("flapjack-#{type}", @config['logger'])
+        @pikelet = @pikelet_class.new(:lock => @lock,
+          :stop_condition => @stop_condition, :config => @config,
+          :boot_time => @boot_time)
 
-        @status = 'initialized'
+        @finished_condition = @lock.new_cond
       end
 
-      def start
-        @status = 'started'
+      def start(&block)
+        @pikelet.siblings = @siblings.map(&:pikelet) if @pikelet.respond_to?(:siblings=)
+
+        @thread = Thread.new do
+
+          Flapjack.configure_log(@logger_name, @config['logger'])
+
+          # TODO rename this, it's only relevant in the error case
+          max_runs = @config['max_runs'] || 1
+          runs = 0
+
+          keep_running = false
+          shutdown_all = false
+
+          loop do
+            begin
+              Flapjack.logger.debug "pikelet start for #{@pikelet_class.name}"
+              yield
+            rescue Flapjack::PikeletStop
+              Flapjack.logger.debug "pikelet exception stop for #{@pikelet_class.name}"
+            rescue Flapjack::GlobalStop
+              Flapjack.logger.debug "global exception stop for #{@pikelet_class.name}"
+              @shutdown_thread = @thread
+              shutdown_all = true
+            rescue Exception => e
+              Flapjack.logger.warn "#{e.class.name} #{e.message}"
+              trace = e.backtrace
+              Flapjack.logger.warn trace.join("\n") if trace
+              runs += 1
+              keep_running = (max_runs > 0) && (runs < max_runs)
+              shutdown_all = !keep_running
+            end
+
+            break unless keep_running
+          end
+
+          @lock.synchronize do
+            @finished = true
+            @finished_condition.signal
+          end
+
+          if shutdown_all
+            @shutdown.call
+          end
+        end
       end
 
-      def reload(cfg)
-        @logger.configure(cfg['logger'])
-        true
+      def reload(cfg, &block)
+        Flapjack.logger.configure(cfg['logger'])
+        yield
       end
 
-      def stop
-        @status = 'stopping'
-      end
+      def stop(&block)
+        fin = nil
+        @lock.synchronize do
+          fin = @finished
+        end
+        return if fin
+        if block_given?
+          yield
+        else
+          case @pikelet.stop_type
+          when :exception
+            @lock.synchronize do
+              Flapjack.logger.debug "triggering pikelet exception stop for #{@pikelet_class.name}"
+              @thread.raise Flapjack::PikeletStop
+              @finished_condition.wait_until { @finished }
+            end
+          when :signal
+            @lock.synchronize do
+              Flapjack.logger.debug "triggering pikelet signal stop for #{@pikelet_class.name}"
+              @pikelet.instance_variable_set('@should_quit', true)
+              @stop_condition.signal
+              @finished_condition.wait_until { @finished }
+            end
+          end
+        end
 
+        @thread.join
+        @thread = nil
+      end
     end
 
     class Generic < Flapjack::Pikelet::Base
 
-     PIKELET_TYPES = {'notifier'   => Flapjack::Notifier,
-                      'processor'  => Flapjack::Processor,
-                      'jabber'     => Flapjack::Gateways::Jabber,
-                      'pagerduty'  => Flapjack::Gateways::Pagerduty,
-                      'oobetet'    => Flapjack::Gateways::Oobetet,
-                      'email'      => Flapjack::Gateways::Email,
-                      'sms'        => Flapjack::Gateways::SmsMessagenet,
-                      'slack'      => Flapjack::Gateways::Slack,
-                      'sms_twilio' => Flapjack::Gateways::SmsTwilio,
-                      'sms_nexmo'  => Flapjack::Gateways::SmsNexmo,
-                      'sns'        => Flapjack::Gateways::AwsSns}
-
-      def self.create(type, opts = {})
-        self.new(type, PIKELET_TYPES[type], :config => opts[:config],
-          :redis_config => opts[:redis_config],
-          :boot_time => opts[:boot_time],
-          :coordinator => opts[:coordinator])
-      end
-
-      def initialize(type, pikelet_klass, opts = {})
-        super(type, pikelet_klass, opts)
-
-        @pikelet = @klass.new(opts.merge(:logger => @logger))
-      end
+     TYPES = ['notifier', 'processor', 'jabber', 'pagerduty', 'oobetet',
+              'email', 'sms', 'aws_sns', 'sms_twilio', 'sms_aspsms']
 
       def start
-        @fiber = Fiber.new {
+        super do
           @pikelet.start
-        }
-        super
-        @fiber.resume
+        end
       end
 
       # this should only reload if all changes can be applied -- will
       # return false to log warning otherwise
       def reload(cfg)
-        @pikelet.respond_to?(:reload) ?
-          (@pikelet.reload(cfg) && super(cfg)) : super(cfg)
-      end
-
-      def stop
-        @pikelet.stop
-        super
+        return false unless @pikelet.respond_to?(:reload)
+        super(cfg) { @pikelet.reload(cfg) }
       end
-
-      def update_status
-        return @status unless 'stopping'.eql?(@status)
-        @status = 'stopped' if @fiber && !@fiber.alive?
-      end
-
     end
 
-    class Thin < Flapjack::Pikelet::Base
-
-      PIKELET_TYPES = {'web'     => Flapjack::Gateways::Web,
-                       'jsonapi' => Flapjack::Gateways::JSONAPI}
+    class HTTP < Flapjack::Pikelet::Base
 
-      def self.create(type, opts = {})
-        ::Thin::Logging.silent = true
-        self.new(type, PIKELET_TYPES[type], :config => opts[:config],
-          :redis_config => opts[:redis_config],
-          :boot_time => opts[:boot_time])
-      end
-
-      def initialize(type, pikelet_klass, opts = {})
-        super(type, pikelet_klass, opts)
+      TYPES = ['jsonapi', 'web']
 
-        pikelet_klass.instance_variable_set('@config', @config)
-        pikelet_klass.instance_variable_set('@redis_config', @redis_config)
-        pikelet_klass.instance_variable_set('@logger', @logger)
+      def start
+        @pikelet_class.instance_variable_set('@config', @config)
 
         if @config
-          @bind_address = @config['bind_address']
-          @port = @config['port']
-          @port = @port.nil? ? nil : @port.to_i
-          @timeout = @config['timeout']
-          @timeout = @timeout.nil? ? 300 : @timeout.to_i
+          bind_address = @config['bind_address']
+          port = @config['port']
+          port = port.nil? ? nil : port.to_i
+          timeout = @config['timeout']
+          timeout = timeout.nil? ? 300 : timeout.to_i
+        end
+        bind_address = '127.0.0.1' if bind_address.nil?
+        port = 3001 if (port.nil? || port <= 0 || port > 65535)
+
+        super do
+          @pikelet_class.start if @pikelet_class.respond_to?(:start)
+          @server = ::Puma::Server.new(@pikelet_class)
+          @server.binder.add_tcp_listener(bind_address, port)
+          yield @server if block_given?
+          @server.run(false) # no background run, use current thread
         end
-        @bind_address = '0.0.0.0' if @bind_address.nil?
-        @port = 3001 if (@port.nil? || @port <= 0 || @port > 65535)
-
-        @server = ::Thin::Server.new(@bind_address, @port,
-                    @klass, :signals => false)
-        @server.timeout = @timeout
-      end
-
-      def start
-        super
-        @klass.start if @klass.respond_to?(:start)
-        @server.start
       end
 
       # this should only reload if all changes can be applied -- will
       # return false to log warning otherwise
       def reload(cfg)
-        # TODO fail if port changes
-        @klass.respond_to?(:reload) ?
-          (@klass.reload(cfg) && super(cfg)) : super(cfg)
+         # TODO handle bind_address/port changes by changing listeners?
+        return false unless @pikelet_class.respond_to?(:reload)
+        super(cfg) { @pikelet_class.reload(cfg) }
       end
 
       def stop
-        @server.stop!
-        @klass.stop if @klass.respond_to?(:stop)
-        super
+        super do |thread|
+          unless @server.nil?
+            Flapjack.logger.info "shutting down server"
+            @server.stop(true)  # no background stop, wait for requests to finish
+            Flapjack.logger.info "shut down server"
+          end
+          @pikelet_class.stop(thread) if @pikelet_class.respond_to?(:stop)
+        end
       end
+    end
 
-      def update_status
-        return @status unless 'stopping'.eql?(@status)
-        @status = 'stopped' if (@server.backend.size <= 0)
-      end
+    WRAPPERS = [Flapjack::Pikelet::Generic, Flapjack::Pikelet::HTTP]
+
+    TYPES = {'jsonapi'    => [Flapjack::Gateways::JSONAPI],
+             'email'      => [Flapjack::Gateways::Email],
+             'notifier'   => [Flapjack::Notifier],
+             'processor'  => [Flapjack::Processor],
+             'jabber'     => [Flapjack::Gateways::Jabber::Bot,
+                              Flapjack::Gateways::Jabber::Notifier,
+                              Flapjack::Gateways::Jabber::Interpreter],
+             'oobetet'    => [Flapjack::Gateways::Oobetet::Bot,
+                              Flapjack::Gateways::Oobetet::Notifier],
+             'pagerduty'  => [Flapjack::Gateways::PagerDuty::Notifier,
+                              Flapjack::Gateways::PagerDuty::AckFinder],
+             'slack'      => [Flapjack::Gateways::Slack],
+             'sms'        => [Flapjack::Gateways::SmsMessagenet],
+             'sms_nexmo'  => [Flapjack::Gateways::SmsNexmo],
+             'sms_twilio' => [Flapjack::Gateways::SmsTwilio],
+             'sms_aspsms' => [Flapjack::Gateways::SmsAspsms],
+             'aws_sns'    => [Flapjack::Gateways::AwsSns],
+             'web'    => [Flapjack::Gateways::Web],
+            }
+
+    def self.is_pikelet?(type)
+      TYPES.has_key?(type)
+    end
+
+    def self.create(type, shutdown, opts = {})
+      config = opts[:config] || {}
+
+      types = TYPES[type]
+
+      return [] if types.nil?
+
+      created = types.collect {|pikelet_class|
+        wrapper = WRAPPERS.detect {|wrap| wrap::TYPES.include?(type) }
+        logger_name = if TYPES[type].size == 1
+          "flapjack-#{type}"
+        else
+          "flapjack-#{type}-#{pikelet_class.name.demodulize.underscore}"
+        end
+        wrapper.new(pikelet_class, shutdown, :logger_name => logger_name,
+          :config => config, :boot_time => opts[:boot_time])
+      }
+      created.each {|c| c.siblings = created - [c] }
+      created
     end
 
   end