def __init__(self, host, port):
self.server = http_server.HttpServer(host, port)
self.server.Register("/get_request", self.get_request)
self.server.Register("/task_num", self.task_num)
self.t = threading.Thread(target = self.read_tasks)
self.read_seconds = 60
self.stop_flag = threading.Event()
self.tasks = task_queue.TaskQueue(3000000)
self.task_reader = task_reader.TaskReader()
def process_commandline_request(self, options):
"""Implements CommandHandler.
This starts the server and will run forever.
"""
url_path_to_handler = {handler.url_path: handler.process_web_request
for handler in self.__handler_list}
httpd = http_server.HttpServer(options, url_path_to_handler)
httpd.serve_forever()
def test_init_from_server_options(self, mock_http):
"""Verify that if options arent overriden we get server config."""
options = {
'port': None,
'host': None,
'server': {
'port': 1234,
'host': 'testHost'
}
}
server = http_server.HttpServer(options)
mock_http.assert_called_with(server, ('testHost', 1234), mock.ANY)
def test_init_from_options(self, mock_http):
"""Verify we pick up commandline args, and empty host is passed through."""
options = {
'port': 1234,
'host': '',
'server': {
'port': 666,
'host': 'wrong'
}
}
server = http_server.HttpServer(options)
mock_http.assert_called_with(server, ('0.0.0.0', 1234), mock.ANY)
def __init__(self, port, on_received_query):
self.__on_received_query = on_received_query
def _on_query_from_clients(handler, instance):
paths, params = handler.parse_url()
instance.__on_received_query(paths=paths,
params=params,
handler=handler)
callbacks = {
'get': functools.partial(_on_query_from_clients, instance=self),
}
self.__server = http_server.HttpServer(port, callbacks)
def process_commandline_request(self, options):
"""Implements CommandHandler.
This starts the server and will run forever.
"""
command_processor.set_global_options(options)
logging.info('Starting HTTP server on port %d', options['port'])
url_path_to_handler = {
handler.url_path: handler.process_web_request
for handler in self.__handler_list
}
httpd = http_server.HttpServer(options['port'], url_path_to_handler)
httpd.serve_forever()
def run(self):
local_port = self.__register_as_client()
self.update_port(local_port)
callbacks = {
'get': functools.partial(self.__on_request_get, instance=self),
}
server = http_server.HttpServer(local_port, callbacks).start()
log.write('start as a server at port {}'.format(local_port))
self.__connection_start.wait()
log.write('start connection to {}'.format(self.__server_http_address))
self.__run_impl(server=server)
def setUp(self):
self.handler_a = mock.Mock()
self.handler_b = mock.Mock()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 0))
self.port = sock.getsockname()[1]
sock.close()
server = http_server.HttpServer({'port': self.port},
handlers={
'/path/a': self.handler_a,
'/path/b': self.handler_b
})
self.thread = threading.Thread(target=server.handle_request)
self.thread.daemon = True
self.thread.start()
def test_init_from_hardcoded_defaults(self, mock_http):
"""Verify if options arent overriden that we get the builtin defaults."""
options = {'port': None, 'host': None}
server = http_server.HttpServer(options)
mock_http.assert_called_with(server, ('localhost', 8008), mock.ANY)
while self._faucet_events:
event = self._faucet_events.next_event()
LOGGER.debug('Faucet event %s', event)
if not event:
return True
(dpid, port, active) = self._faucet_events.as_port_state(event)
if dpid and port:
LOGGER.info('Port state %s %s %s', dpid, port, active)
(dpid, port, target_mac) = self._faucet_events.as_port_learn(event)
if dpid and port:
LOGGER.info('Port learn %s %s %s', dpid, port, target_mac)
(dpid, restart_type) = self._faucet_events.as_config_change(event)
if dpid is not None:
LOGGER.info('DP restart %d %s', dpid, restart_type)
return False
def get_overview(self, params):
"""Get an overview of the system"""
return {'hello': 'world', 'params': params}
if __name__ == '__main__':
logger.set_config(level=logging.INFO)
CONFIG = configurator.Configurator().parse_args(sys.argv)
FORCH = Forchestrator(CONFIG)
FORCH.initialize()
HTTP = http_server.HttpServer(CONFIG)
HTTP.map_request('overview', FORCH.get_overview)
HTTP.start_server()
FORCH.main_loop()
log = logging.getlogger("test")
log.setLevel(logging.DEBUG)
http = logging.getlogger("http")
webs = logging.getlogger("webs")
http.setLevel(logging.DEBUG)
webs.setLevel(logging.DEBUG)
log.info ("WebserverTest")
import sys
print(sys.path)
https = http_server.HttpServer(sys.path[0] + "/../web")
server = webserver.WebServer(https)
server.modeStation()
# 2 tasks
def ledR():
log.info("Starting ledR")
led = machine.Pin(5, mode=machine.Pin.OUT)
total = 0
yield
while True:
total += 1
if led.value() == 1:
led.value(0)
else:
led.value(0)
def handleRoot(request):
led.value(1)
request.sendFile("/index.html")
led.value(0)
def handleKillOs(request):
server.shutdown()
import sys
print(sys.path)
server = http_server.HttpServer(sys.path[0] + "/../../web/ang")
# register all routes
server.resetRouteTable()
server.onExact("", handleRoot)
server.onExact("/", handleRoot)
server.onExact("/index.html", handleStatic)
server.onEnd(".css", handleStatic)
server.onEnd(".js", handleStatic)
server.onEnd(".html", handleStatic)
server.onExact("/kill", handleKillOs)
# 2 tasks
def ledR():
log.info("Starting ledR")
def handleStatic(request):
led.value(1)
yield from request.sendFile(request.path)
led.value(0)
def handleKillOs(request):
log.warn("================= handleKillOs")
yield
server.shutdown()
import sys
print(sys.path)
server = http_server.HttpServer("/web/")
# register all routes
server.resetRouteTable()
server.onEnd(".css", handleStatic)
server.onEnd(".js", handleStatic)
server.onExact("/", handleRoot)
server.onExact("/index.html", handleRoot)
server.onExact("/kill", handleKillOs)
# 2 tasks
def ledR():
log.info("Starting ledR")
yield
while True:
