FWD » Core Development » Runtime Infrastructure

** 039 CA  20180504          Added support for folder aliasing: these are specified via the

**                           "path-aliases" per-server directory node, and provide a mapping of

**                           alias folder name to their 'source' counterpart.  Also, added support

**                           to identify the target source program for a RUN program.r statement.

import java.util.function.*;

import java.util.logging.*;

import com.goldencode.p2j.directory.*;

   /** logger */

   private static final Logger LOG = LogHelper.getLogger(SourceNameMapper.class.getName());

   /** Map of aliases (r-code folders) to their source folders (conversion folders). */

   private static Map<String, String> pathAliases = null;

   /**

    * Map of program names without extension to the programs which can be resolved with this name. 

    */

   private static volatile Map<String, List<ExternalProgram>> p2jNonExtMap = null;

    * <p>

    * If no program name is explicitly found with a <code>.r</code> extension, R-code program 

    * names are looked up using the {@link #p2jNonExtMap} (the program name without the extension).

    * <p> 

    * If {@link #pathAliases} is specified, and the program can be found (as it is or after 

    * removing the <code>.r</code> extension) in the propath, the lookup falls back to resolving

    * the aliased folders in the program name, via {@link #resolvePathAliases}.

    * 

    * 

      Function<String, ExternalProgram> lookupDirectName;

      Function<String, ExternalProgram> lookupCompiledRcode;

      Function<String, ExternalProgram> lookupAliasedDirectName;

      Function<String, ExternalProgram> lookupAliasedCompiledRcode;

      Function<String, Boolean> isRcode = 

         (pname -> pname.endsWith(".r") || (!caseSens && pname.endsWith(".R")));

      boolean legacyRcode = isRcode.apply(legacyProgName);

      boolean hasAliases = pathAliases != null;

      String msg = "Found first match %s for program %s, and additional %s";

      lookupDirectName = (pname -> p2jMap.get(pname));

      lookupCompiledRcode = !legacyRcode ? null : (pname ->

      {

         if (!isRcode.apply(pname))

         {

            return null;

         }

         pname = pname.substring(0, pname.length() - ".r".length());

         ExternalProgram extProg = null;

         // we could use a trie, but keeping a match of names without extension to the full 

         // program names (with extension) is easier

         List<ExternalProgram> progs = p2jNonExtMap.get(pname);

         if (progs != null && !progs.isEmpty())

         {

            extProg = progs.get(0);

            if (LOG.isLoggable(Level.WARNING))

            {

               for (int i = 1; i < progs.size(); i++)

               {

                  LOG.log(Level.WARNING, String.format(msg, 

                                                       extProg.pname, 

                                                       legacyProgName, 

                                                       progs.get(i).pname));

               }

            }

         }

         return extProg;

      });

      lookupAliasedDirectName = !hasAliases ? null : (pname ->

      {

         String[] aliases = resolvePathAliases(pname);

         ExternalProgram extProg = null;

         for (String aliasName : aliases)

         {

            ExternalProgram prog = lookupDirectName.apply(aliasName);

            if (prog != null)

            {

               if (extProg != null)

               {

                  if (LOG.isLoggable(Level.WARNING))

                  {

                     LOG.log(Level.WARNING, String.format(msg, 

                                                          extProg.pname, 

                                                          legacyProgName, 

                                                          prog.pname));

                  }

               }

               else

               {

                  extProg = prog;

               }

            }

         }

         return extProg;

      });

      lookupAliasedCompiledRcode = !legacyRcode || !hasAliases ? null : (pname ->

      {

         if (!isRcode.apply(pname))

         {

            return null;

         }

         String[] aliases = resolvePathAliases(pname);

         ExternalProgram extProg = null;

         for (String aliasName : aliases)

         {

            ExternalProgram prog = lookupCompiledRcode.apply(aliasName);

            if (prog != null)

            {

               if (extProg != null)

               {

                  LOG.log(Level.WARNING, String.format(msg, 

                                                       extProg.pname, 

                                                       legacyProgName, 

                                                       prog.pname));

               }

               else

               {

                  extProg = prog;

               }

            }

         }

         return extProg;

      });

      @SuppressWarnings("unchecked")

      Function<String, ExternalProgram>[] lookups = new Function[]

      {

         lookupDirectName,

         lookupCompiledRcode,

         lookupAliasedDirectName,

         lookupAliasedCompiledRcode,

      };

      for (Function<String, ExternalProgram> lookup : lookups)

      {

         if (lookup == null)

         {

            continue;

         }

         String[] res = convertName(legacyProgName, lookup);

         if (res != null)

         {

            return res;

         }

      }

      return null;

   }

   /**

    * Convert a Progress file name into Java class name. The input name can be an absolute file

    * name, a file name relative to current location or a file name relative to some directory

    * listed in the PROPATH variable. Before processing, the input file name is processed by

    * {@link #canonicalize}.

    * <p>

    * A simple lookup is tried first. If this fails direct check for absolute path if attempted

    * using one of the roots from {@code legacyRoots}. In multiple project scenario, the project

    * name is also added as a path token in order to match the structure from

    * {@code name_map.xml}.

    * <p>

    * If this mapping does not exist then each path segment of the PROPATH is tried in order. 

    * The given program name is check to see if it is prefixed with the PROPATH segment, if so

    * that prefix is removed and a lookup is done with this name. The first match found ends the

    * search.

    * <p>

    * Absolute paths are converted into relative paths based on the existence of a matching path

    * in the legacy PROPATH (see {@link EnvironmentOps#getLegacySearchPath}). To handle additional

    * absolute paths, one must add the appropriate path prefix to the legacy PROPATH and it will

    * be removed here.

    * <p>

    * This same PROPATH processing is how names relative to the current directory can be handled.

    * This is the only way to handle that case since the current directory in the source system is

    * runtime information that is not available here.

    * <p>

    * The legacy PROPATH is the key configuration tool by which one specifies to this method how

    * to remove absolute and current directory relative prefixes.  This means that the legacy

    * PROPATH that is used here may need to be different than the PROPATH on the original system.

    * <p>

    * As a fallback, if no mapping can be found and if the given {@code progName} is a fully

    * qualified Java class name which references a valid Java class, then the {@code progName} is

    * returned unchanged.

    * <p>

    * In Windows it can verify the absolute or relative program name is in current PROPATH 

    * directory set.  This allows to properly map the following program names used in

    * PROGRESS RUN statement:

    * "c:/path/to/project/stcases/uast/rundir/absolute/program.p"

    * "rundir/../../uast/rundir/relative/test11.p."

    * "../uast/rundir/relative/test5.p"

    *

    * @param   legacyProgName

    *          Progress file name.

    * @param   lookup

    *          The lookup function used to resolve a program name to a {@link ExternalProgram}.

    *

    * @return  A {@code String} array with two components: Java class name for the given Progress

    *          file name as first element and the legacy procedure name in second element of the

    *          array. If no appropriate mapping is present {@code null} is returned.

    */

   private static String[] convertName(String legacyProgName, 

                                       Function<String, ExternalProgram> lookup)

   {

            extProg = lookup.apply(relName);

                  extProg = lookup.apply(token + fileSep + relName);

               extProg = lookup.apply(canonicalize(relName));

         extProg = lookup.apply(canonicalize(progName));

    * Given a program name, replace all folder names which have an associated 'source' folder,

    * and return the new path.

    * 

    * @param    pname

    *           The legacy program name.

    *           

    * @return   The resolved program name.

    */

   private static String[] resolvePathAliases(String pname)

   {

      String[] entries = pname.split(fileSep);

      // for now, we replace all found aliases with their source folders;  if needed, we can 

      // compute all power sets made from pathAliases (will be 2^(pathAliases.size()) subsets)

      StringBuilder sb = new StringBuilder();

      for (int i = 0; i < entries.length - 1; i++)

      {

         String entry = entries[i];

         // if this entry is an alias, get its source

         String source = pathAliases.get(entry);

         sb.append(source == null ? entry : source).append(fileSep);

      }

      sb.append(entries[entries.length - 1]);

      return new String[] { sb.toString() };

   }

   /**

    * Load the path aliases from the directory, into the {@link #pathAliases} map.  This map 

    * contains as key the 'aliased' name which is an alias for a 'source' folder.

    * <p>

    * The directory contains these mappings in the <code>/server/default/path-aliases</code> or

    * <code>/server/&lt;server-id&gt;/path-aliases</code> node.  The child nodes have as class 

    * <code>path-alias</code> and this structure:

    * <code>

    *     <node class="path-alias" name="alias1">

    *     <br>&nbsp;&nbsp;&nbsp;

    *       <node-attribute name="source" value="src1"/>

    *       <br>&nbsp;&nbsp;&nbsp;

    *       <node-attribute name="alias" value="obj1"/>

    *       <br>

    *     </node>

    * </code>

    * <p>

    * The <code>alias1</code> name is just an unique ID for each child.

    */

   private static void loadPathAliases()

   {

      DirectoryService ds = DirectoryService.getInstance();

      if (!ds.bind())

         throw new RuntimeException("directory bind failed");

      try

      {

         String path = Utils.findDirectoryNodePath(ds, "path-aliases", "container", false);

         if (path == null)

         {

            return;

         }

         String[] aliasPaths = ds.enumerateNodes(path);

         if (aliasPaths.length == 0)

         {

            return;

         }

         pathAliases = new HashMap<>();

         for (String aliasPath : aliasPaths)

         {

            aliasPath = path + "/" + aliasPath;

            String source = ds.getNodeString(aliasPath, "source");

            String alias = ds.getNodeString(aliasPath, "alias");

            if (!caseSens)

            {

               source = source.toLowerCase();

               alias = alias.toLowerCase();

            }

            pathAliases.put(alias, source);

         }

      }

      finally

      {

         ds.unbind();

      }

   }

   /**

            p2jNonExtMap = new HashMap<>(1024);

               String nonExtName = pname;

               int lastDotIdx = nonExtName.lastIndexOf('.');

               if (lastDotIdx > 0)

               {

                  nonExtName = nonExtName.substring(0, lastDotIdx);

               }

               List<ExternalProgram> progs = p2jNonExtMap.get(nonExtName);

               if (progs == null)

               {

                  p2jNonExtMap.put(nonExtName, progs = new ArrayList<>(1));

               }

               progs.add(ep);

            loadPathAliases();

      <object-class name="path-alias" leaf="true" immutable="false">

         <class-attribute name="source" type="STRING" mandatory="false" multiple="false" immutable="false" />

         <class-attribute name="alias"  type="STRING" mandatory="false" multiple="false" immutable="false" />

      </object-class>