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))); }