def __init__(self, api_key: str, chat: Chat,
scheduler: BaseScheduler) -> None:
"""Init NavigationHandler class."""
request = Request(con_pool_size=self.CONNECTION_POOL_SIZE)
self._bot = Bot(token=api_key, request=request)
self._poll: Optional[Message] = None
self._poll_calback: Optional[TypeCallback] = None
self.scheduler = scheduler
self.chat_id = chat.id
self.user_name = chat.first_name
self.poll_name = f"poll_{self.user_name}"
logger.info("Opening chat with user %s", self.user_name)
self._menu_queue: List[BaseMessage] = [
] # list of menus selected by user
self._message_queue: List[BaseMessage] = [
] # list of application messages sent
# check if messages have expired every MESSAGE_CHECK_TIMEOUT seconds
scheduler.add_job(
self._expiry_date_checker,
"interval",
id="state_nav_update",
seconds=self.MESSAGE_CHECK_TIMEOUT,
replace_existing=True,
)
def start(self, *args, **kwargs):
if self._event is None or self._event.is_set():
self._event = Event()
BaseScheduler.start(self, *args, **kwargs)
self._thread = Thread(target=self._main_loop, name='APScheduler')
self._thread.daemon = self._daemon
self._thread.start()
def register_station_ping(self, uri: URL, scheduler: BaseScheduler):
"""
Registers the station Client for sending regular pings to the /station PHT service
"""
scheduler.add_job(
func=lambda: requests.post(self.uri, data=self.uri_payload),
trigger=IntervalTrigger(seconds=3),
id=self.register_id,
name="Send Station Ping",
max_instances=1,
replace_existing=True)
def __scheduler_init(cls, scheduler: BaseScheduler):
"""
make sure only one scheduled job will be run
:param app:
:return:
"""
if platform.system() != 'Windows':
fcntl = __import__("fcntl")
f = open('scheduler.lock', 'wb')
try:
fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
scheduler.start()
logger.info('Scheduler Started,---------------')
except:
pass
def unlock():
fcntl.flock(f, fcntl.LOCK_UN)
f.close()
atexit.register(unlock)
else:
msvcrt = __import__('msvcrt')
f = open('scheduler.lock', 'wb')
try:
msvcrt.locking(f.fileno(), msvcrt.LK_NBLCK, 1)
scheduler.start()
logger.info('Scheduler Started,----------------')
except:
pass
def _unlock_file():
try:
f.seek(0)
msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1)
except:
pass
atexit.register(_unlock_file)
async def send_mail_from_disk(file_path: Path, file_manager: FileManager,
scheduler: BaseScheduler,
session: Session) -> bool:
logger = logging.getLogger("ModernRelay.log")
envelope, _ = await file_manager.open_file(file_path)
message, attachments = get_message_and_attachments(envelope)
result = await session.mr_agent.send_mail(message,
headers=None,
attachments=attachments)
if result:
logger.info(
f"Success! {file_path} sent with agent {session.mr_agent.__class__.__name__} to {envelope.rcpt_tos}"
)
scheduler.remove_job(file_path.name)
file_path.unlink()
return True
else:
logger.warning(
f"{file_path} failed to send with agent {session.mr_agent.__class__.__name__}"
)
return False
def scheduled_job(self,
trigger,
args=None,
kwargs=None,
id=None,
name=None,
misfire_grace_time=undefined,
coalesce=undefined,
max_instances=undefined,
next_run_time=undefined,
jobstore='default',
executor='default',
**trigger_args):
"""
add default id = md5(name) if id is None
:param trigger:
:param args:
:param kwargs:
:param id:
:param name:
:param misfire_grace_time:
:param coalesce:
:param max_instances:
:param next_run_time:
:param jobstore:
:param executor:
:param trigger_args:
:return:
"""
if id is None and name:
id = hashlib.md5(name.encode()).hexdigest()
else:
raise Exception("job name should not null")
return BaseScheduler.scheduled_job(
self,
trigger,
args=args,
kwargs=kwargs,
id=id,
name=name,
misfire_grace_time=misfire_grace_time,
coalesce=coalesce,
max_instances=max_instances,
next_run_time=next_run_time,
jobstore=jobstore,
executor=executor,
**trigger_args)
def start(self, *args, **kwargs):
self._event = Event()
BaseScheduler.start(self, *args, **kwargs)
self._greenlet = gevent.spawn(self._main_loop)
return self._greenlet
def activate_sentry(scheduler: base_schedulers.BaseScheduler) -> None:
scheduler.add_listener(sentry_listener, cron_events.EVENT_JOB_ERROR)
def start(self):
self._event = Event()
BaseScheduler.start(self)
self._thread = Thread(target=self._main_loop, name='APScheduler')
self._thread.daemon = self._daemon
self._thread.start()
def start(self):
BaseScheduler.start(self)
self._event = Event()
self._greenlet = gevent.spawn(self._main_loop)
return self._greenlet
def remove_station_ping(self, scheduler: BaseScheduler):
scheduler.remove_job(job_id=self.register_id)
def __init__(self, scheduler: BaseScheduler):
super().__init__()
scheduler.add_job(self, "interval", hours=8)
def start(self):
BaseScheduler.start(self)
self._event = Event()
self._thread = Thread(target=self._main_loop, name='APScheduler')
self._thread.daemon = self._daemon
self._thread.start()
def start(self, *args, **kwargs):
self._event = Event()
BaseScheduler.start(self, *args, **kwargs)
self._thread = Thread(target=self._main_loop, name='APScheduler')
self._thread.daemon = self._daemon
self._thread.start()
def __init__(self, scheduler: BaseScheduler):
super().__init__()
scheduler.add_job(self, "interval", seconds=10)
def start(self, *args, **kwargs):
self._event = Event()
BaseScheduler.start(self, *args, **kwargs)
self._greenlet = gevent.spawn(self._main_loop)
return self._greenlet
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.schedulers.base import BaseScheduler
basesch = BaseScheduler()
print('print jobs vvvvvvvvvv ')
basesch.print_jobs()
print('print jobs ^^^^^^^^^^ ')
print('get jobs vvvvvvvvvv ')
basesch.get_job()
print('get jobs ^^^^^^^^^^ ')
print('This job is run every 5 seconds.')
def resume(self):
BaseScheduler.remove_job()
pass
def pause(self):
BaseScheduler.pause_job()
pass
def __init__(self, scheduler: BaseScheduler):
super().__init__()
scheduler.add_job(self, "interval", minutes=30)
def __init__(self, scheduler: BaseScheduler):
super().__init__()
scheduler.add_job(self, "cron", hour=3)
