564 lines
19 KiB
Java
564 lines
19 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.tridium.sys.schema.ComponentSlotMap
|
|
* com.tridium.sys.transfer.DeleteOp
|
|
* com.tridium.sys.transfer.RemoteTransferSpace
|
|
* com.tridium.sys.transfer.TransferResult
|
|
* com.tridium.sys.transfer.TransferStrategy
|
|
* javax.baja.log.Log
|
|
* javax.baja.naming.BOrd
|
|
* javax.baja.naming.OrdQuery
|
|
* javax.baja.naming.SlotPath
|
|
* javax.baja.naming.UnresolvedException
|
|
* javax.baja.net.NotConnectedException
|
|
* javax.baja.nre.util.Array
|
|
* javax.baja.space.BComponentSpace
|
|
* javax.baja.space.LoadCallbacks
|
|
* javax.baja.space.SubscribeCallbacks
|
|
* javax.baja.space.TrapCallbacks
|
|
* javax.baja.spy.SpyWriter
|
|
* javax.baja.sync.BProxyComponentSpace
|
|
* javax.baja.sync.SyncBuffer
|
|
* javax.baja.sync.SyncOp
|
|
* javax.baja.sync.Transaction
|
|
* javax.baja.sync.TrapToSyncBuffer
|
|
* javax.baja.sys.Action
|
|
* javax.baja.sys.ActionInvokeException
|
|
* javax.baja.sys.BAbsTime
|
|
* javax.baja.sys.BComplex
|
|
* javax.baja.sys.BComponent
|
|
* javax.baja.sys.BObject
|
|
* javax.baja.sys.BValue
|
|
* javax.baja.sys.Clock
|
|
* javax.baja.sys.Context
|
|
* javax.baja.sys.CopyHints
|
|
* javax.baja.sys.Property
|
|
* javax.baja.sys.Slot
|
|
* javax.baja.sys.Sys
|
|
* javax.baja.sys.Type
|
|
* javax.baja.util.LexiconText
|
|
* javax.baja.virtual.BVirtualComponent
|
|
* javax.baja.virtual.VirtualPath
|
|
*/
|
|
package com.tridium.fox.sys.broker;
|
|
|
|
import com.tridium.fox.sys.BFoxChannelRegistry;
|
|
import com.tridium.fox.sys.BFoxSession;
|
|
import com.tridium.fox.sys.BIFoxProxySpace;
|
|
import com.tridium.fox.sys.broker.BBrokerChannel;
|
|
import com.tridium.sys.schema.ComponentSlotMap;
|
|
import com.tridium.sys.transfer.DeleteOp;
|
|
import com.tridium.sys.transfer.RemoteTransferSpace;
|
|
import com.tridium.sys.transfer.TransferResult;
|
|
import com.tridium.sys.transfer.TransferStrategy;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.naming.OrdQuery;
|
|
import javax.baja.naming.SlotPath;
|
|
import javax.baja.naming.UnresolvedException;
|
|
import javax.baja.net.NotConnectedException;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.space.BComponentSpace;
|
|
import javax.baja.space.LoadCallbacks;
|
|
import javax.baja.space.SubscribeCallbacks;
|
|
import javax.baja.space.TrapCallbacks;
|
|
import javax.baja.spy.SpyWriter;
|
|
import javax.baja.sync.BProxyComponentSpace;
|
|
import javax.baja.sync.SyncBuffer;
|
|
import javax.baja.sync.SyncOp;
|
|
import javax.baja.sync.Transaction;
|
|
import javax.baja.sync.TrapToSyncBuffer;
|
|
import javax.baja.sys.Action;
|
|
import javax.baja.sys.ActionInvokeException;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BComplex;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Clock;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.CopyHints;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.util.LexiconText;
|
|
import javax.baja.virtual.BVirtualComponent;
|
|
import javax.baja.virtual.VirtualPath;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public abstract class BFoxComponentSpace
|
|
extends BProxyComponentSpace
|
|
implements RemoteTransferSpace,
|
|
BIFoxProxySpace {
|
|
public static final Type TYPE;
|
|
public static final Log log;
|
|
BBrokerChannel channel;
|
|
HashMap subscribed;
|
|
boolean spaceReadonly;
|
|
long defaultLeaseTime;
|
|
static /* synthetic */ Class class$com$tridium$fox$sys$broker$BFoxComponentSpace;
|
|
static /* synthetic */ Class class$java$lang$String;
|
|
static /* synthetic */ Class class$javax$baja$sys$BComponent;
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
public void init(BFoxSession bFoxSession) throws Exception {
|
|
BFoxChannelRegistry bFoxChannelRegistry = bFoxSession.getConnection().getChannels();
|
|
this.channel = bFoxChannelRegistry.getSysChannel().makeBrokerChannel(this);
|
|
}
|
|
|
|
public void cleanup(BFoxSession bFoxSession) throws Exception {
|
|
BFoxChannelRegistry bFoxChannelRegistry = bFoxSession.getConnection().getChannels();
|
|
this.channel.cleanupClient();
|
|
bFoxChannelRegistry.remove(this.channel.getPropertyInParent());
|
|
this.channel = null;
|
|
}
|
|
|
|
public boolean isSpaceReadonly() {
|
|
return this.spaceReadonly;
|
|
}
|
|
|
|
public long getDefaultLeaseTime() {
|
|
return this.defaultLeaseTime;
|
|
}
|
|
|
|
protected BComponent loadByHandle(Object object) {
|
|
SlotPath slotPath = this.handleToSlotPath(object);
|
|
if (slotPath == null) {
|
|
throw new UnresolvedException(String.valueOf(object));
|
|
}
|
|
try {
|
|
return (BComponent)BOrd.make((OrdQuery)slotPath).get((BObject)this);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("loadByHandle(" + object + "): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
public SlotPath handleToSlotPath(Object object) {
|
|
SlotPath slotPath = super.handleToSlotPath(object);
|
|
if (slotPath != null) {
|
|
return slotPath;
|
|
}
|
|
try {
|
|
return this.channel().handleToPath(new Object[]{object})[0];
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("handleToSlotPath(" + object + "): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
public SlotPath[] handlesToSlotPaths(Object[] objectArray) {
|
|
boolean bl = true;
|
|
SlotPath[] slotPathArray = new SlotPath[objectArray.length];
|
|
int n = 0;
|
|
while (n < slotPathArray.length) {
|
|
slotPathArray[n] = super.handleToSlotPath(objectArray[n]);
|
|
if (slotPathArray[n] == null) {
|
|
bl = false;
|
|
break;
|
|
}
|
|
++n;
|
|
}
|
|
if (bl) {
|
|
return slotPathArray;
|
|
}
|
|
try {
|
|
return this.channel().handleToPath(objectArray);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("handlesToSlotPaths(" + objectArray.length + "): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
public Object fw(int n, Object object, Object object2, Object object3, Object object4) {
|
|
switch (n) {
|
|
case 103: {
|
|
return this.generateHandles((Integer)object);
|
|
}
|
|
case 104: {
|
|
this.ensureLoaded((SlotPath[])object);
|
|
return null;
|
|
}
|
|
case 106: {
|
|
return this.delete((DeleteOp)object, false);
|
|
}
|
|
case 107: {
|
|
return this.delete((DeleteOp)object, true);
|
|
}
|
|
case 109: {
|
|
return this.rpc((BComponent)object, (String)object2, (BValue)object3);
|
|
}
|
|
}
|
|
return super.fw(n, object, object2, object3, object4);
|
|
}
|
|
|
|
private final Object[] generateHandles(int n) {
|
|
try {
|
|
return this.channel().generateHandles(n);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("generateHandles(): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
private final DeleteOp delete(DeleteOp deleteOp, boolean bl) {
|
|
try {
|
|
deleteOp = this.channel().delete(deleteOp, bl);
|
|
this.sync();
|
|
return deleteOp;
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("deleteOp(): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
private final BValue rpc(BComponent bComponent, String string, BValue bValue) {
|
|
try {
|
|
return this.channel().rpc(bComponent, string, bValue);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("rpc(): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
public final BBrokerChannel channel() throws Exception {
|
|
if (this.channel == null) {
|
|
throw new NotConnectedException();
|
|
}
|
|
return this.channel;
|
|
}
|
|
|
|
public void ensureLoaded(SlotPath[] slotPathArray) {
|
|
try {
|
|
Class clazz = class$java$lang$String;
|
|
if (clazz == null) {
|
|
clazz = class$java$lang$String = BFoxComponentSpace.class("[Ljava.lang.String;", false);
|
|
}
|
|
Array array = new Array(clazz);
|
|
HashMap<Slot, Slot> hashMap = new HashMap<Slot, Slot>();
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
int n = 0;
|
|
while (n < slotPathArray.length) {
|
|
SlotPath slotPath = slotPathArray[n];
|
|
boolean bl = slotPath instanceof VirtualPath;
|
|
stringBuffer.setLength(0);
|
|
if (bl) {
|
|
stringBuffer.append("virtual:");
|
|
} else {
|
|
stringBuffer.append("slot:");
|
|
}
|
|
BComponent bComponent = this.getRootComponent();
|
|
int n2 = 0;
|
|
while (n2 < slotPath.depth()) {
|
|
Object object;
|
|
String string = slotPath.nameAt(n2);
|
|
stringBuffer.append('/').append(string);
|
|
if (bl) {
|
|
string = SlotPath.escape((String)string);
|
|
}
|
|
if (bComponent instanceof BComplex) {
|
|
ComponentSlotMap componentSlotMap;
|
|
object = ((BComplex)bComponent).getSlot(string);
|
|
if (object instanceof Property) {
|
|
bComponent = ((BComplex)bComponent).get((Property)object);
|
|
} else if (object == null) {
|
|
bComponent = null;
|
|
}
|
|
if (bComponent instanceof BComponent && !(componentSlotMap = (ComponentSlotMap)bComponent.fw(1)).isBrokerPropsLoaded() && !(bComponent instanceof BVirtualComponent)) {
|
|
bComponent = null;
|
|
}
|
|
}
|
|
if (bComponent == null && hashMap.get(object = stringBuffer.toString()) == null) {
|
|
hashMap.put((Slot)object, (Slot)object);
|
|
array.add(object);
|
|
}
|
|
++n2;
|
|
}
|
|
++n;
|
|
}
|
|
if (array.size() == 0) {
|
|
return;
|
|
}
|
|
this.channel().ensureLoaded((String[])array.trim(), 0);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("ensureLoaded(): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
public Transaction newTransaction(Context context) {
|
|
return new Transaction((BComponentSpace)this, context){
|
|
|
|
public final void commit(Context context) throws Exception {
|
|
BFoxComponentSpace.this.channel().syncToMaster((SyncBuffer)this);
|
|
}
|
|
};
|
|
}
|
|
|
|
public void sync() throws Exception {
|
|
this.channel().syncFromMaster();
|
|
}
|
|
|
|
public boolean fireDirectCallbacks() {
|
|
return false;
|
|
}
|
|
|
|
public TransferResult transfer(TransferStrategy transferStrategy) throws Exception {
|
|
try {
|
|
return this.channel().transfer(transferStrategy);
|
|
}
|
|
catch (Exception exception) {
|
|
throw BFoxSession.toException(exception);
|
|
}
|
|
}
|
|
|
|
public void spy(SpyWriter spyWriter) throws Exception {
|
|
super.spy(spyWriter);
|
|
spyWriter.startProps("Subscribed");
|
|
Iterator iterator = this.subscribed.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
BComponent bComponent = (BComponent)iterator.next();
|
|
BAbsTime bAbsTime = (BAbsTime)this.subscribed.get(bComponent);
|
|
spyWriter.tr((Object)bComponent.toPathString(), (Object)bAbsTime);
|
|
}
|
|
spyWriter.endProps();
|
|
}
|
|
|
|
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.subscribed = new HashMap();
|
|
this.spaceReadonly = false;
|
|
this.defaultLeaseTime = 60000L;
|
|
}
|
|
|
|
public BFoxComponentSpace(String string, LexiconText lexiconText, BOrd bOrd) {
|
|
super(string, lexiconText, bOrd);
|
|
this.this();
|
|
this.setLoadCallbacks(new FoxLoadCallbacks());
|
|
this.setTrapCallbacks((TrapCallbacks)new FoxTrapCallbacks());
|
|
this.setSubscribeCallbacks(new FoxSubscribeCallbacks());
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$com$tridium$fox$sys$broker$BFoxComponentSpace;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$fox$sys$broker$BFoxComponentSpace = BFoxComponentSpace.class("[Lcom.tridium.fox.sys.broker.BFoxComponentSpace;", false);
|
|
}
|
|
TYPE = Sys.loadType((Class)clazz);
|
|
log = Log.getLog((String)"FoxSpace");
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
class FoxLoadCallbacks
|
|
extends LoadCallbacks {
|
|
public boolean isLazyLoad() {
|
|
return true;
|
|
}
|
|
|
|
public void loadSlots(BComponent bComponent) {
|
|
try {
|
|
BFoxComponentSpace.this.channel().load(bComponent, 0);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("loadSlots(" + bComponent.toPathString() + "): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
public BValue[] newCopy(BValue[] bValueArray, CopyHints copyHints) {
|
|
try {
|
|
return BFoxComponentSpace.this.channel().copy(bValueArray, copyHints);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("newCopy():" + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
FoxLoadCallbacks() {
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
class FoxTrapCallbacks
|
|
extends TrapToSyncBuffer {
|
|
public SyncBuffer getBuffer() {
|
|
return new AutoCommitSyncBuffer((BComponentSpace)BFoxComponentSpace.this);
|
|
}
|
|
|
|
public BValue invoke(BComponent bComponent, Action action, BValue bValue, Context context) {
|
|
try {
|
|
return BFoxComponentSpace.this.channel().invoke(bComponent, action, bValue);
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("Cannot invoke: " + bComponent.toPathString() + '.' + action);
|
|
throw new ActionInvokeException((Throwable)exception);
|
|
}
|
|
}
|
|
|
|
FoxTrapCallbacks() {
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
class FoxSubscribeCallbacks
|
|
extends SubscribeCallbacks {
|
|
public void update(BComponent bComponent, int n) {
|
|
try {
|
|
BFoxComponentSpace.this.channel().load(bComponent, n);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("update(" + bComponent.toPathString() + "): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public void subscribe(BComponent[] bComponentArray, int n) {
|
|
HashMap hashMap;
|
|
if (n == 0) {
|
|
hashMap = BFoxComponentSpace.this.subscribed;
|
|
synchronized (hashMap) {
|
|
Class clazz = class$javax$baja$sys$BComponent;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$sys$BComponent = BFoxComponentSpace.class("[Ljavax.baja.sys.BComponent;", false);
|
|
}
|
|
Array array = new Array(clazz);
|
|
int n2 = 0;
|
|
while (true) {
|
|
if (n2 >= bComponentArray.length) {
|
|
if (array.size() != 0) break;
|
|
return;
|
|
}
|
|
if (BFoxComponentSpace.this.subscribed.get(bComponentArray[n2]) == null) {
|
|
array.add((Object)bComponentArray[n2]);
|
|
}
|
|
++n2;
|
|
}
|
|
bComponentArray = (BComponent[])array.trim();
|
|
}
|
|
}
|
|
try {
|
|
BFoxComponentSpace.this.channel().subscribe(bComponentArray, n);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("subscribe(" + bComponentArray[0].toPathString() + "): " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
hashMap = BFoxComponentSpace.this.subscribed;
|
|
synchronized (hashMap) {
|
|
int n3 = 0;
|
|
while (n3 < bComponentArray.length) {
|
|
this.addToSubscribed(bComponentArray[n3], n);
|
|
++n3;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void addToSubscribed(BComponent bComponent, int n) {
|
|
BFoxComponentSpace.this.subscribed.put(bComponent, Clock.time());
|
|
if (n > 0) {
|
|
BComponent[] bComponentArray = bComponent.getChildComponents();
|
|
int n2 = 0;
|
|
while (n2 < bComponentArray.length) {
|
|
this.addToSubscribed(bComponentArray[n2], n - 1);
|
|
++n2;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public void unsubscribe(BComponent[] bComponentArray) {
|
|
HashMap hashMap = BFoxComponentSpace.this.subscribed;
|
|
synchronized (hashMap) {
|
|
int n = 0;
|
|
while (n < bComponentArray.length) {
|
|
BFoxComponentSpace.this.subscribed.remove(bComponentArray[n]);
|
|
++n;
|
|
}
|
|
}
|
|
try {
|
|
BFoxComponentSpace.this.channel().unsubscribe(bComponentArray);
|
|
return;
|
|
}
|
|
catch (NotConnectedException notConnectedException) {
|
|
return;
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("Cannot unsubscribe: " + bComponentArray[0].toPathString(), (Throwable)exception);
|
|
}
|
|
}
|
|
|
|
FoxSubscribeCallbacks() {
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
class AutoCommitSyncBuffer
|
|
extends SyncBuffer {
|
|
public void add(SyncOp syncOp) {
|
|
super.add(syncOp);
|
|
try {
|
|
BFoxComponentSpace.this.channel().syncToMaster(this);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("AutoCommitSyncBuffer: " + throwable);
|
|
throw BFoxSession.toException(throwable);
|
|
}
|
|
}
|
|
|
|
AutoCommitSyncBuffer(BComponentSpace bComponentSpace) {
|
|
super(bComponentSpace, false);
|
|
}
|
|
}
|
|
}
|
|
|