def authenticate(cls, username, password):
result = yield cls.collection.find_one({"username": username})
if result:
user_id = result["_id"]
is_valid = yield cls.check_password(result, password)
if is_valid and result["is_active"]:
session = yield SessionStore.make_session(result["_id"])
defer.returnValue({"session_id": session, "user_id": user_id})
defer.returnValue(None)
def setUp(self):
self.multi_session = MultiSession()
# Create the django_session table
from django.db import connection
from django.contrib.sessions.models import Session
self.django_session_model = Session
self.database_cursor = connection.cursor()
tables = connection.introspection.table_names()
if Session._meta.db_table not in tables:
sql, references = connection.creation.sql_create_model(self.django_session_model, no_style())
for statement in sql:
self.database_cursor.execute(statement)
def setUp(self): self.redis_session = RedisSession()
class TestRedisSesssios(unittest.TestCase):
def setUp(self):
self.redis_session = RedisSession()
def test_modify_and_keys(self):
eq_(self.redis_session.modified, False)
self.redis_session['test'] = 'test_me'
eq_(self.redis_session.modified, True)
eq_(self.redis_session['test'], 'test_me')
def test_save_delete(self):
self.redis_session['key'] = 'value'
self.redis_session.save()
self.redis_session.exists(self.redis_session.session_key)
self.redis_session.delete(self.redis_session.session_key)
eq_(self.redis_session.exists(self.redis_session.session_key), False)
def test_flush(self):
self.redis_session['key'] = 'another_value'
self.redis_session.save()
key = self.redis_session.session_key
self.redis_session.flush()
eq_(self.redis_session.exists(key), False)
def test_items(self):
self.redis_session['item1'], self.redis_session['item2'] = 1,2
self.redis_session.save()
eq_(self.redis_session.items(), [('item2', 2), ('item1', 1)])
def test_expiry(self):
self.redis_session.set_expiry(1)
# Test if the expiry age is set correctly
eq_(self.redis_session.get_expiry_age(), 1)
self.redis_session['key'] = 'expiring_value'
self.redis_session.save()
key = self.redis_session.session_key
eq_(self.redis_session.exists(key), True)
time.sleep(2)
eq_(self.redis_session.exists(key), False)
class TestMultiSessions(unittest.TestCase):
def setUp(self):
self.multi_session = MultiSession()
# Create the django_session table
from django.db import connection
from django.contrib.sessions.models import Session
self.django_session_model = Session
self.database_cursor = connection.cursor()
tables = connection.introspection.table_names()
if Session._meta.db_table not in tables:
sql, references = connection.creation.sql_create_model(self.django_session_model, no_style())
for statement in sql:
self.database_cursor.execute(statement)
def tearDown(self):
# Destroy the django_session table
from django.db import connection
sql = connection.creation.sql_destroy_model(self.django_session_model, {}, no_style())
for statement in sql:
self.database_cursor.execute(statement)
def test_modify_and_keys(self):
eq_(self.multi_session.modified, False)
self.multi_session.create()
self.multi_session['test'] = 'test_me'
eq_(self.multi_session.modified, True)
eq_(self.multi_session['test'], 'test_me')
def test_save_and_delete(self):
self.multi_session['key'] = 'value'
self.multi_session.save()
self.multi_session.exists(self.multi_session.session_key)
eq_(self.multi_session.exists(self.multi_session.session_key), True)
self.multi_session.delete(self.multi_session.session_key)
eq_(self.multi_session.exists(self.multi_session.session_key), False)
def test_flush(self):
self.multi_session['key'] = 'another_value'
self.multi_session.save()
key = self.multi_session.session_key
self.multi_session.flush()
eq_(self.multi_session.exists(key), False)
def test_items(self):
self.multi_session['item1'], self.multi_session['item2'] = 1, 2
self.multi_session.save()
eq_(self.multi_session.items(), [('item2', 2), ('item1', 1)])
def test_expiry(self):
self.multi_session.set_expiry(1)
eq_(self.multi_session.get_expiry_age(), 1)
self.multi_session['key'] = 'expiring_value'
self.multi_session.save()
key = self.multi_session.session_key
eq_(self.multi_session.exists(key), True)
time.sleep(2)
eq_(self.multi_session.exists(key), False)
def test_save_and_load(self):
self.multi_session.set_expiry(60)
self.multi_session.setdefault('item_test', 777)
self.multi_session.save()
session_data = self.multi_session.load()
eq_(session_data.get('item_test'), 777)
def test_multiple_backends_separately(self):
# Check the backend if more than two
if len(self.multi_session.pool_backends) < 2:
return None
self.multi_session.create()
session_key = self.multi_session.session_key
for backend in self.multi_session.pool_backends:
engine = import_module(backend['backend'])
session = engine.SessionStore(session_key)
if "write" not in backend["modes"]:
eq_(session.exists(session_key), False)
if "write" in backend["modes"]:
eq_(session.exists(session_key), True)
if "delete" in backend["modes"] and session.exists(session_key) is True:
session.delete(session_key)
eq_(session.exists(session_key), False)
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse, parse_qs
import json
from passlib.hash import bcrypt
from http import cookies
from session import SessionStore
from gamesDB import *
gSessionStore = SessionStore()
class GameServer(BaseHTTPRequestHandler):
def do_OPTIONS(self):
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods',
'GET, POST, PUT, DELETE, OPTIONS')
self.send_header(
'Access-Control-Allow-Headers',
'Content-Type, Content-Length, Origin, Cookie, Set-Cookie')
self.end_headers()
return
def do_GET(self):
self.load_cookie()
print("About to load session")
self.load_session()
member, address = self.getMember()
idList = self.getIDs()
idPass = False
session_length = int(f.readline())
# stop the program if the string is not coercible to integer or the integer is not between 1 to 86400, inclusive
except ValueError:
raise ValueError("The content of inactivity_period.txt is not coercible to an integer!")
raise SystemExit(0)
if session_length < 1 or session_length > 86400:
print("The integer in inactivity_period.txt is beyond the specifications")
raise SystemExit(0)
# create output file writer
output = open(output_path, "w")
# initialize SessionStore object
sessions = SessionStore(session_length, output)
# for benchmarking purposes
start_execution = time.time()
# read log data file
with open(input_path, "r") as f:
# read first line of the log input file
target_vars = ["ip", "date", "time", "cik", "accession", "extention"]
colnames = f.readline().replace("\n", "").split(',')
# column index of targetvars
try:
column_indices = [colnames.index(var) for var in target_vars]
except ValueError as err:
raise ValueError("The input log file: {} is invalid because {}".format(input_path, err))
def setUp(self):
self.redis_session = RedisSession()
class TestRedisSesssios(unittest.TestCase):
def setUp(self):
self.redis_session = RedisSession()
def test_modify_and_keys(self):
eq_(self.redis_session.modified, False)
self.redis_session['test'] = 'test_me'
eq_(self.redis_session.modified, True)
eq_(self.redis_session['test'], 'test_me')
def test_save_and_delete(self):
self.redis_session['key'] = 'value'
self.redis_session.save()
eq_(self.redis_session.exists(self.redis_session.session_key), True)
self.redis_session.delete(self.redis_session.session_key)
eq_(self.redis_session.exists(self.redis_session.session_key), False)
def test_flush(self):
self.redis_session['key'] = 'another_value'
self.redis_session.save()
key = self.redis_session.session_key
self.redis_session.flush()
eq_(self.redis_session.exists(key), False)
def test_items(self):
self.redis_session['item1'], self.redis_session['item2'] = 1, 2
self.redis_session.save()
eq_(self.redis_session.items(), [('item2', 2), ('item1', 1)])
def test_expiry(self):
self.redis_session.set_expiry(1)
# Test if the expiry age is set correctly
eq_(self.redis_session.get_expiry_age(), 1)
self.redis_session['key'] = 'expiring_value'
self.redis_session.save()
key = self.redis_session.session_key
eq_(self.redis_session.exists(key), True)
time.sleep(2)
eq_(self.redis_session.exists(key), False)
def test_save_and_load(self):
self.redis_session.set_expiry(60)
self.redis_session.setdefault('item_test', 8)
self.redis_session.save()
session_data = self.redis_session.load()
eq_(session_data.get('item_test'), 8)
