flapjack 1.6.0 → 2.0.0b1

data/lib/flapjack/cli/flapper.rb

@@ -1,29 +1,11 @@
 #!/usr/bin/env ruby
 
-require 'eventmachine'
 require 'socket'
-require 'dante'
 
 module Flapjack
   module CLI
     class Flapper
 
-      def self.local_ip
-        # turn off reverse DNS resolution temporarily
-        orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
-
-        begin
-          UDPSocket.open do |s|
-            s.connect '64.233.187.99', 1
-            s.addr.last
-          end
-        rescue Errno::ENETUNREACH => e
-          '127.0.0.1'
-        end
-      ensure
-        Socket.do_not_reverse_lookup = orig
-      end
-
       def initialize(global_options, options)
         @global_options = global_options
         @options = options
@@ -38,79 +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'], 'flapper.pid')
-        else
-          "/var/run/flapjack/flapper.pid"
-        end
-
-        @logfile = case
-        when !@options[:logfile].nil?
-          @options[:logfile]
-        when !@config_env['log_dir'].nil?
-          File.join(@config_env['log_dir'], 'flapper.log')
-        else
-          "/var/run/flapjack/flapper.log"
+          exit_now! "No config data found in '#{global_options[:config]}'"
         end
       end
 
       def start
-        if runner.daemon_running?
-          puts "flapper is already running."
-        else
-          print "flapper starting..."
-          main_umask = nil
-          if @options[:daemonize]
-            main_umask = File.umask
-          else
-            print "\n"
-          end
-          runner.execute(:daemonize => @options[:daemonize]) do
-            File.umask(main_umask) if @options[:daemonize]
-            main(@options['bind-ip'] || Flapjack::CLI::Flapper.local_ip, @options['bind-port'].to_i, @options[:frequency])
-          end
-          puts " done."
-        end
-      end
-
-      def stop
-        pid = get_pid
-        if runner.daemon_running?
-          print "flapper stopping..."
-          runner.execute(:kill => true)
-          puts " done."
-        else
-          puts "flapper is not running."
-        end
-        exit_now! unless wait_pid_gone(pid)
-      end
-
-      def restart
-        print "flapper restarting..."
-        main_umask = File.umask
-        runner.execute(:daemonize => true, :restart => true) do
-          File.umask(main_umask)
-          main(@options['bind-ip'], @options['bind-port'].to_i, @options[:frequency])
-        end
+        puts "flapper starting..."
+        main(@options['bind-ip'] || Flapjack::CLI::Flapper.local_ip, @options['bind-port'].to_i, @options[:frequency])
         puts " done."
       end
 
-      def status
-        if runner.daemon_running?
-          pid = get_pid
-          uptime = Time.now - File.stat(@pidfile).ctime
-          puts "flapper is running: pid #{pid}, uptime #{uptime}"
-        else
-          exit_now! "flapper is not running"
-        end
-      end
-
       private
 
       module Receiver
@@ -120,36 +39,77 @@ module Flapjack
         end
       end
 
-      def runner
-        return @runner if @runner
+      def self.local_ip
+        # turn off reverse DNS resolution temporarily
+        orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
 
-        @runner = Dante::Runner.new('flapper', :pid_path => @pidfile,
-          :log_path => @logfile)
-        @runner
+        begin
+          UDPSocket.open do |s|
+            s.connect '64.233.187.99', 1
+            s.addr.last
+          end
+        rescue Errno::ENETUNREACH => e
+          '127.0.0.1'
+        end
+      ensure
+        Socket.do_not_reverse_lookup = orig
       end
 
       def main(bind_ip, bind_port, frequency)
-        raise "bind_port must be an integer" unless bind_port.is_a?(Integer) && (bind_port > 0)
+        raise "bind_port must be an integer" unless bind_port.is_a?(Integer)
         start_every = frequency
-        stop_after  = frequency.to_f / 2
-
-        EM.run do
+        stop_after = frequency.to_f / 2
 
-          puts "#{Time.now}: starting server on #{bind_ip}:#{bind_port}"
-          server_init = EM.start_server bind_ip, bind_port, Flapjack::CLI::Flapper::Receiver
-          EM.add_timer(stop_after) do
-            puts "#{Time.now}: stopping server"
-            EM.stop_server(server_init)
-          end
-
-          EM.add_periodic_timer(start_every) do
-            puts "#{Time.now}: starting server on #{bind_ip}:#{bind_port}"
-            server = EM.start_server bind_ip, bind_port, Flapjack::CLI::Flapper::Receiver
-            EM.add_timer(stop_after) do
+        begin
+          loop do
+            begin
+              fds = []
+              Timeout::timeout(stop_after) do
+                puts "#{Time.now}: starting server"
+
+                acceptor = TCPServer.open(bind_ip, bind_port)
+                fds = [acceptor]
+
+                while true
+                  if ios = select(fds, [], [], 10)
+                    reads = ios.first
+                    reads.each do |client|
+                      if client == acceptor
+                        puts 'Someone connected to server. Adding socket to fds.'
+                        client, sockaddr = acceptor.accept
+                        fds << client
+                      elsif client.eof?
+                        puts "Client disconnected"
+                        fds.delete(client)
+                        client.close
+                      else
+                        # Perform a blocking-read until new-line is encountered.
+                        # We know the client is writing, so as long as it adheres to the
+                        # new-line protocol, we shouldn't block for very long.
+                        data = client.gets("\n")
+                        if data =~ /quit/i
+                          fds.delete(client)
+                          client.close
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            rescue Timeout::Error
               puts "#{Time.now}: stopping server"
-              EM.stop_server(server)
+            ensure
+              # should trigger even for an Interrupt
+              puts "Cleaning up"
+              fds.each {|c| c.close}
             end
+
+            sleep_for = start_every - stop_after
+            puts "sleeping for #{sleep_for}"
+            sleep(sleep_for)
           end
+        rescue Interrupt
+          puts "interrupted"
         end
       end
 
@@ -182,83 +142,24 @@ module Flapjack
         pid = nil
       end
 
-
     end
   end
 end
 
-
-desc 'Artificial service that oscillates up and down, for use in http://flapjack.io/docs/1.0/usage/oobetet'
+desc 'Artificial service that oscillates up and down, for use in http://flapjack.io/docs/2.0/usage/oobetet'
 command :flapper do |flapper|
 
-  flapper.desc 'start flapper'
-  flapper.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   [:b, 'bind-ip'],   :desc => 'Override ADDRESS (IPv4 or IPv6) for flapper to bind to'
-
-    start.flag   [:P, 'bind-port'], :desc => 'PORT for flapper to bind to (default: 12345)',
-      :default_value => '12345'
-
-    start.flag   [:f, 'frequency'], :desc => 'oscillate with a frequency of SECONDS [120]',
-      :default_value => '120.0'
+  flapper.flag   [:b, 'bind-ip'],   :desc => 'Override ADDRESS (IPv4 or IPv6) for flapper to bind to'
 
-    start.action do |global_options, options, args|
-      cli_flapper = Flapjack::CLI::Flapper.new(global_options, options)
-      cli_flapper.start
-    end
-  end
-
-  flapper.desc 'stop flapper'
-  flapper.command :stop do |stop|
+  flapper.flag   [:P, 'bind-port'], :desc => 'PORT for flapper to bind to (default: 12345)',
+    :default_value => '12345'
 
-    stop.flag   [:p, 'pidfile'],   :desc => 'PATH of the pidfile to write to'
+  flapper.flag   [:f, 'frequency'], :desc => 'oscillate with a frequency of SECONDS [120]',
+    :default_value => '120.0'
 
-    stop.flag   [:l, 'logfile'],   :desc => 'PATH of the logfile to write to'
-
-    stop.action do |global_options, options, args|
-      cli_flapper = Flapjack::CLI::Flapper.new(global_options, options)
-      cli_flapper.stop
-    end
+  flapper.action do |global_options, options, args|
+    cli_flapper = Flapjack::CLI::Flapper.new(global_options, options)
+    cli_flapper.start
   end
 
-  flapper.desc 'restart flapper'
-  flapper.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   [:b, 'bind-ip'],   :desc => 'Override ADDRESS (IPv4 or IPv6) for flapper to bind to'
-
-    restart.flag   [:P, 'bind-port'], :desc => 'PORT for flapper to bind to (default: 12345)',
-      :default_value => 12345
-
-    restart.flag   [:f, 'frequency'], :desc => 'oscillate with a frequency of SECONDS [120]',
-      :default_value => 120.0
-
-    restart.action do |global_options, options, args|
-      cli_flapper = Flapjack::CLI::Flapper.new(global_options, options)
-      cli_flapper.restart
-    end
-  end
-
-  flapper.desc 'flapper status'
-  flapper.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|
-      cli_flapper = Flapjack::CLI::Flapper.new(global_options, options)
-      cli_flapper.status
-    end
-  end
 end

data/lib/flapjack/cli/maintenance.rb

@@ -1,12 +1,10 @@
 #!/usr/bin/env ruby
 
 require 'redis'
-require 'hiredis'
 
 require 'flapjack/configuration'
 require 'flapjack/data/event'
-require 'flapjack/data/entity_check'
-require 'flapjack/data/migration'
+require 'flapjack/data/check'
 require 'terminal-table'
 
 module Flapjack
@@ -27,92 +25,310 @@ 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
-        @options[:redis] = redis
+        Flapjack::RedisProxy.config = config.for_redis
+        Zermelo.redis = Flapjack.redis
       end
 
-      def show
-        exit_now!("state must be one of 'ok', 'warning', 'critical', 'unknown'") unless @options[:state].nil? || %w(ok warning critical unknown).include?(@options[:state].downcase)
-        exit_now!("type must be one of 'scheduled', 'unscheduled'") unless %w(scheduled unscheduled).include?(@options[:type].downcase)
-        %w(started finishing).each do |time|
-          exit_now!("#{time.capitalize} time must start with 'more than', 'less than', 'on', 'before', 'after' or between") if @options[time] && !@options[time].downcase.start_with?('more than', 'less than', 'on', 'before', 'after', 'between')
+      def show(base_time = Time.now)
+        state = @options[:state]
+
+        checks = if @options[:check]
+          Flapjack::Data::Check.intersect(:name => Regexp.new(@options[:check])).all
+        else
+          Flapjack::Data::Check.all
+        end
+
+        start_time_begin, start_time_end = self.class.extract_time_range(
+          @options[:started], base_time)
+
+        start_time_begin = start_time_begin.to_i unless start_time_begin.nil?
+        start_time_end = start_time_end.to_i unless start_time_end.nil?
+
+        finish_time_begin, finish_time_end = self.class.extract_time_range(
+          @options[:finishing], base_time)
+
+        finish_time_begin = finish_time_begin.to_i unless finish_time_begin.nil?
+        finish_time_end = finish_time_end.to_i unless finish_time_end.nil?
+
+        duration_range = @options[:duration] ? self.class.extract_duration_range(
+          @options[:duration]) : nil
+
+        start_time_range = Zermelo::Filters::IndexRange.new(start_time_begin,
+          start_time_end, :by_score => true)
+        finish_time_range = Zermelo::Filters::IndexRange.new(finish_time_begin,
+          finish_time_end, :by_score => true)
+
+        maintenances = case @options[:type].downcase
+        when 'scheduled'
+          checks.inject([]) do |memo, check|
+
+            maints = check.scheduled_maintenances.
+              intersect(:start_time => start_time_range, :end_time => finish_time_range).all
+
+            if !maints.empty?
+              filtered = duration_range.nil? ? maints :
+                self.class.filter_duration(maints, duration_range)
+              memo += filtered
+            end
+
+            memo
+          end
+        when 'unscheduled'
+          checks.inject([]) do |memo, check|
+
+            maints = check.unscheduled_maintenances.
+              intersect(:start_time => start_time_range, :end_time => finish_time_range).all
+
+            if !maints.empty?
+              filtered = duration_range.nil? ? maints :
+                self.class.filter_duration(maints, duration_range)
+              memo += filtered
+            end
+
+            memo
+          end
         end
-        @options[:finishing] ||= 'after now'
-        maintenances = Flapjack::Data::EntityCheck.find_maintenance(@options)
-        rows = []
-        maintenances.each do |m|
-          row = []
-          # Convert the unix timestamps of the start and end time back into readable times
-          m.each { |k, v| row.push(k.to_s.end_with?('time') ? Time.at(v) : v) }
-          rows.push(row)
+
+        rows = maintenances.collect do |maint|
+          [maint.check.name,
+           Time.at(maint.start_time), maint.end_time - maint.start_time,
+           maint.summary, Time.at(maint.end_time)]
         end
-        puts Terminal::Table.new :headings => ['Entity', 'Check', 'State', 'Start', 'Duration (s)', 'Reason', 'End'], :rows => rows
+        puts Terminal::Table.new :headings => ['Check',
+          'Start', 'Duration (s)', 'Reason', 'End'], :rows => rows
+        puts "Found #{rows.count} maintenances"
         maintenances
       end
 
       def delete
-        maintenances = show
-        exit_now!('The following maintenances would be deleted.  Run this command again with --apply true to remove them.') unless @options[:apply]
-        errors = Flapjack::Data::EntityCheck.delete_maintenance(@options)
-        (errors.each { |k, v| puts "#{k}: #{v}" }; exit_now!('Failed to delete maintenances')) if errors.length > 0
-        puts "The maintenances above have been deleted"
+        base_time = Time.now
+
+        maintenances = show(base_time)
+
+        unless @options[:apply]
+          exit_now!('The following maintenances would be deleted. Run this ' +
+            'command again with --apply true to remove them.')
+        end
+
+        errors = {}
+        maintenances.each do |maint|
+          check = maint.check
+          identifier = "#{check.name}:#{check.start}"
+          if maint.end_time < base_time
+            errors[identifier] = "Maintenance can't be deleted as it finished in the past"
+          else
+            success = case @options[:type]
+            when 'scheduled'
+              check.end_scheduled_maintenance(maint, base_time)
+            when 'unscheduled'
+              check.clear_unscheduled_maintenance(base_time)
+            end
+            errors[identifier] = "The following maintenance failed to delete: #{entry}" unless success
+          end
+        end
+
+        if errors.empty?
+          puts "The maintenances above have been deleted"
+        else
+          puts(errors.map {|k, v| "#{k}: #{v}" }.join("\n"))
+          exit_now!('Failed to delete maintenances')
+        end
       end
 
       def create
-        errors = Flapjack::Data::EntityCheck.create_maintenance(@options)
-        (errors.each { |k, v| puts "#{k}: #{v}" }; exit_now!('Failed to create maintenances')) if errors.length > 0
-        puts "The maintenances specified have been created"
+        errors = {}
+
+        check_names  = @options[:check].is_a?(String) ? @options[:check].split(',') : @options[:check]
+
+        started = Chronic.parse(@options[:started])
+        raise "Failed to parse start time #{@options[:started]}" if started.nil?
+
+        duration = ChronicDuration.parse(@options[:duration])
+        raise "Failed to parse duration #{@options[:duration]}" if duration.nil?
+
+        check_names.each do |check_name|
+          check = Flapjack::Data::Check.intersect(:name => check_names).all.first
+
+          if check.nil?
+            # Create the check if it doesn't exist, so we can schedule maintenance against it
+            check = Flapjack::Data::Check.new(:name => check_name)
+            check.save
+          end
+
+          success = case @options[:type]
+          when 'scheduled'
+
+            sched_maint = Flapjack::Data::ScheduledMaintenance.new(:start_time => started,
+              :end_time => started + duration, :summary => @options[:reason])
+            sched_maint.save
+
+            check.scheduled_maintenances << sched_maint
+          when 'unscheduled'
+            unsched_maint = Flapjack::Data::UnscheduledMaintenance.new(:start_time => started,
+              :end_time => started + duration, :summary => @options[:reason])
+            unsched_maint.save
+
+            check.set_unscheduled_maintenance(unsched_maint)
+          end
+          identifier = "#{check_name}:#{started}"
+          errors[identifier] = "The following check failed to create: #{identifier}" unless success
+        end
+
+        if errors.empty?
+          puts "The maintenances specified have been created"
+        else
+          puts(errors.map {|k, v| "#{k}: #{v}" }.join("\n"))
+          exit_now!('Failed to create maintenances')
+        end
       end
 
       private
 
-      def redis
-        return @redis unless @redis.nil?
-        @redis = Redis.new(@redis_options.merge(:driver => :hiredis))
-        Flapjack::Data::Migration.migrate_entity_check_data_if_required(:redis => @redis)
-        Flapjack::Data::Migration.clear_orphaned_entity_ids(:redis => @redis)
-        Flapjack::Data::Migration.validate_scheduled_maintenance_periods(:redis => @redis)
-        @redis
+      def self.filter_duration(maints, duration_range)
+        maints.select do |maint|
+          dur = maint.duration
+          lower = duration_range.first
+          upper = duration_range.last
+
+          (lower.nil? && upper.nil?) || ((lower.nil? || (dur >= lower)) &&
+                                         (upper.nil? || (dur <  upper)))
+        end
+      end
+
+      def self.extract_duration_range(duration_in_words)
+        return nil if duration_in_words.nil?
+
+        dur_words = duration_in_words.downcase
+
+        case dur_words
+        when /^(?:equal to|less than|more than)/
+          cdur_words = dur_words.gsub(/^(equal to|less than|more than) /, '')
+          parsed_dur = ChronicDuration.parse(cdur_words)
+          case dur_words
+          when /^equal to/
+            [parsed_dur, parsed_dur + 1]
+          when /^less than/
+            [nil, parsed_dur]
+          when /^more than/
+            [parsed_dur, nil]
+          end
+        when /^between/
+          first, second = dur_words.match(/between (.*) and (.*)/).captures
+
+          # If the first time only contains only a single word, the unit (and past/future) is
+          # most likely directly after the first word of the the second time
+          # eg between 3 and 4 hours
+          suffix = second.match(/\w (.*)/) ? second.match(/\w (.*)/).captures.first : ''
+          first = "#{first} #{suffix}" unless / /.match(first)
+
+          [ChronicDuration.parse(first), ChronicDuration.parse(second)].sort
+        end
+      end
+
+      # returns two timestamps, the start and end of the calculated time range. if
+      # either one is nil that indicates that the range is unbounded at that end.
+      # Start is inclusive of that second, end is exclusive.
+      def self.extract_time_range(time_period_in_words, base_time)
+        return nil if time_period_in_words.nil?
+
+        time_words = time_period_in_words.downcase
+
+        # Chronic can't parse timestamps for strings starting with before, after or in some cases, on.
+        # Strip the before or after for the conversion only, but use it for the comparison later
+        ctime_words = time_words.gsub(/^(on|before|after) /, '')
+
+        case time_words
+        # Between 3 and 4 hours ago translates to more than 3 hours ago, less than 4 hours ago
+        when /^between/
+          first, second = time_words.match(/between (.*) and (.*)/).captures
+
+          # If the first time only contains only a single word, the unit (and past/future) is
+          # most likely directly after the first word of the the second time
+          # eg between 3 and 4 hours ago
+          suffix = second.match(/\w (.*)/) ? second.match(/\w (.*)/).captures.first : ''
+          first = "#{first} #{suffix}" unless / /.match(first)
+
+          [Chronic.parse(first,  :now => base_time),
+           Chronic.parse(second, :now => base_time)].sort
+        when /^on/
+          # e.g. On 1/1/15.  We use Chronic to work out the minimum and maximum timestamp.
+          parsed = Chronic.parse(ctime, :guess => false, :now => base_time)
+          [parsed.first, parsed.last]
+        when /^(less than|more than|before|after)/
+          input_time = Chronic.parse(ctime_words, :keep_zero => true, :now => base_time) ||
+            Chronic.parse("#{ctime_words} from now", :keep_zero => true, :now => base_time)
+          case time_words
+          when /^less than .+ ago$/, /^more than/, /^after/
+            [input_time, nil]
+          when /^less than/, /^more than .+ ago$/, /^before/
+            [nil, input_time]
+          end
+        end
       end
 
     end
   end
 end
 
-desc 'Show, create and delete maintenance windows'
-command :maintenance do |maintenance|
-
-
-  maintenance.desc 'Show maintenance windows according to criteria (default: all ongoing maintenance)'
-  maintenance.command :show do |show|
-
-    show.flag ['entity', :e],
-      :desc => 'The entity for the maintenance window to occur on.  This can be a string, or a ruby regex of the form \'db*\' or \'[[:lower:]]\''
+def common_arguments(cmd_type, gli_cmd)
+
+  if [:show, :delete, :create].include?(cmd_type)
+    gli_cmd.flag ['check', :c],
+      :desc => 'The check for the maintenance window to occur on. This can ' +
+        'be a string, or a Ruby regex of the form \'http*\' or \'[[:lower:]]\'',
+      :required => :create.eql?(cmd_type)
+
+    gli_cmd.flag ['reason', :r],
+      :desc => 'The reason for the maintenance window to occur. This can ' +
+        'be a string, or a Ruby regex of the form \'Downtime for *\' or ' +
+        '\'[[:lower:]]\''
+
+    gli_cmd.flag ['start', 'started', 'starting', :s],
+      :desc => 'The start time for the maintenance window. This should ' +
+               'be prefixed with "more than", "less than", "on", "before", ' +
+               'or "after", or of the form "between T1 and T2"',
+      :must_match => /^(?:more than|less than|on|before|after|between)\s+.+$/
+
+    gli_cmd.flag ['duration', :d],
+      :desc => 'The total duration of the maintenance window. This should ' +
+               'be prefixed with "more than", "less than", or "equal to", ' +
+               'or of the form "between M and N hours". This should be an ' +
+               ' interval',
+      :must_match => /^(?:more than|less than|equal to|between)\s+.+$/
+  end
 
-    show.flag ['check', :c],
-      :desc => 'The check for the maintenance window to occur on.  This can be a string, or a ruby regex of the form \'http*\' or \'[[:lower:]]\''
+  if [:show, :delete].include?(cmd_type)
+    gli_cmd.flag ['finish', 'finished', 'finishing', 'remain', 'remained', 'remaining', 'end', :f],
+      :desc => 'The finishing time for the maintenance window. This should ' +
+               'prefixed with "more than", "less than", "on", "before", or ' +
+               '"after", or of the form "between T1 and T2"' ,
+      :must_match => /^(?:more than|less than|on|before|after|between)\s+.+$/
 
-    show.flag ['reason', :r],
-      :desc => 'The reason for the maintenance window to occur.  This can be a string, or a ruby regex of the form \'Downtime for *\' or \'[[:lower:]]\''
+    gli_cmd.flag ['state', :st],
+      :desc => 'The state that the check is currently in',
+      :must_match => %w(ok warning critical unknown)
+  end
 
-    show.flag ['start', 'started', 'starting', :s],
-      :desc => 'The start time for the maintenance window, eg \'before 10am\'. This should be prefixed with \'more than\', \'less than\', \'on\', \'before\', or \'after\', or of the form \'between times and time\''
+  if [:show, :delete, :create].include?(cmd_type)
+    gli_cmd.flag ['type', :t],
+      :desc          => 'The type of maintenance scheduled',
+      :required      => true,
+      :default_value => 'scheduled',
+      :must_match    => %w(scheduled unscheduled)
+  end
 
-    show.flag ['duration', :d],
-      :desc => 'The total duration of the maintenance window, eg \'equal to 5 hours\'. This should be prefixed with \'more than\', \'less than\', \'before, \'after\' or \'equal to\', or or of the form \'between 3 and 4 hours\'.  This should be an interval'
+end
 
-    show.flag ['finish', 'finished', 'finishing', 'remain', 'remained', 'remaining', 'end', :f],
-      :desc => 'The finishing time for the maintenance window, eg \'more than 1 year from now\'. This should be prefixed with \'more than\', \'less than\', \'on\', \'before\', or \'after\', or of the form \'between time and time\''
+desc 'Show, create and delete maintenance windows'
+command :maintenance do |maintenance|
 
-    show.flag ['state', :st],
-      :desc => 'The state that the check is currently in'
+  maintenance.desc 'Show maintenance windows according to criteria (default: all ongoing maintenance)'
+  maintenance.command :show do |show|
 
-    show.flag ['type', :t],
-      :desc => 'The type of maintenance scheduled',
-      :default_value => 'scheduled'
+    common_arguments(:show, show)
 
     show.action do |global_options,options,args|
       maintenance = Flapjack::CLI::Maintenance.new(global_options, options)
@@ -123,34 +339,11 @@ command :maintenance do |maintenance|
   maintenance.desc 'Delete maintenance windows according to criteria (default: all ongoing maintenance)'
   maintenance.command :delete do |delete|
 
-    delete.flag ['apply', :a],
+    delete.flag [:a, 'apply'],
       :desc => 'Whether this deletion should occur',
       :default_value => false
 
-    delete.flag ['entity', :e],
-      :desc => 'The entity for the maintenance window to occur on.  This can be a string, or a ruby regex of the form \'db*\' or \'[[:lower:]]\''
-
-    delete.flag ['check', :c],
-      :desc => 'The check for the maintenance window to occur on.  This can be a string, or a ruby regex of the form \'http*\' or \'[[:lower:]]\''
-
-    delete.flag ['reason', :r],
-      :desc => 'The reason for the maintenance window to occur.  This can be a string, or a ruby regex of the form \'Downtime for *\' or \'[[:lower:]]\''
-
-    delete.flag ['start', 'started', 'starting', :s],
-      :desc => 'The start time for the maintenance window, eg \'before 10am\'. This should be prefixed with \'more than\', \'less than\', \'on\', \'before\', or \'after\', or of the form \'between times and time\''
-
-    delete.flag ['duration', :d],
-      :desc => 'The total duration of the maintenance window, eg \'equal to 5 hours\'. This should be prefixed with \'more than\', \'less than\', \'before, \'after\' or \'equal to\', or or of the form \'between 3 and 4 hours\'.  This should be an interval'
-
-    delete.flag ['finish', 'finished', 'finishing', 'remain', 'remained', 'remaining', 'end', :f],
-      :desc => 'The finishing time for the maintenance window, eg \'more than 1 year from now\'. This should be prefixed with \'more than\', \'less than\', \'on\', \'before\', or \'after\', or of the form \'between time and time\''
-
-    delete.flag ['state', :st],
-      :desc => 'The state that the check is currently in'
-
-    delete.flag ['type', :t],
-      :desc => 'The type of maintenance scheduled',
-      :default_value => 'scheduled'
+    common_arguments(:delete, delete)
 
     delete.action do |global_options,options,args|
       maintenance = Flapjack::CLI::Maintenance.new(global_options, options)
@@ -161,31 +354,7 @@ command :maintenance do |maintenance|
   maintenance.desc 'Create a maintenance window'
   maintenance.command :create do |create|
 
-    create.flag ['entity', :e],
-      :desc => 'The entity for the maintenance window to occur on.  This can be a comma separated list',
-      :type => Array,
-      :required => true
-
-    create.flag ['check', :c],
-      :desc => 'The check for the maintenance window to occur on.  This can be a comma separated list',
-      :type => Array,
-      :required => true
-
-    create.flag ['reason', :r],
-      :desc => 'The reason for the maintenance window to occur',
-      :required => true
-
-    create.flag ['start', 'started', 'starting', :s],
-      :desc => 'The start time for the maintenance window, eg \'now\' or \'in 3 hours\'',
-      :required => true
-
-    create.flag ['duration', :d],
-      :desc => 'The total duration of the maintenance window, eg \'30 minutes\'.  This should be an interval',
-      :required => true
-
-    create.flag ['type', :t],
-      :desc => 'The type of maintenance scheduled (\'scheduled\')',
-      :default_value => 'scheduled'
+    common_arguments(:create, create)
 
     create.action do |global_options,options,args|
       maintenance = Flapjack::CLI::Maintenance.new(global_options, options)