Python HTTPServer.allow_reuse_address Examples

Example #1

def serve(port, file_):
    try:
        shelf = shelve.open(file_, "r")

        class HTTPRequestHandler(BaseHTTPRequestHandler):
            def do_GET(self):
                try:
                    path = urllib2.unquote(self.path)
                    path = path.replace("+", " ")
                    path_m = re.search(r'(?:http://[^/]*/+(.*)|/*(.*))', path)
                    if path_m:
                        name_ = path_m.group(1) or path_m.group(2)
                        content = shelf[name_]
                        self.send_response(200)
                        self.send_header("Content-Type",
                                         "text/plain; charset=UTF-8")
                        self.end_headers()
                        self.wfile.write(content.encode("UTF-8"))
                except:
                    self.send_response(404)
                    self.send_header("Content-Type", "text/plain")
                    self.end_headers()
                    (a, b, t) = sys.exc_info()
                    self.wfile.write("".join(
                        traceback.format_exception(a, b, t)))

        httpd = HTTPServer(("0.0.0.0", port), HTTPRequestHandler)
        httpd.allow_reuse_address = True
        httpd.serve_forever()

    except KeyboardInterrupt:
        httpd.socket.close()
        sys.exit(0)

Example #2

File: wikishelve_server.py Project: vi/wiki_dump_and_read

def serve(port, file_):
    try:
        shelf = shelve.open(file_, "r")

        class HTTPRequestHandler(BaseHTTPRequestHandler):
            
            def do_GET(self):
                try:
                    path = urllib2.unquote(self.path);
                    path = path.replace("+", " ");
                    path_m = re.search(r'(?:http://[^/]*/+(.*)|/*(.*))', path);
                    if path_m:
                        name_ = path_m.group(1) or path_m.group(2)
                        content = shelf[name_]
                        self.send_response(200)
                        self.send_header("Content-Type", "text/plain; charset=UTF-8");
                        self.end_headers();
                        self.wfile.write(content.encode("UTF-8"))
                except:
                    self.send_response(404)
                    self.send_header("Content-Type", "text/plain");
                    self.end_headers();
                    (a,b,t) = sys.exc_info()
                    self.wfile.write("".join(traceback.format_exception(a,b,t)))

        httpd = HTTPServer(("0.0.0.0", port), HTTPRequestHandler);
        httpd.allow_reuse_address = True;
        httpd.serve_forever();

    except KeyboardInterrupt:
        httpd.socket.close();
        sys.exit(0);

Example #3

def TivoServerThread(ip, port):
    try:
        httpserver = HTTPServer((ip, port), MyVideoHandler)
        Log("Server Starting: %i pid %i" % (port, getpid()))
        httpserver.allow_reuse_address = True
        httpserver.serve_forever()
        Log("Server Ooopsed out %i" % port)
    except:
        Log("Server Already Running or port in use")

Example #4

File: __init__.py Project: renegaudet/TiVoToGo.bundle

def TivoServerThread(ip, port):
    try:
        httpserver = HTTPServer((ip, port), MyVideoHandler)
        Log("Server starting: port %i, PID %i" % (port, getpid()))
        httpserver.allow_reuse_address = True
        httpserver.serve_forever()
        Log("Server ooopsed out: port %i" % port)
    except:
        Log("Server already running or port in use")

Example #5

File: __init__.py Project: GVMike/TiVoToGo.bundle

def TivoServerThread(ip, port):
  try:
    httpserver = HTTPServer((ip, port), MyVideoHandler)
    Log("Server Starting: %i pid %i" % (port, getpid()))
    httpserver.allow_reuse_address = True
    httpserver.serve_forever()
    Log("Server Ooopsed out %i" % port)
  except :
    Log("Server Already Running or port in use")

Example #6

File: server.py Project: raluca-elena/daisy_cam

def run():       
    print('at the beginning of the server side: ')
    thread.start_new_thread( base_conn_funct.initiate_board_conn , (conn_pool, ) )
    thread.start_new_thread(base_conn_funct.verify_conn, (conn_pool, ))
    server_address = ('0.0.0.0', 8989)
    httpd = HTTPServer(server_address, HTTPRequestHandler)
    print('http server is running...')
    httpd.allow_reuse_address = True

    httpd.serve_forever()

Example #7

File: metrics.py Project: wz-h/pythonwise

def serve_metrics(port):
    '''Serve metrics via HTTP/JSON on port.'''

    server = HTTPServer(('localhost', port), Handler)
    server.allow_reuse_address = True

    t = Thread(target=server.serve_forever)
    t.daemon = True
    t.start()

    return server

Example #8

File: tool.py Project: wangkirin/avro

def run_server(uri, proto, msg, datum):
  url_obj = urlparse.urlparse(uri)
  server_addr = (url_obj.hostname, url_obj.port)
  global responder
  global server_should_shutdown
  server_should_shutdown = False
  responder = GenericResponder(proto, msg, datum)
  server = HTTPServer(server_addr, GenericHandler)
  print "Port: %s" % server.server_port
  sys.stdout.flush()
  server.allow_reuse_address = True
  print >> sys.stderr, "Starting server."
  server.serve_forever()

Example #9

File: dalek.py Project: MasterPpv/ENG-198-Project

def main(args):
	#play_sound(exterminate)	
	usage()
        setup_usb()
	server = HTTPServer(('', 7000), turretHandler)
	#Thread_listen(threading.Thread(),listen)
	thread.start_new_thread(listen,(server,))	
	
	
	server.allow_reuse_address = True
	server.serve_forever()
	
	sys.exit(0)

Example #10

File: test_dalek.py Project: MasterPpv/ENG-198-Project

def main(args):
    # play_sound(exterminate)
    usage()
    # setup_usb()
    talker = talk()
    server = HTTPServer(("", 7000), pyshoter)
    # Thread_listen(threading.Thread(),listen)
    # thread.start_new_thread(listen, ("self",talker))

    server.allow_reuse_address = True
    server.serve_forever()

    sys.exit(0)

Example #11

	
	opts,_ = getopt.getopt(sys.argv[1:], "hp:")
	for op,val in opts:
		if op == '-h':
			usage()
			sys.exit()
		elif op == '-p':
			if val.isdigit():
				port = int(val)
			else:
				print "Wrong port number"
				sys.exit()

        
	global serv
	#serv = ThreadingTcpServer(("", port), TrafficRequestHandler)
	serv = HTTPServer(("", port), TrafficRequestHandler)
	serv.allow_reuse_address = True
	
	startwork()
	serv.serve_forever()
        if stop_thd:
                stop_thd.join()
        print "Main exits."
        
        #debug
        #import collect
        #collect.collect(tasks[0])
        #collect.fetchstatistic(flume, 'hdfs-mobile', 'bytes')

Example #12

File: mock_tether_parent.py Project: YiTian0902/RA_JavaPaser_Homework

        call_request_reader = ipc.FramedReader(self.rfile)
        call_request = call_request_reader.read_framed_message()
        resp_body = self.responder.respond(call_request)
        self.send_response(200)
        self.send_header('Content-Type', 'avro/binary')
        self.end_headers()
        resp_writer = ipc.FramedWriter(self.wfile)
        resp_writer.write_framed_message(resp_body)


if __name__ == '__main__':
    if (len(sys.argv) <= 1):
        raise ValueError("Usage: mock_tether_parent command")

    cmd = sys.argv[1].lower()
    if (sys.argv[1] == 'start_server'):
        if (len(sys.argv) == 3):
            port = int(sys.argv[2])
        else:
            raise ValueError("Usage: mock_tether_parent start_server port")

        SERVER_ADDRESS = (SERVER_ADDRESS[0], port)
        print "mock_tether_parent: Launching Server on Port: {0}".format(
            SERVER_ADDRESS[1])

        # flush the output so it shows up in the parent process
        sys.stdout.flush()
        parent_server = HTTPServer(SERVER_ADDRESS, MockParentHandler)
        parent_server.allow_reuse_address = True
        parent_server.serve_forever()

Example #13

File: avro_rpc_server.py Project: darrenmoen/python-avro-rpc-pcap

class MailResponder(ipc.Responder):
    def __init__(self):
        ipc.Responder.__init__(self, PROTOCOL)

    def invoke(self, msg, req):
        if msg.name == 'send':
            message = req['message']
            return ("Sent message to " + message['to']
                    + " from " + message['from']
                    + " with body " + message['body'])
        else:
            raise schema.AvroException("unexpected message:", msg.getname())

class MailHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        self.responder = MailResponder()
        call_request_reader = ipc.FramedReader(self.rfile)
        call_request = call_request_reader.read_framed_message()
        resp_body = self.responder.respond(call_request)
        self.send_response(200)
        self.send_header('Content-Type', 'avro/binary')
        self.end_headers()
        resp_writer = ipc.FramedWriter(self.wfile)
        resp_writer.write_framed_message(resp_body)



if __name__ == '__main__':
    server = HTTPServer(HOST, MailHandler)
    server.allow_reuse_address = True
    server.serve_forever()

Example #14

class MailResponder(ipc.Responder):
  def __init__(self):
    ipc.Responder.__init__(self, MAIL_PROTOCOL)

  def invoke(self, message, request):
    if message.name == 'send':
      request_content = request['message']
      response = "Sent message to %(to)s from %(from)s with body %(body)s" % \
                 request_content
      return response
    elif message.name == 'replay':
      return 'replay'

class MailHandler(BaseHTTPRequestHandler):
  def do_POST(self):
    self.responder = MailResponder()
    call_request_reader = ipc.FramedReader(self.rfile)
    call_request = call_request_reader.read_framed_message()
    resp_body = self.responder.respond(call_request)
    self.send_response(200)
    self.send_header('Content-Type', 'avro/binary')
    self.end_headers()
    resp_writer = ipc.FramedWriter(self.wfile)
    resp_writer.write_framed_message(resp_body)

if __name__ == '__main__':
  mail_server = HTTPServer(SERVER_ADDRESS, MailHandler)
  mail_server.allow_reuse_address = True
  mail_server.serve_forever()

Example #15

File: 02.pingpong.py Project: team-herring/herring-box

def start_server():
    server = HTTPServer(server_addr, PingpongHandler)
    server.allow_reuse_address = True
    server.serve_forever()

Example #16

def start(thermostat,prefs):
	log.info("Starting server.")
	server = HTTPServer(('', PORT), RequestHandler)
	server.context = {'thermostat': thermostat, 'prefs':prefs}
	server.allow_reuse_address = True
	server.serve_forever()

Example #17

def start_server():
    server = HTTPServer(server_addr, PingpongHandler)
    server.allow_reuse_address = True
    server.serve_forever()