public static List <FileModel> RequestVersionMissingFiles(ref InstallationDataModel version)
{
PatchDataModel model = new PatchDataModel()
{
RequestType = PatchNetworkRequest.MissingFiles,
InstalledVersion = version
};
ConnectionHandler.SendObject(model, _client);
PatchDataModel response = ReadServerResponse();
if (response != null)
{
version.MissingFiles = response.InstalledVersion.MissingFiles;
version.VersionName = response.InstalledVersion.VersionName;
version.TotalSize = response.InstalledVersion.TotalSize;
version.RemainingSize = response.InstalledVersion.RemainingSize;
if (version.MissingFiles.Count > 0 && version.Status != InstallationStatus.NotInstalled)
{
version.Status = InstallationStatus.UpdateRequired;
}
return(response.InstalledVersion.MissingFiles);
}
else
{
return(null);
}
}
public static async Task <List <FileModel> > RequestVersionMissingFilesAsync(InstallationDataModel version)
{
PatchDataModel model = new PatchDataModel()
{
RequestType = PatchNetworkRequest.MissingFiles,
InstalledVersion = version
};
await ConnectionHandler.SendObjectAsync(model, _client);
PatchDataModel response = await ReadServerResponseAsync();
if (response != null)
{
version.MissingFiles = response.InstalledVersion.MissingFiles;
if (version.MissingFiles.Count > 0 && version.Status != InstallationStatus.NotInstalled)
{
version.Status = InstallationStatus.UpdateRequired;
}
return(response.InstalledVersion.MissingFiles);
}
else
{
return(null);
}
}
//public static void RequestVerifyVersions()
//{
// foreach (var item in InstalledVersions)
// {
// RequestVerifyVersion(ref item);
// }
//}
public static bool RequestVerifyVersion(ref InstallationDataModel versionData)
{
PatchDataModel model = new PatchDataModel()
{
RequestType = PatchNetworkRequest.VerifyVersion,
InstalledVersion = new InstallationDataModel()
{
VersionName = versionData.VersionName,
VersionBranch = versionData.VersionBranch,
InstallationChecksum = versionData.InstallationChecksum
}
};
ConnectionHandler.SendObject(model, _client);
PatchDataModel response = ReadServerResponse();
if (response != null)
{
if (response.InstalledVersion.Status == InstallationStatus.Verified)
{
versionData.Status = response.InstalledVersion.Status;
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
private void SendFilesToClientStream(TcpClient client, PatchDataModel data)
{
var temp = masterFiles.FirstOrDefault(x => x.VersionBranch == data.InstalledVersion.VersionBranch);
if (temp != null)
{
string path = "";
for (int i = 0; i < data.InstalledVersion.MissingFiles.Count; i++)
{
path = temp.InstallPath + '/' + data.InstalledVersion.MissingFiles[i].FilePath;
FileInfo fi = new FileInfo(path);
byte[] preBuffer = BitConverter.GetBytes((int)fi.Length);
//client.GetStream().Write(preBuffer);
Console.WriteLine(ConsoleExtension.AddTimestamp($"{fi.Name} size: {fi.Length}"));
client.Client.SendFile(fi.FullName, preBuffer, null, TransmitFileOptions.UseDefaultWorkerThread);
Console.WriteLine(ConsoleExtension.AddTimestamp($"{fi.Name} sent"));
}
}
else
{
Console.WriteLine(ConsoleExtension.AddTimestamp($"{data.File.FilePath} was not found under version: {data.InstalledVersion.VersionName}"));
}
}
private void SendMissingFilesList(TcpClient client, PatchDataModel data)
{
//Find the requested version
var temp = masterFiles.FirstOrDefault(x => x.VersionBranch == data.InstalledVersion.VersionBranch);
List <string> missingFiles = new List <string>();
if (temp != null)
{
Console.WriteLine(ConsoleExtension.AddTimestamp("List found"));
//Check which files are missing/mismatched
missingFiles = ChecksumTool.CompareFileDictionaries(temp.GetFilesAsDictionary(), data.InstalledVersion.GetFilesAsDictionary());
Console.WriteLine(ConsoleExtension.AddTimestamp("Missing files found: " + missingFiles.Count));
string dir = ChecksumTool.RootedPathCheck(temp.InstallPath);
Console.WriteLine(ConsoleExtension.AddTimestamp("Dir: " + dir));
data.InstalledVersion = GenerateInstallationDataModel(missingFiles, dir);
data.InstalledVersion.VersionName = temp.VersionName;
data.InstalledVersion.VersionBranch = temp.VersionBranch;
Console.WriteLine(ConsoleExtension.AddTimestamp("Installation datamodel created: " + data.InstalledVersion.VersionName));
ConnectionHandler.SendObject(data, client);
return;
}
data.InstalledVersion.Files.Clear();
data.Message = "Version doesn't exist on server";
ConnectionHandler.SendObject(data, client);
Console.WriteLine(ConsoleExtension.AddTimestamp("Requested version does not exist on the server!"));
}
private void SendVersionVerification(TcpClient client, PatchDataModel data)
{
//Check if the versions combined checksum matches that of the server
var temp = masterFiles.FirstOrDefault(x => x.VersionBranch == data.InstalledVersion.VersionBranch);
if (temp != null)
{
if (temp.InstallationChecksum == data.InstalledVersion.InstallationChecksum)
{
data.InstalledVersion.Status = InstallationStatus.Verified;
ConnectionHandler.SendObject(data, client);
Console.WriteLine(ConsoleExtension.AddTimestamp("Installation checksum matched and " + data.InstalledVersion.VersionName + " was VERIFIED"));
return;
}
else
{
data.InstalledVersion.Status = InstallationStatus.UpdateRequired;
Console.WriteLine(ConsoleExtension.AddTimestamp("Installation checksum did NOT match and " + data.InstalledVersion.VersionName + " was NOT VERIFIED"));
Console.WriteLine(ConsoleExtension.AddTimestamp($"Incoming checksum is: {data.InstalledVersion.InstallationChecksum}\nServer checksum is: {temp.InstallationChecksum})"));
ConnectionHandler.SendObject(data, client);
}
}
else
{
Console.WriteLine(ConsoleExtension.AddTimestamp("Version: " + data.InstalledVersion.VersionName + " NOT FOUND"));
ConnectionHandler.SendObject(data, client);
return;
}
}
public static void DownloadMissingFilesNew(InstallationDataModel version)
{
_client = new TcpClient(_ip, _port);
if (version.MissingFiles.Count == 0)
{
version = ChecksumTool.RecheckVersion(version);
RequestVersionMissingFiles(ref version);
}
DownloadProgressEventArgs args = new DownloadProgressEventArgs();
PatchDataModel model = new PatchDataModel()
{
RequestType = PatchNetworkRequest.DownloadFiles,
InstalledVersion = new InstallationDataModel
{
VersionName = version.VersionName,
VersionBranch = version.VersionBranch,
MissingFiles = version.MissingFiles
}
};
args.Version = version.VersionBranch;
args.TotalSize = version.TotalSize;
ConnectionHandler.SendObject(model, _client);
_downloadingFiles = true;
//While there's still files missing and there's still an active connection
while (version.MissingFiles.Count > 0 && ConnectionHandler.Connected(_client))
{
if (_client.GetStream().DataAvailable)
{
//Raise download progress event
args.NextFileName = version.MissingFiles[0].FilePath;
OnDownloadProgress(args);
//Handle incoming file
// await ConnectionHandler.ReadFileAsync(_client, version.MissingFiles[0].FilePath, InstallPath + '/' + version.VersionName);
ConnectionHandler.ReadFileStream(_client, version.MissingFiles[0].FilePath, version.MissingFiles[0].Size, version.InstallPath);
Console.WriteLine(ConsoleExtension.AddTimestamp(version.MissingFiles[0].FilePath + " downloaded"));
args.DownloadedTotal += version.MissingFiles[0].Size;
lock (version)
version.MissingFiles.RemoveAt(0);
}
}
_downloadingFiles = false;
Console.WriteLine(ConsoleExtension.AddTimestamp("All missing files received!"));
version = ChecksumTool.RecheckVersion(version);
RequestVerifyVersion(ref version);
_client.GetStream().Close();
_client.Close();
DownloadDone?.Invoke(version);
}
private void SendAvailableVersions(TcpClient client)
{
PatchDataModel model = new PatchDataModel()
{
RequestType = PatchNetworkRequest.AvailableVersions,
AvailableBranches = versions
};
byte[] data = ConnectionHandler.ConvertToBytes <PatchDataModel>(model);
client.GetStream().Write(data, 0, data.Length);
}
private void SendTestConnectionResponse(TcpClient client)
{
PatchDataModel model = new PatchDataModel()
{
RequestType = PatchNetworkRequest.TestConnection,
Connected = true,
Message = "You're in!"
};
byte[] data = ConnectionHandler.ConvertToBytes <PatchDataModel>(model);
client.GetStream().Write(data, 0, data.Length);
}
/// <summary>
/// Generates model data for each version installed on the path
/// </summary>
//public static void UpdateCurrentInstallations () {
// InstalledVersions = ChecksumTool.GetInstalledVersions(InstallPath);
//}
/// <summary>
/// Listens for responses from the patching service after connecting
/// </summary>
private static PatchDataModel ReadServerResponse()
{
while (ConnectionHandler.Connected(_client))
{
if (_client.GetStream().DataAvailable)
{
PatchDataModel data = JsonConvert.DeserializeObject <PatchDataModel>(ConnectionHandler.ReadMessage(_client.GetStream()));
return(data);
}
Thread.Sleep(16);
}
return(null);
}
public void HandleClientConnection(TcpClient client)
{
//While the client is still connected, await communication
while (ConnectionHandler.Connected(client))
{
//Wait for data from client
if (client.GetStream().DataAvailable)
{
Console.WriteLine(ConsoleExtension.AddTimestamp("Recieving request"));
PatchDataModel data = JsonConvert.DeserializeObject <PatchDataModel>(ConnectionHandler.ReadMessage(client.GetStream()));
switch (data.RequestType)
{
case PatchNetworkRequest.AvailableVersions:
SendAvailableVersions(client);
Console.WriteLine(ConsoleExtension.AddTimestamp("Versions send to client"));
break;
case PatchNetworkRequest.VerifyVersion:
SendVersionVerification(client, data);
break;
case PatchNetworkRequest.MissingFiles:
SendMissingFilesList(client, data);
break;
case PatchNetworkRequest.DownloadFile:
SendFileToClient(client, data);
break;
case PatchNetworkRequest.DownloadFiles:
SendFilesToClientStream(client, data);
break;
case PatchNetworkRequest.TestConnection:
SendTestConnectionResponse(client);
Console.WriteLine(ConsoleExtension.AddTimestamp("Send test response to client"));
break;
}
}
Thread.Sleep(30);
}
lock (clients)
{
clients.Remove(client);
Console.WriteLine(ConsoleExtension.AddTimestamp("Client disconnected"));
}
}
//public static void RequestVerifyVersion(string versionName)
//{
// var temp = InstalledVersions.FirstOrDefault(x => x.VersionName == versionName);
// if (temp != null)
// {
// RequestVerifyVersion(temp);
// }
//}
private static void HandleVerifyVersionResponse(PatchDataModel data)
{
if (data.InstalledVersion.Status == InstallationStatus.Verified)
{
var temp = InstalledVersions.FirstOrDefault(x => x.VersionName == data.InstalledVersion.VersionName);
if (temp != null)
{
temp.Status = InstallationStatus.Verified;
Console.WriteLine(ConsoleExtension.AddTimestamp(temp.VersionName + " was verified by server"));
}
}
else
{
Console.WriteLine(ConsoleExtension.AddTimestamp(data.InstalledVersion.VersionName + " was NOT verified by server"));
}
VersionVerificationDone?.Invoke();
}
public static string[] RequestAvailableVersions()
{
PatchDataModel model = new PatchDataModel()
{
RequestType = PatchNetworkRequest.AvailableVersions
};
ConnectionHandler.SendObject(model, _client);
Console.WriteLine(ConsoleExtension.AddTimestamp("Version request send to server"));
PatchDataModel response = ReadServerResponse();
if (response != null)
{
return(response.AvailableBranches);
}
else
{
return(new string[0]);
}
}
private static async Task <PatchDataModel> ReadServerResponseAsync()
{
PatchDataModel data = JsonConvert.DeserializeObject <PatchDataModel>(await ConnectionHandler.ReadMessageAsync(_client.GetStream()));
return(data);
}
