send tasks

src/server/main.c

@@ -5,29 +5,134 @@
 #include <common/tcpd/tcpserver.h>
 #include <common/tcpd/tcpclient.h>
 #include <signal.h>
+#include <server/info.h>
+#include <common/packettype.h>
+#include <common/capability.h>
 
 volatile int running = 1;
+task_queue_t taskQueue;
 
 void signalHandler(int sig) {
+    printf("Caught signal %d, shutting down...\n", sig);
     running = 0;
 }
 
 void on_connect(TcpClient* client) {
-    return;
+    char helloPacket[SERVER_HELLO_PACKET_SIZE + 1]; // +1 for packet type
+    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);
+
+    printf("Client connected: %u\n", client->clientId);
 }
 
 void on_data(TcpClient* client) {
-    return;
+    uint8_t packetType;
+    ssize_t bytesReceived = client->dataBufLen;
+
+    if (bytesReceived == 0) {
+        return;
+    } else if (bytesReceived < 0) {
+        perror("Error receiving data from client\n");
+        return;
+    }
+
+    packetType = client->dataBuf[0];
+    switch (packetType) {
+        case PACKET_TYPE_HELLO:
+            // Unexpected, ignore
+            break;
+        case PACKET_TYPE_CLIENT_CAPABILITIES:
+            printf("Received CLIENT_CAPABILITIES packet from client %u\n", client->clientId);
+            // Decode capabilities here
+            char* ptr = (char*)&client->dataBuf[1]; // Skip packet type byte
+            size_t capabilitiesCount = (bytesReceived - 1) / sizeof(capability_t);
+            for (size_t i = 0; i < capabilitiesCount; i++) {
+                capability_t cap;
+                memcpy(&cap, ptr + i * sizeof(capability_t), sizeof(capability_t));
+                printf("Capability: %s, Supported: %s\n", cap.name, cap.supported ? "Yes" : "No");
+                if (client->capabilities) {
+                    DynArr_push_back(client->capabilities, &cap);
+                }
+            }
+
+            break;
+        case PACKET_TYPE_TASK_REQUEST:
+            printf("Received TASK_REQUEST packet from client %u\n", client->clientId);
+
+            if (client->capabilities) {
+                size_t capCount = DynArr_size(client->capabilities);
+
+                if (capCount <= 0) {
+                    // Request capabilities first
+                    char missingInfoPacket[2];
+                    missingInfoPacket[0] = PACKET_TYPE_MISSING_INFO;
+                    missingInfoPacket[1] = PACKET_TYPE_CLIENT_CAPABILITIES;
+                    send(client->clientFd, missingInfoPacket, 2, 0);
+                    printf("Requested capabilities from client %u\n", client->clientId);
+                    break;
+                }
+
+                // Find a task that matches capabilities and assign it
+                for (size_t i = 0; i < DynArr_size(&taskQueue.tasks); i++) {
+                    task_t* task = (task_t*)DynArr_at(&taskQueue.tasks, i);
+                    int assigned = 0;
+
+                    if (task->state == TASK_PENDING) {
+                        // For simplicity, assign the first pending task with capabilities
+                        // The capabilites (for now) are the required binary name; we're just gonna strcmp it for now
+                        for (size_t j = 0; j < capCount; j++) {
+                            capability_t* cap = (capability_t*)DynArr_at(client->capabilities, j);
+                            if (strcmp(cap->name, task->binary) == 0 && cap->supported) {
+                                // Assign task to client
+                                assigned = 1;
+                                task->state = TASK_ASSIGNED;
+                                task->assigned_to = client->clientId;
+                                task->assigned_at = time(NULL);
+
+                                // Make packet
+                                DynArr* packet = DYNARR_CREATE(uint8_t, 1);
+                                uint8_t packetType = PACKET_TYPE_TASK_ASSIGN;
+                                DynArr_push_back(packet, &packetType);
+
+                                // Push back the task struct
+                                DynArr_push_back(packet, task);
+
+                                send(client->clientFd, packet->data, DynArr_size(packet) * sizeof(uint8_t), 0);
+                                printf("Assigned task %u to client %u\n", task->taskId, client->clientId);
+
+                                break;
+                            }
+                        }
+
+                        if (assigned) {
+                            break;
+                        }
+                    }
+                }
+                break;
+            }
+
+            break;
+        case PACKET_TYPE_TASK_RESULT:
+            printf("Received TASK_RESULT packet from client %u\n", client->clientId);
+            break;
+        default:
+            printf("Received unknown packet type %u from client %u\n", packetType, client->clientId);
+            break;
+    }
 }
 
 void on_disconnect(TcpClient* client) {
-    return;
+    printf("Client disconnected: %u\n", client->clientId);
+
+    // TODO; Check if tasks were assigned to this client and handle them
 }
 
 int main(void) {
     signal(SIGINT, signalHandler);
 
-    task_queue_t taskQueue;
     TaskQueue_Init(&taskQueue);
 
     printf("Task Queue Created!\n");
@@ -59,4 +164,4 @@ int main(void) {
     printf("Destroyed!\n");
 
     return 0;
-}
+}