public void setWriteResult(WriteRequest request, WriteReply reply)
{
lock (writeResults)
{
writeResults.Add(request, reply);
Monitor.PulseAll(writeResults);
}
}
// ---------- Handlers
public WriteReply WriteHandler(WriteRequest request)
{
SendValueToReplica svr = new SendValueToReplica(server, request);
server.tpool.AssyncInvoke(new ThrWork(svr.doWork));
WriteReply reply = server.getWriteResult(request);
return(reply);
}
public void doWork()
{
Partition partition = server.getPartition(request.ObjectKey.PartitionId);
Dictionary <string, ServerCommunicationService.ServerCommunicationServiceClient> PartitionReplicas = partition.getReplicas();
lockReplicas(PartitionReplicas, this.request.ObjectKey);
write_new_value_locally(partition, request);
WriteReply reply = write_new_value_replicas(PartitionReplicas, request);
server.setWriteResult(request, reply);
}
public WriteReply getWriteResult(WriteRequest request)
{
lock (writeResults)
{
while (!writeResults.ContainsKey(request))
{
Monitor.Wait(writeResults);
}
WriteReply reply = writeResults[request];
writeResults.Remove(request);
return(reply);
}
}
public void doWork()
{
Partition partition = server.getPartition(request.ObjectKey.PartitionId);
Dictionary <string, ServerCommunicationService.ServerCommunicationServiceClient> PartitionReplicas = partition.getReplicas();
atomicWriteLocallyAndUpdateClock(partition);
int clock = partition.getClock();
Console.WriteLine(">>> PartitionClock=" + clock);
Console.WriteLine(">>> Start Updating value and clock on replicas...");
WriteReply reply = write_new_value_replicas(PartitionReplicas, request, clock);
server.setWriteResult(request, reply);
}
public override Task <WriteReply> Write(WriteRequest req, ServerCallContext _)
{
man.CheckFreeze();
if (ServerManager.RInfos[req.IdPart].IsMaster())
{
if (man.Write(req.IdPart, req.IdObj, req.Val))
{
store.Write(req.IdPart, req.IdObj, req.Val);
}
}
var res = new WriteReply()
{
Mid = ServerManager.SParts[req.IdPart].Mid
};
Lib.Sleep(new Random().Next(minDelay, maxDelay));
return(Task.FromResult(res));
}
public async Task <CopyResult> Write(Stream stream, string name = null, CancellationToken ct = default(CancellationToken))
{
if (stream is null)
{
throw new ArgumentNullException(nameof(stream));
}
if (!stream.CanRead)
{
throw new InvalidOperationException();
}
WriteRequest request = new WriteRequest()
{
FileName = name
};
CopyResult result = new CopyResult()
{
FileName = name
};
try
{
Metadata requestHeaders = request.ToMetadata();
// Create a CancellationTokenSource we will use to cancel on time-outs
// and to transmit any cancellation to server.
using (CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(ct))
{
CallOptions options = default(CallOptions).WithHeaders(requestHeaders).WithCancellationToken(cts.Token);
AsyncClientStreamingCall <Chunk, WriteReply> call;
Stopwatch responseTimer = Stopwatch.StartNew();
try
{
call = client.Write(options);
//responseHeaders = await call.ResponseHeadersAsync.ConfigureAwait(false);
}
catch (Exception e)
{
// TODO: Also handle timeout
result.Status = CopyResultStatus.ConnectionFailure;
result.ErrorType = e.GetType().Name;
result.ErrorMessage = e.Message;
return(result);
}
finally
{
responseTimer.Stop();
result.ResponseTime = responseTimer.Elapsed;
}
byte[] buffer = new byte[CopyConstants.BufferSize];
GrpcContentStreamer streamer = new GrpcContentStreamer(govener);
Stopwatch streamingTimer = Stopwatch.StartNew();
try
{
await streamer.WriteContent(stream, buffer, call.RequestStream, ct).ConfigureAwait(false);
}
catch (Exception e)
{
result.ErrorType = e.GetType().Name;
result.ErrorMessage = e.Message;
if (e is TimeoutException)
{
result.Status = CopyResultStatus.StreamingTimeout;
}
else
{
result.Status = CopyResultStatus.StreamingFailure;
}
return(result);
}
finally
{
streamingTimer.Stop();
result.BytesStreamed = streamer.Bytes;
result.StreamingTime = streamingTimer.Elapsed;
}
// gRPC requires client to explicitly declare end-of-stream
await call.RequestStream.CompleteAsync().ConfigureAwait(false);
WriteReply reply = await call.ResponseAsync;
result.FileName = reply.FileName;
}
return(result);
}
catch (Exception e)
{
result.Status = CopyResultStatus.OtherClientSideError;
result.ErrorType = e.GetType().Name;
result.ErrorMessage = e.Message;
return(result);
}
}
