001: /*
002: * <copyright>
003: *
004: * Copyright 2003-2004 BBNT Solutions, LLC
005: * under sponsorship of the Defense Advanced Research Projects
006: * Agency (DARPA).
007: *
008: * You can redistribute this software and/or modify it under the
009: * terms of the Cougaar Open Source License as published on the
010: * Cougaar Open Source Website (www.cougaar.org).
011: *
012: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
013: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
014: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
015: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
016: * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
017: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
018: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
019: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
020: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
021: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
022: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
023: *
024: * </copyright>
025: */
026: package org.cougaar.lib.aggagent.client;
027:
028: import org.cougaar.lib.aggagent.query.AlertDescriptor;
029: import org.w3c.dom.Element;
030:
031: /**
032: * Provides support for event driven monitoring of active Alert(s) on the
033: * aggregation agent.
034: *
035: * Maintains a collection of monitored alerts and keeps them updated
036: * based on changes on the aggregation agent's blackboard. To react to these
037: * changes either:
038: * <UL>
039: * <LI>add update listener(s) to this monitor class and receive events for
040: * changes to all monitored alerts or</LI>
041: * <LI>add update listener(s) to 'live' alerts provided by this monitor and
042: * receive events only for those objects</LI>
043: * </UL>
044: */
045: public class AlertMonitor extends Monitor {
046: public AlertMonitor(String serverURL, int updateMethod) {
047: super (serverURL, "alert", updateMethod);
048: }
049:
050: /**
051: * Monitor an alert managed by the aggregation agent. Returns a 'live'
052: * alert descriptor for a given persistent query. Update listeners can be
053: * added to this live object to react to changes to that object. If
054: * monitor is not set to monitor-all-objects, this alert is added to
055: * this monitor's set of monitored objects.
056: *
057: * @param queryId id of query result adapter on aggregation agent that is
058: * maintaining this alert.
059: * @param alertName name of alert to monitor
060: *
061: * @return a live alert descriptor that is actively being updated to match
062: * a subject alert on the aggregation agent.
063: */
064: public AlertDescriptor monitorAlert(String queryId, String alertName) {
065: AlertDescriptor ad = new AlertDescriptor();
066: ad.setQueryId(queryId);
067: ad.setName(alertName);
068: AlertIdentifier ai = new AlertIdentifier(queryId, alertName);
069: AlertDescriptor monitoredAlert = (AlertDescriptor) monitorObject(
070: ai, ad);
071: return monitoredAlert;
072: }
073:
074: /**
075: * Remove this alert from the set of alerts being monitored.
076: * This method has a negligible effect if monitor-all is turned on
077: * (old live alert object will die, but new one will take it's place
078: * if that alert is still on the log plan).
079: *
080: * @param queryId id of query result adapter on aggregation agent that is
081: * maintaining this alert.
082: * @param alertName name of alert to monitor
083: *
084: * @return previously live alert descriptor that was removed.
085: */
086: public AlertDescriptor stopMonitoringAlert(String queryId,
087: String alertName) {
088: AlertIdentifier ai = new AlertIdentifier(queryId, alertName);
089: AlertDescriptor removedAlert = (AlertDescriptor) stopMonitoringObject(ai);
090: return removedAlert;
091: }
092:
093: /**
094: * Returns true if an alert matching the given identifiers is currently
095: * being updated by this monitor.
096: *
097: * @param queryId id of query result adapter on aggregation agent that is
098: * maintaining this alert.
099: * @param alertName name of alert to monitor
100: *
101: * @return true if an alert matching the given identifiers is currently
102: * being updated by this monitor.
103: */
104: public boolean isMonitoring(String queryId, String alertName) {
105: AlertIdentifier ai = new AlertIdentifier(queryId, alertName);
106: return isMonitoring(ai);
107: }
108:
109: /**
110: * Provides a xml representation of a given alert identifier.
111: *
112: * @param identifier an object that uniquely identifies an alert on the
113: * aggregation agent.
114: *
115: * @return a xml representation of given alert identifier.
116: */
117: protected String createIdTag(Object identifier) {
118: AlertIdentifier ai = (AlertIdentifier) identifier;
119: return "<alert query_id=\"" + ai.queryId + "\" alert_name=\""
120: + ai.alertName + "\"/>";
121: }
122:
123: /**
124: * Called when a update event (either add or change) is reported by the
125: * aggregation agent to an alert described by the given xml element
126: * tree.
127: *
128: * @param monitoredElement xml element tree that describes the updated
129: * alert.
130: *
131: * @return a live alert descriptor updated based on the given xml
132: */
133: protected Object update(Element monitoredElement) {
134: AlertDescriptor newAd = new AlertDescriptor(monitoredElement);
135: AlertIdentifier ai = new AlertIdentifier(newAd.getQueryId(),
136: newAd.getName());
137: AlertDescriptor monitoredAlert = (AlertDescriptor) monitorObject(
138: ai, newAd);
139: monitoredAlert.setAlerted(newAd.isAlerted());
140: return monitoredAlert;
141: }
142:
143: /**
144: * Called when a remove event is reported by the aggregation agent to an
145: * alert described by the given xml element tree.
146: *
147: * @param monitoredElement xml element tree that describes the removed
148: * alert.
149: *
150: * @return previously live alert descriptor that was removed.
151: */
152: protected Object remove(Element monitoredElement) {
153: AlertDescriptor ad = new AlertDescriptor(monitoredElement);
154: AlertDescriptor removedAlert = stopMonitoringAlert(ad
155: .getQueryId(), ad.getName());
156: removedAlert.fireObjectRemoved();
157: return removedAlert;
158: }
159:
160: /**
161: * Used to uniquely identify an alert. Can be used as a hashtable key.
162: */
163: private static class AlertIdentifier {
164: public String queryId = null;
165: public String alertName = null;
166:
167: public AlertIdentifier(String queryId, String alertName) {
168: this .queryId = queryId;
169: this .alertName = alertName;
170: }
171:
172: public boolean equals(Object o) {
173: if (o instanceof AlertIdentifier) {
174: AlertIdentifier ai = (AlertIdentifier) o;
175: return queryId.equals(ai.queryId)
176: && alertName.equals(ai.alertName);
177: }
178: return false;
179: }
180:
181: public int hashCode() {
182: return queryId.hashCode() + alertName.hashCode();
183: }
184: }
185: }
|