416 lines
14 KiB
Java
416 lines
14 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.xml.XException
|
|
*/
|
|
package com.tridium.sys.registry;
|
|
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.registry.Builder;
|
|
import com.tridium.sys.registry.Debug;
|
|
import com.tridium.sys.registry.NTypeInfo;
|
|
import com.tridium.sys.registry.RegistryChecksum;
|
|
import com.tridium.sys.registry.RegistryDatabase;
|
|
import java.io.BufferedInputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileWriter;
|
|
import java.io.InputStream;
|
|
import java.io.PrintWriter;
|
|
import java.util.Date;
|
|
import javax.baja.agent.AgentInfo;
|
|
import javax.baja.agent.AgentList;
|
|
import javax.baja.agent.BIAgent;
|
|
import javax.baja.io.ValueDocDecoder;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.registry.LexiconInfo;
|
|
import javax.baja.registry.ModuleInfo;
|
|
import javax.baja.registry.Registry;
|
|
import javax.baja.registry.RegistryException;
|
|
import javax.baja.registry.TypeInfo;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BComplex;
|
|
import javax.baja.sys.BModule;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.ModuleNotFoundException;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.sys.TypeNotFoundException;
|
|
import javax.baja.util.BTypeSpec;
|
|
import javax.baja.util.Version;
|
|
import javax.baja.xml.XException;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public final class NRegistry
|
|
implements Registry {
|
|
public static final Log log = Log.getLog("sys.registry");
|
|
public static boolean forceRebuild = false;
|
|
RegistryDatabase db;
|
|
public final ValueDocDecoder.ITypeResolver typeResolver;
|
|
private String[] invalidModules;
|
|
|
|
public final BAbsTime getLastBuildTime() {
|
|
return BAbsTime.make(this.dbFile().lastModified());
|
|
}
|
|
|
|
public final ModuleInfo[] getModules() {
|
|
return this.db().getModules();
|
|
}
|
|
|
|
public final ModuleInfo getModule(String string) {
|
|
return this.db().getModule(string);
|
|
}
|
|
|
|
public final TypeInfo[] getTypes() {
|
|
return this.db().getTypes();
|
|
}
|
|
|
|
public final TypeInfo[] getTypes(TypeInfo typeInfo) {
|
|
return this.db().getTypes(typeInfo, false);
|
|
}
|
|
|
|
public final TypeInfo[] getConcreteTypes(TypeInfo typeInfo) {
|
|
return this.db().getTypes(typeInfo, true);
|
|
}
|
|
|
|
public final TypeInfo getType(String string) {
|
|
return this.db().getType(string);
|
|
}
|
|
|
|
public final String[] getDefs() {
|
|
return this.db().getDefs();
|
|
}
|
|
|
|
public final String[] getDefs(String string) {
|
|
return this.db().getDefs(string);
|
|
}
|
|
|
|
public final String getDef(String string) {
|
|
return this.db().getDef(string, null);
|
|
}
|
|
|
|
public final String getDef(String string, String string2) {
|
|
return this.db().getDef(string, string2);
|
|
}
|
|
|
|
public final AgentList getAgents(TypeInfo typeInfo) {
|
|
return this.db().getAgents(typeInfo);
|
|
}
|
|
|
|
public final AgentList getSpecificAgents(TypeInfo typeInfo) {
|
|
return this.db().getSpecificAgents(typeInfo);
|
|
}
|
|
|
|
public final boolean isAgent(TypeInfo typeInfo, TypeInfo typeInfo2) {
|
|
return this.db().isAgent(typeInfo, typeInfo2);
|
|
}
|
|
|
|
public final boolean isSpecificAgent(TypeInfo typeInfo, TypeInfo typeInfo2) {
|
|
return this.db().isSpecificAgent(typeInfo, typeInfo2);
|
|
}
|
|
|
|
public final TypeInfo[] getAdapters(TypeInfo typeInfo, TypeInfo typeInfo2) {
|
|
return this.db().getAdapters(typeInfo, typeInfo2);
|
|
}
|
|
|
|
public final String[] getFileExtensions() {
|
|
return this.db().getFileExtensions();
|
|
}
|
|
|
|
public final String[] getFileExtensions(TypeInfo typeInfo) {
|
|
return this.db().getFileExtensions(typeInfo);
|
|
}
|
|
|
|
public final TypeInfo getFileTypeForExtension(String string) {
|
|
return this.db().getFileTypeForExtension(string);
|
|
}
|
|
|
|
public final String[] getOrdSchemes() {
|
|
return this.db().getOrdSchemes();
|
|
}
|
|
|
|
public final TypeInfo getOrdScheme(String string) {
|
|
return this.db().getOrdScheme(string);
|
|
}
|
|
|
|
public final boolean isOrdScheme(String string) {
|
|
return this.db().isOrdScheme(string);
|
|
}
|
|
|
|
public final LexiconInfo[] getLexicons() {
|
|
return this.db().getLexicons();
|
|
}
|
|
|
|
public final LexiconInfo[] getLexicons(String string) {
|
|
return this.db().getLexicons(string);
|
|
}
|
|
|
|
public final LexiconInfo[] getLexicons(String string, String string2) {
|
|
return this.db().getLexicons(string, string2);
|
|
}
|
|
|
|
public final LexiconInfo getLexicon(String string, String string2, String string3) {
|
|
return this.db().getLexicon(string, string2, string3);
|
|
}
|
|
|
|
public final Type synthesizeType(BTypeSpec bTypeSpec, String string, TypeInfo typeInfo, TypeInfo[] typeInfoArray, AgentInfo[] agentInfoArray, boolean bl, boolean bl2) {
|
|
return this.db().synthesizeType(bTypeSpec, string, typeInfo, typeInfoArray, agentInfoArray, bl, bl2);
|
|
}
|
|
|
|
public final BModule synthesizeModule(String string, Version version, String string2, Version version2, String string3) {
|
|
return this.db().synthesizeModule(string, version, string2, version2, string3);
|
|
}
|
|
|
|
final RegistryDatabase db() {
|
|
if (this.db == null) {
|
|
try {
|
|
long l = System.currentTimeMillis();
|
|
this.db = new RegistryDatabase();
|
|
InputStream inputStream = Nre.bootEnv.isRemote() ? Nre.bootEnv.read(this.dbRemote()) : new BufferedInputStream(new FileInputStream(this.dbFile()));
|
|
this.db.read(inputStream);
|
|
long l2 = System.currentTimeMillis();
|
|
log.message("Loaded [" + (l2 - l) + "ms]");
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new RegistryException("Cannot load registry", throwable);
|
|
}
|
|
}
|
|
return this.db;
|
|
}
|
|
|
|
public final boolean isRegistryUpToDate() {
|
|
if (Nre.bootEnv.isRemote()) {
|
|
return true;
|
|
}
|
|
if (forceRebuild) {
|
|
log.message("Force rebuild");
|
|
return false;
|
|
}
|
|
if (this.dummyFile().exists()) {
|
|
log.message("*** No Rebuild ***");
|
|
return true;
|
|
}
|
|
long l = System.currentTimeMillis();
|
|
try {
|
|
File file = this.chkFile();
|
|
if (!file.exists()) {
|
|
throw new RegistryException("Missing \"" + file + '\"');
|
|
}
|
|
RegistryChecksum registryChecksum = new RegistryChecksum();
|
|
registryChecksum.read(file);
|
|
File file2 = new File(Nre.bajaHome, "modules");
|
|
File[] fileArray = file2.listFiles();
|
|
int n = 0;
|
|
while (n < fileArray.length) {
|
|
registryChecksum.checkUpToDate(fileArray[n]);
|
|
++n;
|
|
}
|
|
if (registryChecksum.modules.size() > 0) {
|
|
String string = ((RegistryChecksum.ModuleSnapshot)registryChecksum.modules.values().toArray()[0]).name;
|
|
throw new RegistryException("Module removed \"" + string + '\"');
|
|
}
|
|
}
|
|
catch (RegistryException registryException) {
|
|
log.message("Out-of-date: " + registryException.getMessage());
|
|
return false;
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.message("Out-of-date", throwable);
|
|
return false;
|
|
}
|
|
long l2 = System.currentTimeMillis();
|
|
log.message("Up-to-date [" + (l2 - l) + "ms]");
|
|
return true;
|
|
}
|
|
|
|
public final void rebuild() {
|
|
try {
|
|
log.message("Rebuilding registry...");
|
|
long l = System.currentTimeMillis();
|
|
File file = this.dummyFile();
|
|
boolean bl = file.exists();
|
|
int n = Builder.rebuild(this);
|
|
TypeInfo[] typeInfoArray = this.getConcreteTypes(BObject.TYPE.getTypeInfo());
|
|
int n2 = 0;
|
|
while (n2 < typeInfoArray.length) {
|
|
NTypeInfo nTypeInfo = (NTypeInfo)typeInfoArray[n2];
|
|
if (nTypeInfo.agentOn.length > 0 && !nTypeInfo.is(BIAgent.TYPE)) {
|
|
log.warning(nTypeInfo.getTypeSpec() + " declares itself as an agent, but does not implement BIAgent.");
|
|
}
|
|
++n2;
|
|
}
|
|
if (bl) {
|
|
PrintWriter printWriter = new PrintWriter(new FileWriter(file));
|
|
printWriter.write("no-rebuild.dummy " + new Date());
|
|
printWriter.close();
|
|
}
|
|
long l2 = System.currentTimeMillis();
|
|
log.message("Rebuilt: " + n + " types [" + (l2 - l) + "ms]");
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot rebuild", throwable);
|
|
}
|
|
}
|
|
|
|
public final void syncModules() {
|
|
if (Nre.bootEnv.isRemote()) {
|
|
return;
|
|
}
|
|
if (this.db == null) {
|
|
throw new IllegalStateException("Can't syncModules() on uninitialized registry");
|
|
}
|
|
Builder.syncFiles(this);
|
|
}
|
|
|
|
public final void loadModule(String string) throws Exception {
|
|
if (Nre.bootEnv.isRemote()) {
|
|
return;
|
|
}
|
|
if (this.db == null) {
|
|
throw new IllegalStateException("Can't loadModule(" + string + ") on uninitialized registry");
|
|
}
|
|
Builder.loadModule(this, string);
|
|
}
|
|
|
|
public final void unloadModule(String string) throws Exception {
|
|
if (Nre.bootEnv.isRemote()) {
|
|
return;
|
|
}
|
|
if (this.db == null) {
|
|
throw new IllegalStateException("Can't unloadModule(" + string + ") on uninitialized registry");
|
|
}
|
|
Builder.unloadModule(this, string);
|
|
}
|
|
|
|
public final void reloadModule(String string) throws Exception {
|
|
if (Nre.bootEnv.isRemote()) {
|
|
return;
|
|
}
|
|
if (this.db == null) {
|
|
throw new IllegalStateException("Can't reloadModule(" + string + ") on uninitialized registry");
|
|
}
|
|
Builder.reloadModule(this, string);
|
|
}
|
|
|
|
public final void postInit() {
|
|
if (!this.isRegistryUpToDate()) {
|
|
this.rebuild();
|
|
}
|
|
try {
|
|
this.checkNSedona();
|
|
}
|
|
catch (RegistryException registryException) {
|
|
((NRegistryTypeResolver)this.typeResolver).registryException = new RegistryException(registryException.getMessage());
|
|
this.invalidModules = new String[]{((NRegistryTypeResolver)this.typeResolver).invalidModuleName};
|
|
}
|
|
Nre.spySysManagers.add("registryManager", new Debug.SummaryPage());
|
|
}
|
|
|
|
public final String[] getInvalidModules() {
|
|
return this.invalidModules;
|
|
}
|
|
|
|
private final void checkNSedona() throws RegistryException {
|
|
Object object;
|
|
try {
|
|
((NRegistryTypeResolver)this.typeResolver).invalidModuleName = "nsedona";
|
|
object = this.getModule("nsedona");
|
|
String string = "nsedona " + object.getVendorVersion() + " not supported: ";
|
|
if (object.getVendorVersion().compareTo(new Version("1.1")) < 0) {
|
|
throw new RegistryException(string + "baja " + this.getModule("baja").getVendorVersion());
|
|
}
|
|
try {
|
|
this.getType("nsedona:DaspTunnel");
|
|
}
|
|
catch (TypeNotFoundException typeNotFoundException) {
|
|
throw new RegistryException(string + "[0]");
|
|
}
|
|
try {
|
|
this.getType("nsedona:SedonaNetwork");
|
|
throw new RegistryException(string + "[1]");
|
|
}
|
|
catch (TypeNotFoundException typeNotFoundException) {
|
|
}
|
|
}
|
|
catch (ModuleNotFoundException moduleNotFoundException) {}
|
|
object = this.getTypes();
|
|
int n = 0;
|
|
while (n < ((TypeInfo[])object).length) {
|
|
String string = object[n].getTypeClassName();
|
|
if (string.startsWith("javax.baja.sedona.driver.") || string.startsWith("com.tridium.sedona.")) {
|
|
((NRegistryTypeResolver)this.typeResolver).invalidModuleName = object[n].getModuleName();
|
|
throw new RegistryException(object[n] + ": [2]");
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
public final File dir() {
|
|
return new File(Nre.bajaHome, "registry");
|
|
}
|
|
|
|
public final File dbFile() {
|
|
return new File(this.dir(), "registry.db");
|
|
}
|
|
|
|
public final String dbRemote() {
|
|
return "/registry/registry.db";
|
|
}
|
|
|
|
public final File chkFile() {
|
|
return new File(this.dir(), "registry.chk");
|
|
}
|
|
|
|
public final File dummyFile() {
|
|
return new File(this.dir(), "no-rebuild.dummy");
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.typeResolver = new NRegistryTypeResolver();
|
|
this.invalidModules = null;
|
|
}
|
|
|
|
public NRegistry() {
|
|
this.this();
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
private static class NRegistryTypeResolver
|
|
extends ValueDocDecoder.BogTypeResolver {
|
|
String invalidModuleName;
|
|
RegistryException registryException;
|
|
|
|
public final BModule loadModule(ValueDocDecoder valueDocDecoder, BComplex bComplex, String string, String string2, String string3) {
|
|
if (this.registryException != null && this.invalidModuleName != null) {
|
|
String string4 = null;
|
|
try {
|
|
int n = string2.indexOf(61);
|
|
string4 = string2.substring(n + 1).trim();
|
|
}
|
|
catch (Exception exception) {
|
|
super.loadModule(valueDocDecoder, bComplex, string, string2, string3);
|
|
throw new XException("Invalid module attribute '" + string2 + '\'', ((ValueDocDecoder.BogDecoderPlugin)valueDocDecoder.getPlugin()).getXmlParser());
|
|
}
|
|
if (string4.equals(this.invalidModuleName)) {
|
|
throw this.registryException;
|
|
}
|
|
}
|
|
return super.loadModule(valueDocDecoder, bComplex, string, string2, string3);
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.invalidModuleName = null;
|
|
this.registryException = null;
|
|
}
|
|
|
|
private NRegistryTypeResolver() {
|
|
this.this();
|
|
}
|
|
}
|
|
}
|
|
|