rename URI chunk requests from value -> chunk (#166)

6 files changed, 31 insertions, 31 deletions

diff --git a/zenserver/cache/structuredcache.cpp b/zenserver/cache/structuredcache.cpp
index f8cbfa55c..50ecd41c2 100644
--- a/zenserver/cache/structuredcache.cpp
+++ b/zenserver/cache/structuredcache.cpp
@@ -382,7 +382,7 @@ HttpStructuredCacheService::HandleRequest(HttpServerRequest& Request)
 						.BucketSegment	= RequestData.Bucket.value(),
 						.HashKey		= RequestData.HashKey.value(),
 						.ValueContentId = RequestData.ValueContentId.value()};
-		return HandleCacheValueRequest(Request, Ref, ParseCachePolicy(Request.GetQueryParams()));
+		return HandleCacheChunkRequest(Request, Ref, ParseCachePolicy(Request.GetQueryParams()));
 	}
 
 	if (RequestData.HashKey.has_value())
@@ -926,16 +926,16 @@ HttpStructuredCacheService::HandlePutCacheRecord(zen::HttpServerRequest& Request
 }
 
 void
-HttpStructuredCacheService::HandleCacheValueRequest(HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl)
+HttpStructuredCacheService::HandleCacheChunkRequest(HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl)
 {
 	switch (Request.RequestVerb())
 	{
 		case HttpVerb::kHead:
 		case HttpVerb::kGet:
-			HandleGetCacheValue(Request, Ref, PolicyFromUrl);
+			HandleGetCacheChunk(Request, Ref, PolicyFromUrl);
 			break;
 		case HttpVerb::kPut:
-			HandlePutCacheValue(Request, Ref, PolicyFromUrl);
+			HandlePutCacheChunk(Request, Ref, PolicyFromUrl);
 			break;
 		default:
 			break;
@@ -943,7 +943,7 @@ HttpStructuredCacheService::HandleCacheValueRequest(HttpServerRequest& Request,
 }
 
 void
-HttpStructuredCacheService::HandleGetCacheValue(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl)
+HttpStructuredCacheService::HandleGetCacheChunk(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl)
 {
 	Stopwatch Timer;
 
@@ -955,7 +955,7 @@ HttpStructuredCacheService::HandleGetCacheValue(zen::HttpServerRequest& Request,
 
 		if (QueryUpstream)
 		{
-			if (auto UpstreamResult = m_UpstreamCache.GetCacheValue(Ref.Namespace, {Ref.BucketSegment, Ref.HashKey}, Ref.ValueContentId);
+			if (auto UpstreamResult = m_UpstreamCache.GetCacheChunk(Ref.Namespace, {Ref.BucketSegment, Ref.HashKey}, Ref.ValueContentId);
 				UpstreamResult.Success)
 			{
 				if (CompressedBuffer Compressed = CompressedBuffer::FromCompressed(SharedBuffer(UpstreamResult.Value)))
@@ -1011,7 +1011,7 @@ HttpStructuredCacheService::HandleGetCacheValue(zen::HttpServerRequest& Request,
 }
 
 void
-HttpStructuredCacheService::HandlePutCacheValue(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl)
+HttpStructuredCacheService::HandlePutCacheChunk(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl)
 {
 	// Note: Individual cacherecord values are not propagated upstream until a valid cache record has been stored
 	ZEN_UNUSED(PolicyFromUrl);
diff --git a/zenserver/cache/structuredcache.h b/zenserver/cache/structuredcache.h
index 3777e7460..8eca17edc 100644
--- a/zenserver/cache/structuredcache.h
+++ b/zenserver/cache/structuredcache.h
@@ -101,9 +101,9 @@ private:
 	void		 HandleCacheRecordRequest(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
 	void		 HandleGetCacheRecord(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
 	void		 HandlePutCacheRecord(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
-	void		 HandleCacheValueRequest(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
-	void		 HandleGetCacheValue(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
-	void		 HandlePutCacheValue(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
+	void		 HandleCacheChunkRequest(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
+	void		 HandleGetCacheChunk(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
+	void		 HandlePutCacheChunk(zen::HttpServerRequest& Request, const CacheRef& Ref, CachePolicy PolicyFromUrl);
 	void		 HandleRpcRequest(zen::HttpServerRequest& Request);
 	void		 HandleRpcPutCacheRecords(zen::HttpServerRequest& Request, const CbPackage& BatchRequest);
 	void		 HandleRpcGetCacheRecords(zen::HttpServerRequest& Request, CbObjectView BatchRequest);
diff --git a/zenserver/upstream/upstreamcache.cpp b/zenserver/upstream/upstreamcache.cpp
index 8288b910d..6976e5bed 100644
--- a/zenserver/upstream/upstreamcache.cpp
+++ b/zenserver/upstream/upstreamcache.cpp
@@ -346,9 +346,9 @@ namespace detail {
 			return Result;
 		}
 
-		virtual GetUpstreamCacheResult GetCacheValue(std::string_view Namespace, const CacheKey&, const IoHash& ValueContentId) override
+		virtual GetUpstreamCacheResult GetCacheChunk(std::string_view Namespace, const CacheKey&, const IoHash& ValueContentId) override
 		{
-			ZEN_TRACE_CPU("Upstream::Horde::GetSingleCacheValue");
+			ZEN_TRACE_CPU("Upstream::Horde::GetSingleCacheChunk");
 
 			try
 			{
@@ -913,16 +913,16 @@ namespace detail {
 			return {.Error{.ErrorCode = Result.ErrorCode, .Reason = std::move(Result.Reason)}};
 		}
 
-		virtual GetUpstreamCacheResult GetCacheValue(std::string_view Namespace,
+		virtual GetUpstreamCacheResult GetCacheChunk(std::string_view Namespace,
 													 const CacheKey&  CacheKey,
 													 const IoHash&	  ValueContentId) override
 		{
-			ZEN_TRACE_CPU("Upstream::Zen::GetCacheValue");
+			ZEN_TRACE_CPU("Upstream::Zen::GetCacheChunk");
 
 			try
 			{
 				ZenStructuredCacheSession Session(GetClientRef());
-				const ZenCacheResult	  Result = Session.GetCacheValue(Namespace, CacheKey.Bucket, CacheKey.Hash, ValueContentId);
+				const ZenCacheResult	  Result = Session.GetCacheChunk(Namespace, CacheKey.Bucket, CacheKey.Hash, ValueContentId);
 
 				m_Status.SetFromErrorCode(Result.ErrorCode, Result.Reason);
 
@@ -1642,11 +1642,11 @@ public:
 		}
 	}
 
-	virtual GetUpstreamCacheResult GetCacheValue(std::string_view Namespace,
+	virtual GetUpstreamCacheResult GetCacheChunk(std::string_view Namespace,
 												 const CacheKey&  CacheKey,
 												 const IoHash&	  ValueContentId) override
 	{
-		ZEN_TRACE_CPU("Upstream::GetCacheValue");
+		ZEN_TRACE_CPU("Upstream::GetCacheChunk");
 
 		if (m_Options.ReadUpstream)
 		{
@@ -1662,7 +1662,7 @@ public:
 
 				{
 					metrics::OperationTiming::Scope Scope(Stats.CacheGetRequestTiming);
-					Result = Endpoint->GetCacheValue(Namespace, CacheKey, ValueContentId);
+					Result = Endpoint->GetCacheChunk(Namespace, CacheKey, ValueContentId);
 				}
 
 				Stats.CacheGetCount.Increment(1);
@@ -1679,7 +1679,7 @@ public:
 				{
 					Stats.CacheErrorCount.Increment(1);
 
-					ZEN_WARN("get cache value FAILED, endpoint '{}', reason '{}', error code '{}'",
+					ZEN_WARN("get cache chunk FAILED, endpoint '{}', reason '{}', error code '{}'",
 							 Endpoint->GetEndpointInfo().Url,
 							 Result.Error.Reason,
 							 Result.Error.ErrorCode);
diff --git a/zenserver/upstream/upstreamcache.h b/zenserver/upstream/upstreamcache.h
index 5b154a1b5..4a4bede0f 100644
--- a/zenserver/upstream/upstreamcache.h
+++ b/zenserver/upstream/upstreamcache.h
@@ -179,14 +179,14 @@ public:
 												   std::span<CacheKeyRequest*> Requests,
 												   OnCacheRecordGetComplete&&  OnComplete)									 = 0;
 
-	virtual GetUpstreamCacheResult GetCacheValue(std::string_view Namespace, const CacheKey& CacheKey, const IoHash& PayloadId) = 0;
 	virtual GetUpstreamCacheResult GetCacheValues(std::string_view				Namespace,
 												  std::span<CacheValueRequest*> CacheValueRequests,
-												  OnCacheValueGetComplete&&		OnComplete)											= 0;
+												  OnCacheValueGetComplete&&		OnComplete) = 0;
 
+	virtual GetUpstreamCacheResult GetCacheChunk(std::string_view Namespace, const CacheKey& CacheKey, const IoHash& PayloadId) = 0;
 	virtual GetUpstreamCacheResult GetCacheChunks(std::string_view				Namespace,
 												  std::span<CacheChunkRequest*> CacheChunkRequests,
-												  OnCacheChunksGetComplete&&	OnComplete) = 0;
+												  OnCacheChunksGetComplete&&	OnComplete)										= 0;
 
 	virtual PutUpstreamCacheResult PutCacheRecord(const UpstreamCacheRecord& CacheRecord,
 												  IoBuffer					 RecordValue,
@@ -219,14 +219,14 @@ public:
 												   std::span<CacheKeyRequest*> Requests,
 												   OnCacheRecordGetComplete&&  OnComplete)									 = 0;
 
-	virtual GetUpstreamCacheResult GetCacheValue(std::string_view Namespace, const CacheKey& CacheKey, const IoHash& ValueContentId) = 0;
-	virtual void				   GetCacheValues(std::string_view				Namespace,
-												  std::span<CacheValueRequest*> CacheValueRequests,
-												  OnCacheValueGetComplete&&		OnComplete)												 = 0;
+	virtual void GetCacheValues(std::string_view			  Namespace,
+								std::span<CacheValueRequest*> CacheValueRequests,
+								OnCacheValueGetComplete&&	  OnComplete) = 0;
 
-	virtual void GetCacheChunks(std::string_view			  Namespace,
-								std::span<CacheChunkRequest*> CacheChunkRequests,
-								OnCacheChunksGetComplete&&	  OnComplete) = 0;
+	virtual GetUpstreamCacheResult GetCacheChunk(std::string_view Namespace, const CacheKey& CacheKey, const IoHash& ValueContentId) = 0;
+	virtual void				   GetCacheChunks(std::string_view				Namespace,
+												  std::span<CacheChunkRequest*> CacheChunkRequests,
+												  OnCacheChunksGetComplete&&	OnComplete)											 = 0;
 
 	virtual void EnqueueUpstream(UpstreamCacheRecord CacheRecord) = 0;
 
diff --git a/zenserver/upstream/zen.cpp b/zenserver/upstream/zen.cpp
index b837f767c..980958740 100644
--- a/zenserver/upstream/zen.cpp
+++ b/zenserver/upstream/zen.cpp
@@ -437,7 +437,7 @@ ZenStructuredCacheSession::GetCacheRecord(std::string_view Namespace, std::strin
 }
 
 ZenCacheResult
-ZenStructuredCacheSession::GetCacheValue(std::string_view Namespace,
+ZenStructuredCacheSession::GetCacheChunk(std::string_view Namespace,
 										 std::string_view BucketId,
 										 const IoHash&	  Key,
 										 const IoHash&	  ValueContentId)
diff --git a/zenserver/upstream/zen.h b/zenserver/upstream/zen.h
index 955cfa107..9a082ebc9 100644
--- a/zenserver/upstream/zen.h
+++ b/zenserver/upstream/zen.h
@@ -129,7 +129,7 @@ public:
 
 	ZenCacheResult CheckHealth();
 	ZenCacheResult GetCacheRecord(std::string_view Namespace, std::string_view BucketId, const IoHash& Key, ZenContentType Type);
-	ZenCacheResult GetCacheValue(std::string_view Namespace, std::string_view BucketId, const IoHash& Key, const IoHash& ValueContentId);
+	ZenCacheResult GetCacheChunk(std::string_view Namespace, std::string_view BucketId, const IoHash& Key, const IoHash& ValueContentId);
 	ZenCacheResult PutCacheRecord(std::string_view Namespace,
 								  std::string_view BucketId,
 								  const IoHash&	   Key,