private static CachedPathData GetConfigPathData(string configPath)
        {
            bool exists      = false;
            bool isDirectory = false;
            bool flag3       = IsCachedPathDataRemovable(configPath);

            if (flag3 && DoNotCacheUrlMetadata)
            {
                string      str          = null;
                VirtualPath path         = null;
                string      physicalPath = null;
                WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out str, out path);
                physicalPath = GetPhysicalPath(path);
                CachedPathData configPathData = GetConfigPathData(System.Configuration.ConfigPathUtility.GetParent(configPath));
                if (!string.IsNullOrEmpty(physicalPath))
                {
                    System.Web.Util.FileUtil.PhysicalPathStatus(physicalPath, false, false, out exists, out isDirectory);
                }
                CachedPathData data2 = new CachedPathData(configPath, path, physicalPath, exists);
                data2.Init(configPathData);
                return(data2);
            }
            string         key           = CreateKey(configPath);
            CacheInternal  cacheInternal = HttpRuntime.CacheInternal;
            CachedPathData data3         = (CachedPathData)cacheInternal.Get(key);

            if (data3 != null)
            {
                data3.WaitForInit();
                return(data3);
            }
            bool            flag4        = false;
            string          siteID       = null;
            VirtualPath     vpath        = null;
            CachedPathData  parentData   = null;
            CacheDependency dependencies = null;
            string          str6         = null;

            string[] filenames = null;
            string[] cachekeys = null;
            if (WebConfigurationHost.IsMachineConfigPath(configPath))
            {
                flag4 = true;
            }
            else
            {
                string parent = System.Configuration.ConfigPathUtility.GetParent(configPath);
                parentData = GetConfigPathData(parent);
                string str8 = CreateKey(parent);
                cachekeys = new string[] { str8 };
                if (!WebConfigurationHost.IsVirtualPathConfigPath(configPath))
                {
                    flag4 = true;
                }
                else
                {
                    flag4 = !flag3;
                    WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out siteID, out vpath);
                    str6 = GetPhysicalPath(vpath);
                    if (!string.IsNullOrEmpty(str6))
                    {
                        System.Web.Util.FileUtil.PhysicalPathStatus(str6, false, false, out exists, out isDirectory);
                        if (exists && !isDirectory)
                        {
                            filenames = new string[] { str6 };
                        }
                    }
                }
                try
                {
                    dependencies = new CacheDependency(0, filenames, cachekeys);
                }
                catch
                {
                }
            }
            CachedPathData    data5             = null;
            bool              flag5             = false;
            bool              flag6             = false;
            CacheItemPriority priority          = flag4 ? CacheItemPriority.NotRemovable : CacheItemPriority.Normal;
            TimeSpan          slidingExpiration = flag4 ? Cache.NoSlidingExpiration : UrlMetadataSlidingExpiration;

            try
            {
                using (dependencies)
                {
                    data5 = new CachedPathData(configPath, vpath, str6, exists);
                    try
                    {
                    }
                    finally
                    {
                        data3 = (CachedPathData)cacheInternal.UtcAdd(key, data5, dependencies, Cache.NoAbsoluteExpiration, slidingExpiration, priority, s_callback);
                        if (data3 == null)
                        {
                            flag5 = true;
                        }
                    }
                }
                if (!flag5)
                {
                    data3.WaitForInit();
                    return(data3);
                }
                lock (data5)
                {
                    try
                    {
                        data5.Init(parentData);
                        flag6 = true;
                    }
                    finally
                    {
                        data5._flags[1] = true;
                        Monitor.PulseAll(data5);
                        if (data5._flags[0x40])
                        {
                            data5.Close();
                        }
                    }
                    return(data5);
                }
            }
            finally
            {
                if (flag5)
                {
                    if (!data5._flags[1])
                    {
                        lock (data5)
                        {
                            data5._flags[1] = true;
                            Monitor.PulseAll(data5);
                            if (data5._flags[0x40])
                            {
                                data5.Close();
                            }
                        }
                    }
                    if (!flag6 || ((data5.ConfigRecord != null) && data5.ConfigRecord.HasInitErrors))
                    {
                        if (dependencies != null)
                        {
                            if (!flag6)
                            {
                                dependencies = new CacheDependency(0, null, cachekeys);
                            }
                            else
                            {
                                dependencies = new CacheDependency(0, filenames, cachekeys);
                            }
                        }
                        using (dependencies)
                        {
                            cacheInternal.UtcInsert(key, data5, dependencies, DateTime.UtcNow.AddSeconds(5.0), Cache.NoSlidingExpiration, CacheItemPriority.Normal, s_callback);
                        }
                    }
                }
            }
            return(data5);
        }
示例#2
0
        // Example of configPath = "machine/webroot/1/fxtest/sub/foo.aspx"
        // The configPath parameter must be lower case.
        static private CachedPathData GetConfigPathData(string configPath)
        {
            Debug.Assert(ConfigPathUtility.IsValid(configPath), "ConfigPathUtility.IsValid(configPath)");
            Debug.Assert(configPath == configPath.ToLower(CultureInfo.InvariantCulture), "configPath == configPath.ToLower(CultureInfo.InvariantCulture)");
            bool exists      = false;
            bool isDirectory = false;
            bool isRemovable = IsCachedPathDataRemovable(configPath);

            // if the sliding expiration is zero, we won't cache it unless it is a configPath for root web.config or above
            if (isRemovable && DoNotCacheUrlMetadata)
            {
                string      pathSiteID       = null;
                VirtualPath virtualFilePath  = null;
                string      physicalFilePath = null;
                WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out pathSiteID, out virtualFilePath);
                physicalFilePath = GetPhysicalPath(virtualFilePath);

                string         parentConfigPath = ConfigPathUtility.GetParent(configPath);
                CachedPathData pathParentData   = GetConfigPathData(parentConfigPath);
                if (!String.IsNullOrEmpty(physicalFilePath))
                {
                    FileUtil.PhysicalPathStatus(physicalFilePath, false, false, out exists, out isDirectory);
                }
                CachedPathData pathData = new CachedPathData(configPath, virtualFilePath, physicalFilePath, exists);
                pathData.Init(pathParentData);

                return(pathData);
            }

            //
            // First, see if the CachedPathData is in the cache.
            // we don't use Add for this lookup, as doing so requires
            // creating a CacheDependency, which can be slow as it may hit
            // the filesystem.
            //
            string             key           = CreateKey(configPath);
            CacheStoreProvider cacheInternal = HttpRuntime.Cache.InternalCache;
            CachedPathData     data          = (CachedPathData)cacheInternal.Get(key);

            // if found, return the data
            if (data != null)
            {
                data.WaitForInit();
                return(data);
            }

            // WOS


            bool cacheEntryIsNotRemovable = false;

            // if not found, try to add it
            string          siteID       = null;
            VirtualPath     virtualPath  = null;
            CachedPathData  parentData   = null;
            CacheDependency dependency   = null;
            string          physicalPath = null;

            string[] fileDependencies      = null;
            string[] cacheItemDependencies = null;

            if (WebConfigurationHost.IsMachineConfigPath(configPath))
            {
                cacheEntryIsNotRemovable = true;
            }
            else
            {
                // Make sure we have the parent data so we can create a dependency on the parent.
                // The parent dependency will ensure that configuration data in the parent
                // will be referenced by a cache hit on the child. (see UtcUpdateUsageRecursive in Cache.cs)
                string parentConfigPath = ConfigPathUtility.GetParent(configPath);
                parentData = GetConfigPathData(parentConfigPath);
                string parentKey = CreateKey(parentConfigPath);
                cacheItemDependencies = new string[1] {
                    parentKey
                };

                if (!WebConfigurationHost.IsVirtualPathConfigPath(configPath))
                {
                    // assume hardcoded levels above the path, such as root web.config, exist
                    cacheEntryIsNotRemovable = true;
                }
                else
                {
                    cacheEntryIsNotRemovable = !isRemovable;
                    WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out siteID, out virtualPath);
                    physicalPath = GetPhysicalPath(virtualPath);

                    // Add a dependency on the path itself, if it is a file,
                    // to handle the case where a file is deleted and replaced
                    // with a directory of the same name.
                    if (!String.IsNullOrEmpty(physicalPath))
                    {
                        FileUtil.PhysicalPathStatus(physicalPath, false, false, out exists, out isDirectory);
                        if (exists && !isDirectory)
                        {
                            fileDependencies = new string[1] {
                                physicalPath
                            };
                        }
                    }
                }

                try {
                    dependency = new CacheDependency(0, fileDependencies, cacheItemDependencies);
                }
                catch {
                    // CacheDependency ctor could fail because of bogus file path
                    // and it is ok not to watch those
                }
            }

            // Try to add the CachedPathData to the cache.
            CachedPathData    dataAdd           = null;
            bool              isDataCreator     = false;
            bool              initCompleted     = false;
            CacheItemPriority priority          = cacheEntryIsNotRemovable ? CacheItemPriority.NotRemovable : CacheItemPriority.Normal;
            TimeSpan          slidingExpiration = cacheEntryIsNotRemovable ? Cache.NoSlidingExpiration : UrlMetadataSlidingExpiration;

            try {
                using (dependency) {
                    dataAdd = new CachedPathData(configPath, virtualPath, physicalPath, exists);
                    try {
                    }
                    finally {
                        data = (CachedPathData)cacheInternal.Add(key, dataAdd, new CacheInsertOptions()
                        {
                            Dependencies      = dependency,
                            SlidingExpiration = slidingExpiration,
                            Priority          = priority,
                            OnRemovedCallback = s_callback
                        });

                        if (data == null)
                        {
                            isDataCreator = true;
                        }
                    }
                }

                // If another thread added it first, return the data
                if (!isDataCreator)
                {
                    data.WaitForInit();
                    return(data);
                }

                // This thread is the creator of the CachedPathData, initialize it
                lock (dataAdd) {
                    try {
                        dataAdd.Init(parentData);
                        initCompleted = true;
                    }
                    finally {
                        // free waiters
                        dataAdd._flags[FInited] = true;

                        // Wake up waiters.
                        Monitor.PulseAll(dataAdd);

                        if (dataAdd._flags[FCloseNeeded])
                        {
                            // If we have received a call back to close, then lets
                            // make sure that our config object is cleaned up
                            dataAdd.Close();
                        }
                    }
                }
            }
            finally {
                // All the work in this finally block is for the case where we're the
                // creator of the CachedPathData.
                if (isDataCreator)
                {
                    //



                    if (!dataAdd._flags[FInited])
                    {
                        lock (dataAdd) {
                            // free waiters
                            dataAdd._flags[FInited] = true;

                            // Wake up waiters.
                            Monitor.PulseAll(dataAdd);

                            if (dataAdd._flags[FCloseNeeded])
                            {
                                // If we have received a call back to close, then lets
                                // make sure that our config object is cleaned up
                                dataAdd.Close();
                            }
                        }
                    }

                    //
                    // Even though there is a try/catch handler surrounding the call to Init,
                    // a ThreadAbortException can still cause the handler to be bypassed.
                    //
                    // If there is an error, either a thread abort or an error in the config
                    // file itself, we do want to leave the item cached for a short period
                    // so that we do not revisit the error and potentially reparse the config file
                    // on every request.
                    //
                    // The reason we simply do not leave the item in the cache forever is that the
                    // problem that caused the configuration exception may be fixed without touching
                    // the config file in a way that causes a file change notification (for example, an
                    // acl change in a parent directory, or a change of path mapping in the metabase).
                    //
                    // NOTE: It is important to reinsert the item into the cache AFTER dropping
                    // the lock on dataAdd, in order to prevent the possibility of deadlock.
                    //
                    Debug.Assert(dataAdd._flags[FInited], "_flags[FInited]");
                    if (!initCompleted || (dataAdd.ConfigRecord != null && dataAdd.ConfigRecord.HasInitErrors))
                    {
                        //
                        // Create a new dependency object as the old one cannot be reused.
                        // Do not include a file dependency if initialization could not be completed,
                        // as invoking the file system could lead to further errors during a thread abort.
                        //
                        if (dependency != null)
                        {
                            if (!initCompleted)
                            {
                                dependency = new CacheDependency(0, null, cacheItemDependencies);
                            }
                            else
                            {
                                dependency = new CacheDependency(0, fileDependencies, cacheItemDependencies);
                            }
                        }

                        using (dependency) {
                            cacheInternal.Insert(key, dataAdd, new CacheInsertOptions()
                            {
                                Dependencies       = dependency,
                                AbsoluteExpiration = DateTime.UtcNow.AddSeconds(5),
                                OnRemovedCallback  = s_callback
                            });
                        }
                    }
                }
            }

            return(dataAdd);
        }