Merge branch 'main' of https://github.ol.epicgames.net/ue-foundation/zensb/cleanup-main

1 files changed, 41 insertions, 48 deletions

diff --git a/src/zenserver/projectstore/jupiterremoteprojectstore.cpp b/src/zenserver/projectstore/jupiterremoteprojectstore.cpp
index f4fe578ff..e906127ff 100644
--- a/src/zenserver/projectstore/jupiterremoteprojectstore.cpp
+++ b/src/zenserver/projectstore/jupiterremoteprojectstore.cpp
@@ -5,8 +5,10 @@
 #include <zencore/compress.h>
 #include <zencore/fmtutils.h>
 
-#include <upstream/jupiter.h>
-#include <zenhttp/auth/authmgr.h>
+#include <zenhttp/httpclientauth.h>
+
+#include <zenutil/jupiter/jupiterclient.h>
+#include <zenutil/jupiter/jupitersession.h>
 
 namespace zen {
 
@@ -15,7 +17,7 @@ using namespace std::literals;
 class JupiterRemoteStore : public RemoteProjectStore
 {
 public:
-	JupiterRemoteStore(Ref<CloudCacheClient>&&		CloudClient,
+	JupiterRemoteStore(Ref<JupiterClient>&&			InJupiterClient,
 					   std::string_view				Namespace,
 					   std::string_view				Bucket,
 					   const IoHash&				Key,
@@ -23,7 +25,7 @@ public:
 					   bool							ForceDisableBlocks,
 					   bool							ForceDisableTempBlocks,
 					   const std::filesystem::path& TempFilePath)
-	: m_CloudClient(std::move(CloudClient))
+	: m_JupiterClient(std::move(InJupiterClient))
 	, m_Namespace(Namespace)
 	, m_Bucket(Bucket)
 	, m_Key(Key)
@@ -47,7 +49,7 @@ public:
 				.AllowChunking	   = true,
 				.ContainerName	   = fmt::format("{}/{}/{}", m_Namespace, m_Bucket, m_Key),
 				.Description	   = fmt::format("[cloud] {} as {}/{}/{}{}"sv,
-											 m_CloudClient->ServiceUrl(),
+											 m_JupiterClient->ServiceUrl(),
 											 m_Namespace,
 											 m_Bucket,
 											 m_Key,
@@ -73,15 +75,15 @@ public:
 
 	virtual SaveResult SaveContainer(const IoBuffer& Payload) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		PutRefResult	  PutResult = Session.PutRef(m_Namespace, m_Bucket, m_Key, Payload, ZenContentType::kCbObject);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		PutRefResult   PutResult = Session.PutRef(m_Namespace, m_Bucket, m_Key, Payload, ZenContentType::kCbObject);
 		AddStats(PutResult);
 
 		SaveResult Result{ConvertResult(PutResult), {PutResult.Needs.begin(), PutResult.Needs.end()}, PutResult.RawHash};
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed saving oplog container to {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_Key,
@@ -92,15 +94,15 @@ public:
 
 	virtual SaveAttachmentResult SaveAttachment(const CompositeBuffer& Payload, const IoHash& RawHash, Block&&) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  PutResult = Session.PutCompressedBlob(m_Namespace, RawHash, Payload);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  PutResult = Session.PutCompressedBlob(m_Namespace, RawHash, Payload);
 		AddStats(PutResult);
 
 		SaveAttachmentResult Result{ConvertResult(PutResult)};
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed saving oplog attachment to {}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										RawHash,
 										Result.Reason);
@@ -125,7 +127,7 @@ public:
 
 	virtual FinalizeResult FinalizeContainer(const IoHash& RawHash) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
+		JupiterSession	  Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
 		FinalizeRefResult FinalizeRefResult = Session.FinalizeRef(m_Namespace, m_Bucket, m_Key, RawHash);
 		AddStats(FinalizeRefResult);
 
@@ -133,7 +135,7 @@ public:
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed finalizing oplog container to {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_Key,
@@ -162,8 +164,8 @@ public:
 				{.ErrorCode = static_cast<int>(HttpResponseCode::NoContent), .ElapsedSeconds = LoadResult.ElapsedSeconds}};
 		}
 
-		CloudCacheSession	   Session(m_CloudClient.Get());
-		CloudCacheExistsResult ExistsResult =
+		JupiterSession		Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterExistsResult ExistsResult =
 			Session.CompressedBlobExists(m_Namespace, std::set<IoHash>(BlockHashes.begin(), BlockHashes.end()));
 		AddStats(ExistsResult);
 
@@ -172,7 +174,7 @@ public:
 			return GetKnownBlocksResult{{.ErrorCode		 = ExistsResult.ErrorCode,
 										 .ElapsedSeconds = LoadResult.ElapsedSeconds + ExistsResult.ElapsedSeconds,
 										 .Reason		 = fmt::format("Failed checking attachment existance in {}/{}. Reason: '{}'",
-															   m_CloudClient->ServiceUrl(),
+															   m_JupiterClient->ServiceUrl(),
 															   m_Namespace,
 															   ExistsResult.Reason)}};
 		}
@@ -201,15 +203,15 @@ public:
 
 	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  GetResult = Session.GetCompressedBlob(m_Namespace, RawHash, m_TempFilePath);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  GetResult = Session.GetCompressedBlob(m_Namespace, RawHash, m_TempFilePath);
 		AddStats(GetResult);
 
 		LoadAttachmentResult Result{ConvertResult(GetResult), std::move(GetResult.Response)};
 		if (GetResult.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed fetching oplog attachment from {}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										RawHash,
 										Result.Reason);
@@ -237,14 +239,14 @@ public:
 private:
 	LoadContainerResult LoadContainer(const IoHash& Key)
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  GetResult = Session.GetRef(m_Namespace, m_Bucket, Key, ZenContentType::kCbObject);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  GetResult = Session.GetRef(m_Namespace, m_Bucket, Key, ZenContentType::kCbObject);
 		AddStats(GetResult);
 		if (GetResult.ErrorCode || !GetResult.Success)
 		{
 			LoadContainerResult Result{ConvertResult(GetResult)};
 			Result.Reason = fmt::format("Failed fetching oplog container from {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										Key,
@@ -259,7 +261,7 @@ private:
 				RemoteProjectStore::Result{.ErrorCode	   = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError),
 										   .ElapsedSeconds = GetResult.ElapsedSeconds,
 										   .Reason = fmt::format("The ref {}/{}/{}/{} is not formatted as a compact binary object"sv,
-																 m_CloudClient->ServiceUrl(),
+																 m_JupiterClient->ServiceUrl(),
 																 m_Namespace,
 																 m_Bucket,
 																 Key)},
@@ -268,7 +270,7 @@ private:
 		return LoadContainerResult{ConvertResult(GetResult), std::move(ContainerObject)};
 	}
 
-	void AddStats(const CloudCacheResult& Result)
+	void AddStats(const JupiterResult& Result)
 	{
 		m_SentBytes.fetch_add(gsl::narrow<uint64_t>(Result.SentBytes));
 		m_ReceivedBytes.fetch_add(gsl::narrow<uint64_t>(Result.ReceivedBytes));
@@ -284,7 +286,7 @@ private:
 		m_RequestCount.fetch_add(1);
 	}
 
-	static Result ConvertResult(const CloudCacheResult& Response)
+	static Result ConvertResult(const JupiterResult& Response)
 	{
 		std::string Text;
 		int32_t		ErrorCode = 0;
@@ -321,7 +323,7 @@ private:
 		return {.ErrorCode = ErrorCode, .ElapsedSeconds = Response.ElapsedSeconds, .Reason = Response.Reason, .Text = Text};
 	}
 
-	Ref<CloudCacheClient> m_CloudClient;
+	Ref<JupiterClient>	  m_JupiterClient;
 	const std::string	  m_Namespace;
 	const std::string	  m_Bucket;
 	const IoHash		  m_Key;
@@ -348,44 +350,35 @@ CreateJupiterRemoteStore(const JupiterRemoteStoreOptions& Options, const std::fi
 		// Assume https URL
 		Url = fmt::format("https://{}"sv, Url);
 	}
-	CloudCacheClientOptions ClientOptions{.Name			  = "Remote store"sv,
-										  .ServiceUrl	  = Url,
-										  .ConnectTimeout = std::chrono::milliseconds(2000),
-										  .Timeout		  = std::chrono::milliseconds(1800000),
-										  .AssumeHttp2	  = Options.AssumeHttp2,
-										  .AllowResume	  = true,
-										  .RetryCount	  = 4};
+	JupiterClientOptions ClientOptions{.Name		   = "Remote store"sv,
+									   .ServiceUrl	   = Url,
+									   .ConnectTimeout = std::chrono::milliseconds(2000),
+									   .Timeout		   = std::chrono::milliseconds(1800000),
+									   .AssumeHttp2	   = Options.AssumeHttp2,
+									   .AllowResume	   = true,
+									   .RetryCount	   = 4};
 	// 1) openid-provider if given (assumes oidctoken.exe -Zen true has been run with matching Options.OpenIdProvider
 	// 2) Access token as parameter in request
 	// 3) Environment variable (different win vs linux/mac)
 	// 4) Default openid-provider (assumes oidctoken.exe -Zen true has been run with matching Options.OpenIdProvider
 
-	std::unique_ptr<CloudCacheTokenProvider> TokenProvider;
+	std::function<HttpClientAccessToken()> TokenProvider;
 	if (!Options.OpenIdProvider.empty())
 	{
-		TokenProvider =
-			CloudCacheTokenProvider::CreateFromCallback([&AuthManager = Options.AuthManager, OpenIdProvider = Options.OpenIdProvider]() {
-				AuthMgr::OpenIdAccessToken Token = AuthManager.GetOpenIdAccessToken(OpenIdProvider.empty() ? "Default" : OpenIdProvider);
-				return CloudCacheAccessToken{.Value = Token.AccessToken, .ExpireTime = Token.ExpireTime};
-			});
+		TokenProvider = httpclientauth::CreateFromOpenIdProvider(Options.AuthManager, Options.OpenIdProvider);
 	}
 	else if (!Options.AccessToken.empty())
 	{
-		TokenProvider = CloudCacheTokenProvider::CreateFromCallback([AccessToken = "Bearer " + Options.AccessToken]() {
-			return CloudCacheAccessToken{.Value = AccessToken, .ExpireTime = GcClock::TimePoint::max()};
-		});
+		TokenProvider = httpclientauth::CreateFromStaticToken(Options.AccessToken);
 	}
 	else
 	{
-		TokenProvider = CloudCacheTokenProvider::CreateFromCallback([&AuthManager = Options.AuthManager]() {
-			AuthMgr::OpenIdAccessToken Token = AuthManager.GetOpenIdAccessToken("Default");
-			return CloudCacheAccessToken{.Value = Token.AccessToken, .ExpireTime = Token.ExpireTime};
-		});
+		TokenProvider = httpclientauth::CreateFromDefaultOpenIdProvider(Options.AuthManager);
 	}
 
-	Ref<CloudCacheClient> CloudClient(new CloudCacheClient(ClientOptions, std::move(TokenProvider)));
+	Ref<JupiterClient> Client(new JupiterClient(ClientOptions, std::move(TokenProvider)));
 
-	std::shared_ptr<RemoteProjectStore> RemoteStore = std::make_shared<JupiterRemoteStore>(std::move(CloudClient),
+	std::shared_ptr<RemoteProjectStore> RemoteStore = std::make_shared<JupiterRemoteStore>(std::move(Client),
 																						   Options.Namespace,
 																						   Options.Bucket,
 																						   Options.Key,