server/jpywork/SocketServer.java

   1 import org.python.core.*;
   2
   3 public class SocketServer extends java.lang.Object {
   4     static String[] jpy$mainProperties = new String[] {"python.modules.builtin", "exceptions:org.python.core.exceptions"};
   5     static String[] jpy$proxyProperties = new String[] {"python.modules.builtin", "exceptions:org.python.core.exceptions", "python.options.showJavaExceptions", "true"};
   6     static String[] jpy$packages = new String[] {"java.net", null, "java.lang", null, "org.python.core", null, "java.io", null, "java.util.zip", null};
   7
   8     public static class _PyInner extends PyFunctionTable implements PyRunnable {
   9         private static PyObject s$0;
  10         private static PyObject s$1;
  11         private static PyObject s$2;
  12         private static PyObject s$3;
  13         private static PyObject s$4;
  14         private static PyObject s$5;
  15         private static PyObject s$6;
  16         private static PyObject s$7;
  17         private static PyObject s$8;
  18         private static PyObject s$9;
  19         private static PyObject s$10;
  20         private static PyObject s$11;
  21         private static PyObject s$12;
  22         private static PyObject s$13;
  23         private static PyObject s$14;
  24         private static PyObject s$15;
  25         private static PyObject s$16;
  26         private static PyObject s$17;
  27         private static PyObject s$18;
  28         private static PyObject s$19;
  29         private static PyObject s$20;
  30         private static PyObject s$21;
  31         private static PyObject i$22;
  32         private static PyObject s$23;
  33         private static PyObject s$24;
  34         private static PyObject s$25;
  35         private static PyObject s$26;
  36         private static PyObject s$27;
  37         private static PyObject s$28;
  38         private static PyObject s$29;
  39         private static PyObject s$30;
  40         private static PyObject i$31;
  41         private static PyObject s$32;
  42         private static PyObject s$33;
  43         private static PyObject i$34;
  44         private static PyObject i$35;
  45         private static PyObject s$36;
  46         private static PyObject s$37;
  47         private static PyObject s$38;
  48         private static PyObject s$39;
  49         private static PyObject i$40;
  50         private static PyObject s$41;
  51         private static PyObject s$42;
  52         private static PyObject s$43;
  53         private static PyObject s$44;
  54         private static PyObject s$45;
  55         private static PyObject s$46;
  56         private static PyObject s$47;
  57         private static PyObject s$48;
  58         private static PyObject s$49;
  59         private static PyObject s$50;
  60         private static PyObject s$51;
  61         private static PyFunctionTable funcTable;
  62         private static PyCode c$0___init__;
  63         private static PyCode c$1_server_activate;
  64         private static PyCode c$2_serve_forever;
  65         private static PyCode c$3_handle_request;
  66         private static PyCode c$4_verify_request;
  67         private static PyCode c$5_process_request;
  68         private static PyCode c$6_server_close;
  69         private static PyCode c$7_finish_request;
  70         private static PyCode c$8_close_request;
  71         private static PyCode c$9_handle_error;
  72         private static PyCode c$10_BaseServer;
  73         private static PyCode c$11___init__;
  74         private static PyCode c$12_server_bind;
  75         private static PyCode c$13_server_activate;
  76         private static PyCode c$14_server_close;
  77         private static PyCode c$15_fileno;
  78         private static PyCode c$16_get_request;
  79         private static PyCode c$17_close_request;
  80         private static PyCode c$18_TCPServer;
  81         private static PyCode c$19_get_request;
  82         private static PyCode c$20_server_activate;
  83         private static PyCode c$21_close_request;
  84         private static PyCode c$22_UDPServer;
  85         private static PyCode c$23_collect_children;
  86         private static PyCode c$24_process_request;
  87         private static PyCode c$25_ForkingMixIn;
  88         private static PyCode c$26_process_request;
  89         private static PyCode c$27_ThreadingMixIn;
  90         private static PyCode c$28_ForkingUDPServer;
  91         private static PyCode c$29_ForkingTCPServer;
  92         private static PyCode c$30_ThreadingUDPServer;
  93         private static PyCode c$31_ThreadingTCPServer;
  94         private static PyCode c$32_UnixStreamServer;
  95         private static PyCode c$33_UnixDatagramServer;
  96         private static PyCode c$34_ThreadingUnixStreamServer;
  97         private static PyCode c$35_ThreadingUnixDatagramServer;
  98         private static PyCode c$36___init__;
  99         private static PyCode c$37_setup;
 100         private static PyCode c$38___del__;
 101         private static PyCode c$39_handle;
 102         private static PyCode c$40_finish;
 103         private static PyCode c$41_BaseRequestHandler;
 104         private static PyCode c$42_setup;
 105         private static PyCode c$43_finish;
 106         private static PyCode c$44_StreamRequestHandler;
 107         private static PyCode c$45_setup;
 108         private static PyCode c$46_finish;
 109         private static PyCode c$47_DatagramRequestHandler;
 110         private static PyCode c$48_main;
 111         private static void initConstants() {
 112             s$0 = Py.newString("Generic socket server classes.\012\012This module tries to capture the various aspects of defining a server:\012\012For socket-based servers:\012\012- address family:\012        - AF_INET: IP (Internet Protocol) sockets (default)\012        - AF_UNIX: Unix domain sockets\012        - others, e.g. AF_DECNET are conceivable (see <socket.h>\012- socket type:\012        - SOCK_STREAM (reliable stream, e.g. TCP)\012        - SOCK_DGRAM (datagrams, e.g. UDP)\012\012For request-based servers (including socket-based):\012\012- client address verification before further looking at the request\012        (This is actually a hook for any processing that needs to look\012         at the request before anything else, e.g. logging)\012- how to handle multiple requests:\012        - synchronous (one request is handled at a time)\012        - forking (each request is handled by a new process)\012        - threading (each request is handled by a new thread)\012\012The classes in this module favor the server type that is simplest to\012write: a synchronous TCP/IP server.  This is bad class design, but\012save some typing.  (There's also the issue that a deep class hierarchy\012slows down method lookups.)\012\012There are five classes in an inheritance diagram, four of which represent\012synchronous servers of four types:\012\012        +------------+\012        | BaseServer |\012        +------------+\012              |\012              v\012        +-----------+        +------------------+\012        | TCPServer |------->| UnixStreamServer |\012        +-----------+        +------------------+\012              |\012              v\012        +-----------+        +--------------------+\012        | UDPServer |------->| UnixDatagramServer |\012        +-----------+        +--------------------+\012\012Note that UnixDatagramServer derives from UDPServer, not from\012UnixStreamServer -- the only difference between an IP and a Unix\012stream server is the address family, which is simply repeated in both\012unix server classes.\012\012Forking and threading versions of each type of server can be created\012using the ForkingServer and ThreadingServer mix-in classes.  For\012instance, a threading UDP server class is created as follows:\012\012        class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass\012\012The Mix-in class must come first, since it overrides a method defined\012in UDPServer!\012\012To implement a service, you must derive a class from\012BaseRequestHandler and redefine its handle() method.  You can then run\012various versions of the service by combining one of the server classes\012with your request handler class.\012\012The request handler class must be different for datagram or stream\012services.  This can be hidden by using the mix-in request handler\012classes StreamRequestHandler or DatagramRequestHandler.\012\012Of course, you still have to use your head!\012\012For instance, it makes no sense to use a forking server if the service\012contains state in memory that can be modified by requests (since the\012modifications in the child process would never reach the initial state\012kept in the parent process and passed to each child).  In this case,\012you can use a threading server, but you will probably have to use\012locks to avoid two requests that come in nearly simultaneous to apply\012conflicting changes to the server state.\012\012On the other hand, if you are building e.g. an HTTP server, where all\012data is stored externally (e.g. in the file system), a synchronous\012class will essentially render the service \"deaf\" while one request is\012being handled -- which may be for a very long time if a client is slow\012to reqd all the data it has requested.  Here a threading or forking\012server is appropriate.\012\012In some cases, it may be appropriate to process part of a request\012synchronously, but to finish processing in a forked child depending on\012the request data.  This can be implemented by using a synchronous\012server and doing an explicit fork in the request handler class\012handle() method.\012\012Another approach to handling multiple simultaneous requests in an\012environment that supports neither threads nor fork (or where these are\012too expensive or inappropriate for the service) is to maintain an\012explicit table of partially finished requests and to use select() to\012decide which request to work on next (or whether to handle a new\012incoming request).  This is particularly important for stream services\012where each client can potentially be connected for a long time (if\012threads or subprocesses cannot be used).\012\012Future work:\012- Standard classes for Sun RPC (which uses either UDP or TCP)\012- Standard mix-in classes to implement various authentication\012  and encryption schemes\012- Standard framework for select-based multiplexing\012\012XXX Open problems:\012- What to do with out-of-band data?\012\012BaseServer:\012- split generic \"request\" functionality out into BaseServer class.\012  Copyright (C) 2000  Luke Kenneth Casson Leighton <lkcl@samba.org>\012\012  example: read entries from a SQL database (requires overriding\012  get_request() to return a table entry from the database).\012  entry is processed by a RequestHandlerClass.\012\012");
 113             s$1 = Py.newString("0.4");
 114             s$2 = Py.newString("TCPServer");
 115             s$3 = Py.newString("UDPServer");
 116             s$4 = Py.newString("ForkingUDPServer");
 117             s$5 = Py.newString("ForkingTCPServer");
 118             s$6 = Py.newString("ThreadingUDPServer");
 119             s$7 = Py.newString("ThreadingTCPServer");
 120             s$8 = Py.newString("BaseRequestHandler");
 121             s$9 = Py.newString("StreamRequestHandler");
 122             s$10 = Py.newString("DatagramRequestHandler");
 123             s$11 = Py.newString("ThreadingMixIn");
 124             s$12 = Py.newString("ForkingMixIn");
 125             s$13 = Py.newString("AF_UNIX");
 126             s$14 = Py.newString("UnixStreamServer");
 127             s$15 = Py.newString("UnixDatagramServer");
 128             s$16 = Py.newString("ThreadingUnixStreamServer");
 129             s$17 = Py.newString("ThreadingUnixDatagramServer");
 130             s$18 = Py.newString("Base class for server classes.\012\012    Methods for the caller:\012\012    - __init__(server_address, RequestHandlerClass)\012    - serve_forever()\012    - handle_request()  # if you do not use serve_forever()\012    - fileno() -> int   # for select()\012\012    Methods that may be overridden:\012\012    - server_bind()\012    - server_activate()\012    - get_request() -> request, client_address\012    - verify_request(request, client_address)\012    - server_close()\012    - process_request(request, client_address)\012    - close_request(request)\012    - handle_error()\012\012    Methods for derived classes:\012\012    - finish_request(request, client_address)\012\012    Class variables that may be overridden by derived classes or\012    instances:\012\012    - address_family\012    - socket_type\012    - reuse_address\012\012    Instance variables:\012\012    - RequestHandlerClass\012    - socket\012\012    ");
 131             s$19 = Py.newString("Constructor.  May be extended, do not override.");
 132             s$20 = Py.newString("Called by constructor to activate the server.\012\012        May be overridden.\012\012        ");
 133             s$21 = Py.newString("Handle one request at a time until doomsday.");
 134             i$22 = Py.newInteger(1);
 135             s$23 = Py.newString("Handle one request, possibly blocking.");
 136             s$24 = Py.newString("Verify the request.  May be overridden.\012\012        Return true if we should proceed with this request.\012\012        ");
 137             s$25 = Py.newString("Call finish_request.\012\012        Overridden by ForkingMixIn and ThreadingMixIn.\012\012        ");
 138             s$26 = Py.newString("Called to clean-up the server.\012\012        May be overridden.\012\012        ");
 139             s$27 = Py.newString("Finish one request by instantiating RequestHandlerClass.");
 140             s$28 = Py.newString("Called to clean up an individual request.");
 141             s$29 = Py.newString("Handle an error gracefully.  May be overridden.\012\012        The default is to print a traceback and continue.\012\012        ");
 142             s$30 = Py.newString("-");
 143             i$31 = Py.newInteger(40);
 144             s$32 = Py.newString("Exception happened during processing of request from");
 145             s$33 = Py.newString("Base class for various socket-based server classes.\012\012    Defaults to synchronous IP stream (i.e., TCP).\012\012    Methods for the caller:\012\012    - __init__(server_address, RequestHandlerClass)\012    - serve_forever()\012    - handle_request()  # if you don't use serve_forever()\012    - fileno() -> int   # for select()\012\012    Methods that may be overridden:\012\012    - server_bind()\012    - server_activate()\012    - get_request() -> request, client_address\012    - verify_request(request, client_address)\012    - process_request(request, client_address)\012    - close_request(request)\012    - handle_error()\012\012    Methods for derived classes:\012\012    - finish_request(request, client_address)\012\012    Class variables that may be overridden by derived classes or\012    instances:\012\012    - address_family\012    - socket_type\012    - request_queue_size (only for stream sockets)\012    - reuse_address\012\012    Instance variables:\012\012    - server_address\012    - RequestHandlerClass\012    - socket\012\012    ");
 146             i$34 = Py.newInteger(5);
 147             i$35 = Py.newInteger(0);
 148             s$36 = Py.newString("Called by constructor to bind the socket.\012\012        May be overridden.\012\012        ");
 149             s$37 = Py.newString("Return socket file number.\012\012        Interface required by select().\012\012        ");
 150             s$38 = Py.newString("Get the request and client address from the socket.\012\012        May be overridden.\012\012        ");
 151             s$39 = Py.newString("UDP server class.");
 152             i$40 = Py.newInteger(8192);
 153             s$41 = Py.newString("Mix-in class to handle each request in a new process.");
 154             s$42 = Py.newString("Internal routine to wait for died children.");
 155             s$43 = Py.newString("Fork a new subprocess to process the request.");
 156             s$44 = Py.newString("Mix-in class to handle each request in a new thread.");
 157             s$45 = Py.newString("Start a new thread to process the request.");
 158             s$46 = Py.newString("Base class for request handler classes.\012\012    This class is instantiated for each request to be handled.  The\012    constructor sets the instance variables request, client_address\012    and server, and then calls the handle() method.  To implement a\012    specific service, all you need to do is to derive a class which\012    defines a handle() method.\012\012    The handle() method can find the request as self.request, the\012    client address as self.client_address, and the server (in case it\012    needs access to per-server information) as self.server.  Since a\012    separate instance is created for each request, the handle() method\012    can define arbitrary other instance variariables.\012\012    ");
 159             s$47 = Py.newString("Define self.rfile and self.wfile for stream sockets.");
 160             s$48 = Py.newString("rb");
 161             s$49 = Py.newString("wb");
 162             s$50 = Py.newString("Define self.rfile and self.wfile for datagram sockets.");
 163             s$51 = Py.newString("/usr/share/jython/Lib-cpython/SocketServer.py");
 164             funcTable = new _PyInner();
 165             c$0___init__ = Py.newCode(3, new String[] {"self", "server_address", "RequestHandlerClass"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "__init__", false, false, funcTable, 0, null, null, 0, 1);
 166             c$1_server_activate = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "server_activate", false, false, funcTable, 1, null, null, 0, 1);
 167             c$2_serve_forever = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "serve_forever", false, false, funcTable, 2, null, null, 0, 1);
 168             c$3_handle_request = Py.newCode(1, new String[] {"self", "client_address", "request"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "handle_request", false, false, funcTable, 3, null, null, 0, 1);
 169             c$4_verify_request = Py.newCode(3, new String[] {"self", "request", "client_address"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "verify_request", false, false, funcTable, 4, null, null, 0, 1);
 170             c$5_process_request = Py.newCode(3, new String[] {"self", "request", "client_address"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "process_request", false, false, funcTable, 5, null, null, 0, 1);
 171             c$6_server_close = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "server_close", false, false, funcTable, 6, null, null, 0, 1);
 172             c$7_finish_request = Py.newCode(3, new String[] {"self", "request", "client_address"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "finish_request", false, false, funcTable, 7, null, null, 0, 1);
 173             c$8_close_request = Py.newCode(2, new String[] {"self", "request"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "close_request", false, false, funcTable, 8, null, null, 0, 1);
 174             c$9_handle_error = Py.newCode(3, new String[] {"self", "request", "client_address", "traceback"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "handle_error", false, false, funcTable, 9, null, null, 0, 1);
 175             c$10_BaseServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "BaseServer", false, false, funcTable, 10, null, null, 0, 0);
 176             c$11___init__ = Py.newCode(3, new String[] {"self", "server_address", "RequestHandlerClass"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "__init__", false, false, funcTable, 11, null, null, 0, 1);
 177             c$12_server_bind = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "server_bind", false, false, funcTable, 12, null, null, 0, 1);
 178             c$13_server_activate = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "server_activate", false, false, funcTable, 13, null, null, 0, 1);
 179             c$14_server_close = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "server_close", false, false, funcTable, 14, null, null, 0, 1);
 180             c$15_fileno = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "fileno", false, false, funcTable, 15, null, null, 0, 1);
 181             c$16_get_request = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "get_request", false, false, funcTable, 16, null, null, 0, 1);
 182             c$17_close_request = Py.newCode(2, new String[] {"self", "request"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "close_request", false, false, funcTable, 17, null, null, 0, 1);
 183             c$18_TCPServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "TCPServer", false, false, funcTable, 18, null, null, 0, 0);
 184             c$19_get_request = Py.newCode(1, new String[] {"self", "client_addr", "data"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "get_request", false, false, funcTable, 19, null, null, 0, 1);
 185             c$20_server_activate = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "server_activate", false, false, funcTable, 20, null, null, 0, 1);
 186             c$21_close_request = Py.newCode(2, new String[] {"self", "request"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "close_request", false, false, funcTable, 21, null, null, 0, 1);
 187             c$22_UDPServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "UDPServer", false, false, funcTable, 22, null, null, 0, 0);
 188             c$23_collect_children = Py.newCode(1, new String[] {"self", "status", "pid", "options"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "collect_children", false, false, funcTable, 23, null, null, 0, 1);
 189             c$24_process_request = Py.newCode(3, new String[] {"self", "request", "client_address", "pid"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "process_request", false, false, funcTable, 24, null, null, 0, 1);
 190             c$25_ForkingMixIn = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ForkingMixIn", false, false, funcTable, 25, null, null, 0, 0);
 191             c$26_process_request = Py.newCode(3, new String[] {"self", "request", "client_address", "t", "threading"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "process_request", false, false, funcTable, 26, null, null, 0, 1);
 192             c$27_ThreadingMixIn = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ThreadingMixIn", false, false, funcTable, 27, null, null, 0, 0);
 193             c$28_ForkingUDPServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ForkingUDPServer", false, false, funcTable, 28, null, null, 0, 0);
 194             c$29_ForkingTCPServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ForkingTCPServer", false, false, funcTable, 29, null, null, 0, 0);
 195             c$30_ThreadingUDPServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ThreadingUDPServer", false, false, funcTable, 30, null, null, 0, 0);
 196             c$31_ThreadingTCPServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ThreadingTCPServer", false, false, funcTable, 31, null, null, 0, 0);
 197             c$32_UnixStreamServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "UnixStreamServer", false, false, funcTable, 32, null, null, 0, 0);
 198             c$33_UnixDatagramServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "UnixDatagramServer", false, false, funcTable, 33, null, null, 0, 0);
 199             c$34_ThreadingUnixStreamServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ThreadingUnixStreamServer", false, false, funcTable, 34, null, null, 0, 0);
 200             c$35_ThreadingUnixDatagramServer = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "ThreadingUnixDatagramServer", false, false, funcTable, 35, null, null, 0, 0);
 201             c$36___init__ = Py.newCode(4, new String[] {"self", "request", "client_address", "server"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "__init__", false, false, funcTable, 36, null, null, 0, 1);
 202             c$37_setup = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "setup", false, false, funcTable, 37, null, null, 0, 1);
 203             c$38___del__ = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "__del__", false, false, funcTable, 38, null, null, 0, 1);
 204             c$39_handle = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "handle", false, false, funcTable, 39, null, null, 0, 1);
 205             c$40_finish = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "finish", false, false, funcTable, 40, null, null, 0, 1);
 206             c$41_BaseRequestHandler = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "BaseRequestHandler", false, false, funcTable, 41, null, null, 0, 0);
 207             c$42_setup = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "setup", false, false, funcTable, 42, null, null, 0, 1);
 208             c$43_finish = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "finish", false, false, funcTable, 43, null, null, 0, 1);
 209             c$44_StreamRequestHandler = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "StreamRequestHandler", false, false, funcTable, 44, null, null, 0, 0);
 210             c$45_setup = Py.newCode(1, new String[] {"self", "StringIO"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "setup", false, false, funcTable, 45, null, null, 0, 1);
 211             c$46_finish = Py.newCode(1, new String[] {"self"}, "/usr/share/jython/Lib-cpython/SocketServer.py", "finish", false, false, funcTable, 46, null, null, 0, 1);
 212             c$47_DatagramRequestHandler = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "DatagramRequestHandler", false, false, funcTable, 47, null, null, 0, 0);
 213             c$48_main = Py.newCode(0, new String[] {}, "/usr/share/jython/Lib-cpython/SocketServer.py", "main", false, false, funcTable, 48, null, null, 0, 0);
 214         }
 215
 216
 217         public PyCode getMain() {
 218             if (c$48_main == null) _PyInner.initConstants();
 219             return c$48_main;
 220         }
 221
 222         public PyObject call_function(int index, PyFrame frame) {
 223             switch (index){
 224                 case 0:
 225                 return _PyInner.__init__$1(frame);
 226                 case 1:
 227                 return _PyInner.server_activate$2(frame);
 228                 case 2:
 229                 return _PyInner.serve_forever$3(frame);
 230                 case 3:
 231                 return _PyInner.handle_request$4(frame);
 232                 case 4:
 233                 return _PyInner.verify_request$5(frame);
 234                 case 5:
 235                 return _PyInner.process_request$6(frame);
 236                 case 6:
 237                 return _PyInner.server_close$7(frame);
 238                 case 7:
 239                 return _PyInner.finish_request$8(frame);
 240                 case 8:
 241                 return _PyInner.close_request$9(frame);
 242                 case 9:
 243                 return _PyInner.handle_error$10(frame);
 244                 case 10:
 245                 return _PyInner.BaseServer$11(frame);
 246                 case 11:
 247                 return _PyInner.__init__$12(frame);
 248                 case 12:
 249                 return _PyInner.server_bind$13(frame);
 250                 case 13:
 251                 return _PyInner.server_activate$14(frame);
 252                 case 14:
 253                 return _PyInner.server_close$15(frame);
 254                 case 15:
 255                 return _PyInner.fileno$16(frame);
 256                 case 16:
 257                 return _PyInner.get_request$17(frame);
 258                 case 17:
 259                 return _PyInner.close_request$18(frame);
 260                 case 18:
 261                 return _PyInner.TCPServer$19(frame);
 262                 case 19:
 263                 return _PyInner.get_request$20(frame);
 264                 case 20:
 265                 return _PyInner.server_activate$21(frame);
 266                 case 21:
 267                 return _PyInner.close_request$22(frame);
 268                 case 22:
 269                 return _PyInner.UDPServer$23(frame);
 270                 case 23:
 271                 return _PyInner.collect_children$24(frame);
 272                 case 24:
 273                 return _PyInner.process_request$25(frame);
 274                 case 25:
 275                 return _PyInner.ForkingMixIn$26(frame);
 276                 case 26:
 277                 return _PyInner.process_request$27(frame);
 278                 case 27:
 279                 return _PyInner.ThreadingMixIn$28(frame);
 280                 case 28:
 281                 return _PyInner.ForkingUDPServer$29(frame);
 282                 case 29:
 283                 return _PyInner.ForkingTCPServer$30(frame);
 284                 case 30:
 285                 return _PyInner.ThreadingUDPServer$31(frame);
 286                 case 31:
 287                 return _PyInner.ThreadingTCPServer$32(frame);
 288                 case 32:
 289                 return _PyInner.UnixStreamServer$33(frame);
 290                 case 33:
 291                 return _PyInner.UnixDatagramServer$34(frame);
 292                 case 34:
 293                 return _PyInner.ThreadingUnixStreamServer$35(frame);
 294                 case 35:
 295                 return _PyInner.ThreadingUnixDatagramServer$36(frame);
 296                 case 36:
 297                 return _PyInner.__init__$37(frame);
 298                 case 37:
 299                 return _PyInner.setup$38(frame);
 300                 case 38:
 301                 return _PyInner.__del__$39(frame);
 302                 case 39:
 303                 return _PyInner.handle$40(frame);
 304                 case 40:
 305                 return _PyInner.finish$41(frame);
 306                 case 41:
 307                 return _PyInner.BaseRequestHandler$42(frame);
 308                 case 42:
 309                 return _PyInner.setup$43(frame);
 310                 case 43:
 311                 return _PyInner.finish$44(frame);
 312                 case 44:
 313                 return _PyInner.StreamRequestHandler$45(frame);
 314                 case 45:
 315                 return _PyInner.setup$46(frame);
 316                 case 46:
 317                 return _PyInner.finish$47(frame);
 318                 case 47:
 319                 return _PyInner.DatagramRequestHandler$48(frame);
 320                 case 48:
 321                 return _PyInner.main$49(frame);
 322                 default:
 323                 return null;
 324             }
 325         }
 326
 327         private static PyObject __init__$1(PyFrame frame) {
 328             /* Constructor.  May be extended, do not override. */
 329             frame.getlocal(0).__setattr__("server_address", frame.getlocal(1));
 330             frame.getlocal(0).__setattr__("RequestHandlerClass", frame.getlocal(2));
 331             return Py.None;
 332         }
 333
 334         private static PyObject server_activate$2(PyFrame frame) {
 335             /* Called by constructor to activate the server.
 336
 337                     May be overridden.
 338
 339                      */
 340             // pass
 341             return Py.None;
 342         }
 343
 344         private static PyObject serve_forever$3(PyFrame frame) {
 345             /* Handle one request at a time until doomsday. */
 346             while (i$22.__nonzero__()) {
 347                 frame.getlocal(0).invoke("handle_request");
 348             }
 349             return Py.None;
 350         }
 351
 352         private static PyObject handle_request$4(PyFrame frame) {
 353             // Temporary Variables
 354             PyObject[] t$0$PyObject__;
 355             PyException t$0$PyException;
 356
 357             // Code
 358             /* Handle one request, possibly blocking. */
 359             try {
 360                 t$0$PyObject__ = org.python.core.Py.unpackSequence(frame.getlocal(0).invoke("get_request"), 2);
 361                 frame.setlocal(2, t$0$PyObject__[0]);
 362                 frame.setlocal(1, t$0$PyObject__[1]);
 363             }
 364             catch (Throwable x$0) {
 365                 t$0$PyException = Py.setException(x$0, frame);
 366                 if (Py.matchException(t$0$PyException, frame.getglobal("socket").__getattr__("error"))) {
 367                     return Py.None;
 368                 }
 369                 else throw t$0$PyException;
 370             }
 371             if (frame.getlocal(0).invoke("verify_request", frame.getlocal(2), frame.getlocal(1)).__nonzero__()) {
 372                 try {
 373                     frame.getlocal(0).invoke("process_request", frame.getlocal(2), frame.getlocal(1));
 374                 }
 375                 catch (Throwable x$1) {
 376                     t$0$PyException = Py.setException(x$1, frame);
 377                     frame.getlocal(0).invoke("handle_error", frame.getlocal(2), frame.getlocal(1));
 378                     frame.getlocal(0).invoke("close_request", frame.getlocal(2));
 379                 }
 380             }
 381             return Py.None;
 382         }
 383
 384         private static PyObject verify_request$5(PyFrame frame) {
 385             /* Verify the request.  May be overridden.
 386
 387                     Return true if we should proceed with this request.
 388
 389                      */
 390             return i$22;
 391         }
 392
 393         private static PyObject process_request$6(PyFrame frame) {
 394             /* Call finish_request.
 395
 396                     Overridden by ForkingMixIn and ThreadingMixIn.
 397
 398                      */
 399             frame.getlocal(0).invoke("finish_request", frame.getlocal(1), frame.getlocal(2));
 400             frame.getlocal(0).invoke("close_request", frame.getlocal(1));
 401             return Py.None;
 402         }
 403
 404         private static PyObject server_close$7(PyFrame frame) {
 405             /* Called to clean-up the server.
 406
 407                     May be overridden.
 408
 409                      */
 410             // pass
 411             return Py.None;
 412         }
 413
 414         private static PyObject finish_request$8(PyFrame frame) {
 415             /* Finish one request by instantiating RequestHandlerClass. */
 416             frame.getlocal(0).invoke("RequestHandlerClass", new PyObject[] {frame.getlocal(1), frame.getlocal(2), frame.getlocal(0)});
 417             return Py.None;
 418         }
 419
 420         private static PyObject close_request$9(PyFrame frame) {
 421             /* Called to clean up an individual request. */
 422             // pass
 423             return Py.None;
 424         }
 425
 426         private static PyObject handle_error$10(PyFrame frame) {
 427             /* Handle an error gracefully.  May be overridden.
 428
 429                     The default is to print a traceback and continue.
 430
 431                      */
 432             Py.println(s$30._mul(i$31));
 433             Py.printComma(s$32);
 434             Py.println(frame.getlocal(2));
 435             frame.setlocal(3, org.python.core.imp.importOne("traceback", frame));
 436             frame.getlocal(3).__getattr__("print_exc").__call__();
 437             Py.println(s$30._mul(i$31));
 438             return Py.None;
 439         }
 440
 441         private static PyObject BaseServer$11(PyFrame frame) {
 442             /* Base class for server classes.
 443
 444                 Methods for the caller:
 445
 446                 - __init__(server_address, RequestHandlerClass)
 447                 - serve_forever()
 448                 - handle_request()  # if you do not use serve_forever()
 449                 - fileno() -> int   # for select()
 450
 451                 Methods that may be overridden:
 452
 453                 - server_bind()
 454                 - server_activate()
 455                 - get_request() -> request, client_address
 456                 - verify_request(request, client_address)
 457                 - server_close()
 458                 - process_request(request, client_address)
 459                 - close_request(request)
 460                 - handle_error()
 461
 462                 Methods for derived classes:
 463
 464                 - finish_request(request, client_address)
 465
 466                 Class variables that may be overridden by derived classes or
 467                 instances:
 468
 469                 - address_family
 470                 - socket_type
 471                 - reuse_address
 472
 473                 Instance variables:
 474
 475                 - RequestHandlerClass
 476                 - socket
 477
 478                  */
 479             frame.setlocal("__init__", new PyFunction(frame.f_globals, new PyObject[] {}, c$0___init__));
 480             frame.setlocal("server_activate", new PyFunction(frame.f_globals, new PyObject[] {}, c$1_server_activate));
 481             frame.setlocal("serve_forever", new PyFunction(frame.f_globals, new PyObject[] {}, c$2_serve_forever));
 482             frame.setlocal("handle_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$3_handle_request));
 483             frame.setlocal("verify_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$4_verify_request));
 484             frame.setlocal("process_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$5_process_request));
 485             frame.setlocal("server_close", new PyFunction(frame.f_globals, new PyObject[] {}, c$6_server_close));
 486             frame.setlocal("finish_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$7_finish_request));
 487             frame.setlocal("close_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$8_close_request));
 488             frame.setlocal("handle_error", new PyFunction(frame.f_globals, new PyObject[] {}, c$9_handle_error));
 489             return frame.getf_locals();
 490         }
 491
 492         private static PyObject __init__$12(PyFrame frame) {
 493             /* Constructor.  May be extended, do not override. */
 494             frame.getglobal("BaseServer").invoke("__init__", new PyObject[] {frame.getlocal(0), frame.getlocal(1), frame.getlocal(2)});
 495             frame.getlocal(0).__setattr__("socket", frame.getglobal("socket").__getattr__("socket").__call__(frame.getlocal(0).__getattr__("address_family"), frame.getlocal(0).__getattr__("socket_type")));
 496             frame.getlocal(0).invoke("server_bind");
 497             frame.getlocal(0).invoke("server_activate");
 498             return Py.None;
 499         }
 500
 501         private static PyObject server_bind$13(PyFrame frame) {
 502             /* Called by constructor to bind the socket.
 503
 504                     May be overridden.
 505
 506                      */
 507             if (frame.getlocal(0).__getattr__("allow_reuse_address").__nonzero__()) {
 508                 frame.getlocal(0).__getattr__("socket").invoke("setsockopt", new PyObject[] {frame.getglobal("socket").__getattr__("SOL_SOCKET"), frame.getglobal("socket").__getattr__("SO_REUSEADDR"), i$22});
 509             }
 510             frame.getlocal(0).__getattr__("socket").invoke("bind", frame.getlocal(0).__getattr__("server_address"));
 511             return Py.None;
 512         }
 513
 514         private static PyObject server_activate$14(PyFrame frame) {
 515             /* Called by constructor to activate the server.
 516
 517                     May be overridden.
 518
 519                      */
 520             frame.getlocal(0).__getattr__("socket").invoke("listen", frame.getlocal(0).__getattr__("request_queue_size"));
 521             return Py.None;
 522         }
 523
 524         private static PyObject server_close$15(PyFrame frame) {
 525             /* Called to clean-up the server.
 526
 527                     May be overridden.
 528
 529                      */
 530             frame.getlocal(0).__getattr__("socket").invoke("close");
 531             return Py.None;
 532         }
 533
 534         private static PyObject fileno$16(PyFrame frame) {
 535             /* Return socket file number.
 536
 537                     Interface required by select().
 538
 539                      */
 540             return frame.getlocal(0).__getattr__("socket").invoke("fileno");
 541         }
 542
 543         private static PyObject get_request$17(PyFrame frame) {
 544             /* Get the request and client address from the socket.
 545
 546                     May be overridden.
 547
 548                      */
 549             return frame.getlocal(0).__getattr__("socket").invoke("accept");
 550         }
 551
 552         private static PyObject close_request$18(PyFrame frame) {
 553             /* Called to clean up an individual request. */
 554             frame.getlocal(1).invoke("close");
 555             return Py.None;
 556         }
 557
 558         private static PyObject TCPServer$19(PyFrame frame) {
 559             /* Base class for various socket-based server classes.
 560
 561                 Defaults to synchronous IP stream (i.e., TCP).
 562
 563                 Methods for the caller:
 564
 565                 - __init__(server_address, RequestHandlerClass)
 566                 - serve_forever()
 567                 - handle_request()  # if you don't use serve_forever()
 568                 - fileno() -> int   # for select()
 569
 570                 Methods that may be overridden:
 571
 572                 - server_bind()
 573                 - server_activate()
 574                 - get_request() -> request, client_address
 575                 - verify_request(request, client_address)
 576                 - process_request(request, client_address)
 577                 - close_request(request)
 578                 - handle_error()
 579
 580                 Methods for derived classes:
 581
 582                 - finish_request(request, client_address)
 583
 584                 Class variables that may be overridden by derived classes or
 585                 instances:
 586
 587                 - address_family
 588                 - socket_type
 589                 - request_queue_size (only for stream sockets)
 590                 - reuse_address
 591
 592                 Instance variables:
 593
 594                 - server_address
 595                 - RequestHandlerClass
 596                 - socket
 597
 598                  */
 599             frame.setlocal("address_family", frame.getname("socket").__getattr__("AF_INET"));
 600             frame.setlocal("socket_type", frame.getname("socket").__getattr__("SOCK_STREAM"));
 601             frame.setlocal("request_queue_size", i$34);
 602             frame.setlocal("allow_reuse_address", i$35);
 603             frame.setlocal("__init__", new PyFunction(frame.f_globals, new PyObject[] {}, c$11___init__));
 604             frame.setlocal("server_bind", new PyFunction(frame.f_globals, new PyObject[] {}, c$12_server_bind));
 605             frame.setlocal("server_activate", new PyFunction(frame.f_globals, new PyObject[] {}, c$13_server_activate));
 606             frame.setlocal("server_close", new PyFunction(frame.f_globals, new PyObject[] {}, c$14_server_close));
 607             frame.setlocal("fileno", new PyFunction(frame.f_globals, new PyObject[] {}, c$15_fileno));
 608             frame.setlocal("get_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$16_get_request));
 609             frame.setlocal("close_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$17_close_request));
 610             return frame.getf_locals();
 611         }
 612
 613         private static PyObject get_request$20(PyFrame frame) {
 614             // Temporary Variables
 615             PyObject[] t$0$PyObject__;
 616
 617             // Code
 618             t$0$PyObject__ = org.python.core.Py.unpackSequence(frame.getlocal(0).__getattr__("socket").invoke("recvfrom", frame.getlocal(0).__getattr__("max_packet_size")), 2);
 619             frame.setlocal(2, t$0$PyObject__[0]);
 620             frame.setlocal(1, t$0$PyObject__[1]);
 621             return new PyTuple(new PyObject[] {new PyTuple(new PyObject[] {frame.getlocal(2), frame.getlocal(0).__getattr__("socket")}), frame.getlocal(1)});
 622         }
 623
 624         private static PyObject server_activate$21(PyFrame frame) {
 625             // pass
 626             return Py.None;
 627         }
 628
 629         private static PyObject close_request$22(PyFrame frame) {
 630             // pass
 631             return Py.None;
 632         }
 633
 634         private static PyObject UDPServer$23(PyFrame frame) {
 635             /* UDP server class. */
 636             frame.setlocal("allow_reuse_address", i$35);
 637             frame.setlocal("socket_type", frame.getname("socket").__getattr__("SOCK_DGRAM"));
 638             frame.setlocal("max_packet_size", i$40);
 639             frame.setlocal("get_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$19_get_request));
 640             frame.setlocal("server_activate", new PyFunction(frame.f_globals, new PyObject[] {}, c$20_server_activate));
 641             frame.setlocal("close_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$21_close_request));
 642             return frame.getf_locals();
 643         }
 644
 645         private static PyObject collect_children$24(PyFrame frame) {
 646             // Temporary Variables
 647             PyObject[] t$0$PyObject__;
 648             PyException t$0$PyException;
 649
 650             // Code
 651             /* Internal routine to wait for died children. */
 652             while (frame.getlocal(0).__getattr__("active_children").__nonzero__()) {
 653                 if (frame.getglobal("len").__call__(frame.getlocal(0).__getattr__("active_children"))._lt(frame.getlocal(0).__getattr__("max_children")).__nonzero__()) {
 654                     frame.setlocal(3, frame.getglobal("os").__getattr__("WNOHANG"));
 655                 }
 656                 else {
 657                     frame.setlocal(3, i$35);
 658                 }
 659                 try {
 660                     t$0$PyObject__ = org.python.core.Py.unpackSequence(frame.getglobal("os").__getattr__("waitpid").__call__(i$35, frame.getlocal(3)), 2);
 661                     frame.setlocal(2, t$0$PyObject__[0]);
 662                     frame.setlocal(1, t$0$PyObject__[1]);
 663                 }
 664                 catch (Throwable x$0) {
 665                     t$0$PyException = Py.setException(x$0, frame);
 666                     if (Py.matchException(t$0$PyException, frame.getglobal("os").__getattr__("error"))) {
 667                         frame.setlocal(2, frame.getglobal("None"));
 668                     }
 669                     else throw t$0$PyException;
 670                 }
 671                 if (frame.getlocal(2).__not__().__nonzero__()) {
 672                     break;
 673                 }
 674                 frame.getlocal(0).__getattr__("active_children").invoke("remove", frame.getlocal(2));
 675             }
 676             return Py.None;
 677         }
 678
 679         private static PyObject process_request$25(PyFrame frame) {
 680             // Temporary Variables
 681             PyException t$0$PyException;
 682
 683             // Code
 684             /* Fork a new subprocess to process the request. */
 685             frame.getlocal(0).invoke("collect_children");
 686             frame.setlocal(3, frame.getglobal("os").__getattr__("fork").__call__());
 687             if (frame.getlocal(3).__nonzero__()) {
 688                 if (frame.getlocal(0).__getattr__("active_children")._is(frame.getglobal("None")).__nonzero__()) {
 689                     frame.getlocal(0).__setattr__("active_children", new PyList(new PyObject[] {}));
 690                 }
 691                 frame.getlocal(0).__getattr__("active_children").invoke("append", frame.getlocal(3));
 692                 frame.getlocal(0).invoke("close_request", frame.getlocal(1));
 693                 return Py.None;
 694             }
 695             else {
 696                 try {
 697                     frame.getlocal(0).invoke("finish_request", frame.getlocal(1), frame.getlocal(2));
 698                     frame.getglobal("os").__getattr__("_exit").__call__(i$35);
 699                 }
 700                 catch (Throwable x$0) {
 701                     t$0$PyException = Py.setException(x$0, frame);
 702                     try {
 703                         frame.getlocal(0).invoke("handle_error", frame.getlocal(1), frame.getlocal(2));
 704                     }
 705                     finally {
 706                         frame.getglobal("os").__getattr__("_exit").__call__(i$22);
 707                     }
 708                 }
 709             }
 710             return Py.None;
 711         }
 712
 713         private static PyObject ForkingMixIn$26(PyFrame frame) {
 714             /* Mix-in class to handle each request in a new process. */
 715             frame.setlocal("active_children", frame.getname("None"));
 716             frame.setlocal("max_children", i$31);
 717             frame.setlocal("collect_children", new PyFunction(frame.f_globals, new PyObject[] {}, c$23_collect_children));
 718             frame.setlocal("process_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$24_process_request));
 719             return frame.getf_locals();
 720         }
 721
 722         private static PyObject process_request$27(PyFrame frame) {
 723             /* Start a new thread to process the request. */
 724             frame.setlocal(4, org.python.core.imp.importOne("threading", frame));
 725             frame.setlocal(3, frame.getlocal(4).__getattr__("Thread").__call__(new PyObject[] {frame.getlocal(0).__getattr__("finish_request"), new PyTuple(new PyObject[] {frame.getlocal(1), frame.getlocal(2)})}, new String[] {"target", "args"}));
 726             frame.getlocal(3).invoke("start");
 727             return Py.None;
 728         }
 729
 730         private static PyObject ThreadingMixIn$28(PyFrame frame) {
 731             /* Mix-in class to handle each request in a new thread. */
 732             frame.setlocal("process_request", new PyFunction(frame.f_globals, new PyObject[] {}, c$26_process_request));
 733             return frame.getf_locals();
 734         }
 735
 736         private static PyObject ForkingUDPServer$29(PyFrame frame) {
 737             // pass
 738             return frame.getf_locals();
 739         }
 740
 741         private static PyObject ForkingTCPServer$30(PyFrame frame) {
 742             // pass
 743             return frame.getf_locals();
 744         }
 745
 746         private static PyObject ThreadingUDPServer$31(PyFrame frame) {
 747             // pass
 748             return frame.getf_locals();
 749         }
 750
 751         private static PyObject ThreadingTCPServer$32(PyFrame frame) {
 752             // pass
 753             return frame.getf_locals();
 754         }
 755
 756         private static PyObject UnixStreamServer$33(PyFrame frame) {
 757             frame.setlocal("address_family", frame.getname("socket").__getattr__("AF_UNIX"));
 758             return frame.getf_locals();
 759         }
 760
 761         private static PyObject UnixDatagramServer$34(PyFrame frame) {
 762             frame.setlocal("address_family", frame.getname("socket").__getattr__("AF_UNIX"));
 763             return frame.getf_locals();
 764         }
 765
 766         private static PyObject ThreadingUnixStreamServer$35(PyFrame frame) {
 767             // pass
 768             return frame.getf_locals();
 769         }
 770
 771         private static PyObject ThreadingUnixDatagramServer$36(PyFrame frame) {
 772             // pass
 773             return frame.getf_locals();
 774         }
 775
 776         private static PyObject __init__$37(PyFrame frame) {
 777             frame.getlocal(0).__setattr__("request", frame.getlocal(1));
 778             frame.getlocal(0).__setattr__("client_address", frame.getlocal(2));
 779             frame.getlocal(0).__setattr__("server", frame.getlocal(3));
 780             try {
 781                 frame.getlocal(0).invoke("setup");
 782                 frame.getlocal(0).invoke("handle");
 783                 frame.getlocal(0).invoke("finish");
 784             }
 785             finally {
 786                 frame.getglobal("sys").__setattr__("exc_traceback", frame.getglobal("None"));
 787             }
 788             return Py.None;
 789         }
 790
 791         private static PyObject setup$38(PyFrame frame) {
 792             // pass
 793             return Py.None;
 794         }
 795
 796         private static PyObject __del__$39(PyFrame frame) {
 797             // pass
 798             return Py.None;
 799         }
 800
 801         private static PyObject handle$40(PyFrame frame) {
 802             // pass
 803             return Py.None;
 804         }
 805
 806         private static PyObject finish$41(PyFrame frame) {
 807             // pass
 808             return Py.None;
 809         }
 810
 811         private static PyObject BaseRequestHandler$42(PyFrame frame) {
 812             /* Base class for request handler classes.
 813
 814                 This class is instantiated for each request to be handled.  The
 815                 constructor sets the instance variables request, client_address
 816                 and server, and then calls the handle() method.  To implement a
 817                 specific service, all you need to do is to derive a class which
 818                 defines a handle() method.
 819
 820                 The handle() method can find the request as self.request, the
 821                 client address as self.client_address, and the server (in case it
 822                 needs access to per-server information) as self.server.  Since a
 823                 separate instance is created for each request, the handle() method
 824                 can define arbitrary other instance variariables.
 825
 826                  */
 827             frame.setlocal("__init__", new PyFunction(frame.f_globals, new PyObject[] {}, c$36___init__));
 828             frame.setlocal("setup", new PyFunction(frame.f_globals, new PyObject[] {}, c$37_setup));
 829             frame.setlocal("__del__", new PyFunction(frame.f_globals, new PyObject[] {}, c$38___del__));
 830             frame.setlocal("handle", new PyFunction(frame.f_globals, new PyObject[] {}, c$39_handle));
 831             frame.setlocal("finish", new PyFunction(frame.f_globals, new PyObject[] {}, c$40_finish));
 832             return frame.getf_locals();
 833         }
 834
 835         private static PyObject setup$43(PyFrame frame) {
 836             frame.getlocal(0).__setattr__("connection", frame.getlocal(0).__getattr__("request"));
 837             frame.getlocal(0).__setattr__("rfile", frame.getlocal(0).__getattr__("connection").invoke("makefile", s$48, frame.getlocal(0).__getattr__("rbufsize")));
 838             frame.getlocal(0).__setattr__("wfile", frame.getlocal(0).__getattr__("connection").invoke("makefile", s$49, frame.getlocal(0).__getattr__("wbufsize")));
 839             return Py.None;
 840         }
 841
 842         private static PyObject finish$44(PyFrame frame) {
 843             frame.getlocal(0).__getattr__("wfile").invoke("flush");
 844             frame.getlocal(0).__getattr__("wfile").invoke("close");
 845             frame.getlocal(0).__getattr__("rfile").invoke("close");
 846             return Py.None;
 847         }
 848
 849         private static PyObject StreamRequestHandler$45(PyFrame frame) {
 850             /* Define self.rfile and self.wfile for stream sockets. */
 851             frame.setlocal("rbufsize", i$22.__neg__());
 852             frame.setlocal("wbufsize", i$35);
 853             frame.setlocal("setup", new PyFunction(frame.f_globals, new PyObject[] {}, c$42_setup));
 854             frame.setlocal("finish", new PyFunction(frame.f_globals, new PyObject[] {}, c$43_finish));
 855             return frame.getf_locals();
 856         }
 857
 858         private static PyObject setup$46(PyFrame frame) {
 859             // Temporary Variables
 860             PyObject[] t$0$PyObject__;
 861
 862             // Code
 863             frame.setlocal(1, org.python.core.imp.importOne("StringIO", frame));
 864             t$0$PyObject__ = org.python.core.Py.unpackSequence(frame.getlocal(0).__getattr__("request"), 2);
 865             frame.getlocal(0).__setattr__("packet", t$0$PyObject__[0]);
 866             frame.getlocal(0).__setattr__("socket", t$0$PyObject__[1]);
 867             frame.getlocal(0).__setattr__("rfile", frame.getlocal(1).__getattr__("StringIO").__call__(frame.getlocal(0).__getattr__("packet")));
 868             frame.getlocal(0).__setattr__("wfile", frame.getlocal(1).__getattr__("StringIO").__call__());
 869             return Py.None;
 870         }
 871
 872         private static PyObject finish$47(PyFrame frame) {
 873             frame.getlocal(0).__getattr__("socket").invoke("sendto", frame.getlocal(0).__getattr__("wfile").invoke("getvalue"), frame.getlocal(0).__getattr__("client_address"));
 874             return Py.None;
 875         }
 876
 877         private static PyObject DatagramRequestHandler$48(PyFrame frame) {
 878             /* Define self.rfile and self.wfile for datagram sockets. */
 879             frame.setlocal("setup", new PyFunction(frame.f_globals, new PyObject[] {}, c$45_setup));
 880             frame.setlocal("finish", new PyFunction(frame.f_globals, new PyObject[] {}, c$46_finish));
 881             return frame.getf_locals();
 882         }
 883
 884         private static PyObject main$49(PyFrame frame) {
 885             frame.setglobal("__file__", s$51);
 886
 887             /* Generic socket server classes.
 888
 889             This module tries to capture the various aspects of defining a server:
 890
 891             For socket-based servers:
 892
 893             - address family:
 894                     - AF_INET: IP (Internet Protocol) sockets (default)
 895                     - AF_UNIX: Unix domain sockets
 896                     - others, e.g. AF_DECNET are conceivable (see <socket.h>
 897             - socket type:
 898                     - SOCK_STREAM (reliable stream, e.g. TCP)
 899                     - SOCK_DGRAM (datagrams, e.g. UDP)
 900
 901             For request-based servers (including socket-based):
 902
 903             - client address verification before further looking at the request
 904                     (This is actually a hook for any processing that needs to look
 905                      at the request before anything else, e.g. logging)
 906             - how to handle multiple requests:
 907                     - synchronous (one request is handled at a time)
 908                     - forking (each request is handled by a new process)
 909                     - threading (each request is handled by a new thread)
 910
 911             The classes in this module favor the server type that is simplest to
 912             write: a synchronous TCP/IP server.  This is bad class design, but
 913             save some typing.  (There's also the issue that a deep class hierarchy
 914             slows down method lookups.)
 915
 916             There are five classes in an inheritance diagram, four of which represent
 917             synchronous servers of four types:
 918
 919                     +------------+
 920                     | BaseServer |
 921                     +------------+
 922                           |
 923                           v
 924                     +-----------+        +------------------+
 925                     | TCPServer |------->| UnixStreamServer |
 926                     +-----------+        +------------------+
 927                           |
 928                           v
 929                     +-----------+        +--------------------+
 930                     | UDPServer |------->| UnixDatagramServer |
 931                     +-----------+        +--------------------+
 932
 933             Note that UnixDatagramServer derives from UDPServer, not from
 934             UnixStreamServer -- the only difference between an IP and a Unix
 935             stream server is the address family, which is simply repeated in both
 936             unix server classes.
 937
 938             Forking and threading versions of each type of server can be created
 939             using the ForkingServer and ThreadingServer mix-in classes.  For
 940             instance, a threading UDP server class is created as follows:
 941
 942                     class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass
 943
 944             The Mix-in class must come first, since it overrides a method defined
 945             in UDPServer!
 946
 947             To implement a service, you must derive a class from
 948             BaseRequestHandler and redefine its handle() method.  You can then run
 949             various versions of the service by combining one of the server classes
 950             with your request handler class.
 951
 952             The request handler class must be different for datagram or stream
 953             services.  This can be hidden by using the mix-in request handler
 954             classes StreamRequestHandler or DatagramRequestHandler.
 955
 956             Of course, you still have to use your head!
 957
 958             For instance, it makes no sense to use a forking server if the service
 959             contains state in memory that can be modified by requests (since the
 960             modifications in the child process would never reach the initial state
 961             kept in the parent process and passed to each child).  In this case,
 962             you can use a threading server, but you will probably have to use
 963             locks to avoid two requests that come in nearly simultaneous to apply
 964             conflicting changes to the server state.
 965
 966             On the other hand, if you are building e.g. an HTTP server, where all
 967             data is stored externally (e.g. in the file system), a synchronous
 968             class will essentially render the service "deaf" while one request is
 969             being handled -- which may be for a very long time if a client is slow
 970             to reqd all the data it has requested.  Here a threading or forking
 971             server is appropriate.
 972
 973             In some cases, it may be appropriate to process part of a request
 974             synchronously, but to finish processing in a forked child depending on
 975             the request data.  This can be implemented by using a synchronous
 976             server and doing an explicit fork in the request handler class
 977             handle() method.
 978
 979             Another approach to handling multiple simultaneous requests in an
 980             environment that supports neither threads nor fork (or where these are
 981             too expensive or inappropriate for the service) is to maintain an
 982             explicit table of partially finished requests and to use select() to
 983             decide which request to work on next (or whether to handle a new
 984             incoming request).  This is particularly important for stream services
 985             where each client can potentially be connected for a long time (if
 986             threads or subprocesses cannot be used).
 987
 988             Future work:
 989             - Standard classes for Sun RPC (which uses either UDP or TCP)
 990             - Standard mix-in classes to implement various authentication
 991               and encryption schemes
 992             - Standard framework for select-based multiplexing
 993
 994             XXX Open problems:
 995             - What to do with out-of-band data?
 996
 997             BaseServer:
 998             - split generic "request" functionality out into BaseServer class.
 999               Copyright (C) 2000  Luke Kenneth Casson Leighton <lkcl@samba.org>
1000
1001               example: read entries from a SQL database (requires overriding
1002               get_request() to return a table entry from the database).
1003               entry is processed by a RequestHandlerClass.
1004
1005              */
1006             frame.setlocal("__version__", s$1);
1007             frame.setlocal("socket", org.python.core.imp.importOne("socket", frame));
1008             frame.setlocal("sys", org.python.core.imp.importOne("sys", frame));
1009             frame.setlocal("os", org.python.core.imp.importOne("os", frame));
1010             frame.setlocal("__all__", new PyList(new PyObject[] {s$2, s$3, s$4, s$5, s$6, s$7, s$8, s$9, s$10, s$11, s$12}));
1011             if (frame.getname("hasattr").__call__(frame.getname("socket"), s$13).__nonzero__()) {
1012                 frame.getname("__all__").invoke("extend", new PyList(new PyObject[] {s$14, s$15, s$16, s$17}));
1013             }
1014             frame.setlocal("BaseServer", Py.makeClass("BaseServer", new PyObject[] {}, c$10_BaseServer, null));
1015             frame.setlocal("TCPServer", Py.makeClass("TCPServer", new PyObject[] {frame.getname("BaseServer")}, c$18_TCPServer, null));
1016             frame.setlocal("UDPServer", Py.makeClass("UDPServer", new PyObject[] {frame.getname("TCPServer")}, c$22_UDPServer, null));
1017             frame.setlocal("ForkingMixIn", Py.makeClass("ForkingMixIn", new PyObject[] {}, c$25_ForkingMixIn, null));
1018             frame.setlocal("ThreadingMixIn", Py.makeClass("ThreadingMixIn", new PyObject[] {}, c$27_ThreadingMixIn, null));
1019             frame.setlocal("ForkingUDPServer", Py.makeClass("ForkingUDPServer", new PyObject[] {frame.getname("ForkingMixIn"), frame.getname("UDPServer")}, c$28_ForkingUDPServer, null));
1020             frame.setlocal("ForkingTCPServer", Py.makeClass("ForkingTCPServer", new PyObject[] {frame.getname("ForkingMixIn"), frame.getname("TCPServer")}, c$29_ForkingTCPServer, null));
1021             frame.setlocal("ThreadingUDPServer", Py.makeClass("ThreadingUDPServer", new PyObject[] {frame.getname("ThreadingMixIn"), frame.getname("UDPServer")}, c$30_ThreadingUDPServer, null));
1022             frame.setlocal("ThreadingTCPServer", Py.makeClass("ThreadingTCPServer", new PyObject[] {frame.getname("ThreadingMixIn"), frame.getname("TCPServer")}, c$31_ThreadingTCPServer, null));
1023             if (frame.getname("hasattr").__call__(frame.getname("socket"), s$13).__nonzero__()) {
1024                 frame.setlocal("UnixStreamServer", Py.makeClass("UnixStreamServer", new PyObject[] {frame.getname("TCPServer")}, c$32_UnixStreamServer, null));
1025                 frame.setlocal("UnixDatagramServer", Py.makeClass("UnixDatagramServer", new PyObject[] {frame.getname("UDPServer")}, c$33_UnixDatagramServer, null));
1026                 frame.setlocal("ThreadingUnixStreamServer", Py.makeClass("ThreadingUnixStreamServer", new PyObject[] {frame.getname("ThreadingMixIn"), frame.getname("UnixStreamServer")}, c$34_ThreadingUnixStreamServer, null));
1027                 frame.setlocal("ThreadingUnixDatagramServer", Py.makeClass("ThreadingUnixDatagramServer", new PyObject[] {frame.getname("ThreadingMixIn"), frame.getname("UnixDatagramServer")}, c$35_ThreadingUnixDatagramServer, null));
1028             }
1029             frame.setlocal("BaseRequestHandler", Py.makeClass("BaseRequestHandler", new PyObject[] {}, c$41_BaseRequestHandler, null));
1030             frame.setlocal("StreamRequestHandler", Py.makeClass("StreamRequestHandler", new PyObject[] {frame.getname("BaseRequestHandler")}, c$44_StreamRequestHandler, null));
1031             frame.setlocal("DatagramRequestHandler", Py.makeClass("DatagramRequestHandler", new PyObject[] {frame.getname("BaseRequestHandler")}, c$47_DatagramRequestHandler, null));
1032             return Py.None;
1033         }
1034
1035     }
1036     public static void moduleDictInit(PyObject dict) {
1037         dict.__setitem__("__name__", new PyString("SocketServer"));
1038         Py.runCode(new _PyInner().getMain(), dict, dict);
1039     }
1040
1041     public static void main(String[] args) throws java.lang.Exception {
1042         String[] newargs = new String[args.length+1];
1043         newargs[0] = "SocketServer";
1044         System.arraycopy(args, 0, newargs, 1, args.length);
1045         Py.runMain(SocketServer._PyInner.class, newargs, SocketServer.jpy$packages, SocketServer.jpy$mainProperties, "", new String[] {"string", "random", "util", "traceback", "sre_compile", "atexit", "sre", "sre_constants", "StringIO", "javaos", "socket", "yapm", "calendar", "repr", "copy_reg", "SocketServer", "server", "re", "linecache", "javapath", "UserDict", "copy", "threading", "stat", "PathVFS", "sre_parse"});
1046     }
1047
1048 }