Beispiel #1
0
 /// <summary> Check whether any given resource exists. This is not really
 /// a very efficient test and it can and should be overridden in the
 /// subclasses extending ResourceLoader.
 ///
 /// </summary>
 /// <param name="resourceName">The name of a resource.
 /// </param>
 /// <returns> true if a resource exists and can be accessed.
 /// </returns>
 /// <since> 1.6
 /// </since>
 public virtual bool ResourceExists(string resourceName)
 {
     System.IO.Stream is_Renamed = null;
     try
     {
         is_Renamed = GetResourceStream(resourceName);
     }
     catch (ResourceNotFoundException e)
     {
         if (log.DebugEnabled)
         {
             log.Debug("Could not load resource '" + resourceName + "' from ResourceLoader " + this.GetType().FullName + ": ", e);
         }
     }
     finally
     {
         try
         {
             if (is_Renamed != null)
             {
                 is_Renamed.Close();
             }
         }
         catch (System.Exception e)
         {
             if (log.ErrorEnabled)
             {
                 string msg = "While closing InputStream for resource '" + resourceName + "' from ResourceLoader " + this.GetType().FullName;
                 log.Error(msg, e);
                 throw new VelocityException(msg, e);
             }
         }
     }
     return(is_Renamed != null);
 }
Beispiel #2
0
        /// <summary> Initialize the ResourceManager.
        ///
        /// </summary>
        /// <param name="rsvc"> The Runtime Services object which is associated with this Resource Manager.
        ///
        /// </param>
        /// <throws>   Exception </throws>
        public virtual void Initialize(IRuntimeServices rsvc)
        {
            lock (syncOjb)
            {
                if (isInit)
                {
                    log.Debug("Re-initialization of ResourceLoader attempted and ignored.");
                    return;
                }

                ResourceLoader resourceLoader = null;

                this.rsvc = rsvc;
                log       = rsvc.Log;

                log.Trace("Default ResourceManager initializing. (" + this.GetType() + ")");

                AssembleResourceLoaderInitializers();


                for (IEnumerator it = sourceInitializerList.GetEnumerator(); it.MoveNext();)
                {
                    /**
                     * Resource loader can be loaded either via class name or be passed
                     * in as an instance.
                     */

                    ExtendedProperties configuration = (ExtendedProperties)it.Current;

                    string         loaderClass    = StringUtils.NullTrim(configuration.GetString("class"));
                    ResourceLoader loaderInstance = (ResourceLoader)configuration["instance"];

                    if (loaderInstance != null)
                    {
                        resourceLoader = loaderInstance;
                    }
                    else if (loaderClass != null)
                    {
                        resourceLoader = ResourceLoaderFactory.GetLoader(rsvc, loaderClass);
                    }
                    else
                    {
                        string msg = "Unable to find '" + configuration.GetString(RESOURCE_LOADER_IDENTIFIER) + ".resource.loader.class' specification in configuration." + " This is a critical value.  Please adjust configuration.";
                        log.Error(msg);
                        throw new System.Exception(msg);
                    }

                    resourceLoader.CommonInit(rsvc, configuration);
                    resourceLoader.Init(configuration);
                    resourceLoaders.Add(resourceLoader);
                }

                /*
                 * now see if this is overridden by configuration
                 */

                logWhenFound = rsvc.GetBoolean(NVelocity.Runtime.RuntimeConstants.RESOURCE_MANAGER_LOGWHENFOUND, true);

                /*
                 *  now, is a global cache specified?
                 */

                string cacheClassName = rsvc.GetString(RuntimeConstants.RESOURCE_MANAGER_CACHE_CLASS);

                object cacheObject = null;

                if (!string.IsNullOrEmpty(cacheClassName))
                {
                    try
                    {
                        cacheObject = System.Activator.CreateInstance(Type.GetType(cacheClassName.Replace(';', ',')));
                    }
                    catch (System.Exception cnfe)
                    {
                        string msg = "The specified class for ResourceCache (" + cacheClassName + ") does not exist or is not accessible to the current classloader.";
                        log.Error(msg, cnfe);
                        throw cnfe;
                    }

                    if (!(cacheObject is IResourceCache))
                    {
                        string msg = "The specified resource cache class (" + cacheClassName + ") must implement " + typeof(IResourceCache).FullName;
                        log.Error(msg);
                        throw new System.SystemException(msg);
                    }
                }

                /*
                 *  if we didn't Get through that, just use the default.
                 */
                if (cacheObject == null)
                {
                    cacheObject = new ResourceCacheImpl();
                }

                globalCache = (IResourceCache)cacheObject;

                globalCache.Initialize(rsvc);

                log.Trace("Default ResourceManager initialization complete.");
            }
        }