748 lines
27 KiB
Java
748 lines
27 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.tridium.sys.registry.NModuleInfo
|
|
* javax.baja.file.BFileSystem
|
|
* javax.baja.file.BIFile
|
|
* javax.baja.file.FilePath
|
|
* javax.baja.file.FileUtil
|
|
* javax.baja.naming.SlotPath
|
|
* javax.baja.sys.BAbsTime
|
|
* javax.baja.sys.BIcon
|
|
* javax.baja.sys.BValue
|
|
* javax.baja.sys.BVector
|
|
* javax.baja.sys.BajaRuntimeException
|
|
* javax.baja.sys.Context
|
|
* javax.baja.sys.LocalizableRuntimeException
|
|
* javax.baja.sys.Property
|
|
* javax.baja.sys.Sys
|
|
* javax.baja.sys.Type
|
|
* javax.baja.xml.XElem
|
|
*/
|
|
package com.tridium.install.part;
|
|
|
|
import com.tridium.install.BDaemonPlatform;
|
|
import com.tridium.install.BDependency;
|
|
import com.tridium.install.BRemoteDaemonPlatform;
|
|
import com.tridium.install.BVersion;
|
|
import com.tridium.install.ClassCondenser;
|
|
import com.tridium.install.installable.BInstallable;
|
|
import com.tridium.install.installable.BModuleInstallable;
|
|
import com.tridium.install.installable.ModuleManifest;
|
|
import com.tridium.install.part.BModuleStatus;
|
|
import com.tridium.install.part.BPart;
|
|
import com.tridium.platform.daemon.BDaemonSession;
|
|
import com.tridium.platform.daemon.BModuleContent;
|
|
import com.tridium.platform.daemon.DaemonFileUtil;
|
|
import com.tridium.platform.daemon.message.FileTransferMessageElement;
|
|
import com.tridium.sys.registry.NModuleInfo;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
import java.util.zip.ZipEntry;
|
|
import java.util.zip.ZipInputStream;
|
|
import java.util.zip.ZipOutputStream;
|
|
import javax.baja.file.BFileSystem;
|
|
import javax.baja.file.BIFile;
|
|
import javax.baja.file.FilePath;
|
|
import javax.baja.file.FileUtil;
|
|
import javax.baja.naming.SlotPath;
|
|
import javax.baja.platform.install.BVersionRelation;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BIcon;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.BVector;
|
|
import javax.baja.sys.BajaRuntimeException;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.LocalizableRuntimeException;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.xml.XElem;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BModulePart
|
|
extends BPart {
|
|
public static final Property status = BModulePart.newProperty((int)1, (BValue)BModuleStatus.ok, null);
|
|
public static final Property buildDate = BModulePart.newProperty((int)1, (String)"", null);
|
|
public static final Property buildAbsTime = BModulePart.newProperty((int)1, (BValue)BAbsTime.NULL, null);
|
|
public static final Property buildHost = BModulePart.newProperty((int)1, (String)"", null);
|
|
public static final Property archiveDate = BModulePart.newProperty((int)1, (String)"", null);
|
|
public static final Property archiveHost = BModulePart.newProperty((int)1, (String)"", null);
|
|
public static final Property archiveContent = BModulePart.newProperty((int)1, (BValue)BModuleContent.doc, null);
|
|
public static final Property preferredSymbol = BModulePart.newProperty((int)1, (String)"", null);
|
|
public static final Property fileSize = BModulePart.newProperty((int)1, (int)-1, null);
|
|
public static final Property synthetic = BModulePart.newProperty((int)1, (boolean)false, null);
|
|
public static final Property exclusions = BModulePart.newProperty((int)1, (BValue)new BVector(), null);
|
|
public static final Property isNre = BModulePart.newProperty((int)1, (boolean)true, null);
|
|
public static final Property isInstallable = BModulePart.newProperty((int)1, (boolean)true, null);
|
|
public static final Type TYPE;
|
|
public static final FilePath MODULES_PATH;
|
|
public static final FilePath LIB_PATH;
|
|
private static final BIcon icon;
|
|
private BIFile file;
|
|
private boolean localInstance;
|
|
private boolean summaryInitialized;
|
|
private boolean dependsInitialized;
|
|
private ModuleManifest manifest;
|
|
static /* synthetic */ Class class$com$tridium$install$part$BModulePart;
|
|
|
|
public BModuleStatus getStatus() {
|
|
return (BModuleStatus)this.get(status);
|
|
}
|
|
|
|
public void setStatus(BModuleStatus bModuleStatus) {
|
|
this.set(status, (BValue)bModuleStatus, null);
|
|
}
|
|
|
|
public String getBuildDate() {
|
|
return this.getString(buildDate);
|
|
}
|
|
|
|
public void setBuildDate(String string) {
|
|
this.setString(buildDate, string, null);
|
|
}
|
|
|
|
public BAbsTime getBuildAbsTime() {
|
|
return (BAbsTime)this.get(buildAbsTime);
|
|
}
|
|
|
|
public void setBuildAbsTime(BAbsTime bAbsTime) {
|
|
this.set(buildAbsTime, (BValue)bAbsTime, null);
|
|
}
|
|
|
|
public String getBuildHost() {
|
|
return this.getString(buildHost);
|
|
}
|
|
|
|
public void setBuildHost(String string) {
|
|
this.setString(buildHost, string, null);
|
|
}
|
|
|
|
public String getArchiveDate() {
|
|
return this.getString(archiveDate);
|
|
}
|
|
|
|
public void setArchiveDate(String string) {
|
|
this.setString(archiveDate, string, null);
|
|
}
|
|
|
|
public String getArchiveHost() {
|
|
return this.getString(archiveHost);
|
|
}
|
|
|
|
public void setArchiveHost(String string) {
|
|
this.setString(archiveHost, string, null);
|
|
}
|
|
|
|
public BModuleContent getArchiveContent() {
|
|
return (BModuleContent)this.get(archiveContent);
|
|
}
|
|
|
|
public void setArchiveContent(BModuleContent bModuleContent) {
|
|
this.set(archiveContent, (BValue)bModuleContent, null);
|
|
}
|
|
|
|
public String getPreferredSymbol() {
|
|
return this.getString(preferredSymbol);
|
|
}
|
|
|
|
public void setPreferredSymbol(String string) {
|
|
this.setString(preferredSymbol, string, null);
|
|
}
|
|
|
|
public long getFileSize() {
|
|
return this.getLong(fileSize);
|
|
}
|
|
|
|
public void setFileSize(long l) {
|
|
this.setLong(fileSize, l, null);
|
|
}
|
|
|
|
public boolean getSynthetic() {
|
|
return this.getBoolean(synthetic);
|
|
}
|
|
|
|
public void setSynthetic(boolean bl) {
|
|
this.setBoolean(synthetic, bl, null);
|
|
}
|
|
|
|
public BVector getExclusions() {
|
|
return (BVector)this.get(exclusions);
|
|
}
|
|
|
|
public void setExclusions(BVector bVector) {
|
|
this.set(exclusions, (BValue)bVector, null);
|
|
}
|
|
|
|
public boolean getIsNre() {
|
|
return this.getBoolean(isNre);
|
|
}
|
|
|
|
public void setIsNre(boolean bl) {
|
|
this.setBoolean(isNre, bl, null);
|
|
}
|
|
|
|
public boolean getIsInstallable() {
|
|
return this.getBoolean(isInstallable);
|
|
}
|
|
|
|
public void setIsInstallable(boolean bl) {
|
|
this.setBoolean(isInstallable, bl, null);
|
|
}
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
public static BModulePart make(BIFile bIFile) {
|
|
BModuleInstallable bModuleInstallable = BModuleInstallable.make(bIFile, true);
|
|
return bModuleInstallable == null ? null : bModuleInstallable.getModulePart();
|
|
}
|
|
|
|
public static BModulePart make(BIFile bIFile, boolean bl) {
|
|
BModuleInstallable bModuleInstallable = BModuleInstallable.make(bIFile, bl);
|
|
return bModuleInstallable == null ? null : bModuleInstallable.getModulePart();
|
|
}
|
|
|
|
public static BModulePart make(String string, XElem xElem) {
|
|
if (string == null) {
|
|
return null;
|
|
}
|
|
BModulePart bModulePart = new BModulePart();
|
|
bModulePart.setPartName(string);
|
|
if (xElem == null) {
|
|
bModulePart.setStatus(BModuleStatus.nomanifest);
|
|
} else {
|
|
bModulePart.loadManifest(xElem);
|
|
}
|
|
return bModulePart;
|
|
}
|
|
|
|
public static BModulePart make(BIFile bIFile, BInstallable bInstallable) {
|
|
try {
|
|
InputStream inputStream = DaemonFileUtil.getZipStream(bIFile, new FilePath("META-INF/module.xml"));
|
|
if (inputStream == null) {
|
|
inputStream = DaemonFileUtil.getZipStream(bIFile, new FilePath("meta-inf/module.xml"));
|
|
}
|
|
if (inputStream == null) {
|
|
inputStream = DaemonFileUtil.getZipStream(bIFile, new FilePath("META-INF/module.xml"));
|
|
}
|
|
if (inputStream == null) {
|
|
return null;
|
|
}
|
|
return new BModulePart(bIFile, inputStream, bInstallable);
|
|
}
|
|
catch (IOException iOException) {
|
|
throw new LocalizableRuntimeException("platform", "ModulePart.exception.manifestRead", new Object[]{bIFile.getFilePath()}, (Throwable)iOException);
|
|
}
|
|
}
|
|
|
|
public boolean meets(BDependency bDependency) {
|
|
this.initSummary();
|
|
boolean bl = false;
|
|
if (bDependency.getPartType().is(TYPE) && this.getVersion().meets(bDependency) && this.matchesName(bDependency.getPartName())) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
public boolean isInstallable() {
|
|
return true;
|
|
}
|
|
|
|
public BVector getDependencies() {
|
|
if (!this.dependsInitialized) {
|
|
this.init();
|
|
}
|
|
return super.getDependencies();
|
|
}
|
|
|
|
public void initSummary() {
|
|
if (!this.summaryInitialized) {
|
|
this.init();
|
|
}
|
|
}
|
|
|
|
public void init() {
|
|
if (this.manifest != null || !this.localInstance || !this.getInstallable().getIsValid()) {
|
|
return;
|
|
}
|
|
if (this.file != null) {
|
|
try {
|
|
InputStream inputStream = DaemonFileUtil.getZipStream(this.file, new FilePath("META-INF/module.xml"));
|
|
if (inputStream == null) {
|
|
inputStream = DaemonFileUtil.getZipStream(this.file, new FilePath("meta-inf/module.xml"));
|
|
}
|
|
if (inputStream == null) {
|
|
inputStream = DaemonFileUtil.getZipStream(this.file, new FilePath("META-INF/module.xml"));
|
|
}
|
|
this.loadManifest(inputStream);
|
|
}
|
|
catch (RuntimeException runtimeException) {
|
|
throw runtimeException;
|
|
}
|
|
catch (Exception exception) {
|
|
throw new BajaRuntimeException((Throwable)exception);
|
|
}
|
|
}
|
|
}
|
|
|
|
public BDependency getDependency(String string) {
|
|
return (BDependency)this.getDependencies().get(SlotPath.escape((String)string));
|
|
}
|
|
|
|
public FilePath getDestinationPath() {
|
|
if (!this.getSynthetic()) {
|
|
return MODULES_PATH.merge(this.getPartName() + ".jar");
|
|
}
|
|
return MODULES_PATH.merge(this.getPartName() + ".sjar");
|
|
}
|
|
|
|
public BIcon getIcon() {
|
|
return icon;
|
|
}
|
|
|
|
public InputStream getInputStream() {
|
|
if (!this.localInstance) {
|
|
throw new IllegalStateException("illegal call on proxy instance of BModulePart");
|
|
}
|
|
try {
|
|
return this.file.getInputStream();
|
|
}
|
|
catch (IOException iOException) {
|
|
throw new LocalizableRuntimeException("platform", "LocalModulePart.exception.notFound", new Object[]{this.file.getFilePath()}, (Throwable)iOException);
|
|
}
|
|
}
|
|
|
|
public ModuleManifest getManifest() {
|
|
if (!this.localInstance) {
|
|
throw new IllegalStateException("illegal call on proxy instance of BModulePart");
|
|
}
|
|
this.init();
|
|
return this.manifest;
|
|
}
|
|
|
|
public BVersion getVersionRequired(String string) {
|
|
BDependency bDependency = this.getDependency(string);
|
|
return bDependency == null ? BVersion.ZERO : bDependency.getVersion();
|
|
}
|
|
|
|
public Set getRequiredModuleNames() {
|
|
Property[] propertyArray = this.getDependencies().getPropertiesArray();
|
|
HashSet<String> hashSet = new HashSet<String>();
|
|
int n = 0;
|
|
while (n < propertyArray.length) {
|
|
hashSet.add(propertyArray[n].getName());
|
|
++n;
|
|
}
|
|
return hashSet;
|
|
}
|
|
|
|
public boolean isUpgradeFor(BModulePart bModulePart) {
|
|
this.initSummary();
|
|
if (bModulePart.getVersion().meetsVersionRequirement(this.getVersion(), BVersionRelation.minimum)) {
|
|
return bModulePart.getBuildAbsTime() != null && this.getBuildAbsTime() != null && this.getBuildAbsTime().compareTo((Object)bModulePart.getBuildAbsTime()) > 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public boolean isUpdateFor(BModulePart bModulePart) {
|
|
return this.isUpdateFor(bModulePart, null);
|
|
}
|
|
|
|
public boolean isUpdateFor(BModulePart bModulePart, BDaemonPlatform bDaemonPlatform) {
|
|
this.initSummary();
|
|
if (bDaemonPlatform != null && bDaemonPlatform.getModuleContent() != bModulePart.getArchiveContent()) {
|
|
return true;
|
|
}
|
|
if (bModulePart.getVersion().equivalent((Object)this.getVersion())) {
|
|
return bModulePart.getBuildAbsTime() == null || this.getBuildAbsTime() == null || !this.getBuildAbsTime().equals((Object)bModulePart.getBuildAbsTime());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public String toString(Context context) {
|
|
return "Module: " + this.getPartName() + ' ' + (Object)((Object)this.getVersion());
|
|
}
|
|
|
|
public void writePackageArchive(BDaemonPlatform bDaemonPlatform, ZipOutputStream zipOutputStream) throws Exception {
|
|
this.writePackageArchive(bDaemonPlatform.getModuleContent(), bDaemonPlatform.getStripLineNumbers(), zipOutputStream);
|
|
}
|
|
|
|
public void writePackageArchive(BModuleContent bModuleContent, boolean bl, ZipOutputStream zipOutputStream) throws Exception {
|
|
if (!this.localInstance) {
|
|
throw new IllegalStateException("illegal call on proxy instance of BModulePart");
|
|
}
|
|
this.init();
|
|
try {
|
|
ZipEntry zipEntry;
|
|
ZipInputStream zipInputStream = new ZipInputStream(this.getInputStream());
|
|
ClassCondenser classCondenser = new ClassCondenser();
|
|
while ((zipEntry = zipInputStream.getNextEntry()) != null) {
|
|
Object object;
|
|
if (zipEntry.getName().equalsIgnoreCase("meta-inf/module.xml")) {
|
|
object = new ByteArrayOutputStream();
|
|
this.getManifest().write(bModuleContent, (OutputStream)object);
|
|
ZipEntry zipEntry2 = new ZipEntry(zipEntry.getName());
|
|
zipEntry2.setSize(((ByteArrayOutputStream)object).size());
|
|
zipEntry2.setTime(System.currentTimeMillis());
|
|
zipOutputStream.putNextEntry(zipEntry2);
|
|
zipOutputStream.write(((ByteArrayOutputStream)object).toByteArray(), 0, ((ByteArrayOutputStream)object).size());
|
|
zipOutputStream.closeEntry();
|
|
continue;
|
|
}
|
|
if (!this.getManifest().includePath(this.getDirectoryName(zipEntry), bModuleContent)) continue;
|
|
if (bl && zipEntry.getName().endsWith(".class")) {
|
|
zipOutputStream.putNextEntry(new ZipEntry(zipEntry.getName()));
|
|
classCondenser.condense(zipInputStream, zipOutputStream, false);
|
|
} else {
|
|
zipOutputStream.putNextEntry(new ZipEntry(zipEntry));
|
|
object = new byte[65000];
|
|
int n = zipInputStream.read((byte[])object);
|
|
while (n >= 0) {
|
|
zipOutputStream.write((byte[])object, 0, n);
|
|
n = zipInputStream.read((byte[])object);
|
|
}
|
|
}
|
|
zipOutputStream.closeEntry();
|
|
}
|
|
zipInputStream.close();
|
|
}
|
|
catch (IOException iOException) {
|
|
throw new LocalizableRuntimeException("platform", "ModulePart.exception.writePackageArchive", new Object[]{this.getPartName()}, (Throwable)iOException);
|
|
}
|
|
}
|
|
|
|
private final void loadManifest(XElem xElem) {
|
|
this.loadManifest(ModuleManifest.make(xElem));
|
|
}
|
|
|
|
private final void loadManifest(InputStream inputStream) {
|
|
this.loadManifest(inputStream, true);
|
|
}
|
|
|
|
private final void loadManifest(InputStream inputStream, boolean bl) {
|
|
this.loadManifest(ModuleManifest.make(inputStream, bl));
|
|
}
|
|
|
|
private final void loadManifest(ModuleManifest moduleManifest) {
|
|
this.manifest = moduleManifest;
|
|
this.setStatus(moduleManifest.getStatus());
|
|
if (!this.summaryInitialized) {
|
|
this.setPartName(moduleManifest.getName());
|
|
this.setBuildAbsTime(moduleManifest.getBuildAbsTime());
|
|
this.setVersion((BVersion)moduleManifest.getVersion().newCopy());
|
|
this.setDescription(moduleManifest.getDescription());
|
|
this.setArchiveContent(moduleManifest.getModuleContent());
|
|
this.summaryInitialized = true;
|
|
}
|
|
if (!this.dependsInitialized) {
|
|
BVector bVector = (BVector)this.get(dependencies);
|
|
bVector.removeAll();
|
|
BDependency[] bDependencyArray = moduleManifest.getDependencies();
|
|
int n = 0;
|
|
while (n < bDependencyArray.length) {
|
|
bVector.add(SlotPath.escape((String)bDependencyArray[n].getPartName()), bDependencyArray[n].newCopy());
|
|
++n;
|
|
}
|
|
BDependency[] bDependencyArray2 = moduleManifest.getExclusions();
|
|
bVector = (BVector)this.get(exclusions);
|
|
bVector.removeAll();
|
|
int n2 = 0;
|
|
while (n2 < bDependencyArray2.length) {
|
|
bVector.add("excl?", (BValue)bDependencyArray2[n2]);
|
|
++n2;
|
|
}
|
|
this.dependsInitialized = true;
|
|
}
|
|
this.setBuildDate(moduleManifest.getBuildDate());
|
|
this.setBuildHost(moduleManifest.getBuildHost());
|
|
this.setArchiveDate(moduleManifest.getArchiveDate());
|
|
this.setArchiveHost(moduleManifest.getArchiveHost());
|
|
this.setPreferredSymbol(moduleManifest.getPreferredSymbol());
|
|
this.setIsNre(moduleManifest.isNreModule());
|
|
this.setIsInstallable(moduleManifest.isInstallable());
|
|
}
|
|
|
|
private final String getDirectoryName(ZipEntry zipEntry) {
|
|
if (!this.localInstance) {
|
|
throw new IllegalStateException("illegal call on proxy instance of BModulePart");
|
|
}
|
|
if (zipEntry.isDirectory()) {
|
|
return zipEntry.getName();
|
|
}
|
|
int n = zipEntry.getName().lastIndexOf(47);
|
|
if (n < 0) {
|
|
return "";
|
|
}
|
|
return zipEntry.getName().substring(0, n);
|
|
}
|
|
|
|
public long getFilteredFileSize(BDaemonPlatform bDaemonPlatform) {
|
|
return this.getFilteredFileSize(bDaemonPlatform.getModuleContent(), bDaemonPlatform.getStripLineNumbers());
|
|
}
|
|
|
|
public long getFilteredFileSize(BModuleContent bModuleContent, boolean bl) {
|
|
if (this.localInstance && bModuleContent != BModuleContent.doc) {
|
|
try {
|
|
ByteCounter byteCounter = new ByteCounter();
|
|
ZipOutputStream zipOutputStream = new ZipOutputStream(byteCounter);
|
|
this.writePackageArchive(bModuleContent, bl, zipOutputStream);
|
|
zipOutputStream.closeEntry();
|
|
zipOutputStream.flush();
|
|
zipOutputStream.close();
|
|
byteCounter.flush();
|
|
byteCounter.close();
|
|
return byteCounter.size();
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
}
|
|
}
|
|
return this.getInstallable().getInstallableFileSize();
|
|
}
|
|
|
|
public boolean canMakeTransferElements() {
|
|
return this.localInstance;
|
|
}
|
|
|
|
public FileTransferMessageElement makeTransferElement(BDaemonPlatform bDaemonPlatform) {
|
|
if (!this.localInstance) {
|
|
throw new IllegalStateException("illegal call on proxy instance of BModuleInstallable");
|
|
}
|
|
return new ModuleFileTransferElement(this, bDaemonPlatform.getDaemonSession());
|
|
}
|
|
|
|
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.file = null;
|
|
this.localInstance = false;
|
|
this.summaryInitialized = false;
|
|
this.dependsInitialized = false;
|
|
this.manifest = null;
|
|
}
|
|
|
|
public BModulePart() {
|
|
this.this();
|
|
}
|
|
|
|
public BModulePart(BIFile bIFile, NModuleInfo nModuleInfo, BInstallable bInstallable) {
|
|
this.this();
|
|
this.file = bIFile;
|
|
this.localInstance = true;
|
|
this.setInstallable(bInstallable);
|
|
this.setStatus(BModuleStatus.ok);
|
|
this.setFileSize(bIFile.getSize());
|
|
this.setPartName(nModuleInfo.getModuleName());
|
|
this.setBuildAbsTime(BAbsTime.make((long)nModuleInfo.getBuildTime()));
|
|
this.getVersion().setVendor(nModuleInfo.getVendor());
|
|
this.getVersion().setVendorVersion(nModuleInfo.getVendorVersion());
|
|
this.setDescription(nModuleInfo.getDescription());
|
|
this.setArchiveContent(BModuleContent.make(nModuleInfo.getModuleContent()));
|
|
this.setSynthetic(bIFile.getExtension().equals("sjar"));
|
|
this.summaryInitialized = true;
|
|
}
|
|
|
|
public BModulePart(BIFile bIFile, InputStream inputStream, BInstallable bInstallable) {
|
|
this(bIFile, inputStream, bInstallable, true);
|
|
}
|
|
|
|
public BModulePart(BIFile bIFile, InputStream inputStream, BInstallable bInstallable, boolean bl) {
|
|
this.this();
|
|
this.file = bIFile;
|
|
this.localInstance = true;
|
|
this.setInstallable(bInstallable);
|
|
if (inputStream == null) {
|
|
this.setStatus(BModuleStatus.nomanifest);
|
|
if (bInstallable != null) {
|
|
bInstallable.setIsValid(false);
|
|
}
|
|
} else {
|
|
this.setStatus(BModuleStatus.ok);
|
|
}
|
|
this.setFileSize(bIFile.getSize());
|
|
if (bIFile.getExtension().equals("jar")) {
|
|
this.setPartName(bIFile.getFileName().substring(0, bIFile.getFileName().length() - 4));
|
|
} else if (bIFile.getExtension().equals("sjar")) {
|
|
this.setPartName(bIFile.getFileName().substring(0, bIFile.getFileName().length() - 5));
|
|
this.setSynthetic(true);
|
|
}
|
|
if (inputStream != null) {
|
|
this.loadManifest(inputStream, bl);
|
|
}
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$com$tridium$install$part$BModulePart;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$install$part$BModulePart = BModulePart.class("[Lcom.tridium.install.part.BModulePart;", false);
|
|
}
|
|
TYPE = Sys.loadType((Class)clazz);
|
|
MODULES_PATH = new FilePath("!modules");
|
|
LIB_PATH = new FilePath("!lib");
|
|
icon = BPart.getPartTypeIcon(TYPE);
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
private class ByteCounter
|
|
extends OutputStream {
|
|
private long size;
|
|
|
|
public void write(byte[] byArray) throws IOException {
|
|
this.size += (long)byArray.length;
|
|
}
|
|
|
|
public void write(byte[] byArray, int n, int n2) {
|
|
this.size += (long)n2;
|
|
}
|
|
|
|
public void write(int n) {
|
|
++this.size;
|
|
}
|
|
|
|
public long size() {
|
|
return this.size;
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.size = 0L;
|
|
}
|
|
|
|
private ByteCounter() {
|
|
this.this();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
private static class ModuleFileTransferElement
|
|
extends FileTransferMessageElement {
|
|
private static final BIcon icon = BIcon.std((String)"module.png");
|
|
private BModulePart sourceModule;
|
|
private BDaemonSession session;
|
|
private byte[] buf;
|
|
|
|
public InputStream getStream() throws IOException {
|
|
try {
|
|
if (this.modifyContents()) {
|
|
byte[] byArray = this.getModifiedBuf();
|
|
if ("true".equals(System.getProperty("niagara.install.copyProcessedModule", "false"))) {
|
|
BIFile bIFile = BFileSystem.INSTANCE.makeFile(new FilePath("!moduleCopies/" + this.sourceModule.getDestinationPath().getName()));
|
|
FileUtil.pipe((InputStream)new ByteArrayInputStream(byArray), (OutputStream)bIFile.getOutputStream());
|
|
}
|
|
return new ByteArrayInputStream(byArray);
|
|
}
|
|
return this.sourceModule.getInputStream();
|
|
}
|
|
catch (Exception exception) {
|
|
throw new LocalizableRuntimeException("platform", "ModuleFileTransferElement.exception.read", (Throwable)exception);
|
|
}
|
|
}
|
|
|
|
public long getSize() {
|
|
if (this.modifyContents()) {
|
|
return this.getModifiedBuf().length;
|
|
}
|
|
return this.sourceModule.getFileSize();
|
|
}
|
|
|
|
private final BDaemonPlatform getDaemonPlatform() {
|
|
try {
|
|
return BRemoteDaemonPlatform.make(this.session, null);
|
|
}
|
|
catch (RuntimeException runtimeException) {
|
|
throw runtimeException;
|
|
}
|
|
catch (Exception exception) {
|
|
throw new BajaRuntimeException((Throwable)exception);
|
|
}
|
|
}
|
|
|
|
private final boolean modifyContents() {
|
|
boolean bl = false;
|
|
if (this.getDaemonPlatform().getModuleContent() != BModuleContent.doc) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed back jump from a try to a catch block - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
private final byte[] getModifiedBuf() {
|
|
if (this.buf != null) return this.buf;
|
|
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
|
|
ZipOutputStream zipOutputStream = new ZipOutputStream(byteArrayOutputStream);
|
|
try {
|
|
try {
|
|
this.sourceModule.writePackageArchive(this.getDaemonPlatform(), zipOutputStream);
|
|
}
|
|
catch (Exception exception) {}
|
|
}
|
|
catch (Throwable throwable) {
|
|
Object var4_4 = null;
|
|
try {
|
|
zipOutputStream.closeEntry();
|
|
zipOutputStream.flush();
|
|
zipOutputStream.close();
|
|
throw throwable;
|
|
}
|
|
catch (Exception exception) {}
|
|
throw throwable;
|
|
}
|
|
{
|
|
Object var4_5 = null;
|
|
}
|
|
try {}
|
|
catch (Exception exception) {}
|
|
zipOutputStream.closeEntry();
|
|
zipOutputStream.flush();
|
|
zipOutputStream.close();
|
|
this.buf = byteArrayOutputStream.toByteArray();
|
|
return this.buf;
|
|
}
|
|
|
|
public BIcon getIcon() {
|
|
return icon;
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.buf = null;
|
|
}
|
|
|
|
public ModuleFileTransferElement(BModulePart bModulePart, BDaemonSession bDaemonSession) {
|
|
super(bModulePart.getDestinationPath(), bDaemonSession.getFileSpace());
|
|
this.this();
|
|
this.sourceModule = bModulePart;
|
|
this.session = bDaemonSession;
|
|
}
|
|
}
|
|
}
|
|
|