/// <summary>
/// Loads the manifest from disk.
/// </summary>
private void LoadManifest()
{
try
{
lock (ManifestLock)
{
if (File.Exists(ConfigHandler.GetManifestPath()))
{
string[] rawManifest = File.ReadAllLines(ConfigHandler.GetManifestPath());
foreach (string rawEntry in rawManifest)
{
ManifestEntry newEntry = new ManifestEntry();
if (ManifestEntry.TryParse(rawEntry, out newEntry))
{
manifest.Add(newEntry);
}
}
}
}
}
catch (IOException ioex)
{
Console.WriteLine("IOException in LoadManifest(): " + ioex.Message);
}
}
/// <summary>
/// Downloads the manifest.
/// </summary>
public void DownloadManifest()
{
Stream manifestStream = null;
try
{
FTPHandler FTP = new FTPHandler();
string remoteChecksum = FTP.GetRemoteManifestChecksum();
string localChecksum = "";
string RemoteURL = Config.GetManifestURL();
string LocalPath = ConfigHandler.GetManifestPath();
if (File.Exists(ConfigHandler.GetManifestPath()))
{
manifestStream = File.OpenRead(ConfigHandler.GetManifestPath());
localChecksum = MD5Handler.GetFileHash(manifestStream);
if (!(remoteChecksum == localChecksum))
{
//Copy the old manifest so that we can compare them when updating the game
File.Copy(LocalPath, LocalPath + ".old", true);
FTP.DownloadFTPFile(RemoteURL, LocalPath, false);
}
}
else
{
FTP.DownloadFTPFile(RemoteURL, LocalPath, false);
}
}
catch (IOException ioex)
{
Console.WriteLine("IOException in DownloadManifest(): " + ioex.Message);
}
finally
{
if (manifestStream != null)
{
manifestStream.Close();
}
}
}
/// <summary>
/// Determines whether the manifest is outdated.
/// </summary>
/// <returns><c>true</c> if the manifest is outdated; otherwise, <c>false</c>.</returns>
public bool IsManifestOutdated()
{
if (File.Exists(ConfigHandler.GetManifestPath()))
{
FTPHandler FTP = new FTPHandler();
string manifestURL = Config.GetManifestURL();
string remoteHash = FTP.ReadFTPFile(manifestURL);
string localHash = MD5Handler.GetFileHash(File.OpenRead(ConfigHandler.GetManifestPath()));
if (remoteHash != localHash)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
private void RepairGameAsync()
{
//This value is filled with either a path to the last downloaded file, or with an exception message
//this message is used in the main UI to determine how it responds to a failed download.
string repairMetadata = "";
try
{
//check all local file MD5s against latest manifest. Resume partial files, download broken files.
FTPHandler FTP = new FTPHandler();
//bind event handlers
FTP.FileProgressChanged += OnDownloadProgressChanged;
//first, verify that the manifest is correct.
string LocalManifestHash = MD5Handler.GetFileHash(File.OpenRead(ConfigHandler.GetManifestPath()));
string RemoteManifestHash = FTP.GetRemoteManifestChecksum();
//if it is not, download a new copy.
if (!(LocalManifestHash == RemoteManifestHash))
{
LauncherHandler Launcher = new LauncherHandler();
Launcher.DownloadManifest();
}
//then, begin repairing the game
ManifestHandler manifestHandler = new ManifestHandler();
List <ManifestEntry> Manifest = manifestHandler.Manifest;
ProgressArgs.TotalFiles = Manifest.Count;
int i = 0;
foreach (ManifestEntry Entry in Manifest)
{
string RemotePath = String.Format("{0}{1}",
Config.GetGameURL(true),
Entry.RelativePath);
string LocalPath = String.Format("{0}{1}",
Config.GetGamePath(true),
Entry.RelativePath);
ProgressArgs.FileName = Path.GetFileName(LocalPath);
//make sure the directory for the file exists
Directory.CreateDirectory(Directory.GetParent(LocalPath).ToString());
if (File.Exists(LocalPath))
{
FileInfo fileInfo = new FileInfo(LocalPath);
if (fileInfo.Length != Entry.Size)
{
//Resume the download of this partial file.
OnProgressChanged();
repairMetadata = FTP.DownloadFTPFile(RemotePath, LocalPath, fileInfo.Length, false);
//Now verify the file
string localHash = MD5Handler.GetFileHash(File.OpenRead(LocalPath));
if (localHash != Entry.Hash)
{
Console.WriteLine("RepairGameAsync: Resumed file hash was invalid, downloading fresh copy from server.");
//download the file, since it was broken
OnProgressChanged();
repairMetadata = FTP.DownloadFTPFile(RemotePath, LocalPath, false);
}
}
}
else
{
//download the file, since it was missing
OnProgressChanged();
repairMetadata = FTP.DownloadFTPFile(RemotePath, LocalPath, false);
}
if (ChecksHandler.IsRunningOnUnix())
{
//if we're dealing with a file that should be executable,
string gameName = Config.GetGameName();
bool bFileIsGameExecutable = (Path.GetFileName(LocalPath).EndsWith(".exe")) || (Path.GetFileNameWithoutExtension(LocalPath) == gameName);
if (bFileIsGameExecutable)
{
//set the execute bits.
UnixHandler.MakeExecutable(LocalPath);
}
}
++i;
ProgressArgs.DownloadedFiles = i;
OnProgressChanged();
}
OnGameRepairFinished();
//clear out the event handler
FTP.FileProgressChanged -= OnDownloadProgressChanged;
}
catch (IOException ioex)
{
Console.WriteLine("IOException in RepairGameAsync(): " + ioex.Message);
DownloadFailedArgs.Result = "1";
DownloadFailedArgs.ResultType = "Repair";
DownloadFailedArgs.Metadata = repairMetadata;
OnGameRepairFailed();
}
}