protected internal virtual void Create(File storeDir, Config config, GraphDatabaseFacadeFactory.Dependencies dependencies)
{
GraphDatabaseDependencies newDependencies = newDependencies(dependencies).settingsClasses(asList(append(typeof(GraphDatabaseSettings), dependencies.SettingsClasses())));
//JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter:
(new GraphDatabaseFacadeFactory(DatabaseInfo.COMMUNITY, CommunityEditionModule::new)).initFacade(storeDir, config, newDependencies, this);
}
public override ServerControls NewServer()
{
try
{
using (FileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction())
{
File userLogFile = new File(_serverFolder, "neo4j.log");
File internalLogFile = new File(_serverFolder, "debug.log");
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.OutputStream logOutputStream;
Stream logOutputStream;
try
{
logOutputStream = createOrOpenAsOutputStream(fileSystem, userLogFile, true);
}
catch (IOException e)
{
throw new Exception("Unable to create log file", e);
}
_config[ServerSettings.third_party_packages.name()] = ToStringForThirdPartyPackageProperty(_extensions.toList());
_config[GraphDatabaseSettings.store_internal_log_path.name()] = internalLogFile.AbsolutePath;
LogProvider userLogProvider = FormattedLogProvider.withZoneId(LogZoneIdFrom(_config)).toOutputStream(logOutputStream);
GraphDatabaseDependencies dependencies = GraphDatabaseDependencies.newDependencies().userLogProvider(userLogProvider);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: Iterable<org.neo4j.kernel.extension.KernelExtensionFactory<?>> kernelExtensions = append(new Neo4jHarnessExtensions(procedures), dependencies.kernelExtensions());
IEnumerable <KernelExtensionFactory <object> > kernelExtensions = append(new Neo4jHarnessExtensions(_procedures), dependencies.KernelExtensions());
dependencies = dependencies.KernelExtensions(kernelExtensions);
Config dbConfig = Config.defaults(_config);
GraphFactory graphFactory = CreateGraphFactory(dbConfig);
bool httpAndHttpsDisabled = dbConfig.EnabledHttpConnectors().Count == 0;
NeoServer server = httpAndHttpsDisabled ? new DisabledNeoServer(graphFactory, dependencies, dbConfig) : CreateNeoServer(graphFactory, dbConfig, dependencies);
InProcessServerControls controls = new InProcessServerControls(_serverFolder, userLogFile, internalLogFile, server, logOutputStream);
controls.Start();
try
{
_fixtures.applyTo(controls);
}
catch (Exception e)
{
controls.Close();
throw e;
}
return(controls);
}
}
catch (IOException e)
{
throw new Exception(e);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public org.neo4j.server.CommunityNeoServer build() throws java.io.IOException
public virtual CommunityNeoServer Build()
{
if (string.ReferenceEquals(_dataDir, null) && _persistent)
{
throw new System.InvalidOperationException("Must specify path");
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.File configFile = buildBefore();
File configFile = BuildBefore();
Log log = LogProvider.getLog(this.GetType());
Config config = Config.fromFile(configFile).withServerDefaults().build();
config.Logger = log;
return(Build(configFile, config, GraphDatabaseDependencies.newDependencies().userLogProvider(LogProvider).monitors(new Monitors())));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: public GraphDatabaseService newDatabase(@Nonnull Config config)
public GraphDatabaseService newDatabase(Config config)
{
return(new ImpermanentGraphDatabaseAnonymousInnerClass(this, _storeDir, config, GraphDatabaseDependencies.newDependencies(_state.databaseDependencies())));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: public org.neo4j.graphdb.GraphDatabaseService newDatabase(@Nonnull Config config)
public GraphDatabaseService newDatabase(Config config)
{
return((new TestGraphDatabaseFacadeFactory(_state, true)).newFacade(_storeDir, config, GraphDatabaseDependencies.newDependencies(_state.databaseDependencies())));
}
protected internal override GraphDatabaseService NewEmbeddedDatabase(File storeDir, Config config, GraphDatabaseFacadeFactory.Dependencies dependencies)
{
return((new TestGraphDatabaseFacadeFactory(CurrentState)).newFacade(storeDir, config, GraphDatabaseDependencies.newDependencies(dependencies)));
}
///
/// <param name="graphFactory"> </param>
/// <param name="config"> </param>
/// <param name="dependencies">
/// @return </param>
protected internal virtual NeoServer CreateNeoServer(GraphFactory graphFactory, Config config, GraphDatabaseDependencies dependencies)
{
return(new EnterpriseNeoServer(config, graphFactory, dependencies));
}
protected internal override NeoServer CreateNeoServer(GraphFactory graphFactory, Config config, GraphDatabaseDependencies dependencies)
{
this.UserLogProviderConflict = dependencies.UserLogProvider();
return(base.CreateNeoServer(graphFactory, config, dependencies));
}
protected internal override CommunityNeoServer Build(File configFile, Config config, GraphDatabaseFacadeFactory.Dependencies dependencies)
{
return(new TestEnterpriseNeoServer(this, config, configFile, GraphDatabaseDependencies.newDependencies(dependencies).userLogProvider(LogProvider)));
}
public AbstractNeoServerAnonymousInnerClass(ServerBootstrapperAnonymousInnerClass outerInstance, Config config, GraphFactory graphFactory, GraphDatabaseDependencies dependencies) : base(config, graphFactory, dependencies)
{
this.outerInstance = outerInstance;
}
protected internal override NeoServer createNeoServer(GraphFactory graphFactory, Config config, GraphDatabaseDependencies dependencies)
{
dependencies.UserLogProvider();
return(new AbstractNeoServerAnonymousInnerClass(this, config, graphFactory, dependencies));
}
private LifecycleManagingDatabase NewDatabase()
{
return(new LifecycleManagingDatabase(_dbConfig, _dbFactory, GraphDatabaseDependencies.newDependencies().userLogProvider(_logProvider)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAdvertiseServicesWhenAsked() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldAdvertiseServicesWhenAsked()
{
UriInfo uriInfo = mock(typeof(UriInfo));
URI uri = new URI("http://example.org:7474/");
when(uriInfo.BaseUri).thenReturn(uri);
RootService svc = new RootService(new CommunityNeoServer(Config.defaults(stringMap((new HttpConnector("http", HttpConnector.Encryption.NONE)).type.name(), "HTTP", (new HttpConnector("http", HttpConnector.Encryption.NONE)).enabled.name(), "true")), GraphDatabaseDependencies.newDependencies().userLogProvider(NullLogProvider.Instance).monitors(new Monitors())));
EntityOutputFormat output = new EntityOutputFormat(new JsonFormat(), null, null);
Response serviceDefinition = svc.GetServiceDefinition(uriInfo, output);
assertEquals(200, serviceDefinition.Status);
IDictionary <string, object> result = (IDictionary <string, object>)output.ResultAsMap["services"];
assertThat(result["console"].ToString(), containsString(string.Format("{0}server/console", uri.ToString())));
assertThat(result["jmx"].ToString(), containsString(string.Format("{0}server/jmx", uri.ToString())));
}
protected internal override NeoServer createNeoServer(GraphFactory graphFactory, Config config, GraphDatabaseDependencies dependencies)
{
return(mock(typeof(NeoServer)));
}
public ImpermanentGraphDatabaseAnonymousInnerClass(DatabaseCreatorAnonymousInnerClass outerInstance, File storeDir, Config config, GraphDatabaseDependencies newDependencies) : base(storeDir, config, newDependencies)
{
this.outerInstance = outerInstance;
this._config = config;
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void run(final org.neo4j.io.fs.FileSystemAbstraction fs, final java.io.File storeDirectory, org.neo4j.kernel.configuration.Config config, org.neo4j.logging.LogProvider userLogProvider) throws Exception
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
public static void Run(FileSystemAbstraction fs, File storeDirectory, Config config, LogProvider userLogProvider)
{
StoreLogService logService = StoreLogService.withUserLogProvider(userLogProvider).withInternalLog(config.Get(store_internal_log_path)).build(fs);
VisibleMigrationProgressMonitor progressMonitor = new VisibleMigrationProgressMonitor(logService.GetUserLog(typeof(StoreMigration)));
LifeSupport life = new LifeSupport();
life.Add(logService);
// Add participants from kernel extensions...
DefaultExplicitIndexProvider migrationIndexProvider = new DefaultExplicitIndexProvider();
Log log = userLogProvider.GetLog(typeof(StoreMigration));
JobScheduler jobScheduler = JobSchedulerFactory.createInitialisedScheduler();
try
{
using (PageCache pageCache = createPageCache(fs, config, jobScheduler))
{
Dependencies deps = new Dependencies();
Monitors monitors = new Monitors();
deps.SatisfyDependencies(fs, config, migrationIndexProvider, pageCache, logService, monitors, RecoveryCleanupWorkCollector.immediate());
KernelContext kernelContext = new SimpleKernelContext(storeDirectory, DatabaseInfo.UNKNOWN, deps);
DatabaseKernelExtensions kernelExtensions = life.Add(new DatabaseKernelExtensions(kernelContext, GraphDatabaseDependencies.newDependencies().kernelExtensions(), deps, ignore()));
DatabaseLayout databaseLayout = DatabaseLayout.of(storeDirectory);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.impl.transaction.log.files.LogFiles logFiles = org.neo4j.kernel.impl.transaction.log.files.LogFilesBuilder.activeFilesBuilder(databaseLayout, fs, pageCache).withConfig(config).build();
LogFiles logFiles = LogFilesBuilder.activeFilesBuilder(databaseLayout, fs, pageCache).withConfig(config).build();
LogTailScanner tailScanner = new LogTailScanner(logFiles, new VersionAwareLogEntryReader <Org.Neo4j.Kernel.impl.transaction.log.ReadableClosablePositionAwareChannel>(), monitors);
DefaultIndexProviderMap indexProviderMap = life.Add(new DefaultIndexProviderMap(kernelExtensions, config));
// Add the kernel store migrator
life.Start();
long startTime = DateTimeHelper.CurrentUnixTimeMillis();
DatabaseMigrator migrator = new DatabaseMigrator(progressMonitor, fs, config, logService, indexProviderMap, migrationIndexProvider, pageCache, RecordFormatSelector.selectForConfig(config, userLogProvider), tailScanner, jobScheduler);
migrator.Migrate(databaseLayout);
// Append checkpoint so the last log entry will have the latest version
AppendCheckpoint(logFiles, tailScanner);
long duration = DateTimeHelper.CurrentUnixTimeMillis() - startTime;
log.Info(format("Migration completed in %d s%n", duration / 1000));
}
}
catch (Exception e)
{
throw new StoreUpgrader.UnableToUpgradeException("Failure during upgrade", e);
}
finally
{
life.Shutdown();
jobScheduler.close();
}
}
public override void Start()
{
DatabaseConflict = new ReadReplicaGraphDatabase(DatabasesDirectory, _memberConfig, GraphDatabaseDependencies.newDependencies().monitors(MonitorsConflict), DiscoveryServiceFactory, MemberId());
}
public GraphDatabaseService newDatabase(Config config)
{
return(_outerInstance.customFacadeFactory.newFacade(_storeDir, config, GraphDatabaseDependencies.newDependencies(_state.databaseDependencies())));
}
