ladle 0.2.0 → 1.0.0.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7eb45d660b1025e5757a52a72062c48085602ece
+  data.tar.gz: e9755fd3d28bbcc2ab7e3933a7fcf30dd5087c11
+SHA512:
+  metadata.gz: a9b6cac2299323857264240b24f46a8bd26f3e46fe6c687b55e9e59b1c77b21df28b33c132d8e6504d48c1aaa320ccd573c8c56a349facec4f2e7b89b415d0e6
+  data.tar.gz: 7d0864a8edb21452f0c709780cc8def75666f9a19d7aaecd288871077ba8611a82cca2cbba63b802d7e04704b180cafd5e31a2fbc6ac77214f40ea832b4764fd

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+1.0.0
+=====
+
+- Updated to apacheDS 2.0.0-M16 from 1.0.2. (#14, #17, #18; @silarsis, @calavera, @http-418)
+- BACKWARDS_INCOMPATIBLE CHANGE: Custom schemas are now defined in LDIF files,
+  not via the former baroque java system. See CUSTOM-SCHEMA.md for details. (#14, @silarsis)
+- Upgraded dependency to net-ldap-0.3.1 (#14, @silarsis)
+- Added pom.xml to simplify downloading future apacheDS updates (#18, @http-418)
+- Avoid EOF error on `Server#stop`. (#12; @iRyusa)
+- Drop support for Ruby 1.8.7.
+
+0.2.1
+=====
+
+- Improve error handling on newer versions of JRuby.
+- Loosen open4 dependency for wider compatibility with other gems.
+- Correct Cucumber snippets in readme. (#8)
+
 0.2.0
 =====
 

data/CUSTOM-SCHEMA.md

@@ -1,61 +1,36 @@
 Custom Schemas in Ladle
 =======================
 
-If you need to use LDAP classes other the standard ones, you'll need
-to define and include a custom schema.  There are three steps in this
-process:
+If you need to use LDAP classes other the standard ones, you'll need to define
+and include a custom schema.  As of version 2.0 of apacheDS, this is done via
+ldif files. You can create the appropriate schema elements in a stand-alone ldif
+file and specify that be loaded prior to any data files.
 
-Create or obtain the schema in openldap format
-----------------------------------------------
+For an example of how this should look, please refer to
+`spec/ladle/animals-custom-schema.ldif`.
 
-All the details are there in the step name.
+`CN=other,OU=schema` is a good place to put your own custom attributes
+and object types. There is a "test branch" starting with 2.25 which can
+be used for self-generated oids, if you're making things up yourself
+- check [this stackoverflow question][so] for more info.
 
-Generate the java representation of the schema
-----------------------------------------------
-
-The embedded LDAP server in ladle is ApacheDS 1.0.2.  That project
-provides [documentation][ds-custom] of how to build custom schemas;
-look at the section titled "Creating a Maven module for your custom
-schema."  As you might guess from the title, you'll need [maven
-2][mvn] to do this.
-
-The process has one snag -- after you generate the schema using
-`apacheds-schema-archetype.sh`, you'll need to modify the generated
-`pom.xml`.  Under the this code:
-
-    <plugins>
-      <plugin>
-        <groupId>org.apache.directory.server</groupId>
-        <artifactId>apacheds-core-plugin</artifactId>
-
-Add the line:
-
-        <version>1.0.2</version>
-
-Then continue with the directions.
-
-[ds-custom]: http://directory.apache.org/apacheds/1.0/custom-schema.html.
-[mvn]: http://maven.apache.org/
+[so]: http://stackoverflow.com/questions/725837/experimental-private-branch-for-oid-numbers-in-ldap-schemas
 
 Configure ladle to use the custom schema
 ----------------------------------------
 
-At the end of the java schema generation step, you'll have a jar file
-under `target` containing several classes representing the the schema.
-Put that jar somewhere in your project, then configure the
+Put the ldif somewhere in your project, then configure the
 {Ladle::Server} instance to point to it:
 
     Ladle::Server.new(
-      :additional_classpath => %w(path/to/sample-schema-1.0-SNAPSHOT.jar),
-      :custom_schemas => %w(com.example.schema.TestSchema),
-      :ldif => "path/to/schema-using.ldif",
+      :custom_schemas => "path/to/schema.ldif",
+      :ldif => "path/to/data-that-uses-the-schema.ldif",
       :domain => "dc=example,dc=com"
     )
 
-The custom schema classname is derived from the first argument you
-passed to `apacheds-schema-archtype.sh` and the name of your schema
-file.  In the example above, it's as if you ran
-
-    apacheds-schema-archetype.sh com.example.schema sample-schema
-
-And then named the schema file `test.schema`.
+You may also combine the custom schema declarations in the data LDIF (the file
+named by the `:ldif` option). If you do this, do can skip the `:custom_schemas`
+option entirely. The separate `:custom_schemas` option is nice if you use the
+same schema but different data in different tests, or if you use an externally-
+provided schema. If your tests aren't that complicated, then combining them into
+one file has no downsides.

data/README.md

@@ -9,12 +9,16 @@ It spins up an actual LDAP server instance, so you can use it to test
 any sort of client application — anything that communicates over
 the standard LDAP protocol.
 
-Ladle itself is tested on both JRuby 1.5.2 and Ruby 1.8.7 and 1.9.1.
+Ladle itself is tested on both JRuby 1.7.11 and Ruby 1.9.3, 2.0.0, and 2.1.2.
 It is a wrapper around [ApacheDS][] (a pure-java embeddable LDAP
-server), so it needs Java 1.5 or later available whether you are using
+server), so it needs Java 7 or later available whether you are using
 JRuby or not.
 
-[ApacheDS]: http://directory.apache.org/apacheds/1.0/index.html
+Ladle will not work with MRI on Windows. (A pull request adding this support
+would be eagerly reviewed.) It should work with JRuby on Windows, though this
+hasn't been tested.
+
+[ApacheDS]: http://directory.apache.org/apacheds/
 
 Ladle in 30 seconds
 -------------------
@@ -85,7 +89,7 @@ To use a server per test, use Cucumber's `Around` [hook][cucumber-hooks]:
 If you want just one server, consider something like this:
 
     Before('@ldap') do
-      @ladle ||= Ladle::Server.new(:quiet => true).start
+      $ladle ||= Ladle::Server.new(:quiet => true).start
     end
 
 This will start up a server for the first feature which needs it (and
@@ -95,7 +99,7 @@ end of the run.  (Cucumber's hooks documentation notes that you would,
 in general, need to register an `at_exit` block for the process to be
 torn down at the end.  {Ladle::Server#start} does this automatically.)
 
-[cucumber-hooks]: http://github.com/aslakhellesoy/cucumber/wiki/hooks
+[cucumber-hooks]: http://github.com/cucumber/cucumber/wiki/hooks
 
 Test data
 ---------
@@ -121,9 +125,9 @@ provided by ApacheDS, you'll need to specify a custom schema.  See
 Project links
 -------------
 
-* [API documentation](http://rubydoc.info/github/rsutphin/ladle/master/frames)
-* [Continuous integration](https://ctms-ci.nubic.northwestern.edu/hudson/job/ladle/)
-* [Issue tracking](http://github.com/rsutphin/ladle/issues)
+* [API documentation](http://rubydoc.info/github/NUBIC/ladle/master/frames)
+* [Continuous integration](https://travis-ci.org/NUBIC/ladle)
+* [Issue tracking](http://github.com/NUBIC/ladle/issues)
 
 Non-issue questions can be sent to rhett@detailedbalance.net.
 

data/lib/ladle/java/log4j-quiet.properties

@@ -0,0 +1,8 @@
+# Root logger option
+log4j.rootLogger=ERROR, stdout
+
+# Direct log messages to stdout
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.Target=System.out
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

data/lib/ladle/java/net/detailedbalance/ladle/Main.java

@@ -18,6 +18,7 @@ import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -39,20 +40,19 @@ public class Main {
                 behaveBadly(commandLine.getOptionValue('F'));
             }
 
+            List<String> schemaFileNames;
+            if (commandLine.hasOption('S')) {
+                schemaFileNames = Arrays.asList(commandLine.getOptionValue('S').split(","));
+            } else {
+                schemaFileNames = Collections.emptyList();
+            }
+
             final Server s = new Server(
                 new Integer(commandLine.getOptionValue("p")),
                 commandLine.getOptionValue("d"),
                 new File(commandLine.getOptionValue("l")),
                 new File(commandLine.getOptionValue('t')),
-                !commandLine.hasOption('A'));
-            if (commandLine.hasOption('S')) {
-                List<String> schemaClassNames = Arrays.asList(commandLine.getOptionValue('S').split(","));
-                List<Class<?>> schemaClasses = new ArrayList<Class<?>>(schemaClassNames.size());
-                for (String schemaClassName : schemaClassNames) {
-                    schemaClasses.add(Class.forName(schemaClassName));
-                }
-                s.setCustomSchemas(schemaClasses);
-            }
+                !commandLine.hasOption('A'), schemaFileNames);
 
             Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                 public void run() {

data/lib/ladle/java/net/detailedbalance/ladle/Server.java

@@ -1,27 +1,47 @@
 package net.detailedbalance.ladle;
 
 import org.apache.commons.io.FileUtils;
-import org.apache.directory.server.configuration.MutableServerStartupConfiguration;
-import org.apache.directory.server.core.configuration.Configuration;
-import org.apache.directory.server.core.configuration.MutablePartitionConfiguration;
-import org.apache.directory.server.core.configuration.ShutdownConfiguration;
-import org.apache.directory.server.core.schema.bootstrap.BootstrapSchema;
+import org.apache.directory.api.ldap.model.entry.Entry;
+import org.apache.directory.api.ldap.model.entry.DefaultEntry;
+import org.apache.directory.api.ldap.model.exception.LdapException;
+import org.apache.directory.api.ldap.model.name.Dn;
+import org.apache.directory.api.ldap.model.schema.SchemaManager;
+import org.apache.directory.api.ldap.model.schema.registries.SchemaLoader;
+import org.apache.directory.api.ldap.model.ldif.LdifReader;
+import org.apache.directory.api.ldap.model.ldif.LdifEntry;
+import org.apache.directory.api.ldap.schemaextractor.SchemaLdifExtractor;
+import org.apache.directory.api.ldap.schemaextractor.impl.DefaultSchemaLdifExtractor;
+import org.apache.directory.api.ldap.schemaloader.LdifSchemaLoader;
+import org.apache.directory.api.ldap.schemamanager.impl.DefaultSchemaManager;
+import org.apache.directory.api.util.exception.Exceptions;
+import org.apache.directory.server.constants.ServerDNConstants;
+import org.apache.directory.server.core.DefaultDirectoryService;
+import org.apache.directory.server.core.api.CacheService;
+import org.apache.directory.server.core.api.DirectoryService;
+import org.apache.directory.server.core.api.DnFactory;
+import org.apache.directory.server.core.api.InstanceLayout;
+import org.apache.directory.server.core.api.partition.Partition;
+import org.apache.directory.server.core.api.schema.SchemaPartition;
+import org.apache.directory.server.core.partition.impl.btree.jdbm.JdbmIndex;
+import org.apache.directory.server.core.partition.impl.btree.jdbm.JdbmPartition;
+import org.apache.directory.server.core.partition.ldif.LdifPartition;
+import org.apache.directory.server.i18n.I18n;
+import org.apache.directory.server.ldap.LdapServer;
+import org.apache.directory.server.protocol.shared.transport.TcpTransport;
 import org.apache.log4j.Logger;
 
 import javax.naming.Context;
 import javax.naming.NamingException;
-import javax.naming.directory.Attribute;
-import javax.naming.directory.Attributes;
-import javax.naming.directory.BasicAttribute;
-import javax.naming.directory.BasicAttributes;
-import javax.naming.directory.InitialDirContext;
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.FileInputStream;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Set;
+import java.util.List;
 import java.util.UUID;
 
 /**
@@ -31,6 +51,9 @@ import java.util.UUID;
  * <p>
  * The idea of using ApacheDS for this was from Spring Security's LDAP test support.  The details
  * are from the ApacheDS embedding and unit testing documentation.
+ * <p>
+ * This version uses ApacheDS 2.0 and is based on
+ * http://svn.apache.org/repos/asf/directory/sandbox/kayyagari/embedded-sample-trunk/src/main/java/org/apache/directory/seserver/EmbeddedADSVerTrunk.java
  */
 public class Server {
     private final Logger log = Logger.getLogger(getClass());
@@ -39,25 +62,30 @@ public class Server {
     private final String domainComponent;
     private final boolean allowAnonymous;
     private final File tempDir;
-    private final File ldifDir;
+    private final String ldifFileName;
     private boolean running = false;
-    private Collection<Class<?>> customSchemas = Collections.emptyList();
+    private Collection<String> customSchemaFilenames;
+
+    private DirectoryService service;
+    private LdapServer ldapServer;
 
     public Server(
-        int port, String domainComponent, File ldifFile, File tempDirBase, boolean allowAnonymous
+        int port, String domainComponent, File ldifFile, File tempDirBase, boolean allowAnonymous,
+        Collection<String> customSchemaFilenames
     ) {
         this.port = port;
         this.domainComponent = domainComponent;
         this.allowAnonymous = allowAnonymous;
         this.tempDir = createTempDir(tempDirBase);
-        this.ldifDir = prepareLdif(ldifFile);
+        this.ldifFileName = ldifFile.getPath();
+        this.customSchemaFilenames = customSchemaFilenames;
     }
 
     ////// SETUP
 
     private File createTempDir(File tempDirBase) {
         File temp = new File(tempDirBase, "ladle-server-" + UUID.randomUUID());
-        
+
         if (temp.mkdir()) {
             return temp;
         } else {
@@ -79,47 +107,66 @@ public class Server {
         return env;
     }
 
-    private File prepareLdif(File ldifFile) {
-        File dir = new File(tempDir, "ldif");
-        if (!dir.mkdir()) {
-            throw new LadleFatalException("Could not create LDIF directory " + dir);
-        }
+    ////// RUNNING
+
+    @SuppressWarnings(value={"unchecked"})
+    public void start() throws Exception {
+        if (running) return;
 
         try {
-            FileUtils.copyFileToDirectory(ldifFile, dir);
-        } catch (IOException e) {
-            throw new LadleFatalException("Copying " + ldifFile + " to " + dir + " failed.", e);
-        }
+            // Initialize the LDAP service
+            service = new DefaultDirectoryService();
+            service.setInstanceLayout( new InstanceLayout( tempDir ) );
 
-        return dir;
-    }
+            CacheService cacheService = new CacheService();
+            cacheService.initialize( service.getInstanceLayout() );
 
-    ////// RUNNING
+            service.setCacheService( cacheService );
 
-    @SuppressWarnings({"unchecked"})
-    public void start() {
-        if (running) return;
+            // first load the schema
+            initSchemaPartition();
 
-        try {
-            MutableServerStartupConfiguration cfg = new MutableServerStartupConfiguration();
-            cfg.setWorkingDirectory(tempDir);
-            cfg.setLdifDirectory(ldifDir);
-            cfg.setEnableNetworking(true);
-            cfg.setLdapPort(port);
-            cfg.setAllowAnonymousAccess(allowAnonymous);
-            cfg.setAccessControlEnabled(false);
-            cfg.setShutdownHookEnabled(false);
-            cfg.setContextPartitionConfigurations(
-                Collections.singleton(createPartitionConfiguration()));
-            if (!customSchemas.isEmpty()) {
-                Set<BootstrapSchema> schemas = cfg.getBootstrapSchemas();
-                for (Class<?> customSchemaClass : customSchemas) {
-                    schemas.add((BootstrapSchema) customSchemaClass.newInstance());
-                }
-                cfg.setBootstrapSchemas(schemas);
+            // then the system partition
+            initSystemPartition();
+
+            // Disable the ChangeLog system
+            service.getChangeLog().setEnabled( false );
+            service.setDenormalizeOpAttrsEnabled( true );
+
+            // Now we can create as many partitions as we need
+            Partition ladlePartition = addPartition( "ladle", domainComponent, service.getDnFactory() );
+
+            // Setup indexes, access rules, and start it up
+            addIndex( ladlePartition, "objectClass", "ou", "dc", "uid" );
+            service.setAllowAnonymousAccess( allowAnonymous );
+            service.startup();
+
+             // Inject the context entry for the partition if it does not already exist
+            try
+            {
+                service.getAdminSession().lookup( ladlePartition.getSuffixDn() );
+            }
+            catch ( LdapException lnnfe )
+            {
+                Dn userDN = new Dn( domainComponent );
+                Entry userEntry = service.newEntry( userDN );
+                userEntry.add( "objectClass", "top", "domain", "extensibleObject" );
+                userEntry.add( "dc", domainComponent.split(",")[0].substring(3) );
+                service.getAdminSession().add( userEntry );
+            }
+
+            // Load up any extra data
+            for (String schemaFileName : customSchemaFilenames) {
+                loadLDIF(schemaFileName);
             }
+            loadLDIF(ldifFileName);
 
-            new InitialDirContext(createJndiEnvironment(cfg));
+            // Now create the LDAP server and transport for the Directory Service.
+            ldapServer = new LdapServer();
+            ldapServer.setDirectoryService( service );
+            TcpTransport ldapTransport = new TcpTransport( port );
+            ldapServer.setTransports( ldapTransport );
+            ldapServer.start();
         } catch (NamingException e) {
             throw new LadleFatalException("Startup failed", e);
         } catch (InstantiationException e) {
@@ -131,49 +178,139 @@ public class Server {
         running = true;
     }
 
-    // Derived from http://directory.apache.org/apacheds/1.0/using-apacheds-for-unit-tests.html
-    private MutablePartitionConfiguration createPartitionConfiguration() throws NamingException {
-        MutablePartitionConfiguration pCfg = new MutablePartitionConfiguration();
-        pCfg.setName("ladle");
-        pCfg.setSuffix(domainComponent);
+    public void loadLDIF(String filepath) throws Exception {
+
+        log.info("Loading : " + filepath);
+
+        if (!service.isStarted()) {
+            throw new Exception("Directory service not started");
+        } else {
+            InputStream inputStream = null;
+            SchemaManager schemaManager = service.getSchemaManager();
+            try {
+                inputStream = new FileInputStream(filepath);
+                if (inputStream != null) {
+                    LdifReader entries = new LdifReader(inputStream);
+                    for (LdifEntry ldifEntry : entries) {
+                        DefaultEntry newEntry = new DefaultEntry(schemaManager, ldifEntry.getEntry());
+                        service.getAdminSession().add( newEntry );
+                    }
+                }
+            } finally {
+                if (inputStream != null) inputStream.close();
+            }
+        }
+    }
+
+    /**
+     * Add a new partition to the server
+     *
+     * @param partitionId The partition Id
+     * @param partitionDn The partition DN
+     * @param dnFactory The DN factory
+     * @return The newly added partition
+     * @throws Exception If the partition can't be added
+     */
+    private Partition addPartition( String partitionId, String partitionDn, DnFactory dnFactory ) throws Exception
+    {
+        // Create a new partition with the given partition id
+        JdbmPartition partition = new JdbmPartition(service.getSchemaManager(), dnFactory);
+        partition.setId( partitionId );
+        partition.setPartitionPath( new File( service.getInstanceLayout().getPartitionsDirectory(), partitionId ).toURI() );
+        partition.setSuffixDn( new Dn( partitionDn ) );
+        service.addPartition( partition );
+
+        return partition;
+    }
+
+    /**
+     * initialize the schema manager and add the schema partition to directory service
+     *
+     * @throws Exception if the schema LDIF files are not found on the classpath
+     */
+    private void initSchemaPartition() throws Exception
+    {
+        InstanceLayout instanceLayout = service.getInstanceLayout();
 
-        Set<String> indexedAttrs = new HashSet<String>();
-        indexedAttrs.add("objectClass");
-        indexedAttrs.add("dc");
-        indexedAttrs.add("uid");
-        pCfg.setIndexedAttributes( indexedAttrs );
+        File schemaPartitionDirectory = new File( instanceLayout.getPartitionsDirectory(), "schema" );
 
-        // Create the root entry
+        // Extract the schema on disk (a brand new one) and load the registries
+        if ( schemaPartitionDirectory.exists() )
         {
-            Attributes attrs = new BasicAttributes(true);
+            log.warn( "schema partition already exists, skipping schema extraction" );
+        }
+        else
+        {
+            SchemaLdifExtractor extractor = new DefaultSchemaLdifExtractor( instanceLayout.getPartitionsDirectory() );
+            extractor.extractOrCopy();
+        }
 
-            Attribute attr = new BasicAttribute("objectClass");
-            attr.add("top");
-            attr.add("domain");
-            attrs.put(attr);
+        SchemaLoader loader = new LdifSchemaLoader( schemaPartitionDirectory );
+        SchemaManager schemaManager = new DefaultSchemaManager( loader );
 
-            attr = new BasicAttribute("dc");
-            attr.add(domainComponent.split(",")[0].substring(3));
-            attrs.put(attr);
+        // We have to load the schema now, otherwise we won't be able
+        // to initialize the Partitions, as we won't be able to parse
+        // and normalize their suffix Dn
+        schemaManager.loadAllEnabled();
 
-            pCfg.setContextEntry(attrs);
+        List<Throwable> errors = schemaManager.getErrors();
+
+        if ( errors.size() != 0 )
+        {
+            throw new Exception( I18n.err( I18n.ERR_317, Exceptions.printErrors( errors ) ) );
         }
 
-        return pCfg;
+        service.setSchemaManager( schemaManager );
+
+        // Init the LdifPartition with schema
+        LdifPartition schemaLdifPartition = new LdifPartition( schemaManager, service.getDnFactory() );
+        schemaLdifPartition.setPartitionPath( schemaPartitionDirectory.toURI() );
+
+        // The schema partition
+        SchemaPartition schemaPartition = new SchemaPartition( schemaManager );
+        schemaPartition.setWrappedPartition( schemaLdifPartition );
+        service.setSchemaPartition( schemaPartition );
     }
 
-    @SuppressWarnings({ "unchecked" })
-    private Hashtable<String, String> createJndiEnvironment(Configuration cfg) {
-        Hashtable<String, String> env = baseEnvironment();
-        env.putAll(cfg.toJndiEnvironment());
-        return env;
+    private void initSystemPartition() throws Exception {
+        // this is a MANDATORY partition
+        // DO NOT add this via addPartition() method, trunk code complains about duplicate partition
+        // while initializing
+        JdbmPartition systemPartition = new JdbmPartition( service.getSchemaManager(), service.getDnFactory() );
+        systemPartition.setId( "system" );
+        systemPartition.setPartitionPath( new File( service.getInstanceLayout().getPartitionsDirectory(), systemPartition.getId() ).toURI() );
+        systemPartition.setSuffixDn( new Dn( ServerDNConstants.SYSTEM_DN ) );
+        systemPartition.setSchemaManager( service.getSchemaManager() );
+
+        // mandatory to call this method to set the system partition
+        // Note: this system partition might be removed from trunk
+        service.setSystemPartition( systemPartition );
+    }
+
+    /**
+     * Add a new set of index on the given attributes
+     *
+     * @param partition The partition on which we want to add index
+     * @param attrs The list of attributes to index
+     */
+    private void addIndex( Partition partition, String... attrs )
+    {
+        // Index some attributes on the apache partition
+        Set indexedAttributes = new HashSet();
+
+        for ( String attribute : attrs )
+        {
+            indexedAttributes.add( new JdbmIndex( attribute, false ) );
+        }
+
+        ( ( JdbmPartition ) partition ).setIndexedAttributes( indexedAttributes );
     }
 
-    public void stop() {
+    public void stop() throws LadleFatalException {
         if (!running) return;
         try {
-            new InitialDirContext(createJndiEnvironment(new ShutdownConfiguration()));
-        } catch (NamingException e) {
+            service.shutdown();
+        } catch (Exception e) {
             throw new LadleFatalException("Shutdown failed", e);
         }
         running = false;
@@ -186,8 +323,4 @@ public class Server {
             }
         }
     }
-
-    public void setCustomSchemas(Collection<Class<?>> customSchemas) {
-        this.customSchemas = customSchemas;
-    }
 }