public void BroadcastWrite(
string key,
string value,
ImmutableVectorClock replicaTimestamp)
{
MessageId messageId = NextMessageId();
// Broadcast messages
receivedWrites.TryAdd(messageId, new BroadcastWriteMessage {
PartitionId = partitionId,
Key = key,
Value = value,
WriteServerId = selfId,
ReplicaTimestamp = replicaTimestamp
});
BroadcastWrite(messageId, key, value, replicaTimestamp, selfId);
lock (this) {
// Wait for 2 acks
// First time message is reinserted is the first ack
while (!writesAcks.TryGetValue(messageId, out int numAcks) &&
numAcks < 2 && serverIds.Count >= 2)
{
Monitor.Wait(this);
}
receivedWrites.TryGetValue(messageId, out BroadcastWriteMessage message);
writeMessageHandler(message);
}
}
public bool Read(
string serverUrl,
string partitionId,
string objectId,
out string value,
ImmutableVectorClock timestamp,
out ImmutableVectorClock replicaTimeStamp)
{
value = default;
replicaTimeStamp = default;
try {
AdvancedGrpcConnection connection = new AdvancedGrpcConnection(serverUrl);
replicaTimeStamp = connection.Read(
partitionId,
objectId,
out value,
timestamp);
return(true);
}
catch (RpcException e) {
HandleRpcException(serverUrl, e);
return(false);
}
}
public void BroadcastWrite(
string partitionId,
string key,
string value,
ImmutableVectorClock replicaTimestamp)
{
if (partitionHandlers.TryGetValue(partitionId, out PartitionReliableBroadcastHandler handler))
{
handler.BroadcastWrite(
key,
value,
replicaTimestamp);
}
}
public async Task BroadcastWrite(
string serverUrl,
string partitionId,
MessageId messageId,
string key,
string value,
ImmutableVectorClock replicaTimestamp,
string writeServerId)
{
try {
AdvancedReplicaCommunicationConnection connection = new AdvancedReplicaCommunicationConnection(serverUrl);
await connection.BroadcastWrite(partitionId, messageId, key, value, replicaTimestamp, writeServerId, DEFAULT_TIMEOUT);
}
catch (RpcException exception) {
HandleRpcException(serverUrl, exception);
}
}
private void BroadcastWrite(
MessageId messageId,
string key,
string value,
ImmutableVectorClock replicaTimestamp,
string writeServerId)
{
foreach (string serverId in serverIds)
{
_ = AdvancedNamingServiceLayer.Instance.BroadcastWrite(
serverId,
partitionId,
messageId,
key,
value,
replicaTimestamp,
writeServerId);
}
}
public async Task BroadcastWrite(
string serverId,
string partitionId,
MessageId messageId,
string key,
string value,
ImmutableVectorClock replicaTimestamp,
string writeServerId)
{
if (TryGetServer(serverId, out string serverUrl))
{
await AdvancedGrpcMessageLayer.Instance.BroadcastWrite(
serverUrl,
partitionId,
messageId,
key,
value,
replicaTimestamp,
writeServerId);
}
}
public bool Write(
string partitionId,
string objectId,
string value)
{
if (!namingService.ListPartition(partitionId, out ImmutableHashSet <string> serverIds))
{
return(false);
}
if (!timestamps.TryGetValue(partitionId, out MutableVectorClock timestamp))
{
timestamp = MutableVectorClock.Empty();
timestamps.Add(partitionId, timestamp);
}
foreach (string serverId in serverIds)
{
ImmutableVectorClock replicaTimestamp = null;
bool success = namingService.Lookup(serverId, out string serverUrl) &&
AdvancedGrpcMessageLayer.Instance.Write(
serverUrl,
partitionId,
objectId,
value,
timestamp.ToImmutable(),
out replicaTimestamp);
if (success)
{
timestamp.Merge(replicaTimestamp);
return(true);
}
}
return(false);
}
