def setUserSessionAndCookies(self,
request,
user_id,
user,
cookies=http.cookies.SimpleCookie(),
expiration=12 * 30 * 24 * 60 * 60,
json=False):
if self.session_backend_type == 1 and self._mc == None:
raise ValueError(
"setUserSession called without memcached being setup")
if self.session_backend_type == 2 and self._mrq == None:
raise ValueError(
"setUserSession called without mrworkserver being setup")
if self.session_backend_type == 3 and self._mrc == None:
raise ValueError(
"setUserSession called without mrcache being setup")
a = random.getrandbits(64)
b = random.getrandbits(64)
c = random.getrandbits(64)
k = mrhttp.to64(a) + mrhttp.to64(b) + mrhttp.to64(c)
k = k[:32]
while len(k) < 32:
k += mrhttp.to64(random.getrandbits(6))
userk = ""
numbits = user_id.bit_length()
if numbits == 0:
numbits += 1
while numbits > 0:
userk = mrhttp.to64(user_id & 0x1F) + userk
user_id >>= 5
numbits -= 5
userk = userk + mrhttp.to64(0x20 | random.getrandbits(5))
skey = userk + k[len(userk):]
# TODO We could have user id be optional and do this if not given
#skey = uuid.uuid4().hex
# Send the session cookie back to the user
c = cookies
c['mrsession'] = skey
c['mrsession']['path'] = '/'
c['mrsession']['expires'] = expiration
request.response.cookies = c
if self.session_backend_type == 1: # Memcached
if json:
self._mc.set(skey, json.dumpb(user))
else:
self._mc.set(skey, mrpacker.pack(user))
elif self.session_backend_type == 2: # MrWorkServer
self._mrq.set(user_id, mrpacker.pack([skey, user]))
elif self.session_backend_type == 3: # MrCache
self._mrc.set(skey, mrpacker.pack(user))
return skey
async def run(loop):
c = asyncmrws.Client()
#await c.connect(io_loop=loop,servers=[("127.0.0.1",7100), ("127.0.0.1",7002)])
await c.connect(io_loop=loop,servers=[("127.0.0.1",7100)])
bstr = mrpacker.pack([1,2,3,4,5,6,7,8,9,10])
l = len(bstr)
#await c.bench()
start = time.time()
for x in range(1000000):
#if x % 100000 == 0: print (x)
#await c.push( 0, 0, bstr, l )
await c.push_noflush( x, bstr, l )
#print("push failed")
#break
await c.flush()
end = time.time()
print(end - start)
#await c.bench()
await asyncio.sleep(0.5, loop=loop)
await c.close()
async def run(loop):
c = asyncmrws.Client()
await c.connect(io_loop=loop, servers=[("127.0.0.1", 7100)])
# Test fetch
if 0:
print(mrpacker.unpack(await c.get(0, mrpacker.pack([1, 2, 3]))))
# Push some work
if 1:
msg = mrpacker.pack([22] * 100)
while 1:
await c.push(0, msg, len(msg))
await asyncio.sleep(1)
await c.close()
async def run(loop):
rc = await asyncmrcache.create_client([("localhost", 7000)],
loop,
lost_cb=lcb)
await rc.set(b"mrsession43709dd361cc443e976b05714581a7fb",
mrpacker.pack({"user": "******"}))
print(await rc.get(b"mrsession43709dd361cc443e976b05714581a7fb"))
exit()
async def run(loop):
c = asyncmrws.Client()
await c.connect(io_loop=loop, servers=[("127.0.0.1", 7100)])
#sc = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
#sc.load_verify_locations('cert/server.crt')
#await c.connect(io_loop=loop,servers=[("127.0.0.1",7100)],ssl=sc)
m = mrpacker.pack([1, 2, 3, "test"])
l = len(m)
await c.push(0, m, l)
await c.close()
async def run(loop):
c = asyncmrq.Client()
#await c.connect(io_loop=loop,servers=[("127.0.0.1",7100),("127.0.0.1",7002)])
await c.connect(io_loop=loop, servers=[("127.0.0.1", 7100)])
#sc = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
#sc.load_verify_locations('cert/server.crt')
#await c.connect(io_loop=loop,servers=[("127.0.0.1",7100)],ssl=sc)
#await c.push( 0, 0, m, l )
#await asyncio.sleep(0.5, loop=loop)
#await c.close()
#return
if 0:
print(mrpacker.unpack(await c.get(0, mrpacker.pack([1, 2, 3]))))
if 0:
l = []
l.append(c.get(0, mrpacker.pack([1, 2, 3])))
l.append(c.get(0, mrpacker.pack([1, 2, 3, 4])))
l.append(c.get(0, mrpacker.pack([5])))
print(await asyncio.gather(*l))
for x in range(100):
m = mrpacker.pack(x)
l = len(m)
if await c.push(x, 0, m, l):
print(x, "droppped")
else:
print(x)
await asyncio.sleep(0.5, loop=loop)
await asyncio.sleep(0.5, loop=loop)
#msgs = await c.pull( 0, 0 )
#print(msgs)
await c.close()
async def run(loop):
c = asyncmrws.Client()
await c.connect(io_loop=loop,
servers=[("127.0.0.1", 7100), ("127.0.0.1", 7001)])
num = 10000
#m = mrpacker.pack( [1, "foo", {"yay":1}] )
m = mrpacker.pack("AeeGEVMfFEANKzNPhbNkhMbORHAqn-rR")
s = time.time()
for x in range(1000):
l = []
for y in range(10):
l.append(c.get(x, m))
#l.append( c.set( x, m ) )
await asyncio.gather(*l)
e = time.time()
print(num / (e - s), " Requests/second")
await asyncio.sleep(0.5, loop=loop)
await c.close()
async def get(self, slot, o): b = mrpacker.pack(o) srv = self._get(slot, b) return await self.servers[srv].q.get()
def mrp(r):
return mrpacker.pack([1, 2, 3])
#print(o)
#o = [True]*5000
o = {
"name": "MalthusianProphet",
"tl": 2004,
"dankmemes": True,
"list": [1, 2, 3, 4, 5, 6]
}
#o = {"name":55,"tl":2004,"dankmemes":True,"list":[1,2,3,4,5,6]}
#o = [ "fadsfds", 213 , 123, 1, 2, 3, "lists are cool", [1,2,3,] ]
for x in range(1):
if 1:
#st = time.time()
b = mrp.pack(o)
#print( "took ", time.time()-st)
#st = time.time()
#o = mrp.unpack( b )
#print( "took ", time.time()-st)
#exit(1)
if 0:
#st = time.time()
b = mrjson.dumps(o)
#print( "took ", time.time()-st)
#st = time.time()
#o = mrjson.loads( b )
#print( "took ", time.time()-st)
if 0:
def fetchcb(ws, o):
return mrpacker.pack( {"name":"mark"} )
def setcb(ws, k, v): users[k] = mrpacker.pack(v)
import mrpacker
from pymemcache.client.base import Client
c = Client(('localhost', 11211))
c.set("mrsession43709dd361cc443e976b05714581a7fb",
mrpacker.pack({"user": "******"}))
c = Client(('localhost', 11212))
c.set("mrsession43709dd361cc443e976b05714581a7fb",
mrpacker.pack({"user": "******"}))
#print( c.get("mrsessionZZZZ9dd361cc443e976b05714581a7fb"))
import asyncmrcache, asyncio
def lcb(client):
print("Lost conn")
async def run(loop):
rc = await asyncmrcache.create_client([("localhost", 7000)],
loop,
lost_cb=lcb)
await rc.set(b"mrsession43709dd361cc443e976b05714581a7fb",
mrpacker.pack({"user": "******"}))
print(await rc.get(b"mrsession43709dd361cc443e976b05714581a7fb"))
exit()
loop = asyncio.get_event_loop()
loop.run_until_complete(run(loop))
import traceback
from mrhttp import app
import asyncmrq, mrpacker
app.config["memcache"] = [("127.0.0.1", 11211)]
#@app.on('at_start')
#async def setup():
#app.c = asyncmrq.Client()
#await app.c.connect(servers=[("127.0.0.1",7100)])
msg = mrpacker.pack([1, 2, 3])
msglen = len(msg)
print(msg)
@app.route('/', options=['session'])
async def index(r):
#await app.c.push( r.user["id"], 0, msg, msglen )
#print( r.headers )
#print( r.ip )
return "yay"
#x = r.form
#d = r.mrpack
#return d["name"]
#x = r.form
#return x["param2"]
@app.route('/json')
def json(r):
{
"A": [{}, [], {}],
"b": {
"1": 1,
"2": 2,
"3": 3
}
},
]
o = {}
for x in range(100000):
o[x] = x
objs.append(o)
# NaN != Nan so check str rep
o = j.unpack(j.pack(float('nan')))
eq(str(o), 'nan')
for o in objs:
try:
eq(o, j.unpack(j.pack(o)))
except Exception as e:
print("ERROR", str(e), o)
from os import walk
for (dirpath, dirnames, filenames) in walk("test_data"):
for fn in filenames:
f = open("test_data/" + fn, "rb")
o = json.load(f)
try:
eq(o, j.unpack(j.pack(o)))
