public void ListServer(string server_id)
{
if (currentServerId != server_id)
{
TryChangeCommunicationChannel(server_id);
}
try
{
ListServerRequest request = new ListServerRequest();
var reply = Client.ListServer(request);
Console.WriteLine("Received from server: " + server_id);
foreach (var obj in reply.Objects)
{
Console.WriteLine($"object <{obj.Key.PartitionId}, {obj.Key.ObjectId}>, is {server_id} partition master? {obj.IsPartitionMaster}");
}
}
catch (RpcException e)
{
if (e.Status.StatusCode == StatusCode.Unavailable || e.Status.StatusCode == StatusCode.DeadlineExceeded || e.Status.StatusCode == StatusCode.Internal)
{
UpdateCrashedServersList();
}
else
{
throw e;
}
}
}
public List <ListServerResult> ListServerUrl(string serverUrl)
{
var request = new ListServerRequest();
try {
_client = BuildClientFromServerUrl("http://" + serverUrl);
var listServerResponse = _client.listServer(request);
return(listServerResponse
.Objects
.Select(MapToListServerResult)
.ToList());
}
catch (RpcException e) {
RemoveClientUrl(serverUrl);
Console.WriteLine("Server is down");
Console.WriteLine(e.Message);
return(new List <ListServerResult>());
}
catch (Exception e) {
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
return(new List <ListServerResult>());
}
}
public ListServerReply ListMe(ListServerRequest request)
{
Console.WriteLine("Received ListServer");
List <ObjectInfo> lst = new List <ObjectInfo>();
LocalReadWriteLock.AcquireReaderLock(-1);
foreach (ObjectKey obj in KeyValuePairs.Keys)
{
KeyValuePairs[obj].LockRead();
lst.Add(new ObjectInfo
{
IsPartitionMaster = MasteredPartitions.Contains(obj.Partition_id),
Key = new Key
{
PartitionId = obj.Partition_id,
ObjectId = obj.Object_id
},
Value = KeyValuePairs[obj].Value
});
KeyValuePairs[obj].UnlockRead();
}
LocalReadWriteLock.ReleaseReaderLock();
return(new ListServerReply
{
Objects = { lst }
});
}
public async Task <Dictionary <string, ListServerReply> > ListGlobalAsync(ListServerRequest request)
{
var previousId = this.ServerId;
var reply = new Dictionary <string, ListServerReply>(_serversCount);
foreach (var id in _servers.Keys)
{
try
{
EstablishChannel(id);
reply[id] = await ClientListServerAsync(request);
}
catch (RpcException e)
{
Console.WriteLine($"RpcException: {e.StatusCode}");
await CheckCurrentServerStatus();
reply[id] = new ListServerReply(); // empty reply
}
}
Console.WriteLine($"Establish a channel with the server that preceded the ListGlobal operation (id: {previousId}).");
EstablishChannel(previousId);
return(reply);
}
private AsyncUnaryCall <ListServerReply> ClientListServerAsync(ListServerRequest request)
{
if (_isAdvanced)
{
return(_client.ListServerAdvancedAsync(request));
}
return(_client.ListServerAsync(request));
}
public override Task <ListServerResponse> listServer(ListServerRequest request, ServerCallContext context)
{
//Not frozen
delayFunction();
Console.WriteLine("Received List Server Request: " + request.ToString());
return(Task.FromResult(_storage.ListServer()));
}
public override Task <ListServerReply> ListServer(ListServerRequest req, ServerCallContext _)
{
man.CheckFreeze();
var res = new ListServerReply();
var objs = store.ListObjs();
lock (objs) {
foreach (KeyValuePair <string, string> e in objs)
{
res.Objs.Add(e.Key, e.Value);
}
}
Lib.Sleep(new Random().Next(minDelay, maxDelay));
return(Task.FromResult(res));
}
public override Task <ListServerReply> ListServerAdvanced(ListServerRequest request, ServerCallContext context)
{
var currentServerId = _gigaStorage.ServerId;
var reply = new ListServerReply();
var objects = _gigaStorage.ListServerAdvanced();
foreach (var o in objects)
{
var masterId = _gigaStorage.GetMaster(o.PartitionId);
var inMaster = (currentServerId == masterId);
var obj = new ListServerReply.Types.Object {
PartitionId = o.PartitionId,
ObjectId = o.ObjectId,
Value = o.Value,
InMaster = inMaster
};
reply.Objects.Add(obj);
}
return(Task.FromResult(reply));
}
public ListServerReply ListServerHandler(ListServerRequest request)
{
ListServerReply reply = null;
List <DataStorePartitionDto> partitionList = new List <DataStorePartitionDto>();
foreach (Partition p in server.getPartitions())
{
List <DataStoreObjectDto> objectList = new List <DataStoreObjectDto>();
DataStore store = p.getDataStore();
foreach (DataStoreKey key in store.getKeys())
{
Shared.GrpcDataStore.DataStoreObjectDto dto_obj = new Shared.GrpcDataStore.DataStoreObjectDto
{
Key = DataStoreServer.Util.Utilities.ConvertKeyDomainToDto(key),
Value = DataStoreServer.Util.Utilities.ConvertValueDomainToDto(store.getObject(key))
};
objectList.Add(dto_obj);
}
Shared.GrpcDataStore.DataStorePartitionDto dto_part = new Shared.GrpcDataStore.DataStorePartitionDto
{
PartitionId = p.getName(),
IsMaster = p.is_master,
ObjectList = { objectList }
};
partitionList.Add(dto_part);
}
reply = new ListServerReply
{
PartitionList = { partitionList }
};
return(reply);
}
public async Task <ListServerReply> ListServerAsync(ListServerRequest request, string serverId)
{
var previousId = this.ServerId;
ListServerReply reply;
try
{
EstablishChannel(serverId);
reply = await ClientListServerAsync(request);
}
catch (RpcException e)
{
Console.WriteLine($"RpcException: {e.StatusCode}");
await CheckCurrentServerStatus();
reply = new ListServerReply(); // empty reply;
}
Console.WriteLine($"Establish a channel with the server that preceded the ListServer operation (id: {previousId}).");
EstablishChannel(previousId);
return(reply);
}
public override async Task <ListServerReply> ListServer(ListServerRequest request, ServerCallContext context)
{
server.sleepBeforeProcessingMessage();
return(await Task.FromResult(ListServerHandler(request)));
}
// List Server
public override Task <ListServerReply> ListServer(ListServerRequest request, ServerCallContext context)
{
return(Task.FromResult(ListMe(request)));
}
