/// <param name="delayInMillis"> number of milliseconds between each attempt at getting the desired result </param> /// <param name="retries"> the number of attempts to perform before giving up </param> </param> /// <param name="logProvider"> {<seealso cref= LogProvider} </seealso> public MultiRetryStrategy(long delayInMillis, long retries, LogProvider logProvider, System.Action <long> sleeper) { this._delayInMillis = delayInMillis; this._retries = retries; this._logProvider = logProvider; this._sleeper = sleeper; }
/// <param name="sslPolicy"> </param> /// <param name="logProvider"> /// @return </param> private static SSLConfig CommonSslConfig(SslPolicy sslPolicy, LogProvider logProvider) { SSLConfig sslConfig = new SSLConfig(); if (sslPolicy == null) { return(sslConfig); } else { sslConfig.setFactoryImplementation(new SecureHazelcastContextFactory(sslPolicy, logProvider)).setEnabled(true); switch (sslPolicy.ClientAuth) { case REQUIRE: sslConfig.setProperty("javax.net.ssl.mutualAuthentication", "REQUIRED"); break; case OPTIONAL: sslConfig.setProperty("javax.net.ssl.mutualAuthentication", "OPTIONAL"); goto case NONE; case NONE: break; default: throw new System.ArgumentException("Not supported: " + sslPolicy.ClientAuth); } return(sslConfig); } }
protected internal static void ConfigureHazelcast(Config config, LogProvider logProvider) { GroupProperty.WAIT_SECONDS_BEFORE_JOIN.SystemProperty = "1"; GroupProperty.PHONE_HOME_ENABLED.SystemProperty = "false"; GroupProperty.SOCKET_BIND_ANY.SystemProperty = "false"; GroupProperty.SHUTDOWNHOOK_ENABLED.SystemProperty = "false"; string licenseKey = config.Get(CausalClusteringSettings.hazelcast_license_key); if (!string.ReferenceEquals(licenseKey, null)) { GroupProperty.ENTERPRISE_LICENSE_KEY.SystemProperty = licenseKey; } // Make hazelcast quiet if (config.Get(CausalClusteringSettings.disable_middleware_logging)) { // This is clunky, but the documented programmatic way doesn't seem to work GroupProperty.LOGGING_TYPE.SystemProperty = "none"; } else { HazelcastLogging.Enable(logProvider, new HazelcastLogLevel(config)); } }
private static ChildInitializer ChildInitializer(FileSystemAbstraction fileSystem, GraphDatabaseAPI graphDb) { ApplicationSupportedProtocols catchupProtocols = new ApplicationSupportedProtocols(CATCHUP, emptyList()); ModifierSupportedProtocols modifierProtocols = new ModifierSupportedProtocols(COMPRESSION, emptyList()); ApplicationProtocolRepository catchupRepository = new ApplicationProtocolRepository(Protocol_ApplicationProtocols.values(), catchupProtocols); ModifierProtocolRepository modifierRepository = new ModifierProtocolRepository(Protocol_ModifierProtocols.values(), singletonList(modifierProtocols)); System.Func <CheckPointer> checkPointer = () => graphDb.DependencyResolver.resolveDependency(typeof(CheckPointer)); System.Func <bool> availability = () => graphDb.DependencyResolver.resolveDependency(typeof(DatabaseAvailabilityGuard)).Available; System.Func <NeoStoreDataSource> dataSource = () => graphDb.DependencyResolver.resolveDependency(typeof(NeoStoreDataSource)); LogProvider logProvider = NullLogProvider.Instance; Org.Neo4j.Storageengine.Api.StoreId kernelStoreId = dataSource().StoreId; StoreId storeId = new StoreId(kernelStoreId.CreationTime, kernelStoreId.RandomId, kernelStoreId.UpgradeTime, kernelStoreId.UpgradeId); CheckPointerService checkPointerService = new CheckPointerService(checkPointer, createInitialisedScheduler(), Group.CHECKPOINT); RegularCatchupServerHandler catchupServerHandler = new RegularCatchupServerHandler(new Monitors(), logProvider, () => storeId, dataSource, availability, fileSystem, null, checkPointerService); NettyPipelineBuilderFactory pipelineBuilder = new NettyPipelineBuilderFactory(VoidPipelineWrapperFactory.VOID_WRAPPER); CatchupProtocolServerInstaller.Factory catchupProtocolServerInstaller = new CatchupProtocolServerInstaller.Factory(pipelineBuilder, logProvider, catchupServerHandler); ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Server> protocolInstallerRepository = new ProtocolInstallerRepository <Org.Neo4j.causalclustering.protocol.ProtocolInstaller_Orientation_Server>(singletonList(catchupProtocolServerInstaller), Org.Neo4j.causalclustering.protocol.ModifierProtocolInstaller_Fields.AllServerInstallers); return(new HandshakeServerInitializer(catchupRepository, modifierRepository, protocolInstallerRepository, pipelineBuilder, logProvider)); }
public UpdatePullerScheduler(JobScheduler scheduler, LogProvider logProvider, UpdatePuller updatePullingThread, long pullIntervalMillis) { this._scheduler = scheduler; this._log = logProvider.getLog(this.GetType()); this._updatePuller = updatePullingThread; this._pullIntervalMillis = pullIntervalMillis; }
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); }
private SegmentedRaftLog CreateRaftLog(long rotateAtSize) { LogProvider logProvider = Instance; CoreLogPruningStrategy pruningStrategy = (new CoreLogPruningStrategyFactory(raft_log_pruning_strategy.DefaultValue, logProvider)).newInstance(); return(new SegmentedRaftLog(_fileSystemRule.get(), _testDirectory.directory(), rotateAtSize, new DummyRaftableContentSerializer(), logProvider, 0, Clocks.fakeClock(), new OnDemandJobScheduler(), pruningStrategy)); }
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; }
public AuthorizationModule(WebServer webServer, System.Func <AuthManager> authManager, LogProvider logProvider, Config config, Pattern[] uriWhitelist) { this._webServer = webServer; this._config = config; this._authManagerSupplier = authManager; this._logProvider = logProvider; this._uriWhitelist = uriWhitelist; }
public TransactionFacade(TransitionalPeriodTransactionMessContainer kernel, QueryExecutionEngine engine, GraphDatabaseQueryService queryService, TransactionRegistry registry, LogProvider logProvider) { this._kernel = kernel; this._engine = engine; this._queryService = queryService; this._registry = registry; this._logProvider = logProvider; }
private static TopologyServiceRetryStrategy ResolveStrategy(Config config, LogProvider logProvider) { long refreshPeriodMillis = config.Get(CausalClusteringSettings.cluster_topology_refresh).toMillis(); int pollingFrequencyWithinRefreshWindow = 2; int numberOfRetries = pollingFrequencyWithinRefreshWindow + 1; // we want to have more retries at the given frequency than there is time in a refresh period return(new TopologyServiceMultiRetryStrategy(refreshPeriodMillis / pollingFrequencyWithinRefreshWindow, numberOfRetries, logProvider)); }
public SlaveLockManager(Locks localLocks, RequestContextFactory requestContextFactory, Master master, AvailabilityGuard availabilityGuard, LogProvider logProvider, Config config) { this._requestContextFactory = requestContextFactory; this._availabilityGuard = availabilityGuard; this._local = localLocks; this._master = master; this._logProvider = logProvider; }
private StoreFactory StoreFactory(Config config, params OpenOption[] openOptions) { LogProvider logProvider = NullLogProvider.Instance; DatabaseLayout databaseLayout = _testDirectory.databaseLayout(); RecordFormats recordFormats = selectForStoreOrConfig(config, databaseLayout, _fsRule, _pageCache, logProvider); return(new StoreFactory(databaseLayout, config, _idGeneratorFactory, _pageCache, _fsRule.get(), recordFormats, logProvider, EmptyVersionContextSupplier.EMPTY, openOptions)); }
internal IndexProxyCreator(IndexSamplingConfig samplingConfig, IndexStoreView storeView, IndexProviderMap providerMap, TokenNameLookup tokenNameLookup, LogProvider logProvider) { this._samplingConfig = samplingConfig; this._storeView = storeView; this._providerMap = providerMap; this._tokenNameLookup = tokenNameLookup; this._logProvider = logProvider; }
public LockManagerSwitcher(DelegateInvocationHandler <Locks> @delegate, DelegateInvocationHandler <Master> master, RequestContextFactory requestContextFactory, AvailabilityGuard availabilityGuard, Factory <Locks> locksFactory, LogProvider logProvider, Config config) : base(@delegate) { this._master = master; this._requestContextFactory = requestContextFactory; this._availabilityGuard = availabilityGuard; this._locksFactory = locksFactory; this._logProvider = logProvider; this._config = config; }
//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() { _fs = mock(typeof(FileSystemAbstraction)); _logFiles = mock(typeof(LogFiles)); doAnswer(inv => new File((inv.Arguments[0]).ToString())).when(_logFiles).getLogFileForVersion(anyLong()); _logProvider = NullLogProvider.Instance; _clock = mock(typeof(Clock)); _factory = mock(typeof(LogPruneStrategyFactory)); }
internal static void Enable(LogProvider logProvider, Level minLevel) { HazelcastLogging._logProvider = logProvider; HazelcastLogging._minLevel = minLevel; // hazelcast only allows configuring logging through system properties //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: System.setProperty(HZ_LOGGING_CLASS_PROPERTY, typeof(HazelcastLogging).FullName); }
public override SegmentedRaftLog CreateRaftLog(FileSystemAbstraction fsa, File dir) { long rotateAtSize = ByteUnit.mebiBytes(8); LogProvider logProvider = Instance; int readerPoolSize = 8; CoreLogPruningStrategy pruningStrategy = (new CoreLogPruningStrategyFactory(raft_log_pruning_strategy.DefaultValue, logProvider)).newInstance(); return(new SegmentedRaftLog(fsa, dir, rotateAtSize, new DummyRaftableContentSerializer(), logProvider, readerPoolSize, Clocks.fakeClock(), new OnDemandJobScheduler(), pruningStrategy)); }
/// <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(); }
public SocketTransport(string connector, ListenSocketAddress address, SslContext sslCtx, bool encryptionRequired, LogProvider logging, TransportThrottleGroup throttleGroup, BoltProtocolFactory boltProtocolFactory, NetworkConnectionTracker connectionTracker) { this._connector = connector; this._address = address; this._sslCtx = sslCtx; this._encryptionRequired = encryptionRequired; this._logging = logging; this._throttleGroup = throttleGroup; this._boltProtocolFactory = boltProtocolFactory; this._connectionTracker = connectionTracker; }
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; }
private SegmentedRaftLog CreateRaftLog(long rotateAtSize) { File directory = new File(RAFT_LOG_DIRECTORY_NAME); _logDirectory = Dir.directory(directory.Name); LogProvider logProvider = Instance; CoreLogPruningStrategy pruningStrategy = (new CoreLogPruningStrategyFactory("100 entries", logProvider)).NewInstance(); return(new SegmentedRaftLog(FsRule.get(), _logDirectory, rotateAtSize, CoreReplicatedContentMarshal.marshaller(), logProvider, 8, Clocks.fakeClock(), new OnDemandJobScheduler(), pruningStrategy)); }
/// <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()); }
private GraphDatabaseService PrepareDb(Label label, string propertyName, LogProvider logProvider) { GraphDatabaseService db = GetDatabase(logProvider); using (Transaction transaction = Db.beginTx()) { Db.schema().constraintFor(label).assertPropertyIsUnique(propertyName).create(); transaction.Success(); } WaitIndexes(db); return(db); }
public override RaftLog CreateRaftLog() { File directory = new File(RAFT_LOG_DIRECTORY_NAME); FileSystemAbstraction fileSystem = _fsRule.get(); fileSystem.Mkdir(directory); LogProvider logProvider = Instance; CoreLogPruningStrategy pruningStrategy = (new CoreLogPruningStrategyFactory("1 entries", logProvider)).NewInstance(); return(_life.add(new SegmentedRaftLog(fileSystem, directory, 1024, new DummyRaftableContentSerializer(), logProvider, 8, Clocks.fakeClock(), new OnDemandJobScheduler(), pruningStrategy))); }
public NetworkedServerFactory(LifeSupport life, ProtocolServerFactory protocolServerFactory, TimeoutStrategy timeoutStrategy, LogProvider logProvider, ObjectInputStreamFactory objectInputStreamFactory, ObjectOutputStreamFactory objectOutputStreamFactory, NetworkReceiver.Monitor networkReceiverMonitor, NetworkSender.Monitor networkSenderMonitor, NamedThreadFactory.Monitor namedThreadFactoryMonitor) { this._life = life; this._protocolServerFactory = protocolServerFactory; this._timeoutStrategy = timeoutStrategy; this._networkReceiverMonitor = networkReceiverMonitor; this._networkSenderMonitor = networkSenderMonitor; this._logProvider = logProvider; this._objectInputStreamFactory = objectInputStreamFactory; this._objectOutputStreamFactory = objectOutputStreamFactory; this._namedThreadFactoryMonitor = namedThreadFactoryMonitor; }
//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() { Config = Config.defaults(); Clock = Clocks.fakeClock(); LogPruning = LogPruning.NO_PRUNING; LogProvider = NullLogProvider.Instance; IntervalTx = Config.get(GraphDatabaseSettings.check_point_interval_tx); IntervalTime = Config.get(GraphDatabaseSettings.check_point_interval_time); TriggerConsumer = new LinkedBlockingQueue <string>(); Triggered = TriggerConsumer.offer; NotTriggered = s => fail("Should not have triggered: " + s); }
private ClusterConfiguration ClusterConfiguration(params URI[] uris) { LogProvider logProvider = FormattedLogProvider.toOutputStream(System.out); ClusterConfiguration toReturn = new ClusterConfiguration("neo4j.ha", logProvider, asList(uris)); toReturn.Joined(_clusterId1, _clusterUri1); toReturn.Joined(_clusterId2, _clusterUri2); if (uris.Length == 3) { toReturn.Joined(_clusterId3, _clusterUri3); } return(toReturn); }
public StoreFactory(DatabaseLayout databaseLayout, Config config, IdGeneratorFactory idGeneratorFactory, PageCache pageCache, FileSystemAbstraction fileSystemAbstraction, RecordFormats recordFormats, LogProvider logProvider, VersionContextSupplier versionContextSupplier, params OpenOption[] openOptions) { this._databaseLayout = databaseLayout; this._config = config; this._idGeneratorFactory = idGeneratorFactory; this._fileSystemAbstraction = fileSystemAbstraction; this._versionContextSupplier = versionContextSupplier; this._recordFormats = recordFormats; this._openOptions = openOptions; (new RecordFormatPropertyConfigurator(recordFormats, config)).configure(); this._logProvider = logProvider; this._pageCache = pageCache; }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private org.neo4j.causalclustering.core.consensus.log.RaftLog createRaftLog() throws Exception private RaftLog CreateRaftLog() { File directory = new File(RAFT_LOG_DIRECTORY_NAME); FileSystemAbstraction fileSystem = new EphemeralFileSystemAbstraction(); fileSystem.Mkdir(directory); LogProvider logProvider = Instance; CoreLogPruningStrategy pruningStrategy = (new CoreLogPruningStrategyFactory("1 entries", logProvider)).NewInstance(); SegmentedRaftLog newRaftLog = new SegmentedRaftLog(fileSystem, directory, 1, new DummyRaftableContentSerializer(), logProvider, 8, Clocks.fakeClock(), new OnDemandJobScheduler(), pruningStrategy); newRaftLog.Start(); return(newRaftLog); }