public CuratorFrameworkImpl(CuratorFrameworkFactory.Builder builder)
{
IZookeeperFactory localZookeeperFactory = makeZookeeperFactory(builder.GetZookeeperFactory());
this.client = new CuratorZookeeperClient(localZookeeperFactory,
builder.GetEnsembleProvider(),
builder.GetSessionTimeoutMs(),
builder.GetConnectionTimeoutMs(),
new WatchedWatcher(this),
builder.GetRetryPolicy(),
builder.CanBeReadOnly());
listeners = new ListenerContainer<ICuratorListener>();
unhandledErrorListeners = new ListenerContainer<IUnhandledErrorListener>();
backgroundOperations = new DelayQueue<OperationAndData<object>>();
@namespace = new NamespaceImpl(this, builder.GetNamespace());
maxCloseWaitMs = builder.GetMaxCloseWaitMs();
connectionStateManager = new ConnectionStateManager(this, builder.GetEventQueueSize());
compressionProvider = builder.GetCompressionProvider();
aclProvider = builder.GetAclProvider();
state = new AtomicReference<CuratorFrameworkState>(CuratorFrameworkState.LATENT);
useContainerParentsIfAvailable = builder.UseContainerParentsIfAvailable();
byte[] builderDefaultData = builder.GetDefaultData();
byte[] destDefaults = new byte[builderDefaultData.Length];
Array.Copy(builderDefaultData, destDefaults, builderDefaultData.Length);
defaultData = (builderDefaultData != null)
? destDefaults
: new byte[0];
authInfos = buildAuths(builder);
failedDeleteManager = new FailedDeleteManager(this);
namespaceWatcherMap = new NamespaceWatcherMap(this);
namespaceFacadeCache = new NamespaceFacadeCache(this);
}
public void CompareAndSet_when_equal_returns_true()
{
var expected = new object();
var obj = new AtomicReference<object>(expected);
Assert.IsTrue(obj.CompareAndSet(expected, new object()));
}
public void ToString_returns_a_string_representation_of_the_object()
{
var shared = new AtomicReference<object>();
const string expected = "AtomicReference<System.Object>";
Assert.AreEqual(expected, shared.ToString());
}
public void AtomicReference_IEquatable_Of_Ref_Should_Compare()
{
IEquatable<object> firstAtomic = new AtomicReference<object>(new object());
IEquatable<object> secondAtomic = new AtomicReference<object>(null);
Assert.False(firstAtomic.Equals(false));
Assert.False(secondAtomic.Equals(true));
}
/// <summary>
/// Initialize a reference to an on-disk object directory.
/// </summary>
/// <param name="dir">the location of the <code>objects</code> directory.</param>
/// <param name="alternateObjectDir">a list of alternate object directories</param>
public ObjectDirectory(DirectoryInfo dir, DirectoryInfo[] alternateObjectDir)
{
_objects = dir;
_alternateObjectDir = alternateObjectDir;
_infoDirectory = new DirectoryInfo(_objects.FullName + "/info");
_packDirectory = new DirectoryInfo(_objects.FullName + "/pack");
_alternatesFile = new FileInfo(_infoDirectory + "/alternates");
_packList = new AtomicReference<PackList>(NoPacks);
}
public void Constructor_when_given_a_value_instantiates_with_it()
{
var value = new object();
var obj = new AtomicReference<object>(value);
var actual = obj.Value;
Assert.AreEqual(value, actual);
}
public void GetAndSet_returns_old_value()
{
var value = new object();
var obj = new AtomicReference<object>(value);
var actual = obj.GetAndSet(new object());
Assert.AreEqual(value, actual);
}
public void GetAndSet_sets_new_value()
{
var obj = new AtomicReference<object>();
var value = new object();
obj.GetAndSet(value);
Assert.AreEqual(value, obj.Value);
}
public void CompareAndSet_when_not_equal_does_not_set_value()
{
var initial = new object();
var obj = new AtomicReference<object>(initial);
obj.CompareAndSet(new object(), new object());
Assert.AreEqual(initial, obj.Value);
}
protected EnsurePath(String path,
AtomicReference<Helper> helper,
bool makeLastNode,
IInternalACLProvider aclProvider)
{
this.path = path;
this.makeLastNode = makeLastNode;
this.aclProvider = aclProvider;
this.helper = helper ?? new AtomicReference<Helper>(new InitialHelper(this));
}
public void AtomicReference_Implicit_Reassignment_Should_Change_Reference()
{
var firstAtomic = new AtomicReference<object>(new object());
var secondAtomic = firstAtomic;
firstAtomic = false;
Assert.NotEqual(secondAtomic, firstAtomic);
Assert.False(object.ReferenceEquals(secondAtomic, firstAtomic));
}
public void AtomicReference_Implicit_Ref_AcqRel_Should_Success()
{
var source = new object();
var atomicReference = new AtomicReference<object>(source);
var func = new Func<object, object>(i => i);
Assert.NotEqual(source, func(atomicReference));
Assert.Equal(source, func(atomicReference.Value));
}
public void ShouldNotUpdateWhenComparisonIsFalseAndReturnOldValue() {
ReferenceMock reference = Reference;
AtomicReference<ReferenceMock> ar =
new AtomicReference<ReferenceMock>(reference);
ReferenceMock new_mock = new ReferenceMock("new-mock");
ReferenceMock old_mock = ar.CompareExchange(new_mock, new_mock);
Assert.AreEqual(reference, ar.Value);
Assert.AreEqual(reference, old_mock);
}
public void ShouldExchangeAndReturnOldValue() {
ReferenceMock reference = Reference;
AtomicReference<ReferenceMock> ar =
new AtomicReference<ReferenceMock>(reference);
ReferenceMock new_mock = new ReferenceMock("new_mock");
ReferenceMock old_mock = ar.Exchange(new_mock);
Assert.AreEqual(new_mock, ar.Value);
Assert.AreEqual(reference, old_mock);
}
public void AtomicReference_Should_Implement_Reference_Equality()
{
var firstAtomic = new AtomicReference<object>(new object());
var secondAtomic = new AtomicReference<object>(null);
Assert.False(firstAtomic.Equals(secondAtomic));
Assert.False(secondAtomic.Equals(firstAtomic));
// self equality
Assert.True(firstAtomic.Equals(firstAtomic));
Assert.True(secondAtomic.Equals(secondAtomic));
}
public void Cache_should_be_updated_with_the_latest_resolved()
{
var localClock = new AtomicReference<long>(0);
var cache = new SimpleDnsCacheTestDouble(localClock);
var cacheEntryOne = Dns.Resolved.Create("test.local", System.Net.Dns.GetHostEntry("127.0.0.1").AddressList);
var cacheEntryTwo = Dns.Resolved.Create("test.local", System.Net.Dns.GetHostEntry("127.0.0.1").AddressList);
long ttl = 500;
cache.Put(cacheEntryOne, ttl);
cache.Cached("test.local").ShouldBe(cacheEntryOne);
cache.Put(cacheEntryTwo, ttl);
cache.Cached("test.local").ShouldBe(cacheEntryTwo);
}
public async Task TcpSocketChannel_should_not_throw_on_shutdown()
{
AtomicReference<Exception> clientError = new AtomicReference<Exception>(null);
AtomicReference<Exception> serverError = new AtomicReference<Exception>(null);
IChannel s = null;
IChannel c = null;
try
{
var sb = new ServerBootstrap()
.Channel<TcpServerSocketChannel>()
.ChildHandler(
new ActionChannelInitializer<TcpSocketChannel>(
channel => { channel.Pipeline.AddLast(new FailAssertionHandler(serverError)); }))
.Group(_serverGroup);
s = sb.BindAsync(new IPEndPoint(IPAddress.IPv6Loopback, 0)).Result;
var cb = new ClientBootstrap()
.Channel<TcpSocketChannel>()
.Option(ChannelOption.TcpNodelay, true)
.Option(ChannelOption.ConnectTimeout, TimeSpan.FromMilliseconds(100))
.Handler(
new ActionChannelInitializer<TcpSocketChannel>(
channel => { channel.Pipeline.AddLast(new FailAssertionHandler(clientError)); }))
.Group(_clientGroup);
var clientEp = s.LocalAddress;
c = cb.ConnectAsync(clientEp).Result;
c.WriteAndFlushAsync(Unpooled.Buffer(4).WriteInt(2)).Wait(20);
Assert.True(c.IsOpen);
await c.CloseAsync();
// assert that the counters were never decremented
Assert.True(clientError.Value == null,
$"Expected null but error on client was {clientError.Value?.Message} {clientError.Value?.StackTrace}");
Assert.True(serverError.Value == null,
$"Expected null but error on server was {serverError.Value?.Message} {serverError.Value?.StackTrace}");
}
finally
{
try
{
c?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
s?.CloseAsync().Wait(TimeSpan.FromMilliseconds(200));
}
catch
{
}
}
}
public void TestHandlerAddedExecutedInEventLoop(int timeout)
{
var latch = new CountdownEvent(1);
var ex = new AtomicReference<Exception>();
IChannelHandler handler = new ChannelHandler3(latch, ex);
var channel = new EmbeddedChannel(handler);
Assert.False(channel.Finish());
Assert.True(latch.Wait(timeout));
var cause = ex.Value;
if (cause != null)
{
throw cause;
}
}
public void Cache_should_not_reply_with_expired_but_not_yet_swept_out_entries()
{
var localClock = new AtomicReference<long>(0);
var cache = new SimpleDnsCacheTestDouble(localClock);
var cacheEntry = Dns.Resolved.Create("test.local", System.Net.Dns.GetHostEntry("127.0.0.1").AddressList);
cache.Put(cacheEntry, 5000);
cache.Cached("test.local").ShouldBe(cacheEntry);
localClock.CompareAndSet(0, 4999);
cache.Cached("test.local").ShouldBe(cacheEntry);
localClock.CompareAndSet(4999, 5000);
cache.Cached("test.local").ShouldBe(null);
}
/// <summary>
/// Creates a {@link InverseUserFrequency} transformation. Computations use the given log base.
/// throws IllegalArgumentException if dataModel is <code>null</code> or logBase is {@link Double#NaN} or <= 1.0
/// </summary>
/// <param name="dataModel">{@link DataModel} from which to calculate user frequencies</param>
/// <param name="logBase">calculation logarithm base</param>
public InverseUserFrequency(DataModel dataModel, double logBase)
{
if (dataModel == null)
{
throw new ArgumentNullException("dataModel is null");
}
if (double.IsNaN(logBase) || logBase <= 1.0)
{
throw new ArgumentException("logBase is NaN or <= 1.0");
}
this.dataModel = dataModel;
this.LogBase = logBase;
this.iufFactors = new AtomicReference<Dictionary<Item, Double>>(new Dictionary<Item, Double>(1009));
Refresh();
}
internal ConnectionState(ZookeeperFactory zookeeperFactory, EnsembleProvider ensembleProvider,
int sessionTimeoutMs, int connectionTimeoutMs, Watcher parentWatcher, AtomicReference<TracerDriver> tracer,
bool canBeReadOnly)
{
this.ensembleProvider = ensembleProvider;
this.sessionTimeoutMs = sessionTimeoutMs;
this.connectionTimeoutMs = connectionTimeoutMs;
this.tracer = tracer;
if (parentWatcher != null)
{
parentWatchers.AddLast(parentWatcher);
}
zooKeeper = new HandleHolder(zookeeperFactory, this, ensembleProvider, sessionTimeoutMs, canBeReadOnly);
}
public void AtomicReference_Value_Change_Should_Success()
{
var source = new object();
var atomicReference = new AtomicReference<object>(source);
Assert.Equal(source, atomicReference.Value);
atomicReference.Value = null;
Assert.Null(atomicReference.Value);
// same value assignment
atomicReference.Value = source;
Assert.Equal(source, atomicReference.Value);
atomicReference.Value = source;
Assert.Equal(source, atomicReference.Value);
}
public void Cache_should_sweep_out_expired_entries_on_cleanup()
{
var localClock = new AtomicReference<long>(0);
var cache = new SimpleDnsCacheTestDouble(localClock);
var cacheEntry = Dns.Resolved.Create("test.local", System.Net.Dns.GetHostEntry("127.0.0.1").AddressList);
cache.Put(cacheEntry, 5000);
cache.Cached("test.local").ShouldBe(cacheEntry);
localClock.CompareAndSet(0, 5000);
cache.Cached("test.local").ShouldBe(null);
localClock.CompareAndSet(5000, 0);
cache.Cached("test.local").ShouldBe(cacheEntry);
localClock.CompareAndSet(0, 5000);
cache.CleanUp();
cache.Cached("test.local").ShouldBe(null);
localClock.CompareAndSet(5000, 0);
cache.Cached("test.local").ShouldBe(null);
}
public TestDirectMessageListenerContainer(SimpleRoutingConnectionFactory connectionFactory, AtomicReference <object> connectionMakerKey2)
: base(null, connectionFactory, null, null)
{
this.connectionMakerKey2 = connectionMakerKey2;
simpleFactory = connectionFactory;
}
public ClusterListener_AdapterAnonymousInnerClass(ClusterTopologyChangesIT outerInstance, AtomicReference <InstanceId> coordinatorIdWhenReJoined, System.Threading.CountdownEvent latch)
{
this.outerInstance = outerInstance;
this._coordinatorIdWhenReJoined = coordinatorIdWhenReJoined;
this._latch = latch;
}
public ChannelHandler3(CountdownEvent latch, AtomicReference <Exception> error)
{
this.latch = latch;
this.error = error;
}
public SimpleDnsCacheTestDouble(AtomicReference <long> clock)
{
_clock = clock;
}
public TestListener2(AtomicReference <RC.IModel> target, RC.IModel @object)
{
this.target = target;
this.@object = @object;
}
public ThreadAnonymousInnerClassHelper(BaseStoredFieldsFormatTestCase outerInstance, int numDocs, DirectoryReader rd, IndexSearcher searcher, int readsPerThread, AtomicReference <Exception> ex, int i)
{
this.OuterInstance = outerInstance;
this.NumDocs = numDocs;
this.Rd = rd;
this.Searcher = searcher;
this.ReadsPerThread = readsPerThread;
this.Ex = ex;
this.i = i;
queries = new int[ReadsPerThread];
for (int j = 0; j < queries.Length; ++j)
{
queries[j] = Random().NextIntBetween(0, NumDocs);
}
}
/// <summary>
/// Create an empty configuration with a fallback for missing keys.
/// </summary>
/// <param name="defaultConfig">
/// the base configuration to be consulted when a key is missing
/// from this configuration instance.
/// </param>
public Config(Config defaultConfig)
{
_baseConfig = defaultConfig;
_state = new AtomicReference <State>(newState());
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private static java.util.concurrent.Future<?> setPropertyInSeparateThreadAndAttemptToCommit(String threadName, org.neo4j.graphdb.GraphDatabaseService db, Object value, java.util.concurrent.CountDownLatch txStarted, java.util.concurrent.atomic.AtomicReference<org.neo4j.graphdb.Transaction> txReference)
private static Future <object> SetPropertyInSeparateThreadAndAttemptToCommit(string threadName, GraphDatabaseService db, object value, System.Threading.CountdownEvent txStarted, AtomicReference <Transaction> txReference)
{
return(ExecuteInSeparateThread(threadName, () =>
{
using (Transaction tx = Db.beginTx())
{
txReference.set(tx);
Node node = FindNode(db);
txStarted.Signal();
node.setProperty(PROPERTY, value);
tx.success();
}
}));
}
/// <summary>
/// Initialize a new database instance for access.
/// </summary>
protected ObjectDatabase()
{
_alternates = new AtomicReference <ObjectDatabase[]>();
}
public Listener(AtomicReference <SortedSet <Member> > unexpected)
{
_unexpected = unexpected;
}
public SimpleDnsCache()
{
_cache = new AtomicReference <Cache>(new Cache(new SortedSet <ExpiryEntry>(new ExpiryEntryComparer()), new Dictionary <string, CacheEntry>(), Clock));
_ticksBase = DateTime.Now.Ticks;
}
public HttpPoolManager()
{
poolMapRef = new AtomicReference <ChannelPoolMapWrapper>();
}
public PackedRefsWriter(LockFile lck, RefList <Ref> refs, PackedRefList oldPackedList, AtomicReference <PackedRefList> packedRefs)
: base(refs)
{
_lck = lck;
_refs = refs;
_oldPackedList = oldPackedList;
_packedRefs = packedRefs;
}
public ThreadAnonymousInnerClassHelper(TestIndexWriterWithThreads outerInstance, BaseDirectoryWrapper d, AtomicReference <IndexWriter> writerRef, LineFileDocs docs, int iters, AtomicBoolean failed, ReentrantLock rollbackLock, ReentrantLock commitLock)
{
this.OuterInstance = outerInstance;
this.d = d;
this.WriterRef = writerRef;
this.Docs = docs;
this.Iters = iters;
this.Failed = failed;
this.RollbackLock = rollbackLock;
this.CommitLock = commitLock;
}
public void AtomicReference_Equality_AcqRel_Should_Success()
{
var source = new object();
var atomicReference = new AtomicReference<object>(source);
Assert.True(atomicReference == source);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPropagateStoreCopyActionFailureToOtherStoreCopyRequests() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldPropagateStoreCopyActionFailureToOtherStoreCopyRequests()
{
// GIVEN
Org.Neo4j.Test.Barrier_Control barrier = new Org.Neo4j.Test.Barrier_Control();
IOException controlledFailure = new IOException("My own fault");
AtomicReference <Future <object> > secondRequest = new AtomicReference <Future <object> >();
ThrowingAction <IOException> controllableAndFailingAction = () =>
{
// Now that we know we're first, start the second request...
secondRequest.set(T3.execute(state => _mutex.storeCopy(_assertNotCalled)));
// ...and wait for it to reach its destination
barrier.AwaitUninterruptibly();
try
{
// OK, second request has made progress into the request, so we can now produce our failure
throw controlledFailure;
}
finally
{
barrier.Release();
}
};
Future <object> firstRequest = T2.execute(state => _mutex.storeCopy(controllableAndFailingAction));
while (secondRequest.get() == null)
{
ParkARandomWhile();
}
T3.get().waitUntilWaiting(details => details.isAt(typeof(StoreCopyCheckPointMutex), "waitForFirstStoreCopyActionToComplete"));
// WHEN
barrier.Reached();
// THEN
try
{
firstRequest.get();
}
catch (ExecutionException e)
{
assertSame(controlledFailure, e.InnerException);
}
try
{
secondRequest.get().get();
}
catch (ExecutionException e)
{
Exception cooperativeActionFailure = e.InnerException;
assertThat(cooperativeActionFailure.Message, containsString("Co-operative"));
assertSame(controlledFailure, cooperativeActionFailure.InnerException);
}
// WHEN afterwards trying another store-copy
CountingAction action = new CountingAction();
using (Resource @lock = _mutex.storeCopy(action))
{
// THEN
assertEquals(1, action.Count());
}
}
/// <summary>
/// Construct an atom with given intiial value.
/// </summary>
/// <param name="state">The initial value</param>
public Atom(object state)
{
_state = new AtomicReference<object>(state);
}
[Trait("Category", "SkipOnMacOS")] // TODO: Figure out why
public async Task TestDeferredAcks()
{
var connectionFactory = new Mock <Connection.IConnectionFactory>();
var connection = new Mock <Connection.IConnection>();
var channel = new Mock <IChannelProxy>();
var rabbitChannel = new Mock <RC.IModel>();
channel.Setup(c => c.TargetChannel).Returns(rabbitChannel.Object);
connectionFactory.Setup((f) => f.CreateConnection()).Returns(connection.Object);
connection.Setup((c) => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
connection.Setup((c) => c.IsOpen).Returns(true);
channel.Setup((c) => c.IsOpen).Returns(true);
rabbitChannel.Setup(c => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties());
channel.Setup(c => c.QueueDeclarePassive(It.IsAny <string>())).Returns(new RC.QueueDeclareOk("test", 0, 0));
var consumer = new AtomicReference <RC.IBasicConsumer>();
var latch1 = new CountdownEvent(1);
channel.Setup(c =>
c.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <RC.IBasicConsumer>()))
.Callback <string, bool, string, bool, bool, IDictionary <string, object>, RC.IBasicConsumer>(
(queue, autoAck, consumerTag, noLocal, exclusive, args, cons) =>
{
consumer.Value = cons;
cons.HandleBasicConsumeOk("consumerTag");
latch1.Signal();
})
.Returns("consumerTag");
var qos = new AtomicInteger();
channel.Setup(c => c.BasicQos(It.IsAny <uint>(), It.IsAny <ushort>(), It.IsAny <bool>()))
.Callback <uint, ushort, bool>((size, count, global) =>
{
qos.Value = count;
});
var latch2 = new CountdownEvent(1);
var latch3 = new CountdownEvent(1);
channel.Setup(c => c.BasicAck(It.IsAny <ulong>(), It.IsAny <bool>()))
.Callback <ulong, bool>((tag, multi) =>
{
if (tag == 10ul || tag == 16ul)
{
latch2.Signal();
}
else if (tag == 17ul)
{
latch3.Signal();
}
});
var latch4 = new CountdownEvent(1);
channel.Setup(c => c.BasicNack(It.IsAny <ulong>(), It.IsAny <bool>(), It.IsAny <bool>()))
.Callback <ulong, bool, bool>((tag, multi, re) =>
{
latch4.Signal();
});
var container = new DirectMessageListenerContainer(null, connectionFactory.Object);
container.SetQueueNames("test");
container.PrefetchCount = 2;
container.MonitorInterval = 100;
container.MessagesPerAck = 10;
container.AckTimeout = 100;
container.MessageListener = new TestListener();
container.Initialize();
await container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
Assert.True(latch1.Wait(TimeSpan.FromSeconds(10)));
Assert.Equal(10, qos.Value);
var props = new MockRabbitBasicProperties();
var body = new byte[1];
for (long i = 1; i < 16; i++)
{
consumer.Value.HandleBasicDeliver("consumerTag", (ulong)i, false, string.Empty, string.Empty, props, body);
}
Thread.Sleep(200);
consumer.Value.HandleBasicDeliver("consumerTag", 16ul, false, string.Empty, string.Empty, props, body);
// should get 2 acks #10 and #16 (timeout)
Assert.True(latch2.Wait(TimeSpan.FromSeconds(10)));
consumer.Value.HandleBasicDeliver("consumerTag", 17ul, false, string.Empty, string.Empty, props, body);
channel.Verify(c => c.BasicAck(10ul, true));
channel.Verify(c => c.BasicAck(15ul, true));
Assert.True(latch3.Wait(TimeSpan.FromSeconds(10)));
// monitor task timeout
channel.Verify(c => c.BasicAck(17ul, true));
consumer.Value.HandleBasicDeliver("consumerTag", 18ul, false, string.Empty, string.Empty, props, body);
consumer.Value.HandleBasicDeliver("consumerTag", 19ul, false, string.Empty, string.Empty, props, body);
Assert.True(latch4.Wait(TimeSpan.FromSeconds(10)));
// pending acks before nack
channel.Verify(c => c.BasicAck(18ul, true));
channel.Verify(c => c.BasicNack(19ul, true, true));
consumer.Value.HandleBasicDeliver("consumerTag", 20ul, false, string.Empty, string.Empty, props, body);
var latch5 = new CountdownEvent(1);
channel.Setup(c => c.BasicCancel("consumerTag"))
.Callback(() =>
{
consumer.Value.HandleBasicCancelOk("consumerTag");
latch5.Signal();
});
await container.Stop();
Assert.True(latch5.Wait(TimeSpan.FromSeconds(10)));
channel.Verify((c) => c.BasicAck(20ul, true));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private long[] repeatCreateNamedPeopleFor(int totalNumberOfPeople) throws Exception
private long[] RepeatCreateNamedPeopleFor(int totalNumberOfPeople)
{
// Parallelize the creation of persons
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long[] nodes = new long[totalNumberOfPeople];
long[] nodes = new long[totalNumberOfPeople];
const int threads = 100;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int peoplePerThread = totalNumberOfPeople / threads;
int peoplePerThread = totalNumberOfPeople / threads;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.ExecutorService service = java.util.concurrent.Executors.newFixedThreadPool(threads);
ExecutorService service = Executors.newFixedThreadPool(threads);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.internal.kernel.api.exceptions.KernelException> exception = new java.util.concurrent.atomic.AtomicReference<>();
AtomicReference <KernelException> exception = new AtomicReference <KernelException>();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.List<java.util.concurrent.Callable<Void>> jobs = new java.util.ArrayList<>(threads);
IList <Callable <Void> > jobs = new List <Callable <Void> >(threads);
// Start threads that creates these people, relying on batched writes to speed things up
for (int i = 0; i < threads; i++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int finalI = i;
int finalI = i;
jobs.Add(() =>
{
int offset = finalI * peoplePerThread;
while (offset < (finalI + 1) * peoplePerThread)
{
try
{
offset += CreateNamedPeople(nodes, offset);
}
catch (KernelException e)
{
exception.compareAndSet(null, e);
throw new Exception(e);
}
}
return(null);
});
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: for (java.util.concurrent.Future<?> job : service.invokeAll(jobs))
foreach (Future <object> job in service.invokeAll(jobs))
{
job.get();
}
service.awaitTermination(1, TimeUnit.SECONDS);
service.shutdown();
// Make any KernelException thrown from a creation thread visible in the main thread
Exception ex = exception.get();
if (ex != null)
{
throw ex;
}
return(nodes);
}
public async Task TestRemoveQueuesWhileNotConnected()
{
var connectionFactory = new Mock <Connection.IConnectionFactory>();
var connection = new Mock <Connection.IConnection>();
var channel = new Mock <IChannelProxy>();
var rabbitChannel = new Mock <RC.IModel>();
channel.Setup(c => c.TargetChannel).Returns(rabbitChannel.Object);
connectionFactory.Setup((f) => f.CreateConnection()).Returns(connection.Object);
connection.Setup((c) => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
connection.Setup((c) => c.IsOpen).Returns(true);
var isOpen = new AtomicBoolean(true);
channel.Setup((c) => c.IsOpen).Returns(
() =>
isOpen.Value);
rabbitChannel.Setup(c => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties());
var declare = new AtomicReference <string>();
channel.Setup(c => c.QueueDeclarePassive(It.IsAny <string>()))
.Callback <string>(
(name) =>
declare.Value = name)
.Returns(() =>
new RC.QueueDeclareOk(declare.Value, 0, 0));
var latch1 = new CountdownEvent(2);
var latch3 = new CountdownEvent(3);
channel.Setup(c =>
c.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <RC.IBasicConsumer>()))
.Callback(
() =>
{
if (!latch3.IsSet)
{
latch3.Signal();
}
})
.Returns("consumerTag");
var qos = new AtomicInteger();
channel.Setup(c => c.BasicQos(It.IsAny <uint>(), It.IsAny <ushort>(), It.IsAny <bool>()))
.Callback <uint, ushort, bool>((size, count, global) =>
{
qos.Value = count;
if (!latch1.IsSet)
{
latch1.Signal();
}
});
var latch2 = new CountdownEvent(2);
channel.Setup(
c => c.BasicCancel("consumerTag"))
.Callback(
() =>
{
if (!latch2.IsSet)
{
latch2.Signal();
}
});
var container = new DirectMessageListenerContainer(null, connectionFactory.Object);
container.SetQueueNames("test1", "test2");
container.PrefetchCount = 2;
container.MonitorInterval = 100;
container.FailedDeclarationRetryInterval = 100;
container.RecoveryInterval = 100;
container.ShutdownTimeout = 1;
container.Initialize();
await container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
Assert.True(latch1.Wait(TimeSpan.FromSeconds(10)));
Assert.Equal(2, qos.Value);
isOpen.Value = false;
container.RemoveQueueNames("test1");
Assert.True(latch2.Wait(TimeSpan.FromSeconds(20))); // Basic Cancels from isOpen = false
isOpen.Value = true; // Consumers should restart, but only test2,
Assert.True(latch3.Wait(TimeSpan.FromSeconds(10)));
channel.Verify(
c =>
c.BasicConsume("test1", It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <RC.IBasicConsumer>()),
Times.Once());
channel.Verify(
c =>
c.BasicConsume("test2", It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <RC.IBasicConsumer>()),
Times.Exactly(2));
await container.Stop();
}
/**
* Initialize a reference to an on-disk object directory.
*
* @param dir
* the location of the <code>objects</code> directory.
*/
public ObjectDirectory(DirectoryInfo dir)
{
objects = dir;
infoDirectory = new DirectoryInfo(objects.FullName + "/info");
packDirectory = new DirectoryInfo(objects.FullName + "/pack");
alternatesFile = new FileInfo(infoDirectory + "/alternates");
packList = new AtomicReference<PackFile[]>();
}
public ThreadAnonymousClass(int numDocs, DirectoryReader rd, IndexSearcher searcher, int readsPerThread, AtomicReference <Exception> ex)
{
this.numDocs = numDocs;
this.rd = rd;
this.searcher = searcher;
this.readsPerThread = readsPerThread;
this.ex = ex;
queries = new int[this.readsPerThread];
for (int j = 0; j < queries.Length; ++j)
{
queries[j] = Random.Next(this.numDocs);
}
}
public ChannelInboundHandlerAdapter0(AtomicReference <IChannelHandlerContext> ctxRef, AtomicReference <PendingWriteQueue> queueRef)
{
_ctxRef = ctxRef;
_queueRef = queueRef;
}
public TestContext(int times)
{
Access = AccessSafely.AfterCompleting(times);
reference = new AtomicReference <object>();
SetUpWriteRead();
}
public ThreadAnonymousClass(BaseTermVectorsFormatTestCase outerInstance, int numDocs, RandomDocument[] docs, IndexReader reader, AtomicReference <Exception> exception)
{
this.outerInstance = outerInstance;
this.numDocs = numDocs;
this.docs = docs;
this.reader = reader;
this.exception = exception;
}
public void AtomicReference_Equality_SeqCst_Should_Success()
{
var source = new object();
var atomicReference = new AtomicReference<object>(source, MemoryOrder.SeqCst);
Assert.True(atomicReference == source);
}
public ThreadAnonymousInnerClassHelper(TestIndexWriterWithThreads outerInstance, BaseDirectoryWrapper d, AtomicReference <IndexWriter> writerRef, LineFileDocs docs, int iters, AtomicBoolean failed, ReentrantLock rollbackLock, ReentrantLock commitLock)
{
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this.outerInstance = outerInstance;
#endif
this.d = d;
this.writerRef = writerRef;
this.docs = docs;
this.iters = iters;
this.failed = failed;
this.rollbackLock = rollbackLock;
this.commitLock = commitLock;
}
public void AtomicReference_Inequality_SeqCst_Should_Success()
{
var atomicReference = new AtomicReference<object>(null, MemoryOrder.SeqCst);
Assert.False(atomicReference != null);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void shouldShutdownEvenThoughWaitingForLock0(org.neo4j.causalclustering.discovery.Cluster<?> cluster, int victimId, java.util.Collection<int> shutdownOrder) throws Exception
private void ShouldShutdownEvenThoughWaitingForLock0 <T1>(Cluster <T1> cluster, int victimId, ICollection <int> shutdownOrder)
{
const int longTime = 60_000;
const int numberOfLockAcquirers = 2;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.ExecutorService txExecutor = java.util.concurrent.Executors.newCachedThreadPool();
ExecutorService txExecutor = Executors.newCachedThreadPool(); // Blocking transactions are executed in
// parallel, not on the main thread.
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.ExecutorService shutdownExecutor = java.util.concurrent.Executors.newFixedThreadPool(1);
ExecutorService shutdownExecutor = Executors.newFixedThreadPool(1); // Shutdowns are executed
// serially, not on the main thread.
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch acquiredLocksCountdown = new java.util.concurrent.CountDownLatch(NUMBER_OF_LOCK_ACQUIRERS);
System.Threading.CountdownEvent acquiredLocksCountdown = new System.Threading.CountdownEvent(numberOfLockAcquirers);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch locksHolder = new java.util.concurrent.CountDownLatch(1);
System.Threading.CountdownEvent locksHolder = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.graphdb.Node> node = new java.util.concurrent.atomic.AtomicReference<>();
AtomicReference <Node> node = new AtomicReference <Node>();
CompletableFuture <Void> preShutdown = new CompletableFuture <Void>();
// set shutdown order
CompletableFuture <Void> afterShutdown = preShutdown;
foreach (int?id in shutdownOrder)
{
afterShutdown = afterShutdown.thenRunAsync(() => cluster.GetCoreMemberById(id.Value).shutdown(), shutdownExecutor);
}
CreateANode(node);
try
{
// when - blocking on lock acquiring
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.graphdb.GraphDatabaseService leader = cluster.getCoreMemberById(victimId).database();
GraphDatabaseService leader = cluster.GetCoreMemberById(victimId).database();
for (int i = 0; i < numberOfLockAcquirers; i++)
{
txExecutor.execute(() =>
{
try
{
using (Transaction tx = leader.BeginTx())
{
acquiredLocksCountdown.Signal();
tx.acquireWriteLock(node.get());
locksHolder.await();
tx.success();
}
}
catch (Exception)
{
/* Since we are shutting down, a plethora of possible exceptions are expected. */
}
});
}
// await locks
if (!acquiredLocksCountdown.await(longTime, MILLISECONDS))
{
throw new System.InvalidOperationException("Failed to acquire locks");
}
// then shutdown in given order works
preShutdown.complete(null);
afterShutdown.get(longTime, MILLISECONDS);
}
finally
{
afterShutdown.cancel(true);
locksHolder.Signal();
txExecutor.shutdownNow();
shutdownExecutor.shutdownNow();
}
}
public TestMailbox()
{
world = TestWorld.Instance !;
queue = new ConcurrentQueue <IMessage>();
suspendedOverrides = new AtomicReference <Stack <List <Type> > >(new Stack <List <Type> >());
}
public FailAssertionHandler(AtomicReference <Exception> ex)
{
_ex = ex;
}
public Logic(OutputStreamSourceStage stage, BlockingCollection <ByteString> dataQueue, AtomicReference <IDownstreamStatus> downstreamStatus, string dispatcherId) : base(stage.Shape)
{
_stage = stage;
_dataQueue = dataQueue;
_downstreamStatus = downstreamStatus;
_dispatcherId = dispatcherId;
var downstreamCallback = GetAsyncCallback((Either <ByteString, Exception> result) =>
{
if (result.IsLeft)
{
OnPush(result.Value as ByteString);
}
else
{
FailStage(result.Value as Exception);
}
});
_upstreamCallback =
GetAsyncCallback <Tuple <IAdapterToStageMessage, TaskCompletionSource <NotUsed> > >(OnAsyncMessage);
_pullTask = new OnPullRunnable(downstreamCallback, dataQueue, _cancellation.Token);
SetHandler(_stage._out, onPull: OnPull, onDownstreamFinish: OnDownstreamFinish);
}
public TestRecoveryCallback(AtomicReference <IMessage> replyMessage, AtomicReference <Address> replyAddress, AtomicReference <Exception> throwable)
{
this.replyMessage = replyMessage;
this.replyAddress = replyAddress;
this.throwable = throwable;
}
public void AtomicReference_Inequality_AcqRel_Should_Success()
{
var atomicReference = new AtomicReference<object>(null);
Assert.True(atomicReference == null);
Assert.False(object.ReferenceEquals(atomicReference, null));
}
public _Answer_205(AtomicReference <DatanodeProtocolProtos.BlockReportRequestProto
> request)
{
this.request = request;
}
/// <summary>
/// Construct an atom with given initial value and metadata.
/// </summary>
/// <param name="state">The initial value.</param>
/// <param name="meta">The metadata to attach.</param>
public Atom(object state, IPersistentMap meta)
: base(meta)
{
_state = new AtomicReference<object>(state);
}
public void TestRecoverAfterDeletedQueueAndLostConnection()
{
var connectionFactory = new Mock <IConnectionFactory>();
var connection = new Mock <IConnection>();
var channel = new Mock <R.IModel>();
connectionFactory.Setup((f) => f.CreateConnection()).Returns(connection.Object);
connection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
connection.Setup(c => c.IsOpen).Returns(true);
channel.Setup(c => c.IsOpen).Returns(true);
var n = new AtomicInteger();
var consumerCaptor = new AtomicReference <R.IBasicConsumer>();
var consumerLatch = new CountdownEvent(2);
channel.Setup(c => c.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <R.IBasicConsumer>()))
.Callback <string, bool, string, bool, bool, IDictionary <string, object>, R.IBasicConsumer>((a1, a2, a3, a4, a5, a6, a7) =>
{
consumerCaptor.Value = a7;
consumerLatch.Signal();
})
.Returns("consumer" + n.IncrementAndGet());
channel.Setup(c => c.BasicCancel("consumer2"))
.Throws(new Exception("Intentional cancel fail"));
var blockingQueueConsumer = new BlockingQueueConsumer(
connectionFactory.Object,
new DefaultMessageHeadersConverter(),
new ActiveObjectCounter <BlockingQueueConsumer>(),
AcknowledgeMode.AUTO,
false,
1,
null,
"testQ1",
"testQ2");
var latch = new CountdownEvent(1);
Task.Run(() =>
{
blockingQueueConsumer.Start();
while (true)
{
try
{
blockingQueueConsumer.NextMessage(1000);
}
catch (ConsumerCancelledException)
{
latch.Signal();
break;
}
catch (ShutdownSignalException)
{
// Noop
}
catch (Exception)
{
// noop
}
}
});
Assert.True(consumerLatch.Wait(TimeSpan.FromSeconds(10)));
var consumer = consumerCaptor.Value;
consumer.HandleBasicCancel("consumer1");
Assert.True(latch.Wait(TimeSpan.FromSeconds(10)));
}
