protected internal NetworkDirectory(IFileSystem fileSystem, INodeAddress address) : base(fileSystem, address) { this.directoryRefreshInfo = new Pair <DirectoryRefreshMask, int> { Left = DirectoryRefreshMask.All, Right = 0 }; }
public ImaginaryMemoryFile(IFileSystem fileSystem, INodeAddress address, Func <byte[]> valueProvider, Predicate <ImaginaryMemoryFile> existsProvider) : base(fileSystem, address) { this.valueProvider = valueProvider; this.existsProvider = existsProvider; if (this.valueProvider != null) { Create(); } this.Attributes.AttributeValueGetFilter = delegate(string name, object value) { if (this.existsProvider == null) { return(value); } if (name.Equals("exists", StringComparison.CurrentCultureIgnoreCase)) { return(this.existsProvider(this)); } return(value); }; }
internal INode GetOverlay(INodeAddress nodeAddress, NodeType nodeType) { lock (this.FileSystems) { return(OverlayNode(nodeAddress, this.OverlayedNodeSelector.SelectReadNode(this, nodeAddress, nodeType))); } }
protected virtual void AddToCache(INodeAddress address, INode node) { lock (this.cache) { this.cache.Add(address, node); } }
/// <summary> /// <see cref="INode.Resolve(string, NodeType, AddressScope)"/> /// </summary> protected override INode CreateNode(INodeAddress address, NodeType nodeType) { if (nodeType == NodeType.File) { return(new LocalFile(this, (LocalNodeAddress)address)); } else if (nodeType == NodeType.Directory) { return(new LocalDirectory(this, (LocalNodeAddress)address)); } else if (nodeType == NodeType.Any) { if (Directory.Exists(address.RootUri + address.AbsolutePath)) { return(new LocalDirectory(this, (LocalNodeAddress)address)); } else { return(new LocalFile(this, (LocalNodeAddress)address)); } } else { throw new NodeTypeNotSupportedException(nodeType); } }
protected override INode CreateNode(INodeAddress address, NodeType nodeType) { lock (this) { string path; if (nodeType.Equals(NodeType.File)) { path = ((AbstractNodeAddressWithRootPart)address).AbsolutePathIncludingRootPart; return(new ZipFile(this, (LayeredNodeAddress)address, GetEntry(path))); } else if (nodeType.Equals(NodeType.Directory)) { path = ((AbstractNodeAddressWithRootPart)address).AbsolutePathIncludingRootPart; if (path != FileSystemManager.SeperatorString) { path += "/"; } return(new ZipDirectory(this, (LayeredNodeAddress)address, GetEntry(path))); } else { throw new NotSupportedException(nodeType.ToString()); } } }
protected AbstractNode(IFileSystem fileSystem, INodeAddress nodeAddress) { this.Address = nodeAddress; this.FileSystem = fileSystem; this.autoLock = new AutoLock(this.SyncLock); }
public virtual void Add(INodeAddress address, INode node) { lock (this.SyncLock) { this.cache[this.GetKey(address, node.NodeType)] = node; } }
public virtual bool ParentsEqual(INodeAddress nodeAddress, StringComparison comparisonType) { if (this.Depth != nodeAddress.Depth) { return(false); } if (this.IsRoot) { return(true); } var x = this.AbsolutePath.LastIndexOf('/'); var y = nodeAddress.AbsolutePath.LastIndexOf('/'); if (x == -1) { return(false); } if (x != y) { return(false); } return(String.Equals(this.AbsolutePath.Substring(0, x), nodeAddress.AbsolutePath.Substring(0, y))); }
/// <summary> /// Gets a node from this <see cref="IFileSystem"/>'s <see cref="INodeCache"/>. /// </summary> /// <remarks> /// Nodes are with the same address are equivalent. <c>INodeAddress.Equals()</c> is used to compare nodes. /// </remarks> /// <param name="address">The address of the node.</param> /// <param name="nodeType"> /// The type of node to look for. If the this argument is <see cref="NodeType.Any"/> then the first node /// of any type that exists in the cache is returned. If more than one node type with the same address /// exists in the cache then the node that is returned will be one of the nodes that match but the exact /// <see cref="NodeType"/> returned is non-deterministic. /// </param> /// <returns></returns> protected INode GetFromCache(INodeAddress address, NodeType nodeType) { lock (this.cache) { return(this.cache.Get(address, nodeType)); } }
public INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { if (nodeType.GetType().IsGenericType&& nodeType.GetType().GetGenericTypeDefinition() == typeof(DataFileNodeType <>)) { var innerNodeType = nodeType.InnerType ?? NodeType.File; var file = (IFile)resolver.Resolve(address.PathAndQuery, innerNodeType); var dataFileType = typeof(DataFile <>); dataFileType = dataFileType.MakeGenericType(nodeType.GetType().GetGenericArguments()); var dataFile = (INode)Activator.CreateInstance(dataFileType, file, nodeType); canCache = true; return(dataFile); } else { canCache = false; return(null); } }
/// <summary> /// Initializes a new instance of the <see cref="BlobFile" /> class. /// </summary> /// <param name="fileSystem">The file system.</param> /// <param name="address">The address.</param> /// <exception cref="ArgumentOutOfRangeException"/> /// <exception cref="ArgumentNullException"/> public BlobFile(BlobFileSystem fileSystem, INodeAddress address) : base(address, fileSystem) { _blobContainer = fileSystem.BlobClient.GetContainerReference(address.PathToDepth(1).Substring(1)); _path = string.Join("/", Address.AbsolutePath.Split('/').Where((item, index) => index > 1)); _blockBlob = _blobContainer.GetBlockBlobReference(_path); }
protected override INode CreateNode(INodeAddress address, NodeType nodeType) { if (!address.IsRoot) { var parent = (IDirectory)this.Resolve(address.Parent, NodeType.Directory); if (parent is ImaginaryDirectory) { var retval = ((ImaginaryDirectory)parent).GetImaginaryChild(address.Name, nodeType); if (retval != null) { return(retval); } } } if (nodeType == NodeType.Directory) { return(new ImaginaryDirectory(this, address)); } else if (nodeType == NodeType.File) { return(new ImaginaryFile(this, address)); } throw new NotSupportedException(String.Format("{0}:{1}", address, nodeType)); }
protected override INode CreateNode(INodeAddress address, NodeType nodeType) { if (!address.IsRoot) { var parent = (IDirectory)this.Resolve(address.Parent, NodeType.Directory); if (parent is ImaginaryDirectory) { var retval = ((ImaginaryDirectory)parent).GetImaginaryChild(address.Name, nodeType); if (retval != null) { return retval; } } } if (nodeType == NodeType.Directory) { return new ImaginaryDirectory(this, address); } else if (nodeType == NodeType.File) { return new ImaginaryFile(this, address); } throw new NotSupportedException(String.Format("{0}:{1}", address, nodeType)); }
protected virtual INode Find(INodeAddress nodeAddress, NodeType nodeType, FileSystemOptions options) { var rootAddress = nodeAddress.ResolveAddress(FileSystemManager.RootPath); options = options ?? FileSystemOptions.Default; var fileSystem = this.FindFileSystem(rootAddress, options); if (fileSystem == null) { bool cache; fileSystem = NewFileSystem(rootAddress, options, out cache); fileSystem.Closed += FileSystem_Closed; if (cache) { AddFileSystem(rootAddress, fileSystem, options); AddFileSystem(rootAddress, fileSystem, fileSystem.Options); } } return(fileSystem.Resolve(nodeAddress, nodeType)); }
public virtual void Purge(INodeAddress address, NodeType nodeType) { lock (this.SyncLock) { this.cache.Remove(this.GetKey(address, nodeType)); } }
public override INode Resolve(INodeAddress address, NodeType nodeType) { lock (this) { CheckAndReload(); if (nodeType == NodeType.Any) { var node = this.Resolve(address, NodeType.File); if (node.Exists) { return(node); } node = Resolve(address, NodeType.Directory); if (node.Exists) { return(node); } return(base.Resolve(address, NodeType.Directory)); } return(base.Resolve(address, nodeType)); } }
public override INode Resolve(INodeAddress address, NodeType nodeType) { if (nodeType == NodeType.Any) { INode node; node = Resolve(address, NodeType.File); if (node.Exists) { return(node); } node = Resolve(address, NodeType.Directory); if (node.Exists) { return(node); } return(base.Resolve(address, NodeType.File)); } // LocalFileSystem always refreshes node before returning it return(base.Resolve(address, nodeType).Refresh()); }
public INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { if (nodeType.GetType().IsGenericType && nodeType.GetType().GetGenericTypeDefinition() == typeof(DataFileNodeType<>)) { var innerNodeType = nodeType.InnerType ?? NodeType.File; var file = (IFile)resolver.Resolve(address.PathAndQuery, innerNodeType); var dataFileType = typeof(DataFile<>); dataFileType = dataFileType.MakeGenericType(nodeType.GetType().GetGenericArguments()); var dataFile = (INode)Activator.CreateInstance(dataFileType, file, nodeType); canCache = true; return dataFile; } else { canCache = false; return null; } }
protected override IFileSystem NewFileSystem(INodeAddress rootAddress, FileSystemOptions options, out bool cache) { var backingFile = this.Manager.ResolveFile(((LayeredNodeAddress)rootAddress).InnerUri); cache = true; return new ZipFileSystem(rootAddress, backingFile, this.AmmendOptionsFromAddress(backingFile.Address, options)); }
protected override IFileSystem NewFileSystem(INodeAddress rootAddress, FileSystemOptions options, out bool cache) { var backingFile = this.Manager.ResolveFile(((LayeredNodeAddress)rootAddress).InnerUri); cache = options.ReadOnly; return new ZipFileSystem(rootAddress, backingFile, options); }
protected override IFileSystem NewFileSystem(INodeAddress rootAddress, FileSystemOptions options, out bool cache) { var backingFile = this.Manager.ResolveFile(((LayeredNodeAddress)rootAddress).InnerUri); cache = options.ReadOnly; return(new ZipFileSystem(rootAddress, backingFile, options)); }
public virtual string GetRelativePathTo(INodeAddress name) { if (!this.RootUri.Equals(name.RootUri)) { throw new ArgumentOutOfRangeException(name.ToString()); } return(GetRelativePathTo(name.AbsolutePath)); }
protected override IFileSystem NewFileSystem(INodeAddress rootAddress, FileSystemOptions options, out bool cache) { var layeredAddress = (LayeredNodeAddress)rootAddress; var components = layeredAddress.InnerUri.Split(';'); var fileSystems = components.Select(s => this.Manager.Resolve(s).FileSystem).ToList(); cache = true; return new OverlayedFileSystem(fileSystems, options); }
protected override IFileSystem NewFileSystem(INodeAddress rootAddress, FileSystemOptions options, out bool cache) { var layeredAddress = (LayeredNodeAddress)rootAddress; var components = layeredAddress.InnerUri.Split(';'); var fileSystems = components.Select(s => this.Manager.Resolve(s).FileSystem).ToList(); cache = true; return(new OverlayedFileSystem(fileSystems, options)); }
/// <summary> /// Creates the node. /// </summary> /// <param name="address">The address.</param> /// <param name="nodeType">Type of the node.</param> /// <returns></returns> protected override INode CreateNode(INodeAddress address, NodeType nodeType) { lock (this) { if (nodeType.Equals(NodeType.File)) return new PgpFile(this, address, ParentLayer); throw new NodeTypeNotSupportedException(nodeType); } }
public NodeNotFoundException(INodeAddress nodeAddress, NodeType nodeType, Exception innerException) : base(nodeAddress != null ? "VirtualFileSystem item not found: " + nodeAddress.ToString() : "", innerException) { NodeType = nodeType; NodeAddress = nodeAddress; if (NodeAddress != null) { Uri = NodeAddress.Uri; } }
/// <summary> /// Creates the node. /// </summary> /// <param name="address">The address.</param> /// <param name="nodeType">Type of the node.</param> /// <returns></returns> /// <exception cref="NodeTypeNotSupportedException"></exception> protected override INode CreateNode(INodeAddress address, NodeType nodeType) { if (nodeType == NodeType.Directory) return new BlobDirectory(this, address); if (nodeType == NodeType.File || nodeType == NodeType.Any) { return new BlobFile(this, address); } throw new NodeTypeNotSupportedException(nodeType); }
/// <summary> /// Initializes the file system with the supplied <c>rootAddress</c>, <c>parentLayer</c> and <c>options</c>. /// </summary> /// <param name="rootAddress"> /// The rootAddress for the file system. All nodes in the file system are relative to the root name.</param> /// <param name="parentLayer"> /// The parent layer for this file system or <c>null</c> if this <see cref="IFileSystem"/> is not layered. /// </param> /// <param name="options"> /// The options for creating this <c>FileSystem.</c> /// </param> protected AbstractFileSystem(INodeAddress rootAddress, IFile parentLayer, FileSystemOptions options) { this.cache = (INodeCache)Activator.CreateInstance(options.NodeCacheType); this.ParentLayer = parentLayer; this.rootAddress = rootAddress; this.Options = options; this.autoLock = new AutoLock(this); InitializeConstruction(rootAddress, parentLayer, options); this.Extenders = CreateExtenders(); CreateSecurityManager(); }
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { value = "true"; } else { try { if (address.QueryValues[QueryKey] == null) { return null; } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { value = null; } } if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true") { canCache = true; var innerNodeType = nodeType.InnerType; if (innerNodeType == null) { innerNodeType = NodeType.File; } var query = StringUriUtils.BuildQuery ( address.QueryValues, QueryFilter ); var uri = address.AbsolutePath + "?" + query; return new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address); } return null; }
public virtual INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { value = "true"; } else { try { if (address.QueryValues[QueryKey] == null) { return(null); } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { value = null; } } if (nodeType.Equals(NodeType.File) && value != null && value.ToLower() == "true") { canCache = true; var innerNodeType = nodeType.InnerType; if (innerNodeType == null) { innerNodeType = NodeType.File; } var query = StringUriUtils.BuildQuery ( address.QueryValues, QueryFilter ); var uri = address.AbsolutePath + "?" + query; return(new ShadowFile((IFile)resolver.Resolve(uri, innerNodeType), address)); } return(null); }
/// <summary> /// Constructs a new <c>ZipFileSystem</c> /// </summary> /// <param name="rootAddress">The root address of the zip file system.</param> /// <param name="zipFile">The zip file that hosts the file system.</param> /// <param name="options">Options for the file system.</param> public ZipFileSystem(INodeAddress rootAddress, IFile zipFile, FileSystemOptions options) : base(rootAddress, GetZipFile(zipFile), options) { this.changeDeterminer = new AttributeChangeDeterminer(ParentLayer, "LastWriteTime", "Length"); this.OpenZlib(); this.RefreshNodeInfos(); if (zipFile.SupportsActivityEvents && options.ReadOnly) { zipFile.Activity += new NodeActivityEventHandler(ZipFile_Activity); } }
protected virtual INode OverlayNode(INodeAddress nodeAddress, INode node) { if (node.NodeType.Equals(NodeType.File)) { return(new OverlayedFile(this, nodeAddress, (IFile)node)); } if (node.NodeType.Equals(NodeType.Directory)) { return(new OverlayedDirectory(this, nodeAddress, (IDirectory)node)); } throw new NodeTypeNotSupportedException(node.NodeType); }
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { return(null); } else { try { if (address.QueryValues[this.QueryKey] == null) { return(null); } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { return(null); } } if (nodeType.Equals(NodeType.File)) { canCache = true; var query = StringUriUtils.BuildQuery ( address.QueryValues, pair => pair.Key.Equals(this.QueryKey, StringComparison.CurrentCultureIgnoreCase) ); var uri = address.AbsolutePath + "?" + query; var file = resolver.ResolveFile(uri); var service = (ITempIdentityFileService)file.GetService(new TempIdentityFileServiceType(value)); canCache = true; return(service.GetTempFile()); } return(null); }
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { string value; canCache = false; if (this.QueryKey == null) { return null; } else { try { if (address.QueryValues[this.QueryKey] == null) { return null; } value = (string)address.QueryValues[this.QueryKey]; } catch (KeyNotFoundException) { return null; } } if (nodeType.Equals(NodeType.File)) { canCache = true; var query = StringUriUtils.BuildQuery ( address.QueryValues, pair => pair.Key.Equals(this.QueryKey, StringComparison.CurrentCultureIgnoreCase) ); var uri = address.AbsolutePath + "?" + query; var file = resolver.ResolveFile(uri); var service = (ITempIdentityFileService)file.GetService(new TempIdentityFileServiceType(value)); canCache = true; return service.GetTempFile(); } return null; }
public ImaginaryDirectory(IFileSystem fileSystem, INodeAddress address) : base(fileSystem, address) { Comparison <Pair <string, NodeType> > comparison = delegate(Pair <string, NodeType> p1, Pair <string, NodeType> p2) { if (p1.Right != p2.Right) { return(-1); } return(StringComparer.CurrentCultureIgnoreCase.Compare(p1.Left, p2.Left)); }; this.children = new SortedDictionary <Pair <string, NodeType>, INode>(new ComparisonComparer <Pair <string, NodeType> >(comparison)); }
protected override INode CreateNode(INodeAddress name, NodeType nodeType) { if (nodeType == NodeType.Directory) { return new WebDirectory(this, name); } else if (nodeType == NodeType.File || nodeType == NodeType.Any) { return new WebFile(this, name); } else { throw new NodeTypeNotSupportedException(nodeType); } }
protected override INode CreateNode(INodeAddress address, NodeType nodeType) { if (nodeType == NodeType.Directory) { return(new NetworkDirectory(this, address)); } else if (nodeType == NodeType.File || nodeType == NodeType.Any) { return(new NetworkFile(this, address)); } else { throw new NodeTypeNotSupportedException(nodeType); } }
public ImaginaryDirectory(IFileSystem fileSystem, INodeAddress address) : base(fileSystem, address) { Comparison<Pair<string, NodeType>> comparison = delegate(Pair<string, NodeType> p1, Pair<string, NodeType> p2) { if (p1.Right != p2.Right) { return -1; } return StringComparer.CurrentCultureIgnoreCase.Compare(p1.Left, p2.Left); }; this.children = new SortedDictionary<Pair<string, NodeType>, INode>(new ComparisonComparer<Pair<string, NodeType>>(comparison)); }
protected override IFileSystem NewFileSystem(INodeAddress rootAddress, FileSystemOptions options, out bool cache) { FileSystemOptions modifiedOptions; if (!modifiedFileSystemOptions.TryGetValue(options, out modifiedOptions)) { modifiedOptions = options.CreateWithAdditionalConfig(this.configuration); modifiedFileSystemOptions[options] = modifiedOptions; } cache = true; return(new LocalFileSystem(rootAddress, modifiedOptions)); }
protected override IFileSystem NewFileSystem(INodeAddress rootAddress, FileSystemOptions options, out bool cache) { FileSystemOptions modifiedOptions; if (!modifiedFileSystemOptions.TryGetValue(options, out modifiedOptions)) { modifiedOptions = options.CreateWithAdditionalConfig(this.configuration); modifiedFileSystemOptions[options] = modifiedOptions; } cache = true; return new LocalFileSystem(rootAddress, modifiedOptions); }
protected override INode CreateNode(INodeAddress name, NodeType nodeType) { if (nodeType == NodeType.Directory) { return(new WebDirectory(this, name)); } else if (nodeType == NodeType.File || nodeType == NodeType.Any) { return(new WebFile(this, name)); } else { throw new NodeTypeNotSupportedException(nodeType); } }
protected virtual bool IsContainedInShortcut(INodeAddress address) { INodeAddress tempAddress; if (address.IsRoot) { return(false); } if (this.shortcutAddresses.Count == 0) { return(false); } var addressKey = address; if (this.shortcutAddresses.TryGetValue(addressKey, out tempAddress)) { return(true); } foreach (var jumpPointAddress in this.shortcutAddresses.Values) { if (address.Depth < jumpPointAddress.Depth) { break; } if (jumpPointAddress.IsRoot) { continue; } var jumpPointParentAddress = jumpPointAddress.Parent; if (jumpPointParentAddress.AbsolutePath != address.PathToDepth(jumpPointParentAddress.Depth)) { continue; } if (address.IsDescendentOf(jumpPointAddress, StringComparison.CurrentCultureIgnoreCase, AddressScope.DescendentOrSelf)) { return(true); } } return(false); }
protected virtual FileSystemOptions AmmendOptionsFromAddress(INodeAddress address, FileSystemOptions options) { NameValueCollection variables = null; foreach (var key in address.QueryValues.Keys.Cast<string>().Where(key => this.SupportedUriSchemas.Any(c => key.StartsWith(c, StringComparison.InvariantCultureIgnoreCase)))) { if (variables == null) { variables = new NameValueCollection(); } variables[key] = address.QueryValues[key]; } return options.AddVariables(variables); }
public override INode Resolve(string name, NodeType nodeType, AddressScope scope) { if (this.parentAddress == null) { if (this.node.NodeType == NodeType.File) { this.parentAddress = this.node.Address.Parent; } else { this.parentAddress = this.node.Address; } } return this.node.FileSystem.Resolve(this.parentAddress.ResolveAddress(name).AbsolutePath, nodeType, scope); }
/// <summary> /// Initializes a new instance of the <see cref="BlobFileSystem" /> class. /// </summary> /// <param name="rootAddress">The root address.</param> /// <param name="options">The options.</param> protected internal BlobFileSystem(INodeAddress rootAddress, FileSystemOptions options) : base(rootAddress, null, options) { var nodeAddress = (StandardNodeAddress)rootAddress; if (nodeAddress.UserName != null && nodeAddress.UserName.EndsWith("==")) { var account = nodeAddress.HostName.Substring(0, nodeAddress.HostName.IndexOf('.')); var credentials = new StorageCredentials(account, nodeAddress.UserName); BlobClient = new CloudBlobClient(new Uri(rootAddress.RootUri), credentials); } else { var storageAccount = CloudStorageAccount.Parse( CloudConfigurationManager.GetSetting(nodeAddress.HostName)); BlobClient = storageAccount.CreateCloudBlobClient(); } }
protected override INode CreateNode(INodeAddress address, NodeType nodeType) { var retval = this.foriegnRoot.Resolve("." + address.PathAndQuery, nodeType, AddressScope.DescendentOrSelf); if (retval.NodeType.Is(NodeType.File)) { retval = new ViewFile(this, (ViewNodeAddress)address, (IFile)retval); } else if (retval.NodeType.Is(NodeType.Directory)) { retval = new ViewDirectory(this, (ViewNodeAddress)address, (IDirectory)retval); } else { throw new NotSupportedException(retval.NodeType.ToString()); } return retval; }
public override INode Filter(ref INodeResolver resolver, ref INodeAddress address, ref NodeType nodeType, out bool canCache) { MediaFileNodeType mediaFileNodeType; if ((mediaFileNodeType = (nodeType as MediaFileNodeType)) != null) { var file = resolver.ResolveFile(address.PathAndQuery); var mediaFile = MediaFileFactory.Default.NewMediaFile(file, mediaFileNodeType); canCache = !mediaFileNodeType.UniqueInstance; return mediaFile; } else { canCache = false; return null; } }
protected AbstractDirectory(IFileSystem fileSystem, INodeAddress address) : base(fileSystem, address) { }
public JumpPointFile(IFile file, INodeAddress address) : base(file) { this.address = address; }
protected AbstractFile(INodeAddress fileName, IFileSystem fileSystem) : base(fileSystem, fileName) { }
internal protected NetworkFileSystem(INodeAddress rootAddress, FileSystemOptions options) : base(rootAddress, null, options) { var comparer = ObjectReferenceIdentityEqualityComparer<INetworkFileSystemClient>.Default; this.freeClients = new TimedReferenceDictionary<INetworkFileSystemClient, INetworkFileSystemClient>(TimeSpan.FromMinutes(25), comparer); this.freeClientsForBinaryAccess = new TimedReferenceDictionary<INetworkFileSystemClient, INetworkFileSystemClient>(TimeSpan.FromMinutes(25), comparer); lock (staticFileSystemsCache) { IList<NetworkFileSystemWeakReference> fileSystems; var uniqueId = this.GetUniqueId(); if (!staticFileSystemsCache.TryGetValue(uniqueId, out fileSystems)) { fileSystems = new List<NetworkFileSystemWeakReference>(); staticFileSystemsCache[GetUniqueId()] = fileSystems; } fileSystems.Add(new NetworkFileSystemWeakReference(this)); } }
public ShadowFile(IFile file, INodeAddress address) : this(file, address, FileSystemManager.GetManager().Resolve("temp:///").FileSystem) { }
public ShadowFile(IFile file, INodeAddress address, IFileSystem tempFileSystem) : base(file) { this.address = address; this.tempFileSystem = tempFileSystem; }
protected virtual INode OverlayNode(INodeAddress nodeAddress, INode node) { if (node.NodeType.Equals(NodeType.File)) { return new OverlayedFile(this, nodeAddress, (IFile)node); } else if (node.NodeType.Equals(NodeType.Directory)) { return new OverlayedDirectory(this, nodeAddress, (IDirectory)node); } else { throw new NodeTypeNotSupportedException(node.NodeType); } }
public virtual bool SelectNodeForOperation(OverlayedFileSystem fileSystem, FileSystemActivity operation, INodeAddress address, NodeType nodeType, out INode[] nodes) { nodes = null; return false; }
public OverlayedDirectory(OverlayedFileSystem fileSystem, INodeAddress nodeAddress, IDirectory directory) : base(directory) { this.fileSystem = fileSystem; this.nodeAddress = nodeAddress; }
protected override INode CreateNode(INodeAddress address, NodeType nodeType) { return GetOverlay(address, nodeType); }
public abstract INode SelectReadNode(OverlayedFileSystem fileSystem, INodeAddress address, NodeType nodeType);