public string ResolveLink(string sourcePageUri, string componentUri, string excludeComponentTemplateUri)
{
string cacheKey = String.Format(CacheKeyFormatExtended, sourcePageUri, componentUri, excludeComponentTemplateUri);
string link = (string)CacheAgent.Load(cacheKey);
if (link != null)
{
if (link.Equals(CacheValueNull))
{
return(null);
}
return(link);
}
else
{
string resolvedUrl = LinkProvider.ResolveLink(sourcePageUri, componentUri, excludeComponentTemplateUri);
if (resolvedUrl == null)
{
//CacheAgent.Store(cacheKey, CacheRegion, CacheValueNull, new List<string>() { String.Format("ComponentByUri_{0}", componentUri) });
CacheAgent.Store(cacheKey, CacheRegion, CacheValueNull);
}
else
{
//CacheAgent.Store(cacheKey, CacheRegion, resolvedUrl, new List<string>() { String.Format("ComponentByUri_{0}", componentUri) });
CacheAgent.Store(cacheKey, CacheRegion, resolvedUrl);
}
return(resolvedUrl);
}
}
public bool TryGetPageContent(string tcmUri, out string pageContent)
{
pageContent = string.Empty;
string cacheKey = String.Format("PageContentByUri_{0}", tcmUri);
pageContent = (string)CacheAgent.Load(cacheKey);
if (pageContent != null)
{
return(true);
}
else
{
string tempPageContent = PageProvider.GetContentByUri(tcmUri);
if (tempPageContent != string.Empty)
{
pageContent = tempPageContent;
CacheAgent.Store(cacheKey, CacheRegion, pageContent);
return(true);
}
}
return(false);
}
public bool TryGetPage(string tcmUri, out IPage page)
{
page = null;
string cacheKey = String.Format("PageByUri_{0}", tcmUri);
page = (IPage)CacheAgent.Load(cacheKey);
if (page != null)
{
return(true);
}
string tempPageContent = PageProvider.GetContentByUri(tcmUri);
if (tempPageContent != string.Empty)
{
page = GetIPageObject(tempPageContent);
if (IncludeLastPublishedDate)
{
((Page)page).LastPublishedDate = PageProvider.GetLastPublishedDateByUri(tcmUri);
}
CacheAgent.Store(cacheKey, CacheRegion, page);
return(true);
}
return(false);
}
public virtual bool TryFindPageContent(string url, out string pageContent)
{
LoggerService.Debug(">>TryFindPageContent ({0}", LoggingCategory.Performance, url);
pageContent = string.Empty;
string cacheKey = String.Format("PageContent_{0}_{1}", PublicationId, url);
LoggerService.Debug("about to load page content from cache with key {0}", LoggingCategory.Performance, cacheKey);
pageContent = (string)CacheAgent.Load(cacheKey);
LoggerService.Debug("finished loading page content from cache with key {0}, pageContent found {1}", LoggingCategory.Performance, cacheKey, Convert.ToString(!(string.IsNullOrEmpty(pageContent))));
if (pageContent != null)
{
LoggerService.Debug("<<TryFindPageContent ({0}", LoggingCategory.Performance, url);
return(true);
}
else
{
LoggerService.Debug("about to load page content from provider with url {0}", LoggingCategory.Performance, url);
string tempPageContent = PageProvider.GetContentByUrl(url);
LoggerService.Debug("finished loading page content from provider with url {0}, has value: {1}", LoggingCategory.Performance, url, Convert.ToString(!(string.IsNullOrEmpty(tempPageContent))));
if (tempPageContent != string.Empty)
{
pageContent = tempPageContent;
LoggerService.Debug("about to store page in cache with key {0}", LoggingCategory.Performance, cacheKey);
CacheAgent.Store(cacheKey, CacheRegion, pageContent);
LoggerService.Debug("finished storing page in cache with key {0}", LoggingCategory.Performance, cacheKey);
LoggerService.Debug("<<TryFindPageContent ({0}", LoggingCategory.Performance, url);
return(true);
}
}
LoggerService.Debug("<<TryFindPageContent ({0}", LoggingCategory.Performance, url);
return(false);
}
public string ResolveLink(string componentUri)
{
string cacheKey = String.Format(CacheKeyFormat, componentUri);
string link = (string)CacheAgent.Load(cacheKey);
if (link != null)
{
if (link.Equals(CacheValueNull))
{
return(null);
}
return(link);
}
else
{
ILinkProvider lp = GetLinkProvider(componentUri);
if (lp == null)
{
return(string.Empty);
}
string resolvedUrl = lp.ResolveLink(componentUri);
if (resolvedUrl == null)
{
//CacheAgent.Store(cacheKey, CacheRegion, CacheValueNull, new List<string>() { String.Format(ComponentFactory.CacheKeyFormatByUri, componentUri) });
CacheAgent.Store(cacheKey, CacheRegion, CacheValueNull);
}
else
{
//CacheAgent.Store(cacheKey, CacheRegion, resolvedUrl, new List<string>() { String.Format(ComponentFactory.CacheKeyFormatByUri, componentUri) });
CacheAgent.Store(cacheKey, CacheRegion, resolvedUrl);
}
return(resolvedUrl);
}
}
private SiteMapNode ReadSitemapFromXml(string siteprefix, string sitemapUrl)
{
string cachekey = String.Format("SITEMAP_{0}", sitemapUrl);
object result = CacheAgent.Load(cachekey);
if (result != null)
{
if (!(result is SiteMapNode) && ((string)result).Equals(CacheNullValue))
{
return(null);
}
return(result as SiteMapNode);
}
LoggerService.Debug(">>ReadSitemapFromXml", LoggingCategory.Performance);
SiteMapNode rootNode = null;
var existingNode = FindSiteMapNodeFromKey("root_" + siteprefix);
if (existingNode != null)
{
RemoveNode(existingNode);
}
var nodeDictionary = new Dictionary <string, SiteMapNode>();
PublicationNodeDictionary[siteprefix] = nodeDictionary;
string sitemap;
if (!PageFactory.TryFindPageContent(sitemapUrl, out sitemap))
{
sitemap = emptySiteMapString();
}
LoggerService.Debug(string.Format("loaded sitemap with url {0}, length {1}", sitemapUrl, sitemap.Length), LoggingCategory.Performance);
XDocument xDoc = XDocument.Parse(sitemap);
LoggerService.Debug("parsed sitemap into XDocument", LoggingCategory.Performance);
XElement siteMapRoot = xDoc.Root;
rootNode = new NavigationNode(this, "root_" + siteprefix, "root_" + siteprefix, String.Format("/{0}", siteprefix), String.Empty, String.Empty, new ArrayList(), new NameValueCollection(), new NameValueCollection(), String.Empty);
LoggerService.Debug("created root node", LoggingCategory.Performance);
//Fill down the hierarchy.
AddChildren(rootNode, siteMapRoot.Elements("siteMapNode"), 1, nodeDictionary);
CacheAgent.Store(cachekey, rootNode);
LoggerService.Debug("<<ReadSitemapFromXml", LoggingCategory.Performance);
return(rootNode);
}
public virtual bool TryFindPage(string url, out IPage page)
{
LoggerService.Debug(">>TryFindPage ({0}", LoggingCategory.Performance, url);
page = null;
string cacheKey = CacheKeyFactory.GenerateKey(CacheRegion, url, Convert.ToString(PublicationId));
LoggerService.Debug("about to load page from cache with key {0}", LoggingCategory.Performance, cacheKey);
page = (IPage)CacheAgent.Load(cacheKey);
LoggerService.Debug("finished loading page from cache with key {0}, page found = {1}", LoggingCategory.Performance, cacheKey, Convert.ToString(page != null));
if (page != null)
{
if (page.Title == CacheValueNullTitle)
{
page = null;
return(false);
}
LoggerService.Debug("<<TryFindPage ({0}", LoggingCategory.Performance, url);
return(true);
}
else
{
LoggerService.Debug("about to load page content from provider with url {0}", LoggingCategory.Performance, url);
string pageContentFromBroker = PageProvider.GetContentByUrl(url);
LoggerService.Debug("finished loading page content from provider with url {0}, has value: {1}", LoggingCategory.Performance, url, Convert.ToString(!(string.IsNullOrEmpty(pageContentFromBroker))));
if (string.IsNullOrEmpty(pageContentFromBroker))
{
CacheAgent.Store(cacheKey, CacheRegion404, CacheValueNull);
}
else
{
LoggerService.Debug("about to create IPage from content for url {0}", LoggingCategory.Performance, url);
page = GetIPageObject(pageContentFromBroker);
if (IncludeLastPublishedDate)
{
((Page)page).LastPublishedDate = PageProvider.GetLastPublishedDateByUrl(url);
}
LoggerService.Debug("finished creating IPage from content for url {0}", LoggingCategory.Performance, url);
LoggerService.Debug("about to store page in cache with key {0}", LoggingCategory.Performance, cacheKey);
CacheAgent.Store(cacheKey, CacheRegion, page, new List <string> {
page.Id
});
LoggerService.Debug("finished storing page in cache with key {0}", LoggingCategory.Performance, cacheKey);
LoggerService.Debug("<<TryFindPage ({0}", LoggingCategory.Performance, url);
return(true);
}
}
LoggerService.Debug("<<TryFindPage ({0}", LoggingCategory.Performance, url);
return(false);
}
///// <summary>
///// Get or set the CacheAgent
///// </summary>
//public override ICacheAgent CacheAgent
//{
// get
// {
// if (_cacheAgent == null)
// {
// _cacheAgent = new NullCacheAgent();
// // the next line is the only reason we are overriding this property: to set a callback
// _cacheAgent.GetLastPublishDateCallBack = GetLastPublishedDateCallBack;
// }
// return _cacheAgent;
// }
// set
// {
// _cacheAgent = value;
// _cacheAgent.GetLastPublishDateCallBack = GetLastPublishedDateCallBack;
// }
//}
public bool TryGetComponentPresentation(out IComponentPresentation cp, string componentUri, string templateUri = "")
{
cp = null;
string[] cacheUris = { componentUri };
if (!String.IsNullOrEmpty(templateUri))
{
cacheUris = new string[] { componentUri, templateUri };
}
string cacheKey = CacheKeyFactory.GenerateKey(CacheRegion, cacheUris);
cp = (IComponentPresentation)CacheAgent.Load(cacheKey);
if (cp != null)
{
LoggerService.Debug("<<TryGetComponentPresentation ({0}) - from cache", LoggingCategory.Performance, componentUri);
return(true);
}
string content = !String.IsNullOrEmpty(templateUri) ?
ComponentPresentationProvider.GetContent(componentUri, templateUri) :
ComponentPresentationProvider.GetContent(componentUri);
if (string.IsNullOrEmpty(content))
{
LoggerService.Debug("<<TryGetComponentPresentationOrComponent - no content found by provider for uris {0} and {1}", LoggingCategory.Performance, componentUri, templateUri);
return(false);
}
LoggerService.Debug("about to create IComponentPresentation from content ({0})", LoggingCategory.Performance, componentUri);
cp = GetIComponentPresentationObject(content);
LoggerService.Debug("finished creating IComponentPresentation from content ({0})", LoggingCategory.Performance, componentUri);
// if there is no ComponentTemplate, the content of this CP probably represents a component instead of a component PRESENTATION
// in that case, we should at least add the template uri method parameter (if there is one) to the object
if (cp.ComponentTemplate == null)
{
((ComponentPresentation)cp).ComponentTemplate = new ComponentTemplate();
}
if (cp.ComponentTemplate.Id == null)
{
((ComponentPresentation)cp).ComponentTemplate.Id = templateUri;
}
LoggerService.Debug("about to store IComponentPresentation in cache ({0})", LoggingCategory.Performance, componentUri);
CacheAgent.Store(cacheKey, CacheRegion, cp, new List <string> {
cp.Component.Id
});
LoggerService.Debug("finished storing IComponentPresentation in cache ({0})", LoggingCategory.Performance, componentUri);
LoggerService.Debug("<<TryGetComponentPresentation ({0})", LoggingCategory.Performance, componentUri);
return(cp != null);
}
public IBinaryMeta FindBinaryMeta(string url)
{
string cacheKey = CacheKeyFactory.GenerateKey(url);
IBinaryMeta binaryMeta = CacheAgent.Load(cacheKey) as IBinaryMeta;
if (binaryMeta != null)
{
return(binaryMeta);
}
binaryMeta = BinaryProvider.GetBinaryMetaByUrl(url);
if (binaryMeta == null) // TODO: cache null result
{
return(null);
}
CacheAgent.Store(cacheKey, "Binary", binaryMeta, new List <string> {
binaryMeta.Id
});
return(binaryMeta);
}
private bool TryFindBinary(string url, string localPath, bool retrieveData, out IBinary binary)
{
string physicalPath = localPath ?? Path.Combine(Configuration.BinaryFileSystemCachePath, Path.GetFileName(url));
LoggerService.Debug($"Using physical path {physicalPath}");
binary = new Binary();
Dimensions dimensions = null;
string urlWithoutDimensions = StripDimensions(url, out dimensions);
if (LoadBinariesAsStream)
{
LoggerService.Information("retrieving binaries as a stream is obsolete; support will be dropped in future versions of DD4T");
binary.BinaryStream = BinaryProvider.GetBinaryStreamByUrl(urlWithoutDimensions);
if (binary.BinaryStream == null)
{
return(false);
}
}
string cacheKey = CacheKeyFactory.GenerateKey(urlWithoutDimensions);
try
{
IBinaryMeta binaryMeta = CacheAgent.Load(cacheKey) as IBinaryMeta;
bool metaWasInCache = true;
if (binaryMeta == null)
{
metaWasInCache = false;
binaryMeta = BinaryProvider.GetBinaryMetaByUrl(urlWithoutDimensions);
if (binaryMeta == null)
{
throw new BinaryNotFoundException();
}
CacheAgent.Store(cacheKey, "Binary", binaryMeta, new List <string> {
binaryMeta.Id
});
}
if (FileExistsAndIsNotEmpty(physicalPath))
{
if (binaryMeta.HasLastPublishedDate || metaWasInCache)
{
DateTime fileModifiedDate = File.GetLastWriteTime(physicalPath);
if (fileModifiedDate.CompareTo(binaryMeta.LastPublishedDate) >= 0)
{
LoggerService.Debug("binary {0} is still up to date, no action required", urlWithoutDimensions);
// TODO: load bytes from file system into binary
if (retrieveData)
{
FillBinaryFromLocalFS(binary, physicalPath);
}
CopyBinaryMetaToBinary(binaryMeta, binary);
return(true);
}
}
}
// the normal situation (where a binary is still in Tridion and it is present on the file system already and it is up to date) is now covered
// Let's handle the exception situations.
byte[] bytes = BinaryProvider.GetBinaryByUrl(urlWithoutDimensions);
if (bytes == null || bytes.Length == 0)
{
throw new BinaryNotFoundException();
}
bool fileIsCreated = WriteBinaryToFile(bytes, physicalPath, dimensions);
if (!fileIsCreated)
{
LoggerService.Warning($"file '{physicalPath}' could not be created, binary {binary.Id} cannot be returned");
return(false);
}
if (retrieveData)
{
if (dimensions == null)
{
binary.BinaryData = bytes;
}
else
{
FillBinaryFromLocalFS(binary, physicalPath);
}
}
CopyBinaryMetaToBinary(binaryMeta, binary);
return(true);
}
catch (BinaryNotFoundException)
{
LoggerService.Debug("Binary with url {0} not found", urlWithoutDimensions);
// binary does not exist in Tridion, it should be removed from the local file system too
DeleteFile(physicalPath);
return(false);
}
catch (Exception e)
{
LoggerService.Warning($"Caught unexpected exception while retrieving binary with url {urlWithoutDimensions} (requested url: {url}. Error message: {e.Message}\r\n{e.StackTrace}");
// in case of error, the binary should be removed from the local file system too
DeleteFile(physicalPath);
throw e;
}
}
/// <summary>
/// Gets the cached local file for a given URL path.
/// </summary>
/// <param name="urlPath">The URL path.</param>
/// <param name="localization">The Localization.</param>
/// <returns>The path to the local file.</returns>
internal string GetCachedFile(string urlPath, Localization localization)
{
string localFilePath = GetFilePathFromUrl(urlPath, localization);
using (new Tracer(urlPath, localization, localFilePath))
{
Dimensions dimensions;
urlPath = StripDimensions(urlPath, out dimensions);
string cacheKey = GetCacheKey(urlPath);
DateTime?lastPublishedDate = CacheAgent.Load(cacheKey) as DateTime?;
if (lastPublishedDate == null)
{
IBinaryFactory binaryFactory = DD4TFactoryCache.GetBinaryFactory(localization);
try
{
DateTime lpb = binaryFactory.FindLastPublishedDate(urlPath);
if (lpb != DateTime.MinValue.AddSeconds(1)) // this is the secret code for 'does not exist'
{
lastPublishedDate = lpb;
CacheAgent.Store(cacheKey, "Binary", lastPublishedDate);
}
}
catch (NullReferenceException)
{
//Binary not found, this should return a min date, but theres a bug in DD4T where it throws a NRE
//DO NOTHING - binary removed later
}
catch (Exception ex)
{
Log.Error(ex);
if (File.Exists(localFilePath))
{
//if theres an error connecting, but we still have a version on disk, serve this
return(localFilePath);
}
}
}
if (lastPublishedDate != null)
{
if (File.Exists(localFilePath))
{
if (localization.LastRefresh.CompareTo(lastPublishedDate) < 0)
{
//File has been modified since last application start but we don't care
Log.Debug("Binary with URL '{0}' is modified, but only since last application restart, so no action required", urlPath);
return(localFilePath);
}
FileInfo fi = new FileInfo(localFilePath);
if (fi.Length > 0)
{
DateTime fileModifiedDate = File.GetLastWriteTime(localFilePath);
if (fileModifiedDate.CompareTo(lastPublishedDate) >= 0)
{
Log.Debug("Binary with URL '{0}' is still up to date, no action required", urlPath);
return(localFilePath);
}
}
}
}
// the normal situation (where a binary is still in Tridion and it is present on the file system already and it is up to date) is now covered
// Let's handle the exception situations.
IBinary binary;
try
{
IBinaryFactory binaryFactory = DD4TFactoryCache.GetBinaryFactory(localization);
binaryFactory.TryFindBinary(urlPath, out binary);
}
catch (BinaryNotFoundException)
{
// TryFindBinary throws an Exception if not found ?!
binary = null;
}
catch (Exception ex)
{
throw new DxaException(string.Format("Error loading binary for URL '{0}'", urlPath), ex);
}
//For some reason DD4T sometimes returns a non-null binary with null binary data if it doesnt exist
if (binary == null || binary.BinaryData == null)
{
// Binary does not exist in Tridion, it should be removed from the local file system too
if (File.Exists(localFilePath))
{
CleanupLocalFile(localFilePath);
}
throw new DxaItemNotFoundException(urlPath, localization.LocalizationId);
}
WriteBinaryToFile(binary, localFilePath, dimensions);
return(localFilePath);
}
}