public SupportPackageDataProvider([NotNull] IFileSystemEntry source, [CanBeNull] IReadOnlyCollection <ServerRole> roles, [CanBeNull] Action <string> logger)
{
Source = source;
var packageFilePath = source.FullName;
SourcePath = packageFilePath;
FileName = Path.GetFileName(packageFilePath);
Roles = roles;
Logger = logger;
Assert.ArgumentNotNull(packageFilePath, nameof(packageFilePath));
if (File.Exists(packageFilePath))
{
TempFolderPath = Path.GetTempFileName() + "dt";
if (!Directory.Exists(TempFolderPath))
{
Directory.CreateDirectory(TempFolderPath);
}
logger?.Invoke($"Unpacking {packageFilePath} to {TempFolderPath}");
UnpackZip(packageFilePath, TempFolderPath);
}
else if (Directory.Exists(packageFilePath))
{
TempFolderPath = packageFilePath;
}
else
{
throw new InvalidOperationException("Neither file nor folder exists: " + packageFilePath);
}
}
private void RequestFiles(IFileSystemEntry entry)
{
if (!_machineAvailable)
{
return;
}
if (FolderMode)
{
return;
}
_entryFilter[entry] = GetSelectedFilter();
List <FileSystemEntry> childEntries = ConnectionStore.Connections[Machine].ServiceHandler.Service
.GetFileSystemEntries(BuildPath(entry), _entryFilter[entry]).Select(x => x.FromDTO())
.Where(x => !x.IsFolder).OrderBy(x => x.Name).ToList();
_entryTree.Where(x => x.Value == entry && !x.Key.IsFolder).ToList().ForEach(x => _entryTree.Remove(x));
childEntries.ForEach(childEntry => _entryTree.Add(childEntry, entry));
FileSystemTreeNode treeNode = _entryNodes[entry];
treeNode.ChildEntries = treeNode.ChildEntries.Where(x => x.IsFolder).Concat(childEntries).ToList();
}
internal void RemoveItem(IFileSystemEntry item)
{
if (myItems.ContainsKey(item.Path))
{
myItems.Remove(item.Path);
}
}
public static IEnumerable<FileSystemEntryComparison> CompareTo(this IFileSystemEntry referenceEntry,
IFileSystemEntry currentEntry)
{
var currentEntries = currentEntry.Traverse().ToList();
var referenceEntries = referenceEntry.Traverse().ToList();
foreach (var refEntry in referenceEntries)
{
if (currentEntries.Any(c =>
{
_stringComparison = StringComparison.OrdinalIgnoreCase;
return c.Path.Equals(refEntry.Path, _stringComparison);
}))
{
yield return new FileSystemEntryComparison
{
Result = FileSystemEntryComparisonResult.Intact,
ReferenceFileSystemEntry = refEntry,
CurrentFileSystemEntries = currentEntries.Where(c => c.Path.Equals(refEntry.Path, _stringComparison))
};
continue;
}
var newLocations = currentEntries.Where(c => c.Name.Equals(refEntry.Name, _stringComparison)).ToList();
if (newLocations.Any())
{
yield return new FileSystemEntryComparison
{
Result = FileSystemEntryComparisonResult.Moved,
ReferenceFileSystemEntry = refEntry,
CurrentFileSystemEntries = newLocations
};
continue;
}
yield return new FileSystemEntryComparison
{
Result = FileSystemEntryComparisonResult.Removed,
ReferenceFileSystemEntry = refEntry
};
}
var addedEntries = currentEntries.Except(referenceEntries, new FileSystemEntryNameComparer()).ToList();
if (addedEntries.Any())
{
foreach (var addedEntry in addedEntries)
{
yield return new FileSystemEntryComparison
{
Result = FileSystemEntryComparisonResult.Added,
ReferenceFileSystemEntry = null,
CurrentFileSystemEntries = new List<IFileSystemEntry> { addedEntry }
};
}
}
}
private static void PrintingFilesAndDirectories(IFileSystemEntry fileSystemEntry, string prefix)
{
Console.WriteLine(prefix + fileSystemEntry.Name);
foreach (var x in fileSystemEntry.Enteries)
{
PrintingFilesAndDirectories(x, prefix + "\t");
}
}
public static IDirectory[] DecompressMegaPackage(IFileSystemEntry file, IDirectory extracted)
{
var files = extracted.GetFiles();
if (files.Length > 2) // in mega there are collectionLog.html and optional index.html (SDT report included by SupportPackage.aspx)
{
return(new IDirectory[] { extracted });
}
var directories = extracted.GetDirectories();
if (directories.Length == 0)
{
var zipFiles = extracted.GetFiles("*.zip");
if (zipFiles.Length == 0)
{
throw new InvalidOperationException("Mega package does not contain enither subfolders or inner zip files: " + file);
}
var newDirs = new List <IDirectory>();
foreach (var zipFile in zipFiles)
{
var newDir = extracted.GetChildDirectory(zipFile.NameWithoutExtension);
zipFile.ExtractZipToDirectory(newDir);
newDirs.Add(newDir);
}
directories = newDirs.ToArray();
}
// workaround for #197008 - we need to expand .link.link.link before .link.link and before .link
var linkFiles = extracted.GetFiles("*.link", SearchOption.AllDirectories);
if (linkFiles.Length == 0)
{
return(directories);
}
var depth = linkFiles.Max(x => GetDepth(x.Name));
for (var i = depth; i > 0; --i)
{
var suffix = Enumerable.Repeat(".link", i).JoinToString("");
foreach (var directory in directories)
{
var links = directory.GetFiles("*" + suffix, SearchOption.AllDirectories);
foreach (var link in links)
{
TryExpandingLinkFile(link);
}
}
}
return(directories);
}
private static IEnumerable<IFileSystemEntry> Traverse(this IFileSystemEntry root)
{
var stack = new Stack<IFileSystemEntry>();
stack.Push(root);
while (stack.Count > 0)
{
var current = stack.Pop();
yield return current;
foreach (var child in current.Children)
stack.Push(child);
}
}
private string BuildPath(IFileSystemEntry entry)
{
string path = entry.Name;
IFileSystemEntry parentEntry;
while (_entryTree.TryGetValue(entry, out parentEntry))
{
path = Path.Combine(FixPath(parentEntry.Name), path);
entry = parentEntry;
}
return(FixPath(path));
}
public void Add(IFileSystemEntry entry, int priority = 0)
{
if (!entry.IsFolder)
{
return;
}
lock (_lock)
{
_queuedEntries.Add(new PrioritizedFileSystemEntry(entry, priority));
OrderQueue();
}
}
public void IncreasePriority(IFileSystemEntry entry, int priorityIncrement = 1)
{
lock (_lock)
{
PrioritizedFileSystemEntry prioritizedEntry = _queuedEntries.FirstOrDefault(x => x.Entry == entry);
if (prioritizedEntry == null)
{
return;
}
prioritizedEntry.Priority += priorityIncrement;
OrderQueue();
}
}
public IFile CopyTo(IFileSystemEntry dirOrFile, bool overwrite)
{
var target = dirOrFile.Path;
if (dirOrFile is IDirectory)
{
target = System.IO.Path.Combine(dirOrFile.Path, Name);
}
File.Copy(Path, target, overwrite);
return(FileSystem.File(target));
}
/// <inheritdoc/>
public async ValueTask PutFileAsync(IFileSystemEntry entry, CancellationToken cancellationToken = default)
{
var options = new BlobUploadOptions
{
HttpHeaders = new BlobHttpHeaders
{
ContentType = entry.ContentType,
}
};
// TODO: Check file size limit here.
using Stream stream = await entry.CreateReadStreamAsync();
_ = await this.container.GetBlobClient(entry.Name).UploadAsync(stream, options, cancellationToken);
}
private void WriteFileSystemEntry(IFileSystemEntry entry)
{
switch (entry)
{
case FileModel model:
fileRepository.WriteFile(model);
return;
case DirectoryModel model:
directoryRepository.WriteDirectory(model);
return;
default:
throw new NotImplementedException($"Unsupported FileSystemEntry type: {entry}");
}
}
/// <inheritdoc/>
public async Task <IImageResolver> GetAsync(HttpContext context)
{
if (!Udi.TryParse(context.Request.Host + context.Request.Path, out Udi udi) ||
udi.EntityType != Constants.UdiEntityTypes.MediaFile ||
udi.EntityType.Type != UdiType.ClosedString)
{
return(null);
}
IFileSystemEntry file = await this.fileSystem.GetFileAsync(udi.Id, default);
if (file is null)
{
return(null);
}
return(new FileSystemImageResolver(file));
}
public bool TryGetEntry(string name, out IFileSystemEntry entry)
{
if (isDisposed)
{
throw new ObjectDisposedException(nameof(DirectoryEntry));
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(name));
}
entry = directory.GetDirectoryEntries()
.Where(x => x.Name == name)
.Select(x => new FileSystemEntry(x))
.FirstOrDefault();
return(entry != null);
}
public void QuickSortFullTest()
{
FileSystemManager manager = FileSystemManager.Get();
CancellationToken cancellationToken = new();
IList <IFileSystemEntry> entries = new List <IFileSystemEntry>();
string path = @"C:\Users\julie\Documents";
manager.GetFileSystemEntries(path, cancellationToken, entries, (IList <IFileSystemEntry> list, IFileSystemEntry entry) => { list.Add(entry); });
IFileSystemEntry[] array = new IFileSystemEntry[entries.Count];
entries.CopyTo(array, 0);
QuickSort.Sort(array, 0, array.Length - 1);
for (int i = 0; i < array.Length - 1; i++)
{
Assert.IsFalse(array[i].CompareTo(array[i + 1]) > 0, nameof(array) + " is not sorted.");
}
}
private void GetFileSystemEntries(IFileSystemEntry rootDirectory)
{
var dirs = ListDirectories(rootDirectory);
foreach (var dir in dirs)
{
rootDirectory.Children.Add(CreateDir(dir));
}
foreach (var file in Directory.GetFiles(rootDirectory.Path))
{
rootDirectory.Children.Add(CreateFile(file));
}
foreach (var dir in dirs)
{
GetFileSystemEntries(rootDirectory.Children.Single(c => c.Path == dir));
}
}
private async Task SendResponseAsync(
IFileSystemEntry entry,
MediaContext mediaContext,
Stream stream,
TimeSpan maxAge)
{
mediaContext.ComprehendRequestHeaders(entry.LastModifiedUtc, entry.ContentLength);
switch (mediaContext.GetPreconditionState())
{
case MediaContext.PreconditionState.Unspecified:
case MediaContext.PreconditionState.ShouldProcess:
if (mediaContext.IsHeadRequest())
{
await mediaContext.SendStatusAsync(ResponseConstants.Status200Ok, entry.ContentType, maxAge);
return;
}
this.logger.LogFileServed(mediaContext.GetDisplayUrl(), entry.Name);
await mediaContext.SendAsync(stream, entry.ContentType, maxAge);
return;
case MediaContext.PreconditionState.NotModified:
this.logger.LogFileNotModified(mediaContext.GetDisplayUrl());
await mediaContext.SendStatusAsync(ResponseConstants.Status304NotModified, entry.ContentType, maxAge);
return;
case MediaContext.PreconditionState.PreconditionFailed:
this.logger.LogFilePreconditionFailed(mediaContext.GetDisplayUrl());
await mediaContext.SendStatusAsync(ResponseConstants.Status412PreconditionFailed, entry.ContentType, maxAge);
return;
default:
var exception = new NotImplementedException(mediaContext.GetPreconditionState().ToString());
Debug.Fail(exception.ToString());
throw exception;
}
}
/// <inheritdoc/>
public async ValueTask PutFileAsync(IFileSystemEntry entry, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested)
{
await ValueTaskEx.FromCanceled(cancellationToken);
}
string name = entry.Name;
string path = Path.Combine(this.root, ToFilePath(name));
string directory = Path.GetDirectoryName(path);
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
using Stream stream = await entry.CreateReadStreamAsync();
using FileStream fileStream = File.Create(path);
await stream.CopyToAsync(fileStream, cancellationToken);
}
public ResourceEntry(int resourceId, IFileSystemEntry fileSystemEntry)
{
ResourceId = resourceId;
if (fileSystemEntry != null)
{
IsDirectory = fileSystemEntry.IsDirectory;
Name = fileSystemEntry.Name;
if (!IsDirectory)
{
using (Stream stream = fileSystemEntry.OpenStream())
{
CopyStream(stream);
}
}
}
else
{
Name = null;
IsDirectory = true;
}
}
// checks if item belongs to this directory recursively
private bool ItemIsChild(IFileSystemEntry item)
{
if (!item.Path.StartsWith(Path, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
var itemParent = item.Parent;
while (itemParent != null)
{
if (Equals(itemParent))
{
return(true);
}
itemParent = itemParent.Parent;
}
return(false);
}
public IFile CopyTo(IFileSystemEntry dirOrFile, bool overwrite)
{
var directory = dirOrFile as IDirectory;
if (directory == null)
{
directory = ((IFile)dirOrFile).Parent;
}
if (!directory.Exists)
{
directory.Create();
}
var targetFile = (FileImpl)directory.File(Name);
targetFile.CreateOnDemand();
targetFile.myContent = new byte[myContent.Length];
Array.Copy(myContent, targetFile.myContent, myContent.Length);
return(targetFile);
}
private void ListView_DoubleClick(object sender, EventArgs e)
{
if (listView.SelectedItems.Count != 1)
{
return;
}
IFileSystemEntry entry = ((FileSystemListViewItem)listView.SelectedItems[0]).Entry;
if (entry.IsFolder)
{
FileSystemTreeNode treeNode = _entryNodes[entry];
Task.Run(() => TaskActionWrapper.Do(() =>
{
ExpandTreeNode(treeNode.Parent);
SelectTreeNode(treeNode);
}));
}
else
{
buttonOK.PerformClick();
}
}
public bool Equals(IFileSystemEntry other)
{
return(Equals(( object )other));
}
public FileSystemEntryInfo(IFileSystemEntry entry)
{
Name = entry.Name;
VirtualPath = entry.VirtualPath;
PublicUri = entry.PublicUri;
IsDirectory = entry is IDirectory;
if (!IsDirectory)
{
Length = ((IFile)entry).Length;
}
}
private static string[] ListDirectories(IFileSystemEntry rootDirectory)
{
return(Directory.GetDirectories(rootDirectory.Path));
}
public PrioritizedFileSystemEntry(IFileSystemEntry entry, int priority)
{
Entry = entry;
Priority = priority;
}
public static bool IsChownPermissionsOk(this IFileSystemEntry entry, uint newUID, uint newGID)
{
var userUID = Syscall.getuid();
return(userUID == 0 || (entry.UID == newUID && (entry.GID == newGID || userUID == entry.UID)));
}
internal void RemoveItem( IFileSystemEntry item )
{
if( myItems.ContainsKey( item.Path ) )
{
myItems.Remove( item.Path );
}
}
internal void AddItem( IFileSystemEntry item )
{
myItems[ item.Path ] = item;
}
public static int CountAllEntries(this IFileSystemEntry listOfEntries)
{
return listOfEntries.Traverse().Count();
}
internal void AddItem(IFileSystemEntry item)
{
myItems[item.Path] = item;
}
/// <summary>Constructor.</summary>
/// <param name="item"><see cref="IFileSystemEntry"/> to decorate</param>
public FileSystemEntryViewModel(IFileSystemEntry item)
{
pathItem = item;
item.PropertyChanged += OnItemPropertyChanged;
}
public bool Equals(IFileSystemEntry entry)
{
return this.FileSystemPath.Equals(entry.FileSystemPath);
}
