def main(argv=sys.argv[1:]):
# Change the process and thread name so the logs are cleaner.
p = multiprocessing.current_process()
p.name = "pmain"
t = threading.current_thread()
t.name = "tmain"
register_and_load_opts()
cfg.CONF(argv, project="akanda-rug")
log.setup("akanda-rug")
cfg.CONF.log_opt_values(LOG, logging.INFO)
# Purge the mgt tap interface on startup
quantum = quantum_api.Quantum(cfg.CONF)
# TODO(mark): develop better way restore after machine reboot
# quantum.purge_management_interface()
# bring the mgt tap interface up
quantum.ensure_local_service_port()
# bring the external port
if cfg.CONF.plug_external_port:
quantum.ensure_local_external_port()
# Set up the queue to move messages between the eventlet-based
# listening process and the scheduler.
notification_queue = multiprocessing.Queue()
# Ignore signals that might interrupt processing.
daemon.ignore_signals()
# If we see a SIGINT, stop processing.
def _stop_processing(*args):
notification_queue.put((None, None))
signal.signal(signal.SIGINT, _stop_processing)
# Listen for notifications.
notification_proc = multiprocessing.Process(
target=notifications.listen,
kwargs={
"host_id": cfg.CONF.host,
"amqp_url": cfg.CONF.amqp_url,
"notifications_exchange_name": cfg.CONF.incoming_notifications_exchange,
"rpc_exchange_name": cfg.CONF.rpc_exchange,
"notification_queue": notification_queue,
},
name="notification-listener",
)
notification_proc.start()
mgt_ip_address = quantum_api.get_local_service_ip(cfg.CONF).split("/")[0]
metadata_proc = multiprocessing.Process(target=metadata.serve, args=(mgt_ip_address,), name="metadata-proxy")
metadata_proc.start()
# Set up the notifications publisher
Publisher = notifications.Publisher if cfg.CONF.ceilometer.enabled else notifications.NoopPublisher
publisher = Publisher(
cfg.CONF.amqp_url, exchange_name=cfg.CONF.outgoing_notifications_exchange, topic=cfg.CONF.ceilometer.topic
)
# Set up a factory to make Workers that know how many threads to
# run.
worker_factory = functools.partial(
worker.Worker,
num_threads=cfg.CONF.num_worker_threads,
notifier=publisher,
ignore_directory=cfg.CONF.ignored_router_directory,
queue_warning_threshold=cfg.CONF.queue_warning_threshold,
reboot_error_threshold=cfg.CONF.reboot_error_threshold,
)
# Set up the scheduler that knows how to manage the routers and
# dispatch messages.
sched = scheduler.Scheduler(num_workers=cfg.CONF.num_worker_processes, worker_factory=worker_factory)
# Prepopulate the workers with existing routers on startup
populate.pre_populate_workers(sched)
# Set up the periodic health check
health.start_inspector(cfg.CONF.health_check_period, sched)
# Block the main process, copying messages from the notification
# listener to the scheduler
try:
shuffle_notifications(notification_queue, sched)
finally:
# Terminate the scheduler and its workers
LOG.info("stopping processing")
sched.stop()
# Terminate the listening process
LOG.debug("stopping %s", notification_proc.name)
notification_proc.terminate()
LOG.debug("stopping %s", metadata_proc.name)
metadata_proc.terminate()
LOG.info("exiting")
def main(argv=sys.argv[1:]):
"""Main Entry point into the akanda-rug
This is the main entry point into the akanda-rug. On invocation of
this method, logging, local network connectivity setup is performed.
This information is obtained through the 'ak-config' file, passed as
arguement to this method. Worker threads are spawned for handling
various tasks that are associated with processing as well as
responding to different Neutron events prior to starting a notification
dispatch loop.
:param argv: list of Command line arguments
:returns: None
:raises: None
"""
# TODO(rama) Error Handling to be added as part of the docstring
# description
# Change the process and thread name so the logs are cleaner.
p = multiprocessing.current_process()
p.name = 'pmain'
t = threading.current_thread()
t.name = 'tmain'
ak_cfg.parse_config(argv)
log.setup(cfg.CONF, 'akanda-rug')
cfg.CONF.log_opt_values(LOG, logging.INFO)
neutron = neutron_api.Neutron(cfg.CONF)
# TODO(mark): develop better way restore after machine reboot
# neutron.purge_management_interface()
# bring the mgt tap interface up
neutron.ensure_local_service_port()
# bring the external port
if cfg.CONF.plug_external_port:
neutron.ensure_local_external_port()
# Set up the queue to move messages between the eventlet-based
# listening process and the scheduler.
notification_queue = multiprocessing.Queue()
# Ignore signals that might interrupt processing.
daemon.ignore_signals()
# If we see a SIGINT, stop processing.
def _stop_processing(*args):
notification_queue.put((None, None))
signal.signal(signal.SIGINT, _stop_processing)
# Listen for notifications.
notification_proc = multiprocessing.Process(
target=notifications.listen,
kwargs={
'notification_queue': notification_queue
},
name='notification-listener',
)
notification_proc.start()
mgt_ip_address = neutron_api.get_local_service_ip(cfg.CONF).split('/')[0]
metadata_proc = multiprocessing.Process(
target=metadata.serve,
args=(mgt_ip_address,),
name='metadata-proxy'
)
metadata_proc.start()
from akanda.rug.api import rug as rug_api
rug_api_proc = multiprocessing.Process(
target=rug_api.serve,
args=(mgt_ip_address,),
name='rug-api'
)
rug_api_proc.start()
# Set up the notifications publisher
Publisher = (notifications.Publisher if cfg.CONF.ceilometer.enabled
else notifications.NoopPublisher)
publisher = Publisher(
topic=cfg.CONF.ceilometer.topic,
)
# Set up a factory to make Workers that know how many threads to
# run.
worker_factory = functools.partial(
worker.Worker,
notifier=publisher
)
# Set up the scheduler that knows how to manage the routers and
# dispatch messages.
sched = scheduler.Scheduler(
worker_factory=worker_factory,
)
# Prepopulate the workers with existing routers on startup
populate.pre_populate_workers(sched)
# Set up the periodic health check
health.start_inspector(cfg.CONF.health_check_period, sched)
# Block the main process, copying messages from the notification
# listener to the scheduler
try:
shuffle_notifications(notification_queue, sched)
finally:
LOG.info(_LI('Stopping scheduler.'))
sched.stop()
LOG.info(_LI('Stopping notification publisher.'))
publisher.stop()
# Terminate the subprocesses
for subproc in [notification_proc, metadata_proc, rug_api_proc]:
LOG.info(_LI('Stopping %s.'), subproc.name)
subproc.terminate()
def main(argv=sys.argv[1:]):
"""Main Entry point into the akanda-rug
This is the main entry point into the akanda-rug. On invocation of
this method, logging, local network connectivity setup is performed.
This information is obtained through the 'ak-config' file, passed as
arguement to this method. Worker threads are spawned for handling
various tasks that are associated with processing as well as
responding to different Neutron events prior to starting a notification
dispatch loop.
:param argv: list of Command line arguments
:returns: None
:raises: None
"""
# TODO(rama) Error Handling to be added as part of the docstring
# description
# Change the process and thread name so the logs are cleaner.
p = multiprocessing.current_process()
p.name = 'pmain'
t = threading.current_thread()
t.name = 'tmain'
ak_cfg.parse_config(argv)
log.setup(cfg.CONF, 'akanda-rug')
cfg.CONF.log_opt_values(LOG, logging.INFO)
neutron = neutron_api.Neutron(cfg.CONF)
# TODO(mark): develop better way restore after machine reboot
# neutron.purge_management_interface()
# bring the mgt tap interface up
neutron.ensure_local_service_port()
# bring the external port
if cfg.CONF.plug_external_port:
neutron.ensure_local_external_port()
# Set up the queue to move messages between the eventlet-based
# listening process and the scheduler.
notification_queue = multiprocessing.Queue()
# Ignore signals that might interrupt processing.
daemon.ignore_signals()
# If we see a SIGINT, stop processing.
def _stop_processing(*args):
notification_queue.put((None, None))
signal.signal(signal.SIGINT, _stop_processing)
# Listen for notifications.
notification_proc = multiprocessing.Process(
target=notifications.listen,
kwargs={'notification_queue': notification_queue},
name='notification-listener',
)
notification_proc.start()
mgt_ip_address = neutron_api.get_local_service_ip(cfg.CONF).split('/')[0]
metadata_proc = multiprocessing.Process(target=metadata.serve,
args=(mgt_ip_address, ),
name='metadata-proxy')
metadata_proc.start()
from akanda.rug.api import rug as rug_api
rug_api_proc = multiprocessing.Process(target=rug_api.serve,
args=(mgt_ip_address, ),
name='rug-api')
rug_api_proc.start()
# Set up the notifications publisher
Publisher = (notifications.Publisher if cfg.CONF.ceilometer.enabled else
notifications.NoopPublisher)
publisher = Publisher(topic=cfg.CONF.ceilometer.topic, )
# Set up a factory to make Workers that know how many threads to
# run.
worker_factory = functools.partial(worker.Worker, notifier=publisher)
# Set up the scheduler that knows how to manage the routers and
# dispatch messages.
sched = scheduler.Scheduler(worker_factory=worker_factory, )
# Prepopulate the workers with existing routers on startup
populate.pre_populate_workers(sched)
# Set up the periodic health check
health.start_inspector(cfg.CONF.health_check_period, sched)
# Block the main process, copying messages from the notification
# listener to the scheduler
try:
shuffle_notifications(notification_queue, sched)
finally:
LOG.info(_LI('Stopping scheduler.'))
sched.stop()
LOG.info(_LI('Stopping notification publisher.'))
publisher.stop()
# Terminate the subprocesses
for subproc in [notification_proc, metadata_proc, rug_api_proc]:
LOG.info(_LI('Stopping %s.'), subproc.name)
subproc.terminate()
def main(argv=sys.argv[1:]):
# Change the process and thread name so the logs are cleaner.
p = multiprocessing.current_process()
p.name = 'pmain'
t = threading.current_thread()
t.name = 'tmain'
register_and_load_opts()
cfg.CONF(argv, project='akanda-rug')
log.setup('akanda-rug')
cfg.CONF.log_opt_values(LOG, logging.INFO)
# Purge the mgt tap interface on startup
quantum = quantum_api.Quantum(cfg.CONF)
# TODO(mark): develop better way restore after machine reboot
# quantum.purge_management_interface()
# bring the mgt tap interface up
quantum.ensure_local_service_port()
# bring the external port
if cfg.CONF.plug_external_port:
quantum.ensure_local_external_port()
# Set up the queue to move messages between the eventlet-based
# listening process and the scheduler.
notification_queue = multiprocessing.Queue()
# Ignore signals that might interrupt processing.
daemon.ignore_signals()
# If we see a SIGINT, stop processing.
def _stop_processing(*args):
notification_queue.put((None, None))
signal.signal(signal.SIGINT, _stop_processing)
# Listen for notifications.
notification_proc = multiprocessing.Process(
target=notifications.listen,
kwargs={
'host_id': cfg.CONF.host,
'amqp_url': cfg.CONF.amqp_url,
'notifications_exchange_name':
cfg.CONF.incoming_notifications_exchange,
'rpc_exchange_name': cfg.CONF.rpc_exchange,
'notification_queue': notification_queue
},
name='notification-listener',
)
notification_proc.start()
mgt_ip_address = quantum_api.get_local_service_ip(cfg.CONF).split('/')[0]
metadata_proc = multiprocessing.Process(target=metadata.serve,
args=(mgt_ip_address, ),
name='metadata-proxy')
metadata_proc.start()
# Set up the notifications publisher
Publisher = (notifications.Publisher if cfg.CONF.ceilometer.enabled else
notifications.NoopPublisher)
publisher = Publisher(
cfg.CONF.amqp_url,
exchange_name=cfg.CONF.outgoing_notifications_exchange,
topic=cfg.CONF.ceilometer.topic,
)
# Set up a factory to make Workers that know how many threads to
# run.
worker_factory = functools.partial(
worker.Worker,
num_threads=cfg.CONF.num_worker_threads,
notifier=publisher,
ignore_directory=cfg.CONF.ignored_router_directory,
queue_warning_threshold=cfg.CONF.queue_warning_threshold,
reboot_error_threshold=cfg.CONF.reboot_error_threshold,
)
# Set up the scheduler that knows how to manage the routers and
# dispatch messages.
sched = scheduler.Scheduler(
num_workers=cfg.CONF.num_worker_processes,
worker_factory=worker_factory,
)
# Prepopulate the workers with existing routers on startup
populate.pre_populate_workers(sched)
# Set up the periodic health check
health.start_inspector(cfg.CONF.health_check_period, sched)
# Block the main process, copying messages from the notification
# listener to the scheduler
try:
shuffle_notifications(notification_queue, sched)
finally:
# Terminate the scheduler and its workers
LOG.info('stopping processing')
sched.stop()
# Terminate the listening process
LOG.debug('stopping %s', notification_proc.name)
notification_proc.terminate()
LOG.debug('stopping %s', metadata_proc.name)
metadata_proc.terminate()
LOG.info('exiting')