public override bool Execute() { IObserveOperationResult res = client.Observe( Key, Cas, options.Persist, options.Replicate); if (!res.Success) { FailCommand(res); return(false); } string pretty = String.Format("Observe Code: (0x{0:x})", (int)res.KeyState); foreach (string name in Enum.GetNames(typeof(ObserveKeyState))) { ObserveKeyState v = (ObserveKeyState) Enum.Parse(typeof(ObserveKeyState), name); if (res.KeyState == v) { pretty += " " + name; break; } } Console.WriteLine(pretty); pretty = String.Format( "Timings: Persist [{0}], Replicate [{1}]", res.PersistenceStats.ToString(), res.ReplicationStats.ToString()); Console.WriteLine(pretty); return(true); }
public IObserveOperationResult Observe(string key, ulong cas, PersistTo persistTo, ReplicateTo replicateTo, ObserveKeyState persistedKeyState = ObserveKeyState.FoundPersisted, ObserveKeyState replicatedState = ObserveKeyState.FoundNotPersisted) { var hashedKey = this.KeyTransformer.Transform(key); var vbucket = this.poolInstance.GetVBucket(key); var nodes = this.poolInstance.GetWorkingNodes().ToArray(); var command = this.poolInstance.OperationFactory.Observe(hashedKey, vbucket.Index, cas); var runner = new ObserveHandler(new ObserveSettings { PersistTo = persistTo, ReplicateTo = replicateTo, Key = hashedKey, Cas = cas, Timeout = observeTimeout }); //Master only persistence if (replicateTo == ReplicateTo.Zero && persistTo == PersistTo.One) { return(runner.HandleMasterPersistence(poolInstance, persistedKeyState)); } else if (replicateTo == ReplicateTo.Zero && persistTo == PersistTo.Zero) //used for key exists checks { return(runner.HandleMasterOnlyInCache(poolInstance)); } else { return(runner.HandleMasterPersistenceWithReplication(poolInstance, persistedKeyState, replicatedState)); } }
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 unsafe bool Read(PooledSocket socket) { this.StatusCode = -1; if (!socket.IsAlive) { return(false); } var header = new byte[HeaderLength]; socket.Read(header, 0, header.Length); int dataLength, extraLength; DeserializeHeader(header, out dataLength, out extraLength); var keyHeader = new byte[4]; socket.Read(keyHeader, 0, 4); var vbucket = BinaryConverter.DecodeUInt16(keyHeader, 0); var keylen = BinaryConverter.DecodeUInt16(keyHeader, 2); var keyData = new byte[keylen]; socket.Read(keyData, 0, keylen); Key = BinaryConverter.DecodeKey(keyData); var keyStateData = new byte[1]; socket.Read(keyStateData, 0, keyStateData.Length); KeyState = (ObserveKeyState)keyStateData[0]; var casData = new byte[8]; socket.Read(casData, 0, casData.Length); Cas = BinaryConverter.DecodeUInt64(casData, 0); return(this.StatusCode == 0); }
public IObserveOperationResult Observe(string key, ulong cas, PersistTo persistTo, ReplicateTo replicateTo, ObserveKeyState persistedKeyState = ObserveKeyState.FoundPersisted, ObserveKeyState replicatedState = ObserveKeyState.FoundNotPersisted) { throw new NotImplementedException(); }
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; }
private IObserveOperationResult checkNodesForKey(ObservedNode[] nodes, IObserveOperation command, ref bool isMasterInExpectedState, ref int replicaFoundCount, ref int replicaPersistedCount, ObserveKeyState persistedKeyState, ObserveKeyState replicatedKeyState) { var tmpReplicaFoundCount = 0; var tmpReplicaPersistedCount = 0; var tmpIsPersistedToMaster = false; var result = new ObserveOperationResult(); var lockObject = new object(); foreach (var node in nodes) { lock (lockObject) { var opResult = node.Node.ExecuteObserveOperation(command); if (log.IsDebugEnabled) log.Debug("Node: " + node.Node.EndPoint + ", Result: " + opResult.KeyState + ", Master: " + node.IsMaster + ", Cas: " + opResult.Cas + ", Key: " + _settings.Key); if (!opResult.Success) //Probably an IO Exception { break; } else if (node.IsMaster && opResult.Cas != _settings.Cas && (persistedKeyState == ObserveKeyState.FoundPersisted || replicatedKeyState == ObserveKeyState.FoundNotPersisted)) { result.Success = false; result.Message = ObserveOperationConstants.MESSAGE_MODIFIED; break; } else if (opResult.KeyState == persistedKeyState) { node.KeyIsPersisted = true; if (node.IsMaster) { tmpIsPersistedToMaster = true; } else { tmpReplicaPersistedCount++; } } else if (opResult.KeyState == replicatedKeyState) { if (!node.IsMaster) { tmpReplicaFoundCount++; } } } } isMasterInExpectedState = tmpIsPersistedToMaster; replicaFoundCount = tmpReplicaFoundCount; replicaPersistedCount = tmpReplicaPersistedCount; if (log.IsDebugEnabled) log.Debug("Master Persisted: " + tmpIsPersistedToMaster + ", Replica Found: " + replicaFoundCount + ", Replica Persisted: " + tmpReplicaPersistedCount); 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 }; } }
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 }); } }
private IObserveOperationResult checkNodesForKey(ObservedNode[] nodes, IObserveOperation command, ref bool isMasterInExpectedState, ref int replicaFoundCount, ref int replicaPersistedCount, ObserveKeyState persistedKeyState, ObserveKeyState replicatedKeyState) { var tmpReplicaFoundCount = 0; var tmpReplicaPersistedCount = 0; var tmpIsPersistedToMaster = false; var result = new ObserveOperationResult(); var lockObject = new object(); foreach (var node in nodes) { lock (lockObject) { var opResult = node.Node.ExecuteObserveOperation(command); if (log.IsDebugEnabled) { log.Debug("Node: " + node.Node.EndPoint + ", Result: " + opResult.KeyState + ", Master: " + node.IsMaster + ", Cas: " + opResult.Cas + ", Key: " + _settings.Key); } if (!opResult.Success) //Probably an IO Exception { break; } else if (node.IsMaster && opResult.Cas != _settings.Cas && (persistedKeyState == ObserveKeyState.FoundPersisted || replicatedKeyState == ObserveKeyState.FoundNotPersisted)) { result.Success = false; result.Message = ObserveOperationConstants.MESSAGE_MODIFIED; break; } else if (opResult.KeyState == persistedKeyState) { node.KeyIsPersisted = true; if (node.IsMaster) { tmpIsPersistedToMaster = true; } else { tmpReplicaPersistedCount++; } } else if (opResult.KeyState == replicatedKeyState) { if (!node.IsMaster) { tmpReplicaFoundCount++; } } } } isMasterInExpectedState = tmpIsPersistedToMaster; replicaFoundCount = tmpReplicaFoundCount; replicaPersistedCount = tmpReplicaPersistedCount; if (log.IsDebugEnabled) { log.Debug("Master Persisted: " + tmpIsPersistedToMaster + ", Replica Found: " + replicaFoundCount + ", Replica Persisted: " + tmpReplicaPersistedCount); } return(result); }
private IObserveOperationResult performParallelObserve(ICouchbaseServerPool pool, ObserveKeyState persistedKeyState, ObserveKeyState replicatedKeyState) { var commandConfig = setupObserveOperation(pool); var observedNodes = commandConfig.CouchbaseNodes.Select(n => new ObservedNode { Node = n as CouchbaseNode, IsMaster = n == commandConfig.CouchbaseNodes[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.Operation, 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 }); } }