private void RestoreFile()
{
var fileName = Path.Combine(Core.Instance.Config.RestoreDirectory, _fileEntry.FileName);
bool success;
using (var file = File.OpenWrite(fileName))
{
var chunkNo = 0;
ChunkMessage chunk = null;
do
{
success = true;
for (int retryCount = 0; retryCount < MaxEntries; retryCount++)
{
var restoreChunkProtocol =
new EnhancedRestoreChunkProtocol(new FileChunk(_fileEntry.GetFileId(), chunkNo));
restoreChunkProtocol.Run().Wait();
chunk = restoreChunkProtocol.Message;
if (chunk != null && chunk.Body != null && chunk.Body.Length > 0)
{
file.Write(chunk.Body, 0, chunk.Body.Length);
break;
}
if (retryCount == MaxEntries - 1)
{
success = false;
}
}
if (!success)
{
break;
}
++chunkNo;
} while (chunk != null && chunk.Body != null && chunk.Body.Length == Core.Instance.Config.ChunkSize);
}
if (success)
{
Core.Instance.Log.InfoFormat("EnhancedRestoreFileProtocol: file '{0}' was sucessfuly restored",
_fileEntry.FileName);
}
else
{
Core.Instance.Log.ErrorFormat("EnhancedRestoreFileProtocol: file '{0}' restore failed",
_fileEntry.FileName);
try
{
File.Delete(fileName);
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception ex)
{
Core.Instance.Log.ErrorFormat("EnhancedRestoreFileProtocol: delete ex", ex);
}
}
}
public List <ChunkMessage> GetConversationMessagesPerChunk(List <ConversationMessageDocument> messages)
{
// siempre debe de traer al menos el chunck del dia actual
List <ChunkMessage> chunks = new List <ChunkMessage>();
try
{
List <List <ConversationMessageDocument> > messagesOrderByDate = GetMessagesOrdeByDistinctDay(messages);
foreach (var messageByDate in messagesOrderByDate)
{
if (messageByDate.Count > 0)
{
ChunkMessage chunk = new ChunkMessage
{
Messages = messageByDate,
DateConversation = DateTime.Parse(messageByDate[0].MessageTime),
HeadingDate = CalculateHeadingDate(DateTime.Parse(messageByDate[0].MessageTime)),
ElementToAttach = CalculateElementToAttach(DateTime.Parse(messageByDate[0].MessageTime))
};
chunks.Add(chunk);
}
}
ValidateCurrentChunk(ref chunks);
chunks.OrderByDescending(x => x.DateConversation);
}
catch (Exception e)
{
var messageException = telemetria.MakeMessageException(e, System.Reflection.MethodBase.GetCurrentMethod().Name);
telemetria.Critical(messageException);
}
return(chunks);
}
//called on the client when a chunk is recieved from the server
public Chunk recieveChunk(ChunkMessage message)
{
message.chunk.valid = true;
if (NetworkServer.active)
{
//host mode, don't overrwrite the gameobjects if they already exist.
return(loadedChunks.AddOrUpdate(message.chunk.chunkCoords, message.chunk, (key, old) =>
{
if (message.chunk.solidObject == null)
{
message.chunk.solidObject = old.solidObject;
}
if (message.chunk.transparentObject == null)
{
message.chunk.transparentObject = old.transparentObject;
}
return message.chunk;
}));
}
else
{
//this conserves the chunk object if it's already loaded. The animation won't play and you won't get a new object from the pool.
return(loadedChunks.AddOrUpdate(message.chunk.chunkCoords, message.chunk, (key, old) =>
{
message.chunk.solidObject = old.solidObject;
message.chunk.transparentObject = old.transparentObject;
return message.chunk;
}));
}
}
static bool Prefix(CombatHUDRetreatEscMenu __instance) {
if (MissionControl.Instance.AllowMissionControl() && MissionControl.Instance.IsDynamicWithdrawAllowed()) {
Main.LogDebug("[CombatHUDRetreatEscMenuOnRetreatConfirmedPatch] Sending Dynamic Withdraw Trigger Message");
ChunkMessage triggerDynamicWithdrawMessage = new ChunkMessage(ChunkLogic.DYNAMIC_WITHDRAW_CHUNK_GUID);
UnityGameInstance.Instance.Game.Combat.MessageCenter.PublishMessage(triggerDynamicWithdrawMessage);
AccessTools.Method(typeof(CombatHUDRetreatEscMenu), "OnRetreatCancelled").Invoke(__instance, null);
if (!Main.Settings.DynamicWithdraw.DisorderlyWithdrawalCompatibility) return false;
}
return true;
}
public override bool Evaluate(MessageCenterMessage message, string responseName)
{
base.Evaluate(message, responseName);
ChunkMessage chunkMessage = message as ChunkMessage;
Main.LogDebug("[ChunkMatchesChunkGuidConditional] Evaluating...");
if (chunkMessage != null && chunkMessage.ChunkGuid == this.ChunkGuid)
{
base.LogEvaluationPassed("Chunk matches guid of message.", responseName);
return(true);
}
base.LogEvaluationFailed("Chunk did NOT match guid of message.", responseName);
return(false);
}
public void ValidateCurrentChunk(ref List <ChunkMessage> chunks)
{
DateTime time = DateTime.UtcNow;
if (chunks.Count() == 0)
{
ChunkMessage chunk = new ChunkMessage
{
Messages = new List <ConversationMessageDocument>(),
DateConversation = time,
HeadingDate = CalculateHeadingDate(time),
ElementToAttach = CalculateElementToAttach(time)
};
chunks.Add(chunk);
}
}
private void SendGetChunk()
{
int timeout = 1000;
bool timedOut;
int retry = 0;
do
{
timedOut = false;
Core.Instance.MCChannel.Send(new GetChunkMessage(_fileChunk));
try
{
// wait for response
Message = Core.Instance.MDRChannel.Received
.Where(message => message.MessageType == MessageType.Chunk)
.Cast <ChunkMessage>()
.Where(message => message.ChunkNo == _fileChunk.ChunkNo &&
message.FileId == _fileChunk.FileId)
.Timeout(TimeSpan.FromMilliseconds(timeout))
.Next().First();
}
catch (TimeoutException)
{
timedOut = true;
++retry;
timeout *= 2;
Core.Instance.Log.ErrorFormat(
"RestoreChunkSubprotocol: Could not fetch {0} from the network. Retrying.",
_fileChunk);
}
} while (timedOut && retry < MaxRetries);
if (timedOut)
{
Core.Instance.Log.ErrorFormat(
"RestoreChunkSubprotocol: Could not fetch {0} from the network. Giving up.",
_fileChunk);
}
}
public void OnNext(GetChunkMessage msg)
{
var fileChunk = new FileChunk(msg.FileId, msg.ChunkNo);
if (!fileChunk.Exists())
{
// we were supposed to have this chunk: send removed message and remove the entry in the local count
if (Core.Instance.ChunkPeers.HasChunkPeer(fileChunk, false))
{
Core.Instance.MCChannel.Send(new RemovedMessage(fileChunk));
}
return;
}
try
{
var chunkReceived = false;
var disposable = Core.Instance.MDRChannel.Received
.Where(message => message.MessageType == MessageType.Chunk)
.Cast <ChunkMessage>()
.Where(message => message.ChunkNo == msg.ChunkNo &&
message.FileId == msg.FileId)
.Subscribe(_ => chunkReceived = true);
Task.Delay(Core.Instance.RandomDelay).Wait();
disposable.Dispose();
if (!chunkReceived)
{
var data = fileChunk.GetData();
var chunkMsg = new ChunkMessage(fileChunk, data);
Core.Instance.MDRChannel.Send(chunkMsg);
}
}
catch (Exception ex)
{
Core.Instance.Log.Error("RestoreChunkService", ex);
}
}
public void OnChunkRecieved(ChunkMessage message)
{
if (message.chunk != null)
{
MeshGenerator.queueChunk(world.recieveChunk(message), world);
//we have to remesh the neighbors as well. all chunks on client are valid, but we check since we could be in host mode.
if (world.loadedChunks.TryGetValue(message.chunkPos + new Vector3Int(1, 0, 0), out Chunk chunk))
{
MeshGenerator.queueChunk(chunk, world);
}
if (world.loadedChunks.TryGetValue(message.chunkPos + new Vector3Int(-1, 0, 0), out chunk))
{
MeshGenerator.queueChunk(chunk, world);
}
if (world.loadedChunks.TryGetValue(message.chunkPos + new Vector3Int(0, 1, 0), out chunk))
{
MeshGenerator.queueChunk(chunk, world);
}
if (world.loadedChunks.TryGetValue(message.chunkPos + new Vector3Int(0, -1, 0), out chunk))
{
MeshGenerator.queueChunk(chunk, world);
}
if (world.loadedChunks.TryGetValue(message.chunkPos + new Vector3Int(0, 0, 1), out chunk))
{
MeshGenerator.queueChunk(chunk, world);
}
if (world.loadedChunks.TryGetValue(message.chunkPos + new Vector3Int(0, 0, -1), out chunk))
{
MeshGenerator.queueChunk(chunk, world);
}
}
else if (message.willFulfill && !requestedChunks.Contains(message.chunkPos))
{
//re-request the chunk. means that the server is generating it or something
requestedChunks.Add(message.chunkPos);
}
}
public void TestMessageFieldUpperBounds()
{
var body = new byte[255];
for (var i = 0; i < body.Length; ++i)
{
body[i] = (byte)i;
}
var getChunkMsg = new GetChunkMessage(9, 9, FileId1, 999999);
var bytes = getChunkMsg.Serialize();
var getChunkMsg2 = Message.Deserialize(bytes) as GetChunkMessage;
Assert.IsNotNull(getChunkMsg2);
Assert.AreEqual(getChunkMsg.MessageType, getChunkMsg2.MessageType);
Assert.AreEqual(getChunkMsg.VersionM, getChunkMsg2.VersionM);
Assert.AreEqual(getChunkMsg.VersionN, getChunkMsg2.VersionN);
Assert.AreEqual(getChunkMsg.FileId, getChunkMsg2.FileId);
Assert.AreEqual(getChunkMsg.ChunkNo, getChunkMsg2.ChunkNo);
var chunkMsg = new ChunkMessage(9, 9, FileId1, 999999, body);
bytes = chunkMsg.Serialize();
var chunkMsg2 = Message.Deserialize(bytes) as ChunkMessage;
Assert.IsNotNull(chunkMsg2);
Assert.AreEqual(chunkMsg.MessageType, chunkMsg2.MessageType);
Assert.AreEqual(chunkMsg.VersionM, chunkMsg2.VersionM);
Assert.AreEqual(chunkMsg.VersionN, chunkMsg2.VersionN);
Assert.AreEqual(chunkMsg.FileId, chunkMsg2.FileId);
Assert.AreEqual(chunkMsg.ChunkNo, chunkMsg2.ChunkNo);
CollectionAssert.AreEqual(chunkMsg.Body, chunkMsg2.Body);
var putChunkMsg = new PutChunkMessage(9, 9, FileId1, 999999, 9, body);
bytes = putChunkMsg.Serialize();
var putChunkMsg2 = Message.Deserialize(bytes) as PutChunkMessage;
Assert.IsNotNull(putChunkMsg2);
Assert.AreEqual(putChunkMsg.MessageType, putChunkMsg2.MessageType);
Assert.AreEqual(putChunkMsg.VersionM, putChunkMsg2.VersionM);
Assert.AreEqual(putChunkMsg.VersionN, putChunkMsg2.VersionN);
Assert.AreEqual(putChunkMsg.FileId, putChunkMsg2.FileId);
Assert.AreEqual(putChunkMsg.ChunkNo, putChunkMsg2.ChunkNo);
Assert.AreEqual(putChunkMsg.ReplicationDeg, putChunkMsg2.ReplicationDeg);
CollectionAssert.AreEqual(putChunkMsg.Body, putChunkMsg2.Body);
var storedMsg = new StoredMessage(9, 9, FileId1, 999999);
bytes = storedMsg.Serialize();
var storedMsg2 = Message.Deserialize(bytes) as StoredMessage;
Assert.IsNotNull(storedMsg2);
Assert.AreEqual(storedMsg.MessageType, storedMsg2.MessageType);
Assert.AreEqual(storedMsg.VersionM, storedMsg2.VersionM);
Assert.AreEqual(storedMsg.VersionN, storedMsg2.VersionN);
Assert.AreEqual(storedMsg.FileId, storedMsg2.FileId);
Assert.AreEqual(storedMsg.ChunkNo, storedMsg2.ChunkNo);
var deleteMsg = new DeleteMessage(FileId1);
bytes = deleteMsg.Serialize();
var deleteMsg2 = Message.Deserialize(bytes) as DeleteMessage;
Assert.IsNotNull(deleteMsg2);
Assert.AreEqual(deleteMsg.MessageType, deleteMsg2.MessageType);
var removedMsg = new RemovedMessage(9, 9, FileId1, 999999);
bytes = removedMsg.Serialize();
var removedMsg2 = Message.Deserialize(bytes) as RemovedMessage;
Assert.IsNotNull(removedMsg2);
Assert.AreEqual(removedMsg.MessageType, removedMsg2.MessageType);
Assert.AreEqual(removedMsg.VersionM, removedMsg2.VersionM);
Assert.AreEqual(removedMsg.VersionN, removedMsg2.VersionN);
Assert.AreEqual(removedMsg.FileId, removedMsg2.FileId);
Assert.AreEqual(removedMsg.ChunkNo, removedMsg2.ChunkNo);
var lookupMsg = new LookupMessage(9, 9, FileId1);
bytes = lookupMsg.Serialize();
var lookupMsg2 = Message.Deserialize(bytes) as LookupMessage;
Assert.IsNotNull(lookupMsg2);
Assert.AreEqual(lookupMsg.MessageType, lookupMsg2.MessageType);
Assert.AreEqual(lookupMsg.VersionM, lookupMsg2.VersionM);
Assert.AreEqual(lookupMsg.VersionN, lookupMsg2.VersionN);
Assert.AreEqual(lookupMsg.FileId, lookupMsg2.FileId);
var gotMsg = new GotMessage(9, 9, FileId1);
bytes = gotMsg.Serialize();
var gotMsg2 = Message.Deserialize(bytes) as GotMessage;
Assert.IsNotNull(gotMsg2);
Assert.AreEqual(gotMsg.MessageType, gotMsg2.MessageType);
Assert.AreEqual(gotMsg.VersionM, gotMsg2.VersionM);
Assert.AreEqual(gotMsg.VersionN, gotMsg2.VersionN);
Assert.AreEqual(gotMsg.FileId, gotMsg2.FileId);
var ackMsg = new ACKMessage(9, 9, FileId1, 999999);
bytes = ackMsg.Serialize();
var ackMsg2 = Message.Deserialize(bytes) as ACKMessage;
Assert.IsNotNull(ackMsg2);
Assert.AreEqual(ackMsg.MessageType, ackMsg2.MessageType);
Assert.AreEqual(ackMsg.VersionM, ackMsg2.VersionM);
Assert.AreEqual(ackMsg.VersionN, ackMsg2.VersionN);
Assert.AreEqual(ackMsg.FileId, ackMsg2.FileId);
Assert.AreEqual(ackMsg.ChunkNo, ackMsg2.ChunkNo);
}
public void AddWarning(long X, long Y, string msg, FixChunkDelegate FixMethod)
{
ChunkMessage cm = new ChunkMessage(ChunkMessageType.WARNING, X, Y, msg, FixMethod);
Messages.Add(cm);
}
public void AddInfo(long X, long Y, string msg, FixChunkDelegate FixMethod)
{
ChunkMessage cm = new ChunkMessage(ChunkMessageType.INFO, X, Y, msg, FixMethod);
Messages.Add(cm);
}
public void AddError(long X, long Y, string msg, FixChunkDelegate FixMethod)
{
ChunkMessage cm = new ChunkMessage(ChunkMessageType.ERROR, X, Y, msg, FixMethod);
Messages.Add(cm);
}
public Task Run()
{
Core.Instance.Log.InfoFormat("Starting EnhancedRestoreChunkProtocol: {0}", _fileChunk);
return(Task.Factory.StartNew(() =>
{
Core.Instance.MCChannel.Send(new GetChunkMessage(_fileChunk));
var src1 = Core.Instance.MDRChannel.Received
.Where(message => message.MessageType == MessageType.Chunk)
.Cast <ChunkMessage>()
.Where(message => message.ChunkNo == _fileChunk.ChunkNo &&
message.FileId == _fileChunk.FileId)
.Cast <Message>();
var src2 = Core.Instance.MDRChannel.Received
.Where(message => message.MessageType == MessageType.ACK)
.Cast <ACKMessage>()
.Where(message => message.ChunkNo == _fileChunk.ChunkNo &&
message.FileId == _fileChunk.FileId)
.Cast <Message>();
Message msg;
try
{
// wait for response
msg = src1.Merge(src2).Timeout(TimeSpan.FromMilliseconds(Timeout))
.Next().First();
}
catch (TimeoutException)
{
Core.Instance.Log.ErrorFormat("EnhancedRestoreChunkProtocol: Could not fetch {0} from the network (timeout).", _fileChunk);
return;
}
if (msg.MessageType == MessageType.Chunk) // same behaviour as the regular protocol
{
Message = msg as ChunkMessage;
return;
}
var ackMessage = msg as ACKMessage;
if (ackMessage == null)
{
Core.Instance.Log.ErrorFormat("EnhancedRestoreChunkProtocol: could not cast message {0} to ACK", msg);
return;
}
var listener = new TcpListener(IPAddress.Any, 0);
listener.Start();
Core.Instance.MCChannel.Send(new ConnInfoMessage(_fileChunk, ((IPEndPoint)listener.LocalEndpoint).Port,
ackMessage.RemoteEndPoint.Address));
var clientTask = listener.AcceptTcpClientAsync();
if (!clientTask.Wait(Timeout))
{
Core.Instance.Log.Error("EnhancedRestoreChunkProtocol: listener.AcceptTcpClientAsync timed out");
return;
}
Core.Instance.Log.Info("EnhancedRestoreChunkProtocol: TcpClient accepted");
try
{
var stream = clientTask.Result.GetStream();
var bytes = new byte[Core.Instance.Config.ChunkSize];
var bytesRead = stream.Read(bytes, 0, bytes.Length);
Message = new ChunkMessage(_fileChunk, bytes.Take(bytesRead).ToArray());
clientTask.Result.Close();
}
catch (Exception)
{
Core.Instance.Log.Error("EnhancedRestoreChunkProtocol: error receiving chunk");
}
Core.Instance.Log.Info("EnhancedRestoreChunkProtocol: chunk was received with success");
}));
}
