Moved cloud cache token provider out from options.

8 files changed, 54 insertions, 36 deletions

diff --git a/zenserver/compute/apply.cpp b/zenserver/compute/apply.cpp
index 1d32fa35f..83fef9058 100644
--- a/zenserver/compute/apply.cpp
+++ b/zenserver/compute/apply.cpp
@@ -337,14 +337,15 @@ HttpFunctionService::HttpFunctionService(CasStore& Store, CidStore& InCidStore,
 {
 	m_UpstreamApply = MakeUpstreamApply({}, m_CasStore, m_CidStore);
 
-	CloudCacheAccessToken AccessToken{.Value = "ServiceAccount 0f8056b30bd0df0959be55fc3338159b6f938456d3474aed0087fb965268d079"};
+	CloudCacheAccessToken AccessToken{.Value	  = "ServiceAccount 0f8056b30bd0df0959be55fc3338159b6f938456d3474aed0087fb965268d079",
+									  .ExpireTime = CloudCacheAccessToken::TimePoint::max()};
 
 	CloudCacheClientOptions Options = {.ServiceUrl		   = "https://horde.devtools-dev.epicgames.com"sv,
 									   .DdcNamespace	   = "default"sv,
-									   .BlobStoreNamespace = "default"sv,
-									   .TokenProvider	   = CloudCacheTokenProvider::MakeFromStaticToken(AccessToken)};
+									   .BlobStoreNamespace = "default"sv};
 
-	auto HordeUpstreamEndpoint = MakeHordeUpstreamEndpoint(std::move(Options), m_CasStore, m_CidStore);
+	auto HordeUpstreamEndpoint =
+		MakeHordeUpstreamEndpoint(Options, CloudCacheTokenProvider::MakeFromStaticToken(AccessToken), m_CasStore, m_CidStore);
 	m_UpstreamApply->RegisterEndpoint(std::move(HordeUpstreamEndpoint));
 	m_UpstreamApply->Initialize();
 
diff --git a/zenserver/upstream/jupiter.cpp b/zenserver/upstream/jupiter.cpp
index f141856c1..b377ac629 100644
--- a/zenserver/upstream/jupiter.cpp
+++ b/zenserver/upstream/jupiter.cpp
@@ -854,15 +854,16 @@ CloudCacheTokenProvider::MakeFromOAuthClientCredentials(const OAuthClientCredent
 	return std::make_unique<OAuthClientCredentialsTokenProvider>(Params);
 }
 
-CloudCacheClient::CloudCacheClient(CloudCacheClientOptions&& Options)
+CloudCacheClient::CloudCacheClient(const CloudCacheClientOptions& Options, std::unique_ptr<CloudCacheTokenProvider> TokenProvider)
 : m_Log(zen::logging::Get("jupiter"))
 , m_ServiceUrl(Options.ServiceUrl)
 , m_DdcNamespace(Options.DdcNamespace)
 , m_BlobStoreNamespace(Options.BlobStoreNamespace)
 , m_ConnectTimeout(Options.ConnectTimeout)
 , m_Timeout(Options.Timeout)
-, m_TokenProvider(std::move(Options.TokenProvider))
+, m_TokenProvider(std::move(TokenProvider))
 {
+	ZEN_ASSERT(m_TokenProvider.get() != nullptr);
 }
 
 CloudCacheClient::~CloudCacheClient()
diff --git a/zenserver/upstream/jupiter.h b/zenserver/upstream/jupiter.h
index 82b67b8e1..31224500a 100644
--- a/zenserver/upstream/jupiter.h
+++ b/zenserver/upstream/jupiter.h
@@ -161,14 +161,13 @@ public:
 
 struct CloudCacheClientOptions
 {
-	std::string_view						 Name;
-	std::string_view						 ServiceUrl;
-	std::string_view						 DdcNamespace;
-	std::string_view						 BlobStoreNamespace;
-	std::chrono::milliseconds				 ConnectTimeout{5000};
-	std::chrono::milliseconds				 Timeout{};
-	std::unique_ptr<CloudCacheTokenProvider> TokenProvider;
-	bool									 UseLegacyDdc = false;
+	std::string_view		  Name;
+	std::string_view		  ServiceUrl;
+	std::string_view		  DdcNamespace;
+	std::string_view		  BlobStoreNamespace;
+	std::chrono::milliseconds ConnectTimeout{5000};
+	std::chrono::milliseconds Timeout{};
+	bool					  UseLegacyDdc = false;
 };
 
 /**
@@ -177,7 +176,7 @@ struct CloudCacheClientOptions
 class CloudCacheClient : public RefCounted
 {
 public:
-	CloudCacheClient(CloudCacheClientOptions&& Options);
+	CloudCacheClient(const CloudCacheClientOptions& Options, std::unique_ptr<CloudCacheTokenProvider> TokenProvider);
 	~CloudCacheClient();
 
 	CloudCacheAccessToken AcquireAccessToken();
diff --git a/zenserver/upstream/upstreamapply.cpp b/zenserver/upstream/upstreamapply.cpp
index 220daab27..63c334265 100644
--- a/zenserver/upstream/upstreamapply.cpp
+++ b/zenserver/upstream/upstreamapply.cpp
@@ -48,13 +48,16 @@ namespace detail {
 	class HordeUpstreamApplyEndpoint final : public UpstreamApplyEndpoint
 	{
 	public:
-		HordeUpstreamApplyEndpoint(CloudCacheClientOptions&& Options, CasStore& CasStore, CidStore& CidStore)
+		HordeUpstreamApplyEndpoint(const CloudCacheClientOptions&				 Options,
+								   std::unique_ptr<zen::CloudCacheTokenProvider> TokenProvider,
+								   CasStore&									 CasStore,
+								   CidStore&									 CidStore)
 		: m_Log(logging::Get("upstream-apply"))
 		, m_CasStore(CasStore)
 		, m_CidStore(CidStore)
 		{
 			m_DisplayName = fmt::format("Horde - '{}'", Options.ServiceUrl);
-			m_Client	  = new CloudCacheClient(std::move(Options));
+			m_Client	  = new CloudCacheClient(Options, std::move(TokenProvider));
 			m_ChannelId	  = fmt::format("zen-{}", zen::GetSessionIdString());
 		}
 
@@ -1561,9 +1564,12 @@ MakeUpstreamApply(const UpstreamApplyOptions& Options, CasStore& CasStore, CidSt
 }
 
 std::unique_ptr<UpstreamApplyEndpoint>
-MakeHordeUpstreamEndpoint(CloudCacheClientOptions&& Options, CasStore& CasStore, CidStore& CidStore)
+MakeHordeUpstreamEndpoint(const CloudCacheClientOptions&		   Options,
+						  std::unique_ptr<CloudCacheTokenProvider> TokenProvider,
+						  CasStore&								   CasStore,
+						  CidStore&								   CidStore)
 {
-	return std::make_unique<detail::HordeUpstreamApplyEndpoint>(std::move(Options), CasStore, CidStore);
+	return std::make_unique<detail::HordeUpstreamApplyEndpoint>(Options, std::move(TokenProvider), CasStore, CidStore);
 }
 
 }  // namespace zen
diff --git a/zenserver/upstream/upstreamapply.h b/zenserver/upstream/upstreamapply.h
index 114364581..e48b67c61 100644
--- a/zenserver/upstream/upstreamapply.h
+++ b/zenserver/upstream/upstreamapply.h
@@ -24,6 +24,7 @@ class CasStore;
 class CidStore;
 class ZenCacheStore;
 struct CloudCacheClientOptions;
+class CloudCacheTokenProvider;
 
 enum class UpstreamApplyState : int32_t
 {
@@ -169,7 +170,10 @@ public:
 
 std::unique_ptr<UpstreamApply> MakeUpstreamApply(const UpstreamApplyOptions& Options, CasStore& CasStore, CidStore& CidStore);
 
-std::unique_ptr<UpstreamApplyEndpoint> MakeHordeUpstreamEndpoint(CloudCacheClientOptions&& Options, CasStore& CasStore, CidStore& CidStore);
+std::unique_ptr<UpstreamApplyEndpoint> MakeHordeUpstreamEndpoint(const CloudCacheClientOptions&			  Options,
+																 std::unique_ptr<CloudCacheTokenProvider> TokenProvider,
+																 CasStore&								  CasStore,
+																 CidStore&								  CidStore);
 
 }  // namespace zen
 
diff --git a/zenserver/upstream/upstreamcache.cpp b/zenserver/upstream/upstreamcache.cpp
index f432d322c..232ed3031 100644
--- a/zenserver/upstream/upstreamcache.cpp
+++ b/zenserver/upstream/upstreamcache.cpp
@@ -85,7 +85,9 @@ namespace detail {
 	class JupiterUpstreamEndpoint final : public UpstreamEndpoint
 	{
 	public:
-		JupiterUpstreamEndpoint(CloudCacheClientOptions&& Options, AuthMgr& Mgr)
+		JupiterUpstreamEndpoint(const CloudCacheClientOptions&			 Options,
+								std::unique_ptr<CloudCacheTokenProvider> TokenProvider,
+								AuthMgr&								 Mgr)
 		: m_AuthMgr(Mgr)
 		, m_Log(zen::logging::Get("upstream"))
 		, m_UseLegacyDdc(Options.UseLegacyDdc)
@@ -93,7 +95,7 @@ namespace detail {
 			ZEN_ASSERT(!Options.Name.empty());
 			m_Info.Name = Options.Name;
 			m_Info.Url	= Options.ServiceUrl;
-			m_Client	= new CloudCacheClient(std::move(Options));
+			m_Client	= new CloudCacheClient(Options, std::move(TokenProvider));
 		}
 
 		virtual ~JupiterUpstreamEndpoint() = default;
@@ -1490,9 +1492,9 @@ MakeUpstreamCache(const UpstreamCacheOptions& Options, ZenCacheStore& CacheStore
 }
 
 std::unique_ptr<UpstreamEndpoint>
-MakeJupiterUpstreamEndpoint(CloudCacheClientOptions&& Options, AuthMgr& Mgr)
+MakeJupiterUpstreamEndpoint(const CloudCacheClientOptions& Options, std::unique_ptr<CloudCacheTokenProvider> TokenProvider, AuthMgr& Mgr)
 {
-	return std::make_unique<detail::JupiterUpstreamEndpoint>(std::move(Options), Mgr);
+	return std::make_unique<detail::JupiterUpstreamEndpoint>(Options, std::move(TokenProvider), Mgr);
 }
 
 std::unique_ptr<UpstreamEndpoint>
diff --git a/zenserver/upstream/upstreamcache.h b/zenserver/upstream/upstreamcache.h
index 8eb852c53..c82af28c6 100644
--- a/zenserver/upstream/upstreamcache.h
+++ b/zenserver/upstream/upstreamcache.h
@@ -22,6 +22,7 @@ class CbObjectWriter;
 class CidStore;
 class ZenCacheStore;
 struct CloudCacheClientOptions;
+class CloudCacheTokenProvider;
 struct ZenStructuredCacheClientOptions;
 
 struct UpstreamCacheRecord
@@ -204,7 +205,9 @@ public:
 
 std::unique_ptr<UpstreamCache> MakeUpstreamCache(const UpstreamCacheOptions& Options, ZenCacheStore& CacheStore, CidStore& CidStore);
 
-std::unique_ptr<UpstreamEndpoint> MakeJupiterUpstreamEndpoint(CloudCacheClientOptions&& Options, AuthMgr& Mgr);
+std::unique_ptr<UpstreamEndpoint> MakeJupiterUpstreamEndpoint(const CloudCacheClientOptions&		   Options,
+															  std::unique_ptr<CloudCacheTokenProvider> TokenProvider,
+															  AuthMgr&								   Mgr);
 
 std::unique_ptr<UpstreamEndpoint> MakeZenUpstreamEndpoint(const ZenStructuredCacheClientOptions& Options);
 
diff --git a/zenserver/zenserver.cpp b/zenserver/zenserver.cpp
index a67e9f7e8..2c9610866 100644
--- a/zenserver/zenserver.cpp
+++ b/zenserver/zenserver.cpp
@@ -742,20 +742,23 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 
 		// Jupiter upstream
 		{
-			zen::CloudCacheClientOptions Options;
+			zen::CloudCacheClientOptions			 Options;
+			std::unique_ptr<CloudCacheTokenProvider> TokenProvider;
+			std::string								 EndpointName;
+			std::string								 Url;
 
 			if (UpstreamConfig.JupiterConfig.UseProductionSettings || UpstreamConfig.JupiterConfig.UseDevelopmentSettings)
 			{
-				std::string EndpointName = "Jupiter-Dev"sv;
-				std::string Url			 = "https://jupiter.devtools-dev.epicgames.com" sv;
+				EndpointName = "Jupiter-Dev";
+				Url			 = "https://jupiter.devtools-dev.epicgames.com";
 
 				if (UpstreamConfig.JupiterConfig.UseProductionSettings)
 				{
-					EndpointName = "Jupiter-Prod"sv;
-					Url			 = "https://jupiter.devtools.epicgames.com" sv;
+					EndpointName = "Jupiter-Prod";
+					Url			 = "https://jupiter.devtools.epicgames.com";
 				}
 
-				auto TokenProvider = CloudCacheTokenProvider::MakeFromOAuthClientCredentials(
+				TokenProvider = CloudCacheTokenProvider::MakeFromOAuthClientCredentials(
 					{.Url		   = "https://epicgames.okta.com/oauth2/auso645ojjWVdRI3d0x7/v1/token"sv,
 					 .ClientId	   = "0oao91lrhqPiAlaGD0x7"sv,
 					 .ClientSecret = "-GBWjjenhCgOwhxL5yBKNJECVIoDPH0MK4RDuN7d"sv});
@@ -767,14 +770,13 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 												 .BlobStoreNamespace = "ue.ddc"sv,
 												 .ConnectTimeout	 = std::chrono::milliseconds(UpstreamConfig.ConnectTimeoutMilliseconds),
 												 .Timeout			 = std::chrono::milliseconds(UpstreamConfig.TimeoutMilliseconds),
-												 .TokenProvider		 = std::move(TokenProvider),
 												 .UseLegacyDdc		 = false};
 			}
 			else
 			{
-				const auto EndpointName = UpstreamConfig.JupiterConfig.Name.empty() ? "Jupiter"sv : UpstreamConfig.JupiterConfig.Name;
+				EndpointName = UpstreamConfig.JupiterConfig.Name.empty() ? "Jupiter"sv : UpstreamConfig.JupiterConfig.Name;
 
-				auto TokenProvider = CloudCacheTokenProvider::MakeFromOAuthClientCredentials(
+				TokenProvider = CloudCacheTokenProvider::MakeFromOAuthClientCredentials(
 					{.Url		   = "https://epicgames.okta.com/oauth2/auso645ojjWVdRI3d0x7/v1/token"sv,
 					 .ClientId	   = "0oao91lrhqPiAlaGD0x7"sv,
 					 .ClientSecret = "-GBWjjenhCgOwhxL5yBKNJECVIoDPH0MK4RDuN7d"sv});
@@ -786,13 +788,13 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 												 .BlobStoreNamespace = UpstreamConfig.JupiterConfig.Namespace,
 												 .ConnectTimeout	 = std::chrono::milliseconds(UpstreamConfig.ConnectTimeoutMilliseconds),
 												 .Timeout			 = std::chrono::milliseconds(UpstreamConfig.TimeoutMilliseconds),
-												 .TokenProvider		 = std::move(TokenProvider),
 												 .UseLegacyDdc		 = false};
 			}
 
 			if (!Options.ServiceUrl.empty())
 			{
-				std::unique_ptr<zen::UpstreamEndpoint> JupiterEndpoint = zen::MakeJupiterUpstreamEndpoint(std::move(Options), *m_AuthMgr);
+				std::unique_ptr<zen::UpstreamEndpoint> JupiterEndpoint =
+					zen::MakeJupiterUpstreamEndpoint(Options, std::move(TokenProvider), *m_AuthMgr);
 				m_UpstreamCache->RegisterEndpoint(std::move(JupiterEndpoint));
 			}
 		}