mirror of
https://gitea.wildfiregames.com/0ad/0ad
synced 2026-06-16 05:13:58 -07:00
6893654cfc
Some checks failed
checkrefs / lfscheck (push) Has been cancelled
checkrefs / checkrefs (push) Has been cancelled
lint / cppcheck (push) Has been cancelled
lint / copyright (push) Has been cancelled
lint / jenkinsfiles (push) Has been cancelled
pre-commit / build (push) Has been cancelled
This reduces the stutter when a client joins. The decompression isn't put on the task manager. As the client would have to wait for that either way. Also a new polling loop would have to be introduced. The compression code is moved to the file transferer so all data send through it gits compressed. Refs: #4210
140 lines
3.8 KiB
C++
140 lines
3.8 KiB
C++
/* Copyright (C) 2026 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef NETFILETRANSFER_H
|
|
#define NETFILETRANSFER_H
|
|
|
|
#include "lib/alignment.h"
|
|
#include "lib/status.h"
|
|
#include "lib/types.h"
|
|
#include "ps/Future.h"
|
|
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
|
|
class CFileTransferAckMessage;
|
|
class CFileTransferDataMessage;
|
|
class CFileTransferResponseMessage;
|
|
class CNetMessage;
|
|
|
|
// Assume this is sufficiently less than MTU that packets won't get
|
|
// fragmented or dropped.
|
|
static const size_t DEFAULT_FILE_TRANSFER_PACKET_SIZE = 1024;
|
|
|
|
// To improve performance without flooding ENet's internal buffers,
|
|
// maintain a small number of in-flight packets.
|
|
// Pick numbers so that with e.g. 200ms round-trip latency
|
|
// we can hopefully get windowSize*packetSize*1000/200 = 160KB/s bandwidth
|
|
static const size_t DEFAULT_FILE_TRANSFER_WINDOW_SIZE = 32;
|
|
|
|
// Some arbitrary limit to make it slightly harder to use up all of someone's RAM
|
|
static const size_t MAX_FILE_TRANSFER_SIZE = 8*MiB;
|
|
|
|
/**
|
|
* Handles transferring files between clients and servers.
|
|
*/
|
|
class CNetFileTransferer
|
|
{
|
|
public:
|
|
enum class RequestType
|
|
{
|
|
LOADGAME,
|
|
REJOIN
|
|
};
|
|
|
|
template<typename Session>
|
|
CNetFileTransferer(Session& session) :
|
|
m_SendMessage{std::bind_front(&Session::SendMessage, std::ref(session))}
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Should be called when a message is received from the network.
|
|
* Returns INFO::SKIPPED if the message is not one that this class handles.
|
|
* Returns INFO::OK if the message is handled successfully,
|
|
* or ERR::FAIL if handled unsuccessfully.
|
|
*/
|
|
Status HandleMessageReceive(const CNetMessage& message);
|
|
|
|
/**
|
|
* Registers a file-receiving task.
|
|
*/
|
|
void StartTask(RequestType requestType, std::function<void(std::string)> task);
|
|
|
|
/**
|
|
* Registers data to be sent in response to a request.
|
|
* (Callers are expected to have their own mechanism for receiving
|
|
* requests and deciding what to respond with.)
|
|
*/
|
|
void StartResponse(u32 requestID, const std::string& data);
|
|
|
|
/**
|
|
* Call frequently (e.g. once per frame) to trigger any necessary
|
|
* packet processing.
|
|
*/
|
|
void Poll();
|
|
|
|
private:
|
|
Status OnFileTransferResponse(const CFileTransferResponseMessage& message);
|
|
Status OnFileTransferData(const CFileTransferDataMessage& message);
|
|
Status OnFileTransferAck(const CFileTransferAckMessage& message);
|
|
|
|
/**
|
|
* Asynchronous file-sending task.
|
|
*/
|
|
struct CNetFileSendTask
|
|
{
|
|
u32 requestID;
|
|
std::string buffer;
|
|
size_t offset;
|
|
size_t maxWindowSize;
|
|
size_t packetsInFlight;
|
|
Future<std::string> task;
|
|
};
|
|
|
|
std::function<bool(const CNetMessage* message)> m_SendMessage;
|
|
|
|
u32 m_NextRequestID{1};
|
|
|
|
|
|
struct AsyncFileReceiveTask
|
|
{
|
|
/**
|
|
* Called when m_Buffer contains the full received data.
|
|
*/
|
|
std::function<void(std::string)> onComplete;
|
|
|
|
// TODO: Ought to have a failure channel, e.g. when the session drops or there's another error.
|
|
|
|
size_t length{0};
|
|
|
|
std::string buffer;
|
|
};
|
|
|
|
using FileReceiveTasksMap = std::unordered_map<u32, AsyncFileReceiveTask>;
|
|
FileReceiveTasksMap m_FileReceiveTasks;
|
|
|
|
using FileSendTasksMap = std::map<u32, CNetFileSendTask>;
|
|
FileSendTasksMap m_FileSendTasks;
|
|
|
|
double m_LastProgressReportTime{0};
|
|
};
|
|
|
|
#endif // NETFILETRANSFER_H
|