def test_endpoint():
# Create environment
server, session, transport, conn = _get_test_environment()
# Connect endpoint
transport.recv(proto.connect("/test?a=123&b=456"))
# Verify that client received connect message
eq_(transport.pop_outgoing(), "1::/test")
# Verify that connection object was created
conn_test = session.endpoints["/test"]
eq_(conn_test.endpoint, "/test")
eq_(conn_test.is_open, True)
eq_(conn_test.request.arguments, dict(a=["123"], b=["456"]))
eq_(conn_test.request.get_argument("a"), "123")
# Send message to endpoint and verify that it was received
transport.recv(proto.message("/test", "abc"))
eq_(conn_test.pop_incoming(), "abc")
eq_(transport.pop_outgoing(), "3::/test:abc")
# Close endpoint connection from client
transport.recv(proto.disconnect("/test"))
# Verify that everything was cleaned up
eq_(transport.pop_outgoing(), "0::/test")
eq_(conn_test.is_open, False)
eq_(conn.is_open, True)
eq_(session.is_closed, False)
eq_(session.endpoints, dict())
# Open another endpoint connection
transport.recv(proto.connect("/test2"))
# Verify that client received connect message
eq_(transport.pop_outgoing(), "1::/test2")
# Get connection
conn_test = session.endpoints["/test2"]
eq_(conn_test.request.arguments, dict())
# Close main connection
transport.recv(proto.disconnect())
# Check if connections were closed and sent out
eq_(transport.pop_outgoing(), "0::/test2")
eq_(transport.pop_outgoing(), "0::")
eq_(conn_test.is_open, False)
eq_(conn.is_open, False)
eq_(session.is_closed, True)
def test_endpoint():
# Create environment
server, session, transport, conn = _get_test_environment()
# Connect endpoint
transport.recv(proto.connect('/test?a=123&b=456'))
# Verify that client received connect message
eq_(transport.pop_outgoing(), '1::/test')
# Verify that connection object was created
conn_test = session.endpoints['/test']
eq_(conn_test.endpoint, '/test')
eq_(conn_test.is_open, True)
eq_(conn_test.request.arguments, dict(a=['123'], b=['456']))
eq_(conn_test.request.get_argument('a'), '123')
# Send message to endpoint and verify that it was received
transport.recv(proto.message('/test', 'abc'))
eq_(conn_test.pop_incoming(), 'abc')
eq_(transport.pop_outgoing(), '3::/test:abc')
# Close endpoint connection from client
transport.recv(proto.disconnect('/test'))
# Verify that everything was cleaned up
eq_(transport.pop_outgoing(), '0::/test')
eq_(conn_test.is_open, False)
eq_(conn.is_open, True)
eq_(session.is_closed, False)
eq_(session.endpoints, dict())
# Open another endpoint connection
transport.recv(proto.connect('/test2'))
# Verify that client received connect message
eq_(transport.pop_outgoing(), '1::/test2')
# Get connection
conn_test = session.endpoints['/test2']
eq_(conn_test.request.arguments, dict())
# Close main connection
transport.recv(proto.disconnect())
# Check if connections were closed and sent out
eq_(transport.pop_outgoing(), '0::/test2')
eq_(transport.pop_outgoing(), '0::')
eq_(conn_test.is_open, False)
eq_(conn.is_open, False)
eq_(session.is_closed, True)
def test_endpoint():
# Create environment
server, session, transport, conn = _get_test_environment()
# Connect endpoint
transport.recv(proto.connect('/test?a=123&b=456'))
# Verify that client received connect message
eq_(transport.pop_outgoing(), '1::/test')
# Verify that connection object was created
conn_test = session.endpoints['/test']
eq_(conn_test.endpoint, '/test')
eq_(conn_test.is_open, True)
eq_(conn_test.request.arguments, dict(a=['123'], b=['456']))
eq_(conn_test.request.get_argument('a'), '123')
# Send message to endpoint and verify that it was received
transport.recv(proto.message('/test', 'abc'))
eq_(conn_test.pop_incoming(), 'abc')
eq_(transport.pop_outgoing(), '3::/test:abc')
# Close endpoint connection from client
transport.recv(proto.disconnect('/test'))
# Verify that everything was cleaned up
eq_(transport.pop_outgoing(), '0::/test')
eq_(conn_test.is_open, False)
eq_(conn.is_open, True)
eq_(session.is_closed, False)
eq_(session.endpoints, dict())
# Open another endpoint connection
transport.recv(proto.connect('/test2'))
# Verify that client received connect message
eq_(transport.pop_outgoing(), '1::/test2')
# Get connection
conn_test = session.endpoints['/test2']
eq_(conn_test.request.arguments, dict())
# Close main connection
transport.recv(proto.disconnect())
# Check if connections were closed and sent out
eq_(transport.pop_outgoing(), '0::/test2')
eq_(transport.pop_outgoing(), '0::')
eq_(conn_test.is_open, False)
eq_(conn.is_open, False)
eq_(session.is_closed, True)
def connect_endpoint(self, url):
"""Connect endpoint from URL.
`url`
socket.io endpoint URL.
"""
urldata = urlparse.urlparse(url)
endpoint = urldata.path
conn_class = self.conn.get_endpoint(endpoint)
if conn_class is None:
logging.error('There is no handler for endpoint %s' % endpoint)
return
conn = conn_class(self, endpoint)
self.endpoints[endpoint] = conn
self.send_message(proto.connect(endpoint))
args = urlparse.parse_qs(urldata.query)
info = ConnectionInfo(self.remote_ip, args, dict())
conn.on_open(info)
def connect_endpoint(self, url):
"""Connect endpoint from URL.
`url`
socket.io endpoint URL.
"""
urldata = urlparse.urlparse(url)
endpoint = urldata.path
conn_class = self.conn.get_endpoint(endpoint)
if conn_class is None:
logging.error('There is no handler for endpoint %s' % endpoint)
return
conn = conn_class(self, endpoint)
self.endpoints[endpoint] = conn
self.send_message(proto.connect(endpoint))
args = urlparse.parse_qs(urldata.query)
info = ConnectionInfo(self.remote_ip, args, dict())
if conn.on_open(info) == False:
self.disconnect_endpoint(endpoint)
def __init__(self, conn, server, request, expiry=None):
"""Session constructor.
`conn`
Default connection class
`server`
Associated server
`handler`
Request handler that created new session
`expiry`
Session expiry
"""
# Initialize session
super(Session, self).__init__(None, expiry)
self.server = server
self.send_queue = []
self.handler = None
# Stats
server.stats.session_opened()
self.remote_ip = request.remote_ip
# Create connection instance
self.conn = conn(self)
# Call on_open.
self.info = ConnectionInfo(request.remote_ip,
request.arguments,
request.cookies)
# Save request for the future
self.request = request
# If everything is fine - continue
self.send_message(proto.connect())
# Heartbeat related stuff
self._heartbeat_timer = None
self._heartbeat_interval = self.server.settings['heartbeat_interval'] * 1000
self._missed_heartbeats = 0
# Endpoints
self.endpoints = dict()
result = self.conn.on_open(self.info)
if result is not None and not result:
raise HTTPError(401)
def __init__(self, conn, server, request, expiry=None):
"""Session constructor.
`conn`
Default connection class
`server`
Associated server
`handler`
Request handler that created new session
`expiry`
Session expiry
"""
# Initialize session
super(Session, self).__init__(None, expiry)
self.server = server
self.send_queue = []
self.handler = None
# Stats
server.stats.session_opened()
self.remote_ip = request.remote_ip
# Create connection instance
self.conn = conn(self)
# Call on_open.
self.info = ConnectionInfo(request.remote_ip,
request.host,
request.arguments,
request.cookies)
# If everything is fine - continue
self.send_message(proto.connect())
# Heartbeat related stuff
self._heartbeat_timer = None
self._heartbeat_interval = self.server.settings['heartbeat_interval'] * 1000
self._missed_heartbeats = 0
# Endpoints
self.endpoints = dict()
result = self.conn.on_open(self.info)
if result is not None and not result:
raise HTTPError(401)
def connect_endpoint(self, url):
"""Connect endpoint from URL.
`url`
socket.io endpoint URL.
"""
urldata = urlparse.urlparse(url)
endpoint = urldata.path
conn = self.endpoints.get(endpoint, None)
if conn is None:
conn_class = self.conn.get_endpoint(endpoint)
if conn_class is None:
logging.error('There is no handler for endpoint %s' % endpoint)
return
conn = conn_class(self, endpoint)
self.endpoints[endpoint] = conn
self.send_message(proto.connect(endpoint))
if conn.on_open(self.info) == False:
self.disconnect_endpoint(endpoint)
def connect_endpoint(self, url):
"""Connect endpoint from URL.
`url`
socket.io endpoint URL.
"""
urldata = urlparse.urlparse(url)
endpoint = urldata.path
conn = self.endpoints.get(endpoint, None)
if conn is None:
conn_class = self.conn.get_endpoint(endpoint)
if conn_class is None:
logging.error('There is no handler for endpoint %s' % endpoint)
return
conn = conn_class(self, endpoint)
self.endpoints[endpoint] = conn
self.send_message(proto.connect(endpoint))
if conn.on_open(self.info) == False:
self.disconnect_endpoint(endpoint)
