HappyTanuki/NP_Midterm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

둘 다 동시 디버깅을 위해 push

Browse Source
This commit is contained in:
HappyTanuki
2025-05-03 17:58:46 +09:00
parent 4bbb6837e8
commit 6ad787eed7
11 changed files with 305 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Server/include/ServerManager/ServerManager.hpp
View File

@@ -51,8 +51,6 @@ public:
void joinRoom(Snowflake UID, Snowflake RID);
void exitRoom(Snowflake UID, Snowflake RID);
Snowflake generateID();
void run();
private:
ThreadPool threadPool_;
@@ -64,14 +62,13 @@ private:
struct Address clientAddr_;
std::mutex resourceMutex_;
std::mutex snowflakeGenerateMutex_;
std::unordered_map<Snowflake, std::string> roomNames_;
std::unordered_map<Snowflake, std::unordered_map<Snowflake, std::shared_ptr<TCPSocket>>> rooms_;
std::unordered_map<Snowflake, std::shared_ptr<TCPSocket>> UID2userSocket_;
std::unordered_map<TCPSocket*, Snowflake> userSocket2UID_;
std::unordered_map<std::shared_ptr<TCPSocket>, Snowflake> userSocket2UID_;
std::unordered_map<Snowflake, std::string> userNames_;

155
Server/src/ServerManager/ServerManager.cpp
View File

@@ -6,29 +6,52 @@ namespace Chattr {
void ServerManager::_IOCPClient(Chattr::ThreadPool* thread, Chattr::IOCPPASSINDATA* data) {
Chattr::Packet pack;
int packetSize = data->transfrredbytes;
int packetSize = data->transferredbytes;
if (data->recvbytes == 0) {
data->recvbytes = data->transfrredbytes;
data->transfrredbytes = 0;
data->recvbytes = data->transferredbytes;
data->transferredbytes = 0;
}
else if (data->transfrredbytes <= data->sendbytes) {
else if (data->transferredbytes <= data->sendbytes) {
data->IOCPInstance->recv(data, 1);
return;
}
memcpy(pack.serialized, data->wsabuf.buf, data->wsabuf.len);
pack.convToH();
std::string recvString;
bool packetError = false;
DataPostPacket dataPostPacket;
ResponsePacket responsePacket;
LoginRequestPacket loginRequestPacket;
pack.convToH();
std::uint16_t packetLength = pack.__data.packetLength;
switch (packetParser(pack)) {
case PacketSet::LOGINREQUEST:
case PacketSet::LOGINREQUEST: {
pack.convToN();
LoginRequestPacket loginRequestPacket;
std::memcpy(&loginRequestPacket.serialized, &pack, 8 + pack.__data.packetLength);
loginRequestPacket.convToH();
std::string userName(
(char*)loginRequestPacket.__data.data,
loginRequestPacket.__data.packetLength);
registerUser(userName, data->socket);
LoginResponsePacket loginResponsePacket;
loginResponsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
loginResponsePacket.__data.requestType = Chattr::RequestType::LOGIN;
loginResponsePacket.__data.dataType = Chattr::DataType::TEXT;
loginResponsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode) + sizeof(Snowflake);
loginResponsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
::memcpy(loginResponsePacket.__data.yourId, &userSocket2UID_[data->socket], sizeof(Snowflake));
loginResponsePacket.convToN();
memcpy(data->wsabuf.buf, loginResponsePacket.serialized, 16);
data->sendbytes = 16;
data->transferredbytes = 16;
data->IOCPInstance->send(data, 1, 0);
}
break;
case PacketSet::ROOMCREATEREQUEST:
break;
@@ -40,23 +63,60 @@ void ServerManager::_IOCPClient(Chattr::ThreadPool* thread, Chattr::IOCPPASSINDA
break;
case PacketSet::USERSLISTREQUEST:
break;
case PacketSet::DATAPOSTTEXT:
std::memcpy(&dataPostPacket.serialized, &pack, 1500);
dataPostPacket.__data.packetLength = (dataPostPacket.__data.packetLength > 1487) ? 1487 : dataPostPacket.__data.packetLength;
recvString = std::string((char*)dataPostPacket.__data.data, dataPostPacket.__data.packetLength - (sizeof(std::uint16_t) * 4));
spdlog::info("Received [{}] from : [{}]", recvString, (std::string)data->socket->remoteAddr);
case PacketSet::DATAPOSTTEXT: {
pack.convToN();
std::memcpy(&dataPostPacket.serialized, &pack, 8 + pack.__data.packetLength);
dataPostPacket.convToH();
responsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
responsePacket.__data.requestType = Chattr::RequestType::DATA;
responsePacket.__data.dataType = Chattr::DataType::TEXT;
responsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
responsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::BAD_REQUEST;
responsePacket.convToN();
memcpy(data->wsabuf.buf, responsePacket.serialized, responsePacket.__data.packetLength + 8);
Snowflake destID = {};
// data->sendbytes = responsePacket.__data.packetLength + 5;
data->sendbytes = 1500;
data->IOCPInstance->send(data, 1, 0);
::memcpy(&destID.snowflake, dataPostPacket.__data.destId, sizeof(Snowflake));
std::vector<std::shared_ptr<TCPSocket>> destinationSockets;
if (userNames_.find(destID) != userNames_.end())
destinationSockets.push_back(UID2userSocket_[destID]);
else
for (auto user : rooms_[destID])
destinationSockets.push_back(user.second);
spdlog::info("Received [{}] from : [{}] to : [{}]",
std::string((char*)dataPostPacket.__data.data, dataPostPacket.__data.packetLength - (sizeof(std::uint16_t) * 5)),
(std::string)data->socket->remoteAddr,
destID.snowflake);
responsePacket.__data.packetType = Chattr::PacketCategory::PACKET_RESPONSE;
responsePacket.__data.requestType = Chattr::RequestType::DATA;
responsePacket.__data.dataType = Chattr::DataType::TEXT;
responsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
responsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::OK;
responsePacket.convToN();
memcpy(data->wsabuf.buf, responsePacket.serialized, 10);
data->sendbytes = 10;
data->transferredbytes = 10;
data->IOCPInstance->send(data, 1, 0);
for (auto dest : destinationSockets) {
dataPostPacket.__data.packetType = Chattr::PacketCategory::PACKET_POST;
dataPostPacket.__data.requestType = Chattr::RequestType::DATA;
dataPostPacket.__data.dataType = Chattr::DataType::TEXT;
Chattr::IOCPPASSINDATA* ptr = new Chattr::IOCPPASSINDATA;
::memset(&ptr->overlapped, 0, sizeof(OVERLAPPED));
ptr->socket = dest;
ptr->recvbytes = ptr->sendbytes = 0;
ptr->wsabuf.buf = ptr->buf;
ptr->wsabuf.len = 1500;
ptr->IOCPInstance = data->IOCPInstance;
dataPostPacket.convToN();
memcpy(ptr->wsabuf.buf, dataPostPacket.serialized, packetLength + 6);
data->sendbytes = packetLength + 6;
data->transferredbytes = packetLength + 6;
data->IOCPInstance->send(ptr, 1, 0);
}
}
break;
case PacketSet::DATAPOSTBINARY:
break;
@@ -69,18 +129,18 @@ void ServerManager::_IOCPClient(Chattr::ThreadPool* thread, Chattr::IOCPPASSINDA
responsePacket.__data.dataType = Chattr::DataType::TEXT;
responsePacket.__data.packetLength = sizeof(Chattr::ResponseStatusCode);
responsePacket.__data.responseStatusCode = Chattr::ResponseStatusCode::BAD_REQUEST;
responsePacket.convToN();
memcpy(data->wsabuf.buf, responsePacket.serialized, responsePacket.__data.packetLength + 8);
// data->sendbytes = responsePacket.__data.packetLength + 5;
data->sendbytes = responsePacket.__data.packetLength + 8;
data->transfrredbytes = responsePacket.__data.packetLength + 8;
memcpy(data->wsabuf.buf, responsePacket.serialized, 10);
data->sendbytes = 10;
data->transferredbytes = 10;
data->IOCPInstance->send(data, 1, 0);
break;
}
}
PacketSet ServerManager::packetParser(Packet Packet) {
if (Packet.__data.packetLength < 0 || Packet.__data.packetLength > 1500)
if (Packet.__data.packetLength < 0 || Packet.__data.packetLength > 1492)
return PacketSet::INVALID;
switch (Packet.__data.packetType) {
@@ -138,14 +198,16 @@ PacketSet ServerManager::packetParser(Packet Packet) {
default:
return PacketSet::INVALID;
}
return PacketSet::INVALID;
}
void ServerManager::registerUser(std::string userName, std::shared_ptr<TCPSocket> sock) {
std::lock_guard<std::mutex> lock(resourceMutex_);
Snowflake UID = generateID();
Snowflake UID = GenerateID();
userNames_[UID] = userName;
UID2userSocket_[UID] = sock;
userSocket2UID_[sock.get()] = UID;
userSocket2UID_[sock] = UID;
}
void ServerManager::deleteUser(Snowflake UID) {
@@ -153,7 +215,7 @@ void ServerManager::deleteUser(Snowflake UID) {
userNames_.erase(UID);
std::shared_ptr<TCPSocket> sock = UID2userSocket_[UID];
UID2userSocket_.erase(UID);
userSocket2UID_.erase(sock.get());
userSocket2UID_.erase(sock);
}
std::vector<std::pair<Snowflake, std::string>> ServerManager::getUserList() {
@@ -169,7 +231,7 @@ std::vector<std::pair<Snowflake, std::string>> ServerManager::getUserList() {
void ServerManager::createRoom(std::string roomName) {
std::lock_guard<std::mutex> lock(resourceMutex_);
Snowflake RID = generateID();
Snowflake RID = GenerateID();
roomNames_[RID] = roomName;
rooms_[RID] = std::unordered_map<Snowflake, std::shared_ptr<TCPSocket>>();
}
@@ -202,31 +264,6 @@ void ServerManager::exitRoom(Snowflake UID, Snowflake RID) {
rooms_[RID].erase(UID);
}
static struct _EPOCH {
_EPOCH() {
EPOCH = std::chrono::system_clock::now();
}
std::chrono::system_clock::time_point EPOCH;
} __EPOCH__;
Snowflake ServerManager::generateID() {
std::lock_guard<std::mutex> lock(snowflakeGenerateMutex_);
#ifdef _WIN32
DWORD tid = GetCurrentThreadId();
#elif __linux__
pthread_t tid = pthread_self();
#endif
static int sequence = 0;
Snowflake id = {};
auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - __EPOCH__.EPOCH);
id.timestamp = timestamp.count();
id.instance = tid;
id.sequence = sequence++;
return id;
}
void ServerManager::run() {
while (true) {
spdlog::info("Waiting for connection...");