def start(self, node, uri, tunnel=False, external_uri=None):
""" If not tunnel, start listening on uri and handle http requests.
If tunnel, setup a tunnel to uri and handle requests.
"""
self.metering = metering.get_metering()
self.node = node
self.security = Security(self.node)
schema, _ = uri.split(':', 1)
if tunnel:
# Connect to tunnel server
self.tunnel_client = CalvinControlTunnelClient(uri, self)
else:
url = urlparse(uri)
self.port = int(url.port)
self.host = url.hostname
if external_uri is not None:
self.external_host = urlparse(external_uri).hostname
else:
self.external_host = self.host
_log.info("Control API trying to listening on: %s:%s" % (self.host, self.port))
self.server = server_connection.ServerProtocolFactory(self.handle_request, "http", node_name=node.node_name)
self.server.start(self.host, self.port)
# Create tunnel server
self.tunnel_server = CalvinControlTunnelServer(self.node)
def test_default_line_mode(self):
print_header("TEST_DEFAULT_LINE_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
assert not self.factory.connections
assert not self.factory.pending_connections
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
assert self.factory.pending_connections
_, self.conn = self.factory.accept()
####################################################################
####################################################################
print_header("Test_Line_Received")
####################################################################
assert self.conn.data_available is False
yield threads.defer_to_thread(self.client_socket.send, "sending string \r\n")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "sending string "
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def test_many_clients(self):
print_header("TEST_MANY_CLIENTS")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, mode='raw', max_length=10)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
clients = []
for i in range(100):
clients.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
for c in clients:
yield threads.defer_to_thread(c.connect, ('localhost', 8123))
yield threads.defer_to_thread(hundred_connection_made, self.factory)
assert len(self.factory.pending_connections) == 100
for i in range(100):
_, self.conn = self.factory.accept()
assert not self.factory.pending_connections
def test_raw_mode(self):
print_header("TEST_RAW_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, mode='raw', max_length=10)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
assert self.factory.pending_connections
_, self.conn = self.factory.accept()
assert not self.factory.pending_connections
print_header("Test_Data_Received")
####################################################################
assert self.conn.data_available is False
yield threads.defer_to_thread(self.client_socket.send, "abcdefghijklmnopqrstuvxyz123456789")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "abcdefghij"
assert self.conn.data_get() == "klmnopqrst"
assert self.conn.data_get() == "uvxyz12345"
assert self.conn.data_get() == "6789"
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def test_args_in_line_mode(self):
print_header("TEST_ARGS_IN_LINE_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, delimiter='end', max_length=3)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
_, self.conn = self.factory.accept()
print_header("Test_Short_Line_Received")
####################################################################
yield threads.defer_to_thread(self.client_socket.send, "123end")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "123"
print_header("Test_Long_Line_Received")
####################################################################
yield threads.defer_to_thread(self.client_socket.send, "1234end")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "1234"
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def start(self, node, uri):
""" Start listening and handle request on uri
"""
self.port = int(urlparse(uri).port)
self.host = urlparse(uri).hostname
_log.info("Listening on: %s:%s" % (self.host, self.port))
self.node = node
# Set routes for requests
self.routes = [
(re_get_actor_doc, self.handle_get_actor_doc),
(re_get_log, self.handle_get_log),
(re_get_node_id, self.handle_get_node_id),
(re_get_nodes, self.handle_get_nodes),
(re_get_node, self.handle_get_node),
(re_post_peer_setup, self.handle_peer_setup),
(re_get_applications, self.handle_get_applications),
(re_get_application, self.handle_get_application),
(re_del_application, self.handle_del_application),
(re_post_new_actor, self.handle_new_actor),
(re_get_actors, self.handle_get_actors),
(re_get_actor, self.handle_get_actor),
(re_del_actor, self.handle_del_actor),
(re_get_actor_report, self.handle_get_actor_report),
(re_post_actor_migrate, self.handle_actor_migrate),
(re_post_application_requirements, self.handle_application_requirements),
(re_post_actor_disable, self.handle_actor_disable),
(re_get_port, self.handle_get_port),
(re_get_port_state, self.handle_get_port_state),
(re_post_connect, self.handle_connect),
(re_set_port_property, self.handle_set_port_property),
(re_post_deploy, self.handle_deploy),
(re_delete_node, self.handle_quit),
(re_post_disconnect, self.handle_disconnect),
(re_post_index, self.handle_post_index),
(re_delete_index, self.handle_delete_index),
(re_get_index, self.handle_get_index),
(re_get_storage, self.handle_get_storage),
(re_post_storage, self.handle_post_storage),
(re_options, self.handle_options)
]
self.server = server_connection.ServerProtocolFactory(self.handle_request, "http")
self.server.start(self.host, self.port)
def __init__(self, tunnel):
self.tunnel = tunnel
self.connections = {}
# Start a socket server on same interface as calvincontrol
self.host = get_calvincontrol().host
for x in range(0, 10):
try:
self.port = randint(5100, 5200)
self.server = server_connection.ServerProtocolFactory(self.handle_request, "http")
self.server.start(self.host, self.port)
_log.info("Control proxy for %s listening on: %s:%s" % (tunnel.peer_node_id, self.host, self.port))
break
except:
pass
# Tell peer node that we a listening and on what uri
msg = {"cmd": "started",
"controluri": "http://" + get_calvincontrol().external_host + ":" + str(self.port)}
self.tunnel.send(msg)
def __init__(self, node, mode, delimiter, max_length):
self.connection_factory = server_connection.ServerProtocolFactory(
node.sched.trigger_loop, mode, delimiter, max_length)
def __init__(self, node, mode, delimiter, max_length, actor_id=None):
super(Server, self).__init__()
self.connection_factory = server_connection.ServerProtocolFactory(node.sched.trigger_loop, mode,
delimiter, max_length, actor_id)
