001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License. You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing,
013 * software distributed under the License is distributed on an
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015 * KIND, either express or implied. See the License for the
016 * specific language governing permissions and limitations
017 * under the License.
018 *
019 */
020 package org.apache.directory.shared.ldap.schema.loader.ldif;
021
022
023 import java.io.File;
024 import java.io.InputStream;
025 import java.net.URL;
026 import java.util.ArrayList;
027 import java.util.List;
028 import java.util.Map;
029 import java.util.regex.Pattern;
030
031 import org.apache.directory.shared.i18n.I18n;
032 import org.apache.directory.shared.ldap.constants.SchemaConstants;
033 import org.apache.directory.shared.ldap.entry.Entry;
034 import org.apache.directory.shared.ldap.ldif.LdifEntry;
035 import org.apache.directory.shared.ldap.ldif.LdifReader;
036 import org.apache.directory.shared.ldap.schema.ldif.extractor.impl.ResourceMap;
037 import org.apache.directory.shared.ldap.schema.ldif.extractor.impl.DefaultSchemaLdifExtractor;
038 import org.apache.directory.shared.ldap.schema.registries.AbstractSchemaLoader;
039 import org.apache.directory.shared.ldap.schema.registries.Schema;
040 import org.slf4j.Logger;
041 import org.slf4j.LoggerFactory;
042
043
044 /**
045 * Loads schema data from LDIF files containing entries representing schema
046 * objects, using the meta schema format.
047 *
048 * This class is used only for tests.
049 *
050 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
051 * @version $Revision$
052 */
053 public class JarLdifSchemaLoader extends AbstractSchemaLoader
054 {
055 /** ldif file extension used */
056 private static final String LDIF_EXT = "ldif";
057
058 /** static class logger */
059 private static final Logger LOG = LoggerFactory.getLogger( JarLdifSchemaLoader.class );
060
061 /** Speedup for DEBUG mode */
062 private static final boolean IS_DEBUG = LOG.isDebugEnabled();
063
064 /** a map of all the resources in this jar */
065 private static final Map<String,Boolean> RESOURCE_MAP = ResourceMap.getResources( Pattern.compile( ".*schema/ou=schema.*" ) );
066
067
068 /**
069 * Creates a new LDIF based SchemaLoader. The constructor checks to make
070 * sure the supplied base directory exists and contains a schema.ldif file
071 * and if not complains about it.
072 *
073 * @throws Exception if the base directory does not exist or does not
074 * a valid schema.ldif file
075 */
076 public JarLdifSchemaLoader() throws Exception
077 {
078 initializeSchemas();
079 }
080
081
082 private final URL getResource( String resource, String msg ) throws Exception
083 {
084 if ( RESOURCE_MAP.get( resource ) )
085 {
086 return DefaultSchemaLdifExtractor.getUniqueResource( resource, msg );
087 }
088 else
089 {
090 return new File( resource ).toURI().toURL();
091 }
092 }
093
094
095 /**
096 * Scans for LDIF files just describing the various schema contained in
097 * the schema repository.
098 *
099 * @throws Exception
100 */
101 private void initializeSchemas() throws Exception
102 {
103 if ( IS_DEBUG )
104 {
105 LOG.debug( "Initializing schema" );
106 }
107
108 for ( String file : RESOURCE_MAP.keySet() )
109 {
110 Pattern pat = Pattern.compile( ".*schema/ou=schema/cn=[a-z0-9-_]*\\." + LDIF_EXT );
111
112 if ( pat.matcher( file ).matches() )
113 {
114 URL resource = getResource( file, "schema LDIF file" );
115 InputStream in = resource.openStream();
116
117 try
118 {
119 LdifReader reader = new LdifReader( in );
120 LdifEntry entry = reader.next();
121 reader.close();
122 Schema schema = getSchema( entry.getEntry() );
123 schemaMap.put( schema.getSchemaName(), schema );
124
125 if ( IS_DEBUG )
126 {
127 LOG.debug( "Schema Initialized ... \n{}", schema );
128 }
129 }
130 catch ( Exception e )
131 {
132 LOG.error( I18n.err( I18n.ERR_10003, file ), e );
133 throw e;
134 }
135 finally
136 {
137 in.close();
138 }
139 }
140 }
141 }
142
143
144 /**
145 * Utility method to get the path for a schema directory.
146 *
147 * @param schema the schema to get the path for
148 * @return the path for the specific schema directory
149 */
150 private final String getSchemaDirectory( Schema schema )
151 {
152 return "schema/ou=schema/cn=" + schema.getSchemaName();
153 }
154
155
156 /**
157 * {@inheritDoc}
158 */
159 public List<Entry> loadComparators( Schema... schemas ) throws Exception
160 {
161 List<Entry> comparatorList = new ArrayList<Entry>();
162
163 if ( schemas == null )
164 {
165 return comparatorList;
166 }
167
168 for ( Schema schema : schemas )
169 {
170 String comparatorsDirectory = getSchemaDirectory( schema )
171 + "/" + SchemaConstants.COMPARATORS_PATH;
172
173 for ( String resourcePath : RESOURCE_MAP.keySet() )
174 {
175 Pattern regex = Pattern.compile( ".*" + comparatorsDirectory + "/m-oid=.*\\." + LDIF_EXT );
176
177 if ( regex.matcher( resourcePath ).matches() )
178 {
179 URL resource = getResource( resourcePath, "comparator LDIF file" );
180 LdifReader reader = new LdifReader( resource.openStream() );
181 LdifEntry entry = reader.next();
182 reader.close();
183
184 comparatorList.add( entry.getEntry() );
185 }
186 }
187 }
188
189 return comparatorList;
190 }
191
192
193 /**
194 * {@inheritDoc}
195 */
196 public List<Entry> loadSyntaxCheckers( Schema... schemas ) throws Exception
197 {
198 List<Entry> syntaxCheckerList = new ArrayList<Entry>();
199
200 if ( schemas == null )
201 {
202 return syntaxCheckerList;
203 }
204
205 for ( Schema schema : schemas )
206 {
207 String syntaxCheckersDirectory = getSchemaDirectory( schema )
208 + "/" + SchemaConstants.SYNTAX_CHECKERS_PATH;
209
210 for ( String resourcePath : RESOURCE_MAP.keySet() )
211 {
212 Pattern regex = Pattern.compile( ".*" + syntaxCheckersDirectory + "/m-oid=.*\\." + LDIF_EXT );
213
214 if ( regex.matcher( resourcePath ).matches() )
215 {
216 URL resource = getResource( resourcePath, "syntaxChecker LDIF file" );
217 LdifReader reader = new LdifReader( resource.openStream() );
218 LdifEntry entry = reader.next();
219 reader.close();
220
221 syntaxCheckerList.add( entry.getEntry() );
222 }
223 }
224 }
225
226 return syntaxCheckerList;
227 }
228
229
230 /**
231 * {@inheritDoc}
232 */
233 public List<Entry> loadNormalizers( Schema... schemas ) throws Exception
234 {
235 List<Entry> normalizerList = new ArrayList<Entry>();
236
237 if ( schemas == null )
238 {
239 return normalizerList;
240 }
241
242 for ( Schema schema : schemas )
243 {
244 String normalizersDirectory = getSchemaDirectory( schema )
245 + "/" + SchemaConstants.NORMALIZERS_PATH;
246
247 for ( String resourcePath : RESOURCE_MAP.keySet() )
248 {
249 Pattern regex = Pattern.compile( ".*" + normalizersDirectory + "/m-oid=.*\\." + LDIF_EXT );
250
251 if ( regex.matcher( resourcePath ).matches() )
252 {
253 URL resource = getResource( resourcePath, "normalizer LDIF file" );
254 LdifReader reader = new LdifReader( resource.openStream() );
255 LdifEntry entry = reader.next();
256 reader.close();
257
258 normalizerList.add( entry.getEntry() );
259 }
260 }
261 }
262
263 return normalizerList;
264 }
265
266
267 /**
268 * {@inheritDoc}
269 */
270 public List<Entry> loadMatchingRules( Schema... schemas ) throws Exception
271 {
272 List<Entry> matchingRuleList = new ArrayList<Entry>();
273
274 if ( schemas == null )
275 {
276 return matchingRuleList;
277 }
278
279 for ( Schema schema : schemas )
280 {
281 String matchingRulesDirectory = getSchemaDirectory( schema )
282 + "/" + SchemaConstants.MATCHING_RULES_PATH;
283
284 for ( String resourcePath : RESOURCE_MAP.keySet() )
285 {
286 Pattern regex = Pattern.compile( ".*" + matchingRulesDirectory + "/m-oid=.*\\." + LDIF_EXT );
287
288 if ( regex.matcher( resourcePath ).matches() )
289 {
290 URL resource = getResource( resourcePath, "matchingRules LDIF file" );
291 LdifReader reader = new LdifReader( resource.openStream() );
292 LdifEntry entry = reader.next();
293 reader.close();
294
295 matchingRuleList.add( entry.getEntry() );
296 }
297 }
298 }
299
300 return matchingRuleList;
301 }
302
303
304 /**
305 * {@inheritDoc}
306 */
307 public List<Entry> loadSyntaxes( Schema... schemas ) throws Exception
308 {
309 List<Entry> syntaxList = new ArrayList<Entry>();
310
311 if ( schemas == null )
312 {
313 return syntaxList;
314 }
315
316 for ( Schema schema : schemas )
317 {
318 String syntaxesDirectory = getSchemaDirectory( schema )
319 + "/" + SchemaConstants.SYNTAXES_PATH;
320
321 for ( String resourcePath : RESOURCE_MAP.keySet() )
322 {
323 Pattern regex = Pattern.compile( ".*" + syntaxesDirectory + "/m-oid=.*\\." + LDIF_EXT );
324
325 if ( regex.matcher( resourcePath ).matches() )
326 {
327 URL resource = getResource( resourcePath, "syntax LDIF file" );
328 LdifReader reader = new LdifReader( resource.openStream() );
329 LdifEntry entry = reader.next();
330 reader.close();
331
332 syntaxList.add( entry.getEntry() );
333 }
334 }
335 }
336
337 return syntaxList;
338 }
339
340
341 /**
342 * {@inheritDoc}
343 */
344 public List<Entry> loadAttributeTypes( Schema... schemas ) throws Exception
345 {
346 List<Entry> attributeTypeList = new ArrayList<Entry>();
347
348 if ( schemas == null )
349 {
350 return attributeTypeList;
351 }
352
353 for ( Schema schema : schemas )
354 {
355 // check that the attributeTypes directory exists for the schema
356 String attributeTypesDirectory = getSchemaDirectory( schema )
357 + "/" + SchemaConstants.ATTRIBUTES_TYPE_PATH;
358
359 // get list of attributeType LDIF schema files in attributeTypes
360 for ( String resourcePath : RESOURCE_MAP.keySet() )
361 {
362 Pattern regex = Pattern.compile( ".*" + attributeTypesDirectory + "/m-oid=.*\\." + LDIF_EXT );
363
364 if ( regex.matcher( resourcePath ).matches() )
365 {
366 URL resource = getResource( resourcePath, "attributeType LDIF file" );
367 LdifReader reader = new LdifReader( resource.openStream() );
368 LdifEntry entry = reader.next();
369 reader.close();
370
371 attributeTypeList.add( entry.getEntry() );
372 }
373 }
374 }
375
376 return attributeTypeList;
377 }
378
379
380 /**
381 * {@inheritDoc}
382 */
383 public List<Entry> loadMatchingRuleUses( Schema... schemas ) throws Exception
384 {
385 List<Entry> matchingRuleUseList = new ArrayList<Entry>();
386
387 if ( schemas == null )
388 {
389 return matchingRuleUseList;
390 }
391
392 for ( Schema schema : schemas )
393 {
394 String matchingRuleUsesDirectory = getSchemaDirectory( schema )
395 + "/" + SchemaConstants.MATCHING_RULE_USE_PATH;
396
397 for ( String resourcePath : RESOURCE_MAP.keySet() )
398 {
399 Pattern regex = Pattern.compile( ".*" + matchingRuleUsesDirectory + "/m-oid=.*\\." + LDIF_EXT );
400
401 if ( regex.matcher( resourcePath ).matches() )
402 {
403 URL resource = getResource( resourcePath, "matchingRuleUse LDIF file" );
404 LdifReader reader = new LdifReader( resource.openStream() );
405 LdifEntry entry = reader.next();
406 reader.close();
407
408 matchingRuleUseList.add( entry.getEntry() );
409 }
410 }
411 }
412
413 return matchingRuleUseList;
414 }
415
416
417 /**
418 * {@inheritDoc}
419 */
420 public List<Entry> loadNameForms( Schema... schemas ) throws Exception
421 {
422 List<Entry> nameFormList = new ArrayList<Entry>();
423
424 if ( schemas == null )
425 {
426 return nameFormList;
427 }
428
429 for ( Schema schema : schemas )
430 {
431 String nameFormsDirectory = getSchemaDirectory( schema ) + "/" + SchemaConstants.NAME_FORMS_PATH;
432
433 for ( String resourcePath : RESOURCE_MAP.keySet() )
434 {
435 Pattern regex = Pattern.compile( ".*" + nameFormsDirectory + "/m-oid=.*\\." + LDIF_EXT );
436
437 if ( regex.matcher( resourcePath ).matches() )
438 {
439 URL resource = getResource( resourcePath, "nameForm LDIF file" );
440 LdifReader reader = new LdifReader( resource.openStream() );
441 LdifEntry entry = reader.next();
442 reader.close();
443
444 nameFormList.add( entry.getEntry() );
445 }
446 }
447 }
448
449 return nameFormList;
450 }
451
452
453 /**
454 * {@inheritDoc}
455 */
456 public List<Entry> loadDitContentRules( Schema... schemas ) throws Exception
457 {
458 List<Entry> ditContentRulesList = new ArrayList<Entry>();
459
460 if ( schemas == null )
461 {
462 return ditContentRulesList;
463 }
464
465 for ( Schema schema : schemas )
466 {
467 String ditContentRulesDirectory = getSchemaDirectory( schema ) + "/" +
468 SchemaConstants.DIT_CONTENT_RULES_PATH;
469
470 for ( String resourcePath : RESOURCE_MAP.keySet() )
471 {
472 Pattern regex = Pattern.compile( ".*" + ditContentRulesDirectory + "/m-oid=.*\\." + LDIF_EXT );
473
474 if ( regex.matcher( resourcePath ).matches() )
475 {
476 URL resource = getResource( resourcePath, "ditContentRule LDIF file" );
477 LdifReader reader = new LdifReader( resource.openStream() );
478 LdifEntry entry = reader.next();
479 reader.close();
480
481 ditContentRulesList.add( entry.getEntry() );
482 }
483 }
484 }
485
486 return ditContentRulesList;
487 }
488
489
490 /**
491 * {@inheritDoc}
492 */
493 public List<Entry> loadDitStructureRules( Schema... schemas ) throws Exception
494 {
495 List<Entry> ditStructureRuleList = new ArrayList<Entry>();
496
497 if ( schemas == null )
498 {
499 return ditStructureRuleList;
500 }
501
502 for ( Schema schema : schemas )
503 {
504 String ditStructureRulesDirectory = getSchemaDirectory( schema )
505 + "/" + SchemaConstants.DIT_STRUCTURE_RULES_PATH;
506
507 for ( String resourcePath : RESOURCE_MAP.keySet() )
508 {
509 Pattern regex = Pattern.compile( ".*" + ditStructureRulesDirectory + "/m-oid=.*\\." + LDIF_EXT );
510
511 if ( regex.matcher( resourcePath ).matches() )
512 {
513 URL resource = getResource( resourcePath, "ditStructureRule LDIF file" );
514 LdifReader reader = new LdifReader( resource.openStream() );
515 LdifEntry entry = reader.next();
516 reader.close();
517
518 ditStructureRuleList.add( entry.getEntry() );
519 }
520 }
521 }
522
523 return ditStructureRuleList;
524 }
525
526
527 /**
528 * {@inheritDoc}
529 */
530 public List<Entry> loadObjectClasses( Schema... schemas ) throws Exception
531 {
532 List<Entry> objectClassList = new ArrayList<Entry>();
533
534 if ( schemas == null )
535 {
536 return objectClassList;
537 }
538
539 for ( Schema schema : schemas )
540 {
541 // get objectClasses directory, check if exists, return if not
542 String objectClassesDirectory = getSchemaDirectory( schema ) + "/" + SchemaConstants.OBJECT_CLASSES_PATH;
543
544 for ( String resourcePath : RESOURCE_MAP.keySet() )
545 {
546 Pattern regex = Pattern.compile( ".*" + objectClassesDirectory + "/m-oid=.*\\." + LDIF_EXT );
547
548 if ( regex.matcher( resourcePath ).matches() )
549 {
550 URL resource = getResource( resourcePath, "objectClass LDIF file" );
551 LdifReader reader = new LdifReader( resource.openStream() );
552 LdifEntry entry = reader.next();
553 reader.close();
554
555 objectClassList.add( entry.getEntry() );
556 }
557 }
558 }
559
560 return objectClassList;
561 }
562 }