flapjack 0.7.17 → 0.7.18

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 ## Flapjack Changelog
 
+# 0.7.18 - 2013-07-05
+- Feature: delete currently active scheduled maintenance via api should truncate from Time.now gh-242 (@ali-graham)
+
 # 0.7.17 - 2013-07-04
 - Feature: split API methods into two separate files, also specs gh-215 (@ali-graham)
 - Feature: unlock ruby version, build with Ruby 2 in travis gh-237 (@ali-graham)

data/lib/flapjack/data/entity_check.rb

@@ -131,37 +131,39 @@ module Flapjack
         update_current_scheduled_maintenance(:revalidate => true)
       end
 
-      # change the end time of a scheduled maintenance (including when one is current)
-      # TODO allow to update summary as well
-      def update_scheduled_maintenance(start_time, patches = {})
-
-        # check if there is such a scheduled maintenance period
-        old_duration = @redis.zscore("#{@key}:scheduled_maintenances", start_time)
-        raise ArgumentError, 'no such scheduled maintenance period can be found' unless old_duration
-        raise ArgumentError, 'no handled patches have been supplied' unless patches[:end_time]
-
-        if patches[:end_time]
-          end_time = patches[:end_time]
-          raise ArgumentError, "end time must be after start time" unless end_time > start_time
-          old_end_time = start_time + old_duration
-          duration = end_time - start_time
-          @redis.zadd("#{@key}:scheduled_maintenances", duration, start_time)
-        end
+      # TODO allow summary to be changed as part of the termination
+      def end_scheduled_maintenance(start_time)
+        raise ArgumentError, 'start time must be supplied as a Unix timestamp' unless start_time && start_time.is_a?(Integer)
 
-        # scheduled maintenance periods have changed, revalidate
-        update_current_scheduled_maintenance(:revalidate => true)
-      end
+        # don't do anything if a scheduled maintenance period with that start time isn't stored
+        duration = @redis.zscore("#{@key}:scheduled_maintenances", start_time)
+        return false if duration.nil?
 
-      # delete a scheduled maintenance
-      def delete_scheduled_maintenance(opts = {})
-        start_time = opts[:start_time]
-        @redis.del("#{@key}:#{start_time}:scheduled_maintenance:summary")
-        @redis.zrem("#{@key}:scheduled_maintenances", start_time)
+        current_time = Time.now.to_i
 
-        @redis.zremrangebyscore("#{@key}:sorted_scheduled_maintenance_timestamps", start_time, start_time)
+        if start_time > current_time
+          # the scheduled maintenance period (if it exists) is in the future
+          @redis.del("#{@key}:#{start_time}:scheduled_maintenance:summary")
+          @redis.zrem("#{@key}:scheduled_maintenances", start_time)
 
-        # scheduled maintenance periods have changed, revalidate
-        update_current_scheduled_maintenance(:revalidate => true)
+          @redis.zremrangebyscore("#{@key}:sorted_scheduled_maintenance_timestamps", start_time, start_time)
+
+          # scheduled maintenance periods (may) have changed, revalidate
+          update_current_scheduled_maintenance(:revalidate => true)
+
+          return true
+        elsif (start_time + duration) > current_time
+          # it spans the current time, so we'll stop it at that point
+          new_duration = current_time - start_time
+          @redis.zadd("#{@key}:scheduled_maintenances", new_duration, start_time)
+
+          # scheduled maintenance periods have changed, revalidate
+          update_current_scheduled_maintenance(:revalidate => true)
+
+          return true
+        end
+          
+        false
       end
 
       # if not in scheduled maintenance, looks in scheduled maintenance list for a check to see if
@@ -174,9 +176,9 @@ module Flapjack
         end
 
         # are we within a scheduled maintenance period?
-        t = Time.now.to_i
+        current_time = Time.now.to_i
         current_sched_ms = maintenances(nil, nil, :scheduled => true).select {|sm|
-          (sm[:start_time] <= t) && (t < sm[:end_time])
+          (sm[:start_time] <= current_time) && (current_time < sm[:end_time])
         }
         return if current_sched_ms.empty?
 

data/lib/flapjack/gateways/api/entity_methods.rb

@@ -270,8 +270,7 @@ module Flapjack
               start_time = validate_and_parsetime(params[:start_time])
               halt( err(403, "start time must be provided") ) unless start_time
               opts = {}
-              opts[:start_time] = start_time.to_i
-              proc {|entity_check| entity_check.delete_scheduled_maintenance(opts) }
+              proc {|entity_check| entity_check.end_scheduled_maintenance(start_time.to_i) }
             when 'unscheduled_maintenances'
               end_time = validate_and_parsetime(params[:end_time])
               opts = {}

data/lib/flapjack/gateways/web.rb

@@ -247,30 +247,12 @@ module Flapjack
         redirect back
       end
 
-      # modify scheduled maintenance
-      patch '/scheduled_maintenances/:entity/:check' do
-        entity_check = get_entity_check(params[:entity], params[:check])
-        return 404 if entity_check.nil?
-
-        end_time   = Chronic.parse(params[:end_time]).to_i
-        start_time = params[:start_time].to_i
-        raise ArgumentError, "start time parsed to zero" unless start_time > 0
-
-        patches = {}
-        patches[:end_time] = end_time if end_time && (end_time > start_time)
-
-        raise ArgumentError.new("no valid data received to patch with") if patches.empty?
-
-        entity_check.update_scheduled_maintenance(start_time, patches)
-        redirect back
-      end
-
       # delete a scheduled maintenance
       delete '/scheduled_maintenances/:entity/:check' do
         entity_check = get_entity_check(params[:entity], params[:check])
         return 404 if entity_check.nil?
 
-        entity_check.delete_scheduled_maintenance(:start_time => params[:start_time].to_i)
+        entity_check.end_scheduled_maintenance(params[:start_time].to_i)
         redirect back
       end
 

data/lib/flapjack/gateways/web/views/check.haml

@@ -3,6 +3,7 @@
 - head = render_haml('_head.haml', self)
 - foot = render_haml('_foot.haml', self)
 - check_path_escaped = URI.escape(@entity, ' #&;/=?') << '/' << URI.escape(@check, ' #&;/=?')
+- current_time = Time.now
 %html
   %head
     %title Flapjack - Check: #{@entity}:#{@check}
@@ -26,7 +27,6 @@
               duration:
             %input{:type => 'text', :name => 'duration', :value => ''}
               e.g. "5 hours"
-        - current_time = (@current_unscheduled_maintenance || @current_scheduled_maintenance) ? Time.now : nil
         - if @current_unscheduled_maintenance
           %h3 (Acknowledged - #{@current_unscheduled_maintenance[:summary]})
           - start  = Time.at(@current_unscheduled_maintenance[:start_time])
@@ -125,18 +125,12 @@
                 %td= ChronicDuration.output(duration)
                 %td= summary
                 %td
-                  - if end_time > Time.now.to_i
-                    - if start_time > Time.now.to_i
-                      %form{ :action => "/scheduled_maintenances/#{check_path_escaped}", :method => "post"}
-                        %input{:type => 'hidden', :name => '_method', :value => 'delete'}
-                        %input{:type => 'hidden', :name => 'start_time', :value => start_time}
-                        %input{:type => 'submit', :value => 'Delete', :class => 'button'}
-                    - else
-                      %form{ :action => "/scheduled_maintenances/#{check_path_escaped}", :method => "post"}
-                        %input{:type => 'hidden', :name => '_method',    :value => 'patch'}
-                        %input{:type => 'hidden', :name => 'start_time', :value => start_time}
-                        %input{:type => 'hidden', :name => 'end_time',   :value => 'now'}
-                        %input{:type => 'submit', :value => 'End Now', :class => 'button'}
+                  - if end_time > current_time.to_i
+                    - label = (start_time > current_time.to_i) ? 'Delete' : 'End Now'
+                    %form{ :action => "/scheduled_maintenances/#{check_path_escaped}", :method => "post"}
+                      %input{:type => 'hidden', :name => '_method', :value => 'delete'}
+                      %input{:type => 'hidden', :name => 'start_time', :value => start_time}
+                      %input{:type => 'submit', :value => label, :class => 'button'}
         - else
           %p No maintenance is scheduled
         %h4 Add Scheduled Maintenance

data/lib/flapjack/version.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
 module Flapjack
-  VERSION = "0.7.17"
+  VERSION = "0.7.18"
 end

data/spec/lib/flapjack/data/entity_check_spec.rb

@@ -181,63 +181,13 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       duration.should == 2 * (60 * 60)
     end
 
-    it "updates a scheduled maintenance period for a future time" do
-      t = Time.now.to_i
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
-        :duration => 2 * (60 * 60), :summary => "2 hours")
-
-      ec.update_scheduled_maintenance(t + (60 * 60), :end_time => t + (4 * (60 * 60)))
-      smps = ec.maintenances(nil, nil, :scheduled => true)
-      smps.should_not be_nil
-      smps.should be_an(Array)
-      smps.should have(1).scheduled_maintenance_period
-      smps[0].should be_a(Hash)
-
-      start_time = smps[0][:start_time]
-      start_time.should_not be_nil
-      start_time.should be_an(Integer)
-      start_time.should == (t + (60 * 60))
-
-      duration = smps[0][:duration]
-      duration.should_not be_nil
-      duration.should be_a(Float)
-      duration.should == 3 * (60 * 60)
-    end
-
-    # TODO this should probably enforce that it starts in the future
-    it "updates a scheduled maintenance period covering the current time", :time => true do
+    it "removes a scheduled maintenance period for a future time" do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
         :duration => 2 * (60 * 60), :summary => "2 hours")
 
-      Delorean.time_travel_to( Time.at(t + (90 * 60)) )
-
-      ec.update_scheduled_maintenance(t + (60 * 60), :end_time => t + (4 * (60 * 60)))
-      smps = ec.maintenances(nil, nil, :scheduled => true)
-      smps.should_not be_nil
-      smps.should be_an(Array)
-      smps.should have(1).scheduled_maintenance_period
-      smps[0].should be_a(Hash)
-
-      start_time = smps[0][:start_time]
-      start_time.should_not be_nil
-      start_time.should be_an(Integer)
-      start_time.should == (t + (60 * 60))
-
-      duration = smps[0][:duration]
-      duration.should_not be_nil
-      duration.should be_a(Float)
-      duration.should == 3 * (60 * 60)
-    end
-
-    it "fails to update a scheduled maintenance period when not found" do
-      t = Time.now.to_i
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      lambda {
-        ec.update_scheduled_maintenance(t + (60 * 60), :end_time => t + (2 * (60 * 60)))
-      }.should raise_error(ArgumentError)
+      ec.end_scheduled_maintenance(t + (60 * 60))
 
       smps = ec.maintenances(nil, nil, :scheduled => true)
       smps.should_not be_nil
@@ -245,61 +195,42 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       smps.should be_empty
     end
 
-    it "fails to update a scheduled maintenance period with invalid end time" do
+    # maint period starts an hour from now, goes for two hours -- at 30 minutes into
+    # it we stop it, and its duration should be 30 minutes
+    it "shortens a scheduled maintenance period covering a current time", :time => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
         :duration => 2 * (60 * 60), :summary => "2 hours")
 
-      lambda {
-        ec.update_scheduled_maintenance(t + (60 * 60), :end_time => t - (4 * (60 * 60)))
-      }.should raise_error(ArgumentError)
-      smps = ec.maintenances(nil, nil, :scheduled => true)
-      smps.should_not be_nil
-      smps.should be_an(Array)
-      smps.should have(1).scheduled_maintenance_period
-      smps[0].should be_a(Hash)
-
-      start_time = smps[0][:start_time]
-      start_time.should_not be_nil
-      start_time.should be_an(Integer)
-      start_time.should == (t + (60 * 60))
-
-      duration = smps[0][:duration]
-      duration.should_not be_nil
-      duration.should be_a(Float)
-      duration.should == 2 * (60 * 60)
-    end
-
-    it "removes a scheduled maintenance period for a future time" do
-      t = Time.now.to_i
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
-        :duration => 2 * (60 * 60), :summary => "2 hours")
+      Delorean.time_travel_to( Time.at(t + (90 * 60)) )
 
-      ec.delete_scheduled_maintenance(:start_time => t + (60 * 60))
+      ec.end_scheduled_maintenance(t + (60 * 60))
 
       smps = ec.maintenances(nil, nil, :scheduled => true)
       smps.should_not be_nil
       smps.should be_an(Array)
-      smps.should be_empty
+      smps.should_not be_empty
+      smps.should have(1).item
+      smps.first[:duration].should == (30 * 60)
     end
 
-    # TODO this should probably enforce that it starts in the future
-    it "removes a scheduled maintenance period covering a current time", :time => true do
+    it "does not alter or remove a scheduled maintenance period covering a past time", :time => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(:start_time => t + (60 * 60),
         :duration => 2 * (60 * 60), :summary => "2 hours")
 
-      Delorean.time_travel_to( Time.at(t + (90 * 60)) )
+      Delorean.time_travel_to( Time.at(t + (6 * (60 * 60)) ))
 
-      ec.delete_scheduled_maintenance(:start_time => t + (60 * 60))
+      ec.end_scheduled_maintenance(t + (60 * 60))
 
       smps = ec.maintenances(nil, nil, :scheduled => true)
       smps.should_not be_nil
       smps.should be_an(Array)
-      smps.should be_empty
+      smps.should_not be_empty
+      smps.should have(1).item
+      smps.first[:duration].should == 2 * (60 * 60)
     end
 
     it "returns a list of scheduled maintenance periods" do

data/spec/lib/flapjack/gateways/api/entity_methods_spec.rb

@@ -413,7 +413,7 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
 
     it "deletes a scheduled maintenance period for an entity check" do
       start_time = Time.now + (60 * 60) # an hour from now
-      entity_check.should_receive(:delete_scheduled_maintenance).with(:start_time => start_time.to_i)
+      entity_check.should_receive(:end_scheduled_maintenance).with(start_time.to_i)
 
       Flapjack::Data::EntityCheck.should_receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)
@@ -426,7 +426,7 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
     end
 
     it "doesn't delete a scheduled maintenance period if the start time isn't passed" do
-      entity_check.should_not_receive(:delete_scheduled_maintenance)
+      entity_check.should_not_receive(:end_scheduled_maintenance)
 
       delete "/scheduled_maintenances", :check => {entity_name => check}
       last_response.status.should == 403
@@ -437,8 +437,8 @@ describe 'Flapjack::Gateways::API::EntityMethods', :sinatra => true, :logger =>
 
       entity_check_2 = mock(Flapjack::Data::EntityCheck)
 
-      entity_check.should_receive(:delete_scheduled_maintenance).with(:start_time => start_time.to_i)
-      entity_check_2.should_receive(:delete_scheduled_maintenance).with(:start_time => start_time.to_i)
+      entity_check.should_receive(:end_scheduled_maintenance).with(start_time.to_i)
+      entity_check_2.should_receive(:end_scheduled_maintenance).with(start_time.to_i)
 
       Flapjack::Data::EntityCheck.should_receive(:for_entity).
         with(entity, check, :redis => redis).and_return(entity_check)

data/spec/lib/flapjack/gateways/web_spec.rb

@@ -112,7 +112,7 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
 
   it "shows the state of a check for an entity" do
     time = Time.now
-    Time.should_receive(:now).exactly(4).times.and_return(time)
+    Time.should_receive(:now).exactly(5).times.and_return(time)
 
     last_notifications = {:problem         => {:timestamp => time.to_i - ((3 * 60 * 60) + (5 * 60)), :summary => 'prob'},
                           :recovery        => {:timestamp => time.to_i - (3 * 60 * 60), :summary => nil},
@@ -202,27 +202,6 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
     last_response.status.should == 302
   end
 
-  it "updates a scheduled maintenance period for an entity check" do
-    t = Time.new.to_i
-
-    start_time = t - (24 * 60 * 60)
-
-    Flapjack::Data::Entity.should_receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-
-    Flapjack::Data::EntityCheck.should_receive(:for_entity).
-      with(entity, 'ping', :redis => redis).and_return(entity_check)
-
-    Chronic.should_receive(:parse).with('now').and_return(t)
-
-    entity_check.should_receive(:update_scheduled_maintenance).
-      with(start_time, {:end_time => t})
-
-    patch "/scheduled_maintenances/#{entity_name_esc}/ping",
-      {"start_time" => start_time, "end_time" => 'now'}
-    last_response.status.should == 302
-  end
-
   it "deletes a scheduled maintenance period for an entity check" do
     t = Time.now.to_i
 
@@ -234,8 +213,7 @@ describe Flapjack::Gateways::Web, :sinatra => true, :logger => true do
     Flapjack::Data::EntityCheck.should_receive(:for_entity).
       with(entity, 'ping', :redis => redis).and_return(entity_check)
 
-    entity_check.should_receive(:delete_scheduled_maintenance).
-      with(:start_time => start_time)
+    entity_check.should_receive(:end_scheduled_maintenance).with(start_time)
 
     delete "/scheduled_maintenances/#{entity_name_esc}/ping?start_time=#{start_time}"
     last_response.status.should == 302

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flapjack
 version: !ruby/object:Gem::Version
-  version: 0.7.17
+  version: 0.7.18
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-04 00:00:00.000000000 Z
+date: 2013-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dante
@@ -557,7 +557,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4104603407459161527
+      hash: -3760765416681204020
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -566,7 +566,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4104603407459161527
+      hash: -3760765416681204020
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23