docs: public void contextInitialized(ServletContextEvent event) {
          JenkinsJVMAccess._setJenkinsJVM(true);
          final ServletContext context = event.getServletContext();
          File home=null;
          try {
  
              // use the current request to determine the language
              LocaleProvider.setProvider(new LocaleProvider() {
                  public Locale get() {
                      return Functions.getCurrentLocale();
                  }
              });
  
              // quick check to see if we (seem to) have enough permissions to run. (see #719)
              JVM jvm;
              try {
                  jvm = new JVM();
                  new URLClassLoader(new URL[0],getClass().getClassLoader());
              } catch(SecurityException e) {
                  throw new InsufficientPermissionDetected(e);
              }
  
              try {// remove Sun PKCS11 provider if present. See http://wiki.jenkins-ci.org/display/JENKINS/Solaris+Issue+6276483
                  Security.removeProvider("SunPKCS11-Solaris");
              } catch (SecurityException e) {
                  // ignore this error.
              }
  
              installLogger();
  
              final FileAndDescription describedHomeDir = getHomeDir(event);
              home = describedHomeDir.file.getAbsoluteFile();
              home.mkdirs();
              System.out.println("Jenkins home directory: "+home+" found at: "+describedHomeDir.description);
  
              // check that home exists (as mkdirs could have failed silently), otherwise throw a meaningful error
              if (!home.exists())
                  throw new NoHomeDir(home);
  
              recordBootAttempt(home);
  
              // make sure that we are using XStream in the "enhanced" (JVM-specific) mode
              if(jvm.bestReflectionProvider().getClass()==PureJavaReflectionProvider.class) {
                  throw new IncompatibleVMDetected(); // nope
              }
  
  //  JNA is no longer a hard requirement. It's just nice to have. See HUDSON-4820 for more context.
  //            // make sure JNA works. this can fail if
  //            //    - platform is unsupported
  //            //    - JNA is already loaded in another classloader
  //            // see http://wiki.jenkins-ci.org/display/JENKINS/JNA+is+already+loaded
  //            // TODO: or shall we instead modify Hudson to work gracefully without JNA?
  //            try {
  //                /*
  //                    java.lang.UnsatisfiedLinkError: Native Library /builds/apps/glassfish/domains/hudson-domain/generated/jsp/j2ee-modules/hudson-1.309/loader/com/sun/jna/sunos-sparc/libjnidispatch.so already loaded in another classloader
  //                        at java.lang.ClassLoader.loadLibrary0(ClassLoader.java:1743)
  //                        at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1674)
  //                        at java.lang.Runtime.load0(Runtime.java:770)
  //                        at java.lang.System.load(System.java:1005)
  //                        at com.sun.jna.Native.loadNativeLibraryFromJar(Native.java:746)
  //                        at com.sun.jna.Native.loadNativeLibrary(Native.java:680)
  //                        at com.sun.jna.Native.<clinit>(Native.java:108)
  //                        at hudson.util.jna.GNUCLibrary.<clinit>(GNUCLibrary.java:86)
  //                        at hudson.Util.createSymlink(Util.java:970)
  //                        at hudson.model.Run.run(Run.java:1174)
  //                        at hudson.matrix.MatrixBuild.run(MatrixBuild.java:149)
  //                        at hudson.model.ResourceController.execute(ResourceController.java:88)
  //                        at hudson.model.Executor.run(Executor.java:123)
  //                 */
  //                String.valueOf(Native.POINTER_SIZE); // this meaningless operation forces the classloading and initialization
  //            } catch (LinkageError e) {
  //                if (e.getMessage().contains("another classloader"))
  //                    context.setAttribute(APP,new JNADoublyLoaded(e));
  //                else
  //                    context.setAttribute(APP,new HudsonFailedToLoad(e));
  //            }
  
              // make sure this is servlet 2.4 container or above
              try {
                  ServletResponse.class.getMethod("setCharacterEncoding",String.class);
              } catch (NoSuchMethodException e) {
                  throw new IncompatibleServletVersionDetected(ServletResponse.class);
              }
  
              // make sure that we see Ant 1.7
              try {
                  FileSet.class.getMethod("getDirectoryScanner");
              } catch (NoSuchMethodException e) {
                  throw new IncompatibleAntVersionDetected(FileSet.class);
              }
  
              // make sure AWT is functioning, or else JFreeChart won't even load.
              if(ChartUtil.awtProblemCause!=null) {
                  throw new AWTProblem(ChartUtil.awtProblemCause);
              }
  
              // some containers (in particular Tomcat) doesn't abort a launch
              // even if the temp directory doesn't exist.
              // check that and report an error
              try {
                  File f = File.createTempFile("test", "test");
                  f.delete();
              } catch (IOException e) {
                  throw new NoTempDir(e);
              }
  
              // Tomcat breaks XSLT with JDK 5.0 and onward. Check if that's the case, and if so,
              // try to correct it
              try {
                  TransformerFactory.newInstance();
                  // if this works we are all happy
              } catch (TransformerFactoryConfigurationError x) {
                  // no it didn't.
                  LOGGER.log(WARNING, "XSLT not configured correctly. Hudson will try to fix this. See http://issues.apache.org/bugzilla/show_bug.cgi?id=40895 for more details",x);
                  System.setProperty(TransformerFactory.class.getName(),"com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl");
                  try {
                      TransformerFactory.newInstance();
                      LOGGER.info("XSLT is set to the JAXP RI in JRE");
                  } catch(TransformerFactoryConfigurationError y) {
                      LOGGER.log(SEVERE, "Failed to correct the problem.");
                  }
              }
  
              installExpressionFactory(event);
  
              context.setAttribute(APP,new HudsonIsLoading());
  
              final File _home = home;
              initThread = new Thread("Jenkins initialization thread") {
                  @Override
                  public void run() {
                      boolean success = false;
                      try {
                          Jenkins instance = new Hudson(_home, context);
  
                          // one last check to make sure everything is in order before we go live
                          if (Thread.interrupted())
                              throw new InterruptedException();
  
                          context.setAttribute(APP, instance);
  
                          BootFailure.getBootFailureFile(_home).delete();
  
                          // at this point we are open for business and serving requests normally
                          LOGGER.info("Jenkins is fully up and running");
                          success = true;
                      } catch (Error e) {
                          new HudsonFailedToLoad(e).publish(context,_home);
                          throw e;
                      } catch (Exception e) {
                          new HudsonFailedToLoad(e).publish(context,_home);
                      } finally {
                          Jenkins instance = Jenkins.getInstanceOrNull();
                          if(!success && instance!=null)
                              instance.cleanUp();
                      }
                  }
              };
              initThread.start();
          } catch (BootFailure e) {
              e.publish(context, home);
          } catch (Error | RuntimeException e) {
              LOGGER.log(SEVERE, "Failed to initialize Jenkins",e);
              throw e;
          }
      }