Liste certificats LDAP Documentum

Lors de l'installation d'un annuaire LDAP, il est parfois nécessaire d'injecter un certificat au niveau de la Docbase. Il est parfois nécessaire de connaître les certificats déjà installés. Ceci est faisable sous DA, mais cela est totalement réalisable en script API.

Cet article se propose de lister les différentes commandes afin de lister les certificats.

Votre avis

Nobody voted on this yet  You need to enable JavaScript to vote

Tweet

Analyse DA

Définition composant

Le composant ldapcertdblist est utilisé pour lister les certificats installés. Il est défini dans le fichier webcomponent/config/admin/ldapcertdb/ldapcertdblist_component.xml avec la configuration suivante:

Configuration composant 

<config version='1.0'>
   <scope>

      <component id="ldapcertdblist">

         <!-- Component Layout -->
         <pages>
            <start>/webcomponent/admin/ldapcertdb/ldapcertdblist.jsp</start>
            <failover>/webcomponent/admin/ldapcertdb/ldapcertdberror.jsp</failover> 
         </pages>

         <!-- Component Behavior -->
         <class>com.documentum.webcomponent.admin.ldapcertdb.LdapCertDbList</class>
         <nlsbundle>com.documentum.webcomponent.admin.ldapcertdb.LdapCertDbListNlsProp</nlsbundle>

         <!-- Component specific Configuration -->
         <helpcontextid>ldapcertdblist</helpcontextid>
         <objecttype>dm_ldap_certificate</objecttype> 

      </component>

   </scope>
</config>

Tout le code est réalisé dans la classe JAVA associée.

Classe d'instance

La récupération des certificats s'effectue dans la méthode initDataGrid.

Classe instance 

package com.documentum.webcomponent.admin.ldapcertdb;

import com.documentum.fc.client.IDfPersistentObject;
import com.documentum.fc.client.IDfSession;
import com.documentum.fc.common.DfException;
import com.documentum.fc.common.IDfLoginInfo;
import com.documentum.web.common.AccessibilityService;
import com.documentum.web.common.ArgumentList;
import com.documentum.web.common.ErrorMessageService;
import com.documentum.web.form.control.databound.DataProvider;
import com.documentum.web.form.control.databound.Datagrid;
import com.documentum.web.form.control.databound.TableResultSet;
import com.documentum.web.formext.control.action.ActionMultiselect;
import com.documentum.webcomponent.admin.databound.DataRow;
import com.documentum.webcomponent.admin.databound.DataRowManager;
import com.documentum.webcomponent.admin.dbconfig.ConfigurationList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

public class LdapCertDbList extends ConfigurationList
{
  public static final String CONTROL_BREADCRUMB = "breadcrumb";
  public static final String CONTROL_HEADER = "controlheader";
  public static final String MULTISELECT_CONTROL = "multiselect";
  private TableResultSet m_resultSet = null;
  private boolean m_isMethodServerRunning = true;
  public static final String CONTROL_GRID = "grouplistgrid";
  private static final String PREF_CLASSIC_CABINETS = "application.display.classic_certdblist_columns";
  private static final String LOC_OBJECT_QUERY = "dm_location where object_name='ldapcertdb_loc'";

  public void onInit(ArgumentList args)
  {
    super.onInit(args);

    ActionMultiselect multiSelect = (ActionMultiselect)getControl("multiselect", ActionMultiselect.class);
    multiSelect.setOnComplete("onComplete");
    initDataGrid();

    initColumnWidths("grouplistgrid", "application.display.classic_certdblist_columns");
    initBreadCrumbs();
  }

  public void initDataGrid()
  {
    IDfSession session = getDfSession();
    String dataBasepath = "";
    try
    {
      IDfPersistentObject locObject = getDfSession().getObjectByQualification("dm_location where object_name='ldapcertdb_loc'");
      dataBasepath = locObject.getString("file_system_path");
      StringBuffer arguments = new StringBuffer();
      arguments.append("-operation_id ");
      arguments.append("display");
      arguments.append(" -launch_type ");
      arguments.append("auto");
      arguments.append(" -user_name ");
      arguments.append(session.getLoginInfo().getUser());
      arguments.append(" -repository_name ");
      arguments.append(session.getDocbaseName());
      arguments.append(" -database_path ");
      arguments.append(dataBasepath);
      arguments.append(" -user_domain ");
      arguments.append(session.getLoginInfo().getDomain());

      CertDbInfoCache.initialize(getDfSession(1), arguments.toString());
    }
    catch (DfException e)
    {
      this.m_isMethodServerRunning = false;
      setComponentPage("failover");
    }

    if (this.m_isMethodServerRunning)
    {
      this.m_resultSet = getLdapCertDbList().getTableResultSet();

      ((Datagrid)getControl("grouplistgrid", Datagrid.class)).getDataProvider().setScrollableResultSet(this.m_resultSet);
    }
  }

  public void onRefreshData()
  {
    super.onRefreshData();

    if (this.m_isMethodServerRunning)
    {
      if (AccessibilityService.isAllAccessibilitiesEnabled())
      {
        this.m_resultSet = getLdapCertDbList().getTableResultSet();
        ((Datagrid)getControl("grouplistgrid", Datagrid.class)).getDataProvider().setScrollableResultSet(this.m_resultSet);
      }
      ((Datagrid)getControl("grouplistgrid", Datagrid.class)).getDataProvider().refresh(this.m_resultSet);
    }
  }

  public void onRender()
  {
    super.onRender();
    if (this.m_isMethodServerRunning)
    {
      Datagrid datagrid = (Datagrid)getControl("grouplistgrid", Datagrid.class);
      readPreferences(datagrid);
    }
  }

  private DataRowManager getLdapCertDbList()
  {
    DataRowManager ldapCertDbListMgr = new DataRowManager(LdapCertDbRow.COLUMNS);
    try
    {
      Collection certDataCollection = CertDbInfoCache.fetchCertDbCollection();
      Iterator e = certDataCollection.iterator();

      while (e.hasNext())
      {
        ldapCertDbListMgr.addDataRow((DataRow)e.next());
      }

    }
    catch (Exception ex)
    {
      ErrorMessageService.getService().setNonFatalError(getForm(), ex.getMessage(), ex);
    }

    return ldapCertDbListMgr;
  }

  public void onComplete(String strAction, boolean bSuccess, Map map)
  {
    if (strAction.equals("ldapcertimport"))
    {
      this.m_resultSet = getLdapCertDbList().getTableResultSet();
      ((Datagrid)getControl("grouplistgrid", Datagrid.class)).getDataProvider().setScrollableResultSet(this.m_resultSet);
    }
  }
}

Les données qui viennent peuplées la grille ne proviennent pas d'une requête DQL mais du résultat d'une méthode serveur, donc le commande d'exécution est construite dans la méthode initDataGrid. La première opération consiste à récupérer l'emplacement défini dans l'objet dm_location dont le nom est ldapcertdb_loc. Cette valeur est utilisée pour l'argument database_path.

Puis ceci est envoyé à la méthode initialize de la classe CertDbInfoCache, dans le même package.

Classe CertDbInfoCache

Classe instance 

package com.documentum.webcomponent.admin.ldapcertdb;

import com.documentum.admin.DaSession;
import com.documentum.admin.IDaSession;
import com.documentum.fc.client.IDfCollection;
import com.documentum.fc.client.IDfDocument;
import com.documentum.fc.client.IDfPersistentObject;
import com.documentum.fc.client.IDfSession;
import com.documentum.fc.commands.admin.IDfApplyDoMethod;
import com.documentum.fc.common.DfException;
import com.documentum.fc.common.DfId;
import com.documentum.fc.common.DfPreferences;
import com.documentum.fc.common.IDfLoginInfo;
import java.io.File;
import java.util.Collection;
import java.util.HashMap;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class CertDbInfoCache
{
  private static HashMap<String, LdapCertDbRow> nickNametoInfoMap;
  private static String METHOD_NAME = "dm_LDAPCertDbAutomation";
  private static String CERTDB_NAME = "certdb.xml";
  private static String CERTDB_PARSE_EXCPETION = "MSG_CERTDB_PARSEEXCEPTION";
  private static String CERT_DB_CACHE_EXCEPTION = "MSG_CERTDB_CACHE_ERROR";
  private static String CERT_OBJECT_TAG = "cert-object";
  private static final String LOC_OBJECT_QUERY = "dm_location where object_name='ldapcertdb_loc'";

  public static void initialize(IDfSession session, String arguments)
    throws DfException
  {
    String objId = runApplyMethod(session, arguments);
    fetchResultDoc(session, objId);
    buildResultMap();
  }

  public static String runApplyMethod(IDfSession session, String arguments)
    throws DfException
  {
    IDfCollection resultCollection = null;
    try
    {
      String objId = null;
      IDaSession daSession = DaSession.getDaSession(session);

      IDfApplyDoMethod applyMethod = (IDfApplyDoMethod)daSession.getCommand(106);
      applyMethod.setMethod(METHOD_NAME);
      applyMethod.setArguments(arguments);
      applyMethod.setLaunchDirect(true);
      applyMethod.setSaveResults(true);
      applyMethod.setRunAsServer(true);
      applyMethod.setTraceLaunch(true);
      resultCollection = applyMethod.execute(session);
      while (resultCollection.next())
      {
        objId = resultCollection.getString("result_doc_id");
      }

      String str1 = objId;
      return str1;
    }
    catch (DfException ex)
    {
      throw new DfException(ex);
    }
    finally
    {
      if (resultCollection != null)
      {
        resultCollection.close(); } 
    }throw localObject;
  }

  private static void fetchResultDoc(IDfSession session, String objId)
    throws DfException
  {
    IDfDocument resultDoc = null;
    try
    {
      resultDoc = (IDfDocument)session.getObject(new DfId(objId));
      resultDoc.getFile(DfPreferences.getInstance().getDataDirectory() + File.separator + CERTDB_NAME);
    }
    finally
    {
      if (resultDoc != null)
      {
        resultDoc.destroy();
      }
    }
  }

  private static void buildResultMap()
    throws DfException
  {
    try
    {
      nickNametoInfoMap = new HashMap();
      File resultDoc = new File(DfPreferences.getInstance().getDataDirectory() + File.separator + CERTDB_NAME);
      DocumentBuilderFactory parserFactory = DocumentBuilderFactory.newInstance();
      DocumentBuilder docBuilder = parserFactory.newDocumentBuilder();
      Document parsedDoc = docBuilder.parse(resultDoc);
      NodeList certNodes = parsedDoc.getElementsByTagName(CERT_OBJECT_TAG);

      for (int i = 0; i < certNodes.getLength(); i++)
      {
        Node certNode = certNodes.item(i);
        LdapCertDbRow certDataRow = new LdapCertDbRow();
        NodeList childNodes = certNode.getChildNodes();
        for (int j = 0; j < childNodes.getLength(); j++)
        {
          Node attributeNode = childNodes.item(j);
          addAttribute(certDataRow, attributeNode.getNodeName(), attributeNode.getTextContent());
        }

        nickNametoInfoMap.put(certDataRow.getNickName(), certDataRow);
      }

    }
    catch (Exception e)
    {
      throw new DfException(CERTDB_PARSE_EXCPETION);
    }
  }

  private static void addAttribute(LdapCertDbRow dataRow, String attribute, String value)
  {
    switch (1.$SwitchMap$com$documentum$webcomponent$admin$ldapcertdb$LdapCertDbAttributes[LdapCertDbAttributes.valueOf(attribute).ordinal()]) {
    case 1:
      dataRow.setNickName(value); break;
    case 2:
      dataRow.setIssuedBy(value); break;
    case 3:
      dataRow.setIssuedTo(value); break;
    case 4:
      dataRow.setValidFrom(value); break;
    case 5:
      dataRow.setValidTo(value); break;
    case 6:
      dataRow.setSignAlg(value); break;
    case 7:
      dataRow.setSerialNum(value); break;
    case 8:
      dataRow.setVersion(value);
    }
  }

  public static void invalidateInMemoryCache(IDfSession session)
    throws DfException
  {
    nickNametoInfoMap = null;
    IDfPersistentObject locObject = session.getObjectByQualification("dm_location where object_name='ldapcertdb_loc'");
    String dataBasepath = locObject.getString("file_system_path");
    StringBuffer arguments = new StringBuffer();
    arguments.append("-operation_id ");
    arguments.append("display");
    arguments.append(" -launch_type ");
    arguments.append("auto");
    arguments.append(" -user_name ");
    arguments.append(session.getLoginInfo().getUser());
    arguments.append(" -repository_name ");
    arguments.append(session.getDocbaseName());
    arguments.append(" -database_path ");
    arguments.append(dataBasepath);
    arguments.append(" -user_domain ");
    arguments.append(session.getLoginInfo().getDomain());
    initialize(session, arguments.toString());
  }

  public static LdapCertDbRow fetchDataRow(String key)
    throws DfException
  {
    if ((nickNametoInfoMap == null) || (!nickNametoInfoMap.containsKey(key))) {
      throw new DfException(CERT_DB_CACHE_EXCEPTION);
    }
    return (LdapCertDbRow)nickNametoInfoMap.get(key);
  }

  public static Collection<LdapCertDbRow> fetchCertDbCollection()
    throws DfException
  {
    if (nickNametoInfoMap == null) {
      throw new DfException(CERT_DB_CACHE_EXCEPTION);
    }
    return nickNametoInfoMap.values();
  }
}

Nous passerons sur le fait que tout est en statique. Ce qui fait que si plusieurs personnes travaille sur DA en même temps, cela peut poser problème. Une fois la méthode serveur (dm_LDAPCertDbAutomation) exécutée, un identifiant de document est retourné. Celui-ci, au format XML, contient le listing des certificats installés.

Mais dans le cadre de cette étude, nous avons suffisamment d'informations pour effectuer les opérations manuellement.

Exécution

L'analyse de DA a permis d'identifier toutes les actions nécessaire pour effectuer tout cela avec un simple Samson.

La première action est donc de récupérer l'emplacement de ldapcertdb_loc

API> retrieve,c,dm_location where object_name='ldapcertdb_loc'
...
3a13f97280000146
API> get,c,l,file_system_path
...
/logiciels/dctm/6.7_sp1/dba/secure/ldapdb

Il faut conserver car utiliser dans l'appel de la méthode serveur. Dans l'exemple de commande, le compte de conenxion est dmadmin et la docbase my_docbase.

API> apply,c,NULL,DO_METHOD,METHOD,S,dm_LDAPCertDbAutomation,ARGUMENTS,S,-operation_id display -launch_type auto 
-user_name dmadmin -repository_name my_docbase -database_path /logiciels/dctm/6.7_sp1/dba/secure/ldapdb 
-user_domain,LAUNCH_DIRECT,B,T,SAVE_RESULTS,B,T,RUN_AS_SERVER,B,T,TRACE_LAUNCH,B,T
...
q0

Dans le cas où tout fonctionne correctement, la commande va retourner un identifiant de collection. Donc comme toute collection, il faut appeler la commande next dessus afin de lire les résultats.

API> next,c,q0
...
Ok

Etant en API, le plus simple est de demandé un dump de la "ligne" en cours de lecture suite à la commande next.

API> dump,c,q0
...
USER ATTRIBUTES

  result                     : 0913f97280223d01
  result_doc_id              : 0913f97280223d01
  process_id                 : 0
  launch_failed              : F
  method_return_val          : 0
  os_system_error            : No Error
  timed_out                  : F
  time_out_length            : 86400
  app_server_host_name       : localhost
  app_server_port            : 9040
  app_server_uri             : /DmMethods/servlet/DoMethod
  error_message              : 

SYSTEM ATTRIBUTES


APPLICATION ATTRIBUTES


INTERNAL ATTRIBUTES

Comme toute collection, il faut la fermer.

API> close,c,q0
...
Ok

Les "attributs" result et result_doc_id donne l'identifiant du document créé en base, et qui contient la liste des certificats installés. Il ne reste plusqu'à le télécharger à l'aide de la commande getfile

API> getfile,c,0913f97280223d01
...
C:\logiciels\samson\dmcl\0013f972\130\80005d20\Resulta47da296.txt

Une fois téléchargé, il n'est pas nécessaire de conserver le document dans la docbase. Il suffit de le supprimer avec la commande destroy.

API> destroy,c,0913f97280223d01
...
Ok

Le contenu du fichier est au format XML et doit ressembler à quelque chose comme ceci:

<?xml version="1.0" encoding="UTF-8" ?> 
<cert-database>
	<cert-object>
		<nickname>...</nickname>
		<issuedto>...</issuedto>
		<issuedby>...</issuedby>
		<validfrom>...</validfrom>
		<validto>...</validto>
		<signalg>...</signalg>
		<serialnum>...</serialnum>
		<version>...</version> 
	</cert-object>
	<cert-object>
		<nickname>...</nickname>
		<issuedto>...</issuedto>
		<issuedby>...</issuedby>
		<validfrom>...</validfrom>
		<validto>...</validto>
		<signalg>...</signalg>
		<serialnum>...</serialnum>
		<version>...</version> 
	</cert-object>
</cert-database>

Il y a autant de noeud cert-object qu'il y a de certificats installés.

Annexe

Cet article a mis en évidence l'utilisation de la méthode serveur dm_LDAPCertDbAutomation, dont la définition est la suivante:

 object_name                : dm_LDAPCertDbAutomation
 title                      : Docbase
 subject                    : 
 authors                  []: <none>
 keywords                 []: <none>
 resolution_label           : 
 owner_name                 : dmadmin
 owner_permit               : 7
 group_name                 : docu
 group_permit               : 1
 world_permit               : 1
 log_entry                  : 
 acl_domain                 : my_docbaseowner
 acl_name                   : dm_acl_superusers
 language_code              : 
 method_verb                : com.documentum.ldap.ldapcertdb.LDAPCertDbAutomation 
 method_args              []: <none>
 timeout_min                : 30
 timeout_max                : 604800
 timeout_default            : 86400
 launch_direct              : F
 launch_async               : F
 trace_launch               : F
 run_as_server              : T
 use_method_content         : F
 method_type                : java
 use_method_server          : T
 success_return_codes     []: <none>
 success_status             : 
 is_restartable             : F