Catcrafts/Crafter.Network
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

port to crafter.build v2

Browse source 
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jorijn van der Graaf 2026-05-06 01:06:05 +02:00
commit 4e097d2b2d
8 changed files with 156 additions and 193 deletions
Download patch file Download diff file Expand all files Collapse all files

71
project.cpp Normal file
View file

@ -0,0 +1,71 @@
import std;
import Crafter.Build;
namespace fs = std::filesystem;
using namespace Crafter;
extern "C" Configuration CrafterBuildProject(std::span<const std::string_view> args) {
constexpr std::array<std::string_view, 6> networkInterfaces = {
"interfaces/Crafter.Network",
"interfaces/Crafter.Network-ClientTCP",
"interfaces/Crafter.Network-ListenerTCP",
"interfaces/Crafter.Network-ClientHTTP",
"interfaces/Crafter.Network-ListenerHTTP",
"interfaces/Crafter.Network-HTTP",
};
constexpr std::array<std::string_view, 4> networkImplementations = {
"implementations/Crafter.Network-ClientTCP",
"implementations/Crafter.Network-ListenerTCP",
"implementations/Crafter.Network-ClientHTTP",
"implementations/Crafter.Network-ListenerHTTP",
};
std::vector<std::string> depArgs(args.begin(), args.end());
Configuration* thread = GitProject({
.source = { .url = "https://forgejo.catcrafts.net/Catcrafts/Crafter.Thread.git" },
.args = depArgs,
});
Configuration cfg;
cfg.path = "./";
cfg.name = "Crafter.Network";
cfg.outputName = "Crafter.Network";
cfg.type = ConfigurationType::LibraryStatic;
ApplyStandardArgs(cfg, args);
cfg.dependencies = { thread };
{
std::array<fs::path, 6> ifaces;
std::ranges::copy(networkInterfaces, ifaces.begin());
std::array<fs::path, 4> impls;
std::ranges::copy(networkImplementations, impls.begin());
cfg.GetInterfacesAndImplementations(ifaces, impls);
}
auto addTest = [&](std::string name, fs::path implFile) {
Test t;
t.config.path = "./";
t.config.name = std::move(name);
t.config.outputName = t.config.name;
t.config.target = cfg.target;
t.config.debug = cfg.debug;
t.config.march = cfg.march;
t.config.mtune = cfg.mtune;
t.config.type = ConfigurationType::Executable;
t.config.dependencies = { thread };
std::array<fs::path, 6> ifaces;
std::ranges::copy(networkInterfaces, ifaces.begin());
std::array<fs::path, 5> impls;
std::ranges::copy(networkImplementations, impls.begin());
impls[4] = std::move(implFile);
t.config.GetInterfacesAndImplementations(ifaces, impls);
cfg.tests.push_back(std::move(t));
};
addTest("ShouldCompile", "tests/ShouldCompile");
addTest("ShouldRecieveHTTP", "tests/ShouldRecieveHTTP");
addTest("ShouldSendHTTP", "tests/ShouldSendHTTP");
addTest("ShouldSendRecieveHTTP", "tests/ShouldSendRecieveHTTP");
addTest("ShouldSendRecieveKeepaliveHTTP", "tests/ShouldSendRecieveKeepaliveHTTP");
addTest("ShouldSendRecieveLargeHTTP", "tests/ShouldSendRecieveLargeHTTP");
return cfg;
}

99
project.json
View file

@ -1,99 +0,0 @@
{
"name": "crafter-network",
"configurations": [
{
"name": "base",
"interfaces": ["interfaces/Crafter.Network-ClientTCP", "interfaces/Crafter.Network-ListenerTCP", "interfaces/Crafter.Network", "interfaces/Crafter.Network-ListenerHTTP", "interfaces/Crafter.Network-ClientHTTP", "interfaces/Crafter.Network-HTTP"],
"implementations": ["implementations/Crafter.Network-ClientTCP", "implementations/Crafter.Network-ListenerTCP", "implementations/Crafter.Network-ListenerHTTP", "implementations/Crafter.Network-ClientHTTP"]
},
{
"name": "lib",
"extends": ["base"],
"type":"library",
"dependencies": [
{
"path":"https://forgejo.catcrafts.net/Catcrafts/Crafter.Thread.git",
"configuration":"lib"
}
]
},
{
"name": "lib-debug",
"extends": ["lib"],
"debug": true
},
{
"name": "lib-shared",
"extends": ["base"],
"type":"shared-library",
"dependencies": [
{
"path":"https://forgejo.catcrafts.net/Catcrafts/Crafter.Thread.git",
"configuration":"lib-shared"
}
]
}
],
"tests":[
{
"name": "should-compile",
"implementations": ["tests/ShouldCompile"],
"dependencies": [
{
"path":"./project.json",
"configuration":"lib-shared"
}
]
},
{
"name": "should-recieve-http",
"implementations": ["tests/ShouldRecieveHTTP"],
"dependencies": [
{
"path":"./project.json",
"configuration":"lib-shared"
}
]
},
{
"name": "should-send-http",
"implementations": ["tests/ShouldSendHTTP"],
"dependencies": [
{
"path":"./project.json",
"configuration":"lib-shared"
}
]
},
{
"name": "should-send-recieve-http",
"implementations": ["tests/ShouldSendRecieveHTTP"],
"dependencies": [
{
"path":"./project.json",
"configuration":"lib-shared"
}
]
},
{
"name": "should-send-recieve-keepalive-http",
"implementations": ["tests/ShouldSendRecieveKeepaliveHTTP"],
"dependencies": [
{
"path":"./project.json",
"configuration":"lib-shared"
}
]
},
{
"name": "should-send-recieve-large-http",
"implementations": ["tests/ShouldSendRecieveLargeHTTP"],
"dependencies": [
{
"path":"./project.json",
"configuration":"lib-shared"
}
]
}
]
}

8
tests/ShouldCompile.cpp
View file

@ -1,6 +1,6 @@
/* /*
Crafter® Build Crafter® Build
Copyright (C) 2025 Catcrafts® Copyright (C) 2026 Catcrafts®
Catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
@ -20,10 +20,8 @@ import Crafter.Network;
import std; import std;
using namespace Crafter; using namespace Crafter;
extern "C" { int main() {
std::string* RunTest() { return 0;
return nullptr;
}
} }

35
tests/ShouldRecieveHTTP.cpp
View file

@ -1,6 +1,6 @@
/* /*
Crafter® Build Crafter® Build
Copyright (C) 2025 Catcrafts® Copyright (C) 2026 Catcrafts®
Catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
@ -22,23 +22,22 @@ import Crafter.Network;
import std; import std;
using namespace Crafter; using namespace Crafter;
extern "C" { int main() {
std::string* RunTest() { bool success = false;
bool success = false; ListenerAsyncHTTP listener(8081, {{"/", [&](const HTTPRequest& request) {
ListenerAsyncHTTP listener(8080, {{"/", [&](const HTTPRequest& request) { success = true;
success = true; return CreateResponseHTTP("200 OK", "Hello World!");
return CreateResponseHTTP("200 OK", "Hello World!"); }}});
}}}); try {
try { system("curl http://localhost:8081 > /dev/null 2>&1");
system("curl http://localhost:8080 > /dev/null 2>&1"); std::this_thread::sleep_for(std::chrono::seconds(1));
std::this_thread::sleep_for(std::chrono::seconds(1)); if (success) {
if (success) { return 0;
return nullptr;
} else {
return new std::string("Did not receive");
}
} catch(std::exception& e) {
return new std::string(e.what());
} }
std::println("Did not receive");
return 1;
} catch (std::exception& e) {
std::println("{}", e.what());
return 1;
} }
} }

18
tests/ShouldSendHTTP.cpp
View file

@ -1,6 +1,6 @@
/* /*
Crafter® Build Crafter® Build
Copyright (C) 2025 Catcrafts® Copyright (C) 2026 Catcrafts®
Catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
@ -20,14 +20,12 @@ import Crafter.Network;
import std; import std;
using namespace Crafter; using namespace Crafter;
extern "C" { int main() {
std::string* RunTest() { ClientHTTP client("httpbin.org", 80);
ClientHTTP client("httpbin.org", 80); HTTPResponse response = client.Send(CreateRequestHTTP("GET", "/get", "httpbin.org"));
HTTPResponse response = client.Send(CreateRequestHTTP("GET", "/get", "httpbin.org")); if (response.status == "200 OK") {
if(response.status == "200 OK") { return 0;
return nullptr;
} else {
return new std::string(response.body);
}
} }
std::println("{}", response.body);
return 1;
} }

32
tests/ShouldSendRecieveHTTP.cpp
View file

@ -1,6 +1,6 @@
/* /*
Crafter® Build Crafter® Build
Copyright (C) 2025 Catcrafts® Copyright (C) 2026 Catcrafts®
Catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
@ -22,22 +22,20 @@ import Crafter.Network;
import std; import std;
using namespace Crafter; using namespace Crafter;
extern "C" { int main() {
std::string* RunTest() { ListenerAsyncHTTP listener(8082, {{"/", [&](const HTTPRequest& request) {
bool success = false; return CreateResponseHTTP("200 OK", "Hello World!");
ListenerAsyncHTTP listener(8080, {{"/", [&](const HTTPRequest& request) { }}});
return CreateResponseHTTP("200 OK", "Hello World!"); try {
}}}); ClientHTTP client("localhost", 8082);
try { HTTPResponse response = client.Send(CreateRequestHTTP("GET", "/", "localhost"));
ClientHTTP client("localhost", 8080); if (response.status == "200 OK" && response.body == "Hello World!") {
HTTPResponse response = client.Send(CreateRequestHTTP("GET", "/", "localhost")); return 0;
if(response.status == "200 OK" && response.body == "Hello World!") {
return nullptr;
} else {
return new std::string(response.status +response.body);
}
} catch(std::exception& e) {
return new std::string(e.what());
} }
std::println("{}{}", response.status, response.body);
return 1;
} catch (std::exception& e) {
std::println("{}", e.what());
return 1;
} }
} }

45
tests/ShouldSendRecieveKeepaliveHTTP.cpp
View file

@ -1,6 +1,6 @@
/* /*
Crafter® Build Crafter® Build
Copyright (C) 2025 Catcrafts® Copyright (C) 2026 Catcrafts®
Catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
@ -22,28 +22,27 @@ import Crafter.Network;
import std; import std;
using namespace Crafter; using namespace Crafter;
extern "C" { int main() {
std::string* RunTest() { ListenerAsyncHTTP listener(8083, {{"/", [&](const HTTPRequest& request) {
ListenerAsyncHTTP listener(8080, {{"/", [&](const HTTPRequest& request) { return CreateResponseHTTP("200 OK", "Hello World!");
return CreateResponseHTTP("200 OK", "Hello World!"); }}});
}}}); try {
try { ClientHTTP client("localhost", 8083);
ClientHTTP client("localhost", 8080); HTTPResponse response = client.Send(CreateRequestHTTP("GET", "/", "localhost"));
HTTPResponse response = client.Send(CreateRequestHTTP("GET", "/", "localhost")); std::this_thread::sleep_for(std::chrono::seconds(1));
std::this_thread::sleep_for(std::chrono::seconds(1)); if (response.status != "200 OK" || response.body != "Hello World!") {
if(response.status == "200 OK" && response.body == "Hello World!") { std::println("{}{}", response.status, response.body);
response = client.Send(CreateRequestHTTP("GET", "/", "localhost")); return 1;
std::this_thread::sleep_for(std::chrono::seconds(1));
if(response.status == "200 OK" && response.body == "Hello World!") {
return nullptr;
} else {
return new std::string(response.status +response.body);
}
} else {
return new std::string(response.status +response.body);
}
} catch(std::exception& e) {
return new std::string(e.what());
} }
response = client.Send(CreateRequestHTTP("GET", "/", "localhost"));
std::this_thread::sleep_for(std::chrono::seconds(1));
if (response.status != "200 OK" || response.body != "Hello World!") {
std::println("{}{}", response.status, response.body);
return 1;
}
return 0;
} catch (std::exception& e) {
std::println("{}", e.what());
return 1;
} }
} }

43
tests/ShouldSendRecieveLargeHTTP.cpp
View file

@ -1,6 +1,6 @@
/* /*
Crafter® Build Crafter® Build
Copyright (C) 2025 Catcrafts® Copyright (C) 2026 Catcrafts®
Catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
@ -22,28 +22,27 @@ import Crafter.Network;
import std; import std;
using namespace Crafter; using namespace Crafter;
extern "C" { int main() {
std::string* RunTest() { ListenerAsyncHTTP listener(8084, {{ "/", [&](const HTTPRequest& request) {
ListenerAsyncHTTP listener(8080, {{ "/", [&](const HTTPRequest& request) { if (request.body.size() > 1'000'000) {
if (request.body.size() > 1'000'000) { return CreateResponseHTTP("200 OK", "Large request received: " + std::to_string(request.body.size()) + " bytes");
return CreateResponseHTTP("200 OK", "Large request received: " + std::to_string(request.body.size()) + " bytes");
}
return CreateResponseHTTP("200 OK", "Small request received");
} }
}}); return CreateResponseHTTP("200 OK", "Small request received");
try {
ClientHTTP client("localhost", 8080);
std::string large_body(10 * 1024 * 1024, 'A');
HTTPResponse response = client.Send(CreateRequestHTTP("POST", "/", "localhost", large_body));
std::this_thread::sleep_for(std::chrono::seconds(1));
if (response.status == "200 OK" && response.body.find("Large request received") != std::string::npos) {
return nullptr;
} else {
return new std::string("Unexpected response: " + response.status + " " + response.body);
}
} catch (const std::exception& e) {
return new std::string(e.what());
} }
}});
try {
ClientHTTP client("localhost", 8084);
std::string large_body(10 * 1024 * 1024, 'A');
HTTPResponse response = client.Send(CreateRequestHTTP("POST", "/", "localhost", large_body));
std::this_thread::sleep_for(std::chrono::seconds(1));
if (response.status == "200 OK" && response.body.find("Large request received") != std::string::npos) {
return 0;
}
std::println("Unexpected response: {} {}", response.status, response.body);
return 1;
} catch (const std::exception& e) {
std::println("{}", e.what());
return 1;
} }
} }