def run_hook(
logger: logging.Logger,
identifier: str,
args: argparse.Namespace,
actions: typing.List[str],
) -> argparse.Namespace:
"""Run hook actions"""
for action_name in actions:
logger.info("Run %s action %s", identifier.lower(), action_name)
func = get_function(action_name)
if not func:
logger.warning(
"Failed to get action function instance. Stop process.")
exit(1)
try:
args = func(identifier, args)
except:
logger.exception("Error occurs during %s action. Stop process.",
identifier.lower())
exit(1)
if not isinstance(args, argparse.Namespace):
logger.error(
"Expect namespace object from %s's return value. Got %s",
action_name,
type(args).__name__,
)
exit(1)
return args
def warm_start_model(model: nn.Module, warm_model: CheckpointTacotron,
hparams: HParams, logger: Logger):
warm_model_hparams = warm_model.get_hparams(logger)
use_speaker_emb = hparams.use_speaker_embedding and warm_model_hparams.use_speaker_embedding
speakers_embedding_dim_mismatch = use_speaker_emb and (
warm_model_hparams.speakers_embedding_dim !=
hparams.speakers_embedding_dim)
if speakers_embedding_dim_mismatch:
msg = "Mismatch in speaker embedding dimensions!"
logger.exception(msg)
raise Exception(msg)
symbols_embedding_dim_mismatch = warm_model_hparams.symbols_embedding_dim != hparams.symbols_embedding_dim
if symbols_embedding_dim_mismatch:
msg = "Mismatch in symbol embedding dimensions!"
logger.exception(msg)
raise Exception(msg)
copy_state_dict(
state_dict=warm_model.state_dict,
to_model=model,
ignore=hparams.ignore_layers + [
SYMBOL_EMBEDDING_LAYER_NAME,
# ACCENT_EMBEDDING_LAYER_NAME,
SPEAKER_EMBEDDING_LAYER_NAME
])
def read(
self,
logger: logging.Logger,
config: Mapping[str, Any],
catalog: ConfiguredAirbyteCatalog,
state: MutableMapping[str,
Any] = None) -> Iterable[AirbyteMessage]:
state = state or {}
client = self._get_client(config)
logger.info(f"Starting syncing {self.name}")
total_state = copy.deepcopy(state)
for configured_stream in catalog.streams:
try:
yield from self._read_stream(
logger=logger,
client=client,
configured_stream=configured_stream,
state=total_state)
except Exception:
logger.exception(
f"Encountered an exception while reading stream {self.name}"
)
raise
logger.info(f"Finished syncing {self.name}")
async def main(loop: AbstractEventLoop, log: Logger, args: Args) -> int:
try:
proc = await run_build(loop, log, args)
return proc.return_code
except Exception as e:
log.exception("unhandled exception in main: '%s'", e)
return 1
async def _call_hook(hook_func: HookType, model: models.Base,
local: LocalRequestData, logger: logging.Logger) -> Any:
"""
Call the specified hook function with the supplied three arguments
"""
if hook_func is not None and isinstance(hook_func, Callable):
try:
if asyncio.iscoroutinefunction(hook_func):
logger.debug(
f"Calling hook coroutine {hook_func} with {model} ...")
return await hook_func(model, local, logger)
else:
logger.debug(
f"Calling hook function {hook_func} with {model} ...")
return hook_func(model, local, logger)
except sqlalchemy.exc.DBAPIError as exc:
raise await _handle_db_exception(local.session, exc,
logger) from exc
except TypeError as exc:
logger.exception(
f"Broken hook function {hook_func} raised: {exc} (TypeError)")
raise
except APIException as exc:
logger.exception(f"APIException: {exc!r} during hook {hook_func}")
raise
elif hook_func is not None:
raise TypeError(f"{hook_func!r} object is not callable")
def update_forked_repository(yang_models: str, LOGGER: logging.Logger) -> None:
""" Check whether forked repository yang-catalog/yang is up-to-date with YangModels/yang repository.
Push missing commits to the forked repository if any are missing.
Arguments:
:param yang_models (str) path to the directory where YangModels/yang repo is cloned
:param LOGGER (logging.Logger) formated logger with the specified name
"""
try:
main_repo = repoutil.load(yang_models,
'{}/YangModels/yang.git'.format(github_url))
origin = main_repo.repo.remote('origin')
fork = main_repo.repo.remote('fork')
# git fetch --all
for remote in main_repo.repo.remotes:
info = remote.fetch('main')[0]
LOGGER.info('Remote: {} - Commit: {}'.format(
remote.name, info.commit))
# git pull origin main
origin.pull('main')[0]
# git push fork main
push_info = fork.push('main')[0]
LOGGER.info('Push info: {}'.format(push_info.summary))
if 'non-fast-forward' in push_info.summary:
LOGGER.warning('yang-catalog/yang repo might not be up-to-date')
except GitCommandError:
LOGGER.exception('yang-catalog/yang repo might not be up-to-date')
def do_checking_reminders(log: Logger, bot: Bot):
while True:
try:
expected_time = DT.datetime.now() - DT.timedelta(seconds=1)
query = (
Reminder
.select()
.where(
(Reminder.is_sent == False)
& (Reminder.finish_time <= expected_time)
)
.order_by(Reminder.finish_time)
)
for reminder in query:
log.info('Send reminder: %s', reminder)
bot.send_message(
chat_id=reminder.chat_id, text='⌛',
reply_to_message_id=reminder.message_id
)
reminder.is_sent = True
reminder.save()
except:
log.exception('')
finally:
time.sleep(1)
def run_forever(func: Callable, must_stop: Event, logger: Logger,
*args, **kwargs):
attempt = 0
while not must_stop.is_set():
start = time.monotonic()
try:
func(*args, **kwargs)
except Exception as e:
# Reset the attempt counter if `func` ran for 10 minutes without
# an error
if int(time.monotonic() - start) > 600:
attempt = 1
else:
attempt += 1
delay = exponential_backoff(attempt, cap=120)
if isinstance(e, (ConnectionError, TimeoutError)):
logger.warning('Connection issue: %s. Retrying in %s', e,
delay)
else:
logger.exception('Unexpected error. Retrying in %s', delay)
must_stop.wait(delay.total_seconds())
def do_event_action(history: Any, settings: Settings, config: Dict[str, Any], logger: Logger,
event_columns: Any, action: Any, event: Any, user: Any) -> None:
if action["disabled"]:
logger.info("Skipping disabled action %s." % action["id"])
return
try:
action_type, action_settings = action["action"]
if action_type == 'email':
to = _escape_null_bytes(
_substitute_event_tags(event_columns, action_settings["to"], event))
subject = _escape_null_bytes(
_substitute_event_tags(event_columns, action_settings["subject"], event))
body = _escape_null_bytes(
_substitute_event_tags(event_columns, action_settings["body"], event))
_send_email(config, to, subject, body, logger)
history.add(event, "EMAIL", user, "%s|%s" % (to, subject))
elif action_type == 'script':
_execute_script(
event_columns,
_escape_null_bytes(
_substitute_event_tags(event_columns, action_settings["script"],
_get_quoted_event(event, logger))), event, logger)
history.add(event, "SCRIPT", user, action['id'])
else:
logger.error("Cannot execute action %s: invalid action type %s" %
(action["id"], action_type))
except Exception:
if settings.options.debug:
raise
logger.exception("Error during execution of action %s" % action["id"])
def send(log: logging.Logger, cli: redis.Redis, *args):
try:
r = cli.execute_command('XADD', 'log', '*', *args)
except redis.RedisError as e:
log.exception('send: failed to log {}'.format(e))
sys.exit(1)
log.info('send: success {}'.format(r))
def run_coalescer(cfg: dict,
tables: List[str],
periodstr: str,
run_once: bool,
logger: Logger,
no_sqpoller: bool = False) -> None:
"""Run the coalescer.
Runs it once and returns or periodically depending on the
value of run_once. It also writes out the coalescer records
as a parquet file.
:param cfg: dict, the Suzieq config file read in
:param tables: List[str], list of table names to coalesce
:param periodstr: str, the string of how periodically the poller runs,
Examples are '1h', '1d' etc.
:param run_once: bool, True if you want the poller to run just once
:param logger: logging.Logger, the logger to write logs to
:param no_sqpoller: bool, write records even when there's no sqpoller rec
:returns: Nothing
:rtype: none
"""
try:
schemas = Schema(cfg['schema-directory'])
except Exception as ex:
logger.error(f'Aborting. Unable to load schema: {str(ex)}')
print(f'ERROR: Aborting. Unable to load schema: {str(ex)}')
sys.exit(1)
coalescer_schema = SchemaForTable('sqCoalescer', schemas)
pqdb = get_sqdb_engine(cfg, 'sqCoalescer', None, logger)
status, errmsg = validate_periodstr(periodstr)
if not status:
logger.error(errmsg)
print(f'ERROR: {errmsg}')
sys.exit(1)
while True:
try:
stats = do_coalesce(cfg, tables, periodstr, logger, no_sqpoller)
except Exception:
logger.exception('Coalescer aborted. Continuing')
# Write the selftats
if stats:
df = pd.DataFrame([asdict(x) for x in stats])
if not df.empty:
df['sqvers'] = coalescer_schema.version
df['version'] = SUZIEQ_VERSION
df['active'] = True
df['namespace'] = ''
pqdb.write('sqCoalescer', 'pandas', df, True,
coalescer_schema.get_arrow_schema(), None)
if run_once:
break
sleep_time = get_sleep_time(periodstr)
sleep(sleep_time)
def sents_convert_to_ipa(sentences: SentenceList, text_symbols: SymbolIdDict, ignore_tones: bool, ignore_arcs: bool, mode: Optional[EngToIpaMode], consider_ipa_annotations: bool, logger: Logger) -> Tuple[SymbolIdDict, SentenceList]:
sents_new_symbols = []
for sentence in sentences.items(True):
if sentence.lang == Language.ENG and mode is None:
ex = "Please specify the ipa conversion mode."
logger.exception(ex)
raise Exception(ex)
new_symbols, new_accent_ids = symbols_to_ipa(
symbols=text_symbols.get_symbols(sentence.serialized_symbols),
lang=sentence.lang,
accent_ids=deserialize_list(sentence.serialized_accents),
ignore_arcs=ignore_arcs,
ignore_tones=ignore_tones,
mode=mode,
replace_unknown_with=DEFAULT_PADDING_SYMBOL,
consider_ipa_annotations=consider_ipa_annotations,
logger=logger,
)
assert len(new_symbols) == len(new_accent_ids)
sentence.lang = Language.IPA
sentence.serialized_accents = serialize_list(new_accent_ids)
sents_new_symbols.append(new_symbols)
assert len(sentence.get_accent_ids()) == len(new_symbols)
return update_symbols_and_text(sentences, sents_new_symbols)
def _get_quoted_event(event: Any, logger: Logger) -> Any:
new_event: Dict[str, Any] = {}
fields_to_quote = [
"application", "match_groups", "text", "comment", "contact"
]
for key, value in event.items():
if key not in fields_to_quote:
new_event[key] = value
else:
try:
new_value: Any = None
if isinstance(value, list):
new_value = list(map(quote_shell_string, value))
elif isinstance(value, tuple):
new_value = value
else:
new_value = quote_shell_string(value)
new_event[key] = new_value
except Exception as e:
# If anything unforeseen happens, we use the intial value
new_event[key] = value
logger.exception("Unable to quote event text %r: %r, %r" %
(key, value, e))
return new_event
def create_instance(
cls,
nova: NovaClient,
resource_conf: OSResourceConfig,
deploy_app: OSNovaImgDeployApp,
cancellation_manager: CancellationContextManager,
logger: Logger,
) -> "NovaService":
if not deploy_app.instance_flavor:
raise ValueError("Instance flavor cannot be empty.")
logger.info(
f"Creating OpenStack Instance for Image: {deploy_app.image_id}, "
f"Flavor: {deploy_app.instance_flavor}")
create_args = cls._prepare_creating_args(deploy_app, resource_conf,
nova)
instance = nova.servers.create(**create_args)
with cancellation_manager:
instance_service = cls(instance, nova, logger)
try:
instance_service._wait_for_status(
cls.STATUS.ACTIVE, cancellation_manager=cancellation_manager)
except Exception:
logger.exception("Failed to deploy instance")
nova.servers.delete(instance)
raise
msg = f"Deploy operation done. Instance created {instance.name}:{instance.id}"
logger.info(msg)
return instance_service
def check(self, line: str, logger: logging.Logger) -> dict:
a = self.expr.fullmatch(line)
if a is None: return None
info = {}
for index in range(len(self.keys)):
key = self.keys[index]
cnv = self.types[index]
val = a[index + 1]
try:
if cnv == "float":
info[key] = float(val)
elif cnv == "int":
info[key] = int(val)
elif cnv == "degMin":
info[key] = self.__mkDegrees(val)
elif cnv == "datetime":
info[key] = self.__strptime(val)
elif cnv == "TRUE":
info[key] = True
else:
raise Exception(
"Unrecognized conversion type, {}".format(cnv))
except:
logger.exception(
"Error converting {} to type {} for {}".format(
val, cnv, key))
return None
return info
def get_client(
config: dict,
logger: logging.Logger,
protocol=ssl.PROTOCOL_SSLv23,
verify_cert: bool = False,
) -> IMAPClient:
"""Return client."""
ssl_context = ssl.SSLContext(protocol)
if not verify_cert:
ssl_context.verify_flags = ssl.CERT_OPTIONAL
else:
ssl_context.verify_mode = ssl.CERT_REQUIRED
try:
client = IMAPClient(
config["hostname"],
port=config["imap_port"],
ssl=config.get("ssl", True),
ssl_context=ssl_context,
timeout=config.get("timeout", 10),
)
except ssl.SSLError:
logger.exception("Error due to ssl.")
raise
except socket.error:
logger.exception("Could not connect to the mail server.")
raise
else:
return client
def log(logger: Logger,
*messages_to_log: str,
subtask_id: Optional[str] = None,
client_public_key: Union[bytes, str, None] = None,
logging_level: Optional[LoggingLevel] = LoggingLevel.INFO) -> None:
client_key_message = f'CLIENT_PUBLIC_KEY: {convert_public_key_to_hex(client_public_key)}. ' if client_public_key is not None else ''
subtask_id_message = f'SUBTASK_ID: {subtask_id}. ' if subtask_id is not None else ''
if isinstance(logging_level,
LoggingLevel) and logging_level == logging_level.INFO:
logger.info(
f'{subtask_id_message}{client_key_message}{join_messages(*messages_to_log)}'
)
elif isinstance(logging_level,
LoggingLevel) and logging_level == logging_level.EXCEPTION:
logger.exception(
f'{subtask_id_message}{client_key_message}{join_messages(*messages_to_log)}'
)
elif isinstance(logging_level,
LoggingLevel) and logging_level == logging_level.WARNING:
logger.warning(
f'{subtask_id_message}{client_key_message}{join_messages(*messages_to_log)}'
)
elif isinstance(logging_level,
LoggingLevel) and logging_level == logging_level.ERROR:
logger.error(
f'{subtask_id_message}{client_key_message}{join_messages(*messages_to_log)}'
)
else:
raise TypeError('Unexpected logging level')
def handle(f, handler, exceptions=Exception, logger: Logger = None):
try:
return f()
except exceptions as e:
if logger:
logger.exception(e)
return handler()
def log_exc(log: Logger, suppress: bool = False) -> Iterator[None]:
try:
yield None
except Exception as e:
log.exception("%s", e)
if not suppress:
raise
def __init__(self, waveglow: WaveGlow, hparams: TSTFTHParams, mode: str,
logger: Logger):
super().__init__()
self.stft = STFT(
filter_length=hparams.filter_length,
hop_length=hparams.hop_length,
win_length=hparams.win_length,
).cuda()
if mode == 'zeros':
mel_input = torch.zeros(
(1, hparams.n_mel_channels, BIAS_MEL_LENGTH),
dtype=waveglow.upsample.weight.dtype,
device=waveglow.upsample.weight.device)
elif mode == 'normal':
mel_input = torch.randn(
(1, hparams.n_mel_channels, BIAS_MEL_LENGTH),
dtype=waveglow.upsample.weight.dtype,
device=waveglow.upsample.weight.device)
else:
msg = f"Mode {mode} if not supported"
logger.exception(msg)
raise Exception(msg)
with torch.no_grad():
bias_audio = waveglow.infer(mel_input, sigma=0.0).float()
bias_spec, _ = self.stft.transform(bias_audio)
self.register_buffer('bias_spec', bias_spec[:, :, 0][:, :, None])
def suppress(logger: Logger):
try:
yield
except Exception as e:
logger.exception(f"Suppressed Exception {e}")
finally:
pass
def post(self):
try:
name = cgi.escape(self.request.get('name'))
description = cgi.escape(self.request.get('description'))
url = cgi.escape(self.request.get('url'))
seller = cgi.escape(self.request.get('seller'))
except:
log.exception( "fail to get data from form" )
print( "fail to get data from form" )
seller = Seller.get( seller )
if seller:
turl = URL()
turl.url = url
turl.put()
target = Target()
target.name = name
target.description = description
target.url = turl
target.seller = seller
target.put()
else:
print( "no seller with specified name" )
def _get_quoted_event(event: Event, logger: Logger) -> Event:
new_event: Dict[str, Any] = {}
fields_to_quote = [
"application", "match_groups", "text", "comment", "contact"
]
for key, value in event.items():
if key not in fields_to_quote:
new_event[key] = value
else:
try:
if isinstance(value, list):
new_event[key] = list(map(quote_shell_string, value))
elif isinstance(value, tuple):
# TODO: Huh??? Shouldn't we map over the tuple?
new_event[key] = value
elif isinstance(value, str):
new_event[key] = quote_shell_string(value)
else:
raise ValueError(f'unquotable field "{key}": {value}')
except Exception as e:
# If anything unforeseen happens, we use the intial value
new_event[key] = value
logger.exception("Unable to quote event text %r: %r, %r" %
(key, value, e))
return cast(Event, new_event)
def do_event_action(
history: History,
settings: Settings,
config: Config,
logger: Logger,
event_columns: Iterable[Tuple[str, Any]],
action: Action,
event: Event,
user: str,
) -> None:
action_id = action["id"]
if action["disabled"]:
logger.info("Skipping disabled action %s.", action_id)
return
try:
act = action["action"]
if act[0] == "email":
_do_email_action(history, config, logger, event_columns, act[1],
event, user)
elif act[0] == "script":
_do_script_action(history, logger, event_columns, act[1],
action_id, event, user)
else:
logger.error("Cannot execute action %s: invalid action type %s",
action_id, act[0])
except Exception:
if settings.options.debug:
raise
logger.exception("Error during execution of action %s", action_id)
async def migrate_is_my_offer(log: logging.Logger, db_connection: aiosqlite.Connection) -> None:
"""
Migrate the is_my_offer property contained in the serialized TradeRecord (trade_record column)
to the is_my_offer column in the trade_records table.
"""
log.info("Beginning migration of is_my_offer property in trade_records")
start_time = perf_counter()
cursor = await db_connection.execute("SELECT trade_record, trade_id from trade_records")
rows = await cursor.fetchall()
await cursor.close()
updates: List[Tuple[int, str]] = []
for row in rows:
record = TradeRecord.from_bytes(row[0])
is_my_offer = 1 if record.is_my_offer else 0
updates.append((is_my_offer, row[1]))
try:
await db_connection.executemany(
"UPDATE trade_records SET is_my_offer=? WHERE trade_id=?",
updates,
)
except (aiosqlite.OperationalError, aiosqlite.IntegrityError):
log.exception("Failed to migrate is_my_offer property in trade_records")
raise
end_time = perf_counter()
log.info(f"Completed migration of {len(updates)} records in {end_time - start_time} seconds")
def start_node_monitor(node_monitor: NodeMonitor, monitor_period: int,
logger: logging.Logger):
# Start
while True:
# Read node data
try:
logger.debug('Reading %s.', node_monitor.node)
node_monitor.monitor()
logger.debug('Done reading %s.', node_monitor.node)
except ReqConnectionError:
node_monitor.node.set_as_down(node_monitor.channels, logger)
except ReadTimeout:
node_monitor.node.set_as_down(node_monitor.channels, logger)
except (IncompleteRead, ChunkedEncodingError, ProtocolError) as e:
logger.error(
'Error when reading data from %s: %s. '
'Alerter will continue running normally.', node_monitor.node,
e)
except Exception as e:
logger.exception(e)
raise e
# Save all state
node_monitor.save_state()
node_monitor.node.save_state(logger)
# Sleep
logger.debug('Sleeping for %s seconds.', monitor_period)
time.sleep(monitor_period)
def start_network_monitor(network_monitor: NetworkMonitor, monitor_period: int,
logger: logging.Logger):
# Start
while True:
# Read network data
try:
logger.debug('Reading network data.')
network_monitor.monitor()
logger.debug('Done reading network data.')
except NoLiveFullNodeException:
network_monitor.channels.alert_major(
CouldNotFindLiveFullNodeAlert(network_monitor.monitor_name))
except (ReqConnectionError, ReadTimeout):
network_monitor.last_full_node_used.set_as_down(
network_monitor.channels, logger)
except (IncompleteRead, ChunkedEncodingError, ProtocolError) as e:
network_monitor.channels.alert_error(
ErrorWhenReadingDataFromNode(
network_monitor.last_full_node_used))
logger.error('Error when reading data from %s: %s',
network_monitor.last_full_node_used, e)
except Exception as e:
logger.exception(e)
raise e
# Save all state
network_monitor.save_state()
# Sleep
if not network_monitor.is_syncing():
logger.debug('Sleeping for %s seconds.', monitor_period)
time.sleep(monitor_period)
def _construct_resolver(
logger: Logger, mibs_dir: Path,
load_texts: bool) -> Optional[pysnmp.smi.view.MibViewController]:
try:
builder = pysnmp.smi.builder.MibBuilder(
) # manages python MIB modules
# load MIBs from our compiled MIB and default MIB paths
builder.setMibSources(
*[pysnmp.smi.builder.DirMibSource(str(mibs_dir))] +
list(builder.getMibSources()))
# Indicate if we wish to load DESCRIPTION and other texts from MIBs
builder.loadTexts = load_texts
# This loads all or specified pysnmp MIBs into memory
builder.loadModules()
loaded_mib_module_names = list(builder.mibSymbols.keys())
logger.info('Loaded %d SNMP MIB modules' %
len(loaded_mib_module_names))
logger.log(VERBOSE, 'Found modules: %s',
', '.join(loaded_mib_module_names))
# This object maintains various indices built from MIBs data
return pysnmp.smi.view.MibViewController(builder)
except pysnmp.smi.error.SmiError as e:
logger.info(
"Exception while loading MIB modules. Proceeding without modules!"
)
logger.exception("Exception: %s" % e)
return None
def get_person_listing(
request: Request,
logger: Logger,
session: LocalProxy,
service: DirectorySearchService,
):
context = RenderingContext.construct(
uwnetid=session.get("uwnetid"),
)
template = "views/person.html"
try:
request_input = SearchDirectoryFormInput.parse_obj(request.form)
context.request_input = request_input
context.search_result = service.get_listing(
b64decode(request_input.person_href.encode("UTF-8")).decode("UTF-8")
)
except Exception as e:
template = "views/index.html"
logger.exception(str(e))
SearchBlueprint.handle_search_exception(e, context)
finally:
return (
render_template(template, **context.dict(exclude_none=True)),
context.status_code,
)
def search_listing(
request: Request,
service: DirectorySearchService,
logger: Logger,
session: LocalProxy,
settings: ApplicationConfig,
):
context = RenderingContext.construct(
uwnetid=session.get("uwnetid"),
show_experimental=settings.show_experimental,
)
try:
form_input = SearchDirectoryFormInput.parse_obj(request.form)
context.request_input = form_input
request_input = SearchDirectoryInput.from_form_input(form_input)
context.search_result = service.search_directory(request_input)
except Exception as e:
logger.exception(str(e))
SearchBlueprint.handle_search_exception(e, context)
finally:
return (
render_template(
"views/search_results.html", **context.dict(exclude_none=True)
),
context.status_code,
)
def onException(args: argparse.ArgumentParser, logger: logging.Logger) -> None:
try:
email = []
sql = 'SELECT email.email FROM email' \
+ ' LEFT JOIN emailReports ON email.id=emailReports.email' \
+ ' LEFT JOIN webList ON webList.id=emailReports.report' \
+ " WHERE webList.key='systemd';"
db = DB.DB(args.db, logger)
with db.cursor() as cur:
cur.execute(sql)
for row in cur:
email.append(row[0])
db.close()
if email:
fqdn = socket.getfqdn()
item = os.path.basename(sys.argv[0])
cnt = "command line:\n" + ' '.join(sys.argv)
cnt += traceback.format_exc()
msg = MIMEText(cnt)
msg['Subject'] = '{} failed on {}'.format(item, fqdn)
msg['From'] = email[0]
msg['To'] = ','.join(email)
s = smtplib.SMTP('localhost')
s.send_message(msg)
s.quit()
except Exception as e:
logger.exception('Exception processing during Notify')
async def send_dumplings_from_queue_to_hub(
kitchen_name: str,
hub: str,
dumpling_queue: multiprocessing.Queue,
kitchen_info: dict,
log: logging.Logger,
):
"""
Grabs dumplings from the dumpling queue and sends them to ``nd-hub``.
:param kitchen_name: The name of the kitchen.
:param hub: The address where ``nd-hub`` is receiving dumplings.
:param dumpling_queue: Queue to grab dumplings from.
:param kitchen_info: Dict describing the kitchen.
:param log: Logger.
"""
hub_ws = 'ws://{0}'.format(hub)
log.info("{0}: Connecting to the dumpling hub at {1}".format(
kitchen_name, hub_ws)
)
try:
websocket = await websockets.connect(hub_ws)
except OSError as e:
log.error(
"{0}: There was a problem with the dumpling hub connection. "
"Is nd-hub available?".format(kitchen_name))
log.error("{0}: {1}".format(kitchen_name, e))
return
try:
# Register our kitchen information with the dumpling hub.
await websocket.send(json.dumps(kitchen_info))
# Send dumplings to the hub when they come in from the chefs.
while True:
dumpling = dumpling_queue.get()
await websocket.send(dumpling)
except asyncio.CancelledError:
log.warning(
"{0}: Connection to dumpling hub cancelled; closing...".format(
kitchen_name))
try:
await websocket.close(*ND_CLOSE_MSGS['conn_cancelled'])
except websockets.exceptions.InvalidState:
pass
except websockets.exceptions.ConnectionClosed as e:
log.warning("{0}: Lost connection to dumpling hub: {1}".format(
kitchen_name, e))
except OSError as e:
log.exception(
"{0}: Error talking to dumpling hub: {1}".format(kitchen_name, e)
)
def __init__(self, msg: str, code: str=None, exception: Exception=None, logger: logging.Logger=None):
self.code = code or RegovarException.code
self.msg = msg or RegovarException.msg
self.id = str(uuid.uuid4())
self.date = datetime.datetime.utcnow().timestamp()
self.log = "ERROR {} [{}] {}".format(self.code, self.id, self.msg)
if logger:
logger.error(self.log)
if exception and not isinstance(exception, RegovarException):
# To avoid to log multiple time the same exception when chaining try/catch
logger.exception(exception)
else:
err(self.log, exception)
def post(self):
try:
name = cgi.escape(self.request.get('name'))
pricesoup = cgi.escape(self.request.get('pricesoup'))
picsoup = cgi.escape(self.request.get('picsoup'))
shipsoup = cgi.escape(self.request.get('shipsoup'))
except:
log.exception( "fail to get data from form" )
print( "fail to get data from form" )
seller = Seller()
seller.name = name
seller.pricesoup = pricesoup
seller.picsoup = picsoup
seller.shipsoup = shipsoup
seller.put()
def wrapped_f(sess_maker,
lgg: logging.Logger,
user,
*args,
begin_transaction: bool=True,
**kwargs):
if begin_transaction:
transaction.begin()
sess = sess_maker()
try:
job = Scheduler.find(sess, self.job)
""":type: Scheduler"""
user = pam.User.find(sess, user)
job.start(user)
sp = transaction.savepoint()
try:
out = f(sess, lgg, user, begin_transaction, *args, **kwargs)
except Exception as exc:
lgg.exception(exc)
sp.rollback()
out = [
str(exc),
traceback.format_exception(*sys.exc_info())
]
job.stop_error(user, out)
else:
job.stop_ok(user, out)
except:
if begin_transaction:
transaction.abort()
raise
else:
if begin_transaction:
transaction.commit()
return job