#include "wren.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>
#ifdef _WIN32
#include <windows.h>
typedef HANDLE thread_t;
typedef CRITICAL_SECTION mutex_t;
typedef CONDITION_VARIABLE cond_t;
#else
#include <pthread.h>
typedef pthread_t thread_t;
typedef pthread_mutex_t mutex_t;
typedef pthread_cond_t cond_t;
#endif
// --- Data Structures ---
typedef struct {
int isError;
long statusCode;
char* body;
size_t body_len;
} ResponseData;
typedef struct {
char* memory;
size_t size;
} MemoryStruct;
typedef struct HttpContext {
WrenVM* vm;
WrenHandle* callback;
char* url;
char* method;
char* body;
struct curl_slist* headers;
bool success;
char* response_body;
size_t response_body_len;
long status_code;
char* error_message;
struct HttpContext* next;
} HttpContext;
// --- Thread-Safe Queue ---
typedef struct {
HttpContext *head, *tail;
mutex_t mutex;
cond_t cond;
} ThreadSafeQueue;
void http_queue_init(ThreadSafeQueue* q) {
q->head = q->tail = NULL;
#ifdef _WIN32
InitializeCriticalSection(&q->mutex);
InitializeConditionVariable(&q->cond);
#else
pthread_mutex_init(&q->mutex, NULL);
pthread_cond_init(&q->cond, NULL);
#endif
}
void http_queue_destroy(ThreadSafeQueue* q) {
#ifdef _WIN32
DeleteCriticalSection(&q->mutex);
#else
pthread_mutex_destroy(&q->mutex);
pthread_cond_destroy(&q->cond);
#endif
}
void http_queue_push(ThreadSafeQueue* q, HttpContext* context) {
#ifdef _WIN32
EnterCriticalSection(&q->mutex);
#else
pthread_mutex_lock(&q->mutex);
#endif
if(context) context->next = NULL;
if (q->tail) q->tail->next = context;
else q->head = context;
q->tail = context;
#ifdef _WIN32
WakeConditionVariable(&q->cond);
LeaveCriticalSection(&q->mutex);
#else
pthread_cond_signal(&q->cond);
pthread_mutex_unlock(&q->mutex);
#endif
}
HttpContext* http_queue_pop(ThreadSafeQueue* q) {
#ifdef _WIN32
EnterCriticalSection(&q->mutex);
while (q->head == NULL) {
SleepConditionVariableCS(&q->cond, &q->mutex, INFINITE);
}
#else
pthread_mutex_lock(&q->mutex);
while (q->head == NULL) {
pthread_cond_wait(&q->cond, &q->mutex);
}
#endif
HttpContext* context = q->head;
q->head = q->head->next;
if (q->head == NULL) q->tail = NULL;
#ifdef _WIN32
LeaveCriticalSection(&q->mutex);
#else
pthread_mutex_unlock(&q->mutex);
#endif
return context;
}
bool http_queue_empty(ThreadSafeQueue* q) {
#ifdef _WIN32
EnterCriticalSection(&q->mutex);
bool empty = (q->head == NULL);
LeaveCriticalSection(&q->mutex);
#else
pthread_mutex_lock(&q->mutex);
bool empty = (q->head == NULL);
pthread_mutex_unlock(&q->mutex);
#endif
return empty;
}
// --- libcurl Helpers ---
static size_t write_memory_callback(void *contents, size_t size, size_t nmemb, void *userp) {
size_t realsize = size * nmemb;
MemoryStruct *mem = (MemoryStruct *)userp;
char *ptr = (char*)realloc(mem->memory, mem->size + realsize + 1);
if (ptr == NULL) return 0;
mem->memory = ptr;
memcpy(&(mem->memory[mem->size]), contents, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
return realsize;
}
// --- Async HTTP Manager ---
typedef struct {
WrenVM* vm;
volatile bool running;
thread_t threads[4];
ThreadSafeQueue requestQueue;
ThreadSafeQueue completionQueue;
} AsyncHttpManager;
static AsyncHttpManager* httpManager = NULL;
void free_http_context(HttpContext* context) {
if (!context) return;
free(context->url);
free(context->method);
free(context->body);
curl_slist_free_all(context->headers);
free(context->response_body);
free(context->error_message);
free(context);
}
#ifdef _WIN32
DWORD WINAPI httpWorkerThread(LPVOID arg) {
#else
void* httpWorkerThread(void* arg) {
#endif
AsyncHttpManager* manager = (AsyncHttpManager*)arg;
while (manager->running) {
HttpContext* context = http_queue_pop(&manager->requestQueue);
if (!context || !manager->running) {
if (context) free_http_context(context);
break;
}
CURL *curl = curl_easy_init();
if (curl) {
MemoryStruct chunk;
chunk.memory = (char*)malloc(1);
chunk.size = 0;
curl_easy_setopt(curl, CURLOPT_URL, context->url);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_memory_callback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
curl_easy_setopt(curl, CURLOPT_USERAGENT, "wren-curl-agent/1.0");
if (strcmp(context->method, "POST") == 0) {
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, context->body);
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, context->headers);
}
CURLcode res = curl_easy_perform(curl);
if (res == CURLE_OK) {
context->success = true;
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &context->status_code);
context->response_body = chunk.memory;
context->response_body_len = chunk.size;
} else {
context->success = false;
context->status_code = -1;
context->error_message = strdup(curl_easy_strerror(res));
free(chunk.memory);
}
curl_easy_cleanup(curl);
} else {
context->success = false;
context->error_message = strdup("Failed to initialize cURL handle.");
}
http_queue_push(&manager->completionQueue, context);
}
return 0;
}
void httpManager_create(WrenVM* vm) {
httpManager = (AsyncHttpManager*)malloc(sizeof(AsyncHttpManager));
httpManager->vm = vm;
httpManager->running = true;
http_queue_init(&httpManager->requestQueue);
http_queue_init(&httpManager->completionQueue);
for (int i = 0; i < 4; ++i) {
#ifdef _WIN32
httpManager->threads[i] = CreateThread(NULL, 0, httpWorkerThread, httpManager, 0, NULL);
#else
pthread_create(&httpManager->threads[i], NULL, httpWorkerThread, httpManager);
#endif
}
}
void httpManager_destroy() {
httpManager->running = false;
for (int i = 0; i < 4; ++i) {
http_queue_push(&httpManager->requestQueue, NULL);
}
for (int i = 0; i < 4; ++i) {
#ifdef _WIN32
WaitForSingleObject(httpManager->threads[i], INFINITE);
CloseHandle(httpManager->threads[i]);
#else
pthread_join(httpManager->threads[i], NULL);
#endif
}
http_queue_destroy(&httpManager->requestQueue);
http_queue_destroy(&httpManager->completionQueue);
free(httpManager);
}
void httpManager_processCompletions() {
while (!http_queue_empty(&httpManager->completionQueue)) {
HttpContext* context = http_queue_pop(&httpManager->completionQueue);
WrenHandle* callHandle = wrenMakeCallHandle(httpManager->vm, "call(_,_)");
wrenEnsureSlots(httpManager->vm, 3);
wrenSetSlotHandle(httpManager->vm, 0, context->callback);
if (context->success) {
wrenSetSlotNull(httpManager->vm, 1);
wrenGetVariable(httpManager->vm, "requests", "Response", 2);
void* foreign = wrenSetSlotNewForeign(httpManager->vm, 2, 2, sizeof(ResponseData));
ResponseData* data = (ResponseData*)foreign;
data->isError = false;
data->statusCode = context->status_code;
data->body = context->response_body;
data->body_len = context->response_body_len;
context->response_body = NULL;
} else {
wrenSetSlotString(httpManager->vm, 1, context->error_message);
wrenSetSlotNull(httpManager->vm, 2);
}
wrenCall(httpManager->vm, callHandle);
wrenReleaseHandle(httpManager->vm, context->callback);
wrenReleaseHandle(httpManager->vm, callHandle);
free_http_context(context);
}
}
void httpManager_submit(HttpContext* context) {
http_queue_push(&httpManager->requestQueue, context);
}
// --- Wren Foreign Methods ---
void responseFinalize(void* data) {
ResponseData* response = (ResponseData*)data;
free(response->body);
}
void responseAllocate(WrenVM* vm) {
ResponseData* data = (ResponseData*)wrenSetSlotNewForeign(vm, 0, 0, sizeof(ResponseData));
data->isError = 0;
data->statusCode = 0;
data->body = NULL;
data->body_len = 0;
}
void responseIsError(WrenVM* vm) {
ResponseData* data = (ResponseData*)wrenGetSlotForeign(vm, 0);
wrenSetSlotBool(vm, 0, data->isError ? true : false);
}
void responseStatusCode(WrenVM* vm) {
ResponseData* data = (ResponseData*)wrenGetSlotForeign(vm, 0);
wrenSetSlotDouble(vm, 0, (double)data->statusCode);
}
void responseBody(WrenVM* vm) {
ResponseData* data = (ResponseData*)wrenGetSlotForeign(vm, 0);
wrenSetSlotBytes(vm, 0, data->body ? data->body : "", data->body_len);
}
void responseJson(WrenVM* vm) {
// CORRECTED: Replaced incorrect call with the actual logic.
ResponseData* data = (ResponseData*)wrenGetSlotForeign(vm, 0);
wrenSetSlotBytes(vm, 0, data->body ? data->body : "", data->body_len);
}
void requestsGet(WrenVM* vm) {
HttpContext* context = (HttpContext*)calloc(1, sizeof(HttpContext));
context->vm = vm;
context->method = strdup("GET");
context->url = strdup(wrenGetSlotString(vm, 1));
context->callback = wrenGetSlotHandle(vm, 3);
httpManager_submit(context);
}
void requestsPost(WrenVM* vm) {
HttpContext* context = (HttpContext*)calloc(1, sizeof(HttpContext));
context->vm = vm;
context->method = strdup("POST");
context->url = strdup(wrenGetSlotString(vm, 1));
context->body = strdup(wrenGetSlotString(vm, 2));
const char* contentType = wrenGetSlotString(vm, 3);
char contentTypeHeader[256];
snprintf(contentTypeHeader, sizeof(contentTypeHeader), "Content-Type: %s", contentType);
context->headers = curl_slist_append(NULL, contentTypeHeader);
context->callback = wrenGetSlotHandle(vm, 5);
httpManager_submit(context);
}
// --- FFI Binding Functions ---
WrenForeignMethodFn bindForeignMethod(WrenVM* vm, const char* module,
const char* className, bool isStatic, const char* signature) {
if (strcmp(module, "requests") != 0) return NULL;
if (strcmp(className, "Requests") == 0 && isStatic) {
if (strcmp(signature, "get_(_,_,_)") == 0) return requestsGet;
if (strcmp(signature, "post_(_,_,_,_,_)") == 0) return requestsPost;
}
if (strcmp(className, "Response") == 0 && !isStatic) {
if (strcmp(signature, "isError") == 0) return responseIsError;
if (strcmp(signature, "statusCode") == 0) return responseStatusCode;
if (strcmp(signature, "body") == 0) return responseBody;
if (strcmp(signature, "json()") == 0) return responseJson;
}
return NULL;
}
WrenForeignClassMethods bindForeignClass(WrenVM* vm, const char* module, const char* className) {
WrenForeignClassMethods methods = {0, 0};
if (strcmp(module, "requests") == 0) {
if (strcmp(className, "Response") == 0) {
methods.allocate = responseAllocate;
methods.finalize = responseFinalize;
}
}
return methods;
}
Reference in New Issue View Git Blame Copy Permalink