7.1 Utilitaire Importation/Conversion/Exportation NetIQ

Ajouter un schéma depuis un fichier

ICE peut comparer le schéma dans la source et la cible. La source est un fichier ou serveur LDAP ; la cible, un serveur LDAP. Le fichier du schéma source peut être au format LDIF ou SCH.

Si vous souhaitez simplement comparer le schéma sans ajouter de schéma supplémentaire au serveur de destination, sélectionnez l'option Ne pas ajouter mais comparer le schéma. Dans ce cas, le schéma supplémentaire n'est pas ajouté au serveur cible, mais les différences de schéma peuvent être affichées en cliquant sur le lien disponible à la fin de l'opération.

Ajouter un schéma depuis un serveur

La source et la cible sont des serveurs LDAP.

Si vous souhaitez simplement comparer le schéma sans ajouter de schéma supplémentaire au serveur de destination, sélectionnez l'option Ne pas ajouter mais comparer le schéma. Dans ce cas, le schéma supplémentaire n'est pas ajouté au serveur cible, mais les différences de schéma peuvent être affichées en cliquant sur le lien disponible à la fin de l'opération.

ice general_options
-S[LDIF | LDAP | DELIM | LOAD | SCH] source_options
-D[LDIF | LDAP | DELIM] destination_options

ice -C schema_options
-S[LDIF | LDAP] source_options
-D[LDIF | LDAP] destination_options

Options générales

Les options générales ont une incidence sur l'ensemble du traitement effectué par le moteur Importation/Conversion/Exportation NetIQ.

Options de schéma

Les options de schéma vous permettent d'utiliser le cache de schéma pour effectuer des comparaisons et des mises à jour de schémas.

Options du gestionnaire source

L'option du gestionnaire source (-S) détermine la source des données d'importation. Vous ne pouvez spécifier qu'une seule des options suivantes sur la ligne de commande.

Options du gestionnaire cible

L'option du gestionnaire cible (-D) permet de définir la cible des données d'exportation. Vous ne pouvez spécifier qu'une seule des options suivantes sur la ligne de commande.

Options du gestionnaire source LDIF

Le gestionnaire source LDIF lit les données à partir d'un fichier LDIF, puis les transmet au moteur Importation/Conversion/Exportation NetIQ.

Options du gestionnaire de destination LDIF

Le gestionnaire cible LDIF reçoit les données du moteur Importation/Conversion/Exportation NetIQ et les inscrit dans un fichier LDIF.

Options du gestionnaire source LDAP

Le gestionnaire source LDAP lit les données d'un serveur LDAP en lui envoyant une requête de recherche. Il envoie ensuite au moteur Importation/Conversion/Exportation NetIQ les entrées résultant de cette opération de recherche.

Options du gestionnaire de destination LDAP

Le gestionnaire cible LDAP reçoit des données du moteur Importation/Conversion/Exportation NetIQ et les renvoie à un serveur LDAP sous forme d'opérations de mise à jour que le serveur doit exécuter.

Pour des informations sur le mot de passe haché dans un fichier LDIF, reportez-vous à la section Représentation du mot de passe haché dans les fichiers LDIF.

Options du gestionnaire source DELIM

Le gestionnaire source DELIM lit des données provenant d'un fichier de données séparées par une virgule, avant de les envoyer au gestionnaire cible.

Options du gestionnaire cible DELIM

Le gestionnaire cible DELIM reçoit les données provenant d'un gestionnaire source et les écrit dans un fichier de données séparées par une virgule.

Options du gestionnaire source SCH

Le gestionnaire SCH lit les données à partir d'un fichier de schéma NDS ou eDirectory hérité (fichiers avec l'extension *.sch), puis les envoie au moteur Importation/Conversion/Exportation NetIQ. Vous pouvez utiliser ce gestionnaire pour mettre en oeuvre des opérations liées au schéma sur un serveur LDAP, par exemple des extensions avec un fichier *.sch en entrée.

Le gestionnaire SCH est uniquement un gestionnaire source. Vous pouvez l'utiliser pour importer des fichiers *.sch dans un serveur LDAP, mais pas pour exporter des fichiers *.sch.

Les options prises en charge par le gestionnaire SCH sont indiquées dans le tableau suivant.

Options du gestionnaire source LOAD

Le gestionnaire DirLoad génère les informations eDirectory à partir des commandes d'un modèle. Ce fichier de modèle est spécifié avec l'argument -f et contient les informations de spécification d'attribut et les informations de contrôle de programme.

Reportez-vous à l'exemple suivant de fichier de spécification d'attributs :

givenname: $R(first)
initial: $R(initial)
sn: $R(last)
dn:cn=$A(givenname,%.1s)$A(initial,%.1s)$A(sn),ou=dev,ou=ds,o=novell
objectclass: inetorgperson
telephonenumber: 1-800-$N(1-999,%03d)-$C(%04d)
title: $R(titles)
locality: Our location

Le format du fichier de spécification d'attributs est semblable à celui d'un fichier LDIF. Cependant, il permet d'exploiter des structures performantes pour fournir des informations supplémentaires et définir des relations entre les attributs.

Syntax: $C[(<format)]

La variable facultative <format indique le format d'impression à appliquer à la valeur. Notez que si aucun format n'est spécifié, il est également impossible d'utiliser les parenthèses :

$C
$C(%d) 
$C(%04d)

La séquence simple $C insère la valeur numérique courante dans une valeur d'attribut. Elle équivaut à $C(%d), car « %d » est le format par défaut utilisé par le programme si aucun autre format n'est spécifié. La valeur numérique est incrémentée après chaque objet : si vous utilisez $C à plusieurs reprises dans la spécification d'attribut, la valeur est identique pour un même objet. La valeur initiale peut être spécifiée dans le fichier de paramètres à l'aide de la syntaxe !COUNTER=valeur.

$N(<low-<high[,<format])]

Les variables <bas et <haut fixent respectivement les limites inférieure et supérieure employées pour générer un nombre aléatoire. La variable facultative <format indique le format d'impression à appliquer à une valeur de la liste.

$N(1-999) 
$N(1-999,%d) 
$N(1-999,%03d)

$R(<filename[,<format])]

La variable <nom_fichier désigne un fichier qui contient une liste de valeurs. Il peut s'agir du chemin absolu ou relatif d'un fichier. Divers fichiers contenant les listes sont inclus avec ce paquetage. Les valeurs doivent être séparées par un caractère de retour à la ligne.

La variable facultative <format indique le format d'impression à appliquer à une valeur de la liste.

$A(givenname)
$A(givenname,%s) 
$A(givenname,%.1s)

Notez que les références en aval ne sont pas autorisées. Tout attribut dont vous prévoyez d'utiliser la valeur doit précéder l'attribut actuel dans le fichier de spécification d'attributs. Dans l'exemple suivant, le cn en tant que partie du DN est constitué à partir de givenname, initial et sn. Par conséquent, ces attributs doivent précéder le DN dans le fichier de paramètres.

givenname: $R(first)
initial: $R(initial)
sn: $R(last) dn:o=novell,ou=dev,ou=ds,cn=$A(givenname,%.1s)$A(initial,%.1s)$A(sn)

Le DN reçoit un traitement particulier dans le fichier LDIF : quel que soit l'emplacement du DN dans les paramètres, il sera écrit en premier (conformément à la syntaxe LDIF) dans le fichier LDIF. Tous les autres attributs sont écrits dans l'ordre dans lequel ils apparaissent.

!COUNTER=300
!OBJECTCOUNT=2
!CYCLE=title
!UNICYCLE=first,last
!CYCLE=ou,BLOCK=10

Exécution d'une importation LDIF

Pour effectuer une importation LDIF, associez le gestionnaire source LDIF et le gestionnaire de destination LDAP de la manière suivante :

ice -S LDIF -f entries.ldif -D LDAP ‑s server1.acme.com -p 389 -d cn=admin,c=us -w secret

Cette commande permet de lire les données LDIF à partir du fichier entries.ldif et de les envoyer au serveur LDAP server1.acme.com sur le port 389 à l'aide de l'identité cn=admin,c=us et du mot de passe « secret ».

Exécution d'une exportation LDIF

Pour effectuer une exportation LDIF, associez le gestionnaire source LDAP et le gestionnaire cible LDIF. Par exemple :

ice -S LDAP -s server1.acme.com -p 389 -d cn=admin,c=us ‑w password -F objectClass=* -c sub -D LDIF ‑f server1.ldif

Cette commande permet de rechercher dans une sous-arborescence tous les objets situés sur le serveur server1.acme.com au niveau du port 389, à l'aide de l'identité cn=admin,c=us et du mot de passe « password », ainsi que de générer les données au format LDIF dans le fichier server1.ldif.

Importation de données séparées par une virgule

Pour exécuter une importation délimitée par des virgules, utilisez une commande similaire à la suivante :

ice -S DELIM -f/tmp/in.csv -F /tmp/order.csv -ncn -lo=acme -D LDAP -s server1.acme.com -p389 -d cn=admin,c=us -w secret

Cette commande lit les données séparées par une virgule du fichier /tmp/in.csv, ainsi que l'ordre des attributs, défini dans le fichier /tmp/order.csv. Pour chaque entrée d'attribut du fichier in.csv, le type d'attribut est spécifié dans le fichier order.csv. Par exemple, si le fichier in.csv contient

pat,pat,engineer,john

alors le fichier order.csv contient

dn,cn,title,sn

Les informations du fichier order.csv peuvent être saisies directement à l'aide de l'option -t.

Les données sont ensuite envoyées au serveur LDAP server1.acme.com sur le port 389 à l'aide de l'identité cn=admin,c=us et du mot de passe « secret ».

Cet exemple indique que cn doit devenir le nouveau DN pour cet à en utilisant l'option -n et cet objet a été ajouté au conteneur Organisation acme à l'aide de l'option -l.

Le modèle utilisé pour générer des fichiers séparés par une virgule créés à l'aide de l'utilitaire Importation/Conversion/Exportation NetIQ figure à la première ligne. Pour spécifier que la première ligne du fichier délimité est le modèle, utilisez l'option -k. Si F - ou -t est utilisé avec -k, le modèle spécifié doit être cohérent avec celui dans le fichier délimité, dans lequel les deux possèdent exactement les mêmes attributs. Toutefois, le nombre d'occurrences et l'ordre d'apparition de chaque attribut peuvent différer. Dans l'exemple ci-dessus, le fichier in.csv contient

dn,cn,title,title,title,sn à la première ligne. Les modèles suivants sont cohérents et peuvent être utilisés avec l'option -t ou -F lorsque -k est utilisé :

dn,cn,title,sn (le nombre de répétitions du titre de l'attribut diffère)

dn,sn,titre cn (l'ordre des attributs diffère)

Toutefois, les éléments suivants ne sont pas compatibles avec le modèle in.csv et ne peuvent donc pas être spécifiés avec l'option -t ou -F lorsque -k est utilisé :

dn,cn,title,sn,objectclass (nouvel attribut de classe d'objet)

dn,cn,title (attribut sn manquant)

Exportation de données séparées par une virgule

Pour exécuter une exportation délimitée par des virgules, utilisez une commande similaire à la suivante :

ice -S LDAP -s server1.acme.com -p 389 -d cn=admin,c=us ‑w password -F objectClass=* -c sub -D DELIM -f /tmp/server1.csv -F order.csv

Cette commande permet de rechercher dans une sous-arborescence tous les objets situés sur le serveur server1.acme.com au niveau du port 389, à l'aide de l'identité cn=admin,c=us et du mot de passe « password » et compile les données séparées par une virgule, dans le fichier /tmp/server1.csv.

Si un attribut dans le fichier order.csv a plusieurs valeurs, /tmp/server1.csv, le nombre de colonnes pour cet attribut correspond au nombre maximal de valeurs pour l'attribut. Si un attribut se répète dans le fichier order.csv, le nombre de colonnes pour cet attribut correspond au nombre de répétitions de l'attribut.

Par exemple, si le fichier order.csv contient dn, sn,objectclass et que objectclass possède 4 valeurs, alors que dn et sn ont uniquement 1 valeur pour toutes les entrées exportées, dn et sn auraient 1 colonne tandis que objectclass compterait 4 colonnes. Si vous ne voulez que 2 valeurs pour objectclass dans le fichier délimité, le fichier order.csv doit contenir dn,sn,objectclass,objectclass.

Dans les deux cas, les attributs sont écrits dans le fichier /tmp/server1.csv sur la première ligne. Dans le premier cas, la première ligne du fichier /tmp/server1.csv sera dn,sn,objectclass,objectclass,objectclass,objectclasss, et dans le second cas, elle contiendra dn,sn,objectclass,objectclass.

Pour éviter que la première ligne soit considérée comme une succession d'attributs lors d'une importation ultérieure, utilisez l'option -k. Pour plus d'informations, reportez-vous à la section Importation de données séparées par une virgule.

Exécution d'une migration de données entre des serveurs LDAP

Pour effectuer une migration de données entre des serveurs LDAP, associez les gestionnaires source et cible LDAP. Par exemple :

ice -S LDAP -s server1.acme.com -p 389 -d cn=admin,c=us ‑w password -F objectClass=* -c sub -D LDAP ‑s server2.acme.com -p 389 -d cn=admin,c=us -w secret

Cette commande permet de rechercher dans une sous-arborescence tous les objets situés sur le serveur server1.acme.com au niveau du port 389, sous l'identité cn=admin,c=us et à l'aide du mot de passe « password » et envoie les données au serveur LDAP server2.acme.com sur le port 389 sous l'identité cn=admin,c=us à l'aide du mot de passe « secret ».

Exécution d'une importation de schéma

Pour exécuter une importation de schéma, utilisez une commande similaire à la suivante :

ice -S SCH -f $HOME/myfile.sch -D LDAP -s myserver -d cn=admin,o=novell -w passwd

Cette commande lit les données de schéma à partir du fichier myfile.sch et les envoie au serveur LDAP myserver sous l'identité cn=admin,o=novell et à l'aide de du mot de passe « passwd ».

Exécution d'une importation de fichier LOAD

Pour exécuter une importation de fichier LOAD, utilisez une commande similaire à la suivante :

ice -S LOAD -f attrs -D LDIF -f new.ldf

Dans cet exemple, le contenu du fichier d'attributs attrs est le suivant :

#===================================================================== 

#  DirLoad 1.00
#=====================================================================

!COUNTER=300 

!OBJECTCOUNT=2
#-----------------------------------------------------------------------

#  ATTRIBUTE TEMPLATE
# --------------------------------------------------------------------

objectclass: inetorgperson 

givenname: $R(first) 

initials: $R(initial) 

sn: $R(last) 

dn: cn=$A(givenname,%.1s)$A(initial,%.1s)$A(sn),ou=$R(ou),ou=dev,o=novell,

telephonenumber: 1-800-$N(1-999,%03d)-$C(%04d) 

title: $R(titles)

L'exécution de la commande précédente à partir de l'invite de commande génère le fichier LDIF suivant :

version: 1

dn: cn=JohnBBill,ou=ds,ou=dev,o=novell 

changetype: add 

objectclass: inetorgperson 

givenname: John 

initials: B 

sn: Bill 

telephonenumber: 1-800-290-0300 

title: Amigo 

dn: cn=BobJAmy,ou=ds,ou=dev,o=novell 

changetype: add 

objectclass: inetorgperson 

givenname: Bob 

initials: J 

sn: Amy 

telephonenumber: 1-800-486-0301 

title: Pomo

L'exécution de la commande suivante à partir de l'invite de commande entraîne l'envoi des données à un serveur LDAP via le gestionnaire LDAP :

ice -S LOAD -f attrs -D LDAP -s www.novell.com -d cn=admin,o=novell -w admin

Si le fichier de modèle précédent est utilisé avec la commande suivante, tous les enregistrements ajoutés via la commande ci-dessus sont supprimés.

ice -S LOAD -f attrs -r -D LDAP -s www.novell.com -d cn=admin,o=novell -w admin

L'exemple ci-dessous illustre la façon de modifier des enregistrements à l'aide du paramètre –m :

# ====================================================================== 

#  DirLoad 1.00

# ====================================================================== !COUNTER=300

!OBJECTCOUNT=2

#---------------------------------------------------------------------- 

#  ATTRIBUTE TEMPLATE

# ---------------------------------------------------------------------- 

dn: cn=$R(first),%.1s)($R(initial),%.1s)$R(last),ou=$R(ou),ou=dev,o=novell

delete: givenname

add: givenname

givenname: test1 

replace: givenname

givenname: test2 

givenname: test3

Si le fichier attrs contient les données ci-dessus et que vous utilisez la commande suivante :

ice -S LOAD -f attrs -m -D LDIF -f new.ldf

les données LDIF suivantes sont générées :

version: 1 

dn: cn=BillTSmith,ou=ds,ou=dev,o=novell 

changetype: modify

delete: givenname

-

add: givenname

givenname: test1

-

replace: givenname

givenname: test2 

givenname: test3 

-

dn: cn=JohnAWilliams,ou=ldap,ou=dev,o=novell 

changetype: modify

delete: givenname

-

add: givenname

givenname: test1

-

replace: givenname

givenname: test2 

givenname: test3 

-

Exécution d'une exportation LDIF à partir d'un serveur LDAP contenant des attributs chiffrés

Pour effectuer une exportation LDIF à partir d'un serveur LDAP comportant des attributs chiffrés, associez le gestionnaire source LDAP et le gestionnaire cible LDIF, ainsi que le modèle et le mot de passe de chiffrement. Par exemple :

ice -S LDAP -s server1.acme.com -p 636 -L cert-server1.der -d cn=admin,c=us -w password -F objectClass=* -c sub -D LDIF -f server1.ldif -e des -E secret

Exécution d'une importation LDIF comportant des attributs chiffrés

Pour effectuer une importation LDIF d'un fichier dont les attributs ont été précédemment chiffrés par ICE, associez la source LDIF au modèle et mot de passe utilisés précédemment pour l'exportation du fichier et au gestionnaire cible LDAP. Par exemple :

ice -S LDIF -f server1.ldif -e des -E secret -D LDAP -s server2.acme.com -p 636 -L cert-server2.der -d cn=admin,c=us -w password

Règles d'assignation de schéma

L'élément <attr-name-map> est l'élément le plus élevé pour les règles d'assignation de schéma. Les règles d'assignation déterminent comment le schéma d'importation interagit avec le schéma d'exportation. Elles associent les définitions et les attributs de classe d'importation indiqués aux définitions correspondantes dans le schéma d'exportation.

Les règles d'assignation peuvent être définies pour les noms d'attribut ou les noms de classe.

Voici la définition formelle des DTD concernant les règles d'assignation de schéma:

<!ELEMENT attr-name-map (attr-name | class-name)*>

<!ELEMENT attr-name (nds-name, app-name)>
<!ATTLIST attr-name 
          class-name    CDATA    #IMPLIED>

<!ELEMENT class-name (nds-name, app-name)>

<!ELEMENT nds-name (#PCDATA)>

<!ELEMENT app-name (#PCDATA)>

Vous pouvez avoir plusieurs éléments d'assignation dans un fichier. Chaque élément est traité dans l'ordre où il apparaît dans le fichier. Si vous assignez la même classe ou le même attribut plusieurs fois, la première assignation est prioritaire.

Les exemples suivants illustrent la création d'une règle d'assignation de schéma.

<attr-name-map>
   <attr-name class-name="inetOrgPperson">
      <nds-name>surname</nds-name>
      <app-name>sn</app-name>
   </attr-name>
</attr-name-map>

<attr-name-map>
   <class-name>
      <nds-name>inetOrgPerson</nds-name>
      <app-name>User</app-name>
   </class-name>
</attr-name-map>

<attr-name-map>
   <attr-name>
      <nds-name>surname</nds-name>
      <app-name>sn</app-name>
   </attr-name>
   <class-name>
      <nds-name>inetOrgPerson</nds-name>
      <app-name>User</app-name>
   </class-name>
</attr-name-map>

ice -o -sfile://sr1.xml -SLDIF -f1entry.ldf -c -DLDIF 
-foutt1.ldf

Règles de création

Les règles de création précisent les conditions de création d'une nouvelle entrée dans le répertoire de destination. Elles prennent en charge les éléments suivants :

Voici la définition formelle des DTD concernant les règles de création :

<!ELEMENT create-rules (create-rule)*>

<!ELEMENT create-rule (match-attr*, 
                       required-attr*, 
                       template?) >
<!ATTLIST create-rule 
          class-name    CDATA   #IMPLIED
          description   CDATA   #IMPLIED>

<!ELEMENT match-attr    (value)+ >
<!ATTLIST match-attr
          attr-name      CDATA    #REQUIRED>

<!ELEMENT required-attr (value)*>
<!ATTLIST required-attr 
          attr-name     CDATA   #REQUIRED>

<!ELEMENT template EMPTY>
<!ATTLIST template
          template-dn   CDATA   #REQUIRED>

Vous pouvez avoir plusieurs éléments de règle de création dans un fichier. Chaque règle est traitée dans l'ordre où elle apparaît dans le fichier. Si un enregistrement ne correspond à aucune des règles, il est ignoré sans pour autant générer un message d'erreur.

Les exemples suivants montrent comment formater les règles de création.

<create-rules>
   <create-rule class-name="inetOrgPerson">
      <required-attr attr-name="givenName"/>
      <required-attr attr-name="surname"/>
      <required-attr attr-name="L">
         <value>Provo</value>
      </required-attr>
   </create-rule>
</create-rules>

<create-rules>
   <create-rule>
      <required-attr attr-name="givenName"/>
      <required-attr attr-name="Surname"/>
      <required-attr attr-name="L">
         <value>Provo</value>
      </required-attr>
   </create-rule>
</create-rules>

<create-rules>
   <create-rule>
      <match-attr attr-name="uid">
         <value>cn=ratuid</value>
      </match-attr>
      <required-attr attr-name="L">
         <value>Provo</value>
      </required-attr>
   </create-rule>
</create-rules>

ice -o -cfile://cr1.xml -SLDIF -f1entry.ldf -c -DLDIF 
-foutt1.ldf

Règles de placement

Les règles de placement déterminent l'endroit où une entrée est créée dans le répertoire de destination. Elles prennent en charge les conditions suivantes pour déterminer si la règle doit être utilisée pour placer une entrée :

Le dernier élément de la règle indique où placer l'entrée. La règle de placement peut utiliser aucun ou plusieurs des éléments suivants :

Voici la DTD formelle de la règle de placement :

<!ELEMENT placement-rules (placement-rule*)>
<!ATTLIST placement-rules
          src-dn-format    (%dn-format;)   "slash"
          dest-dn-format   (%dn-format;)   "slash"
          src-dn-delims    CDATA           #IMPLIED
          dest-dn-delims   CDATA           #IMPLIED>

<!ELEMENT placement-rule (match-class*,
                          match-path*,
                          match-attr*,
                          placement)>
<!ATTLIST placement-rule
          description      CDATA            #IMPLIED>

<!ELEMENT match-class      EMPTY>
<!ATTLIST match-class
          class-name       CDATA            #REQUIRED>

<!ELEMENT match-path       EMPTY>
<!ATTLIST match-path
          prefix           CDATA            #REQUIRED>

<!ELEMENT match-attr       (value)+ >
<!ATTLIST match-attr
          attr-name        CDATA            #REQUIRED>

<!ELEMENT placement        (#PCDATA | 
                           copy-name | 
                           copy-attr | 
                           copy-path | 
                           copy-path-suffix)* >

Vous pouvez avoir plusieurs éléments de règle de placement dans un fichier. Chaque règle est traitée dans l'ordre où elle apparaît dans le fichier. Si un enregistrement ne correspond à aucune des règles, il est ignoré sans pour autant générer un message d'erreur.

Les exemples suivants montrent comment formater les règles de placement. Les attributs scr-dn-format="ldap" et dest-dn-format="ldap" définissent la règle de façon à ce que l'espace de noms du DN de la source et de la cible se présente au format LDAP.

L'utilitaire Importation/Conversion/Exportation NetIQ ne prend en charge que les noms sources et cibles au format LDAP.

<placement-rules src-dn-format="ldap" dest-dn-format="ldap">
    <placement-rule> 
       <match-class class-name="inetOrgPerson"></match-class>
       <placement>cn=<copy-name/>,o=test</placement> 
    </placement-rule> 
 </placement-rules>

Avec cette règle, un enregistrement avec une classe de base de inetOrgPerson et avec le DN suivant :

dn: cn=Kim Jones, ou=English, ou=Humanities, o=UofZ

aurait le DN suivant dans le répertoire cible :

dn: cn=Kim Jones, o=test

<placement-rules src-dn-format="ldap" dest-dn-format="ldap">
    <placement-rule> 
       <match-attr attr-name="sn"></match-attr> 
       <placement>cn=<copy-name/>,o=test</placement> 
    </placement-rule> 
 </placement-rules>

Avec cette règle, un enregistrement avec le dn et l'attribut sn suivants :

dn: cn=Kim Jones, ou=English, ou=Humanities, o=UofZ
sn: Jones

aurait le DN suivant dans le répertoire cible :

dn: cn=Kim Jones, o=test

<placement-rules src-dn-format="ldap" dest-dn-format="ldap">
  <placement-rule> 
    <match-attr attr-name="sn"></match-attr> 
    <placement>cn=<copy-attr attr-name="sn"/>,o=test</placement>
  </placement-rule> 
</placement-rules>

Avec cette règle, un enregistrement avec le dn et l'attribut sn suivants :

dn: cn=Kim Jones, ou=English, ou=Humanities, o=UofZ
sn: Jones

aurait le DN suivant dans le répertoire cible :

dn: cn=Jones, o=test

<placement-rules src-dn-format="ldap" dest-dn-format="ldap">
    <placement-rule> 
       <match-attr attr-name="sn"></match-attr> 
       <placement><copy-path/></placement> 
    </placement-rule> 
 </placement-rules>

<placement-rules src-dn-format="ldap" dest-dn-format="ldap">
    <placement-rule> 
       <match-attr attr-name="sn"></match-attr> 
       <placement><copy-path-suffix/>,o=test</placement> 
    </placement-rule> 
 </placement-rules>

Avec cette règle, un enregistrement avec le dn et l'attribut sn suivants :

dn: cn=Kim Jones, ou=English, ou=Humanities, o=UofZ
sn: Jones

aurait le DN suivant dans le répertoire cible :

dn: cn=Kim Jones, ou=English, ou=Humanities, o=UofZ, o=test

<placement-rules>
 <placement-rule>
  <match-path prefix="o=engineering"/>
  <placement><copy-path-suffix/>o=neworg</placement>
 </placement-rule>
</placement-rules>

Par exemple :

dn: cn=bob,o=engineering

devient

dn: cn=bob,o=neworg

ice -o -pfile://pr1.xml -SLDIF -f1entry.ldf -c -DLDIF 
-foutt1.ldf