public void SafeDelete()
{
var dir = new DirectoryInfo("abc");
dir.SafeDelete(true);
dir.Refresh();
Assert.That(dir.SafeDelete(true), Is.False);
Directory.CreateDirectory(dir.GetDirectory("test2").FullName);
dir.Refresh();
Assert.That(dir.SafeDelete(true), Is.True);
dir.Refresh();
Assert.That(dir.Exists, Is.False);
}
static void Main(string[] args)
{
//validate input arguements
if(args.Length != 1)
PrintUsageAndExit(FileErrors.FILE_DOES_NOT_EXIST);
else
inputFilename = args[0];
//validate file type and that it exists
FileInfo fInfo = new FileInfo(inputFilename);
if(!fInfo.Exists)
PrintUsageAndExit(FileErrors.FILE_DOES_NOT_EXIST);
else if(!fInfo.Extension.Equals(".go"))
PrintUsageAndExit(FileErrors.WRONG_FILETYPE);
//read file
string[] lines = File.ReadAllLines(inputFilename);
GoLangFile gData = new GoLangFile(lines);
DirectoryInfo dInfo = new DirectoryInfo(gData.PackageName);
if(!dInfo.Exists)
{
dInfo.Create();
dInfo.Refresh();
if(!dInfo.Exists)
{
Console.WriteLine("error: unable to create package folder");
Environment.Exit(-1);
}
}
gData.ExportStructsAsClasses(dInfo, "CerebroM", NOV_HEADER);
}
/// <summary>
/// Ensures that the data has been loaded in the Lucene index
///
/// SIDE EFFECT
/// This method sets property _searcher
/// </summary>
/// <param name="absoluteLucenePath">
/// Absolute path of the directory where the Lucene files get stored.
/// </param>
/// <param name="onlyIfNotExists">
/// If true, the index will only be created if there is no index at all (that is, no Lucene directory).
/// If false, this will always create a new index.
/// </param>
/// <param name="loadLuceneIndex">
/// Actually loads data into the Lucene index
/// </param>
protected void LoadStore(string absoluteLucenePath, bool onlyIfNotExists, Action<SimpleFSDirectory> loadLuceneIndex)
{
var luceneDir = new DirectoryInfo(absoluteLucenePath);
bool luceneDirExists = luceneDir.Exists;
if (!luceneDirExists)
{
luceneDir.Create();
luceneDir.Refresh();
}
var directory = new SimpleFSDirectory(luceneDir);
if (onlyIfNotExists && luceneDirExists)
{
// Make sure to always create a searcher.
// There must actually be a valid Lucene index in the directory, otherwise this will throw an exception.
_searcher = new IndexSearcher(directory, true);
return;
}
loadLuceneIndex(directory);
// Now that the index has been updated, need to open a new searcher.
// Existing searcher will still be reading the previous index.
_searcher = new IndexSearcher(directory, true);
}
public void copyRemoteDirectoryLocal()
{
var info = util.GetUsernameAndPassword();
using (var s = new SSHConnection(info.Item1, info.Item2))
{
// Create a "complex" directory structure on the remote machine
s
.ExecuteCommand("mkdir -p /tmp/usergwatts/data")
.ExecuteCommand("mkdir -p /tmp/usergwatts/data/d1")
.ExecuteCommand("mkdir -p /tmp/usergwatts/data/d2")
.ExecuteCommand("echo hi1 > /tmp/usergwatts/data/f1")
.ExecuteCommand("echo hi2 > /tmp/usergwatts/data/d1/f2")
.ExecuteCommand("echo hi3 > /tmp/usergwatts/data/d2/f3")
.ExecuteCommand("echo hi4 > /tmp/usergwatts/data/d2/f4");
// Remove everything local
var d = new DirectoryInfo("./data");
if (d.Exists)
{
d.Delete(true);
d.Refresh();
}
d.Create();
// Do the copy
s.CopyRemoteDirectoryLocally("/tmp/usergwatts/data", d);
Assert.IsTrue(File.Exists(Path.Combine(d.FullName, "f1")));
Assert.IsTrue(File.Exists(Path.Combine(d.FullName, "d1", "f2")));
Assert.IsTrue(File.Exists(Path.Combine(d.FullName, "d2", "f3")));
Assert.IsTrue(File.Exists(Path.Combine(d.FullName, "d2", "f4")));
}
}
/// <summary>
/// Initializes an area from a directory.
/// </summary>
public AreaState(ISystemContext context, DirectoryInfo directoryInfo) : base(null)
{
directoryInfo.Refresh();
string name = directoryInfo.Name;
// need to read the correct casing from the file system.
if (directoryInfo.Exists)
{
DirectoryInfo[] directories = directoryInfo.Parent.GetDirectories(name);
if (directories != null && directories.Length > 0)
{
name = directories[0].Name;
}
}
// get the system to use.
FileSystemMonitor system = context.SystemHandle as FileSystemMonitor;
if (system != null)
{
this.NodeId = system.CreateNodeIdFromDirectoryPath(ObjectTypes.AreaType, directoryInfo.FullName);
this.BrowseName = new QualifiedName(name, system.NamespaceIndex);
this.OnValidate = system.ValidateArea;
}
this.DisplayName = new LocalizedText(name);
this.EventNotifier = EventNotifiers.None;
this.TypeDefinitionId = GetDefaultTypeDefinitionId(context.NamespaceUris);
}
/// <summary>
/// Creates a file from a list of strings; each string is placed on a line in the file.
/// </summary>
/// <param name="TempFileName">Name of response file</param>
/// <param name="Lines">List of lines to write to the response file</param>
public static string Create(string TempFileName, List<string> Lines)
{
FileInfo TempFileInfo = new FileInfo( TempFileName );
DirectoryInfo TempFolderInfo = new DirectoryInfo( TempFileInfo.DirectoryName );
// Delete the existing file if it exists
if( TempFileInfo.Exists )
{
TempFileInfo.IsReadOnly = false;
TempFileInfo.Delete();
TempFileInfo.Refresh();
}
// Create the folder if it doesn't exist
if( !TempFolderInfo.Exists )
{
// Create the
TempFolderInfo.Create();
TempFolderInfo.Refresh();
}
using( FileStream Writer = TempFileInfo.OpenWrite() )
{
using( StreamWriter TextWriter = new StreamWriter( Writer ) )
{
Lines.ForEach( x => TextWriter.WriteLine( x ) );
}
}
return TempFileName;
}
public void TestReadWriteFileDirectory()
{
DirectoryInfo dir = new DirectoryInfo(@"c:\_junk\rwtesting");
if (dir.Exists)
dir.Delete(true);
dir.Refresh();
ReaderWriter rw = new ReaderWriter();
Assert.IsFalse(rw.Exists(dir));
rw.CreateDirectory(dir);
Assert.IsTrue(rw.Exists(dir));
string blah = "blah";
string fileName = "blah.txt";
FileInfo file = new FileInfo(Path.Combine(dir.FullName, fileName));
Assert.IsFalse(rw.Exists(file));
rw.WriteFile(file, blah.Encode());
Assert.IsTrue(rw.Exists(file));
byte[] buffer = rw.ReadFile(file);
string result = buffer.Decode();
Assert.AreEqual(blah, result);
rw.Delete(file);
Assert.IsFalse(file.Exists);
rw.Delete(dir);
Assert.IsFalse(dir.Exists);
}
public void AttemptToDownloadBadDS()
{
// Seen in wild: try to download a bad dataset, and it creates a directory
// anyway. Ops!
var dsinfo = MakeDSInfo("ds1.1.1");
var d = new DirectoryInfo("AttemptToDownloadBadDS");
if (d.Exists)
{
d.Delete(true);
}
var ld = new LinuxMirrorDownloaderPretend(d, "forkitover");
var gf = new GRIDFetchToLinuxVisibleOnWindows(d, ld, "/bogus/files/store");
try {
var r = gf.GetDS(dsinfo);
} catch (ArgumentException)
{
// Expecting it to throw here - no dataset should exist by that name!
}
// Did a local directory get created?
d.Refresh();
Assert.IsFalse(d.Exists);
}
public static IIndex LoadIndex(DirectoryInfo directory)
{
if (directory == null)
throw new ArgumentNullException("directory", "directory cannot be null");
directory.Refresh();
if (!directory.Exists)
throw new DirectoryNotFoundException(directory.FullName + " does not exist");
FileInfo[] topLevelFiles = directory.GetFiles("*.*", SearchOption.TopDirectoryOnly);
var toggleFile = topLevelFiles.FirstOrDefault(x => x.Name.Equals("toggle.txt", StringComparison.OrdinalIgnoreCase));
var totalIndexHeaders = topLevelFiles.Count(x => x.Extension.Equals(".cfx", StringComparison.OrdinalIgnoreCase) || x.Extension.Equals(".cfs", StringComparison.OrdinalIgnoreCase));
var segments = topLevelFiles.Count(x => x.Extension.Equals(".gen", StringComparison.OrdinalIgnoreCase));
if (toggleFile == null) {
// single
if (segments == 0 && totalIndexHeaders == 0)
return new Index(directory) { IndexStructure = IndexType.None };
return new Index(directory) { IndexStructure = IndexType.SingleIndex };
}
else {
// double or cyclic
DirectoryInfo mirrorDir = new DirectoryInfo(Path.Combine(directory.FullName, StaticValues.DirectoryMirror));
DirectoryInfo dirA = new DirectoryInfo(Path.Combine(directory.FullName, StaticValues.DirectoryA));
DirectoryInfo dirB = new DirectoryInfo(Path.Combine(directory.FullName, StaticValues.DirectoryB));
if (!dirA.Exists || !dirB.Exists)
return new DoubleIndex(directory) { IndexStructure = IndexType.None };
if (mirrorDir.Exists)
return new CyclicalIndex(directory);
return new DoubleIndex(directory);
}
}
public DirectoryInfo GetStorageDir(Guid newAct)
{
DirectoryInfo storageDir = new DirectoryInfo(GetStorageDir().FullName + Path.DirectorySeparatorChar + newAct.ToString());
if (!storageDir.Exists)
storageDir.Create();
storageDir.Refresh();
return storageDir;
}
public void Copying_To_Root_Directory_Should_Work()
{
targetDir = new DirectoryInfo(Path.Combine(rootDirectory.FullName, "targetFoo"));
Assert.False(targetDir.Exists);
var targetFolder = provider.CopyFolder(originalFolder, targetDir.FullName);
targetDir.Refresh();
Assert.True(targetDir.Exists);
}
public DirectoryInfo GetAccountStorageDir(Guid accountId)
{
DirectoryInfo storageDir = new DirectoryInfo(StorageDir.FullName + Path.DirectorySeparatorChar + accountId.ToString());
if (!storageDir.Exists)
storageDir.Create();
storageDir.Refresh();
return storageDir;
}
public IgnoredCleanFileInfoEnumerator(DirectoryInfo directory)
{
directory.Refresh();
if (!directory.Exists)
{
throw new DirectoryNotFoundException(string.Format("Directory '{0}' does not exist", directory));
}
_directory = directory;
}
public DirectoryFileBackup(FileInfo file, DirectoryInfo destination)
{
this.file = file;
this.destination = destination;
destination.Refresh();
if(!destination.Exists)
destination.Create();
}
public static void NewFolder(string s1)
{
var di = new DirectoryInfo(s1);
if (di.Parent != null && !di.Exists)
NewFolder(di.Parent.FullName);
if (di.Exists) return;
di.Create();
di.Refresh();
}
internal ResourceDirectory(DirectoryInfo directory)
{
directory.Refresh();
foreach (var file in directory.EnumerateFiles("*.resx"))
{
var resourceFile = new ResourceFile(file);
this.resourceByFileName[file.Name] = resourceFile;
}
}
public TestDirectory()
{
var tempPath = Path.GetTempPath();
_testDir = new DirectoryInfo(Path.Combine(tempPath, Guid.NewGuid().ToString()));
Assume.That(_testDir.Exists, Is.False, _testDir + " should not already exist");
_testDir.Create();
_testDir.Refresh();
Assume.That(_testDir.Exists, Is.True, "Failed to create test dir " + _testDir);
}
public static void EnsureDirectoryExists(DirectoryInfo directory)
{
directory.Refresh();
if (directory.Exists)
{
return;
}
EnsureDirectoryExists(directory.Parent);
directory.Create();
}
/// <summary>
/// Checks if the provided DirectoryInfo path exists.
/// </summary>
/// <param name="dInfo">Directory to check</param>
/// <returns>True if the directory exists, false if it doesn't or the DirectoryInfo is null</returns>
public static bool DirectoryExists(System.IO.DirectoryInfo dInfo)
{
if (dInfo != null)
{
dInfo.Refresh();
return(dInfo.Exists);
}
else
{
return(false);
}
}
private void Button_Click_2(object sender, RoutedEventArgs e)
{
// Caminho que iniciou o .EXE
var currentDir = Environment.CurrentDirectory;
// Caminho garantido do .EXE
var pathDoExe = AppDomain.CurrentDomain.BaseDirectory;
var pathCompleto = Path.Combine(pathDoExe, "readme.txt");
File.WriteAllText(pathCompleto, txtConteudo.Text);
var ioPath = Path.Combine(pathDoExe, "Teste", "IO");
// Directory.CreateDirectory(ioPath);
var ioDir = new DirectoryInfo(ioPath);
ioDir.Refresh();
if (!ioDir.Exists)
{
ioDir.Create();
}
FileInfo[] todosArquivos = ioDir.GetFiles();
int i = 0;
foreach (FileInfo arquivo in todosArquivos)
{
var nomeSemExtensao = Path.
GetFileNameWithoutExtension(arquivo.FullName);
int numeroArquivo;
if (int.TryParse(nomeSemExtensao, out numeroArquivo))
{
i = Math.Max(i, numeroArquivo);
}
}
var limite = i + 100;
for (; i < limite; i++)
{
using (var fileStream = File.Create(Path.Combine(ioPath, i + ".txt")))
using (var streamWriter = new StreamWriter(fileStream))
{
streamWriter.Write(txtConteudo.Text);
}
}
}
internal DirectoryInfo getObjectsDirectory()
{
// Create the 'objects' subdirectory if it doesn't exist:
DirectoryInfo objDir = new DirectoryInfo(System.IO.Path.Combine(Root.FullName, "objects"));
if (!objDir.Exists)
lock (SystemLock)
{
objDir.Refresh();
if (!objDir.Exists)
objDir.Create();
}
return objDir;
}
static void Tidy(DirectoryInfo tree)
{
foreach (DirectoryInfo di in tree.EnumerateDirectories())
{
Tidy(di);
}
tree.Refresh();
if (!tree.EnumerateFileSystemInfos().Any())
{
tree.Delete();
}
return;
}
public static void WaitExistImage(string pathFolder)
{
var fi = new System.IO.DirectoryInfo(pathFolder);
int seconds = 0;
if (fi.Exists)
{
fi.Refresh();
while (fi.GetFiles().Count() == 0)
{
System.Threading.Thread.Sleep(1000);
fi.Refresh();
seconds++;
if (seconds == 60)
{
return;
}
}
}
}
public void DirectoryInfoExists()
{
string dirPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(dirPath);
var dir = new DirectoryInfo(dirPath);
Assert.IsTrue(dir.Exists, "Directory does not exist.");
Directory.Delete(dirPath);
dir.Refresh();
AssertHelper.IgnoreOn(AssertedPlatform.Mono, () => { var doesExist = dir.Exists; }, "As identified by nestalk (http://bugzilla.novell.com/show_bug.cgi?id=582667), DirectoryInfo.Refresh() doesn't seem to refresh the Exist property.");
Assert.IsFalse(dir.Exists, "Directory exists.");
}
public static void ebfFolderCreate(Object s1)
{
DirectoryInfo di = new DirectoryInfo(s1.ToString());
if (di.Parent != null && !di.Exists)
{
ebfFolderCreate(di.Parent.FullName);
}
if (!di.Exists)
{
di.Create();
di.Refresh();
}
}
public FileSystemLearningRepository(DirectoryInfo input)
{
_rootDirectory = input;
if(!input.Exists)
{
input.Create();
input.Refresh();
}
var dirs = input.EnumerateDirectories("??");
_learnings = dirs
.SelectMany(d =>d.EnumerateFiles().Select(f => new {f.Name, Text = File.ReadAllText(f.FullName).Trim().Split('\n').ToList()}))
.ToDictionary(t => t.Name, t => t.Text);
}
/// <summary>
/// Gets information about all existing backups
/// </summary>
/// <returns> List of SnapshotInfo</returns>
public List<SnapshotInfo> GetAllInfo()
{
DirectoryInfo info = new DirectoryInfo(Path);
info.Refresh();
string[] files = info.GetFiles("*.xml")
.Select(inf => inf.FullName).ToArray();
var result = new List<SnapshotInfo>();
foreach (string path in files)
{
XDocument doc = XDocument.Load(path);
SnapshotInfo snapshot = Serializer.ParseInfo(doc);
result.Add(snapshot);
}
return result;
}
public void Clear()
{
var dir = new DirectoryInfo("abc");
var subdir = dir.GetDirectory("test2");
subdir.Create();
using (var fs = new FileStream(subdir.GetFile("test3.txt").FullName, FileMode.Create)) {
fs.WriteByte(1);
}
dir.Clear();
Assert.That(dir.Exists, Is.True);
Assert.That(dir.SafeClear(), Is.True);
Assert.That(dir.SafeDelete(), Is.True);
dir.Refresh();
Assert.That(dir.Exists, Is.False);
Assert.That(dir.SafeClear(), Is.False);
}
public void copyBadRemoteDirectoryLocal()
{
var info = util.GetUsernameAndPassword();
using (var s = new SSHConnection(info.Item1, info.Item2))
{
// Do the copy
var d = new DirectoryInfo("./databogus");
if (d.Exists)
{
d.Delete(true);
d.Refresh();
}
d.Create();
s.CopyRemoteDirectoryLocally("/tmp/usergwatts/databogusbogusbogusbogus", d);
}
}
/// <summary>
/// Extracts a directory entry from the specified stream.
/// </summary>
/// <param name="inputStream">The <see cref="Stream" /> containing the directory entry.</param>
/// <param name="destDirectory">The directory where to create the subdirectory.</param>
/// <param name="entryName">The name of the directory entry.</param>
/// <param name="entryDate">The date of the entry.</param>
/// <exception cref="BuildException">
/// <para>The destination directory for the entry could not be created.</para>
/// </exception>
protected void ExtractDirectory(Stream inputStream, string destDirectory, string entryName, DateTime entryDate)
{
DirectoryInfo destDir = new DirectoryInfo(Path.Combine(
destDirectory, entryName));
if (!destDir.Exists) {
try {
destDir.Create();
destDir.LastWriteTime = entryDate;
destDir.Refresh();
} catch (Exception ex) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
"Directory '{0}' could not be created.", destDir.FullName),
Location, ex);
}
}
}
/// <summary>
/// Initialisiert statische Felder.
/// </summary>
static TestBase()
{
// Load from configuration
TestDirectory = new DirectoryInfo( ConfigurationManager.AppSettings["TestDirectory"] );
Profile = ProfileManager.FindProfile( ConfigurationManager.AppSettings["ProfileName"] );
// Create
if (!TestDirectory.Exists)
{
// Do it
TestDirectory.Create();
// Must manually refresh
TestDirectory.Refresh();
}
}
public void EnsureDirectoryStructure(Guid accountId, string path, DirectoryInfo baseDir)
{
path = path.Replace(Path.GetFileName(path), string.Empty);
string[] parts = path.Split(Path.DirectorySeparatorChar);
DirectoryInfo dir = baseDir;
foreach (string part in parts)
{
DirectoryInfo sub = new DirectoryInfo(dir.FullName + Path.DirectorySeparatorChar + part);
if (!sub.Exists)
{
sub.Create();
sub.Refresh();
}
dir = sub;
}
}
/// <summary>
/// Create a folder at the specified path.
/// </summary>
/// <param name="dInfo"></param>
/// <returns></returns>
public static bool CreateFolder(System.IO.DirectoryInfo dInfo)
{
// TODO: Create parent directories if they don't exist
bool folderCreated = false;
if (dInfo != null)
{
if (!dInfo.Exists)
{
dInfo.Create();
dInfo.Refresh();
folderCreated = dInfo.Exists;
Console.WriteLine(folderCreated ? "INFO: Util: Creating folder: " : "INFO: Util: Failed to create folder: " + dInfo.FullName);
}
}
return(folderCreated);
}
/// <summary>
/// Tries to set the attributes.
/// </summary>
/// <param name="This">This DirectoryInfo.</param>
/// <param name="attributes">The attributes.</param>
/// <returns><c>true</c> on success; otherwise, <c>false</c>.</returns>
public static bool TrySetAttributes(this DirectoryInfo This, FileAttributes attributes)
{
#if NET40
Contract.Requires(This != null);
#endif
This.Refresh();
if (!This.Exists)
{
return(false);
}
if (This.Attributes == attributes)
{
return(true);
}
try {
This.Attributes = attributes;
return(true);
} catch (Exception) {
return(This.Attributes == attributes);
}
}
/// <summary>
/// Tries to set the creation time.
/// </summary>
/// <param name="This">This DirectoryInfo.</param>
/// <param name="creationTimeUtc">The date&time.</param>
/// <returns><c>true</c> on success; otherwise, <c>false</c>.</returns>
public static bool TrySetCreationTimeUtc(this DirectoryInfo This, DateTime creationTimeUtc)
{
#if NET40
Contract.Requires(This != null);
#endif
This.Refresh();
if (!This.Exists)
{
return(false);
}
if (This.CreationTimeUtc == creationTimeUtc)
{
return(true);
}
try {
This.CreationTimeUtc = creationTimeUtc;
return(true);
} catch (Exception) {
return(This.CreationTimeUtc == creationTimeUtc);
}
}
