getdown.txt
* configuration file.
*/
public class Application
{
/** The name of our configuration file. */
public static final String CONFIG_FILE = "getdown.txt";
/** Dir where a backup config file might reside */
public static final String BACKUP_CONFIG_DIR = "install";
/** The name of our target version file. */
public static final String VERSION_FILE = "version.txt";
/** System properties that are prefixed with this string will be passed through to our
* application (minus this prefix). */
public static final String PROP_PASSTHROUGH_PREFIX = "app.";
/** Suffix used for control file signatures. */
public static final String SIGNATURE_SUFFIX = ".sig";
/** A special classname that means 'use -jar code.jar' instead of a classname. */
public static final String MANIFEST_CLASS = "manifest";
/** Used to communicate information about the UI displayed when updating the application. */
public static final class UpdateInterface
{
/**
* The major steps involved in updating, along with some arbitrary percentages
* assigned to them, to mark global progress.
*/
public enum Step
{
//UPDATE_JAVA(10),
UPDATE_JAVA(20),
//VERIFY_METADATA(15, 65, 95),
VERIFY_METADATA(15, 45, 90),
DOWNLOAD(60),
PATCH(60),
//VERIFY_RESOURCES(70, 97),
VERIFY_RESOURCES(40, 90),
//REDOWNLOAD_RESOURCES(90),
REDOWNLOAD_RESOURCES(80),
//UNPACK(98),
UNPACK(95),
//LAUNCH(99);
LAUNCH(100);
/** What is the final percent value for this step? */
public final Listgetdown.txt
* configuration file from the supplied application directory.
*
*/
public Application (EnvConfig envc) {
_envc = envc;
_config = getLocalPath(envc.appDir, CONFIG_FILE);
_backupConfig = getLocalPath(envc.appDir, BACKUP_CONFIG_DIR+File.separator+CONFIG_FILE);
}
/**
* Returns the configured application directory.
*/
public File getAppDir () {
return _envc.appDir;
}
/**
* Returns whether the application should cache code resources prior to launching the
* application.
*/
public boolean useCodeCache ()
{
return _useCodeCache;
}
/**
* Returns the number of days a cached code resource is allowed to stay unused before it
* becomes eligible for deletion.
*/
public int getCodeCacheRetentionDays ()
{
return _codeCacheRetentionDays;
}
/**
* Returns the configured maximum concurrent downloads. Used to cap simultaneous downloads of
* app files from its hosting server.
*/
public int maxConcurrentDownloads () {
return _maxConcDownloads;
}
/**
* Returns a resource that refers to the application configuration file itself.
*/
public Resource getConfigResource ()
{
try {
return createResource(CONFIG_FILE, Resource.NORMAL);
} catch (Exception e) {
throw new RuntimeException("Invalid appbase '" + _vappbase + "'.", e);
}
}
/**
* Returns a list of the code {@link Resource} objects used by this application.
*/
public Listgetdown.txt file based on information parsed from a
* previous call to {@link #init}.
*/
public void attemptRecovery (StatusDisplay status)
throws IOException
{
status.updateStatus("m.updating_metadata");
downloadConfigFile();
}
/**
* Downloads and replaces the getdown.txt and digest.txt files with
* those for the target version of our application.
*/
public void updateMetadata ()
throws IOException
{
try {
// update our versioned application base with the target version
_vappbase = createVAppBase(_targetVersion);
} catch (MalformedURLException mue) {
String err = MessageUtil.tcompose("m.invalid_appbase", _appbase);
throw (IOException) new IOException(err).initCause(mue);
}
try {
// now re-download our control files; we download the digest first so that if it fails,
// our config file will still reference the old version and re-running the updater will
// start the whole process over again
downloadDigestFiles();
downloadConfigFile();
} catch (IOException ex) {
// if we are allowing offline execution, we want to allow the application to run in its
// current form rather than aborting the entire process; to do this, we delete the
// version.txt file and "trick" Getdown into thinking that it just needs to validate
// the application as is; next time the app runs when connected to the internet, it
// will have to rediscover that it needs updating and reattempt to update itself
if (_allowOffline) {
log.warning("Failed to update digest files. Attempting offline operaton.", ex);
if (!FileUtil.deleteHarder(getLocalPath(VERSION_FILE))) {
log.warning("Deleting version.txt failed. This probably isn't going to work.");
}
} else {
throw ex;
}
}
}
/**
* Invokes the process associated with this application definition.
*
* @param optimum whether or not to include the set of optimum arguments (as opposed to falling
* back).
*/
public Process createProcess (boolean optimum)
throws IOException
{
ArrayListdigest.txt file and verifies the contents of both that file and the
* getdown.text file. Then it loads the version.txt and decides
* whether or not the application needs to be updated or whether we can proceed to verification
* and execution.
*
* @return true if the application needs to be updated, false if it is up to date and can be
* verified and executed.
*
* @exception IOException thrown if we encounter an unrecoverable error while verifying the
* metadata.
*/
public boolean verifyMetadata (StatusDisplay status)
throws IOException
{
log.info("Verifying application: " + _vappbase);
log.info("Version: " + _version);
log.info("Class: " + _class);
// this will read in the contents of the digest file and validate itself
try {
_digest = new Digest(getAppDir(), _strictComments);
} catch (IOException ioe) {
log.info("Failed to load digest: " + ioe.getMessage() + ". Attempting recovery...");
}
// if we have no version, then we are running in unversioned mode so we need to download
// our digest.txt file on every invocation
if (_version == -1) {
// make a note of the old meta-digest, if this changes we need to revalidate all of our
// resources as one or more of them have also changed
String olddig = (_digest == null) ? "" : _digest.getMetaDigest();
try {
status.updateStatus("m.checking");
downloadDigestFiles();
_digest = new Digest(getAppDir(), _strictComments);
if (!olddig.equals(_digest.getMetaDigest())) {
log.info("Unversioned digest changed. Revalidating...");
status.updateStatus("m.validating");
clearValidationMarkers();
}
} catch (IOException ioe) {
log.warning("Failed to refresh non-versioned digest: " +
ioe.getMessage() + ". Proceeding...");
}
}
// regardless of whether we're versioned, if we failed to read the digest from disk, try to
// redownload the digest file and give it another good college try; this time we allow
// exceptions to propagate up to the caller as there is nothing else we can do
if (_digest == null) {
status.updateStatus("m.updating_metadata");
downloadDigestFiles();
_digest = new Digest(getAppDir(), _strictComments);
}
// now verify the contents of our main config file
Resource crsrc = getConfigResource();
if (!_digest.validateResource(crsrc, null)) {
status.updateStatus("m.updating_metadata");
// attempt to redownload both of our metadata files; again we pass errors up to our
// caller because there's nothing we can do to automatically recover
downloadConfigFile();
downloadDigestFiles();
_digest = new Digest(getAppDir(), _strictComments);
// revalidate everything if we end up downloading new metadata
clearValidationMarkers();
// if the new copy validates, reinitialize ourselves; otherwise report baffling hoseage
if (_digest.validateResource(crsrc, null)) {
// unset _initialisedConfig so new file is initialised
_initialisedConfig = null;
init(true);
} else {
log.warning(CONFIG_FILE + " failed to validate even after redownloading. " +
"Blindly forging onward.");
}
}
// start by assuming we are happy with our version
_targetVersion = _version;
// if we are a versioned application, read in the contents of the version.txt file
// and/or check the latest config URL for a newer version
if (_version != -1) {
File vfile = getLocalPath(VERSION_FILE);
long fileVersion = VersionUtil.readVersion(vfile);
if (fileVersion != -1) {
_targetVersion = fileVersion;
}
if (_latest != null) {
try (InputStream in = ConnectionUtil.open(proxy, _latest, 0, 0).getInputStream();
InputStreamReader reader = new InputStreamReader(in, UTF_8);
BufferedReader bin = new BufferedReader(reader)) {
for (String[] pair : Config.parsePairs(bin, Config.createOpts(false))) {
if (pair[0].equals("version")) {
_targetVersion = Math.max(Long.parseLong(pair[1]), _targetVersion);
if (fileVersion != -1 && _targetVersion > fileVersion) {
// replace the file with the newest version
try (FileOutputStream fos = new FileOutputStream(vfile);
PrintStream out = new PrintStream(fos)) {
out.println(_targetVersion);
}
}
break;
}
}
} catch (Exception e) {
log.warning("Unable to retrieve version from latest config file.", e);
}
}
}
// finally let the caller know if we need an update
return _version != _targetVersion;
}
/**
* Verifies the code and media resources associated with this application. A list of resources
* that do not exist or fail the verification process will be returned. If all resources are
* ready to go, null will be returned and the application is considered ready to run.
*
* @param obs a progress observer that will be notified of verification progress. NOTE: this
* observer may be called from arbitrary threads, so if you update a UI based on calls to it,
* you have to take care to get back to your UI thread.
* @param alreadyValid if non-null a 1 element array that will have the number of "already
* validated" resources filled in.
* @param unpacked a set to populate with unpacked resources.
* @param toInstall a list into which to add resources that need to be installed.
* @param toDownload a list into which to add resources that need to be downloaded.
*/
public void verifyResources (
ProgressObserver obs, int[] alreadyValid, Set TODO: Switch to PKCS #7 or CMS.
*
* @param sigVersion if {@code 0} no validation will be performed, if {@code > 0} then this
* should indicate the version of the digest file being validated which indicates which
* algorithm to use to verify the signature. See {@link Digest#VERSION}.
*/
protected void downloadControlFile (String path, int sigVersion)
throws IOException
{
File target = downloadFile(path);
if (sigVersion > 0) {
if (_envc.certs.isEmpty()) {
log.info("No signing certs, not verifying digest.txt", "path", path);
} else {
File signatureFile = downloadFile(path + SIGNATURE_SUFFIX);
byte[] signature = null;
try (FileInputStream signatureStream = new FileInputStream(signatureFile)) {
signature = StreamUtil.toByteArray(signatureStream);
} finally {
FileUtil.deleteHarder(signatureFile); // delete the file regardless
}
byte[] buffer = new byte[8192];
int length, validated = 0;
for (Certificate cert : _envc.certs) {
try (FileInputStream dataInput = new FileInputStream(target)) {
Signature sig = Signature.getInstance(Digest.sigAlgorithm(sigVersion));
sig.initVerify(cert);
while ((length = dataInput.read(buffer)) != -1) {
sig.update(buffer, 0, length);
}
if (!sig.verify(Base64.decode(signature, Base64.DEFAULT))) {
log.info("Signature does not match", "cert", cert.getPublicKey());
continue;
} else {
log.info("Signature matches", "cert", cert.getPublicKey());
validated++;
}
} catch (IOException ioe) {
log.warning("Failure validating signature of " + target + ": " + ioe);
} catch (GeneralSecurityException gse) {
// no problem!
}
}
// if we couldn't find a key that validates our digest, we are the hosed!
if (validated == 0) {
// delete the temporary digest file as we know it is invalid
FileUtil.deleteHarder(target);
throw new IOException("m.corrupt_digest_signature_error");
}
}
}
// now move the temporary file over the original
File original = getLocalPath(path);
if (!FileUtil.renameTo(target, original)) {
throw new IOException("Failed to rename(" + target + ", " + original + ")");
}
}
/**
* Download a path to a temporary file, returning a {@link File} instance with the path
* contents.
*/
protected File downloadFile (String path)
throws IOException
{
File target = getLocalPath(path + "_new");
URL targetURL = null;
try {
targetURL = getRemoteURL(path);
} catch (Exception e) {
log.warning("Requested to download invalid control file",
"appbase", _vappbase, "path", path, "error", e);
throw (IOException) new IOException("Invalid path '" + path + "'.").initCause(e);
}
log.info("Attempting to refetch '" + path + "' from '" + targetURL + "'.");
// stream the URL into our temporary file
URLConnection uconn = ConnectionUtil.open(proxy, targetURL, 0, 0);
// we have to tell Java not to use caches here, otherwise it will cache any request for
// same URL for the lifetime of this JVM (based on the URL string, not the URL object);
// if the getdown.txt file, for example, changes in the meanwhile, we would never hear
// about it; turning off caches is not a performance concern, because when Getdown asks
// to download a file, it expects it to come over the wire, not from a cache
uconn.setUseCaches(false);
uconn.setRequestProperty("Accept-Encoding", "gzip");
try (InputStream fin = uconn.getInputStream()) {
String encoding = uconn.getContentEncoding();
boolean gzip = "gzip".equalsIgnoreCase(encoding);
try (InputStream fin2 = (gzip ? new GZIPInputStream(fin) : fin)) {
try (FileOutputStream fout = new FileOutputStream(target)) {
StreamUtil.copy(fin2, fout);
}
}
}
return target;
}
/** Helper function for creating {@link Resource} instances. */
protected Resource createResource (String path, EnumSet