public void Start()
{
// ioloop.AddHandler (Socket.Handle, HandleEvents, IOLoop.EPOLL_READ_EVENTS);
iowatcher = new IOWatcher (Socket.Handle, EventTypes.Read, ioloop.EventLoop, HandleIOEvents);
iowatcher.Start ();
}
public override void Connect(string host, int port, Action callback)
{
if (state != Socket.SocketState.Invalid)
throw new InvalidOperationException ("Socket already in use");
int error;
var fd = manos_socket_connect (host, port, out error);
if (fd < 0)
throw new Exception (String.Format ("An error occurred while trying to connect to {0}:{1} errno: {2}", host, port, error));
stream = new PlainSocketStream (this, new IntPtr (fd));
var connectWatcher = new IOWatcher (new IntPtr (fd), EventTypes.Write, Context.Loop, (watcher, revents) => {
watcher.Stop ();
watcher.Dispose ();
this.address = host;
this.port = port;
this.state = Socket.SocketState.Open;
callback ();
});
connectWatcher.Start ();
}
private static void StaticCallback(IntPtr loop, IntPtr watcher, EventTypes revents)
{
UnmanagedIOWatcher iow = (UnmanagedIOWatcher)Marshal.PtrToStructure(watcher, typeof(UnmanagedIOWatcher));
GCHandle gchandle = GCHandle.FromIntPtr(iow.data);
IOWatcher w = (IOWatcher)gchandle.Target;
w.callback(w.Loop, w, revents);
}
protected EventedStream(Context context, IntPtr handle)
: base(context)
{
if (handle == IntPtr.Zero)
throw new ArgumentException ("handle");
this.Handle = handle;
this.readWatcher = new IOWatcher (Handle, EventTypes.Read, Context.Loop, HandleReadReady);
this.writeWatcher = new IOWatcher (Handle, EventTypes.Write, Context.Loop, HandleWriteReady);
}
public IOStream(Socket socket, IOLoop ioloop)
{
this.socket = socket;
this.ioloop = ioloop;
ReadChunkSize = DefaultReadChunkSize;
socket.Blocking = false;
read_watcher = new IOWatcher (socket.Handle, EventTypes.Read, ioloop.EventLoop, HandleIORead);
write_watcher = new IOWatcher (socket.Handle, EventTypes.Write, ioloop.EventLoop, HandleIOWrite);
}
protected EventedStream(IOLoop loop, IntPtr handle)
{
if (loop == null)
throw new ArgumentNullException ("loop");
if (handle == IntPtr.Zero)
throw new ArgumentException ("handle");
this.Loop = loop;
this.Handle = handle;
this.readWatcher = new IOWatcher (Handle, EventTypes.Read, Loop.EVLoop, HandleReadReady);
this.writeWatcher = new IOWatcher (Handle, EventTypes.Write, Loop.EVLoop, HandleWriteReady);
}
public IOStream(Socket socket, IOLoop ioloop)
{
this.socket = socket;
this.ioloop = ioloop;
TimeOut = TimeSpan.FromMinutes (2);
Expires = DateTime.UtcNow + TimeOut;
socket.Blocking = false;
handle = IOWatcher.GetHandle (socket);
read_watcher = new IOWatcher (handle, EventTypes.Read, ioloop.EventLoop, HandleIOReadEvent);
write_watcher = new IOWatcher (handle, EventTypes.Write, ioloop.EventLoop, HandleIOWriteEvent);
}
public override void Connect(string host, int port)
{
int error;
fd = manos_socket_connect (host, port, out error);
if (fd < 0)
throw new Exception (String.Format ("An error occurred while trying to connect to {0}:{1} errno: {2}", host, port, error));
IOWatcher iowatcher = new IOWatcher (new IntPtr (fd), EventTypes.Write, (LibEvLoop)IOLoop.EventLoop, (l, w, r) => {
w.Stop ();
this.host = host;
this.port = port;
OnConnected ();
});
iowatcher.Start ();
}
public void Start()
{
iowatcher = new IOWatcher (Socket.Handle, EventTypes.Read, ioloop.EventLoop, HandleIOEvents);
iowatcher.Start ();
}
public void Listen( string host, int port )
{
int error;
fd = manos_dgram_socket_listen( host, port, out error );
if (fd < 0)
throw new Exception (String.Format ("An error occurred while trying to connect to {0}:{1} errno: {2}", host, port, error));
watcher = new IOWatcher( new IntPtr( fd ), EventTypes.Read, loop.EventLoop, (l, w, r) => onRead() );
watcher.Start();
}
public IOStream(Socket socket, IOLoop ioloop)
{
this.socket = socket;
this.ioloop = ioloop;
TimeOut = TimeSpan.FromMinutes (2);
Expires = DateTime.UtcNow + TimeOut;
ReadChunkSize = DefaultReadChunkSize;
socket.Blocking = false;
read_watcher = new IOWatcher (socket.Handle, EventTypes.Read, ioloop.EventLoop, HandleIORead);
write_watcher = new IOWatcher (socket.Handle, EventTypes.Write, ioloop.EventLoop, HandleIOWrite);
}
private void HandleIOWrite(Loop loop, IOWatcher watcher, int revents)
{
// write ready can still be raised after we are done writing.
if (send_file == null && write_data == null)
return;
if (send_file != null) {
HandleSendFile ();
return;
}
HandleWrite ();
}
private void HandleIORead(Loop loop, IOWatcher watcher, int revents)
{
try {
HandleRead ();
} catch (Exception e) {
Close ();
}
}
public override void Close()
{
base.Close ();
if (Handle != IntPtr.Zero) {
PauseReading ();
PauseWriting ();
readWatcher.Dispose ();
writeWatcher.Dispose ();
if (readTimeoutWatcher != null)
readTimeoutWatcher.Dispose ();
if (writeTimeoutWatcher != null)
writeTimeoutWatcher.Dispose ();
readWatcher = null;
writeWatcher = null;
readTimeoutWatcher = null;
writeTimeoutWatcher = null;
Handle = IntPtr.Zero;
}
}
private void HandleIOEvents(Loop loop, IOWatcher watcher, EventTypes revents)
{
while (true) {
Socket s = null;
try {
s = Socket.Accept ();
} catch (SocketException se) {
if (se.SocketErrorCode == SocketError.WouldBlock || se.SocketErrorCode == SocketError.TryAgain)
return;
throw se;
} catch {
throw;
}
IOStream iostream = new IOStream (s, IOLoop);
transactions.Add (HttpTransaction.BeginTransaction (this, iostream, s, callback));
}
}
void HandleReadReady(IOWatcher watcher, EventTypes revents)
{
if (readTimeoutContinuation == null) {
readTimeoutContinuation = DateTime.Now;
}
HandleRead ();
}
private void HandleIOReadEvent(Loop loop, IOWatcher watcher, EventTypes revents)
{
// Happens after a close
if (socket == null)
return;
Expires = DateTime.UtcNow + TimeOut;
HandleRead ();
}
private void HandleIOWrite(Loop loop, IOWatcher watcher, int revents)
{
HandleWrite ();
}
private void HandleIORead(Loop loop, IOWatcher watcher, int revents)
{
HandleRead ();
}
public void Connect(string host, int port)
{
socket = CreateSocket ();
socket.Connect (host, port);
IntPtr handle = IOWatcher.GetHandle (socket);
IOWatcher iowatcher = new IOWatcher (handle, EventTypes.Write, IOLoop.EventLoop, (l, w, r) => {
w.Stop ();
OnConnected ();
});
iowatcher.Start ();
}
private void HandleIOEvents(Loop loop, IOWatcher watcher, EventTypes revents)
{
while (true) {
Socket s = null;
try {
s = Socket.Accept ();
} catch (SocketException se) {
if (se.SocketErrorCode == SocketError.WouldBlock || se.SocketErrorCode == SocketError.TryAgain)
return;
Console.WriteLine ("Socket exception in Accept handler");
Console.WriteLine (se);
return;
} catch (Exception e) {
Console.WriteLine ("Exception in Accept handler");
Console.WriteLine (e);
return;
}
IOStream iostream = new IOStream (s, IOLoop);
transactions.Add (HttpTransaction.BeginTransaction (this, iostream, s, callback));
}
}
public void SetHandle(IntPtr handle)
{
if (this.handle != IntPtr.Zero && this.handle != handle)
Close ();
this.handle = handle;
read_watcher = new IOWatcher (handle, EventTypes.Read, ioloop.EventLoop, HandleIOReadEvent);
write_watcher = new IOWatcher (handle, EventTypes.Write, ioloop.EventLoop, HandleIOWriteEvent);
timeout_watcher = new TimerWatcher (TimeOut, TimeOut, ioloop.EventLoop, HandleTimeoutEvent);
timeout_watcher.Start ();
}
public void Start()
{
handle = IOWatcher.GetHandle (Socket);
iowatcher = new IOWatcher (handle, EventTypes.Read, ioloop.EventLoop, HandleIOEvents);
iowatcher.Start ();
}
private void HandleIOWriteEvent(Loop loop, IOWatcher watcher, EventTypes revents)
{
// Happens after a close
if (handle == IntPtr.Zero)
return;
Expires = DateTime.UtcNow + TimeOut;
HandleWrite ();
}
public virtual void Close()
{
if (handle == IntPtr.Zero)
return;
DisableReading ();
DisableWriting ();
read_watcher.Dispose ();
write_watcher.Dispose ();
timeout_watcher.Dispose ();
read_watcher = null;
write_watcher = null;
timeout_watcher = null;
handle = IntPtr.Zero;
foreach (IWriteOperation op in write_ops) {
op.Dispose ();
}
write_ops.Clear ();
if (Closed != null)
Closed (this, EventArgs.Empty);
Closed = null;
read_callback = null;
}
void HandleWriteReady(IOWatcher watcher, EventTypes revents)
{
if (writeTimeoutContinuation == null) {
writeTimeoutContinuation = DateTime.Now;
}
HandleWrite ();
}
