def __init__(self,
task_id,
specification_tree,
resource_estimator,
resource_availability_checker,
radb: RADatabase,
broker=DEFAULT_BROKER):
"""
Creates a PriorityScheduler instance
:param task_id: the ID of the task at hand
:param specification_tree: the full specification; will be modified where needed with respect to resources
:param resource_estimator: the ResourceEstimator function that turns a specification into resource estimates
:param resource_availability_checker: the ResourceAvailabilityChecker instance to use
:param radb: a RADatabase instance.
:param broker: the message broker to use for send messages/RPC calls/etc.
"""
super(PriorityScheduler,
self).__init__(task_id, specification_tree, resource_estimator,
resource_availability_checker, radb)
self.momqueryservice = MoMQueryRPC.create(broker=broker, timeout=180)
# Time needed in between tasks to setup the stations
self.STATION_SETUP_TIME_MINUTES = 1
def __init__(self,
exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER,
radb_dbcreds=None):
"""
Creates a ResourceAssigner instance
:param exchange: name of the bus on which the services listen (default: lofar)
:param ra_notification_prefix: prefix used in notification message subject (default: ResourceAssigner.)
:param broker: Valid Qpid broker host (default: None, which means localhost)
:param radb_dbcreds: the credentials to be used for accessing the RADB (default: None, which means default)
"""
self.radb = RADatabase(dbcreds=radb_dbcreds)
self.rerpc = ResourceEstimatorRPC.create(exchange=exchange,
broker=broker)
self.otdbrpc = OTDBRPC.create(exchange=exchange, broker=broker)
self.momrpc = MoMQueryRPC.create(exchange=exchange, broker=broker)
self.sqrpc = StorageQueryRPC.create(exchange=exchange, broker=broker)
self.curpc = CleanupRPC.create(exchange=exchange, broker=broker)
self.ra_notification_bus = ToBus(exchange=exchange, broker=broker)
self.obscontrol = ObservationControlRPCClient.create(exchange=exchange,
broker=broker)
self.resource_availability_checker = ResourceAvailabilityChecker(
self.radb)
# For the DwellScheduler instances created during run-time we store the following variables
self.radb_creds = radb_dbcreds
self.broker = broker
def __init__(self, momquery_rpc=MoMQueryRPC()):
"""
TriggerNotificationHandler listens on the lofar trigger message bus and emails when trigger
gets submitted.
"""
super(TriggerNotificationHandler, self).__init__()
self.mom_rpc_client = momquery_rpc
def __init__(self, exchange=DEFAULT_BUSNAME, broker=DEFAULT_BROKER):
"""
Creates a TaskInfoCache instance, which listens for OTDB task status events, and then fetches and caches relevant info for the current active task(s).
:param exchange:
:param broker:
"""
# the internal cache is a dict with a mapping of otdb_id->TaskInfo
self._cache = {}
# the internal project cache is a dict with a mapping of project_name->project_info_dict
self._project_cache = {}
# the internal stations cache is a list of the currently used stations
self._stations_cache = []
# internal rpc's to fetch the needed information
self._otdbrpc = OTDBRPC.create(exchange=exchange,
broker=broker,
timeout=DEFAULT_RPC_TIMEOUT)
self._momrpc = MoMQueryRPC.create(exchange=exchange,
broker=broker,
timeout=DEFAULT_RPC_TIMEOUT)
self._radbrpc = RADBRPC.create(exchange=exchange,
broker=broker,
timeout=DEFAULT_RPC_TIMEOUT)
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser('%prog [options]',
description='run the resource assignment editor web service')
parser.add_option('-p', '--port', dest='port', type='int', default=5000, help='port number on which to host the webservice, default: %default')
parser.add_option('-q', '--broker', dest='broker', type='string', default=None, help='Address of the qpid broker, default: localhost')
parser.add_option('--radb_busname', dest='radb_busname', type='string', default=DEFAULT_RADB_BUSNAME, help='Name of the bus exchange on the qpid broker on which the radbservice listens, default: %default')
parser.add_option('--radb_servicename', dest='radb_servicename', type='string', default=DEFAULT_RADB_SERVICENAME, help='Name of the radbservice, default: %default')
parser.add_option('--radb_notification_busname', dest='radb_notification_busname', type='string', default=DEFAULT_RADB_CHANGES_BUSNAME, help='Name of the notification bus exchange on the qpid broker on which the radb notifications are published, default: %default')
parser.add_option('--radb_notification_subjects', dest='radb_notification_subjects', type='string', default=DEFAULT_RADB_CHANGES_SUBJECTS, help='Subject(s) to listen for on the radb notification bus exchange on the qpid broker, default: %default')
parser.add_option('--mom_busname', dest='mom_busname', type='string', default=DEFAULT_MOMQUERY_BUSNAME, help='Name of the bus exchange on the qpid broker on which the momservice listens, default: %default')
parser.add_option('--mom_servicename', dest='mom_servicename', type='string', default=DEFAULT_MOMQUERY_SERVICENAME, help='Name of the momservice, 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)
global rarpc
rarpc = RARPC(busname=DEFAULT_RADB_BUSNAME, servicename=DEFAULT_RADB_SERVICENAME, broker=options.broker)
global momrpc
momrpc = MoMQueryRPC(busname=DEFAULT_MOMQUERY_BUSNAME, servicename=DEFAULT_MOMQUERY_SERVICENAME, timeout=2.5, broker=options.broker)
global radbchangeshandler
radbchangeshandler = RADBChangesHandler(DEFAULT_RADB_CHANGES_BUSNAME, broker=options.broker, momrpc=momrpc)
with radbchangeshandler, rarpc, momrpc:
'''Start the webserver'''
app.run(debug=options.verbose, threaded=True, host='0.0.0.0', port=options.port)
def __init__(self,
radb_busname=RADB_BUSNAME,
radb_servicename=RADB_SERVICENAME,
radb_broker=None,
otdb_busname=DEFAULT_OTDB_SERVICE_BUSNAME,
otdb_servicename=DEFAULT_OTDB_SERVICENAME,
mom_busname=DEFAULT_MOMQUERY_BUSNAME,
mom_servicename=DEFAULT_MOMQUERY_SERVICENAME,
otdb_broker=None,
mom_broker=None,
broker=None):
"""
RAtoOTDBPropagator updates tasks in the OTDB after the ResourceAssigner is done with them.
:param radb_busname: busname on which the radb service listens (default: lofar.ra.command)
:param radb_servicename: servicename of the radb service (default: RADBService)
:param radb_broker: valid Qpid broker host (default: None, which means localhost)
:param otdb_busname: busname on which the OTDB service listens (default: lofar.otdb.command)
:param otdb_servicename: servicename of the OTDB service (default: OTDBService)
:param otdb_broker: valid Qpid broker host (default: None, which means localhost)
:param broker: if specified, overrules radb_broker and otdb_broker. Valid Qpid broker host (default: None, which means localhost)
"""
if broker:
radb_broker = broker
otdb_broker = broker
mom_broker = broker
self.radbrpc = RADBRPC(busname=radb_busname, servicename=radb_servicename, broker=radb_broker) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.otdbrpc = OTDBRPC(busname=otdb_busname, servicename=otdb_servicename, broker=otdb_broker) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.momrpc = MoMQueryRPC(busname=mom_busname, servicename=mom_servicename, broker=mom_broker)
self.translator = RAtoOTDBTranslator()
def __init__(self,
momqueryrpc = MoMQueryRPC.create(exchange=DEFAULT_BUSNAME, broker=DEFAULT_BROKER),
exchange = DEFAULT_BUSNAME,
broker = DEFAULT_BROKER):
super(TriggerCancellationService, self).__init__(
handler_type=TriggerCancellationHandler, handler_kwargs={'momquery_rpc': momqueryrpc},
exchange=exchange, broker=broker)
def __init__(self, **kwargs):
super(SpecificationHandler, self).__init__()
self.momqueryrpc = MoMQueryRPC.create(exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER)
self.validationrpc = ValidationRPC.create(exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER)
self.specificationtranslationrpc = TranslationRPC.create(
exchange=DEFAULT_BUSNAME, broker=DEFAULT_BROKER)
def __init__(self, exchange=DEFAULT_BUSNAME, broker=DEFAULT_BROKER):
"""
:param exchange: name of the exchange to listen on.
:param broker: name of the broker to connect to.
"""
super().__init__()
self.otdbrpc = OTDBRPC.create(exchange=exchange, broker=broker)
self.radbrpc = RADBRPC.create(exchange=exchange, broker=broker)
self.momrpc = MoMQueryRPC.create(exchange=exchange, broker=broker)
self.send_bus = ToBus(exchange=exchange, broker=broker)
def __init__(self, exchange=DEFAULT_BUSNAME, broker=DEFAULT_BROKER):
"""
RAtoOTDBPropagator updates tasks in the OTDB after the ResourceAssigner is done with them.
:param exchange: exchange on which the services listen (default: lofar)
:param broker: Valid Qpid broker host (default: None, which means localhost)
"""
self.radbrpc = RADBRPC.create(exchange=exchange, broker=broker)
self.otdbrpc = OTDBRPC.create(exchange=exchange, broker=broker)
self.momrpc = MoMQueryRPC.create(exchange=exchange, broker=broker)
self.translator = RAtoOTDBTranslator()
def __init__(self, exchange=DEFAULT_BUSNAME, broker=DEFAULT_BROKER):
"""
"""
self._thread = None
self._running = False
self._radbrpc = RADBRPC.create(exchange=exchange, broker=broker)
self._momrpc = MoMQueryRPC.create(exchange=exchange, broker=broker)
self._curpc = CleanupRPC.create(exchange=exchange, broker=broker)
self._otdbrpc = OTDBRPC.create(exchange=exchange,
broker=broker,
timeout=180)
def __init__(self,
radb_busname=RADB_BUSNAME,
radb_servicename=RADB_SERVICENAME,
radb_broker=None,
otdb_busname=DEFAULT_OTDB_SERVICE_BUSNAME,
otdb_servicename=DEFAULT_OTDB_SERVICENAME,
mom_busname=DEFAULT_MOMQUERY_BUSNAME,
mom_servicename=DEFAULT_MOMQUERY_SERVICENAME,
otdb_broker=None,
mom_broker=None,
broker=None):
"""
RAtoOTDBPropagator updates tasks in the OTDB after the ResourceAssigner is done with them.
:param radb_busname: busname on which the radb service listens (default: lofar.ra.command)
:param radb_servicename: servicename of the radb service (default: RADBService)
:param radb_broker: valid Qpid broker host (default: None, which means localhost)
:param otdb_busname: busname on which the OTDB service listens (default: lofar.otdb.command)
:param otdb_servicename: servicename of the OTDB service (default: OTDBService)
:param otdb_broker: valid Qpid broker host (default: None, which means localhost)
:param broker: if specified, overrules radb_broker and otdb_broker. Valid Qpid broker host (default: None, which means localhost)
"""
if broker:
radb_broker = broker
otdb_broker = broker
mom_broker = broker
self.radbrpc = RADBRPC(
busname=radb_busname,
servicename=radb_servicename,
broker=radb_broker
) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.otdbrpc = OTDBRPC(
busname=otdb_busname,
servicename=otdb_servicename,
broker=otdb_broker
) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.momrpc = MoMQueryRPC(busname=mom_busname,
servicename=mom_servicename,
broker=mom_broker)
self.translator = RAtoOTDBTranslator()
def __init__(self,
momquery_rpc=MoMQueryRPC(),
exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER):
"""
TriggerNotificationListener listens on the lofar trigger message bus and emails when trigger
gets submitted.
:param exchange: valid message exchange address
:param broker: valid broker host (default: None, which means localhost)
"""
super(OTDBTriggerListener,
self).__init__(handler_type=OTDBTriggerHandler,
handler_kwargs={'momquery_rpc': momquery_rpc},
exchange=exchange,
broker=broker)
def __init__(self,
mountpoint=CEP4_DATA_MOUNTPOINT,
exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER):
self.mountpoint = mountpoint
self.projects_path = os.path.join(
self.mountpoint,
'projects' if isProductionEnvironment() else 'test-projects')
self.scratch_path = os.path.join(self.mountpoint, 'scratch',
'pipeline')
self.share_path = os.path.join(self.mountpoint, 'share', 'pipeline')
self.radbrpc = RADBRPC.create(exchange=exchange, broker=broker)
self.momrpc = MoMQueryRPC.create(exchange=exchange, broker=broker)
def __init__(self,
momquery_rpc=MoMQueryRPC(),
busname=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER):
"""
TriggerNotificationListener listens on the lofar trigger message bus and emails when trigger
gets submitted.
:param address: valid Qpid address (default: lofar.otdb.status)
:param broker: valid Qpid broker host (default: None, which means localhost)
"""
super(TriggerNotificationListener,
self).__init__(handler_type=TriggerNotificationHandler,
handler_kwargs={'momquery_rpc': momquery_rpc},
exchange=busname,
routing_key=DEFAULT_TRIGGER_NOTIFICATION_SUBJECT,
broker=broker)
def main():
# make sure we run in UTC timezone
import os
os.environ['TZ'] = 'UTC'
# Check the invocation arguments
parser = OptionParser(
'%prog [options]',
description='run the resource assignment editor web service')
parser.add_option(
'--webserver_port',
dest='webserver_port',
type='int',
default=7412,
help='port number on which to host the webservice, default: %default')
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 exchange on the qpid 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()
logging.basicConfig(
format='%(asctime)s %(levelname)s %(message)s',
level=logging.DEBUG if options.verbose else logging.INFO)
global _radb_dbcreds
_radb_dbcreds = dbcredentials.parse_options(options)
if _radb_dbcreds.database:
logger.info("Using dbcreds for direct RADB access: %s" %
_radb_dbcreds.stringWithHiddenPassword())
else:
_radb_dbcreds = None
global rarpc
rarpc = RADBRPC.create(exchange=options.exchange, broker=options.broker)
global otdbrpc
otdbrpc = OTDBRPC.create(exchange=options.exchange, broker=options.broker)
global curpc
curpc = CleanupRPC.create(exchange=options.exchange, broker=options.broker)
global sqrpc
sqrpc = StorageQueryRPC.create(exchange=options.exchange,
timeout=10,
broker=options.broker)
global momqueryrpc
momqueryrpc = MoMQueryRPC.create(exchange=options.exchange,
timeout=10,
broker=options.broker)
global changeshandler
changeshandler = ChangesHandler(exchange=options.exchange,
broker=options.broker,
momqueryrpc=momqueryrpc,
radbrpc=rarpc,
sqrpc=sqrpc)
with changeshandler, rarpc, otdbrpc, curpc, sqrpc, momqueryrpc:
'''Start the webserver'''
app.run(debug=options.verbose,
threaded=True,
host='0.0.0.0',
port=options.webserver_port)
from lofar.sas.TriggerEmailService.common.config import DEFAULT_TRIGGER_NOTIFICATION_SUBJECT
from lofar.triggerservices.voevent_listener import VOEventListenerInterface
import lofar.triggerservices.voevent_decider
from lofar.mac.tbb.tbb_util import parse_parset_from_voevent
from lofar.mac.tbbservice.client.tbbservice_rpc import TBBRPC
from lofar.mac.tbb.tbb_set_storage import create_mapping
import dateutil.parser
import time
import logging
logger = logging.getLogger(__name__)
momqueryrpc = MoMQueryRPC.create(exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER)
validationrpc = ValidationRPC.create(exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER)
specificationrpc = SpecificationRPC.create(exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER)
translationrpc = TranslationRPC.create(exchange=DEFAULT_BUSNAME,
broker=DEFAULT_BROKER)
def _auth_allows_triggers(project):
response = momqueryrpc.allows_triggers(project)
return response['allows']
def _quota_allows_triggers(project):
response = momqueryrpc.get_trigger_quota(project)
def __init__(self, exchange=DEFAULT_BUSNAME, broker=DEFAULT_BROKER):
super().__init__()
self.otdbrpc = OTDBRPC.create(exchange=exchange, broker=broker)
self.momquery = MoMQueryRPC.create(exchange=exchange, broker=broker)
self.radb = RADatabase()
class RAtoOTDBPropagator():
def __init__(self,
radb_busname=RADB_BUSNAME,
radb_servicename=RADB_SERVICENAME,
radb_broker=None,
otdb_busname=DEFAULT_OTDB_SERVICE_BUSNAME,
otdb_servicename=DEFAULT_OTDB_SERVICENAME,
mom_busname=DEFAULT_MOMQUERY_BUSNAME,
mom_servicename=DEFAULT_MOMQUERY_SERVICENAME,
otdb_broker=None,
mom_broker=None,
broker=None):
"""
RAtoOTDBPropagator updates tasks in the OTDB after the ResourceAssigner is done with them.
:param radb_busname: busname on which the radb service listens (default: lofar.ra.command)
:param radb_servicename: servicename of the radb service (default: RADBService)
:param radb_broker: valid Qpid broker host (default: None, which means localhost)
:param otdb_busname: busname on which the OTDB service listens (default: lofar.otdb.command)
:param otdb_servicename: servicename of the OTDB service (default: OTDBService)
:param otdb_broker: valid Qpid broker host (default: None, which means localhost)
:param broker: if specified, overrules radb_broker and otdb_broker. Valid Qpid broker host (default: None, which means localhost)
"""
if broker:
radb_broker = broker
otdb_broker = broker
mom_broker = broker
self.radbrpc = RADBRPC(
busname=radb_busname,
servicename=radb_servicename,
broker=radb_broker
) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.otdbrpc = OTDBRPC(
busname=otdb_busname,
servicename=otdb_servicename,
broker=otdb_broker
) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.momrpc = MoMQueryRPC(busname=mom_busname,
servicename=mom_servicename,
broker=mom_broker)
self.translator = RAtoOTDBTranslator()
def __enter__(self):
"""Internal use only. (handles scope 'with')"""
self.open()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""Internal use only. (handles scope 'with')"""
self.close()
def open(self):
"""Open rpc connections to radb service and resource estimator service"""
self.radbrpc.open()
self.otdbrpc.open()
self.momrpc.open()
def close(self):
"""Close rpc connections to radb service and resource estimator service"""
self.radbrpc.close()
self.otdbrpc.close()
self.momrpc.close()
def doTaskConflict(self, otdb_id):
logger.info('doTaskConflict: otdb_id=%s' % (otdb_id, ))
if not otdb_id:
logger.warning('doTaskConflict no valid otdb_id: otdb_id=%s' %
(otdb_id, ))
return
try:
self.otdbrpc.taskSetStatus(otdb_id, 'conflict')
except Exception as e:
logger.error(e)
def doTaskScheduled(self, ra_id, otdb_id, mom_id):
try:
logger.info('doTaskScheduled: ra_id=%s otdb_id=%s mom_id=%s' %
(ra_id, otdb_id, mom_id))
if not otdb_id:
logger.warning('doTaskScheduled no valid otdb_id: otdb_id=%s' %
(otdb_id, ))
return
ra_info = self.getRAinfo(ra_id)
logger.info('RA info for ra_id=%s otdb_id=%s: %s' %
(ra_id, otdb_id, ra_info))
# check if this is a CEP4 task, or an old CEP2 task
# at this moment the most simple check is to see if RA claimed (CEP4) storage
# TODO: do proper check on cluster/storage/etc
if not ra_info['storage']:
logger.info(
"No (CEP4) storage claimed for ra_id=%s otdb_id=%s, skipping otdb specification update."
% (ra_id, otdb_id))
return
#get mom project name
try:
project = self.momrpc.getProjectDetails(mom_id)
logger.info(project)
project_name = "_".join(
project[str(mom_id)]['project_name'].split())
except (RPCException, KeyError) as e:
logger.error(
'Could not get project name from MoM for mom_id %s: %s' %
(mom_id, str(e)))
logger.info('Using \'unknown\' as project name.')
project_name = 'unknown'
otdb_info = self.translator.CreateParset(otdb_id, ra_info,
project_name)
logger.debug("Parset info for OTDB: %s" % otdb_info)
self.setOTDBinfo(otdb_id, otdb_info, 'scheduled')
except Exception as e:
logger.error(e)
self.doTaskConflict(otdb_id)
def getRAinfo(self, ra_id):
info = {}
info["storage"] = {}
task = self.radbrpc.getTask(ra_id)
claims = self.radbrpc.getResourceClaims(task_ids=ra_id,
extended=True,
include_properties=True)
for claim in claims:
logger.debug("Processing claim: %s" % claim)
if claim['resource_type_name'] == 'storage':
info['storage'] = claim
info["starttime"] = task["starttime"]
info["endtime"] = task["endtime"]
info["status"] = task["status"]
return info
def setOTDBinfo(self, otdb_id, otdb_info, otdb_status):
try:
logger.info('Setting specticication for otdb_id %s: %s' %
(otdb_id, otdb_info))
self.otdbrpc.taskSetSpecification(otdb_id, otdb_info)
self.otdbrpc.taskPrepareForScheduling(
otdb_id, otdb_info["LOFAR.ObsSW.Observation.startTime"],
otdb_info["LOFAR.ObsSW.Observation.stopTime"])
logger.info('Setting status (%s) for otdb_id %s' %
(otdb_status, otdb_id))
self.otdbrpc.taskSetStatus(otdb_id, otdb_status)
except Exception as e:
logger.error(e)
self.doTaskConflict(otdb_id)
def __init__(self, momquery_rpc=MoMQueryRPC()):
super().__init__()
self.momqueryrpc = momquery_rpc
testid = '1234'
# create a mock for the MoMDatabaseWrapper
# so we don't need the actual momdb for this test
# and we don't need the momdb passwd
class MockMoMDatabaseWrapper:
def getProjectDetails(self, mom_ids_str):
return {str(testid): {'project_mom2id': '4567', 'project_name': 'foo', 'project_description': 'bar', 'object_mom2id': testid}}
class MockProjectDetailsQueryHandler(ProjectDetailsQueryHandler):
def prepare_loop(self):
self.momdb = MockMoMDatabaseWrapper()
# inject the mock into the service
with createService(busname, handler=MockProjectDetailsQueryHandler), \
MoMQueryRPC(busname, DEFAULT_MOMQUERY_SERVICENAME) as momrpc:
class TestLTAStorageDb(unittest.TestCase):
def testProjectDetailsQuery(self):
result = momrpc.getProjectDetails(testid)
self.assertEquals(1, len(result.keys()))
self.assertEquals(testid, result.keys()[0])
self.assertTrue('project_mom2id' in result[testid])
self.assertTrue('project_name' in result[testid])
self.assertTrue('project_description' in result[testid])
def testSqlInjection(self):
inj_testid = testid + '; select * from lofar_mom3.mom2object;'
with self.assertRaises(ValueError) as error:
result = momrpc.getProjectDetails(inj_testid)
from lxml import etree
from io import BytesIO
from lofar.triggerservices.trigger_service_rpc import TriggerRPC
from lofar.specificationservices.specification_service_rpc import SpecificationRPC
from lofar.mom.momqueryservice.momqueryrpc import MoMQueryRPC
from lofar.messaging import ToBus, EventMessage, RPCException, DEFAULT_BROKER, DEFAULT_BUSNAME
import logging
import traceback
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
triggerrpc = TriggerRPC()
specrpc = SpecificationRPC()
momrpc = MoMQueryRPC()
from .config import TRIGGER_SUBMISSION_NOTIFICATION_SUBJECT
notification_bus = ToBus()
# The base URL for triggers specifications
base_url = 'https://lofar.astron.nl/mom3/user/main/explorer/setUpExplorer.do?action=open&object=FP1_CF'
if "LOFARENV" in os.environ:
lofar_environment = os.environ['LOFARENV']
if lofar_environment != "PRODUCTION":
base_url = 'http://lofartest.control.lofar:8080/mom3/user/main/explorer/setUpExplorer.do?action=open&object=FP1_CF'
class TriggerListView(views.APIView):
def __init__(self, **kwargs):
def init_tobus(self,
exchange: str = DEFAULT_BUSNAME,
broker: str = DEFAULT_BROKER):
super().init_tobus(exchange, broker)
self._momrpc = MoMQueryRPC.create(exchange=exchange, broker=broker)
class RAtoOTDBPropagator():
def __init__(self,
radb_busname=RADB_BUSNAME,
radb_servicename=RADB_SERVICENAME,
radb_broker=None,
otdb_busname=DEFAULT_OTDB_SERVICE_BUSNAME,
otdb_servicename=DEFAULT_OTDB_SERVICENAME,
mom_busname=DEFAULT_MOMQUERY_BUSNAME,
mom_servicename=DEFAULT_MOMQUERY_SERVICENAME,
otdb_broker=None,
mom_broker=None,
broker=None):
"""
RAtoOTDBPropagator updates tasks in the OTDB after the ResourceAssigner is done with them.
:param radb_busname: busname on which the radb service listens (default: lofar.ra.command)
:param radb_servicename: servicename of the radb service (default: RADBService)
:param radb_broker: valid Qpid broker host (default: None, which means localhost)
:param otdb_busname: busname on which the OTDB service listens (default: lofar.otdb.command)
:param otdb_servicename: servicename of the OTDB service (default: OTDBService)
:param otdb_broker: valid Qpid broker host (default: None, which means localhost)
:param broker: if specified, overrules radb_broker and otdb_broker. Valid Qpid broker host (default: None, which means localhost)
"""
if broker:
radb_broker = broker
otdb_broker = broker
mom_broker = broker
self.radbrpc = RADBRPC(busname=radb_busname, servicename=radb_servicename, broker=radb_broker) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.otdbrpc = OTDBRPC(busname=otdb_busname, servicename=otdb_servicename, broker=otdb_broker) ## , ForwardExceptions=True hardcoded in RPCWrapper right now
self.momrpc = MoMQueryRPC(busname=mom_busname, servicename=mom_servicename, broker=mom_broker)
self.translator = RAtoOTDBTranslator()
def __enter__(self):
"""Internal use only. (handles scope 'with')"""
self.open()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
"""Internal use only. (handles scope 'with')"""
self.close()
def open(self):
"""Open rpc connections to radb service and resource estimator service"""
self.radbrpc.open()
self.otdbrpc.open()
self.momrpc.open()
def close(self):
"""Close rpc connections to radb service and resource estimator service"""
self.radbrpc.close()
self.otdbrpc.close()
self.momrpc.close()
def doTaskConflict(self, otdb_id):
logger.info('doTaskConflict: otdb_id=%s' % (otdb_id,))
if not otdb_id:
logger.warning('doTaskConflict no valid otdb_id: otdb_id=%s' % (otdb_id,))
return
try:
self.otdbrpc.taskSetStatus(otdb_id, 'conflict')
except Exception as e:
logger.error(e)
def doTaskScheduled(self, ra_id, otdb_id, mom_id):
try:
logger.info('doTaskScheduled: ra_id=%s otdb_id=%s mom_id=%s' % (ra_id, otdb_id, mom_id))
if not otdb_id:
logger.warning('doTaskScheduled no valid otdb_id: otdb_id=%s' % (otdb_id,))
return
ra_info = self.getRAinfo(ra_id)
logger.info('RA info for ra_id=%s otdb_id=%s: %s' % (ra_id, otdb_id, ra_info))
# check if this is a CEP4 task, or an old CEP2 task
# at this moment the most simple check is to see if RA claimed (CEP4) storage
# TODO: do proper check on cluster/storage/etc
if not ra_info['storage']:
logger.info("No (CEP4) storage claimed for ra_id=%s otdb_id=%s, skipping otdb specification update." % (ra_id, otdb_id))
return
#get mom project name
try:
project = self.momrpc.getProjectDetails(mom_id)
logger.info(project)
project_name = "_".join(project[str(mom_id)]['project_name'].split())
except (RPCException, KeyError) as e:
logger.error('Could not get project name from MoM for mom_id %s: %s' % (mom_id, str(e)))
logger.info('Using \'unknown\' as project name.')
project_name = 'unknown'
otdb_info = self.translator.CreateParset(otdb_id, ra_info, project_name)
logger.debug("Parset info for OTDB: %s" %otdb_info)
self.setOTDBinfo(otdb_id, otdb_info, 'scheduled')
except Exception as e:
logger.error(e)
self.doTaskConflict(otdb_id)
def getRAinfo(self, ra_id):
info = {}
info["storage"] = {}
task = self.radbrpc.getTask(ra_id)
claims = self.radbrpc.getResourceClaims(task_ids=ra_id, extended=True, include_properties=True)
for claim in claims:
logger.debug("Processing claim: %s" % claim)
if claim['resource_type_name'] == 'storage':
info['storage'] = claim
info["starttime"] = task["starttime"]
info["endtime"] = task["endtime"]
info["status"] = task["status"]
return info
def setOTDBinfo(self, otdb_id, otdb_info, otdb_status):
try:
logger.info('Setting specticication for otdb_id %s: %s' % (otdb_id, otdb_info))
self.otdbrpc.taskSetSpecification(otdb_id, otdb_info)
self.otdbrpc.taskPrepareForScheduling(otdb_id, otdb_info["LOFAR.ObsSW.Observation.startTime"], otdb_info["LOFAR.ObsSW.Observation.stopTime"])
logger.info('Setting status (%s) for otdb_id %s' % (otdb_status, otdb_id))
self.otdbrpc.taskSetStatus(otdb_id, otdb_status)
except Exception as e:
logger.error(e)
self.doTaskConflict(otdb_id)