/// <summary>
/// Handle the scenario when PersistTo == 0 && ReplicateTo == 0
/// Primary use case is to check whether key exists without
/// having to perform a Get + null check
/// </summary>
public IObserveOperationResult HandleMasterOnlyInCache(ICouchbaseServerPool pool)
{
try
{
var commandConfig = SetupObserveOperation(pool);
var node = commandConfig.CouchbaseNodes[0];
var result = node.ExecuteObserveOperation(commandConfig.Operation);
if (Log.IsDebugEnabled) Log.Debug("Node: " + node.EndPoint + ", Result: " + result.KeyState + ", Cas: " + result.Cas + ", Key: " + _settings.Key);
if ((_settings.Cas == 0 || result.Cas == _settings.Cas) &&
(result.KeyState == ObserveKeyState.FoundNotPersisted || result.KeyState == ObserveKeyState.FoundPersisted))
{
result.Pass();
}
else
{
result.Fail("Key not found");
}
return result;
}
catch (ObserveExpectationException ex)
{
return new ObserveOperationResult { Success = false, Message = ex.Message };
}
catch (Exception ex)
{
return new ObserveOperationResult { Success = false, Exception = ex };
}
}
public IObserveOperationResult HandleMasterPersistence(ICouchbaseServerPool pool, ObserveKeyState passingState = ObserveKeyState.FoundPersisted)
{
try
{
var commandConfig = setupObserveOperation(pool);
var node = commandConfig.CouchbaseNodes[0] as CouchbaseNode;
IObserveOperationResult result = new ObserveOperationResult();
do
{
var are = new AutoResetEvent(false);
var timer = new Timer(state =>
{
result = node.ExecuteObserveOperation(commandConfig.Operation);
if (log.IsDebugEnabled)
{
log.Debug("Node: " + node.EndPoint + ", Result: " + result.KeyState + ", Cas: " + result.Cas + ", Key: " + _settings.Key);
}
if (result.Success && result.Cas != _settings.Cas && result.Cas > 0 && passingState == ObserveKeyState.FoundPersisted) //don't check CAS for deleted items
{
result.Fail(ObserveOperationConstants.MESSAGE_MODIFIED);
are.Set();
}
else if (result.KeyState == passingState ||
(result.KeyState == ObserveKeyState.FoundPersisted &&
passingState == ObserveKeyState.FoundNotPersisted)) //if checking in memory, on disk should pass too
{
//though in memory checks are supported in this condition
//a miss will require a timeout
result.Pass();
are.Set();
}
}, are, 0, 500);
if (!are.WaitOne(_settings.Timeout))
{
timer.Change(-1, -1);
result.Fail(ObserveOperationConstants.MESSAGE_TIMEOUT, new TimeoutException());
break;
}
timer.Change(-1, -1);
} while (result.Message == string.Empty && result.KeyState != passingState);
return(result);
}
catch (ObserveExpectationException ex)
{
return(new ObserveOperationResult {
Success = false, Message = ex.Message
});
}
catch (Exception ex)
{
return(new ObserveOperationResult {
Success = false, Exception = ex
});
}
}
public IObserveOperationResult HandleMasterPersistence(ICouchbaseServerPool pool, ObserveKeyState passingState = ObserveKeyState.FoundPersisted)
{
try
{
var commandConfig = SetupObserveOperation(pool);
var node = commandConfig.CouchbaseNodes[0];
IObserveOperationResult result = new ObserveOperationResult();
do
{
var are = new AutoResetEvent(false);
var timer = new Timer(state =>
{
result = node.ExecuteObserveOperation(commandConfig.Operation);
if (Log.IsDebugEnabled) Log.Debug("Node: " + node.EndPoint + ", Result: " + result.KeyState + ", Cas: " + result.Cas + ", Key: " + _settings.Key);
if (result.Success && result.Cas != _settings.Cas && result.Cas > 0 && passingState == ObserveKeyState.FoundPersisted) //don't check CAS for deleted items
{
result.Fail(ObserveOperationConstants.MESSAGE_MODIFIED);
are.Set();
}
else if (result.KeyState == passingState ||
(result.KeyState == ObserveKeyState.FoundPersisted &&
passingState == ObserveKeyState.FoundNotPersisted)) //if checking in memory, on disk should pass too
{
//though in memory checks are supported in this condition
//a miss will require a timeout
result.Pass();
are.Set();
}
}, are, 0, 500);
if (!are.WaitOne(_settings.Timeout))
{
timer.Change(-1, -1);
result.Fail(ObserveOperationConstants.MESSAGE_TIMEOUT, new TimeoutException());
break;
}
timer.Change(-1, -1);
} while (result.Message == string.Empty && result.KeyState != passingState);
return result;
}
catch (ObserveExpectationException ex)
{
return new ObserveOperationResult { Success = false, Message = ex.Message };
}
catch (Exception ex)
{
return new ObserveOperationResult { Success = false, Exception = ex };
}
}
public IObserveOperationResult HandleMasterPersistenceWithReplication(ICouchbaseServerPool pool)
{
try
{
return(performParallelObserve(pool));
}
catch (Exception ex)
{
return(new ObserveOperationResult {
Success = false, Exception = ex
});
}
}
/// <summary>
/// Handle the scenario when PersistTo == 1
/// </summary>
public IObserveOperationResult HandleMasterPersistence(ICouchbaseServerPool pool)
{
try
{
var commandConfig = setupObserveOperation(pool);
var node = commandConfig.Item2[0] as CouchbaseNode;
IObserveOperationResult result = new ObserveOperationResult();
do
{
var are = new AutoResetEvent(false);
var timer = new Timer(state =>
{
result = node.ExecuteObserveOperation(commandConfig.Item3);
if (log.IsDebugEnabled)
{
log.Debug("Node: " + node.EndPoint + ", Result: " + result.KeyState + ", Cas: " + result.Cas + ", Key: " + _settings.Key);
}
if (result.Success && result.Cas != _settings.Cas && result.Cas > 0)
{
result.Fail(ObserveOperationConstants.MESSAGE_MODIFIED);
are.Set();
}
else if (result.KeyState == ObserveKeyState.FoundPersisted)
{
result.Pass();
are.Set();
}
}, are, 0, 500);
if (!are.WaitOne(_settings.Timeout))
{
timer.Change(-1, -1);
result.Fail(ObserveOperationConstants.MESSAGE_TIMEOUT, new TimeoutException());
break;
}
timer.Change(-1, -1);
} while (result.Message == string.Empty && result.KeyState != ObserveKeyState.FoundPersisted);
return(result);
}
catch (Exception ex)
{
return(new ObserveOperationResult {
Success = false, Exception = ex
});
}
}
private IObserveOperationResult performParallelObserve(ICouchbaseServerPool pool)
{
var commandConfig = setupObserveOperation(pool);
var observedNodes = commandConfig.Item2.Select(n => new ObservedNode
{
Node = n as CouchbaseNode,
IsMaster = n == commandConfig.Item2[0]
}).ToArray();
var replicaFoundCount = 0;
var replicaPersistedCount = 0;
var isKeyPersistedToMaster = false;
IObserveOperationResult result = new ObserveOperationResult();
do
{
var are = new AutoResetEvent(false);
var timer = new Timer(state =>
{
result = checkNodesForKey(observedNodes, commandConfig.Item3, ref isKeyPersistedToMaster, ref replicaFoundCount, ref replicaPersistedCount);
if (result.Message == ObserveOperationConstants.MESSAGE_MODIFIED)
{
are.Set();
result.Fail(ObserveOperationConstants.MESSAGE_MODIFIED);
}
else if (isInExpectedState(replicaFoundCount, replicaPersistedCount, isKeyPersistedToMaster))
{
are.Set();
result.Pass();
}
}, are, 0, 500);
if (!are.WaitOne(_settings.Timeout))
{
timer.Change(-1, -1);
result.Fail(ObserveOperationConstants.MESSAGE_TIMEOUT, new TimeoutException());
return(result);
}
if (result.Success)
{
timer.Change(-1, -1);
}
} while (result.Message == string.Empty && !isInExpectedState(replicaFoundCount, replicaPersistedCount, isKeyPersistedToMaster));
return(result);
}
/// <summary>
/// Handle the scenario when PersistTo == 1
/// </summary>
public IObserveOperationResult HandleMasterPersistence(ICouchbaseServerPool pool)
{
try
{
var commandConfig = setupObserveOperation(pool);
var node = commandConfig.Item2[0] as CouchbaseNode;
IObserveOperationResult result = new ObserveOperationResult();
do
{
var are = new AutoResetEvent(false);
var timer = new Timer(state =>
{
result = node.ExecuteObserveOperation(commandConfig.Item3);
if (log.IsDebugEnabled) log.Debug("Node: " + node.EndPoint + ", Result: " + result.KeyState + ", Cas: " + result.Cas + ", Key: " + _settings.Key);
if (result.Success && result.Cas != _settings.Cas && result.Cas > 0)
{
result.Fail(ObserveOperationConstants.MESSAGE_MODIFIED);
are.Set();
}
else if (result.KeyState == ObserveKeyState.FoundPersisted)
{
result.Pass();
are.Set();
}
}, are, 0, 500);
if (!are.WaitOne(_settings.Timeout))
{
timer.Change(-1, -1);
result.Fail(ObserveOperationConstants.MESSAGE_TIMEOUT, new TimeoutException());
break;
}
timer.Change(-1, -1);
} while (result.Message == string.Empty && result.KeyState != ObserveKeyState.FoundPersisted);
return result;
}
catch (Exception ex)
{
return new ObserveOperationResult { Success = false, Exception = ex };
}
}
protected CouchbaseClient(ICouchbaseServerPool pool, ICouchbaseClientConfiguration configuration)
: base(pool,
configuration.CreateKeyTransformer(),
configuration.CreateTranscoder(),
configuration.CreatePerformanceMonitor())
{
this.documentNameTransformer = configuration.CreateDesignDocumentNameTransformer();
this.poolInstance = (ICouchbaseServerPool)this.Pool;
observeTimeout = configuration.ObserveTimeout;
StoreOperationResultFactory = new DefaultStoreOperationResultFactory();
GetOperationResultFactory = new DefaultGetOperationResultFactory();
MutateOperationResultFactory = new DefaultMutateOperationResultFactory();
ConcatOperationResultFactory = new DefaultConcatOperationResultFactory();
RemoveOperationResultFactory = new DefaultRemoveOperationResultFactory();
}
private ObserveOperationSetup setupObserveOperation(ICouchbaseServerPool pool)
{
var vbucket = pool.GetVBucket(_settings.Key);
// Check to see if our persistence requirements can be satisfied
if (((int)_settings.ReplicateTo > vbucket.Replicas.Length + 1) ||
((int)_settings.PersistTo > vbucket.Replicas.Length + 1))
{
throw new ObserveExpectationException(
"Requested replication or persistence to more nodes than are currently " +
"configured");
}
var command = pool.OperationFactory.Observe(_settings.Key, vbucket.Index, _settings.Cas);
var workingNodes = pool.GetWorkingNodes().ToArray();
var masterAndReplicaNodes = new List <CouchbaseNode>();
masterAndReplicaNodes.Add(workingNodes[vbucket.Master] as CouchbaseNode);
for (var i = 0; i < vbucket.Replicas.Length; i++)
{
int replicaIndex = vbucket.Replicas[i];
if (replicaIndex < 0)
{
continue;
}
masterAndReplicaNodes.Add(workingNodes[replicaIndex] as CouchbaseNode);
}
if (masterAndReplicaNodes.Count < (int)_settings.PersistTo ||
masterAndReplicaNodes.Count - 1 < (int)_settings.ReplicateTo)
{
throw new ObserveExpectationException(
"Requested replication or persistence to more nodes than are currently " +
"online");
}
return(new ObserveOperationSetup
{
VBucket = vbucket,
CouchbaseNodes = masterAndReplicaNodes.ToArray(),
Operation = command
});
}
public IObserveOperationResult HandleMasterPersistenceWithReplication(ICouchbaseServerPool pool, ObserveKeyState persistedKeyState, ObserveKeyState replicatedKeyState)
{
try
{
return(performParallelObserve(pool, persistedKeyState, replicatedKeyState));
}
catch (ObserveExpectationException ex)
{
return(new ObserveOperationResult {
Success = false, Message = ex.Message
});
}
catch (Exception ex)
{
return(new ObserveOperationResult {
Success = false, Exception = ex
});
}
}
/// <summary>
/// Handle the scenario when PersistTo == 0 && ReplicateTo == 0
/// Primary use case is to check whether key exists without
/// having to perform a Get + null check
/// </summary>
public IObserveOperationResult HandleMasterOnlyInCache(ICouchbaseServerPool pool)
{
try
{
var commandConfig = setupObserveOperation(pool);
var node = commandConfig.CouchbaseNodes[0] as CouchbaseNode;
var result = node.ExecuteObserveOperation(commandConfig.Operation);
if (log.IsDebugEnabled)
{
log.Debug("Node: " + node.EndPoint + ", Result: " + result.KeyState + ", Cas: " + result.Cas + ", Key: " + _settings.Key);
}
if ((_settings.Cas == 0 || result.Cas == _settings.Cas) &&
(result.KeyState == ObserveKeyState.FoundNotPersisted || result.KeyState == ObserveKeyState.FoundPersisted))
{
result.Pass();
}
else
{
result.Fail("Key not found");
}
return(result);
}
catch (ObserveExpectationException ex)
{
return(new ObserveOperationResult {
Success = false, Message = ex.Message
});
}
catch (Exception ex)
{
return(new ObserveOperationResult {
Success = false, Exception = ex
});
}
}
public CouchbaseClientExtended(ICouchbaseServerPool pool, CouchbaseClientConfiguration config) : base(pool, config)
{
LoadBaseConfig(config);
}
private Tuple<VBucket, CouchbaseNode[], IObserveOperation> setupObserveOperation(ICouchbaseServerPool pool)
{
var vbucket = pool.GetVBucket(_settings.Key);
// Check to see if our persistence requirements can be satisfied
if (((int)_settings.ReplicateTo > vbucket.Replicas.Length + 1) ||
((int)_settings.PersistTo > vbucket.Replicas.Length + 1))
{
throw new ObserveExpectationException(
"Requested replication or persistence to more nodes than are currently " +
"available");
}
var command = pool.OperationFactory.Observe(_settings.Key, vbucket.Index, _settings.Cas);
var workingNodes = pool.GetWorkingNodes().ToArray();
var masterAndReplicaNodes = new List<CouchbaseNode>();
masterAndReplicaNodes.Add(workingNodes[vbucket.Master] as CouchbaseNode);
for (var i = 0; i < vbucket.Replicas.Length; i++)
{
int replicaIndex = vbucket.Replicas[i];
if (replicaIndex < 0)
{
continue;
}
masterAndReplicaNodes.Add(workingNodes[replicaIndex] as CouchbaseNode);
}
return Tuple.Create(vbucket, masterAndReplicaNodes.ToArray(), command);
}
private IObserveOperationResult performParallelObserve(ICouchbaseServerPool pool, ObserveKeyState persistedKeyState, ObserveKeyState replicatedKeyState)
{
var commandConfig = setupObserveOperation(pool);
var observedNodes = commandConfig.Item2.Select(n => new ObservedNode
{
Node = n as CouchbaseNode,
IsMaster = n == commandConfig.Item2[0]
}).ToArray();
var replicaFoundCount = 0;
var replicaPersistedCount = 0;
var isKeyPersistedToMaster = false;
IObserveOperationResult result = new ObserveOperationResult();
do
{
var are = new AutoResetEvent(false);
var timer = new Timer(state =>
{
result = checkNodesForKey(observedNodes, commandConfig.Item3, ref isKeyPersistedToMaster, ref replicaFoundCount, ref replicaPersistedCount, persistedKeyState, replicatedKeyState);
if (result.Message == ObserveOperationConstants.MESSAGE_MODIFIED)
{
are.Set();
result.Fail(ObserveOperationConstants.MESSAGE_MODIFIED);
}
else if (isInExpectedState(replicaFoundCount, replicaPersistedCount, isKeyPersistedToMaster))
{
result.Pass();
are.Set();
}
}, are, 0, 500);
if (!are.WaitOne(_settings.Timeout))
{
timer.Change(-1, -1);
result.Fail(ObserveOperationConstants.MESSAGE_TIMEOUT, new TimeoutException());
return result;
}
if (result.Success)
{
timer.Change(-1, -1);
}
} while (result.Message == string.Empty && !isInExpectedState(replicaFoundCount, replicaPersistedCount, isKeyPersistedToMaster));
return result;
}
public IObserveOperationResult HandleMasterPersistenceWithReplication(ICouchbaseServerPool pool, ObserveKeyState persistedKeyState, ObserveKeyState replicatedKeyState)
{
try
{
return performParallelObserve(pool, persistedKeyState, replicatedKeyState);
}
catch (ObserveExpectationException ex)
{
return new ObserveOperationResult { Success = false, Message = ex.Message };
}
catch (Exception ex)
{
return new ObserveOperationResult { Success = false, Exception = ex };
}
}
private Tuple <VBucket, CouchbaseNode[], IObserveOperation> setupObserveOperation(ICouchbaseServerPool pool)
{
var vbucket = pool.GetVBucket(_settings.Key);
var command = pool.OperationFactory.Observe(_settings.Key, vbucket.Index, _settings.Cas);
var workingNodes = pool.GetWorkingNodes().ToArray();
var masterAndReplicaNodes = new CouchbaseNode[vbucket.Replicas.Count() + 1];
masterAndReplicaNodes[0] = workingNodes[vbucket.Master] as CouchbaseNode;
for (var i = 0; i < vbucket.Replicas.Length; i++)
{
masterAndReplicaNodes[i + 1] = workingNodes[vbucket.Replicas[i]] as CouchbaseNode;
}
return(Tuple.Create(vbucket, masterAndReplicaNodes, command));
}
private Tuple<VBucket, CouchbaseNode[], IObserveOperation> setupObserveOperation(ICouchbaseServerPool pool)
{
var vbucket = pool.GetVBucket(_settings.Key);
var command = pool.OperationFactory.Observe(_settings.Key, vbucket.Index, _settings.Cas);
var workingNodes = pool.GetWorkingNodes().ToArray();
var masterAndReplicaNodes = new CouchbaseNode[vbucket.Replicas.Count() + 1];
masterAndReplicaNodes[0] = workingNodes[vbucket.Master] as CouchbaseNode;
for (var i = 0; i < vbucket.Replicas.Length; i++)
{
masterAndReplicaNodes[i + 1] = workingNodes[vbucket.Replicas[i]] as CouchbaseNode;
}
return Tuple.Create(vbucket, masterAndReplicaNodes, command);
}
private ObserveOperationSetup SetupObserveOperation(ICouchbaseServerPool pool)
{
var vbucket = pool.GetVBucket(_settings.Key);
// Check to see if our persistence requirements can be satisfied
if (((int)_settings.ReplicateTo > vbucket.Replicas.Length + 1) ||
((int)_settings.PersistTo > vbucket.Replicas.Length + 1))
{
throw new ObserveExpectationException(
"Requested replication or persistence to more nodes than are currently " +
"configured");
}
var command = pool.OperationFactory.Observe(_settings.Key, vbucket.Index, _settings.Cas);
var workingNodes = pool.GetWorkingNodes().Cast<ICouchbaseNode>().ToArray();
var masterAndReplicaNodes = new List<ICouchbaseNode> {workingNodes[vbucket.Master]};
for (var i = 0; i < vbucket.Replicas.Length; i++)
{
int replicaIndex = vbucket.Replicas[i];
if (replicaIndex < 0)
{
continue;
}
masterAndReplicaNodes.Add(workingNodes[replicaIndex]);
}
if (masterAndReplicaNodes.Count < (int)_settings.PersistTo ||
masterAndReplicaNodes.Count - 1 < (int)_settings.ReplicateTo)
{
throw new ObserveExpectationException(
"Requested replication or persistence to more nodes than are currently " +
"online");
}
return new ObserveOperationSetup
{
VBucket = vbucket,
CouchbaseNodes = masterAndReplicaNodes.ToArray(),
Operation = command
};
}
public IObserveOperationResult HandleMasterPersistenceWithReplication(ICouchbaseServerPool pool)
{
try
{
return performParallelObserve(pool);
}
catch (Exception ex)
{
return new ObserveOperationResult { Success = false, Exception = ex };
}
}
