def main():
plugin_list= cf.sections()
print plugin_list
notif = pynsca.NSCANotifier(cf.monitor_server, password=cf.nsca_pass)
plugin_scheduler = BackgroundScheduler()
try:
for svc_name in plugin_list:
if str(svc_name) == 'defaults': pass
else:
logging.info("%s loading" % str(svc_name))
cmd=cf.g(svc_name,"check")
if cmd is None:
logging.error("%s check not exists" % svc_name)
sys.exit(2)
plugin_interval = cf.g(svc_name,"interval")
if plugin_interval is None:
continue
plugin_scheduler.add_job(func=check_execute,args=[cmd,svc_name,notif],trigger='interval',seconds = plugin_interval, id = svc_name)
logging.info("%s loaded" %str(svc_name))
plugin_scheduler.start()
while True:
time.sleep(2)
except Exception,e:
logging.info("Agent boot up error: %s" % str(e))
sys.exit(1)
def go():
preflight()
sched = BackgroundScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults)
# startTime = datetime.datetime.now()+datetime.timedelta(seconds=60*60)
# startTime = datetime.datetime.now()+datetime.timedelta(seconds=60*15)
# startTime = datetime.datetime.now()+datetime.timedelta(seconds=60*5)
# startTime = datetime.datetime.now()+datetime.timedelta(seconds=20)
startTime = datetime.datetime.now()+datetime.timedelta(seconds=10)
scheduleJobs(sched, startTime)
sched.start()
# spinwait for ctrl+c, and exit when it's received.
loops = 0
while runStatus.run:
time.sleep(0.1)
# loops += 1
# if loops > 100:
# logging_tree.printout()
# loops = 0
print("Scraper stopping scheduler")
sched.shutdown()
nt.dirNameProxy.stop()
class cScheduler():
def __init__(self):
jobstores = {
'default': SQLAlchemyJobStore(url='sqlite:///__secret//jobs.db')
}
executors = {
'default': {'type': 'threadpool', 'max_workers': 20},
'processpool': ProcessPoolExecutor(max_workers=5)
}
job_defaults = {
'coalesce': False,
'max_instances': 1
}
self.the_sched = BackgroundScheduler()
self.the_sched.configure(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=utc)
self.telegram_server = None
self.job_queue = None
def start(self):
self.the_sched.start()
def set_telegram_server(self, telegram_server):
self.telegram_server = telegram_server
self.telegram_job_queue = telegram_server.get_job_queue()
def start_main_schedule(self):
self.telegram_job_queue.put(self.telegram_server.extjob_send_all, 5, repeat=True)
def run_web():
nt.dirNameProxy.startDirObservers()
sched = BackgroundScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults)
sched.start()
x = 60
for name, classInstance in nt.__dict__.items():
# look up all class instances in nameTools. If they have the magic attribute "NEEDS_REFRESHING",
# that means they support scheduling, so schedule the class in question.
# To support auto-refreshing, the class needs to define:
# cls.NEEDS_REFRESHING = {anything, just checked for existance}
# cls.REFRESH_INTERVAL = {number of seconds between refresh calls}
# cls.refresh() = Call to do the refresh operation. Takes no arguments.
#
if isinstance(classInstance, type) or not hasattr(classInstance, "NEEDS_REFRESHING"):
continue
sched.add_job(classInstance.refresh,
trigger='interval',
seconds=classInstance.REFRESH_INTERVAL,
start_date=datetime.datetime.now()+datetime.timedelta(seconds=20+x),
jobstore='main_jobstore')
x += 60*2.5
# It looks like cherrypy installs a ctrl+c handler, so I don't need to.
webserver_process.serverProcess()
def schedule_notices():
sched = BackgroundScheduler()
sched.start()
trigger = CronTrigger(day_of_week='*', hour=17)
sched.add_job(send_notice, trigger)
def scheduler(event):
scheduler = BackgroundScheduler()
settings = event.app.registry.settings
jobstores = {'default': SQLAlchemyJobStore(url=settings['scheduler.url'])}
executors = {
'default': {
'type': settings['scheduler.executors.type'],
'max_workers': settings['scheduler.executors.max_workers']
},
'processpool': ProcessPoolExecutor(
max_workers=settings['scheduler.executors.processpool.max_workers']
)
}
job_defaults = {
'coalesce': False,
'max_instances': settings['scheduler.job_defaults.max_instances']
}
scheduler.configure(
jobstores=jobstores,
executors=executors,
job_defaults=job_defaults,
timezone=timezone('UTC')
)
if settings['scheduler.autostart'] == 'true':
scheduler.start()
event.app.registry.registerUtility(scheduler, IScheduler)
class MyScheduler(object): """scheduler class, difine scheduler and jobs""" def __init__(self): super(MyScheduler, self).__init__() self.scheduler = BackgroundScheduler() self.wish_time = setting.WISH_DELAY self.book_time = setting.BOOK_LAST_TIME def start(self): self.scheduler.start() def shutdown(self): self.scheduler.shutdown() def add_check_wish_status_job(self, wish_id): # print datetime.now() run_date = datetime.now() + timedelta(seconds=self.wish_time) self.scheduler.add_job(_reset_wish_status, 'date', args=[wish_id], run_date=run_date) def add_set_book_removed_job(self, book_id): run_date = datetime.now() + timedelta(days=self.book_time) self.scheduler.add_job(_set_book_removed, 'date', args=[book_id], run_date=run_date) def add_xapian_reindex_job(self, xapian_tool): self.scheduler.add_job(xapian_tool.index, 'interval', minutes=15)
def main(args):
scheduler = BackgroundScheduler(coalesce=True, misfire_grace_time=4)
taskparser = TaskParser(args['f'])
taskparser.parse()
yml_handler = YmlFileEventHandler(patterns=["*.yml"])
yml_handler.set_scheduler(scheduler)
yml_handler.set_parser(taskparser)
file_observer = Observer()
file_observer.schedule(yml_handler, path=args['f'], recursive=False)
file_observer.start()
# Initial parsing of the task folder
for t in taskparser.task_list:
addJob(t, scheduler)
# Spread tasks from each other to prevent overload/task miss
time.sleep(1)
scheduler.start()
# Update jobs while running
while True:
try:
time.sleep(15)
except KeyboardInterrupt:
break
scheduler.shutdown()
def run_scheduler():
scheduler = BackgroundScheduler()
# scheduler.add_job(func, "interval", days=1)
scheduler.add_job(check_overdue, "interval", days=1)
# scheduler.add_job(send_mail_test(), "interval", minutes=1)
scheduler.start()
print "Scheduler started!"
class Bot():
def __init__(self, cfg):
self.token = cfg.TOKEN_BOT
self.scheduler = BackgroundScheduler({
'apscheduler.jobstores.default': {
'type': 'sqlalchemy',
'url': cfg.POSTGRESQL_DB
},
'apscheduler.executors.default': {
'class': 'apscheduler.executors.pool:ThreadPoolExecutor',
'max_workers': '20'
},
'apscheduler.executors.processpool': {
'type': 'processpool',
'max_workers': '5'
},
'apscheduler.job_defaults.coalesce': 'false',
'apscheduler.job_defaults.max_instances': '3',
'apscheduler.timezone': 'UTC',
})
def post(self, text, channel):
url = 'https://{domain}/services/hooks/slackbot?token={token}&channel=%23{channel}'
r = requests.post(url.format(domain=cfg.TEAMDOMAIN, token=self.token, channel=channel), data=text)
def test(self, args=None):
print 'Scheduler test'
if args:
print 'job args: {0}'.format(' '.join(args))
def add_reminder(self):
self.scheduler.add_job(self.test, 'interval', minutes=1, id='job_id', jobstore='default')
def init():
scheduler = BackgroundScheduler()
scheduler.start()
scheduler.add_job(dochatcleanup, 'interval',
minutes=int(plugin.config.config('sleep')),
id='dochatcleanup', replace_existing=True)
return
def startScheduler():
db.create_all()
#create default roles!
if not db.session.query(models.Role).filter(models.Role.name == "admin").first():
admin_role = models.Role(name='admin', description='Administrator Role')
user_role = models.Role(name='user', description='User Role')
db.session.add(admin_role)
db.session.add(user_role)
db.session.commit()
try:
import tzlocal
tz = tzlocal.get_localzone()
logger.info("local timezone: %s" % tz)
except:
tz = None
if not tz or tz.zone == "local":
logger.error('Local timezone name could not be determined. Scheduler will display times in UTC for any log'
'messages. To resolve this set up /etc/timezone with correct time zone name.')
tz = pytz.utc
#in debug mode this is executed twice :(
#DONT run flask in auto reload mode when testing this!
scheduler = BackgroundScheduler(logger=sched_logger, timezone=tz)
scheduler.add_job(notify.task, 'interval', seconds=config.SCAN_INTERVAL, max_instances=1,
start_date=datetime.datetime.now(tz) + datetime.timedelta(seconds=2))
scheduler.start()
sched = scheduler
def nameserver_check_scheduler(heartbeat_obj):
""" Schedule the check using the heartbeat object """
sched = BackgroundScheduler()
sched.start()
sched.add_job(heartbeat_obj.nameserver_check,
'cron',
second=("*/%s" % int(heartbeat_obj.configuration['heartbeat']['default']['interval'])))
retries_check = int(heartbeat_obj.configuration['heartbeat']['default']['init_retries'])
retry_wait = int(10)
while(retries_check != 0):
try:
heartbeat_obj.nameservers.next()
except StopIteration:
pretty_log("Heartbeat scheduler not initialized yet... Will retry %s times..." % retries_check)
pretty_log("Will retry in %s seconds" % retry_wait)
retries_check -= 1
sleep(retry_wait)
else:
pretty_log("Heartbeat scheduler initalized...")
return True
else:
pretty_log("Heartbeat scheduler error!")
return False
def initialize():
"""Setting a schedule for the background process"""
with app.app_context():
print("Scheduling...")
apsched = BackgroundScheduler()
apsched.add_job(run_check, 'interval', seconds=60)
apsched.start()
def getScheduler():
"getScheduler constructs and returns a scheduler object"
#Define default background scheduler
scheduler = BackgroundScheduler()
#Define ownerJob to be scheduled
def ownerJob():
"ownerJob updates the active_owners file with owner information"
#Get current list of owners
data = DevicesAttached().getActiveOwners()
#Obtain local time and
timeStruct = time.localtime()
[year,month,day,hour,minute,second,weekDay,yearDay,isDes] = timeStruct
data["timestamp"] = "{:02d}:{:02d}:{:02d}".format(hour,minute,second)
#Save file with date name
filename = "active_owners_{:02d}_{:02d}_{:02d}.csv".format(day,month,year)
saveRow(filename,data)
#If end of a day upload log to dropbox
if ((hour == 23) and (minute > 57)):
try:
DropboxAPI().saveFile(filename)
except Exception as exception:
print str(exception)
ownerJob()
scheduler.add_job(ownerJob,'interval',minutes=2,id="owner-job")
return scheduler
class TestPySpout(basesinfonierspout.BaseSinfonierSpout):
def __init__(self):
basesinfonierspout.BaseSinfonierSpout().__init__()
def useropen(self):
# Using deque as a queue
self.queue = deque()
self.frequency = int(self.getParam("frequency"))
# This scheduler launches self.job function every X seconds
self.sched = BackgroundScheduler()
self.sched.add_job(self.job, "interval", seconds=self.frequency, id="testpy")
self.sched.start()
def usernextTuple(self):
# If there are items in self.queue, get the first one (.popleft()), do what you want with it and emit the tuple
if self.queue:
self.addField("timestamp",self.queue.popleft())
self.emit()
def userclose(self):
pass
def job(self):
self.queue.append(str(int(time.time())))
def configure_scheduler_from_config(settings):
scheduler = BackgroundScheduler()
scheduler.start()
# run `purge_account` job at 0:00
scheduler.add_job(
purge_account,
id='purge_account',
name='Purge accounts which where not activated',
trigger='cron',
hour=0,
minute=0
)
# run `purge_token` job at 0:30
scheduler.add_job(
purge_token,
id='purge_token',
name='Purge expired tokens',
trigger='cron',
hour=0,
minute=30
)
scheduler.add_listener(exception_listener, EVENT_JOB_ERROR)
atexit.register(lambda: scheduler.shutdown())
class Processor:
def like_wall(self):
print "Will like a wall!"
try:
news = self.user.get_news(random.randint(10,100))
print "News: ", len(news)
for n in news:
likes = n.get("likes",None)
if likes and likes["user_likes"] == 0 and likes["can_like"] == 1:
print "LIKE", n["post_id"]
self.user.like_post(n["post_id"],n["source_id"])
print "Sleeep"
time.sleep(random.uniform(0, 5))
print "Done"
except:
print "Error in like"
pass
def __init__(self , user):
self.user = user
self.shced = BackgroundScheduler()
self.shced.add_job(self.like_wall, "interval", seconds=60);
self.shced.start()
def process_message(self, message, chatid, userid):
return;
def initialize():
Database.initialize()
session['email'] = session.get('email')
session['name'] = session.get('name')
scheduler = BackgroundScheduler()
scheduler.add_job(check_alert, "cron", day_of_week="0-4", hour="16", minute=30)
scheduler.start()
def __init__(self,interval=2):
global se_scheduler
se_scheduler = BackgroundScheduler()
se_scheduler.add_jobstore("mongodb", database="felix_se",
collection="ScheduledJobs")
se_scheduler.start()
super(SESchedulerService, self).__init__("SESchedulerService",interval)
self.first_time = True
def interval():
"""
Setup the scheduler.
"""
scheduler = BackgroundScheduler()
scheduler.add_job(tick, 'interval', seconds=10)
scheduler.start()
print('Scheduler Started')
def test_aps_eventlet():
def showMessage():
print "Show this message"
sh = BackgroundScheduler()
sh.start()
sh.add_job(showMessage, 'interval', seconds=2, timezone=utc)
time.sleep(10)
def setup_tasks(self):
scheduler = BackgroundScheduler()
def remove_dead_inbound_connections():
self.remove_dead_inbound_connections()
scheduler.add_job(remove_dead_inbound_connections, CronTrigger(second='*/15'))
scheduler.start()
def run_timer():
global RUNNING_TIMER
if not RUNNING_TIMER:
RUNNING_TIMER = True
# 30分钟同步一次文章点击率
scheduler = BackgroundScheduler()
scheduler.add_job(sync_click, 'interval', minutes=30)
scheduler.start()
def set_scheduler_initial():
print(' -------------- SETTING INITiAL SCHEDULER ---------------------')
global scheduler
scheduler = BackgroundScheduler()
scheduler.start()
log.info(os.environ.get('SCHEDULER_HOUR'))
log.info(os.environ.get('SCHEDULER_MIN'))
set_scheduler(os.environ.get('SCHEDULER_HOUR'), os.environ.get('SCHEDULER_MIN'))
class scheduler(object):
def __init__(self):
logging.basicConfig()
self.sched = BackgroundScheduler()
self.sched.start()
def addjob(self, function, time, arguments):
print "in addjob"
self.sched.add_job(function, 'date', run_date=time, args= arguments)
class Pokeradar():
def __init__(self):
self.api = PGoApi()
self.scheduler = BackgroundScheduler()
self.logged_in = False
self.nearby_pokemon = None
self.latitude = None
self.longitude = None
with open(os.path.join(os.path.dirname(__file__), 'data/pokemon.json')) as f:
self.pokemon_names = json.load(f)
def login(self, form_data):
username = form_data['username']
password = form_data['password']
latitude = form_data['latitude']
longitude = form_data['longitude']
if not self.logged_in:
if not self.api.login('ptc', username, password):
return 'Login failed (either servers are down or invalid credentials).', 401
self.latitude = float(latitude)
self.longitude = float(longitude)
self.api.set_position(self.latitude, self.longitude, 0)
self.api.get_player()
if self.api.call() == False:
logging.warning("Pokémon GO servers are currently down.")
return 'Pokémon GO servers are currently down. Try again later.', 502
self.scheduler.start()
self.scheduler.add_job(self.update_nearby, 'interval', seconds=30)
self.logged_in = True
return 'Success!', 200
def update_nearby(self):
pokemon = find_nearby_pokemon(self.api, self.latitude, self.longitude)
self.nearby_pokemon = []
for key, poke in pokemon.items():
dex_num = int(poke['pokemon_data']['pokemon_id'])
name = self.pokemon_names[format(dex_num, '03')]
time_til_hidden = poke['time_till_hidden_ms'] // 1000
distance = poke['distance']
if time_til_hidden > 0 and distance < 200:
p = [dex_num, name, time_til_hidden, distance]
self.nearby_pokemon.append(p)
self.nearby_pokemon.sort(key=lambda x: x[2], reverse=True)
def timer():
global scheduler
global job
if scheduler is not None:
job = scheduler.add_job(watering_task,'interval',hours=INTERVAL_BETWN_WATER_HR)
else:
scheduler = BackgroundScheduler()
job = scheduler.add_job(watering_task,'interval',hours=INTERVAL_BETWN_WATER_HR)
scheduler.start()
return 'ok'
class Scheduler_publish(object):
def __init__(self):
self.run_date = datetime.datetime.now() + datetime.timedelta(seconds=3)
self.run_date = self.run_date.strftime('%Y-%m-%d %H:%M:%S')
self.tm = time.strftime('%Y%m%d%H%M',time.localtime())
self.scheduler = BackgroundScheduler({'apscheduler.job_defaults.max_instances': '5'})
self.scheduler.configure(timezone=pytz.timezone('Asia/Shanghai'))
def Scheduler_mem(self,func,publish_key = 'None',taskKey = 'None'):
self.scheduler.add_job(func,'date', run_date=self.run_date,args=[publish_key,taskKey],id='%s_%s'%(taskKey,self.tm),replace_existing=False)
return self.scheduler
def post(self, action, position = ''):
global scheduler
self.checkStartup()
if action == 'play':
runCommand('mpc play ' + position)
#Settings.set('radio', 'state', 'play')
if scheduler is None:
scheduler = BackgroundScheduler()
scheduler.add_job(self.checkStatus, 'interval', seconds=30, id='checkStatus', replace_existing=True)
scheduler.start()
elif action == 'stop':
runCommand('mpc stop')
#Settings.set('radio', 'state', 'stop')
if scheduler is not None:
scheduler.remove_job('checkStatus')
scheduler.shutdown()
scheduler = None
return {'playMode': 'stopped'}
elif action =='pause':
runCommand('mpc pause')
elif action =='next':
runCommand('mpc next')
elif action =='previous':
runCommand('mpc prev')
else:
return {'playMode': 'invalid'}
(out, err) = runCommand('mpc status')
if err:
return {'error', err}, 500
return {'playMode': Parser.parsePlayMode(out)}
class Core(object):
def __init__(self):
self.started = False
# process id
self.PID = os.getpid()
# generate notifiers dict
self.notifiersDict = notifiersDict()
# generate metadata providers dict
self.metadataProvidersDict = metadataProvidersDict()
# generate providers dict
self.providersDict = providersDict()
# init notification queue
self.srNotifications = Notifications()
# init logger
self.srLogger = srLogger()
# init config
self.srConfig = srConfig()
# init databases
self.mainDB = MainDB()
self.cacheDB = CacheDB()
self.failedDB = FailedDB()
# init scheduler service
self.srScheduler = BackgroundScheduler()
# init web server
self.srWebServer = srWebServer()
# init web client session
self.srWebSession = srSession()
# google api
self.googleAuth = googleAuth()
# name cache
self.NAMECACHE = srNameCache()
# queues
self.SHOWQUEUE = srShowQueue()
self.SEARCHQUEUE = srSearchQueue()
# updaters
self.VERSIONUPDATER = srVersionUpdater()
self.SHOWUPDATER = srShowUpdater()
# searchers
self.DAILYSEARCHER = srDailySearcher()
self.BACKLOGSEARCHER = srBacklogSearcher()
self.PROPERSEARCHER = srProperSearcher()
self.TRAKTSEARCHER = srTraktSearcher()
self.SUBTITLESEARCHER = srSubtitleSearcher()
# auto postprocessor
self.AUTOPOSTPROCESSOR = srPostProcessor()
# sickrage version
self.NEWEST_VERSION = None
self.NEWEST_VERSION_STRING = None
# anidb connection
self.ADBA_CONNECTION = None
# show list
self.SHOWLIST = []
self.USER_AGENT = 'SiCKRAGE.CE.1/({};{};{})'.format(
platform.system(), platform.release(), str(uuid.uuid1()))
self.SYS_ENCODING = get_sys_encoding()
# patch modules with encoding kludge
patch_modules()
def start(self):
self.started = True
# thread name
threading.currentThread().setName('CORE')
# Check if we need to perform a restore first
if os.path.exists(
os.path.abspath(os.path.join(sickrage.DATA_DIR, 'restore'))):
success = restoreSR(
os.path.abspath(os.path.join(sickrage.DATA_DIR, 'restore')),
sickrage.DATA_DIR)
print("Restoring SiCKRAGE backup: %s!\n" %
("FAILED", "SUCCESSFUL")[success])
if success:
shutil.rmtree(os.path.abspath(
os.path.join(sickrage.DATA_DIR, 'restore')),
ignore_errors=True)
# migrate old database file names to new ones
if os.path.isfile(
os.path.abspath(os.path.join(sickrage.DATA_DIR,
'sickbeard.db'))):
if os.path.isfile(os.path.join(sickrage.DATA_DIR, 'sickrage.db')):
helpers.moveFile(
os.path.join(sickrage.DATA_DIR, 'sickrage.db'),
os.path.join(
sickrage.DATA_DIR, '{}.bak-{}'.format(
'sickrage.db',
datetime.datetime.now().strftime(
'%Y%m%d_%H%M%S'))))
helpers.moveFile(
os.path.abspath(os.path.join(sickrage.DATA_DIR,
'sickbeard.db')),
os.path.abspath(os.path.join(sickrage.DATA_DIR,
'sickrage.db')))
# load config
self.srConfig.load()
# set socket timeout
socket.setdefaulttimeout(self.srConfig.SOCKET_TIMEOUT)
# setup logger settings
self.srLogger.logSize = self.srConfig.LOG_SIZE
self.srLogger.logNr = self.srConfig.LOG_NR
self.srLogger.logFile = self.srConfig.LOG_FILE
self.srLogger.debugLogging = self.srConfig.DEBUG
self.srLogger.consoleLogging = not sickrage.QUITE
# start logger
self.srLogger.start()
# user agent
if self.srConfig.RANDOM_USER_AGENT:
self.USER_AGENT = UserAgent().random
urlparse.uses_netloc.append('scgi')
urllib.FancyURLopener.version = self.USER_AGENT
# Check available space
try:
total_space, available_space = getFreeSpace(sickrage.DATA_DIR)
if available_space < 100:
self.srLogger.error(
'Shutting down as SiCKRAGE needs some space to work. You\'ll get corrupted data otherwise. Only %sMB left',
available_space)
return
except:
self.srLogger.error('Failed getting diskspace: %s',
traceback.format_exc())
# perform database startup actions
for db in [self.mainDB, self.cacheDB, self.failedDB]:
# initialize database
db.initialize()
# check integrity of database
db.check_integrity()
# migrate database
db.migrate()
# misc database cleanups
db.cleanup()
# compact main database
if not self.srConfig.DEVELOPER and self.srConfig.LAST_DB_COMPACT < time.time(
) - 604800: # 7 days
self.mainDB.compact()
self.srConfig.LAST_DB_COMPACT = int(time.time())
# load name cache
self.NAMECACHE.load()
# load data for shows from database
self.load_shows()
if self.srConfig.DEFAULT_PAGE not in ('home', 'schedule', 'history',
'news', 'IRC'):
self.srConfig.DEFAULT_PAGE = 'home'
# cleanup cache folder
for folder in ['mako', 'sessions', 'indexers']:
try:
shutil.rmtree(os.path.join(sickrage.CACHE_DIR, folder),
ignore_errors=True)
except Exception:
continue
# init anidb connection
if self.srConfig.USE_ANIDB:
def anidb_logger(msg):
return self.srLogger.debug("AniDB: {} ".format(msg))
try:
self.ADBA_CONNECTION = adba.Connection(keepAlive=True,
log=anidb_logger)
self.ADBA_CONNECTION.auth(self.srConfig.ANIDB_USERNAME,
self.srConfig.ANIDB_PASSWORD)
except Exception as e:
self.srLogger.warning("AniDB exception msg: %r " % repr(e))
if self.srConfig.WEB_PORT < 21 or self.srConfig.WEB_PORT > 65535:
self.srConfig.WEB_PORT = 8081
if not self.srConfig.WEB_COOKIE_SECRET:
self.srConfig.WEB_COOKIE_SECRET = generateCookieSecret()
# attempt to help prevent users from breaking links by using a bad url
if not self.srConfig.ANON_REDIRECT.endswith('?'):
self.srConfig.ANON_REDIRECT = ''
if not re.match(r'\d+\|[^|]+(?:\|[^|]+)*', self.srConfig.ROOT_DIRS):
self.srConfig.ROOT_DIRS = ''
self.srConfig.NAMING_FORCE_FOLDERS = check_force_season_folders()
if self.srConfig.NZB_METHOD not in ('blackhole', 'sabnzbd', 'nzbget'):
self.srConfig.NZB_METHOD = 'blackhole'
if self.srConfig.TORRENT_METHOD not in ('blackhole', 'utorrent',
'transmission', 'deluge',
'deluged', 'download_station',
'rtorrent', 'qbittorrent',
'mlnet', 'putio'):
self.srConfig.TORRENT_METHOD = 'blackhole'
if self.srConfig.PROPER_SEARCHER_INTERVAL not in ('15m', '45m', '90m',
'4h', 'daily'):
self.srConfig.PROPER_SEARCHER_INTERVAL = 'daily'
if self.srConfig.AUTOPOSTPROCESSOR_FREQ < self.srConfig.MIN_AUTOPOSTPROCESSOR_FREQ:
self.srConfig.AUTOPOSTPROCESSOR_FREQ = self.srConfig.MIN_AUTOPOSTPROCESSOR_FREQ
if self.srConfig.NAMECACHE_FREQ < self.srConfig.MIN_NAMECACHE_FREQ:
self.srConfig.NAMECACHE_FREQ = self.srConfig.MIN_NAMECACHE_FREQ
if self.srConfig.DAILY_SEARCHER_FREQ < self.srConfig.MIN_DAILY_SEARCHER_FREQ:
self.srConfig.DAILY_SEARCHER_FREQ = self.srConfig.MIN_DAILY_SEARCHER_FREQ
self.srConfig.MIN_BACKLOG_SEARCHER_FREQ = self.BACKLOGSEARCHER.get_backlog_cycle_time(
)
if self.srConfig.BACKLOG_SEARCHER_FREQ < self.srConfig.MIN_BACKLOG_SEARCHER_FREQ:
self.srConfig.BACKLOG_SEARCHER_FREQ = self.srConfig.MIN_BACKLOG_SEARCHER_FREQ
if self.srConfig.VERSION_UPDATER_FREQ < self.srConfig.MIN_VERSION_UPDATER_FREQ:
self.srConfig.VERSION_UPDATER_FREQ = self.srConfig.MIN_VERSION_UPDATER_FREQ
if self.srConfig.SHOWUPDATE_HOUR > 23:
self.srConfig.SHOWUPDATE_HOUR = 0
elif self.srConfig.SHOWUPDATE_HOUR < 0:
self.srConfig.SHOWUPDATE_HOUR = 0
if self.srConfig.SUBTITLE_SEARCHER_FREQ < self.srConfig.MIN_SUBTITLE_SEARCHER_FREQ:
self.srConfig.SUBTITLE_SEARCHER_FREQ = self.srConfig.MIN_SUBTITLE_SEARCHER_FREQ
if self.srConfig.SUBTITLES_LANGUAGES[0] == '':
self.srConfig.SUBTITLES_LANGUAGES = []
# add version checker job
self.srScheduler.add_job(
self.VERSIONUPDATER.run,
srIntervalTrigger(
**{
'hours': self.srConfig.VERSION_UPDATER_FREQ,
'min': self.srConfig.MIN_VERSION_UPDATER_FREQ
}),
name="VERSIONUPDATER",
id="VERSIONUPDATER")
# add network timezones updater job
self.srScheduler.add_job(update_network_dict,
srIntervalTrigger(**{'days': 1}),
name="TZUPDATER",
id="TZUPDATER")
# add show updater job
self.srScheduler.add_job(
self.SHOWUPDATER.run,
srIntervalTrigger(
**{
'days':
1,
'start_date':
datetime.datetime.now().replace(
hour=self.srConfig.SHOWUPDATE_HOUR)
}),
name="SHOWUPDATER",
id="SHOWUPDATER")
# add show next episode job
self.srScheduler.add_job(self.SHOWUPDATER.nextEpisode,
srIntervalTrigger(**{'hours': 1}),
name="SHOWNEXTEP",
id="SHOWNEXTEP")
# add daily search job
self.srScheduler.add_job(self.DAILYSEARCHER.run,
srIntervalTrigger(
**{
'minutes':
self.srConfig.DAILY_SEARCHER_FREQ,
'min':
self.srConfig.MIN_DAILY_SEARCHER_FREQ,
'start_date':
datetime.datetime.now() +
datetime.timedelta(minutes=4)
}),
name="DAILYSEARCHER",
id="DAILYSEARCHER")
# add backlog search job
self.srScheduler.add_job(
self.BACKLOGSEARCHER.run,
srIntervalTrigger(
**{
'minutes':
self.srConfig.BACKLOG_SEARCHER_FREQ,
'min':
self.srConfig.MIN_BACKLOG_SEARCHER_FREQ,
'start_date':
datetime.datetime.now() + datetime.timedelta(minutes=30)
}),
name="BACKLOG",
id="BACKLOG")
# add auto-postprocessing job
self.srScheduler.add_job(
self.AUTOPOSTPROCESSOR.run,
srIntervalTrigger(
**{
'minutes': self.srConfig.AUTOPOSTPROCESSOR_FREQ,
'min': self.srConfig.MIN_AUTOPOSTPROCESSOR_FREQ
}),
name="POSTPROCESSOR",
id="POSTPROCESSOR")
# add find proper job
self.srScheduler.add_job(
self.PROPERSEARCHER.run,
srIntervalTrigger(
**{
'minutes': {
'15m': 15,
'45m': 45,
'90m': 90,
'4h': 4 * 60,
'daily': 24 * 60
}[self.srConfig.PROPER_SEARCHER_INTERVAL]
}),
name="PROPERSEARCHER",
id="PROPERSEARCHER")
# add trakt.tv checker job
self.srScheduler.add_job(self.TRAKTSEARCHER.run,
srIntervalTrigger(**{'hours': 1}),
name="TRAKTSEARCHER",
id="TRAKTSEARCHER")
# add subtitles finder job
self.srScheduler.add_job(
self.SUBTITLESEARCHER.run,
srIntervalTrigger(
**{'hours': self.srConfig.SUBTITLE_SEARCHER_FREQ}),
name="SUBTITLESEARCHER",
id="SUBTITLESEARCHER")
# start scheduler service
self.srScheduler.start()
# Pause/Resume PROPERSEARCHER job
(self.srScheduler.get_job('PROPERSEARCHER').pause,
self.srScheduler.get_job('PROPERSEARCHER').resume
)[self.srConfig.DOWNLOAD_PROPERS]()
# Pause/Resume TRAKTSEARCHER job
(self.srScheduler.get_job('TRAKTSEARCHER').pause,
self.srScheduler.get_job('TRAKTSEARCHER').resume
)[self.srConfig.USE_TRAKT]()
# Pause/Resume SUBTITLESEARCHER job
(self.srScheduler.get_job('SUBTITLESEARCHER').pause,
self.srScheduler.get_job('SUBTITLESEARCHER').resume
)[self.srConfig.USE_SUBTITLES]()
# Pause/Resume POSTPROCESS job
(self.srScheduler.get_job('POSTPROCESSOR').pause,
self.srScheduler.get_job('POSTPROCESSOR').resume
)[self.srConfig.PROCESS_AUTOMATICALLY]()
# start queue's
self.SEARCHQUEUE.start()
self.SHOWQUEUE.start()
# start webserver
self.srWebServer.start()
def shutdown(self, restart=False):
if self.started:
self.srLogger.info('SiCKRAGE IS SHUTTING DOWN!!!')
# shutdown webserver
self.srWebServer.shutdown()
# shutdown show queue
if self.srScheduler:
self.srLogger.debug("Shutting down scheduler")
self.srScheduler.shutdown()
# shutdown show queue
if self.SHOWQUEUE:
self.srLogger.debug("Shutting down show queue")
self.SHOWQUEUE.shutdown()
del self.SHOWQUEUE
# shutdown search queue
if self.SEARCHQUEUE:
self.srLogger.debug("Shutting down search queue")
self.SEARCHQUEUE.shutdown()
del self.SEARCHQUEUE
# log out of ADBA
if self.ADBA_CONNECTION:
self.srLogger.debug("Shutting down ANIDB connection")
self.ADBA_CONNECTION.stop()
# save all show and config settings
self.save_all()
# close databases
for db in [self.mainDB, self.cacheDB, self.failedDB]:
if db.opened:
self.srLogger.debug(
"Shutting down {} database connection".format(db.name))
db.close()
# shutdown logging
self.srLogger.close()
if restart:
os.execl(sys.executable, sys.executable, *sys.argv)
elif sickrage.daemon:
sickrage.daemon.stop()
self.started = False
def save_all(self):
# write all shows
self.srLogger.info("Saving all shows to the database")
for SHOW in self.SHOWLIST:
try:
SHOW.saveToDB()
except:
continue
# save config
self.srConfig.save()
def load_shows(self):
"""
Populates the showlist with shows from the database
"""
for dbData in [
x['doc'] for x in self.mainDB.db.all('tv_shows', with_doc=True)
]:
try:
self.srLogger.debug("Loading data for show: [%s]",
dbData['show_name'])
show = TVShow(int(dbData['indexer']),
int(dbData['indexer_id']))
show.nextEpisode()
self.NAMECACHE.build(show)
self.SHOWLIST += [show]
except Exception as e:
self.srLogger.error("Show error in [%s]: %s" %
(dbData['location'], e.message))
class BountyCollector(base_agent.BaseAgent):
def __init__(self, skale, node_id=None):
super().__init__(skale, node_id)
self.logger.info('Start checking logs on blockchain')
start = time.time()
try:
pass
self.collect_last_bounty_logs()
except Exception as err:
self.logger.error(
f'Error occurred while checking logs from blockchain: {err} ')
end = time.time()
self.logger.info(f'Check completed. Execution time = {end - start}')
self.scheduler = BackgroundScheduler(timezone='UTC',
job_defaults={
'coalesce':
True,
'misfire_grace_time':
MISFIRE_GRACE_TIME
})
def get_reward_date(self):
reward_period = self.skale.constants_holder.get_reward_period()
reward_date = self.skale.nodes_data.get(
self.id)['last_reward_date'] + reward_period
return datetime.utcfromtimestamp(reward_date) + timedelta(
seconds=REWARD_DELAY)
def collect_last_bounty_logs(self):
start_date = datetime.utcfromtimestamp(
self.skale.nodes_data.get(self.id)['start_date'])
last_block_number_in_db = db.get_bounty_max_block_number()
if last_block_number_in_db is None:
start_block_number = find_block_for_tx_stamp(
self.skale, start_date)
else:
start_block_number = last_block_number_in_db + 1
count = 0
while True:
last_block_number = self.skale.web3.eth.blockNumber
self.logger.debug(f'last block = {last_block_number}')
end_chunk_block_number = start_block_number + BLOCK_STEP_SIZE - 1
if end_chunk_block_number > last_block_number:
end_chunk_block_number = last_block_number + 1
event_filter = self.skale.manager.contract.events.BountyGot.createFilter(
argument_filters={'nodeIndex': self.id},
fromBlock=hex(start_block_number),
toBlock=hex(end_chunk_block_number))
logs = event_filter.get_all_entries()
for log in logs:
args = log['args']
tx_block_number = log['blockNumber']
block_data = self.skale.web3.eth.getBlock(tx_block_number)
block_timestamp = datetime.utcfromtimestamp(
block_data['timestamp'])
self.logger.debug(log)
tx_hash = log['transactionHash'].hex()
gas_used = self.skale.web3.eth.getTransactionReceipt(
tx_hash)['gasUsed']
db.save_bounty_event(block_timestamp, tx_hash,
log['blockNumber'], args['nodeIndex'],
args['bounty'], args['averageDowntime'],
args['averageLatency'], gas_used)
count += 1
self.logger.debug(f'count = {count}')
start_block_number = start_block_number + BLOCK_STEP_SIZE
if end_chunk_block_number >= last_block_number:
break
def get_bounty(self):
address = self.skale.wallet.address
eth_bal_before = self.skale.web3.eth.getBalance(address)
skl_bal_before = self.skale.token.get_balance(address)
self.logger.info(f'ETH balance before: {eth_bal_before}')
self.logger.info('--- Getting Bounty ---')
try:
self.skale.manager.get_bounty(self.id, dry_run=True)
except ValueError as err:
self.logger.info(f'Tx call failed: {err}')
raise TxCallFailedException
tx_res = self.skale.manager.get_bounty(self.id, wait_for=True)
tx_res.raise_for_status()
tx_hash = tx_res.receipt['transactionHash'].hex()
self.logger.info(LONG_DOUBLE_LINE)
self.logger.info('The bounty was successfully received')
self.logger.info(f'tx hash: {tx_hash}')
self.logger.debug(f'Receipt: {tx_res.receipt}')
eth_bal = self.skale.web3.eth.getBalance(address)
skl_bal = self.skale.token.get_balance(address)
self.logger.info(f'ETH balance after: {eth_bal}')
self.logger.info(f'ETH difference: {eth_bal - eth_bal_before}')
try:
db.save_bounty_stats(tx_hash, eth_bal_before, skl_bal_before,
eth_bal, skl_bal)
except Exception as err:
self.logger.error(f'Cannot save getBounty stats. Error: {err}')
h_receipt = self.skale.manager.contract.events.BountyGot(
).processReceipt(tx_res.receipt, errors=DISCARD)
self.logger.info(LONG_LINE)
self.logger.info(h_receipt)
args = h_receipt[0]['args']
try:
db.save_bounty_event(datetime.utcfromtimestamp(args['time']),
str(tx_hash), tx_res.receipt['blockNumber'],
args['nodeIndex'], args['bounty'],
args['averageDowntime'],
args['averageLatency'],
tx_res.receipt['gasUsed'])
except Exception as err:
self.logger.error(f'Cannot save getBounty event. Error: {err}')
return tx_res.receipt['status']
@tenacity.retry(wait=tenacity.wait_fixed(60),
retry=tenacity.retry_if_exception_type(IsNotTimeException)
| tenacity.retry_if_exception_type(TxCallFailedException))
def job(self) -> None:
""" Periodic job"""
self.logger.info(f'Job started')
try:
reward_date = self.get_reward_date()
except Exception as err:
self.logger.error(f'Cannot get reward date: {err}')
# TODO: notify Skale Admin
raise
last_block_number = self.skale.web3.eth.blockNumber
block_data = self.skale.web3.eth.getBlock(last_block_number)
block_timestamp = datetime.utcfromtimestamp(block_data['timestamp'])
self.logger.info(f'Reward date: {reward_date}')
self.logger.info(f'Timestamp: {block_timestamp}')
if reward_date > block_timestamp:
self.logger.info(
'Current block timestamp is less than reward time. Will try in 1 min'
)
raise IsNotTimeException(Exception)
self.get_bounty()
def job_listener(self, event):
if event.exception:
self.logger.info('The job failed')
utc_now = datetime.utcnow()
self.scheduler.add_job(self.job,
'date',
run_date=utc_now + timedelta(seconds=60))
self.logger.debug(self.scheduler.get_jobs())
else:
self.logger.debug('The job finished successfully)')
reward_date = self.get_reward_date()
self.logger.debug(f'Reward date after job: {reward_date}')
utc_now = datetime.utcnow()
if utc_now > reward_date:
self.logger.debug('Changing reward date for now')
reward_date = utc_now
self.scheduler.add_job(self.job, 'date', run_date=reward_date)
self.scheduler.print_jobs()
def run(self) -> None:
"""Starts agent"""
self.logger.debug(f'{self.agent_name} started')
reward_date = self.get_reward_date()
self.logger.debug(f'Reward date on agent\'s start: {reward_date}')
utc_now = datetime.utcnow()
if utc_now > reward_date:
reward_date = utc_now
self.scheduler.add_job(self.job, 'date', run_date=reward_date)
self.scheduler.print_jobs()
self.scheduler.add_listener(self.job_listener,
EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
self.scheduler.start()
while True:
time.sleep(1)
pass
import atexit
import logging
RELAY_SUNSCREEN = [17, 18, 27, 22]
RELAY_MOTOR_POWER = 25
RELAY_MOTOR_OVERLOAD = 8
MOTOR_1 = 23
MOTOR_2 = 24
# Motor speed 0 (off) to 255 (max speed)
currentMotorSpeed = 0
timestamp_motor_power = 0
status_motor_power = GPIO.LOW
sched = BackgroundScheduler() #daemon=True
# create a pigpio object, that accesses the pigpiod deamon (which handles the PWM to the motors)
# to start the daemon: sudo pigpiod
pi = pigpio.pi()
def control(screen_id, movement, percentage, ms=5000.0):
ensure_motor_power()
ss = [screen_id]
if (screen_id == 0):
ss = [1, 2, 3, 4]
print("relais ", ss, " on ")
for s in ss:
GPIO.output(RELAY_SUNSCREEN[s - 1], GPIO.LOW)
time.sleep(1)
class CardLiveDataManager:
INSTANCE = None
def __init__(self, cardlive_home: Path):
ncbi_db_path = cardlive_home / 'db' / 'taxa.sqlite'
card_live_data_dir = cardlive_home / 'data' / 'card_live'
self._data_loader = CardLiveDataLoader(card_live_data_dir)
self._data_loader.add_data_modifiers([
AntarcticaNAModifier(np.datetime64('2020-07-20')),
AddGeographicNamesModifier(region_codes),
AddTaxonomyModifier(ncbi_db_path),
])
self._card_live_data = self._data_loader.read_or_update_data()
self._scheduler = BackgroundScheduler(
jobstores={'default': MemoryJobStore()},
executors={'default': ThreadPoolExecutor(1)},
job_defaults={'max_instances': 1})
self._scheduler.add_job(self.update_job, 'interval', minutes=10)
self._scheduler.start()
def update_job(self):
logger.debug('Updating CARD:Live data.')
try:
new_data = self._data_loader.read_or_update_data(
self._card_live_data)
if new_data is not self._card_live_data:
logger.debug(
f'Old data has {len(self._card_live_data)} samples, new data has {len(new_data)} samples'
)
self._card_live_data = new_data
except Exception as e:
logger.info(
'An exeption occured when attempting to load new data. Skipping new data.'
)
logger.exception(e)
logger.debug('Finished updating CARD:Live data.')
def data_archive_generator(
self,
file_names: Union[List[str], Set[str]] = None
) -> Generator[bytes, None, None]:
"""
Get the CARD:Live JSON files as a zipstream generator.
:param file_names: The file names to load into the archive.
:return: A generator which allows streaming of the zip file contents.
"""
if file_names is None:
file_names = self.card_data.files()
return self._data_loader.data_archive_generator(file_names)
@property
def card_data(self) -> CardLiveData:
return self._card_live_data
@classmethod
def create_instance(cls, cardlive_home: Path) -> None:
cls.INSTANCE = CardLiveDataManager(cardlive_home)
@classmethod
def get_instance(cls) -> CardLiveDataManager:
if cls.INSTANCE is not None:
return cls.INSTANCE
else:
raise Exception(f'{cls} does not yet have an instance.')
witness = rpc.get_witness_by_account(user)
pprint(witness)
for key in ['last_mbd_exchange_update']:
witness[key] = datetime.strptime(witness[key], "%Y-%m-%dT%H:%M:%S")
# Convert to Numbers
for key in ['votes', 'total_missed']:
witness[key] = float(witness[key])
witness.update({'account': user})
db.witness.update({'_id': user}, {'$set': witness}, upsert=True)
def run():
update_witnesses()
# check_misses()
if __name__ == '__main__':
# Start job immediately
run()
# Schedule it to run every 1 minute
scheduler = BackgroundScheduler()
scheduler.add_job(run, 'interval', minutes=1, id='run')
scheduler.start()
# Loop
try:
while True:
sys.stdout.flush()
time.sleep(2)
except (KeyboardInterrupt, SystemExit):
scheduler.shutdown()
PROG_DIR = None FULL_PATH = None ARGS = None SIGNAL = None SYS_PLATFORM = None SYS_ENCODING = None QUIET = False VERBOSE = True DAEMON = False CREATEPID = False PIDFILE = None SCHED = BackgroundScheduler() SCHED_LOCK = threading.Lock() INIT_LOCK = threading.Lock() _INITIALIZED = False started = False DATA_DIR = None CONFIG = None CONFIG_FILE = None DB_FILE = None LOG_LIST = []
# the task may not exist if sent using `send_task` which
# sends tasks by name, so fall back to the default result backend
# if that is the case.
task = celery.tasks.get(sender)
backend = task.backend if task else celery.backend
backend.store_result(headers['id'], None, 'WAITING')
# register celery tasks. removing them will cause the tasks to not function. so don't remove them
# it is important to register them after celery is defined to resolve circular imports
from .api.helpers import tasks
# import helpers.tasks
scheduler = BackgroundScheduler(timezone=utc)
# scheduler.add_job(send_mail_to_expired_orders, 'interval', hours=5)
# scheduler.add_job(empty_trash, 'cron', hour=5, minute=30)
if app.config['ENABLE_ELASTICSEARCH']:
scheduler.add_job(sync_events_elasticsearch, 'interval', minutes=60)
scheduler.add_job(cron_rebuild_events_elasticsearch, 'cron', day=7)
scheduler.add_job(send_after_event_mail, 'cron', hour=5, minute=30)
scheduler.add_job(send_event_fee_notification, 'cron', day=1)
scheduler.add_job(send_event_fee_notification_followup, 'cron', day=15)
scheduler.add_job(change_session_state_on_event_completion,
'cron',
hour=5,
minute=30)
scheduler.add_job(expire_pending_tickets, 'cron', minute=45)
scheduler.add_job(send_monthly_event_invoice, 'cron', day=1, month='1-12')
from apscheduler.schedulers.background import BackgroundScheduler
import atexit
from flask import Flask
from flask_bootstrap import Bootstrap
from SpeedTester import SpeedTester
app = Flask(__name__)
Bootstrap(app)
speed_tester = SpeedTester()
scheduler = BackgroundScheduler()
scheduler.add_job(func=speed_tester.run_speed_test,
trigger="interval",
minutes=15)
scheduler.start()
# Shut down the scheduler when exiting the app
atexit.register(lambda: scheduler.shutdown())
# -*- coding: utf-8 -*-
import logging
import time
from apscheduler.schedulers.background import BackgroundScheduler
from zvt import init_log
from zvt.domain import *
from zvt.informer.informer import EmailInformer
logger = logging.getLogger(__name__)
sched = BackgroundScheduler()
@sched.scheduled_job('cron', hour=15, minute=30)
def run():
while True:
email_action = EmailInformer()
try:
Block.record_data(provider='sina')
BlockStock.record_data(provider='sina')
BlockMoneyFlow.record_data(provider='sina')
email_action.send_message("*****@*****.**", 'sina runner finished',
'')
break
except Exception as e:
msg = f'sina runner error:{e}'
logger.exception(msg)
import os
import logging
from flask import Flask
from flask_cors import CORS
from back import route
from back.main import main
from apscheduler.schedulers.background import BackgroundScheduler
logging.basicConfig(filename='log_app.log',
format='%(asctime)s %(message)s',
level=logging.DEBUG)
sched = BackgroundScheduler(daemon=True)
sched.add_job(main, 'interval', seconds=59)
sched.start()
template_dir = os.path.abspath('./front/templates')
app = Flask(__name__, template_folder=template_dir)
CORS(app)
logging.debug("the db is going to initialize")
main()
logging.debug("the db is initialize")
app.add_url_rule('/', view_func=route.entry_point)
app.add_url_rule('/hello_world', view_func=route.hello_world)
app.add_url_rule('/<ville>/stations/<station>', view_func=route.nexttram)
app.add_url_rule('/<ville>/stations/', view_func=route.citystations)
app.add_url_rule('/<ville>/ligne/<ligne>', view_func=route.line_station)
app.add_url_rule('/<ville>/<station>/<ligne>/<direction>',
view_func=route.next_to_direction)
app.add_url_rule('/<ville>/stationslike/<station>',
def run(self):
"""TODO: Docstring for run.
:returns: TODO
"""
SCHED = BackgroundScheduler()
ACCOUNT_TRIGGER = IntervalTrigger(seconds=3)
PID_TRIGGER = IntervalTrigger(seconds=5)
EIP_TRIGGER = IntervalTrigger(seconds=10)
FUNC_IAM = iam.Iam('/etc/.hwzabbix/config.ini')
FUNC_ACCOUNT = FUNC_IAM.account_to_redis
FUNC_PID = FUNC_IAM.pid_to_redis
FUNC_VPC = vpc.Vpc()
FUNC_EIP = FUNC_VPC.eip_to_redis
SCHED.add_job(func=FUNC_ACCOUNT, trigger=ACCOUNT_TRIGGER)
SCHED.add_job(func=FUNC_PID,
args=('cn-north-1', ),
trigger=PID_TRIGGER)
SCHED.add_job(func=FUNC_PID, args=('cn-east-2', ), trigger=PID_TRIGGER)
SCHED.add_job(func=FUNC_PID,
args=('cn-south-1', ),
trigger=PID_TRIGGER)
SCHED.add_job(func=FUNC_EIP,
args=('cn-north-1', ),
trigger=EIP_TRIGGER)
SCHED.add_job(func=FUNC_EIP, args=('cn-east-2', ), trigger=EIP_TRIGGER)
SCHED.add_job(func=FUNC_EIP,
args=('cn-south-1', ),
trigger=EIP_TRIGGER)
SCHED.start()
while True:
time.sleep(10)
log.logging.info('service is active.')
from module import Module
from task import ActiveTask
from apis import api_lib
from apscheduler.schedulers.background import BackgroundScheduler
import string
import random
import dateutil.parser as parser
from functions import jsonentities
from datetime import datetime
from pyowm.utils import timeutils
import json
import log
scheduler = BackgroundScheduler()
scheduler.start()
def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
def timer_function(id, text):
print(text)
scheduler.print_jobs()
api_lib['sql'].delete_item('timers', 'key', id)
print('Scheduled Timers Remaining..')
scheduler.print_jobs()
class Timers(ActiveTask):
def __init__(self):
template_mode='bootstrap3',
index_view=MyHomeView())
# config celery
celery = celery_module.make_celery(app)
# config logging
logging.basicConfig(level=logging.DEBUG)
# config jwt
jwt = JWTManager(app)
# config firebase
cred = credentials.Certificate(app.config['FIREBASE'])
default_app = firebase_admin.initialize_app(cred)
# config schedule
scheduler = BackgroundScheduler({'apscheduler.timezone': 'Asia/Ho_Chi_Minh'})
# import routes
from project.routes.v1 import *
# schedule init
from project.schedule import *
# start schedule
scheduler.start()
# Shut down the scheduler when exiting the app
atexit.register(lambda: scheduler.shutdown())
def sendMsgToskYpe(empName, skypeId):
try:
sk = Skype("*****@*****.**",
"Terafastnetworkspvtltd") # connect to Skype
sk.user
cont = sk.contacts
sk.chats
ch = sk.contacts[skypeId].chat
ch.sendMsg(
"Hi %s (cake) On your special day, I wish you good luck. I hope this wonderful day will fill up your heart with joy and blessings. Have a fantastic birthday, celebrate the happiness on every day of your life. Happy Birthday!! (sparkler) (flower) "
% empName)
ch.getMsgs()
except Exception as er:
print("[WARNING] SEND MESSAGE TO SKYPE EXCEPTION ERROR :: %s " % er)
scheduler = BackgroundScheduler()
scheduler.start()
job = scheduler.add_job(readDataFromExcelSheet,
'cron',
hour='12',
minute='25',
second='00')
print "Current job starting....."
while True:
time.sleep(45)
readDataFromExcelSheet()
from flask import Flask
from apscheduler.schedulers.background import BackgroundScheduler
from cryptomon.jobs import *
app = Flask(__name__)
app.config.from_mapping(
SECRET_KEY='dev'
)
app.config.from_pyfile('config.py', silent=True)
app.config.from_envvar('CRYPTOMON_SETTINGS', silent=True)
cron = BackgroundScheduler()
job_kwargs = {
'ether_scan_api_root': app.config['ETHER_SCAN_API_ROOT'],
'ether_scan_api_key': app.config['ETHER_SCAN_API_KEY'],
'check_threshold_min': app.config['CHECK_THRESHOLD_MIN'],
'check_threshold_max': app.config['CHECK_THRESHOLD_MAX'],
'mail_from': app.config['MAIL_FROM'],
'mail_to': app.config['MAIL_TO'],
'mail_server': app.config['MAIL_SERVER'],
'mail_user': app.config['MAIL_USER'],
'mail_pass': app.config['MAIL_PASS']
}
cron.add_job(last_price_alarm,
'interval',
kwargs=job_kwargs,
minutes=app.config['CHECK_LAST_PRICE_INTERVAL'])
# Establish session for retrieval of all balances
with requests.Session() as session:
balances = []
# Determine which tokens to load
targetTokens = tokens
# If a tokens array is specified in the request, use it
if 'tokens' in request:
targetTokens = []
for token in request.get('tokens'):
contract, symbol = token.split(':')
targetTokens.append((symbol, contract))
# Launch async event loop to gather balances
loop = asyncio.get_event_loop()
balances = loop.run_until_complete(
get_balances(request.get('account'), targetTokens))
# Server the response
resp.body = json.dumps(balances)
# Load the initial tokens on startup
get_tokens()
# Schedule tokens to be refreshed from smart contract every minute
scheduler = BackgroundScheduler()
scheduler.add_job(get_tokens, 'interval', minutes=1, id='get_tokens')
scheduler.start()
# Launch falcon API
app = falcon.API()
app.add_route('/v1/chain/get_currency_balances', GetCurrencyBalances())
class RateFetcher(object):
""" Fetches currency exchange rates from a URL (that is defined in a
configuration file). The new rates are stored in a file (JSON),
as well as kept in memory.
"""
def __init__(self):
self.settings = None
self.scheduler = BackgroundScheduler()
self.full_url = ""
self.rates_file_name = ""
self.rates = None
self.update_iterval_sec = 86400 # don't lower it
def apply_settings(self, settingsfile):
with open(settingsfile, 'r') as f:
self.settings = json.loads(f.read())
subsettings = self.settings['fetch_rates']
if 'refresh_seconds' in self.settings:
self.update_iterval_sec = max(subsettings['refresh_seconds'],
self.update_iterval_sec)
self.full_url = (subsettings['base_url'] + "?app_id=" +
subsettings['app_id'])
self.rates = self.load_rates()
if self.settings['test_mode']:
pass
else:
self.start_scheduler()
def get_rates(self):
return self.rates
def load_rates(self):
if self.settings['test_mode']: # load from fallback file
rates_file_name = str(self.settings['common_path'] +
self.settings['fallback_currency_file'])
rates_file = open(rates_file_name, 'r')
data = json.loads(rates_file.read())
return data['rates']
else:
rates_file_name = str(self.settings['common_path'] +
self.settings['refreshed_currency_file'])
self.rates_file_name = rates_file_name
rates_file = open(rates_file_name, 'w') # to write!
newrates = self.download_and_save_rates(rates_file)
return newrates
def start_scheduler(self):
self.scheduler.add_job(self.update_rates,
'interval',
seconds=self.update_iterval_sec)
self.scheduler.start()
def update_rates(self):
rates_file = open(self.rates_file_name, 'w')
new_rates = self.download_and_save_rates(rates_file)
self.rates = new_rates
def download_and_save_rates(self, outfile):
r = requests.get(self.full_url)
if 200 != r.status_code:
print("There was a problem with downloading the conversion rates")
outfile.close()
return None
else:
data = r.json()
json.dump(data, outfile)
outfile.close()
return data['rates']
def __del__(self):
self.scheduler.shutdown()
login = LoginManager(app)
login.login_view = 'login'
mail = Mail(app)
bootstrap = Bootstrap(app)
moment = Moment(app)
log_path = os.path.join(app.config['WRITE_PATH'], 'logs')
if not os.path.exists(log_path):
os.mkdir(log_path)
file_handler = RotatingFileHandler(log_path + '/olirowanxyz_app.log',
maxBytes=10000000,
backupCount=10)
file_handler.setFormatter(
logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(logging.DEBUG)
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.DEBUG)
app.logger.info('STARTED olirowanxyz')
task_schedule = BackgroundScheduler(daemon=True)
task_schedule.start()
from app import routes, models, errors
class Filament(Process):
"""Filament initialization and execution engine.
Filaments are lightweight Python modules which run
on top of Fibratus. They are often used to enrich/extend the
functionality of Fibratus by performing any type of logic
(aggregations, groupings, filters, counters, etc) on the
kernel event stream.
Each filament runs in its own execution context, i.e. in
its own copy of the Python interpreter process.
"""
def __init__(self):
"""Builds a new instance of the filament.
Attributes:
----------
filament_module: module
module which contains the filament logic
keventq: Queue
queue where the main process pushes the kernel events
"""
Process.__init__(self)
self._filament_module = None
self._keventq = None
self._filters = []
self._cols = []
self._tabular = None
self._limit = 10
self._interval = 1
self._sort_by = None
self._sort_desc = True
self._log_path = None
self._logger = None
self.scheduler = BackgroundScheduler()
def load_filament(self, name):
"""Loads the filament module.
Finds and loads the python module which
holds the filament logic. It also looks up for
some essential filament methods and raises an error
if they can't be found.
Parameters
----------
name: str
name of the filament to load
"""
Filament._assert_root_dir()
filament_path = self._find_filament_path(name)
if filament_path:
loader = SourceFileLoader(name, filament_path)
self._filament_module = loader.load_module()
sys.path.append(FILAMENTS_DIR)
doc = inspect.getdoc(self._filament_module)
if not doc:
raise FilamentError('Please provide a short '
'description for the filament')
on_next_kevent = self._find_filament_func('on_next_kevent')
if on_next_kevent:
if self._num_args(on_next_kevent) != 1:
raise FilamentError('Missing one argument on_next_kevent '
'method on filament')
self._initialize_funcs()
else:
raise FilamentError('Missing required on_next_kevent '
'method on filament')
else:
raise FilamentError('%s filament not found' % name)
def _initialize_funcs(self):
"""Setup the filament modules functions.
Functions
---------
set_filter: func
accepts the comma separated list of kernel events
for whose the filter should be applied
set_interval: func
establishes the fixed repeating interval in seconds
columns: func
configure the column set for the table
add_row: func
adds a new row to the table
sort_by: func
sorts the table by specific column
"""
def set_filter(*args):
self._filters = args
self._filament_module.set_filter = set_filter
def set_interval(interval):
if not type(interval) is int:
raise FilamentError('Interval must be an integer value')
self._interval = interval
self._filament_module.set_interval = set_interval
def columns(cols):
if not isinstance(cols, list):
raise FilamentError('Columns must be a list, '
'%s found' % type(cols))
self._cols = cols
self._tabular = Tabular(self._cols)
self._tabular.padding_width = 10
self._tabular.junction_char = '|'
def add_row(row):
if not isinstance(row, list):
raise FilamentError(
'Expected list type for the row, found %s' % type(row))
self._tabular.add_row(row)
def sort_by(col, sort_desc=True):
if len(self._cols) == 0:
raise FilamentError('Expected at least 1 column but 0 found')
if col not in self._cols:
raise FilamentError('%s column does not exist' % col)
self._sort_by = col
self._sort_desc = sort_desc
def limit(l):
if len(self._cols) == 0:
raise FilamentError('Expected at least 1 column but 0 found')
if not type(l) is int:
raise FilamentError('Limit must be an integer value')
self._limit = l
def title(text):
self._tabular.title = text
self._filament_module.columns = columns
self._filament_module.title = title
self._filament_module.sort_by = sort_by
self._filament_module.limit = limit
self._filament_module.add_row = add_row
self._filament_module.render_tabular = self.render_tabular
# call filament initialization method.
# This is the right place to perform any
# initialization logic
on_init = self._find_filament_func('on_init')
if on_init and self._zero_args(on_init):
self._filament_module.on_init()
def setup_adapters(self, output_adapters):
"""Creates the filament adapters accessors.
Parameters
----------
output_adapters: dict
output adapters
"""
for name, adapter in output_adapters.items():
adapter_metavariable = AdapterMetaVariable(adapter)
setattr(self._filament_module, name, adapter_metavariable)
def run(self):
"""Filament main routine.
Setups the interval repeating function and polls for
the kernel events from the queue.
"""
on_interval = self._find_filament_func('on_interval')
if on_interval:
self.scheduler.add_executor(ThreadPoolExecutor(max_workers=4))
self.scheduler.start()
self.scheduler.add_job(self._filament_module.on_interval,
'interval',
seconds=self._interval,
max_instances=4,
misfire_grace_time=60)
while self._poll():
try:
kevent = self._keventq.get()
self._filament_module.on_next_kevent(ddict(kevent))
except Exception:
print(traceback.format_exc())
self._logger.error('Unexpected filament error %s' %
traceback.format_exc())
def render_tabular(self):
"""Renders the table to the console.
"""
if len(self._cols) > 0:
tabular = self._tabular.get_string(start=1, end=self._limit)
if self._sort_by:
tabular = self._tabular.get_string(start=1,
end=self._limit,
sortby=self._sort_by,
reversesort=self._sort_desc)
self._tabular.clear_rows()
if not _ansi_term.term_ready:
try:
_ansi_term.setup_console()
except TermInitializationError:
panic(
'fibratus run: ERROR - console initialization failed')
_ansi_term.cls()
_ansi_term.write_output(tabular)
def close(self):
on_stop = self._find_filament_func('on_stop')
if on_stop and self._zero_args(on_stop):
self._filament_module.on_stop()
if self.scheduler.running:
self.scheduler.shutdown()
_ansi_term.restore_console()
if self.is_alive():
self.terminate()
def _poll(self):
return True
@classmethod
def exists(cls, filament):
Filament._assert_root_dir()
return os.path.exists(os.path.join(FILAMENTS_DIR, '%s.py' % filament))
@classmethod
def list_filaments(cls):
Filament._assert_root_dir()
filaments = {}
paths = [
os.path.join(FILAMENTS_DIR, path)
for path in os.listdir(FILAMENTS_DIR) if path.endswith('.py')
]
for path in paths:
filament_name = os.path.basename(path)[:-3]
loader = SourceFileLoader(filament_name, path)
filament = loader.load_module()
filaments[filament_name] = inspect.getdoc(filament)
return filaments
@classmethod
def _assert_root_dir(cls):
if not os.path.exists(FILAMENTS_DIR):
panic('fibratus run: ERROR - %s path does not exist.' %
FILAMENTS_DIR)
@property
def keventq(self):
return self._keventq
@keventq.setter
def keventq(self, keventq):
self._keventq = keventq
@property
def filters(self):
return self._filters
@property
def logger(self):
return self._logger
@logger.setter
def logger(self, log_path):
self._log_path = log_path
FileHandler(self._log_path).push_application()
self._logger = Logger(Filament.__name__)
@property
def filament_module(self):
return self._filament_module
def _find_filament_func(self, func_name):
"""Finds the function in the filament module.
Parameters
----------
func_name: str
the name of the function
"""
functions = inspect.getmembers(self._filament_module,
predicate=inspect.isfunction)
return next(
iter([func for name, func in functions if name == func_name]),
None)
def _find_filament_path(self, filament_name):
"""Resolves the filament full path from the name
Parameters
----------
filament_name: str
the name of the filament whose path if about to be resolved
"""
return next(
iter([
os.path.join(FILAMENTS_DIR, filament)
for filament in os.listdir(FILAMENTS_DIR)
if filament.endswith('.py') and filament_name == filament[:-3]
]), None)
def _num_args(self, func):
return len(inspect.getargspec(func).args)
def _zero_args(self, func):
return self._num_args(func) == 0
class SchedulerManager(object, metaclass=Singleton):
def __init__(self):
print("Initialisation of the scheduler manager")
self.scheduler = BackgroundScheduler()
# create the async loop in the main thread
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop) # bind event loop to current thread
asyncio.get_child_watcher().attach_loop(self.loop)
def start(self):
print("Starting scheduler manager")
if settings.DEBUG:
# Hook into the apscheduler logger
logging.basicConfig()
logging.getLogger('apscheduler').setLevel(logging.DEBUG)
self.scheduler.start()
self.add_job_for_each_alarm_clock()
def play_web_radio(self, url, auto_stop_minutes):
from restapi.models.backup_file import BackupFile
backup_files = BackupFile.objects.all()
backup_file_path = None
if backup_files is not None and len(backup_files) > 0:
backup_file_path = backup_files[0].backup_file.url
print("Path to the backup MP3: {}".format(backup_file_path))
print("play_web_radio triggered by scheduler")
PlayerManager().async_start(self.loop, url, auto_stop_minutes, backup_file_path)
print("play_web_radio thread terminated")
def add_job_for_each_alarm_clock(self):
"""
load all enabled alarm clock from the DB and create a new app scheduler job
"""
from restapi.models import AlarmClock
all_alarm_clock = AlarmClock.objects.all()
for alarm in all_alarm_clock:
if alarm.enabled:
self.add_new_job(job_id=alarm.id,
day_of_week_string=alarm.get_day_of_week(),
hour=alarm.hour,
minute=alarm.minute,
url=alarm.webradio.url,
auto_stop_minutes=alarm.auto_stop_minutes)
def add_new_job(self, job_id, day_of_week_string, hour, minute, url, auto_stop_minutes) -> bool:
print("add a new job with id {}, {}, {}, {}, {}, {}".
format(job_id, day_of_week_string, hour, minute, url, auto_stop_minutes))
my_cron = CronTrigger(hour=hour,
minute=minute,
day_of_week=day_of_week_string)
self.scheduler.add_job(func=self.play_web_radio,
trigger=my_cron,
id=str(job_id),
args=[url, auto_stop_minutes])
return True
def delete_job_by_id(self, job_id):
print("removing job id {} form the scheduler".format(job_id))
try:
self.scheduler.remove_job(str(job_id))
except JobLookupError:
print("Job id {} was already deleted".format(job_id))
# sched.start()
# while True:
# time.sleep(1)
#
#
# if __name__ == '__main__':
# main()
import datetime as dt
import os
import time
from datetime import datetime
from apscheduler.executors.pool import ThreadPoolExecutor
from apscheduler.schedulers.background import BackgroundScheduler
scheduler = BackgroundScheduler(
executors={"processpool": ThreadPoolExecutor(10)})
def tick():
next_run_at = datetime.now() + dt.timedelta(seconds=3.0)
print('Tick! The time is: %s, run next at:%s' %
(datetime.now(), next_run_at))
scheduler.add_job(tick,
next_run_time=next_run_at,
executor="processpool",
id="hello kitty")
print("pid:%r" % os.getpid())
if __name__ == '__main__':
next_run_at = datetime.now() + dt.timedelta(seconds=3.0)
entries_newDF['TournamentTotal'] = entries_newDF['TournamentTotal'].astype(
'str')
entries_newDF.to_csv('entries2.csv')
for i in range(len(entries_newDF)):
entry_id = entries_newDF.loc[i]['id']
fields = {
'R3': entries_newDF.loc[i]['R3'],
'R3Total': entries_newDF.loc[i]['R3Total'],
'TournamentTotal': entries_newDF.loc[i]['TournamentTotal']
}
airtableEntries.update(entry_id, fields)
print(i)
print('Tick! The time is: %s' % datetime.now())
if __name__ == '__main__':
scheduler = BackgroundScheduler()
scheduler.add_job(tick, 'interval', minutes=5)
scheduler.start()
print('Press Ctrl+{0} to exit'.format('Break' if os.name == 'nt' else 'C'))
try:
# This is here to simulate application activity (which keeps the main thread alive).
while True:
time.sleep(2)
except (KeyboardInterrupt, SystemExit):
# Not strictly necessary if daemonic mode is enabled but should be done if possible
scheduler.shutdown()
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from dotenv import load_dotenv
from apscheduler.schedulers.background import BackgroundScheduler
from rival_regions_wrapper.rival_regions_wrapper import LocalAuthentication, RemoteAuthentication
load_dotenv()
# database
ENGINE = create_engine(os.environ["DATABASE_URI"])
SESSION = sessionmaker(bind=ENGINE)
# scheduler
SCHEDULER = BackgroundScheduler(
daemon=True,
job_defaults={'misfire_grace_time': 300},
)
SCHEDULER.start()
# get logger
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.INFO)
SCHEDULER_LOGGER = logging.getLogger('apscheduler')
SCHEDULER_LOGGER.setLevel(logging.DEBUG)
# create file handler
FILE_HANDLER = logging.FileHandler('output.log')
FILE_HANDLER.setLevel(logging.DEBUG)
# create console handler
STREAM_HANDLER = logging.StreamHandler()
def mainjob(self, name):
self.filename = '/tmp/dc/django_celery_%s.log' % name
# prepare
out_output(str(self.request.retries), self.filename)
self.default_retry_delay = 5
self.max_retries = 2
self.count = 0
# reply_to = self.request.reply_to
# out_output(reply_to, self.filename)
# out_output(dir(reply_to), self.filename)
# out_output(reply_to.__doc__, self.filename)
# out_output(type(reply_to), self.filename)
jlogger = logging.getLogger('apscheduler.scheduler')
jlogger.setLevel(logging.ERROR)
scheduler = Scheduler(logger=jlogger)
self.update_state(state='RUNNING')
# shutdown
def shutdown(a, b):
output('shuting')
scheduler.shutdown()
output('down - %s' % time())
def terminate(a, b):
output('terminating')
scheduler.shutdown()
output('down - %s' % time())
def retryer(a, b):
out_output('before retry', self.filename)
scheduler.shutdown()
raise self.retry()
out_output('after retry', self.filename)
signal(SIGUSR1, shutdown)
signal(SIGTERM, terminate)
signal(SIGALRM, retryer)
# listen
def listener(event):
try:
raise event.exception
except Exception as e:
out_output(e, self.filename)
[job.pause() for job in scheduler.get_jobs()]
alarm(1)
scheduler.add_listener(listener, EVENT_JOB_ERROR)
# add job and start
def output(msg):
self.count += 1
#if self.count == 9: raise StandardError('haha')
with open(self.filename, 'a') as file:
file.write('(%s - %s) %s\n' % (time(), name, msg))
scheduler.add_job(output, 'interval', args=('--a',), seconds=1)
sleep(0.5)
scheduler.add_job(output, 'interval', args=('------b',), seconds=1)
#scheduler.add_job(output, 'interval', args=('--b',), seconds=3)
scheduler.start()
# wait for retry
pause()
def checkForPolling():
last_update = FileUtils.getObject('last_update.txt')
for tweet_id,last_updated in last_update.iteritems():
current_time = TimeUtils.getCurrentTime()
time_difference = TimeUtils.getTimeDifference(last_updated,current_time)
if time_difference > 5:
last_update[tweet_id] = TimeUtils.getCurrentTime()
updateTwitterStatistics(tweet_id)
FileUtils.persist('last_update.txt',last_update)
scheduler = BackgroundScheduler()
scheduler.add_job(checkForPolling,'interval',seconds=60)
try:
scheduler.start()
except (KeyboardInterrupt, SystemExit):
pass
try:
while True:
time.sleep(1)
except (KeyboardInterrupt, SystemExit):
pass
def run(self):
logging.warning("Starting streamming")
# Initialize a timer
sched = BackgroundScheduler(daemon=True)
# check if user has request to stop server, every "seconds" ,
sched.add_job(self.checkStatus,
'interval',
seconds=int(os.environ['TIME_TO_CHECK']))
sched.start()
# read Data for specific user and camera
if self.checkData():
username = self.settings[0]['username']
password = self.settings[0]['password']
ip = self.settings[0]["ip"]
port = self.settings[0]["port"]
URL = self.settings[0]["url_path"]
else:
sched.shutdown()
logging.warning("User doesn't exists or Camera is not configured")
return "Server stopped"
try:
video_capture = cv2.VideoCapture(
f"rtsp://{username}:{password}@{ip}:{port}/{URL}")
if not video_capture.isOpened():
self.suspectData.changeServerStatus(0, "No stream available")
logging.warning("No stream available, check RTSP settings")
video_capture.release()
sched.shutdown()
return "Server stopped"
else:
self.suspectData.changeServerStatus(1, "Streaming")
# Initialize detection variables
face_locations = []
face_encodings = []
face_names = []
process_this_frame = True
log = {}
# Face Detaction process, exits if self.stop_running is True
logging.warning("Streamming")
while not self.stop_running:
try:
# Grab a single frame of video
ret, frame = video_capture.read()
if not (ret):
logging.warning("No Video capture")
st = time.time()
video_capture = cv2.VideoCapture(
f"rtsp://{username}:{password}@{ip}:{port}/{URL}")
ret, frame = video_capture.read()
continue
#if ret == True:
# Resize frame of video to 1/4 size for faster face recognition processing
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_small_frame = small_frame[:, :, ::-1]
# Only process every other frame of video to save time
if process_this_frame:
# Find all the faces and face encodings in the current frame of video
face_locations = face_recognition.face_locations(
rgb_small_frame)
face_encodings = face_recognition.face_encodings(
rgb_small_frame, face_locations)
face_names = []
for face_encoding in face_encodings:
# See if the face is a match for the known face(s)
matches = face_recognition.compare_faces(
self.encodings, face_encoding)
name = "Unknown"
face_distances = face_recognition.face_distance(
self.encodings, face_encoding)
best_match_index = np.argmin(face_distances)
if matches[best_match_index]:
name = self.names[best_match_index]
now = datetime.now()
if log.get(name) != None:
if abs(now -
log[name]) < timedelta(minutes=10):
log[name] = now
logging.warning(
f'{name} seen no more than 10 min ago'
)
else:
face_names.append(name)
logging.warning(
f'{name} Return to site')
log[name] = now
date = now.strftime("%m/%d/%y, %H:%M")
self.snapShot(face_locations,
face_names, frame, name)
self.reportFinding(name, date)
else:
#logger(name, self.settings["phone"])
face_names.append(name)
logging.warning(f'{name} seen')
log[name] = now
print(name)
date = now.strftime("%m/%d/%y, %H:%M")
self.snapShot(face_locations, face_names,
frame, name)
self.reportFinding(name, date)
face_names.append(name)
# if cv2.waitKey(1) & 0xFF == ord('q'):
# break
if self.stop_running:
break
process_this_frame = not process_this_frame
if (self.showVideoVariable):
# Display the results
for (top, right, bottom,
left), name in zip(face_locations, face_names):
# Scale back up face locations since the frame we detected in was scaled to 1/4 size
top *= 4
right *= 4
bottom *= 4
left *= 4
# Draw a box around the face
cv2.rectangle(frame, (left, top), (right, bottom),
(0, 0, 255), 2)
# Draw a label with a name below the face
cv2.rectangle(frame, (left, bottom - 35),
(right, bottom), (0, 0, 255),
cv2.FILLED)
font = cv2.FONT_HERSHEY_DUPLEX
cv2.putText(frame, name, (left + 6, bottom - 6),
font, 1.0, (255, 255, 255), 1)
# Display the resulting image
cv2.imshow('Video', frame)
# Hit 'q' on the keyboard to quit!
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# if self.stop_running:
# break
except cv2.error as e:
self.suspectData.changeServerStatus(
0, "No stream available")
logging.warning(
"CV2 Error - Streaming failed, check RTSP settings", e)
#video_capture.release()
sched.shutdown()
return "Server stopped"
# Release handle to the webcam
video_capture.release()
cv2.destroyAllWindows()
sched.shutdown()
logging.warning("Streamming terminated")
self.suspectData.changeServerStatus(0, "streamming terminated")
return "Server stopped"
except cv2.error as e:
self.suspectData.changeServerStatus(0, "No stream available")
logging.warning(
"CV2 Error - Streaming failed, check RTSP settings", e)
#video_capture.release()
sched.shutdown()
return "Server stopped"
def __init__(self):
self.started = False
# process id
self.PID = os.getpid()
# generate notifiers dict
self.notifiersDict = notifiersDict()
# generate metadata providers dict
self.metadataProvidersDict = metadataProvidersDict()
# generate providers dict
self.providersDict = providersDict()
# init notification queue
self.srNotifications = Notifications()
# init logger
self.srLogger = srLogger()
# init config
self.srConfig = srConfig()
# init databases
self.mainDB = MainDB()
self.cacheDB = CacheDB()
self.failedDB = FailedDB()
# init scheduler service
self.srScheduler = BackgroundScheduler()
# init web server
self.srWebServer = srWebServer()
# init web client session
self.srWebSession = srSession()
# google api
self.googleAuth = googleAuth()
# name cache
self.NAMECACHE = srNameCache()
# queues
self.SHOWQUEUE = srShowQueue()
self.SEARCHQUEUE = srSearchQueue()
# updaters
self.VERSIONUPDATER = srVersionUpdater()
self.SHOWUPDATER = srShowUpdater()
# searchers
self.DAILYSEARCHER = srDailySearcher()
self.BACKLOGSEARCHER = srBacklogSearcher()
self.PROPERSEARCHER = srProperSearcher()
self.TRAKTSEARCHER = srTraktSearcher()
self.SUBTITLESEARCHER = srSubtitleSearcher()
# auto postprocessor
self.AUTOPOSTPROCESSOR = srPostProcessor()
# sickrage version
self.NEWEST_VERSION = None
self.NEWEST_VERSION_STRING = None
# anidb connection
self.ADBA_CONNECTION = None
# show list
self.SHOWLIST = []
self.USER_AGENT = 'SiCKRAGE.CE.1/({};{};{})'.format(
platform.system(), platform.release(), str(uuid.uuid1()))
self.SYS_ENCODING = get_sys_encoding()
# patch modules with encoding kludge
patch_modules()
from django_apscheduler.jobstores import DjangoJobStore, register_events, register_job
from proxy.models import *
from main.models import *
from lazy_balancer.views import is_auth
from nginx.views import reload_config
from .models import system_settings, sync_status
from datetime import datetime
from nginx.views import *
import logging
import uuid
import json
import time
import hashlib
logger = logging.getLogger('django')
scheduler = BackgroundScheduler()
scheduler.add_jobstore(DjangoJobStore(), 'default')
@login_required(login_url="/login/")
def view(request):
user = {
'name':request.user,
'date':time.time()
}
_system_settings = system_settings.objects.all()
_sync_status = sync_status.objects.all()
if len(_system_settings) == 0:
system_settings.objects.create(config_sync_type=0)
_system_settings = system_settings.objects.all()
db.drop() #Drop data before uploading again
records_ = df.to_dict(orient="records")
result = db.insert_many(records_)
x = db.count_documents({})
print("number of records",
x) #Print the number of records to see how many are added
headData = db.find()
row_list = []
for i in headData:
row_list.append(i)
#Using apscheduler to refresh data every 24 hours
sched = BackgroundScheduler(daemon=True)
sched.add_job(get_data, 'interval', hours=24)
sched.start()
@app.route('/')
def index():
return render_template('index.html')
@app.route('/casesbydate')
def casesbydate():
return render_template('casesbydate.html')
@app.route('/activecasesbystates')
trigger_method = "manual"
else:
trigger_method = "scheduled"
logger.info(f'APscheduler {trigger_method} phonescrape update triggered')
from api.scheduler.update_from_phonescraper import rq_scrape_phones
# call phone scrape script to do the actual work
rq_scrape_phones()
scheduler.resume() # resume scheduler
# scheduler init
scheduler = BackgroundScheduler()
# get settings values from database and convert values to dict
settings = settings_management.get_all_settings()
settings_dict = {}
for setting in settings:
settings_dict[setting.name] = setting.value
# schedule CUCM API phone sync job
scheduler_phone_sync_job = scheduler.add_job(
scheduler_phone_sync,
'cron',
hour='*',
minute=settings_dict['cucm_update_minute'])
# schedule Phonescrape API sync job
