public TcpServer(IOLoop io_loop_=null, object ssl_options_=null) { io_loop = io_loop_; ssl_options = ssl_options_; _sockets = new Dictionary<int, Socket>(); // fd -> socket object _pending_sockets = new List<Socket>(); _started = false; // Verify the SSL options. Otherwise we don't get errors until clients // connect. This doesn't verify that the keys are legitimate, but // the SSL module doesn't do that until there is a connected socket // which seems like too much work if (ssl_options != null) { //todo /* Only certfile is required: it can contain both keys if 'certfile' not in self.ssl_options: raise KeyError('missing key "certfile" in ssl_options') if not os.path.exists(self.ssl_options['certfile']): raise ValueError('certfile "%s" does not exist' % self.ssl_options['certfile']) if ('keyfile' in self.ssl_options and not os.path.exists(self.ssl_options['keyfile'])): raise ValueError('keyfile "%s" does not exist' % self.ssl_options['keyfile'])*/ } }
public IOStream(Socket socket_, IOLoop io_loop_, int max_buffer_size_=104857600, int read_chunk_size_=4096) { socket = socket_; socket.Blocking = false; io_loop = io_loop_ ?? IOLoop.instance(); max_buffer_size = max_buffer_size_; read_chunk_size = read_chunk_size_; error = null; _read_buffer = new LinkedList<byte[]>(); // collections.deque(); _write_buffer = new LinkedList<byte[]>(); //collections.deque(); _read_buffer_size = 0; _write_buffer_frozen = false; _read_delimiter = null; _read_regex = null; _read_bytes = 0; _read_until_close = false; _read_callback = null; _streaming_callback = null; _write_callback = null; _close_callback = null; _connect_callback = null; _connecting = false; _state = 0; _pending_callbacks = 0; }
public void install() { /* Installs this IOloop object as the singleton instance. This is normally not necessary as `instance()` will create an IOLoop on demand, but you may want to call `install` to use a custom subclass of IOLoop. */ Debug.Assert(!initialized()); IOLoop._instance = this; }
public static IOLoop instance() { /*Returns a global IOLoop instance. Most single-threaded applications have a single, global IOLoop. Use this method instead of passing around IOLoop instances throughout your code. A common pattern for classes that depend on IOLoops is to use a default argument to enable programs with multiple IOLoops but not require the argument for simpler applications:: class MyClass(object): def __init__(self, io_loop=None): self.io_loop = io_loop or IOLoop.instance() */ if(_instance == null) _instance = new IOLoop(); return _instance; }
public HTTPServer(Func<HTTPRequest, RequestHandler> request_callback_, bool no_keep_alive_ = false, IOLoop io_loop_ = null, bool xheaders_ = false, object ssl_options_ = null) : base(io_loop_, ssl_options_) { request_callback = request_callback_; no_keep_alive = no_keep_alive_; xheaders = xheaders_; }
public void add_accept_handler(Socket sock, Action<Socket, IPEndPoint> callback, IOLoop io_loop = null) { /*Adds an ``IOLoop`` event handler to accept new connections on ``sock``. When a connection is accepted, ``callback(connection, address)`` will be run (``connection`` is a socket object, and ``address`` is the address of the other end of the connection). Note that this signature is different from the ``callback(fd, events)`` signature used for ``IOLoop`` handlers. */ if (io_loop == null) io_loop = IOLoop.instance(); Action<int, int> accept_handler = (fd, events) => { while (true) { Socket connection = null; try { connection = sock.Accept(); } catch (SocketException ex) { if (ex.SocketErrorCode == SocketError.WouldBlock || ex.SocketErrorCode == SocketError.TryAgain) return; throw; } callback(connection, connection.RemoteEndPoint as IPEndPoint); } }; io_loop.add_handler(sock, sock.fileno(), accept_handler, IOLoop.READ); }
public void add_sockets(List<Socket> sockets) { /*Makes this server start accepting connections on the given sockets. The ``sockets`` parameter is a list of socket objects such as those returned by `bind_sockets`. `add_sockets` is typically used in combination with that method and `tornado.process.fork_processes` to provide greater control over the initialization of a multi-process server. */ if(io_loop == null) io_loop = IOLoop.instance(); foreach(var sock in sockets) { _sockets[sock.fileno()] = sock; add_accept_handler(sock, _handle_connection, io_loop); } }