private async Task ProcessGetFileCmd(CommandHeader cmdHeader)
{
var data = await NetworkHelperSequential.Read <GetFileCommandData>(_networkStream, cmdHeader.PayloadLength);
var ret = new ServerResponse();
var session = SessionStorage.Instance.GetSession(data.SessionId);
if (session == null)
{
ret.ErrorMsg = "Session does not exist";
}
else if (session.Expired)
{
ret.ErrorMsg = "Session has expired";
//Log?.Invoke("Session has expired");
//return ret;
}
else
{
data.RelativeFilePath = PathHelpers.NormalizeRelative(data.RelativeFilePath);
Msg?.Invoke($"Sending '{data.RelativeFilePath}'");
var filePath = Path.Combine(session.BaseDir, data.RelativeFilePath);
var fileLength = new FileInfo(filePath).Length;
var fileLengthBytes = BitConverter.GetBytes(fileLength);
await NetworkHelperSequential.WriteCommandHeader(_networkStream, Commands.GetFileCmd, sizeof(long));
await NetworkHelperSequential.WriteBytes(_networkStream, fileLengthBytes);
await NetworkHelperSequential.WriteFromFileAndHashAsync(_networkStream, filePath, (int)fileLength);
}
}
private async Task ProcessFinishSessionCmd(CommandHeader cmdHeader)
{
var sessionId = await NetworkHelperSequential.Read <Guid>(_networkStream, cmdHeader.PayloadLength);
var response = new ServerResponseWithData <SyncInfo>();
var session = SessionStorage.Instance.GetSession(sessionId);
if (session == null)
{
response.ErrorMsg = "Session does not exist";
}
else if (session.Expired)
{
response.ErrorMsg = "Session has expired";
//Log?.Invoke("Session has expired");
//return ret;
}
else
{
try
{
FinishSession(session);
}
catch (Exception e)
{
response.ErrorMsg = e.ToString();
}
//session.SyncDb = SyncDatabase.Initialize(session.BaseDir, session.SyncDbDir);
session.SyncDb.Store(session.SyncDbDir);
}
await CommandHelper.WriteCommandResponse(_networkStream, Commands.FinishSessionCmd, response);
}
private async Task ProcessSendFileCmd(CommandHeader cmdHeader)
{
var data = await NetworkHelperSequential.Read <SendFileCommandData>(_networkStream, cmdHeader.PayloadLength);
var ret = new ServerResponse();
var session = SessionStorage.Instance.GetSession(data.SessionId);
if (session == null)
{
ret.ErrorMsg = "Session does not exist";
}
else if (session.Expired)
{
ret.ErrorMsg = "Session has expired";
Msg?.Invoke("Session has expired");
}
else
{
data.RelativeFilePath = PathHelpers.NormalizeRelative(data.RelativeFilePath);
var filePath = Path.Combine(session.NewDir, data.RelativeFilePath);
var fileDir = Path.GetDirectoryName(filePath);
PathHelpers.EnsureDirExists(fileDir);
Msg?.Invoke($"Receiving file '{data.RelativeFilePath}'");
var newHash = await NetworkHelperSequential.ReadToFileAndHashAsync(_networkStream, filePath, data.FileLength);
var fileInfo = session.SyncDb.Files.FirstOrDefault(i => i.RelativePath == data.RelativeFilePath);
if (fileInfo != null)
{
fileInfo.HashStr = newHash.ToHashString();
fileInfo.State = SyncFileState.NotChanged;
}
else
{
session.SyncDb.AddFile(session.BaseDir, data.RelativeFilePath, newHash.ToHashString());
}
}
}
private async Task ProcessGetSyncListCmd(CommandHeader cmdHeader)
{
var data = await NetworkHelperSequential.Read <GetSyncListCommandData>(_networkStream, cmdHeader.PayloadLength);
var ret = new ServerResponseWithData <SyncInfo>();
var session = SessionStorage.Instance.GetSession(data.SessionId);
if (session == null)
{
ret.ErrorMsg = "Session does not exist";
}
else if (session.Expired)
{
ret.ErrorMsg = "Session has expired";
//Log?.Invoke("Session has expired");
//return ret;
}
else
{
Msg?.Invoke("Scanning local folder...");
var syncDb = GetSyncDb(session.BaseDir, session.SyncDbDir, out var error);
if (syncDb == null)
{
ret.ErrorMsg = error;
Msg?.Invoke($"Failed to get sync db: {error}");
}
else
{
var syncInfo = new SyncInfo();
PathHelpers.NormalizeRelative(data.Files);
Msg?.Invoke("Preparing sync list...");
foreach (var localFileInfo in syncDb.Files)
{
var remoteFileInfo = data.Files.FirstOrDefault(remoteFile =>
remoteFile.RelativePath == localFileInfo.RelativePath);
if (remoteFileInfo == null)
{
if (localFileInfo.State != SyncFileState.Deleted)
{
syncInfo.ToDownload.Add(localFileInfo);
}
}
else
{
data.Files.Remove(remoteFileInfo);
switch (remoteFileInfo.State)
{
case SyncFileState.Deleted:
if (localFileInfo.State == SyncFileState.NotChanged ||
localFileInfo.State == SyncFileState.Deleted)
{
var filePath = Path.Combine(session.BaseDir, localFileInfo.RelativePath);
if (File.Exists(filePath))
{
var movedFilePath = Path.Combine(session.RemovedDir, localFileInfo.RelativePath);
var movedFileDir = Path.GetDirectoryName(movedFilePath);
if (movedFileDir == null)
{
throw new InvalidOperationException($"Unable to get '{movedFilePath}'s dir");
}
if (!Directory.Exists(movedFileDir))
{
Directory.CreateDirectory(movedFileDir);
}
File.Move(filePath, movedFilePath);
}
}
else if (localFileInfo.State == SyncFileState.New)
{
syncInfo.ToDownload.Add(localFileInfo);
}
else
{
syncInfo.Conflicts.Add(localFileInfo);
}
break;
case SyncFileState.New:
syncInfo.Conflicts.Add(localFileInfo);
break;
case SyncFileState.Modified:
if (localFileInfo.State == SyncFileState.NotChanged)
{
syncInfo.ToUpload.Add(localFileInfo);
}
else
{
syncInfo.Conflicts.Add(remoteFileInfo);
}
break;
case SyncFileState.NotChanged:
if (localFileInfo.State == SyncFileState.Modified)
{
syncInfo.ToDownload.Add(localFileInfo);
}
else if (localFileInfo.State == SyncFileState.Deleted)
{
syncInfo.ToRemove.Add(remoteFileInfo);
}
else if (localFileInfo.State == SyncFileState.New)
{
Debugger.Break(); // not possible
}
break;
}
}
}
foreach (var remoteFileInfo in data.Files.Where(x => x.State != SyncFileState.Deleted))
{
syncInfo.ToUpload.Add(remoteFileInfo);
}
ret.Data = syncInfo;
session.SyncDb = syncDb;
}
}
await CommandHelper.WriteCommandResponse(_networkStream, Commands.GetSyncListCmd, ret);
}
