blob: 0a17446aeabc8cb1afdd2eda9958f9f7de81a385 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include <zenhttp/httpserver.h>
#include <zenhttp/httpstatus.h>
#include <zenutil/zenserverprocess.h>
#include <memory>
#include <string_view>
ZEN_THIRD_PARTY_INCLUDES_START
#include <asio.hpp>
ZEN_THIRD_PARTY_INCLUDES_END
//////////////////////////////////////////////////////////////////////////
// Services
//
#include <zenhttp/auth/authmgr.h>
#include <zenhttp/auth/authservice.h>
#include <zenhttp/httpstats.h>
#include <zenhttp/httpstatus.h>
#include <zenhttp/httptest.h>
#include <zenstore/cache/structuredcachestore.h>
#include <zenstore/gc.h>
#include "admin/admin.h"
#include "buildstore/httpbuildstore.h"
#include "cache/httpstructuredcache.h"
#include "diag/diagsvcs.h"
#include "frontend/frontend.h"
#include "objectstore/objectstore.h"
#include "projectstore/httpprojectstore.h"
#include "projectstore/projectstore.h"
#include "stats/statsreporter.h"
#include "upstream/upstream.h"
#include "vfs/vfsservice.h"
#include "workspaces/httpworkspaces.h"
#ifndef ZEN_APP_NAME
# define ZEN_APP_NAME "Unreal Zen Storage Server"
#endif
namespace zen {
struct ZenServerOptions;
class ZenServer : public IHttpStatusProvider
{
ZenServer& operator=(ZenServer&&) = delete;
ZenServer(ZenServer&&) = delete;
public:
ZenServer();
~ZenServer();
int Initialize(const ZenServerOptions& ServerOptions, ZenServerState::ZenServerEntry* ServerEntry);
void InitializeState(const ZenServerOptions& ServerOptions);
void InitializeStructuredCache(const ZenServerOptions& ServerOptions);
void Run();
void RequestExit(int ExitCode);
void Cleanup();
void SetDedicatedMode(bool State) { m_IsDedicatedMode = State; }
void SetTestMode(bool State) { m_TestMode = State; }
void SetDataRoot(std::filesystem::path Root) { m_DataRoot = Root; }
void SetContentRoot(std::filesystem::path Root) { m_ContentRoot = Root; }
std::function<void()> m_IsReadyFunc;
void SetIsReadyFunc(std::function<void()>&& IsReadyFunc) { m_IsReadyFunc = std::move(IsReadyFunc); }
void OnReady();
void EnsureIoRunner();
void EnqueueProcessMonitorTimer();
void EnqueueStateMarkerTimer();
void EnqueueSigIntTimer();
void EnqueueStateExitFlagTimer();
void EnqueueStatsReportingTimer();
void CheckStateMarker();
void CheckSigInt();
void CheckStateExitFlag();
void CheckOwnerPid();
bool UpdateProcessMonitor();
void Flush();
virtual void HandleStatusRequest(HttpServerRequest& Request) override;
private:
ZenServerState::ZenServerEntry* m_ServerEntry = nullptr;
bool m_IsDedicatedMode = false;
bool m_TestMode = false;
bool m_IsPowerCycle = false;
CbObject m_RootManifest;
std::filesystem::path m_DataRoot;
std::filesystem::path m_ContentRoot;
std::thread m_IoRunner;
asio::io_context m_IoContext;
asio::steady_timer m_PidCheckTimer{m_IoContext};
asio::steady_timer m_StateMakerTimer{m_IoContext};
asio::steady_timer m_StateExitFlagTimer{m_IoContext};
asio::steady_timer m_SigIntTimer{m_IoContext};
asio::steady_timer m_StatsReportingTimer{m_IoContext};
ProcessMonitor m_ProcessMonitor;
NamedMutex m_ServerMutex;
bool m_FoundNoActiveSponsors = false;
enum ServerState
{
kInitializing,
kRunning,
kShuttingDown
} m_CurrentState = kInitializing;
inline void SetNewState(ServerState NewState) { m_CurrentState = NewState; }
static std::string_view ToString(ServerState Value);
StatsReporter m_StatsReporter;
Ref<HttpServer> m_Http;
std::unique_ptr<AuthMgr> m_AuthMgr;
std::unique_ptr<HttpAuthService> m_AuthService;
HttpStatusService m_StatusService;
HttpStatsService m_StatsService;
GcManager m_GcManager;
GcScheduler m_GcScheduler{m_GcManager};
tsl::robin_map<std::string, std::unique_ptr<CidStore>> m_CidStores;
Ref<ZenCacheStore> m_CacheStore;
std::unique_ptr<OpenProcessCache> m_OpenProcessCache;
HttpTestService m_TestService;
std::unique_ptr<CidStore> m_BuildCidStore;
std::unique_ptr<BuildStore> m_BuildStore;
#if ZEN_WITH_TESTS
HttpTestingService m_TestingService;
#endif
RefPtr<ProjectStore> m_ProjectStore;
std::unique_ptr<HttpProjectService> m_HttpProjectService;
std::unique_ptr<Workspaces> m_Workspaces;
std::unique_ptr<HttpWorkspacesService> m_HttpWorkspacesService;
std::unique_ptr<UpstreamCache> m_UpstreamCache;
std::unique_ptr<HttpUpstreamService> m_UpstreamService;
std::unique_ptr<HttpStructuredCacheService> m_StructuredCacheService;
HttpHealthService m_HealthService;
std::unique_ptr<HttpFrontendService> m_FrontendService;
std::unique_ptr<HttpObjectStoreService> m_ObjStoreService;
std::unique_ptr<HttpBuildStoreService> m_BuildStoreService;
std::unique_ptr<VfsService> m_VfsService;
std::unique_ptr<JobQueue> m_JobQueue;
std::unique_ptr<HttpAdminService> m_AdminService;
bool m_DebugOptionForcedCrash = false;
bool m_UseSentry = false;
std::string m_StartupScrubOptions;
};
void zenserver_forcelinktests();
} // namespace zen
|