public static void ValidateDataDirectory(string bundledDataDirectory, string dataDirectory)
{
if (!Directory.Exists(dataDirectory))
{
Directory.CreateDirectory(dataDirectory);
}
foreach (var bundledDataPath in Directory.GetFiles(bundledDataDirectory))
{
var data = Path.GetFileName(bundledDataPath);
var dataPath = Path.Combine(dataDirectory, data.NonNull());
if (!File.Exists(dataPath))
{
File.Copy(bundledDataPath, dataPath);
}
else
{
var time1 = FileInfo.FromFileName(bundledDataPath).LastWriteTimeUtc;
var time2 = FileInfo.FromFileName(dataPath).LastWriteTimeUtc;
if (time1 != time2)
{
File.Copy(bundledDataPath, dataPath, true);
}
}
}
}
public void Refresh(ImportAssetOptions options = ImportAssetOptions.Default)
{
logger.Verbose("Refreshing assets...");
foreach (var asset in importedAssets)
{
string metaPath = Path.ChangeExtension(asset, ".meta");
if (!file.Exists(metaPath))
{
file.Copy(asset, metaPath);
}
}
}
public void StoreVersion(IResource resource, string userName, string reason, Guid workSpaceId, string resourcePath)
{
if (workSpaceId == Guid.Empty)
{
if (string.IsNullOrEmpty(userName))
{
userName = Thread.CurrentPrincipal.Identity.Name;
}
lock (LockObject)
{
var old = _catalogue.GetResource(Guid.Empty, resource.ResourceID);
if (old != null)
{
var versions = GetVersions(resource.ResourceID).FirstOrDefault();
old.VersionInfo = _versionStrategy.GetCurrentVersion(resource, versions?.VersionInfo, userName, reason);
var folderPath = GetVersionFolderFromResource(old.GetResourcePath(workSpaceId));
var fileName = $"{old.VersionInfo.VersionId}_{old.VersionInfo.VersionNumber}_{GetDateString(old.VersionInfo.DateTimeStamp)}_{reason}.xml";
if (!_file.Exists(Path.Combine(folderPath, fileName))) //todo: remove this and stop save on workspace
{
var sourceFile = Path.Combine(GetFolderFromResource(old.GetResourcePath(workSpaceId)), old.ResourceName) + ".xml";
if (_file.Exists(sourceFile))
{
_file.Copy(sourceFile, Path.Combine(folderPath, fileName));
}
}
resource.VersionInfo = _versionStrategy.GetNextVersion(resource, old, userName, reason);
}
}
}
}
private void CopyFile(string sourceFile, string dest)
{
var copied = false;
var attempts = 0;
while (!copied)
{
try
{
var destFolder = Path.GetDirectoryName(dest);
if (!_directory.Exists(destFolder))
{
_directory.CreateDirectory(destFolder);
}
_file.Copy(sourceFile, dest, true);
copied = true;
}
catch (Exception ex)
{
Thread.Sleep(500);
attempts++;
if (attempts >= 10)
{
_messenger.Send(
new LogMessage(string.Format("Failed to copy {0} to {1}: {2}", sourceFile, dest, ex.Message)));
break;
}
}
}
}
private void MoveLogFileIfOld()
{
var newFilePath = _detailedLogFile.GetNewFileName();
_fileWrapper.Copy(_detailedLogFile.LogFilePath, Path.Combine(_detailedLogFile.LogFilePath, newFilePath));
_fileWrapper.Delete(_detailedLogFile.LogFilePath);
}
public void StoreVersion(IResource resource, string userName, string reason, Guid workSpaceId)
{
if (workSpaceId == Guid.Empty)
{
lock (LockObject)
{
var old = _catalogue.GetResource(Guid.Empty, resource.ResourceID);
if (old != null)
{
var versions = GetVersions(resource.ResourceID).FirstOrDefault();
old.VersionInfo = _versionStrategy.GetCurrentVersion(resource, versions == null? null :versions.VersionInfo, userName, reason);
var folderPath = GetVersionFolderFromResource(resource);
var fileName = string.Format("{0}_{1}_{2}_{3}.xml", old.VersionInfo.VersionId, old.VersionInfo.VersionNumber, GetDateString(old.VersionInfo.DateTimeStamp), reason);
if (!_file.Exists(Path.Combine(folderPath, fileName))) //todo: remove this and stop save on workspace
{
var sourceFile = Path.Combine(GetFolderFromResource(resource), old.ResourceName) + ".xml";
if (_file.Exists(sourceFile))
{
_file.Copy(sourceFile, Path.Combine(folderPath, fileName));
}
}
resource.VersionInfo = _versionStrategy.GetNextVersion(resource, old, userName, reason);
}
}
}
}
public SourceFileInfo Duplicate(SourceFileInfo sfi, string duplicateFolder, string profileGuid)
{
var duplicate = new SourceFileInfo();
duplicate.SessionId = sfi.SessionId;
duplicate.WinStation = sfi.WinStation;
duplicate.Author = sfi.Author;
duplicate.ClientComputer = sfi.ClientComputer;
duplicate.PrinterName = sfi.PrinterName;
duplicate.JobCounter = sfi.JobCounter;
duplicate.JobId = sfi.JobId;
duplicate.DocumentTitle = sfi.DocumentTitle;
duplicate.OriginalFilePath = sfi.OriginalFilePath;
duplicate.Type = sfi.Type;
duplicate.TotalPages = sfi.TotalPages;
duplicate.Copies = sfi.Copies;
duplicate.UserTokenEvaluated = sfi.UserTokenEvaluated;
duplicate.UserToken = sfi.UserToken;
duplicate.OutputFileParameter = sfi.OutputFileParameter;
duplicate.PrinterParameter = profileGuid == null ? sfi.PrinterParameter : "";
duplicate.ProfileParameter = profileGuid ?? sfi.ProfileParameter;
var duplicateFilename = PathSafe.GetFileNameWithoutExtension(sfi.Filename);
var duplicateFilePath = PathSafe.Combine(duplicateFolder, duplicateFilename);
duplicateFilePath = _uniqueFilePathBuilder.Build(duplicateFilePath).Unique;
_file.Copy(sfi.Filename, duplicateFilePath);
duplicate.Filename = duplicateFilePath;
return(duplicate);
}
protected void InitializeSettingsFiles(string settingsConfigFile)
{
if (!_directoryWrapper.Exists(EnvironmentVariables.ServerSettingsFolder))
{
_directoryWrapper.CreateDirectory(EnvironmentVariables.ServerSettingsFolder);
}
if (_fileWrapper.Exists("Settings.config") && !_fileWrapper.Exists(EnvironmentVariables.ServerLogSettingsFile))
{
_fileWrapper.Copy("Settings.config", EnvironmentVariables.ServerLogSettingsFile);
}
if (_fileWrapper.Exists("secure.config") && !_fileWrapper.Exists(EnvironmentVariables.ServerSecuritySettingsFile))
{
_fileWrapper.Copy("secure.config", EnvironmentVariables.ServerSecuritySettingsFile);
}
if (!_fileWrapper.Exists(settingsConfigFile))
{
_fileWrapper.WriteAllText(settingsConfigFile, GlobalConstants.DefaultServerLogFileConfig);
}
}
private string CopyFileToJobFolder(string jobFolder, string file)
{
var shortUniqueFilename = _path.GetRandomFileName();
var extension = PathSafe.GetExtension(file);
var psFileInJobFolder = PathSafe.Combine(jobFolder, shortUniqueFilename + extension);
_file.Copy(file, psFileInJobFolder);
Logger.Debug("Copied direct conversion file to spool folder: " + psFileInJobFolder);
return(psFileInJobFolder);
}
private void BackupOriginFile()
{
// Using InvariantCulture since this is internal
var timestamp = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss-fffffff", CultureInfo.InvariantCulture);
var directory = Path.GetDirectoryName(FilePath).NonNull();
var originName = Path.GetFileNameWithoutExtension(FilePath);
var backupName = $"{originName}-{timestamp}{FileSuffix}";
var backupPath = Path.Combine(directory, backupName);
File.Copy(FilePath, backupPath, true);
// todo give user notification for the backup process
}
/// <summary>
/// Copy file with logging and catching of ioException
/// </summary>
/// <returns>true if successfull</returns>
protected bool CopyFile(string tempFile, string outputFile)
{
try
{
FileWrap.Copy(tempFile, outputFile, true);
Logger.Debug("Copied output file \"{0}\" \r\nto \"{1}\"", tempFile, outputFile);
return(true);
}
catch (IOException ioException)
{
Logger.Warn("Error while copying to target file.\r\nfrom\"{0}\" \r\nto \"{1}\"\r\n{2}", tempFile, outputFile, ioException.Message);
}
return(false);
}
private bool CopyMissingResources(string[] programDataIds, List <ResourceBuilderTO> programFilesBuilders, IDirectory directory, IFile fileWrapper)
{
var foundMissingResources = false;
// NOTE: we have not filtered for files that are not
programFilesBuilders.ForEach(programFileItem =>
{
XElement xml = null;
try
{
xml = XElement.Load(programFileItem._fileStream);
}
catch (Exception e)
{
Dev2Logger.Error("Resource [ " + programFileItem._filePath + " ] caused " + e.Message, GlobalConstants.WarewolfError);
}
var id = xml?.Attribute("ID")?.Value ?? null;
if (id != null && programDataIds.Any(programDataId => programDataId == id))
{ // resource already installed
return;
}
if (id is null) // invalid resource
{
return;
}
// Only get here if the bite file does not exist in ProgramData directory
foundMissingResources = true;
programFileItem._fileStream.Close();
var currentPath = programFileItem._filePath;
var appResourcesPath = Path.Combine(EnvironmentVariables.ApplicationPath, "Resources");
var currentSubPath = currentPath.Replace(appResourcesPath, "").Replace(".xml", ".bite");
var MyNewInstalledFilePath = EnvironmentVariables.ResourcePath + $"{currentSubPath}";
directory.CreateIfNotExists(fileWrapper.DirectoryName(MyNewInstalledFilePath));
try
{
fileWrapper.Copy(programFileItem._filePath, MyNewInstalledFilePath, false);
}
catch (Exception e)
{
Dev2Logger.Warn("Failed to copy Examples resource to ProgramData, " + e.Message, GlobalConstants.WarewolfWarn);
}
});
return(foundMissingResources);
}
public List <HistoricJob> Load()
{
var oldHistoryDir = PathSafe.Combine(_environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "PDFCreator");
var oldSavePath = PathSafe.Combine(oldHistoryDir, "PDFCreatorHistory.json");
if (!_file.Exists(_savePath))
{
if (_file.Exists(oldSavePath))
{
_file.Copy(oldSavePath, _savePath);
_logger.Debug($"Migrated job history from '{oldSavePath}' to '{_savePath}'.");
}
else
{
return(new List <HistoricJob>());
}
}
return(ReadHistoryJobsFile());
}
public void StoreVersion(IResource resource, string userName, string reason, Guid workSpaceId, string resourcePath)
{
var versionFolder = GetVersionFolderPath(resource.ResourceID.ToString());
var _userName = userName;
if (workSpaceId == Guid.Empty)
{
if (string.IsNullOrEmpty(_userName))
{
_userName = Thread.CurrentPrincipal.Identity.Name;
}
lock (LockObject)
{
var old = _catalogue.GetResource(Guid.Empty, resource.ResourceID);
if (old == null)
{
return;
}
var versions = GetVersions(resource.ResourceID).FirstOrDefault();
old.VersionInfo = _versionStrategy.GetCurrentVersion(resource, versions?.VersionInfo, _userName, reason);
var fileName = $"{old.VersionInfo.VersionNumber}_{GetDateString(old.VersionInfo.DateTimeStamp)}_{reason}.bite";
if (!_file.Exists(_filePath.Combine(versionFolder, fileName)))
{
var sourceFile = _filePath.Combine(GetFolderFromResource(old.GetResourcePath(workSpaceId)), old.ResourceName) + ".bite";
if (_file.Exists(sourceFile))
{
_directory.CreateIfNotExists(versionFolder);
_file.Copy(sourceFile, _filePath.Combine(versionFolder, fileName));
}
}
resource.VersionInfo = _versionStrategy.GetNextVersion(resource, old, _userName, reason);
}
}
}
public static void Copy(string source, string destination)
{
f.Copy(source, destination);
}
private void CopyMatchMetadata(TradeDetail trade)
{
var fileName = new FileInfo(trade.Match.WhoScoredData.MatchMetadataLocation).Name;
_file.Copy(trade.Match.WhoScoredData.MatchMetadataLocation, @"C:/Users/Cobalt4/TradeDecisionData/" + fileName);
}
/// <inheritdoc /> public void Copy(string newPath, NameCollisionOption collisionOption = NameCollisionOption.ReplaceExisting) => _file.Copy(newPath, collisionOption);
/// <summary>
/// Optimizes a list of files using a given optimizer
/// </summary>
/// <param name="optimizer">The optimizer to use.</param>
/// <param name="file">The file to optimze.</param>
/// <param name="outputPath">The path of the optimized file.</param>
/// <param name="configFiles">The config files to compare against.</param>
public OptimizedFile Optimize(string optimizer, IFile file, FilePath outputPath, IList <OptimizedFile> configFiles)
{
//Check Config
OptimizedFile config = configFiles.FirstOrDefault(o => o.Path.FullPath.ToLower() == file.Path.FullPath.ToLower());
OptimizedFile optimizedFile = null;
string hash = this.GetHash(file);
try
{
if ((config == null) || config.RequiresOptimization(hash) || config.DifferentService(optimizer))
{
//Optimize
ImageOptimizerResult result = _OptimizerFactory.Optimize(optimizer, file.Path, outputPath);
if ((result != null) && !result.HasError)
{
//Optimzed
optimizedFile = new OptimizedFile(file.Path, result.Service, result.ModifiedDate, hash, result.SizeBefore, result.SizeAfter);
_ImagesOptimized.Add(file.Path.FullPath);
_SizeBefore += result.SizeBefore;
_SizeAfter += result.SizeAfter;
_Log.Information("Optimized: " + file.Path + " - Saved: " + result.SavedSize + " bytes (" + result.SavedPercent.ToString("N0") + "%)");
}
else if ((result.ErrorMessage == "Unsupported File") ||
(result.ErrorMessage == "Invalid FileSize") ||
(result.ErrorMessage == "Matching FileSize"))
{
//Skipped
_ImagesSkipped++;
_SizeBefore += file.Length;
_SizeAfter += file.Length;
// Copy to destination
if (file.Path.FullPath.ToLower() != outputPath.FullPath.ToLower())
{
IDirectory parent = _FileSystem.GetDirectory(outputPath.GetDirectory());
if (!parent.Exists)
{
parent.Create();
}
file.Copy(outputPath, true);
}
_Log.Information("Skipped: " + file.Path + " - " + result.ErrorMessage);
}
else
{
//Errored
_ImagesErrored++;
_Log.Information("Errored: " + file.Path + " - " + result.ErrorMessage);
}
}
else
{
//Skipped
_ImagesSkipped++;
if (config != null)
{
optimizedFile = new OptimizedFile(file.Path, config.Service, config.OptimizedDate, hash, config.SizeBefore, config.SizeAfter);
_SizeBefore += config.SizeBefore;
_SizeAfter += config.SizeAfter;
}
else
{
_SizeBefore += file.Length;
_SizeAfter += file.Length;
}
_Log.Information("Skipped: " + file.Path + " - Saved: " + config.SavedSize + " bytes (" + config.SavedPercent.ToString("N0") + "%)");
}
}
catch (Exception ex)
{
//Errored
_ImagesErrored++;
_Log.Information("Errored: " + file.Path + " - " + ex.Message);
}
this.OnProgress(optimizedFile);
return(optimizedFile);
}
