IRIS uses the following conventions in the Spring initialization files, and anyone who modifies or creates bean configuration must also follow the same conventions:

As mentioned before, startup options are a way to specify that only a subset of beans load when IRIS starts. A plugin can provide startup options by simply including a file with the name syntax "NAME-startupOptions.xml" in its plugin directory (under iris/plugins). An example file is:

<beans default-lazy-init="true">
    <bean id="StartupOptions-StandAlone" class="com.sri.iris.kernel.StartupOptions" name="defaultOptions">
        <property name="displayName" value="Full Configuration" />
        <property name="description" value="Run IRIS with all installed plugins" />
        <property name="defaultOptions" value="true" />
        <property name="includedPluginBeanNames">
            <value>**</value>
        </property>
        <property name="excludedPluginBeanNames">
            <list>
                <value>MailLoader</value>
            </list>
        </property>
    </bean>
</beans>

This is a Spring configuration file where an instance of com.sri.iris.kernel.StartupOptions is declared which can have the following properties:

Specifying startup options as described above will cause them to appear in the bottom cmbo box at startup. Startup options which appear in the top combo box are called aggregate startup options and are instance of com.sri.iris.kernel.AggregableStartupOptions. These startup options take the same parameters as regular startup options with additional arguments:

IRIS aggregates options by combining the included and excluded beans. See the method applyAggregateOption in com.sri.iris.kernel.StartupOptions for more details.

IRIS is executed by running iris.bat or iris.sh from iris/bin. These scripts use the environment variable JAVA_HOME to launch Java, and they pass the following Java system and application properties when launching Java:

It is also possible to pass in runtime arguments to IRIS as arguments to iris.bat or iris.sh:

APIs exist to bootstrap IRIS. These APIs are used heavily in unit tests, and are also available if applications want to bootstrap and use IRIS services. Bootstrapping is often desireable because IRIS can be started very quickly and services are lazy inited. The application can then simply retrieve the services it cares about to perform some task (such as unit testing).

To bootstrap IRIS from another application, note the following constraints:

The main boottrapping interface is com.sri.iris.kernel.IIrisMain. To retrieve an instance of IIrisMain, use the static method "newIrisMain" in com.sri.iris.kernel.Main. An example of bootstrapping IRIS is the base class used to bootstrap for the purpose of unit testing: com.sri.iris.test.IrisJUnitTestCase. The following code boostraps IRIS (copied from IrisJUnitTestCase):

    // It is recommended to disable caching of classes when bootstrapping
    System.setProperty("proxy.loadClassProps", "false");
    main = Main.newIrisMain("iris_svc_config_bootstrap.xml", false, "iris.properties");
    final Object loadLock = new Object();
    if (!launchExternalKeychainServer) {
        // Make the keychain server run locally, and also make it bind to a random port...
        System.setProperty("iris.keychain.launch", "false");
        System.setProperty("iris.keychain.launch.checkIsRunning", "false");
        System.setProperty("keychain.setlocal", "true");
        System.setProperty("keychain.port", "0"); // 0 forces a random port to be used
        options.getIncludedPluginBeanNames().add("keychain_server");
    }

Note the following:

IRIS is started asynchronously. Once IRIS is started, services can be injected or retrieved. The following code adds a startup listener, starts IRIS, and during startup injects services.

    main.addStartupListener(new IIrisStartupListener() {
        public void notifyRootApplicationContextCreated(ApplicationContext rootContext) {
            IrisJUnitTestCase.this.rootContext = rootContext;
            if (!(rootContext instanceof AbstractApplicationContext)) {
                throw new RuntimeException("Expected root context to be of type AbstractApplicationContext");
            }
            // Temporary IRIS data dirs are used for the test. Also, a dummy username/password is supplied
            // and ILogin is overriden so no login pane is displayed.
            ((AbstractApplicationContext)rootContext).getBeanFactory().registerSingleton(
                    IUserAccountManager.class.getName(), new IUserAccountManager() {
                    public void createAccount(String username, String password) {}
                    public boolean userAccountExists() { return false; }
                    public String getUserName() { return loginName; }
                    public String getPassword() { return loginPassword; }
            });
            ((AbstractApplicationContext)rootContext).getBeanFactory().registerSingleton(
                    ILogin.class.getName(), new ILogin() {
                    private List<ILoginListener> listeners = new ArrayList<ILoginListener>();

                    public void addLoginListener(ILoginListener listener) {
                        listeners.add(listener);
                    }

                    public void displayLogin() {
                        // Immediately indicate user has logged in
                        new Thread(new Runnable() {
                            public void run() {
                                for (ILoginListener listener : listeners) {
                                    listener.notifyLoggedIn(options);
                                }
                            }
                        }).start();
                    }

                    public void hideLogin() {}
                    public void setNumbeans(int nBeans) {}
                    public void notifyBeanStartLoading(String beanName) { }
                    public void notifyBeanFinishedLoading(String beanName) {}
                    public void updateStatus(String status) {}
                    public void setStartupOptions(List<StartupOptions> options) {}
            });
            ((AbstractApplicationContext)rootContext).getBeanFactory().registerSingleton(
                    IIrisAppDirLocator.class.getName(), new TestIrisAppDirLocator(appDirRoot));
        }

        public void notifyIRISLoadStarted(StartupOptions startupOptions) {}
        public void notifyApplicationContextCreated(ApplicationContext appContext, String beanName) {}
        public void notifyBeanLoaded(ApplicationContext appContext, String beanName, Object bean) {}
        public void notifyIRISFailedToLoad(Exception ex) {}
        public void setStartupOptions(List<StartupOptions> options) {}

        public void notifyIRISLoaded(Map<String, Throwable> loadErrors) {
            irisSystem = (IIrisSystem)rootContext.getBean(IIrisSystem.class.getName());
            // IRIS has been loaded
            synchronized (loadLock) {
                loadLock.notifyAll();
            }
        }
    });
    // Load IRIS and wait for it to load
    long startTime = System.currentTimeMillis();
    main.startIris();
    main.getSecurityManager().setEnforceShutdown(false);

Note the following:

Finally, note that bootstrapping programatically is only currently used for unit testing. However, the same technique applies to any application. For example, it is possible to write a small test application that bootstraps the knowledge base and runs some queries.

To debug IRIS, run "iris.bat -debug" or "iris.sh -debug". Then configure the debugger to connect to port 5005 on the machine IRIS is running.