docs: @Override
      public String verifyJarAndPrepareProcRunners(byte[] catalogBytes, String diffCommands,
              byte[] catalogBytesHash, byte[] deploymentBytes) {
          ImmutableMap.Builder<String, Class<?>> classesMap = ImmutableMap.<String, Class<?>>builder();
          InMemoryJarfile newCatalogJar;
          JarLoader jarLoader;
          String errorMsg;
          try {
              newCatalogJar = new InMemoryJarfile(catalogBytes);
              jarLoader = newCatalogJar.getLoader();
              for (String classname : jarLoader.getClassNames()) {
                  try {
                      Class<?> procCls = CatalogContext.classForProcedureOrUDF(classname, jarLoader);
                      classesMap.put(classname, procCls);
                  }
                  // LinkageError catches most of the various class loading errors we'd
                  // care about here.
                  catch (UnsupportedClassVersionError e) {
                      errorMsg = "Cannot load classes compiled with a higher version of Java than currently" +
                                   " in use. Class " + classname + " was compiled with ";
  
                      Integer major = 0;
                      // update the matcher pattern for various jdk
                      Pattern pattern = Pattern.compile("version\\s(\\d+).(\\d+)");
                      Matcher matcher = pattern.matcher(e.getMessage());
                      if (matcher.find()) {
                          major = Integer.parseInt(matcher.group(1));
                      } else {
                          hostLog.info("Unable to parse compile version number from UnsupportedClassVersionError.");
                      }
  
                      if (VerifyCatalogAndWriteJar.SupportedJavaVersionMap.containsKey(major)) {
                          errorMsg = errorMsg.concat(VerifyCatalogAndWriteJar.SupportedJavaVersionMap.get(major) + ", current runtime version is " +
                                           System.getProperty("java.version") + ".");
                      } else {
                          errorMsg = errorMsg.concat("an incompatible Java version.");
                      }
                      hostLog.info(errorMsg);
                      return errorMsg;
                  }
                  catch (LinkageError | ClassNotFoundException e) {
                      String cause = e.getMessage();
                      if (cause == null && e.getCause() != null) {
                          cause = e.getCause().getMessage();
                      }
                      errorMsg = "Error loading class \'" + classname + "\': " +
                          e.getClass().getCanonicalName() + " for " + cause;
                      hostLog.info(errorMsg);
                      return errorMsg;
                  }
              }
          } catch (Exception e) {
              // catch all exceptions, anything may fail now can be safely rolled back
              return e.getMessage();
          }
  
          CatalogContext ctx = VoltDB.instance().getCatalogContext();
          Catalog newCatalog = ctx.getNewCatalog(diffCommands);
  
          Database db = newCatalog.getClusters().get("cluster").getDatabases().get("database");
          CatalogMap<Procedure> catalogProcedures = db.getProcedures();
  
          int siteCount = m_nodeSettings.getLocalSitesCount() + 1; // + MPI site
  
          ctx.m_preparedCatalogInfo = new CatalogContext.CatalogInfo(catalogBytes, catalogBytesHash, deploymentBytes);
          ctx.m_preparedCatalogInfo.m_catalog = newCatalog;
          ctx.m_preparedCatalogInfo.m_preparedProcRunners = new ConcurrentLinkedQueue<>();
  
          for (long i = 0; i < siteCount; i++) {
              try {
                  ImmutableMap<String, ProcedureRunner> userProcRunner =
                      LoadedProcedureSet.loadUserProcedureRunners(catalogProcedures, null,
                                                                  classesMap.build(), null);
  
                  ctx.m_preparedCatalogInfo.m_preparedProcRunners.offer(userProcRunner);
              } catch (Exception e) {
                  String msg = "error setting up user procedure runners using NT-procedure pattern: "
                              + e.getMessage();
                  hostLog.info(msg);
                  return msg;
              }
          }
  
          return null;
      }