rocketjob 3.0.0.rc5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba208764fdc107e2344875ae2370fcd382f13455
-  data.tar.gz: 3e048ff46edb4bc5648659b42f2d5177d67ce8f1
+  metadata.gz: 665d894a78de154892a8c53e03f2a2a81f6230f9
+  data.tar.gz: d89dba90f39ef98f7205366b166a45d928fb84db
 SHA512:
-  metadata.gz: 2feee5c761e3b7f5bc219f709547bc0356594e0c1aa2a568ac672b38bc22133e74adfd2fdb8f82249736ab68a1663989fbfaeb1787ec8f2495ac4f9f5d628050
-  data.tar.gz: fba78d1d97e122a79a0187d8e42518e421f35fe3fa9db3cf9e7faf297fb941bcf8060ca65970ab912842dcae5d727f719d6a03f0e53583d51bf8daf2a46e1fac
+  metadata.gz: c275f0ca475518de2acddce890b924312e8e40e5f04f74e2f4c8a235235723c5b1d3a322d0c10dd29d512f3d2f492b6c52d917b8a491185a18a61634ecfde174
+  data.tar.gz: 6f368bdd55d728530252d30d16a34b0b215caaa4cbe1a199b3aa1d369a48044cbd90642e2bec55fa039238897401a5223f67c56bbe7d02d98adea63e44f2b09e

data/lib/rocket_job/cli.rb

@@ -32,6 +32,9 @@ module RocketJob
       rails? ? boot_rails : boot_standalone
       write_pidfile
 
+      # In case Rails did not load the Mongoid Config
+      RocketJob::Config.load!(environment, mongo_config, symmetric_encryption_config) if Mongoid::Config.clients.empty?
+
       opts               = {}
       opts[:name]        = name if name
       opts[:max_workers] = workers if workers

data/lib/rocket_job/extensions/aasm.rb

@@ -55,3 +55,18 @@ module AASM
   end
 end
 
+# Patch to try and make AASM threadsafe
+AASM::StateMachineStore
+module AASM
+  class StateMachineStore
+    @stores = Concurrent::Map.new
+
+    def self.stores
+      @stores
+    end
+
+    def initialize
+      @machines = Concurrent::Map.new
+    end
+  end
+end

data/lib/rocket_job/plugins/rufus/cron_line.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2016, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2017, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -32,9 +32,15 @@ module RocketJob::Plugins::Rufus
   #
   class CronLine
 
+    # The max number of years in the future or the past before giving up
+    # searching for #next_time or #previous_time respectively
+    #
+    NEXT_TIME_MAX_YEARS = 14
+
     # The string used for creating this cronline instance.
     #
     attr_reader :original
+    attr_reader :original_timezone
 
     attr_reader :seconds
     attr_reader :minutes
@@ -52,10 +58,15 @@ module RocketJob::Plugins::Rufus
       ) unless line.is_a?(String)
 
       @original = line
+      @original_timezone = nil
 
       items = line.split
 
-      @timezone = items.pop if ZoTime.is_timezone?(items.last)
+      if @timezone = RocketJob::Plugins::Rufus::ZoTime.get_tzone(items.last)
+        @original_timezone = items.pop
+      else
+        @timezone = RocketJob::Plugins::Rufus::ZoTime.get_tzone(:current)
+      end
 
       fail ArgumentError.new(
         "not a valid cronline : '#{line}'"
@@ -76,18 +87,26 @@ module RocketJob::Plugins::Rufus
           "invalid cronline: '#{line}'"
         ) if es && es.find { |e| ! e.is_a?(Fixnum) }
       end
+
+      if @days && @days.include?(0) # gh-221
+
+        fail ArgumentError.new('invalid day 0 in cronline')
+      end
     end
 
     # Returns true if the given time matches this cron line.
     #
     def matches?(time)
 
-      time = ZoTime.new(time.to_f, @timezone || ENV['TZ']).time
+      # FIXME Don't create a new ZoTime if time is already a ZoTime in same
+      #       zone ...
+      #       Wait, this seems only used in specs...
+      t = ZoTime.new(time.to_f, @timezone)
 
-      return false unless sub_match?(time, :sec, @seconds)
-      return false unless sub_match?(time, :min, @minutes)
-      return false unless sub_match?(time, :hour, @hours)
-      return false unless date_match?(time)
+      return false unless sub_match?(t, :sec, @seconds)
+      return false unless sub_match?(t, :min, @minutes)
+      return false unless sub_match?(t, :hour, @hours)
+      return false unless date_match?(t)
       true
     end
 
@@ -118,78 +137,90 @@ module RocketJob::Plugins::Rufus
     #
     # (Thanks to K Liu for the note and the examples)
     #
-    def next_time(from=Time.now)
+    def next_time(from=ZoTime.now)
 
-      time = nil
-      zotime = ZoTime.new(from.to_i + 1, @timezone || ENV['TZ'])
+      nt = nil
+      zt = ZoTime.new(from.to_i + 1, @timezone)
+      maxy = from.year + NEXT_TIME_MAX_YEARS
 
       loop do
 
-        time = zotime.time
+        nt = zt.dup
+
+        fail RangeError.new(
+          "failed to reach occurrence within " +
+            "#{NEXT_TIME_MAX_YEARS} years for '#{original}'"
+        ) if nt.year > maxy
 
-        unless date_match?(time)
-          zotime.add((24 - time.hour) * 3600 - time.min * 60 - time.sec)
+        unless date_match?(nt)
+          zt.add((24 - nt.hour) * 3600 - nt.min * 60 - nt.sec)
           next
         end
-        unless sub_match?(time, :hour, @hours)
-          zotime.add((60 - time.min) * 60 - time.sec)
+        unless sub_match?(nt, :hour, @hours)
+          zt.add((60 - nt.min) * 60 - nt.sec)
           next
         end
-        unless sub_match?(time, :min, @minutes)
-          zotime.add(60 - time.sec)
+        unless sub_match?(nt, :min, @minutes)
+          zt.add(60 - nt.sec)
           next
         end
-        unless sub_match?(time, :sec, @seconds)
-          zotime.add(next_second(time))
+        unless sub_match?(nt, :sec, @seconds)
+          zt.add(next_second(nt))
           next
         end
 
         break
       end
 
-      time
+      nt
     end
 
     # Returns the previous time the cronline matched. It's like next_time, but
     # for the past.
     #
-    def previous_time(from=Time.now)
+    def previous_time(from=ZoTime.now)
 
-      time = nil
-      zotime = ZoTime.new(from.to_i - 1, @timezone || ENV['TZ'])
+      pt = nil
+      zt = ZoTime.new(from.to_i - 1, @timezone)
+      miny = from.year - NEXT_TIME_MAX_YEARS
 
       loop do
 
-        time = zotime.time
+        pt = zt.dup
+
+        fail RangeError.new(
+          "failed to reach occurrence within " +
+            "#{NEXT_TIME_MAX_YEARS} years for '#{original}'"
+        ) if pt.year < miny
 
-        unless date_match?(time)
-          zotime.substract(time.hour * 3600 + time.min * 60 + time.sec + 1)
+        unless date_match?(pt)
+          zt.substract(pt.hour * 3600 + pt.min * 60 + pt.sec + 1)
           next
         end
-        unless sub_match?(time, :hour, @hours)
-          zotime.substract(time.min * 60 + time.sec + 1)
+        unless sub_match?(pt, :hour, @hours)
+          zt.substract(pt.min * 60 + pt.sec + 1)
           next
         end
-        unless sub_match?(time, :min, @minutes)
-          zotime.substract(time.sec + 1)
+        unless sub_match?(pt, :min, @minutes)
+          zt.substract(pt.sec + 1)
           next
         end
-        unless sub_match?(time, :sec, @seconds)
-          zotime.substract(prev_second(time))
+        unless sub_match?(pt, :sec, @seconds)
+          zt.substract(prev_second(pt))
           next
         end
 
         break
       end
 
-      time
+      pt
     end
 
     # Returns an array of 6 arrays (seconds, minutes, hours, days,
     # months, weekdays).
-    # This method is used by the cronline unit tests.
+    # This method is mostly used by the cronline specs.
     #
-    def to_array
+    def to_a
 
       [
         toa(@seconds),
@@ -199,9 +230,10 @@ module RocketJob::Plugins::Rufus
         toa(@months),
         toa(@weekdays),
         toa(@monthdays),
-        @timezone
+        @timezone.name
       ]
     end
+    alias to_array to_a
 
     # Returns a quickly computed approximation of the frequency for this
     # cron line.
@@ -261,8 +293,10 @@ module RocketJob::Plugins::Rufus
         t1 = next_time(t0)
         d = t1 - t0
         delta = d if d < delta
-
-        break if @months == nil && t1.month == 2
+        break if @months.nil? && t1.month == 2
+        break if @months.nil? && @days.nil? && t1.day == 2
+        break if @months.nil? && @days.nil? && @hours.nil? && t1.hour == 1
+        break if @months.nil? && @days.nil? && @hours.nil? && @minutes.nil? && t1.min == 1
         break if t1.year >= 2001
 
         t0 = t1
@@ -312,39 +346,38 @@ module RocketJob::Plugins::Rufus
 
     WEEKDAYS = %w[ sun mon tue wed thu fri sat ]
     DAY_S = 24 * 3600
-    WEEK_S = 7 * DAY_S
 
     def parse_weekdays(item)
 
       return nil if item == '*'
 
-      items = item.downcase.split(',')
-
       weekdays = nil
       monthdays = nil
 
-      items.each do |it|
+      item.downcase.split(',').each do |it|
 
-        if m = it.match(/^(.+)#(l|-?[12345])$/)
+        WEEKDAYS.each_with_index { |a, i| it.gsub!(/#{a}/, i.to_s) }
+
+        it = it.gsub(/([^#])l/, '\1#-1')
+        # "5L" == "5#-1" == the last Friday
+
+        if m = it.match(/\A(.+)#(l|-?[12345])\z/)
 
           fail ArgumentError.new(
             "ranges are not supported for monthdays (#{it})"
           ) if m[1].index('-')
 
-          expr = it.gsub(/#l/, '#-1')
+          it = it.gsub(/#l/, '#-1')
 
-          (monthdays ||= []) << expr
+          (monthdays ||= []) << it
 
         else
 
-          expr = it.dup
-          WEEKDAYS.each_with_index { |a, i| expr.gsub!(/#{a}/, i.to_s) }
-
           fail ArgumentError.new(
-            "invalid weekday expression (#{it})"
-          ) if expr !~ /^0*[0-7](-0*[0-7])?$/
+            "invalid weekday expression (#{item})"
+          ) if it !~ /\A0*[0-7](-0*[0-7])?\z/
 
-          its = expr.index('-') ? parse_range(expr, 0, 7) : [ Integer(expr) ]
+          its = it.index('-') ? parse_range(it, 0, 7) : [ Integer(it) ]
           its = its.collect { |i| i == 7 ? 0 : i }
 
           (weekdays ||= []).concat(its)
@@ -371,7 +404,7 @@ module RocketJob::Plugins::Rufus
       Set.new(r)
     end
 
-    RANGE_REGEX = /^(\*|-?\d{1,2})(?:-(-?\d{1,2}))?(?:\/(\d{1,2}))?$/
+    RANGE_REGEX = /\A(\*|-?\d{1,2})(?:-(-?\d{1,2}))?(?:\/(\d{1,2}))?\z/
 
     def parse_range(item, min, max)
 
@@ -409,6 +442,10 @@ module RocketJob::Plugins::Rufus
         "#{item.inspect} is not in range #{min}..#{max}"
       ) if sta < min || edn > max
 
+      fail ArgumentError.new(
+        "#{item.inspect} increment must be greater than zero"
+      ) if inc == 0
+
       r = []
       val = sta
 
@@ -425,12 +462,14 @@ module RocketJob::Plugins::Rufus
       r.uniq
     end
 
+    # FIXME: Eventually split into day_match?, hour_match? and monthdays_match?o
+    #
     def sub_match?(time, accessor, values)
 
-      value = time.send(accessor)
-
       return true if values.nil?
 
+      value = time.send(accessor)
+
       if accessor == :day
 
         values.each do |v|
@@ -444,48 +483,37 @@ module RocketJob::Plugins::Rufus
         return true if value == 0 && values.include?(24)
       end
 
-      values.include?(value)
-    end
-
-    def monthday_match?(date, values)
-
-      return true if values.nil?
+      if accessor == :monthdays
 
-      today_values = monthdays(date)
-
-      (today_values & values).any?
-    end
-
-    def date_match?(date)
+        return true if (values & value).any?
+      end
 
-      return false unless sub_match?(date, :day, @days)
-      return false unless sub_match?(date, :month, @months)
-      return false unless sub_match?(date, :wday, @weekdays)
-      return false unless monthday_match?(date, @monthdays)
-      true
+      values.include?(value)
     end
 
-    def monthdays(date)
+    #    def monthday_match?(zt, values)
+    #
+    #      return true if values.nil?
+    #
+    #      today_values = monthdays(zt)
+    #
+    #      (today_values & values).any?
+    #    end
 
-      pos = 1
-      d = date.dup
+    def date_match?(zt)
 
-      loop do
-        d = d - WEEK_S
-        break if d.month != date.month
-        pos = pos + 1
-      end
+      return false unless sub_match?(zt, :day, @days)
+      return false unless sub_match?(zt, :month, @months)
 
-      neg = -1
-      d = date.dup
+      return true if (
+      (@weekdays && @monthdays) &&
+        (sub_match?(zt, :wday, @weekdays) ||
+          sub_match?(zt, :monthdays, @monthdays)))
 
-      loop do
-        d = d + WEEK_S
-        break if d.month != date.month
-        neg = neg - 1
-      end
+      return false unless sub_match?(zt, :wday, @weekdays)
+      return false unless sub_match?(zt, :monthdays, @monthdays)
 
-      [ "#{WEEKDAYS[date.wday]}##{pos}", "#{WEEKDAYS[date.wday]}##{neg}" ]
+      true
     end
   end
 end

data/lib/rocket_job/plugins/rufus/zo_time.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2006-2016, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2006-2017, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,186 +23,79 @@
 #++
 
 module RocketJob::Plugins::Rufus
-
-  TIMEZONES = %w[
-GB NZ UCT EET CET PRC ROC WET GMT EST ROK UTC MST HST MET Zulu Cuba Iran W-SU
-Eire GMT0 Libya Japan Egypt GMT+0 GMT-0 Israel Poland Navajo Turkey GB-Eire
-Iceland PST8PDT Etc/UCT CST6CDT NZ-CHAT MST7MDT Jamaica EST5EDT Etc/GMT Etc/UTC
-US/Samoa Etc/GMT0 Portugal Hongkong Etc/Zulu Singapore Asia/Baku Etc/GMT-9
-Etc/GMT+1 Etc/GMT+0 Asia/Aden Etc/GMT+2 Etc/GMT+3 Etc/GMT+4 Etc/GMT+5 Etc/GMT+6
-Etc/GMT+7 Etc/GMT+8 Etc/GMT+9 Etc/GMT-0 Etc/GMT-1 Universal Asia/Dili Greenwich
-Asia/Gaza Etc/GMT-8 Etc/GMT-7 US/Alaska Asia/Oral Etc/GMT-6 Etc/GMT-5 Etc/GMT-4
-Asia/Hovd Etc/GMT-3 US/Hawaii Etc/GMT-2 Kwajalein Asia/Omsk Asia/Macao
-Etc/GMT-14 Asia/Kabul US/Central Etc/GMT-13 US/Arizona Asia/Macau Asia/Qatar
-Asia/Seoul Asia/Tokyo Asia/Dubai US/Pacific Etc/GMT-12 Etc/GMT-11 Etc/GMT-10
-Asia/Dhaka Asia/Dacca Asia/Chita Etc/GMT+12 Etc/GMT+10 Asia/Amman Asia/Aqtau
-Etc/GMT+11 US/Eastern Asia/Thimbu Asia/Brunei Asia/Tehran Asia/Beirut
-Europe/Rome Europe/Riga Brazil/Acre Brazil/East Europe/Oslo Brazil/West
-Africa/Lome Asia/Taipei Asia/Saigon Asia/Riyadh Asia/Aqtobe Asia/Anadyr
-Europe/Kiev Asia/Almaty Africa/Juba Pacific/Yap US/Aleutian Asia/Muscat
-US/Mountain Asia/Harbin Asia/Hebron Asia/Manila Asia/Kuwait Asia/Urumqi
-US/Michigan Indian/Mahe SystemV/EST5 Asia/Kashgar Indian/Cocos Asia/Jakarta
-Asia/Kolkata Asia/Kuching America/Atka Asia/Irkutsk Pacific/Apia Asia/Magadan
-Africa/Dakar America/Lima Pacific/Fiji Pacific/Guam Europe/Vaduz Pacific/Niue
-Asia/Nicosia Africa/Ceuta Pacific/Truk America/Adak Pacific/Wake Africa/Tunis
-Africa/Cairo Asia/Colombo SystemV/AST4 SystemV/CST6 Asia/Karachi Asia/Rangoon
-SystemV/MST7 Asia/Baghdad Europe/Malta Africa/Lagos Europe/Minsk SystemV/PST8
-Canada/Yukon Asia/Tbilisi America/Nome Asia/Bahrain Africa/Accra Europe/Paris
-Asia/Bangkok Asia/Bishkek Asia/Thimphu SystemV/YST9 Asia/Yerevan Asia/Yakutsk
-Europe/Sofia Asia/Ust-Nera Australia/ACT Australia/LHI Europe/Tirane
-Asia/Tel_Aviv Australia/NSW Africa/Luanda Asia/Tashkent Africa/Lusaka
-Asia/Shanghai Africa/Malabo Asia/Sakhalin Africa/Maputo Africa/Maseru
-SystemV/HST10 Africa/Kigali Africa/Niamey Pacific/Samoa America/Sitka
-Pacific/Palau Pacific/Nauru Pacific/Efate Asia/Makassar Pacific/Chuuk
-Africa/Harare Africa/Douala America/Aruba America/Thule America/Bahia
-America/Jujuy America/Belem Asia/Katmandu America/Boise Indian/Comoro
-Indian/Chagos Asia/Jayapura Europe/Zurich Asia/Istanbul Europe/Zagreb
-Etc/Greenwich Europe/Warsaw Europe/Vienna Etc/Universal Asia/Dushanbe
-Europe/Athens Europe/Berlin Africa/Bissau Asia/Damascus Africa/Banjul
-Europe/Dublin Africa/Bangui Africa/Bamako Europe/Jersey Africa/Asmera
-Europe/Lisbon Africa/Asmara Europe/London Asia/Ashgabat Asia/Calcutta
-Europe/Madrid Europe/Monaco Europe/Moscow Europe/Prague Europe/Samara
-Europe/Skopje Asia/Khandyga Canada/Pacific Africa/Abidjan America/Manaus
-Asia/Chongqing Asia/Chungking Africa/Algiers America/Maceio US/Pacific-New
-Africa/Conakry America/La_Paz America/Juneau America/Nassau America/Inuvik
-Europe/Andorra Africa/Kampala Asia/Ashkhabad Asia/Hong_Kong America/Havana
-Canada/Eastern Europe/Belfast Canada/Central Australia/West Asia/Jerusalem
-Africa/Mbabane Asia/Kamchatka America/Virgin America/Guyana Asia/Kathmandu
-Mexico/General America/Panama Europe/Nicosia America/Denver Europe/Tallinn
-Africa/Nairobi America/Dawson Europe/Vatican Europe/Vilnius America/Cuiaba
-Africa/Tripoli Pacific/Wallis Atlantic/Faroe Pacific/Tarawa Pacific/Tahiti
-Pacific/Saipan Pacific/Ponape America/Cayman America/Cancun Asia/Pontianak
-Asia/Pyongyang Asia/Vientiane Asia/Qyzylorda Pacific/Noumea America/Bogota
-Pacific/Midway Pacific/Majuro Asia/Samarkand Indian/Mayotte Pacific/Kosrae
-Asia/Singapore Indian/Reunion America/Belize America/Regina America/Recife
-Pacific/Easter Mexico/BajaSur America/Merida Pacific/Chatham Pacific/Fakaofo
-Pacific/Gambier America/Rosario Asia/Ulan_Bator Indian/Maldives Pacific/Norfolk
-America/Antigua Asia/Phnom_Penh America/Phoenix America/Caracas America/Cayenne
-Atlantic/Azores Pacific/Pohnpei Atlantic/Canary America/Chicago Atlantic/Faeroe
-Africa/Windhoek America/Cordoba America/Creston Africa/Timbuktu America/Curacao
-Africa/Sao_Tome Africa/Ndjamena SystemV/AST4ADT Europe/Uzhgorod Europe/Tiraspol
-SystemV/CST6CDT Africa/Monrovia America/Detroit Europe/Sarajevo Australia/Eucla
-America/Tijuana America/Toronto America/Godthab America/Grenada Europe/Istanbul
-America/Ojinaga America/Tortola Australia/Perth Europe/Helsinki Australia/South
-Europe/Guernsey SystemV/EST5EDT Europe/Chisinau SystemV/MST7MDT Europe/Busingen
-Europe/Budapest Europe/Brussels America/Halifax America/Mendoza America/Noronha
-America/Nipigon Canada/Atlantic America/Yakutat SystemV/PST8PDT SystemV/YST9YDT
-Canada/Mountain Africa/Kinshasa Africa/Khartoum Africa/Gaborone Africa/Freetown
-America/Iqaluit America/Jamaica US/East-Indiana Africa/El_Aaiun America/Knox_IN
-Africa/Djibouti Africa/Blantyre America/Moncton America/Managua Asia/Choibalsan
-America/Marigot Australia/North Europe/Belgrade America/Resolute
-America/Mazatlan Pacific/Funafuti Pacific/Auckland Pacific/Honolulu
-Pacific/Johnston America/Miquelon America/Santarem Mexico/BajaNorte
-America/Santiago Antarctica/Troll America/Asuncion America/Atikokan
-America/Montreal America/Barbados Africa/Bujumbura Pacific/Pitcairn
-Asia/Ulaanbaatar Indian/Mauritius America/New_York Antarctica/Syowa
-America/Shiprock Indian/Kerguelen Asia/Novosibirsk America/Anguilla
-Indian/Christmas Asia/Vladivostok Asia/Ho_Chi_Minh Antarctica/Davis
-Atlantic/Bermuda Europe/Amsterdam Antarctica/Casey America/St_Johns
-Atlantic/Madeira America/Winnipeg America/St_Kitts Europe/Volgograd
-Brazil/DeNoronha Europe/Bucharest Africa/Mogadishu America/St_Lucia
-Atlantic/Stanley Europe/Stockholm Australia/Currie Europe/Gibraltar
-Australia/Sydney Asia/Krasnoyarsk Australia/Darwin America/Dominica
-America/Edmonton America/Eirunepe Europe/Podgorica America/Ensenada
-Europe/Ljubljana Australia/Hobart Europe/Mariehamn Africa/Lubumbashi
-America/Goose_Bay Europe/Luxembourg America/Menominee America/Glace_Bay
-America/Fortaleza Africa/Nouakchott America/Matamoros Pacific/Galapagos
-America/Guatemala Pacific/Kwajalein Pacific/Marquesas America/Guayaquil
-Asia/Kuala_Lumpur Europe/San_Marino America/Monterrey Europe/Simferopol
-America/Araguaina Antarctica/Vostok Europe/Copenhagen America/Catamarca
-Pacific/Pago_Pago America/Sao_Paulo America/Boa_Vista America/St_Thomas
-Chile/Continental America/Vancouver Africa/Casablanca Europe/Bratislava
-Pacific/Enderbury Pacific/Rarotonga Europe/Zaporozhye US/Indiana-Starke
-Antarctica/Palmer Asia/Novokuznetsk Africa/Libreville America/Chihuahua
-America/Anchorage Pacific/Tongatapu Antarctica/Mawson Africa/Porto-Novo
-Asia/Yekaterinburg America/Paramaribo America/Hermosillo Atlantic/Jan_Mayen
-Antarctica/McMurdo America/Costa_Rica Antarctica/Rothera America/Grand_Turk
-Atlantic/Reykjavik Atlantic/St_Helena Australia/Victoria Chile/EasterIsland
-Asia/Ujung_Pandang Australia/Adelaide America/Montserrat America/Porto_Acre
-Africa/Brazzaville Australia/Brisbane America/Kralendijk America/Montevideo
-America/St_Vincent America/Louisville Australia/Canberra Australia/Tasmania
-Europe/Isle_of_Man Europe/Kaliningrad Africa/Ouagadougou America/Rio_Branco
-Pacific/Kiritimati Africa/Addis_Ababa America/Metlakatla America/Martinique
-Asia/Srednekolymsk America/Guadeloupe America/Fort_Wayne Australia/Lindeman
-America/Whitehorse Arctic/Longyearbyen America/Pangnirtung America/Mexico_City
-America/Los_Angeles America/Rainy_River Atlantic/Cape_Verde Pacific/Guadalcanal
-Indian/Antananarivo America/El_Salvador Australia/Lord_Howe Africa/Johannesburg
-America/Tegucigalpa Canada/Saskatchewan America/Thunder_Bay Canada/Newfoundland
-America/Puerto_Rico America/Yellowknife Australia/Melbourne America/Porto_Velho
-Australia/Queensland Australia/Yancowinna America/Santa_Isabel
-America/Blanc-Sablon America/Scoresbysund America/Danmarkshavn
-Pacific/Port_Moresby Antarctica/Macquarie America/Buenos_Aires
-Africa/Dar_es_Salaam America/Campo_Grande America/Dawson_Creek
-America/Indianapolis Pacific/Bougainville America/Rankin_Inlet
-America/Indiana/Knox America/Lower_Princes America/Coral_Harbour
-America/St_Barthelemy Australia/Broken_Hill America/Cambridge_Bay
-America/Indiana/Vevay America/Swift_Current America/Port_of_Spain
-Antarctica/South_Pole America/Santo_Domingo Atlantic/South_Georgia
-America/Port-au-Prince America/Bahia_Banderas America/Indiana/Winamac
-America/Indiana/Marengo America/Argentina/Jujuy America/Argentina/Salta
-Canada/East-Saskatchewan America/Indiana/Vincennes America/Argentina/Tucuman
-America/Argentina/Ushuaia Antarctica/DumontDUrville America/Indiana/Tell_City
-America/Argentina/Mendoza America/Argentina/Cordoba America/Indiana/Petersburg
-America/Argentina/San_Luis America/Argentina/San_Juan America/Argentina/La_Rioja
-America/North_Dakota/Center America/Kentucky/Monticello
-America/North_Dakota/Beulah America/Kentucky/Louisville
-America/Argentina/Catamarca America/Indiana/Indianapolis
-America/North_Dakota/New_Salem America/Argentina/Rio_Gallegos
-America/Argentina/Buenos_Aires America/Argentina/ComodRivadavia
-]
-  TIMEZONEs = TIMEZONES.collect(&:downcase)
-
   #
   # Zon{ing|ed}Time, whatever.
   #
   class ZoTime
 
-    attr_accessor :seconds
-    attr_accessor :zone
+    attr_reader :seconds
+    attr_reader :zone
 
     def initialize(s, zone)
 
       @seconds = s.to_f
-      @zone = zone
-    end
+      @zone = self.class.get_tzone(zone || :current)
 
-    def time
+      fail ArgumentError.new(
+        "cannot determine timezone from #{zone.inspect}" +
+          " (etz:#{ENV['TZ'].inspect},tnz:#{Time.now.zone.inspect}," +
+          "tzid:#{defined?(TZInfo::Data).inspect})"
+      ) unless @zone
 
-      in_zone do
+      @time = nil # cache for #to_time result
+    end
 
-        t = Time.at(@seconds)
+    def seconds=(f)
 
-        #if t.isdst
-        #  t1 = Time.at(@seconds + 3600)
-        #  t = t1 if t.zone != t1.zone && t.hour == t1.hour && t.min == t1.min
-        #    # ambiguous TZ (getting out of DST)
-        #else
-        #  t.hour # force t to compute itself
-        #end
-        #
-        # jump out of DST as soon as possible, jumps 1h as seen from UTC
+      @time = nil
+      @seconds = f
+    end
 
-        t.hour # force t to compute itself
-        #
-        # stay in DST as long as possible, no jump seen from UTC
+    def zone=(z)
 
-        t
-      end
+      @time = nil
+      @zone = self.class.get_tzone(zone || :current)
     end
 
     def utc
 
-      time.utc
+      Time.utc(1970, 1, 1) + @seconds
     end
 
-    def add(s)
+    # Returns a Ruby Time instance.
+    #
+    # Warning: the timezone of that Time instance will be UTC.
+    #
+    def to_time
 
-      @seconds += s.to_f
+      @time ||= begin; u = utc; @zone.period_for_utc(u).to_local(u); end
     end
 
-    def substract(s)
+    %w[
+      year month day wday hour min sec usec asctime
+    ].each do |m|
+      define_method(m) { to_time.send(m) }
+    end
+    def iso8601(fraction_digits=0); to_time.iso8601(fraction_digits); end
+
+    def ==(o)
+
+      o.is_a?(ZoTime) && o.seconds == @seconds && o.zone == @zone
+    end
+    #alias eq? == # FIXME see Object#== (ri)
+
+    def >(o); @seconds > _to_f(o); end
+    def >=(o); @seconds >= _to_f(o); end
+    def <(o); @seconds < _to_f(o); end
+    def <=(o); @seconds <= _to_f(o); end
+    def <=>(o); @seconds <=> _to_f(o); end
+
+    alias getutc utc
+    alias getgm utc
 
-      @seconds -= s.to_f
+    def to_i
+
+      @seconds.to_i
     end
 
     def to_f
@@ -210,82 +103,372 @@ America/Argentina/Buenos_Aires America/Argentina/ComodRivadavia
       @seconds
     end
 
-    #DELTA_TZ_REX = /^[+-][0-1][0-9]:?[0-5][0-9]$/
+    def is_dst?
+
+      @zone.period_for_utc(utc).std_offset != 0
+    end
+    alias isdst is_dst?
+
+    def utc_offset
+
+      #@zone.period_for_utc(utc).utc_offset
+      #@zone.period_for_utc(utc).utc_total_offset
+      #@zone.period_for_utc(utc).std_offset
+      @zone.period_for_utc(utc).utc_offset
+    end
+
+    def strftime(format)
+
+      format = format.gsub(/%(\/?Z|:{0,2}z)/) { |f| strfz(f) }
+
+      to_time.strftime(format)
+    end
+
+    def add(t); @time = nil; @seconds += t.to_f; end
+    def substract(t); @time = nil; @seconds -= t.to_f; end
+
+    def +(t); inc(t, 1); end
+    def -(t); inc(t, -1); end
+
+    WEEK_S = 7 * 24 * 3600
+
+    def monthdays
+
+      date = to_time
+
+      pos = 1
+      d = self.dup
+
+      loop do
+        d.add(-WEEK_S)
+        break if d.month != date.month
+        pos = pos + 1
+      end
+
+      neg = -1
+      d = self.dup
+
+      loop do
+        d.add(WEEK_S)
+        break if d.month != date.month
+        neg = neg - 1
+      end
+
+      [ "#{date.wday}##{pos}", "#{date.wday}##{neg}" ]
+    end
+
+    def to_s
 
-    def self.envtzable?(s)
+      strftime('%Y-%m-%d %H:%M:%S %z')
+    end
+
+    def to_debug_s
+
+      uo = self.utc_offset
+      uos = uo < 0 ? '-' : '+'
+      uo = uo.abs
+      uoh, uom = [ uo / 3600, uo % 3600 ]
+
+      [
+        'zt',
+        self.strftime('%Y-%m-%d %H:%M:%S'),
+        "%s%02d:%02d" % [ uos, uoh, uom ],
+        "dst:#{self.isdst}"
+      ].join(' ')
+    end
+
+    # Debug current time by showing local time / delta / utc time
+    # for example: "0120-7(0820)"
+    #
+    def to_utc_comparison_s
 
-      TIMEZONES.include?(s)
+      per = @zone.period_for_utc(utc)
+      off = per.utc_total_offset
+
+      off = off / 3600
+      off = off >= 0 ? "+#{off}" : off.to_s
+
+      strftime('%H%M') + off + utc.strftime('(%H%M)')
+    end
+
+    def to_time_s
+
+      strftime("%H:%M:%S.#{'%06d' % usec}")
+    end
+
+    def self.now(zone=nil)
+
+      ZoTime.new(Time.now.to_f, zone)
+    end
+
+    # https://en.wikipedia.org/wiki/ISO_8601
+    # Postel's law applies
+    #
+    def self.extract_iso8601_zone(s)
+
+      m = s.match(
+        /[0-2]\d(?::?[0-6]\d(?::?[0-6]\d))?\s*([+-]\d\d(?::?\d\d)?)\s*\z/)
+      return nil unless m
+
+      zs = m[1].split(':')
+      zs << '00' if zs.length < 2
+
+      zh = zs[0].to_i.abs
+
+      return nil if zh > 24
+      return nil if zh == 24 && zs[1].to_i != 0
+
+      zs.join(':')
     end
 
     def self.parse(str, opts={})
 
       if defined?(::Chronic) && t = ::Chronic.parse(str, opts)
-        return ZoTime.new(t, ENV['TZ'])
+        return ZoTime.new(t, nil)
       end
 
+      #rold = RUBY_VERSION < '1.9.0'
+      #rold = RUBY_VERSION < '2.0.0'
+
       begin
         DateTime.parse(str)
       rescue
-        fail ArgumentError, "no time information in #{o.inspect}"
-      end if RUBY_VERSION < '1.9.0'
+        fail ArgumentError, "no time information in #{str.inspect}"
+      end #if rold
+      #
+      # is necessary since Time.parse('xxx') in Ruby < 1.9 yields `now`
 
       zone = nil
 
       s =
-        str.gsub(/\S+/) { |m|
-          if envtzable?(m)
-            zone ||= m
+        str.gsub(/\S+/) do |w|
+          if z = get_tzone(w)
+            zone ||= z
             ''
           else
-            m
+            w
           end
-        }
+        end
+
+      local = Time.parse(s)
+      izone = extract_iso8601_zone(s)
+
+      zone ||=
+        if s.match(/\dZ\b/)
+          get_tzone('Zulu')
+          #elsif rold && izone
+        elsif izone
+          get_tzone(izone)
+        elsif local.zone.nil? && izone
+          get_tzone(local.strftime('%:z'))
+        else
+          get_tzone(:local)
+        end
+
+      secs =
+        #if rold && izone
+        if izone
+          local.to_f
+        else
+          zone.period_for_local(local).to_utc(local).to_f
+        end
+
+      ZoTime.new(secs, zone)
+    end
 
-      return nil unless zone.nil? || is_timezone?(zone)
+    def self.get_tzone(str)
+      return str if str.is_a?(::TZInfo::Timezone)
 
-      zt = ZoTime.new(0, zone || ENV['TZ'])
-      zt.in_zone { zt.seconds = Time.parse(s).to_f }
+      # discard quickly when it's certainly not a timezone
 
-      zt.seconds == nil ? nil : zt
-    end
+      return nil if str == nil
+      return nil if str == '*'
 
-    def self.is_timezone?(str)
+      # ok, it's a timezone then
 
-      return false if str == nil
-      return false if str == '*'
+      ostr = str
+      str = ENV['TZ'] || Time.now.zone if str == :current || str == :local
 
-      return false if str.index('#')
-      # "sun#2", etc... On OSX would go all the way to true
+      # utc_offset
 
-      return true if Time.zone_offset(str)
+      if str.is_a?(Numeric)
+        i = str.to_i
+        sn = i < 0 ? '-' : '+'; i = i.abs
+        hr = i / 3600; mn = i % 3600; sc = i % 60
+        str = (sc > 0 ? "%s%02d:%02d:%02d" : "%s%02d:%02d") % [ sn, hr, mn, sc ]
+      end
+
+      return nil if str.nil? || str.index('#')
+      # counters "sun#2", etc... On OSX would go all the way to true
+
+      # vanilla time zones
+
+      z = (::TZInfo::Timezone.get(str) rescue nil)
+      return z if z
+
+      # time zone abbreviations
+
+      if str.match(/\A[A-Z0-9-]{3,6}\z/)
 
-      return !! (::TZInfo::Timezone.get(str) rescue nil) if defined?(::TZInfo)
+        toff = Time.now.utc_offset
+        toff = nil if str != Time.now.zone
+
+        twin = Time.utc(Time.now.year, 1, 1) # winter
+        tsum = Time.utc(Time.now.year, 7, 1) # summer
+
+        z =
+          ::TZInfo::Timezone.all.find do |tz|
+
+            pwin = tz.period_for_utc(twin)
+            psum = tz.period_for_utc(tsum)
+
+            if toff
+              (pwin.abbreviation.to_s == str && pwin.utc_offset == toff) ||
+                (psum.abbreviation.to_s == str && psum.utc_offset == toff)
+            else
+              # returns the first tz with the given abbreviation, almost useless
+              # favour fully named zones...
+              pwin.abbreviation.to_s == str ||
+                psum.abbreviation.to_s == str
+            end
+          end
+        return z if z
+      end
 
-      return true if TIMEZONES.include?(str)
-      return true if TIMEZONEs.include?(str)
+      # some time zone aliases
 
-      t = ZoTime.new(0, str).time
+      return ::TZInfo::Timezone.get('Zulu') if %w[ Z ].include?(str)
 
-      return false if t.zone == ''
-      return false if t.zone == 'UTC'
-      return false if t.utc_offset == 0 && str.start_with?(t.zone)
-      # 3 common fallbacks...
+      # custom timezones, no DST, just an offset, like "+08:00" or "-01:30"
 
-      return false if RUBY_PLATFORM.include?('java') && ! envtzable?(str)
+      tz = (@custom_tz_cache ||= {})[str]
+      return tz if tz
 
-      true
+      if m = str.match(/\A([+-][0-1][0-9]):?([0-5][0-9])\z/)
+
+        hr = m[1].to_i
+        mn = m[2].to_i
+
+        hr = nil if hr.abs > 11
+        hr = nil if mn > 59
+        mn = -mn if hr && hr < 0
+
+        return (
+        @custom_tz_cache[str] =
+          begin
+            tzi = TZInfo::TransitionDataTimezoneInfo.new(str)
+            tzi.offset(str, hr * 3600 + mn * 60, 0, str)
+            tzi.create_timezone
+          end
+        ) if hr
+      end
+
+      # last try with ENV['TZ']
+
+      z =
+        (ostr == :local || ostr == :current) &&
+          (::TZInfo::Timezone.get(ENV['TZ']) rescue nil)
+      return z if z
+
+      # so it's not a timezone.
+
+      nil
+    end
+
+    def self.local_tzone
+
+      get_tzone(:local)
     end
 
-    def in_zone(&block)
+    def self.make(o)
+
+      zt =
+        case o
+        when Time
+          ZoTime.new(o.to_f, o.zone)
+        when Date
+          t =
+            o.respond_to?(:to_time) ?
+              o.to_time :
+              Time.parse(o.strftime('%Y-%m-%d %H:%M:%S'))
+          ZoTime.new(t.to_f, t.zone)
+        when String
+          Rufus::Scheduler.parse_in(o, :no_error => true) || self.parse(o)
+        else
+          o
+        end
+
+      zt = ZoTime.new(Time.now.to_f + zt, nil) if zt.is_a?(Numeric)
+
+      fail ArgumentError.new(
+        "cannot turn #{o.inspect} to a ZoTime instance"
+      ) unless zt.is_a?(ZoTime)
+
+      zt
+    end
+
+    #    def in_zone(&block)
+    #
+    #      current_timezone = ENV['TZ']
+    #      ENV['TZ'] = @zone
+    #
+    #      block.call
+    #
+    #    ensure
+    #
+    #      ENV['TZ'] = current_timezone
+    #    end
+
+    protected
+
+    def inc(t, dir)
+
+      if t.is_a?(Numeric)
+        nt = self.dup
+        nt.seconds += dir * t.to_f
+        nt
+      elsif t.respond_to?(:to_f)
+        @seconds + dir * t.to_f
+      else
+        fail ArgumentError.new(
+          "cannot call ZoTime #- or #+ with arg of class #{t.class}")
+      end
+    end
+
+    def _to_f(o)
+
+      fail ArgumentError(
+        "comparison of ZoTime with #{o.inspect} failed"
+      ) unless o.is_a?(ZoTime) || o.is_a?(Time)
+
+      o.to_f
+    end
+
+    def strfz(code)
+
+      return @zone.name if code == '%/Z'
+
+      per = @zone.period_for_utc(utc)
 
-      current_timezone = ENV['TZ']
-      ENV['TZ'] = @zone
+      return per.abbreviation.to_s if code == '%Z'
 
-      block.call
+      off = per.utc_total_offset
+      #
+      sn = off < 0 ? '-' : '+'; off = off.abs
+      hr = off / 3600
+      mn = (off % 3600) / 60
+      sc = 0
 
-    ensure
+      fmt =
+        if code == '%z'
+          "%s%02d%02d"
+        elsif code == '%:z'
+          "%s%02d:%02d"
+        else
+          "%s%02d:%02d:%02d"
+        end
 
-      ENV['TZ'] = current_timezone
+      fmt % [ sn, hr, mn, sc ]
     end
   end
 end

data/lib/rocket_job/plugins/state_machine.rb

@@ -31,6 +31,10 @@ module RocketJob
 
       included do
         include AASM
+        # Try to make aasm lookup thread safe
+        @aasm = Concurrent::Map.new
+        # Call aasm to create default instance upfront
+        aasm
 
         # Adds a :before or :after callback to an event
         #  state_machine_add_event_callback(:start, :before, :my_method)

data/lib/rocket_job/server.rb

@@ -202,6 +202,19 @@ module RocketJob
       self.class.shutdown? || !running?
     end
 
+    # Scope for all zombie servers
+    def self.zombies(missed = 4)
+      dead_seconds        = Config.instance.heartbeat_seconds * missed
+      last_heartbeat_time = Time.now - dead_seconds
+      where(
+        :state.in => [:stopping, :running, :paused],
+        '$or'     => [
+          {"heartbeat.updated_at" => {'$exists' => false}},
+          {"heartbeat.updated_at" => {'$lte' => last_heartbeat_time}}
+        ]
+      )
+    end
+
     # Returns [true|false] if this server has missed at least the last 4 heartbeats
     #
     # Possible causes for a server to miss its heartbeats:
@@ -209,7 +222,7 @@ module RocketJob
     # - The server process is "hanging"
     # - The server is no longer able to communicate with the MongoDB Server
     def zombie?(missed = 4)
-      return false unless running? || stopping?
+      return false unless running? || stopping? || paused?
       return true if heartbeat.nil? || heartbeat.updated_at.nil?
       dead_seconds = Config.instance.heartbeat_seconds * missed
       (Time.now - heartbeat.updated_at) >= dead_seconds
@@ -258,7 +271,7 @@ module RocketJob
     ensure
       # Logs the backtrace for each running worker
       if SemanticLogger::VERSION.to_i >= 4
-        workers.each { |thread| logger.backtrace(thread: thread) }
+        workers.each { |worker| logger.backtrace(thread: worker.thread) }
       end
     end
 

data/lib/rocket_job/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module RocketJob #:nodoc
-  VERSION = '3.0.0.rc5'
+  VERSION = '3.0.0'
 end

data/test/plugins/cron_test.rb

@@ -32,7 +32,7 @@ module Plugins
 
         describe 'timezones are supported' do
           it 'handles UTC' do
-            time = Time.parse('2015-12-09 17:50:05 +0000')
+            time = Time.parse('2015-12-09 17:50:05 UTC')
             Time.stub(:now, time) do
               @job = CronJob.create!(cron_schedule: '* 1 * * * UTC')
             end
@@ -42,7 +42,7 @@ module Plugins
           end
 
           it 'handles Eastern' do
-            time = Time.parse('2015-12-09 17:50:05 +0000')
+            time = Time.parse('2015-12-09 17:50:05 UTC')
             Time.stub(:now, time) do
               @job = CronJob.create!(cron_schedule: '* 1 * * * America/New_York')
             end

data/test/plugins/processing_window_test.rb

@@ -32,7 +32,7 @@ module Plugins
 
         describe 'timezones are supported' do
           it 'handles UTC' do
-            time = Time.parse('2015-12-09 17:50:05 +0000')
+            time = Time.parse('2015-12-09 17:50:05 UTC')
             Time.stub(:now, time) do
               @job = ProcessingWindowJob.create!(processing_schedule: '* 1 * * * UTC', processing_duration: 1.hour)
             end
@@ -42,7 +42,7 @@ module Plugins
           end
 
           it 'handles Eastern' do
-            time = Time.parse('2015-12-09 17:50:05 +0000')
+            time = Time.parse('2015-12-09 17:50:05 UTC')
             Time.stub(:now, time) do
               @job = ProcessingWindowJob.create!(processing_schedule: '* 1 * * * America/New_York', processing_duration: 1.hour)
             end
@@ -55,7 +55,7 @@ module Plugins
 
       describe '#rocket_job_processing_window_active?' do
         it 'returns true when in the processing window' do
-          time   = Time.parse('2015-12-09 17:50:05 +0000')
+          time   = Time.parse('2015-12-09 17:50:05 UTC')
           @job   = ProcessingWindowJob.new(processing_schedule: '* 17 * * * UTC', processing_duration: 1.hour)
           result = Time.stub(:now, time) do
             @job.rocket_job_processing_window_active?
@@ -64,7 +64,7 @@ module Plugins
         end
 
         it 'returns false when not in the processing window' do
-          time   = Time.parse('2015-12-09 16:50:05 +0000')
+          time   = Time.parse('2015-12-09 16:50:05 UTC')
           @job   = ProcessingWindowJob.new(processing_schedule: '* 17 * * * UTC', processing_duration: 1.hour)
           result = Time.stub(:now, time) do
             @job.rocket_job_processing_window_active?
@@ -96,7 +96,7 @@ module Plugins
 
       describe 're-queue' do
         it 'if outside processing window' do
-          time = Time.parse('2015-12-09 16:50:05 +0000')
+          time = Time.parse('2015-12-09 16:50:05 UTC')
           Time.stub(:now, time) do
             @job = ProcessingWindowJob.new(processing_schedule: '* 17 * * * UTC', processing_duration: 1.hour)
             @job.perform_now

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rocketjob
 version: !ruby/object:Gem::Version
-  version: 3.0.0.rc5
+  version: 3.0.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-11 00:00:00.000000000 Z
+date: 2017-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -165,9 +165,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.8