class FileSearchServer(Thread):
""" Thread which answers to file/tag queries sent through unix socket. """
def __init__(self, pname='SET_ME_PLEASE'):
Thread.__init__(self)
self.name = "%s/%s" % (
pname, str(self.__class__).rsplit('.', 1)[1].split("'")[0])
# old socket from a crashed daemon ?
# remove it, the ThreadingUnixStreamServer will create it.
#if os.path.exists(socket_path): os.unlink(socket_path)
self._stop_event = Event()
self.server = ThreadingTCPServer(('127.0.0.1', searcher_port), FileSearchRequestHandler)
self.server.allow_reuse_address = True
# TODO: the socket is set to non-blocking to be able to gracefully terminate the thread,
# but this could lead to CPU hogging problems. VERIFY THIS !!
self.server.socket.setblocking(False)
def run(self):
logging.progress("%s: thread running." % (self.getName()))
#os.chmod(socket_path, stat.S_IRUSR|stat.S_IWUSR|stat.S_IRGRP|stat.S_IWGRP|stat.S_IROTH|stat.S_IWOTH)
while not self._stop_event.isSet():
self.server.handle_request()
time.sleep(0.01)
logging.progress("%s: thread ended." % (self.getName()))
def stop(self):
if not self._stop_event.isSet():
logging.progress("%s: stopping thread." % (self.getName()))
self._stop_event.set()
self.server.socket.close()
self.server.server_close()
if os.path.exists(socket_path):
os.unlink(socket_path)
class XXEWebServer(Thread):
def __init__(self, host='0.0.0.0', port=8000, HandlerClass=XXEHandler):
Thread.__init__(self)
self._stop = Event()
self.host = host
self.port = port
self.server_address = (self.host, self.port)
self.HandlerClass = HandlerClass
if self.HandlerClass is None:
self.HandlerClass = SimpleHTTPRequestHandler
self.HandlerClass.protocol_version = "HTTP/1.0"
self.httpd = HTTPServer(self.server_address, self.HandlerClass)
else:
self.httpd = ThreadingTCPServer(self.server_address, self.HandlerClass)
def stop(self):
self._stop.set()
def stopped(self):
return self._stop.isSet()
def run(self):
sa = self.httpd.socket.getsockname()
print "Serving HTTP on ", sa[0], " port ", sa[1]
#self.httpd.serve_forever()
while not self.stopped():
if exiting: return
self.httpd.handle_request()
def handle_request(self):
print " handle request "
handler = ThreadingTCPServer.handle_request(self)
handler.set_handlers(self.handleWiFlyMessage,
self.handleBrowserMessage)
clients.append(handler)
return handler
class HttpMonitor(Monitor):
"""
Monitor incoming documents on a HTTP endpoint.
For messages received via HTTP GET it uses the the path from URL path after host address as a 'str' type input.
For messages received via HTTP POST it expects the content body to be JSON.
Sockets:
output (*) : Document received on the HTTP endpoint.
Config:
host = "localhost"
port = 4000
max_length = 1024*1024 : Max length of incoming data via POST, in bytes.
"""
ThreadingTCPServer.allow_reuse_address = True # OBS: Class level setting.
def __init__(self, hook=None, **kwargs):
super(HttpMonitor, self).__init__(**kwargs)
self.output = self.create_socket("output", None, "Document received on the HTTP endpoint.")
self.config.set_default(host="localhost", port=4000)
self.config.set_default(
host = "localhost",
port = 4000,
max_length = 1024*1024 # 1 MB
)
self.hook = hook
def on_open(self):
self.log.info("Starting HTTP listener on %s:%d" % (self.config.host, self.config.port))
self._server = ThreadingTCPServer((self.config.host, self.config.port), _ServerHandlerClass, bind_and_activate=True)
self._server.owner = self
self._server.timeout = 1.0 # Max 1 second blocking in _server.handle_request()
def on_close(self):
self.log.info("Closing HTTP listener.")
self._server.server_close()
self._server = None
def _incoming_WITH_DATA(self, request_handler, verb, path, data):
if self.suspended:
return "Server suspended; incoming data ignored."
if verb == "GET":
self.total += 1
self.count += 1
# For GET, use path as document
if self.output.has_output:
self.output.send(path[1:])
data_obj = None
if data:
if request_handler.headers.gettype() == "application/json":
try:
data_obj = json.loads(data)
except Exception as e:
self.doclog.error("Failed to parse incoming data as JSON: " + e.message)
return "Failed to parse data as JSON."
else:
data_obj = data
if verb != "GET":
self.total += 1
self.count += 1
if self.output.has_output:
# For non-GET, use data as document
self.output.send(data_obj)
return self._call_hook(request_handler, verb, path, data_obj)
def _call_hook(self, request_handler, http_verb, path, data):
if self.hook:
try:
return self.hook(request_handler, http_verb, path, data)
except Exception as e:
self.log.exception("Failed to call hook: %s: %s" % (e.__class__.__name__, e))
def on_startup(self):
self.total = 0
self.count = 0
def on_tick(self):
self._server.handle_request()
def handle_request(self):
print " handle request "
handler = ThreadingTCPServer.handle_request(self)
handler.set_handlers(self.handleWiFlyMessage, self.handleBrowserMessage)
return handler
