Initial project's source code check-in.
This commit is contained in:
ptsurbeleu
commit
b03b0b373f
4573 changed files with 981205 additions and 0 deletions
951
WebsitePanel/Sources/WebsitePanel.Server.Utils/FileUtils.cs
Normal file
951
WebsitePanel/Sources/WebsitePanel.Server.Utils/FileUtils.cs
Normal file
|
|
@ -0,0 +1,951 @@
|
|||
// Copyright (c) 2011, Outercurve Foundation.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// - Redistributions of source code must retain the above copyright notice, this
|
||||
// list of conditions and the following disclaimer.
|
||||
//
|
||||
// - Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// - Neither the name of the Outercurve Foundation nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from this
|
||||
// software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Text;
|
||||
using System.Text.RegularExpressions;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Diagnostics;
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using System.Reflection;
|
||||
using Ionic.Zip;
|
||||
using WebsitePanel.Providers.OS;
|
||||
|
||||
|
||||
namespace WebsitePanel.Providers.Utils
|
||||
{
|
||||
/// <summary>
|
||||
/// Summary description for FileUtils.
|
||||
/// </summary>
|
||||
public class FileUtils
|
||||
{
|
||||
public static string EvaluateSystemVariables(string str)
|
||||
{
|
||||
if (String.IsNullOrEmpty(str))
|
||||
return str;
|
||||
|
||||
Regex re = new Regex("%(.+)%", RegexOptions.IgnoreCase);
|
||||
return re.Replace(str, new MatchEvaluator(EvaluateSystemVariable));
|
||||
}
|
||||
|
||||
public static string GetExecutablePathWithoutParameters(string path)
|
||||
{
|
||||
if (String.IsNullOrEmpty(path))
|
||||
return path;
|
||||
|
||||
int idx = -1;
|
||||
int exeIdx = path.ToLower().IndexOf(".exe");
|
||||
int dllIdx = path.ToLower().IndexOf(".dll");
|
||||
|
||||
if (exeIdx != -1)
|
||||
idx = exeIdx;
|
||||
|
||||
if (dllIdx != -1)
|
||||
idx = dllIdx;
|
||||
|
||||
if (exeIdx != -1 && dllIdx != -1)
|
||||
{
|
||||
idx = exeIdx;
|
||||
if (dllIdx < exeIdx)
|
||||
idx = dllIdx;
|
||||
}
|
||||
|
||||
string execPath = path;
|
||||
if (idx != -1)
|
||||
{
|
||||
execPath = path.Substring(0, idx + 4);
|
||||
if (execPath.StartsWith("\""))
|
||||
execPath = execPath.Substring(1);
|
||||
}
|
||||
|
||||
return execPath;
|
||||
}
|
||||
|
||||
public static string CorrectRelativePath(string relativePath)
|
||||
{
|
||||
// clean path
|
||||
string correctedPath = Regex.Replace(relativePath.Replace("/", "\\"),
|
||||
@"\.\\|\.\.|\\\\|\?|\:|\""|\<|\>|\||%|\$", "");
|
||||
if (correctedPath.StartsWith("\\"))
|
||||
correctedPath = correctedPath.Substring(1);
|
||||
return correctedPath;
|
||||
}
|
||||
|
||||
private static string EvaluateSystemVariable(Match match)
|
||||
{
|
||||
return Environment.GetEnvironmentVariable(match.Groups[1].Value);
|
||||
}
|
||||
|
||||
public static bool FileExists(string path)
|
||||
{
|
||||
return File.Exists(path);
|
||||
}
|
||||
|
||||
public static bool DirectoryExists(string path)
|
||||
{
|
||||
return Directory.Exists(path);
|
||||
}
|
||||
|
||||
public static string CreatePackageFolder(string initialPath)
|
||||
{
|
||||
// substitute vars
|
||||
initialPath = FileUtils.EvaluateSystemVariables(initialPath);
|
||||
|
||||
int i = 0;
|
||||
string path = null;
|
||||
while (true)
|
||||
{
|
||||
path = initialPath + ((i == 0) ? "" : i.ToString());
|
||||
if (!FileUtils.DirectoryExists(path))
|
||||
{
|
||||
// create directory
|
||||
FileUtils.CreateDirectory(path);
|
||||
break;
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
// Set permissions
|
||||
// We decided to inherit NTFS permissions from the parent folder to comply with with the native security schema in Windows,
|
||||
// when a user decides on his own how to implement security practices for NTFS permissions schema and harden the server.
|
||||
SecurityUtils.GrantNtfsPermissionsBySid(path, SystemSID.ADMINISTRATORS, NTFSPermission.FullControl, true, true);
|
||||
SecurityUtils.GrantNtfsPermissionsBySid(path, SystemSID.SYSTEM, NTFSPermission.FullControl, true, true);
|
||||
//
|
||||
return path;
|
||||
}
|
||||
|
||||
public static SystemFile GetFile(string path)
|
||||
{
|
||||
if (!File.Exists(path))
|
||||
return null;
|
||||
|
||||
FileInfo file = new FileInfo(path);
|
||||
return new SystemFile(file.Name, file.FullName, false, file.Length,
|
||||
file.CreationTime, file.LastWriteTime);
|
||||
}
|
||||
|
||||
public static SystemFile[] GetFiles(string path)
|
||||
{
|
||||
ArrayList items = new ArrayList();
|
||||
DirectoryInfo root = new DirectoryInfo(path);
|
||||
|
||||
// get directories
|
||||
DirectoryInfo[] dirs = root.GetDirectories();
|
||||
foreach (DirectoryInfo dir in dirs)
|
||||
{
|
||||
string fullName = System.IO.Path.Combine(path, dir.Name);
|
||||
SystemFile fi = new SystemFile(dir.Name, fullName, true, 0, dir.CreationTime, dir.LastWriteTime);
|
||||
items.Add(fi);
|
||||
|
||||
// check if the directory is empty
|
||||
fi.IsEmpty = (Directory.GetFileSystemEntries(fullName).Length == 0);
|
||||
}
|
||||
|
||||
// get files
|
||||
FileInfo[] files = root.GetFiles();
|
||||
foreach (FileInfo file in files)
|
||||
{
|
||||
string fullName = System.IO.Path.Combine(path, file.Name);
|
||||
SystemFile fi = new SystemFile(file.Name, fullName, false, file.Length, file.CreationTime, file.LastWriteTime);
|
||||
items.Add(fi);
|
||||
}
|
||||
|
||||
return (SystemFile[])items.ToArray(typeof(SystemFile));
|
||||
}
|
||||
|
||||
public static SystemFile[] GetFilesRecursive(string rootFolder, string path)
|
||||
{
|
||||
return GetFilesRecursiveByPattern(rootFolder, path, "*.*");
|
||||
}
|
||||
|
||||
public static SystemFile[] GetFilesRecursiveByPattern(string rootFolder, string path, string pattern)
|
||||
{
|
||||
// parse pattern
|
||||
string[] patterns = new string[] { pattern };
|
||||
if (pattern.IndexOf("|") != -1 || pattern.IndexOf(";") != -1)
|
||||
patterns = pattern.Split(new char[] { '|', ';' });
|
||||
|
||||
// get files
|
||||
ArrayList files = new ArrayList();
|
||||
foreach (string ptrn in patterns)
|
||||
GetFilesList(files, rootFolder, path, ptrn);
|
||||
return (SystemFile[])files.ToArray(typeof(SystemFile));
|
||||
}
|
||||
|
||||
private static void GetFilesList(ArrayList files, string rootFolder, string folder, string pattern)
|
||||
{
|
||||
string fullPath = System.IO.Path.Combine(rootFolder, folder);
|
||||
|
||||
// add files in the current folder
|
||||
FileInfo[] dirFiles = new DirectoryInfo(fullPath).GetFiles(pattern);
|
||||
foreach (FileInfo file in dirFiles)
|
||||
{
|
||||
SystemFile fi = new SystemFile(folder + "\\" + file.Name, file.Name, false, file.Length,
|
||||
file.CreationTime, file.LastWriteTime);
|
||||
files.Add(fi);
|
||||
}
|
||||
|
||||
// add children folders
|
||||
|
||||
DirectoryInfo[] dirs = new DirectoryInfo(fullPath).GetDirectories();
|
||||
foreach (DirectoryInfo dir in dirs)
|
||||
{
|
||||
GetFilesList(files, rootFolder, System.IO.Path.Combine(folder, dir.Name), pattern);
|
||||
}
|
||||
}
|
||||
|
||||
public static SystemFile[] GetDirectoriesRecursive(string rootFolder, string path)
|
||||
{
|
||||
ArrayList folders = new ArrayList();
|
||||
GetDirectoriesRecursive(folders, rootFolder, path);
|
||||
return (SystemFile[])folders.ToArray(typeof(SystemFile));
|
||||
}
|
||||
|
||||
private static void GetDirectoriesRecursive(ArrayList folders, string rootFolder, string folder)
|
||||
{
|
||||
// add the current folder
|
||||
SystemFile fi = new SystemFile("\\" + folder, folder, true, 0, DateTime.Now, DateTime.Now);
|
||||
folders.Add(fi);
|
||||
|
||||
// add children folders
|
||||
string fullPath = System.IO.Path.Combine(rootFolder, folder);
|
||||
DirectoryInfo dir = new DirectoryInfo(fullPath);
|
||||
fi.Created = dir.CreationTime;
|
||||
fi.Changed = dir.LastWriteTime;
|
||||
DirectoryInfo[] subDirs = dir.GetDirectories();
|
||||
foreach (DirectoryInfo subDir in subDirs)
|
||||
{
|
||||
GetDirectoriesRecursive(folders, rootFolder, System.IO.Path.Combine(folder, subDir.Name));
|
||||
}
|
||||
}
|
||||
|
||||
public static byte[] GetFileBinaryContent(string path)
|
||||
{
|
||||
if (!File.Exists(path))
|
||||
return null;
|
||||
|
||||
FileStream stream = new FileStream(path, FileMode.Open);
|
||||
if (stream == null)
|
||||
return null;
|
||||
|
||||
long length = stream.Length;
|
||||
byte[] content = new byte[length];
|
||||
stream.Read(content, 0, (int)length);
|
||||
stream.Close();
|
||||
return content;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns file contents trying to read according to file contents
|
||||
/// </summary>
|
||||
/// <param name="path">Path to the file.</param>
|
||||
/// <param name="encoding">Current file encoding.</param>
|
||||
/// <returns>Array of bytes.</returns>
|
||||
/// <remarks>
|
||||
/// It uses UTF8 by default, so in case incorrect or not supported encoding name
|
||||
/// UTF8 will be used to read file contents and convert it to the byte array.
|
||||
/// </remarks>
|
||||
public static byte[] GetFileBinaryContent(string path, string encoding)
|
||||
{
|
||||
if (!File.Exists(path))
|
||||
return null;
|
||||
|
||||
Encoding fileEncoding = GetEncodingByNameOrDefault(encoding, Encoding.UTF8);
|
||||
|
||||
string fileContent = String.Empty;
|
||||
using (StreamReader sr = new StreamReader(path, fileEncoding))
|
||||
{
|
||||
fileContent = sr.ReadToEnd();
|
||||
}
|
||||
|
||||
return fileEncoding.GetBytes(fileContent).Clone() as byte[];
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns <see cref="Encoding"/> from <paramref name="encoding"/> name specified.
|
||||
/// If cannot find <see cref="Encoding"/>, returns <paramref name="defaultEncoding"/>.
|
||||
/// </summary>
|
||||
/// <param name="encoding">The name of the encoding to return.</param>
|
||||
/// <param name="defaultEncoding"><see cref="Encoding"/> that will be returned if no <paramref name="encoding"/> will be found.</param>
|
||||
/// <returns>
|
||||
/// <see cref="Encoding"/> from the <paramref name="encoding"/> name specified,
|
||||
/// otherwise <paramref name="defaultEncoding"/>.
|
||||
/// </returns>
|
||||
private static Encoding GetEncodingByNameOrDefault(string encoding, Encoding defaultEncoding)
|
||||
{
|
||||
Encoding currentEncoding = defaultEncoding;
|
||||
|
||||
try
|
||||
{
|
||||
currentEncoding = Encoding.GetEncoding(encoding);
|
||||
}
|
||||
catch(ArgumentException)
|
||||
{
|
||||
// this encoding is either no supported or incorrect
|
||||
// set to default encoding
|
||||
currentEncoding = defaultEncoding;
|
||||
}
|
||||
|
||||
return currentEncoding;
|
||||
}
|
||||
|
||||
public static Stream GetFileBinaryContentStream(string path)
|
||||
{
|
||||
if (!File.Exists(path))
|
||||
return null;
|
||||
|
||||
return new FileStream(path, FileMode.Open);
|
||||
}
|
||||
|
||||
public static byte[] GetFileBinaryChunk(string path, int offset, int length)
|
||||
{
|
||||
if (!File.Exists(path))
|
||||
return null;
|
||||
|
||||
FileStream stream = new FileStream(path, FileMode.Open);
|
||||
if (stream == null)
|
||||
return null;
|
||||
|
||||
if (offset > 0)
|
||||
stream.Seek(offset, SeekOrigin.Begin);
|
||||
|
||||
byte[] content = new byte[length];
|
||||
int readBytes = stream.Read(content, 0, length);
|
||||
stream.Close();
|
||||
|
||||
if (readBytes < length)
|
||||
{
|
||||
byte[] lastContent = new byte[readBytes];
|
||||
if (readBytes > 0)
|
||||
{
|
||||
Array.Copy(content, 0, lastContent, 0, readBytes);
|
||||
}
|
||||
// avoiding of getting empty content
|
||||
if (lastContent.Length == 0)
|
||||
{
|
||||
lastContent = new byte[] { 1 };
|
||||
}
|
||||
return lastContent;
|
||||
}
|
||||
else
|
||||
{
|
||||
return content;
|
||||
}
|
||||
}
|
||||
|
||||
public static string GetFileTextContent(string path)
|
||||
{
|
||||
StreamReader reader = new StreamReader(path);
|
||||
string content = reader.ReadToEnd();
|
||||
reader.Close();
|
||||
return content;
|
||||
}
|
||||
|
||||
public static void UpdateFileBinaryContent(string path, byte[] content)
|
||||
{
|
||||
FileStream stream = new FileStream(path, FileMode.Create);
|
||||
stream.Write(content, 0, content.Length);
|
||||
stream.Close();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Updates file contents using encoding.
|
||||
/// </summary>
|
||||
/// <param name="path">Path to the file.</param>
|
||||
/// <param name="content">File contents.</param>
|
||||
/// <param name="encoding">Current file encoding.</param>
|
||||
/// <remarks>
|
||||
/// It uses UTF8 by default, so in case incorrect or not supported encoding name is submitted,
|
||||
/// then UTF8 will be used to convert bytes to file contents.
|
||||
/// </remarks>
|
||||
public static void UpdateFileBinaryContent(string path, byte[] content, string encoding)
|
||||
{
|
||||
Encoding fileEncoding = GetEncodingByNameOrDefault(encoding, Encoding.UTF8);
|
||||
|
||||
using (StreamWriter sw = new StreamWriter(File.Create(path), fileEncoding))
|
||||
{
|
||||
sw.Write(
|
||||
fileEncoding.GetString(content)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
public static void AppendFileBinaryContent(string path, byte[] chunk)
|
||||
{
|
||||
FileStream stream = new FileStream(path, FileMode.Append, FileAccess.Write);
|
||||
stream.Write(chunk, 0, chunk.Length);
|
||||
stream.Close();
|
||||
}
|
||||
|
||||
public static void UpdateFileTextContent(string path, string content)
|
||||
{
|
||||
StreamWriter stream = new StreamWriter(path);
|
||||
stream.Write(content);
|
||||
stream.Close();
|
||||
}
|
||||
|
||||
public static void CreateFile(string path)
|
||||
{
|
||||
FileStream stream = File.Create(path);
|
||||
stream.Close();
|
||||
}
|
||||
|
||||
public static void ChangeFileAttributes(string path, DateTime createdTime, DateTime changedTime)
|
||||
{
|
||||
if (Directory.Exists(path))
|
||||
{
|
||||
Directory.SetCreationTime(path, createdTime);
|
||||
Directory.SetLastWriteTime(path, changedTime);
|
||||
}
|
||||
else if (File.Exists(path))
|
||||
{
|
||||
File.SetCreationTime(path, createdTime);
|
||||
File.SetLastWriteTime(path, changedTime);
|
||||
}
|
||||
}
|
||||
|
||||
public static void DeleteFile(string path)
|
||||
{
|
||||
if (File.Exists(path))
|
||||
File.Delete(path);
|
||||
else
|
||||
if (Directory.Exists(path))
|
||||
Directory.Delete(path, true);
|
||||
|
||||
}
|
||||
|
||||
public static void DeleteFiles(string[] files)
|
||||
{
|
||||
foreach (string file in files)
|
||||
DeleteFile(file);
|
||||
}
|
||||
|
||||
public static void DeleteEmptyDirectories(string[] directories)
|
||||
{
|
||||
foreach (string directory in directories)
|
||||
DeleteEmptyDirectoryRecursive(directory);
|
||||
}
|
||||
|
||||
private static bool DeleteEmptyDirectoryRecursive(string directory)
|
||||
{
|
||||
if (!Directory.Exists(directory))
|
||||
return true;
|
||||
|
||||
// iterate through child folders
|
||||
bool empty = true;
|
||||
string[] dirs = Directory.GetDirectories(directory);
|
||||
foreach (string dir in dirs)
|
||||
{
|
||||
if (!DeleteEmptyDirectoryRecursive(dir))
|
||||
empty = false;
|
||||
}
|
||||
|
||||
string[] files = Directory.GetFiles(directory);
|
||||
empty = empty && (files.Length == 0);
|
||||
|
||||
// try to delete directory
|
||||
if (empty)
|
||||
Directory.Delete(directory);
|
||||
|
||||
return empty;
|
||||
}
|
||||
|
||||
public static void MoveFile(string sourcePath, string destinationPath)
|
||||
{
|
||||
if (File.Exists(sourcePath))
|
||||
{
|
||||
File.Move(sourcePath, destinationPath);
|
||||
}
|
||||
else if (Directory.Exists(sourcePath))
|
||||
{
|
||||
Directory.Move(sourcePath, destinationPath);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new Exception("Specified file is not found!");
|
||||
}
|
||||
|
||||
// reset NTFS permissions on destination file/folder
|
||||
SecurityUtils.ResetNtfsPermissions(destinationPath);
|
||||
}
|
||||
|
||||
public static void CopyFile(string sourcePath, string destinationPath)
|
||||
{
|
||||
if (File.Exists(sourcePath))
|
||||
{
|
||||
File.Copy(sourcePath, destinationPath, true);
|
||||
}
|
||||
else if (Directory.Exists(sourcePath))
|
||||
{
|
||||
CopyDirectory(sourcePath, destinationPath);
|
||||
}
|
||||
else
|
||||
{
|
||||
throw new Exception("Specified file is not found!");
|
||||
}
|
||||
|
||||
// reset NTFS permissions on destination file/folder
|
||||
SecurityUtils.ResetNtfsPermissions(destinationPath);
|
||||
}
|
||||
|
||||
private static void CopyDirectory(string sourceDir, string destinationDir)
|
||||
{
|
||||
// create directory
|
||||
DirectoryInfo srcDir = new DirectoryInfo(sourceDir);
|
||||
if(!Directory.Exists(destinationDir))
|
||||
Directory.CreateDirectory(destinationDir);
|
||||
|
||||
// create subdirectories
|
||||
DirectoryInfo[] dirs = srcDir.GetDirectories();
|
||||
foreach (DirectoryInfo dir in dirs)
|
||||
{
|
||||
CopyDirectory(System.IO.Path.Combine(sourceDir, dir.Name),
|
||||
System.IO.Path.Combine(destinationDir, dir.Name));
|
||||
}
|
||||
|
||||
// copy files
|
||||
FileInfo[] files = srcDir.GetFiles();
|
||||
foreach (FileInfo file in files)
|
||||
{
|
||||
// copy file
|
||||
file.CopyTo(System.IO.Path.Combine(destinationDir, file.Name), true);
|
||||
}
|
||||
}
|
||||
|
||||
public static void CreateDirectory(string path)
|
||||
{
|
||||
if (!Directory.Exists(path))
|
||||
{
|
||||
// create directory structure
|
||||
Directory.CreateDirectory(path);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public static void ZipFiles(string zipFile, string rootPath, string[] files)
|
||||
{
|
||||
using (ZipFile zip = new ZipFile())
|
||||
{
|
||||
//use unicode if necessary
|
||||
zip.UseUnicodeAsNecessary = true;
|
||||
zip.UseZip64WhenSaving = Zip64Option.AsNecessary;
|
||||
|
||||
//skip locked files
|
||||
zip.ZipErrorAction = ZipErrorAction.Skip;
|
||||
foreach (string file in files)
|
||||
{
|
||||
string fullPath = Path.Combine(rootPath, file);
|
||||
if (Directory.Exists(fullPath))
|
||||
{
|
||||
//add directory with the same directory name
|
||||
zip.AddDirectory(fullPath, file);
|
||||
}
|
||||
else if (File.Exists(fullPath))
|
||||
{
|
||||
//add file to the root folder
|
||||
zip.AddFile(fullPath, "");
|
||||
}
|
||||
}
|
||||
zip.Save(zipFile);
|
||||
}
|
||||
}
|
||||
|
||||
public static string[] UnzipFiles(string zipFile, string destFolder)
|
||||
{
|
||||
using (ZipFile zip = ZipFile.Read(zipFile))
|
||||
{
|
||||
foreach (ZipEntry e in zip)
|
||||
{
|
||||
// Remove Read-Only attribute from a zip entry
|
||||
if ((e.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
|
||||
e.Attributes ^= FileAttributes.ReadOnly;
|
||||
//
|
||||
e.Extract(destFolder, ExtractExistingFileAction.OverwriteSilently);
|
||||
}
|
||||
}
|
||||
|
||||
List<string> files = new List<string>();
|
||||
foreach(SystemFile systemFile in GetFiles(destFolder))
|
||||
{
|
||||
files.Add(systemFile.FullName);
|
||||
}
|
||||
|
||||
return files.ToArray();
|
||||
}
|
||||
|
||||
private static void CreateDirectoriesStructure(string path)
|
||||
{
|
||||
string dir = System.IO.Path.GetDirectoryName(path);
|
||||
if (!Directory.Exists(dir))
|
||||
{
|
||||
// create directory structure
|
||||
Directory.CreateDirectory(dir);
|
||||
}
|
||||
}
|
||||
|
||||
public static string ExecuteSystemCommand(string cmd, string args)
|
||||
{
|
||||
return ExecuteSystemCommand(cmd, args, null);
|
||||
}
|
||||
|
||||
public static string ExecuteSystemCommand(string cmd, string args, string outputFile)
|
||||
{
|
||||
// launch system process
|
||||
ProcessStartInfo startInfo = new ProcessStartInfo(cmd, args);
|
||||
startInfo.WindowStyle = ProcessWindowStyle.Hidden;
|
||||
startInfo.RedirectStandardOutput = true;
|
||||
startInfo.UseShellExecute = false;
|
||||
startInfo.CreateNoWindow = true;
|
||||
|
||||
// get working directory from executable path
|
||||
startInfo.WorkingDirectory = Path.GetDirectoryName(cmd);
|
||||
Process proc = Process.Start(startInfo);
|
||||
|
||||
|
||||
// analyze results
|
||||
StreamReader reader = proc.StandardOutput;
|
||||
string results = "";
|
||||
if (!String.IsNullOrEmpty(outputFile))
|
||||
{
|
||||
// stream to writer
|
||||
StreamWriter writer = new StreamWriter(outputFile);
|
||||
int BUFFER_LENGTH = 2048;
|
||||
int readBytes = 0;
|
||||
char[] buffer = new char[BUFFER_LENGTH];
|
||||
while ((readBytes = reader.Read(buffer, 0, BUFFER_LENGTH)) > 0)
|
||||
{
|
||||
writer.Write(buffer, 0, readBytes);
|
||||
}
|
||||
writer.Close();
|
||||
}
|
||||
else
|
||||
{
|
||||
// return as string
|
||||
results = reader.ReadToEnd();
|
||||
}
|
||||
reader.Close();
|
||||
|
||||
return results;
|
||||
}
|
||||
|
||||
public static void ExecuteCmdCommand(string command)
|
||||
{
|
||||
ProcessStartInfo ProcessInfo;
|
||||
Process process;
|
||||
|
||||
ProcessInfo = new ProcessStartInfo("cmd.exe", "/C " + command);
|
||||
ProcessInfo.CreateNoWindow = true;
|
||||
ProcessInfo.UseShellExecute = false;
|
||||
process = Process.Start(ProcessInfo);
|
||||
if (process != null)
|
||||
{
|
||||
process.WaitForExit(500);
|
||||
process.Close();
|
||||
}
|
||||
}
|
||||
|
||||
public static void SaveStreamToFile(Stream stream, string path)
|
||||
{
|
||||
try
|
||||
{
|
||||
//Create a file to save to
|
||||
Stream toStream = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
|
||||
|
||||
//use the binary reader & writer because
|
||||
//they can work with all formats
|
||||
//i.e images, text files ,avi,mp3..
|
||||
BinaryReader br = new BinaryReader(stream);
|
||||
BinaryWriter bw = new BinaryWriter(toStream);
|
||||
|
||||
//copy data from the FromStream to the outStream
|
||||
//convert from long to int
|
||||
bw.Write(br.ReadBytes((int)stream.Length));
|
||||
|
||||
//save
|
||||
bw.Flush();
|
||||
|
||||
//clean up
|
||||
bw.Close();
|
||||
br.Close();
|
||||
}
|
||||
//use Exception e as it can handle any exception
|
||||
catch
|
||||
{
|
||||
//code if u like
|
||||
}
|
||||
}
|
||||
|
||||
public static long CalculateFolderSize(string path)
|
||||
{
|
||||
int files = 0;
|
||||
int folders = 0;
|
||||
// check directory exists
|
||||
if (!Directory.Exists(path))
|
||||
return 0;
|
||||
// normalize path
|
||||
path = path.Replace("/", "\\");
|
||||
// remove trailing slash
|
||||
if (path.EndsWith(@"\"))
|
||||
path = path.Substring(0, path.Length - 1);
|
||||
// calculate folder size
|
||||
return CalculateFolderSize(path, out files, out folders);
|
||||
}
|
||||
|
||||
private static long CalculateFolderSize(string path, out int files, out int folders)
|
||||
{
|
||||
files = 0;
|
||||
folders = 0;
|
||||
|
||||
IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
|
||||
long size = 0;
|
||||
FindData findData = new FindData();
|
||||
|
||||
IntPtr findHandle;
|
||||
|
||||
findHandle = path.StartsWith("\\\\")
|
||||
? Kernel32.FindFirstFile(path + @"\*", findData)
|
||||
: Kernel32.FindFirstFile(@"\\?\" + path + @"\*", findData);
|
||||
if (findHandle != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
|
||||
do
|
||||
{
|
||||
if ((findData.fileAttributes & (int)FileAttributes.Directory) != 0)
|
||||
{
|
||||
|
||||
if (findData.fileName != "." && findData.fileName != "..")
|
||||
{
|
||||
folders++;
|
||||
|
||||
int subfiles, subfolders;
|
||||
string subdirectory = path + (path.EndsWith(@"\") ? "" : @"\") +
|
||||
findData.fileName;
|
||||
size += CalculateFolderSize(subdirectory, out subfiles, out subfolders);
|
||||
folders += subfolders;
|
||||
files += subfiles;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// File
|
||||
files++;
|
||||
|
||||
size += (long)findData.nFileSizeLow + (long)findData.nFileSizeHigh * 4294967296;
|
||||
}
|
||||
}
|
||||
while (Kernel32.FindNextFile(findHandle, findData));
|
||||
Kernel32.FindClose(findHandle);
|
||||
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
public static void CreateAccessDatabase(string databasePath)
|
||||
{
|
||||
if (String.IsNullOrEmpty(databasePath))
|
||||
throw new ArgumentException("databasePath");
|
||||
|
||||
string connectionString = String.Format("Provider=Microsoft.Jet.OLEDB.4.0;Data Source={0};Jet OLEDB:Engine Type=5;Mode=Share Deny None;Jet OLEDB:Database Locking Mode=0",
|
||||
databasePath);
|
||||
|
||||
Type adoxType = Type.GetTypeFromProgID("ADOX.Catalog");
|
||||
object cat = Activator.CreateInstance(adoxType);
|
||||
adoxType.InvokeMember("Create", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod,
|
||||
null, cat, new object[] { connectionString });
|
||||
object conn = adoxType.InvokeMember("ActiveConnection", BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty,
|
||||
null, cat, null);
|
||||
adoxType.InvokeMember("Close", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null,
|
||||
conn, null);
|
||||
cat = null;
|
||||
}
|
||||
#region Advanced Delete
|
||||
/// <summary>
|
||||
/// Deletes the specified file.
|
||||
/// </summary>
|
||||
/// <param name="fileName">The name of the file to be deleted.</param>
|
||||
public static void DeleteFileAdvanced(string fileName)
|
||||
{
|
||||
int attempts = 0;
|
||||
while (true)
|
||||
{
|
||||
try
|
||||
{
|
||||
DeleteFileInternal(fileName);
|
||||
break;
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
if (attempts > 2)
|
||||
throw;
|
||||
|
||||
attempts++;
|
||||
System.Threading.Thread.Sleep(1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deletes the specified file.
|
||||
/// </summary>
|
||||
/// <param name="fileName">The name of the file to be deleted.</param>
|
||||
private static void DeleteReadOnlyFile(string fileName)
|
||||
{
|
||||
FileInfo info = new FileInfo(fileName);
|
||||
info.Attributes = FileAttributes.Normal;
|
||||
info.Delete();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deletes the specified file.
|
||||
/// </summary>
|
||||
/// <param name="fileName">The name of the file to be deleted.</param>
|
||||
private static void DeleteFileInternal(string fileName)
|
||||
{
|
||||
try
|
||||
{
|
||||
File.Delete(fileName);
|
||||
}
|
||||
catch (UnauthorizedAccessException)
|
||||
{
|
||||
DeleteReadOnlyFile(fileName);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deletes the specified directory.
|
||||
/// </summary>
|
||||
/// <param name="directory">The name of the directory to be deleted.</param>
|
||||
public static void DeleteDirectoryAdvanced(string directory)
|
||||
{
|
||||
if (!Directory.Exists(directory))
|
||||
return;
|
||||
|
||||
// iterate through child folders
|
||||
string[] dirs = Directory.GetDirectories(directory);
|
||||
foreach (string dir in dirs)
|
||||
{
|
||||
DeleteDirectoryAdvanced(dir);
|
||||
}
|
||||
|
||||
// iterate through child files
|
||||
string[] files = Directory.GetFiles(directory);
|
||||
foreach (string file in files)
|
||||
{
|
||||
DeleteFileAdvanced(file);
|
||||
}
|
||||
|
||||
//try to delete dir for 3 times
|
||||
int attempts = 0;
|
||||
while (true)
|
||||
{
|
||||
try
|
||||
{
|
||||
DeleteDirectoryInternal(directory);
|
||||
break;
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
if (attempts > 2)
|
||||
throw;
|
||||
|
||||
attempts++;
|
||||
System.Threading.Thread.Sleep(1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deletes the specified directory.
|
||||
/// </summary>
|
||||
/// <param name="directory">The name of the directory to be deleted.</param>
|
||||
public static void DeleteDirectoryInternal(string directory)
|
||||
{
|
||||
try
|
||||
{
|
||||
Directory.Delete(directory);
|
||||
}
|
||||
catch (IOException)
|
||||
{
|
||||
DeleteReadOnlyDirectory(directory);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Deletes the specified directory.
|
||||
/// </summary>
|
||||
/// <param name="directory">The name of the directory to be deleted.</param>
|
||||
private static void DeleteReadOnlyDirectory(string directory)
|
||||
{
|
||||
DirectoryInfo info = new DirectoryInfo(directory);
|
||||
info.Attributes = FileAttributes.Normal;
|
||||
info.Delete();
|
||||
}
|
||||
#endregion
|
||||
|
||||
}
|
||||
|
||||
#region File Size Calculation helper classes
|
||||
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
||||
class FindData
|
||||
{
|
||||
public int fileAttributes;
|
||||
public int creationTime_lowDateTime;
|
||||
public int creationTime_highDateTime;
|
||||
public int lastAccessTime_lowDateTime;
|
||||
public int lastAccessTime_highDateTime;
|
||||
public int lastWriteTime_lowDateTime;
|
||||
public int lastWriteTime_highDateTime;
|
||||
public uint nFileSizeHigh;
|
||||
public uint nFileSizeLow;
|
||||
public int dwReserved0;
|
||||
public int dwReserved1;
|
||||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
|
||||
public String fileName;
|
||||
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
|
||||
public String alternateFileName;
|
||||
}
|
||||
|
||||
class Kernel32
|
||||
{
|
||||
[DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
|
||||
public static extern IntPtr FindFirstFile(String fileName, [In, Out] FindData findFileData);
|
||||
|
||||
[DllImport("kernel32", CharSet = CharSet.Auto)]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
public static extern bool FindNextFile(IntPtr hFindFile, [In, Out] FindData lpFindFileData);
|
||||
|
||||
[DllImport("kernel32", CharSet = CharSet.Auto)]
|
||||
[return: MarshalAs(UnmanagedType.Bool)]
|
||||
public static extern bool FindClose(IntPtr hFindFile);
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue