def main():
logging.basicConfig(filename='log/lims_sql.log', format='%(levelname)s: %(message)s', level=logging.DEBUG)
logging.info(local_datetime_string() + '- App Initiated')
kwargs_task_hourly = {
"cutoff_month": 6,
"tablename_dispo_history": 'dispo_history',
"tablename_sample_results": 'sample_results',
"tablename_update_date": 'update_date'
}
kwargs_task_daily = {
"cutoff_month": 36,
"tablename_dispo_history": 'dispo_history_3_years',
"tablename_sample_results": 'sample_results_3_years',
"tablename_update_date": 'update_date_3_years'
}
def hourly():
return SampleUpdateTask(**kwargs_task_hourly)
def daily():
return SampleUpdateTask(**kwargs_task_daily)
Scheduler([hourly]).on(hour=11, minute=55).every(hours=1, minutes=0).run()
Scheduler([daily]).on(hour=23, minute=55).run()
return None
def main():
def exit():
logger.debug("Stopping active friends")
for f in ui.friend_list:
f.close()
logger.debug("Shutdown scheduler")
ui.scheduler.must_run = False
while ui.scheduler.isRunning():
logger.debug("Waiting scheduler")
if ui.scheduler.waiting_authorized_contact == True:
break
sleep(0.1)
logger.debug("Restore profile")
config.restore_profile()
if config.useusb == QtCore.Qt.Checked:
logger.debug("Restore USB")
config.restore_useusb()
opt_parser = OptionParser()
opt_parser.add_option("-d",
"--debug",
dest="debug_mode",
action="store_true",
default='False',
help="Debug mode")
app = QtGui.QApplication(sys.argv)
# app.setOrganizationName("HeySms")
# app.setOrganizationDomain("HeySms")
app.setApplicationName("HeySms")
(options, args) = opt_parser.parse_args([str(i) for i in app.arguments()])
logger.set_debug(options.debug_mode)
main_window = QtGui.QMainWindow()
ui = Ui_MainWindow(app)
ui.setupUi(main_window)
config.parent = ui
ui.call_listener = Call_listener(ui)
ui.call_listener.start()
logger.debug("Call_listener started")
ui.sms_listener = Sms_listener(ui)
ui.sms_listener.start()
logger.debug("Sms_listener started")
ui.scheduler = Scheduler(ui)
ui.scheduler.start()
logger.debug("Scheduler started")
main_window.setWindowTitle("HeySms")
main_window.setAttribute(QtCore.Qt.WA_Maemo5AutoOrientation, True)
main_window.show()
main_window.repaint()
ui.central_widget.repaint()
ui.central_widget.reload_contacts()
QtCore.QObject.connect(app, QtCore.SIGNAL("aboutToQuit()"), exit)
sys.exit(app.exec_())
def main():
global scheduler, schedulerThread, downloader
setup()
downloader = Downloader()
scheduler = Scheduler()
schedulerThread = None
Pusher()
t = threading.Thread(target=send_heartbeat)
t.daemon = True
t.start()
t = threading.Thread(target=websocket_server)
t.daemon = True
t.start()
watchdog_thread = threading.Event()
notify_systemd(watchdog_thread)
if is_under_voltage():
browser_template('under_voltage')
sleep(5)
logging.debug('Entering infinite loop.')
while True:
if not scheduler.slides or len(
scheduler.slides
) - 1 == scheduler.index or scheduler.state != scheduler.STATE_OK:
schedulerThread = threading.Thread(target=run_scheduler)
schedulerThread.start()
if not scheduler.slides and schedulerThread.isAlive():
wait_for_scheduler()
broadcast_loop(scheduler)
if scheduler.index is 0 and schedulerThread and schedulerThread.isAlive(
):
wait_for_scheduler()
def __init__(self, server_id, server_data, client):
self.server_id = server_id
self.client = client
self.server_os = 'w'
self.gamemap = 'chernarus+'
self.hive = 'public'
self.servername = DEFAULT_SERVERNAME
self.max_players = 1
self.gametime = '0:00'
self.time_acceleration = 0
self._update(server_data)
self.players = {}
self.first_players_fetch = True
self.create_callbacks(
'player',
['connect', 'disconnect', 'guid', 'chat', 'kick', 'ping_update'])
self.create_callbacks('tool', [
'started', 'stopped', 'halted', 'error', 'config_update',
'module_update', 'notice'
])
self.client.api.server_state(self.server_id, ServerStates.STARTING)
self.setup_rcon()
self.scheduler = Scheduler()
self.tasks_created = False
self.checkalive_fails = 0
self.reconnects = 0
self.start()
self._modules = []
self.load_modules()
def __init__(self, name, igh=None):
Instrument.__init__(self, name, tags=['virtual'])
self._igh = qkit.instruments.get(igh)
self.add_parameter('timeout',
type=float,
flags=Instrument.FLAG_GETSET,
units='sec')
self.add_parameter('idle_mintime',
type=float,
flags=Instrument.FLAG_GETSET,
units='sec')
self.add_parameter('slow_mintime',
type=float,
flags=Instrument.FLAG_GETSET,
units='sec')
self.add_parameter('disk_mintime',
type=float,
flags=Instrument.FLAG_GETSET,
units='sec')
self.add_parameter('timeout_mode',
type=bool,
flags=Instrument.FLAG_GET)
self.add_parameter('idle_mode', type=bool, flags=Instrument.FLAG_GET)
self.add_parameter('plot_enable', type=bool, flags=Instrument.FLAG_GET)
self.add_parameter('status', type=str, flags=Instrument.FLAG_GET)
self.add_function('start')
self.add_function('stop')
self.add_function('plot_start')
self.add_function('plot_stop')
self.add_function('set_default_fast')
self.add_function('set_default_slow')
self._debug_counter = 0
self._timeout = 10
self._idle_mintime = 10
self._slow_mintime = 300
self._disk_mintime = 10
self._slow_lasttime = 0
self._disk_lasttime = 0
self.plot_stop()
self._dir = os.path.join(qkit.cfg.get('datadir'), 'Tlog')
self._filebasename = 'temperature_log'
self._this_month = None
if not os.path.isdir(self._dir):
os.makedirs(self._dir)
self._last_hour = TimeBuffer(60 * 60, self._dir, 'last_hour.dat')
self._last_12hour = TimeBuffer(60 * 60 * 12, self._dir,
'last_12hour.dat')
self._task = Scheduler(self._run_all,
self._timeout,
self._idle_mintime,
timeout_mode=True,
idle_mode=True)
self._status = 'running'
self.get_all()
from lib.libvirt_utils import LibvirtUtils, VirtDupXML, SnapshotManager
from lib.scheduler import Scheduler
from lib.config import Config
from pprint import pprint
import libvirt
from lib.qemu_utils import img_info
import logging
#config_path = "/etc/virt-dup.yml"
config_path = "/home/spencer/git-repos/virt-dup/virt-dup.yml"
config = Config(config_path)
Scheduler(config)
"""
lv = LibvirtUtils(config)
domain = lv.domain_search('ubuntu18.04')
xml = VirtDupXML(config, domain)
#xml.delete_all_jobs()
#xml.add_job()
for job in xml.loaded_jobs:
# pass
sm = SnapshotManager(config, xml, job)
sm.stage_image(staging=False)
# sm.block_commit()
pubSub = PubSub()
def import_events() -> [Event]:
events = []
events_path = Path('events.json').resolve()
with open(events_path, 'r') as f:
data = f.read()
events_json = json.loads(data)
for event_json in events_json:
event = Event(**event_json)
event.date = datetime.strptime(event_json['date'],
'%Y-%m-%d %H:%M') # format date
events.append(event)
return events
def subscribe_events_to_functions():
pubSub.subscribe('PRINT_CONSOLE', print_console)
pubSub.subscribe('WRITE_QUOTE_FILE', write_quote_file)
if __name__ == '__main__':
subscribe_events_to_functions()
events = import_events()
# Just for testing, we will publish_missed_events one time only
scheduler = Scheduler(waitSec=1, events=events)
scheduler.publish_missed_events()
scheduler.active = False
def run(self):
self.scheduler = Scheduler()
self.scheduler.start()
import sys
from json import dumps
from flask import request, render_template, redirect, url_for, session
from flask_wtf.csrf import CSRFError
from config import *
from . import app, csrf, apscheduler
from lib.login import login_check
from lib import common
from lib.scheduler import Scheduler
from lib.dependency import Dependency
reload(sys)
sys.setdefaultencoding('utf8')
scheduler = Scheduler()
dependency = Dependency()
@app.template_filter(name='unicode2str')
def unicode2str(data):
convert = []
for i in data:
convert.append(str(i))
return convert
# 镜像详情
@app.route('/images_details')
@app.route('/tmp_link')
def images_details():
