mirror of https://github.com/adamdruppe/arsd.git
finally removing obsolete stuff
This commit is contained in:
Adam D. Ruppe
parent
16b84d2c2d
commit
53e7bbb89d
|
|
@ -1,6 +0,0 @@
|
|||
/**
|
||||
|
||||
*/
|
||||
module arsd.domconvenience;
|
||||
|
||||
// the contents of this file are back in dom.d for now. I might split them out later.
|
||||
311
obsolete/httpd.d
311
obsolete/httpd.d
|
|
@ -1,311 +0,0 @@
|
|||
// This thing sucks. It's primarily to prove that cgi.d *can* work
|
||||
// with an embedded http server without much difficulty, so you aren't
|
||||
// tied to CGI if you don't want to be, even if you have a huge codebase
|
||||
// built on cgi.d already.
|
||||
|
||||
// But this particular module is no where near ready for serious use.
|
||||
// (it does do reasonably well under controlled conditions though)
|
||||
|
||||
module arsd.httpd;
|
||||
|
||||
public import arsd.cgi;
|
||||
|
||||
import arsd.netman;
|
||||
|
||||
import std.range;
|
||||
|
||||
/*
|
||||
|
||||
import arsd.curl;
|
||||
void handler(Cgi cgi) {
|
||||
cgi.write("hello world!");
|
||||
cgi.close();
|
||||
}
|
||||
|
||||
void main() {
|
||||
serveHttp(&handler, 5000);
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
void serveHttp(CustomCgi)(void function(Cgi) requestHandler, ushort port) if(is(CustomCgi: Cgi)) {
|
||||
auto netman = new NetMan!(CustomCgi)(requestHandler);
|
||||
netman.listen(port);
|
||||
for(;;)
|
||||
try
|
||||
netman.proceed();
|
||||
catch(ConnectionException e)
|
||||
e.c.disconnectNow();
|
||||
catch(Exception e)
|
||||
writefln("Exception: %s", e.toString());
|
||||
}
|
||||
|
||||
class NetMan(CustomCgi) : NetworkManager /*if(is(CustomCgi : Cgi))*/ {
|
||||
void function(Cgi) requestHandler;
|
||||
|
||||
this(void function(Cgi) requestHandler) {
|
||||
this.requestHandler = requestHandler;
|
||||
}
|
||||
|
||||
override Connection allocConnection(int port) {
|
||||
return new HttpdConnection!CustomCgi(requestHandler);
|
||||
}
|
||||
}
|
||||
|
||||
class HttpdConnection(CustomCgi) : Connection /* if(is(CustomCgi : Cgi)) */ {
|
||||
// The way this rolls is to get the whole thing in memory, then pass it off to Cgi to do the rest
|
||||
|
||||
this(void function(Cgi) requestHandler) {
|
||||
handler = requestHandler;
|
||||
}
|
||||
|
||||
void function(Cgi) handler;
|
||||
|
||||
int state;
|
||||
string[] headers;
|
||||
immutable(ubyte)[] data;
|
||||
int contentLength;
|
||||
bool chunked;
|
||||
int chunkSize = 0;
|
||||
string separator = "\r\n";
|
||||
bool closeConnection;
|
||||
|
||||
void log(in ubyte[] a) {
|
||||
data ~= a;
|
||||
}
|
||||
|
||||
void finishRequest() {
|
||||
state = 0;
|
||||
separator = "\r\n";
|
||||
|
||||
// writeln("FINISHED");
|
||||
|
||||
scope(exit) {
|
||||
if(closeConnection)
|
||||
disconnect();
|
||||
closeConnection = false;
|
||||
}
|
||||
|
||||
Cgi cgi;
|
||||
|
||||
try {
|
||||
cgi = new CustomCgi(headers, data, peerAddress(),
|
||||
cast(void delegate(const(ubyte)[])) &this.write, 0, &this.flush);
|
||||
} catch(Throwable t) {
|
||||
write("HTTP/1.1 400 Bad Request\r\n");
|
||||
write("Content-Type: text/plain\r\n");
|
||||
string s = t.toString();
|
||||
write("Content-Length: "~to!string(s.length)~"\r\n");
|
||||
write("Connection: close\r\n");
|
||||
write("\r\n");
|
||||
write(s);
|
||||
|
||||
closeConnection = true;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
scope(exit) {
|
||||
cgi.close();
|
||||
cgi.dispose();
|
||||
}
|
||||
|
||||
try {
|
||||
handler(cgi);
|
||||
} catch(Throwable e) {
|
||||
cgi.setResponseStatus("500 Internal Server Error");
|
||||
cgi.write(e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
override void onDataReceived(){
|
||||
auto a = read();
|
||||
|
||||
// writeln("data received ", state, "\n", cast(string) a);
|
||||
|
||||
more:
|
||||
switch(state) {
|
||||
default: assert(0);
|
||||
case 0: // reading the headers
|
||||
// while it's supposed to be \r\n, we want
|
||||
// to be permissive here to avoid hanging if
|
||||
// the wrong thing comes.
|
||||
try_again:
|
||||
int l = locationOf(a, separator ~ separator);
|
||||
if(l == -1) {
|
||||
if(separator.length > 1) {
|
||||
separator = "\n";
|
||||
goto try_again;
|
||||
} else {
|
||||
separator = "\r\n";
|
||||
}
|
||||
|
||||
return; // not enough data
|
||||
}
|
||||
changeReadPosition(l+separator.length * 2); // we're now at the beginning of the data
|
||||
|
||||
data.length = 0;
|
||||
contentLength = 0;
|
||||
|
||||
string hdrs = cast(string) a[0..l].idup;
|
||||
a = read(); // advance ourselves
|
||||
headers = hdrs.split(separator);
|
||||
|
||||
chunked = false;
|
||||
|
||||
if(headers.length == 0) {
|
||||
disconnect();
|
||||
return;
|
||||
}
|
||||
|
||||
if(headers[0].indexOf("HTTP/1.0") != -1)
|
||||
closeConnection = true; // always one request per connection with 1.0
|
||||
|
||||
foreach(ref h; headers[1..$]) {
|
||||
int colon = h.indexOf(":");
|
||||
if(colon == -1)
|
||||
throw new Exception("Http headers need colons");
|
||||
string name = h[0..colon].tolower;
|
||||
string value = h[colon+2..$]; // FIXME?
|
||||
|
||||
switch(name) {
|
||||
case "transfer-encoding":
|
||||
if(value == "chunked")
|
||||
chunked = true;
|
||||
break;
|
||||
case "content-length":
|
||||
contentLength = to!int(value);
|
||||
break;
|
||||
case "connection":
|
||||
if(value == "close")
|
||||
closeConnection = true;
|
||||
break;
|
||||
default:
|
||||
// leave it unmolested for passthrough
|
||||
}
|
||||
}
|
||||
|
||||
// forward the header and advance our state
|
||||
state = 1;
|
||||
// break; // fall through to read some more data if we have any
|
||||
case 1: // reading Content-Length type data
|
||||
// We need to read up the data we have, and write it out as a chunk.
|
||||
if(!chunked) {
|
||||
if(a.length <= contentLength) {
|
||||
log(a);
|
||||
contentLength -= a.length;
|
||||
resetRead();
|
||||
// we just finished it off, terminate the chunks
|
||||
if(contentLength == 0) {
|
||||
finishRequest();
|
||||
}
|
||||
} else {
|
||||
// we actually have *more* here than we need....
|
||||
log(a[0..contentLength]);
|
||||
contentLength = 0;
|
||||
finishRequest();
|
||||
|
||||
changeReadPosition(contentLength);
|
||||
a = read();
|
||||
// we're done
|
||||
goto more; // see if we can make use of the rest of the data
|
||||
}
|
||||
} else {
|
||||
// decode it, modify it, then reencode it
|
||||
// If here, we are at the beginning of a chunk.
|
||||
int loc = locationOf(a, "\r\n");
|
||||
if(loc == -1) {
|
||||
return; // don't have the length
|
||||
}
|
||||
|
||||
string hex;
|
||||
hex = "";
|
||||
for(int i = 0; i < loc; i++) {
|
||||
char c = a[i];
|
||||
if(c >= 'A' && c <= 'Z')
|
||||
c += 0x20;
|
||||
if((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z')) {
|
||||
hex ~= c;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
assert(hex.length);
|
||||
|
||||
int power = 1;
|
||||
int size = 0;
|
||||
foreach(cc1; retro(hex)) {
|
||||
dchar cc = cc1;
|
||||
if(cc >= 'a' && cc <= 'z')
|
||||
cc -= 0x20;
|
||||
int val = 0;
|
||||
if(cc >= '0' && cc <= '9')
|
||||
val = cc - '0';
|
||||
else
|
||||
val = cc - 'A' + 10;
|
||||
|
||||
size += power * val;
|
||||
power *= 16;
|
||||
}
|
||||
|
||||
chunkSize = size;
|
||||
assert(size >= 0);
|
||||
|
||||
if(loc + 2 > a.length) {
|
||||
return; // need more data
|
||||
}
|
||||
changeReadPosition(loc+2); // skips the chunk header
|
||||
a = read();
|
||||
|
||||
if(chunkSize == 0) { // we're done with the response
|
||||
state = 3;
|
||||
goto more;
|
||||
} else {
|
||||
state = 2;
|
||||
goto more;
|
||||
}
|
||||
|
||||
resetRead();
|
||||
}
|
||||
break;
|
||||
case 2: // reading a chunk
|
||||
// if we got here, will change must be true....
|
||||
if(a.length < chunkSize + 2) {
|
||||
return; // we want to handle the whole chunk at once
|
||||
}
|
||||
|
||||
log(a[0..chunkSize]);
|
||||
|
||||
state = 1;
|
||||
|
||||
if(a.length > chunkSize + 2) {
|
||||
assert(a[chunkSize] == 13);
|
||||
assert(a[chunkSize+1] == 10);
|
||||
changeReadPosition(chunkSize + 2); // skip the \r\n
|
||||
a = read();
|
||||
chunkSize = 0;
|
||||
state = 1;
|
||||
goto more;
|
||||
} else {
|
||||
chunkSize = 0;
|
||||
resetRead();
|
||||
}
|
||||
break;
|
||||
case 3: // reading footers
|
||||
// if we got here, will change must be true....
|
||||
int loc = locationOf(a, "\r\n");
|
||||
if(loc == -1) {
|
||||
return; // not done yet
|
||||
} else {
|
||||
assert(loc == 0);
|
||||
changeReadPosition(loc+2); // FIXME: should handle footers properly
|
||||
finishRequest();
|
||||
a = read();
|
||||
|
||||
goto more;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
module arsd.image;
|
||||
|
||||
/**
|
||||
This provides two image classes and a bunch of functions that work on them.
|
||||
|
||||
Why are they separate classes? I think the operations on the two of them
|
||||
are necessarily different. There's a whole bunch of operations that only
|
||||
really work on truecolor (blurs, gradients), and a few that only work
|
||||
on indexed images (palette swaps).
|
||||
|
||||
Even putpixel is pretty different. On indexed, it is a palette entry's
|
||||
index number. On truecolor, it is the actual color.
|
||||
|
||||
A greyscale image is the weird thing in the middle. It is truecolor, but
|
||||
fits in the same size as indexed. Still, I'd say it is a specialization
|
||||
of truecolor.
|
||||
|
||||
There is a subset that works on both
|
||||
|
||||
*/
|
||||
|
||||
// the basic image definitions have all been moved to the color module
|
||||
public import arsd.color;
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
/* this file is now obsolete, use png.d instead */
|
||||
module arsd.lazypng;
|
||||
static assert(0, "This file is now obsolete. Use png.d instead. The only difference on the user side is the old lazypng.writePng is now png.writePngLazy");
|
||||
|
|
@ -1,540 +0,0 @@
|
|||
// This is a little core I wrote a few years ago to write custom tcp servers
|
||||
// in D. It only works on Linux, doesn't care much for efficiency, and uses
|
||||
// select() to handle multiple connections in a single thread.
|
||||
|
||||
// It is my hope that someday soon, Phobos will get a network module that
|
||||
// can completely replace this. But, until that happens, this little thing
|
||||
// is better than nothing.
|
||||
|
||||
// See httpd.d for a (pretty bad) http server built on this, or rtud.d
|
||||
// for a real time update helper program that also uses it.
|
||||
|
||||
// If anyone is interested, I also have chat (including TOC protocol to be
|
||||
// a little AIM client) and minimal gui (version one of my D windowing system
|
||||
// idea... which is still on my todo list, but it's going to be aeons before
|
||||
// it's remotely usable at the rate I'm going) built on this module.
|
||||
|
||||
module arsd.netman;
|
||||
|
||||
version(linux):
|
||||
|
||||
import std.c.linux.linux;
|
||||
import std.c.linux.socket;
|
||||
|
||||
static import std.string;
|
||||
static import std.c.string;
|
||||
static import std.stdio;
|
||||
static import std.conv;
|
||||
|
||||
alias std.c.linux.socket sock;
|
||||
alias std.c.linux.linux linux;
|
||||
|
||||
enum int PF_INET = 2;
|
||||
enum int AF_INET = PF_INET;
|
||||
|
||||
|
||||
int max(int a, int b){ return a > b ? a : b; }
|
||||
|
||||
class ConnectionException : Exception {
|
||||
this(string message, Connection conn) {
|
||||
msg = message;
|
||||
c = conn;
|
||||
super(message);
|
||||
}
|
||||
|
||||
string msg;
|
||||
public:
|
||||
Connection c;
|
||||
override string toString() {
|
||||
return msg;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
class NetworkManager {
|
||||
// you might want to override this to construct subclasses of connection
|
||||
protected:
|
||||
Connection allocConnection(int port) {
|
||||
if(auto a = port in allocs)
|
||||
return (*a)();
|
||||
assert(0);
|
||||
}
|
||||
Connection allocOutgoingConnection(int port){
|
||||
if(auto a = port in allocs)
|
||||
return (*a)();
|
||||
return new Connection();
|
||||
assert(0);
|
||||
}
|
||||
|
||||
|
||||
public:
|
||||
// void openSerialPort();
|
||||
this() {
|
||||
if(!handledSignal) {
|
||||
handledSignal = true;
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
}
|
||||
}
|
||||
static bool handledSignal = false;
|
||||
|
||||
void setConnectionSpawner(int port, Connection delegate() c) {
|
||||
assert(c !is null);
|
||||
allocs[port] = c;
|
||||
}
|
||||
|
||||
void setConnectionSpawner(int port, Connection function() c) {
|
||||
setConnectionSpawner(port, { return c(); });
|
||||
}
|
||||
|
||||
|
||||
size_t numActiveConnections(){
|
||||
return connections.length;
|
||||
}
|
||||
|
||||
Connection connect(string ipaddr, ushort port){
|
||||
Connection c = allocOutgoingConnection(port);
|
||||
|
||||
c.parentManager = this;
|
||||
|
||||
hostent* h;
|
||||
sockaddr_in addr;
|
||||
|
||||
h = gethostbyname(std.string.toStringz(ipaddr));
|
||||
if(h is null)
|
||||
throw new Exception("gethostbyname");
|
||||
|
||||
int s = socket(PF_INET, SOCK_STREAM, 0);
|
||||
if(s == -1)
|
||||
throw new Exception("socket");
|
||||
|
||||
scope(failure)
|
||||
close(s);
|
||||
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_port = htons(port);
|
||||
std.c.string.memcpy(&addr.sin_addr.s_addr, h.h_addr, h.h_length);
|
||||
|
||||
if(sock.connect(s, cast(sockaddr*) &addr, addr.sizeof) == -1)
|
||||
throw new Exception("connect");
|
||||
|
||||
addConnection(c, s, cast(sockaddr) addr, port);
|
||||
c.onConnect();
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
void openStdin() {
|
||||
Connection c = allocConnection(0);
|
||||
|
||||
c.parentManager = this;
|
||||
|
||||
sockaddr addr;
|
||||
|
||||
addConnection(c, 0, addr, 0);
|
||||
}
|
||||
|
||||
|
||||
void listen(ushort port, int queue = 4){
|
||||
int s = socket(PF_INET, SOCK_STREAM, 0);
|
||||
if(s == -1)
|
||||
throw new Exception("socket");
|
||||
scope(failure)
|
||||
close(s);
|
||||
|
||||
sockaddr_in addr;
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_port = htons(port);
|
||||
addr.sin_addr.s_addr = INADDR_ANY;
|
||||
|
||||
// HACKISH
|
||||
int on = 1;
|
||||
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, on.sizeof);
|
||||
// end hack
|
||||
|
||||
|
||||
if(bind(s, cast(sockaddr*) &addr, addr.sizeof) == -1)
|
||||
throw new Exception("bind");
|
||||
|
||||
if(sock.listen(s, queue) == -1)
|
||||
throw new Exception("listen");
|
||||
|
||||
listenings.length = listenings.length + 1;
|
||||
|
||||
listenings[$-1].s = s;
|
||||
listenings[$-1].port = port;
|
||||
}
|
||||
|
||||
/// returns true if stuff happened, false if timed out
|
||||
/// timeout of 0 means wait forever - set it to -1 if you want it to return immediately
|
||||
bool proceed(int timeout = 0){
|
||||
//events to handle: data ready to read, timeout, new connection, connection error
|
||||
// stuff to do: write data
|
||||
|
||||
try_again:
|
||||
|
||||
fd_set rdfs;
|
||||
fd_set writefs;
|
||||
timeval tv;
|
||||
|
||||
FD_ZERO(&rdfs);
|
||||
FD_ZERO(&writefs);
|
||||
|
||||
int biggest = -1;
|
||||
|
||||
foreach(connection; connections){
|
||||
if(connection.socket == -1)
|
||||
continue;
|
||||
if(connection.writeBufferLength > 0)
|
||||
FD_SET(connection.socket, &writefs);
|
||||
|
||||
FD_SET(connection.socket, &rdfs);
|
||||
biggest = max(biggest, connection.socket);
|
||||
}
|
||||
|
||||
foreach(c; listenings){
|
||||
FD_SET(c.s, &rdfs);
|
||||
biggest = max(biggest, c.s);
|
||||
}
|
||||
|
||||
|
||||
if(timeout == -1)
|
||||
tv.tv_sec = 0;
|
||||
else
|
||||
tv.tv_sec = timeout;
|
||||
tv.tv_usec = 0;
|
||||
|
||||
int ret;
|
||||
if(timeout == 0)
|
||||
ret = linux.select(biggest + 1, &rdfs, &writefs, null, null);
|
||||
else
|
||||
ret = linux.select(biggest + 1, &rdfs, &writefs, null, &tv);
|
||||
|
||||
if(ret == -1) {
|
||||
import core.stdc.errno;
|
||||
import std.conv;
|
||||
if(errno == 4) // interrupted by signal
|
||||
goto try_again;
|
||||
else
|
||||
throw new Exception("select " ~ to!string(errno));
|
||||
}
|
||||
|
||||
if(ret) {
|
||||
// data ready somewhere
|
||||
|
||||
|
||||
foreach(connection; connections){
|
||||
if(connection.socket == -1)
|
||||
continue;
|
||||
if(connection.writeBufferLength > 0)
|
||||
if(FD_ISSET(connection.socket, &writefs)){
|
||||
auto b = connection.writeBuffer[connection.writeBufferPosition..(connection.writeBufferPosition+connection.writeBufferLength)];
|
||||
//auto num = send(connection.socket, b.ptr, b.length, 0);
|
||||
auto num = write(connection.socket, b.ptr, b.length);
|
||||
if(num < 0)
|
||||
throw new ConnectionException("send", connection);
|
||||
|
||||
connection.writeBufferLength -= num;
|
||||
if(connection.writeBufferLength > 0)
|
||||
connection.writeBufferPosition += num;
|
||||
else
|
||||
connection.writeBufferPosition = 0;
|
||||
|
||||
connection.timeOfLastActivity = now;
|
||||
}
|
||||
if(FD_ISSET(connection.socket, &rdfs)){
|
||||
size_t s = connection.readBufferPosition + connection.readBufferLength;
|
||||
s += 1024;
|
||||
if(connection.readBuffer.length < s)
|
||||
connection.readBuffer.length = s;
|
||||
//auto size = recv(connection.socket, connection.readBuffer.ptr + connection.readBufferPosition + connection.readBufferLength, 1024, 0);
|
||||
//std.stdio.writefln("read buffer length: %s", connection.readBufferLength);
|
||||
auto size = read(connection.socket, connection.readBuffer.ptr + connection.readBufferPosition + connection.readBufferLength, 1024);
|
||||
if(size == 0){
|
||||
connection.disconnectQueued = true;
|
||||
connection.reason = "size == 0";
|
||||
}
|
||||
else if (size < 0)
|
||||
throw new ConnectionException("recv", connection);
|
||||
else {
|
||||
connection.readBufferLength += size;
|
||||
connection.onDataReceived();
|
||||
}
|
||||
|
||||
connection.timeOfLastActivity = now;
|
||||
}
|
||||
}
|
||||
|
||||
foreach(c; listenings){
|
||||
if(FD_ISSET(c.s, &rdfs)){
|
||||
uint i;
|
||||
sockaddr addr;
|
||||
i = addr.sizeof;
|
||||
int s = accept(c.s, &addr, &i);
|
||||
|
||||
if(s == -1)
|
||||
throw new Exception("accept");
|
||||
|
||||
version(threaded_connections) {
|
||||
auto con = allocConnection(c.port);
|
||||
con.socket = s;
|
||||
con.addr = addr;
|
||||
con.port = c.port;
|
||||
auto t = new ConnectionThread(con);
|
||||
t.start();
|
||||
} else {
|
||||
auto con = allocConnection(c.port);
|
||||
con.parentManager = this;
|
||||
addConnection(con, s, addr, c.port);
|
||||
con.onRemoteConnect();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// One last run through the connections to remove any stale ones...
|
||||
for(int a = 0; a < connections.length; a++) {
|
||||
if( /* HACK */ connections[a].socket != 0 && /* END HACK */
|
||||
connectionTimeOut && (now-connections[a].timeOfLastActivity) > connectionTimeOut){
|
||||
connections[a].disconnectQueued = true;
|
||||
connections[a].reason = "stale";
|
||||
}
|
||||
if(connections[a].disconnectQueued && connections[a].writeBufferLength == 0)
|
||||
connections[a].disconnectNow();
|
||||
|
||||
if(connections[a].socket == -1){
|
||||
for(int b = a; b < connections.length-1; b++)
|
||||
connections[b] = connections[b+1];
|
||||
connections.length = connections.length - 1;
|
||||
a--;
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
// timed out
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// FIXME: for some reason, this whole timeout thing doesn't actually work correctly.
|
||||
|
||||
int connectionTimeOut = 0;//152;
|
||||
|
||||
private:
|
||||
Connection delegate()[int] allocs;
|
||||
|
||||
void addConnection(Connection c, int s, sockaddr addr, int port){
|
||||
c.socket = s;
|
||||
c.addr = addr;
|
||||
c.port = port;
|
||||
|
||||
if(c.socket < 0)
|
||||
throw new Exception("don't add bad sockets");
|
||||
connections.length = connections.length + 1;
|
||||
connections[$-1] = c;
|
||||
}
|
||||
|
||||
struct ListeningSocket{
|
||||
int s;
|
||||
int port;
|
||||
}
|
||||
|
||||
ListeningSocket[] listenings;
|
||||
Connection[] connections;
|
||||
}
|
||||
|
||||
|
||||
// You should only ever construct these in the allocConnection delegate for the manager.
|
||||
// Otherwise it will probably crash/
|
||||
class Connection {
|
||||
public:
|
||||
|
||||
NetworkManager parentManager;
|
||||
|
||||
protected this(){ timeOfLastActivity = now; }
|
||||
|
||||
string reason;
|
||||
|
||||
~this(){
|
||||
disconnectNow(false);
|
||||
}
|
||||
|
||||
void disconnectNow(bool cod = true){
|
||||
if(socket >= 0){
|
||||
close(socket);
|
||||
socket = -1;
|
||||
if(cod)
|
||||
onDisconnect();
|
||||
}
|
||||
}
|
||||
|
||||
void disconnect() {
|
||||
disconnectQueued = true;
|
||||
}
|
||||
|
||||
// Writes the pending data to the socket now instead of waiting for the manager to proceed
|
||||
void flush(){
|
||||
if(writeBufferLength > 0) {
|
||||
auto b = writeBuffer[writeBufferPosition..(writeBufferPosition+writeBufferLength)];
|
||||
auto num = .write(socket, b.ptr, b.length);
|
||||
if(num < 0)
|
||||
throw new ConnectionException("send", this);
|
||||
|
||||
writeBufferLength -= num;
|
||||
if(writeBufferLength > 0)
|
||||
writeBufferPosition += num;
|
||||
else
|
||||
writeBufferPosition = 0;
|
||||
|
||||
timeOfLastActivity = now;
|
||||
fsync(socket);
|
||||
}
|
||||
}
|
||||
|
||||
// reads the requested amount now, blocking until you get it all.
|
||||
void fetch(int amount){
|
||||
|
||||
}
|
||||
|
||||
void write(const(void)[] data){
|
||||
if(socket < 0)
|
||||
throw new ConnectionException("cannot write to a closed connection", this);
|
||||
|
||||
size_t newEnd = writeBufferPosition + writeBufferLength + data.length;
|
||||
|
||||
if(newEnd >= writeBuffer.length)
|
||||
writeBuffer.length = newEnd;
|
||||
|
||||
writeBuffer[writeBufferLength..newEnd] = cast(const(ubyte)[]) data[0..$];
|
||||
|
||||
writeBufferLength += data.length;
|
||||
}
|
||||
|
||||
|
||||
const(ubyte)[] read(){
|
||||
if(socket < 0)
|
||||
return null;
|
||||
|
||||
auto d = readBuffer[readBufferPosition..(readBufferPosition + readBufferLength)];
|
||||
rofl = readBufferPosition;
|
||||
copter = readBufferLength;
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
private size_t rofl, copter;
|
||||
|
||||
void changeReadPosition(int p) {
|
||||
//assert(p <= copter);
|
||||
//std.stdio.writefln("%d from %d of %d", p, readBufferPosition, readBufferLength);
|
||||
readBufferLength = copter - p;
|
||||
readBufferPosition = rofl + p;
|
||||
//std.stdio.writefln("became %d of %d", readBufferPosition, readBufferLength);
|
||||
}
|
||||
|
||||
void resetRead(){
|
||||
readBufferLength = 0;
|
||||
readBufferPosition = 0;
|
||||
}
|
||||
|
||||
|
||||
// These events should be reimplemented by subclasses
|
||||
|
||||
void onDataReceived(){
|
||||
// read() the data and process it
|
||||
// then resetRead() to prepare for the next batch
|
||||
resetRead;
|
||||
}
|
||||
|
||||
// we just connected to someone
|
||||
void onConnect(){
|
||||
|
||||
}
|
||||
|
||||
// someone just connected to us
|
||||
void onRemoteConnect(){
|
||||
onConnect();
|
||||
}
|
||||
|
||||
void onDisconnect(){
|
||||
}
|
||||
|
||||
bool ready() {
|
||||
return socket != -1;
|
||||
}
|
||||
|
||||
string peerAddress() {
|
||||
if(addr.sa_family != 2)
|
||||
throw new ConnectionException("peerAddress not supported for this connection", this);
|
||||
|
||||
return std.conv.to!string(cast(const(ubyte)[]) addr.sa_data[2..6],
|
||||
"", ".", ""
|
||||
);
|
||||
|
||||
}
|
||||
/*
|
||||
ushort peerPort() {
|
||||
|
||||
}
|
||||
*/
|
||||
int fd() { return socket; }
|
||||
private:
|
||||
int socket = -1;
|
||||
|
||||
ubyte[] writeBuffer;
|
||||
ubyte[] readBuffer;
|
||||
|
||||
size_t writeBufferPosition;
|
||||
size_t writeBufferLength;
|
||||
|
||||
size_t readBufferPosition;
|
||||
size_t readBufferLength;
|
||||
|
||||
bool disconnectQueued;
|
||||
|
||||
sockaddr addr;
|
||||
int port;
|
||||
|
||||
int timeOfLastActivity;
|
||||
}
|
||||
|
||||
|
||||
import std.date;
|
||||
int now() {
|
||||
return cast(int) getUTCtime();
|
||||
}
|
||||
|
||||
|
||||
|
||||
version(threaded_connections) {
|
||||
import core.thread;
|
||||
import std.stdio : writeln;
|
||||
class ConnectionThread : Thread {
|
||||
Connection connection;
|
||||
this(Connection c) {
|
||||
connection = c;
|
||||
super(&run);
|
||||
}
|
||||
|
||||
void run() {
|
||||
scope(exit)
|
||||
connection.disconnectNow();
|
||||
auto manager = new NetworkManager();
|
||||
connection.parentManager = manager;
|
||||
manager.addConnection(connection, connection.socket, connection.addr, connection.port);
|
||||
bool breakNext = false;
|
||||
while(manager.proceed()) {
|
||||
if(breakNext)
|
||||
break;
|
||||
if(connection.disconnectQueued)
|
||||
if(connection.writeBufferLength)
|
||||
breakNext = true;
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
19
postgres.d
19
postgres.d
|
|
@ -14,8 +14,20 @@ import std.exception;
|
|||
//
|
||||
// SQL: `DEALLOCATE name` is how to dealloc a prepared statement.
|
||||
|
||||
/++
|
||||
The PostgreSql implementation of the [Database] interface.
|
||||
|
||||
You should construct this class, but then use it through the
|
||||
interface functions.
|
||||
|
||||
---
|
||||
auto db = new PostgreSql("dbname=name");
|
||||
foreach(row; db.query("SELECT id, data FROM table_name"))
|
||||
writeln(row[0], " = ", row[1]);
|
||||
---
|
||||
+/
|
||||
class PostgreSql : Database {
|
||||
// dbname = name is probably the most common connection string
|
||||
/// dbname = name is probably the most common connection string
|
||||
this(string connectionString) {
|
||||
conn = PQconnectdb(toStringz(connectionString));
|
||||
if(conn is null)
|
||||
|
|
@ -29,7 +41,7 @@ class PostgreSql : Database {
|
|||
PQfinish(conn);
|
||||
}
|
||||
|
||||
/*
|
||||
/**
|
||||
Prepared statement support
|
||||
|
||||
This will be added to the Database interface eventually in some form,
|
||||
|
|
@ -59,6 +71,7 @@ class PostgreSql : Database {
|
|||
|
||||
}
|
||||
|
||||
///
|
||||
override void startTransaction() {
|
||||
query("START TRANSACTION");
|
||||
}
|
||||
|
|
@ -85,6 +98,7 @@ class PostgreSql : Database {
|
|||
}
|
||||
|
||||
|
||||
///
|
||||
string error() {
|
||||
return copyCString(PQerrorMessage(conn));
|
||||
}
|
||||
|
|
@ -93,6 +107,7 @@ class PostgreSql : Database {
|
|||
PGconn* conn;
|
||||
}
|
||||
|
||||
///
|
||||
class PostgresResult : ResultSet {
|
||||
// name for associative array to result index
|
||||
int getFieldIndex(string field) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue