def configure_logging(self):
"""Configure logging"""
config = self.config
log_def = 'debug' if config.get('debug_mode') else 'info'
daq_env = config.get('daq_loglevel', log_def)
level = minilog.LEVELS.get(daq_env, minilog.LEVELS['info'])
logger.set_config(level=level, fmt=_LOG_FORMAT, datefmt=_DATE_FORMAT)
# This handler is used by everything, so be permissive here.
ROOT_LOG.handlers[0].setLevel(minilog.LEVELS['debug'])
mininet_env = config.get('mininet_loglevel', 'info')
minilog.setLogLevel(mininet_env)
# pylint: disable=protected-access
minilog.MininetLogger._log = _stripped_alt_logger
#################################################################
# Modeling #
#################################################################
from djangomodels import *
from setynuco.models import *
import util
import logging
import numpy as np
from logger import set_config
logger = set_config(logging.getLogger(__name__))
#
# logger = logging.getLogger(__name__)
# handler = logging.FileHandler('core.log')
# formatter = logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
# handler.setFormatter(formatter)
# logger.addHandler(handler)
# logger.setLevel(logging.DEBUG)
def model_add(name, knowledge_graph, class_uris):
mlmodel = MLModel()
mlmodel.name = name
mlmodel.knowledge_graph = knowledge_graph
mlmodel.save()
logger.info(class_uris)
for curi in class_uris:
logger.debug("will add <%s>" % curi)
if end:
LOGGER.info('Limiting to end time %s', to_timestamp(end))
query = query.where('updated', '<=', to_timestamp(end))
if daq_run_id:
LOGGER.info('Limiting to DAQ run id %s', daq_run_id)
query = query.where('daq_run_id', '==', daq_run_id)
runids = query.order_by(
u'updated', direction=DESCENDING).limit(limit_count).stream()
for runid in runids:
json_report = self._get_json_report(runid)
if json_report:
yield json_report
def _query_user(self, message):
reply = input(message)
options = set(('y', 'Y', 'yes', 'YES', 'Yes', 'sure'))
if reply in options:
return True
return False
if __name__ == '__main__':
logger.set_config(format='%(levelname)s:%(message)s', level="INFO")
CONFIGURATOR = configurator.Configurator()
CONFIG = CONFIGURATOR.parse_args(sys.argv)
GCP = GcpManager(CONFIG, None)
if CONFIG.get('register_offenders'):
GCP.register_offenders()
else:
print('Unknown command mode for gcp module.')
channel = grpc.insecure_channel(address)
self._stub = server_grpc.SessionServerStub(channel)
grpc.channel_ready_future(channel).result()
def start_session(self, mac):
"""Send device result of a device to server"""
devices_state = {'device_mac': mac}
LOGGER.info('Connecting to stream for mac %s', mac)
generator = self._stub.StartSession(
dict_proto(devices_state, SessionParams))
return generator
if __name__ == '__main__':
# Snippet for testing basic client/server operation from the command line.
def _receive_session(result):
LOGGER.info('Received session %s', result.device_mac)
logger.set_config(level=logging.INFO)
if sys.argv[1] == 'server':
SERVER = SessionServer(_receive_session)
SERVER.start()
LOGGER.info('Blocking for test')
time.sleep(1000)
elif sys.argv[1] == 'client':
CLIENT = TestingSessionServerClient()
RESULTS = CLIENT.start_session('123')
for message in RESULTS:
LOGGER.info('Received %s', str(message).strip())
