private bool CopyFilesWithFilter(SyncRule rule, string filter)
{
try
{
_directory.CreateDirectory(rule.Dest);
}
catch (Exception ex)
{
_messenger.Send(new LogMessage(string.Format("Failed to create directory {0}: {1}", rule.Dest, ex.Message)));
return(false);
}
foreach (var sourceFile in _directory.GetFiles(rule.Source, filter, SearchOption.AllDirectories))
{
if (!_enabled)
{
break;
}
var destPath = GetFileDest(sourceFile, rule.Source, rule.Dest, rule.Flatten);
if (ShouldSync(sourceFile, destPath))
{
_messenger.Send(new LogMessage(string.Format("Copying {0} to {1}", sourceFile, destPath)));
CopyFile(sourceFile, destPath);
}
}
return(true);
}
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 WriteFile(string fileName, string data, Encoding encoding)
{
if (!_directory.Exists(Path.GetDirectoryName(fileName)))
{
_directory.CreateDirectory(Path.GetDirectoryName(fileName));
}
_file.WriteAllText(fileName, data, encoding);
}
string GetTempBasePath()
{
var path = CrossPlatform.GetApplicationTempDir();
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
return(path);
}
private void SetTempFolders(Job job)
{
job.JobTempFolder = Path.Combine(_tempFolderProvider.TempFolder,
"Job_" + Path.GetFileNameWithoutExtension(Path.GetRandomFileName()));
job.JobTempOutputFolder = Path.Combine(job.JobTempFolder, "tempoutput");
_directory.CreateDirectory(job.JobTempFolder);
_directory.CreateDirectory(job.JobTempOutputFolder);
// Shorten the temp folder for GS compatibility
job.JobTempFolder = PathHelper.GetShortPathName(job.JobTempFolder);
//TODO remove this after upgrade to GS 9.19
}
public override bool ExecuteOperation()
{
if (_impersonatedUser != null)
{
return(ExecuteOperationWithAuth());
}
if (DirectoryExist(_path, _dirWrapper))
{
_handleOverwrite.ExecuteOperation();
}
_dirWrapper.CreateDirectory(_path.Path);
return(true);
}
string GetTempBasePath()
{
var path1 = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
path1 = Path.Combine(path1, Assembly.GetEntryAssembly()?.GetName().Name ?? "Octopus.Calamari");
path1 = Path.Combine(path1, "Temp");
var path = path1;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
return(path);
}
public DirectoryMockWithSpy(IDirectory directorySystem, IList <string> directories = null)
{
if (directorySystem != null)
{
_directorySystem = directorySystem;
}
if (directories != null)
{
foreach (var directory in directories)
{
_directorySystem.CreateDirectory(directory);
}
}
}
public void Save(IEnumerable <SiteFile> files)
{
string outputPath = _settings.TargetConnection.GetConnectionStringValue(_connectionStringFilepathKey);
foreach (var sitePage in files)
{
string fullPath = System.IO.Path.Combine(outputPath, sitePage.RelativeFilePath);
string folderPath = System.IO.Path.GetDirectoryName(fullPath);
if (!_directory.Exists(folderPath))
{
_directory.CreateDirectory(folderPath);
}
if (sitePage.IsBase64Encoded)
{
try
{
_file.WriteAllBytes(fullPath, Convert.FromBase64String(sitePage.Content));
}
catch (UnauthorizedAccessException)
{
//TODO: Log the fact that this file was skipped
}
}
else
{
_file.WriteAllText(fullPath, sitePage.Content);
}
}
}
public static void CreateDirectoryIfNotExists(this IDirectory directory, string path)
{
if (!directory.Exists(path))
{
directory.CreateDirectory(path);
}
}
public List <CbrExtractOutput> Extract(CbrPaths paths)
{
var outputList = new List <CbrExtractOutput>();
var files = _directory.GetFiles(paths.SourcePath, "*.*", paths.SourceSearchOption).Where(f => f.EndsWith(".cbr") || f.EndsWith(".cbz"));
foreach (var item in files)
{
string finalDestination = paths.DestinationPath;
if (_extractionRules.ForceSubFolder)
{
finalDestination = _path.Combine(finalDestination, _path.GetFileName(item).Replace(_path.GetExtension(item), ""));
_directory.CreateDirectory(finalDestination);
}
var output = new CbrExtractOutput();
output.HasFolder = _extractionRules.ForceSubFolder;
output.OriginalCbrFileName = _path.GetFileName(item);
//TODO: consider subfolder approach
output.FullSourcePath = paths.SourcePath;
output.FullDestinationPath = paths.DestinationPath;
output.Files = FactoryDecoupling.WriteToFiles(finalDestination, item);
outputList.Add(output);
}
return(outputList);
}
public void Save(IEnumerable <SiteFile> files)
{
foreach (var sitePage in files)
{
String fullPath = System.IO.Path.Combine(_outputPath, sitePage.RelativeFilePath);
String folderPath = System.IO.Path.GetDirectoryName(fullPath);
if (!_directory.Exists(folderPath))
{
_directory.CreateDirectory(folderPath);
}
if (sitePage.IsBase64Encoded)
{
try
{
_file.WriteAllBytes(fullPath, Convert.FromBase64String(sitePage.Content));
}
catch (UnauthorizedAccessException)
{
//TODO: Log the fact that this file was skipped
}
}
else
{
_file.WriteAllText(fullPath, sitePage.Content);
}
}
Console.WriteLine($"Site written to {System.IO.Path.GetFullPath(_outputPath)}");
}
private void RecursiveCopy(IElement srcelem, IDirectory dstdirpar)
{
if(srcelem.IsDirectory) {
IDirectory srcdir = (IDirectory) srcelem;
IElement dstelem = dstdirpar.GetChild(srcdir.Name); // TODO: try catch
if(dstelem != null) {
throw new Exception(dstelem.FullName + " already exists.");
}
IDirectory dstdir = dstdirpar.CreateDirectory(srcdir.Name); // TODO: try catch
foreach(IDirectory srcsub in srcdir.GetDirectories()) { // TODO: try catch
if(!_cancel) RecursiveCopy(srcsub, dstdir);
}
foreach(IFile srcsub in srcdir.GetFiles()) { // TODO: try catch
if(!_cancel) RecursiveCopy(srcsub, dstdir);
}
} else {
SingleCopy((IFile) srcelem, dstdirpar);
}
}
public ImageRepository(IFile file, IDirectory directory, IConfigurationManager configurationManager)
{
_configurationManager = configurationManager;
File = file;
Directory = directory;
var client = new MongoClient("mongodb://localhost:27017");
Database = client.GetDatabase(_configurationManager.GetValue("database"));
Collection = Database.GetCollection <Image>("Images");
GridFs = new GridFSBucket(Database);
var fs = new FileStream("config.json", FileMode.Open, FileAccess.Read);
JObject config = null;
using (StreamReader streamReader = new StreamReader(fs))
using (JsonTextReader reader = new JsonTextReader(streamReader))
{
config = (JObject)JToken.ReadFrom(reader);
}
ImageDirectory = config?.GetValue("ImageDirectory")?.ToString();
if (!Directory.Exists(ImageDirectory))
{
Directory.CreateDirectory(ImageDirectory);
}
}
internal static void EnsureDirectory(this IDirectory directory, string filePath, out IDirectory dir, out string fileName)
{
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath");
}
filePath = filePath.Trim('/');
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentException("filePath");
}
var index = filePath.LastIndexOf('/');
if (index < 0)
{
dir = directory;
fileName = filePath;
}
else
{
dir = directory.CreateDirectory(filePath.Substring(0, index));
fileName = filePath.Substring(index + 1);
}
}
private static void ValidateUserDirectory()
{
if (!Directory.Exists(Constant.PluginsDirectory))
{
Directory.CreateDirectory(Constant.PluginsDirectory);
}
}
private void ConfigureClientToRedirectMailsToDisk(SmtpClient client)
{
// http://stackoverflow.com/questions/567765/how-can-i-save-an-email-instead-of-sending-when-using-smtpclient
client.DeliveryMethod = SmtpDeliveryMethod.SpecifiedPickupDirectory;
client.PickupDirectoryLocation = GetMailDiskFolderPath();
// if we are working with a relative path we need to modify it
if (client.PickupDirectoryLocation.StartsWith("~"))
{
var root = AppDomain.CurrentDomain.BaseDirectory;
var pickupRoot = client.PickupDirectoryLocation
.Replace("~", root);
pickupRoot = pickupRoot.Replace("/", @"\");
client.PickupDirectoryLocation = pickupRoot;
}
// ensure that the pickup location exists
if (_directory.Exists(client.PickupDirectoryLocation))
{
return;
}
_logger.Info($"RnMailClient - mail pickup directory not found ({client.PickupDirectoryLocation})," +
" attempting to create it now");
_directory.CreateDirectory(client.PickupDirectoryLocation);
_logger.Debug("RnMailClient - successfully created mail pickup directory");
}
public bool CompressAsset(string sourceFilePath, string targetFolderPath, bool overwrite = true, string encryptionKey = null)
{
if (string.IsNullOrWhiteSpace(sourceFilePath) ||
!_file.Exists(sourceFilePath) ||
(!string.IsNullOrWhiteSpace(targetFolderPath) &&
_directory.Exists(targetFolderPath) &&
(_file.GetAttributes(targetFolderPath) & FileAttributes.Directory) == 0))
{
return(false);
}
if (!string.IsNullOrWhiteSpace(targetFolderPath) &&
!_directory.Exists(targetFolderPath))
{
_directory.CreateDirectory(targetFolderPath);
}
var targetCompressedFilePath = Path.Combine(targetFolderPath ?? string.Empty, GetCompressedAssetFileName(sourceFilePath, false));
var targetEncryptedFilePath = Path.Combine(targetFolderPath ?? string.Empty, GetCompressedAssetFileName(sourceFilePath, true));
var encrypted = !string.IsNullOrWhiteSpace(encryptionKey);
if (!overwrite &&
((_file.Exists(targetCompressedFilePath) && !encrypted) ||
(_file.Exists(targetEncryptedFilePath) && encrypted)))
{
return(false);
}
_file.DeleteFileIfExists(targetCompressedFilePath);
SaveCompressedFile(sourceFilePath, targetCompressedFilePath);
EncryptCompressedFileIfRequired(encrypted, targetEncryptedFilePath, targetCompressedFilePath, encryptionKey);
return(true);
}
public string RunWithCache(string cacheKey, Func <string> getValueToCache)
{
var cacheFilepath = GetCacheFilePath(cacheKey);
try
{
if (!_file.Exists(cacheFilepath))
{
if (!_directory.Exists(_dotnetUserProfileFolderPath))
{
_directory.CreateDirectory(_dotnetUserProfileFolderPath);
}
var runResult = getValueToCache();
_file.WriteAllText(cacheFilepath, runResult);
return(runResult);
}
else
{
return(_file.ReadAllText(cacheFilepath));
}
}
catch (Exception ex)
{
if (ex is UnauthorizedAccessException ||
ex is PathTooLongException ||
ex is IOException)
{
return(getValueToCache());
}
throw;
}
}
/// <summary>
/// Creates the directory and stores in "CreatedDirectories" which parent directories hab to be created
/// </summary>
/// <returns>false if creating directory throws exception</returns>
public bool CreateDirectory(string directory)
{
try
{
var directoryTree = GetDirectoryTree(directory);
directoryTree = directoryTree.OrderBy(x => x).ToList(); //start with smallest
foreach (var path in directoryTree)
{
if (!_directoryWrap.Exists(path))
{
try
{
_directoryWrap.CreateDirectory(path);
_logger.Debug("Created directory " + path);
}
catch (Exception ex)
{
_logger.Warn("Exception while creating \"" + path + "\"\r\n" + ex.Message);
return(false);
}
_createdDirectories.Add(path);
}
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public void SendTestMail_EmailClientGetsCalledWithCorrectEmailContent_AttachmentFile()
{
var currentEmail = new Email();
_pathWrap.GetTempPath().Returns("temp");
_emailClient.When(x => x.ShowEmailClient(Arg.Any <Email>())).Do(
x =>
{
currentEmail = x[0] as Email;
});
_clientTestEmail.SendTestEmail(_emailClientSettings);
Received.InOrder(() =>
{
_pathWrap.GetTempPath();
_directoryWrap.CreateDirectory(@"temp\PDFCreator-Test\SendSmtpTestmail");
_fileWrap.WriteAllText(@"temp\PDFCreator-Test\SendSmtpTestmail\PDFCreator Mail Client Test.pdf", "");
});
Assert.AreEqual(1, currentEmail.Attachments.Count, "Test mail has more than one attachment");
Assert.AreEqual(@"temp\PDFCreator-Test\SendSmtpTestmail\PDFCreator Mail Client Test.pdf",
currentEmail.Attachments.First().Filename);
}
static Log()
{
CurrentLogDirectory = Path.Combine(Constant.DataDirectory, DirectoryName, Constant.Version);
if (!Directory.Exists(CurrentLogDirectory))
{
Directory.CreateDirectory(CurrentLogDirectory);
}
var configuration = new LoggingConfiguration();
var target = new FileTarget();
target.Layout = NLog.Layouts.Layout.FromString("[${longdate}] [${level:uppercase=true}]${message}\n");
configuration.AddTarget("file", target);
// Adding CurrentCulture since this is user facing
target.FileName = CurrentLogDirectory.Replace(@"\", "/", StringComparison.CurrentCulture) + "/${shortdate}.txt";
#if DEBUG
var rule = new LoggingRule("*", LogLevel.Debug, target);
#else
var rule = new LoggingRule("*", LogLevel.Info, target);
#endif
configuration.LoggingRules.Add(rule);
target.Dispose();
LogManager.Configuration = configuration;
}
private void SetInProgressSentinel()
{
try
{
if (!_directory.Exists(_nugetCachePath))
{
_directory.CreateDirectory(_nugetCachePath);
}
// open an exclusive handle to the in-progress sentinel and mark it for delete on close.
// we open with exclusive FileShare.None access to indicate that the operation is in progress.
// buffer size is minimum since we won't be reading or writing from the file.
// delete on close is to indicate that the operation is no longer in progress when we dispose
// this.
InProgressSentinel = _file.OpenFile(
InProgressSentinelPath,
FileMode.OpenOrCreate,
FileAccess.ReadWrite,
FileShare.None,
1,
FileOptions.DeleteOnClose);
}
catch (UnauthorizedAccessException)
{
UnauthorizedAccess = true;
}
catch { }
}
public static void CreateDirectoryIfNotExists(this IDirectory directory, string path)
{
Guard.Against.NullOrWhiteSpace(path, nameof(path));
if (!directory.Exists(path))
{
directory.CreateDirectory(path);
}
}
public void Move(string filePath, string destinationDirectory)
{
_directory.CreateDirectory(destinationDirectory);
var newFilePath = $@"{destinationDirectory}\{_path.GetFileName(filePath)}";
_file.Move(filePath, newFilePath);
}
private void CreateOutputDirectory(string outputFilenameTemplate)
{
var directory = PathSafe.GetDirectoryName(outputFilenameTemplate);
if (directory != null && !DirectoryWrap.Exists(directory))
{
DirectoryWrap.CreateDirectory(directory);
}
}
public void ValidateResourceFolder()
{
var folder = EnvironmentVariables.ResourcePath;
if (!_directory.Exists(folder))
{
_directory.CreateDirectory(folder);
}
}
public void TestCleanup()
{
CloseEditor();
if (!Directory.Exists(_settingsFolderPath))
{
Directory.CreateDirectory(_settingsFolderPath);
}
}
// Public Methods (3)
public IDirectory GetDirectory(IEnumerable <char> path, bool createIfNotExist = false)
{
var dirPath = path.AsString();
if (dirPath != null)
{
// remove beginning '/' chars
while (dirPath.StartsWith(_PATH_SEPERATOR_EXPR))
{
dirPath = dirPath.Substring(1)
.Trim();
}
// remove encoding '/' chars
while (dirPath.EndsWith(_PATH_SEPERATOR_EXPR))
{
dirPath = dirPath.Substring(0, dirPath.Length - 1)
.Trim();
}
}
if (string.IsNullOrWhiteSpace(dirPath))
{
return(this.GetRootDirectory());
}
var parts = dirPath.Split(new string[] { _PATH_SEPERATOR_EXPR },
StringSplitOptions.None);
IDirectory currentDir = this.GetRootDirectory();
for (var i = 0; i < parts.Length; i++)
{
var p = parts[i].ToLower().Trim();
var subDir = CollectionHelper.SingleOrDefault(currentDir.GetDirectories(),
d => p == (d.Name ?? string.Empty).ToLower().Trim());
if (subDir == null)
{
if (createIfNotExist)
{
subDir = currentDir.CreateDirectory(p);
}
}
currentDir = subDir;
if (currentDir == null)
{
// part does not exist
break;
}
}
return(currentDir);
}
public string GetDownloadPath(string downloadUrl)
{
var downloadLocation = _tempFolderProvider.TempFolder;
_directory.CreateDirectory(downloadLocation);
var uri = new Uri(downloadUrl);
var filename = PathSafe.GetFileName(uri.LocalPath);
return(PathSafe.Combine(downloadLocation, filename));
}
public void BuildReleaseExamples(string releasePath)
{
var programDataBuilders = new List <ResourceBuilderTO>();
var resourcePath = EnvironmentVariables.ResourcePath;
if (!_directoryWrapper.Exists(resourcePath))
{
_directoryWrapper.CreateDirectory(resourcePath);
}
var resourcesFolders = _directoryWrapper.EnumerateDirectories(resourcePath, "*", SearchOption.AllDirectories);
var allResourcesFolders = resourcesFolders.ToList();
allResourcesFolders.Add(resourcePath);
BuildStream(resourcePath, allResourcesFolders.ToArray(), programDataBuilders);
// get all installed resource ids in ProgramData
var programDataIds = programDataBuilders.Select(currentItem =>
{
XElement xml = null;
try
{
xml = XElement.Load(currentItem._fileStream);
}
catch (Exception e)
{
Dev2Logger.Error("Resource [ " + currentItem._filePath + " ] caused " + e.Message, GlobalConstants.WarewolfError);
}
return(xml?.Attribute("ID")?.Value ?? null);
})
.Where(o => o != null) // ignore files with no id
.OrderBy(o => o).ToArray(); // cache installed ids in array
var releaseFolders = _directoryWrapper.EnumerateDirectories(releasePath, "*", SearchOption.AllDirectories);
var allReleaseFolders = releaseFolders.ToList();
allReleaseFolders.Add(releasePath);
var programFilesBuilders = new List <ResourceBuilderTO>();
BuildStream(releasePath, allReleaseFolders.ToArray(), programFilesBuilders);
var foundMissingResources = CopyMissingResources(programDataIds, programFilesBuilders, _directoryWrapper, _fileWrapper);
foreach (var builderTO in programDataBuilders.Concat(programFilesBuilders))
{
builderTO._fileStream.Close();
}
if (foundMissingResources)
{
ResourceCatalog.Instance.Reload();
}
}
public void Directory(IDirectory sdir, IDirectory ddir)
{
if (ddir == null || sdir == null) return;
sdir.Source = ddir.Source = sdir;
sdir.Destination = ddir.Destination = ddir;
int con;
if (sdir is LocalDirectory && ddir is LocalDirectory) con = 1;
else {
con = Math.Max(FtpConnections.Count(true, sdir.Url), FtpConnections.Count(false, ddir.Url));
if (ddir is FtpDirectory) {
((FtpDirectory)ddir).TransferProgress = true;
} else if (sdir is FtpDirectory) {
((FtpDirectory)sdir).TransferProgress = true;
}
}
if (con == 0) con = 1;
var list = sdir.List().Where(file => !Silversite.Services.Paths.Match(ExcludePatterns, file.RelativePath)).ToList();
var dlist = ddir.List();
//ddir.CreateDirectory(null);
Parallel.ForEach<FileOrDirectory>(list, new ParallelOptions { MaxDegreeOfParallelism = con },
(src) => {
FileOrDirectory dest = null;
lock(dlist) { if (dlist.Contains(src.Name)) dest = dlist[src.Name]; }
if (dest != null && dest.Class != src.Class && (src.Changed > dest.Changed || Mode == Silversite.Services.Sync.Mode.Clone)) {
ddir.Delete(dest);
dest = null;
}
if (src.Class == ObjectClass.File) { // src is a file
if (dest == null
|| ((Mode == Silversite.Services.Sync.Mode.Update || Mode == Silversite.Services.Sync.Mode.Add) && src.Changed > dest.Changed)
|| (Mode == Silversite.Services.Sync.Mode.Clone && (src.Changed > dest.Changed + dt))) {
var s = sdir.ReadFile(src);
if (s != null) {
using (s) {
ddir.WriteFile(s, src);
}
}
}
} else { // src is a directory
if (dest == null) Directory((IDirectory)src, ddir.CreateDirectory(src));
else Directory((IDirectory)src, (IDirectory)dest);
}
lock (dlist) { dlist.Remove(src.Name); }
});
if (Mode != Silversite.Services.Sync.Mode.Add) {
foreach (var dest in dlist) ddir.Delete(dest);
}
}
public void StartTest()
{
_directoryWrap = new DirectoryWrap();
_directoryInfoWrap = _directoryWrap.CreateDirectory(path);
Assert.IsTrue(_directoryInfoWrap.Exists, "Directory TempTest must be created.");
}
