public Object GetObject(IObjRef oriToGet, ICacheIntern targetCache, CacheDirective cacheDirective)
{
CheckNotDisposed();
if (oriToGet == null)
{
return(null);
}
List <IObjRef> orisToGet = new List <IObjRef>(1);
orisToGet.Add(oriToGet);
IList <Object> objects = GetObjects(orisToGet, targetCache, cacheDirective);
if (objects.Count == 0)
{
return(null);
}
return(objects[0]);
}
public IList <object> GetObjects(IList <IObjRef> orisToGet, CacheDirective cacheDirective)
{
IList <object> objs = new List <object>();
foreach (IObjRef ori in orisToGet)
{
object obj;
if (ori == null)
{
obj = null;
}
else if (ori is IDirectObjRef)
{
obj = ((IDirectObjRef)ori).Direct;
}
else
{
obj = GetObject(ori.RealType, ori.Id);
}
objs.Add(obj);
}
return(objs);
}
protected IList <Object> CreateResult(IList <IObjRef> orisToGet, CacheDirective cacheDirective, bool checkVersion)
{
List <Object> result = new List <Object>(orisToGet.Count);
bool returnMisses = cacheDirective.HasFlag(CacheDirective.ReturnMisses);
for (int a = 0, size = orisToGet.Count; a < size; a++)
{
IObjRef oriToGet = orisToGet[a];
if (oriToGet == null)
{
if (returnMisses)
{
result.Add(null);
}
continue;
}
if (oriToGet is IDirectObjRef)
{
IDirectObjRef dori = (IDirectObjRef)oriToGet;
Object entity = dori.Direct;
if (entity != null)
{
result.Add(entity);
continue;
}
}
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(oriToGet.RealType);
Object cacheValue = GetCacheValue(metaData, oriToGet, checkVersion);
if (cacheValue != null || returnMisses)
{
result.Add(cacheValue);
}
}
return(result);
}
public Object GetObject(Type type, Object id, CacheDirective cacheDirective)
{
throw new NotImplementedException();
}
public Object GetObject(IObjRef oriToGet, CacheDirective cacheDirective)
{
throw new NotImplementedException();
}
public IList <IObjRelationResult> GetObjRelations(IList <IObjRelation> objRels, CacheDirective cacheDirective)
{
throw new NotImplementedException();
}
public IList <Object> GetObjects(IList <IObjRef> orisToGet, CacheDirective cacheDirective)
{
throw new NotImplementedException();
}
protected void ChangeSecondLevelCacheIntern(CacheDependencyNode node, CacheDirective cacheDirective)
{
IRootCache rootCache = node.rootCache;
HashMap <IObjRef, CacheValueAndPrivilege> objRefToLoadContainerDict = node.objRefToCacheValueMap;
CHashSet <IObjRef> objRefsToLoad = new CHashSet <IObjRef>(node.objRefsToLoad);
if (node.cacheChangeItems != null)
{
foreach (CacheChangeItem cci in node.cacheChangeItems)
{
if (cci == null)
{
continue;
}
objRefsToLoad.AddAll(cci.UpdatedObjRefs);
}
}
IList <IObjRef> objRefs = objRefsToLoad.ToList();
IList <Object> refreshResult = rootCache.GetObjects(objRefs, cacheDirective);
IPrivilege[] privileges = null;
if (SecurityActivation != null && PrivilegeProvider != null && SecurityActivation.FilterActivated)
{
privileges = PrivilegeProvider.GetPrivilegesByObjRef(objRefs).GetPrivileges();
}
for (int a = refreshResult.Count; a-- > 0;)
{
RootCacheValue cacheValue = (RootCacheValue)refreshResult[a];
if (cacheValue == null)
{
continue;
}
objRefToLoadContainerDict.Put(objRefs[a], new CacheValueAndPrivilege(cacheValue, privileges != null ? privileges[a] : null));
}
CheckCascadeRefreshNeeded(node);
CHashSet <IObjRef> cascadeRefreshObjRefsSet = node.cascadeRefreshObjRefsSet;
CHashSet <IObjRelation> cascadeRefreshObjRelationsSet = node.cascadeRefreshObjRelationsSet;
if (cascadeRefreshObjRelationsSet.Count > 0)
{
IList <IObjRelationResult> relationsResult = rootCache.GetObjRelations(cascadeRefreshObjRelationsSet.ToList(), cacheDirective);
for (int a = relationsResult.Count; a-- > 0;)
{
IObjRelationResult relationResult = relationsResult[a];
cascadeRefreshObjRefsSet.AddAll(relationResult.Relations);
}
// apply gathered information of unknown relations to the rootCache
rootCache.Put(relationsResult);
}
if (cascadeRefreshObjRefsSet.Count > 0)
{
IList <IObjRef> cascadeRefreshObjRefsSetList = cascadeRefreshObjRefsSet.ToList();
refreshResult = rootCache.GetObjects(cascadeRefreshObjRefsSetList, cacheDirective);
}
List <CacheDependencyNode> childNodes = node.childNodes;
for (int a = childNodes.Count; a-- > 0;)
{
ChangeSecondLevelCacheIntern(childNodes[a], failInCacheHierarchyAndCacheValueResultAndReturnMissesSet);
}
}
/// <summary>Apply a CacheDirective to a file.</summary>
/// <param name="directive">The CacheDirective to apply.</param>
/// <param name="file">The file.</param>
private void RescanFile(CacheDirective directive, INodeFile file)
{
BlockInfoContiguous[] blockInfos = file.GetBlocks();
// Increment the "needed" statistics
directive.AddFilesNeeded(1);
// We don't cache UC blocks, don't add them to the total here
long neededTotal = file.ComputeFileSizeNotIncludingLastUcBlock() * directive.GetReplication
();
directive.AddBytesNeeded(neededTotal);
// The pool's bytesNeeded is incremented as we scan. If the demand
// thus far plus the demand of this file would exceed the pool's limit,
// do not cache this file.
CachePool pool = directive.GetPool();
if (pool.GetBytesNeeded() > pool.GetLimit())
{
Log.Debug("Directive {}: not scanning file {} because " + "bytesNeeded for pool {} is {}, but the pool's limit is {}"
, directive.GetId(), file.GetFullPathName(), pool.GetPoolName(), pool.GetBytesNeeded
(), pool.GetLimit());
return;
}
long cachedTotal = 0;
foreach (BlockInfoContiguous blockInfo in blockInfos)
{
if (!blockInfo.GetBlockUCState().Equals(HdfsServerConstants.BlockUCState.Complete
))
{
// We don't try to cache blocks that are under construction.
Log.Trace("Directive {}: can't cache block {} because it is in state " + "{}, not COMPLETE."
, directive.GetId(), blockInfo, blockInfo.GetBlockUCState());
continue;
}
Block block = new Block(blockInfo.GetBlockId());
CachedBlock ncblock = new CachedBlock(block.GetBlockId(), directive.GetReplication
(), mark);
CachedBlock ocblock = cachedBlocks.Get(ncblock);
if (ocblock == null)
{
cachedBlocks.Put(ncblock);
ocblock = ncblock;
}
else
{
// Update bytesUsed using the current replication levels.
// Assumptions: we assume that all the blocks are the same length
// on each datanode. We can assume this because we're only caching
// blocks in state COMPLETE.
// Note that if two directives are caching the same block(s), they will
// both get them added to their bytesCached.
IList <DatanodeDescriptor> cachedOn = ocblock.GetDatanodes(DatanodeDescriptor.CachedBlocksList.Type
.Cached);
long cachedByBlock = Math.Min(cachedOn.Count, directive.GetReplication()) * blockInfo
.GetNumBytes();
cachedTotal += cachedByBlock;
if ((mark != ocblock.GetMark()) || (ocblock.GetReplication() < directive.GetReplication
()))
{
//
// Overwrite the block's replication and mark in two cases:
//
// 1. If the mark on the CachedBlock is different from the mark for
// this scan, that means the block hasn't been updated during this
// scan, and we should overwrite whatever is there, since it is no
// longer valid.
//
// 2. If the replication in the CachedBlock is less than what the
// directive asks for, we want to increase the block's replication
// field to what the directive asks for.
//
ocblock.SetReplicationAndMark(directive.GetReplication(), mark);
}
}
Log.Trace("Directive {}: setting replication for block {} to {}", directive.GetId
(), blockInfo, ocblock.GetReplication());
}
// Increment the "cached" statistics
directive.AddBytesCached(cachedTotal);
if (cachedTotal == neededTotal)
{
directive.AddFilesCached(1);
}
Log.Debug("Directive {}: caching {}: {}/{} bytes", directive.GetId(), file.GetFullPathName
(), cachedTotal, neededTotal);
}
public IList <IObjRelationResult> GetObjRelations(IList <IObjRelation> objRels, ICacheIntern targetCache, CacheDirective cacheDirective)
{
CheckNotDisposed();
IEventQueue eventQueue = EventQueue;
if (eventQueue != null)
{
eventQueue.Pause(this);
}
try
{
bool oldCacheModificationValue = CacheModification.Active;
bool acquireSuccess = AcquireHardRefTLIfNotAlready(objRels.Count);
CacheModification.Active = true;
try
{
if (SecurityActive && ((targetCache == null && Privileged) || (targetCache != null && targetCache.Privileged) && //
SecurityActivation != null && SecurityActivation.FilterActivated))
{
return(SecurityActivation.ExecuteWithoutFiltering(delegate()
{
return Parent.GetObjRelations(objRels, targetCache, cacheDirective);
}));
}
else
{
return(Parent.GetObjRelations(objRels, targetCache, cacheDirective));
}
}
finally
{
CacheModification.Active = oldCacheModificationValue;
ClearHardRefs(acquireSuccess);
}
}
finally
{
if (eventQueue != null)
{
eventQueue.Resume(this);
}
}
}
public override IList <IObjRelationResult> GetObjRelations(IList <IObjRelation> objRels, CacheDirective cacheDirective)
{
return(GetObjRelations(objRels, this, cacheDirective));
}
protected IList <Object> GetObjectsRetry(IList <IObjRef> orisToGet, CacheDirective cacheDirective, out bool doAnotherRetry)
{
doAnotherRetry = false;
Lock readLock = ReadLock;
if (cacheDirective.HasFlag(CacheDirective.FailEarly))
{
readLock.Lock();
try
{
return(CreateResult(orisToGet, cacheDirective, true));
}
finally
{
readLock.Unlock();
}
}
List <IObjRef> orisToLoad = new List <IObjRef>();
int cacheVersionBeforeLongTimeAction = WaitForConcurrentReadFinish(orisToGet, orisToLoad);
if (orisToLoad.Count == 0)
{
// Everything found in the cache. We STILL hold the readlock so we can immediately create the result
// We already even checked the version. So we do not bother version anymore here
try
{
return(CreateResult(orisToGet, cacheDirective, false));
}
finally
{
readLock.Unlock();
}
}
CacheDirective parentCacheDirective = CacheDirective.None;
if (cacheDirective.HasFlag(CacheDirective.FailInCacheHierarchy))
{
parentCacheDirective = CacheDirective.FailEarly;
}
Parent.GetObjects(orisToLoad, this, parentCacheDirective);
// Objects do not have to be put, because their were already
// added by the parent to this cache
readLock.Lock();
try
{
int cacheVersionAfterLongTimeAction = changeVersion;
if (cacheVersionAfterLongTimeAction != cacheVersionBeforeLongTimeAction)
{
// Another thread did some changes (possibly DataChange-Remove actions)
// We have to ensure that our result-scope is still valid
// We return null to allow a further full retry of getObjects()
doAnotherRetry = true;
return(null);
}
return(CreateResult(orisToGet, cacheDirective, false));
}
finally
{
readLock.Unlock();
}
}
public IList <Object> GetObjects(IList <IObjRef> orisToGet, ICacheIntern targetCache, CacheDirective cacheDirective)
{
CheckNotDisposed();
if (orisToGet == null || orisToGet.Count == 0)
{
return(new List <Object>(0));
}
IEventQueue eventQueue = EventQueue;
if (eventQueue != null)
{
eventQueue.Pause(this);
}
try
{
bool oldCacheModificationValue = CacheModification.Active;
bool acquireSuccess = AcquireHardRefTLIfNotAlready(orisToGet.Count);
CacheModification.Active = true;
try
{
if (cacheDirective.HasFlag(CacheDirective.LoadContainerResult) || cacheDirective.HasFlag(CacheDirective.CacheValueResult))
{
return(Parent.GetObjects(orisToGet, this, cacheDirective));
}
bool doAnotherRetry;
while (true)
{
doAnotherRetry = false;
IList <Object> result = GetObjectsRetry(orisToGet, cacheDirective, out doAnotherRetry);
if (!doAnotherRetry)
{
return(result);
}
}
}
finally
{
CacheModification.Active = oldCacheModificationValue;
ClearHardRefs(acquireSuccess);
}
}
finally
{
if (eventQueue != null)
{
eventQueue.Resume(this);
}
}
}
public override IList <Object> GetObjects(IList <IObjRef> orisToGet, CacheDirective cacheDirective)
{
return(GetObjects(orisToGet, this, cacheDirective));
}
