बार-बार होने वाले शेड्यूल किए गए इवेंट के स्टार्टर

ऑटोमेशन को पहले से शेड्यूल करने के लिए, तीन अलग-अलग स्टार्टर उपलब्ध हैं:

1. Time.ScheduledTimeEvent
2. Time.RecurringClockTimeScheduledEvent
3. Time.RecurringSolarTimeScheduledEvent

पहले विकल्प Time.ScheduledTimeEvent की मदद से, ऑटोमेशन को शेड्यूल किया जा सकता है. इसे आने वाले समय में किसी एक तय समय पर शुरू किया जा सकता है. इसके अलावा, इसे घड़ी के समय या सौर घटना (जैसे, सूर्योदय या सूर्यास्त) के आधार पर बार-बार शुरू होने के लिए भी शेड्यूल किया जा सकता है.

उदाहरण के लिए, यह स्टार्टर हर दिन रात 10:00 बजे ऑटोमेशन शुरू करता है:

starter<_>(structure, Time.ScheduledTimeEvent) {
  parameter(Time.ScheduledTimeEvent.clockTime(LocalTime.of(22, 0, 0, 0)))
}

इसके अलावा, घड़ी के समय के बजाय सौर समय के हिसाब से इवेंट तय किया जा सकता है. इस तरह के स्टार्टर के लिए पैरामीटर, SolarTimeStruct होता है. इसमें ये शामिल होते हैं:

1. type, जो कि SolarTimeType.Sunrise या SolarTimeType.Sunset में से कोई एक है.
2. offset, इसकी मदद से, सौर ऊर्जा से जुड़े इवेंट के हिसाब से, शुरू होने के समय को किसी भी अवधि के लिए बदला जा सकता है. पॉज़िटिव वैल्यू से, सोलर इवेंट के बाद देरी होती है. वहीं, नेगेटिव वैल्यू से, सोलर इवेंट के पहले स्टार्टर ट्रिगर होता है.

यहां एक ऐसे स्टार्टर का उदाहरण दिया गया है जो हर दिन सूर्योदय से 15 मिनट पहले, ऑटोमेशन शुरू करता है:

starter<_>(structure, Time.ScheduledTimeEvent) {
  parameter(
    Time.ScheduledTimeEvent.solarTime(
      SolarTimeStruct(SolarTimeType.Sunrise, java.time.Duration.ofMinutes(-15))
    )
  )
}

दूसरे दो स्टार्टर, बार-बार शेड्यूल किए जाने वाले इवेंट स्टार्टर हैं. इनकी मदद से, ऐसे ऑटोमेशन बनाए जा सकते हैं जो ज़्यादा खास शर्तों के हिसाब से समय-समय पर चलते हैं. इनमें समय और कैलेंडर पर आधारित शर्तें शामिल हो सकती हैं.

Time.RecurringClockTimeScheduledEvent की मदद से, एक या एक से ज़्यादा समय या तारीख की शर्तों के आधार पर ऑटोमेशन शेड्यूल किया जा सकता है. इस स्टार्टर में, Unix cron यूटिलिटी के इस्तेमाल किए गए सिंटैक्स जैसा ही सिंटैक्स इस्तेमाल किया जाता है. इसका इस्तेमाल, बार-बार होने वाले ऑटोमेशन के लिए शेड्यूल तय करने के लिए किया जाता है.

Time.RecurringSolarTimeScheduledEvent की मदद से, सूरज के उगने या डूबने के समय के हिसाब से ऑटोमेशन शेड्यूल किया जा सकता है. इसके अलावा, कैलेंडर पर आधारित शर्त के साथ भी इसे शेड्यूल किया जा सकता है.

cron एक्सप्रेशन

ऐसा हो सकता है कि आपको cron के बारे में पहले से पता हो. यह एक ऐसा कमांड है जिसका इस्तेमाल Unix और Linux सिस्टम पर, बार-बार होने वाले कामों को शेड्यूल करने के लिए किया जाता है.

बार-बार शेड्यूल किए जाने वाले इवेंट के स्टार्टर, शेड्यूल करने के लिए ऐसे सिंटैक्स का इस्तेमाल करते हैं जो cron के सिंटैक्स से मिलता-जुलता है. इसलिए, इन स्टार्टर के साथ इस्तेमाल किए जाने वाले शेड्यूल करने के एक्सप्रेशन को cron एक्सप्रेशन कहा जाता है.

cron के कई अलग-अलग 'फ्लेवर' होते हैं. साथ ही, इन सभी को लागू करने के लिए सिंटैक्स के कई वर्शन होते हैं. शेड्यूल किए गए बार-बार होने वाले इवेंट के स्टार्टर cron एक्सप्रेशन, Quartz scheduler के सिंटैक्स का इस्तेमाल करते हैं. Quartz cron एक्सप्रेशन सिंटैक्स के बारे में, Quartz के दस्तावेज़ CronExpression में बताया गया है.

उदाहरण

यहां कुछ उदाहरण दिए गए हैं.

RecurringClockTimeScheduledEvent

RecurringClockTimeScheduledEvent स्टार्टर में, cron एक्सप्रेशन स्ट्रिंग को Time.RecurringClockTimeScheduledEvent.cronExpression फ़ील्ड में असाइन किया जाता है.

यहां RecurringClockTimeScheduledEvent स्टार्टर का एक उदाहरण दिया गया है. यह हर बुधवार को रात 8:00 बजे, अप्रैल में ऑटोमेशन शुरू करता है:

starter<_>(structure, event = Time.RecurringClockTimeScheduledEvent) {
  parameter(Time.RecurringClockTimeScheduledEvent.cronExpression("0 0 20 ? 4 4 *"))
}

RecurringSolarTimeScheduleEvent

RecurringSolarTimeScheduleEvent स्टार्टर के दो पैरामीटर होते हैं:

1. SolarTimeStruct.
2. cronExpression: यह cron एक्सप्रेशन का सबसेट होता है. इसमें सिर्फ़ महीने का दिन, महीना, हफ़्ते का दिन, और साल फ़ील्ड शामिल होते हैं. सौर समय से यह तय होता है कि ऑटोमेशन कब शुरू होगा. इसलिए, सेकंड, मिनट, और घंटे के फ़ील्ड शामिल नहीं किए जाते हैं.

यहां दिया गया उदाहरण, एक ऐसे स्टार्टर का है जिसकी वजह से अप्रैल के हर बुधवार को, सूर्योदय के एक घंटे बाद ऑटोमेशन शुरू हो जाता है:

starter<_>(structure, event = Time.RecurringSolarTimeScheduledEvent) {
  parameter(
    Time.RecurringSolarTimeScheduledEvent.solarTime(
      TimeTrait.SolarTimeStruct(SolarTimeType.Sunrise, Duration.ofHours(1))
    )
  )
  parameter(Time.RecurringSolarTimeScheduledEvent.cronExpression("? 4 4 *"))
}