1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.directory.server.core.api.schema.registries.synchronizers;
21
22
23 import org.apache.directory.api.ldap.model.constants.MetaSchemaConstants;
24 import org.apache.directory.api.ldap.model.constants.SchemaConstants;
25 import org.apache.directory.api.ldap.model.entry.Entry;
26 import org.apache.directory.api.ldap.model.exception.LdapException;
27 import org.apache.directory.api.ldap.model.exception.LdapInvalidDnException;
28 import org.apache.directory.api.ldap.model.exception.LdapSchemaViolationException;
29 import org.apache.directory.api.ldap.model.exception.LdapUnwillingToPerformException;
30 import org.apache.directory.api.ldap.model.message.ResultCodeEnum;
31 import org.apache.directory.api.ldap.model.name.Dn;
32 import org.apache.directory.api.ldap.model.name.Rdn;
33 import org.apache.directory.api.ldap.model.schema.SchemaManager;
34 import org.apache.directory.api.ldap.model.schema.SyntaxChecker;
35 import org.apache.directory.api.ldap.model.schema.registries.Schema;
36 import org.apache.directory.api.util.Strings;
37 import org.apache.directory.server.core.api.interceptor.context.ModifyOperationContext;
38 import org.apache.directory.server.i18n.I18n;
39 import org.slf4j.Logger;
40 import org.slf4j.LoggerFactory;
41
42
43
44
45
46
47
48
49 public class SyntaxCheckerSynchronizer extends AbstractRegistrySynchronizer
50 {
51
52 private static final Logger LOG = LoggerFactory.getLogger( SyntaxCheckerSynchronizer.class );
53
54
55
56
57
58
59
60
61 public SyntaxCheckerSynchronizer( SchemaManager schemaManager ) throws Exception
62 {
63 super( schemaManager );
64 }
65
66
67
68
69
70 @Override
71 public boolean modify( ModifyOperationContext modifyContext, Entry targetEntry, boolean cascade )
72 throws LdapException
73 {
74 Dn name = modifyContext.getDn();
75 Entry entry = modifyContext.getEntry();
76 String schemaName = getSchemaName( name );
77 String oid = getOid( entry );
78 SyntaxChecker syntaxChecker = factory.getSyntaxChecker( schemaManager, targetEntry, schemaManager
79 .getRegistries(), schemaName );
80
81 if ( isSchemaEnabled( schemaName ) )
82 {
83 syntaxChecker.setSchemaName( schemaName );
84
85 schemaManager.unregisterSyntaxChecker( oid );
86 schemaManager.add( syntaxChecker );
87
88 return SCHEMA_MODIFIED;
89 }
90
91 return SCHEMA_UNCHANGED;
92 }
93
94
95
96
97
98 @Override
99 public void add( Entry entry ) throws LdapException
100 {
101 Dn dn = entry.getDn();
102 Dn parentDn = dn.getParent();
103
104
105 checkParent( parentDn, schemaManager, SchemaConstants.SYNTAX_CHECKER );
106
107
108 checkOidIsUniqueForSyntaxChecker( entry );
109
110
111 String schemaName = getSchemaName( dn );
112
113 SyntaxChecker syntaxChecker = factory.getSyntaxChecker( schemaManager, entry, schemaManager.getRegistries(),
114 schemaName );
115
116
117
118
119 Schema schema = schemaManager.getLoadedSchema( schemaName );
120
121 if ( schema.isEnabled() && syntaxChecker.isEnabled() )
122 {
123 if ( schemaManager.add( syntaxChecker ) )
124 {
125 LOG.debug( "Added {} into the enabled schema {}", dn.getName(), schemaName );
126 }
127 else
128 {
129 String msg = I18n.err( I18n.ERR_386, entry.getDn().getName(),
130 Strings.listToString( schemaManager.getErrors() ) );
131 LOG.info( msg );
132 throw new LdapUnwillingToPerformException( ResultCodeEnum.UNWILLING_TO_PERFORM, msg );
133 }
134 }
135 else
136 {
137 LOG.debug( "The SyntaxChecker {} cannot be added in the disabled schema {}", dn.getName(), schemaName );
138 }
139 }
140
141
142
143
144
145 @Override
146 public void delete( Entry entry, boolean cascade ) throws LdapException
147 {
148 Dn dn = entry.getDn();
149 Dn parentDn = dn.getParent();
150
151
152 checkParent( parentDn, schemaManager, SchemaConstants.SYNTAX_CHECKER );
153
154
155 String schemaName = getSchemaName( entry.getDn() );
156
157
158 Schema schema = schemaManager.getLoadedSchema( schemaName );
159
160 if ( schema.isDisabled() )
161 {
162
163 LOG.debug( "The SyntaxChecker {} cannot be deleted from the disabled schema {}", dn.getName(), schemaName );
164
165 return;
166 }
167
168
169 SyntaxChecker syntaxChecker = null;
170
171 try
172 {
173 syntaxChecker = checkSyntaxCheckerOidExists( entry );
174 }
175 catch ( LdapSchemaViolationException lsve )
176 {
177
178 syntaxChecker = factory.getSyntaxChecker( schemaManager, entry, schemaManager.getRegistries(), schemaName );
179
180 if ( schemaManager.getRegistries().contains( syntaxChecker ) )
181 {
182
183 schemaManager.getRegistries().dissociateFromSchema( syntaxChecker );
184
185
186 return;
187 }
188 else
189 {
190
191 String msg = I18n.err( I18n.ERR_387, entry.getDn().getName() );
192 LOG.info( msg );
193 throw new LdapSchemaViolationException( ResultCodeEnum.UNWILLING_TO_PERFORM, msg );
194 }
195 }
196
197 if ( schema.isEnabled() && syntaxChecker.isEnabled() )
198 {
199 if ( schemaManager.delete( syntaxChecker ) )
200 {
201 LOG.debug( "Deleted {} from the enabled schema {}", dn.getName(), schemaName );
202 }
203 else
204 {
205 String msg = I18n.err( I18n.ERR_386, entry.getDn().getName(),
206 Strings.listToString( schemaManager.getErrors() ) );
207 LOG.info( msg );
208 throw new LdapUnwillingToPerformException( ResultCodeEnum.UNWILLING_TO_PERFORM, msg );
209 }
210 }
211 else
212 {
213 LOG.debug( "The syntaxChecker {} cannot be deleted from the disabled schema {}", dn.getName(), schemaName );
214 }
215 }
216
217
218
219
220
221 @Override
222 public void rename( Entry entry, Rdn newRdn, boolean cascade ) throws LdapException
223 {
224 String oldOid = getOid( entry );
225 String schemaName = getSchemaName( entry.getDn() );
226
227 if ( schemaManager.getLdapSyntaxRegistry().contains( oldOid ) )
228 {
229 throw new LdapUnwillingToPerformException( ResultCodeEnum.UNWILLING_TO_PERFORM,
230 I18n.err( I18n.ERR_389, oldOid ) );
231 }
232
233 Entry targetEntry = entry.clone();
234 String newOid = newRdn.getValue();
235
236 if ( schemaManager.getSyntaxCheckerRegistry().contains( newOid ) )
237 {
238 throw new LdapSchemaViolationException( ResultCodeEnum.OTHER,
239 I18n.err( I18n.ERR_390, newOid ) );
240 }
241
242 targetEntry.put( MetaSchemaConstants.M_OID_AT, newOid );
243
244 if ( isSchemaEnabled( schemaName ) )
245 {
246 SyntaxChecker syntaxChecker = factory.getSyntaxChecker( schemaManager, targetEntry, schemaManager
247 .getRegistries(), schemaName );
248 schemaManager.unregisterSyntaxChecker( oldOid );
249 schemaManager.add( syntaxChecker );
250 }
251 }
252
253
254
255
256
257 @Override
258 public void moveAndRename( Dn oriChildName, Dn newParentName, Rdn newRdn, boolean deleteOldRn,
259 Entry entry, boolean cascade ) throws LdapException
260 {
261 checkNewParent( newParentName );
262 String oldOid = getOid( entry );
263 String oldSchemaName = getSchemaName( oriChildName );
264 String newSchemaName = getSchemaName( newParentName );
265
266 if ( schemaManager.getLdapSyntaxRegistry().contains( oldOid ) )
267 {
268 throw new LdapUnwillingToPerformException( ResultCodeEnum.UNWILLING_TO_PERFORM,
269 I18n.err( I18n.ERR_391, oldOid ) );
270 }
271
272 Entry targetEntry = entry.clone();
273
274 String newOid = newRdn.getValue();
275
276 if ( schemaManager.getSyntaxCheckerRegistry().contains( newOid ) )
277 {
278 throw new LdapSchemaViolationException( ResultCodeEnum.OTHER,
279 I18n.err( I18n.ERR_390, newOid ) );
280 }
281
282 targetEntry.put( MetaSchemaConstants.M_OID_AT, newOid );
283 SyntaxChecker syntaxChecker = factory.getSyntaxChecker( schemaManager, targetEntry, schemaManager
284 .getRegistries(), newSchemaName );
285
286 if ( isSchemaEnabled( oldSchemaName ) )
287 {
288 schemaManager.unregisterSyntaxChecker( oldOid );
289 }
290
291 if ( isSchemaEnabled( newSchemaName ) )
292 {
293 schemaManager.add( syntaxChecker );
294 }
295 }
296
297
298
299
300
301 @Override
302 public void move( Dn oriChildName, Dn newParentName, Entry entry, boolean cascade ) throws LdapException
303 {
304 checkNewParent( newParentName );
305 String oid = getOid( entry );
306 String oldSchemaName = getSchemaName( oriChildName );
307 String newSchemaName = getSchemaName( newParentName );
308
309 if ( schemaManager.getLdapSyntaxRegistry().contains( oid ) )
310 {
311 throw new LdapUnwillingToPerformException( ResultCodeEnum.UNWILLING_TO_PERFORM,
312 I18n.err( I18n.ERR_393, oid ) );
313 }
314
315 SyntaxChecker syntaxChecker = factory.getSyntaxChecker( schemaManager, entry, schemaManager.getRegistries(),
316 newSchemaName );
317
318 if ( isSchemaEnabled( oldSchemaName ) )
319 {
320 schemaManager.unregisterSyntaxChecker( oid );
321 }
322
323 if ( isSchemaEnabled( newSchemaName ) )
324 {
325 schemaManager.add( syntaxChecker );
326 }
327 }
328
329
330 private void checkOidIsUniqueForSyntaxChecker( Entry entry ) throws LdapException
331 {
332 String oid = getOid( entry );
333
334 if ( schemaManager.getNormalizerRegistry().contains( oid ) )
335 {
336 throw new LdapSchemaViolationException( ResultCodeEnum.OTHER,
337 I18n.err( I18n.ERR_390, oid ) );
338 }
339 }
340
341
342
343
344
345
346
347
348
349
350 protected SyntaxChecker checkSyntaxCheckerOidExists( Entry entry ) throws LdapException
351 {
352 String oid = getOid( entry );
353
354 if ( schemaManager.getSyntaxCheckerRegistry().contains( oid ) )
355 {
356 return schemaManager.getSyntaxCheckerRegistry().get( oid );
357 }
358 else
359 {
360 throw new LdapSchemaViolationException( ResultCodeEnum.OTHER,
361 I18n.err( I18n.ERR_336, oid ) );
362 }
363 }
364
365
366 private void checkNewParent( Dn newParent ) throws LdapException
367 {
368 if ( newParent.size() != 3 )
369 {
370 throw new LdapInvalidDnException( ResultCodeEnum.NAMING_VIOLATION,
371 I18n.err( I18n.ERR_396 ) );
372 }
373
374 Rdn rdn = newParent.getRdn();
375 if ( !schemaManager.getAttributeTypeRegistry().getOidByName( rdn.getNormType() ).equals(
376 SchemaConstants.OU_AT_OID ) )
377 {
378 throw new LdapInvalidDnException( ResultCodeEnum.NAMING_VIOLATION,
379 I18n.err( I18n.ERR_397 ) );
380 }
381
382 if ( !rdn.getValue().equalsIgnoreCase( SchemaConstants.SYNTAX_CHECKERS_AT ) )
383 {
384 throw new LdapInvalidDnException( ResultCodeEnum.NAMING_VIOLATION,
385 I18n.err( I18n.ERR_372 ) );
386 }
387 }
388 }