def main():
smsolver = small_solvers(queue_local, Usersolver, poly_small_threads)
# Reuse the port to debug
TCPServer.allow_reuse_address = True
ss = TCPServer(("0.0.0.0", portnumber), PHC_Server)
print "server is listening to", portnumber
try:
print "press ctrl c to stop server"
ss.serve_forever()
except KeyboardInterrupt:
print " ctrl c pressed, closing server"
if queue:
print "writing recover file"
save_queue(queue)
print "closing solver threads"
for i in range(poly_small_threads):
smsolver[i]._Thread__stop()
print "server closed"
ss.socket.close()
def setUp(self):
handler = SimpleHTTPRequestHandler
httpd = TCPServer(("", PORT), handler)
httpd.allow_reuse_address = True
self.httpd_thread = Thread(target=httpd.serve_forever)
self.httpd_thread.setDaemon(True)
self.httpd_thread.start()
class jeedom_socket():
def __init__(self,address='localhost', port=55000):
self.address = address
self.port = port
SocketServer.TCPServer.allow_reuse_address = True
def open(self):
self.netAdapter = TCPServer((self.address, self.port), jeedom_socket_handler)
if self.netAdapter:
logging.debug("Socket interface started")
threading.Thread(target=self.loopNetServer, args=()).start()
else:
logging.debug("Cannot start socket interface")
def loopNetServer(self):
logging.debug("LoopNetServer Thread started")
logging.debug("Listening on: [%s:%d]" % (self.address, self.port))
self.netAdapter.serve_forever()
logging.debug("LoopNetServer Thread stopped")
def close(self):
self.netAdapter.shutdown()
def getMessage(self):
return self.message
# ------------------------------------------------------------------------------
# END
# ------------------------------------------------------------------------------
def __init__(self, addr, request_handler):
# hmm, TCPServer is not sub-classed from object!
if issubclass(TCPServer, object):
super(TCPServerWrapper, self).__init__(addr, request_handler)
else:
TCPServer.__init__(self, addr, request_handler)
self.running = False
def test_make_fetcher():
symmetric362 = SPHERE_FILES['symmetric362']
with TemporaryDirectory() as tmpdir:
stored_md5 = fetcher._get_file_md5(symmetric362)
# create local HTTP Server
testfile_url = op.split(symmetric362)[0] + os.sep
test_server_url = "http://127.0.0.1:8000/"
print(testfile_url)
print(symmetric362)
current_dir = os.getcwd()
# change pwd to directory containing testfile.
os.chdir(testfile_url)
server = HTTPServer(('localhost', 8000), SimpleHTTPRequestHandler)
server_thread = Thread(target=server.serve_forever)
server_thread.deamon = True
server_thread.start()
# test make_fetcher
sphere_fetcher = fetcher._make_fetcher("sphere_fetcher",
tmpdir, test_server_url,
[op.split(symmetric362)[-1]],
["sphere_name"],
md5_list=[stored_md5])
sphere_fetcher()
assert op.isfile(op.join(tmpdir, "sphere_name"))
npt.assert_equal(fetcher._get_file_md5(op.join(tmpdir, "sphere_name")),
stored_md5)
# stop local HTTP Server
server.shutdown()
# change to original working directory
os.chdir(current_dir)
def main(argv):
IP = socket.gethostbyname(socket.getfqdn())
PORT = 8080
try:
opts, args = getopt.getopt(argv,"hd:i:p:",["dir=","ip=","port="])
if not opts:
raise getopt.GetoptError('NULL options', argv)
except getopt.GetoptError:
print 'abookrss.py -d/--dir= <dir_with_mp3> [-i/--ip=<ip_to_bind>] [-p/--port=8080]'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'abookrss.py -d/--dir= <dir_with_mp3> [-i/--ip=<ip_to_bind>] [-p/--port=port]'
sys.exit()
elif opt in ("-d", "--dir"):
FOLDER = arg
elif opt in ("-i", "--ip"):
IP = arg
elif opt in ("-p", "--port"):
PORT = int(arg)
RES = RSSBook(FOLDER, IP, PORT)
RES.generate()
os.chdir(FOLDER)
SERV = TCPServer(('', PORT), SimpleHTTPRequestHandler)
print('serving at %s:%d' % (IP, PORT))
SERV.serve_forever()
def __init__(self, address, handler, max_proc = 4, bitstream_directory="/boffiles/", offline = False):
"""
@max_proc (DON'T CHANGE): number of fpgas, or maximum number of bitstreams that can be run simultaneously on the machine
@bitstream_directory : directory containing bitstreams(.bof files) that should be run on the machine
"""
self._logger = logging.getLogger('BORPHControl')
if not offline:
TCPServer.__init__(self, address, handler)
self._logger.debug('__init__')
self._command_set = { 8 : self.get_resource,
9 : self.set_resource,
10 : self.kill_resource,
32 : self.get_values,
33 : self.set_values,
34 : self.get_values_binary,
35 : self.set_values_binary,
}
else:
self._logger.info('BORPHControl was initialized in offline mode!!!!')
self.max_proc = max_proc ##Maximum number of bitstreams that can be run simultaneously.
self.processes = {} # a dictionary mapping bitstreams to PIDs
## self.proc_dir = "/proc/"
## self.registers_subfolder = "/hw/ioreg/"
self.bitstream_directory = bitstream_directory
def serve(path=settings.OUTPUT_DIR, port=8000):
old_working_dir = getcwd()
chdir(path)
new_working_dir = getcwd()
httpd = TCPServer(("", port), SimpleHTTPRequestHandler)
print 'Starting development server rooted at %s' % new_working_dir
httpd.serve_forever()
def server():
addr = ("",PORT)
#sock = socket.socket()
#sock.bind(addr)
#handel = StreamRequestHandler(request,'','')
serv = TCPServer(addr,TransRequestHandler)
serv.serve_forever()
def __init__(self, code):
self.allow_reuse_address = True
TCPServer.__init__(self, ('localhost', 0), _RequestHandler)
self.log = io.StringIO()
self.requests = []
self.main_thread = None
self.code = code
def __init__(self, server_address, client):
self._client = client
if 1:
address6 = server_address[0].split("|")[1]
server_address6= (address6,server_address[1] )
TCPServer.__init__(self, ("",server_address6[1]), Uploader)
def main():
host = ''
port = 2048
addr = (host, port)
thread.start_new_thread(timer_thread, ())
server = TCPServer(addr, MyRequestHandler)
server.serve_forever()
def __init__(
self,
server_address,
q_recv,
q_send,
client_poll=0.001
):
# thread super
Thread.__init__(self, name='SimIOServer')
self.daemon = True
# members
self.q_recv = q_recv # singleton receive queue
self.q_send = q_send # incomming send queue
self.send_queues = {}
self.send_queues_lock = Lock()
self.client_poll = client_poll
self._status = None
self._serving = False
self._is_shutdown = Event()
self._is_shutdown.set()
# TCPerver super
TCPServer.__init__(self, server_address, SimIOProtocol, False)
def main():
try:
from SimpleHTTPServer import SimpleHTTPRequestHandler
except ImportError:
from http.server import SimpleHTTPRequestHandler
try:
from SocketServer import TCPServer as HTTPServer
# from BaseHTTPServer import HTTPServer
except ImportError:
from http.server import HTTPServer
# simple web server
# serves files relative to the current directory.
try:
server_port = int(sys.argv[1])
except:
server_port = default_port()
httpd = HTTPServer(("", server_port), SimpleHTTPRequestHandler)
#httpd.header.send_header("Access-Control-Allow-Origin", "*")
print("serving at port {0}".format(server_port))
# Let's cleanup after ourselves
def signal_handler(signal,frame):
print("\nCleaning up\n")
httpd.shutdown
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
httpd.serve_forever()
def run(self):
server = TCPServer(self.addr, self.app)
try:
self.logger.info('Maria System Start at %s:%s' % self.addr)
server.serve_forever()
except KeyboardInterrupt:
self.logger.info('Maria System Stopped')
def __init__(self, server_address, RequestHandlerClass, container,
thread_class = Thread):
self.allow_reuse_address = True
TCPServer.__init__(self, server_address, RequestHandlerClass)
CustomThreadingMixIn.__init__(self, thread_class)
self.container = container
self.daemon_threads = True
def server_bind(self): if OsInterfaceIsSupported(): try: self.socket.setsockopt(socket.SOL_SOCKET, 25, settings.Config.Bind_To+'\0') except: pass TCPServer.server_bind(self)
def server_activate(self):
ui('Server started successfully')
logging.debug('Listening on http://%s:%s/' % self.server_address)
if platform.python_version_tuple()[0] == '2':
TCPServer.server_activate(self)
else:
super().server_activate()
def __init__(self, server_address, RequestHandlerClass,
secret, dirname):
TCPServer.__init__(self, server_address, RequestHandlerClass)
self.secret = secret
self.dirname = dirname
self.block_size = int(config().get('global',
'block_size'))
class TuneServer(threading.Thread):
"""A TuneServer is a thread that initializes and runs a HTTPServer.
The server handles requests from a TuneClient.
Attributes:
runner (TrialRunner): Runner that modifies and accesses trials.
port_forward (int): Port number of TuneServer.
"""
DEFAULT_PORT = 4321
def __init__(self, runner, port=None):
"""Initialize HTTPServer and serve forever by invoking self.run()"""
threading.Thread.__init__(self)
self._port = port if port else self.DEFAULT_PORT
address = ('localhost', self._port)
logger.info("Starting Tune Server...")
self._server = HTTPServer(address, RunnerHandler(runner))
self.daemon = True
self.start()
def run(self):
self._server.serve_forever()
def shutdown(self):
"""Shutdown the underlying server."""
self._server.shutdown()
def __init__(self, addr):
self.allow_reuse_address = 1
self.hostname, self.port = addr
TCPServer.__init__(self, addr, ServerRequestHandler)
# shared state
self.data = dict()
# set server defaults
self.data = {
u'started_at' : datetime.now(),
u'port' : self.port,
u'hostname' : Config.hostname,
u'running' : True
}
# create a shared Data object
self.manager = DataManager(address=('', self.port + 1),
authkey=Config.authkey)
# "Private" methods ('__'-prefixed) are *not* exported out of
# the manager by default. This includes stuff to make dict work
# minimally. See
# http://docs.python.org/library/multiprocessing.html
#
# Upshot is we need to explicitly name the exposed functions:
DataManager.register('get_data', callable=lambda: self.data,
exposed=('__str__', '__delitem__', '__getitem__',
'__setitem__'))
self.manager.start()
self.manager.connect()
self.data = self.manager.get_data()
def start(self):
TCPServer.__init__(self, ('localhost', int(HTTP_PORT)), CustomHandler)
self.RESOURCE_LOCATION = path.abspath(path.dirname(__file__))
print "Server serving from DocumentRoot:" + self.RESOURCE_LOCATION
chdir(self.RESOURCE_LOCATION)
server_thread = threading.Thread(target=self.serve_forever)
server_thread.daemon = True
server_thread.start()
def shutdown(self, reason=''):
for client in self.clients:
client.close_connection(reason)
msg = 'Stop server'
if reason:
msg += ' because %s' % reason
self.log_info(msg)
TCPServer.shutdown(self)
def __init__(self, server_address, RequestHandlerClass):
TCPServer.__init__(self, server_address, RequestHandlerClass)
self._shutdown_request = False
# watchdog guards against the failure mode when the remote target fails
# to send any packets. If the watchdog reaches the high water mark, the
# server is terminated so as not to leave the server thread unterminated
self.watchdog = 0.0
def start(self, resource_root="../../src/test/resources"):
TCPServer.__init__(self, ('localhost', int(HTTP_PORT)), CustomHandler)
self.RESOURCE_LOCATION = path.abspath(resource_root)
print "Server serving from DocumentRoot:" + self.RESOURCE_LOCATION
chdir(self.RESOURCE_LOCATION)
server_thread = threading.Thread(target=self.serve_forever)
server_thread.daemon = True
server_thread.start()
def __init__(self, server_address, RequestHandlerClass, controller):
"""Constructor. May be extended, do not override."""
TCPServer.__init__(self, server_address, RequestHandlerClass)
# XXX - controller = MudMaster?
self.controller = controller
self.active = True
self.souls = []
self.greeting_msg = GREETING
def __init__(self, server_address=('', 8080)):
TCPServer.__init__(self,
server_address,
RequestHandler
)
self.sinks = [ ]
self.is_playing = False
self.lock = threading.Lock()
def __init__(self, west):
self.west = west
self.jc_mine = west.jc['wsts']
TCPServer.__init__(self, (self.jc_mine['addr'], self.jc_mine['port']),
ExtendedWebSocketHandler)
self.set_fn_new_client(self.new_client)
self.set_fn_client_left(self.client_left)
self.set_fn_message_received(self.message_received)
def start_wsKeyboard_server(port=DEFAULT_PORT):
httpd = TCPServer(('', port), WsKeyboardRequestHandler)
for address in get_addresses():
print 'ws://%s:%d/' % (address, port)
httpd.serve_forever()
def shutdown(self): myPID = os.getpid() path = os.path.join(tempfile.gettempdir(), "sublime_invite." + str(myPID)) if os.path.isfile(path) == True: os.remove(path) TCPServer.shutdown(self) TCPServer.server_close(self) self.trd.join() del self.trd
def shutdown(self):
"""Completely shutdown the server and close it's socket."""
TCPServer.shutdown(self)
self.server_close()
self.ae._servers.remove(self)
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyRequestHandle(SRH):
def handle(self):
print '...connected from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServ = TCP(ADDR, MyRequestHandle)
print 'Waiting for connection...'
tcpServ.serve_forever()
def startServer(self):
#绑定套接字
Server = TCPServer((self.serverAddress, self.serverPort),
CustomTcpHandler)
Server.serve_forever()
def __init__(self, address, port):
self.httpd = TCPServer((address, port), self)
self.thread = None
manager = OneServerManager()
self.log = manager.log
luma = LUMA(FILE)
# load the LUMA configuration data and start its update loop.
success = luma.load()
if not success:
try:
firstTimeStartup()
except:
print('\n\n Keyboard interrupt. Cancelling.')
print('*******************************************************************************')
exit()
luma.start()
# Create the SocketServer client.
client = TCPServer((HOST, PORT), LUMATCPHandler)
# Set the client's time-out.
client.timeout = TIMEOUT
# Set the client's maximum request queue length so peeeeps don't get peeeeeeepy.
client.request_queue_size = 1
# Go ahead and print some info about this client.
printWelcomeHeader(luma)
# Now that everything is all set up and going, we start the webs portion.
try:
client.serve_forever()
# Yes, we do catch every possible problem so that we can stop the LUMA
# updater.
import os
try:
from SimpleHTTPServer import SimpleHTTPRequestHandler as Handler
from SocketServer import TCPServer as Server
except ImportError:
from http.server import SimpleHTTPRequestHandler as Handler
from http.server import HTTPServer as Server
# Read port selected by the cloud for our application
PORT = int(os.getenv('PORT', 8000))
# Change current directory to avoid exposure of control files
os.chdir('goal')
httpd = Server(("", PORT), Handler)
try:
print("Start serving at port %i" % PORT)
httpd.serve_forever()
except KeyboardInterrupt:
pass
httpd.server_close()
def __init__(self, server_address, nx_common):
"""Initialization of MSLTCPServer"""
nx_common.log(msg='Constructing MSLTCPServer')
self.nx_common = nx_common
self.msl_handler = MSL(nx_common)
TCPServer.__init__(self, server_address, MSLHttpRequestHandler)
#!/usr/bin/python
"USAGE: echoserver.py <port>"
from SocketServer import BaseRequestHandler, TCPServer
import sys, socket
class EchoHandler(BaseRequestHandler):
def handle(self):
print "Client connected:", self.client_address
self.request.sendall(self.request.recv(2**16))
self.request.close()
if len(sys.argv) != 2:
print __doc__
else:
TCPServer(('',int(sys.argv[1])), EchoHandler).serve_forever()
def serve():
print("Listening on 0.0.0.0:8080 ...")
server = TCPServer(('0.0.0.0', 8080), SimpleHTTPRequestHandler)
os.chdir(gen.SITE_DIR)
server.serve_forever()
def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING):
logger.setLevel(loglevel)
self.port = port
TCPServer.__init__(self, (host, port), WebSocketHandler)
def __init__(self, port, host='0.0.0.0'):
self.port = port
TCPServer.__init__(self, (host, port), WebSocketHandler)
def shutdown(self):
self.running = False
if issubclass(TCPServer, object):
super(TCPServerWrapper, self).shutdown()
else:
TCPServer.shutdown(self)
def serve_forever(self):
self.running = True
if issubclass(TCPServer, object):
super(TCPServerWrapper, self).serve_forever()
else:
TCPServer.serve_forever(self)
import os
try:
from SimpleHTTPServer import SimpleHTTPRequestHandler as Handler
from SocketServer import TCPServer as Server
except ImportError:
from http.server import SimpleHTTPRequestHandler as Handler
from http.server import HTTPServer as Server
import os
import ssl
# Read port selected by the cloud for our application
PORT = int(os.getenv('PORT', 8000))
httpd = Server(("", PORT), Handler)
httpd.socket = ssl.wrap_socket(httpd.socket,
keyfile="private.key",
certfile="certificate.crt",
server_side=True)
# Change current directory to avoid exposure of control files
os.chdir('static')
try:
print("Start serving at port %i" % PORT)
httpd.serve_forever()
except KeyboardInterrupt:
pass
httpd.server_close()
return Handler
if __name__ == "__main__":
logging.basicConfig(
format='%(asctime)s %(levelname)-8s: %(message)s',
level=logging.DEBUG)
logging.info(platform.python_version())
logging.debug(sys.argv)
port = int(sys.argv[1])
app_id = sys.argv[2]
version = sys.argv[3]
base_url = sys.argv[4]
task_id = os.getenv("MESOS_TASK_ID", "<UNKNOWN>")
HTTPServer.allow_reuse_address = True
httpd = HTTPServer(("", port), make_handler(app_id, version, task_id, base_url))
msg = "AppMock[%s %s]: %s has taken the stage at port %d. "\
"Will query %s for health and readiness status."
logging.info(msg, app_id, version, task_id, port, base_url)
try:
httpd.serve_forever()
except KeyboardInterrupt:
pass
logging.info("Shutting down.")
httpd.shutdown()
httpd.socket.close()
#!/usr/bin/python
import sys
if sys.version_info.major == 2:
from SimpleHTTPServer import SimpleHTTPRequestHandler
from SocketServer import TCPServer
elif sys.version_info.major == 3:
from http.server import SimpleHTTPRequestHandler
from socketserver import TCPServer
PORT = 10565
Handler = SimpleHTTPRequestHandler
httpd = TCPServer(("", PORT), Handler)
print("serving at port {}".format(PORT))
httpd.serve_forever()
def handle(self):
print('Got connection from', self.client_address)
while True:
# expected command two integers separated vie comma (e.g. 100, 200)
command = self.request.recv(8192)
x, y = parser(command)
print x, y # testing
# sending order to engines here
if not command:
# if connection lost engines stop here
break
self.request.send(self.ACK)
def parser(command):
try:
vals = command.split(',')
x, y = int(vals[0]), int(vals[1])
if x not in xrange(401):
x, y = 0, 0
if y not in xrange(401):
x, y = 0, 0
except ValueError:
x, y = 0, 0
return x, y
if __name__ == '__main__':
serv = TCPServer(('', 20002), EchoHandler)
serv.serve_forever()
def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING):
logger.setLevel(loglevel)
self.port = port
self.clients = {}
self.id_counter = 0
TCPServer.__init__(self, (host, port), WebSocketHandler)
def __init__(self, host, port):
super(WebServer, self).__init__()
self.daemon = True
LOG.info("Creating TCPServer...")
self.server = TCPServer((host, port), CaptiveHTTPRequestHandler)
LOG.info("Created TCPServer")
def __init__(self, app, server_address=("",9001)):
"""
@param app: A WSGI app as defined in PEP 333.
"""
self.app = app
TCPServer.__init__(self, server_address, self.REQUEST_HANDLER)
def __init__(self, server_address):
"""Initialization of ManifestServer"""
TCPServer.__init__(self, server_address, ManifestServerHttpRequestHandler)
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True, logger=None):
TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate)
self.logger = logger
logger.debug("GLLS Inicialized server")
from SocketServer import TCPServer, StreamRequestHandler
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyRequestHandler(StreamRequestHandler):
def handle(self):
print '...connected from', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServ = TCPServer(ADDR, MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
def server_bind(self):
TCPServer.server_bind(self)
class MyStreamRequestHandlerr(StreamRequestHandler):
"""
#继承StreamRequestHandler，并重写handle方法
#（StreamRequestHandler继承自BaseRequestHandler）
"""
def handle(self):
while True:
#客户端主动断开连接时，self.rfile.readline()会抛出异常
try:
#self.rfile类型是socket._fileobject,读写模式是"rb",方法有
#read,readline,readlines,write(data),writelines(list),close,flush
data = self.rfile.readline().strip()
print "receive from (%r):%r" % (self.client_address, data)
#self.wfile类型是socket._fileobject,读写模式是"wb"
self.wfile.write(data.upper())
except:
traceback.print_exc()
break
if __name__ == "__main__":
host = "0.0.0.0" #主机名，可以是ip,像localhost的主机名,或""
port = 9999 if len(sys.argv) < 2 else int(sys.argv[1]) #端口
addr = (host, port)
server = TCPServer(addr, MyStreamRequestHandlerr)
server.serve_forever()
"""
def handle(self):
#循环监听（读取）来自客户端的数据
while True:
#当客户端主动断开连接时，self.recv(1024)会抛出异常
try:
#一次读取1024字节,并去除两端的空白字符(包括空格,TAB,\r,\n)
data = self.request.recv(1024).strip()
#self.client_address是客户端的连接(host, port)的元组
print "receive from (%r):%r" % (self.client_address, data)
#转换成大写后写回(发生到)客户端
self.request.sendall(data.upper())
except:
traceback.print_exc()
break
if __name__ == "__main__":
#telnet 127.0.0.1 9999
host = "" #主机名，可以是ip,像localhost的主机名,或""
port = 9999 #端口
addr = (host, port)
#购置TCPServer对象，
server = TCPServer(addr, MyBaseRequestHandlerr)
#启动服务监听
server.serve_forever()
#coding:utf-8
'''
一个基于SocketServer的小型服务器
'''
from SocketServer import TCPServer, StreamRequestHandler
class Handler(StreamRequestHandler):
def handle(self):
addr = self.request.getpeername()
print 'Got connection from ', addr
self.wfile.write('Thank you for connection')
server = TCPServer(('', 1234), Handler)
server.serve_forever()
def shutdown(self):
"""Completely shutdown the server and close it's socket."""
# Can't use super() due to Python 2.7 compatibility
TCPServer.shutdown(self)
self.server_close()
self.ae._servers.remove(self)
class Httpd(BaseHTTPRequestHandler):
##
# Creates and sets up the server but does not start it.
#
# @param address - the server address (can be empty string)
# @param port - the port to listen on
def __init__(self, address, port):
self.httpd = TCPServer((address, port), self)
self.thread = None
manager = OneServerManager()
self.log = manager.log
##
# Starts the server and handles requests.
def start(self):
def run():
self.httpd.serve_forever()
self.log.debug('Starting HTTPD server')
self.thread = Thread(group=None, target=run)
self.thread.start()
##
# Stops the server from handling requests.
def stop(self):
self.log.debug('Shutting down HTTPD server')
self.httpd.shutdown()
self.thread.join(15.0)
if self.thread.isAlive():
self.log.error('HTTPD thread could not be stopped!')
##
# Handles GET requests.
def do_GET(self):
self.log.debug('GET request received: ' + self.path)
pass
##
# Handles POST requests.
def do_POST(self):
self.log.debug('POST request received')
pass
##
# Handles HEAD requests.
def do_HEAD(self):
self.log.debug('HEAD request received')
pass
##
# Handles SIMPLEGET requests.
def do_SIMPLEGET(self):
self.log.debug('SIMPLEGET request received')
pass
##
# Handles NOTIFY requests.
def do_NOTIFY(self):
self.log.debug('NOTIFY request received')
pass
##
# Handles SUBSCRIBE requests.
def do_SUBSCRIBE(self):
self.log.debug('SUBSCRIBE request received')
pass
##
# Handles UNSUBSCRIBE requests.
def do_UNSUBSCRIBE(self):
self.log.debug('UNSUBSCRIBE request received')
pass
##
# Handles MPOST requests.
def do_MPOST(self):
self.log.debug('MPOST request receieved')
pass
def get_request(self):
(socket, addr) = TCPServer.get_request(self)
socket.do_handshake()
return socket, addr
