<pre>
App Engine release this instance is running on.
&#64;OutputOnly
</pre>

<code>string app_engine_release = 3;</code>
359753
public com.google.protobuf.ByteString
      getAppEngineReleaseBytes() {
    java.lang.Object ref = appEngineRelease_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      appEngineRelease_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
797653
@Override
    public void release()
    {
        _applicationFactory = null;
        _currentFacesContext = null;
        if (_defaultExternalContext != null)
        {
            _defaultExternalContext.release();
            _defaultExternalContext = null;
        }
        
        _application = null;
        _externalContext = null;
        _viewRoot = null;
        _renderKitFactory = null;
        _elContext = null;
        _exceptionHandler = null;
        _cachedRenderKit = null;
        _cachedRenderKitId = null;
        _separatorChar = null;
        
        // Spec JSF 2 section getAttributes when release is called the attributes map
        // must!!! be cleared! (probably to trigger some clearance methods on possible
        // added entries before nullifying everything)
        if (_attributes != null)
        {
            _attributes.clear();
            _attributes = null;
        }
        
        _released = true;
        FacesContext.setCurrentInstance(null);
    }
637501
public OutputVariable removeOutputVariable(String name) {
        for (Iterator<OutputVariable> it = this.outputVariables.iterator(); it.hasNext();) {
            OutputVariable outputVariable = it.next();
            if (outputVariable.getName().equals(name)) {
                it.remove();
                return outputVariable;
            }
        }
        throw new RuntimeException(String.format(
                "[engine error] no output variable by name <%s>", name));
    }
1316324
public void closeOutputStreamAppender(String appenderName) throws IOException {
		if (null == appenderName) {
			return;
		}
		final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
		final Configuration config = ctx.getConfiguration();
		AdminToolLog4j2OutputStream baos = outputStreams.get(appenderName);
		
		if (null != config && null != config.getAppenders()) {
			OutputStreamAppender appender = config.getAppender(appenderName);
			if (null != appender) {
				appender.stop();
				
				Collection<String> parentLoggerNames = getParentLoggerNames();
				
				for (String configuredLoggerName : getAllLoggerNames()) {
					LoggerConfig loggerConfig = config.getLoggerConfig(configuredLoggerName);
					loggerConfig.removeAppender(appender.getName());
					if (null != baos.getOriginalLevel(configuredLoggerName)) {
						changeLogger(configuredLoggerName, baos.getOriginalLevel(configuredLoggerName), 
								parentLoggerNames.contains(configuredLoggerName));
					}
				}
				//unsure about, if removing the appender from logger config if it gets also removed from logger instance too...
				removeAppender(appender, getParentLoggers());
				removeAppender(appender, getLoggers());
				appender.getManager().getByteBuffer().clear();
				
				ctx.updateLoggers();
			}
		}
		
		if (null != baos) {
			try {
				baos.close();
				baos.clearOriginalLevels();
			} catch (Exception ignore) {
			} finally {
				outputStreams.remove(appenderName);
			}
		}
	}
648250
private boolean _update(final Identification id) throws IOException, ServletException {

	final File newLucee = downloadCore(id);
	if (newLucee == null) return false;

	if (singelton != null) singelton.reset();

	final Version v = null;
	try {

	    bundleCollection = BundleLoader.loadBundles(this, getFelixCacheDirectory(), getBundleDirectory(), newLucee, bundleCollection);
	    final CFMLEngine e = getEngine(bundleCollection);
	    if (e == null) throw new IOException("can't load engine");
	    version = e.getInfo().getVersion();
	    // engine = e;
	    setEngine(e);
	    // e.reset();
	    callListeners(e);

	    ConfigServer cs = getConfigServer(e);
	    if (cs != null) {
		Log log = cs.getLog("deploy");
		log.info("loader", "Lucee Version [" + v + "] installed");
	    }

	}
	catch (final Exception e) {
	    System.gc();
	    try {
		newLucee.delete();
	    }
	    catch (final Exception ee) {}
	    log(e);
	    e.printStackTrace();
	    return false;
	}

	log(Logger.LOG_DEBUG, "Version (" + v + ")installed");
	return true;
    }
1163895
@Override
    public final void release()
    {
        assertNotReleased();

        _messages = null;
        _orderedMessages = null;
        _currentPhaseId = null;
        _responseStream = null;
        _responseWriter = null;
        _maximumSeverity = null;
        _partialViewContext = null;
        _renderKitFactory = null;
        _partialViewContextFactory = null;

        if (_facesContextFactory != null)
        {
            _facesContextFactory.release();
            _facesContextFactory = null;
        }

        // release FacesContextImplBase (sets current instance to null)
        super.release();
    }
888256
public void appendTo(
      Appendable out,
      DependencyInfo info,
      CharSource content) throws IOException {
    if (info.isModule()) {
      mode.appendGoogModule(transpile(content.read()), out, sourceUrl);
    } else if ("es6".equals(info.getLoadFlags().get("module")) && transpiler == Transpiler.NULL) {
      // TODO(johnplaisted): Make the default transpiler the ES_MODULE_TO_CJS_TRANSPILER. Currently
      // some code is passing in unicode identifiers in non-ES6 modules the compiler fails to parse.
      // Once this compiler bug is fixed we can always transpile.
      mode.appendTraditional(transpileEs6Module(content.read()), out, sourceUrl);
    } else {
      mode.appendTraditional(transpile(content.read()), out, sourceUrl);
    }
  }
398406
public static void main(String[] args) {
        int exitCode = 0;
        final App app = new App();
        exitCode = app.run(args);
        LOGGER.debug("Exit code: {}", exitCode);
        System.exit(exitCode);
    }
193104
@Override
	public <T> AppEngineUpdate<E> set(Property<?, T> property, T value) {
		if (property == null) {
			throw new IllegalArgumentException("'property' must not be [" + property + "]");
		}
		
		properties.put(property, value); 
		return this;
	}
231844
@Override
	public void release(Throwable cause) {
		if (STATE_UPDATER.compareAndSet(this, State.ALIVE, State.RELEASING)) {
			signalPayloadRelease(cause);
		}
		markReleased();
		releaseFuture.complete(null);
	}
1334538
@Override
    public void out() throws Exception {
        Object val = fa.getFieldValue();
//        Object val = access;

//        if (ens.shouldFire()) {
//            DataflowEvent e = new DataflowEvent(ens.getController(), this, val);
////            DataflowEvent e = new DataflowEvent(ens.getController(), this, access.toObject());
//            ens.fireOut(e);
//            // the value might be altered
//            val = e.getValue();
//        }
        // if data==null this unconsumed @Out, its OK but we do not want to set it.
        if (fa.getData() != null) {
            fa.getData().setValue0(val);
        }
        fa.out();
    }
1318302
public static void main(final String[] args)
    {
        // passing true to constructor indicates the compiler is being run in standalone mode
        final VoltCompiler compiler = new VoltCompiler(true, false);

        boolean success = false;
        if (args.length > 0 && args[0].toLowerCase().endsWith(".jar")) {
            // The first argument is *.jar for the new syntax.
            if (args.length >= 2) {
                // Check for accidental .jar or .xml files specified for argument 2
                // to catch accidental incomplete use of the legacy syntax.
                if (args[1].toLowerCase().endsWith(".xml") || args[1].toLowerCase().endsWith(".jar")) {
                    System.err.println("Error: Expecting a DDL file as the second argument.\n"
                                     + "      .xml and .jar are invalid DDL file extensions.");
                    System.exit(-1);
                }
                success = compiler.compileFromDDL(args[0], ArrayUtils.subarray(args, 1, args.length));
            }
            else {
                System.err.printf("Usage: %s\n", usageNew);
                System.exit(-1);
            }
        }
        else {
            // Can't recognize the arguments or there are no arguments.
            System.err.printf("Usage: %s\n       %s\n", usageNew, usageLegacy);
            System.exit(-1);
        }

        // Should have exited if inadequate arguments were provided.
        assert(args.length > 0);

        // Exit with error code if we failed
        if (!success) {
            compiler.summarizeErrors(System.out, null);
            System.exit(-1);
        }
        compiler.summarizeSuccess(System.out, null, args[0]);
    }
1203822
function stdout(context, file, fileSet, next) {
  if (!file.data.unifiedEngineGiven) {
    debug('Ignoring programmatically added file')
    next()
  } else if (stats(file).fatal || context.output || !context.out) {
    debug('Ignoring writing to `streamOut`')
    next()
  } else {
    debug('Writing document to `streamOut`')
    context.streamOut.write(file.toString(), next)
  }
}
878485
@Override
    protected void analyzeDependency(Dependency dependency, Engine engine)
            throws AnalysisException {
        if (needToDisableGemspecAnalyzer) {
            boolean failed = true;
            final String className = RubyGemspecAnalyzer.class.getName();
            for (FileTypeAnalyzer analyzer : engine.getFileTypeAnalyzers()) {
                if (analyzer instanceof RubyBundlerAnalyzer) {
                    ((RubyBundlerAnalyzer) analyzer).setEnabled(false);
                    LOGGER.info("Disabled {} to avoid noisy duplicate results.", RubyBundlerAnalyzer.class.getName());
                } else if (analyzer instanceof RubyGemspecAnalyzer) {
                    ((RubyGemspecAnalyzer) analyzer).setEnabled(false);
                    LOGGER.info("Disabled {} to avoid noisy duplicate results.", className);
                    failed = false;
                }
            }
            if (failed) {
                LOGGER.warn("Did not find {}.", className);
            }
            needToDisableGemspecAnalyzer = false;
        }
        final File parentFile = dependency.getActualFile().getParentFile();
        final Process process = launchBundleAudit(parentFile);
        final int exitValue;
        try {
            exitValue = process.waitFor();
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
            throw new AnalysisException("bundle-audit process interrupted", ie);
        }
        if (exitValue < 0 || exitValue > 1) {
            final String msg = String.format("Unexpected exit code from bundle-audit process; exit code: %s", exitValue);
            throw new AnalysisException(msg);
        }
        try {
            try (BufferedReader errReader = new BufferedReader(new InputStreamReader(process.getErrorStream(), StandardCharsets.UTF_8))) {
                while (errReader.ready()) {
                    final String error = errReader.readLine();
                    LOGGER.warn(error);
                }
            }
            try (BufferedReader rdr = new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
                processBundlerAuditOutput(dependency, engine, rdr);
            }
        } catch (IOException | CpeValidationException ioe) {
            LOGGER.warn("bundle-audit failure", ioe);
        }
    }
511396
private void internalRelease() {

        // try {

        // setKey(null);

        // getNotifier().unlistenAll(getWaveReady());

        callAnnotatedMethod(OnRelease.class);

        if (localFacade() != null) {
            localFacade().unregister(key());
        }

        // thisObject.ready = false;

        // Shall also release all InnerComponent
        if (getInnerComponentMap().isPresent()) {

            final List<Component<?>> toRemove = new ArrayList<>();
            for (final Component<?> innerComponent : getInnerComponentMap().get().values()) {

                // Release the InnerComponent
                innerComponent.release();

                // Store it to avoid co-modification error
                toRemove.add(innerComponent);
            }

            for (final Component<?> innerComponent : toRemove) {

                // Remove it from the list
                // getInnerComponentList().get().remove(innerComponent);

                // Then remove it from map
                getInnerComponentMap().get().remove(innerComponent.key());
            }
        }

        // } catch (final JRebirthThreadException jte) {
        // LOGGER.error(COMPONENT_RELEASE_ERROR, jte);
        // }

    }
789626
@GwtIncompatible("Unnecessary")
  private boolean shouldGenerateOutputPerModule(String output) {
    return !config.module.isEmpty()
        && output != null && output.contains("%outname%");
  }
884421
public static int run(String[] args, PrintWriter out) {
        JdepsTask t = new JdepsTask();
        t.setLog(out);
        return t.run(args);
    }