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 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 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"]))