public IAbsolutePath ResolveAbsolutePath(string nativePath)
{
try
{
var absPath = Path.IsPathRooted(nativePath)
? nativePath
: Path.GetFullPath(nativePath);
var isDirectory = Directory.Exists(nativePath);
return(isDirectory
? (IAbsolutePath)AbsoluteDirectoryPath.Parse(absPath)
: (IAbsolutePath)AbsoluteFilePath.Parse(absPath));
}
catch (ArgumentException e)
{
throw new InvalidPath(nativePath, e);
}
catch (NotSupportedException e)
{
throw new InvalidPath(nativePath, e);
}
catch (PathTooLongException e)
{
throw new InvalidPath(nativePath, e);
}
}
public static AbsoluteFilePath GetCodeBaseFilePath(this Assembly assembly)
{
if (Platform.OperatingSystem == OS.Windows)
{
return(AbsoluteFilePath.Parse(assembly.CodeBase.StripPrefix("file:///")));
}
else
{
return(AbsoluteFilePath.Parse(assembly.CodeBase.StripPrefix("file://")));
}
}
void ReplaceAllDescendantPermissionsFromObject(
DirectoryInfo dInfo,
DirectorySecurity dSecurity,
FileSystemPermission fileSystemPermission,
FileSystemGroup group)
{
dInfo.SetAccessControl(dSecurity);
foreach (FileInfo fi in dInfo.GetFiles())
{
SetPermission(AbsoluteFilePath.Parse(fi.FullName), fileSystemPermission, group);
}
dInfo.GetDirectories().ToList()
.ForEach(d => ReplaceAllDescendantPermissionsFromObject(d, dSecurity, fileSystemPermission, group));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (objectType == typeof(AbsoluteFilePath))
{
return(AbsoluteFilePath.Parse((string)reader.Value));
}
if (objectType == typeof(RelativeFilePath))
{
return(RelativeFilePath.Parse((string)reader.Value));
}
if (objectType == typeof(AbsoluteDirectoryPath))
{
return(AbsoluteDirectoryPath.Parse((string)reader.Value));
}
if (objectType == typeof(RelativeDirectoryPath))
{
return(RelativeDirectoryPath.Parse((string)reader.Value));
}
throw new ArgumentException("The type '" + objectType.FullName + "' was not recognized by this converter");
}
public IObservable <FileSystemEventData> Watch(AbsoluteDirectoryPath path, Optional <string> filter = default(Optional <string>))
{
return(Observable.Create <FileSystemEventData>(observer =>
{
if (!Exists(path))
{
observer.OnError(new FileNotFoundException("Directory not found", path.ContainingDirectory.NativePath));
return Disposable.Empty;
}
var fsw = filter.Select(f => new FileSystemWatcher(path.NativePath, f)).Or(new FileSystemWatcher(path.NativePath));
fsw.IncludeSubdirectories = false;
fsw.NotifyFilter = NotifyFilters.CreationTime
| NotifyFilters.FileName
| NotifyFilters.LastWrite
| NotifyFilters.Size;
var garbage = Disposable.Combine(
fsw,
Observable.FromEventPattern <ErrorEventArgs>(fsw, "Error")
.Subscribe(_ => observer.OnError(_.EventArgs.GetException())),
Observable.FromEventPattern <FileSystemEventArgs>(fsw, "Changed")
.Subscribe(e => observer.OnNext(new FileSystemEventData(AbsoluteFilePath.Parse(e.EventArgs.FullPath), FileSystemEvent.Changed))),
Observable.FromEventPattern <FileSystemEventArgs>(fsw, "Created")
.Subscribe(e => observer.OnNext(new FileSystemEventData(AbsoluteFilePath.Parse(e.EventArgs.FullPath), FileSystemEvent.Created))),
Observable.FromEventPattern <RenamedEventArgs>(fsw, "Renamed")
.Subscribe(e =>
{
observer.OnNext(new FileSystemEventData(
AbsoluteFilePath.Parse(e.EventArgs.FullPath),
FileSystemEvent.Renamed,
AbsoluteFilePath.Parse(e.EventArgs.OldFullPath)));
}),
Observable.FromEventPattern <FileSystemEventArgs>(fsw, "Deleted")
.Subscribe(e => observer.OnNext(new FileSystemEventData(AbsoluteFilePath.Parse(e.EventArgs.FullPath), FileSystemEvent.Removed))));
fsw.EnableRaisingEvents = true;
return garbage;
}));
}
public void SetPermission(
AbsoluteDirectoryPath dir,
FileSystemPermission permission,
FileSystemGroup group,
bool recursive)
{
var permissionBits = GetPermissionBits(permission, group);
Syscall.chmod(dir.NativePath, (FilePermissions)permissionBits);
if (recursive)
{
foreach (var file in Directory.GetFiles(dir.NativePath))
{
var filePermission = (int)permission & ~(int)FileSystemPermission.Execute;
SetPermission(AbsoluteFilePath.Parse(file), (FileSystemPermission)filePermission, group);
}
foreach (var directory in Directory.GetDirectories(dir.NativePath))
{
SetPermission(AbsoluteDirectoryPath.Parse(directory), permission, group, recursive);
}
}
}
public static AbsoluteFilePath ToAbsoluteFilePath(this Uri uri)
{
return(AbsoluteFilePath.Parse(Uri.UnescapeDataString(uri.AbsolutePath)));
}
/// <exception cref="System.IO.IOException" />
public static AbsoluteFilePath CreateTempFile()
{
return(AbsoluteFilePath.Parse(Path.GetTempFileName()));
}
public static IFilePath Parse(string relativeOrAbsolutePath)
{
return(Path.IsPathRooted(relativeOrAbsolutePath)
? (IFilePath)AbsoluteFilePath.Parse(relativeOrAbsolutePath)
: (IFilePath)RelativeFilePath.Parse(relativeOrAbsolutePath));
}
