cleanup

1 files changed, 54 insertions, 45 deletions

diff --git a/zenserver/cache/structuredcache.cpp b/zenserver/cache/structuredcache.cpp
index eef350663..11a23242f 100644
--- a/zenserver/cache/structuredcache.cpp
+++ b/zenserver/cache/structuredcache.cpp
@@ -1286,9 +1286,10 @@ namespace impl {
 
 		struct RecordRequestData
 		{
-			bool   MissingRecord	 = false;
-			bool   UsedUpstream		 = false;
-			size_t MissingValueCount = 0;
+			CachePolicy RecordPolicy;
+			bool		MissingLocalRecord = true;
+			bool		UsedUpstream	   = false;
+			size_t		MissingValueCount  = 0;
 		};
 		std::vector<RecordRequestData> RequestData(RequestCount);
 
@@ -1298,12 +1299,12 @@ namespace impl {
 
 			RecordRequestData&									RecordRequestData = RequestData[RequestIndex];
 			std::optional<cacherequests::GetCacheRecordResult>& RecordResult	  = OutResult.Results[RequestIndex];
-			const CachePolicy RecordPolicy = cacherequests::GetEffectiveRecordPolicy(Policy, RequestIndex);
+			RecordRequestData.RecordPolicy = cacherequests::GetEffectiveRecordPolicy(Policy, RequestIndex);
 
-			const bool QueryLocalRecord = EnumHasAllFlags(RecordPolicy, CachePolicy::QueryLocal);
+			const bool RecordQueryLocal = EnumHasAllFlags(RecordRequestData.RecordPolicy, CachePolicy::QueryLocal);
 
 			ZenCacheValue RecordCacheValue;
-			if (QueryLocalRecord && CacheStore.Get(Request.Namespace, Key.Bucket, Key.Hash, RecordCacheValue))
+			if (RecordQueryLocal && CacheStore.Get(Request.Namespace, Key.Bucket, Key.Hash, RecordCacheValue))
 			{
 				if (RecordCacheValue.Value.GetContentType() != ZenContentType::kCbObject)
 				{
@@ -1314,26 +1315,29 @@ namespace impl {
 				cacherequests::CacheRecord CacheRecord;
 				if (!CacheRecord.Parse(Record))
 				{
-					ZEN_WARN("local record {}/{}/{} is corrupt, skipping.", Request.Namespace, Key.Bucket, Key.Hash);
+					ZEN_WARN("local record {}/{}/{} is corrupt, skipping", Request.Namespace, Key.Bucket, Key.Hash);
 					continue;
 				}
 
-				RecordResult = {.Key = CacheRecord.Key};
+				RecordResult						 = {.Key = CacheRecord.Key};
+				RecordRequestData.MissingLocalRecord = false;
 
-				RecordResult->Values.resize(CacheRecord.Values.size());
-				for (size_t ValueIndex = 0; ValueIndex < CacheRecord.Values.size(); ++ValueIndex)
+				size_t ValueCount = CacheRecord.Values.size();
+				RecordResult->Values.resize(ValueCount);
+				for (size_t ValueIndex = 0; ValueIndex < ValueCount; ++ValueIndex)
 				{
 					const cacherequests::CacheRecordValue& Value = CacheRecord.Values[ValueIndex];
 					const CachePolicy ValuePolicy				 = cacherequests::GetEffectiveValuePolicy(Policy, RequestIndex, Value.Id);
 					RecordResult->Values[ValueIndex]			 = {.Id = Value.Id, .RawHash = Value.RawHash, .RawSize = Value.RawSize};
-					bool ValueQueryAny							 = EnumHasAnyFlags(ValuePolicy, CachePolicy::Query);
+
+					const bool ValueQueryAny = EnumHasAnyFlags(ValuePolicy, CachePolicy::Query);
 					if (!ValueQueryAny)
 					{
-						// A value that is requested without the Query flag (such as None/Disable) counts as existing, because we
+						// A value that is requested without the Query flag counts as existing, because we
 						// didn't ask for it and thus the record is complete in its absence.
 						continue;
 					}
-					bool ValueSkipData = EnumHasAllFlags(ValuePolicy, CachePolicy::SkipData);
+					const bool ValueSkipData = EnumHasAllFlags(ValuePolicy, CachePolicy::SkipData);
 					if (ValueSkipData)
 					{
 						// Verify that chunk exist even if we skip the actual data
@@ -1341,7 +1345,7 @@ namespace impl {
 						{
 							continue;
 						}
-						bool ValueQueryRemote = EnumHasAllFlags(ValuePolicy, CachePolicy::QueryRemote);
+						const bool ValueQueryRemote = EnumHasAllFlags(ValuePolicy, CachePolicy::QueryRemote);
 						if (ValueQueryRemote)
 						{
 							RecordRequestData.MissingValueCount++;
@@ -1350,26 +1354,31 @@ namespace impl {
 					}
 					if (IoBuffer Chunk = CidStore.FindChunkByCid(Value.RawHash))
 					{
-						ZEN_ASSERT(Chunk.GetSize() > 0);
+						if (Chunk.GetSize() == 0)
+						{
+							ZEN_WARN("local value {}/{}/{}/{} is zero size, skipping",
+									 Request.Namespace,
+									 Key.Bucket,
+									 Key.Hash,
+									 Value.RawHash);
+							continue;
+						}
 						RecordResult->Values[ValueIndex].Body = CompressedBuffer::FromCompressed(SharedBuffer(Chunk));
 						continue;
 					}
-					if (EnumHasAllFlags(ValuePolicy, CachePolicy::QueryRemote))
+					const bool ValueQueryRemote = EnumHasAllFlags(ValuePolicy, CachePolicy::QueryRemote);
+					if (ValueQueryRemote)
 					{
 						RecordRequestData.MissingValueCount++;
 					}
 				}
 			}
-			ZEN_ASSERT(RecordRequestData.MissingValueCount <= RecordResult->Values.size());
-			if (!RecordResult || RecordRequestData.MissingValueCount > 0)
+
+			bool RecordQueryRemote = EnumHasAllFlags(RecordRequestData.RecordPolicy, CachePolicy::QueryRemote);
+
+			if ((RecordRequestData.MissingLocalRecord && RecordQueryRemote) || (RecordRequestData.MissingValueCount > 0))
 			{
-				bool RecordQueryRemote = EnumHasAllFlags(RecordPolicy, CachePolicy::QueryRemote);
-				if (!RecordQueryRemote)
-				{
-					continue;
-				}
 				UpstreamRecordIndexes.push_back(RequestIndex);
-				RecordRequestData.MissingRecord = !RecordResult;
 			}
 		}
 
@@ -1396,14 +1405,15 @@ namespace impl {
 				CacheRecordPolicyBuilder Builder(UpstreamBasePolicy);
 				for (size_t ValueIndex = 0; ValueIndex < RecordResult->Values.size(); ++ValueIndex)
 				{
-					cacherequests::GetCacheRecordResultValue& Value = RecordResult->Values[ValueIndex];
-					const CachePolicy ValuePolicy		  = cacherequests::GetEffectiveValuePolicy(Policy, RequestIndex, Value.Id);
-					CachePolicy		  ValueUpstreamPolicy = ConvertToUpstream(ValuePolicy);
-					const bool		  QueryRemote		  = EnumHasAllFlags(ValueUpstreamPolicy, CachePolicy::QueryLocal);
-					const bool		  GetData			  = !EnumHasAnyFlags(ValueUpstreamPolicy, CachePolicy::SkipData) &&
-										 !EnumHasAnyFlags(ValuePolicy, CachePolicy::SkipData);
-					bool GetFromUpstream = QueryRemote && GetData;
-					if (RecordResult->Values[ValueIndex].Body || !GetFromUpstream)
+					const cacherequests::GetCacheRecordResultValue& Value = RecordResult->Values[ValueIndex];
+					const CachePolicy ValuePolicy			= cacherequests::GetEffectiveValuePolicy(Policy, RequestIndex, Value.Id);
+					const bool		  ValueQueryRemote		= EnumHasAllFlags(ValuePolicy, CachePolicy::QueryRemote);
+					CachePolicy		  ValueUpstreamPolicy	= ConvertToUpstream(ValuePolicy);
+					const bool		  ValueSkipData			= EnumHasAnyFlags(ValuePolicy, CachePolicy::SkipData);
+					const bool		  ValueUpstreamSkipData = EnumHasAnyFlags(ValueUpstreamPolicy, CachePolicy::SkipData);
+					const bool		  ValueGetFromRemote	= !ValueSkipData && !ValueUpstreamSkipData;
+					const bool		  ValueGetFromUpstream	= ValueQueryRemote && ValueGetFromRemote;
+					if (RecordResult->Values[ValueIndex].Body || (!ValueGetFromUpstream))
 					{
 						ValueUpstreamPolicy |= CachePolicy::SkipData;
 					}
@@ -1426,12 +1436,11 @@ namespace impl {
 					continue;
 				}
 
-				if (RecordRequestData.MissingRecord)
+				if (RecordRequestData.MissingLocalRecord)
 				{
 					RecordRequestData.UsedUpstream = true;
 
-					const CachePolicy RecordPolicy = cacherequests::GetEffectiveRecordPolicy(Policy, RequestIndex);
-					if (EnumHasAllFlags(RecordPolicy, CachePolicy::StoreLocal))
+					if (EnumHasAllFlags(RecordRequestData.RecordPolicy, CachePolicy::StoreLocal))
 					{
 						cacherequests::CacheRecord Record = {.Key = RecordResult->Key};
 						Record.Values.reserve(RecordResult->Values.size());
@@ -1455,18 +1464,20 @@ namespace impl {
 				for (cacherequests::GetCacheRecordResultValue& ValueResult : RecordResult->Values)
 				{
 					const CachePolicy UpstreamValuePolicy = GetEffectiveValuePolicy(UpstreamPolicy, RequestIndex, ValueResult.Id);
-					if (!EnumHasAnyFlags(UpstreamValuePolicy, CachePolicy::Query))
+					const bool		  ValueQueryUpstream  = EnumHasAnyFlags(UpstreamValuePolicy, CachePolicy::Query);
+					if (!ValueQueryUpstream)
 					{
 						continue;
 					}
-					if (EnumHasAnyFlags(UpstreamValuePolicy, CachePolicy::SkipData))
+					const bool ValueSkipDataUpstream = EnumHasAnyFlags(UpstreamValuePolicy, CachePolicy::SkipData);
+					if (ValueSkipDataUpstream)
 					{
 						continue;
 					}
 
 					if (ValueResult.Body)
 					{
-						if (!RecordRequestData.MissingRecord)
+						if (!RecordRequestData.MissingLocalRecord)
 						{
 							ZEN_ASSERT(RecordRequestData.MissingValueCount > 0);
 							RecordRequestData.MissingValueCount--;
@@ -1479,7 +1490,7 @@ namespace impl {
 						}
 						continue;
 					}
-					if (RecordRequestData.MissingRecord)
+					if (RecordRequestData.MissingLocalRecord)
 					{
 						RecordRequestData.MissingValueCount++;
 						ZEN_ASSERT(RecordRequestData.MissingValueCount <= RecordResult->Values.size());
@@ -1498,17 +1509,15 @@ namespace impl {
 				continue;
 			}
 			RecordRequestData& RecordRequestData = RequestData[RequestIndex];
-			const CachePolicy  RecordPolicy		 = cacherequests::GetEffectiveRecordPolicy(Policy, RequestIndex);
-			const bool		   IsPartial		 = RecordRequestData.MissingValueCount > 0;
-			//! RecordRequestData.MissingValues.empty();
-			if (IsPartial && !EnumHasAllFlags(RecordPolicy, CachePolicy::PartialRecord))
+			const bool		   RecordIsPartial	 = RecordRequestData.MissingValueCount > 0;
+			if (RecordIsPartial && !EnumHasAllFlags(RecordRequestData.RecordPolicy, CachePolicy::PartialRecord))
 			{
 				// Clear the result record here, caller did not want any partial records
 				ZEN_DEBUG("MISS - '{}/{}/{}' {}{}",
 						  Request.Namespace,
 						  Key.Bucket,
 						  Key.Hash,
-						  IsPartial ? " (PARTIAL)"sv : ""sv,
+						  "(PARTIAL)"sv,
 						  RecordRequestData.UsedUpstream ? " (UPSTREAM)"sv : ""sv);
 				RecordResult.reset();
 				MissCount++;
@@ -1518,7 +1527,7 @@ namespace impl {
 					  Request.Namespace,
 					  Key.Bucket,
 					  Key.Hash,
-					  IsPartial ? " (PARTIAL)"sv : ""sv,
+					  RecordIsPartial ? " (PARTIAL)"sv : ""sv,
 					  RecordRequestData.UsedUpstream ? " (UPSTREAM)"sv : ""sv);
 			HitCount++;
 			UpstreamHitCount += RecordRequestData.UsedUpstream ? 1 : 0;