Edit File: asyncore.html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>17.6. asyncore — Asynchronous socket handler — Python 2.7.5 documentation</title> <link rel="stylesheet" href="../_static/default.css" type="text/css" /> <link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <script type="text/javascript"> var DOCUMENTATION_OPTIONS = { URL_ROOT: '../', VERSION: '2.7.5', COLLAPSE_INDEX: false, FILE_SUFFIX: '.html', HAS_SOURCE: true }; </script> <script type="text/javascript" src="../_static/jquery.js"></script> <script type="text/javascript" src="../_static/underscore.js"></script> <script type="text/javascript" src="../_static/doctools.js"></script> <script type="text/javascript" src="../_static/sidebar.js"></script> <link rel="search" type="application/opensearchdescription+xml" title="Search within Python 2.7.5 documentation" href="../_static/opensearch.xml"/> <link rel="author" title="About these documents" href="../about.html" /> <link rel="copyright" title="Copyright" href="../copyright.html" /> <link rel="top" title="Python 2.7.5 documentation" href="../index.html" /> <link rel="up" title="17. Interprocess Communication and Networking" href="ipc.html" /> <link rel="next" title="17.7. asynchat — Asynchronous socket command/response handler" href="asynchat.html" /> <link rel="prev" title="17.5. popen2 — Subprocesses with accessible I/O streams" href="popen2.html" /> <link rel="shortcut icon" type="image/png" href="../_static/py.png" /> <script type="text/javascript" src="../_static/copybutton.js"></script> </head> <body> <div class="related"> <h3>Navigation</h3> <ul> <li class="right" style="margin-right: 10px"> <a href="../genindex.html" title="General Index" accesskey="I">index</a></li> <li class="right" > <a href="../py-modindex.html" title="Python Module Index" >modules</a> |</li> <li class="right" > <a href="asynchat.html" title="17.7. asynchat — Asynchronous socket command/response handler" accesskey="N">next</a> |</li> <li class="right" > <a href="popen2.html" title="17.5. popen2 — Subprocesses with accessible I/O streams" accesskey="P">previous</a> |</li> <li><img src="../_static/py.png" alt="" style="vertical-align: middle; margin-top: -1px"/></li> <li><a href="http://www.python.org/">Python</a> »</li> <li> <a href="../index.html">Python 2.7.5 documentation</a> » </li> <li><a href="index.html" >The Python Standard Library</a> »</li> <li><a href="ipc.html" accesskey="U">17. Interprocess Communication and Networking</a> »</li> </ul> </div> <div class="document"> <div class="documentwrapper"> <div class="bodywrapper"> <div class="body"> <div class="section" id="module-asyncore"> <span id="asyncore-asynchronous-socket-handler"></span><h1>17.6. <a class="reference internal" href="#module-asyncore" title="asyncore: A base class for developing asynchronous socket handling services."><tt class="xref py py-mod docutils literal"><span class="pre">asyncore</span></tt></a> — Asynchronous socket handler<a class="headerlink" href="#module-asyncore" title="Permalink to this headline">¶</a></h1> <p><strong>Source code:</strong> <a class="reference external" href="http://hg.python.org/cpython/file/2.7/Lib/asyncore.py">Lib/asyncore.py</a></p> <hr class="docutils" /> <p>This module provides the basic infrastructure for writing asynchronous socket service clients and servers.</p> <p>There are only two ways to have a program on a single processor do “more than one thing at a time.” Multi-threaded programming is the simplest and most popular way to do it, but there is another very different technique, that lets you have nearly all the advantages of multi-threading, without actually using multiple threads. It’s really only practical if your program is largely I/O bound. If your program is processor bound, then pre-emptive scheduled threads are probably what you really need. Network servers are rarely processor bound, however.</p> <p>If your operating system supports the <tt class="xref c c-func docutils literal"><span class="pre">select()</span></tt> system call in its I/O library (and nearly all do), then you can use it to juggle multiple communication channels at once; doing other work while your I/O is taking place in the “background.” Although this strategy can seem strange and complex, especially at first, it is in many ways easier to understand and control than multi-threaded programming. The <a class="reference internal" href="#module-asyncore" title="asyncore: A base class for developing asynchronous socket handling services."><tt class="xref py py-mod docutils literal"><span class="pre">asyncore</span></tt></a> module solves many of the difficult problems for you, making the task of building sophisticated high-performance network servers and clients a snap. For “conversational” applications and protocols the companion <a class="reference internal" href="asynchat.html#module-asynchat" title="asynchat: Support for asynchronous command/response protocols."><tt class="xref py py-mod docutils literal"><span class="pre">asynchat</span></tt></a> module is invaluable.</p> <p>The basic idea behind both modules is to create one or more network <em>channels</em>, instances of class <a class="reference internal" href="#asyncore.dispatcher" title="asyncore.dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">asyncore.dispatcher</span></tt></a> and <a class="reference internal" href="asynchat.html#asynchat.async_chat" title="asynchat.async_chat"><tt class="xref py py-class docutils literal"><span class="pre">asynchat.async_chat</span></tt></a>. Creating the channels adds them to a global map, used by the <a class="reference internal" href="#asyncore.loop" title="asyncore.loop"><tt class="xref py py-func docutils literal"><span class="pre">loop()</span></tt></a> function if you do not provide it with your own <em>map</em>.</p> <p>Once the initial channel(s) is(are) created, calling the <a class="reference internal" href="#asyncore.loop" title="asyncore.loop"><tt class="xref py py-func docutils literal"><span class="pre">loop()</span></tt></a> function activates channel service, which continues until the last channel (including any that have been added to the map during asynchronous service) is closed.</p> <dl class="function"> <dt id="asyncore.loop"> <tt class="descclassname">asyncore.</tt><tt class="descname">loop</tt><big>(</big><span class="optional">[</span><em>timeout</em><span class="optional">[</span>, <em>use_poll</em><span class="optional">[</span>, <em>map</em><span class="optional">[</span>, <em>count</em><span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><span class="optional">]</span><big>)</big><a class="headerlink" href="#asyncore.loop" title="Permalink to this definition">¶</a></dt> <dd><p>Enter a polling loop that terminates after count passes or all open channels have been closed. All arguments are optional. The <em>count</em> parameter defaults to None, resulting in the loop terminating only when all channels have been closed. The <em>timeout</em> argument sets the timeout parameter for the appropriate <a class="reference internal" href="select.html#module-select" title="select: Wait for I/O completion on multiple streams."><tt class="xref py py-func docutils literal"><span class="pre">select()</span></tt></a> or <tt class="xref py py-func docutils literal"><span class="pre">poll()</span></tt> call, measured in seconds; the default is 30 seconds. The <em>use_poll</em> parameter, if true, indicates that <tt class="xref py py-func docutils literal"><span class="pre">poll()</span></tt> should be used in preference to <a class="reference internal" href="select.html#module-select" title="select: Wait for I/O completion on multiple streams."><tt class="xref py py-func docutils literal"><span class="pre">select()</span></tt></a> (the default is <tt class="docutils literal"><span class="pre">False</span></tt>).</p> <p>The <em>map</em> parameter is a dictionary whose items are the channels to watch. As channels are closed they are deleted from their map. If <em>map</em> is omitted, a global map is used. Channels (instances of <a class="reference internal" href="#asyncore.dispatcher" title="asyncore.dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">asyncore.dispatcher</span></tt></a>, <a class="reference internal" href="asynchat.html#asynchat.async_chat" title="asynchat.async_chat"><tt class="xref py py-class docutils literal"><span class="pre">asynchat.async_chat</span></tt></a> and subclasses thereof) can freely be mixed in the map.</p> </dd></dl> <dl class="class"> <dt id="asyncore.dispatcher"> <em class="property">class </em><tt class="descclassname">asyncore.</tt><tt class="descname">dispatcher</tt><a class="headerlink" href="#asyncore.dispatcher" title="Permalink to this definition">¶</a></dt> <dd><p>The <a class="reference internal" href="#asyncore.dispatcher" title="asyncore.dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">dispatcher</span></tt></a> class is a thin wrapper around a low-level socket object. To make it more useful, it has a few methods for event-handling which are called from the asynchronous loop. Otherwise, it can be treated as a normal non-blocking socket object.</p> <p>The firing of low-level events at certain times or in certain connection states tells the asynchronous loop that certain higher-level events have taken place. For example, if we have asked for a socket to connect to another host, we know that the connection has been made when the socket becomes writable for the first time (at this point you know that you may write to it with the expectation of success). The implied higher-level events are:</p> <table border="1" class="docutils"> <colgroup> <col width="35%" /> <col width="65%" /> </colgroup> <thead valign="bottom"> <tr class="row-odd"><th class="head">Event</th> <th class="head">Description</th> </tr> </thead> <tbody valign="top"> <tr class="row-even"><td><tt class="docutils literal"><span class="pre">handle_connect()</span></tt></td> <td>Implied by the first read or write event</td> </tr> <tr class="row-odd"><td><tt class="docutils literal"><span class="pre">handle_close()</span></tt></td> <td>Implied by a read event with no data available</td> </tr> <tr class="row-even"><td><tt class="docutils literal"><span class="pre">handle_accept()</span></tt></td> <td>Implied by a read event on a listening socket</td> </tr> </tbody> </table> <p>During asynchronous processing, each mapped channel’s <a class="reference internal" href="#asyncore.dispatcher.readable" title="asyncore.dispatcher.readable"><tt class="xref py py-meth docutils literal"><span class="pre">readable()</span></tt></a> and <a class="reference internal" href="#asyncore.dispatcher.writable" title="asyncore.dispatcher.writable"><tt class="xref py py-meth docutils literal"><span class="pre">writable()</span></tt></a> methods are used to determine whether the channel’s socket should be added to the list of channels <tt class="xref c c-func docutils literal"><span class="pre">select()</span></tt>ed or <tt class="xref c c-func docutils literal"><span class="pre">poll()</span></tt>ed for read and write events.</p> <p>Thus, the set of channel events is larger than the basic socket events. The full set of methods that can be overridden in your subclass follows:</p> <dl class="method"> <dt id="asyncore.dispatcher.handle_read"> <tt class="descname">handle_read</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.handle_read" title="Permalink to this definition">¶</a></dt> <dd><p>Called when the asynchronous loop detects that a <tt class="xref py py-meth docutils literal"><span class="pre">read()</span></tt> call on the channel’s socket will succeed.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.handle_write"> <tt class="descname">handle_write</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.handle_write" title="Permalink to this definition">¶</a></dt> <dd><p>Called when the asynchronous loop detects that a writable socket can be written. Often this method will implement the necessary buffering for performance. For example:</p> <div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">handle_write</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="n">sent</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">buffer</span><span class="p">)</span> <span class="bp">self</span><span class="o">.</span><span class="n">buffer</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">buffer</span><span class="p">[</span><span class="n">sent</span><span class="p">:]</span> </pre></div> </div> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.handle_expt"> <tt class="descname">handle_expt</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.handle_expt" title="Permalink to this definition">¶</a></dt> <dd><p>Called when there is out of band (OOB) data for a socket connection. This will almost never happen, as OOB is tenuously supported and rarely used.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.handle_connect"> <tt class="descname">handle_connect</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.handle_connect" title="Permalink to this definition">¶</a></dt> <dd><p>Called when the active opener’s socket actually makes a connection. Might send a “welcome” banner, or initiate a protocol negotiation with the remote endpoint, for example.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.handle_close"> <tt class="descname">handle_close</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.handle_close" title="Permalink to this definition">¶</a></dt> <dd><p>Called when the socket is closed.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.handle_error"> <tt class="descname">handle_error</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.handle_error" title="Permalink to this definition">¶</a></dt> <dd><p>Called when an exception is raised and not otherwise handled. The default version prints a condensed traceback.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.handle_accept"> <tt class="descname">handle_accept</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.handle_accept" title="Permalink to this definition">¶</a></dt> <dd><p>Called on listening channels (passive openers) when a connection can be established with a new remote endpoint that has issued a <a class="reference internal" href="#asyncore.dispatcher.connect" title="asyncore.dispatcher.connect"><tt class="xref py py-meth docutils literal"><span class="pre">connect()</span></tt></a> call for the local endpoint.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.readable"> <tt class="descname">readable</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.readable" title="Permalink to this definition">¶</a></dt> <dd><p>Called each time around the asynchronous loop to determine whether a channel’s socket should be added to the list on which read events can occur. The default method simply returns <tt class="docutils literal"><span class="pre">True</span></tt>, indicating that by default, all channels will be interested in read events.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.writable"> <tt class="descname">writable</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.writable" title="Permalink to this definition">¶</a></dt> <dd><p>Called each time around the asynchronous loop to determine whether a channel’s socket should be added to the list on which write events can occur. The default method simply returns <tt class="docutils literal"><span class="pre">True</span></tt>, indicating that by default, all channels will be interested in write events.</p> </dd></dl> <p>In addition, each channel delegates or extends many of the socket methods. Most of these are nearly identical to their socket partners.</p> <dl class="method"> <dt id="asyncore.dispatcher.create_socket"> <tt class="descname">create_socket</tt><big>(</big><em>family</em>, <em>type</em><big>)</big><a class="headerlink" href="#asyncore.dispatcher.create_socket" title="Permalink to this definition">¶</a></dt> <dd><p>This is identical to the creation of a normal socket, and will use the same options for creation. Refer to the <a class="reference internal" href="socket.html#module-socket" title="socket: Low-level networking interface."><tt class="xref py py-mod docutils literal"><span class="pre">socket</span></tt></a> documentation for information on creating sockets.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.connect"> <tt class="descname">connect</tt><big>(</big><em>address</em><big>)</big><a class="headerlink" href="#asyncore.dispatcher.connect" title="Permalink to this definition">¶</a></dt> <dd><p>As with the normal socket object, <em>address</em> is a tuple with the first element the host to connect to, and the second the port number.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.send"> <tt class="descname">send</tt><big>(</big><em>data</em><big>)</big><a class="headerlink" href="#asyncore.dispatcher.send" title="Permalink to this definition">¶</a></dt> <dd><p>Send <em>data</em> to the remote end-point of the socket.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.recv"> <tt class="descname">recv</tt><big>(</big><em>buffer_size</em><big>)</big><a class="headerlink" href="#asyncore.dispatcher.recv" title="Permalink to this definition">¶</a></dt> <dd><p>Read at most <em>buffer_size</em> bytes from the socket’s remote end-point. An empty string implies that the channel has been closed from the other end.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.listen"> <tt class="descname">listen</tt><big>(</big><em>backlog</em><big>)</big><a class="headerlink" href="#asyncore.dispatcher.listen" title="Permalink to this definition">¶</a></dt> <dd><p>Listen for connections made to the socket. The <em>backlog</em> argument specifies the maximum number of queued connections and should be at least 1; the maximum value is system-dependent (usually 5).</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.bind"> <tt class="descname">bind</tt><big>(</big><em>address</em><big>)</big><a class="headerlink" href="#asyncore.dispatcher.bind" title="Permalink to this definition">¶</a></dt> <dd><p>Bind the socket to <em>address</em>. The socket must not already be bound. (The format of <em>address</em> depends on the address family — refer to the <a class="reference internal" href="socket.html#module-socket" title="socket: Low-level networking interface."><tt class="xref py py-mod docutils literal"><span class="pre">socket</span></tt></a> documentation for more information.) To mark the socket as re-usable (setting the <tt class="xref py py-const docutils literal"><span class="pre">SO_REUSEADDR</span></tt> option), call the <a class="reference internal" href="#asyncore.dispatcher" title="asyncore.dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">dispatcher</span></tt></a> object’s <tt class="xref py py-meth docutils literal"><span class="pre">set_reuse_addr()</span></tt> method.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.accept"> <tt class="descname">accept</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.accept" title="Permalink to this definition">¶</a></dt> <dd><p>Accept a connection. The socket must be bound to an address and listening for connections. The return value can be either <tt class="docutils literal"><span class="pre">None</span></tt> or a pair <tt class="docutils literal"><span class="pre">(conn,</span> <span class="pre">address)</span></tt> where <em>conn</em> is a <em>new</em> socket object usable to send and receive data on the connection, and <em>address</em> is the address bound to the socket on the other end of the connection. When <tt class="docutils literal"><span class="pre">None</span></tt> is returned it means the connection didn’t take place, in which case the server should just ignore this event and keep listening for further incoming connections.</p> </dd></dl> <dl class="method"> <dt id="asyncore.dispatcher.close"> <tt class="descname">close</tt><big>(</big><big>)</big><a class="headerlink" href="#asyncore.dispatcher.close" title="Permalink to this definition">¶</a></dt> <dd><p>Close the socket. All future operations on the socket object will fail. The remote end-point will receive no more data (after queued data is flushed). Sockets are automatically closed when they are garbage-collected.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="asyncore.dispatcher_with_send"> <em class="property">class </em><tt class="descclassname">asyncore.</tt><tt class="descname">dispatcher_with_send</tt><a class="headerlink" href="#asyncore.dispatcher_with_send" title="Permalink to this definition">¶</a></dt> <dd><p>A <a class="reference internal" href="#asyncore.dispatcher" title="asyncore.dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">dispatcher</span></tt></a> subclass which adds simple buffered output capability, useful for simple clients. For more sophisticated usage use <a class="reference internal" href="asynchat.html#asynchat.async_chat" title="asynchat.async_chat"><tt class="xref py py-class docutils literal"><span class="pre">asynchat.async_chat</span></tt></a>.</p> </dd></dl> <dl class="class"> <dt id="asyncore.file_dispatcher"> <em class="property">class </em><tt class="descclassname">asyncore.</tt><tt class="descname">file_dispatcher</tt><a class="headerlink" href="#asyncore.file_dispatcher" title="Permalink to this definition">¶</a></dt> <dd><p>A file_dispatcher takes a file descriptor or file object along with an optional map argument and wraps it for use with the <tt class="xref c c-func docutils literal"><span class="pre">poll()</span></tt> or <tt class="xref c c-func docutils literal"><span class="pre">loop()</span></tt> functions. If provided a file object or anything with a <tt class="xref c c-func docutils literal"><span class="pre">fileno()</span></tt> method, that method will be called and passed to the <a class="reference internal" href="#asyncore.file_wrapper" title="asyncore.file_wrapper"><tt class="xref py py-class docutils literal"><span class="pre">file_wrapper</span></tt></a> constructor. Availability: UNIX.</p> </dd></dl> <dl class="class"> <dt id="asyncore.file_wrapper"> <em class="property">class </em><tt class="descclassname">asyncore.</tt><tt class="descname">file_wrapper</tt><a class="headerlink" href="#asyncore.file_wrapper" title="Permalink to this definition">¶</a></dt> <dd><p>A file_wrapper takes an integer file descriptor and calls <a class="reference internal" href="os.html#os.dup" title="os.dup"><tt class="xref py py-func docutils literal"><span class="pre">os.dup()</span></tt></a> to duplicate the handle so that the original handle may be closed independently of the file_wrapper. This class implements sufficient methods to emulate a socket for use by the <a class="reference internal" href="#asyncore.file_dispatcher" title="asyncore.file_dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">file_dispatcher</span></tt></a> class. Availability: UNIX.</p> </dd></dl> <div class="section" id="asyncore-example-basic-http-client"> <span id="asyncore-example-1"></span><h2>17.6.1. asyncore Example basic HTTP client<a class="headerlink" href="#asyncore-example-basic-http-client" title="Permalink to this headline">¶</a></h2> <p>Here is a very basic HTTP client that uses the <a class="reference internal" href="#asyncore.dispatcher" title="asyncore.dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">dispatcher</span></tt></a> class to implement its socket handling:</p> <div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">asyncore</span><span class="o">,</span> <span class="nn">socket</span> <span class="k">class</span> <span class="nc">HTTPClient</span><span class="p">(</span><span class="n">asyncore</span><span class="o">.</span><span class="n">dispatcher</span><span class="p">):</span> <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">host</span><span class="p">,</span> <span class="n">path</span><span class="p">):</span> <span class="n">asyncore</span><span class="o">.</span><span class="n">dispatcher</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="bp">self</span><span class="o">.</span><span class="n">create_socket</span><span class="p">(</span><span class="n">socket</span><span class="o">.</span><span class="n">AF_INET</span><span class="p">,</span> <span class="n">socket</span><span class="o">.</span><span class="n">SOCK_STREAM</span><span class="p">)</span> <span class="bp">self</span><span class="o">.</span><span class="n">connect</span><span class="p">(</span> <span class="p">(</span><span class="n">host</span><span class="p">,</span> <span class="mi">80</span><span class="p">)</span> <span class="p">)</span> <span class="bp">self</span><span class="o">.</span><span class="n">buffer</span> <span class="o">=</span> <span class="s">'GET </span><span class="si">%s</span><span class="s"> HTTP/1.0</span><span class="se">\r\n\r\n</span><span class="s">'</span> <span class="o">%</span> <span class="n">path</span> <span class="k">def</span> <span class="nf">handle_connect</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">pass</span> <span class="k">def</span> <span class="nf">handle_close</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="bp">self</span><span class="o">.</span><span class="n">close</span><span class="p">()</span> <span class="k">def</span> <span class="nf">handle_read</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">print</span> <span class="bp">self</span><span class="o">.</span><span class="n">recv</span><span class="p">(</span><span class="mi">8192</span><span class="p">)</span> <span class="k">def</span> <span class="nf">writable</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="k">return</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">buffer</span><span class="p">)</span> <span class="o">></span> <span class="mi">0</span><span class="p">)</span> <span class="k">def</span> <span class="nf">handle_write</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="n">sent</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">buffer</span><span class="p">)</span> <span class="bp">self</span><span class="o">.</span><span class="n">buffer</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">buffer</span><span class="p">[</span><span class="n">sent</span><span class="p">:]</span> <span class="n">client</span> <span class="o">=</span> <span class="n">HTTPClient</span><span class="p">(</span><span class="s">'www.python.org'</span><span class="p">,</span> <span class="s">'/'</span><span class="p">)</span> <span class="n">asyncore</span><span class="o">.</span><span class="n">loop</span><span class="p">()</span> </pre></div> </div> </div> <div class="section" id="asyncore-example-basic-echo-server"> <span id="asyncore-example-2"></span><h2>17.6.2. asyncore Example basic echo server<a class="headerlink" href="#asyncore-example-basic-echo-server" title="Permalink to this headline">¶</a></h2> <p>Here is a basic echo server that uses the <a class="reference internal" href="#asyncore.dispatcher" title="asyncore.dispatcher"><tt class="xref py py-class docutils literal"><span class="pre">dispatcher</span></tt></a> class to accept connections and dispatches the incoming connections to a handler:</p> <div class="highlight-python"><div class="highlight"><pre><span class="kn">import</span> <span class="nn">asyncore</span> <span class="kn">import</span> <span class="nn">socket</span> <span class="k">class</span> <span class="nc">EchoHandler</span><span class="p">(</span><span class="n">asyncore</span><span class="o">.</span><span class="n">dispatcher_with_send</span><span class="p">):</span> <span class="k">def</span> <span class="nf">handle_read</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="n">data</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">recv</span><span class="p">(</span><span class="mi">8192</span><span class="p">)</span> <span class="k">if</span> <span class="n">data</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">send</span><span class="p">(</span><span class="n">data</span><span class="p">)</span> <span class="k">class</span> <span class="nc">EchoServer</span><span class="p">(</span><span class="n">asyncore</span><span class="o">.</span><span class="n">dispatcher</span><span class="p">):</span> <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">host</span><span class="p">,</span> <span class="n">port</span><span class="p">):</span> <span class="n">asyncore</span><span class="o">.</span><span class="n">dispatcher</span><span class="o">.</span><span class="n">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="bp">self</span><span class="o">.</span><span class="n">create_socket</span><span class="p">(</span><span class="n">socket</span><span class="o">.</span><span class="n">AF_INET</span><span class="p">,</span> <span class="n">socket</span><span class="o">.</span><span class="n">SOCK_STREAM</span><span class="p">)</span> <span class="bp">self</span><span class="o">.</span><span class="n">set_reuse_addr</span><span class="p">()</span> <span class="bp">self</span><span class="o">.</span><span class="n">bind</span><span class="p">((</span><span class="n">host</span><span class="p">,</span> <span class="n">port</span><span class="p">))</span> <span class="bp">self</span><span class="o">.</span><span class="n">listen</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span> <span class="k">def</span> <span class="nf">handle_accept</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span> <span class="n">pair</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">accept</span><span class="p">()</span> <span class="k">if</span> <span class="n">pair</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">:</span> <span class="n">sock</span><span class="p">,</span> <span class="n">addr</span> <span class="o">=</span> <span class="n">pair</span> <span class="k">print</span> <span class="s">'Incoming connection from </span><span class="si">%s</span><span class="s">'</span> <span class="o">%</span> <span class="nb">repr</span><span class="p">(</span><span class="n">addr</span><span class="p">)</span> <span class="n">handler</span> <span class="o">=</span> <span class="n">EchoHandler</span><span class="p">(</span><span class="n">sock</span><span class="p">)</span> <span class="n">server</span> <span class="o">=</span> <span class="n">EchoServer</span><span class="p">(</span><span class="s">'localhost'</span><span class="p">,</span> <span class="mi">8080</span><span class="p">)</span> <span class="n">asyncore</span><span class="o">.</span><span class="n">loop</span><span class="p">()</span> </pre></div> </div> </div> </div> </div> </div> </div> <div class="sphinxsidebar"> <div class="sphinxsidebarwrapper"> <h3><a href="../contents.html">Table Of Contents</a></h3> <ul> <li><a class="reference internal" href="#">17.6. <tt class="docutils literal"><span class="pre">asyncore</span></tt> — Asynchronous socket handler</a><ul> <li><a class="reference internal" href="#asyncore-example-basic-http-client">17.6.1. asyncore Example basic HTTP client</a></li> <li><a class="reference internal" href="#asyncore-example-basic-echo-server">17.6.2. asyncore Example basic echo server</a></li> </ul> </li> </ul> <h4>Previous topic</h4> <p class="topless"><a href="popen2.html" title="previous chapter">17.5. <tt class="docutils literal"><span class="pre">popen2</span></tt> — Subprocesses with accessible I/O streams</a></p> <h4>Next topic</h4> <p class="topless"><a href="asynchat.html" title="next chapter">17.7. <tt class="docutils literal"><span class="pre">asynchat</span></tt> — Asynchronous socket command/response handler</a></p> <h3>This Page</h3> <ul class="this-page-menu"> <li><a href="../bugs.html">Report a Bug</a></li> <li><a href="../_sources/library/asyncore.txt" rel="nofollow">Show Source</a></li> </ul> <div id="searchbox" style="display: none"> <h3>Quick search</h3> <form class="search" action="../search.html" method="get"> <input type="text" name="q" /> <input type="submit" value="Go" /> <input type="hidden" name="check_keywords" value="yes" /> <input type="hidden" name="area" value="default" /> </form> <p class="searchtip" style="font-size: 90%"> Enter search terms or a module, class or function name. </p> </div> <script type="text/javascript">$('#searchbox').show(0);</script> </div> </div> <div class="clearer"></div> </div> <div class="related"> <h3>Navigation</h3> <ul> <li class="right" style="margin-right: 10px"> <a href="../genindex.html" title="General Index" >index</a></li> <li class="right" > <a href="../py-modindex.html" title="Python Module Index" >modules</a> |</li> <li class="right" > <a href="asynchat.html" title="17.7. asynchat — Asynchronous socket command/response handler" >next</a> |</li> <li class="right" > <a href="popen2.html" title="17.5. popen2 — Subprocesses with accessible I/O streams" >previous</a> |</li> <li><img src="../_static/py.png" alt="" style="vertical-align: middle; margin-top: -1px"/></li> <li><a href="http://www.python.org/">Python</a> »</li> <li> <a href="../index.html">Python 2.7.5 documentation</a> » </li> <li><a href="index.html" >The Python Standard Library</a> »</li> <li><a href="ipc.html" >17. Interprocess Communication and Networking</a> »</li> </ul> </div> <div class="footer"> © <a href="../copyright.html">Copyright</a> 1990-2020, Python Software Foundation. <br /> The Python Software Foundation is a non-profit corporation. <a href="http://www.python.org/psf/donations/">Please donate.</a> <br /> Last updated on Oct 13, 2020. <a href="../bugs.html">Found a bug</a>? <br /> Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3. </div> </body> </html>