539 lines
21 KiB
Java
539 lines
21 KiB
Java
/*
|
|
* Copyright (c) 2014 Hewlett-Packard Development Company, L.P.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
* implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package monasca.thresh.infrastructure.thresholding;
|
|
|
|
import backtype.storm.task.OutputCollector;
|
|
import backtype.storm.task.TopologyContext;
|
|
import backtype.storm.topology.OutputFieldsDeclarer;
|
|
import backtype.storm.topology.base.BaseRichBolt;
|
|
import backtype.storm.tuple.Fields;
|
|
import backtype.storm.tuple.Tuple;
|
|
import backtype.storm.tuple.Values;
|
|
|
|
import monasca.common.model.alarm.AlarmState;
|
|
import monasca.common.model.alarm.AlarmSubExpression;
|
|
import monasca.common.model.event.AlarmDefinitionDeletedEvent;
|
|
import monasca.common.model.event.AlarmDefinitionUpdatedEvent;
|
|
import monasca.common.model.event.AlarmDeletedEvent;
|
|
import monasca.common.model.metric.MetricDefinition;
|
|
import monasca.common.streaming.storm.Logging;
|
|
import monasca.common.util.Injector;
|
|
import monasca.thresh.domain.model.Alarm;
|
|
import monasca.thresh.domain.model.AlarmDefinition;
|
|
import monasca.thresh.domain.model.MetricDefinitionAndTenantId;
|
|
import monasca.thresh.domain.model.SubAlarm;
|
|
import monasca.thresh.domain.model.SubExpression;
|
|
import monasca.thresh.domain.model.TenantIdAndMetricName;
|
|
import monasca.thresh.domain.service.AlarmDAO;
|
|
import monasca.thresh.domain.service.AlarmDefinitionDAO;
|
|
import monasca.thresh.infrastructure.persistence.PersistenceModule;
|
|
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Handles creation of Alarms and Alarmed Metrics.
|
|
*/
|
|
public class AlarmCreationBolt extends BaseRichBolt {
|
|
private static final long serialVersionUID = 1096706128973976599L;
|
|
|
|
public static final String ALARM_CREATION_STREAM = "alarm-creation-stream";
|
|
public static final String[] ALARM_CREATION_FIELDS = new String[] {"control",
|
|
"tenantIdAndMetricName", "metricDefinitionAndTenantId", "alarmDefinitionId", "subAlarm"};
|
|
|
|
private transient Logger logger;
|
|
private DataSourceFactory dbConfig;
|
|
private transient AlarmDefinitionDAO alarmDefDAO;
|
|
private transient AlarmDAO alarmDAO;
|
|
private OutputCollector collector;
|
|
private final Map<String, List<Alarm>> waitingAlarms = new HashMap<>();
|
|
private final Map<String, List<Alarm>> alarmCache = new HashMap<>();
|
|
private final Map<String, AlarmDefinition> alarmDefinitionCache = new HashMap<>();
|
|
private static final List<Alarm> EMPTY_LIST = Collections.<Alarm>emptyList();
|
|
|
|
public AlarmCreationBolt(DataSourceFactory dbConfig) {
|
|
this.dbConfig = dbConfig;
|
|
}
|
|
|
|
public AlarmCreationBolt(AlarmDefinitionDAO alarmDefDAO,
|
|
AlarmDAO alarmDAO) {
|
|
this.alarmDefDAO = alarmDefDAO;
|
|
this.alarmDAO = alarmDAO;
|
|
}
|
|
|
|
@Override
|
|
public void declareOutputFields(OutputFieldsDeclarer declarer) {
|
|
declarer.declareStream(ALARM_CREATION_STREAM, new Fields(ALARM_CREATION_FIELDS));
|
|
}
|
|
|
|
@Override
|
|
public void execute(Tuple tuple) {
|
|
logger.debug("tuple: {}", tuple);
|
|
try {
|
|
if (MetricFilteringBolt.NEW_METRIC_FOR_ALARM_DEFINITION_STREAM.equals(tuple.getSourceStreamId())) {
|
|
final MetricDefinitionAndTenantId metricDefinitionAndTenantId =
|
|
(MetricDefinitionAndTenantId) tuple.getValue(0);
|
|
handleNewMetricDefinition(metricDefinitionAndTenantId, tuple.getString(1));
|
|
} else if (EventProcessingBolt.METRIC_SUB_ALARM_EVENT_STREAM_ID.equals(tuple
|
|
.getSourceStreamId())) {
|
|
final String eventType = tuple.getString(0);
|
|
if (EventProcessingBolt.UPDATED.equals(eventType)) {
|
|
final SubExpression subExpression = (SubExpression) tuple.getValue(1);
|
|
final String alarmDefinitionId = tuple.getString(2);
|
|
updateSubAlarms(subExpression, alarmDefinitionId);
|
|
}
|
|
} else if (EventProcessingBolt.ALARM_DEFINITION_EVENT_STREAM_ID.equals(tuple.getSourceStreamId())) {
|
|
final String eventType = tuple.getString(0);
|
|
logger.debug("Received {} Event", eventType);
|
|
if (EventProcessingBolt.ALARM_DEFINITION_EVENT_STREAM_ID.equals(tuple.getSourceStreamId())) {
|
|
if (EventProcessingBolt.DELETED.equals(eventType)) {
|
|
final AlarmDefinitionDeletedEvent event =
|
|
(AlarmDefinitionDeletedEvent) tuple.getValue(1);
|
|
deleteAlarmDefinition(event.alarmDefinitionId);
|
|
}
|
|
else if (EventProcessingBolt.UPDATED.equals(eventType)) {
|
|
updateAlarmDefinition((AlarmDefinitionUpdatedEvent) tuple.getValue(1));
|
|
}
|
|
}
|
|
} else if (EventProcessingBolt.ALARM_EVENT_STREAM_ID.equals(tuple.getSourceStreamId())) {
|
|
final String eventType = tuple.getString(0);
|
|
if (EventProcessingBolt.DELETED.equals(eventType)) {
|
|
removeAlarm((AlarmDeletedEvent) tuple.getValue(2));
|
|
}
|
|
}
|
|
else {
|
|
logger.error("Received tuple on unknown stream {}", tuple);
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error processing tuple {}", tuple, e);
|
|
} finally {
|
|
collector.ack(tuple);
|
|
}
|
|
}
|
|
|
|
private void removeAlarm(AlarmDeletedEvent event) {
|
|
logger.debug("Deleting alarm {} for Alarm Definition {}", event.alarmId, event.alarmDefinitionId);
|
|
final List<Alarm> alarms = alarmCache.get(event.alarmDefinitionId);
|
|
if (alarms != null) {
|
|
for (final Alarm alarm : alarms) {
|
|
if (alarm.getId().equals(event.alarmId)) {
|
|
logger.debug("Deleted alarm {} for Alarm Definition {}", event.alarmId, event.alarmDefinitionId);
|
|
alarms.remove(alarm);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateSubAlarms(final SubExpression subExpression, final String alarmDefinitionId) {
|
|
logger.debug("Updating SubAlarms for AlarmDefinition Id {} SubExpression {}",
|
|
alarmDefinitionId, subExpression);
|
|
int count = 0;
|
|
if (alarmDefinitionCache.containsKey(alarmDefinitionId)) {
|
|
final List<Alarm> waiting = waitingAlarms.get(alarmDefinitionId);
|
|
if (waiting != null && !waiting.isEmpty()) {
|
|
for (final Alarm alarm : waiting) {
|
|
if (!alarm.updateSubAlarm(subExpression)) {
|
|
logger.error("Did not find SubAlarms for AlarmDefinition Id {} SubExpression {} Alarm {}",
|
|
alarmDefinitionId, subExpression, alarm);
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
logger.debug("Updated {} SubAlarms for AlarmDefinition Id {}", count, alarmDefinitionId);
|
|
}
|
|
|
|
private void updateAlarmDefinition(final AlarmDefinitionUpdatedEvent event) {
|
|
final AlarmDefinition alarmDefinition = alarmDefinitionCache.get(event.alarmDefinitionId);
|
|
if (alarmDefinition != null) {
|
|
logger.debug("Updating AlarmDefinition {}", event.alarmDefinitionId);
|
|
alarmDefinition.setName(event.alarmName);
|
|
alarmDefinition.setDescription(event.alarmDescription);
|
|
alarmDefinition.setActionsEnabled(event.alarmActionsEnabled);
|
|
alarmDefinition.setExpression(event.alarmExpression);
|
|
alarmDefinition.setSeverity(event.severity);
|
|
if (!alarmDefinition.getMatchBy().equals(event.matchBy)) {
|
|
logger.error("AlarmDefinition {}: match-by changed, was {} now {}",
|
|
event.alarmDefinitionId, alarmDefinition.getMatchBy(), event.matchBy);
|
|
}
|
|
alarmDefinition.setMatchBy(event.matchBy); // Should never change
|
|
for (Map.Entry<String, AlarmSubExpression> entry : event.changedSubExpressions.entrySet()) {
|
|
if (!alarmDefinition.updateSubExpression(entry.getKey(), entry.getValue())) {
|
|
logger.error("AlarmDefinition {}: Did not finding matching SubAlarmExpression id={} SubAlarmExpression{}",
|
|
event.alarmDefinitionId, entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void deleteAlarmDefinition(String alarmDefinitionId) {
|
|
logger.debug("Deleting AlarmDefinition {}", alarmDefinitionId);
|
|
final List<Alarm> waiting = waitingAlarms.remove(alarmDefinitionId);
|
|
if (waiting != null && !waiting.isEmpty()) {
|
|
logger.debug("{} waiting alarms removed for Alarm Definition Id {}", waiting != null
|
|
&& !waiting.isEmpty() ? waiting.size() : "No", alarmDefinitionId);
|
|
}
|
|
alarmCache.remove(alarmDefinitionId);
|
|
alarmDefinitionCache.remove(alarmDefinitionId);
|
|
alarmDAO.deleteByDefinitionId(alarmDefinitionId);
|
|
}
|
|
|
|
protected void handleNewMetricDefinition(
|
|
final MetricDefinitionAndTenantId metricDefinitionAndTenantId, final String alarmDefinitionId) {
|
|
final long start = System.currentTimeMillis();
|
|
final AlarmDefinition alarmDefinition = lookUpAlarmDefinition(alarmDefinitionId);
|
|
if (alarmDefinition == null) {
|
|
return;
|
|
}
|
|
|
|
if (!validMetricDefinition(alarmDefinition, metricDefinitionAndTenantId)) {
|
|
return;
|
|
}
|
|
|
|
final List<Alarm> existingAlarms = getExistingAlarms(alarmDefinitionId);
|
|
if (alreadyCreated(existingAlarms, metricDefinitionAndTenantId)) {
|
|
logger.warn("MetricDefinition {} is already in existing Alarm", metricDefinitionAndTenantId);
|
|
return;
|
|
}
|
|
|
|
if (alreadyCreated(getWaitingAlarmsForAlarmDefinition(alarmDefinition),
|
|
metricDefinitionAndTenantId)) {
|
|
logger.warn("MetricDefinition {} is already in waiting Alarm", metricDefinitionAndTenantId);
|
|
return;
|
|
}
|
|
|
|
final List<Alarm> matchingAlarms =
|
|
fitsInExistingAlarm(metricDefinitionAndTenantId, alarmDefinition, existingAlarms);
|
|
|
|
if (!matchingAlarms.isEmpty()) {
|
|
for (final Alarm matchingAlarm : matchingAlarms) {
|
|
logger.info("Metric {} fits into existing alarm {}", metricDefinitionAndTenantId,
|
|
matchingAlarm.getId());
|
|
addToExistingAlarm(matchingAlarm, metricDefinitionAndTenantId);
|
|
sendNewMetricDefinition(matchingAlarm, metricDefinitionAndTenantId);
|
|
}
|
|
} else {
|
|
final List<Alarm> newAlarms =
|
|
finishesAlarm(alarmDefinition, metricDefinitionAndTenantId, existingAlarms);
|
|
for (final Alarm newAlarm : newAlarms) {
|
|
logger.info("Metric {} finishes waiting alarm {}", metricDefinitionAndTenantId, newAlarm);
|
|
existingAlarms.add(newAlarm);
|
|
for (final MetricDefinitionAndTenantId md : newAlarm.getAlarmedMetrics()) {
|
|
sendNewMetricDefinition(newAlarm, md);
|
|
}
|
|
}
|
|
}
|
|
logger.debug("Total processing took {} milliseconds", System.currentTimeMillis() - start);
|
|
}
|
|
|
|
private List<Alarm> getExistingAlarms(final String alarmDefinitionId) {
|
|
List<Alarm> alarms = alarmCache.get(alarmDefinitionId);
|
|
if (alarms != null) {
|
|
return alarms;
|
|
}
|
|
final long start = System.currentTimeMillis();
|
|
alarms = alarmDAO.findForAlarmDefinitionId(alarmDefinitionId);
|
|
logger.info("Loading {} Alarms took {} milliseconds", alarms.size(), System.currentTimeMillis() - start);
|
|
alarmCache.put(alarmDefinitionId, alarms);
|
|
return alarms;
|
|
}
|
|
|
|
private List<Alarm> fitsInExistingAlarm(final MetricDefinitionAndTenantId metricDefinitionAndTenantId,
|
|
final AlarmDefinition alarmDefinition, final List<Alarm> existingAlarms) {
|
|
final List<Alarm> result = new LinkedList<>();
|
|
if (alarmDefinition.getMatchBy().isEmpty()) {
|
|
if (!existingAlarms.isEmpty()) {
|
|
result.add(existingAlarms.get(0));
|
|
}
|
|
}
|
|
else {
|
|
for (final Alarm alarm : existingAlarms) {
|
|
if (metricFitsInAlarm(alarm, alarmDefinition, metricDefinitionAndTenantId)) {
|
|
result.add(alarm);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void addToExistingAlarm(Alarm existingAlarm,
|
|
MetricDefinitionAndTenantId metricDefinitionAndTenantId) {
|
|
existingAlarm.addAlarmedMetric(metricDefinitionAndTenantId);
|
|
final long start = System.currentTimeMillis();
|
|
alarmDAO.addAlarmedMetric(existingAlarm.getId(), metricDefinitionAndTenantId);
|
|
logger.debug("Add Alarm Metric took {} milliseconds", System.currentTimeMillis() - start);
|
|
}
|
|
|
|
private void sendNewMetricDefinition(Alarm existingAlarm,
|
|
MetricDefinitionAndTenantId metricDefinitionAndTenantId) {
|
|
for (final SubAlarm subAlarm : existingAlarm.getSubAlarms()) {
|
|
if (metricFitsInAlarmSubExpr(subAlarm.getExpression(),
|
|
metricDefinitionAndTenantId.metricDefinition)) {
|
|
final TenantIdAndMetricName timn = new TenantIdAndMetricName(metricDefinitionAndTenantId);
|
|
final Values values =
|
|
new Values(EventProcessingBolt.CREATED, timn, metricDefinitionAndTenantId,
|
|
existingAlarm.getAlarmDefinitionId(), subAlarm);
|
|
logger.debug("Emitting new SubAlarm {}", values);
|
|
collector.emit(ALARM_CREATION_STREAM, values);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static boolean metricFitsInAlarmSubExpr(AlarmSubExpression subExpr,
|
|
MetricDefinition check) {
|
|
final MetricDefinition md = subExpr.getMetricDefinition();
|
|
if (!md.name.equals(check.name)) {
|
|
return false;
|
|
}
|
|
if ((md.dimensions != null) && !md.dimensions.isEmpty()) {
|
|
for (final Map.Entry<String, String> entry : md.dimensions.entrySet()) {
|
|
if (!entry.getValue().equals(check.dimensions.get(entry.getKey()))) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected boolean validMetricDefinition(AlarmDefinition alarmDefinition,
|
|
MetricDefinitionAndTenantId check) {
|
|
if (!alarmDefinition.getTenantId().equals(check.tenantId)) {
|
|
return false;
|
|
}
|
|
for (final AlarmSubExpression subExpr : alarmDefinition.getAlarmExpression()
|
|
.getSubExpressions()) {
|
|
if (metricFitsInAlarmSubExpr(subExpr, check.metricDefinition)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* This is only used for testing
|
|
*
|
|
* @param alarmDefinitionId
|
|
* @return
|
|
*/
|
|
protected Integer countWaitingAlarms(final String alarmDefinitionId) {
|
|
final List<Alarm> waiting = waitingAlarms.get(alarmDefinitionId);
|
|
return waiting == null ? null: Integer.valueOf(waiting.size());
|
|
}
|
|
|
|
private List<Alarm> finishesAlarm(AlarmDefinition alarmDefinition,
|
|
MetricDefinitionAndTenantId metricDefinitionAndTenantId, List<Alarm> existingAlarms) {
|
|
final List<Alarm> waitingAlarms =
|
|
findMatchingWaitingAlarms(getWaitingAlarmsForAlarmDefinition(alarmDefinition),
|
|
alarmDefinition, metricDefinitionAndTenantId);
|
|
final List<Alarm> result = new LinkedList<>();
|
|
if (waitingAlarms.isEmpty()) {
|
|
final Alarm newAlarm = new Alarm(alarmDefinition, AlarmState.UNDETERMINED);
|
|
newAlarm.addAlarmedMetric(metricDefinitionAndTenantId);
|
|
reuseExistingMetric(newAlarm, alarmDefinition, existingAlarms);
|
|
if (alarmIsComplete(newAlarm)) {
|
|
logger.debug("New alarm is complete. Saving");
|
|
saveAlarm(newAlarm);
|
|
result.add(newAlarm);
|
|
} else {
|
|
logger.debug("Adding new alarm to the waiting list");
|
|
addToWaitingAlarms(newAlarm, alarmDefinition);
|
|
}
|
|
} else {
|
|
for (final Alarm waiting : waitingAlarms) {
|
|
waiting.addAlarmedMetric(metricDefinitionAndTenantId);
|
|
if (alarmIsComplete(waiting)) {
|
|
removeFromWaitingAlarms(waiting, alarmDefinition);
|
|
saveAlarm(waiting);
|
|
result.add(waiting);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void reuseExistingMetric(Alarm newAlarm, final AlarmDefinition alarmDefinition,
|
|
List<Alarm> existingAlarms) {
|
|
for (final Alarm existingAlarm : existingAlarms) {
|
|
for (final MetricDefinitionAndTenantId mtid : existingAlarm.getAlarmedMetrics()) {
|
|
if (metricFitsInAlarm(newAlarm, alarmDefinition, mtid)) {
|
|
newAlarm.addAlarmedMetric(mtid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void saveAlarm(Alarm newAlarm) {
|
|
final long start = System.currentTimeMillis();
|
|
alarmDAO.createAlarm(newAlarm);
|
|
logger.debug("Add Alarm took {} milliseconds", System.currentTimeMillis() - start);
|
|
}
|
|
|
|
private List<Alarm> findMatchingWaitingAlarms(List<Alarm> waiting, AlarmDefinition alarmDefinition,
|
|
MetricDefinitionAndTenantId check) {
|
|
final List<Alarm> result = new LinkedList<>();
|
|
for (final Alarm alarm : waiting) {
|
|
if (metricFitsInAlarm(alarm, alarmDefinition, check)) {
|
|
result.add(alarm);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
protected boolean metricFitsInAlarm(final Alarm alarm, AlarmDefinition alarmDefinition,
|
|
MetricDefinitionAndTenantId check) {
|
|
final Map<String, String> matchesByValues = getMatchesByValues(alarmDefinition, alarm);
|
|
boolean result = false;
|
|
for (final SubAlarm subAlarm : alarm.getSubAlarms()) {
|
|
if (metricFitsInAlarmSubExpr(subAlarm.getExpression(), check.metricDefinition)) {
|
|
result = true;
|
|
if (!matchesByValues.isEmpty()) {
|
|
boolean foundOne = false;
|
|
for (final Map.Entry<String, String> entry : matchesByValues.entrySet()) {
|
|
final String value = check.metricDefinition.dimensions.get(entry.getKey());
|
|
if (value != null) {
|
|
if (!value.equals(entry.getValue())) {
|
|
return false;
|
|
}
|
|
foundOne = true;
|
|
}
|
|
}
|
|
if (!foundOne) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private Map<String, String> getMatchesByValues(AlarmDefinition alarmDefinition, final Alarm alarm) {
|
|
final Map<String, String> matchesByValues = new HashMap<>();
|
|
if (!alarmDefinition.getMatchBy().isEmpty()) {
|
|
for (final MetricDefinitionAndTenantId md : alarm.getAlarmedMetrics()) {
|
|
for (final String matchBy : alarmDefinition.getMatchBy()) {
|
|
final String value = md.metricDefinition.dimensions.get(matchBy);
|
|
if (value != null) {
|
|
matchesByValues.put(matchBy, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return matchesByValues;
|
|
}
|
|
|
|
private void removeFromWaitingAlarms(Alarm toRemove, AlarmDefinition alarmDefinition) {
|
|
final List<Alarm> waiting = waitingAlarms.get(alarmDefinition.getId());
|
|
if ((waiting == null) || !waiting.remove(toRemove)) {
|
|
logger.error("Did not find Alarm to remove");
|
|
}
|
|
}
|
|
|
|
private void addToWaitingAlarms(Alarm newAlarm, AlarmDefinition alarmDefinition) {
|
|
List<Alarm> waiting = waitingAlarms.get(alarmDefinition.getId());
|
|
if (waiting == null) {
|
|
waiting = new LinkedList<>();
|
|
waitingAlarms.put(alarmDefinition.getId(), waiting);
|
|
}
|
|
waiting.add(newAlarm);
|
|
}
|
|
|
|
private List<Alarm> getWaitingAlarmsForAlarmDefinition(AlarmDefinition alarmDefinition) {
|
|
final List<Alarm> waiting = waitingAlarms.get(alarmDefinition.getId());
|
|
if (waiting == null) {
|
|
return EMPTY_LIST;
|
|
}
|
|
return waiting;
|
|
}
|
|
|
|
private boolean alarmIsComplete(Alarm newAlarm) {
|
|
for (final SubAlarm subAlarm : newAlarm.getSubAlarms()) {
|
|
boolean found = false;
|
|
for (final MetricDefinitionAndTenantId md : newAlarm.getAlarmedMetrics()) {
|
|
if (metricFitsInAlarmSubExpr(subAlarm.getExpression(), md.metricDefinition)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private boolean alreadyCreated(List<Alarm> existingAlarms,
|
|
MetricDefinitionAndTenantId metricDefinitionAndTenantId) {
|
|
for (final Alarm alarm : existingAlarms) {
|
|
for (final MetricDefinitionAndTenantId md : alarm.getAlarmedMetrics()) {
|
|
if (md.equals(metricDefinitionAndTenantId)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private AlarmDefinition lookUpAlarmDefinition(String alarmDefinitionId) {
|
|
AlarmDefinition found = alarmDefinitionCache.get(alarmDefinitionId);
|
|
if (found != null) {
|
|
return found;
|
|
}
|
|
found = alarmDefDAO.findById(alarmDefinitionId);
|
|
if (found == null) {
|
|
logger.warn("Did not find AlarmDefinition for ID {}", alarmDefinitionId);
|
|
return null;
|
|
}
|
|
|
|
alarmDefinitionCache.put(found.getId(), found);
|
|
return found;
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings("rawtypes")
|
|
public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
|
|
logger = LoggerFactory.getLogger(Logging.categoryFor(getClass(), context));
|
|
logger.info("Preparing");
|
|
this.collector = collector;
|
|
|
|
if (alarmDefDAO == null) {
|
|
Injector.registerIfNotBound(AlarmDefinitionDAO.class, new PersistenceModule(dbConfig));
|
|
alarmDefDAO = Injector.getInstance(AlarmDefinitionDAO.class);
|
|
}
|
|
|
|
if (alarmDAO == null) {
|
|
Injector.registerIfNotBound(AlarmDAO.class, new PersistenceModule(dbConfig));
|
|
alarmDAO = Injector.getInstance(AlarmDAO.class);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allow override of current time for testing.
|
|
*/
|
|
protected long getCurrentTime() {
|
|
return System.currentTimeMillis() / 1000;
|
|
}
|
|
}
|