def test_http_session(self):
"""
Tests that http_session correctly extracts a session cookie.
"""
# Make a session to try against
session1 = session_for_reply_channel("test-reply")
# Construct message to send
message = Message(
{
"reply_channel": "test-reply",
"http_version": "1.1",
"method": "GET",
"path": "/test2/",
"headers": {
"host":
b"example.com",
"cookie":
("%s=%s" % (settings.SESSION_COOKIE_NAME,
session1.session_key)).encode("ascii"),
},
}, None, None)
# Run it through http_session, make sure it works (test double here too)
@http_session
@http_session
def inner(message):
message.http_session["species"] = "horse"
inner(message)
# Check value assignment stuck
session2 = session_for_reply_channel("test-reply")
self.assertEqual(session2["species"], "horse")
def test_http_session(self):
"""
Tests that http_session correctly extracts a session cookie.
"""
# Make a session to try against
session1 = session_for_reply_channel("test-reply")
# Construct message to send
message = Message({
"reply_channel": "test-reply",
"http_version": "1.1",
"method": "GET",
"path": "/test2/",
"headers": {
"host": b"example.com",
"cookie": ("%s=%s" % (settings.SESSION_COOKIE_NAME, session1.session_key)).encode("ascii"),
},
}, None, None)
# Run it through http_session, make sure it works (test double here too)
@http_session
@http_session
def inner(message):
message.http_session["species"] = "horse"
inner(message)
# Check value assignment stuck
session2 = session_for_reply_channel("test-reply")
self.assertEqual(session2["species"], "horse")
def test_session_for_reply_channel(self):
"""
Tests storing and retrieving values by reply_channel.
"""
session1 = session_for_reply_channel("test-reply-channel")
session1["testvalue"] = 42
session1.save(must_create=True)
session2 = session_for_reply_channel("test-reply-channel")
self.assertEqual(session2["testvalue"], 42)
def test_session_for_reply_channel(self):
"""
Tests storing and retrieving values by reply_channel.
"""
session1 = session_for_reply_channel("test-reply-channel")
session1["testvalue"] = 42
session1.save(must_create=True)
session2 = session_for_reply_channel("test-reply-channel")
self.assertEqual(session2["testvalue"], 42)
def test_channel_and_http_session(self):
"""
Tests that channel_and_http_session decorator stores the http session key and hydrates it when expected
"""
# Make a session to try against
session = session_for_reply_channel("test-reply-session")
# Construct message to send
message = Message({
"reply_channel": "test-reply-session",
"http_version": "1.1",
"method": "GET",
"path": "/test2/",
"headers": {
"host": b"example.com",
"cookie": ("%s=%s" % (settings.SESSION_COOKIE_NAME, session.session_key)).encode("ascii"),
},
}, None, None)
@channel_and_http_session
def inner(message):
pass
inner(message)
# It should store the session key
self.assertEqual(message.channel_session[settings.SESSION_COOKIE_NAME], session.session_key)
# Construct a new message
message2 = Message({"reply_channel": "test-reply-session", "path": "/"}, None, None)
inner(message2)
# It should hydrate the http_session
self.assertEqual(message2.http_session.session_key, session.session_key)
def test_channel_and_http_session(self):
"""
Tests that channel_and_http_session decorator stores the http session key and hydrates it when expected
"""
# Make a session to try against
session = session_for_reply_channel("test-reply-session")
# Construct message to send
message = Message({
"reply_channel": "test-reply-session",
"http_version": "1.1",
"method": "GET",
"path": "/test2/",
"headers": {
"host": b"example.com",
"cookie": ("%s=%s" % (settings.SESSION_COOKIE_NAME, session.session_key)).encode("ascii"),
},
}, None, None)
@channel_and_http_session
def inner(message):
pass
inner(message)
# It should store the session key
self.assertEqual(message.channel_session[settings.SESSION_COOKIE_NAME], session.session_key)
# Construct a new message
message2 = Message({"reply_channel": "test-reply-session", "path": "/"}, None, None)
inner(message2)
# It should hydrate the http_session
self.assertEqual(message2.http_session.session_key, session.session_key)
def get_session_from_channels(channels_list, device_type, session=None):
for channel in channels_list:
sessions = session_for_reply_channel(channel)
if sessions["device_type"] == device_type:
if session is not None:
sessions = sessions.get(session, None)
return sessions
return None
def build_data(self):
"""
Creates all the data, saves it to the cache and returns it.
"""
websocket_user_ids = defaultdict(set)
for channel_name in Group('site').channel_layer.group_channels('site'):
session = session_for_reply_channel(channel_name)
user_id = session.get('user_id', None)
websocket_user_ids[user_id or 0].add(channel_name)
self.save_data(websocket_user_ids)
return websocket_user_ids
def get_session_from_group(group_name, device_type, session=None):
print(group_name)
if len(get_channel_layer().group_channels(group_name)) > 0:
channels_list = list(
get_channel_layer().group_channels(group_name).keys())
for channel in channels_list:
print(channel)
sessions = session_for_reply_channel(channel)
if sessions["device_type"] == device_type:
if session is not None:
sessions = sessions.get(session, None)
return sessions
return None
def test_channel_session(self):
"""
Tests the channel_session decorator
"""
# Construct message to send
message = Message({"reply_channel": "test-reply"}, None, None)
# Run through a simple fake consumer that assigns to it
@channel_session
def inner(message):
message.channel_session["num_ponies"] = -1
inner(message)
# Test the session worked
session2 = session_for_reply_channel("test-reply")
self.assertEqual(session2["num_ponies"], -1)
def test_channel_session(self):
"""
Tests the channel_session decorator
"""
# Construct message to send
message = Message({"reply_channel": "test-reply"}, None, None)
# Run through a simple fake consumer that assigns to it
@channel_session
def inner(message):
message.channel_session["num_ponies"] = -1
inner(message)
# Test the session worked
session2 = session_for_reply_channel("test-reply")
self.assertEqual(session2["num_ponies"], -1)
def whois(request):
mimetype = 'application/json'
# Get channel_layer function
from channels.asgi import get_channel_layer
from channels.sessions import session_for_reply_channel
# passing group_channel takes channel name
#channel_layer = get_channel_layer()
#data = channel_layer.group_channels('notifications')
#data = channel_layer.global_statistics()
#data = channel_layer.channel_statistics('notifications')
#data = get_channel_layer().group_channels('notifications')
#data = Group("notifications").extensions
#data = get_channel_layer().receive_twisted()
#from channels import channel_layers
#layer = channel_layers["default"]
#print(layer.router.channels)
data = []
from django.contrib.sessions.backends import cache as engine
data = get_channel_layer().group_channels('notifications')
active_users = []
for C in data:
#Channel(C).send({"text": json.dumps({'clean_signal':True})})
c_session = session_for_reply_channel(C)
session = engine.SessionStore(c_session._session_key)
#print(c_session._session['_auth_user_id'])
#print(session.keys())
#print(session.get('username', None), session.get_expiry_date())
username = session.get('username', None)
# this is the same
# username = c_session.get('username', None)
if username not in active_users and username != None:
active_users.append(username)
data = active_users
return HttpResponse(json.dumps(data), mimetype)
def test_channel_session_double(self):
"""
Tests the channel_session decorator detects being wrapped in itself
and doesn't blow up.
"""
# Construct message to send
message = Message({"reply_channel": "test-reply"}, None, None)
# Run through a simple fake consumer that should trigger the error
@channel_session
@channel_session
def inner(message):
message.channel_session["num_ponies"] = -1
inner(message)
# Test the session worked
session2 = session_for_reply_channel("test-reply")
self.assertEqual(session2["num_ponies"], -1)
def test_channel_session_double(self):
"""
Tests the channel_session decorator detects being wrapped in itself
and doesn't blow up.
"""
# Construct message to send
message = Message({"reply_channel": "test-reply"}, None, None)
# Run through a simple fake consumer that should trigger the error
@channel_session
@channel_session
def inner(message):
message.channel_session["num_ponies"] = -1
inner(message)
# Test the session worked
session2 = session_for_reply_channel("test-reply")
self.assertEqual(session2["num_ponies"], -1)
def get_session_from_group(group_name, session=None):
channel_list = get_channel_layer().group_channels(group_name).keys()
sessions = session_for_reply_channel(channel_list[0])
if session is not None:
sessions = sessions.get(session, None)
return sessions
def get_reply_channel_sessions(channel):
channel_session = session_for_reply_channel(channel)
http_session = SessionStore(
session_key=channel_session.get('http_session_key'))
return {"channel": channel_session, "http": http_session}
def get_session_from_channels(channels_list, session=None):
channel_list = channels_list.keys()
sessions = session_for_reply_channel(channel_list[0])
if session is not None:
sessions = sessions.get(session, None)
return sessions
