/// <summary>
/// Handles the reconnection attempts.
/// If it succeeds, it marks the host as UP.
/// If not, it marks the host as DOWN
/// </summary>
internal void AttemptReconnection()
{
_poolModificationSemaphore.Wait();
var toRemove = _connections.Where(c => c.IsClosed).ToArray();
foreach (var c in toRemove)
{
_connections.Remove(c);
}
if (_connections.Count > 0)
{
//there is already an open connection
_poolModificationSemaphore.Release();
return;
}
Logger.Info("Attempting reconnection to host {0}", _host.Address);
CreateConnection().ContinueWith(t =>
{
if (t.Status == TaskStatus.RanToCompletion)
{
_connections.Add(t.Result);
//Release as soon as possible
_poolModificationSemaphore.Release();
Logger.Info("Reconnection attempt to host {0} succeeded", _host.Address);
_host.BringUpIfDown();
}
else
{
_poolModificationSemaphore.Release();
Logger.Info("Reconnection attempt to host {0} failed", _host.Address);
_host.SetDown();
}
}, TaskContinuationOptions.ExecuteSynchronously);
}
public void CopyOnWriteList_Should_Add_And_Count()
{
var list = new CopyOnWriteList<string>();
list.Add("one");
list.Add("two");
Assert.AreEqual(2, list.Count);
CollectionAssert.AreEqual(new[] { "one", "two" }, list);
}
/// <summary>
/// Handles the reconnection attempts.
/// If it succeeds, it marks the host as UP.
/// If not, it marks the host as DOWN
/// </summary>
internal void AttemptReconnection()
{
_isShuttingDown = false;
if (_isDisposed)
{
return;
}
var tcs = new TaskCompletionSource <Connection[]>();
//While there is a single thread here, there might be another thread
//Calling MaybeCreateFirstConnection()
//Guard for multiple creations
var creationTcs = Interlocked.CompareExchange(ref _creationTcs, tcs, null);
if (creationTcs != null || _connections.Count > 0)
{
//Already creating as host is back UP (possibly via events)
return;
}
Logger.Info("Attempting reconnection to host {0}", _host.Address);
//There is a single thread creating a connection
CreateConnection().ContinueWith(t =>
{
if (t.Status == TaskStatus.RanToCompletion)
{
if (_isShuttingDown)
{
t.Result.Dispose();
TransitionCreationTask(tcs, EmptyConnectionsArray);
return;
}
_connections.Add(t.Result);
Logger.Info("Reconnection attempt to host {0} succeeded", _host.Address);
_host.BringUpIfDown();
TransitionCreationTask(tcs, new [] { t.Result });
return;
}
Logger.Info("Reconnection attempt to host {0} failed", _host.Address);
Exception ex = null;
if (t.Exception != null)
{
t.Exception.Handle(e => true);
ex = t.Exception.InnerException;
//This makes sure that the exception is observed, but still sets _creationTcs' exception
//for MaybeCreateFirstConnection
tcs.Task.ContinueWith(x =>
{
if (x.Exception != null)
{
x.Exception.Handle(_ => true);
}
});
}
TransitionCreationTask(tcs, EmptyConnectionsArray, ex);
_host.SetDown(failedReconnection: true);
}, TaskContinuationOptions.ExecuteSynchronously);
}
// Checks type and adds to cache
private static bool CheckAddType(
Type[] classes,
Type type,
CopyOnWriteList<Pair<Type, bool>> resultCache)
{
lock (resultCache) {
// check again in synchronized block
foreach (Pair<Type, bool> pair in resultCache) {
if (pair.First == type) {
return pair.Second;
}
}
// get the types superclasses and interfaces, and their superclasses and interfaces
ISet<Type> classesToCheck = new HashSet<Type>();
TypeHelper.GetBase(type, classesToCheck);
classesToCheck.Add(type);
// check type against each class
var fits = false;
foreach (var clazz in classes) {
if (classesToCheck.Contains(clazz)) {
fits = true;
break;
}
}
resultCache.Add(new Pair<Type, bool>(type, fits));
return fits;
}
}
// Checks type and adds to cache
private bool?CheckAddType(Type type)
{
using (_oLock.Acquire())
{
// check again in synchronized block
foreach (Pair <Type, Boolean> pair in _resultCache)
{
if (pair.First == type)
{
return(pair.Second);
}
}
// get the types superclasses and interfaces, and their superclasses and interfaces
ICollection <Type> classesToCheck = new HashSet <Type>();
TypeHelper.GetBase(type, classesToCheck);
classesToCheck.Add(type);
// check type against each class
bool fits = false;
foreach (Type clazz in _classes)
{
if (classesToCheck.Contains(clazz))
{
fits = true;
break;
}
}
_resultCache.Add(new Pair <Type, Boolean>(type, fits));
return(fits);
}
}
public override void OnWireReceived(UnsafeReader reader)
{
var contextBase = RdContextBase.Read(SerializationContext, reader);
contextBase.RegisterOn(this);
myCounterpartHandlers.Add(myHandlersMap[contextBase]);
}
public void AddListener(ContextPartitionStateListener listener)
{
if (listenersLazy == null) {
listenersLazy = new CopyOnWriteList<ContextPartitionStateListener>();
}
listenersLazy.Add(listener);
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="clazz">class</param>
/// <param name="field">field</param>
/// <param name="cache">cache</param>
/// <returns>descriptor</returns>
public static DynamicPropertyDescriptorByField DynamicPropertyCacheAdd(
Type clazz,
FieldInfo field,
CopyOnWriteList <DynamicPropertyDescriptorByField> cache)
{
var propertyDescriptor = new DynamicPropertyDescriptorByField(clazz, field);
cache.Add(propertyDescriptor);
return(propertyDescriptor);
}
/// <summary>
/// Creates a new session on this cluster and using a keyspace an existing keyspace.
/// </summary>
/// <param name="keyspace">Case-sensitive keyspace name to use</param>
public ISession Connect(string keyspace)
{
Init();
var session = new Session(this, Configuration, keyspace, _serializer);
session.Init();
_connectedSessions.Add(session);
_logger.Info("Session connected ({0})", session.GetHashCode());
return(session);
}
/// <summary>
/// Creates a new session on this cluster and using a keyspace an existing keyspace.
/// </summary>
/// <param name="keyspace">Case-sensitive keyspace name to use</param>
public async Task <ISession> ConnectAsync(string keyspace)
{
await Init().ConfigureAwait(false);
var session = new Session(this, Configuration, keyspace, _serializer);
await session.Init().ConfigureAwait(false);
_connectedSessions.Add(session);
_logger.Info("Session connected ({0})", session.GetHashCode());
return(session);
}
public void Add_does_not_cause_concurrent_modifications()
{
var list = new CopyOnWriteList <int> {
1, 2, 3
};
var e = list.GetEnumerator();
// Adding an item should not cause concurrent modifications
list.Add(4);
Assert.DoesNotThrow(() => e.MoveNext());
}
async Task <TSession> IInternalCluster.ConnectAsync <TSession>(ISessionFactory <TSession> sessionFactory, string keyspace)
{
await Init().ConfigureAwait(false);
var session = await sessionFactory.CreateSessionAsync(keyspace, _serializer).ConfigureAwait(false);
await session.Init().ConfigureAwait(false);
_connectedSessions.Add(session);
Cluster.Logger.Info("Session connected ({0})", session.GetHashCode());
return(session);
}
/// <summary>
/// Creates a new session on this cluster and using a keyspace an existing keyspace.
/// </summary>
/// <param name="keyspace">Case-sensitive keyspace name to use</param>
public async Task <ISession> ConnectAsync(string keyspace)
{
await Init().ConfigureAwait(false);
var newSessionName = GetNewSessionName();
var session = await Configuration.SessionFactory.CreateSessionAsync(this, keyspace, _controlConnection.Serializer, newSessionName).ConfigureAwait(false);
await session.Init().ConfigureAwait(false);
_connectedSessions.Add(session);
Cluster.Logger.Info("Session connected ({0})", session.GetHashCode());
return(session);
}
public IDisposable Subscribe <T>(string path, Action <T> consumeAction)
{
Action <string, object> consumer = (pattern, message) =>
{
if (path == pattern && message is T)
{
consumeAction((T)message);
}
};
_list.Add(consumer);
return(new AnonymousDisposer(() => _list.Remove(consumer)));
}
public IDisposable Subscribe(string topicPattern, Action <string, object> messageConsumer)
{
var topicExpression = new Regex(topicPattern);
Action <string, object> conditionalConsume =
(path, message) =>
{
if (topicExpression.IsMatch(path))
{
messageConsumer(path, message);
}
};
_subscribtions.Add(conditionalConsume);
return(new AnonymousDisposer(() => _subscribtions.Remove(conditionalConsume)));
}
private DynamicPropertyDescriptor GetPopulateCache(Object obj)
{
// Check if the method is already there
Type target = obj.GetType();
foreach (DynamicPropertyDescriptor desc in _cache)
{
if (desc.GetClazz() == target)
{
return(desc);
}
}
// need to add it
using (_iLock.Acquire())
{
foreach (DynamicPropertyDescriptor desc in _cache)
{
if (desc.GetClazz() == target)
{
return(desc);
}
}
// Lookup method to use
MethodInfo method = DetermineMethod(target);
// Cache descriptor and create fast method
DynamicPropertyDescriptor propertyDescriptor;
if (method == null)
{
propertyDescriptor = new DynamicPropertyDescriptor(target, null, false);
}
else
{
FastClass fastClass = FastClass.Create(target);
FastMethod fastMethod = fastClass.GetMethod(method);
propertyDescriptor = new DynamicPropertyDescriptor(target, fastMethod, fastMethod.ParameterCount > 0);
}
_cache.Add(propertyDescriptor);
return(propertyDescriptor);
}
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="clazz">class</param>
/// <param name="method">method</param>
/// <param name="cache">cache</param>
/// <returns>descriptor</returns>
public static DynamicPropertyDescriptorByMethod DynamicPropertyCacheAdd(
Type clazz,
MethodInfo method,
CopyOnWriteList <DynamicPropertyDescriptorByMethod> cache)
{
DynamicPropertyDescriptorByMethod propertyDescriptor;
if (method == null)
{
propertyDescriptor = new DynamicPropertyDescriptorByMethod(clazz, null, false);
}
else
{
propertyDescriptor = new DynamicPropertyDescriptorByMethod(clazz, method, method.GetParameters().Length > 0);
}
cache.Add(propertyDescriptor);
return(propertyDescriptor);
}
private static DynamicPropertyDescriptor GetPopulateCache(CopyOnWriteList <DynamicPropertyDescriptor> cache, DynamicPropertyGetterBase dynamicPropertyGetterBase, Object obj, EventAdapterService eventAdapterService)
{
// Check if the method is already there
var target = obj.GetType();
foreach (DynamicPropertyDescriptor desc in cache)
{
if (desc.Clazz == target)
{
return(desc);
}
}
// need to add it
lock (dynamicPropertyGetterBase)
{
foreach (DynamicPropertyDescriptor desc in cache)
{
if (desc.Clazz == target)
{
return(desc);
}
}
// Lookup method to use
var method = dynamicPropertyGetterBase.DetermineMethod(target);
// Cache descriptor and create fast method
DynamicPropertyDescriptor propertyDescriptor;
if (method == null)
{
propertyDescriptor = new DynamicPropertyDescriptor(target, null, false);
}
else
{
var fastClass = FastClass.Create(target);
var fastMethod = fastClass.GetMethod(method);
propertyDescriptor = new DynamicPropertyDescriptor(target, fastMethod, fastMethod.ParameterCount > 0);
}
cache.Add(propertyDescriptor);
return(propertyDescriptor);
}
}
public void CopyOnWriteList_Should_Allow_Parallel_Calls_To_Remove()
{
var actions = new List<Action>();
var list = new CopyOnWriteList<int>();
for (var i = 0; i < 100; i++)
{
list.Add(i);
}
Assert.AreEqual(100, list.Count);
for (var i = 0; i < 100; i++)
{
var item = i;
actions.Add(() =>
{
list.Remove(item);
});
}
TestHelper.ParallelInvoke(actions);
Assert.AreEqual(0, list.Count);
}
public void Add_does_not_enumerate_added_items()
{
var list = new CopyOnWriteList <int> {
1, 2, 3
};
var e = list.GetEnumerator();
Assert.True(e.MoveNext());
Assert.Equal(1, e.Current);
// Adding an item should not cause concurrent modifications
list.Add(4);
Assert.DoesNotThrow(() => e.MoveNext());
Assert.Equal(2, e.Current);
Assert.True(e.MoveNext());
Assert.Equal(3, e.Current);
Assert.False(e.MoveNext());
}
public void CopyOnWriteList_Should_Allow_Parallel_Calls_To_Add()
{
var actions = new List<Action>();
var list = new CopyOnWriteList<int>();
for (var i = 0; i < 100; i++)
{
var item = i;
actions.Add(() =>
{
list.Add(item);
});
}
TestHelper.ParallelInvoke(actions);
Assert.AreEqual(100, list.Count);
for (var i = 0; i < 100; i++)
{
Assert.True(list.Contains(i));
}
var counter = 0;
CollectionAssert.AreEquivalent(Enumerable.Repeat(0, 100).Select(_ => counter++), list);
}
public void Writes_to_original_are_not_visible_to_clones()
{
var items = new CopyOnWriteList <string>();
items.Add("test");
Assert.Equal("test", items[0]);
var clone = items.Clone();
var clone2 = items.Clone();
Assert.True(items.HasSameBacking(clone));
Assert.True(items.HasSameBacking(clone2));
items[0] = "no";
Assert.False(items.HasSameBacking(clone));
Assert.False(items.HasSameBacking(clone2));
Assert.True(clone.HasSameBacking(clone2));
Assert.Equal("test", clone[0]);
Assert.Equal("test", clone2[0]);
}
public IDisposable Subscribe(Action <object> consumer)
{
_subscribers.Add(consumer);
EnsureWatching();
return(new AnonymousDisposer(() => _subscribers.Remove(consumer)));
}
public void Register_For_Events()
{
var receivedEvents = new CopyOnWriteList <CassandraEventArgs>();
using (var connection = CreateConnection())
{
connection.Open().Wait();
Query(connection, string.Format("DROP KEYSPACE IF EXISTS test_events_kp", 1)).Wait();
var eventTypes = CassandraEventType.TopologyChange | CassandraEventType.StatusChange | CassandraEventType.SchemaChange;
var task = connection.Send(new RegisterForEventRequest(eventTypes));
TaskHelper.WaitToComplete(task, 1000);
Assert.IsInstanceOf <ReadyResponse>(task.Result);
connection.CassandraEventResponse += (o, e) =>
{
receivedEvents.Add(e);
};
//create a keyspace and check if gets received as an event
Query(connection, string.Format(TestUtils.CreateKeyspaceSimpleFormat, "test_events_kp", 1)).Wait(1000);
TestHelper.RetryAssert(
() =>
{
Assert.Greater(receivedEvents.Count, 0);
var evs = receivedEvents.Select(e => e as SchemaChangeEventArgs).Where(e => e != null);
var createdEvent = evs.SingleOrDefault(
e => e.What == SchemaChangeEventArgs.Reason.Created && e.Keyspace == "test_events_kp" &&
string.IsNullOrEmpty(e.Table));
Assert.IsNotNull(createdEvent, JsonConvert.SerializeObject(receivedEvents.ToArray()));
},
100,
50);
//create a table and check if gets received as an event
Query(connection, string.Format(TestUtils.CreateTableAllTypes, "test_events_kp.test_table", 1)).Wait(1000);
TestHelper.RetryAssert(
() =>
{
Assert.Greater(receivedEvents.Count, 0);
var evs = receivedEvents.Select(e => e as SchemaChangeEventArgs).Where(e => e != null);
var createdEvent = evs.SingleOrDefault(
e => e.What == SchemaChangeEventArgs.Reason.Created && e.Keyspace == "test_events_kp" &&
e.Table == "test_table");
Assert.IsNotNull(createdEvent, JsonConvert.SerializeObject(receivedEvents.ToArray()));
},
100,
50);
if (TestClusterManager.CheckCassandraVersion(false, Version.Parse("2.1"), Comparison.GreaterThanOrEqualsTo))
{
Query(connection, "CREATE TYPE test_events_kp.test_type (street text, city text, zip int);").Wait(1000);
TestHelper.RetryAssert(
() =>
{
Assert.Greater(receivedEvents.Count, 0);
var evs = receivedEvents.Select(e => e as SchemaChangeEventArgs).Where(e => e != null);
var createdEvent = evs.SingleOrDefault(
e => e.What == SchemaChangeEventArgs.Reason.Created && e.Keyspace == "test_events_kp" &&
e.Type == "test_type");
Assert.IsNotNull(createdEvent, JsonConvert.SerializeObject(receivedEvents.ToArray()));
},
100,
50);
}
}
}
public override void AddHandler(object callableObject, Delegate handler)
{
Assert.NotNull(handler);
_handlers.Add(new KeyValuePair <object, object>(callableObject, handler));
}
public override void AddHandler(object callableObject, Delegate handler)
{
Assert.NotNull(handler);
_handlers.Add(new KeyValuePair <WeakReference, WeakReference>(new WeakReference(callableObject), new WeakReference(handler)));
}
