/// <summary> /// Returns an existing <see cref="Aspect"/> by the given name. /// If it is not found, returns null. /// </summary> /// <param name="name">Name of the <see cref="Aspect"/>.</param> public static Aspect LoadAspectByName(string name) { // IMPORTANT: // We can't use external query here because this method is called during indexing! // It would mean trying to query the index while writing to it, which would result in a deadlock. // For this reason, this method uses its own cache for finding aspects. // Try to find the aspect in cache var cacheKey = "SN_AspectCacheByName_" + name; var aspect = Cache.Get(cacheKey) as Aspect; if (aspect == null) { // Find aspect via node query. // DO NOT replace this call with either Linq or Content Query for the reasons detailed above! var result = NodeQuery.QueryNodesByTypeAndName(ActiveSchema.NodeTypes[typeof(Aspect).Name], false, name); aspect = result.Nodes.FirstOrDefault() as Aspect; // If not found, return null if (aspect == null) { return(null); } // Store in cache var dependency = CacheDependencyFactory.CreateNodeDependency(aspect); Cache.Insert(cacheKey, aspect, dependency); } return(aspect); }
/* ----------------------------------------------------------------------------------------------- */ public Stream GetBinaryStream(int nodeId, int versionId, int propertyTypeId) { // Try to load cached binary entity var cacheKey = BinaryCacheEntity.GetCacheKey(versionId, propertyTypeId); var binaryCacheEntity = (BinaryCacheEntity)Cache.Get(cacheKey); if (binaryCacheEntity == null) { //TODO: [DIBLOB] get the storage service through the constructor later // Not in cache, load it from the database binaryCacheEntity = Providers.Instance.BlobStorage.LoadBinaryCacheEntityAsync(versionId, propertyTypeId, CancellationToken.None) .GetAwaiter().GetResult(); // insert the binary cache entity into the // cache only if we know the node id if (binaryCacheEntity != null && nodeId != 0) { if (!RepositoryEnvironment.WorkingMode.Populating) { var head = NodeHead.Get(nodeId); Cache.Insert(cacheKey, binaryCacheEntity, CacheDependencyFactory.CreateBinaryDataDependency(nodeId, head.Path, head.NodeTypeId)); } } } // Not found even in the database if (binaryCacheEntity == null || binaryCacheEntity.Length == -1) { return(null); } return(new SnStream(binaryCacheEntity.Context, Providers.Instance.BlobStorage, binaryCacheEntity.RawData)); }
public override void AddPortletDependency() { base.AddPortletDependency(); if (!CacheByContext) { return; } // this works similarly to GetCacheKey, use GetContextNodeInternal instead of GetContextNode Node contextNode; using (new SystemAccount()) { contextNode = GetContextNodeInternalSafe(); } if (contextNode == null) { return; } var nodeDependency = CacheDependencyFactory.CreateNodeDependency(contextNode); Dependencies.Add(nodeDependency); }
internal static void CacheNodeHead(NodeHead head, string idKey, string pathKey) { var dependencyForPathKey = CacheDependencyFactory.CreateNodeHeadDependency(head); var dependencyForIdKey = CacheDependencyFactory.CreateNodeHeadDependency(head); DistributedApplication.Cache.Insert(idKey, head, dependencyForIdKey); DistributedApplication.Cache.Insert(pathKey, head, dependencyForPathKey); }
private void CacheNodeHead(NodeHead head, string idKey, string pathKey) { var dependencyForPathKey = CacheDependencyFactory.CreateNodeHeadDependency(head); var dependencyForIdKey = CacheDependencyFactory.CreateNodeHeadDependency(head); Cache.Insert(idKey, head, dependencyForIdKey); Cache.Insert(pathKey, head, dependencyForPathKey); }
public override void AddPortletDependency() { base.AddPortletDependency(); if (_contentPath != null) { var nodeHead = NodeHead.Get(_contentPath); if (nodeHead != null) { var nodeDependency = CacheDependencyFactory.CreateNodeDependency(nodeHead); Dependencies.Add(nodeDependency); } } }
internal static void CacheNodeData(NodeData nodeData, string cacheKey = null) { if (nodeData == null) { throw new ArgumentNullException("nodeData"); } if (cacheKey == null) { cacheKey = GenerateNodeDataVersionIdCacheKey(nodeData.VersionId); } var dependency = CacheDependencyFactory.CreateNodeDataDependency(nodeData); DistributedApplication.Cache.Insert(cacheKey, nodeData, dependency); }
public void CacheNodeData(NodeData nodeData, string cacheKey = null) { if (nodeData == null) { throw new ArgumentNullException(nameof(nodeData)); } if (cacheKey == null) { cacheKey = CreateNodeDataVersionIdCacheKey(nodeData.VersionId); } var dependency = CacheDependencyFactory.CreateNodeDataDependency(nodeData); Cache.Insert(cacheKey, nodeData, dependency); }
public override void AddPortletDependency() { base.AddPortletDependency(); if (!CacheByContext) { return; } //this works similar to GetCacheKey, use GetContextNodeInternal instead of GetContextNode var contextNode = this.GetContextNodeInternal(); if (contextNode != null) { var nodeDependency = CacheDependencyFactory.CreateNodeDependency(contextNode); Dependencies.Add(nodeDependency); } }
internal static Stream GetBinaryStream(int nodeId, int versionId, int propertyTypeId) { BinaryCacheEntity binaryCacheEntity = null; if (TransactionScope.IsActive) { binaryCacheEntity = DataProvider.Current.LoadBinaryCacheEntity(versionId, propertyTypeId); return(new SnStream(binaryCacheEntity.Context, binaryCacheEntity.RawData)); } // Try to load cached binary entity var cacheKey = BinaryCacheEntity.GetCacheKey(versionId, propertyTypeId); binaryCacheEntity = (BinaryCacheEntity)DistributedApplication.Cache.Get(cacheKey); if (binaryCacheEntity == null) { // Not in cache, load it from the database binaryCacheEntity = DataProvider.Current.LoadBinaryCacheEntity(versionId, propertyTypeId); // insert the binary cache entity into the // cache only if we know the node id if (binaryCacheEntity != null && nodeId != 0) { if (!RepositoryEnvironment.WorkingMode.Populating) { var head = NodeHead.Get(nodeId); DistributedApplication.Cache.Insert(cacheKey, binaryCacheEntity, CacheDependencyFactory.CreateBinaryDataDependency(nodeId, head.Path, head.NodeTypeId)); } } } // Not found even in the database if (binaryCacheEntity == null) { return(null); } if (binaryCacheEntity.Length == -1) { return(null); } return(new SnStream(binaryCacheEntity.Context, binaryCacheEntity.RawData)); }
public static User Load(string domain, string name, ExecutionHint hint) { domain = string.IsNullOrWhiteSpace(domain) ? IdentityManagement.DefaultDomain : domain; if (domain == null) { throw new ArgumentNullException(nameof(domain)); } if (name == null) { throw new ArgumentNullException(nameof(name)); } // look for the user ID in the cache by the doman-username key var ck = GetUserCacheKey(domain, name); var userIdobject = DistributedApplication.Cache.Get(ck); if (userIdobject != null) { var userId = Convert.ToInt32(userIdobject); var cachedUser = Node.Load <User>(userId); if (cachedUser != null) { return(cachedUser); } } var domainPath = string.Concat(RepositoryStructure.ImsFolderPath, RepositoryPath.PathSeparator, domain); var type = ActiveSchema.NodeTypes[typeof(User).Name]; User user; bool forceCql; switch (hint) { case ExecutionHint.None: forceCql = RepositoryInstance.ContentQueryIsAllowed; break; case ExecutionHint.ForceIndexedEngine: forceCql = true; break; case ExecutionHint.ForceRelationalEngine: forceCql = false; break; default: throw new SnNotSupportedException("Unknown ExecutionHint: " + hint); } try { if (forceCql) { var userResult = ContentQuery.Query(SafeQueries.UsersByLoginName, QuerySettings.AdminSettings, domainPath, name); // non-unique user, do not allow login if (userResult.Count > 1) { return(null); } user = userResult.Count == 0 ? null : userResult.Nodes.Cast <User>().FirstOrDefault(); } else { var queryProps = new List <QueryPropertyData> { new QueryPropertyData { PropertyName = LOGINNAME, QueryOperator = Operator.Equal, Value = name } }; var userResult = NodeQuery.QueryNodesByTypeAndPathAndProperty(type, false, domainPath, false, queryProps); // non-unique user, do not allow login if (userResult.Count > 1) { return(null); } user = userResult.Count == 0 ? null : userResult.Nodes.Cast <User>().FirstOrDefault(); } } catch (Exception e) { SnLog.WriteException(e); return(null); } if (user == null) { return(null); } // insert id into cache if (DistributedApplication.Cache.Get(ck) == null) { DistributedApplication.Cache.Insert(ck, user.Id, CacheDependencyFactory.CreateNodeDependency(user)); } return(user); }
public static User Load(string domain, string name, ExecutionHint hint) { if (domain == null) { throw new ArgumentNullException("domain"); } if (name == null) { throw new ArgumentNullException("name"); } //look for the user ID in the cache by the doman-username key var ck = GetUserCacheKey(domain, name); var userIdobject = DistributedApplication.Cache.Get(ck); if (userIdobject != null) { var userId = Convert.ToInt32(userIdobject); var cachedUser = Node.Load <User>(userId); if (cachedUser != null) { //Trace.WriteLine("##UCACHE#>> User ID found in cache: " + ck); return(cachedUser); } } //Trace.WriteLine("##UCACHE#>> User ID NOT found in cache: " + ck); var path = String.Concat(Repository.ImsFolderPath, RepositoryPath.PathSeparator, domain); var type = ActiveSchema.NodeTypes[typeof(User).Name]; IEnumerable <Node> users; switch (hint) { case ExecutionHint.None: if (StorageContext.Search.IsOuterEngineEnabled && StorageContext.Search.SearchEngine != InternalSearchEngine.Instance) { users = SearchInLucene(path, type.Name, name); } else { users = NodeQuery.QueryNodesByTypeAndPathAndName(type, false, path, false, name).Nodes; } break; case ExecutionHint.ForceRelationalEngine: users = NodeQuery.QueryNodesByTypeAndPathAndName(type, false, path, false, name).Nodes; break; case ExecutionHint.ForceIndexedEngine: users = SearchInLucene(path, type.Name, name); break; default: throw new NotImplementedException(); } var count = users.Count(); if (count == 0) { return(null); } if (count > 1) { throw new ApplicationException(string.Format("The Username (='Domain\\Name', in this case '{0}\\{1}') should be unique. {2} matching users have been found.", domain, name, count)); } var user = users.First() as User; //insert id into cache if (user != null && DistributedApplication.Cache.Get(ck) == null) { DistributedApplication.Cache.Insert(ck, user.Id, CacheDependencyFactory.CreateNodeDependency(user)); //Trace.WriteLine("##UCACHE#>> User ID inserted into cache: " + ck); } return(user); }
public static User Load(string domain, string name, ExecutionHint hint) { if (domain == null) { throw new ArgumentNullException("domain"); } if (name == null) { throw new ArgumentNullException("name"); } //look for the user ID in the cache by the doman-username key var ck = GetUserCacheKey(domain, name); var userIdobject = DistributedApplication.Cache.Get(ck); if (userIdobject != null) { var userId = Convert.ToInt32(userIdobject); var cachedUser = Node.Load <User>(userId); if (cachedUser != null) { return(cachedUser); } } var path = String.Concat(Repository.ImsFolderPath, RepositoryPath.PathSeparator, domain); var type = ActiveSchema.NodeTypes[typeof(User).Name]; IEnumerable <Node> users; var forceCql = false; if (hint == ExecutionHint.None) { forceCql = StorageContext.Search.IsOuterEngineEnabled && StorageContext.Search.SearchEngine != InternalSearchEngine.Instance; } else if (hint == ExecutionHint.ForceIndexedEngine) { forceCql = true; } else if (hint == ExecutionHint.ForceRelationalEngine) { forceCql = false; } else { throw new NotImplementedException("Unknown ExecutionHint: " + hint); } try { users = forceCql ? ContentQuery.Query(SafeQueries.InTreeAndTypeIsAndName, null, path, type.Name, name).Nodes : users = NodeQuery.QueryNodesByTypeAndPathAndName(type, false, path, false, name).Nodes; } catch (Exception e) { Logger.WriteException(e); return(null); } var count = users.Count(); if (count != 1) { return(null); } var user = users.First() as User; //insert id into cache if (user != null && DistributedApplication.Cache.Get(ck) == null) { DistributedApplication.Cache.Insert(ck, user.Id, CacheDependencyFactory.CreateNodeDependency(user)); } return(user); }