def connect(cls, retry=RETRY): logger.info('Start connection...') client = None try: for trying in range(1, retry + 1): client = MongoClient(MongoConf.URL) try: info = client.server_info() logger.info(info) break except errors.ServerSelectionTimeoutError as error: logger.info(f' { error } : retry...{ trying }/{ retry }') except Exception as error: client = None logger.error(error) finally: cls.CLIENT = client logger.info('End connection!!!') return client
def run(self): try: _, temp_path = mkstemp() if config.get('USE_MOTION') is True: response = requests.get(config.get('MOTION_EYE_SNAPSHOT_URL')) buffered_reader = BufferedReader(BytesIO(response.content)) logger.debug('Image retrieved from motionEye') with open(temp_path, 'wb') as capture: capture.write(response.content) else: command = [ config.get('WEBCAM_BIN'), '--device', config.get('WEBCAM_DEVICE', '/dev/video0'), '--resolution', config.get('WEBCAM_RESOLUTION', '1920x1080'), '--no-banner', '--delay', config.get('WEBCAM_DELAY', '2'), '--rotate', config.get('WEBCAM_ROTATE', '180'), '--jpeg', config.get('WEBCAM_JPG_COMP', '80'), temp_path ] if logger.level > logging.DEBUG: command.insert(1, '--quiet') call(command) buffered_reader = open(temp_path, 'rb') logger.debug('Image {} captured from webcam'.format(temp_path)) notification = Notification(buffered_reader) notification.run() # Move picture in place as background for WebRTC call. destination_folder = os.path.join( config.ROOT_PATH, 'app', 'www', 'mobile', 'static', 'img' ) # Create destination folder if it does not exist if not os.path.exists(destination_folder): os.mkdir(destination_folder) destination = os.path.join( destination_folder, 'capture.jpg' ) move(temp_path, destination) except Exception as e: logger.error('Camera Helper: {}'.format(str(e))) return
def response(event, context): line_header = "X-Line-Signature".lower() signature = event["headers"][line_header] body = event["body"] ok_json = { "isBase64Encoded": False, "statusCode": 200, "headers": {}, "body": "" } error_json = { "isBase64Encoded": False, "statusCode": 403, "headers": {}, "body": "Error", } try: handler.handle(body, signature) except LineBotApiError as e: logger.error("Got exception from LINE Messaging API: %s\n" % e.message) for m in e.error.details: logger.error(" %s: %s" % (m.property, m.message)) return error_json except InvalidSignatureError: return error_json else: return ok_json
def time_limit_parse(author, rss_url): try: items = parse_rss(author, rss_url) logger.info(rss_url + ' over') return items except func_timeout.exceptions.FunctionTimedOut as e: logger.error(rss_url) logger.error(e) return None
def get_user_from_authorization(cls, authorization): try: plain = aes.decrypt(authorization) if ';' not in plain: return None except: logger.error(traceback.format_exc()) return None id = plain.split(';')[0] return cls.query_by_id(id)
def insert(cls, collection=None, data={}, retry=RETRY): res = None try: res = cls.CLIENT[collection].insert_one(data, session=cls.SESSION) logger.info(f'inserted!!! ObjectId: { ObjectId(res.inserted_id) }') except Exception as error: logger.error(error) return res
def save(self, force_insert=False, only=None): if self.id is not None: self.modified_date = datetime.now() try: return super().save(force_insert=force_insert, only=only) except Exception as e: logger.error("{}.save - {}".format(self.__class__.__name__, str(e))) return False
def save(self, force_insert=False, only=None): if self.id is None: self.token = os.urandom(32).hex() try: return super().save(force_insert=force_insert, only=only) except Exception as e: logger.error("{}.save - {}".format(self.__class__.__name__, str(e))) return False
def run(self): try: logger.debug('Ring bell, ring bell...') for i in range(0, self.__times): self.__buzzer.on() sleep(self.PAUSE_BETWEEN_STATES) self.__buzzer.off() sleep(self.PAUSE_BETWEEN_STATES) except Exception as e: logger.error(e) return # Close thread
def error_handlers(response: Response) -> None: status_code = response.status_code if status_code == 403: raise HTTPException( status_code=403, detail='Forbidden') if status_code == 400: raise HTTPException( status_code=400, detail='Bad request') if status_code == 422: logger.error(f'Validation error: {response.json()}') raise HTTPException( status_code=422, detail='Validation error') if status_code != 200: raise HTTPException(status_code=status_code)
def select(cls, collection=None, cond=None, filter=None, retry=RETRY): res = None try: res = list(cls.CLIENT[collection].find(cond, filter, session=cls.SESSION)) cls.CLIENT[collection].aggregate(pipeline=pipe) logger.info(f'selected!!! length: { len( res ) }') except Exception as error: logger.error(error) return res
def get_network(self, metadata=False, limit=None): """ Constructs a citation network from the edge list. :param metadata: whether or not to include metadata :param limit: a limit to the number of documents to return :return: the NetworkX graph """ if self.cache: try: return nx.read_gpickle(self.make_filename(prefix="GRAPH")) except FileNotFoundError: logger.warn("No file on record, creating new graph") logger.info( "Generating network from data (metadata={}, limit={})".format( metadata, limit)) df_edges = self.get_edges() if limit is not None: df_edges = df_edges.head(limit) # for key in self.get_citation_keys(): # df_edges[key] = df_edges[key].str.strip() G = nx.from_pandas_edgelist(df_edges, source='citation_id', target='patent_id', edge_attr="date", create_using=nx.DiGraph()) if metadata: self.ensure_meta() for entry in self.df_meta.to_dict(orient='records'): try: G.nodes[entry['patent_number']].update({ key: val for key, val in entry.items() if key != 'patent_number' }) except KeyError: logger.error("Couldn't find network entry for {}".format( entry['patent_number'])) logger.info("Generated network with {} nodes and {} edges".format( len(G.nodes), len(G.edges))) self.write_graph_to_file(G, self.make_filename(prefix="GRAPH")) return G
def create_role(db: Session, role_data: RoleModel) -> Role: try: role = Role(**role_data.dict()) db.add(role) db.commit() db.refresh(role) except (DataError, OperationalError, IntegrityError) as e: logger.error(e) raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="invalid data") except Exception as e: logger.error(e) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="unknown error") else: return role
def create_policy(db: Session, policy_data: PolicyModel) -> Policy: try: policy = Policy(**policy_data.dict()) db.add(policy) db.commit() db.refresh(policy) except (DataError, OperationalError, IntegrityError) as e: logger.error(e) raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="invalid data") except Exception as e: logger.error(e) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="unknown error") else: return policy
def create_user(db: Session, user_data: UserModel) -> User: try: user = User(**user_data.dict()) db.add(user) db.commit() db.refresh(user) except (DataError, OperationalError, IntegrityError) as e: logger.error(e) raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="invalid data") except Exception as e: logger.error(e) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="unknown error") else: return user
def read(cls, message, last_time_received): try: message_datetime = datetime.fromtimestamp(message['timestamp']) delta = message_datetime - last_time_received if delta.seconds >= int(config.get('BUTTON_PRESS_THRESHOLD')): if message.get('device') == config.get( 'BACK_DOORBELL_DEVICE_MAC'): telegram = Notification(front_door=False) telegram.start() chime = Chime( times=config.get('BACK_DOORBELL_RINGS_NUMBER')) chime.run() # No need to run it as thread else: logger.debug('Relax dude! Stop pushing the button') except KeyError: logger.error('Message is invalid.') return False
def send(cls, message, type_): message.update({ 'type': type_, 'timestamp': time.time(), 'signature': config.get('MESSAGE_BROKER_KEY') }) host = config.get('MESSAGE_BROKER_HOST') port = int(config.get('MESSAGE_BROKER_PORT')) try: with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((host, port)) s.sendall(json.dumps(message).encode('utf-8')) except ConnectionRefusedError: logger.error('Could not connect to socket') return False return True
def kill(cls, slug): logger.debug('Process.run: KILL ' + slug) if slug is None: processes = Process.select().where(cls.slug.is_null(False)) else: processes = Process.select().where(cls.slug == slug) for process in processes: cp = subprocess.run(['kill', '-9', str(process.pid)], stderr=subprocess.PIPE) if cp.returncode != 0: logger.error('Process #{} ({}) could not be killed'.format( process.pid, process.slug)) else: logger.debug('Process #{} ({}) has been killed'.format( process.pid, process.slug)) process.delete_instance()
def get_security_body(self, msg_encrypt, msg_signature, timestamp, nonce): '''获取加密消息体''' check_data = [self.token, msg_encrypt, timestamp, nonce] check_data.sort() sign = sha1(''.join(check_data)) if sign == msg_signature: try: aes_key = base64.b64decode(f'{self.encoding_aes_key}=') aes = AESecurity(aes_key) aes_msg = base64.b64decode(msg_encrypt) body = aes.decrypt(aes_msg) res = body[20:body.rfind('>') + 1] return 200, res except Exception as e: logger.error(e) return 500, '加密信息解析失败' else: return 500, '加密校验失败'
def return_response(cls, data={}, status=200, message="", headers={}): try: logger.debug('return %s %s', status, message) except: logger.error(traceback.format_exc()) try: filters = request.args.get('filters') if filters: fd = BaseDict(data).filter(*filters.split(',')) data = fd except: logger.error(traceback.format_exc()) data = data try: if isinstance(data, db.Model): data = data.format() elif isinstance(data, list) and data and \ isinstance(data[0], db.Model): data = [o.format() for o in data] except: logger.error(traceback.format_exc()) data = data res = cls( data=data, status=status, message=message ).to_dict() return make_response(jsonify(res), status, headers)
def run(self): now = datetime.datetime.now().replace(microsecond=0).isoformat() if self.__picture is None: if self.__front_door: token = Token() token.save() auth_web_app_link = 'https://{domain}:{port}?token={token}'.format( message=config.get('NOTIFICATION_FRONT_DOOR_MESSAGE'), domain=config.get('WEB_APP_DOMAIN_NAME'), port=config.get('WEB_APP_PORT'), token=token.token) message = '{message}\n' \ '[{call_cta_label}]({call_cta_link})'.\ format( message=_('daemon/notification/front_door_message'), call_cta_label=_('daemon/notification/call_cta_label'), call_cta_link=auth_web_app_link) else: message = _('daemon/notification/back_door_message') bot.send_message(chat_id=config.get('TELEGRAM_CHAT_ID'), text=message, parse_mode=telegram.ParseMode.MARKDOWN) logger.debug('Ring notification sent to Telegram') return # Close thread try: bot.send_photo(chat_id=config.get('TELEGRAM_CHAT_ID'), photo=self.__picture, caption=_('Photo'), disable_notification=True) logger.debug('Photo sent to Telegram') except Exception as e: logger.error('Could not send attachment to Telegram: {}'.format( str(e))) return # Close thread
def get(self): kind = None identifier = None try: identifier = get_kvk_number_from_request(request) kind = "kvk" except SamlVerificationException: return {"status": "ERROR", "message": "Missing SAML token"}, 400 except KeyError: # does not contain kvk number, might still contain BSN pass if not identifier: try: identifier = get_bsn_from_request(request) except InvalidBSNException: return {"status": "ERROR", "message": "Invalid BSN"}, 400 kind = "bsn" try: has_erfpacht, notifications = get_data(kind, identifier) except Timeout: return {"status": "ERROR", "message": "Timeout"}, 500 except ConnectionError as e: logger.error(f"ConnectionError {e}") return {"status": "ERROR", "message": "Connection Error"}, 500 except Exception as e: logger.exception(e) return {"status": "ERROR", "message": "Unknown error"}, 500 return { "status": "OK", "content": { "isKnown": has_erfpacht, "meldingen": notifications, }, }
def run(self, command, slug=None): logger.debug('Process.run: START ') logger.debug(command) proc = subprocess.Popen(command, stderr=subprocess.PIPE) try: command_str = ' '.join(command) self.pid = proc.pid self.slug = slug self.command = command_str if proc.returncode: logger.error( 'Process.run: Command `{}` failed: Error ({}): {}'.format( command_str, proc.returncode, proc.stderr.read().encode())) self.save() except Exception as e: logger.error('Process.run: Command `{}` failed: Error: {}'.format( command_str, str(e))) logger.debug('Process.run: END ' + command_str)
def transWrap(pipeline=None): if cls.CLIENT != None and pipeline != None: logger.info(pipeline) ''' Setting pipeline ''' session = cls.CLIENT.start_session() res = None try: session.start_transaction() res = func(client=cls.CLIENT[database], session=session) session.commit_transaction() except Exception as error: session.abort_transaction() logger.error(error) return res else: return func(client=None, session=None)
def before_request(): g.request_start_time = time.time() try: data = request.data logger.debug('data %s', data) args = request.args or {} logger.debug('args %s', args) json_data = request.json or {} logger.debug('json %s', json_data) form_data = request.form or {} logger.debug('form %s', form_data) h_data = request.headers or {} for k, v in h_data: logger.debug('header %s: %s', k, v) except Exception as e: logger.error('params %s', e) logger.error(traceback.format_exc()) navs = Nav.query_items() g.navs = navs g.current_nav = Nav.query_item(url=request.path) authorization = request.cookies.get('authorization') or\ request.headers.get(BaseConfig.HEAD_AUTHORIZATION) if not authorization: user = None else: user = User.get_user_from_authorization(authorization) if request.path.startswith('/admin'): if not user and (request.path != '/admin/login' or request.path.startswith('/static')): return redirect('/admin/login') g.current_user = user logger.debug('current_user %s', g.current_user)