929 lines
40 KiB
Java
929 lines
40 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.tridium.fox.sys.BFoxChannelRegistry
|
|
* com.tridium.fox.sys.BFoxSession
|
|
* com.tridium.platform.BPlatformService
|
|
* com.tridium.platform.BPlatformServiceContainer
|
|
* com.tridium.platform.alarm.BIAlarmablePlatformService
|
|
* com.tridium.platform.alarm.BPlatformServiceAlarmRecord
|
|
* com.tridium.platform.alarm.BPlatformServiceSourceState
|
|
* com.tridium.platform.alarm.PlatformServiceAlarmListener
|
|
* com.tridium.sys.station.Station
|
|
* com.tridium.sys.station.Station$SaveListener
|
|
* javax.baja.agent.AgentList
|
|
* javax.baja.collection.BITable
|
|
* javax.baja.control.trigger.BIntervalTriggerMode
|
|
* javax.baja.control.trigger.BTimeTrigger
|
|
* javax.baja.control.trigger.BTriggerMode
|
|
* javax.baja.data.BIDataValue
|
|
* javax.baja.dataRecovery.BIDataRecoveryService
|
|
* javax.baja.dataRecovery.BIDataRecoverySourceService
|
|
* javax.baja.log.Log
|
|
* javax.baja.naming.BOrd
|
|
* javax.baja.naming.BOrdList
|
|
* javax.baja.naming.SlotPath
|
|
* javax.baja.naming.UnresolvedException
|
|
* javax.baja.nre.util.Array
|
|
* javax.baja.security.AuditEvent
|
|
* javax.baja.security.Auditor
|
|
* javax.baja.spy.SpyWriter
|
|
* javax.baja.sys.Action
|
|
* javax.baja.sys.BAbsTime
|
|
* javax.baja.sys.BBoolean
|
|
* javax.baja.sys.BComponent
|
|
* javax.baja.sys.BFacets
|
|
* javax.baja.sys.BIService
|
|
* javax.baja.sys.BIcon
|
|
* javax.baja.sys.BLink
|
|
* javax.baja.sys.BObject
|
|
* javax.baja.sys.BRelTime
|
|
* javax.baja.sys.BString
|
|
* javax.baja.sys.BValue
|
|
* javax.baja.sys.BVector
|
|
* javax.baja.sys.BajaRuntimeException
|
|
* javax.baja.sys.Context
|
|
* javax.baja.sys.Cursor
|
|
* javax.baja.sys.IllegalNameException
|
|
* javax.baja.sys.LocalizableRuntimeException
|
|
* javax.baja.sys.Property
|
|
* javax.baja.sys.Sys
|
|
* javax.baja.sys.Topic
|
|
* javax.baja.sys.Type
|
|
* javax.baja.units.BDimension
|
|
* javax.baja.units.BUnit
|
|
* javax.baja.user.BUser
|
|
* javax.baja.util.BUuid
|
|
* javax.baja.util.CoalesceQueue
|
|
* javax.baja.util.IFuture
|
|
* javax.baja.util.Invocation
|
|
* javax.baja.util.Queue
|
|
* javax.baja.util.Version
|
|
* javax.baja.util.Worker
|
|
* javax.baja.util.Worker$ITodo
|
|
*/
|
|
package javax.baja.alarm;
|
|
|
|
import com.tridium.alarm.BAlarmExtStatusJob;
|
|
import com.tridium.alarm.BIUpdatableAlarmSource;
|
|
import com.tridium.alarm.db.file.BFileAlarmDatabase;
|
|
import com.tridium.alarm.fox.BAlarmDbChannel;
|
|
import com.tridium.fox.sys.BFoxChannelRegistry;
|
|
import com.tridium.fox.sys.BFoxSession;
|
|
import com.tridium.platform.BPlatformService;
|
|
import com.tridium.platform.BPlatformServiceContainer;
|
|
import com.tridium.platform.alarm.BIAlarmablePlatformService;
|
|
import com.tridium.platform.alarm.BPlatformServiceAlarmRecord;
|
|
import com.tridium.platform.alarm.BPlatformServiceSourceState;
|
|
import com.tridium.platform.alarm.PlatformServiceAlarmListener;
|
|
import com.tridium.sys.station.Station;
|
|
import java.lang.reflect.Method;
|
|
import java.util.HashMap;
|
|
import java.util.Hashtable;
|
|
import javax.baja.agent.AgentList;
|
|
import javax.baja.alarm.AlarmException;
|
|
import javax.baja.alarm.BAckState;
|
|
import javax.baja.alarm.BAlarmClass;
|
|
import javax.baja.alarm.BAlarmClassFolder;
|
|
import javax.baja.alarm.BAlarmDatabase;
|
|
import javax.baja.alarm.BAlarmInstructions;
|
|
import javax.baja.alarm.BAlarmRecord;
|
|
import javax.baja.alarm.BAlarmTransitionBits;
|
|
import javax.baja.alarm.BIAlarmClassFolder;
|
|
import javax.baja.alarm.BIAlarmSource;
|
|
import javax.baja.alarm.BIRemoteAlarmSource;
|
|
import javax.baja.alarm.BSourceState;
|
|
import javax.baja.collection.BITable;
|
|
import javax.baja.control.trigger.BIntervalTriggerMode;
|
|
import javax.baja.control.trigger.BTimeTrigger;
|
|
import javax.baja.control.trigger.BTriggerMode;
|
|
import javax.baja.data.BIDataValue;
|
|
import javax.baja.dataRecovery.BIDataRecoveryService;
|
|
import javax.baja.dataRecovery.BIDataRecoverySourceService;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.naming.BOrdList;
|
|
import javax.baja.naming.SlotPath;
|
|
import javax.baja.naming.UnresolvedException;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.security.AuditEvent;
|
|
import javax.baja.security.Auditor;
|
|
import javax.baja.spy.SpyWriter;
|
|
import javax.baja.sys.Action;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BBoolean;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BIService;
|
|
import javax.baja.sys.BIcon;
|
|
import javax.baja.sys.BLink;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BRelTime;
|
|
import javax.baja.sys.BString;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.BVector;
|
|
import javax.baja.sys.BajaRuntimeException;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Cursor;
|
|
import javax.baja.sys.IllegalNameException;
|
|
import javax.baja.sys.LocalizableRuntimeException;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Topic;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.units.BDimension;
|
|
import javax.baja.units.BUnit;
|
|
import javax.baja.user.BUser;
|
|
import javax.baja.util.BUuid;
|
|
import javax.baja.util.CoalesceQueue;
|
|
import javax.baja.util.IFuture;
|
|
import javax.baja.util.Invocation;
|
|
import javax.baja.util.Queue;
|
|
import javax.baja.util.Version;
|
|
import javax.baja.util.Worker;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BAlarmService
|
|
extends BComponent
|
|
implements BIService,
|
|
BIAlarmClassFolder,
|
|
BIDataRecoverySourceService {
|
|
public static final Property capacity = BAlarmService.newProperty((int)0, (int)500, (BFacets)BFacets.makeInt((BUnit)BUnit.make((String)"records", (BDimension)BDimension.DEFAULT), (int)1, (int)250000));
|
|
public static final Property defaultAlarmClass = BAlarmService.newProperty((int)0, (BValue)new BAlarmClass(), null);
|
|
public static final Property masterAlarmInstructions = BAlarmService.newProperty((int)0, (BValue)BAlarmInstructions.make(""), null);
|
|
public static final Property escalationTimeTrigger = BAlarmService.newProperty((int)4, (BValue)new BTimeTrigger((BTriggerMode)BIntervalTriggerMode.make((BRelTime)BRelTime.makeMinutes((int)1))), null);
|
|
public static final Property coalesceAlarms = BAlarmService.newProperty((int)0, (boolean)BBoolean.TRUE.getBoolean(), null);
|
|
public static final Action routeAlarm = BAlarmService.newAction((int)4, (BValue)new BAlarmRecord(), null);
|
|
public static final Action ackAlarm = BAlarmService.newAction((int)4, (BValue)new BAlarmRecord(), null);
|
|
public static final Action enableToOffnormal = BAlarmService.newAction((int)4, (BValue)new BVector(), null);
|
|
public static final Action disableToOffnormal = BAlarmService.newAction((int)4, (BValue)new BVector(), null);
|
|
public static final Action enableToFault = BAlarmService.newAction((int)4, (BValue)new BVector(), null);
|
|
public static final Action disableToFault = BAlarmService.newAction((int)4, (BValue)new BVector(), null);
|
|
public static final Action auditForceClear = BAlarmService.newAction((int)2052, (BValue)new BAlarmRecord(), null);
|
|
public static final Action escalateAlarms = BAlarmService.newAction((int)2068, null);
|
|
public static final Topic alarm = BAlarmService.newTopic((int)8, null);
|
|
public static final Type TYPE;
|
|
private static Type[] serviceTypes;
|
|
private static final BIcon icon;
|
|
public static final Log logger;
|
|
HashMap alarmClassDisplayNames;
|
|
private Version remoteVersion;
|
|
private PlatformServiceListener listener;
|
|
private BAlarmDatabase alarmDb;
|
|
private Queue alarmQueue;
|
|
private Worker alarmWorker;
|
|
private Station.SaveListener saveListener;
|
|
static /* synthetic */ Class class$javax$baja$alarm$BAlarmService;
|
|
static /* synthetic */ Class class$com$tridium$platform$BPlatformService;
|
|
static /* synthetic */ Class class$javax$baja$alarm$BAlarmClass;
|
|
static /* synthetic */ Class class$javax$baja$alarm$BAlarmClassFolder;
|
|
|
|
public int getCapacity() {
|
|
return this.getInt(capacity);
|
|
}
|
|
|
|
public void setCapacity(int n) {
|
|
this.setInt(capacity, n, null);
|
|
}
|
|
|
|
public BAlarmClass getDefaultAlarmClass() {
|
|
return (BAlarmClass)this.get(defaultAlarmClass);
|
|
}
|
|
|
|
public void setDefaultAlarmClass(BAlarmClass bAlarmClass) {
|
|
this.set(defaultAlarmClass, (BValue)bAlarmClass, null);
|
|
}
|
|
|
|
public BAlarmInstructions getMasterAlarmInstructions() {
|
|
return (BAlarmInstructions)this.get(masterAlarmInstructions);
|
|
}
|
|
|
|
public void setMasterAlarmInstructions(BAlarmInstructions bAlarmInstructions) {
|
|
this.set(masterAlarmInstructions, (BValue)bAlarmInstructions, null);
|
|
}
|
|
|
|
public BTimeTrigger getEscalationTimeTrigger() {
|
|
return (BTimeTrigger)this.get(escalationTimeTrigger);
|
|
}
|
|
|
|
public void setEscalationTimeTrigger(BTimeTrigger bTimeTrigger) {
|
|
this.set(escalationTimeTrigger, (BValue)bTimeTrigger, null);
|
|
}
|
|
|
|
public boolean getCoalesceAlarms() {
|
|
return this.getBoolean(coalesceAlarms);
|
|
}
|
|
|
|
public void setCoalesceAlarms(boolean bl) {
|
|
this.setBoolean(coalesceAlarms, bl, null);
|
|
}
|
|
|
|
public void routeAlarm(BAlarmRecord bAlarmRecord) {
|
|
this.invoke(routeAlarm, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public void ackAlarm(BAlarmRecord bAlarmRecord) {
|
|
this.invoke(ackAlarm, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public BOrd enableToOffnormal(BVector bVector) {
|
|
return (BOrd)this.invoke(enableToOffnormal, (BValue)bVector, null);
|
|
}
|
|
|
|
public BOrd disableToOffnormal(BVector bVector) {
|
|
return (BOrd)this.invoke(disableToOffnormal, (BValue)bVector, null);
|
|
}
|
|
|
|
public BOrd enableToFault(BVector bVector) {
|
|
return (BOrd)this.invoke(enableToFault, (BValue)bVector, null);
|
|
}
|
|
|
|
public BOrd disableToFault(BVector bVector) {
|
|
return (BOrd)this.invoke(disableToFault, (BValue)bVector, null);
|
|
}
|
|
|
|
public void auditForceClear(BAlarmRecord bAlarmRecord) {
|
|
this.invoke(auditForceClear, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public void escalateAlarms() {
|
|
this.invoke(escalateAlarms, null, null);
|
|
}
|
|
|
|
public void fireAlarm(BAlarmRecord bAlarmRecord) {
|
|
this.fire(alarm, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
public Type[] getServiceTypes() {
|
|
return serviceTypes;
|
|
}
|
|
|
|
public void serviceStarted() throws Exception {
|
|
BPlatformServiceContainer bPlatformServiceContainer;
|
|
try {
|
|
bPlatformServiceContainer = (BPlatformServiceContainer)Sys.getService((Type)BPlatformServiceContainer.TYPE);
|
|
Class clazz = class$com$tridium$platform$BPlatformService;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$platform$BPlatformService = BAlarmService.class("[Lcom.tridium.platform.BPlatformService;", false);
|
|
}
|
|
BPlatformService[] bPlatformServiceArray = (BPlatformService[])bPlatformServiceContainer.getChildren(clazz);
|
|
int n = 0;
|
|
while (n < bPlatformServiceArray.length) {
|
|
if (bPlatformServiceArray[n] instanceof BIAlarmablePlatformService) {
|
|
((BIAlarmablePlatformService)bPlatformServiceArray[n]).addPlatformServiceAlarmListener((PlatformServiceAlarmListener)this.listener);
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
logger.error("Cannot setup alarming for platform service\n " + exception);
|
|
}
|
|
if (this.alarmWorker == null) {
|
|
this.alarmWorker = new Worker((Worker.ITodo)this.alarmQueue);
|
|
this.alarmWorker.start("Alarm:ServiceWorker");
|
|
}
|
|
this.initAlarmDb();
|
|
bPlatformServiceContainer = BFoxChannelRegistry.getPrototype();
|
|
if (bPlatformServiceContainer.get("alarmdb") == null) {
|
|
bPlatformServiceContainer.add("alarmdb", (BValue)new BAlarmDbChannel());
|
|
}
|
|
Station.addSaveListener((Station.SaveListener)this.saveListener);
|
|
}
|
|
|
|
public void atSteadyState() {
|
|
}
|
|
|
|
public void serviceStopped() throws Exception {
|
|
Station.removeSaveListener((Station.SaveListener)this.saveListener);
|
|
this.alarmWorker.stop();
|
|
BFoxChannelRegistry bFoxChannelRegistry = BFoxChannelRegistry.getPrototype();
|
|
if (bFoxChannelRegistry.get("alarmdb") != null) {
|
|
bFoxChannelRegistry.remove("alarmdb");
|
|
}
|
|
this.alarmDb.close();
|
|
this.alarmDb = null;
|
|
BPlatformServiceContainer bPlatformServiceContainer = (BPlatformServiceContainer)Sys.getService((Type)BPlatformServiceContainer.TYPE);
|
|
Class clazz = class$com$tridium$platform$BPlatformService;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$platform$BPlatformService = BAlarmService.class("[Lcom.tridium.platform.BPlatformService;", false);
|
|
}
|
|
BPlatformService[] bPlatformServiceArray = (BPlatformService[])bPlatformServiceContainer.getChildren(clazz);
|
|
int n = 0;
|
|
while (n < bPlatformServiceArray.length) {
|
|
if (bPlatformServiceArray[n] instanceof BIAlarmablePlatformService) {
|
|
((BIAlarmablePlatformService)bPlatformServiceArray[n]).removePlatformServiceAlarmListener((PlatformServiceAlarmListener)this.listener);
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
public void initDataRecoverySource(BIDataRecoveryService bIDataRecoveryService) {
|
|
if (this.alarmWorker == null) {
|
|
this.alarmWorker = new Worker((Worker.ITodo)this.alarmQueue);
|
|
this.alarmWorker.start("Alarm:ServiceWorker");
|
|
}
|
|
this.initAlarmDb();
|
|
}
|
|
|
|
private final void initAlarmDb() {
|
|
if (this.alarmDb == null) {
|
|
this.alarmDb = this.createAlarmDb();
|
|
try {
|
|
this.updateDbCapacity(this.alarmDb);
|
|
this.alarmDb.open();
|
|
}
|
|
catch (Exception exception) {
|
|
logger.error("Cannot open alarm database.", (Throwable)exception);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final BAlarmDatabase getAlarmDb() {
|
|
if (this.alarmDb == null) {
|
|
throw new AlarmException("Alarm database is not open.");
|
|
}
|
|
return this.alarmDb;
|
|
}
|
|
|
|
protected BAlarmDatabase createAlarmDb() {
|
|
return new BFileAlarmDatabase();
|
|
}
|
|
|
|
private final void updateDbCapacity(BAlarmDatabase bAlarmDatabase) throws Exception {
|
|
try {
|
|
Method method = ((Object)((Object)bAlarmDatabase)).getClass().getMethod("setCapacity", Integer.TYPE);
|
|
method.invoke((Object)bAlarmDatabase, new Integer(this.getCapacity()));
|
|
}
|
|
catch (Exception exception) {
|
|
logger.trace("Alarm database capacity could not be updated.");
|
|
}
|
|
}
|
|
|
|
public IFuture post(Action action, BValue bValue, Context context) {
|
|
if (action.equals((Object)escalateAlarms)) {
|
|
this.alarmQueue.enqueue((Object)new Invocation((BComponent)this, action, null, context));
|
|
return null;
|
|
}
|
|
return super.post(action, bValue, context);
|
|
}
|
|
|
|
public void doEscalateAlarms() {
|
|
if (!this.isRunning()) {
|
|
return;
|
|
}
|
|
try {
|
|
Object object;
|
|
Object object2;
|
|
BAlarmClass.log.trace("Escalating");
|
|
BAlarmClass[] bAlarmClassArray = this.getAlarmClasses();
|
|
BAlarmDatabase bAlarmDatabase = this.getAlarmDb();
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
stringBuffer.append("alarm:|bql:select from openAlarms ");
|
|
int n = 0;
|
|
boolean bl = false;
|
|
int n2 = 0;
|
|
while (n2 < bAlarmClassArray.length) {
|
|
if (bAlarmClassArray[n2].getEscalationLevel1Enabled() || bAlarmClassArray[n2].getEscalationLevel2Enabled() || bAlarmClassArray[n2].getEscalationLevel3Enabled()) {
|
|
bl = true;
|
|
if (n++ != 0) {
|
|
stringBuffer.append("or ");
|
|
} else {
|
|
stringBuffer.append("where (");
|
|
}
|
|
stringBuffer.append("alarmClass='");
|
|
stringBuffer.append(SlotPath.escape((String)bAlarmClassArray[n2].getName()));
|
|
stringBuffer.append("' ");
|
|
}
|
|
++n2;
|
|
}
|
|
if (n > 0) {
|
|
stringBuffer.append(")");
|
|
}
|
|
if (!bl) {
|
|
return;
|
|
}
|
|
BITable bITable = (BITable)BOrd.make((String)stringBuffer.toString()).get((BObject)this);
|
|
Cursor cursor = bITable.cursor();
|
|
Hashtable<BUuid, BValue> hashtable = new Hashtable<BUuid, BValue>();
|
|
while (cursor.next()) {
|
|
object2 = (BAlarmRecord)cursor.get();
|
|
if (((BAlarmRecord)((Object)object2)).getAckState() != BAckState.unacked) continue;
|
|
object = this.lookupAlarmClass(((BAlarmRecord)((Object)object2)).getAlarmClass());
|
|
if (((BAlarmClass)((Object)object)).getEscalationLevel1Enabled() && ((BAlarmRecord)((Object)object2)).getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)""))) {
|
|
if (!((BAlarmRecord)((Object)object2)).getTimestamp().add(((BAlarmClass)((Object)object)).getEscalationLevel1Delay()).isBefore(BAbsTime.now())) continue;
|
|
((BAlarmRecord)((Object)object2)).addAlarmFacet(BAlarmClass.ESCALATED, (BIDataValue)BString.make((String)BAlarmClass.LEVEL_1));
|
|
hashtable.put(((BAlarmRecord)((Object)object2)).getUuid(), object2.newCopy());
|
|
continue;
|
|
}
|
|
if (((BAlarmClass)((Object)object)).getEscalationLevel2Enabled() && (((BAlarmRecord)((Object)object2)).getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)BAlarmClass.LEVEL_1)) || ((BAlarmRecord)((Object)object2)).getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)"")))) {
|
|
if (!((BAlarmRecord)((Object)object2)).getTimestamp().add(((BAlarmClass)((Object)object)).getEscalationLevel2Delay()).isBefore(BAbsTime.now())) continue;
|
|
((BAlarmRecord)((Object)object2)).addAlarmFacet(BAlarmClass.ESCALATED, (BIDataValue)BString.make((String)BAlarmClass.LEVEL_2));
|
|
hashtable.put(((BAlarmRecord)((Object)object2)).getUuid(), object2.newCopy());
|
|
BAlarmClass.log.trace("Escalating " + ((BAlarmRecord)((Object)object2)).getUuid() + " to level 2");
|
|
continue;
|
|
}
|
|
if (!((BAlarmClass)((Object)object)).getEscalationLevel3Enabled() || !((BAlarmRecord)((Object)object2)).getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)BAlarmClass.LEVEL_2)) && !((BAlarmRecord)((Object)object2)).getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)BAlarmClass.LEVEL_1)) && !((BAlarmRecord)((Object)object2)).getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)"")) || !((BAlarmRecord)((Object)object2)).getTimestamp().add(((BAlarmClass)((Object)object)).getEscalationLevel3Delay()).isBefore(BAbsTime.now())) continue;
|
|
((BAlarmRecord)((Object)object2)).addAlarmFacet(BAlarmClass.ESCALATED, (BIDataValue)BString.make((String)BAlarmClass.LEVEL_3));
|
|
hashtable.put(((BAlarmRecord)((Object)object2)).getUuid(), object2.newCopy());
|
|
BAlarmClass.log.trace("Escalating " + ((BAlarmRecord)((Object)object2)).getUuid() + " to level 3");
|
|
}
|
|
object2 = hashtable.elements();
|
|
while (object2.hasMoreElements()) {
|
|
object = (BAlarmRecord)((Object)object2.nextElement());
|
|
bAlarmDatabase.update((BAlarmRecord)((Object)object));
|
|
BAlarmClass bAlarmClass = this.lookupAlarmClass(object.getAlarmClass());
|
|
if (object.getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)BAlarmClass.LEVEL_1))) {
|
|
bAlarmClass.fireAlarm((BAlarmRecord)((Object)object));
|
|
bAlarmClass.fireEscalatedAlarm1((BAlarmRecord)((Object)object));
|
|
continue;
|
|
}
|
|
if (object.getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)BAlarmClass.LEVEL_2))) {
|
|
bAlarmClass.fireAlarm((BAlarmRecord)((Object)object));
|
|
bAlarmClass.fireEscalatedAlarm1((BAlarmRecord)((Object)object));
|
|
bAlarmClass.fireEscalatedAlarm2((BAlarmRecord)((Object)object));
|
|
continue;
|
|
}
|
|
if (!object.getAlarmData().get(BAlarmClass.ESCALATED).equals((Object)BString.make((String)BAlarmClass.LEVEL_3))) continue;
|
|
bAlarmClass.fireAlarm((BAlarmRecord)((Object)object));
|
|
bAlarmClass.fireEscalatedAlarm1((BAlarmRecord)((Object)object));
|
|
bAlarmClass.fireEscalatedAlarm2((BAlarmRecord)((Object)object));
|
|
bAlarmClass.fireEscalatedAlarm3((BAlarmRecord)((Object)object));
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public void doAckAlarm(BAlarmRecord bAlarmRecord) throws Exception {
|
|
BObject bObject = null;
|
|
try {
|
|
bObject = this.resolveAlarmSource(bAlarmRecord);
|
|
}
|
|
catch (UnresolvedException unresolvedException) {}
|
|
if (bObject != null && bObject instanceof BIRemoteAlarmSource) {
|
|
this.doRouteToSource(bAlarmRecord, bObject);
|
|
} else if (bAlarmRecord.getAckRequired()) {
|
|
this.doRouteToSource(bAlarmRecord, bObject);
|
|
} else {
|
|
bAlarmRecord.setAckState(BAckState.acked);
|
|
this.doRouteToRecipient(bAlarmRecord);
|
|
}
|
|
}
|
|
|
|
public void doRouteAlarm(BAlarmRecord bAlarmRecord) throws Exception {
|
|
if (!this.isRunning()) {
|
|
return;
|
|
}
|
|
logger.trace("BAlarmService.doRouteAlarm: " + (Object)((Object)bAlarmRecord.getSourceState()) + ' ' + (Object)((Object)bAlarmRecord.getAckState()) + ' ' + bAlarmRecord.getTimestamp() + ' ' + bAlarmRecord.getAlarmClass());
|
|
this.doRouteToRecipient(bAlarmRecord);
|
|
}
|
|
|
|
public void doRouteToRecipient(BAlarmRecord bAlarmRecord) {
|
|
BAlarmClass bAlarmClass = this.lookupAlarmClass(bAlarmRecord.getAlarmClass());
|
|
bAlarmClass.routeAlarm(bAlarmRecord);
|
|
this.fireAlarm(bAlarmRecord);
|
|
}
|
|
|
|
public void doRouteToSource(BAlarmRecord bAlarmRecord) throws Exception {
|
|
BObject bObject = null;
|
|
try {
|
|
bObject = this.resolveAlarmSource(bAlarmRecord);
|
|
}
|
|
catch (UnresolvedException unresolvedException) {}
|
|
this.doRouteToSource(bAlarmRecord, bObject);
|
|
}
|
|
|
|
/*
|
|
* Unable to fully structure code
|
|
*/
|
|
public void doRouteToSource(BAlarmRecord var1_1, BObject var2_2) throws Exception {
|
|
block18: {
|
|
block19: {
|
|
var3_3 = true;
|
|
var4_4 = false;
|
|
var5_5 = false;
|
|
if (var1_1.getAckState() == BAckState.ackPending || var1_1.getAckState() == BAckState.acked && var1_1.getAckRequired()) {
|
|
var5_5 = true;
|
|
}
|
|
if (var2_2 == null) {
|
|
BAlarmService.logger.error("BAlarmService.doRouteToSource cannot resolve alarm source " + var1_1.getSource());
|
|
if (var5_5) {
|
|
var1_1.setAckState(BAckState.acked);
|
|
var1_1.setAckTime(BAbsTime.now());
|
|
var1_1.setAckRequired(false);
|
|
var1_1.addAlarmFacet("autoAcked", (BIDataValue)BString.make((String)("Cannot resolve: " + var1_1.getSource())));
|
|
this.doRouteToRecipient(var1_1);
|
|
}
|
|
return;
|
|
}
|
|
if (var2_2 == null || !var3_3) break block18;
|
|
BAlarmService.logger.trace("BAlarmService.doRouteToSource: " + var2_2);
|
|
if (!(var2_2 instanceof BIAlarmSource)) break block19;
|
|
if (!var5_5) ** GOTO lbl26
|
|
if (((BIAlarmSource)var2_2).ackAlarm(var1_1).getBoolean()) {
|
|
var4_4 = true;
|
|
}
|
|
if (var2_2 instanceof BIRemoteAlarmSource) {
|
|
return;
|
|
}
|
|
try {
|
|
break block18;
|
|
lbl26:
|
|
// 1 sources
|
|
|
|
if (var2_2 instanceof BIUpdatableAlarmSource) {
|
|
var6_6 = (BIUpdatableAlarmSource)var2_2;
|
|
var6_6.updateAlarm(var1_1);
|
|
}
|
|
break block18;
|
|
}
|
|
catch (Exception var6_7) {
|
|
if (var6_7 instanceof BajaRuntimeException) {
|
|
throw (Exception)((BajaRuntimeException)var6_7).getCause();
|
|
}
|
|
throw var6_7;
|
|
}
|
|
}
|
|
if (var5_5 && var2_2 instanceof BIAlarmablePlatformService) {
|
|
var7_9 = var1_1.getAlarmTransition();
|
|
if (var7_9 == BSourceState.offnormal) {
|
|
var6_8 = BPlatformServiceSourceState.offnormal;
|
|
} else if (var7_9 == BSourceState.fault) {
|
|
var6_8 = BPlatformServiceSourceState.fault;
|
|
} else if (var7_9 == BSourceState.alert) {
|
|
var6_8 = BPlatformServiceSourceState.alert;
|
|
} else {
|
|
throw new IllegalStateException();
|
|
}
|
|
var8_10 = var1_1.getSource();
|
|
var9_11 = var8_10.get(var8_10.size() - 1);
|
|
var10_12 = new BPlatformServiceAlarmRecord(var9_11, var1_1.getAlarmClass(), var6_8, var1_1.getAlarmData());
|
|
var10_12.setTimestamp(var1_1.getTimestamp());
|
|
if (((BIAlarmablePlatformService)var2_2).ackAlarm(var10_12).getBoolean()) {
|
|
var4_4 = true;
|
|
}
|
|
var1_1.setAckState(BAckState.acked);
|
|
var1_1.setAckTime(BAbsTime.now());
|
|
var1_1.setAckRequired(false);
|
|
var1_1.setAlarmClass(var10_12.getAlarmClass());
|
|
this.doRouteToRecipient(var1_1);
|
|
}
|
|
}
|
|
}
|
|
|
|
public BOrd doEnableToOffnormal(BVector bVector, Context context) {
|
|
return new BAlarmExtStatusJob(this, bVector, BAlarmTransitionBits.toOffnormal, true).submit(context);
|
|
}
|
|
|
|
public BOrd doDisableToOffnormal(BVector bVector, Context context) {
|
|
return new BAlarmExtStatusJob(this, bVector, BAlarmTransitionBits.toOffnormal, false).submit(context);
|
|
}
|
|
|
|
public BOrd doEnableToFault(BVector bVector, Context context) {
|
|
return new BAlarmExtStatusJob(this, bVector, BAlarmTransitionBits.toFault, true).submit(context);
|
|
}
|
|
|
|
public BOrd doDisableToFault(BVector bVector, Context context) {
|
|
return new BAlarmExtStatusJob(this, bVector, BAlarmTransitionBits.toFault, false).submit(context);
|
|
}
|
|
|
|
public void doAuditForceClear(BAlarmRecord bAlarmRecord, Context context) {
|
|
Auditor auditor = Sys.getAuditor();
|
|
if (auditor != null) {
|
|
BUser bUser = context.getUser();
|
|
String string = "";
|
|
if (bUser != null) {
|
|
string = bUser.getUsername();
|
|
}
|
|
bUser.getUsername();
|
|
auditor.audit(new AuditEvent("Force Clear Alarm", bAlarmRecord.getSource().toString(), bAlarmRecord.getUuid().toString(), "", "", string));
|
|
}
|
|
}
|
|
|
|
public BAlarmClass[] getAlarmClasses() {
|
|
return this.loadFromFolder(this);
|
|
}
|
|
|
|
private final BAlarmClass[] loadFromFolder(BComponent bComponent) {
|
|
Class clazz = class$javax$baja$alarm$BAlarmClass;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$alarm$BAlarmClass = BAlarmService.class("[Ljavax.baja.alarm.BAlarmClass;", false);
|
|
}
|
|
Array array = new Array(clazz);
|
|
bComponent.lease();
|
|
Class clazz2 = class$javax$baja$alarm$BAlarmClass;
|
|
if (clazz2 == null) {
|
|
clazz2 = class$javax$baja$alarm$BAlarmClass = BAlarmService.class("[Ljavax.baja.alarm.BAlarmClass;", false);
|
|
}
|
|
BComponent[] bComponentArray = (BComponent[])bComponent.getChildren(clazz2);
|
|
int n = 0;
|
|
while (n < bComponentArray.length) {
|
|
array.add((Object)bComponentArray[n]);
|
|
++n;
|
|
}
|
|
Class clazz3 = class$javax$baja$alarm$BAlarmClassFolder;
|
|
if (clazz3 == null) {
|
|
clazz3 = class$javax$baja$alarm$BAlarmClassFolder = BAlarmService.class("[Ljavax.baja.alarm.BAlarmClassFolder;", false);
|
|
}
|
|
BAlarmClassFolder[] bAlarmClassFolderArray = (BAlarmClassFolder[])bComponent.getChildren(clazz3);
|
|
int n2 = 0;
|
|
while (n2 < bAlarmClassFolderArray.length) {
|
|
this.loadFromFolder((BComponent)bAlarmClassFolderArray[n2]);
|
|
BAlarmClass[] bAlarmClassArray = this.loadFromFolder((BComponent)bAlarmClassFolderArray[n2]);
|
|
int n3 = 0;
|
|
while (n3 < bAlarmClassArray.length) {
|
|
array.add((Object)bAlarmClassArray[n3]);
|
|
++n3;
|
|
}
|
|
++n2;
|
|
}
|
|
return (BAlarmClass[])array.trim();
|
|
}
|
|
|
|
public BAlarmClass lookupAlarmClass(String string) {
|
|
BAlarmClass bAlarmClass = this.lookupAlarmClass(this, string);
|
|
if (bAlarmClass == null) {
|
|
bAlarmClass = this.getDefaultAlarmClass();
|
|
logger.trace("BAlarmService.lookupAlarmClass can't find alarm class <" + string + "> using default <" + bAlarmClass.getName() + '>');
|
|
} else {
|
|
logger.trace("BAlarmService.lookupAlarmClass: will route alarm with " + (Object)((Object)bAlarmClass));
|
|
}
|
|
return bAlarmClass;
|
|
}
|
|
|
|
protected BAlarmClass lookupAlarmClass(BComponent bComponent, String string) {
|
|
bComponent.lease();
|
|
Property property = bComponent.getProperty(string);
|
|
if (property == null || !bComponent.get(property).getType().is(BAlarmClass.TYPE)) {
|
|
Class clazz = class$javax$baja$alarm$BAlarmClassFolder;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$alarm$BAlarmClassFolder = BAlarmService.class("[Ljavax.baja.alarm.BAlarmClassFolder;", false);
|
|
}
|
|
BAlarmClassFolder[] bAlarmClassFolderArray = (BAlarmClassFolder[])bComponent.getChildren(clazz);
|
|
int n = 0;
|
|
while (n < bAlarmClassFolderArray.length) {
|
|
BAlarmClass bAlarmClass = this.lookupAlarmClass((BComponent)bAlarmClassFolderArray[n], string);
|
|
if (bAlarmClass != null) {
|
|
return bAlarmClass;
|
|
}
|
|
++n;
|
|
}
|
|
} else {
|
|
return (BAlarmClass)bComponent.get(property);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public BString getAlarmClassDisplayName(Object object, Context context) {
|
|
if (Sys.getStation() == null) {
|
|
if (this.remoteVersion == null) {
|
|
try {
|
|
this.remoteVersion = (Version)((BFoxSession)this.getSession()).fw(404, (Object)"alarm", null, null, null);
|
|
}
|
|
catch (Exception exception) {}
|
|
}
|
|
if (this.remoteVersion != null && !this.remoteVersion.isNull() && this.remoteVersion.compareTo((Object)new Version("3.7.35")) >= 0) {
|
|
try {
|
|
BString bString = (BString)this.getComponentSpace().fw(109, (Object)this, (Object)"reflect:getAlarmClassDisplayName", (Object)BString.make((String)object.toString()), null);
|
|
if (bString != null) {
|
|
return bString;
|
|
}
|
|
}
|
|
catch (Exception exception) {}
|
|
}
|
|
return BString.make((String)object.toString());
|
|
}
|
|
String string = (String)this.alarmClassDisplayNames.get(object.toString());
|
|
if (string == null) {
|
|
string = this.lookupAlarmClass(object.toString()).getDisplayName(context);
|
|
this.alarmClassDisplayNames.put(object, string);
|
|
}
|
|
return BString.make((String)string);
|
|
}
|
|
|
|
private final BObject resolveAlarmSource(BAlarmRecord bAlarmRecord) throws Exception {
|
|
BObject bObject = null;
|
|
BOrdList bOrdList = bAlarmRecord.getSource();
|
|
BOrd bOrd = bOrdList.get(bOrdList.size() - 1);
|
|
logger.trace("BAlarmService::resolveAlarmSource = " + bOrd);
|
|
bObject = bOrd.get((BObject)this);
|
|
logger.trace(" BAlarmService::resolveAlarmSource resolved = " + bObject);
|
|
return bObject;
|
|
}
|
|
|
|
public void checkAdd(String string, BValue bValue, int n, BFacets bFacets, Context context) {
|
|
if (this.isRunning() && bValue.getType().is(BAlarmClass.TYPE)) {
|
|
BAlarmClass bAlarmClass = this.lookupAlarmClass(string);
|
|
if (string.equals("defaultAlarmClass") || !bAlarmClass.getName().equals("defaultAlarmClass")) {
|
|
throw new LocalizableRuntimeException("alarm", "DuplicateAlarmClass", (Object[])new String[]{string});
|
|
}
|
|
}
|
|
super.checkAdd(string, bValue, n, bFacets, context);
|
|
}
|
|
|
|
public void checkRename(Property property, String string, Context context) {
|
|
if (property.getType().is(BAlarmClass.TYPE)) {
|
|
BAlarmClass bAlarmClass = this.lookupAlarmClass(string);
|
|
if (string.equals("defaultAlarmClass") || !bAlarmClass.getName().equals("defaultAlarmClass")) {
|
|
throw new IllegalNameException("alarm", "DuplicateAlarmClass", (Object[])new String[]{string});
|
|
}
|
|
this.alarmClassDisplayNames.clear();
|
|
}
|
|
super.checkRename(property, string, context);
|
|
}
|
|
|
|
public void changed(Property property, Context context) {
|
|
if (property.equals((Object)capacity)) {
|
|
if (this.alarmDb != null) {
|
|
try {
|
|
this.updateDbCapacity(this.alarmDb);
|
|
}
|
|
catch (Exception exception) {
|
|
logger.error("Cannot change database capacity to " + this.getCapacity() + '.', (Throwable)exception);
|
|
}
|
|
}
|
|
} else if (property.getName().equals("displayNames")) {
|
|
this.alarmClassDisplayNames.clear();
|
|
}
|
|
}
|
|
|
|
public void added(Property property, Context context) {
|
|
if (property.getName().equals("displayNames")) {
|
|
this.alarmClassDisplayNames.clear();
|
|
}
|
|
}
|
|
|
|
public void removed(Property property, BValue bValue, Context context) {
|
|
if (property.getName().equals("displayNames")) {
|
|
this.alarmClassDisplayNames.clear();
|
|
}
|
|
}
|
|
|
|
public AgentList getAgents(Context context) {
|
|
AgentList agentList = super.getAgents(context);
|
|
agentList.toTop("wiresheet:WireSheet");
|
|
return agentList;
|
|
}
|
|
|
|
public BIcon getIcon() {
|
|
return icon;
|
|
}
|
|
|
|
public final Object fw(int n, Object object, Object object2, Object object3, Object object4) {
|
|
switch (n) {
|
|
case 11: {
|
|
this.add(null, (BValue)new BLink(this.getEscalationTimeTrigger().getOrdInSession(), "fireTrigger", "escalateAlarms", true), 6);
|
|
break;
|
|
}
|
|
case 21: {
|
|
if (this.alarmDb == null) break;
|
|
this.alarmDb.fw(n, object, object2, object3, object4);
|
|
break;
|
|
}
|
|
case 601: {
|
|
return this.alarmQueue;
|
|
}
|
|
}
|
|
return super.fw(n, object, object2, object3, object4);
|
|
}
|
|
|
|
public void spy(SpyWriter spyWriter) throws Exception {
|
|
super.spy(spyWriter);
|
|
spyWriter.startProps();
|
|
spyWriter.trTitle((Object)"BAlarmService", 2);
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
int n = 0;
|
|
if (this.alarmQueue != null) {
|
|
n = this.alarmQueue.size();
|
|
}
|
|
spyWriter.prop((Object)"workInAlarmQueue", (Object)stringBuffer.append(n).toString());
|
|
spyWriter.endProps();
|
|
if (this.alarmWorker != null) {
|
|
this.alarmWorker.spy(spyWriter);
|
|
}
|
|
}
|
|
|
|
static /* synthetic */ Class class(String string, boolean bl) {
|
|
try {
|
|
Class<?> clazz = Class.forName(string);
|
|
if (!bl) {
|
|
clazz = clazz.getComponentType();
|
|
}
|
|
return clazz;
|
|
}
|
|
catch (ClassNotFoundException classNotFoundException) {
|
|
throw new NoClassDefFoundError(classNotFoundException.getMessage());
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.alarmClassDisplayNames = new HashMap();
|
|
this.remoteVersion = null;
|
|
this.listener = new PlatformServiceListener();
|
|
this.alarmQueue = new CoalesceQueue();
|
|
this.saveListener = new Station.SaveListener(){
|
|
|
|
public final void stationSave() {
|
|
try {
|
|
BAlarmService.this.getAlarmDb().save();
|
|
}
|
|
catch (Exception exception) {
|
|
BAlarmDatabase.log.error("Alarm database save failed.", (Throwable)exception);
|
|
}
|
|
}
|
|
|
|
public final void stationSaveOk() {
|
|
}
|
|
|
|
public final void stationSaveFail(String string) {
|
|
}
|
|
|
|
public final String toString() {
|
|
return "AlarmService " + BAlarmService.this.getNavOrd();
|
|
}
|
|
};
|
|
}
|
|
|
|
public BAlarmService() {
|
|
this.this();
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$javax$baja$alarm$BAlarmService;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$alarm$BAlarmService = BAlarmService.class("[Ljavax.baja.alarm.BAlarmService;", false);
|
|
}
|
|
TYPE = Sys.loadType((Class)clazz);
|
|
serviceTypes = new Type[]{TYPE};
|
|
icon = BIcon.std((String)"alarm.png");
|
|
logger = Log.getLog((String)"alarm");
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
class PlatformServiceListener
|
|
implements PlatformServiceAlarmListener {
|
|
public void platformServiceAlarm(BPlatformServiceAlarmRecord bPlatformServiceAlarmRecord) {
|
|
BSourceState bSourceState;
|
|
BPlatformServiceSourceState bPlatformServiceSourceState = bPlatformServiceAlarmRecord.getSourceState();
|
|
if (bPlatformServiceSourceState == BPlatformServiceSourceState.normal) {
|
|
this.platformServiceToNormal(bPlatformServiceAlarmRecord);
|
|
return;
|
|
}
|
|
if (bPlatformServiceSourceState == BPlatformServiceSourceState.offnormal) {
|
|
bSourceState = BSourceState.offnormal;
|
|
} else if (bPlatformServiceSourceState == BPlatformServiceSourceState.fault) {
|
|
bSourceState = BSourceState.fault;
|
|
} else if (bPlatformServiceSourceState == BPlatformServiceSourceState.alert) {
|
|
bSourceState = BSourceState.alert;
|
|
} else {
|
|
throw new IllegalStateException();
|
|
}
|
|
BAlarmRecord bAlarmRecord = null;
|
|
try {
|
|
bAlarmRecord = BAlarmService.this.getAlarmDb().getRecord(bPlatformServiceAlarmRecord.getUuid());
|
|
}
|
|
catch (Exception exception) {}
|
|
if (bAlarmRecord == null) {
|
|
bAlarmRecord = new BAlarmRecord(bPlatformServiceAlarmRecord.getSource(), bPlatformServiceAlarmRecord.getAlarmClass(), bPlatformServiceAlarmRecord.getAlarmData());
|
|
bAlarmRecord.setUuid(bPlatformServiceAlarmRecord.getUuid());
|
|
bAlarmRecord.setTimestamp(bPlatformServiceAlarmRecord.getTimestamp());
|
|
}
|
|
bAlarmRecord.setSourceState(bSourceState);
|
|
bAlarmRecord.setAlarmTransition(bSourceState);
|
|
BAlarmService.this.routeAlarm(bAlarmRecord);
|
|
}
|
|
|
|
public void platformServiceToNormal(BPlatformServiceAlarmRecord bPlatformServiceAlarmRecord) {
|
|
try {
|
|
Cursor cursor = BAlarmService.this.getAlarmDb().getAlarmsForSource(BOrdList.make((BOrd)bPlatformServiceAlarmRecord.getSource()));
|
|
while (cursor.next()) {
|
|
BAlarmRecord bAlarmRecord = (BAlarmRecord)cursor.get();
|
|
if (bAlarmRecord.isNormal()) continue;
|
|
bAlarmRecord.setAlarmClass(bPlatformServiceAlarmRecord.getAlarmClass());
|
|
bAlarmRecord.setAlarmData(BFacets.make((BFacets)bAlarmRecord.getAlarmData(), (BFacets)bPlatformServiceAlarmRecord.getAlarmData()));
|
|
bAlarmRecord.setNormalTime(bPlatformServiceAlarmRecord.getTimestamp());
|
|
bAlarmRecord.setSourceState(BSourceState.normal);
|
|
BAlarmService.this.routeAlarm((BAlarmRecord)bAlarmRecord.newCopy());
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
logger.error("Unable to generate toNormal PlatformServiceAlarm for: " + bPlatformServiceAlarmRecord.getSource(), (Throwable)exception);
|
|
}
|
|
}
|
|
|
|
PlatformServiceListener() {
|
|
}
|
|
}
|
|
}
|
|
|