docs: void processServerContentRequest() {
  
          File installRoot = new File(locationService.resolveString("${wlp.install.dir}"));
  
          final Set<String> absPathsForLibertyContent = new HashSet<String>();
          final Map<String, List<String>> specificPlatformPathsByPlatform = new HashMap<String, List<String>>();
          Set<String> discoveredFeatures = new HashSet<String>();
          Collection<FeatureResource> fixes = new ArrayList<FeatureResource>();
  
          // We need ALL Kernel features (even the ones that aren't active in the system)
          // as well as all installed features.
          List<ProvisioningFeatureDefinition> allFeatureDefs = new ArrayList<ProvisioningFeatureDefinition>();
          allFeatureDefs.addAll(KernelFeatureDefinitionImpl.getAllKernelFeatures(bundleContext, locationService));
          allFeatureDefs.addAll(featureResolver.getInstalledFeatureDefinitions());
  
          //keep a list of product extensions being used in the server
          List<String> extensionRepos = new ArrayList<String>();
  
          for (ProvisioningFeatureDefinition fd : allFeatureDefs) {
  
              BundleRepositoryHolder brh = BundleRepositoryRegistry.getRepositoryHolder(fd.getBundleRepositoryType());
              ContentBasedLocalBundleRepository br = brh.getBundleRepository();
              Collection<FeatureResource> frs = fd.getConstituents(null);
  
              /*
               * lib/fixes processing needs to happen here, to filter the xml down to just the current in use set.
               * made slightly more complex, because the locations tracked for minify are absolute, so we have to identify and trim installroot
               * to identify lib/fixes/* content, which we process afterward
               */
              File libFixes = new File(installRoot, "lib/fixes");
  
              for (FeatureResource fr : frs) {
                  switch (fr.getType()) {
                      case FEATURE_TYPE: {
                          //type = feature, no paths to worry about, we are processing the list of all installed features
                          //                which will include nested features.
                          discoveredFeatures.add(fr.getSymbolicName());
                          break;
                      }
  
                      case BUNDLE_TYPE:
                      case JAR_TYPE:
                      case BOOT_JAR_TYPE: {
                          //type = bundle, need to query the bundle repository for this feature def, to find which
                          //               files are being used.
                          //type = jar, basically same as type=bundle.. for minify purposes.
                          //type = boot.jar, basically same as type=bundle.. for minify purposes.
                          File b = br.selectBundle(fr.getLocation(), fr.getSymbolicName(), fr.getVersionRange());
                          File bb = br.selectBaseBundle(fr.getLocation(), fr.getSymbolicName(), fr.getVersionRange());
                          //b & bb will be the same bundle if the base was the selected.. 
                          if (b != null && bb != null) {
                              boolean pathsSame = b.getAbsolutePath().equals(bb.getAbsolutePath());
                              absPathsForLibertyContent.add(b.getAbsolutePath());
                              if (!pathsSame) {
                                  absPathsForLibertyContent.add(bb.getAbsolutePath());
                              }
                              List<String> osList = fr.getOsList();
                              if (osList != null) {
                                  for (String os : osList) {
                                      List<String> pathsForOs = specificPlatformPathsByPlatform.get(os);
                                      if (pathsForOs == null) {
                                          pathsForOs = new ArrayList<String>();
                                          specificPlatformPathsByPlatform.put(os, pathsForOs);
                                      }
                                      pathsForOs.add(b.getAbsolutePath());
                                      if (!pathsSame) {
                                          pathsForOs.add(bb.getAbsolutePath());
                                      }
                                  }
                              }
                          } else {
                              //b & bb were null, we have no match for this resource.. 
                              //maybe the resource was minfiied out?
                              List<String> osList = fr.getOsList();
                              if (osList != null) {
                                  //ignore the missing resource, as the file is tagged for specific os's,
                                  //and will be reported missing based on the os filters later.
                                  //(if the user has no os filter set, they meant 'all currently supported by the install')
                                  //(so this can still be ignored).
                              } else {
                                  //use match string for error message, it provides best chance for being helpful.
                                  Tr.warning(tc, "ERROR_MISSING_FEATURE_RESOURCE", new Object[] { fd.getFeatureName(), fr.getMatchString() });
                              }
                          }
                          break;
                      }
  
                      case FILE_TYPE: {
                          //file uses loc as a relative path from install root.
                          String locString = fr.getLocation();
                          if (locString != null) {
                              String[] locs;
                              if (locString.contains(",")) {
                                  locs = locString.split(",");
                              } else {
                                  locs = new String[] { locString };
                              }
  
                              for (String loc : locs) {
                                  File test = new File(loc);
                                  if (!test.isAbsolute()) {
                                      test = new File(brh.getInstallDir(), loc);
                                  }
                                  loc = test.getAbsolutePath();
                                  //filter fixes content into the fixes set, all other content is remembered.
                                  if (loc.startsWith(libFixes.getAbsolutePath() + File.separator)) {
                                      fixes.add(fr);
                                  } else {
                                      absPathsForLibertyContent.add(loc);
                                  }
  
                                  List<String> osList = fr.getOsList();
                                  if (osList != null) {
                                      for (String os : osList) {
                                          List<String> pathsForOs = specificPlatformPathsByPlatform.get(os);
                                          if (pathsForOs == null) {
                                              pathsForOs = new ArrayList<String>();
                                              specificPlatformPathsByPlatform.put(os, pathsForOs);
                                          }
                                          pathsForOs.add(loc);
                                      }
                                  }
                              }
                          } else {
                              //a file type without a loc is bad, means misuse of the type.
                              Tr.warning(tc, "ERROR_UNKNOWN_FEATURE_RESOURCE_TYPE", new Object[] { fd.getFeatureName(), fr.getSymbolicName(), "file" });
                          }
                          break;
                      }
  
                      case UNKNOWN: {
                          //if its not jar,bundle,feature, or file.. then something is wrong.
                          Tr.warning(tc, "ERROR_UNKNOWN_FEATURE_RESOURCE_TYPE", new Object[] { fd.getFeatureName(),
                                                                                              fr.getSymbolicName(),
                                                                                              fr.getRawType() });
                          //we assume that other types will use the location field as something useful.
                          String loc = fr.getLocation();
                          if (loc != null) {
                              File test = new File(loc);
                              if (!test.isAbsolute()) {
                                  test = new File(installRoot, loc);
                              }
                              absPathsForLibertyContent.add(test.getAbsolutePath());
  
                              List<String> osList = fr.getOsList();
                              if (osList != null) {
                                  for (String os : osList) {
                                      List<String> pathsForOs = specificPlatformPathsByPlatform.get(os);
                                      if (pathsForOs == null) {
                                          pathsForOs = new ArrayList<String>();
                                          specificPlatformPathsByPlatform.put(os, pathsForOs);
                                      }
                                      pathsForOs.add(test.getAbsolutePath());
                                  }
                              }
                          }
                          break;
                      }
                      default:
                          break;
                  }
              }
              //add in (all) the NLS files for this featuredef.. if any..
              for (File nls : fd.getLocalizationFiles()) {
                  if (nls.exists()) {
                      absPathsForLibertyContent.add(nls.getAbsolutePath());
                  }
              }
  
              //add in the manifest for the feature itself .. 
              File featureFile = fd.getFeatureDefinitionFile();
              if (featureFile != null) {
                  absPathsForLibertyContent.add(featureFile.getAbsolutePath());
              }
              File checksumFile = fd.getFeatureChecksumFile();
              if (checksumFile != null) {
                  absPathsForLibertyContent.add(checksumFile.getAbsolutePath());
              }
  
              String repoType = fd.getBundleRepositoryType();
              //work out if this content is a product extension and if it is include its properties file
              if (repoType != null && !ExtensionConstants.CORE_EXTENSION.equals(repoType)
                  && !ExtensionConstants.USER_EXTENSION.equals(repoType)) {
                  //not core or user, must be a product extension
                  extensionRepos.add(repoType);
              }
  
              // Add in any Icon files
              File featureDefinitionFile = fd.getFeatureDefinitionFile();
              if (featureDefinitionFile != null) {
                  File featureDefinitionParent = featureDefinitionFile.getParentFile();
                  Collection<String> expectedIcons = fd.getIcons();
                  if (featureDefinitionParent != null && expectedIcons != null) {
                      File iconsFolder = new File(featureDefinitionParent, "icons/" + fd.getSymbolicName());
                      scanFolderForIcons(absPathsForLibertyContent, iconsFolder.getAbsolutePath(), iconsFolder, expectedIcons);
                  }
              }
  
          }
  
          //if there are any extensions in use we need to bring their wlp/etc/extensions/*.properties file along
          for (String extensionRepo : extensionRepos) {
              WsResource extensionProperties = locationService.getRuntimeResource("etc/extensions/" + extensionRepo + ".properties");
              absPathsForLibertyContent.add(locationService.resolveResource(extensionProperties.toRepositoryPath()).asFile().getAbsolutePath());
          }
  
          //this odd looking bit of code will take the current list of files identified,
          //and if any are jars, will look in them to see if they have manifest classpaths
          //if so, the jars referenced by the manifest classpaths are added to the manifestJars
          //argument.
          //We have to start by passing both args as the current set of content (but using different set instances).
          Set<String> manifestJars = new HashSet<String>();
          manifestJars.addAll(absPathsForLibertyContent);
          gatherManifestClasspathJars(absPathsForLibertyContent, manifestJars);
          manifestJars.removeAll(absPathsForLibertyContent);
  
          //now manifestJars contains any jars that we didn't already know about, discovered via manifests.
          absPathsForLibertyContent.addAll(manifestJars);
  
          //process the fixes set of fix xml's, and add the required ones to the set of files to keep.
          addRequiredFixFiles(installRoot, absPathsForLibertyContent, fixes);
  
          final String OS_REMOVE_CHAR = "-";
  
          //publish the service that will be used by the launcher to read back the data.
          final Dictionary<String, Object> d = new Hashtable<String, Object>();
          final String[] pathArray = absPathsForLibertyContent.toArray(new String[] {});
  
          bundleContext.registerService(ServerContent.class, new ServerContent() {
              @Override
              public String[] getServerContentPaths(String osRequest) throws IOException {
                  if (osRequest == null || osRequest.isEmpty() || "all".equals(osRequest))
                      return pathArray;
                  else {
                      //filter paths as required.. then return them..                                       
                      String[] osNames = osRequest.split(",");
                      boolean add = true;
  
                      //check if this is an add, or a remove.
                      //if both are specified, remove wins ;p
                      for (String osName : osNames) {
                          if (osName.startsWith(OS_REMOVE_CHAR)) {
                              add = false;
                          }
                      }
  
                      if (add) {
                          //someone has named an os (or os's) they want
                          //so we remove everything, and add back just those os's.
                          for (Map.Entry<String, List<String>> me : specificPlatformPathsByPlatform.entrySet()) {
                              absPathsForLibertyContent.removeAll(me.getValue());
                          }
                          for (String osName : osNames) {
                              if (!osName.startsWith(OS_REMOVE_CHAR)) {
                                  List<String> osPaths = specificPlatformPathsByPlatform.get(osName);
                                  if (osPaths != null && !osPaths.isEmpty()) {
                                      absPathsForLibertyContent.addAll(osPaths);
  
                                      //verify the requested paths File.exists .. otherwise 
                                      //this could be an error ?
                                      for (String osPath : osPaths) {
                                          if (!FileUtils.fileExists(new File(osPath))) {
                                              throw new FileNotFoundException(osPath);
                                          }
                                      }
                                  }
                              }
                          }
                      } else {
                          //user request 'all except this platform' type filter..
                          for (String osName : osNames) {
                              if (osName.startsWith(OS_REMOVE_CHAR)) {
                                  osName = osName.substring(1);
                                  List<String> osPaths = specificPlatformPathsByPlatform.get(osName);
                                  if (osPaths != null && !osPaths.isEmpty()) {
                                      absPathsForLibertyContent.removeAll(osPaths);
                                      //in this kind of filter, we don't need to test at all.
                                  }
                              } else {
                                  List<String> osPaths = specificPlatformPathsByPlatform.get(osName);
                                  if (osPaths != null && !osPaths.isEmpty()) {
                                      //verify the requested paths File.exists .. otherwise 
                                      //this could be an error.
                                      for (String osPath : osPaths) {
                                          if (!FileUtils.fileExists(new File(osPath))) {
                                              throw new FileNotFoundException(osPath);
                                          }
                                      }
                                  }
                              }
                          }
                      }
  
                      //return newly filtered data
                      return absPathsForLibertyContent.toArray(new String[] {});
                  }
              }
          }, d);
  
          //we're done here.. let liberty proceed to declare itself 'started' =)
      }