def __init__(self, **kargs):
self.conn = kargs['conn']
self.objstore = kargs['objstore']
self.caps = CapabilitiesModel()
self.guests_stats_thread = BackgroundTask(GUESTS_STATS_INTERVAL,
self._update_guests_stats)
self.guests_stats_thread.start()
def start_scheduled_job(self):
"""
Scrape every 5 minutes in background and on a different thread
"""
background_job = BackgroundTask(5 * 60,
self.scrapper.persist,
bus=cherrypy.engine)
background_job.start()
def __init__(self):
self.routes = get_routes()
for route in self.routes:
route['time_table'] = explode_times(route['departure_times'])
task = BackgroundTask(interval=1, function=self.track_minibuses, bus=cherrypy.engine)
task.start()
pass
def __init__(self, **kargs):
self.host_stats = defaultdict(list)
gbconfig = config.get('gingerbase', {})
self.statshistory_on = gbconfig.get('statshistory_on', True)
# create thread to collect statistcs and cache values only if
# statshistory_on is enabled in gingerbase.conf
if self.statshistory_on:
self.host_stats_thread = BackgroundTask(HOST_STATS_INTERVAL,
self.update_host_stats)
self.host_stats_thread.start()
def start(self):
'''
Starts Polling by initialising the CherryPy background task and the
tester Class and
'''
self.tester = OmniPingTester(interval=self.setup.interval)
actual_interval = self.tester.interval - self.tester.timeout
self.bgtask = BackgroundTask(actual_interval,
self.testerCall,
bus=cherrypy.engine)
self.bgtask.start()
self.running = True
def __init__(self):
log = os.path.join(paths.state_dir, REQUEST_LOG_FILE)
h = logging.handlers.WatchedFileHandler(log, 'a')
h.setFormatter(logging.Formatter('%(message)s'))
self.handler = h
self.logger = logging.getLogger(WOK_REQUEST_LOGGER)
self.logger.setLevel(logging.INFO)
self.logger.addHandler(self.handler)
# start request log's downloadable temporary files removal task
interval = LOG_DOWNLOAD_TIMEOUT * SECONDS_PER_HOUR
self.clean_task = BackgroundTask(interval, self.cleanLogFiles)
self.clean_task.start()
def __init__(self):
log = os.path.join(config.get("logging", "log_dir"), REQUEST_LOG_FILE)
h = logging.handlers.RotatingFileHandler(log, 'a',
maxBytes=MAX_FILE_SIZE,
backupCount=NUM_BACKUP_FILES)
h.setFormatter(logging.Formatter('%(message)s'))
self.handler = h
self.logger = logging.getLogger(WOK_REQUEST_LOGGER)
self.logger.setLevel(logging.INFO)
self.logger.addHandler(self.handler)
# start request log's downloadable temporary files removal task
interval = LOG_DOWNLOAD_TIMEOUT * SECONDS_PER_HOUR
self.clean_task = BackgroundTask(interval, self.cleanLogFiles)
self.clean_task.start()
def __init__(self, libvirt_uri=None, objstore_loc=None):
self.libvirt_uri = libvirt_uri or 'qemu:///system'
self.conn = LibvirtConnection(self.libvirt_uri)
self.objstore = ObjectStore(objstore_loc)
self.graphics_ports = {}
self.next_taskid = 1
self.stats = {}
self.qemu_stream = False
self.qemu_stream_dns = False
self.libvirt_stream_protocols = []
# Subscribe function to set host capabilities to be run when cherrypy
# server is up
# It is needed because some features tests depends on the server
cherrypy.engine.subscribe('start', self._set_capabilities)
self.statsThread = BackgroundTask(STATS_INTERVAL, self._update_stats)
self.statsThread.start()
self.distros = self._get_distros()
if 'qemu:///' in self.libvirt_uri:
self._default_pool_check()
self._default_network_check()
def start(ask_queue, data_queue, host=None, port=None, name=None):
global server_ip
global server_port
global server_name
import setproctitle
setproctitle.setproctitle("aqi: web server")
(machine, ipaddresses) = system_tools.get_host_info()
cherrypy.log.screen = False
if host == None:
host = ipaddress[0]
if port == None:
port = 8080
if name == None:
name = "localhost"
server_ip = host
server_port = port
server_name = name
config = {
'global': {
'server.socket_host': server_ip,
'server.socket_port': server_port,
'log.access_file': '',
'log.error_file': '',
}
}
server = RawDataServer(ask_queue, data_queue)
task = BackgroundTask(interval=1,
function=server.read_queue,
args=[],
bus=cherrypy.engine)
task.start()
print("INFO: [aqi] web server starting: {}:{}".format(
server_ip, server_port))
cherrypy.quickstart(server, '/', config)
print("INFO: [aqi] web server finished")
def __init__(self, **kargs):
self.host_stats = defaultdict(list)
self.host_stats_thread = BackgroundTask(HOST_STATS_INTERVAL,
self._update_host_stats)
self.host_stats_thread.start()
def __init__(self, *args, **kwargs):
self.nse = NSE()
# Start the cherrypy background cron-like task
BackgroundTask(interval=5 * 60,
function=self.store_now,
bus=cherrypy.engine).start()
'entry 0', 'entry 1', 'entry 2', 'entry 3', 'entry 4', 'entry 5',
'entry 6', 'entry 7', 'entry 8', 'entry 9'
]
# class Scraper(Thread):
# def __init__(self):
# Thread.__init__(self, delay)
# self.delay = delay
# def run(self):
# while True:
# time.sleep(self.delay)
# nScrape()
nScrape()
BackgroundTask(300, nScrape, bus=cherrypy.engine).start()
class HomePage:
@cherrypy.expose
def index(self):
data_to_render = redis_inst
tmpl = env.get_template('index.html')
return tmpl.render(redis_data=data_to_render,
entries=entries,
keys=keys)
root = HomePage()
config = {
game = "Offline"
elif resp.json(
)['response']['players'][0]['personastate'] == 1 or resp.json(
)['response']['players'][0]['personastate'] == 5 or resp.json(
)['response']['players'][0]['personastate'] == 6:
game = "Online"
#c.execute("UPDATE games SET game = replace(game,'Away','Offline') WHERE game LIKE 'Away%'")
c.execute("INSERT INTO games VALUES ('" + date + "','" + game + "')")
conn.commit()
conn.close()
if __name__ == '__main__':
cherrypy.server.socket_host = '0.0.0.0'
cherrypy.server.socket_port = 80
if len(sys.argv) > 1:
cherrypy.server.socket_port = int(sys.argv[1])
conf = {
'/': {
'tools.staticdir.root': os.path.abspath(os.getcwd())
},
'/static': {
'tools.staticdir.on': True,
'tools.staticdir.dir': './public'
}
}
StringGenerator()._task()
BackgroundTask(59, StringGenerator()._task, bus=cherrypy.engine).start()
cherrypy.quickstart(StringGenerator(), '/', conf)
