Java tutorial
/* * NOTE: This copyright doesnot cover user programs that use HQ program services * by normal system calls through the application program interfaces provided as * part of the Hyperic Plug-in Development Kit or the Hyperic Client Development * Kit - this is merely considered normal use of the program, and doesnot fall * under the heading of "derived work". Copyright (C) [2004, 2005, 2006], * Hyperic, Inc. This file is part of HQ. HQ is free software; you can * redistribute it and/or modify it under the terms version 2 of the GNU General * Public License as published by the Free Software Foundation. This program is * distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE. See the GNU General Public License for more details. You * should have received a copy of the GNU General Public License along with this * program; if not, write to the Free Software Foundation, Inc., 59 Temple * Place, Suite 330, Boston, MA 02111-1307 USA. */ package org.hyperic.hq.events.server.session; import java.io.Serializable; import java.sql.Connection; import java.sql.SQLException; import java.sql.Statement; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import javax.annotation.PostConstruct; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.hyperic.hq.appdef.shared.AppdefEntityID; import org.hyperic.hq.appdef.shared.AppdefUtil; import org.hyperic.hq.authz.server.session.AuthzSubject; import org.hyperic.hq.bizapp.server.trigger.conditional.ConditionalTriggerInterface; import org.hyperic.hq.events.AlertFiredEvent; import org.hyperic.hq.events.EventConstants; import org.hyperic.hq.events.InvalidTriggerDataException; import org.hyperic.hq.events.TriggerCreateException; import org.hyperic.hq.events.ext.RegisterableTriggerInterface; import org.hyperic.hq.events.ext.RegisterableTriggerRepository; import org.hyperic.hq.events.shared.AlertConditionValue; import org.hyperic.hq.events.shared.AlertDefinitionValue; import org.hyperic.hq.events.shared.EventLogManager; import org.hyperic.hq.events.shared.RegisteredTriggerManager; import org.hyperic.hq.events.shared.RegisteredTriggerValue; import org.hyperic.hq.zevents.Zevent; import org.hyperic.hq.zevents.ZeventEnqueuer; import org.hyperic.util.config.ConfigResponse; import org.hyperic.util.config.EncodingException; import org.hyperic.util.config.InvalidOptionException; import org.hyperic.util.config.InvalidOptionValueException; import org.hyperic.util.jdbc.DBUtil; import org.hyperic.util.timer.StopWatch; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.support.TransactionSynchronization; import org.springframework.transaction.support.TransactionSynchronizationManager; /** * The trigger manager. * */ @Service @Transactional public class RegisteredTriggerManagerImpl implements RegisteredTriggerManager { private final Log log = LogFactory.getLog(RegisteredTriggerManagerImpl.class); private final Log traceLog = LogFactory.getLog(RegisteredTriggerManagerImpl.class.getName() + "Trace"); private final AlertConditionEvaluatorFactory alertConditionEvaluatorFactory; private RegisterableTriggerRepository registeredTriggerRepository; private final TriggerDAOInterface triggerDAO; private ZeventEnqueuer zeventEnqueuer; private final AlertConditionEvaluatorRepository alertConditionEvaluatorRepository; private final AlertDefinitionDAOInterface alertDefinitionDAO; private final AlertDAO alertDAO; private final EventLogManager eventLogManager; private final DBUtil dbUtil; @Autowired public RegisteredTriggerManagerImpl(AlertConditionEvaluatorFactory alertConditionEvaluatorFactory, TriggerDAOInterface triggerDAO, ZeventEnqueuer zeventEnqueuer, AlertConditionEvaluatorRepository alertConditionEvaluatorRepository, AlertDefinitionDAOInterface alertDefinitionDAO, RegisterableTriggerRepository registerableTriggerRepository, AlertDAO alertDAO, EventLogManager eventLogManager, DBUtil dbUtil) { this.alertConditionEvaluatorFactory = alertConditionEvaluatorFactory; this.triggerDAO = triggerDAO; this.zeventEnqueuer = zeventEnqueuer; this.alertConditionEvaluatorRepository = alertConditionEvaluatorRepository; this.alertDefinitionDAO = alertDefinitionDAO; this.registeredTriggerRepository = registerableTriggerRepository; this.alertDAO = alertDAO; this.eventLogManager = eventLogManager; this.dbUtil = dbUtil; } @PostConstruct public void cleanupRegisteredTriggers() { Connection conn = null; Statement stmt = null; Boolean autocommit = null; boolean commit = false; try { conn = dbUtil.getConnection(); autocommit = Boolean.valueOf(conn.getAutoCommit()); conn.setAutoCommit(false); stmt = conn.createStatement(); stmt.addBatch("update EAM_ALERT_CONDITION set trigger_id = null " + "WHERE exists (" + "select 1 from EAM_ALERT_DEFINITION WHERE deleted = '1' " + "AND EAM_ALERT_CONDITION.alert_definition_id = id" + ")"); stmt.addBatch("delete from EAM_REGISTERED_TRIGGER WHERE exists (" + "select 1 from EAM_ALERT_DEFINITION WHERE deleted = '1' " + "AND EAM_REGISTERED_TRIGGER.alert_definition_id = id" + ")"); int[] rows = stmt.executeBatch(); conn.commit(); commit = true; log.info("disassociated " + rows[0] + " triggers in EAM_ALERT_CONDITION" + " from their deleted alert definitions"); log.info("deleted " + rows[1] + " rows from EAM_REGISTERED_TRIGGER"); } catch (SQLException e) { log.error(e, e); } finally { resetAutocommit(conn, autocommit); if (!commit) rollback(conn); DBUtil.closeJDBCObjects(RegisteredTriggerManagerImpl.class.getName(), conn, stmt, null); } } private void rollback(Connection conn) { try { if (conn != null) { conn.rollback(); } } catch (SQLException e) { log.error(e, e); } } private void resetAutocommit(Connection conn, Boolean autocommit) { try { if (autocommit != null) { conn.setAutoCommit(autocommit.booleanValue()); } } catch (SQLException e) { log.error(e, e); } } /** * Processes {@link TriggerCreatedEvent}s that indicate that triggers should * be created * */ public void handleTriggerCreatedEvents(Collection<TriggersCreatedZevent> events) { for (TriggersCreatedZevent z : events) { Integer alertDefId = ((TriggersCreatedZeventSource) z.getSourceId()).getId(); registerTriggers(alertDefId); } } /** * Initialize the in-memory triggers and update the RegisteredTriggers * repository * * */ @Transactional(readOnly = true) public void initializeTriggers() { StopWatch watch = new StopWatch(); // Only initialize the enabled triggers. If disabled ones become enabled // we will lazy init log.info("Initializing triggers"); this.registeredTriggerRepository.init(); try { watch.markTimeBegin("findAllEnabledTriggers"); Collection<RegisteredTrigger> registeredTriggers = triggerDAO.findAllEnabledTriggers(); watch.markTimeEnd("findAllEnabledTriggers"); log.info("Found " + registeredTriggers.size() + " enabled triggers"); watch.markTimeBegin("initializeTriggers"); initializeTriggers(registeredTriggers); watch.markTimeEnd("initializeTriggers"); } finally { log.info("Finished initializing triggers: " + watch); } } private void registerTriggers(Integer alertDefId) { Collection<RegisteredTrigger> registeredTriggers = getAllTriggersByAlertDefId(alertDefId); if (!(registeredTriggers.isEmpty())) { AlertDefinition alertDefinition = getDefinitionFromTrigger(registeredTriggers.iterator().next()); if (alertDefinition == null) { log.warn( "Unable to find AlertDefinition with id: " + alertDefId + ". These alerts will not fire."); return; } AlertConditionEvaluator alertConditionEvaluator = alertConditionEvaluatorFactory .create(alertDefinition); initializeAlertConditionEvaluatorState(alertConditionEvaluator); alertConditionEvaluatorRepository.addAlertConditionEvaluator(alertConditionEvaluator); for (RegisteredTrigger tv : registeredTriggers) { // Try to register each trigger, if exception, then move on try { registerTrigger(tv.getRegisteredTriggerValue(), alertConditionEvaluator, alertDefinition.isEnabled()); } catch (Exception e) { log.error("Error registering trigger", e); } } } } private void initializeAlertConditionEvaluatorState(AlertConditionEvaluator ace) { Serializable initialState = null; if (ace instanceof RecoveryConditionEvaluator) { // HQ-1903: The initial state of a recovery alert definition // should be reconstituted from the db so that it is aware of // the current state of the problem alert definition. RecoveryConditionEvaluator rce = (RecoveryConditionEvaluator) ace; Integer alertDefId = rce.getRecoveringFromAlertDefinitionId(); try { AlertDefinition def = alertDefinitionDAO.findById(alertDefId); Alert alert = alertDAO.findLastByDefinition(def, false); if (alert != null) { AlertDefinition ad = alert.getAlertDefinition(); initialState = new AlertFiredEvent(alert.getId(), ad.getId(), AppdefUtil.newAppdefEntityId(ad.getResource()), ad.getName(), alert.getTimestamp(), null); } } catch (Exception e) { //Alert not found } } if (initialState != null) { ace.initialize(initialState); } } private void initializeTriggers(Collection<RegisteredTrigger> registeredTriggers) { final boolean debug = log.isDebugEnabled(); StopWatch watch = new StopWatch(); if (debug) { watch.markTimeBegin("findLastUnfixedAlertFiredEvents"); } Map<Integer, AlertFiredEvent> alertFiredEvents = findLastUnfixedAlertFiredEvents(registeredTriggers); if (debug) { watch.markTimeEnd("findLastUnfixedAlertFiredEvents"); watch.markTimeBegin("initializeAlertConditionEvaluators"); } initializeAlertConditionEvaluators(registeredTriggers, alertFiredEvents); if (debug) { watch.markTimeEnd("initializeAlertConditionEvaluators"); watch.markTimeBegin("registerTriggers[" + registeredTriggers.size() + "]"); } for (RegisteredTrigger tv : registeredTriggers) { // Try to register each trigger, if exception, then move on try { AlertDefinition def = getDefinitionFromTrigger(tv); if (def != null) { AlertConditionEvaluator evaluator = alertConditionEvaluatorRepository .getAlertConditionEvaluatorById(def.getId()); if (evaluator != null) { registerTrigger(tv.getRegisteredTriggerValue(), evaluator, def.isEnabled()); } } } catch (Exception e) { log.error("Error registering trigger", e); } } if (debug) { watch.markTimeEnd("registerTriggers[" + registeredTriggers.size() + "]"); log.debug("initializeTriggers: " + watch); } } /** * Create AlertConditionEvaluator for each AlertDefinition, so they can * be shared by all triggers associated with the alertDef * * @param registeredTriggers Collection of all enabled triggers * @param alertFiredEvents Map of alert definition id {@link Integer} to {@link AlertFiredEvent} */ private void initializeAlertConditionEvaluators(Collection<RegisteredTrigger> registeredTriggers, Map<Integer, AlertFiredEvent> alertFiredEvents) { for (RegisteredTrigger tv : registeredTriggers) { try { AlertDefinition def = getDefinitionFromTrigger(tv); if (def == null) { log.warn("Unable to find AlertDefinition for trigger with id " + tv.getId() + ". These alerts will not fire."); } else if (alertConditionEvaluatorRepository.getAlertConditionEvaluatorById(def.getId()) == null) { AlertConditionEvaluator alertConditionEvaluator = alertConditionEvaluatorFactory.create(def); Serializable initialState = null; if (alertConditionEvaluator instanceof RecoveryConditionEvaluator) { RecoveryConditionEvaluator rce = (RecoveryConditionEvaluator) alertConditionEvaluator; if (alertFiredEvents == null) { log.warn("Initial state map empty for RecoveryConditionEvaluator of trigger with id " + tv.getId() + ". These alerts will not be fired"); continue; } initialState = alertFiredEvents.get(rce.getRecoveringFromAlertDefinitionId()); } else { initialState = alertConditionEvaluatorRepository.getStateRepository() .getAlertConditionEvaluatorStates().get(def.getId()); } alertConditionEvaluator.initialize(initialState); Serializable initialExStrategyState = alertConditionEvaluatorRepository.getStateRepository() .getExecutionStrategyStates().get(def.getId()); alertConditionEvaluator.getExecutionStrategy().initialize(initialExStrategyState); alertConditionEvaluatorRepository.addAlertConditionEvaluator(alertConditionEvaluator); } } catch (Exception e) { log.error("Error retrieving alert definition for trigger", e); } } } /** * * @return {@link Map} of alert definition id {@link Integer} to {@link AlertFiredEvent} */ private Map<Integer, AlertFiredEvent> findLastUnfixedAlertFiredEvents( Collection<RegisteredTrigger> registeredTriggers) { final boolean debug = log.isDebugEnabled(); StopWatch watch = new StopWatch(); Set<Integer> alertDefinitionIds = new HashSet<Integer>(registeredTriggers.size()); if (debug) { watch.markTimeBegin("getRecoveringFromAlertDefId"); } try { for (RegisteredTrigger tv : registeredTriggers) { AlertDefinition def = getDefinitionFromTrigger(tv); if (def != null) { for (AlertCondition condition : def.getConditions()) { if (condition.getType() == EventConstants.TYPE_ALERT) { Integer recoveringFromAlertDefId = Integer.valueOf(condition.getMeasurementId()); alertDefinitionIds.add(recoveringFromAlertDefId); break; } } } } } finally { if (debug) { watch.markTimeEnd("getRecoveringFromAlertDefId"); log.debug("alertDefinitionIds.size=" + alertDefinitionIds.size()); log.debug(watch); watch.markTimeBegin("find"); } } Map<Integer, AlertFiredEvent> results = null; try { results = eventLogManager.findLastUnfixedAlertFiredEvents(); } catch (Exception e) { log.error(e.getMessage(), e); } if (debug) { watch.markTimeEnd("find"); log.debug("findLastUnfixedAlertFiredEvents: " + watch); } return results; } /** * Register a trigger. NOTE: This method should be called within an active * Hibernate session/transaction. Trigger init method may interact with a DB * @param tv The trigger to register * @param alertDef The trigger's corresponding alert definition * @param enableTrigger True if trigger should be enabled * @throws ClassNotFoundException * @throws InstantiationException * @throws IllegalAccessException * @throws InvalidTriggerDataException */ void registerTrigger(RegisteredTriggerValue tv, AlertConditionEvaluator alertConditionEvaluator, boolean enableTrigger) throws InstantiationException, IllegalAccessException, InvalidTriggerDataException { Class<?> tc; try { tc = Class.forName(tv.getClassname()); } catch (ClassNotFoundException e) { log.warn("Trigger class " + tv.getClassname() + " is not supported. Triggers of this type should be " + "removed from the database."); return; } RegisterableTriggerInterface trigger = (RegisterableTriggerInterface) tc.newInstance(); trigger.init(tv, alertConditionEvaluator); trigger.setEnabled(enableTrigger); this.registeredTriggerRepository.addTrigger(trigger); } /** * Enable or disable triggers associated with an alert definition * * */ public void setAlertDefinitionTriggersEnabled(Integer alertDefId, boolean enabled) { setAlertDefinitionTriggersEnabled(Collections.singletonList(alertDefId), enabled); } public void setAlertDefinitionTriggersEnabled(List<Integer> alertDefIds, boolean enabled) { final boolean debug = log.isDebugEnabled(); StopWatch watch = new StopWatch(); if (debug) watch.markTimeBegin("getTriggerIdsByAlertDefIds"); Map<Integer, List<Integer>> alertDefTriggerMap = getTriggerIdsByAlertDefIds(alertDefIds); if (debug) { watch.markTimeEnd("getTriggerIdsByAlertDefIds"); watch.markTimeBegin("addPostCommitSetEnabledListener"); } addPostCommitSetEnabledListener(alertDefTriggerMap, enabled); if (debug) { watch.markTimeEnd("addPostCommitSetEnabledListener"); if (traceLog.isDebugEnabled()) { traceLog.debug("alertDefTriggerMap: " + alertDefTriggerMap); } log.debug("setAlertDefinitionTriggersEnabled: " + watch); } } private void addPostCommitSetEnabledListener(final Map<Integer, List<Integer>> alertDefTriggerMap, final boolean enabled) { try { TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() { public void suspend() { } public void resume() { } public void flush() { } public void beforeCompletion() { } public void beforeCommit(boolean readOnly) { } public void afterCompletion(int status) { } public void afterCommit() { try { setTriggersEnabled(alertDefTriggerMap, enabled); } catch (Exception e) { log.error("Error setting triggers enabled to " + enabled, e); } } }); } catch (Throwable t) { log.error("Error registering to set triggers enabled to " + enabled, t); } } void setTriggersEnabled(final Map<Integer, List<Integer>> alertDefTriggerMap, final boolean enabled) { final boolean debug = log.isDebugEnabled(); StopWatch watch = new StopWatch(); List<TriggersCreatedZevent> zevents = new ArrayList<TriggersCreatedZevent>(); List<Integer> enabledTriggersToProcess = new ArrayList<Integer>(); if (debug) { watch.markTimeBegin("processTriggers"); } for (Integer alertDefId : alertDefTriggerMap.keySet()) { Collection<Integer> triggerIds = alertDefTriggerMap.get(alertDefId); if (enabled && !triggerIds.isEmpty()) { Integer triggerId = triggerIds.iterator().next(); if (registeredTriggerRepository.getTriggerById(triggerId) == null) { zevents.add(new TriggersCreatedZevent(alertDefId)); continue; } } enabledTriggersToProcess.addAll(triggerIds); } if (debug) { watch.markTimeEnd("processTriggers"); } if (!zevents.isEmpty()) { if (debug) { watch.markTimeBegin("enqueueEvents"); } try { zeventEnqueuer.enqueueEvents(zevents); } catch (InterruptedException e) { log.error("Error sending event to create newly enabled triggers for alert definition " + alertDefTriggerMap.keySet() + ". These alerts will not fire", e); } if (debug) watch.markTimeEnd("enqueueEvents"); } if (!enabledTriggersToProcess.isEmpty()) { if (debug) watch.markTimeBegin("setTriggersEnabled"); registeredTriggerRepository.setTriggersEnabled(enabledTriggersToProcess, enabled); if (debug) watch.markTimeEnd("setTriggersEnabled"); } log.debug("setTriggersEnabled: " + watch); } Map<Integer, List<Integer>> getTriggerIdsByAlertDefIds(List<Integer> alertDefIds) { return triggerDAO.findTriggerIdsByAlertDefinitionIds(alertDefIds); } /** * Finds a trigger by its ID, assuming existence * @param id The trigger ID * @return The trigger with the specified ID (exception will occur if * trigger does not exist) * * */ @Transactional(readOnly = true) public RegisteredTrigger findById(Integer id) { return triggerDAO.findById(id); } void unregisterTriggers(Integer alertDefinitionId, Collection<RegisteredTrigger> triggers) { for (RegisteredTrigger trigger : triggers) { this.registeredTriggerRepository.removeTrigger(trigger.getId()); } alertConditionEvaluatorRepository.removeAlertConditionEvaluator(alertDefinitionId); } private AlertDefinition getDefinitionFromTrigger(RegisteredTrigger trigger) { AlertDefinition def = trigger.getAlertDefinition(); if (def != null && !def.isDeleted()) { return def; } else { return null; } } /** * Get the registered trigger objects associated with a given alert * definition. * * @param id The alert def id. * @return The registered trigger objects. */ private Collection<RegisteredTrigger> getAllTriggersByAlertDefId(Integer id) { return triggerDAO.findByAlertDefinitionId(id); } /** * Create a new trigger * * @return a RegisteredTriggerValue * * */ public RegisteredTrigger createTrigger(RegisteredTriggerValue val) { // XXX -- Things here aren't symmetrical. The EventsBoss is currently // registering the trigger with the dispatcher, and updateTrigger() // is updating it with the dispatcher. Seems like this should all // be done here in the manager return triggerDAO.create(val); // DAO method will set ID on val obj } /** * Create new triggers * * @return a RegisteredTriggerValue * * */ public void createTriggers(AuthzSubject subject, AlertDefinitionValue alertdef) throws TriggerCreateException, InvalidOptionException, InvalidOptionValueException { createTriggers(subject, alertdef, true); } /** * Create new triggers * * @param subject The user creating the trigger * @param alertdef The alert definition value object * @param addTxListener Indicates whether a TriggersCreatedListener should be added. * The default value is true. HHQ-3423: To improve performance when * creating resource type alert definitions, this should be set to false. * If false, it is the caller's responsibility to call * addTriggersCreatedListener() to ensure triggers are registered. * * * * */ public void createTriggers(AuthzSubject subject, AlertDefinitionValue alertdef, boolean addTxListener) throws TriggerCreateException, InvalidOptionException, InvalidOptionValueException { final List<RegisteredTrigger> triggers = new ArrayList<RegisteredTrigger>(); // Create AppdefEntityID from the alert definition AppdefEntityID id = new AppdefEntityID(alertdef.getAppdefType(), alertdef.getAppdefId()); AlertConditionValue[] conds = alertdef.getConditions(); if (conds.length == 1) { // Transform into registered trigger RegisteredTriggerValue triggerVal = convertToTriggerValue(id, conds[0]); RegisteredTrigger trigger = createTrigger(triggerVal); // Set the trigger ID in the condition conds[0].setTriggerId(trigger.getId()); alertdef.updateCondition(conds[0]); triggers.add(trigger); } else { for (int i = 0; i < conds.length; i++) { AlertConditionValue cond = conds[i]; // Transform into registered trigger RegisteredTrigger rt = createTrigger(convertToTriggerValue(id, cond)); triggers.add(rt); // Set the trigger ID in the condition conds[i].setTriggerId(rt.getId()); alertdef.updateCondition(conds[0]); } } for (RegisteredTrigger tval : triggers) { alertdef.addTrigger(tval.getRegisteredTriggerValue()); } // HHQ-3423: Add the TransactionListener after all the triggers are created if (addTxListener) { addTriggersCreatedTxListener(triggers); } } public void addTriggersCreatedTxListener(final List list) { try { TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() { public void suspend() { } public void resume() { } public void flush() { } public void beforeCompletion() { } public void beforeCommit(boolean readOnly) { } public void afterCompletion(int status) { } public void afterCommit() { final boolean debug = log.isDebugEnabled(); StopWatch watch = new StopWatch(); try { // We need to process this in a new transaction, // AlertDef ID should be set now that original tx is // committed if (!list.isEmpty()) { Object object = list.get(0); if (object instanceof Zevent) { if (debug) watch.markTimeBegin("enqueueEvents[" + list.size() + "]"); zeventEnqueuer.enqueueEvents(list); if (debug) watch.markTimeEnd("enqueueEvents[" + list.size() + "]"); } else if (object instanceof RegisteredTrigger) { RegisteredTrigger trigger = (RegisteredTrigger) object; AlertDefinition alertDefinition = getDefinitionFromTrigger(trigger); if (alertDefinition != null) { if (debug) watch.markTimeBegin("enqueueEvent"); zeventEnqueuer.enqueueEvent(new TriggersCreatedZevent(alertDefinition.getId())); if (debug) watch.markTimeEnd("enqueueEvent"); } } } } catch (Exception e) { log.error("Error creating triggers for alert definition.", e); } finally { if (debug) { log.debug("TransactionListener.afterCommit: time=" + watch); } } } }); } catch (Throwable t) { log.error("Error registering to create triggers for alert definition.", t); } } private RegisteredTriggerValue convertToTriggerValue(AppdefEntityID id, AlertConditionValue cond) throws InvalidOptionException, InvalidOptionValueException { // Create trigger based on the type of the condition RegisteredTriggerValue trigger; try { Class<?> trigClass = (Class<?>) ConditionalTriggerInterface.MAP_COND_TRIGGER .get(new Integer(cond.getType())); if (trigClass == null) throw new InvalidOptionValueException("Condition type not yet supported"); // Create the new instance Object newObj = trigClass.newInstance(); // Make sure that the new object implements the right interface if (!(newObj instanceof ConditionalTriggerInterface)) throw new InvalidOptionValueException("Condition does not generate valid trigger"); trigger = new RegisteredTriggerValue(); trigger.setClassname(trigClass.getName()); // Get the config response ConditionalTriggerInterface ctrig = (ConditionalTriggerInterface) newObj; ConfigResponse resp = ctrig.getConfigResponse(id, cond); try { trigger.setConfig(resp.encode()); } catch (EncodingException e) { trigger.setConfig(new byte[0]); } } catch (InstantiationException e) { throw new InvalidOptionValueException("Could not create a trigger instance", e); } catch (IllegalAccessException e) { throw new InvalidOptionValueException("Could not create a trigger instance", e); } return trigger; } /** * Delete all triggers for an alert definition. * * @param adId The alert definition id * * */ public void deleteTriggers(Integer adId) { AlertDefinition def = alertDefinitionDAO.findById(adId); deleteTriggers(def); } /** * Completely deletes all triggers when an alert definition is deleted * * @param alertDef The alert definition * * */ public void deleteTriggers(AlertDefinition alertDef) { unregisterTriggers(alertDef.getId(), alertDef.getTriggers()); alertDef.clearTriggers(); } void setRegisteredTriggerRepository(RegisterableTriggerRepository registeredTriggerRepository) { this.registeredTriggerRepository = registeredTriggerRepository; } void setZeventEnqueuer(ZeventEnqueuer zeventEnqueuer) { this.zeventEnqueuer = zeventEnqueuer; } }