/// <summary>
/// Process message once status is received by moving document to the
/// appropriate folder and writing out a log for the processed document
/// </summary>
/// <param name="executionStatus">Execution status</param>
/// <param name="dataMessage">Name of the file whose status is being processed</param>
private void PostProcessMessage(string executionStatus, DataMessage dataMessage)
{
switch (executionStatus)
{
case "Succeeded":
{
// Move message file and delete processing status file
var processingSuccessDestination = Path.Combine(_settings.ProcessingSuccessDir, dataMessage.Name);
_retryPolicyForIo.Execute(() => FileOperationsHelper.MoveDataToTarget(dataMessage.FullPath, processingSuccessDestination, true, _settings.StatusFileExtension));
CreateLinkToExecutionSummaryPage(dataMessage.MessageId, processingSuccessDestination);
}
break;
case "Unknown":
case "PartiallySucceeded":
case "Failed":
case "Canceled":
{
var processingErrorDestination = Path.Combine(_settings.ProcessingErrorsDir, dataMessage.Name);
_retryPolicyForIo.Execute(() => FileOperationsHelper.MoveDataToTarget(dataMessage.FullPath, processingErrorDestination, true, _settings.StatusFileExtension));
CreateLinkToExecutionSummaryPage(dataMessage.MessageId, processingErrorDestination);
}
break;
default: //"NotRun", "Executing"
break;
}
}
/// <summary>
/// Process message once status is received by moving document to the
/// appropriate folder and writing out a log for the processed document
/// </summary>
/// <param name="jobStatusDetail">DataJobStatusDetail object</param>
/// <param name="dataMessage">Name of the file whose status is being processed</param>
private void PostProcessMessage(DataJobStatusDetail jobStatusDetail, DataMessage dataMessage)
{
if (jobStatusDetail?.DataJobStatus == null)
{
return;
}
dataMessage.DataJobState = jobStatusDetail.DataJobStatus.DataJobState;
FileOperationsHelper.WriteStatusFile(dataMessage, _settings.StatusFileExtension);
switch (dataMessage.DataJobState)
{
case DataJobState.Processed:
{
// Move message file and delete processing status file
FileOperationsHelper.MoveDataToTarget(dataMessage.FullPath, Path.Combine(_settings.ProcessingSuccessDir, dataMessage.Name), true);
}
break;
case DataJobState.PostProcessError:
case DataJobState.PreProcessError:
case DataJobState.ProcessedWithErrors:
{
var targetDataMessage = new DataMessage(dataMessage)
{
FullPath = Path.Combine(_settings.ProcessingErrorsDir, dataMessage.Name),
MessageStatus = MessageStatus.Failed
};
FileOperationsHelper.MoveDataToTarget(dataMessage.FullPath, targetDataMessage.FullPath);
FileOperationsHelper.WriteStatusLogFile(jobStatusDetail, targetDataMessage, null, _settings.StatusFileExtension);
}
break;
}
}
private void CreateBackup()
{
var relativeFilePaths = GetRelativeBackupFilePaths();
var absoluteSourcePaths = relativeFilePaths.Select(fp => Path.Combine(_gamePath, fp)).ToList();
var backupVersion = _gtaVersionProvider.GetCurrentGtaVersion().Build;
var backupName = $"downgrade_{backupVersion}_{GetGtaGameType(_gamePath)}";
var backupPath = Path.Combine(GetBackupPath(), backupName);
var archivePath = Path.Combine(GetBackupPath(), backupName + ".zip");
var totalBackupSize = FileOperationsHelper.CalculateTotalFileSizes(absoluteSourcePaths);
var readableBackupSize = FileOperationsHelper.BytesToReadableString(totalBackupSize);
if (MessageBox.Show($"The backup will take {readableBackupSize} of disk space and might take some minutes. Continue?", "Backup disk usage", MessageBoxButton.YesNoCancel) != MessageBoxResult.Yes)
{
return;
}
_logger.Write($"Backup has started. ( Type = {GetGtaGameType(_gamePath)}, Gta 5 Version = {_gtaVersionProvider.GetCurrentGtaVersion()} )");
FileOperationsHelper.CopyFiles(_gamePath, backupPath, relativeFilePaths);
_logger.Write("Backup has completed.");
_logger.Write("Archiving Backup.");
ZipFile.CreateFromDirectory(backupPath, archivePath, CompressionLevel.NoCompression, false);
Directory.Delete(backupPath, true);
_logger.Write("Archiving completed.");
_notificationService.ShowNotification("Successfully created a backup of your GTA 5 files.");
}
/// <summary>
/// Processes this instance.
/// </summary>
/// <returns></returns>
private async Task Process()
{
InputQueue = new ConcurrentQueue <DataMessage>();
var oneDriveAuthenticationHelper = new OneDriveAuthenticationHelper(
"", // TODO: Client Id of the OneDrive Azure app
"", // TODO: Tenant Id of the OneDrive Azure app
"", // TODO: Username of the user who's OneDrive will be used
"" // TODO: Password for the user
);
// This action will create a GraphClient which later will be user for other OneDrive actions
// I will not be writing any more code about that functionality, since it's not important at the time being
// When creation of GraphClient will be called from here, it will throw an error that Newtonsoft 6.0.0.0 is not being loaded, although it's referenced in the project.
await oneDriveAuthenticationHelper.GetAuthenticatedClient();
foreach (
var dataMessage in FileOperationsHelper.GetFiles(MessageStatus.Input, _settings.InputDir, _settings.SearchPattern, SearchOption.AllDirectories, _settings.OrderBy, _settings.ReverseOrder))
{
if (_settings.LogVerbose || Log.IsDebugEnabled)
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_found_in_input_location, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}")));
}
InputQueue.Enqueue(dataMessage);
}
if (!InputQueue.IsEmpty)
{
Log.InfoFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Found_1_file_s_in_input_folder, _context.JobDetail.Key, InputQueue.Count));
await ProcessInputQueue();
}
}
public frmEthereumAccountDetails(string userFile)
{
InitializeComponent();
UserFile = userFile;
fileHelper = new FileOperationsHelper();
}
public async Task UpdateSelf()
{
var applicationFileName = Path.GetFileName(Assembly.GetExecutingAssembly().Location);
FileOperationsHelper.EnsureFileDirectory(GetUpdateDownloadPath());
if (!await TryDownloadNewLauncher(GetUpdateDownloadPath()))
{
_notificationService.ShowNotification("Failed to download new launcher.", true);
return;
}
if (!await ExtractUpdate(GetUpdateDownloadPath()))
{
_notificationService.ShowNotification("Failed to extract launcher update.", true);
return;
}
var updateBatTargetPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "update.bat");
if (!await TryExtractUpdateBat(updateBatTargetPath))
{
_notificationService.ShowNotification("Failed to perform update.", true);
return;
}
Process.Start(updateBatTargetPath, applicationFileName);
Process.GetCurrentProcess().Kill();
}
/// <summary>
/// Process message once status is received by moving document to the
/// appropriate folder and writing out a log for the processed document
/// </summary>
/// <param name="jobStatusDetail">DataJobStatusDetail object</param>
/// <param name="dataMessage">Name of the file whose status is being processed</param>
/// <param name="cancellationToken">Cancellation token</param>
private async Task PostProcessMessage(DataJobStatusDetail jobStatusDetail, DataMessage dataMessage, CancellationToken cancellationToken)
{
if (jobStatusDetail?.DataJobStatus == null)
{
return;
}
dataMessage.DataJobState = jobStatusDetail.DataJobStatus.DataJobState;
await _retryPolicyForAsyncIo.ExecuteAsync(ct => FileOperationsHelper.WriteStatusFileAsync(dataMessage, _settings.StatusFileExtension, ct), cancellationToken);
switch (dataMessage.DataJobState)
{
case DataJobState.Processed:
{
// Move message file and delete processing status file
_retryPolicyForIo.Execute(() => FileOperationsHelper.MoveDataToTarget(dataMessage.FullPath, Path.Combine(_settings.ProcessingSuccessDir, dataMessage.Name), true));
}
break;
case DataJobState.PostProcessError:
case DataJobState.PreProcessError:
case DataJobState.ProcessedWithErrors:
{
var targetDataMessage = new DataMessage(dataMessage)
{
FullPath = Path.Combine(_settings.ProcessingErrorsDir, dataMessage.Name),
MessageStatus = MessageStatus.Failed
};
_retryPolicyForIo.Execute(() => FileOperationsHelper.MoveDataToTarget(dataMessage.FullPath, targetDataMessage.FullPath));
await _retryPolicyForAsyncIo.ExecuteAsync(ct => FileOperationsHelper.WriteStatusLogFileAsync(jobStatusDetail, targetDataMessage, null, _settings.StatusFileExtension, ct), cancellationToken);
if (_settings.GetExecutionErrors)
{
if (_settings.LogVerbose || Log.IsDebugEnabled)
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Trying_to_download_execution_errors, _context.JobDetail.Key));
}
var response = await _httpClientHelper.GetExecutionErrors(dataMessage.MessageId, cancellationToken);
if (!response.IsSuccessStatusCode)
{
throw new JobExecutionException(string.Format(Resources.Job_0_download_of_execution_errors_failed_1, _context.JobDetail.Key, string.Format($"Status: {response.StatusCode}. Message: {response.Content}")));
}
using Stream downloadedStream = await response.Content.ReadAsStreamAsync();
var errorsFileName = $"{Path.GetFileNameWithoutExtension(dataMessage.Name)}-ExecutionErrors-{DateTime.Now:yyyy-MM-dd_HH-mm-ss-ffff}.txt";
var errorsFilePath = Path.Combine(Path.GetDirectoryName(dataMessage.FullPath.Replace(_settings.UploadSuccessDir, _settings.ProcessingErrorsDir)), errorsFileName);
var dataMessageForErrorsFile = new DataMessage()
{
FullPath = errorsFilePath,
Name = errorsFileName,
MessageStatus = MessageStatus.Failed
};
await _retryPolicyForAsyncIo.ExecuteAsync(ct => FileOperationsHelper.CreateAsync(downloadedStream, dataMessageForErrorsFile.FullPath, ct), cancellationToken);
}
}
break;
}
}
/// <summary>
/// Generate file for individual member
/// </summary>
/// <param name="viewModel"></param>
private void GenerateFiles(ViewModel viewModel)
{
// Read the Letter text rom the Content Folder
var letterStream = FileOperationsHelper.ReadFromTemplate();
//formating the letter for individual Member
var formatedLetter = GenericHelper.FormattingFile(viewModel, letterStream);
//Store te file in location
FileOperationsHelper.CreateFile(viewModel, formatedLetter.ToString());
}
private void GetRecipientInfo()
{
fileHelper = new FileOperationsHelper();
EthereumUser userInfo = fileHelper.ReadBinaryFile(fileHelper.FilePathGenerator(Constants.RecipientFile));
if (userInfo != null)
{
tbAddress.Text = userInfo.PublicAddress;
tbPrivateKey.Text = userInfo.PrivateKey;
}
}
private void ReadEncryptedEmail_Load(object sender, RibbonUIEventArgs e)
{
blockchainHelper = new BlockchainHelper();
securityHelper = new SecurityHelper();
fileHelper = new FileOperationsHelper();
ethContract = new EthereumContract();
ethContract.ContractAddress = Constants.ContractAddress;
ethContract.ContractABI = Constants.ContractABI;
// Get recipient's saved Ethereum account details (If exists)
GetRecipientInfo();
}
private void BrowseServerFileClicked()
{
var selectedFile = FileOperationsHelper.BrowseForGtMpServerExe();
if (!File.Exists(selectedFile))
{
NotificationService.ShowNotification("Invalid file selected.", true);
return;
}
Settings.ServerHostPath = selectedFile;
RaisePropertyChanged(nameof(Settings));
}
public IResult Delete(CarImage img)
{
IResult result = BusinessRules.Run(CheckIfImagePathIsExists(img.ImagePath));
if (result != null)
{
return(result);
}
_carImageDal.Delete(img);
FileOperationsHelper.Delete(img.ImagePath);
return(new SuccessResult("Image" + Messages.DeleteSingular));
}
private string BrowseForServerExePath()
{
var selectedFile = FileOperationsHelper.BrowseForGta5Exe();
if (!IsValidGtMpServerPath(selectedFile))
{
return(null);
}
_settings.ServerHostPath = selectedFile;
_settingsProvider.SaveSettings(_settings);
return(selectedFile);
}
/// <summary>
/// Processes download queue by downloading each
/// file to download success location.
/// </summary>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns>
/// Task object for continuation
/// </returns>
/// <exception cref="System.Exception"></exception>
private async Task ProcessDownloadQueue(CancellationToken cancellationToken)
{
var fileCount = 0;
while (DownloadQueue.TryDequeue(out DataMessage dataMessage))
{
var response = await _httpClientHelper.GetRequestAsync(new UriBuilder(dataMessage.DownloadLocation).Uri, true, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
if (!response.IsSuccessStatusCode)
{
throw new JobExecutionException(string.Format(Resources.Job_0_Download_failure_1, _context.JobDetail.Key, response.StatusCode));
}
using (var downloadedStream = await response.Content.ReadAsStreamAsync())
{
if (fileCount > 0 && _settings.DelayBetweenFiles > 0) //Only delay after first file and never after last.
{
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(_settings.DelayBetweenFiles));
}
fileCount++;
cancellationToken.ThrowIfCancellationRequested();
//Downloaded file has no file name. We need to create it.
//It will be timestamp followed by number in this download batch.
var fileName = $"{DateTime.Now:yyyy-MM-dd_HH-mm-ss-ffff}-{fileCount:D6}";
fileName = Path.ChangeExtension(fileName, "zip");
dataMessage.FullPath = Path.Combine(_settings.DownloadSuccessDir, fileName);
dataMessage.Name = fileName;
dataMessage.MessageStatus = MessageStatus.Succeeded;
await _retryPolicyForAsyncIo.ExecuteAsync(ct => FileOperationsHelper.CreateAsync(downloadedStream, dataMessage.FullPath, ct), cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
}
if (_settings.LogVerbose || Log.IsDebugEnabled)
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_was_downloaded, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}")));
}
await AcknowledgeDownload(dataMessage, cancellationToken);
if (_settings.UnzipPackage)
{
await _retryPolicyForAsyncIo.ExecuteAsync(ct => FileOperationsHelper.UnzipPackageAsync(dataMessage.FullPath, _settings.DeletePackage, _settings.AddTimestamp, ct), cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
}
}
}
/// <summary>
/// Processes this instance.
/// </summary>
/// <returns></returns>
private async Task Process()
{
EnqueuedJobs = new ConcurrentQueue <DataMessage>();
foreach (var dataMessage in FileOperationsHelper.GetStatusFiles(MessageStatus.InProcess, _settings.UploadSuccessDir, "*" + _settings.StatusFileExtension))
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_found_in_processing_location_and_added_to_queue_for_status_check, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}")));
EnqueuedJobs.Enqueue(dataMessage);
}
if (!EnqueuedJobs.IsEmpty)
{
await ProcessEnqueuedQueue();
}
}
private void GetSenderInfo()
{
// Email sender
emailSender = new EthereumUser();
fileHelper = new FileOperationsHelper();
EthereumUser userInfo = fileHelper.ReadBinaryFile(fileHelper.FilePathGenerator(Constants.SenderFile));
if (userInfo != null)
{
emailSender.PublicAddress = userInfo.PublicAddress;
emailSender.PrivateKey = userInfo.PrivateKey;
}
}
private void CopyFixedSaveGame(string saveGameFolderPath)
{
var currentSaveGameBackupFilePath = Path.Combine(saveGameFolderPath, "SGTA50000.bak");
var currentSaveGameFilePath = Path.Combine(saveGameFolderPath, "SGTA50000");
var fixedSaveGameFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"savegame\SGTA50000");
if (File.Exists(currentSaveGameFilePath))
{
_logger.Write($"Backing up save game file: {currentSaveGameFilePath} to {currentSaveGameBackupFilePath}");
FileOperationsHelper.MoveFileIgnoreReadonly(currentSaveGameFilePath, currentSaveGameBackupFilePath);
}
_logger.Write($"Copying custom save game: {fixedSaveGameFilePath} to {currentSaveGameFilePath}");
File.Copy(fixedSaveGameFilePath, currentSaveGameFilePath);
}
public IResult Add(IFormFile image, CarImage img)
{
IResult result = BusinessRules.Run(CheckIfCarIsExists(img.CarId),
CheckIfFileExtensionValid(image.FileName),
CheckIfImageNumberLimitForCar(img.CarId));
if (result != null)
{
return(result);
}
img.ImagePath = FileOperationsHelper.Add(image);
img.CreatedAt = DateTime.Now;
_carImageDal.Add(img);
return(new SuccessResult("Image" + Messages.AddSingular));
}
/// <summary>
/// Processes this instance.
/// </summary>
/// <returns></returns>
private async Task Process()
{
InputQueue = new ConcurrentQueue <DataMessage>();
foreach (var dataMessage in FileOperationsHelper.GetFiles(MessageStatus.Input, _settings.InputDir, _settings.SearchPattern, SearchOption.AllDirectories, _settings.OrderBy, _settings.ReverseOrder))
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_found_in_input_location, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}")));
InputQueue.Enqueue(dataMessage);
}
if (!InputQueue.IsEmpty)
{
Log.InfoFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Found_1_file_s_in_input_folder, _context.JobDetail.Key, InputQueue.Count));
await ProcessInputQueue();
}
}
private void MoveGrandTheftMultiplayerLibsToDisabledFolder(string gamePath, string disabledModsFolderPath)
{
foreach (var modFileName in _modFiles)
{
var modFileTargetPath = Path.Combine(gamePath, modFileName);
var modFileDisabledPath = Path.Combine(disabledModsFolderPath, modFileName);
if (!File.Exists(modFileTargetPath))
{
continue;
}
_logger.Write($"Moving game mod from {modFileTargetPath} to {modFileDisabledPath}");
FileOperationsHelper.MoveFileIgnoreReadonly(modFileTargetPath, modFileDisabledPath);
}
}
private string BrowseForGta5ExePath()
{
var selectedFile = FileOperationsHelper.BrowseForGta5Exe();
_logger.Write($"User manually selected {selectedFile} as GTA5.exe path.");
var selectedFolder = string.IsNullOrEmpty(selectedFile) ? null : Path.GetDirectoryName(selectedFile);
if (!IsValidGtaPath(selectedFolder))
{
return(null);
}
_settings.GamePath = selectedFolder;
_settingsProvider.SaveSettings(_settings);
return(selectedFile);
}
private void MoveActiveModsToDisabledFolder(string gamePath)
{
var disabledModsFolderPath = Path.Combine(gamePath, DisabledModsFolderName);
FileOperationsHelper.EnsureDirectory(disabledModsFolderPath);
_logger.Write("Moving active game mods to disabled folder");
try
{
MoveAsiFilesToDisabledFolder(gamePath, disabledModsFolderPath);
MoveGrandTheftMultiplayerLibsToDisabledFolder(gamePath, disabledModsFolderPath);
}
catch (Exception e)
{
_logger.Write(e);
}
}
public IResult Update(IFormFile image, CarImage img)
{
IResult result = BusinessRules.Run(CheckIfImageIsExists(img.Id),
CheckIfFileExtensionValid(image.FileName));
if (result != null)
{
return(result);
}
var carImg = _carImageDal.Get(x => x.Id == img.Id);
carImg.CreatedAt = DateTime.Now;
carImg.ImagePath = FileOperationsHelper.Add(image);
FileOperationsHelper.Delete(img.ImagePath);
_carImageDal.Update(carImg);
return(new SuccessResult("Image" + Messages.UpdateSingular));
}
private static void EnsureLogFile(string logFilePath)
{
FileOperationsHelper.EnsureFileDirectory(logFilePath);
if (File.Exists(logFilePath))
{
return;
}
try
{
File.Create(logFilePath).Dispose();
}
catch (Exception ex)
{
MessageBox.Show("Failed to create log file! Exception:\n\n" + ex);
}
}
private void MoveAsiFilesToDisabledFolder(string gamePath, string disabledModsFolderPath)
{
var asiModFiles = Directory.GetFiles(gamePath, "*.asi", SearchOption.TopDirectoryOnly);
foreach (var asiModFilePath in asiModFiles)
{
var modFileName = Path.GetFileName(asiModFilePath);
if (modFileName == null)
{
continue;
}
var targetDisabledPath = Path.Combine(disabledModsFolderPath, modFileName);
_logger.Write($"Moving game mod from {asiModFilePath} to {targetDisabledPath}");
FileOperationsHelper.MoveFileIgnoreReadonly(asiModFilePath, targetDisabledPath);
}
}
private void RestoreBackedUpSaveGame(string saveGameFolderPath)
{
var saveGameBackupFilePath = Path.Combine(saveGameFolderPath, "SGTA50000.bak");
var saveGameFilePath = Path.Combine(saveGameFolderPath, "SGTA50000");
if (!File.Exists(saveGameBackupFilePath))
{
return;
}
if (File.Exists(saveGameFilePath))
{
_logger.Write($"Deleting save game file: {saveGameFilePath}");
File.Delete(saveGameFilePath);
}
_logger.Write($"Moving backed up save game file: {saveGameBackupFilePath} to {saveGameFilePath}");
FileOperationsHelper.MoveFileIgnoreReadonly(saveGameBackupFilePath, saveGameFilePath);
}
private static void LoadConfigurationFiles()
{
var file = FileOperationsHelper.GetFilesFromPath("appsettings.json")?.FirstOrDefault();
if (file == null)
{
throw new ArgumentException("No appsettings.json was provided");
}
Configuration = new ConfigurationBuilder().AddJsonFile(file, true, true).Build();
var environmentFileName = Configuration.GetSection("Environment").Value;
var environmentFile = FileOperationsHelper.GetFilesFromPath($"appsettings.{environmentFileName}.json")?.FirstOrDefault();
Configuration = new ConfigurationBuilder().AddConfiguration(Configuration).AddJsonFile(environmentFile, true, true).Build();
CdkOptions = Configuration.GetSection("CdkOptions").Get <List <CdkOptions> >();
}
/// <summary>
/// Acknowledges the download.
/// </summary>
/// <param name="dataMessage">The data message.</param>
/// <returns></returns>
private async Task AcknowledgeDownload(DataMessage dataMessage)
{
var content = JsonConvert.SerializeObject((DequeueResponse)dataMessage);
var response = await _httpClientHelper.PostStringRequestAsync(_acknowledgeDownloadUri, content);
if (response.StatusCode == HttpStatusCode.OK)
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_was_acknowledged_successfully, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}")));
}
else
{
// Acknowledgment failed. Log error.
Log.ErrorFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Acknowledgment_failure_response, _context.JobDetail.Key, response.StatusCode, response.StatusCode, response.ReasonPhrase));
// Move message file
FileOperationsHelper.Move(dataMessage.FullPath, Path.Combine(_settings.DownloadErrorsDir, dataMessage.Name));
}
}
/// <summary>
/// Processes download queue by downloading each
/// file to download success location.
/// </summary>
/// <returns>
/// Task object for continuation
/// </returns>
/// <exception cref="System.Exception"></exception>
private async Task ProcessDownloadQueue()
{
//Stream downloadedStream = null;
var fileCount = 0;
while (DownloadQueue.TryDequeue(out DataMessage dataMessage))
{
var response = await _httpClientHelper.GetRequestAsync(new UriBuilder(dataMessage.DownloadLocation).Uri);
if (!response.IsSuccessStatusCode)
{
throw new Exception(string.Format(Resources.Job_0_Download_failure_1, _context.JobDetail.Key, response.StatusCode));
}
using (var downloadedStream = await response.Content.ReadAsStreamAsync())
{
fileCount++;
//Downloaded file has no file name. We need to create it.
//It will be timestamp followed by number in this download batch.
var fileName = $"{DateTime.Now:yyyy-MM-dd_HH-mm-ss-ffff}-{fileCount:D6}";
fileName = Path.ChangeExtension(fileName, "zip");
dataMessage.FullPath = Path.Combine(_settings.DownloadSuccessDir, fileName);
dataMessage.Name = fileName;
dataMessage.MessageStatus = MessageStatus.Succeeded;
_retryPolicyForIo.Execute(() => FileOperationsHelper.Create(downloadedStream, dataMessage.FullPath));
}
if (Log.IsDebugEnabled)
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_was_downloaded, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}")));
}
await AcknowledgeDownload(dataMessage);
if (_settings.UnzipPackage)
{
_retryPolicyForIo.Execute(() => FileOperationsHelper.UnzipPackage(dataMessage.FullPath, _settings.DeletePackage, _settings.AddTimestamp));
}
System.Threading.Thread.Sleep(_settings.Interval);
}
}
/// <summary>
/// Processes this instance.
/// </summary>
/// <param name="cancellationToken">Cancellation token</param>
/// <returns></returns>
private async Task Process(CancellationToken cancellationToken)
{
PowerShellHelper.ExecutePowerShellScript(_settings.PreTaskScript, new Dictionary <string, string> {
["taskFolderName"] = _settings.InputDir
});
InputQueue = new ConcurrentQueue <DataMessage>();
foreach (
var dataMessage in FileOperationsHelper.GetFiles(MessageStatus.Input, _settings.InputDir, _settings.SearchPattern, SearchOption.AllDirectories, _settings.OrderBy, _settings.ReverseOrder))
{
if (_settings.LogVerbose || Log.IsDebugEnabled)
{
Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_found_in_input_location, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}")));
}
InputQueue.Enqueue(dataMessage);
}
if (!InputQueue.IsEmpty)
{
Log.InfoFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Found_1_file_s_in_input_folder, _context.JobDetail.Key, InputQueue.Count));
await ProcessInputQueue(cancellationToken);
}
}
