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);
     }
 }
Ejemplo n.º 5
0
 /// <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);
     }
 }
Ejemplo n.º 6
0
        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());
                }
            }
        }
Ejemplo n.º 7
0
        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)));
        }
Ejemplo n.º 10
0
 /// <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));
     }
 }
Ejemplo n.º 11
0
        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);
            }
        }
Ejemplo n.º 12
0
 /// <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));
		}
Ejemplo n.º 15
0
        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));
     }
 }
Ejemplo n.º 17
0
        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));
            }
        }
Ejemplo n.º 18
0
        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);
		}
Ejemplo n.º 22
0
        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));
        }
Ejemplo n.º 26
0
        /// <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;
			}
		}
Ejemplo n.º 28
0
        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;
            }
        }
Ejemplo n.º 29
0
        /// <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);
        }
Ejemplo n.º 33
0
        /// <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);
        }
Ejemplo n.º 35
0
        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);
		}
Ejemplo n.º 43
0
 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);
			}
Ejemplo n.º 47
0
        /// <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);