async def main(args=None):
opts = open_config_file()
options_engine = opts.northbound_dispatcher
options_tracer = opts.tracer
tracer = None
if options_tracer['enabled']:
options_tracer['service'] = __service_name_listener__
logging.debug(f'Enabling tracing for service "{__service_name_listener__}"')
tracer = Tracer(options_tracer)
tracer.init_tracer()
southbound = SouthboundConnector(options_engine)
southbound.inject_tracer(tracer)
client_south = await create_client(opts.brokers.southbound)
southbound.register_for_client(client_south)
northbound = NorthboundConnector(options_engine)
northbound.inject_tracer(tracer)
client_north = await create_client(opts.brokers.northbound)
northbound.register_for_client(client_north)
dispatcher = Dispatcher(options_engine)
southbound.inject_dispatcher(dispatcher)
dispatcher.inject(southbound, northbound)
dispatcher.inject_tracer(tracer)
dispatcher.subscribe_to_southbound()
logging.info('Waiting message from Privacy Engine')
await STOP.wait()
await client_south.disconnect()
await client_north.disconnect()
async def main(args=None):
opts = open_config_file()
options_mqtt = opts.brokers.northbound
options_alert_digester = opts.alert_digester
options_db = opts.local_storage
options_tracer = opts.tracer
options_alert_digester['client_id'] = uuid.uuid4()
client = gmqtt.Client(
f"{__service_name__}_{options_alert_digester['client_id']}",
clean_session=True)
await client.connect(host=options_mqtt['host'],
port=options_mqtt['port'],
version=4)
logger = AlertDigester(options_alert_digester)
logger.register_for_client(client)
logger.set_up_local_storage(options_db)
if options_tracer['enabled'] is True:
options_tracer['service'] = __service_name__
logging.info(f'Enabling tracing for service "{__service_name__}"')
logger.set_up_tracer(options_tracer)
logger.set_topics([options_alert_digester['listen']])
logger.subscribe_to_topics()
await STOP.wait()
await client.disconnect()
def main(args=None):
opts = open_config_file()
options_engine = opts.privacy_engine
service = TrainService(options_engine)
dataset = service.query_data()
dataset.to_csv('test.csv')
service.train(dataset)
async def main(args=None):
opts = open_config_file()
sensors = opts.simulation['sensors']
gateways = opts.simulation['gateways']
interval = opts.simulation['interval']
client = await create_client(opts.brokers.southbound, 'demo_client')
rndTraffic = RndTrafficConnector()
rndTraffic.register_for_client(client)
while not STOP.is_set():
logging.info('Send messages')
for sensor in sensors:
generate_sensor_message(rndTraffic, sensor)
for gateway in gateways:
generate_gateway_message(rndTraffic, gateway)
logging.info(f'Wait {interval}sec')
await asyncio.sleep(interval)
await STOP.wait()
await client.disconnect()
def get_tracer():
opts = open_config_file()
service = Traceable()
options_tracer = opts.tracer
service.set_up_tracer(options_tracer)
yield service.tracer
service.tracer.close()
async def main(args=None):
opts = open_config_file()
options_watson = opts.watson_iot
options_db = opts.local_storage
options_dispatcher = opts.dispatcher
options_tracer = opts.tracer
client_south = await create_client(opts.brokers.southbound,
'_chariot_southbound_dispatcher')
client_north = await create_client(opts.brokers.northbound,
'_chariot_northbound_dispatcher')
northbound = NorthboundConnector()
northbound.register_for_client(client_north)
logger = LogDigester(options_dispatcher)
logger.register_for_client(client_south)
logger.set_up_local_storage(options_db)
logger.register_northbound(northbound)
if options_tracer['enabled'] is True:
service_name = f'{__service_name__}_{__version__}'
options_tracer['service'] = service_name
logging.info(f'Enabling tracing for service "{service_name}"')
logger.set_up_tracer(options_tracer)
northbound.inject_tracer(logger.tracer)
if options_watson['enabled'] is True:
logging.info('Enabling watson forwarding')
logger.set_up_watson(options_watson['client'])
topics = [options_dispatcher['listen']]
for key, value in options_dispatcher['gateways_ids'].items():
topics.append(key)
logger.set_topics(topics)
logger.subscribe_to_topics()
await STOP.wait()
await client_south.disconnect()
await client_north.disconnect()
async def main(args=None):
opts = open_config_file()
options_engine = opts.privacy_engine
options_tracer = opts.tracer
options_topology = opts.topology
engine = Engine(options_engine)
ioTLWrapper = IoTLWrapper(options_topology)
ioTLWrapper.load()
if options_tracer['enabled'] is True:
options_tracer['service'] = __service_name__
logging.info(f'Enabling tracing for service "{__service_name__}"')
engine.set_up_tracer(options_tracer)
engine.inject_iotl(ioTLWrapper)
engine.set_up_iotl_url(options_topology['iotl_url'])
southbound = SouthboundConnector(options_engine)
southbound.set_up_engine(engine)
southbound.inject_tracer(engine.tracer)
client_south = await create_client(opts.brokers.southbound)
southbound.register_for_client(client_south)
northbound = NorthboundConnector(options_engine)
northbound.set_up_engine(engine)
northbound.inject_tracer(engine.tracer)
client_north = await create_client(opts.brokers.northbound)
northbound.register_for_client(client_north)
engine.inject(southbound, northbound)
engine.start()
logging.info('Waiting message from Southbound Dispatcher')
await STOP.wait()
await client_south.disconnect()
await client_north.disconnect()
async def main(args=None):
opts = open_config_file()
options_db = opts.local_storage
options_engine = opts.health
options_tracer = opts.tracer
scheduler = AsyncIOScheduler(timezone=utc)
client = MongoClient(opts.database['url'])
db = client['chariot_service_health']
southbound = SouthboundConnector(options_engine)
if options_tracer['enabled'] is True:
options_tracer['service'] = __service_name_listener__
logging.debug(
f'Enabling tracing for service "{__service_name_listener__}"')
tracer = Tracer(options_tracer)
tracer.init_tracer()
southbound.inject_tracer(tracer)
options_db['database'] = options_engine['database']
southbound.set_up_local_storage(options_db)
client_south = await create_client(opts.brokers.southbound)
southbound.register_for_client(client_south)
southbound.inject_db(db)
scheduler.add_job(southbound.send_ping,
'interval',
seconds=options_engine['interval'])
southbound.set_topics([options_engine['listen']])
southbound.subscribe_to_topics()
await southbound.send_ping()
scheduler.start()
await STOP.wait()
await client_south.disconnect()
from chariot_base.utilities import Tracer
from chariot_base.utilities import open_config_file
from chariot_firmware_upload_service import __service_name__
from chariot_firmware_upload_service.resources import FirmwareResource
from chariot_firmware_upload_service.store import FirmwareStore, FirmwareUploader
from wsgiref import simple_server
# falcon.API instances are callable WSGI apps
app = falcon.API(middleware=[
MultipartMiddleware(),
# falcon_jsonify.Middleware(help_messages=True),
])
opts = open_config_file()
options_tracer = opts.tracer
# Resources are represented by long-lived class instances
store = FirmwareStore('upload')
uploader = FirmwareUploader({
'storage_path': 'upload'
})
firmware = FirmwareResource(store, uploader)
if options_tracer['enabled'] is True:
options_tracer['service'] = __service_name__
logging.info(f'Enabling tracing for service "{__service_name__}"')
tracer = Tracer(options_tracer)