def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
import logging
from optparse import OptionParser
from lofar.common.util import waitForInterrupt
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description="run the rataskspecified service")
parser.add_option("-e", "--exchange", dest="exchange", type="string",
default=DEFAULT_BUSNAME,
help="Bus or queue to communicate on. [default: %default]")
parser.add_option('-b', '--broker', dest='broker', type='string', default=DEFAULT_BROKER,
help='Address of the broker, default: localhost')
(options, args) = parser.parse_args()
with OTDBBusListener(handler_type=RATaskSpecifiedOTDBEventMessageHandler,
exchange=options.exchange,
broker=options.broker):
waitForInterrupt()
def main():
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-q', '--broker', dest='broker', type='string', default=None, help='Address of the qpid broker, default: localhost')
parser.add_option("--otdb_notification_busname", dest="otdb_notification_busname", type="string",
default=DEFAULT_OTDB_NOTIFICATION_BUSNAME,
help="Bus or queue where the OTDB notifications are published. [default: %default]")
parser.add_option("--otdb_notification_subject", dest="otdb_notification_subject", type="string",
default=DEFAULT_OTDB_NOTIFICATION_SUBJECT,
help="Subject of OTDB notifications on otdb_notification_busname. [default: %default]")
parser.add_option("--radb_busname", dest="radb_busname", type="string",
default=DEFAULT_RADB_BUSNAME,
help="Name of the radb bus exchange on the qpid broker. [default: %default]")
parser.add_option("--radb_servicename", dest="radb_servicename", type="string",
default=DEFAULT_RADB_SERVICENAME,
help="Name of the radb service. [default: %default]")
(options, args) = parser.parse_args()
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
with OTDBtoRATaskStatusPropagator(otdb_notification_busname=options.otdb_notification_busname,
otdb_notification_subject=options.otdb_notification_subject,
radb_busname=options.radb_busname,
radb_servicename=options.radb_servicename,
broker=options.broker):
waitForInterrupt()
def main():
"""
Starts the momqueryservice.GetObjectDetails service
"""
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the momqueryservice')
parser.add_option('-b', '--broker', dest='broker', type='string', default=DEFAULT_BROKER,
help='Address of the messaging broker, default: %default')
parser.add_option("-e", "--exchange", dest="exchange", type="string", default=DEFAULT_BUSNAME,
help="Name of the bus exchange on the broker, [default: %default]")
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="MoM")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
logger.info("Using dbcreds: %s", dbcreds.stringWithHiddenPassword())
with RPCService(service_name=DEFAULT_MOMQUERY_SERVICENAME,
handler_type=MoMQueryServiceMessageHandler, handler_kwargs={'dbcreds': dbcreds},
broker=options.broker, exchange=options.exchange,
num_threads=6):
waitForInterrupt()
def main():
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the systemstatus database service')
parser.add_option('-q', '--broker', dest='broker', type='string',
default=None,
help='Address of the qpid broker, default: localhost')
parser.add_option("-b", "--busname", dest="busname", type="string",
default=DEFAULT_SSDB_BUSNAME,
help="Name of the bus exchange on the qpid broker. [default: %default]")
parser.add_option("-s", "--servicename", dest="servicename", type="string",
default=DEFAULT_SSDB_SERVICENAME,
help="Name for this service. [default: %default]")
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="SSDB")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
logger.info("Using dbcreds: %s" % dbcreds.stringWithHiddenPassword())
with createService(busname=options.busname, servicename=options.servicename, dbcreds=dbcreds, broker=options.broker):
waitForInterrupt()
def main():
from optparse import OptionParser
# Check the invocation arguments
parser = OptionParser('%prog [options]',
description='run the ingest job monitor')
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the message broker, default: %default')
parser.add_option(
'-e',
'--exchange',
dest='exchange',
type='string',
default=DEFAULT_BUSNAME,
help=
'Name of the exchange on which the ingest notifications are published, default: %default'
)
(options, args) = parser.parse_args()
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.INFO,
stream=sys.stdout)
event_listener = IngestEventMesssageBusListener(exchange=options.exchange,
broker=options.broker)
# wrap event_listener in a janitor to auto cleanup the designed listening queue upon exit.
# this tool is only meant for live listening, not for historic logs.
with BusListenerJanitor(event_listener):
waitForInterrupt()
def main():
from optparse import OptionParser
# Check the invocation arguments
parser = OptionParser('%prog [options]', description='run the messegelogger, which logs each received message')
parser.add_option('-b', '--broker', dest='broker', type='string', default=DEFAULT_BROKER,
help='Address of the messaging broker, default: %default')
parser.add_option("-e", "--exchange", dest="exchange", type="string", default=DEFAULT_BUSNAME,
help="Name of the bus (exchange) to receive messages from. [default: %default]")
parser.add_option("-r", "--routing_key", dest="routing_key", type="string", default="#",
help="filter messages on by subject using this routing_key. #=all. [default: %default]")
parser.add_option("-n", "--no_newlines", dest="no_newlines", action='store_true',
help="remove newlines in message content, so we have single line log messages")
parser.add_option("-m", "--max_content_size", dest="max_content_size", type="int", default=-1,
help="delimit the logged content to at most <max_content_size> characters (or all if -1). [default: %default]")
options, args = parser.parse_args()
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
logger.info("**************************")
logger.info("* starting messagelogger *")
logger.info("**************************")
with MessageLogger(exchange=options.exchange, routing_key=options.routing_key, broker=options.broker,
remove_content_newlines=bool(options.no_newlines), max_content_size=options.max_content_size):
waitForInterrupt()
def main():
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-q', '--broker', dest='broker', type='string', default=None, help='Address of the qpid broker, default: localhost')
parser.add_option("-b", "--busname", dest="busname", type="string", default=DEFAULT_BUSNAME, help="Name of the bus exchange on the qpid broker, default: %s" % DEFAULT_BUSNAME)
parser.add_option("-s", "--servicename", dest="servicename", type="string", default=DEFAULT_SERVICENAME, help="Name for this service, default: %s" % DEFAULT_SERVICENAME)
parser.add_option('-Q', '--log-queries', dest='log_queries', action='store_true', help='log all pqsl queries')
parser.add_option('-V', '--verbose', dest='verbose', action='store_true', help='verbose logging')
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="RADB")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
setQpidLogLevel(logging.INFO)
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
logger.info("Using dbcreds: %s" % dbcreds.stringWithHiddenPassword())
with createService(busname=options.busname,
servicename=options.servicename,
broker=options.broker,
verbose=options.verbose,
log_queries=options.log_queries,
dbcreds=dbcreds):
waitForInterrupt()
def main():
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.INFO)
# Check the invocation arguments
parser = OptionParser(
"%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: %default')
parser.add_option(
'-e',
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help=
"Bus or queue where the OTDB notifications are published. [default: %default]"
)
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="RADB")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
logger.info("Using dbcreds: %s" % dbcreds.stringWithHiddenPassword())
with OTDBBusListener(handler_type=OTDBtoRATaskStatusPropagator,
exchange=options.exchange,
broker=options.broker,
num_threads=1):
waitForInterrupt()
def main():
# Check the invocation arguments
parser = OptionParser(
"%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-q',
'--broker',
dest='broker',
type='string',
default=None,
help='Address of the qpid broker, default: localhost')
parser.add_option(
"-b",
"--busname",
dest="busname",
type="string",
default=DEFAULT_BUSNAME,
help="Name of the bus exchange on the qpid broker, default: %s" %
DEFAULT_BUSNAME)
parser.add_option("-s",
"--servicename",
dest="servicename",
type="string",
default=DEFAULT_SERVICENAME,
help="Name for this service, default: %s" %
DEFAULT_SERVICENAME)
parser.add_option('-Q',
'--log-queries',
dest='log_queries',
action='store_true',
help='log all pqsl queries')
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="RADB")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
setQpidLogLevel(logging.INFO)
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
logger.info("Using dbcreds: %s" % dbcreds.stringWithHiddenPassword())
with createService(busname=options.busname,
servicename=options.servicename,
broker=options.broker,
verbose=options.verbose,
log_queries=options.log_queries,
dbcreds=dbcreds):
waitForInterrupt()
def main():
with RPCService(service_name=TRIGGER_SERVICENAME,
handler_type=TriggerServiceMessageHandler,
exchange=DEFAULT_BUSNAME,
num_threads=4):
# next to RT events, also (independently) handle vo events
with ALERTHandler(
broker_host=ALERT_BROKER_HOST,
broker_port=ALERT_BROKER_PORT,
filter_for=ALERT_PACKET_TYPE_FILTER) as alert_handler:
waitForInterrupt()
def main():
# Check the invocation arguments
parser = OptionParser(
"%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-q',
'--broker',
dest='broker',
type='string',
default=None,
help='Address of the qpid broker, default: localhost')
parser.add_option(
"--otdb_notification_busname",
dest="otdb_notification_busname",
type="string",
default=DEFAULT_OTDB_NOTIFICATION_BUSNAME,
help=
"Bus or queue where the OTDB notifications are published. [default: %default]"
)
parser.add_option(
"--otdb_notification_subject",
dest="otdb_notification_subject",
type="string",
default=DEFAULT_OTDB_NOTIFICATION_SUBJECT,
help=
"Subject of OTDB notifications on otdb_notification_busname. [default: %default]"
)
parser.add_option(
"--radb_busname",
dest="radb_busname",
type="string",
default=DEFAULT_RADB_BUSNAME,
help=
"Name of the radb bus exchange on the qpid broker. [default: %default]"
)
parser.add_option("--radb_servicename",
dest="radb_servicename",
type="string",
default=DEFAULT_RADB_SERVICENAME,
help="Name of the radb service. [default: %default]")
(options, args) = parser.parse_args()
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.INFO)
with OTDBtoRATaskStatusPropagator(
otdb_notification_busname=options.otdb_notification_busname,
otdb_notification_subject=options.otdb_notification_subject,
radb_busname=options.radb_busname,
radb_servicename=options.radb_servicename,
broker=options.broker):
waitForInterrupt()
def main():
logger.warning("!!! This is unfinished work!") # todo: finish, if required: Create proper events that are accepted by the comet broker
# Check the invocation arguments
parser = argparse.ArgumentParser("This script will listen to TBB trigger messages via UDP, generate a VO event and send that to a specified VOevent broker.")
parser.add_argument('-l', '--listening-port', dest='lport', help="Port to listen for UDP messages", required=False, default=DEFAULT_LISTENING_PORT)
parser.add_argument('-b', '--broker-host', dest='host', help="Host of the VO event broker", required=False, default=DEFAULT_TBB_ALERT_BROKER_HOST)
parser.add_argument('-p', '--broker-port', dest='port', help="Port of the VO event broker", required=False, default=DEFAULT_TBB_ALERT_BROKER_PORT)
args = parser.parse_args()
with VOEventPublisher(args.lport,
broker_host=args.host,
broker_port=args.port):
waitForInterrupt()
def main():
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-b', '--broker', dest='broker', type='string', default=DEFAULT_BROKER,
help='Address of the broker, default: %default')
parser.add_option('-e', "--exchange", dest="exchange", type="string", default=DEFAULT_BUSNAME,
help="Exchange where the OTDB notifications are published. "
"[default: %default]")
(options, args) = parser.parse_args()
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
with TriggerCancellationService(exchange=options.exchange,
broker=options.broker):
waitForInterrupt()
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the storagequery service')
parser.add_option(
'-c',
'--cache_path',
dest='cache_path',
type='string',
default=os.path.expandvars('$LOFARROOT/etc/storagequery_cache.py'),
help='path of the cache file, default: %default')
parser.add_option(
'-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the messaging broker, default: %default')
parser.add_option(
"-e",
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help="Name of the bus exchange on the broker, [default: %default]")
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
(options, args) = parser.parse_args()
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with CacheManager(exchange=options.exchange,
broker=options.broker,
cache_path=options.cache_path) as cache_manager:
with createService(exchange=options.exchange,
broker=options.broker,
cache_manager=cache_manager):
waitForInterrupt()
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
from optparse import OptionParser
from lofar.common.util import waitForInterrupt
# Check the invocation arguments
parser = OptionParser(
"%prog [options]",
description='runs the RAtoOTDBTaskSpecificationPropagator service')
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: %default')
parser.add_option(
'-e',
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help=
"Name of the bus on which messages are published, default: %default")
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
(options, args) = parser.parse_args()
logging.getLogger('lofar.sas.resourceassignment.database.radbbuslistener'
).level = logging.WARN
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with RAtoOTDBPropagator(exchange=options.exchange,
broker=options.broker) as propagator:
with RABusListener(handler_type=RATaskStatusChangedHandler,
handler_kwargs={'propagator': propagator},
exchange=options.exchange,
broker=options.broker):
waitForInterrupt()
def main():
from optparse import OptionParser
from lofar.messaging import setQpidLogLevel
from lofar.common.util import waitForInterrupt
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the resourceassigner service')
parser.add_option('-q',
'--broker',
dest='broker',
type='string',
default=None,
help='Address of the qpid broker, default: localhost')
parser.add_option(
"-b",
"--busname",
dest="busname",
type="string",
default=DEFAULT_BUSNAME,
help="Name of the bus exchange on the qpid broker, default: %s" %
DEFAULT_BUSNAME)
parser.add_option("-s",
"--servicename",
dest="servicename",
type="string",
default=DEFAULT_SERVICENAME,
help="Name for this service, default: %s" %
DEFAULT_SERVICENAME)
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
(options, args) = parser.parse_args()
setQpidLogLevel(logging.INFO)
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with createService(busname=options.busname,
servicename=options.servicename,
broker=options.broker):
waitForInterrupt()
def main():
from optparse import OptionParser
from lofar.messaging import setQpidLogLevel
from lofar.common.util import waitForInterrupt
from lofar.sas.resourceassignment.resourceassignmentservice.config import DEFAULT_BUSNAME as RADB_BUSNAME
from lofar.sas.resourceassignment.resourceassignmentservice.config import DEFAULT_SERVICENAME as RADB_SERVICENAME
from lofar.sas.otdb.config import DEFAULT_OTDB_SERVICE_BUSNAME, DEFAULT_OTDB_SERVICENAME
from lofar.mom.momqueryservice.config import DEFAULT_MOMQUERY_BUSNAME, DEFAULT_MOMQUERY_SERVICENAME
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the RAtoOTDBTaskSpecificationPropagator service')
parser.add_option('-q', '--broker', dest='broker', type='string', default=None, help='Address of the qpid broker, default: localhost')
parser.add_option("--notification_busname", dest="notification_busname", type="string", default=RA_NOTIFICATION_BUSNAME, help="Name of the notification bus on which messages are published, default: %default")
parser.add_option("--notification_subject", dest="notification_subject", type="string", default=RA_NOTIFICATION_PREFIX+'TaskUpdated', help="Subject of the published messages to listen for, default: %default")
parser.add_option("--radb_busname", dest="radb_busname", type="string", default=RADB_BUSNAME, help="Name of the bus on which the RADB service listens, default: %default")
parser.add_option("--radb_servicename", dest="radb_servicename", type="string", default=RADB_SERVICENAME, help="Name of the RADB service, default: %default")
parser.add_option("--otdb_busname", dest="otdb_busname", type="string", default=DEFAULT_OTDB_SERVICE_BUSNAME, help="Name of the bus on which the OTDB service listens, default: %default")
parser.add_option("--otdb_servicename", dest="otdb_servicename", type="string", default=DEFAULT_OTDB_SERVICENAME, help="Name of the OTDB service, default: %default")
parser.add_option("--mom_busname", dest="mom_busname", type="string", default=DEFAULT_MOMQUERY_BUSNAME, help="Name of the bus on which the MoM service listens, default: %default")
parser.add_option("--mom_servicename", dest="mom_servicename", type="string", default=DEFAULT_MOMQUERY_SERVICENAME, help="Name of the MoM service, default: %default")
parser.add_option('-V', '--verbose', dest='verbose', action='store_true', help='verbose logging')
(options, args) = parser.parse_args()
logging.getLogger('lofar.sas.resourceassignment.database.radbbuslistener').level = logging.WARN
setQpidLogLevel(logging.INFO)
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with RAtoOTDBPropagator(radb_busname=options.radb_busname,
radb_servicename=options.radb_servicename,
otdb_busname=options.otdb_busname,
otdb_servicename=options.otdb_servicename,
mom_busname=options.mom_busname,
mom_servicename=options.mom_servicename,
broker=options.broker) as propagator:
with RATaskStatusChangedListener(busname=options.notification_busname,
subject=options.notification_subject,
broker=options.broker,
propagator=propagator) as listener:
waitForInterrupt()
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser(
"%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: %default')
parser.add_option(
"-e",
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help="Name of the bus exchange on the broker, default: %default")
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="RADB")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
logging.basicConfig(
format='%(asctime)s %(thread)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
logger.info("Using dbcreds: %s" % dbcreds.stringWithHiddenPassword())
with createService(exchange=options.exchange,
broker=options.broker,
dbcreds=dbcreds):
waitForInterrupt()
def main():
from optparse import OptionParser
from lofar.messaging import setQpidLogLevel
from lofar.common.util import waitForInterrupt
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the resourceassigner service')
parser.add_option('-q', '--broker', dest='broker', type='string', default=None, help='Address of the qpid broker, default: localhost')
parser.add_option("-b", "--busname", dest="busname", type="string", default=DEFAULT_BUSNAME, help="Name of the bus exchange on the qpid broker, default: %s" % DEFAULT_BUSNAME)
parser.add_option("-s", "--servicename", dest="servicename", type="string", default=DEFAULT_SERVICENAME, help="Name for this service, default: %s" % DEFAULT_SERVICENAME)
parser.add_option('-V', '--verbose', dest='verbose', action='store_true', help='verbose logging')
(options, args) = parser.parse_args()
setQpidLogLevel(logging.INFO)
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with createService(busname=options.busname, servicename=options.servicename, broker=options.broker):
waitForInterrupt()
def main():
'''Starts the momqueryservice.GetProjectDetails service'''
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the momqueryservice')
parser.add_option('-q', '--broker', dest='broker', type='string', default=None, help='Address of the qpid broker, default: localhost')
parser.add_option("-b", "--busname", dest="busname", type="string", default=DEFAULT_MOMQUERY_BUSNAME, help="Name of the bus exchange on the qpid broker, [default: %default]")
parser.add_option("-s", "--servicename", dest="servicename", type="string", default=DEFAULT_MOMQUERY_SERVICENAME, help="Name for this service, [default: %default]")
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="MoM")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
# start the service and listen.
with createService(busname=options.busname,
servicename=options.servicename,
broker=options.broker,
dbcreds=dbcreds):
waitForInterrupt()
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the cleanup service')
parser.add_option(
'-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the messaging broker, default: %default')
parser.add_option(
"-e",
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help="Name of the bus exchange on the broker, [default: %default]")
parser.add_option("--mountpoint",
dest="mountpoint",
type="string",
default=CEP4_DATA_MOUNTPOINT,
help="path of local cep4 mount point, default: %default")
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
(options, args) = parser.parse_args()
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with createService(exchange=options.exchange, broker=options.broker):
waitForInterrupt()
def main():
from optparse import OptionParser
from lofar.common.util import waitForInterrupt
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the task prescheduler service')
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: %default')
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
parser.add_option('-e',
'--exchange',
dest='exchange',
type='string',
default=DEFAULT_BUSNAME,
help='exchange for communication. [default: %default]')
(options, args) = parser.parse_args()
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with RABusListener(handler_type=TaskPreschedulerEventHandler,
exchange=options.exchange,
broker=options.broker,
num_threads=1):
waitForInterrupt()
def main():
'''
Run the qa service program with commandline arguments.
'''
# Check the invocation arguments
parser = OptionParser(
"%prog [options]",
description=
'run the qa_service which listens for observations/pipelines finished events on '
'the bus and then starts the QA (Quality Assurance) processes to convert MS to '
'hdf5 files and generate inspection plots.')
group = OptionGroup(parser, 'QPid Messaging options')
group.add_option('-b',
'--broker',
dest='broker',
type='string',
default='localhost',
help='Address of the qpid broker, default: %default')
group.add_option(
'-e',
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help=
"Bus or queue where the OTDB notifications are published. [default: %default]"
)
parser.add_option_group(group)
(options, args) = parser.parse_args()
#config logging
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.INFO)
#start the qa service
with QAService(exchange=options.exchange, broker=options.broker):
#loop and wait for messages or interrupt.
waitForInterrupt()
def main():
from optparse import OptionParser
from lofar.common import dbcredentials
from lofar.common.util import waitForInterrupt
# Check the invocation arguments
parser = OptionParser("%prog [options]")
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: localhost')
parser.add_option(
"-e",
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help="Bus on which RPC commands are received. [default: %default]")
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
# Add options of dbcredentials: --database, --host, ...
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="OTDB")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
print("###dbcreds:", dbcreds)
with create_service(broker=options.broker,
exchange=options.exchange,
dbcreds=dbcreds):
waitForInterrupt()
logger.info("Stopped the OTDB services")
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
from optparse import OptionParser
from lofar.common.util import waitForInterrupt
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the resourceassigner service')
parser.add_option('-b', '--broker', dest='broker', type='string',
default=DEFAULT_BROKER,
help='Address of the broker, default: localhost')
parser.add_option('-e', "--exchange", dest="exchange", type="string",
default=DEFAULT_BUSNAME,
help="Name of the bus on which communication occurs [default: %default]")
parser.add_option('-V', '--verbose', dest='verbose', action='store_true', help='verbose logging')
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="RADB")
(options, args) = parser.parse_args()
radb_dbcreds = dbcredentials.parse_options(options)
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with ResourceAssigner(exchange=options.exchange,
broker=options.broker,
radb_dbcreds=radb_dbcreds) as assigner:
with RATaskSpecifiedBusListener(handler_type=SpecifiedTaskEventMessageHandler,
handler_kwargs={"assigner": assigner},
exchange=options.exchange,
broker=options.broker):
with ScheduleChecker(exchange=options.exchange,
broker=options.broker):
waitForInterrupt()
def main():
'''Starts the momqueryservice.GetProjectDetails service'''
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the momqueryservice')
parser.add_option('-q',
'--broker',
dest='broker',
type='string',
default=None,
help='Address of the qpid broker, default: localhost')
parser.add_option(
"-b",
"--busname",
dest="busname",
type="string",
default=DEFAULT_MOMQUERY_BUSNAME,
help="Name of the bus exchange on the qpid broker, [default: %default]"
)
parser.add_option("-s",
"--servicename",
dest="servicename",
type="string",
default=DEFAULT_MOMQUERY_SERVICENAME,
help="Name for this service, [default: %default]")
parser.add_option_group(dbcredentials.options_group(parser))
parser.set_defaults(dbcredentials="MoM")
(options, args) = parser.parse_args()
dbcreds = dbcredentials.parse_options(options)
# start the service and listen.
with createService(busname=options.busname,
servicename=options.servicename,
broker=options.broker,
dbcreds=dbcreds):
waitForInterrupt()
def main():
from optparse import OptionParser
from lofar.common.util import waitForInterrupt
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser(
"%prog [options]",
description='runs the resourceassignment database service')
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: %default')
parser.add_option(
"-e",
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help="Name of the bus exchange on the qpid broker, default: %default")
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
(options, args) = parser.parse_args()
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with createService(exchange=options.exchange, broker=options.broker):
waitForInterrupt()
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the observationcontrol service')
parser.add_option('-b',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: %default')
parser.add_option(
"-e",
"--exchange",
dest="exchange",
type="string",
default=DEFAULT_BUSNAME,
help="Name of the exchange on the qpid broker, default: %default")
parser.add_option('-V',
'--verbose',
dest='verbose',
action='store_true',
help='verbose logging')
(options, args) = parser.parse_args()
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with RPCService(
service_name=config.DEFAULT_OBSERVATION_CONTROL_SERVICE_NAME,
handler_type=ObservationControlHandler,
broker=options.broker,
exchange=options.exchange):
waitForInterrupt()
def main():
import logging
import sys
from optparse import OptionParser
from lofar.common.util import waitForInterrupt
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', level=logging.INFO)
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description="run the rataskspecified service")
parser.add_option("-b", "--notification_bus", dest="notification_bus", type="string",
default=DEFAULT_RA_TASK_SPECIFIED_NOTIFICATION_BUSNAME,
help="Bus or queue we publish resource requests on. [default: %default]")
parser.add_option("-s", "--notification_subject", dest="notification_subject", type="string",
default=DEFAULT_RA_TASK_SPECIFIED_NOTIFICATION_SUBJECT,
help="The subject of the event messages which this service publishes. [default: %default]")
parser.add_option("--otdb_notification_bus", dest="otdb_notification_bus", type="string",
default=DEFAULT_OTDB_NOTIFICATION_BUSNAME,
help="Bus or queue where the OTDB notifications are published. [default: %default]")
parser.add_option("--otdb_notification_subject", dest="otdb_notification_subject", type="string",
default=DEFAULT_OTDB_NOTIFICATION_SUBJECT,
help="Subject of OTDB notifications on otdb_notification_bus. [default: %default]")
parser.add_option("--otdb_request_bus", dest="otdb_request_bus", type="string",
default=DEFAULT_OTDB_SERVICE_BUSNAME,
help="Bus or queue where the OTDB requests are handled. [default: %default]")
parser.add_option('-q', '--broker', dest='broker', type='string', default=None, help='Address of the qpid broker, default: localhost')
(options, args) = parser.parse_args()
with RATaskSpecified(otdb_notification_busname=options.otdb_notification_bus,
otdb_notification_subject=options.otdb_notification_subject,
otdb_service_busname=options.otdb_request_bus,
otdb_service_subject=DEFAULT_OTDB_SERVICENAME, ##TODO parse this from command line
notification_busname=options.notification_bus,
notification_subject=options.notification_subject,
broker=options.broker):
waitForInterrupt()
def main():
from lofar.common.util import waitForInterrupt
from optparse import OptionParser
import os, sys
# make sure we run in UTC timezone
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser('%prog [options]',
description='run the ingest job monitor')
parser.add_option('-q', '--broker', dest='broker', type='string', default=DEFAULT_BROKER, help='Address of the qpid broker, default: %default')
parser.add_option("-n", "--busname", dest="busname", type="string",
default=DEFAULT_BUSNAME,
help='Name of the notification exchange where to listen for the published tbb notifications, default: %default')
(options, args) = parser.parse_args()
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.INFO,
stream=sys.stdout)
with TBBBusListener(exchange=options.busname,
broker=options.broker):
waitForInterrupt()
def main():
with create_service():
waitForInterrupt()
def main():
import logging
import sys
from optparse import OptionParser
from lofar.common.util import waitForInterrupt
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.INFO)
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description="run the rataskspecified service")
parser.add_option(
"-b",
"--notification_bus",
dest="notification_bus",
type="string",
default=DEFAULT_RA_TASK_SPECIFIED_NOTIFICATION_BUSNAME,
help="Bus or queue we publish resource requests on. [default: %default]"
)
parser.add_option(
"-s",
"--notification_subject",
dest="notification_subject",
type="string",
default=DEFAULT_RA_TASK_SPECIFIED_NOTIFICATION_SUBJECT,
help=
"The subject of the event messages which this service publishes. [default: %default]"
)
parser.add_option(
"--otdb_notification_bus",
dest="otdb_notification_bus",
type="string",
default=DEFAULT_OTDB_NOTIFICATION_BUSNAME,
help=
"Bus or queue where the OTDB notifications are published. [default: %default]"
)
parser.add_option(
"--otdb_notification_subject",
dest="otdb_notification_subject",
type="string",
default=DEFAULT_OTDB_NOTIFICATION_SUBJECT,
help=
"Subject of OTDB notifications on otdb_notification_bus. [default: %default]"
)
parser.add_option(
"--otdb_request_bus",
dest="otdb_request_bus",
type="string",
default=DEFAULT_OTDB_SERVICE_BUSNAME,
help=
"Bus or queue where the OTDB requests are handled. [default: %default]"
)
parser.add_option('-q',
'--broker',
dest='broker',
type='string',
default=None,
help='Address of the qpid broker, default: localhost')
(options, args) = parser.parse_args()
with RATaskSpecified(
otdb_notification_busname=options.otdb_notification_bus,
otdb_notification_subject=options.otdb_notification_subject,
otdb_service_busname=options.otdb_request_bus,
otdb_service_subject=
DEFAULT_OTDB_SERVICENAME, ##TODO parse this from command line
notification_busname=options.notification_bus,
notification_subject=options.notification_subject,
broker=options.broker):
waitForInterrupt()
def onResourceClaimInserted(self, new_claim):
'''onResourceClaimInserted is called upon receiving a ResourceClaimInserted message.
:param new_claim: dictionary with the inserted claim'''
pass
def onResourceClaimDeleted(self, old_claim):
'''onResourceClaimDeleted is called upon receiving a ResourceClaimDeleted message.
:param old_claim: dictionary with the deleted claim'''
pass
def onResourceAvailabilityUpdated(self, old_availability,
new_availability):
'''onResourceAvailabilityUpdated is called upon receiving a ResourceAvailabilityUpdated message.
:param old_availability: dictionary with the resource availability before the update
:param new_availability: dictionary with the updated availability'''
pass
def onResourceCapacityUpdated(self, old_capacity, new_capacity):
'''onResourceCapacityUpdated is called upon receiving a ResourceCapacityUpdated message.
:param old_capacity: dictionary with the resource capacity before the update
:param new_capacity: dictionary with the updated capacity'''
pass
if __name__ == '__main__':
with RADBBusListener(broker=None) as listener:
waitForInterrupt()
__all__ = ["RADBBusListener"]
def main():
from optparse import OptionParser
from lofar.messaging import setQpidLogLevel
from lofar.common.util import waitForInterrupt
from lofar.sas.resourceassignment.resourceassignmentservice.config import DEFAULT_BUSNAME as RADB_BUSNAME
from lofar.sas.resourceassignment.resourceassignmentservice.config import DEFAULT_SERVICENAME as RADB_SERVICENAME
from lofar.sas.resourceassignment.resourceassignmentestimator.config import DEFAULT_BUSNAME as RE_BUSNAME
from lofar.sas.resourceassignment.resourceassignmentestimator.config import DEFAULT_SERVICENAME as RE_SERVICENAME
from lofar.sas.otdb.config import DEFAULT_OTDB_SERVICE_BUSNAME, DEFAULT_OTDB_SERVICENAME
from lofar.sas.systemstatus.service.config import DEFAULT_SSDB_BUSNAME
from lofar.sas.systemstatus.service.config import DEFAULT_SSDB_SERVICENAME
# Check the invocation arguments
parser = OptionParser("%prog [options]",
description='runs the resourceassigner service')
parser.add_option('-q', '--broker', dest='broker', type='string',
default=None,
help='Address of the qpid broker, default: localhost')
parser.add_option("--notification_busname", dest="notification_busname", type="string",
default=DEFAULT_RA_TASK_SPECIFIED_NOTIFICATION_BUSNAME,
help="Name of the notification bus on which taskspecified messages are published. [default: %default]")
parser.add_option("--notification_subject", dest="notification_subject", type="string",
default=DEFAULT_RA_TASK_SPECIFIED_NOTIFICATION_SUBJECT,
help="Subject of the published taskspecified messages to listen for. [default: %default]")
parser.add_option("--radb_busname", dest="radb_busname", type="string",
default=RADB_BUSNAME,
help="Name of the bus on which the radb service listens. [default: %default]")
parser.add_option("--radb_servicename", dest="radb_servicename", type="string",
default=RADB_SERVICENAME,
help="Name of the radb service. [default: %default]")
parser.add_option("--re_busname", dest="re_busname", type="string",
default=RE_BUSNAME,
help="Name of the bus on which the resource estimator service listens. [default: %default]")
parser.add_option("--re_servicename", dest="re_servicename", type="string",
default=RE_SERVICENAME,
help="Name of the resource estimator service. [default: %default]")
parser.add_option("--otdb_busname", dest="otdb_busname", type="string", default=DEFAULT_OTDB_SERVICE_BUSNAME, help="Name of the bus on which the OTDB service listens, default: %default")
parser.add_option("--otdb_servicename", dest="otdb_servicename", type="string", default=DEFAULT_OTDB_SERVICENAME, help="Name of the OTDB service, default: %default")
parser.add_option("--ssdb_busname", dest="ssdb_busname", type="string",
default=DEFAULT_SSDB_BUSNAME,
help="Name of the bus on which the ssdb service listens. [default: %default]")
parser.add_option("--ssdb_servicename", dest="ssdb_servicename", type="string",
default=DEFAULT_SSDB_SERVICENAME,
help="Name of the ssdb service. [default: %default]")
parser.add_option('-V', '--verbose', dest='verbose', action='store_true', help='verbose logging')
(options, args) = parser.parse_args()
logging.getLogger('lofar.messaging.messagebus').setLevel(logging.WARNING)
setQpidLogLevel(logging.INFO)
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
with ResourceAssigner(radb_busname=options.radb_busname,
radb_servicename=options.radb_servicename,
re_busname=options.re_busname,
re_servicename=options.re_servicename,
otdb_busname=options.otdb_busname,
otdb_servicename=options.otdb_servicename,
ssdb_busname=options.ssdb_busname,
ssdb_servicename=options.ssdb_servicename,
broker=options.broker) as assigner:
with SpecifiedTaskListener(busname=options.notification_busname,
subject=options.notification_subject,
broker=options.broker,
assigner=assigner) as listener:
waitForInterrupt()
pass
def onResourceClaimInserted(self, new_claim):
'''onResourceClaimInserted is called upon receiving a ResourceClaimInserted message.
:param new_claim: dictionary with the inserted claim'''
pass
def onResourceClaimDeleted(self, old_claim):
'''onResourceClaimDeleted is called upon receiving a ResourceClaimDeleted message.
:param old_claim: dictionary with the deleted claim'''
pass
def onResourceAvailabilityUpdated(self, old_availability, new_availability):
'''onResourceAvailabilityUpdated is called upon receiving a ResourceAvailabilityUpdated message.
:param old_availability: dictionary with the resource availability before the update
:param new_availability: dictionary with the updated availability'''
pass
def onResourceCapacityUpdated(self, old_capacity, new_capacity):
'''onResourceCapacityUpdated is called upon receiving a ResourceCapacityUpdated message.
:param old_capacity: dictionary with the resource capacity before the update
:param new_capacity: dictionary with the updated capacity'''
pass
if __name__ == '__main__':
with RADBBusListener(broker=None) as listener:
waitForInterrupt()
__all__ = ["RADBBusListener"]
def main():
from optparse import OptionParser
# Check the invocation arguments
parser = OptionParser(
'%prog [options]',
description=
'run ingest mom adapter, which receives jobs from MoM, and updates ingest statuses to MoM'
)
parser.add_option('-q',
'--broker',
dest='broker',
type='string',
default=DEFAULT_BROKER,
help='Address of the qpid broker, default: %default')
parser.add_option(
'--exchange',
dest='exchange',
type='string',
default=DEFAULT_BUSNAME,
help='Name of the bus on which the services listen, default: %default')
parser.add_option(
"-m",
"--mom_credentials",
dest="mom_credentials",
type="string",
default='MoM_site' if isProductionEnvironment() else 'MoM_site_test',
help=
"Name of website credentials for MoM user/pass (see ~/.lofar/dbcredentials) [default=%default]"
)
parser.add_option(
"--host",
dest="host",
type="string",
default=DEFAULT_MOM_XMLRPC_HOST,
help=
"address on which the xmlrpc server listens for (mom) jobs [default=%default]"
)
parser.add_option(
"-p",
"--port",
dest="port",
type="int",
default=DEFAULT_MOM_XMLRPC_PORT,
help=
"port on which the xmlrpc server listens for (mom) jobs [default=%default]"
)
(options, args) = parser.parse_args()
logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s',
level=logging.INFO)
mom_creds = DBCredentials().get(options.mom_credentials)
logger.info("Using username \'%s\' for MoM web client" % mom_creds.user)
logger.info('*****************************************')
logger.info('Starting IngestMomAdapter...')
logger.info('*****************************************')
with IngestMomAdapter(mom_creds, options.exchange, options.broker,
options.host, options.port) as adapter:
waitForInterrupt()
logger.info('Stopped IngestMomAdapter')
