dcrubro/miniboinc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Works

Browse Source
This commit is contained in:
DcruBro
2026-01-18 18:42:28 +01:00
parent 8ed280126c
commit ce70bf02bf
9 changed files with 260 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

178
src/server/main.c
View File

@@ -11,6 +11,7 @@
volatile int running = 1;
task_queue_t taskQueue;
TcpServer* svr;
void signalHandler(int sig) {
printf("Caught signal %d, shutting down...\n", sig);
@@ -22,7 +23,8 @@ void on_connect(TcpClient* client) {
helloPacket[0] = PACKET_TYPE_HELLO;
helloPacket[1] = SERVER_INFO_VERSION;
memcpy(&helloPacket[2], SERVER_INFO_IDENTIFIER, 16);
send(client->clientFd, helloPacket, SERVER_HELLO_PACKET_SIZE + 1, 0);
TcpServer_Send(svr, client, helloPacket, SERVER_HELLO_PACKET_SIZE + 1);
//send(client->clientFd, helloPacket, SERVER_HELLO_PACKET_SIZE + 1, 0);
printf("Client connected: %u\n", client->clientId);
}
@@ -62,7 +64,8 @@ void on_data(TcpClient* client) {
// Send ACKNOWLEDGE; Might embed which packet is being acknowledged later
char ackPacket[1];
ackPacket[0] = PACKET_TYPE_ACKNOWLEDGE;
send(client->clientFd, ackPacket, 1, 0);
TcpServer_Send(svr, client, ackPacket, 1);
//send(client->clientFd, ackPacket, 1, 0);
printf("Sent ACKNOWLEDGE to client %u\n", client->clientId);
}
@@ -70,6 +73,12 @@ void on_data(TcpClient* client) {
case PACKET_TYPE_TASK_REQUEST:
printf("Received TASK_REQUEST packet from client %u\n", client->clientId);
if (client->assignedTaskNumber != -1) {
// Client already has a task assigned
printf("Client %u already has a task assigned (%ld), ignoring request\n", client->clientId, client->assignedTaskNumber);
break;
}
if (client->capabilities) {
size_t capCount = DynArr_size(client->capabilities);
@@ -78,7 +87,7 @@ void on_data(TcpClient* client) {
char missingInfoPacket[2];
missingInfoPacket[0] = PACKET_TYPE_MISSING_INFO;
missingInfoPacket[1] = PACKET_TYPE_CLIENT_CAPABILITIES;
send(client->clientFd, missingInfoPacket, 2, 0);
TcpServer_Send(svr, client, missingInfoPacket, 2);
printf("Requested capabilities from client %u\n", client->clientId);
break;
}
@@ -113,39 +122,33 @@ void on_data(TcpClient* client) {
uint8_t packetType = PACKET_TYPE_TASK_ASSIGN;
DynArr_push_back(packet, &packetType);
// Push back the task struct
for (size_t k = 0; k < sizeof(task_t); k++) {
DynArr_push_back(packet, ((char*)task) + k);
uint32_t dataSize = sizeof(uint32_t) + 64 + DynArr_size(task->args);
// Push data size
for (size_t k = 0; k < sizeof(uint32_t); k++) {
DynArr_push_back(packet, &((uint8_t*)&dataSize)[k]);
}
// Special sequence to indicate start of args
char sequence[] = "ARGSTART";
for (size_t k = 0; k < sizeof(sequence); k++) {
DynArr_push_back(packet, &sequence[k]);
// Task ID
for (size_t k = 0; k < sizeof(uint32_t); k++) {
DynArr_push_back(packet, &((uint8_t*)&task->taskId)[k]);
}
// Push back args
for (size_t k = 0; k < DynArr_size(task->args); k++) {
task_arg_t* arg = (task_arg_t*)DynArr_at(task->args, k);
for (size_t m = 0; m < sizeof(task_arg_t); m++) {
DynArr_push_back(packet, ((char*)arg) + m);
}
// Push back arg data
for (size_t m = 0; m < DynArr_size(arg->data); m++) {
char* dataPtr = (char*)DynArr_at(arg->data, m);
for (size_t n = 0; n < sizeof(char); n++) {
DynArr_push_back(packet, dataPtr + n);
}
}
// Push back next arg indicator
char nextArgIndicator[] = "ARGNEXT";
for (size_t n = 0; n < sizeof(nextArgIndicator); n++) {
DynArr_push_back(packet, &nextArgIndicator[n]);
}
// Binary name
for (size_t k = 0; k < 64; k++) {
DynArr_push_back(packet, &task->binary[k]); // char is uint8_t compatible
}
send(client->clientFd, packet->data, DynArr_size(packet) * sizeof(uint8_t), 0);
// Args
uint32_t argsSize = (uint32_t)DynArr_size(task->args);
for (size_t k = 0; k < argsSize; k++) {
uint8_t* argByte = (uint8_t*)DynArr_at(task->args, k);
DynArr_push_back(packet, argByte);
}
TcpServer_Send(svr, client, packet->data, DynArr_size(packet) * sizeof(uint8_t));
client->assignedTaskNumber = task->taskId;
DynArr_destroy(packet);
printf("Assigned task %u to client %u\n", task->taskId, client->clientId);
break;
@@ -157,12 +160,87 @@ void on_data(TcpClient* client) {
}
}
}
if (!assigned) {
// No task available
char noneAvailablePacket[1];
noneAvailablePacket[0] = PACKET_TYPE_TASK_NONE_AVAILABLE;
TcpServer_Send(svr, client, noneAvailablePacket, 1);
printf("No available tasks for client %u\n", client->clientId);
}
break;
}
break;
case PACKET_TYPE_TASK_REJECT:
printf("Received TASK_REJECT packet from client %u\n", client->clientId);
if (client->assignedTaskNumber == -1) {
// No task assigned
printf("Client %u has no task assigned, ignoring reject\n", client->clientId);
break;
} else {
// Mark task as pending again
for (size_t i = 0; i < DynArr_size(taskQueue.tasks); i++) {
task_t* task = (task_t*)DynArr_at(taskQueue.tasks, i);
if (task && task->taskId == client->assignedTaskNumber) {
task->state = TASK_PENDING;
task->assigned_to = 0;
task->assigned_at = 0;
printf("Marked task %u as pending again\n", task->taskId);
break;
}
}
client->assignedTaskNumber = -1; // Clear assigned task
}
break;
case PACKET_TYPE_TASK_RESULT:
printf("Received TASK_RESULT packet from client %u\n", client->clientId);
if (client->assignedTaskNumber == -1) {
// No task assigned
printf("Client %u has no task assigned, ignoring result\n", client->clientId);
break;
} else {
// Mark task as done; TODO: Store results
for (size_t i = 0; i < DynArr_size(taskQueue.tasks); i++) {
task_t* task = (task_t*)DynArr_at(taskQueue.tasks, i);
if (task && task->taskId == client->assignedTaskNumber) {
task->state = TASK_DONE;
printf("Marked task %u as done\n", task->taskId);
// Temporary: log as int
//if (bytesReceived - 1 >= sizeof(int)) {
// int result;
// memcpy(&result, &client->dataBuf[1 + sizeof(uint32_t)], sizeof(int));
// printf("Task %u result: %d\n", task->taskId, result);
//}
uint32_t resultDataSize;
memcpy(&resultDataSize, &client->dataBuf[1], sizeof(uint32_t));
printf("Task %u result data size: %u bytes\n", task->taskId, resultDataSize);
// Store results
task->assigned_to = 0;
task->assigned_at = 0;
task->results = DYNARR_CREATE(uint8_t, 1);
// Store result data
for (size_t j = 1; j < resultDataSize; j++) {
uint8_t byte = client->dataBuf[j + 1 + sizeof(uint32_t)]; // +1 for packet type, +4 for size
DynArr_push_back(task->results, &byte);
}
// TODO: Optionally dump results to file or process them here
// Note: This assumes that the results are trustworthy, which might need to be verified via multiple clients
break;
}
}
client->assignedTaskNumber = -1; // Clear assigned task
}
break;
default:
printf("Received unknown packet type %u from client %u\n", packetType, client->clientId);
@@ -183,21 +261,41 @@ int main(void) {
TaskQueue_Init(&taskQueue);
printf("Task Queue Created!\n");
task_t task1;
Task_Create(&task1);
task1.state = TASK_PENDING;
task1.args = DYNARR_CREATE(task_arg_t, 1);
strcpy(task1.binary, "test_computation");
task_arg_t* blk = DynArr_push_back(task1.args, &(task_arg_t){ .name = "input_data", .data = DYNARR_CREATE(char, 1) });
DynArr_push_back(blk->data, "12"); // Compute the square of 12
task1.taskId = 1;
TaskQueue_AddTask(&taskQueue, &task1);
//task_t task1;
//Task_Create(&task1);
//task1.state = TASK_PENDING;
//task1.args = DYNARR_CREATE(uint8_t, 1);
//int argVal = 10000019; // This should stay in the stack due to the loop below (I guess we'll see soon enough)
//strcpy(task1.binary, "test_computation");
//for (size_t i = 0; i < sizeof(argVal); i++) {
// uint8_t b = ((uint8_t*)&argVal)[i]; // Byte hacking to get each byte of the int
// DynArr_push_back(task1.args, &b);
//}
//task1.taskId = 1;
//
//TaskQueue_AddTask(&taskQueue, &task1);
// Create some dummy tasks
for (int i = 0; i < 5; i++) {
task_t task;
Task_Create(&task);
task.state = TASK_PENDING;
task.args = DYNARR_CREATE(uint8_t, 1);
int argVal = rand(); // Different arg for each task
snprintf(task.binary, sizeof(task.binary), "test_computation");
for (size_t j = 0; j < sizeof(argVal); j++) {
uint8_t b = ((uint8_t*)&argVal)[j]; // Byte hacking to get each byte of the int
DynArr_push_back(task.args, &b);
}
TaskQueue_AddTask(&taskQueue, &task); // AddTask copies to the dynamic array, so we can free the stack task safely
}
//Task_DestroyArgs(&task1);
printf("Task added!\n");
TcpServer* svr = TcpServer_Create();
svr = TcpServer_Create();
TcpServer_Init(svr, 6175, "127.0.0.1");
svr->on_connect = on_connect;
svr->on_data = on_data;