gt:         Map<Object, Object> result = new HashMap<Object, Object>();
context: /**
   * Copyright (c) 2002-2011 "Neo Technology,"
   * Network Engine for Objects in Lund AB [http://neotechnology.com]
   *
   * This file is part of Neo4j.
   *
   * Neo4j is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Affero General Public License for more details.
   *
   * You should have received a copy of the GNU Affero General Public License
   * along with this program. If not, see <http://www.gnu.org/licenses/>.
   */
  package org.neo4j.kernel;
  
  import java.io.File;
  import java.lang.management.GarbageCollectorMXBean;
  import java.lang.management.ManagementFactory;
  import java.lang.management.OperatingSystemMXBean;
  import java.lang.management.RuntimeMXBean;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.TreeSet;
  
  import javax.transaction.TransactionManager;
  
  import org.neo4j.graphdb.GraphDatabaseService;
  import org.neo4j.graphdb.RelationshipType;
  import org.neo4j.graphdb.TransactionFailureException;
  import org.neo4j.helpers.Service;
  import org.neo4j.helpers.UTF8;
  import org.neo4j.kernel.impl.core.LockReleaser;
  import org.neo4j.kernel.impl.nioneo.xa.NioNeoDbPersistenceSource;
  import org.neo4j.kernel.impl.transaction.LockManager;
  import org.neo4j.kernel.impl.transaction.TxModule;
  import org.neo4j.kernel.impl.transaction.xaframework.XaDataSource;
  import org.neo4j.kernel.impl.util.FileUtils;
  import org.neo4j.kernel.impl.util.StringLogger;
  
  class GraphDbInstance
  {
      private boolean started = false;
      private final boolean create;
      private String storeDir;
  
      GraphDbInstance( String storeDir, boolean create, Config config )
      {
          this.storeDir = storeDir;
          this.create = create;
          this.config = config;
      }
  
      private final Config config;
  
      private NioNeoDbPersistenceSource persistenceSource = null;
  
      public Config getConfig()
      {
          return config;
      }
  
      /**
       * Starts Neo4j with default configuration
       * @param graphDb The graph database service.
       *
       * @param storeDir path to directory where Neo4j store is located
       * @param create if true a new Neo4j store will be created if no store exist
       *            at <CODE>storeDir</CODE>
       * @param configuration parameters
       * @throws StartupFailedException if unable to start
       */
      public synchronized Map<Object, Object> start( GraphDatabaseService graphDb,
              KernelExtensionLoader kernelExtensionLoader )
      {
          if ( started )
          {
              throw new IllegalStateException( "Neo4j instance already started" );
          }
          Map<Object, Object> params = config.getParams();
          boolean useMemoryMapped = Boolean.parseBoolean( (String) config.getInputParams().get(
                  Config.USE_MEMORY_MAPPED_BUFFERS ) );
          boolean dumpToConsole = Boolean.parseBoolean( (String) config.getInputParams().get(
                  Config.DUMP_CONFIGURATION ) );
          storeDir = FileUtils.fixSeparatorsInPath( storeDir );
          StringLogger logger = StringLogger.getLogger( storeDir );
          AutoConfigurator autoConfigurator = new AutoConfigurator( storeDir, useMemoryMapped, dumpToConsole );
          autoConfigurator.configure( subset( config.getInputParams(), Config.USE_MEMORY_MAPPED_BUFFERS ) );
          // params.putAll( config.getInputParams() );
  
          String separator = System.getProperty( "file.separator" );
          String store = storeDir + separator + "neostore";
          params.put( "store_dir", storeDir );
          params.put( "neo_store", store );
          params.put( "create", String.valueOf( create ) );
          String logicalLog = storeDir + separator + "nioneo_logical.log";
          params.put( "logical_log", logicalLog );
          byte resourceId[] = UTF8.encode( "414141" );
          params.put( LockManager.class, config.getLockManager() );
          params.put( LockReleaser.class, config.getLockReleaser() );
  
          kernelExtensionLoader.configureKernelExtensions();
  
          config.getTxModule().registerDataSource( Config.DEFAULT_DATA_SOURCE_NAME,
                  Config.NIO_NEO_DB_CLASS, resourceId, params );
          // hack for lucene index recovery if in path
          if ( !config.isReadOnly() || config.isBackupSlave() )
          {
              try
              {
                  Class clazz = Class.forName( Config.LUCENE_DS_CLASS );
                  cleanWriteLocksInLuceneDirectory( storeDir + File.separator + "lucene" );
                  byte luceneId[] = UTF8.encode( "162373" );
                  registerLuceneDataSource( "lucene", clazz.getName(),
                          config.getTxModule(), storeDir + File.separator + "lucene",
                          config.getLockManager(), luceneId, params );
              }
              catch ( ClassNotFoundException e )
              { // ok index util not on class path
              }
              catch ( NoClassDefFoundError err )
              { // ok index util not on class path
              }
  
              try
              {
                  Class clazz = Class.forName( Config.LUCENE_FULLTEXT_DS_CLASS );
                  cleanWriteLocksInLuceneDirectory( storeDir + File.separator + "lucene-fulltext" );
                  byte[] luceneId = UTF8.encode( "262374" );
                  registerLuceneDataSource( "lucene-fulltext",
                          clazz.getName(), config.getTxModule(),
                          storeDir + File.separator + "lucene-fulltext", config.getLockManager(),
                          luceneId, params );
              }
              catch ( ClassNotFoundException e )
              { // ok index util not on class path
              }
              catch ( NoClassDefFoundError err )
              { // ok index util not on class path
              }
          }
          persistenceSource = new NioNeoDbPersistenceSource();
          config.setPersistenceSource( Config.DEFAULT_DATA_SOURCE_NAME, create );
          config.getIdGeneratorModule().setPersistenceSourceInstance(
                  persistenceSource );
          config.getTxModule().init();
          config.getPersistenceModule().init();
          persistenceSource.init();
          config.getIdGeneratorModule().init();
          config.getGraphDbModule().init();
  
          kernelExtensionLoader.initializeIndexProviders();
  
          config.getTxModule().start();
          config.getPersistenceModule().start( config.getTxModule().getTxManager(),
                  persistenceSource, config.getSyncHookFactory() );
          persistenceSource.start( config.getTxModule().getXaDataSourceManager() );
          config.getIdGeneratorModule().start();
          config.getGraphDbModule().start( config.getLockReleaser(),
                  config.getPersistenceModule().getPersistenceManager(),
                  config.getRelationshipTypeCreator(), params );
  
          logger.logMessage( "--- CONFIGURATION START ---" );
          logger.logMessage( autoConfigurator.getNiceMemoryInformation() );
          logger.logMessage( "Kernel version: " + Version.getKernel() );
          for ( Version componentVersion : Service.load( Version.class ) )
          {
              logger.logMessage( componentVersion.toString() );
          }
          RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
          OperatingSystemMXBean os = ManagementFactory.getOperatingSystemMXBean();
          logger.logMessage( String.format( "Operating System: %s; version: %s; arch: %s; cpus: %s",
                  os.getName(), os.getVersion(), os.getArch(), os.getAvailableProcessors() ) );
          logger.logMessage( "VM Name: " + runtime.getVmName() );
          logger.logMessage( "VM Vendor: " + runtime.getVmVendor() );
          logger.logMessage( "VM Version: " + runtime.getVmVersion() );
          if ( runtime.isBootClassPathSupported() )
          {
              logger.logMessage( "Boot Class Path: " + runtime.getBootClassPath() );
          }
          logger.logMessage( "Class Path: " + runtime.getClassPath() );
          logger.logMessage( "Library Path: " + runtime.getLibraryPath() );
          for ( GarbageCollectorMXBean gcBean : ManagementFactory.getGarbageCollectorMXBeans() )
          {
              logger.logMessage( "Garbage Collector: " + gcBean.getName() + ": "
                                 + Arrays.toString( gcBean.getMemoryPoolNames() ) );
          }
          logger.logMessage( "VM Arguments: " + runtime.getInputArguments() );
          logger.logMessage( "" );
          logConfiguration( params, logger, dumpToConsole );
          logger.logMessage( "--- CONFIGURATION END ---" );
          logger.flush();
          started = true;
          return Collections.unmodifiableMap( params );
      }
  
      private static Map<Object, Object> subset( Map<Object, Object> source, String... keys )
      {
  