# DirectoryDiff.java

    /*
    ** Module   : DirectoryDiff.java
    ** Abstract : compare and report on two directory trees
    **
    ** Copyright (c) 2006-2023, Golden Code Development Corporation.
    **
    ** -#- -I- --Date-- --JPRM-- ----------------Description-----------------
    ** 001 NVS 20060808   @28502 Created initial version
    ** 002 NVS 20060808   @28518 Added new feature: comparison of a branch vs
    **                           the whole directory. A branch can be commonly
    **                           named in both directories or even have two
    **                           different names.
    ** 003 GES 20061215   @31703 Changes in bootstrap config interface.
    ** 004 GES 20101117          Switched to new static schema loader that reads
    **                           from well-known resources rather than a manually
    **                           defined configuration file.
    ** 005 GBB 20230512          Logging methods replaced by CentralLogger/ConversionStatus.
    */
    /*
    ** This program is free software: you can redistribute it and/or modify
    ** it under the terms of the GNU Affero General Public License as
    ** published by the Free Software Foundation, either version 3 of the
    ** License, or (at your option) any later version.
    **
    ** This program is distributed in the hope that it will be useful,
    ** but WITHOUT ANY WARRANTY; without even the implied warranty of
    ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ** GNU Affero General Public License for more details.
    **
    ** You may find a copy of the GNU Affero GPL version 3 at the following
    ** location: https://www.gnu.org/licenses/agpl-3.0.en.html
    **
    ** Additional terms under GNU Affero GPL version 3 section 7:
    **
    **   Under Section 7 of the GNU Affero GPL version 3, the following additional
    **   terms apply to the works covered under the License.  These additional terms
    **   are non-permissive additional terms allowed under Section 7 of the GNU
    **   Affero GPL version 3 and may not be removed by you.
    **
    **   0. Attribution Requirement.
    **
    **     You must preserve all legal notices or author attributions in the covered
    **     work or Appropriate Legal Notices displayed by works containing the covered
    **     work.  You may not remove from the covered work any author or developer
    **     credit already included within the covered work.
    **
    **   1. No License To Use Trademarks.
    **
    **     This license does not grant any license or rights to use the trademarks
    **     Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
    **     of Golden Code Development Corporation. You are not authorized to use the
    **     name Golden Code, FWD, or the names of any author or contributor, for
    **     publicity purposes without written authorization.
    **
    **   2. No Misrepresentation of Affiliation.
    **
    **     You may not represent yourself as Golden Code Development Corporation or FWD.
    **
    **     You may not represent yourself for publicity purposes as associated with
    **     Golden Code Development Corporation, FWD, or any author or contributor to
    **     the covered work, without written authorization.
    **
    **   3. No Misrepresentation of Source or Origin.
    **
    **     You may not represent the covered work as solely your work.  All modified
    **     versions of the covered work must be marked in a reasonable way to make it
    **     clear that the modified work is not originating from Golden Code Development
    **     Corporation or FWD.  All modified versions must contain the notices of
    **     attribution required in this license.
    */

    package com.goldencode.p2j.directory;

    import java.util.*;
    import com.goldencode.p2j.cfg.*;
    import com.goldencode.p2j.util.logging.*;

    /**
     * This class compares two directories and reports the differences.
     * <p>
     * To be able to compare directories, this class needs access to any directory
     * schema extension files and the directories to compare. The extensions (if
     * they exist) are loaded from application-specific JAR files in the classpath.
     * <p>
     * The directories to compare are specified with the command line and can be
     * anywhere.
     * <p>
     * The class starts with the root node and compares every node in both
     * directories. Nodes are treated as different, if they have different object
     * class or different number or order of attribute values.
     * <p>
     * Every found difference is reported to the standard output. The first
     * directory in the command line is marked as L (meaning Left) and the second
     * one is marked as R (meaning Right).
     * <p>
     * This is the first cut of this utility class. It can be enhanced in multiple
     * directions:
     * <ul>
     *   <li>the output can be made clearer; a good example to follow is the
     *       GCD COMPDIRS utility;
     *   <li>functionality can be added to:
     *     <ul>
     *       <li>limit the comparison to only the specified branch of tree;
     *       <li>exclude some branches from comparison;
     *       <li>exclude some attributes from comparison;
     *       <li>compare only listed attributes;
     *       <li>produce a diff tree as a file;
     *       <li>synchronize trees selectively etc.
     *     </ul>
     * </ul>
     *
     * @author  NVS
     */
    public class DirectoryDiff
    {
       /** Logger */
       private static final CentralLogger LOG = CentralLogger.get(DirectoryDiff.class);

       /** backend for the first file */
       private Remapper r1 = null;

       /** backend for the first file */
       private Remapper r2 = null;

       /** starting left directory path */
       private String pathL = "";

       /** starting right directory path */
       private String pathR = "";

       /**
        * Construct an instance of DirectoryDiff for the given command line
        * parameters.
        *
        * @param   args
        *          Command line parameters. Expected are two file names for the
        *          first (left) and the second (right) directories.
        * @throws  ConfigurationException
        *          In case of configuration error.
        */
       public DirectoryDiff(String[] args)
       throws ConfigurationException
       {
          if (args.length < 2 || args.length > 4)
          {
             say("Usage: java DirectoryDiff left-dir.xml right-dir.xml " +
                 "[ path | left-path [ right-path] ]");

             throw new ConfigurationException("");
          }

          if (args.length > 2)
          {
             pathL = args[2];
             pathR = args[2];
          }

          if (args.length == 4)
             pathR = args[3];

          // Empty BootstrapConfigs
          BootstrapConfig bc1 = new BootstrapConfig(null, null, null, null);
          BootstrapConfig bc2 = new BootstrapConfig(null, null, null, null);

          // directory package configuration
          bc1.setServer(true);
          bc1.setConfigItem("directory", "backend", "type",     "xml");
          bc1.setConfigItem("directory", "xml",     "filename", args[0]);

          bc2.setServer(true);
          bc2.setConfigItem("directory", "backend", "type",     "xml");
          bc2.setConfigItem("directory", "xml",     "filename", args[1]);

          // initialize directory schema
          SchemaLoad.initSchema();

          // instantiating directory tree backends
          r1 = DirectoryService.genRemapper(bc1);
          r2 = DirectoryService.genRemapper(bc2);
       }

       /**
        * Shortcut for the System.out.prinln()
        *
        * @param   msg
        *          Message to print to standard output.
        */
       static void say(String msg)
       {
          System.out.println(msg);
       }

       /**
        * Main application worker routine.
        *
        */
       private void run()
       {
          boolean res = true;

          // binding to the directories
          do
          {
             res = r1.bind();

             if (!res)
             {
                say("Binding to left directory failed");
                break;
             }

             res = r2.bind();

             if (!res)
             {
                say("Binding to right directory failed");
                break;
             }
          }
          while (false);

          if (!res)
             return;

          // do comparison
          boolean rc = diffNodes(pathL, pathR);

          // unbinding from the directories
          res = r1.unbind();

          if (!res)
             say("Unbinding from tree 1 failed");

          res = r2.unbind();

          if (!res)
             say("Unbinding from tree 2 failed");

          if (rc)
             say("Directories are identical");
       }

       /**
        * Compares two nodes.
        *
        * @param   nid1
        *          node ID for the first tree node
        * @param   nid2
        *          node ID for the second tree node
        */
       private boolean diffNodes(String nid1, String nid2)
       {
          boolean rc = true;

          // compare the directory node class
          String oc1 = r1.getNodeClassName(nid1);
          String oc2 = r2.getNodeClassName(nid2);
          String pid1 = new String("L '" + nid1 + "' (" + oc1 + ") ");
          String pid2 = new String("R '" + nid2 + "' (" + oc2 + ") ");
          if (!oc1.equals(oc2))
          {
             say("Object classes mismatch; attributes comparison skipped");
             say(pid1);
             say(pid2);
             rc = false;
          }

          // compare attributes if of the same class
          Set sa1 = new HashSet();
          Set sa2 = new HashSet();
          Set su1 = new HashSet();
          Set su2 = new HashSet();
          Set sc  = new HashSet();

          if (rc)
          {
             // enumerate attributes
             AttributeDefinition[] a1 = r1.enumerateNodeAttributes(nid1);
             int la1 = a1 == null ? 0 : a1.length;
             for (int i = 0; i < la1; i ++)
                sa1.add(a1[i].getName());

             AttributeDefinition[] a2 = r2.enumerateNodeAttributes(nid2);
             int la2 = a2 == null ? 0 : a2.length;
             for (int i = 0; i < la2; i ++)
                sa2.add(a2[i].getName());

             // separate attributes into 3 groups: 1st only, common, 2nd only
             su1.addAll(sa1);
             su1.removeAll(sa2);
             su2.addAll(sa2);
             su2.removeAll(sa1);
             sc.addAll(sa1);
             sc.retainAll(sa2);

             // report unique attributes from the 1st node
             if (su1.size() != 0)
             {
                say(pid1 + "has unique attributes:");

                Iterator s = su1.iterator();
                while (s.hasNext())
                {
                   String name = (String)s.next();
                   say("   '" + name + "'");
                }

                rc = false;
             }

             // report unique attributes from the 2nd node
             if (su2.size() != 0)
             {
                say(pid2 + "has unique attributes:");

                Iterator s = su2.iterator();
                while (s.hasNext())
                {
                   String name = (String)s.next();
                   say("   '" + name + "'");
                }

                rc = false;
             }

             // compare attribute values from the common set
             if (sc.size() != 0)
             {
                Iterator s = sc.iterator();
                while (s.hasNext())
                {
                   String name = (String)s.next();
                   Attribute al1 = DirectoryService.getNodeAttribute(r1, nid1,
                                                                     name);
                   Attribute al2 = DirectoryService.getNodeAttribute(r2, nid2,
                                                                     name);
                   String[] v1 = al1 == null ? null : al1.getValues();
                   String[] v2 = al2 == null ? null : al2.getValues();
                   int l1 = v1 == null ? 0 : v1.length;
                   int l2 = v2 == null ? 0 : v2.length;

                   boolean rcc = l1 == l2;
                   if (rcc && l1 > 0)
                   {
                      for (int i = 0; i < l1; i ++)
                      {
                         if (!v1[i].equals(v2[i]))
                         {
                            rcc = false;
                            break;
                         }
                      }
                   }

                   // report discrepancies
                   if (!rcc)
                   {
                      say(pid1 + "attribute '" + name +
                          "' has different value(s):");
                      for (int i = 0; i < l1; i ++)
                         say("   " + v1[i]);

                      say(pid2 + "attribute '" + name +
                          "' has different value(s):");
                      for (int i = 0; i < l2; i ++)
                         say("   " + v2[i]);
                   }

                   if (rc && !rcc)
                      rc = false;
                }
             }
          }

          // enumerate child nodes
          String[] n1 = r1.enumerateNodes(nid1);
          int la1 = n1 == null ? 0 : n1.length;
          sa1.clear();
          for (int i = 0; i < la1; i ++)
             sa1.add(n1[i]);

          String[] n2 = r2.enumerateNodes(nid2);
          int la2 = n2 == null ? 0 : n2.length;
          sa2.clear();
          for (int i = 0; i < la2; i ++)
             sa2.add(n2[i]);

          // separate children into 3 groups: 1st only, common, 2nd only
          su1.clear();
          su2.clear();
          sc.clear();
          su1.addAll(sa1);
          su1.removeAll(sa2);
          su2.addAll(sa2);
          su2.removeAll(sa1);
          sc.addAll(sa1);
          sc.retainAll(sa2);

          // report unique children from the 1st node
          if (su1.size() != 0)
          {
             say(pid1 + "has unique children:");

             Iterator s = su1.iterator();
             while (s.hasNext())
             {
                String name = (String)s.next();
                say("   '" + name + "' (" +
                    r1.getNodeClassName(new String(nid1 + "/" + name)) + ")");
             }

             rc = false;
          }

          // report unique attributes from the 2nd node
          if (su2.size() != 0)
          {
             say(pid2 + "has unique children:");

             Iterator s = su2.iterator();
             while (s.hasNext())
             {
                String name = (String)s.next();
                say("   '" + name + "' (" +
                    r2.getNodeClassName(new String(nid2 + "/" + name)) + ")");
             }

             rc = false;
          }

          // compare child nodes from the common set
          if (sc.size() != 0)
          {
             Iterator s = sc.iterator();
             while (s.hasNext())
             {
                String name = (String)s.next();
                String nc1 = new String(nid1 + "/" + name);
                String nc2 = new String(nid2 + "/" + name);
                boolean rcc = diffNodes(nc1, nc2);
                if (rc && !rcc)
                   rc = false;
             }
          }

          // return
          return rc;
       }

       /**
        * Application entry point.
        *
        * @param   args
        *          Command line parameters.
        */
       public static void main(String[] args)
       {
          DirectoryDiff dir = null;

          try
          {
             dir = new DirectoryDiff(args);
             dir.run();
          }
          catch (ConfigurationException e)
          {
             LOG.severe("", e);
          }
       }
    }