org.apache.directory.server.core.api.DirectoryService Java Examples

private void createPrincipal(final String sn,
                             final String cn,
                             final String uid,
                             final String userPassword,
                             final String kerberosPrincipalName) throws LdapException
{
    final DirectoryService directoryService = LDAP.getDirectoryService();
    final Entry entry = new DefaultEntry(directoryService.getSchemaManager());
    entry.setDn(String.format("uid=%s,%s", uid, USERS_DN));
    entry.add("objectClass", "top", "person", "inetOrgPerson", "krb5principal", "krb5kdcentry");
    entry.add("cn", cn);
    entry.add("sn", sn);
    entry.add("uid", uid);
    entry.add("userPassword", userPassword);
    entry.add("krb5PrincipalName", kerberosPrincipalName);
    entry.add("krb5KeyVersionNumber", "0");
    directoryService.getAdminSession().add(entry);
}
 

private void createPrincipal(String principal, String password)
    throws Exception {
  DirectoryService ds = getService();
  String baseDn = "ou=users,ou=system";
  String content = "dn: uid=" + principal + "," + baseDn + "\n" +
      "objectClass: top\n" +
      "objectClass: person\n" +
      "objectClass: inetOrgPerson\n" +
      "cn: " + principal + "\n" +
      "sn: " + principal + "\n" +
      "uid: " + principal + "\n" +
      "userPassword: " + password;

  for (LdifEntry ldifEntry : new LdifReader(new StringReader(content))) {
    ds.getAdminSession().add(new DefaultEntry(ds.getSchemaManager(),
        ldifEntry.getEntry()));
  }
}
 

private void importLdif(DirectoryService directoryService,
                        final SchemaManager schemaManager,
                        LdifReader ldifReader) throws Exception {
   try {
      for (LdifEntry ldifEntry : ldifReader) {
         checkPartition(ldifEntry);
         directoryService.getAdminSession().add(new DefaultEntry(schemaManager, ldifEntry.getEntry()));
      }
   } finally {
      try {
         ldifReader.close();
      } catch (IOException ioe) {
         // ignore
      }
   }
}
 

/**
 * Creates an environment configuration for JNDI access.
 */
private Properties createEnv() {
    // Fetch directory service from servlet context
    ServletContext servletContext = this.getServletContext();
    DirectoryService directoryService = (DirectoryService) servletContext.getAttribute(DirectoryService.JNDI_KEY);

    Properties env = new Properties();
    env.put(DirectoryService.JNDI_KEY, directoryService);
    env.put(Context.PROVIDER_URL, "");
    env.put(Context.INITIAL_CONTEXT_FACTORY, CoreContextFactory.class.getName());

    env.put(Context.SECURITY_PRINCIPAL, "uid=admin,ou=system");
    env.put(Context.SECURITY_CREDENTIALS, "secret");
    env.put(Context.SECURITY_AUTHENTICATION, "simple");

    return env;
}
 

@Override
protected DirectoryService createDirectoryService() throws Exception {
    DirectoryService directoryService = super.createDirectoryService();

    directoryService.addLast(new KeyDerivationInterceptor());
    return directoryService;
}
 

public void setDirectoryService( DirectoryService directoryService )
{
    super.setDirectoryService( directoryService );
    Iterator<String> itr = directoryService.getLdapCodecService().registeredControls();
    while ( itr.hasNext() )
    {
        supportedControls.add( itr.next() );
    }
}
 

/**
 * {@inheritDoc}
 */
public void init( DirectoryService directoryService ) throws LdapException
{
    super.init( directoryService );
    nexus = directoryService.getPartitionNexus();
    Value<?> attr = nexus.getRootDse( null ).get( SchemaConstants.SUBSCHEMA_SUBENTRY_AT ).get();
    subschemSubentryDn = directoryService.getDnFactory().create( attr.getString() );
}
 

/**
 * Initialize the Schema Service
 *
 * @param directoryService the directory service core
 * @throws Exception if there are problems during initialization
 */
public void init( DirectoryService directoryService ) throws LdapException
{
    if ( IS_DEBUG )
    {
        LOG.debug( "Initializing SchemaInterceptor..." );
    }

    super.init( directoryService );

    nexus = directoryService.getPartitionNexus();
    topFilter = new TopFilter();
    filters.add( topFilter );

    schemaBaseDn = directoryService.getDnFactory().create( SchemaConstants.OU_SCHEMA );

    // stuff for dealing with subentries (garbage for now)
    Value<?> subschemaSubentry = nexus.getRootDse( null ).get( SchemaConstants.SUBSCHEMA_SUBENTRY_AT ).get();
    subschemaSubentryDn = directoryService.getDnFactory().create( subschemaSubentry.getString() );
    subschemaSubentryDn.apply( schemaManager );
    subschemaSubentryDnNorm = subschemaSubentryDn.getNormName();

    schemaModificationAttributesDn = directoryService.getDnFactory().create(
        SchemaConstants.SCHEMA_MODIFICATIONS_DN );
    schemaModificationAttributesDn.apply( schemaManager );

    computeSuperiors();

    // Initialize the schema manager
    SchemaLoader loader = directoryService.getSchemaManager().getLoader();
    schemaSubEntryManager = new SchemaSubentryManager( schemaManager, loader, directoryService.getDnFactory() );

    if ( IS_DEBUG )
    {
        LOG.debug( "SchemaInterceptor Initialized !" );
    }
}
 

public void setDirectoryService( DirectoryService directoryService )
{
    super.setDirectoryService( directoryService );
    Iterator<String> itr = directoryService.getLdapCodecService().registeredControls();
    while ( itr.hasNext() )
    {
        supportedControls.add( itr.next() );
    }
}
 

/**
 * {@inheritDoc}
 */
public void init( DirectoryService directoryService ) throws LdapException
{
    super.init( directoryService );
    nexus = directoryService.getPartitionNexus();
    Value<?> attr = nexus.getRootDseValue( SUBSCHEMA_SUBENTRY_AT );
    subschemSubentryDn = dnFactory.create( attr.getString() );
}
 

/**
 * Initialize the Schema Service
 *
 * @param directoryService the directory service core
 * @throws Exception if there are problems during initialization
 */
public void init( DirectoryService directoryService ) throws LdapException
{
    if ( IS_DEBUG )
    {
        LOG.debug( "Initializing SchemaInterceptor..." );
    }

    super.init( directoryService );

    nexus = directoryService.getPartitionNexus();
    topFilter = new TopFilter();
    filters.add( topFilter );

    schemaBaseDn = dnFactory.create( SchemaConstants.OU_SCHEMA );

    // stuff for dealing with subentries (garbage for now)
    Value<?> subschemaSubentry = nexus.getRootDseValue( SUBSCHEMA_SUBENTRY_AT );
    subschemaSubentryDn = dnFactory.create( subschemaSubentry.getString() );
    subschemaSubentryDnNorm = subschemaSubentryDn.getNormName();

    schemaModificationAttributesDn = dnFactory.create(
        SchemaConstants.SCHEMA_MODIFICATIONS_DN );

    computeSuperiors();

    // Initialize the schema manager
    SchemaLoader loader = directoryService.getSchemaManager().getLoader();
    schemaSubEntryManager = new SchemaSubentryManager( schemaManager, loader, dnFactory );

    if ( IS_DEBUG )
    {
        LOG.debug( "SchemaInterceptor Initialized !" );
    }
}
 

private void createGroup(String groupName, String memberDn) throws Exception {
  DirectoryService ds = getService();
  String baseDn = "ou=groups,ou=system";
  String content = "dn: cn=" + groupName + "," + baseDn + "\n" +
      "objectClass: top\n" +
      "objectClass: groupofnames\n" +
      "cn: " + groupName + "\n" +
      "description: " + groupName + "\n" +
      "member: " + memberDn;

  for (LdifEntry ldifEntry : new LdifReader(new StringReader(content))) {
    ds.getAdminSession().add(new DefaultEntry(ds.getSchemaManager(),
        ldifEntry.getEntry()));
  }
}
 

private static void createPartition(final DirectoryServiceFactory dsf, final SchemaManager schemaManager, final String id,
        final String suffix, final DirectoryService directoryService, final File workingDir) throws Exception {
    PartitionFactory pf = dsf.getPartitionFactory();
    Partition p = pf.createPartition(schemaManager, id, suffix, 1000, workingDir);
    pf.addIndex(p, "uid", 10);
    pf.addIndex(p, "departmentNumber", 10);
    pf.addIndex(p, "member", 10);
    pf.addIndex(p, "memberOf", 10);
    p.initialize();
    directoryService.addPartition(p);
}
 

@Test
public void testEmbeddedLdapServerInitialization() throws IndexNotFoundException {
    LdapServer ldapServer = embeddedLdapServer.getLdapServer();
    assertNotNull(ldapServer);

    DirectoryService directoryService = embeddedLdapServer.getDirectoryService();
    assertNotNull(directoryService);
    assertNotNull(directoryService.getSchemaPartition());
    assertNotNull(directoryService.getSystemPartition());
    assertNotNull(directoryService.getSchemaManager());
    assertNotNull(directoryService.getDnFactory());

    assertNotNull(directoryService.isDenormalizeOpAttrsEnabled());

    ChangeLog changeLog = directoryService.getChangeLog();

    assertNotNull(changeLog);
    assertFalse(changeLog.isEnabled());

    assertNotNull(directoryService.isStarted());
    assertNotNull(ldapServer.isStarted());

    List userList = new ArrayList(embeddedLdapServer.getUserIndexMap().keySet());
    java.util.Collections.sort(userList);
    List checkList = Arrays.asList("uid");
    assertEquals(userList, checkList);
}
 

public static void shutdownDirectoryService(DirectoryService service) throws Exception {
    if (service != null) {
        LOG.debug("Shuting down DS for {}", service.getInstanceId());
        service.shutdown();
        FileUtils.deleteDirectory(service.getInstanceLayout().getInstanceDirectory());
    }
}
 

public static long getCurrentRevision(DirectoryService dirService) throws Exception {
    if ((dirService != null) && (dirService.getChangeLog().isEnabled())) {
        long revision = dirService.getChangeLog().getCurrentRevision();
        LOG.debug("Create revision {}", revision);
        return revision;
    }
    return 0;
}
 

public static void revert(DirectoryService dirService, long revision) throws Exception {
    ChangeLog cl = dirService.getChangeLog();
    if (cl.isEnabled() && (revision < cl.getCurrentRevision())) {
        LOG.debug("Revert revision {}", revision);
        dirService.revert(revision);
    }
}
 

/**
 * Initialize the registries, normalizers.
 */
@Override
public void init( DirectoryService directoryService ) throws LdapException
{
    LOG.debug( "Initialiazing the NormalizationInterceptor" );

    super.init( directoryService );

    NameComponentNormalizer ncn = new ConcreteNameComponentNormalizer( schemaManager );
    normVisitor = new FilterNormalizingVisitor( ncn, schemaManager );
}
 

public Partition getPartition(DirectoryService directory, String id) throws LdapException {
    Set<? extends Partition> partitions = directory.getPartitions();
    for (Partition part : partitions) {
        if (part.getId().equalsIgnoreCase(id)) return part;
    }
    throw new LdapException("No partition with the ID " + id);
}
 

public LDAPIAMPoller(DirectoryService directoryService) throws LdapException {
    this.directory = directoryService;

    credentials = new DefaultAWSCredentialsProviderChain();
    try {
        credentials.getCredentials(); // throws
    } catch (AmazonClientException ex) {
        LOG.error("AWS credentials error", ex);
        throw new LdapException("Unable to initialze AWS poller - cannot retrieve valid credentials");
    }
    utils = new ApacheDSUtils(directory);
    runner = new Runner(directory);
    LOG.info("IAMPoller created");
}
 

private static void importLdifContent(DirectoryService directoryService, String ldifContent) throws Exception {
    LdifReader ldifReader = new LdifReader(IOUtils.toInputStream(ldifContent));

    try {
        for (LdifEntry ldifEntry : ldifReader) {
            try {
                directoryService.getAdminSession().add(new DefaultEntry(directoryService.getSchemaManager(), ldifEntry.getEntry()));
            } catch (LdapEntryAlreadyExistsException ignore) {
                log.info("Entry " + ldifEntry.getDn() + " already exists. Ignoring.");
            }
        }
    } finally {
        ldifReader.close();
    }
}
 

public void startLdapServer(MiniKdc miniKdc) throws Exception {
    ldapServer = new LdapServer();
    Field f = MiniKdc.class.getDeclaredField("ds");
    f.setAccessible(true);
    DirectoryService ds = (DirectoryService) f.get(miniKdc);
    ldapServer.setDirectoryService(ds);
    TcpTransport tcpTransport = new TcpTransport(4016);
    ldapServer.setTransports(tcpTransport);
    LOG.info(ds.getAdminSession().getAuthenticatedPrincipal().getDn());
    ldapServer.start();
}
 

public DirectoryService getDirectoryService() {
    return directoryService;
}
 

private WrapperDirectoryService(DirectoryService wrapped, CacheManager cacheManager) {
    this.wrapped = wrapped;
    this.cacheManager = cacheManager;
}
 

/**
 * {@inheritDoc}
 */
@Override
public DirectoryService getDirectoryService() throws Exception {
    return cacheManager != null ? new WrapperDirectoryService(directoryService, cacheManager) : directoryService;
}
 

private WrapperDirectoryService(DirectoryService wrapped, CacheManager cacheManager) {
    this.wrapped = wrapped;
    this.cacheManager = cacheManager;
}
 

private WrapperDirectoryService(DirectoryService wrapped, CacheManager cacheManager) {
    this.wrapped = wrapped;
    this.cacheManager = cacheManager;
}
 

public DefaultOperationManager( DirectoryService directoryService )
{
    this.directoryService = directoryService;
}
 

public DirectoryService getDirectoryService() {
    return _directoryService;
}
 

/**
 * {@inheritDoc}
 */
@Override
public DirectoryService getDirectoryService() throws Exception {
    return cacheManager != null ? new WrapperDirectoryService(directoryService, cacheManager) : directoryService;
}