getdown.txt
+ * configuration file.
+ */
+public class Application
+{
+ /** The name of our configuration file. */
+ public static final String CONFIG_FILE = "getdown.txt";
+
+ /** 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),
+ VERIFY_METADATA(15, 65, 95),
+ DOWNLOAD(40),
+ PATCH(60),
+ VERIFY_RESOURCES(70, 97),
+ REDOWNLOAD_RESOURCES(90),
+ UNPACK(98),
+ LAUNCH(99);
+
+ /** 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);
+ }
+
+ /**
+ * 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)) {
+ 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