public override void CheckClientTrusted(X509Certificate[] x509Certificates, string s) { foreach (X509Certificate x509Certificate in x509Certificates) { _certSink.accept(x509Certificate); } }
/// <summary> /// Should be called every now and then to check for safe thresholds of buffered chunks and potentially /// release them onto the <seealso cref="Consumer"/>. /// </summary> public virtual void Maintenance() { lock (this) { Flush(); } if (!_chunks.Empty) { lock ( _chunks ) { // Potentially hand over chunks to the consumer while (!_chunks.Empty) { Chunk <T> candidate = _chunks.peek(); if (_safeThreshold.test(candidate.Threshold)) { _chunkConsumer.accept(candidate.Values); _chunks.remove(); } else { // The chunks are ordered by chunkThreshold, so we know that no more chunks will qualify anyway break; } } } } }
public override void WaitingForCoreMembers(int minimumCount) { _binderLimit.accept(() => { string message = "Waiting for a total of %d core members..."; _user.info(format(message, minimumCount)); }); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void begin(KEY key) throws ConcurrentAccessException public virtual void Begin(KEY key) { VALUE instance = _factory.newInstance(); Entry existing; if ((existing = _repo.putIfAbsent(key, new Entry(this, instance))) != null) { _reaper.accept(instance); // Need to clear up our optimistically allocated value throw new ConcurrentAccessException(string.Format("Cannot begin '{0}', because {1} with that key already exists.", key, existing)); } }
// The stamp is in two 32-bit parts: // The high bits are the number of IOs performed since the last pause. // The low bits is the 32-bit timestamp in milliseconds (~25 day range) since the last pause. // We keep adding summing up the IOs until either a quantum elapses, or we've exhausted the IOs we're allowed in // this quantum. If we've exhausted our IOs, we pause for the rest of the quantum. // We don't make use of the Flushable at this point, because IOs from fsyncs have a high priority, so they // might jump the IO queue and cause delays for transaction log IOs. Further, fsync on some file systems also // flush the entire IO queue, which can cause delays on IO rate limited cloud machines. // We need the Flushable to be implemented in terms of sync_file_range before we can make use of it. // NOTE: The check-pointer IOPS setting is documented as being a "best effort" hint. We are making use of that // wording here, and not compensating for over-counted IOs. For instance, if we receive 2 quantums worth of IOs // in one quantum, we are not going to sleep for two quantums. The reason is that such compensation algorithms // can easily over-compensate, and end up sleeping a lot more than what makes sense for other rate limiting factors // in the system, thus wasting IO bandwidth. No, "best effort" here means that likely end up doing a little bit // more IO than what we've been configured to allow, but that's okay. If it's a problem, people can just reduce // their IOPS limit setting a bit more. public override long MaybeLimitIO(long previousStamp, int recentlyCompletedIOs, Flushable flushable) { long state = _stateUpdater.get(this); if (GetDisabledCounter(state) > 0) { return(Org.Neo4j.Io.pagecache.IOLimiter_Fields.INITIAL_STAMP); } long now = CurrentTimeMillis() & _timeMask; long then = previousStamp & _timeMask; if (now - then > QUANTUM_MILLIS) { return(now + ((( long )recentlyCompletedIOs) << TIME_BITS)); } long ioSum = (previousStamp >> TIME_BITS) + recentlyCompletedIOs; if (ioSum >= GetIOPQ(state)) { long millisLeftInQuantum = QUANTUM_MILLIS - (now - then); _pauseNanos.accept(this, TimeUnit.MILLISECONDS.toNanos(millisLeftInQuantum)); return(CurrentTimeMillis() & _timeMask); } return(then + (ioSum << TIME_BITS)); }
/// <summary> /// {@inheritDoc} /// </summary> public override OUTPUT Apply(INPUT retriableInput, System.Func <INPUT, OUTPUT> retriable, System.Predicate <OUTPUT> wasRetrySuccessful) { Log log = _logProvider.getLog(typeof(MultiRetryStrategy)); OUTPUT result = retriable(retriableInput); int currentIteration = 0; while (!wasRetrySuccessful(result) && currentIteration++ < _retries) { log.Debug("Try attempt was unsuccessful for input: %s\n", retriableInput); _sleeper.accept(_delayInMillis); result = retriable(retriableInput); } return(result); }
/// <summary> /// Even if instances are meant to be accessed by a single thread at a time, lifecycle calls /// can guard for it nonetheless. Only the first call to close will perform close. /// </summary> public override void Close() { lock (this) { if (!_closed && _currentBatch != null) { long id; while ((id = _currentBatch.nextId()) != VALUE_REPRESENTING_NULL) { _excessIdConsumer.accept(id); } _currentBatch = null; } _closed = true; } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setUp() throws java.net.URISyntaxException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void SetUp() { if (_portRegistryOverrider != null) { _portRegistryOverrider.accept(_portRegistry); } else { when(_portRegistry.getLocalAddress("bolt")).thenReturn(new HostnamePort("localhost", 7687)); } DependencyResolver dependencyResolver = mock(typeof(DependencyResolver)); when(dependencyResolver.ResolveDependency(typeof(ConnectorPortRegister))).thenReturn(_portRegistry); when(_neoServer.Database.Graph.DependencyResolver).thenReturn(dependencyResolver); }
private Config MockConfig() { Dictionary <string, string> settings = new Dictionary <string, string>(); settings[GraphDatabaseSettings.auth_enabled.name()] = "false"; settings[(new BoltConnector("bolt")).type.name()] = "BOLT"; settings[(new BoltConnector("bolt")).enabled.name()] = "true"; settings[ServerSettings.management_api_path.name()] = _managementUri.ToString(); settings[ServerSettings.rest_api_path.name()] = _dataUri.ToString(); Config config = Config.defaults(settings); if (_configOverrider != null) { _configOverrider.accept(config); } return(config); }
public override void Accept(T t) { _callable.accept(t); }
public override void WaitingToHearFromLeader() { _waiterLimit.accept(() => _user.info("Waiting to hear from leader...")); }
public override void Accept(PageCursor cursor) { cursor.PutByte(_state); _additionalHeaderWriter.accept(cursor); }