Drop broken, unused code

src/sugar/network.py

@@ -474,119 +474,3 @@ class _Method:
         return _Method(self.__send, "%s.%s" % (self.__name, name))
     def __call__(self, *args, **kwargs):
         return self.__send(self.__name, *args, **kwargs)
-
-
-class GlibServerProxy(xmlrpclib.ServerProxy):
-    """Subclass xmlrpclib.ServerProxy so we can run the XML-RPC request
-    in two parts, integrated with the glib mainloop, such that we don't
-    block anywhere.
-    
-    Using this object is somewhat special; it requires more arguments to each
-    XML-RPC request call than the normal xmlrpclib.ServerProxy object:
-    
-    client = GlibServerProxy("http://127.0.0.1:8888")
-    user_data = "bar"
-    xmlrpc_arg1 = "test"
-    xmlrpc_arg2 = "foo"
-    client.test(xmlrpc_test_cb, user_data, xmlrpc_arg1, xmlrpc_arg2)
-
-    Here, 'xmlrpc_test_cb' is the callback function, which has the following
-    signature:
-    
-    def xmlrpc_test_cb(result_status, response, user_data=None):
-        ...
-    """
-    def __init__(self, uri, encoding=None, verbose=0, allow_none=0):
-        self._transport = GlibXMLRPCTransport()
-        self._encoding = encoding
-        self._verbose = verbose
-        self._allow_none = allow_none
-        xmlrpclib.ServerProxy.__init__(self, uri, self._transport,
-                                       encoding, verbose, allow_none)
-
-        # get the url
-        urltype, uri = urllib.splittype(uri)
-        if urltype not in ("http", "https"):
-            raise IOError, "unsupported XML-RPC protocol"
-        self._host, self._handler = urllib.splithost(uri)
-        if not self._handler:
-            self._handler = "/RPC2"
-
-    def __request(self, methodname, *args, **kwargs):
-        """Call the method on the remote server.  We just start the request here
-        and the transport itself takes care of scheduling the response callback
-        when the remote server returns the response.
-        We don't want to block anywhere."""
-
-        request = xmlrpclib.dumps(args, methodname, encoding=self._encoding,
-                        allow_none=self._allow_none)
-
-        reply_hdl = kwargs.get("reply_handler")
-        err_hdl = kwargs.get("error_handler")
-        udata = kwargs.get("user_data")
-        try:
-            response = self._transport.start_request(
-                self._host,
-                self._handler,
-                request,
-                verbose=self._verbose,
-                reply_handler=reply_hdl,
-                error_handler=err_hdl,
-                user_data=udata
-                )
-        except socket.error, exc:
-            if err_hdl:
-                gobject.idle_add(err_hdl, exc, udata)
-
-    def __getattr__(self, name):
-        # magic method dispatcher
-        return _Method(self.__request, name)
-
-
-class Test(object):
-    def test(self, arg1, arg2):
-        print "Request got %s, %s" % (arg1, arg2)
-        return "success", "bork"
-
-def xmlrpc_success_cb(response, resp2, loop):
-    print "Response was %s %s" % (response, resp2)
-    loop.quit()
-
-def xmlrpc_error_cb(err, loop):
-    print "Error: %s" % err
-    loop.quit()
-
-def xmlrpc_test(loop):
-    client = GlibServerProxy("http://127.0.0.1:8888")
-    client.test("bar", "baz",
-                reply_handler=xmlrpc_success_cb,
-                error_handler=xmlrpc_error_cb,
-                user_data=loop)
-
-def start_xmlrpc():
-    server = GlibXMLRPCServer(("", 8888))
-    inst = Test()
-    server.register_instance(inst)
-    gobject.idle_add(xmlrpc_test, loop)
-
-class TestReqHandler(ChunkedGlibHTTPRequestHandler):
-    def translate_path(self, path):
-        return "/tmp/foo"
-
-def start_http():
-    server = GlibTCPServer(("", 8890), TestReqHandler)
-
-def main():
-    loop = gobject.MainLoop()
-#    start_xmlrpc()
-    start_http()
-    try:
-        loop.run()
-    except KeyboardInterrupt:
-        print 'Ctrl+C pressed, exiting...'
-    print "Done."
-
-if __name__ == "__main__":
-    main()
-
-