def get_context_data(self, *args, **kwargs):
"""
Runs the ``fetch_alerts`` method specific to the given ``BrokerQuery`` and adds the matching alerts to the
context dictionary.
:returns: context
:rtype: dict
"""
context = super().get_context_data()
query = get_object_or_404(BrokerQuery, pk=self.kwargs['pk'])
broker_class = get_service_class(query.broker)()
alerts = broker_class.fetch_alerts(query.parameters_as_dict)
context['alerts'] = []
query.last_run = timezone.now()
query.save()
context['query'] = query
try:
while len(context['alerts']) < 20:
alert = next(alerts)
generic_alert = broker_class.to_generic_alert(alert)
cache.set('alert_{}'.format(generic_alert.id),
json.dumps(alert), 3600)
context['alerts'].append(generic_alert)
except StopIteration:
pass
return context
def handle(self, *args, **options):
brokers = alerts.get_service_classes()
broker_classes = {}
for broker in brokers:
broker_classes[broker] = alerts.get_service_class(broker)()
target = None
if options['target_id']:
try:
targets = [Target.objects.get(pk=options['target_id'])]
except ObjectDoesNotExist:
raise Exception('Invalid target id provided')
else:
sources = ReducedDatumSource.objects.filter(
name__in=broker_classes.keys()).distinct()
targets = Target.objects.filter(id__in=ReducedDatum.objects.filter(
source__in=sources).values_list('target').distinct())
failed_records = {}
for target in targets:
for class_name, clazz in broker_classes.items():
try:
clazz.process_reduced_data(target)
except HTTPError:
failed_records[class_name] = target.id
if len(failed_records) == 0:
return 'Update completed successfully'
else:
return 'Update completed with errors: {0}'.format(
str(failed_records))
def form_valid(self, form):
broker_name = self.get_broker_name()
broker = get_service_class(broker_name)()
target = form.cleaned_data.pop('target')
obsr = form.cleaned_data.pop('observation_record')
form.cleaned_data.pop(
'redirect_url'
) # redirect_url doesn't need to be passed to submit_upstream_alert
try:
# Pass non-standard fields from query parameters as kwargs
success = broker.submit_upstream_alert(target=target,
observation_record=obsr,
**form.cleaned_data)
except AlertSubmissionException as e:
logger.log(msg=f'Failed to submit alert: {e}', level=logging.WARN)
success = False
if success:
messages.success(
self.request,
f'Successfully submitted alerts to {broker_name}!')
else:
messages.warning(
self.request,
f'Unable to submit one or more alerts to {self.get_broker_name()}. See logs for details.'
)
return redirect(self.get_redirect_url())
def get_form_class(self):
"""
Returns the form class to use in this view. The form class will be the one defined in the specific broker
module for which the query is being updated.
"""
self.object = self.get_object()
return get_service_class(self.object.broker).form
def get_form_class(self):
broker_name = self.get_broker_name()
if not broker_name:
raise ValueError('Must provide a broker name')
return get_service_class(broker_name).form
def submit_upstream_form(broker,
target=None,
observation_record=None,
redirect_url=None):
"""
Renders a form to submit an alert upstream to a broker.
At least one of target/obs record should be given.
:param broker: The name of the broker to which the button will lead, as in the name field of the broker module.
:type broker: str
:param target: The target to be submitted as an alert, if any.
:type target: ``Target``
:param observation_record: The observation record to be submitted as an alert, if any.
:type observation_record: ``ObservationRecord``
:param redirect_url:
:type redirect_url: str
"""
broker_class = get_service_class(broker)
form_class = broker_class.alert_submission_form
form = form_class(broker=broker,
initial={
'target': target,
'observation_record': observation_record,
'redirect_url': redirect_url
})
return {'submit_upstream_form': form}
def handle(self, *args, **options):
query = BrokerQuery.objects.get(name=options['query_name'])
broker_class = get_service_class(query.broker)()
alerts = broker_class.fetch_alerts(query.parameters_as_dict)
targetdir = target_path + 'targetlist.dat'
targetlist = open(targetdir, 'r+')
targetlines = []
for line in targetlist:
targetlines.append(line)
for alert in alerts:
now = datetime.now()
print(now, alert, '\n')
analyze_individual_alert(alert)
if str(alert['objectId']) in str(targetlines):
pass
else:
alert = broker_class.fetch_alert(alert['lco_id'])
target = broker_class.to_target(alert)
target.save()
broker_class.process_reduced_data(target, alert)
targetlist.write(alert['objectId'] + '\n')
targetlist.close()
def get_context_data(self, *args, **kwargs):
"""
Runs the ``fetch_alerts`` method specific to the given ``BrokerQuery`` and adds the matching alerts to the
context dictionary.
:returns: context
:rtype: dict
"""
context = super().get_context_data()
query = get_object_or_404(BrokerQuery, pk=self.kwargs['pk'])
context['amon_brokers'] = settings.AMON_BROKERS
context['broker'] = query.broker
broker_class = get_service_class(query.broker)()
alerts = broker_class.fetch_alerts(query.parameters_as_dict)
context['alerts'] = []
query.last_run = timezone.now()
query.save()
# NB ideally I would use pagination but I didn't manage to do it
# Anyway we won't have more than 100 public events in one broker within the coming years
max_n_evts = 100 # maximum number of events to display
context['max_n_evts'] = 0
try:
while len(context['alerts']) < max_n_evts:
alert = next(alerts)
generic_alert = broker_class.to_generic_alert(alert)
cache.set('alert_{}'.format(generic_alert.id),
json.dumps(alert), 3600)
context['alerts'].append(generic_alert)
if len(context['alerts']) == max_n_evts:
context['max_n_evts'] = max_n_evts
except StopIteration:
pass
return context
def post(self, request, *args, **kwargs):
query_id = self.request.POST['query_id']
broker_name = self.request.POST['broker']
broker_class = get_service_class(broker_name)
alerts = self.request.POST.getlist('alerts')
if not alerts:
messages.warning(request, 'Please select at least one alert from which to create a target.')
return redirect(reverse('tom_alerts:run', kwargs={'pk': query_id}))
for alert_id in alerts:
cached_alert = cache.get('alert_{}'.format(alert_id))
if not cached_alert:
messages.error(request, 'Could not create targets. Try re running the query again.')
return redirect(reverse('tom_alerts:run', kwargs={'pk': query_id}))
generic_alert = broker_class().to_generic_alert(json.loads(cached_alert))
target = generic_alert.to_target()
target.save()
broker_class().process_reduced_data(target, json.loads(cached_alert))
target.save()
for group in request.user.groups.all().exclude(name='Public'):
assign_perm('tom_targets.view_target', group, target)
assign_perm('tom_targets.change_target', group, target)
assign_perm('tom_targets.delete_target', group, target)
if (len(alerts) == 1):
return redirect(reverse(
'tom_targets:update', kwargs={'pk': target.id})
)
else:
return redirect(reverse(
'tom_targets:list')
)
def get_form_class(self):
"""
Returns the form class to use in this view.
"""
broker_name = self.get_broker_name()
if not broker_name:
raise ValueError('Must provide a broker name')
return get_service_class(broker_name).form
def get_context_data(self, *args, **kwargs):
context = super().get_context_data()
query = get_object_or_404(BrokerQuery, pk=self.kwargs['pk'])
broker_class = get_service_class(query.broker)()
alerts = broker_class.fetch_alerts(query.parameters_as_dict)
context['alerts'] = [
broker_class.to_generic_alert(alert) for alert in alerts
]
context['query'] = query
return context
def post(self, request, *args, **kwargs):
"""
Handles the POST requests to this view. Creates a ``Target`` for each alert sent in the POST. Redirects to the
``TargetListView`` if multiple targets were created, and the ``TargetUpdateView`` if only one was created.
Redirects to the ``RunQueryView`` if no ``Target`` objects. were successfully created.
"""
query_id = self.request.POST['query_id']
broker_name = self.request.POST['broker']
broker_class = get_service_class(broker_name)
alerts = self.request.POST.getlist('alerts')
errors = []
if not alerts:
messages.warning(
request,
'Please select at least one alert from which to create a target.'
)
return redirect(reverse('tom_alerts:run', kwargs={'pk': query_id}))
for alert_id in alerts:
cached_alert = cache.get('alert_{}'.format(alert_id))
if not cached_alert:
messages.error(
request,
'Could not create targets. Try re running the query again.'
)
return redirect(
reverse('tom_alerts:run', kwargs={'pk': query_id}))
generic_alert = broker_class().to_generic_alert(
json.loads(cached_alert))
target = generic_alert.to_target()
try:
target.save()
broker_class().process_reduced_data(target,
json.loads(cached_alert))
exclude_groups = ['Public']
if broker_name in settings.PRIVATE_BROKERS:
exclude_groups += ['Public alerts']
for group in request.user.groups.all().exclude(
name__in=exclude_groups):
logger.info(group)
assign_perm('tom_targets.view_target', group, target)
assign_perm('tom_targets.change_target', group, target)
assign_perm('tom_targets.delete_target', group, target)
except IntegrityError:
messages.warning(
request,
f'Unable to save {target.name}, target with that name already exists.'
)
errors.append(target.name)
if (len(alerts) == len(errors)):
return redirect(reverse('tom_alerts:run', kwargs={'pk': query_id}))
elif (len(alerts) == 1):
return redirect(
reverse('tom_targets:update', kwargs={'pk': target.id}))
else:
return redirect(reverse('tom_targets:list'))
def get_form_class(self):
"""
Returns the form class to use in this view. The form class will be the one defined in the specific broker
module for which a new query is being created.
"""
broker_name = self.get_broker_name()
if not broker_name:
raise ValueError('Must provide a broker name')
return get_service_class(broker_name).form
def get_context_data(self, *args, **kwargs):
"""
Runs the ``fetch_alerts`` method specific to the given ``BrokerQuery`` and adds the matching alerts to the
context dictionary.
:returns: context
:rtype: dict
"""
query = get_object_or_404(BrokerQuery, pk=self.kwargs['pk'])
if query.broker in settings.PRIVATE_BROKERS and not self.request.user.groups.filter(
name='AMON members').exists():
raise PermissionDenied()
context = super().get_context_data()
context['amon_brokers'] = settings.AMON_BROKERS
context['broker'] = query.broker
broker_class = get_service_class(query.broker)()
alerts = broker_class.fetch_alerts(query.parameters_as_dict)
context['alerts'] = []
query.last_run = timezone.now()
query.save()
context['query'] = query
# NB ideally I would use pagination but I didn't manage to do it
# Anyway we won't have more than 100 public events in one broker within the coming years
max_n_evts = 100 # maximum number of events to display
context['max_n_evts'] = 0
try:
while len(context['alerts']) < max_n_evts:
alert = next(alerts)
generic_alert = broker_class.to_generic_alert(alert)
cache.set('alert_{}'.format(generic_alert.id),
json.dumps(alert), 3600)
context['alerts'].append(generic_alert)
if len(context['alerts']) == max_n_evts:
context['max_n_evts'] = max_n_evts
except StopIteration:
pass
# Reorder
ordering = self.request.GET.get('ordering', 'defaultOrderField')
ordering_list = []
if ordering != 'defaultOrderField':
for alert in context['alerts']:
if not hasattr(alert, ordering) or type(
eval('alert.' + ordering)) is type(None):
ordering_list += [1e10]
else:
ordering_list += [eval('alert.' + ordering)]
arg_sort = np.argsort(ordering_list)
context['alerts'] = [context['alerts'][arg] for arg in arg_sort]
return context
def handle(self, *args, **options):
try:
query = BrokerQuery.objects.get(name=options['query_name'])
broker_class = get_service_class(query.broker)
broker = broker_class()
alerts = broker.fetch_alerts(query.parameters_as_dict)
while True:
try:
generic_alert = broker.to_generic_alert(next(alerts))
target = generic_alert.to_target()
target.save()
self.stdout.write('Created target: {}'.format(target))
except StopIteration:
self.stdout.write('Finished creating targets')
sleep(1)
except KeyboardInterrupt:
self.stdout.write('Exiting...')
def get_context_data(self, *args, **kwargs):
context = super().get_context_data()
query = get_object_or_404(BrokerQuery, pk=self.kwargs['pk'])
broker_class = get_service_class(query.broker)()
alerts = broker_class.fetch_alerts(query.parameters_as_dict)
context['alerts'] = []
query.last_run = timezone.now()
query.save()
context['query'] = query
try:
while len(context['alerts']) < 20:
alert = next(alerts)
generic_alert = broker_class.to_generic_alert(alert)
cache.set('alert_{}'.format(generic_alert.id), json.dumps(alert), 3600)
context['alerts'].append(generic_alert)
except StopIteration:
pass
return context
def post(self, request, *args, **kwargs):
query_id = self.request.POST['query_id']
broker_name = self.request.POST['broker']
broker_class = get_service_class(broker_name)
alerts = self.request.POST.getlist('alerts')
if not alerts:
messages.warning(
request,
'Please select at least one alert from which to create a target.'
)
return redirect(reverse('tom_alerts:run', kwargs={'pk': query_id}))
for alert in alerts:
alert = broker_class().fetch_alert(alert)
target = broker_class().to_target(alert)
broker_class().process_reduced_data(target, alert)
target.save()
if (len(alerts) == 1):
return redirect(
reverse('tom_targets:detail', kwargs={'pk': target.id}))
else:
return redirect(reverse('tom_targets:list'))
def get_form_class(self):
broker_name = self.get_broker_name()
return get_service_class(broker_name).alert_submission_form
def test_get_broker_class(self):
self.assertEqual(GaiaBroker, get_service_class('Gaia'))
def test_get_invalid_broker(self):
with self.assertRaises(ImportError):
get_service_class('LASAIR')
def test_get_broker_class(self):
self.assertEqual(MARSBroker, get_service_class('MARS'))
def test_get_broker_class(self):
self.assertEqual(LasairBroker, get_service_class('Lasair'))
def test_get_broker_class(self):
self.assertEqual(TestBroker, get_service_class('TEST'))
def get_form_class(self):
self.object = self.get_object()
return get_service_class(self.object.broker).form
