def send_mail(self, alarm_state):
now = time.strftime("%Y-%m-%d %H:%M:%S")
alarm_info = alarm_state.copy()
alarm_info["ts"] = now
mail_center.add_alarm_info(alarm_info)
log.error("send mail %s %s" %
(alarm_info['key_word'], alarm_info['msg']))
def _func(request, *args, **kwargs):
if request.method != method:
log.error('view_method_error|url=%s,method=%s',
request.get_full_path().encode('utf-8'),
request.method)
return response_parms_error(
request, 'request method is not %s' % method)
from common.form_validator import FormValidateError
if method == 'GET':
try:
form = FormValidator(schema)
form_data = request.json
form_data = form.normalize(form_data)
except FormValidateError as form_error:
return form_validate_error_message(request, schema,
form_error)
except Exception as ex:
return response_parms_error(request, ex.message)
else:
form_data = request.json
check_result = check_json_schema_v2(schema, form_data)
if check_result:
return json_schema_error_message(request, schema, check_result)
try:
return func(request, form_data, *args, **kwargs)
except ExceptionResp as ex:
return response_data(ex.resp)
def do_GET(self):
# Handle well-behaved bots
_path = self.path.strip()
log.info(u"Request path: %s" % _path)
if _path == u"/robots.txt":
self.send(u"User-agent: *\nDisallow: /\n")
elif _path != u"/":
self.send_error(403, u"Bad request.\n")
else:
# path is /
#
# examine some headers
# Client candidates:
""" cmus """
# GET / HTTP/1.0
# Host: 0x7be.org
# User-Agent: cmus/v2.3.2
# Icy-MetaData: 1
""" mplayer """
# GET / HTTP/1.0
# Host: 0x7be.org:18944
# User-Agent: MPlayer/SVN-r31347-4.5.0
# Icy-MetaData: 1
# Connection: close
# GET / HTTP/1.0
# Accept: */*
# User-Agent: NSPlayer/4.1.0.3856
# Host: 0x7be.org:18944
# Pragma: xClientGUID={c77e7400-738a-11d2-9add-0020af0a3278}
# Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=0:0,
# request-context=1,max-duration=0
# Connection: Close
""" squeezebox """
# Connection: close
# Cache-Control: no-cache
# Accept: */*
# Host: localhost:18944
# User-Agent: iTunes/4.7.1 (Linux; N; Linux; i686-linux; EN;
# utf8) SqueezeCenter, Squeezebox Server/7.4.1/28947
# Icy-Metadata: 1
H, icy_client = self.headers, False
try:
icy_client = (int(H[u'icy-metadata']) == 1)
except KeyError, e:
log.error(u"non-icy client: %s" % e)
log.error(self.address_string())
if not icy_client:
self.send_response(
400, u"Bad client.\n Try http://cmus.sourceforge.net/\n")
return False
user_agent = None
try:
user_agent = H[u'user-agent']
except KeyError, e:
log.exception(u"Couldn't get user agent.")
def call(self):
currnet_thread = threading.current_thread
self.generate_list.append(currnet_thread)
event = self.q.get()
while event != self.StopEvent:
func, arguments, callback = event
try:
result = func(*arguments)
status = True
except Exception as e:
status = False
result = e
log.error("调用函数执行错误 {}").format(result)
if status:
if callback is not None:
try:
callback(status, result)
except Exception as e:
log.error("回调函数执行错误 {}").format(e)
if self.terminal:
event = self.StopEvent
else:
with self.worker_state(self.free_list, currnet_thread):
event = self.q.get()
else:
self.generate_list.remove(currnet_thread)
def start(self):
pid = self.read_pid()
if pid:
log.error(u"Server already running, pid %s." % pid)
sys.exit(-1)
else:
self.write_pid(os.getpid())
server = None
try:
time.sleep(0.001)
server = Server((Config.hostname, self.port))
log.info(u"Bloops and bleeps at http://%s:%s" %
server.server_address)
server.serve_forever()
# will never reach this line
except socket.error, se:
if se.errno == errno.EACCES:
log.warn(u"Bad port: %s" % self.port)
sys.exit(se.errno)
elif se.errno == errno.ECONNREFUSED:
log.warn(u"Connection refused: %s" % self.port)
sys.exit(se.errno)
else:
log.exception(se)
def get_redis_conn(cls):
try:
conn = redis.Redis(connection_pool=pool)
return conn
except BaseException as e:
log.error(str(e))
raise CacheError('can not get conn from redis pool')
def get_one_blog_comment(comment_list):
try:
comment_list = comment_list[:-1].split(",")
except BaseExpection as e:
log.error(e)
raise ArgsError('args comment_list format error')
comment_list = Comment.get_one_blog_comment(reversed(comment_list))
return jsonify([comment.to_json() for comment in comment_list])
def __init__(self, message=None, status=None, http_status_code=None):
super().__init__(message, status)
self.message = message
self.status = status
self.http_status_code = http_status_code
log.error(
"an raise happen with message: {}, status: {}, http_status_code: {}"
.format(message, str(status), str(http_status_code)))
def send_email_to_user(self, *args, **kwargs):
activity_id = kwargs.get('activity_id')
activity = activity_manager.get_activity(activity_id)
if activity is None:
log.error('不存在id为{}的活动'.format(activity_id))
return
start_id = 0
while start_id >= 0:
start_id = _handler(start_id, activity_id)
def connect_redis():
connect_time = 5
while connect_time:
try:
pool = redis.ConnectionPool(host=config.REDIS.HOST, port=config.REDIS.PROT, db=0)
return pool
except BaseException as e:
log.error(str(e))
log.error('connect redis fail, try it in 3 second....')
time.sleep(3) # in second
connect_time -= 1
raise CacheError('can not connect redis')
def var_(*args):
(_, nid, cargs) = args
node = nd.Cluster(nid)
log.info('var: {0}'.format(str(node)))
endog = node.readings.dropna()
if not endog.empty and cargs.lags:
maxlags = max(cargs.lags)
try:
res = vm.VAR(endog=endog).fit(maxlags=maxlags)
mkplot(node, 'var', res, cargs.output, maxlags)
except (LinAlgError, ValueError) as err:
log.error(err)
def read_requests(self, r_clients):
responses = {}
for sock in r_clients:
try:
data = sock.recv(1024)
responses[sock] = data.decode('utf-8')
log.debug(f'data = {responses[sock]}')
except Exception as e:
log.error(
f'Клиент {sock.fileno()} {sock.getpeername()} отключился\n\t\t{e}'
)
self.clients.remove(sock)
return responses
def var_(*args):
(_, nid, cargs) = args
node = nd.Cluster(nid)
log.info('var: {0}'.format(str(node)))
endog = node.readings.dropna()
if not endog.empty and cargs.lags:
maxlags = max(cargs.lags)
try:
res = vm.VAR(endog=endog).fit(maxlags=maxlags)
mkplot(node, 'var', res, cargs.output, maxlags)
except (LinAlgError, ValueError) as err:
log.error(err)
def start_telemetry(self):
if self.session.is_active:
log.error(
"A new session can't be started when another one is active")
return False
# Update user config
self.api_key = self.api_key_field.text()
self.broadcast_mode_enabled = self.udp_broadcast_checkbox.isChecked()
self.user_config.set("API_KEY", self.api_key)
self.user_config.set("UDP_BROADCAST_ENABLED",
self.broadcast_mode_enabled)
# Validate API key via F1Laps API
self.validate_api_key(self.api_key)
def write_responses(self, requests, w_clients):
for sock in self.clients:
if sock in requests:
try:
resp = requests[sock].encode('utf-8')
for i in w_clients:
i.send(resp)
except Exception as e:
log.error(
f'Клиент {sock.fileno()} {sock.getpeername()} отключился\n\t\t{e}'
)
sock.close()
self.clients.remove(sock)
def ols_(*args):
(_, nid, cargs) = args
log.info('ols: {0}'.format(nid))
node = nd.Cluster(nid)
for i in cargs.lags:
node.addlag(i)
idx = repr(node)
endog = node.readings[idx]
exog = node.readings.drop(idx, axis=1)
try:
res = sm.OLS(endog=endog, exog=exog, missing='drop').fit()
mkplot(node, 'ols', res, cargs.output)
except (LinAlgError, ValueError) as err:
log.error('{0}: {1},{2}'.format(err, endog.shape, exog.shape))
def ols_(*args):
(_, nid, cargs) = args
log.info('ols: {0}'.format(nid))
node = nd.Cluster(nid)
for i in cargs.lags:
node.addlag(i)
idx = repr(node)
endog = node.readings[idx]
exog = node.readings.drop(idx, axis=1)
try:
res = sm.OLS(endog=endog, exog=exog, missing='drop').fit()
mkplot(node, 'ols', res, cargs.output)
except (LinAlgError, ValueError) as err:
log.error('{0}: {1},{2}'.format(err, endog.shape, exog.shape))
def execute(cls, sql):
threadLock.acquire()
log.info('execute sql: {}'.format(sql))
try:
cls.global_db.begin()
cursor = cls.global_db.cursor()
cursor.execute(sql)
result = cursor.fetchall()
cls.global_db.commit()
cursor.close()
return result
except BaseException as e:
log.error(str(e))
cls.global_db.rollback()
raise DatabaseError("internal database error")
finally:
threadLock.release()
def set_data(self):
try:
# get data from manager (see lib/server.py)
DataManager.register('get_data')
# manager port is one higher than listen port
manager = DataManager(address=(Config.hostname, self.port + 1),
authkey=Config.authkey)
manager.connect()
except socket_error as serr:
import errno
if serr.errno != errno.ECONNREFUSED: raise serr
log.error("Connection refused.")
sys.exit()
self.data = manager.get_data()
playlist_data = None
try:
playlist_data = self.data['playlist']
except KeyError:
playlist_data = PlaylistFile.read()
if playlist_data is None:
playlist_data = PlaylistFile.read()
# set default playlist data
default_data = {
u'playlist': playlist_data,
u'continue': False,
u'repeat': False,
u'shuffle': False,
u'status': u'stopped',
u'index': 0,
u'song': None,
u'skip': False,
u'sum_bytes': 0,
u'progress': 0,
u'elapsed': 0,
}
for k, v in default_data.items():
try:
if self.data[k] is None:
self.data[k] = default_data[k]
except KeyError:
self.data[k] = default_data[k]
def start(self):
pid = self.read_pid()
if pid:
log.error("Server already running, pid %s." % pid)
sys.exit( -1 )
else:
self.write_pid( os.getpid() )
try:
time.sleep(0.001)
Server((Config.hostname, self.port))
# will never reach this line
except socket.error, se:
if se.errno == errno.EACCES:
log.warn("Bad port: %s" % self.port)
sys.exit( se.errno )
else:
log.exception(se)
def connect_database():
connect_time = 5
while connect_time:
try:
db = pymysql.connect(
user=config.DB.USER, \
password=config.DB.PASSWORD, \
database=config.DB.DATABASE, \
host=config.DB.HOST, \
autocommit=False
)
return db
except BaseException as e:
log.error(str(e))
log.error('connect database fail, try it in 3 second....')
time.sleep(3) # in second
connect_time -= 1
raise DatabaseError('can not connect database')
def set_data(self):
try:
# get data from manager (see lib/server.py)
DataManager.register('get_data')
# manager port is one higher than listen port
manager = DataManager(address=(Config.hostname, self.port + 1),
authkey=Config.authkey)
manager.connect()
except socket_error as serr:
import errno
if serr.errno != errno.ECONNREFUSED: raise serr
log.error("Connection refused.")
sys.exit()
self.data = manager.get_data()
playlist_data = None
try: playlist_data = self.data['playlist']
except KeyError: playlist_data = PlaylistFile.read()
if playlist_data is None:
playlist_data = PlaylistFile.read()
# set default playlist data
default_data = {
u'playlist' : playlist_data,
u'continue' : False,
u'repeat' : False,
u'shuffle' : False,
u'status' : u'stopped',
u'index' : 0,
u'song' : None,
u'skip' : False,
u'sum_bytes' : 0,
u'progress' : 0,
u'elapsed' : 0,
}
for k, v in default_data.items():
try:
if self.data[k] is None:
self.data[k] = default_data[k]
except KeyError:
self.data[k] = default_data[k]
def f(*args):
(index, nid, (window, oneday, threshold, agg)) = args
log.info('{0} create'.format(nid))
node = nd.Node(nid)
winlen = nd.winsum(window)
log.info('{0} apply'.format(nid))
#
# determine which windows constitute a traffic event
#
df = pd.rolling_apply(node.readings.speed,
winlen,
g,
min_periods=winlen,
args=[window, threshold])
df.dropna(inplace=True)
#
# aggregate the results
#
log.info('{0} aggregate'.format(nid))
if df.empty:
log.error('{0}: No observations'.format(nid))
return []
# items = zip(range(oneday), [ [] ] * oneday)
totals = OrderedDict()
for i in range(oneday):
totals[i] = [0]
for i in df.index:
key = cp.bucket(i)
totals[key].append(df.ix[i])
vals = [agg(x) for x in totals.values()]
vals.append(nid) # this is important
return vals
def _log_f1laps_response_status(self, response, descriptor):
if response is None:
log.info("%s failed, empty response" % descriptor)
return False
elif response.status_code >= 200 and response.status_code < 300:
log.info("%s succeeded" % descriptor)
return True
elif response.status_code >= 400 and response.status_code < 500:
# Log level depends on error type
error_message = self._get_error_message(response.content)
if error_message == 'You need an active subscription to use the F1Laps Telemetry App.':
log.info("%s failed: no active F1Laps subscription" %
descriptor)
else:
log.error("%s failed: %s" % (descriptor, error_message))
return False
else:
log.error("%s failed: %s" %
(descriptor, self._get_error_message(response.content)))
return False
def create_lap_in_f1laps(self, lap_number):
""" Send Lap to F1Laps """
response = F1LapsAPI(self.f1laps_api_key, "f12020").lap_create(
track_id = self.track_id,
team_id = self.team_id,
conditions = self.map_weather_ids_to_f1laps_token(),
game_mode = "time_trial", # hardcoded as the only supported value
sector_1_time = self.lap_list[lap_number]["sector_1_time_ms"],
sector_2_time = self.lap_list[lap_number]["sector_2_time_ms"],
sector_3_time = self.lap_list[lap_number]["sector_3_time_ms"],
setup_data = self.setup,
is_valid = self.lap_list[lap_number].get("is_valid", True),
telemetry_data_string = self.get_lap_telemetry_data(lap_number)
)
if response.status_code == 201:
log.info("Lap #%s successfully created in F1Laps" % lap_number)
return True
else:
log.error("Error creating lap %s in F1Laps" % lap_number)
log.error("F1Laps API response: %s" % json.loads(response.content))
return False
def f(*args):
(index, nid, (window, oneday, threshold, agg)) = args
log.info('{0} create'.format(nid))
node = nd.Node(nid)
winlen = nd.winsum(window)
log.info('{0} apply'.format(nid))
#
# determine which windows constitute a traffic event
#
df = pd.rolling_apply(node.readings.speed, winlen, g, min_periods=winlen,
args=[ window, threshold ])
df.dropna(inplace=True)
#
# aggregate the results
#
log.info('{0} aggregate'.format(nid))
if df.empty:
log.error('{0}: No observations'.format(nid))
return []
# items = zip(range(oneday), [ [] ] * oneday)
totals = OrderedDict()
for i in range(oneday):
totals[i] = [ 0 ]
for i in df.index:
key = cp.bucket(i)
totals[key].append(df.ix[i])
vals = [ agg(x) for x in totals.values() ]
vals.append(nid) # this is important
return vals
def start(self):
pid = self.read_pid()
if pid:
log.error(u"Server already running, pid %s." % pid)
sys.exit( -1 )
else:
self.write_pid( os.getpid() )
server = None
try:
time.sleep(0.001)
server = Server((Config.hostname, self.port))
log.info(u"Bloops and bleeps at http://%s:%s" % server.server_address)
server.serve_forever()
# will never reach this line
except socket.error, se:
if se.errno == errno.EACCES:
log.warn(u"Bad port: %s" % self.port)
sys.exit( se.errno )
elif se.errno == errno.ECONNREFUSED:
log.warn(u"Connection refused: %s" % self.port)
sys.exit( se.errno )
else:
log.exception(se)
def send_to_f1laps(self):
if not self.session:
log.error("No session defined for %s" % self)
return None
if self.session.is_time_trial():
log.info("Skipping F1Laps sync because it's Time Trial, for %s" %
self)
return None
if not self.f1laps_api_class:
log.error("No F1Laps API class defined for %s" % self)
return None
if self.session.has_ended():
log.info("Skipping F1Laps sync because session has ended, for %s" %
self)
return None
if not self.session.f1_laps_session_id:
success = self.session.send_session_to_f1laps()
if not success:
log.error("No session ID defined for %s" % self)
return None
api = self.f1laps_api_class(self.session.f1laps_api_key,
self.session.game_version)
success = api.penalty_create(
f1_laps_session_id=self.session.f1_laps_session_id,
penalty_type=self.penalty_type,
infringement_type=self.infringement_type,
vehicle_index=self.vehicle_index,
other_vehicle_index=self.other_vehicle_index,
time_spent_gained=self.time_spent_gained,
lap_number=self.lap_number,
places_gained=self.places_gained,
)
log.info("Penalty %s successfully created in F1Laps" %
self) if success else log.info(
"Penalty %s not created in F1Laps" % self)
return success
def do_GET(self):
log.debug("post")
# Handle well-behaved bots
_path = self.path.strip()
log.info("Request path: %s" % _path)
if _path == "/robots.txt":
self.send("User-agent: *\nDisallow: /\n")
elif _path != "/":
self.send_error(403, "Bad request.\n")
else:
# path is /
#
# examine some headers
# Client candidates:
""" cmus """
# GET / HTTP/1.0
# Host: 0x7be.org
# User-Agent: cmus/v2.3.2
# Icy-MetaData: 1
""" mplayer """
# GET / HTTP/1.0
# Host: 0x7be.org:18944
# User-Agent: MPlayer/SVN-r31347-4.5.0
# Icy-MetaData: 1
# Connection: close
# GET / HTTP/1.0
# Accept: */*
# User-Agent: NSPlayer/4.1.0.3856
# Host: 0x7be.org:18944
# Pragma: xClientGUID={c77e7400-738a-11d2-9add-0020af0a3278}
# Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=0:0,
# request-context=1,max-duration=0
# Connection: Close
""" squeezebox """
# Connection: close
# Cache-Control: no-cache
# Accept: */*
# Host: localhost:18944
# User-Agent: iTunes/4.7.1 (Linux; N; Linux; i686-linux; EN;
# utf8) SqueezeCenter, Squeezebox Server/7.4.1/28947
# Icy-Metadata: 1
H, icy_client = self.headers, False
try:
icy_client = (int(H['icy-metadata']) == 1)
except KeyError, e:
log.error("non-icy client: %s" % e)
log.error(self.address_string())
if not icy_client:
self.send_response(400, "Bad client.\n Try http://cmus.sourceforge.net/\n")
return False
user_agent = None
try: user_agent = H['user-agent']
except KeyError, e: log.exception("Couldn't get user agent.")
if user_agent: log.info("User-Agent: %s" % user_agent)
self.do_HEAD( icy_client )
Streamer( self.request, self.server.port ).stream( icy_client )
def stop_telemetry(self):
if not self.session.is_active:
log.error("Session can't be stopped as there is no active session")
return None
self.session.kill()
return None
def __remove_token(self, token):
try:
self.__worker_queue.remove(token)
except Exception as e:
log.error(f"删除{token}出错:{e}")
def run(self):
self.__socket = zmq.Context().socket(zmq.PAIR)
try:
if self.__role == "server":
self.__socket.bind(self.__url)
else:
self.__socket.connect(self.__url)
except Exception as e:
log.error("ZMQ连接参数错误，信息：%s" % e)
return
executor = ThreadPool(max_pool=5, queue_size=10**8)
log.info("Worker开启，服务角色为【%s】，创建最大线程数为【%s】的线程池处理请求" %
(self.__role, self.__max_workers))
log.info("等待请求 ...")
while True:
try:
try:
msg = self.__socket.recv_json()
except Exception as e:
self.__send_json({
"token": None,
"result": None,
"err": "数据接收出错"
})
continue
log.info("接收到消息: %s" % msg)
try:
assert msg.get("token") is not None
assert msg.get("function") is not None
assert msg.get("args") is not None
except AssertionError as e:
self.__send_json({
"token": msg.get("token"),
"result": None,
"err": "json格式出错，无法完成解析"
})
continue
if msg["token"] in self.__worker_queue:
self.__send_json({
"token": msg["token"],
"result": None,
"err": "token=%s对应的请求正在执行" % msg["token"]
})
continue
else:
self.__worker_queue.add(msg["token"])
try:
executor.submit(fn=execute,
callback=partial(self.done,
token=msg["token"]),
timeout=5,
**msg)
except Exception as e:
self.__send_json({
"token": msg["token"],
"result": None,
"err": "提交请求出错"
})
self.__remove_token(msg["token"])
continue
except Exception as exce:
log.error(f"错误信息:{exce}")
def send_mail(self, state, msg):
now = time.strftime("%Y-%m-%d %H:%M:%S")
if state != contants.ALARM_OK:
mail_center.add_alarm_info({"ts": now,"name":self.rule.name,"host":self.host,"state":state,"msg":msg})
log.error("send mail %s %s %s" % (self.rule.name, state, msg) )
def send_mail(self, alarm_state):
now = time.strftime("%Y-%m-%d %H:%M:%S")
alarm_info = alarm_state.copy()
alarm_info["ts"] = now
mail_center.add_alarm_info(alarm_info)
log.error("send mail %s %s" % (alarm_info["key_word"], alarm_info["msg"]))
