CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Runtime/NetworkFileSystem/Private/NetworkFileServerConnection.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

1444 lines
46 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "NetworkFileServerConnection.h"
#include "HAL/PlatformFileManager.h"
#include "Misc/Paths.h"
#include "Misc/PathViews.h"
#include "Misc/ScopeLock.h"
#include "Serialization/BufferArchive.h"
#include "Misc/ConfigCacheIni.h"
#include "Misc/LocalTimestampDirectoryVisitor.h"
#include "IPlatformFileSandboxWrapper.h"
#include "NetworkMessage.h"
#include "ProjectDescriptor.h"
#include "NetworkFileSystemLog.h"
#include "Misc/PackageName.h"
#include "Interfaces/ITargetPlatform.h"
#include "HAL/PlatformTime.h"
#include "Interfaces/IPluginManager.h"
#include "PlatformInfo.h"
/**
* Helper function for resolving engine and game sandbox paths
*/
void GetSandboxRootDirectories(FSandboxPlatformFile* Sandbox, FString& SandboxEngine, FString& SandboxProject, FString& SandboxEnginePlatformExtensions, FString& SandboxProjectPlatformExtensions, const FString& LocalEngineDir, const FString& LocalProjectDir, const FString& LocalEnginePlatformExtensionsDir, const FString& LocalProjectPlatformExtensionsDir)
{
SandboxEngine = Sandbox->ConvertToSandboxPath(*LocalEngineDir);
if (SandboxEngine.EndsWith(TEXT("/"), ESearchCase::CaseSensitive) == false)
{
SandboxEngine += TEXT("/");
}
// we need to add an extra bit to the game path to make the sandbox convert it correctly (investigate?)
// @todo: double check this
SandboxProject = Sandbox->ConvertToSandboxPath(*(LocalProjectDir + TEXT("a.txt"))).Replace(TEXT("a.txt"), TEXT(""));
SandboxEnginePlatformExtensions = Sandbox->ConvertToSandboxPath(*(LocalEnginePlatformExtensionsDir + TEXT("a.txt"))).Replace(TEXT("a.txt"), TEXT(""));
SandboxProjectPlatformExtensions = Sandbox->ConvertToSandboxPath(*(LocalProjectPlatformExtensionsDir + TEXT("a.txt"))).Replace(TEXT("a.txt"), TEXT(""));
}
static FString MakeAbsoluteNormalizedDir(const FString& InPath)
{
FString Out = FPaths::ConvertRelativePathToFull(InPath);
if (Out.EndsWith(TEXT("/")))
{
Out.RemoveAt(Out.Len() - 1, EAllowShrinking::No);
}
return Out;
}
struct FSandboxOnlyScope
{
FSandboxOnlyScope(FSandboxPlatformFile& InSandbox, bool bInSandboxOnly)
: Sandbox(InSandbox)
{
Sandbox.SetSandboxOnly(bInSandboxOnly);
}
~FSandboxOnlyScope()
{
Sandbox.SetSandboxOnly(false);
}
FSandboxPlatformFile& Sandbox;
};
// These are marked unsafe because they do not work with Programs. However, COTF is unlikely to be used with Programs
// These are also temporary until some issues can be debugged
static FString UnsafeEnginePlatformExtensionDir()
{
return FPaths::EnginePlatformExtensionDir(TEXT("")).TrimChar('/');
}
static FString UnsafeProjectPlatformExtensionDir()
{
return FPaths::ProjectPlatformExtensionDir(TEXT("")).TrimChar('/');
}
/* FNetworkFileServerClientConnection structors
*****************************************************************************/
FNetworkFileServerClientConnection::FNetworkFileServerClientConnection(const FNetworkFileServerOptions& Options)
: LastHandleId(0)
, Sandbox(NULL)
, NetworkFileDelegates(&Options.Delegates)
, ActiveTargetPlatforms(Options.TargetPlatforms)
, bRestrictPackageAssetsToSandbox(Options.bRestrictPackageAssetsToSandbox)
{
//stats
FileRequestDelegateTime = 0.0;
PackageFileTime = 0.0;
UnsolicitedFilesTime = 0.0;
FileRequestCount = 0;
UnsolicitedFilesCount = 0;
PackageRequestsSucceeded = 0;
PackageRequestsFailed = 0;
FileBytesSent = 0;
if ( NetworkFileDelegates && NetworkFileDelegates->OnFileModifiedCallback )
{
NetworkFileDelegates->OnFileModifiedCallback->AddRaw(this, &FNetworkFileServerClientConnection::FileModifiedCallback);
}
LocalEngineDir = FPaths::EngineDir();
LocalProjectDir = FPaths::ProjectDir();
LocalEnginePlatformExtensionsDir = UnsafeEnginePlatformExtensionDir();
LocalProjectPlatformExtensionsDir = UnsafeProjectPlatformExtensionDir();
if (FPaths::IsProjectFilePathSet())
{
LocalProjectDir = FPaths::GetPath(FPaths::GetProjectFilePath()) + TEXT("/");
FPaths::MakeStandardFilename(LocalProjectDir);
}
LocalEngineDirAbs = MakeAbsoluteNormalizedDir(LocalEngineDir);
LocalProjectDirAbs = MakeAbsoluteNormalizedDir(LocalProjectDir);
LocalEnginePlatformExtensionsDirAbs = MakeAbsoluteNormalizedDir(LocalEnginePlatformExtensionsDir);
LocalProjectPlatformExtensionsDirAbs = MakeAbsoluteNormalizedDir(LocalEnginePlatformExtensionsDir);
}
FNetworkFileServerClientConnection::~FNetworkFileServerClientConnection( )
{
if (NetworkFileDelegates && NetworkFileDelegates->OnFileModifiedCallback)
{
NetworkFileDelegates->OnFileModifiedCallback->RemoveAll(this);
}
// close all the files the client had opened through us when the client disconnects
for (TMap<uint64, IFileHandle*>::TIterator It(OpenFiles); It; ++It)
{
delete It.Value();
}
}
static bool TrySubstituteDirectory(FString& FilenameToConvert, const FString& Directory, const FString& DirectoryToReplace)
{
FString NormalizedFilenameToConvert = FilenameToConvert;
FPaths::NormalizeFilename(NormalizedFilenameToConvert);
FString NormalizedDirectoryToReplace = DirectoryToReplace;
FPaths::NormalizeDirectoryName(NormalizedDirectoryToReplace);
if (NormalizedFilenameToConvert.StartsWith(NormalizedDirectoryToReplace) && (NormalizedFilenameToConvert.Len() == NormalizedDirectoryToReplace.Len() || NormalizedFilenameToConvert[NormalizedDirectoryToReplace.Len()] == '/'))
{
if (NormalizedFilenameToConvert.Len() > NormalizedDirectoryToReplace.Len())
{
FilenameToConvert = Directory / NormalizedFilenameToConvert.RightChop(NormalizedDirectoryToReplace.Len() + 1);
}
else
{
FilenameToConvert = Directory;
}
return true;
}
return false;
}
/* FStreamingNetworkFileServerConnection implementation
*****************************************************************************/
void FNetworkFileServerClientConnection::ConvertClientFilenameToServerFilename(FString& FilenameToConvert)
{
if (TrySubstituteDirectory(FilenameToConvert, FPaths::EngineDir(), ConnectedEngineDir))
{
return;
}
if (TrySubstituteDirectory(FilenameToConvert, FPaths::IsProjectFilePathSet() ? LocalProjectDir : (IS_PROGRAM ? ConnectedProjectDir : FPaths::ProjectDir()), ConnectedProjectDir))
{
// We have set the replacement value argument of TrySubstituteDirectory to be the same as the search value in the IS_PROGRAM case. We do this because:
// UnrealFileServer has a ProjectDir of ../../../Engine/Programs/UnrealFileServer.
// We do *not* want to replace the directory in that case.
return;
}
if (TrySubstituteDirectory(FilenameToConvert, UnsafeEnginePlatformExtensionDir(), ConnectedEnginePlatformExtensionsDir))
{
return;
}
if (TrySubstituteDirectory(FilenameToConvert, UnsafeProjectPlatformExtensionDir(), ConnectedProjectPlatformExtensionsDir))
{
return;
}
}
void FNetworkFileServerClientConnection::ConvertLocalFilenameToServerFilename(FString& FilenameToConvert)
{
FString FilenameToConvertAbs = FPaths::ConvertRelativePathToFull(FilenameToConvert);
if (TrySubstituteDirectory(FilenameToConvertAbs, LocalEngineDir, LocalEngineDirAbs))
{
FilenameToConvert = FilenameToConvertAbs;
return;
}
if (TrySubstituteDirectory(FilenameToConvertAbs, LocalProjectDir, LocalProjectDirAbs))
{
FilenameToConvert = FilenameToConvertAbs;
return;
}
if (TrySubstituteDirectory(FilenameToConvertAbs, LocalEnginePlatformExtensionsDir, LocalEnginePlatformExtensionsDirAbs))
{
FilenameToConvert = FilenameToConvertAbs;
return;
}
if (TrySubstituteDirectory(FilenameToConvertAbs, LocalProjectPlatformExtensionsDir, LocalProjectPlatformExtensionsDirAbs))
{
FilenameToConvert = FilenameToConvertAbs;
return;
}
}
/**
* Fixup sandbox paths to match what package loading will request on the client side. e.g.
* Sandbox path: "../../../Elemental/Content/Elemental/Effects/FX_Snow_Cracks/Crack_02/Materials/M_SnowBlast.uasset ->
* client path: "../../../Samples/Showcases/Elemental/Content/Elemental/Effects/FX_Snow_Cracks/Crack_02/Materials/M_SnowBlast.uasset"
* This ensures that devicelocal-cached files will be properly timestamp checked before deletion.
*/
TMap<FString, FDateTime> FNetworkFileServerClientConnection::FixupSandboxPathsForClient(const TMap<FString, FDateTime>& SandboxPaths)
{
TMap<FString,FDateTime> FixedFiletimes;
// since the sandbox remaps from A/B/C to C, and the client has no idea of this, we need to put the files
// into terms of the actual LocalProjectDir, which is all that the client knows about
for (TMap<FString, FDateTime>::TConstIterator It(SandboxPaths); It; ++It)
{
FixedFiletimes.Add(FixupSandboxPathForClient(It.Key()), It.Value());
}
return FixedFiletimes;
}
/**
* Fixup sandbox paths to match what package loading will request on the client side. e.g.
* Sandbox path: "../../../Elemental/Content/Elemental/Effects/FX_Snow_Cracks/Crack_02/Materials/M_SnowBlast.uasset ->
* client path: "../../../Samples/Showcases/Elemental/Content/Elemental/Effects/FX_Snow_Cracks/Crack_02/Materials/M_SnowBlast.uasset"
* This ensures that devicelocal-cached files will be properly timestamp checked before deletion.
*/
FString FNetworkFileServerClientConnection::FixupSandboxPathForClient(const FString& Filename)
{
FString Fixed = Sandbox->ConvertToSandboxPath(*Filename);
Fixed = Fixed.Replace(*SandboxEngine, *LocalEngineDir);
Fixed = Fixed.Replace(*SandboxProject, *LocalProjectDir);
Fixed = Fixed.Replace(*SandboxEnginePlatformExtensions, *LocalEnginePlatformExtensionsDir);
Fixed = Fixed.Replace(*SandboxProjectPlatformExtensions, *LocalProjectPlatformExtensionsDir);
if (bSendLowerCase)
{
Fixed = Fixed.ToLower();
}
return Fixed;
}
static void ConvertServerFilenameToClientFilename(FString& FilenameToConvert, const FString& ConnectedEngineDir, const FString& ConnectedProjectDir)
{
if (FilenameToConvert.StartsWith(FPaths::EngineDir()))
{
FilenameToConvert = FilenameToConvert.Replace(*(FPaths::EngineDir()), *ConnectedEngineDir);
}
else if (FPaths::IsProjectFilePathSet())
{
if (FilenameToConvert.StartsWith(FPaths::GetPath(FPaths::GetProjectFilePath())))
{
FilenameToConvert = FilenameToConvert.Replace(*(FPaths::GetPath(FPaths::GetProjectFilePath()) + TEXT("/")), *ConnectedProjectDir);
}
}
#if !IS_PROGRAM
else if (FilenameToConvert.StartsWith(FPaths::ProjectDir()))
{
// UnrealFileServer has a ProjectDir of ../../../Engine/Programs/UnrealFileServer.
// We do *not* want to replace the directory in that case.
FilenameToConvert = FilenameToConvert.Replace(*(FPaths::ProjectDir()), *ConnectedProjectDir);
}
#endif
}
static FCriticalSection SocketCriticalSection;
bool FNetworkFileServerClientConnection::ProcessPayload(FArchive& Ar)
{
FBufferArchive Out;
bool Result = true;
// first part of the payload is always the command
uint32 Cmd;
Ar << Cmd;
UE_LOG(LogFileServer, Verbose, TEXT("Processing payload with Cmd %d"), Cmd);
// what type of message is this?
NFS_Messages::Type Msg = NFS_Messages::Type(Cmd);
// make sure the first thing is GetFileList which initializes the game/platform
checkf(Msg == NFS_Messages::GetFileList || Msg == NFS_Messages::Heartbeat || Sandbox != NULL, TEXT("The first client message MUST be GetFileList, not %d"), (int32)Msg);
// process the message!
bool bSendUnsolicitedFiles = false;
{
FScopeLock SocketLock(&SocketCriticalSection);
switch (Msg)
{
case NFS_Messages::OpenRead:
ProcessOpenFile(Ar, Out, false);
break;
case NFS_Messages::OpenWrite:
ProcessOpenFile(Ar, Out, true);
break;
case NFS_Messages::Read:
ProcessReadFile(Ar, Out);
break;
case NFS_Messages::Write:
ProcessWriteFile(Ar, Out);
break;
case NFS_Messages::Seek:
ProcessSeekFile(Ar, Out);
break;
case NFS_Messages::Close:
ProcessCloseFile(Ar, Out);
break;
case NFS_Messages::MoveFile:
ProcessMoveFile(Ar, Out);
break;
case NFS_Messages::DeleteFile:
ProcessDeleteFile(Ar, Out);
break;
case NFS_Messages::GetFileInfo:
ProcessGetFileInfo(Ar, Out);
break;
case NFS_Messages::CopyFile:
ProcessCopyFile(Ar, Out);
break;
case NFS_Messages::SetTimeStamp:
ProcessSetTimeStamp(Ar, Out);
break;
case NFS_Messages::SetReadOnly:
ProcessSetReadOnly(Ar, Out);
break;
case NFS_Messages::CreateDirectory:
ProcessCreateDirectory(Ar, Out);
break;
case NFS_Messages::DeleteDirectory:
ProcessDeleteDirectory(Ar, Out);
break;
case NFS_Messages::DeleteDirectoryRecursively:
ProcessDeleteDirectoryRecursively(Ar, Out);
break;
case NFS_Messages::ToAbsolutePathForRead:
ProcessToAbsolutePathForRead(Ar, Out);
break;
case NFS_Messages::ToAbsolutePathForWrite:
ProcessToAbsolutePathForWrite(Ar, Out);
break;
case NFS_Messages::ReportLocalFiles:
ProcessReportLocalFiles(Ar, Out);
break;
case NFS_Messages::GetFileList:
Result = ProcessGetFileList(Ar, Out);
break;
case NFS_Messages::Heartbeat:
ProcessHeartbeat(Ar, Out);
break;
case NFS_Messages::SyncFile:
ProcessSyncFile(Ar, Out);
bSendUnsolicitedFiles = true;
break;
default:
UE_LOG(LogFileServer, Error, TEXT("Bad incomming message tag (%d)."), (int32)Msg);
}
}
// send back a reply if the command wrote anything back out
if (Out.Num() && Result )
{
int32 NumUnsolictedFiles = 0;
if (bSendUnsolicitedFiles)
{
int64 MaxMemoryAllowed = 50 * 1024 * 1024;
for (const auto& Filename : UnsolictedFiles)
{
// get file timestamp and send it to client
FDateTime ServerTimeStamp = Sandbox->GetTimeStamp(*Filename);
TArray<uint8> Contents;
// open file
int64 FileSize = Sandbox->FileSize(*Filename);
if (MaxMemoryAllowed > FileSize)
{
MaxMemoryAllowed -= FileSize;
++NumUnsolictedFiles;
}
}
Out << NumUnsolictedFiles;
}
UE_LOG(LogFileServer, Verbose, TEXT("Returning payload with %d bytes"), Out.Num());
// send back a reply
Result &= SendPayload( Out );
TArray<FString> UnprocessedUnsolictedFiles;
UnprocessedUnsolictedFiles.Empty(NumUnsolictedFiles);
if (bSendUnsolicitedFiles && Result )
{
double StartTime;
StartTime = FPlatformTime::Seconds();
for (int32 Index = 0; Index < NumUnsolictedFiles; Index++)
{
FBufferArchive OutUnsolicitedFile;
ConvertLocalFilenameToServerFilename(UnsolictedFiles[Index]);
FString TargetFilename = UnsolictedFiles[Index];
ConvertServerFilenameToClientFilename(TargetFilename, ConnectedEngineDir, ConnectedProjectDir);
PackageFile(UnsolictedFiles[Index], TargetFilename, OutUnsolicitedFile);
UE_LOG(LogFileServer, Display, TEXT("Returning unsolicited file %s with %d bytes"), *UnsolictedFiles[Index], OutUnsolicitedFile.Num());
Result &= SendPayload(OutUnsolicitedFile);
++UnsolicitedFilesCount;
}
UnsolictedFiles.RemoveAt(0, NumUnsolictedFiles);
UnsolicitedFilesTime += 1000.0f * float(FPlatformTime::Seconds() - StartTime);
}
}
UE_LOG(LogFileServer, Verbose, TEXT("Done Processing payload with Cmd %d Total Size sending %" INT64_FMT " "), Cmd,Out.TotalSize());
return Result;
}
void FNetworkFileServerClientConnection::ProcessOpenFile( FArchive& In, FArchive& Out, bool bIsWriting )
{
// Get filename
FString Filename;
In << Filename;
bool bAppend = false;
bool bAllowRead = false;
if (bIsWriting)
{
In << bAppend;
In << bAllowRead;
}
// todo: clients from the same ip address "could" be trying to write to the same file in the same sandbox (for example multiple windows clients)
// should probably have the sandbox write to separate files for each client
// not important for now
ConvertClientFilenameToServerFilename(Filename);
if (bIsWriting)
{
// Make sure the directory exists...
Sandbox->CreateDirectoryTree(*(FPaths::GetPath(Filename)));
}
TArray<FString> NewUnsolictedFiles;
NetworkFileDelegates->FileRequestDelegate.ExecuteIfBound(Filename, ConnectedPlatformName, NewUnsolictedFiles);
// Disable access to outside the sandbox to prevent sending uncooked packages to the client
const bool bSandboxOnly = bRestrictPackageAssetsToSandbox && !bIsWriting && FPackageName::IsPackageExtension(*FPaths::GetExtension(Filename, true));
FSandboxOnlyScope _(*Sandbox, bSandboxOnly);
FDateTime ServerTimeStamp = Sandbox->GetTimeStamp(*Filename);
int64 ServerFileSize = 0;
IFileHandle* File = bIsWriting ? Sandbox->OpenWrite(*Filename, bAppend, bAllowRead) : Sandbox->OpenRead(*Filename);
if (!File)
{
UE_LOG(LogFileServer, Display, TEXT("Open request for %s failed for file %s."), bIsWriting ? TEXT("Writing") : TEXT("Reading"), *Filename);
ServerTimeStamp = FDateTime::MinValue(); // if this was a directory, this will make sure it is not confused with a zero byte file
}
else
{
ServerFileSize = File->Size();
}
uint64 HandleId = ++LastHandleId;
OpenFiles.Add( HandleId, File );
Out << HandleId;
Out << ServerTimeStamp;
Out << ServerFileSize;
}
void FNetworkFileServerClientConnection::ProcessReadFile( FArchive& In, FArchive& Out )
{
// Get Handle ID
uint64 HandleId = 0;
In << HandleId;
int64 BytesToRead = 0;
In << BytesToRead;
IFileHandle* File = FindOpenFile(HandleId);
if (File)
{
constexpr int64 BufferSize = 4 << 20;
uint8* Buffer = (uint8*)FMemory::Malloc(BufferSize);
bool bIsFirstRead = true;
while (BytesToRead > 0)
{
int64 CappedBytesToRead = FMath::Min(BufferSize, BytesToRead);
if (!File->Read(Buffer, CappedBytesToRead))
{
if (bIsFirstRead)
{
int64 BytesRead = 0;
Out << BytesRead;
break;
}
// If this is not the first read we've already written the expected number of bytes to the stream so we have to deliver on that
FMemory::Memset(Buffer, 0, CappedBytesToRead);
}
else if (bIsFirstRead)
{
Out << BytesToRead;
}
Out.Serialize(Buffer, CappedBytesToRead);
BytesToRead -= CappedBytesToRead;
bIsFirstRead = false;
}
FMemory::Free(Buffer);
}
else
{
int64 BytesRead = 0;
Out << BytesRead;
}
}
void FNetworkFileServerClientConnection::ProcessWriteFile( FArchive& In, FArchive& Out )
{
// Get Handle ID
uint64 HandleId = 0;
In << HandleId;
int64 BytesWritten = 0;
IFileHandle* File = FindOpenFile(HandleId);
if (File)
{
int64 BytesToWrite = 0;
In << BytesToWrite;
constexpr int64 BufferSize = 4 << 20;
uint8* Buffer = (uint8*)FMemory::Malloc(BufferSize);
while (BytesToWrite > 0)
{
int64 CappedBytesToWrite = FMath::Min(BufferSize, BytesToWrite);
In.Serialize(Buffer, CappedBytesToWrite);
if (!File->Write(Buffer, CappedBytesToWrite))
{
break;
}
BytesWritten += CappedBytesToWrite;
BytesToWrite -= CappedBytesToWrite;
}
FMemory::Free(Buffer);
}
Out << BytesWritten;
}
void FNetworkFileServerClientConnection::ProcessSeekFile( FArchive& In, FArchive& Out )
{
// Get Handle ID
uint64 HandleId = 0;
In << HandleId;
int64 NewPosition;
In << NewPosition;
int64 SetPosition = -1;
IFileHandle* File = FindOpenFile(HandleId);
if (File && File->Seek(NewPosition))
{
SetPosition = File->Tell();
}
Out << SetPosition;
}
void FNetworkFileServerClientConnection::ProcessCloseFile( FArchive& In, FArchive& Out )
{
// Get Handle ID
uint64 HandleId = 0;
In << HandleId;
uint32 Closed = 0;
IFileHandle* File = FindOpenFile(HandleId);
if (File)
{
Closed = 1;
OpenFiles.Remove(HandleId);
delete File;
}
Out << Closed;
}
void FNetworkFileServerClientConnection::ProcessGetFileInfo( FArchive& In, FArchive& Out )
{
// Get filename
FString Filename;
In << Filename;
ConvertClientFilenameToServerFilename(Filename);
FFileInfo Info;
Info.FileExists = Sandbox->FileExists(*Filename);
// if the file exists, cook it if necessary (the FileExists flag won't change value based on this callback)
// without this, the server can return the uncooked file size, which can cause reads off the end
if (Info.FileExists)
{
TArray<FString> NewUnsolictedFiles;
NetworkFileDelegates->FileRequestDelegate.ExecuteIfBound(Filename, ConnectedPlatformName, NewUnsolictedFiles);
}
// get the rest of the info
Info.ReadOnly = Sandbox->IsReadOnly(*Filename);
Info.Size = Sandbox->FileSize(*Filename);
Info.TimeStamp = Sandbox->GetTimeStamp(*Filename);
Info.AccessTimeStamp = Sandbox->GetAccessTimeStamp(*Filename);
Out << Info.FileExists;
Out << Info.ReadOnly;
Out << Info.Size;
Out << Info.TimeStamp;
Out << Info.AccessTimeStamp;
}
void FNetworkFileServerClientConnection::ProcessMoveFile( FArchive& In, FArchive& Out )
{
FString From;
In << From;
FString To;
In << To;
ConvertClientFilenameToServerFilename(From);
ConvertClientFilenameToServerFilename(To);
uint32 Success = Sandbox->MoveFile(*To, *From);
Out << Success;
}
void FNetworkFileServerClientConnection::ProcessDeleteFile( FArchive& In, FArchive& Out )
{
FString Filename;
In << Filename;
ConvertClientFilenameToServerFilename(Filename);
uint32 Success = Sandbox->DeleteFile(*Filename);
Out << Success;
}
void FNetworkFileServerClientConnection::ProcessReportLocalFiles( FArchive& In, FArchive& Out )
{
// get the list of files on the other end
TMap<FString, FDateTime> ClientFileTimes;
In << ClientFileTimes;
// go over them and compare times to this side
TArray<FString> OutOfDateFiles;
for (TMap<FString, FDateTime>::TIterator It(ClientFileTimes); It; ++It)
{
FString ClientFile = It.Key();
ConvertClientFilenameToServerFilename(ClientFile);
// get the local timestamp
FDateTime Timestamp = Sandbox->GetTimeStamp(*ClientFile);
// if it's newer than the client/remote timestamp, it's newer here, so tell the other side it's out of date
if (Timestamp > It.Value())
{
OutOfDateFiles.Add(ClientFile);
}
}
UE_LOG(LogFileServer, Display, TEXT("There were %d out of date files"), OutOfDateFiles.Num());
}
/** Copies file. */
void FNetworkFileServerClientConnection::ProcessCopyFile( FArchive& In, FArchive& Out )
{
FString To;
FString From;
In << To;
In << From;
ConvertClientFilenameToServerFilename(To);
ConvertClientFilenameToServerFilename(From);
bool Success = Sandbox->CopyFile(*To, *From);
Out << Success;
}
void FNetworkFileServerClientConnection::ProcessSetTimeStamp( FArchive& In, FArchive& Out )
{
FString Filename;
FDateTime Timestamp;
In << Filename;
In << Timestamp;
ConvertClientFilenameToServerFilename(Filename);
Sandbox->SetTimeStamp(*Filename, Timestamp);
// Need to sends something back otherwise the response won't get sent at all.
bool Success = true;
Out << Success;
}
void FNetworkFileServerClientConnection::ProcessSetReadOnly( FArchive& In, FArchive& Out )
{
FString Filename;
bool bReadOnly;
In << Filename;
In << bReadOnly;
ConvertClientFilenameToServerFilename(Filename);
bool Success = Sandbox->SetReadOnly(*Filename, bReadOnly);
Out << Success;
}
void FNetworkFileServerClientConnection::ProcessCreateDirectory( FArchive& In, FArchive& Out )
{
FString Directory;
In << Directory;
ConvertClientFilenameToServerFilename(Directory);
bool bSuccess = Sandbox->CreateDirectory(*Directory);
Out << bSuccess;
}
void FNetworkFileServerClientConnection::ProcessDeleteDirectory( FArchive& In, FArchive& Out )
{
FString Directory;
In << Directory;
ConvertClientFilenameToServerFilename(Directory);
bool bSuccess = Sandbox->DeleteDirectory(*Directory);
Out << bSuccess;
}
void FNetworkFileServerClientConnection::ProcessDeleteDirectoryRecursively( FArchive& In, FArchive& Out )
{
FString Directory;
In << Directory;
ConvertClientFilenameToServerFilename(Directory);
bool bSuccess = Sandbox->DeleteDirectoryRecursively(*Directory);
Out << bSuccess;
}
void FNetworkFileServerClientConnection::ProcessToAbsolutePathForRead( FArchive& In, FArchive& Out )
{
FString Filename;
In << Filename;
ConvertClientFilenameToServerFilename(Filename);
Filename = Sandbox->ConvertToAbsolutePathForExternalAppForRead(*Filename);
Out << Filename;
}
void FNetworkFileServerClientConnection::ProcessToAbsolutePathForWrite( FArchive& In, FArchive& Out )
{
FString Filename;
In << Filename;
ConvertClientFilenameToServerFilename(Filename);
Filename = Sandbox->ConvertToAbsolutePathForExternalAppForWrite(*Filename);
Out << Filename;
}
static void AddDirectoriesToIgnore(const FString& RootDir, TArray<FString>& OutDirectoriesToSkip, TArray<FString>& OutDirectoriesToNotRecurse)
{
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Intermediate")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Documentation")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Extras")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Binaries")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Source")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Saved")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Plugins")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Programs")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Platforms")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Build")));
OutDirectoriesToSkip.Add(FString(RootDir / TEXT("Restricted")));
OutDirectoriesToNotRecurse.Add(FString(RootDir / TEXT("DerivedDataCache")));
}
static void ScanExtensionRootDirectory(FSandboxPlatformFile* Sandbox, const FString& RootDir, const TArray<FString>& RootDirectories, TMap<FString, FDateTime>& OutFileTimes)
{
// Ensure that the path from the extension root to any containing root directory is in the FileTimes map
for (int32 DirIndex = 0; DirIndex < RootDirectories.Num(); DirIndex++)
{
if (FPaths::IsUnderDirectory(RootDir, RootDirectories[DirIndex]))
{
FString PathUpwardSegment = RootDir;
do
{
OutFileTimes.Add(PathUpwardSegment, 0);
PathUpwardSegment = FPaths::GetPath(PathUpwardSegment);
} while (FPaths::IsUnderDirectory(PathUpwardSegment, RootDirectories[DirIndex]));
break;
}
}
TArray<FString> ExtensionDirectoriesToSkip;
TArray<FString> ExtensionDirectoriesToNotRecurse;
AddDirectoriesToIgnore(RootDir, ExtensionDirectoriesToSkip, ExtensionDirectoriesToNotRecurse);
FLocalTimestampDirectoryVisitor ExtensionVisitor(*Sandbox, ExtensionDirectoriesToSkip, ExtensionDirectoriesToNotRecurse, true);
Sandbox->IterateDirectory(*RootDir, ExtensionVisitor);
OutFileTimes.Append(ExtensionVisitor.FileTimes);
}
bool FNetworkFileServerClientConnection::ProcessGetFileList( FArchive& In, FArchive& Out )
{
// get the list of directories to process
TArray<FString> TargetPlatformNames;
FString GameName;
FString EngineRelativePath;
FString GameRelativePath;
FString EnginePlatformExtensionsRelativePath;
FString ProjectPlatformExtensionsRelativePath;
FString EnginePluginsRelativePath;
FString ProjectPluginsRelativePath;
TArray<FString> RootDirectories;
TMap<FString,FString> CustomPlatformData;
EConnectionFlags ConnectionFlags;
FString ClientVersionInfo;
FString TargetAddress;
In << TargetPlatformNames;
In << GameName;
In << EngineRelativePath;
In << GameRelativePath;
In << EnginePlatformExtensionsRelativePath;
In << ProjectPlatformExtensionsRelativePath;
In << EnginePluginsRelativePath;
In << ProjectPluginsRelativePath;
In << RootDirectories;
In << ConnectionFlags;
In << ClientVersionInfo;
In << TargetAddress;
In << CustomPlatformData;
if ( NetworkFileDelegates->NewConnectionDelegate.IsBound() )
{
bool bIsValidVersion = true;
for ( const FString& TargetPlatform : TargetPlatformNames )
{
bIsValidVersion &= NetworkFileDelegates->NewConnectionDelegate.Execute(ClientVersionInfo, TargetPlatform );
}
if ( bIsValidVersion == false )
{
return false;
}
}
const bool bIsStreamingRequest = (ConnectionFlags & EConnectionFlags::Streaming) == EConnectionFlags::Streaming;
ConnectedPlatformName = TEXT("");
ConnectedTargetPlatform = nullptr;
ConnectedIPAddress = TEXT("");
ConnectedTargetCustomData.Reset();
// if we didn't find one (and this is a dumb server - no active platforms), then just use what was sent
if (ActiveTargetPlatforms.Num() == 0)
{
ConnectedPlatformName = TargetPlatformNames[0];
}
// we only need to care about validating the connected platform if there are active targetplatforms
else
{
// figure out the best matching target platform for the set of valid ones
for (int32 TPIndex = 0; TPIndex < TargetPlatformNames.Num() && ConnectedPlatformName == TEXT(""); TPIndex++)
{
UE_LOG(LogFileServer, Display, TEXT(" Possible Target Platform from client: %s"), *TargetPlatformNames[TPIndex]);
// look for a matching target platform
for (int32 ActiveTPIndex = 0; ActiveTPIndex < ActiveTargetPlatforms.Num(); ActiveTPIndex++)
{
UE_LOG(LogFileServer, Display, TEXT(" Checking against: %s"), *ActiveTargetPlatforms[ActiveTPIndex]->PlatformName());
if (ActiveTargetPlatforms[ActiveTPIndex]->PlatformName() == TargetPlatformNames[TPIndex])
{
bSendLowerCase = ActiveTargetPlatforms[ActiveTPIndex]->SendLowerCaseFilePaths();
ConnectedPlatformName = ActiveTargetPlatforms[ActiveTPIndex]->PlatformName();
ConnectedTargetPlatform = ActiveTargetPlatforms[ActiveTPIndex];
ConnectedIPAddress = TargetAddress;
ConnectedTargetCustomData = MoveTemp(CustomPlatformData);
break;
}
}
}
// if we didn't find one, reject client and also print some warnings
if (ConnectedPlatformName == TEXT(""))
{
// reject client we can't cook/compile shaders for you!
UE_LOG(LogFileServer, Warning, TEXT("Unable to find target platform for client, terminating client connection!"));
for (int32 TPIndex = 0; TPIndex < TargetPlatformNames.Num() && ConnectedPlatformName == TEXT(""); TPIndex++)
{
UE_LOG(LogFileServer, Warning, TEXT(" Target platforms from client: %s"), *TargetPlatformNames[TPIndex]);
}
for (int32 ActiveTPIndex = 0; ActiveTPIndex < ActiveTargetPlatforms.Num(); ActiveTPIndex++)
{
UE_LOG(LogFileServer, Warning, TEXT(" Active target platforms on server: %s"), *ActiveTargetPlatforms[ActiveTPIndex]->PlatformName());
}
return false;
}
}
ConnectedEngineDir = EngineRelativePath;
ConnectedProjectDir = GameRelativePath;
ConnectedEnginePlatformExtensionsDir = EnginePlatformExtensionsRelativePath;
ConnectedProjectPlatformExtensionsDir = ProjectPlatformExtensionsRelativePath;
UE_LOG(LogFileServer, Display, TEXT(" Connected EngineDir = %s"), *ConnectedEngineDir);
UE_LOG(LogFileServer, Display, TEXT(" Local EngineDir = %s"), *LocalEngineDir);
UE_LOG(LogFileServer, Display, TEXT(" Connected ProjectDir = %s"), *ConnectedProjectDir);
UE_LOG(LogFileServer, Display, TEXT(" Local ProjectDir = %s"), *LocalProjectDir);
UE_LOG(LogFileServer, Display, TEXT(" Connected EnginePlatformExtDir = %s"), *ConnectedEnginePlatformExtensionsDir);
UE_LOG(LogFileServer, Display, TEXT(" Local EnginePlatformExtDir = %s"), *LocalEnginePlatformExtensionsDir);
UE_LOG(LogFileServer, Display, TEXT(" Connected ProjectPlatformExtDir = %s"), *ConnectedProjectPlatformExtensionsDir);
UE_LOG(LogFileServer, Display, TEXT(" Local ProjectPlatformExtDir = %s"), *LocalProjectPlatformExtensionsDir);
// Remap the root directories requested...
for (int32 RootDirIdx = 0; RootDirIdx < RootDirectories.Num(); RootDirIdx++)
{
FString CheckRootDir = RootDirectories[RootDirIdx];
ConvertClientFilenameToServerFilename(CheckRootDir);
RootDirectories[RootDirIdx] = CheckRootDir;
}
// figure out the sandbox directory
// @todo: This should use FPlatformMisc::SavedDirectory(GameName)
FString SandboxDirectory;
if (NetworkFileDelegates->SandboxPathOverrideDelegate.IsBound() )
{
SandboxDirectory = NetworkFileDelegates->SandboxPathOverrideDelegate.Execute();
// if the sandbox directory delegate returns a path with the platform name in it then replace it :)
SandboxDirectory.ReplaceInline(TEXT("[Platform]"), *ConnectedPlatformName);
}
else if ( FPaths::IsProjectFilePathSet() )
{
FString ProjectDir = FPaths::GetPath(FPaths::GetProjectFilePath());
SandboxDirectory = FPaths::Combine(*ProjectDir, TEXT("Saved"), TEXT("Cooked"), *ConnectedPlatformName);
// this is a workaround because the cooker and the networkfile server don't have access to eachother and therefore don't share the same Sandbox
// the cooker in cook in editor saves to the EditorCooked directory
if ( GIsEditor && !IsRunningCommandlet())
{
SandboxDirectory = FPaths::Combine(*ProjectDir, TEXT("Saved"), TEXT("EditorCooked"), *ConnectedPlatformName);
}
if( bIsStreamingRequest )
{
RootDirectories.Add(ProjectDir);
}
}
else
{
if (FPaths::GetExtension(GameName) == FProjectDescriptor::GetExtension())
{
SandboxDirectory = FPaths::Combine(*FPaths::GetPath(GameName), TEXT("Saved"), TEXT("Cooked"), *ConnectedPlatformName);
}
else
{
//@todo: This assumes the game is located in the Unreal Root directory
SandboxDirectory = FPaths::Combine(*FPaths::GetRelativePathToRoot(), *GameName, TEXT("Saved"), TEXT("Cooked"), *ConnectedPlatformName);
}
}
// Convert to full path so that the sandbox wrapper doesn't re-base to Saved/Sandboxes
SandboxDirectory = FPaths::ConvertRelativePathToFull(SandboxDirectory);
// delete any existing one first, in case game name somehow changed and client is re-asking for files (highly unlikely)
Sandbox.Reset();
Sandbox = FSandboxPlatformFile::Create(false);
Sandbox->Initialize(&FPlatformFileManager::Get().GetPlatformFile(), *FString::Printf(TEXT("-sandbox=\"%s\""), *SandboxDirectory));
GetSandboxRootDirectories(Sandbox.Get(), SandboxEngine, SandboxProject, SandboxEnginePlatformExtensions, SandboxProjectPlatformExtensions, LocalEngineDir, LocalProjectDir, LocalEnginePlatformExtensionsDir, LocalProjectPlatformExtensionsDir);
UE_LOG(LogFileServer, Display, TEXT("Getting files for %d directories, game = %s, platform = %s"), RootDirectories.Num(), *GameName, *ConnectedPlatformName);
UE_LOG(LogFileServer, Display, TEXT(" Sandbox dir = %s"), *SandboxDirectory);
for (int32 DumpIdx = 0; DumpIdx < RootDirectories.Num(); DumpIdx++)
{
UE_LOG(LogFileServer, Display, TEXT("\t%s"), *(RootDirectories[DumpIdx]));
}
TArray<FString> DirectoriesToAlwaysStageAsUFS;
if ( GConfig->GetArray(TEXT("/Script/UnrealEd.ProjectPackagingSettings"), TEXT("DirectoriesToAlwaysStageAsUFS"), DirectoriesToAlwaysStageAsUFS, GGameIni) )
{
for ( const auto& DirectoryToAlwaysStage : DirectoriesToAlwaysStageAsUFS )
{
RootDirectories.Add( DirectoryToAlwaysStage );
}
}
// list of directories to skip
TArray<FString> DirectoriesToSkip;
TArray<FString> DirectoriesToNotRecurse;
// @todo: This should really be FPlatformMisc::GetSavedDirForGame(ClientGameName), etc
for (const FString& RootDir : RootDirectories)
{
AddDirectoriesToIgnore(RootDir, DirectoriesToSkip, DirectoriesToNotRecurse);
}
UE_LOG(LogFileServer, Display, TEXT("Scanning server files for timestamps..."));
double FileScanStartTime = FPlatformTime::Seconds();
// use the timestamp grabbing visitor (include directories)
FLocalTimestampDirectoryVisitor Visitor(*Sandbox, DirectoriesToSkip, DirectoriesToNotRecurse, true);
for (int32 DirIndex = 0; DirIndex < RootDirectories.Num(); DirIndex++)
{
bool bIsSubDirOfOtherRootDir = false;
for (int32 OtherDirIndex = 0; OtherDirIndex < DirIndex; OtherDirIndex++)
{
if (OtherDirIndex == DirIndex)
continue;
if (FPaths::IsUnderDirectory(RootDirectories[DirIndex], RootDirectories[OtherDirIndex]))
{
bIsSubDirOfOtherRootDir = true;
break;
}
}
if (!bIsSubDirOfOtherRootDir)
Sandbox->IterateDirectory(*RootDirectories[DirIndex], Visitor);
}
// Get PlatformDirectoryNames
FString ServerEnginePlatformExtensionsRelativePath = EnginePlatformExtensionsRelativePath;
ConvertClientFilenameToServerFilename(ServerEnginePlatformExtensionsRelativePath);
FString ServerProjectPlatformExtensionsRelativePath = ProjectPlatformExtensionsRelativePath;
ConvertClientFilenameToServerFilename(ServerProjectPlatformExtensionsRelativePath);
TArray<FString> PlatformDirectoryNames;
for (const FString& TargetPlatform : TargetPlatformNames)
{
FName IniPlatformName = PlatformInfo::FindPlatformInfo(*TargetPlatform)->IniPlatformName;
const FDataDrivenPlatformInfo& PlatformInfo = FDataDrivenPlatformInfoRegistry::GetPlatformInfo(IniPlatformName);
PlatformDirectoryNames.Reserve(PlatformInfo.IniParentChain.Num() + PlatformInfo.AdditionalRestrictedFolders.Num() + 1);
PlatformDirectoryNames.Add(IniPlatformName.ToString());
for (const FString& PlatformName : PlatformInfo.AdditionalRestrictedFolders)
{
PlatformDirectoryNames.AddUnique(PlatformName);
}
for (const FString& PlatformName : PlatformInfo.IniParentChain)
{
PlatformDirectoryNames.AddUnique(PlatformName);
}
}
// Traverse plugin directories
TSet<FString> PlatformDirectoryNameSet;
PlatformDirectoryNameSet.Append(PlatformDirectoryNames);
TArray<TSharedRef<IPlugin>> AllPlugins = IPluginManager::Get().GetDiscoveredPlugins();
for (TSharedRef<IPlugin> Plugin : AllPlugins)
{
// First the base directory of the plugin.
ScanExtensionRootDirectory(Sandbox.Get(), Plugin->GetBaseDir(), RootDirectories, Visitor.FileTimes);
// Next the plugin extension directories of this plugin.
TArray<FString> PluginExtensionDirs = Plugin->GetExtensionBaseDirs();
for (const FString& ExtensionDir : PluginExtensionDirs)
{
// Scan for Platforms/X. If X is not one of our platforms do not scan this extension directory.
// If X is one of our platforms or this extension is not Platforms restricted at all scan it.
bool bFoundPlatforms = false;
bool bDone = false;
bool bWrongPlatform = false;
FPathViews::IterateComponents(
ExtensionDir,
[&bFoundPlatforms, &bDone, &bWrongPlatform, &PlatformDirectoryNameSet](FStringView CurrentPathComponent)
{
if (!bFoundPlatforms)
{
if (CurrentPathComponent == FString(TEXT("Platforms")))
{
bFoundPlatforms = true;
}
}
else if (!bDone)
{
bWrongPlatform = !PlatformDirectoryNameSet.Contains(FString(CurrentPathComponent));
bDone = true;
}
else
{
// Do nothing.
}
}
);
if (!bWrongPlatform)
{
ScanExtensionRootDirectory(Sandbox.Get(), ExtensionDir, RootDirectories, Visitor.FileTimes);
}
}
}
// Traverse platform extension directories
for (const FString& PlatformDirectoryName : PlatformDirectoryNames)
{
ScanExtensionRootDirectory(Sandbox.Get(), ServerEnginePlatformExtensionsRelativePath / PlatformDirectoryName, RootDirectories, Visitor.FileTimes);
ScanExtensionRootDirectory(Sandbox.Get(), ServerProjectPlatformExtensionsRelativePath / PlatformDirectoryName, RootDirectories, Visitor.FileTimes);
}
UE_LOG(LogFileServer, Display, TEXT("Scanned server files, found %d files in %.2f seconds"), Visitor.FileTimes.Num(), FPlatformTime::Seconds() - FileScanStartTime);
// report the package version information
// The downside of this is that ALL cooked data will get tossed on package version changes
FPackageFileVersion PackageFileUnrealVersion = GPackageFileUEVersion;
Out << PackageFileUnrealVersion;
int32 PackageFileLicenseeUnrealVersion = GPackageFileLicenseeUEVersion;
Out << PackageFileLicenseeUnrealVersion;
// Send *our* engine and game dirs
Out << LocalEngineDir;
Out << LocalProjectDir;
Out << LocalEnginePlatformExtensionsDir;
Out << LocalProjectPlatformExtensionsDir;
// return the files and their timestamps
TMap<FString, FDateTime> FixedTimes = FixupSandboxPathsForClient(Visitor.FileTimes);
Out << FixedTimes;
#if 0 // dump the list of files
for ( const auto& FileTime : Visitor.FileTimes)
{
UE_LOG(LogFileServer, Display, TEXT("Server list of files %s time %d"), *FileTime.Key, *FileTime.Value.ToString() );
}
#endif
// Do it again, preventing access to non-cooked files
if( bIsStreamingRequest == false )
{
TArray<FString> RootContentPaths;
FPackageName::QueryRootContentPaths(RootContentPaths);
TArray<FString> ContentFolders;
for (const auto& RootPath : RootContentPaths)
{
const FString& ContentFolder = FPackageName::LongPackageNameToFilename(RootPath);
FString ConnectedContentFolder = ContentFolder;
ConnectedContentFolder.ReplaceInline(*LocalEngineDir, *ConnectedEngineDir);
ConnectedContentFolder.ReplaceInline(*LocalEnginePlatformExtensionsDir, *ConnectedEnginePlatformExtensionsDir);
ConnectedContentFolder.ReplaceInline(*LocalProjectPlatformExtensionsDir, *ConnectedProjectPlatformExtensionsDir);
int32 ReplaceCount = 0;
// If one path is relative and the other isn't, convert both to absolute paths before trying to replace
if (FPaths::IsRelative(LocalProjectDir) != FPaths::IsRelative(ConnectedContentFolder))
{
FString AbsoluteLocalGameDir = FPaths::ConvertRelativePathToFull(LocalProjectDir);
FString AbsoluteConnectedContentFolder = FPaths::ConvertRelativePathToFull(ConnectedContentFolder);
ReplaceCount = AbsoluteConnectedContentFolder.ReplaceInline(*AbsoluteLocalGameDir, *ConnectedProjectDir);
if (ReplaceCount > 0)
{
ConnectedContentFolder = AbsoluteConnectedContentFolder;
}
}
else
{
ReplaceCount = ConnectedContentFolder.ReplaceInline(*LocalProjectDir, *ConnectedProjectDir);
}
if (ReplaceCount == 0)
{
int32 GameDirOffset = ConnectedContentFolder.Find(ConnectedProjectDir, ESearchCase::IgnoreCase, ESearchDir::FromEnd);
if (GameDirOffset != INDEX_NONE)
{
ConnectedContentFolder.RightChopInline(GameDirOffset, EAllowShrinking::No);
}
}
ContentFolders.Add(ConnectedContentFolder);
}
Out << ContentFolders;
// return the cached files and their timestamps
// TODO: This second file list is now identical to the first. This should be cleaned up in the future to not send two lists.
Out << FixedTimes;
}
return true;
}
void FNetworkFileServerClientConnection::FileModifiedCallback( const FString& Filename)
{
FScopeLock Lock(&ModifiedFilesSection);
// do we care about this file???
// translation here?
ModifiedFiles.AddUnique(Filename);
}
void FNetworkFileServerClientConnection::ProcessHeartbeat( FArchive& In, FArchive& Out )
{
TArray<FString> FixedupModifiedFiles;
// Protect the array
if (Sandbox)
{
FScopeLock Lock(&ModifiedFilesSection);
for (const auto& ModifiedFile : ModifiedFiles)
{
FixedupModifiedFiles.Add(FixupSandboxPathForClient(ModifiedFile));
}
ModifiedFiles.Empty();
}
// return the list of modified files
Out << FixedupModifiedFiles;
// @todo: note the last received time, and toss clients that don't heartbeat enough!
// @todo: Right now, there is no directory watcher adding to ModifiedFiles. It had to be pulled from this thread (well, the ModuleManager part)
// We should have a single directory watcher that pushes the changes to all the connections - or possibly pass in a shared DirectoryWatcher
// and have each connection set up a delegate (see p4 history for HandleDirectoryWatcherDirectoryChanged)
}
/* FStreamingNetworkFileServerConnection callbacks
*****************************************************************************/
bool FNetworkFileServerClientConnection::PackageFile( FString& Filename, FString& TargetFilename, FArchive& Out )
{
// get file timestamp and send it to client
FDateTime ServerTimeStamp = Sandbox->GetTimeStamp(*Filename);
// Disable access to outside the sandbox to prevent sending uncooked packages to the client
const bool bSandboxOnly = bRestrictPackageAssetsToSandbox && FPackageName::IsPackageExtension(*FPaths::GetExtension(Filename, true));
FSandboxOnlyScope _(*Sandbox, bSandboxOnly);
FString AbsHostFile = Sandbox->ConvertToAbsolutePathForExternalAppForRead(*Filename);
if (ConnectedTargetPlatform != nullptr && ConnectedTargetPlatform->CopyFileToTarget(ConnectedIPAddress, AbsHostFile, TargetFilename, ConnectedTargetCustomData))
{
Out << Filename;
Out << ServerTimeStamp;
// MAX_uint64 here indicates that it was copied already
uint64 FileSize = MAX_uint64;
Out << FileSize;
return true;
}
TArray<uint8> Contents;
// open file
IFileHandle* File = Sandbox->OpenRead(*Filename);
bool bRetVal = true;
if (!File)
{
++PackageRequestsFailed;
UE_LOG(LogFileServer, Warning, TEXT("Opening file %s failed"), *Filename);
ServerTimeStamp = FDateTime::MinValue(); // if this was a directory, this will make sure it is not confused with a zero byte file
bRetVal = false;
}
else
{
++PackageRequestsSucceeded;
if (!File->Size())
{
UE_LOG(LogFileServer, Warning, TEXT("Sending empty file %s...."), *Filename);
}
else
{
if (IntFitsIn<int32, int64>(File->Size()))
{
int32 FileSize32 = static_cast<int32>(File->Size());
FileBytesSent += FileSize32;
// read it
Contents.AddUninitialized(FileSize32);
File->Read(Contents.GetData(), Contents.Num());
}
else
{
UE_LOG(LogFileServer, Warning, TEXT("Unable to open %s because it is too large"), *Filename);
bRetVal = false;
}
}
// close it
delete File;
UE_LOG(LogFileServer, Display, TEXT("Read %s, %d bytes"), *Filename, Contents.Num());
}
Out << Filename;
Out << ServerTimeStamp;
uint64 FileSize = Contents.Num();
Out << FileSize;
Out.Serialize(Contents.GetData(), FileSize);
return bRetVal;
}
bool FNetworkFileServerClientConnection::ProcessSyncFile( FArchive& In, FArchive& Out )
{
double StartTime;
StartTime = FPlatformTime::Seconds();
// get filename
FString Filename;
In << Filename;
UE_LOG(LogFileServer, Verbose, TEXT("Try sync file %s"), *Filename);
FString ClientFilename = Filename;
ConvertClientFilenameToServerFilename(Filename);
//FString AbsFile(FString(*Sandbox->ConvertToAbsolutePathForExternalApp(*Filename)).MakeStandardFilename());
// ^^ we probably in general want that filename, but for cook on the fly, we want the un-sandboxed name
TArray<FString> NewUnsolictedFiles;
NetworkFileDelegates->FileRequestDelegate.ExecuteIfBound(Filename, ConnectedPlatformName, NewUnsolictedFiles);
FileRequestDelegateTime += 1000.0f * float(FPlatformTime::Seconds() - StartTime);
StartTime = FPlatformTime::Seconds();
for (int32 Index = 0; Index < NewUnsolictedFiles.Num(); Index++)
{
if (NewUnsolictedFiles[Index] != Filename)
{
UnsolictedFiles.AddUnique(NewUnsolictedFiles[Index]);
}
}
bool bRetVal = PackageFile(Filename, ClientFilename, Out);
PackageFileTime += 1000.0f * float(FPlatformTime::Seconds() - StartTime);
return bRetVal;
}
FString FNetworkFileServerClientConnection::GetDescription() const
{
return FString("Client For " ) + ConnectedPlatformName;
}
bool FNetworkFileServerClientConnection::Exec_Runtime(class UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar )
{
if (FParse::Command(&Cmd, TEXT("networkserverconnection")))
{
if (FParse::Command(&Cmd, TEXT("stats")))
{
Ar.Logf(TEXT("Network server connection %s stats\n"
"FileRequestDelegateTime \t%fms \n"
"PackageFileTime \t%fms \n"
"UnsolicitedFilesTime \t%fms \n"
"FileRequestCount \t%d \n"
"UnsolicitedFilesCount \t%d \n"
"PackageRequestsSucceeded \t%d \n"
"PackageRequestsFailed \t%d \n"
"FileBytesSent \t%d \n"),
*GetDescription(),
FileRequestDelegateTime,
PackageFileTime,
UnsolicitedFilesTime,
FileRequestCount,
UnsolicitedFilesCount,
PackageRequestsSucceeded,
PackageRequestsFailed,
FileBytesSent);
// there could be multiple network platform files so let them all report their stats
return false;
}
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink