/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package flex2.tools.oem.internal;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import flash.localization.LocalizationManager;
import flash.localization.ResourceBundleLocalizer;
import flash.util.FileUtils;
import flash.util.Trace;
import flex2.compiler.CompilerAPI;
import flex2.compiler.CompilationUnit;
import flex2.compiler.CompilerSwcContext;
import flex2.compiler.Source;
import flex2.compiler.common.CompilerConfiguration;
import flex2.compiler.common.DefaultsConfigurator;
import flex2.compiler.config.CommandLineConfigurator;
import flex2.compiler.config.ConfigurationBuffer;
import flex2.compiler.config.ConfigurationException;
import flex2.compiler.config.FileConfigurator;
import flex2.compiler.config.SystemPropertyConfigurator;
import flex2.compiler.io.FileUtil;
import flex2.compiler.io.VirtualFile;
import flex2.compiler.swc.Swc;
import flex2.compiler.swc.SwcScript;
import flex2.compiler.util.CompilerControl;
import flex2.compiler.util.MimeMappings;
import flex2.compiler.util.QName;
import flex2.compiler.util.ThreadLocalToolkit;
import flex2.tools.CommandLineConfiguration;
import flex2.tools.CompcConfiguration;
import flex2.tools.Mxmlc;
import flex2.tools.ToolsConfiguration;
import flex2.tools.oem.*;
/**
* A collection of utility methods used by classes in flex2.tools.oem.
*
* @version 2.0.1
* @author Clement Wong
*/
public class OEMUtil
{
/**
*
*/
public static final LocalizationManager setupLocalizationManager()
{
LocalizationManager l10n = ThreadLocalToolkit.getLocalizationManager();
if (l10n == null)
{
// set up for localizing messages
l10n = new LocalizationManager();
l10n.addLocalizer(new ResourceBundleLocalizer());
ThreadLocalToolkit.setLocalizationManager(l10n);
}
return l10n;
}
/**
*
* @param logger
* @param mimeMappings
*/
public static final void init(Logger logger,
MimeMappings mimeMappings,
ProgressMeter meter,
PathResolver resolver,
CompilerControl cc)
{
CompilerAPI.useAS3();
CompilerAPI.usePathResolver(resolver != null ? new OEMPathResolver(resolver) : null);
setupLocalizationManager();
ThreadLocalToolkit.setLogger(new OEMLogAdapter(logger));
ThreadLocalToolkit.setMimeMappings(mimeMappings);
ThreadLocalToolkit.setProgressMeter(meter);
ThreadLocalToolkit.setCompilerControl(cc);
}
/**
*
*
*/
public static final void clean()
{
CompilerAPI.removePathResolver();
ThreadLocalToolkit.setLogger(null);
ThreadLocalToolkit.setLocalizationManager(null);
ThreadLocalToolkit.setMimeMappings(null);
ThreadLocalToolkit.setProgressMeter(null);
ThreadLocalToolkit.setCompilerControl(null);
ThreadLocalToolkit.setCompatibilityVersion(null);
}
/**
*
* @param in
* @return
* @throws IOException
*/
public static final String load(InputStream in, String cacheName) throws IOException
{
// grab the data and put it in a temp file...
File temp = null;
if (cacheName == null)
{
temp = FileUtil.createTempFile(in);
temp.deleteOnExit();
}
else
{
temp = FileUtil.openFile(cacheName);
FileUtil.writeBinaryFile(temp, in);
}
return FileUtil.getCanonicalPath(temp);
}
/**
*
* @param out
* @param cacheName
* @param data
* @return
* @throws IOException
*/
public static final long save(OutputStream out, String cacheName, ApplicationData data) throws IOException
{
if (cacheName == null)
{
// this will create a temp file and populate cacheName.
cacheName = load(new ByteArrayInputStream(new byte[0]), null);
}
// only save when there is something for us to save (i.e. data != null)
if (cacheName != null && data != null)
{
// delete the existing cache file
File dead = FileUtil.openFile(cacheName);
if (dead != null && dead.exists())
{
dead.delete();
}
RandomAccessFile cacheFile = null;
try
{
cacheFile = new RandomAccessFile(cacheName, "rw");
CompilerAPI.persistCompilationUnits(data.configuration, data.fileSpec, data.sourceList,
data.sourcePath, data.resources, data.bundlePath,
data.sources, data.units, data.checksum,
data.cmdChecksum, data.linkChecksum, data.swcChecksum,
data.swcDefSignatureChecksums, data.swcFileChecksums,
"", cacheFile);
}
finally
{
if (cacheFile != null) { try { cacheFile.close(); } catch (IOException ex) {} }
}
// write the data to the specified output stream
InputStream in = null;
try
{
in = new BufferedInputStream(new FileInputStream(cacheName));
FileUtil.streamOutput(in, out);
}
finally
{
if (in != null) { try { in.close(); } catch (IOException ex) {} }
}
return new File(cacheName).length();
}
else
{
return 0;
}
}
/**
*
* @param args
* @param logger
* @param mimeMappings
* @return
*/
public static final OEMConfiguration getApplicationConfiguration(String[] args, boolean keepLinkReport,
boolean keepSizeReport, Logger logger, PathResolver resolver,
MimeMappings mimeMappings)
{
return getApplicationConfiguration(args, keepLinkReport, keepSizeReport, logger, resolver, mimeMappings, true);
}
/**
*
* @param args
* @param logger
* @param mimeMappings
* @param processDefaults
* @return
*/
public static final OEMConfiguration getApplicationConfiguration(String[] args, boolean keepLinkReport, boolean keepSizeReport,
Logger logger, PathResolver resolver, MimeMappings mimeMappings,
boolean processDefaults)
{
if (!processDefaults)
{
return new OEMConfiguration(null, null);
}
// expect args to have --file-specs because we need it to find app-specific-config.xml.
OEMUtil.init(logger, mimeMappings, null, resolver, null);
try
{
ConfigurationBuffer cfgbuf = new ConfigurationBuffer(ApplicationCompilerConfiguration.class,
ApplicationCompilerConfiguration.getAliases());
cfgbuf.setDefaultVar(Mxmlc.FILE_SPECS);
DefaultsConfigurator.loadDefaults(cfgbuf);
Object obj = Mxmlc.processConfiguration(ThreadLocalToolkit.getLocalizationManager(),
"oem",
args,
cfgbuf,
ApplicationCompilerConfiguration.class,
Mxmlc.FILE_SPECS);
ApplicationCompilerConfiguration configuration = (ApplicationCompilerConfiguration) obj;
configuration.keepLinkReport(keepLinkReport);
configuration.keepSizeReport(keepSizeReport);
return new OEMConfiguration(cfgbuf, configuration);
}
catch (ConfigurationException ex)
{
Mxmlc.processConfigurationException(ex, "oem");
return null;
}
catch (IOException ex)
{
ThreadLocalToolkit.logError(ex.getMessage());
return null;
}
catch (RuntimeException ex)
{
Class c;
try
{
c = Class.forName("flex.messaging.config.ConfigurationException");
if (c.isInstance(ex))
{
ThreadLocalToolkit.logError(ex.getMessage());
}
}
catch (ClassNotFoundException ex2)
{
}
return null;
}
}
/**
*
* @param args
* @param logger
* @param mimeMappings
* @return
*/
public static final OEMConfiguration getLibraryConfiguration(String[] args, boolean keepLinkReport,
boolean keepSizeReport, Logger logger, PathResolver resolver,
MimeMappings mimeMappings)
{
return getLibraryConfiguration(args, keepLinkReport, keepSizeReport, logger, resolver, mimeMappings, true);
}
/**
*
* @param args
* @param logger
* @param mimeMappings
* @param processDefaults
* @return
*/
public static final OEMConfiguration getLibraryConfiguration(String[] args, boolean keepLinkReport,
boolean keepSizeReport, Logger logger,
PathResolver resolver, MimeMappings mimeMappings,
boolean processDefaults)
{
if (!processDefaults)
{
return new OEMConfiguration(null, null);
}
// expect no SWC inputs in args.
OEMUtil.init(logger, mimeMappings, null, resolver, null);
try
{
ConfigurationBuffer cfgbuf = new ConfigurationBuffer(LibraryCompilerConfiguration.class,
LibraryCompilerConfiguration.getAliases());
DefaultsConfigurator.loadOEMCompcDefaults( cfgbuf );
Object obj = Mxmlc.processConfiguration(ThreadLocalToolkit.getLocalizationManager(),
"oem",
args,
cfgbuf,
LibraryCompilerConfiguration.class,
null);
LibraryCompilerConfiguration configuration = (LibraryCompilerConfiguration) obj;
configuration.keepLinkReport(keepLinkReport);
configuration.keepSizeReport(keepSizeReport);
return new OEMConfiguration(cfgbuf, configuration);
}
catch (ConfigurationException ex)
{
Mxmlc.processConfigurationException(ex, "oem");
return null;
}
catch (IOException ex)
{
ThreadLocalToolkit.logError(ex.getMessage());
return null;
}
catch (RuntimeException ex)
{
Class c;
try
{
c = Class.forName("flex.messaging.config.ConfigurationException");
if (c.isInstance(ex))
{
ThreadLocalToolkit.logError(ex.getMessage());
}
}
catch (ClassNotFoundException ex2)
{
}
return null;
}
}
/**
*
* @param args
* @param logger
* @param mimeMappings
* @return
*/
public static final OEMConfiguration getLinkerConfiguration(String[] args, boolean keepLinkReport, boolean keepSizeReport,
Logger logger, MimeMappings mimeMappings,
PathResolver resolver,
flex2.compiler.common.Configuration c,
Set newLinkerOptions, Set<String> includes, Set<String> excludes)
{
OEMUtil.init(logger, mimeMappings, null, resolver, null);
try
{
ConfigurationBuffer cfgbuf = new ConfigurationBuffer(LinkerConfiguration.class,
LinkerConfiguration.getAliases());
DefaultsConfigurator.loadDefaults(cfgbuf);
Object obj = Mxmlc.processConfiguration(ThreadLocalToolkit.getLocalizationManager(),
"oem",
args,
cfgbuf,
LinkerConfiguration.class,
null);
LinkerConfiguration configuration = (LinkerConfiguration) obj;
configuration.setOriginalConfiguration(c, newLinkerOptions, includes, excludes);
configuration.keepLinkReport(keepLinkReport);
configuration.keepSizeReport(keepSizeReport);
return new OEMConfiguration(cfgbuf, configuration);
}
catch (ConfigurationException ex)
{
Mxmlc.processConfigurationException(ex, "oem");
return null;
}
catch (IOException ex)
{
ThreadLocalToolkit.logError(ex.getMessage());
return null;
}
catch (RuntimeException ex)
{
Class cls;
try
{
cls = Class.forName("flex.messaging.config.ConfigurationException");
if (cls.isInstance(ex))
{
ThreadLocalToolkit.logError(ex.getMessage());
}
}
catch (ClassNotFoundException ex2)
{
}
return null;
}
}
public static final ConfigurationBuffer getCommandLineConfigurationBuffer(Logger logger, PathResolver resolver, String[] args)
{
ConfigurationBuffer cfgbuf = null;
try
{
OEMUtil.init(logger, null, null, resolver, null);
cfgbuf = new ConfigurationBuffer(CommandLineConfiguration.class, CommandLineConfiguration.getAliases());
SystemPropertyConfigurator.load( cfgbuf, "flex" );
CommandLineConfigurator.parse( cfgbuf, null, args);
}
catch (ConfigurationException ex)
{
ThreadLocalToolkit.log(ex);
cfgbuf = null;
}
return cfgbuf;
}
public static final ConfigurationBuffer getCompcConfigurationBuffer(Logger logger, PathResolver resolver, String[] args)
{
ConfigurationBuffer cfgbuf = null;
try
{
OEMUtil.init(logger, null, null, resolver, null);
cfgbuf = new ConfigurationBuffer(CompcConfiguration.class, CompcConfiguration.getAliases());
SystemPropertyConfigurator.load( cfgbuf, "flex" );
CommandLineConfigurator.parse( cfgbuf, null, args);
}
catch (ConfigurationException ex)
{
ThreadLocalToolkit.log(ex);
cfgbuf = null;
}
return cfgbuf;
}
public static String[] trim(String[] args, ConfigurationBuffer cfgbuf, Set excludes)
{
List<Object[]> positions = cfgbuf.getPositions();
List<Object> newArgs = new ArrayList<Object>();
for (int i = 0, length = positions.size(); i < length; i++)
{
Object[] a = positions.get(i);
String var = (String) a[0];
int iStart = ((Integer) a[1]).intValue(), iEnd = ((Integer) a[2]).intValue();
if (!excludes.contains(var))
{
for (int j = iStart; j < iEnd; j++)
{
newArgs.add(args[j]);
}
}
}
args = new String[newArgs.size()];
newArgs.toArray(args);
return args;
}
public static final Logger getLogger(Logger logger, List<Message> messages)
{
return new BuilderLogger(logger == null ? new OEMConsole() : logger, messages);
}
public static final String formatConfigurationBuffer(ConfigurationBuffer cfgbuf)
{
return FileConfigurator.formatBuffer(cfgbuf, "flex-config",
OEMUtil.setupLocalizationManager(), "flex2.configuration");
}
/**
*
* @param configuration
* @return
*/
public static final Map getLicenseMap(ToolsConfiguration configuration)
{
return configuration.getLicensesConfiguration().getLicenseMap();
}
public static final void setGeneratedDirectory(CompilerConfiguration compilerConfig, File output)
{
if (compilerConfig.keepGeneratedActionScript())
{
File canonical = FileUtils.canonicalFile( output );
if (canonical != null)
output = canonical;
String parent = output.getParent();
String generated = null;
if (parent == null)
{
generated = new File( "generated" ).getAbsolutePath();
}
else
{
generated = FileUtils.addPathComponents( parent, "generated", File.separatorChar );
}
compilerConfig.setGeneratedDirectory( generated );
new File( generated ).mkdirs();
}
}
/**
* Save the compiler units signature checksums to ApplicationData.
* These will be used by the next compilation to determine if we
* can do an incremental compiler or if a full recompilation is required.
*
* @param units - compilation units, may be null
* @param data - application data, may not be null
*/
public static void saveSignatureChecksums(List units, ApplicationData data,
flex2.compiler.common.Configuration config)
{
if (!config.isSwcChecksumEnabled())
{
data.swcDefSignatureChecksums = null;
return;
}
if (units != null)
{
data.swcDefSignatureChecksums = new HashMap<QName, Long>();
for (Iterator iter = units.iterator(); iter.hasNext();)
{
CompilationUnit unit = (CompilationUnit)iter.next();
Source source = unit == null ? null : unit.getSource();
if (source != null && source.isSwcScriptOwner() && !source.isInternal())
{
addSignatureChecksumToData(data, unit);
}
}
}
}
/**
* @param swcContext context, may not be null
* @param data - application data, may not be null
*/
public static void saveSwcFileChecksums(CompilerSwcContext swcContext, ApplicationData data,
flex2.compiler.common.Configuration config)
{
if (!config.isSwcChecksumEnabled())
{
data.swcFileChecksums = null;
return;
}
data.swcFileChecksums = new HashMap<String, Long>();
for (Iterator iter = swcContext.getFiles().entrySet().iterator(); iter.hasNext();)
{
Map.Entry entry = (Map.Entry)iter.next();
String filename = (String)entry.getKey();
VirtualFile file = (VirtualFile)entry.getValue();
data.swcFileChecksums.put(filename, new Long(file.getLastModified()));
}
for (VirtualFile themeStyleSheet : swcContext.getThemeStyleSheets())
{
data.swcFileChecksums.put(themeStyleSheet.getName(),
new Long(themeStyleSheet.getLastModified()));
}
}
/**
* Loop thru the saved signature checksums in the application data and compare them with
* the signature checksums in the swc context.
*
* @param data application data from a previous compile. May not be null.
* @param swcContext swc context
* @return true if all the signature checksums in application data match the checksums
* in the swc context.
*/
public static boolean isRecompilationNeeded(ApplicationData data,
CompilerSwcContext swcContext,
OEMConfiguration config)
{
int checksum = OEMUtil.calculateChecksum(data, swcContext, config);
// if the checksum from last time and the current checksum do not match,
// then we need to recompile.
if (checksum != data.checksum)
{
if (Trace.swcChecksum)
{
Trace.trace("isRecompilationNeeded: calculated checksum differs from last checksum, recompile");
}
data.checksum = checksum;
return true;
}
// if we got here and swc checksums are disabled, then
// the checksums are equal and a recompilation is not needed.
// Otherwise continue on and compare the swc checksums.
if (!config.configuration.isSwcChecksumEnabled())
{
if (Trace.swcChecksum)
{
Trace.trace("isRecompilationNeeded: checksums equal, swc-checksum disabled, incremental compile");
}
return false;
}
Map signatureChecksums = data.swcDefSignatureChecksums;
if (signatureChecksums == null)
{
if (Trace.swcChecksum)
{
Trace.trace("isRecompilationNeeded: checksums equal, signatureChecksums is null, incremental compile");
}
}
else
{
for (Iterator iter = signatureChecksums.entrySet().iterator(); iter.hasNext();)
{
Map.Entry entry = (Map.Entry)iter.next();
// lookup definition in swc context
QName qName = (QName) entry.getKey();
Long dataSignatureChecksum = (Long)entry.getValue();
Long swcSignatureChecksum = swcContext.getChecksum(qName);
if (swcSignatureChecksum == null && qName != null)
{
Source source = swcContext.getSource(qName.getNamespace(), qName.getLocalPart());
if (source != null)
{
swcSignatureChecksum = new Long(source.getLastModified());
}
}
if (Trace.swcChecksum)
{
if (dataSignatureChecksum == null)
{
throw new IllegalStateException("dataSignatureChecksum should never be null");
}
}
if (dataSignatureChecksum != null && swcSignatureChecksum == null)
{
if (Trace.swcChecksum)
{
Trace.trace("isRecompilationNeeded: signature checksums not equal, recompile");
Trace.trace("compare " + entry.getKey());
Trace.trace("data = " + dataSignatureChecksum);
Trace.trace("swc = " + swcSignatureChecksum);
}
return true;
}
if (dataSignatureChecksum != null)
{
if (dataSignatureChecksum.longValue() != swcSignatureChecksum.longValue())
{
if (Trace.swcChecksum)
{
Trace.trace("isRecompilationNeeded: signature checksums not equal, recompile");
Trace.trace("compare " + entry.getKey());
Trace.trace("data = " + dataSignatureChecksum);
Trace.trace("swc = " + swcSignatureChecksum);
}
return true;
}
}
else {
// dataSignatureChecksum should never be null, but if it is then recompile.
return true;
}
}
}
boolean result = !areSwcFileChecksumsEqual(data, swcContext);
if (Trace.swcChecksum)
{
Trace.trace("isRecompilationNeeded: " + (result ? "recompile" : "incremental compile"));
}
return result;
}
/**
* Calculate the data checksum.
*
* @param data application data from a previous compile. If a recompilation is
* needed, data.checksum is updated with the new checksum. May not be null.
* @param swcContext swc context
* @return true if all the signature checksums in application data match the checksums
* in the swc context.
*/
public static int calculateChecksum(ApplicationData data,
CompilerSwcContext swcContext,
OEMConfiguration config)
{
int checksum = config.cfgbuf.checksum_ts();
// if swc checksums are disabled or there are no checksums to compare, then
// include the swc timestamp as part of the checksum.
if (!config.configuration.isSwcChecksumEnabled() ||
data.swcDefSignatureChecksums == null ||
data.swcDefSignatureChecksums.size() == 0)
{
checksum += swcContext.checksum();
}
return checksum;
}
/**
* Add all top level definitions to ApplicationData
* @param swcDefSignatureChecksums
* @param unit
* @param signatureChecksum
*/
private static void addSignatureChecksumToData(ApplicationData data, CompilationUnit unit)
{
Long signatureChecksum = unit.getSignatureChecksum();
if (signatureChecksum == null)
{
SwcScript script = (SwcScript) unit.getSource().getOwner();
signatureChecksum = new Long(script.getLastModified());
}
if (data.swcDefSignatureChecksums != null)
{
for (Iterator iter = unit.topLevelDefinitions.iterator(); iter.hasNext();)
{
QName qname = (QName) iter.next();
data.swcDefSignatureChecksums.put(qname, signatureChecksum);
}
}
}
/**
* Test if the files in the compiler swc context have changed since the last compile.
*
* @param data - application data, may not be null
* @param swcContext context, may not be null
* @return true it the swc files compiled with last time are the same as this time.
*/
private static boolean areSwcFileChecksumsEqual(ApplicationData data,
CompilerSwcContext swcContext)
{
if (data.swcFileChecksums == null)
{
if (Trace.swcChecksum)
{
Trace.trace("areSwcFileChecksumsEqual: no file checksum map, not equal");
}
return false;
}
Map swcFiles = swcContext.getFiles();
for (VirtualFile themeStyleSheet : swcContext.getThemeStyleSheets())
{
swcFiles.put(themeStyleSheet.getName(), themeStyleSheet);
}
Set dataSet = data.swcFileChecksums.entrySet();
if (swcFiles.size() < dataSet.size())
{
if (Trace.swcChecksum)
{
Trace.trace("areSwcFileChecksumsEqual: less files than before, not equal");
}
return false;
}
for (Iterator iter = dataSet.iterator(); iter.hasNext();)
{
Map.Entry entry = (Map.Entry)iter.next();
String filename = (String)entry.getKey();
// When we are reusing cached SWC's, the catalog.xml and
// library.swf are updated each time we save the
// SwcDynamicArchive, but we don't want to reload the SWC
// from disk, because all the compilation units
// represented by catalog.xml should be cached. If any of
// the cached CompilationUnit's becomes out of data,
// CompilerAPI.validateCompilationUnits() will handle
// removing the cached CompilationUnit, which will cause
// it to be reloaded from disk.
if (!filename.equals(Swc.CATALOG_XML) &&
!filename.equals(Swc.LIBRARY_SWF))
{
Long dataFileLastModified = (Long)entry.getValue();
Long swcFileLastModified = null;
VirtualFile swcFile = (VirtualFile)swcFiles.get(filename);
if (swcFile != null)
{
swcFileLastModified = new Long(swcFile.getLastModified());
}
if (!dataFileLastModified.equals(swcFileLastModified))
{
if (Trace.swcChecksum)
{
Trace.trace("areSwcFileChecksumsEqual: not equal");
Trace.trace("filename = " + filename);
Trace.trace("last modified1 = " + dataFileLastModified);
Trace.trace("last modified2 = " + swcFileLastModified);
}
return false;
}
}
}
if (Trace.swcChecksum)
{
Trace.trace("areSwcFileChecksumsEqual: equal");
}
return true;
}
}