def _query_for_id(self):
if not self.db_conn:
return False
time_check_query="""SELECT CASE
WHEN (SELECT COUNT(1) FROM {0} WHERE {1}_truncate=(SELECT date_trunc('{1}',now())::timestamp without time zone)) > 0
THEN NULL ELSE LOCALTIMESTAMP END AS actual_time,
date_trunc('{1}',LOCALTIMESTAMP) AS {1}_truncate""".format(self.table_name,self.truncate_unit)
cur=self.db_conn.cursor()
cur.execute(time_check_query)
time_data=cur.fetchone()
if not time_data[0]:
logger.critical('Appropriate record for "{0}" already exists'.format(time_data[1]))
cur.close()
return False
# logger.debug('Log time obtained. Actual Time: {0}\tHour Truncate: {1}'.format(time_data[0],time_data[1]))
try:
cur.execute("INSERT INTO {0} ({1}_truncate,actual_time) VALUES (%s,%s) RETURNING id".format(self.table_name,self.truncate_unit),(time_data[1],time_data[0]))
except Exception as e:
logger.critical("Cannot create time log record into {0}. Error: {1}".format(self.table_name,e.pgerror))
cur.close()
self.db_conn.rollback()
return False
self.id=cur.fetchone()[0]
# logger.debug("Log time ID: {0}".format(self.id))
cur.close()
self.db_conn.commit()
return True
def makeTraceDir():
try:
mode = stat(TRACES_DIR).st_mode
if (mode & S_IFDIR == 0):
logger.critical('%s is not a directory or not accessible -- tell a friend' % TRACES_DIR)
except OSError:
print 'making', TRACES_DIR
try:
makedirs(TRACES_DIR)
except:
logger.critical('could not create %s == tell a friend' % TRACES_DIR)
def connect(self):
try:
self.conn = psycopg2.connect(self.connect_str)
self.conn.autocommit = True
self.cursor = self.conn.cursor()
logger.debug(__name__ + " Connected to Database")
self.initilaize()
return self.cursor
except Exception as e:
logger.critical(__name__ + " Database Connection Error!" + str(e))
return None
def setting_recup(): # Function to read parameter settings
args = parser_generation()
logger.setLevel(args.verbose.upper())
if args.i_path is None and not args.profile == 2:
logger.warning(
"\nCannot analyse an image neither a video without a path\nSwitching to Webcam..."
)
args.profile = 2
try:
model = load_model(args.model_path)
except OSError:
logger.critical("\nCannot localize model\nLeaving...")
sys.exit(3)
return args, model
def runMatch(red, blue):
(redUser, redPlayer) = red
(blueUser, bluePlayer) = blue
rname = redUser + '/' + redPlayer
bname = blueUser + '/' + bluePlayer
logger.info('playing %s vs. %s' % (rname, bname))
makeTraceDir()
command = (runtemplate % (ICYPC_JAR, script(redUser, redPlayer), script(blueUser, bluePlayer), TRACES_DIR)).split()
logger.info('running: "%s"' % command)
p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(output, stderr) = p.communicate();
m = output_pattern.match(output)
(winner, loser) = (red, blue) # default
if m:
logger.info('winner is %s' % m.group(1))
challengerState = 'loses'
if m.group(1) == '1':
challengerState = 'wins'
(winner, loser) = (blue, red) # challenger won
log = 'challenger (%s) %s: %s [%s (%s %s)] vs. %s [%s (%s %s)]' % (bname, challengerState,
rname, m.group(2), m.group(3), m.group(4),
bname, m.group(5), m.group(6), m.group(7))
r = Result(time=datetime.now(), winnerUser=winner[0], winnerPlayer=winner[1], loserUser=loser[0], loserPlayer=loser[1],
output=log)
r.save()
umask(002) # ensure world can read these files
rename(TRACES_DIR + '/trace.txt', TRACES_DIR + '/%s.txt' % r.pk)
try:
f = open('%s/%s-stdout.txt' % (TRACES_DIR, r.pk), 'w'); f.write(output); f.close()
f = open('%s/%s-stderr.txt' % (TRACES_DIR, r.pk), 'w'); f.write(stderr); f.close()
except:
logger.critical('could not write std out/err files in %s--tell a friend' % TRACES_DIR)
else:
logger.error('no winner found in stdout; probably a script was not executable; stdout and stderr follow')
logger.error('===== begin stdout =====\n%s\n===== end stdout' % output)
logger.error('===== begin stderr =====\n%s\n===== end stderr' % stderr)
return (winner, loser)
def main_process():
args, model = setting_recup()
if args.profile == 1: # Image or Video
if args.i_path.endswith(tuple(images_extension)):
from src.main_img import main_process_img
main_process_img(args.i_path, model, args.save)
elif args.i_path.endswith(tuple(video_extension)):
from src.main_video import main_grid_detector_video
main_grid_detector_video(model,
video_path=args.i_path,
save=args.save,
display=args.display)
else:
logger.critical("\nCannot identify File type\nLeaving...")
sys.exit(3)
else: # Webcam
from src.main_video import main_grid_detector_video
main_grid_detector_video(model, save=args.save,
display=args.display) #
def __init__(self):
time_check_query="""SELECT CASE
WHEN (SELECT TRUE FROM log_time WHERE hour_truncate=date_trunc('hour',now()))
THEN NULl
ELSE
LOCALTIMESTAMP END AS actual_time,date_trunc('hour',LOCALTIMESTAMP) AS hour_truncate"""
self.cursor.execute(time_check_query)
time_data=self.cursor.fetchone()
if not time_data[0]:
logger.critical('Appropriate record for "{0}" already exists'.format(time_data[1]))
self.cursor.close()
db_handler.close()
exit()
logger.debug('Log time obtained. Actual Time: {0}\tHour Truncate: {1}'.format(time_data[0],time_data[1]))
self.actual_time=time_data[0]
self.hour_truncate=time_data[1]
self.cursor.execute("INSERT INTO log_time (hour_truncate,actual_time) VALUES ('{0}','{1}') RETURNING id".format(time_data[1],time_data[0]))
self.id=self.cursor.fetchone()[0]
db_handler.commit()
def __init__(self,
host,
port=80,
use_https=False,
user=None,
password=None):
self.user = user
self.password = password
self.host = host
self.use_https = use_https
self.port = str(port)
self.url = '{}://{}:{}/'.format('https' if use_https else 'http', host,
port)
try:
self.marathon_cli = MarathonClient([self.url],
username=self.user,
password=self.password)
except Exception as e:
logger.critical(e)
raise e
# -*- coding: utf-8 -*-
import smtplib, sys
from smtplib import SMTPException
import datetime
from settings import logger
import settings as const
from email.MIMEText import MIMEText
def sendmail(alarm, body_msg, subject='EWSoDS detect low disk space !!!'):
""" Sending mail through the smtp lib. """
try:
receiver = const.CRITICAL_EMAIL if alarm == 2 else const.WARNING_EMAIL
smtpObj = smtplib.SMTP(const.SMTP_HOST, const.SMTP_PORT)
message = MIMEText(body_msg)
message['From'] = const.SMTP_SENDER
message['To'] = receiver
message['Subject'] = subject
smtpObj.sendmail( message['From'], message['To'], message.as_string())
logger.info( "Mail is just sended successfully." )
return True
except SMTPException, e:
logger.error( "Unable to send email. SMTPException !!! see line below for details:\n" + e )
except Exception, e:
logger.critical( "Unable to send email. Exception !!! see line below for details:\n" + e )
return False;
#!/usr/local/bin/python -B
from objects import *
from settings import logger,db_handler
import transfer
from sys import exit
db_handler.autocommit=False
self_cursor=db_handler.cursor()
stats=['bgwriter_stat','database_stat','table_stat','table_va_stat','index_stat','table_toast_stat','index_toast_stat']
try:
self_cursor.execute("DELETE FROM queue_log_time RETURNING id,hour_truncate")
# self_cursor.execute("SELECT * FROM queue_log_time ORDER BY hour_truncate")
except Exception as e:
logger.critical("Cannot get queue ids! Details: {0}".format(e.pgerror))
exit(1)
queue_ids=self_cursor.fetchall()
hc=HostCluster()
sn=SchemaName()
for log_id in queue_ids:
output=dict()
output['stat_payload']=dict()
output['list_payload']=dict()
output['hour_truncate']=log_id[1]
s_payload=dict()
for stat_tbl in stats:
