stdlib: Remove sio and aio. Bitrotted.

8 files changed, 1 insertions, 375 deletions

diff --git a/src/lib/aio.rs b/src/lib/aio.rs
deleted file mode 100644
index 81abac86e39..00000000000
--- a/src/lib/aio.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-import task;
-import vec;
-
-import comm;
-import comm::{chan, port, send, recv};
-import net;
-
-native "cdecl" mod rustrt {
-    type socket;
-    type server;
-    fn aio_init();
-    fn aio_run();
-    fn aio_stop();
-    fn aio_connect(host: *u8, port: int, connected: chan<socket>);
-    fn aio_serve(host: *u8, port: int, acceptChan: chan<socket>) -> server;
-    fn aio_writedata(s: socket, buf: *u8, size: uint, status: chan<bool>);
-    fn aio_read(s: socket, reader: chan<[u8]>);
-    fn aio_close_server(s: server, status: chan<bool>);
-    fn aio_close_socket(s: socket);
-    fn aio_is_null_client(s: socket) -> bool;
-}
-
-// FIXME: these should be unsafe pointers or something, but those aren't
-// currently in the sendable kind, so we'll unsafely cast between ints.
-type server = rustrt::server;
-type client = rustrt::socket;
-tag pending_connection { remote(net::ip_addr, int); incoming(server); }
-
-tag socket_event { connected(client); closed; received([u8]); }
-
-tag server_event { pending(chan<chan<socket_event>>); }
-
-tag request {
-    quit;
-    connect(pending_connection, chan<socket_event>);
-    serve(net::ip_addr, int, chan<server_event>, chan<server>);
-    write(client, [u8], chan<bool>);
-    close_server(server, chan<bool>);
-    close_client(client);
-}
-
-type ctx = chan<request>;
-
-fn ip_to_sbuf(ip: net::ip_addr) -> *u8 unsafe {
-
-    // FIXME: This is broken. We're creating a vector, getting a pointer
-    // to its buffer, then dropping the vector. On top of that, the vector
-    // created by str::bytes is not null-terminated.
-    vec::to_ptr(str::bytes(net::format_addr(ip)))
-}
-
-fn connect_task(args: (net::ip_addr, int, chan<socket_event>)) {
-    let (ip, portnum, evt) = args;
-    let connecter = port();
-    rustrt::aio_connect(ip_to_sbuf(ip), portnum, chan(connecter));
-    let client = recv(connecter);
-    new_client(client, evt);
-}
-
-fn new_client(client: client, evt: chan<socket_event>) {
-    // Start the read before notifying about the connect.  This avoids a race
-    // condition where the receiver can close the socket before we start
-    // reading.
-    let reader: port<[u8]> = port();
-    rustrt::aio_read(client, chan(reader));
-
-    send(evt, connected(client));
-
-    while true {
-        log "waiting for bytes";
-        let data: [u8] = recv(reader);
-        log "got some bytes";
-        log vec::len::<u8>(data);
-        if vec::len::<u8>(data) == 0u {
-            log "got empty buffer, bailing";
-            break;
-        }
-        log "got non-empty buffer, sending";
-        send(evt, received(data));
-        log "sent non-empty buffer";
-    }
-    log "done reading";
-    send(evt, closed);
-    log "close message sent";
-}
-
-fn accept_task(args: (client, chan<server_event>)) {
-    let (client, events) = args;
-    log "accept task was spawned";
-    let p = port();
-    send(events, pending(chan(p)));
-    let evt = recv(p);
-    new_client(client, evt);
-    log "done accepting";
-}
-
-fn server_task(args: (net::ip_addr, int, chan<server_event>,
-                       chan<server>)) {
-    let (ip, portnum, events, server) = args;
-    let accepter = port();
-    send(server, rustrt::aio_serve(ip_to_sbuf(ip), portnum, chan(accepter)));
-
-    let client: client;
-    while true {
-        log "preparing to accept a client";
-        client = recv(accepter);
-        if rustrt::aio_is_null_client(client) {
-            log "client was actually null, returning";
-            ret;
-        } else { task::spawn((client, events), accept_task); }
-    }
-}
-
-fn request_task(c: chan<ctx>) {
-    // Create a port to accept IO requests on
-    let p = port();
-    // Hand of its channel to our spawner
-    send(c, chan(p));
-    log "uv run task spawned";
-    // Spin for requests
-    let req: request;
-    while true {
-        req = recv(p);
-        alt req {
-          quit. {
-            log "got quit message";
-            log "stopping libuv";
-            rustrt::aio_stop();
-            ret;
-          }
-          connect(remote(ip, portnum), client) {
-            task::spawn((ip, portnum, client), connect_task);
-          }
-          serve(ip, portnum, events, server) {
-            task::spawn((ip, portnum, events, server), server_task);
-          }
-          write(socket, v, status) unsafe {
-            rustrt::aio_writedata(socket, vec::unsafe::to_ptr::<u8>(v),
-                                  vec::len::<u8>(v), status);
-          }
-          close_server(server, status) {
-            log "closing server";
-            rustrt::aio_close_server(server, status);
-          }
-          close_client(client) {
-            log "closing client";
-            rustrt::aio_close_socket(client);
-          }
-        }
-    }
-}
-
-fn iotask(c: chan<ctx>) {
-    log "io task spawned";
-    // Initialize before accepting requests
-    rustrt::aio_init();
-
-    log "io task init";
-    // Spawn our request task
-    let reqtask = task::spawn_joinable(copy c, request_task);
-
-    log "uv run task init";
-    // Enter IO loop. This never returns until aio_stop is called.
-    rustrt::aio_run();
-    log "waiting for request task to finish";
-
-    task::join(reqtask);
-}
-
-fn new() -> ctx {
-    let p: port<ctx> = port();
-    task::spawn(chan(p), iotask);
-    ret recv(p);
-}
-
-// Local Variables:
-// mode: rust;
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
-// End:
diff --git a/src/lib/sio.rs b/src/lib/sio.rs
deleted file mode 100644
index fccf8b5c8fd..00000000000
--- a/src/lib/sio.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-import comm::{port, chan, send, recv};
-
-import net;
-
-type ctx = aio::ctx;
-type client = {ctx: ctx, client: aio::client, evt: port<aio::socket_event>};
-type server = {ctx: ctx, server: aio::server, evt: port<aio::server_event>};
-
-fn new() -> ctx { ret aio::new(); }
-
-fn destroy(ctx: ctx) { send(ctx, aio::quit); }
-
-fn make_socket(ctx: ctx, p: port<aio::socket_event>) -> client {
-    let evt: aio::socket_event = recv(p);
-    alt evt {
-      aio::connected(client) { ret {ctx: ctx, client: client, evt: p}; }
-      _ { fail "Could not connect to client"; }
-    }
-}
-
-fn connect_to(ctx: ctx, ip: net::ip_addr, portnum: int) -> client {
-    let p: port<aio::socket_event> = port();
-    send(ctx, aio::connect(aio::remote(ip, portnum), chan(p)));
-    ret make_socket(ctx, p);
-}
-
-fn read(c: client) -> [u8] {
-    alt recv(c.evt) {
-      aio::closed. { ret []; }
-      aio::received(buf) { ret buf; }
-    }
-}
-
-fn create_server(ctx: ctx, ip: net::ip_addr, portnum: int) -> server {
-    let evt: port<aio::server_event> = port();
-    let p: port<aio::server> = port();
-    send(ctx, aio::serve(ip, portnum, chan(evt), chan(p)));
-    let srv: aio::server = recv(p);
-    ret {ctx: ctx, server: srv, evt: evt};
-}
-
-fn accept_from(server: server) -> client {
-    let evt: aio::server_event = recv(server.evt);
-    alt evt {
-      aio::pending(callback) {
-        let p = port();
-        send(callback, chan(p));
-        ret make_socket(server.ctx, p);
-      }
-    }
-}
-
-fn write_data(c: client, data: [u8]) -> bool {
-    let p = port();
-    send(c.ctx, aio::write(c.client, data, chan(p)));
-    ret recv(p);
-}
-
-fn close_server(server: server) {
-    // TODO: make this unit once we learn to send those from native code
-    let p = port();
-    send(server.ctx, aio::close_server(server.server, chan(p)));
-    log "Waiting for close";
-    recv(p);
-    log "Got close";
-}
-
-fn close_client(client: client) {
-    send(client.ctx, aio::close_client(client.client));
-    let evt: aio::socket_event;
-    do  { evt = recv(client.evt); alt evt { aio::closed. { ret; } _ { } } }
-        while true
-}
-
-// Local Variables:
-// mode: rust;
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
-// End:
diff --git a/src/lib/std.rc b/src/lib/std.rc
index bc085c1803f..9207f1cfdc9 100644
--- a/src/lib/std.rc
+++ b/src/lib/std.rc
@@ -8,7 +8,7 @@
 
 
 export box, char, float, int, str, ptr, uint, u8, u32, u64, vec;
-export aio, comm, fs, io, net, run, sio, sys, task;
+export comm, fs, io, net, run, sys, task;
 export ctypes, either, option, result, util;
 export bitv, deque, fun_treemap, list, map, smallintmap, sort, treemap, ufind;
 export rope;
@@ -35,13 +35,11 @@ mod vec;
 
 // General io and system-services modules
 
-mod aio;
 mod comm;
 mod fs;
 mod io;
 mod net;
 mod run = "run_program.rs";
-mod sio;
 mod sys;
 mod task;
 
diff --git a/src/test/run-pass/sio-client.rs b/src/test/run-pass/sio-client.rs
deleted file mode 100644
index 14e5e2e44cf..00000000000
--- a/src/test/run-pass/sio-client.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// xfail-test
-use std;
-import std::sio;
-import std::task;
-import std::net;
-
-fn connectTask(cx: sio::ctx, ip: net::ip_addr, portnum: int) {
-  let client: sio::client;
-  client = sio::connect_to(cx, ip, portnum);
-  sio::close_client(client);
-}
-
-fn main() {
-  let cx: sio::ctx = sio::new();
-  let srv: sio::server = sio::create_server(
-       cx, net::parse_addr("0.0.0.0"), 9090);
-  let child = task::_spawn(bind connectTask(cx,
-                                            net::parse_addr("127.0.0.1"),
-                                            9090));
-  let client: sio::client = sio::accept_from(srv);
-  task::join_id(child);
-  sio::close_client(client);
-  sio::close_server(srv);
-  sio::destroy(cx);
-}
-
diff --git a/src/test/run-pass/sio-ctx.rs b/src/test/run-pass/sio-ctx.rs
deleted file mode 100644
index ea3374e493f..00000000000
--- a/src/test/run-pass/sio-ctx.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Seems to hang for long periods, probably with RUST_THREADS > 1. Issue #810
-// xfail-test
-
-use std;
-import std::sio;
-
-fn main() {
-  let cx: sio::ctx = sio::new();
-  sio::destroy(cx);
-}
diff --git a/src/test/run-pass/sio-read.rs b/src/test/run-pass/sio-read.rs
deleted file mode 100644
index 0085f4983f2..00000000000
--- a/src/test/run-pass/sio-read.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-// xfail-test
-use std;
-import std::sio;
-import std::task;
-import std::str;
-import std::net;
-
-fn connectTask(cx: sio::ctx, ip: net::ip_addr, portnum: int) {
-  let client: sio::client;
-  client = sio::connect_to(cx, ip, portnum);
-  let data = sio::read(client);
-  sio::close_client(client);
-}
-
-fn main() {
-  let cx: sio::ctx = sio::new();
-  let srv: sio::server = sio::create_server(
-          cx, net::parse_addr("0.0.0.0"), 9090);
-  let child = task::_spawn(bind connectTask(cx,
-                                            net::parse_addr("127.0.0.1"),
-                                            9090));
-  let client: sio::client = sio::accept_from(srv);
-  sio::write_data(client, str::bytes("hello, world\n"));
-  task::join_id(child);
-  sio::close_client(client);
-  sio::close_server(srv);
-  sio::destroy(cx);
-}
-
-
diff --git a/src/test/run-pass/sio-srv.rs b/src/test/run-pass/sio-srv.rs
deleted file mode 100644
index 1171971427e..00000000000
--- a/src/test/run-pass/sio-srv.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// xfail-test
-use std;
-import std::sio;
-import std::net;
-
-fn main() {
-  let cx: sio::ctx = sio::new();
-  let srv: sio::server = sio::create_server(cx,
-                                            net::parse_addr("127.0.0.1"),
-                                            9090);
-  sio::close_server(srv);
-  sio::destroy(cx);
-}
diff --git a/src/test/run-pass/sio-write.rs b/src/test/run-pass/sio-write.rs
deleted file mode 100644
index cc372bc916d..00000000000
--- a/src/test/run-pass/sio-write.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// xfail-test
-use std;
-import std::sio;
-import std::task;
-import std::str;
-import std::net;
-
-fn connectTask(cx: sio::ctx, ip: net::ip_addr, portnum: int) {
-  let client: sio::client;
-  client = sio::connect_to(cx, ip, portnum);
-  sio::close_client(client);
-}
-
-fn main() {
-  let cx: sio::ctx = sio::new();
-  let srv: sio::server = sio::create_server(cx, net::parse_addr("0.0.0.0"),
-                                            9090);
-  let child = task::_spawn(bind connectTask(cx, net::parse_addr("127.0.0.1"),
-                                            9090));
-  let client: sio::client = sio::accept_from(srv);
-  sio::write_data(client, str::bytes("hello, world\n"));
-  task::join_id(child);
-  sio::close_client(client);
-  sio::close_server(srv);
-  sio::destroy(cx);
-}
-
-