private void ReportUploadProgress(object sender, ProgressModel e)
{
if (UploadProgressList.Count > 0 && (UploadProgressList.Where(p => p.Filename.Equals(e.Filename)).ToList().Count > 0))
{
UploadProgressList.Where(p => p.Filename.Equals(e.Filename)).First().PctCompleted = e.PctCompleted;
}
}
// Other methods
// Initiate progress bar for file upload/download
private void InitProgress(out ProgressModel progModel, out Progress <ProgressModel> progress, string filename, ActionType actionType)
{
lock (this)
{
progModel = new ProgressModel()
{
PctCompleted = 0, Filename = filename
};
progress = new Progress <ProgressModel>();
if (actionType == ActionType.Upload)
{
AddOnUI(UploadProgressList, progModel);
progress.ProgressChanged += ReportUploadProgress;
}
else if (actionType == ActionType.Download)
{
AddOnUI(DownloadProgressList, progModel);
progress.ProgressChanged += ReportDownloadProgress;
}
}
}
// Download a file from the shared drive
private void DownloadFile(string fileToDownload, IProgress <ProgressModel> progress)
{
NetworkStream networkStream = null;
FileStream fileStream = null;
try
{
var report = new ProgressModel()
{
PctCompleted = 0, Filename = fileToDownload
};
var socket = new TcpClient(ServerIPAddress, ServerPortNumber);
networkStream = socket.GetStream();
// Send request
var request_bytes = BitConverter.GetBytes((int)RequestType.DownloadFile);
networkStream.Write(request_bytes, 0, request_bytes.Length);
// Create and send request header
var clientHeader = new ClientDownloadFileHeader()
{
Filename = fileToDownload
};
var clientHeaderBytes = SerializationMethods.Serialize(clientHeader);
var clientHeaderLengthBytes = BitConverter.GetBytes(clientHeaderBytes.Length);
networkStream.Write(clientHeaderLengthBytes, 0, clientHeaderLengthBytes.Length);
networkStream.Write(clientHeaderBytes, 0, clientHeaderBytes.Length);
// Check server response
var responseBytes = new byte[sizeof(int)];
networkStream.Read(responseBytes, 0, responseBytes.Length);
var response = BitConverter.ToInt32(responseBytes, 0);
if (response == (int)ResponeType.Failure)
{
throw new FileDownloadException();
}
// Receive server header
var serverHeaderSizeBytes = new byte[sizeof(int)];
networkStream.Read(serverHeaderSizeBytes, 0, serverHeaderSizeBytes.Length);
var serverHeaderBytes = new byte[BitConverter.ToInt32(serverHeaderSizeBytes, 0)];
networkStream.Read(serverHeaderBytes, 0, serverHeaderBytes.Length);
var serverHeader = (ServerDownloadFileHeader)SerializationMethods.Deserialize(serverHeaderBytes);
var receivedBlockBuffer = new byte[BlockSize];
fileStream = File.OpenWrite(DownloadDirectory + fileToDownload);
int totalBytesRead = 0;
var fileSize = serverHeader.FileSize;
while (totalBytesRead < fileSize)
{
var buffer = new byte[BlockSize];
var bytesRead = networkStream.Read(buffer, 0, buffer.Length);
totalBytesRead += bytesRead;
fileStream.Write(buffer, 0, bytesRead);
var bytesReadRatio = (double)totalBytesRead / serverHeader.FileSize;
report.PctCompleted = (int)(bytesReadRatio * 100);
progress.Report(report);
}
}
catch (FileDownloadException)
{
MessageBox.Show("The requested file cannot be downloaded at this time");
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
finally
{
if (fileStream != null)
{
fileStream.Close();
}
networkStream.Close();
}
}
// Upload a file to the shared drive
public void UploadFile(string fullPath, string filename, IProgress <ProgressModel> progress)
{
try
{
var report = new ProgressModel()
{
PctCompleted = 0, Filename = filename
};
var fileSize = (int)new FileInfo(fullPath).Length;
int numBlocks = fileSize / BlockSize;
int lastBlockSize = fileSize % BlockSize;
// Header to be sent to the server
var fileHeader = new ClientUploadFileHeader()
{
Filename = filename,
FileSize = fileSize,
NumBlocks = numBlocks,
LastBlockSize = lastBlockSize
};
// Connect to server
var clientSocket = new TcpClient(ServerIPAddress, ServerPortNumber);
var networkStream = clientSocket.GetStream();
// Convert data to byte arrays, then write to network stream
var uploadRequestBytes = BitConverter.GetBytes((int)RequestType.UploadFile);
var headerBytes = SerializationMethods.Serialize(fileHeader);
var headerLenBytes = BitConverter.GetBytes(headerBytes.Length);
networkStream.Write(uploadRequestBytes, 0, uploadRequestBytes.Length);
networkStream.Write(headerLenBytes, 0, headerLenBytes.Length);
networkStream.Write(headerBytes, 0, headerBytes.Length);
var fstream = File.OpenRead(fullPath);
for (int i = 0; i < numBlocks; i++)
{
var file_data = new byte[BlockSize];
fstream.Seek(i * BlockSize, SeekOrigin.Begin);
fstream.Read(file_data, 0, file_data.Length);
networkStream.Write(file_data, 0, file_data.Length);
report.PctCompleted = (i + 1) * 100 / numBlocks;
progress.Report(report);
}
if (lastBlockSize > 0)
{
var file_data = new byte[lastBlockSize];
fstream.Seek(numBlocks * BlockSize, SeekOrigin.Begin);
fstream.Read(file_data, 0, file_data.Length);
networkStream.Write(file_data, 0, file_data.Length);
}
fstream.Dispose();
// Check if upload was successful
var responeBuffer = new byte[sizeof(int)];
var read = networkStream.Read(responeBuffer, 0, responeBuffer.Length);
var responseType = BitConverter.ToInt32(responeBuffer, 0);
if (responseType == (int)ResponeType.Failure)
{
throw new Exception("Error uploading file, try again");
}
networkStream.Close();
RefreshList();
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
