//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldDropIndexOnRecovery() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldDropIndexOnRecovery() { // given a transaction stream ending in an INDEX DROP command. CommittedTransactionRepresentation dropTransaction = PrepareDropTransaction(); File storeDir = Directory.databaseDir(); GraphDatabaseService db = (new TestGraphDatabaseFactory()).newEmbeddedDatabase(storeDir); CreateIndex(db); Db.shutdown(); AppendDropTransactionToTransactionLog(Directory.databaseDir(), dropTransaction); // when recovering this (the drop transaction with the index file intact) Monitors monitors = new Monitors(); AssertRecoveryIsPerformed recoveryMonitor = new AssertRecoveryIsPerformed(); monitors.AddMonitorListener(recoveryMonitor); db = (new TestGraphDatabaseFactory()).setMonitors(monitors).newEmbeddedDatabase(storeDir); try { assertTrue(recoveryMonitor.RecoveryWasPerformed); // then using (Transaction tx = Db.beginTx()) { assertEquals(0, count(Db.schema().Indexes)); tx.Success(); } } finally { // and the ability to shut down w/o failing on still open files Db.shutdown(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldConvertListsAndMapsWhenPassingFromScalaToJava() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldConvertListsAndMapsWhenPassingFromScalaToJava() { GraphDatabaseQueryService graph = new GraphDatabaseCypherService(this.Database.GraphDatabaseAPI); DependencyResolver resolver = graph.DependencyResolver; Monitors monitors = resolver.ResolveDependency(typeof(Monitors)); NullLogProvider nullLogProvider = NullLogProvider.Instance; Config config = resolver.ResolveDependency(typeof(Config)); CypherConfiguration cypherConfig = CypherConfiguration.fromConfig(config); CommunityCompilerFactory compilerFactory = new CommunityCompilerFactory(graph, monitors, nullLogProvider, cypherConfig.toCypherPlannerConfiguration(config), cypherConfig.toCypherRuntimeConfiguration()); ExecutionEngine executionEngine = new ExecutionEngine(graph, nullLogProvider, compilerFactory); Result result; using (InternalTransaction tx = graph.BeginTransaction(KernelTransaction.Type.@implicit, LoginContext.AUTH_DISABLED)) { string query = "RETURN { key : 'Value' , collectionKey: [{ inner: 'Map1' }, { inner: 'Map2' }]}"; TransactionalContext tc = CreateTransactionContext(graph, tx, query); result = executionEngine.ExecuteQuery(query, _noParams, tc); VerifyResult(result); result.Close(); tx.Success(); } }
public ClusteringModule(DiscoveryServiceFactory discoveryServiceFactory, MemberId myself, PlatformModule platformModule, File clusterStateDirectory, DatabaseLayout databaseLayout) { LifeSupport life = platformModule.Life; Config config = platformModule.Config; LogProvider logProvider = platformModule.Logging.InternalLogProvider; LogProvider userLogProvider = platformModule.Logging.UserLogProvider; Dependencies dependencies = platformModule.Dependencies; Monitors monitors = platformModule.Monitors; FileSystemAbstraction fileSystem = platformModule.FileSystem; RemoteMembersResolver remoteMembersResolver = chooseResolver(config, platformModule.Logging); _topologyService = discoveryServiceFactory.CoreTopologyService(config, myself, platformModule.JobScheduler, logProvider, userLogProvider, remoteMembersResolver, ResolveStrategy(config, logProvider), monitors); life.Add(_topologyService); dependencies.SatisfyDependency(_topologyService); // for tests CoreBootstrapper coreBootstrapper = new CoreBootstrapper(databaseLayout, platformModule.PageCache, fileSystem, config, logProvider, platformModule.Monitors); SimpleStorage <ClusterId> clusterIdStorage = new SimpleFileStorage <ClusterId>(fileSystem, clusterStateDirectory, CLUSTER_ID_NAME, new ClusterId.Marshal(), logProvider); SimpleStorage <DatabaseName> dbNameStorage = new SimpleFileStorage <DatabaseName>(fileSystem, clusterStateDirectory, DB_NAME, new DatabaseName.Marshal(), logProvider); string dbName = config.Get(CausalClusteringSettings.database); int minimumCoreHosts = config.Get(CausalClusteringSettings.minimum_core_cluster_size_at_formation); Duration clusterBindingTimeout = config.Get(CausalClusteringSettings.cluster_binding_timeout); _clusterBinder = new ClusterBinder(clusterIdStorage, dbNameStorage, _topologyService, Clocks.systemClock(), () => sleep(100), clusterBindingTimeout, coreBootstrapper, dbName, minimumCoreHosts, platformModule.Monitors); }
public RecoveryRequiredChecker(FileSystemAbstraction fs, PageCache pageCache, Config config, Monitors monitors) { this._fs = fs; this._pageCache = pageCache; this._config = config; this._monitors = monitors; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setUp() public virtual void SetUp() { TestHighlyAvailableGraphDatabaseFactory factory = new TestHighlyAvailableGraphDatabaseFactory(); Monitors monitors = new Monitors(); monitors.AddMonitorListener(_monitor); //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: factory.RemoveKernelExtensions(extension => extension.GetType().FullName.Contains("LabelScan")); ClusterManager clusterManager = (new ClusterManager.Builder(TestDirectory.directory("root"))).withDbFactory(factory).withMonitors(monitors).withStoreDirInitializer((serverId, storeDir) => { if (serverId == 1) { GraphDatabaseService db = (new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(storeDir).setConfig(OnlineBackupSettings.online_backup_enabled, Settings.FALSE).newGraphDatabase(); try { CreateSomeLabeledNodes(db, new Label[] { Labels.First }, new Label[] { Labels.First, Labels.Second }, new Label[] { Labels.Second }); } finally { Db.shutdown(); } } }).build(); _life.add(clusterManager); _life.start(); _cluster = clusterManager.Cluster; _cluster.await(allSeesAllAsAvailable()); _cluster.await(allAvailabilityGuardsReleased()); }
public DefaultSlaveFactory(LogProvider logProvider, Monitors monitors, int chunkSize, System.Func <LogEntryReader <ReadableClosablePositionAwareChannel> > logEntryReader) { this._logProvider = logProvider; this._monitors = monitors; this._chunkSize = chunkSize; this._entryReader = logEntryReader; }
private static BinaryLatch InjectWarmupLatch( ClusterMember member, AtomicLong pagesLoadedInWarmup ) { BinaryLatch warmupLatch = new BinaryLatch(); Monitors monitors = member.monitors(); monitors.AddMonitorListener( new PageCacheWarmerMonitorAdapterAnonymousInnerClass( pagesLoadedInWarmup, warmupLatch ) ); return warmupLatch; }
public LifecycleAdapterAnonymousInnerClass(QueryLoggerKernelExtension outerInstance, FileSystemAbstraction fileSystem, Config config, Monitors monitoring, LogService logService, JobScheduler jobScheduler) { this.outerInstance = outerInstance; this._fileSystem = fileSystem; this._config = config; this._monitoring = monitoring; this._logService = logService; this._jobScheduler = jobScheduler; }
public PhysicalLogicalTransactionStore(LogFiles logFiles, TransactionMetadataCache transactionMetadataCache, LogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader, Monitors monitors, bool failOnCorruptedLogFiles) { this._logFiles = logFiles; this._logFile = logFiles.LogFile; this._transactionMetadataCache = transactionMetadataCache; this._logEntryReader = logEntryReader; this._monitors = monitors; this._failOnCorruptedLogFiles = failOnCorruptedLogFiles; }
public DefaultBoltConnectionFactory(BoltSchedulerProvider schedulerProvider, TransportThrottleGroup throttleGroup, Config config, LogService logService, Clock clock, Monitors monitors) { this._schedulerProvider = schedulerProvider; this._throttleGroup = throttleGroup; this._config = config; this._logService = logService; this._clock = clock; this._monitors = monitors; this._metricsMonitor = monitors.NewMonitor(typeof(BoltConnectionMetricsMonitor)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Override public org.neo4j.kernel.lifecycle.Lifecycle newInstance(@SuppressWarnings("unused") org.neo4j.kernel.impl.spi.KernelContext context, final Dependencies dependencies) //JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: public override Lifecycle NewInstance(KernelContext context, Dependencies dependencies) { FileSystemAbstraction fileSystem = dependencies.FileSystem(); Config config = dependencies.Config(); Monitors monitoring = dependencies.Monitoring(); LogService logService = dependencies.Logger(); JobScheduler jobScheduler = dependencies.JobScheduler(); return(new LifecycleAdapterAnonymousInnerClass(this, fileSystem, config, monitoring, logService, jobScheduler)); }
public CoreStateDownloaderService(JobScheduler jobScheduler, CoreStateDownloader downloader, CommandApplicationProcess applicationProcess, LogProvider logProvider, Org.Neo4j.causalclustering.helper.TimeoutStrategy_Timeout downloaderPauseStrategy, System.Func <DatabaseHealth> dbHealth, Monitors monitors) { this._jobScheduler = jobScheduler; this._downloader = downloader; this._applicationProcess = applicationProcess; this._log = logProvider.getLog(this.GetType()); this._downloaderPauseStrategy = downloaderPauseStrategy; this._dbHealth = dbHealth; this._monitors = monitors; }
public BoltMetrics(MetricRegistry registry, Monitors monitors) { if (!InstanceFieldsInitialized) { InitializeInstanceFields(); InstanceFieldsInitialized = true; } this._registry = registry; this._monitors = monitors; }
/// <summary> /// Dependencies that can be resolved immediately after launching the backup tool /// </summary> /// <param name="outsideWorld"> filesystem and output streams that the tool interacts with </param> /// <param name="logProvider"> made available to subsequent dependency resolution classes </param> /// <param name="monitors"> will become shared across all resolved dependencies </param> internal BackupModule(OutsideWorld outsideWorld, LogProvider logProvider, Monitors monitors) { this._outsideWorld = outsideWorld; this._logProvider = logProvider; this._monitors = monitors; this._clock = Clock.systemDefaultZone(); this._transactionLogCatchUpFactory = new TransactionLogCatchUpFactory(); this._fileSystemAbstraction = outsideWorld.FileSystem(); this._jobScheduler = createInitialisedScheduler(); }
/// <summary> /// Creates an execution engine around the give graph database </summary> /// <param name="queryService"> The database to wrap </param> /// <param name="logProvider"> A <seealso cref="LogProvider"/> for cypher-statements </param> public ExecutionEngine(GraphDatabaseQueryService queryService, LogProvider logProvider, CompilerFactory compilerFactory) { DependencyResolver resolver = queryService.DependencyResolver; Monitors monitors = resolver.ResolveDependency(typeof(Monitors)); CacheTracer cacheTracer = new MonitoringCacheTracer(monitors.NewMonitor(typeof(StringCacheMonitor))); Config config = resolver.ResolveDependency(typeof(Config)); CypherConfiguration cypherConfiguration = CypherConfiguration.fromConfig(config); CompilationTracer tracer = new TimingCompilationTracer(monitors.NewMonitor(typeof(TimingCompilationTracer.EventListener))); _inner = new [email protected](queryService, monitors, tracer, cacheTracer, cypherConfiguration, compilerFactory, logProvider, Clock.systemUTC()); }
internal static long WaitForCacheProfile(Monitors monitors) { AtomicLong pageCount = new AtomicLong(); BinaryLatch profileLatch = new BinaryLatch(); PageCacheWarmerMonitor listener = new AwaitProfileMonitor(pageCount, profileLatch); monitors.AddMonitorListener(listener); profileLatch.Await(); monitors.RemoveMonitorListener(listener); return(pageCount.get()); }
public RegularCatchupServerHandler(Monitors monitors, LogProvider logProvider, System.Func <StoreId> storeIdSupplier, System.Func <NeoStoreDataSource> dataSourceSupplier, System.Func <bool> dataSourceAvailabilitySupplier, FileSystemAbstraction fs, CoreSnapshotService snapshotService, CheckPointerService checkPointerService) { this._monitors = monitors; this._logProvider = logProvider; this._storeIdSupplier = storeIdSupplier; this._dataSourceSupplier = dataSourceSupplier; this._dataSourceAvailabilitySupplier = dataSourceAvailabilitySupplier; this._fs = fs; this._snapshotService = snapshotService; this._checkPointerService = checkPointerService; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Override @Nonnull public org.neo4j.commandline.admin.AdminCommand create(java.nio.file.Path homeDir, java.nio.file.Path configDir, org.neo4j.commandline.admin.OutsideWorld outsideWorld) public override AdminCommand Create(Path homeDir, Path configDir, OutsideWorld outsideWorld) { bool debug = System.getenv().get("NEO4J_DEBUG") != null; LogProvider logProvider = FormattedLogProvider.withDefaultLogLevel(debug ? Level.DEBUG : Level.NONE).toOutputStream(outsideWorld.OutStream()); Monitors monitors = new Monitors(); OnlineBackupContextFactory contextBuilder = new OnlineBackupContextFactory(homeDir, configDir); BackupModule backupModule = new BackupModule(outsideWorld, logProvider, monitors); BackupSupportingClassesFactoryProvider classesFactoryProvider = ProvidersByPriority.findFirst().orElseThrow(NoProviderException()); BackupSupportingClassesFactory supportingClassesFactory = classesFactoryProvider.GetFactory(backupModule); BackupStrategyCoordinatorFactory coordinatorFactory = new BackupStrategyCoordinatorFactory(backupModule); return(new OnlineBackupCommand(outsideWorld, contextBuilder, supportingClassesFactory, coordinatorFactory)); }
public PullerFactory(RequestContextFactory requestContextFactory, Master master, LastUpdateTime lastUpdateTime, LogProvider logging, InstanceId serverId, InvalidEpochExceptionHandler invalidEpochHandler, long pullInterval, JobScheduler jobScheduler, DependencyResolver dependencyResolver, AvailabilityGuard availabilityGuard, HighAvailabilityMemberStateMachine memberStateMachine, Monitors monitors, Config config) { this._requestContextFactory = requestContextFactory; this._master = master; this._lastUpdateTime = lastUpdateTime; this._logging = logging; this._serverId = serverId; this._invalidEpochHandler = invalidEpochHandler; this._pullInterval = pullInterval; this._jobScheduler = jobScheduler; this._dependencyResolver = dependencyResolver; this._availabilityGuard = availabilityGuard; this._memberStateMachine = memberStateMachine; this._monitors = monitors; this._activeDatabaseName = config.Get(GraphDatabaseSettings.active_database); }
internal DataCollector(Kernel kernel, JobScheduler jobScheduler, Monitors monitors, Org.Neo4j.Values.ValueMapper_JavaMapper valueMapper, Config config) { this.Kernel = kernel; this.JobScheduler = jobScheduler; this.ValueMapper = valueMapper; this.QueryCollector = new QueryCollector(jobScheduler, config.Get(GraphDatabaseSettings.data_collector_max_recent_query_count), config.Get(GraphDatabaseSettings.data_collector_max_query_text_size)); try { this.QueryCollector.collect(Collections.emptyMap()); } catch (InvalidArgumentsException e) { throw new System.InvalidOperationException("An empty config cannot be invalid", e); } monitors.AddMonitorListener(QueryCollector); }
public DefaultMasterImplSPI(GraphDatabaseAPI graphDb, FileSystemAbstraction fileSystemAbstraction, Monitors monitors, TokenHolders tokenHolders, IdGeneratorFactory idGeneratorFactory, TransactionCommitProcess transactionCommitProcess, CheckPointer checkPointer, TransactionIdStore transactionIdStore, LogicalTransactionStore logicalTransactionStore, NeoStoreDataSource neoStoreDataSource, LogProvider logProvider) { this._graphDb = graphDb; this._fileSystem = fileSystemAbstraction; this._tokenHolders = tokenHolders; this._idGeneratorFactory = idGeneratorFactory; this._transactionCommitProcess = transactionCommitProcess; this._checkPointer = checkPointer; this._neoStoreDataSource = neoStoreDataSource; this._databaseDirectory = graphDb.DatabaseLayout().databaseDirectory(); this._txChecksumLookup = new TransactionChecksumLookup(transactionIdStore, logicalTransactionStore); this._responsePacker = new ResponsePacker(logicalTransactionStore, transactionIdStore, graphDb.storeId); this._monitors = monitors; //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: monitors.AddMonitorListener(new LoggingStoreCopyServerMonitor(logProvider.GetLog(typeof(StoreCopyServer))), typeof(StoreCopyServer).FullName); }
public override IndexProvider NewInstance(KernelContext context, DEPENDENCIES dependencies) { PageCache pageCache = dependencies.PageCache(); File databaseDir = context.Directory(); FileSystemAbstraction fs = dependencies.FileSystem(); Log log = dependencies.LogService.InternalLogProvider.getLog(LoggingClass()); Monitors monitors = dependencies.Monitors(); monitors.AddMonitorListener(new LoggingMonitor(log), DescriptorString()); IndexProvider.Monitor monitor = monitors.NewMonitor(typeof(IndexProvider.Monitor), DescriptorString()); Config config = dependencies.Config; OperationalMode operationalMode = context.DatabaseInfo().OperationalMode; RecoveryCleanupWorkCollector recoveryCleanupWorkCollector = dependencies.RecoveryCleanupWorkCollector(); return(InternalCreate(pageCache, databaseDir, fs, monitor, config, operationalMode, recoveryCleanupWorkCollector)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldMonitorTerm() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldMonitorTerm() { // given Monitors monitors = new Monitors(); StubRaftTermMonitor raftTermMonitor = new StubRaftTermMonitor(); monitors.AddMonitorListener(raftTermMonitor); TermState state = new TermState(); MonitoredTermStateStorage monitoredTermStateStorage = new MonitoredTermStateStorage(new InMemoryStateStorage <TermState>(new TermState()), monitors); // when state.Update(7); monitoredTermStateStorage.PersistStoreData(state); // then assertEquals(7, raftTermMonitor.Term()); }
public override Lifecycle NewInstance(KernelContext context, Dependencies deps) { JobScheduler scheduler = deps.JobScheduler(); DatabaseAvailabilityGuard databaseAvailabilityGuard = deps.AvailabilityGuard(); PageCache pageCache = deps.PageCache(); FileSystemAbstraction fs = deps.FileSystemAbstraction(); LogService logService = deps.LogService(); NeoStoreDataSource dataSourceManager = deps.DataSource; Log log = logService.GetInternalLog(typeof(PageCacheWarmer)); Monitors monitors = deps.Monitors(); PageCacheWarmerMonitor monitor = monitors.NewMonitor(typeof(PageCacheWarmerMonitor)); monitors.AddMonitorListener(new PageCacheWarmerLoggingMonitor(log)); Config config = deps.Config(); return(new PageCacheWarmerKernelExtension(scheduler, databaseAvailabilityGuard, pageCache, fs, dataSourceManager, log, monitor, config)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldKeepIndexInPopulatingStateBetweenRestarts() throws InterruptedException, java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldKeepIndexInPopulatingStateBetweenRestarts() { // given Monitors monitors = Db.DependencyResolver.resolveDependency(typeof(Monitors)); Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control(); monitors.AddMonitorListener(PopulationCompletionBlocker(barrier)); // when CreateRelevantNode(); CreateIndex(); barrier.Await(); // This call will eventually make a call to populationCancelled on the monitor below Db.restartDatabase(); // then assertEquals(Schema_IndexState.Online, AwaitAndGetIndexState()); }
protected internal override QueryExecutionEngine CreateEngine(Dependencies deps, GraphDatabaseAPI graphAPI) { GraphDatabaseCypherService queryService = new GraphDatabaseCypherService(graphAPI); deps.SatisfyDependency(queryService); DependencyResolver resolver = graphAPI.DependencyResolver; LogService logService = resolver.ResolveDependency(typeof(LogService)); Monitors monitors = resolver.ResolveDependency(typeof(Monitors)); Config config = resolver.ResolveDependency(typeof(Config)); CypherConfiguration cypherConfig = CypherConfiguration.fromConfig(config); CypherPlannerConfiguration plannerConfig = cypherConfig.toCypherPlannerConfiguration(config); CypherRuntimeConfiguration runtimeConfig = cypherConfig.toCypherRuntimeConfiguration(); LogProvider logProvider = logService.InternalLogProvider; CommunityCompilerFactory compilerFactory = new CommunityCompilerFactory(queryService, monitors, logProvider, plannerConfig, runtimeConfig); deps.SatisfyDependencies(compilerFactory); return(CreateEngine(queryService, config, logProvider, compilerFactory)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldNotDuplicateToAnyLog() public virtual void ShouldNotDuplicateToAnyLog() { AssertableLogProvider userLogProvider = new AssertableLogProvider(); AssertableLogProvider debugLogProvider = new AssertableLogProvider(); SimpleLogService logService = new SimpleLogService(userLogProvider, debugLogProvider); Monitors monitors = new Monitors(); CoreMonitor.Register(logService.InternalLogProvider, logService.UserLogProvider, monitors); ClusterBinder.Monitor monitor = monitors.NewMonitor(typeof(ClusterBinder.Monitor)); ClusterId clusterId = new ClusterId(System.Guid.randomUUID()); monitor.BoundToCluster(clusterId); userLogProvider.RawMessageMatcher().assertContainsSingle(Matchers.allOf(Matchers.containsString("Bound to cluster with id " + clusterId.Uuid()))); debugLogProvider.RawMessageMatcher().assertContainsSingle(Matchers.allOf(Matchers.containsString("Bound to cluster with id " + clusterId.Uuid()))); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldLetPageCacheHandleRecordStoresAndNativeLabelScanStoreFiles() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldLetPageCacheHandleRecordStoresAndNativeLabelScanStoreFiles() { // GIVEN Monitors monitors = new Monitors(); StreamToDiskProvider writerProvider = new StreamToDiskProvider(_directory.databaseDir(), _fs, monitors); // WHEN foreach (StoreType type in StoreType.values()) { if (type.RecordStore) { //JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter: File[] files = _directory.databaseLayout().file(type.DatabaseFile).toArray(File[] ::new); foreach (File file in files) { WriteAndVerify(writerProvider, file); } } } WriteAndVerify(writerProvider, _directory.databaseLayout().labelScanStore()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void communityBackupSupportingFactory() public virtual void CommunityBackupSupportingFactory() { AssertableLogProvider logProvider = new AssertableLogProvider(); //OutsideWorld outsideWorld = mock( OutsideWorld.class ); RealOutsideWorld outsideWorld = new RealOutsideWorld(); FileSystemAbstraction fileSystemMock = mock(typeof(FileSystemAbstraction)); //outsideWorld.fileSystemAbstraction = fileSystemMock; Monitors monitors = mock(typeof(Monitors)); BackupModule backupModule = new BackupModule(outsideWorld, logProvider, monitors); // when( backupModule.getOutsideWorld() ).thenReturn( outsideWorld ); BackupSupportingClassesFactoryProvider provider = ProvidersByPriority.findFirst().get(); BackupSupportingClassesFactory factory = provider.GetFactory(backupModule); /* * SecurePipelineWrapperFactory pipelineWrapperFactory = new SecurePipelineWrapperFactory(); * SslPolicyLoader sslPolicyLoader; * // and * Config config = Config.defaults(); * config.augment( CausalClusteringSettings.ssl_policy, "default" ); * * // We want to create dependencies the same way factory.createPipelineWrapper does so.s * Dependencies dependencies = new Dependencies( ); * dependencies.satisfyDependencies(new Object[]{SslPolicyLoader.create(config, logProvider)}); * * assertEquals( pipelineWrapperFactory.forClient(config, dependencies, logProvider, CausalClusteringSettings.ssl_policy), * factory.createPipelineWrapper( Config.defaults() ) ); */ assertEquals(typeof(SecureClientPipelineWrapper), factory.CreatePipelineWrapper(Config.defaults()).GetType()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldMonitorAppendIndexAndCommitIndex() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldMonitorAppendIndexAndCommitIndex() { // Given Monitors monitors = new Monitors(); StubRaftLogAppendIndexMonitor appendMonitor = new StubRaftLogAppendIndexMonitor(); monitors.AddMonitorListener(appendMonitor); StubRaftLogCommitIndexMonitor commitMonitor = new StubRaftLogCommitIndexMonitor(); monitors.AddMonitorListener(commitMonitor); MonitoredRaftLog log = new MonitoredRaftLog(new InMemoryRaftLog(), monitors); // When log.Append(new RaftLogEntry(0, ReplicatedInteger.valueOf(1))); log.Append(new RaftLogEntry(0, ReplicatedInteger.valueOf(1))); assertEquals(1, appendMonitor.AppendIndex()); assertEquals(0, commitMonitor.CommitIndex()); log.Truncate(1); assertEquals(0, appendMonitor.AppendIndex()); }