protected internal void RefreshResource(Resource resource, string encoding) { if (resource.RequiresChecking()) { resource.Touch(); if (resource.IsSourceModified()) { if (!resource.Encoding.Equals(encoding)) { this.rsvc.Error(string.Concat(new string[] { "Declared encoding for template '", resource.Name, "' is different on reload. Old = '", resource.Encoding, "' New = '", encoding })); resource.Encoding = encoding; } long lastModified = resource.ResourceLoader.GetLastModified(resource); resource.Process(); resource.LastModified = lastModified; } } }
/// <summary> Takes an existing resource, and 'refreshes' it. This generally means that the source of the resource is checked for changes /// according to some cache/check algorithm and if the resource changed, then the resource data is reloaded and re-parsed. /// /// </summary> /// <param name="resource"> resource to refresh /// </param> /// <param name="encoding"> character encoding of the resource to refresh. /// /// </param> /// <throws> ResourceNotFoundException if template not found from current source for this Resource </throws> /// <throws> ParseErrorException if template cannot be parsed due to syntax (or other) Error. </throws> /// <throws> Exception if a problem in parse </throws> protected internal virtual Resource RefreshResource(Resource resource, string encoding) { /* * The resource knows whether it needs to be checked * or not, and the resource's loader can check to * see if the source has been modified. If both * these conditions are true then we must reload * the input stream and parse it to make a new * AST for the resource. */ /* * touch() the resource to reset the counters */ resource.Touch(); if (resource.IsSourceModified) { /* * now check encoding Info. It's possible that the newly declared * encoding is different than the encoding already in the resource * this strikes me as bad... */ if (!string.Equals(resource.Encoding, encoding)) { log.Warn("Declared encoding for template '" + resource.Name + "' is different on reload. Old = '" + resource.Encoding + "' New = '" + encoding); resource.Encoding = encoding; } /* * read how old the resource is _before_ * processing (=>reading) it */ long howOldItWas = resource.ResourceLoader.GetLastModified(resource); string resourceKey = resource.Type + resource.Name; /* * we create a copy to avoid partially overwriting a * template which may be in use in another thread */ Resource newResource = ResourceFactory.getResource(resource.Name, resource.Type); newResource.RuntimeServices = rsvc; newResource.Name = resource.Name; newResource.Encoding = resource.Encoding; newResource.ResourceLoader = resource.ResourceLoader; newResource.ModificationCheckInterval = resource.ResourceLoader.ModificationCheckInterval; newResource.Process(); newResource.LastModified = howOldItWas; resource = newResource; globalCache.Put(resourceKey, newResource); } return(resource); }
/// <summary> Takes an existing resource, and 'refreshes' it. This /// generally means that the source of the resource is checked /// for changes according to some cache/check algorithm /// and if the resource changed, then the resource data is /// reloaded and re-parsed. /// * /// </summary> /// <param name="resource">resource to refresh /// * /// @throws ResourceNotFoundException if template not found /// from current source for this Resource /// @throws ParseErrorException if template cannot be parsed due /// to syntax (or other) error. /// @throws Exception if a problem in parse /// /// </param> /// <param name="encoding"></param> protected internal void RefreshResource(Resource resource, String encoding) { /* * The resource knows whether it needs to be checked * or not, and the resource's loader can check to * see if the source has been modified. If both * these conditions are true then we must reload * the input stream and parse it to make a new * AST for the resource. */ if (resource.RequiresChecking()) { /* * touch() the resource to reset the counters */ resource.Touch(); if (resource.IsSourceModified()) { /* * now check encoding info. It's possible that the newly declared * encoding is different than the encoding already in the resource * this strikes me as bad... */ if (!resource.Encoding.Equals(encoding)) { runtimeServices.Error( string.Format("Declared encoding for template '{0}' is different on reload. Old = '{1}' New = '{2}", resource.Name, resource.Encoding, encoding)); resource.Encoding = encoding; } /* * read how old the resource is _before_ * processing (=>reading) it */ long howOldItWas = resource.ResourceLoader.GetLastModified(resource); /* * read in the fresh stream and parse */ resource.Process(); /* * now set the modification info and reset * the modification check counters */ resource.LastModified = howOldItWas; } } }
protected internal Resource LoadResource(string resourceName, ResourceType resourceType, string encoding) { Resource resource = ResourceFactory.GetResource(resourceName, resourceType); resource.RuntimeServices = this.rsvc; resource.Name = resourceName; resource.Encoding = encoding; long lastModified = 0L; ResourceLoader resourceLoader = null; for (int i = 0; i < this.resourceLoaders.Count; i++) { resourceLoader = (ResourceLoader)this.resourceLoaders[i]; resource.ResourceLoader = resourceLoader; try { if (resource.Process()) { if (this.logWhenFound) { this.rsvc.Info("ResourceManager : found " + resourceName + " with loader " + resourceLoader.ClassName); } lastModified = resourceLoader.GetLastModified(resource); break; } } catch (ResourceNotFoundException) { } } if (resource.Data == null) { throw new ResourceNotFoundException("Unable to find resource '" + resourceName + "'"); } resource.LastModified = lastModified; resource.ModificationCheckInterval = resourceLoader.ModificationCheckInterval; resource.Touch(); return(resource); }
/// <summary> Takes an existing resource, and 'refreshes' it. This /// generally means that the source of the resource is checked /// for changes according to some cache/check algorithm /// and if the resource changed, then the resource data is /// reloaded and re-parsed. /// * /// </summary> /// <param name="resource">resource to refresh /// * /// @throws ResourceNotFoundException if template not found /// from current source for this Resource /// @throws ParseErrorException if template cannot be parsed due /// to syntax (or other) error. /// @throws Exception if a problem in parse /// /// </param> protected internal virtual void refreshResource(Resource resource, System.String encoding) { /* * The resource knows whether it needs to be checked * or not, and the resource's loader can check to * see if the source has been modified. If both * these conditions are true then we must reload * the input stream and parse it to make a new * AST for the resource. */ if (resource.RequiresChecking()) { /* * touch() the resource to reset the counters */ resource.Touch(); if (resource.IsSourceModified()) { /* * now check encoding info. It's possible that the newly declared * encoding is different than the encoding already in the resource * this strikes me as bad... */ if (!resource.Encoding.Equals(encoding)) { rsvc.error("Declared encoding for template '" + resource.Name + "' is different on reload. Old = '" + resource.Encoding + "' New = '" + encoding); resource.Encoding = encoding; } /* * read how old the resource is _before_ * processing (=>reading) it */ long howOldItWas = resource.ResourceLoader.getLastModified(resource); /* * read in the fresh stream and parse */ resource.Process(); /* * now set the modification info and reset * the modification check counters */ resource.LastModified = howOldItWas; } } }
/// <summary> Loads a resource from the current set of resource loaders. /// /// </summary> /// <param name="resourceName"> The name of the resource to retrieve. /// </param> /// <param name="resourceType"> The type of resource (<code>RESOURCE_TEMPLATE</code>, <code>RESOURCE_CONTENT</code>, etc.). /// </param> /// <param name="encoding"> The character encoding to use. /// /// </param> /// <returns> Resource with the template parsed and ready. /// /// </returns> /// <throws> ResourceNotFoundException if template not found from any available source. </throws> /// <throws> ParseErrorException if template cannot be parsed due to syntax (or other) Error. </throws> /// <throws> Exception if a problem in parse </throws> protected internal virtual Resource LoadResource(string resourceName, int resourceType, string encoding) { Resource resource = CreateResource(resourceName, resourceType); resource.RuntimeServices = rsvc; resource.Name = resourceName; resource.Encoding = encoding; /* * Now we have to try to find the appropriate * loader for this resource. We have to cycle through * the list of available resource loaders and see * which one gives us a stream that we can use to * make a resource with. */ long howOldItWas = 0; for (IEnumerator <ResourceLoader> it = resourceLoaders.GetEnumerator(); it.MoveNext();) { ResourceLoader resourceLoader = it.Current; resource.ResourceLoader = resourceLoader; /* * catch the ResourceNotFound exception * as that is ok in our new multi-loader environment */ try { if (resource.Process()) { /* * FIXME (gmj) * moved in here - technically still * a problem - but the resource needs to be * processed before the loader can figure * it out due to to the new * multi-path support - will revisit and fix */ if (logWhenFound && log.DebugEnabled) { log.Debug("ResourceManager : found " + resourceName + " with loader " + resourceLoader.ClassName); } howOldItWas = resourceLoader.GetLastModified(resource); break; } } catch (ResourceNotFoundException) { /* * that's ok - it's possible to fail in * multi-loader environment */ } } /* * Return null if we can't find a resource. */ if (resource.Data == null) { throw new ResourceNotFoundException("Unable to find resource '" + resourceName + "'"); } /* * some final cleanup */ resource.LastModified = howOldItWas; resource.ModificationCheckInterval = resource.ResourceLoader.ModificationCheckInterval; resource.Touch(); return(resource); }
/// <summary> /// Loads a resource from the current set of resource loaders /// </summary> /// <param name="resourceName">The name of the resource to retrieve.</param> /// <param name="resourceType">The type of resource (<code>Template</code>, /// <code>Content</code>, etc.). /// </param> /// <param name="encoding"> The character encoding to use.</param> /// <returns>Resource with the template parsed and ready. /// @throws ResourceNotFoundException if template not found /// from any available source. /// @throws ParseErrorException if template cannot be parsed due /// to syntax (or other) error. /// @throws Exception if a problem in parse /// </returns> protected internal Resource LoadResource(String resourceName, ResourceType resourceType, String encoding) { Resource resource = ResourceFactory.GetResource(resourceName, resourceType); resource.RuntimeServices = runtimeServices; resource.Name = resourceName; resource.Encoding = encoding; /* * Now we have to try to find the appropriate * loader for this resource. We have to cycle through * the list of available resource loaders and see * which one gives us a stream that we can use to * make a resource with. */ long howOldItWas = 0; // Initialize to avoid warnings ResourceLoader resourceLoader = null; for (int i = 0; i < resourceLoaders.Count; i++) { resourceLoader = (ResourceLoader)resourceLoaders[i]; resource.ResourceLoader = resourceLoader; /* * catch the ResourceNotFound exception * as that is ok in our new multi-loader environment */ try { if (resource.Process()) { /* * FIXME (gmj) * moved in here - technically still * a problem - but the resource needs to be * processed before the loader can figure * it out due to to the new * multi-path support - will revisit and fix */ if (logWhenFound) { runtimeServices.Info( string.Format("ResourceManager : found {0} with loader {1}", resourceName, resourceLoader.ClassName)); } howOldItWas = resourceLoader.GetLastModified(resource); break; } } catch (ResourceNotFoundException) { /* * that's ok - it's possible to fail in * multi-loader environment */ } } /* * Return null if we can't find a resource. */ if (resource.Data == null) { throw new ResourceNotFoundException(string.Format("Unable to find resource '{0}'", resourceName)); } /* * some final cleanup */ resource.LastModified = howOldItWas; resource.ModificationCheckInterval = resourceLoader.ModificationCheckInterval; resource.Touch(); return(resource); }
private void ProcessResourceWithSensibleExceptionWrapping(string resourceName, Resource resource) { try { resource.Process(); } catch(Exception e) { throw new ResourceProcessingException(resourceName, e); } }