X-Git-Url: http://nitlanguage.org diff --git a/lib/libevent.nit b/lib/libevent.nit index 56ab0a2..2dfb046 100644 --- a/lib/libevent.nit +++ b/lib/libevent.nit @@ -67,6 +67,14 @@ in "C" `{ } #endif +#ifdef EventCallback_incr_ref + // Callback forwarded to 'EventCallback.callback' + static void signal_cb(evutil_socket_t fd, short events, void *data) + { + EventCallback handler = data; + EventCallback_callback(handler, events); + } +#endif `} # Structure to hold information and state for a Libevent dispatch loop. @@ -82,19 +90,58 @@ extern class NativeEventBase `{ struct event_base * `} # Has `self` been correctly initialized? fun is_valid: Bool do return not address_is_null + # Reinitialize the event base after a fork + # + # Some event mechanisms do not survive across fork. + # The event base needs to be reinitialized with the `reinit` method. + # + # Returns `true` if some events could not be re-added. + fun reinit: Bool `{ return event_reinit(self); `} + # Event dispatching loop # # This loop will run the event base until either there are no more added - # events, or until something calls `exit_loop`. + # events, or until something calls `loopexit`. fun dispatch `{ event_base_dispatch(self); `} # Exit the event loop # # TODO support timer - fun exit_loop `{ event_base_loopexit(self, NULL); `} + fun loopexit `{ event_base_loopexit(self, NULL); `} - # Destroy this instance - fun destroy `{ event_base_free(self); `} + redef fun free `{ event_base_free(self); `} +end + +# Event, libevent's basic unit of operation +extern class NativeEvent `{ struct event * `} + + # Add to the set of pending events + # + # TODO support timeout + fun add `{ event_add(self, NULL); `} + + # Remove from the set of monitored events + fun del `{ event_del(self); `} + + redef fun free `{ event_free(self); `} +end + +# Signal event +extern class NativeEvSignal + super NativeEvent + + new (base: NativeEventBase, signal: Int, handler: EventCallback) + import EventCallback.callback `{ + EventCallback_incr_ref(handler); + return evsignal_new(base, signal, signal_cb, handler); + `} +end + +# Receiver of event callbacks +interface EventCallback + + # Callback on an event + fun callback(events: Int) do end end # Spawned to manage a specific connection @@ -145,7 +192,7 @@ class Connection do var evbuffer = bev.input_buffer var len = evbuffer.length - var buf = new NativeString(len) + var buf = new CString(len) evbuffer.remove(buf, len) var str = buf.to_s_with_length(len) read_callback str @@ -163,7 +210,17 @@ class Connection fun event_callback(events: Int): Bool do if events & bev_event_error != 0 or events & bev_event_eof != 0 then - if events & bev_event_error != 0 then print_error "Error from bufferevent" + if events & bev_event_error != 0 then + var sock_err = evutil_socket_error + # Ignore some normal errors and print the others for debugging + if sock_err == 110 then + # Connection timed out (ETIMEDOUT) + else if sock_err == 104 then + # Connection reset by peer (ECONNRESET) + else + print_error "libevent error event: {evutil_socket_error_to_string(sock_err)} ({sock_err})" + end + end force_close return true end @@ -242,6 +299,18 @@ fun bev_event_timeout: Int `{ return BEV_EVENT_TIMEOUT; `} # connect operation finished. fun bev_event_connected: Int `{ return BEV_EVENT_CONNECTED; `} +# Global error code for the last socket operation on the calling thread +# +# Not idempotent on all platforms. +fun evutil_socket_error: Int `{ + return EVUTIL_SOCKET_ERROR(); +`} + +# Convert an error code from `evutil_socket_error` to a string +fun evutil_socket_error_to_string(error_code: Int): CString `{ + return evutil_socket_error_to_string(error_code); +`} + # --- # Options that can be specified when creating a `NativeBufferEvent` @@ -283,7 +352,7 @@ extern class NativeBufferEvent `{ struct bufferevent * `} # Set callbacks to `read_callback_native`, `write_callback` and `event_callback` of `conn` fun setcb(conn: Connection) import Connection.read_callback_native, - Connection.write_callback, Connection.event_callback, NativeString `{ + Connection.write_callback, Connection.event_callback, CString `{ Connection_incr_ref(conn); bufferevent_setcb(self, (bufferevent_data_cb)c_read_cb, @@ -292,7 +361,7 @@ extern class NativeBufferEvent `{ struct bufferevent * `} `} # Write `length` bytes of `line` - fun write(line: NativeString, length: Int): Int `{ + fun write(line: CString, length: Int): Int `{ return bufferevent_write(self, line, length); `} @@ -323,7 +392,7 @@ extern class NativeEvBuffer `{ struct evbuffer * `} fun length: Int `{ return evbuffer_get_length(self); `} # Read data from an evbuffer and drain the bytes read - fun remove(buffer: NativeString, len: Int) `{ + fun remove(buffer: CString, len: Int) `{ evbuffer_remove(self, buffer, len); `} end @@ -349,7 +418,7 @@ end # A listener acting on an interface and port, spawns `Connection` on new connections extern class ConnectionListener `{ struct evconnlistener * `} - private new bind_to(base: NativeEventBase, address: NativeString, port: Int, factory: ConnectionFactory) + private new bind_to(base: NativeEventBase, address: CString, port: Int, factory: ConnectionFactory) import ConnectionFactory.accept_connection, error_callback `{ struct sockaddr_in sin; @@ -384,16 +453,9 @@ extern class ConnectionListener `{ struct evconnlistener * `} # Callback method on listening error fun error_callback do - var cstr = socket_error - sys.stderr.write "libevent error: '{cstr}'" + var cstr = evutil_socket_error_to_string(evutil_socket_error) + print_error "libevent error: '{cstr}'" end - - # Error with sockets - fun socket_error: NativeString `{ - // TODO move to Nit and maybe NativeEventBase - int err = EVUTIL_SOCKET_ERROR(); - return evutil_socket_error_to_string(err); - `} end # Factory to listen on sockets and create new `Connection` @@ -411,7 +473,7 @@ class ConnectionFactory # Human representation of remote client address var addr_len = 46 # Longest possible IPv6 address + null byte - var addr_buf = new NativeString(addr_len) + var addr_buf = new CString(addr_len) addr_buf = addrin_to_address(addrin, addr_buf, addr_len) var addr = if addr_buf.address_is_null then "Unknown address" @@ -439,7 +501,7 @@ class ConnectionFactory end # Put string representation of source `address` into `buf` - private fun addrin_to_address(address: Pointer, buf: NativeString, buf_len: Int): NativeString `{ + private fun addrin_to_address(address: Pointer, buf: CString, buf_len: Int): CString `{ struct sockaddr *addrin = (struct sockaddr*)address; if (addrin->sa_family == AF_INET) { @@ -453,3 +515,24 @@ class ConnectionFactory return NULL; `} end + +# Enable some relatively expensive debugging checks that would normally be turned off +fun enable_debug_mode `{ event_enable_debug_mode(); `} + +# Use Windows builtin locking and thread ID functions +fun use_windows_threads: Bool `{ +#ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED + return evthread_use_windows_threads(); +#else + return -1; +#endif +`} + +# Use Pthreads locking and thread ID functions +fun use_pthreads: Bool `{ +#ifdef EVTHREAD_USE_PTHREADS_IMPLEMENTED + return evthread_use_pthreads(); +#else + return -1; +#endif +`}