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);
            }
        }
Пример #3
0
 public void BroadcastWrite(
     string partitionId,
     string key,
     string value,
     ImmutableVectorClock replicaTimestamp)
 {
     if (partitionHandlers.TryGetValue(partitionId, out PartitionReliableBroadcastHandler handler))
     {
         handler.BroadcastWrite(
             key,
             value,
             replicaTimestamp);
     }
 }
Пример #4
0
 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);
     }
 }
Пример #7
0
        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);
        }