private static IApplicationContext GetContextInternal(string virtualPath)
        {
            string virtualDirectory = WebUtils.GetVirtualDirectory(virtualPath);
            string contextName      = virtualDirectory;

            if (0 == string.Compare(contextName, ("" + HttpRuntime.AppDomainAppVirtualPath).TrimEnd('/') + "/", true))
            {
                contextName = DefaultRootContextName;
            }

            ILog s_weblog          = LogManager.GetLogger(typeof(WebApplicationContext));
            bool isLogDebugEnabled = s_weblog.IsDebugEnabled;

            lock (s_webContextCache)
            {
                if (isLogDebugEnabled)
                {
                    s_weblog.Debug(string.Format("looking up web context '{0}' in WebContextCache", contextName));
                }
                // first lookup in our own cache
                IApplicationContext context = (IApplicationContext)s_webContextCache[contextName];
                if (context != null)
                {
                    // found - nothing to do anymore
                    if (isLogDebugEnabled)
                    {
                        s_weblog.Debug(
                            string.Format("returning WebContextCache hit '{0}' for vpath '{1}' ", context, contextName));
                    }
                    return(context);
                }

                // lookup ContextRegistry
                lock (ContextRegistry.SyncRoot)
                {
                    if (isLogDebugEnabled)
                    {
                        s_weblog.Debug(string.Format("looking up web context '{0}' in ContextRegistry", contextName));
                    }

                    if (ContextRegistry.IsContextRegistered(contextName))
                    {
                        context = ContextRegistry.GetContext(contextName);
                    }

                    if (context == null)
                    {
                        // finally ask HttpConfigurationSystem for the requested context
                        try
                        {
                            if (isLogDebugEnabled)
                            {
                                s_weblog.Debug(
                                    string.Format(
                                        "web context for vpath '{0}' not found. Force creation using filepath '{1}'",
                                        contextName, virtualPath));
                            }

                            // assure context is resolved to the given virtualDirectory
                            using (new HttpContextSwitch(virtualDirectory))
                            {
                                context = (IApplicationContext)ConfigurationUtils.GetSection(ContextSectionName);
                            }

                            if (context != null)
                            {
                                if (isLogDebugEnabled)
                                {
                                    s_weblog.Debug(string.Format("got context '{0}' for vpath '{1}'", context, contextName));
                                }
                            }
                            else
                            {
                                if (isLogDebugEnabled)
                                {
                                    s_weblog.Debug(string.Format("no context defined for vpath '{0}'", contextName));
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            if (s_weblog.IsErrorEnabled)
                            {
                                s_weblog.Error(string.Format("failed creating context '{0}', Stacktrace:\n{1}", contextName, new StackTrace()), ex);
                            }

                            throw;
                        }
                    }
                }

                // add it to the cache
                // Note: use 'contextName' not 'context.Name' here - the same context may be used for different paths!
                s_webContextCache.Add(contextName, context);
                if (isLogDebugEnabled)
                {
                    s_weblog.Debug(
                        string.Format("added context '{0}' to WebContextCache for vpath '{1}'", context, contextName));
                }

                if (context != null)
                {
                    // register this context and all ParentContexts by their name - parent contexts may be additionally created by the HttpRuntime
                    IApplicationContext parentContext = context;
                    while (parentContext != null)
                    {
                        if (!s_webContextCache.ContainsKey(parentContext.Name))
                        {
                            s_webContextCache.Add(parentContext.Name, parentContext);
                            if (isLogDebugEnabled)
                            {
                                s_weblog.Debug(
                                    string.Format("added parent context '{0}' to WebContextCache for vpath '{1}'",
                                                  parentContext, parentContext.Name));
                            }
                        }
                        parentContext = parentContext.ParentContext;
                    }
                }
                return(context);
            } // lock(s_webContextCache)
        }
 public void SetUp()
 {
     ContextRegistry.Clear();
 }
 public void TearDown()
 {
     ContextRegistry.Clear();
 }
Exemple #4
0
 public void SetUp()
 {
     ContextRegistry.Clear();
     ResetConfigurationSystem();
 }
Exemple #5
0
 /// <summary>
 /// This handler simulates calls to ContextRegistry during context creation
 /// </summary>
 private static object GetContextRecursive(object parent, object context, XmlNode section)
 {
     return(ContextRegistry.GetContext()); // this must fail!
 }
Exemple #6
0
 public void GetContextWithEmptyName()
 {
     Assert.Throws <ArgumentException>(() => ContextRegistry.GetContext(""));
 }
Exemple #7
0
 public void GetContextByNameNotRegisteredThrowsException()
 {
     Assert.Throws <ApplicationContextException>(
         () => ContextRegistry.GetContext("bingo"),
         "No context registered under name 'bingo'. Use the 'RegisterContext' method or the 'spring/context' section from your configuration file.");
 }
Exemple #8
0
 public void GetContextWithNullName()
 {
     Assert.Throws <ArgumentException>(() => ContextRegistry.GetContext(null));
 }
Exemple #9
0
        /// <summary>
        /// Creates an <see cref="Spring.Context.IApplicationContext"/> instance
        /// using the context definitions supplied in a custom
        /// configuration section.
        /// </summary>
        /// <remarks>
        /// <p>
        /// This <see cref="Spring.Context.IApplicationContext"/> instance is
        /// also used to configure the <see cref="ContextRegistry"/>.
        /// </p>
        /// </remarks>
        /// <param name="parent">
        /// The configuration settings in a corresponding parent
        /// configuration section.
        /// </param>
        /// <param name="configContext">
        /// The configuration context when called from the ASP.NET
        /// configuration system. Otherwise, this parameter is reserved and
        /// is <see langword="null"/>.
        /// </param>
        /// <param name="section">
        /// The <see cref="System.Xml.XmlNode"/> for the section.
        /// </param>
        /// <returns>
        /// An <see cref="Spring.Context.IApplicationContext"/> instance
        /// populated with the object definitions supplied in the configuration
        /// section.
        /// </returns>
        public object Create(object parent, object configContext, XmlNode section)
        {
            XmlElement contextElement = section as XmlElement;

            #region Sanity Checks

            if (contextElement == null)
            {
                throw ConfigurationUtils.CreateConfigurationException(
                          "Context configuration section must be an XmlElement.");
            }

            // sanity check on parent
            if ((parent != null) && !(parent is IApplicationContext))
            {
                throw ConfigurationUtils.CreateConfigurationException(
                          String.Format("Parent context must be of type IApplicationContext, but was '{0}'", parent.GetType().FullName));
            }

            #endregion

            // determine name of context to be created
            string contextName = GetContextName(configContext, contextElement);
            if (!StringUtils.HasLength(contextName))
            {
                contextName = AbstractApplicationContext.DefaultRootContextName;
            }

            #region Instrumentation
            if (Log.IsDebugEnabled)
            {
                Log.Debug(string.Format("creating context '{0}'", contextName));
            }
            #endregion

            IApplicationContext context = null;
            try
            {
                IApplicationContext parentContext = parent as IApplicationContext;

                // determine context type
                Type contextType = GetContextType(contextElement, parentContext);

                // determine case-sensitivity
                bool caseSensitive = GetCaseSensitivity(contextElement);

                // get resource-list
                string[] resources = GetResources(contextElement);

                // finally create the context instance
                context = InstantiateContext(parentContext, configContext, contextName, contextType, caseSensitive, resources);
                // and register with global context registry
                if (AutoRegisterWithContextRegistry)
                {
                    ContextRegistry.RegisterContext(context);
                }

                // get and create child context definitions
                XmlNode[] childContexts = GetChildContexts(contextElement);
                CreateChildContexts(context, configContext, childContexts);

                if (Log.IsDebugEnabled)
                {
                    Log.Debug(string.Format("context '{0}' created for name '{1}'", context, contextName));
                }
            }
            catch (Exception ex)
            {
                if (!ConfigurationUtils.IsConfigurationException(ex))
                {
                    throw ConfigurationUtils.CreateConfigurationException(
                              String.Format("Error creating context '{0}': {1}",
                                            contextName, ReflectionUtils.GetExplicitBaseException(ex).Message), ex);
                }
                throw;
            }
            return(context);
        }
Exemple #10
0
 public void GetContextByNameNotRegisteredThrowsException()
 {
     IApplicationContext context = ContextRegistry.GetContext("bingo");
 }
Exemple #11
0
 public void GetContextWithEmptyName()
 {
     ContextRegistry.GetContext("");
 }
Exemple #12
0
 public void GetContextWithNullName()
 {
     ContextRegistry.GetContext(null);
 }