public static async Task ExecuteAsync(MasterReplicaService.MasterReplicaServiceClient Stub, string selfServerId, int timeout)
{
await Stub.HeartBeatAsync(new HeartBeatRequest
{
ServerId = selfServerId
}, deadline : DateTime.UtcNow.AddMilliseconds(timeout));
}
private static async Task <ReadRecoveryReply> ExecuteServerAsync(MasterReplicaService.MasterReplicaServiceClient Stub, GStoreObjectIdentifier gStoreObjectIdentifier)
{
ReadRecoveryRequest request = new ReadRecoveryRequest
{
ObjectIdentifier = new ObjectIdentifierDto
{
PartitionId = gStoreObjectIdentifier.PartitionId,
ObjectId = gStoreObjectIdentifier.ObjectId
}
};
return(await Stub.ReadRecoveryAsync(request));
}
private static async Task <int> ExecuteReplicaAsync(MasterReplicaService.MasterReplicaServiceClient Stub, GStoreObjectIdentifier gStoreObjectIdentifier)
{
LockRequest lockRequest = new LockRequest
{
ObjectIdentifier = new ObjectIdentifierDto
{
PartitionId = gStoreObjectIdentifier.PartitionId,
ObjectId = gStoreObjectIdentifier.ObjectId
}
};
LockReply lockReply = await Stub.LockAsync(lockRequest);
return(lockReply.LockId);
}
private static ConnectionManager CreateServerConnectionManager(string networkConfiguration)
{
InitializationParser initializationParser = new InitializationParser(networkConfiguration);
List <Tuple <string, string> > serversConfiguration = initializationParser.GetServersConfiguration();
List <Tuple <string, List <string> > > partitionsConfiguration = initializationParser.GetPartitionsConfiguration();
IDictionary <string, Domain.Server> servers = new Dictionary <string, Domain.Server>();
IDictionary <string, Partition> partitions = new Dictionary <string, Partition>();
for (int i = 0; i < serversConfiguration.Count; i++)
{
Tuple <string, string> serverConfig = serversConfiguration[i];
string serverId = serverConfig.Item1;
if (myServerId != serverId)
{
string address = serverConfig.Item2;
GrpcChannel channel = GrpcChannel.ForAddress(address);
MasterReplicaService.MasterReplicaServiceClient stub = new MasterReplicaService.MasterReplicaServiceClient(channel);
Domain.Server server = new Domain.Server(serverId, stub);
servers.Add(serverId, server);
}
}
foreach (Tuple <string, List <string> > partitionConfig in partitionsConfiguration)
{
string partitionId = partitionConfig.Item1;
string masterId = partitionConfig.Item2.ElementAt(0);
ISet <string> partitionReplicaSet = new HashSet <string>();
foreach (string serverId in partitionConfig.Item2)
{
if (serverId != masterId)
{
partitionReplicaSet.Add(serverId);
}
}
Partition partition = new Partition(partitionId, masterId, partitionReplicaSet);
partitions.Add(partitionId, partition);
}
ConnectionManager connectionManager = new ConnectionManager(servers, partitions, myServerId);
return(connectionManager);
}
private static async Task ExecuteServerAsync(ConnectionManager connectionManager, MasterReplicaService.MasterReplicaServiceClient stub, GStoreObject gStoreObject, int version)
{
WriteRequest writeRequest = new WriteRequest
{
Object = new ObjectDto
{
ObjectIdentifier = new ObjectIdentifierDto
{
PartitionId = gStoreObject.Identifier.PartitionId,
ObjectId = gStoreObject.Identifier.ObjectId
},
Value = gStoreObject.Value
},
ServerId = connectionManager.SelfServerId,
Version = version
};
await stub.WriteAsync(writeRequest);
}
