def connnect():
if request.method == "GET":
req = request.args
elif request.method == "POST":
req = request.form
else:
return jsonify(ok=0)
username = req.get("username")
passphrase = req.get("passphrase")
if zeosocket:
socket = zeosocket
else:
host = req.get("host")
port = req.get("port")
if host and port:
socket = (host, port)
elif host:
socket = host
else:
socket = None
if not (username and passphrase and socket):
return jsonify(ok=0, message="Incomplete login information")
try:
db = zerodb.DB(socket, username=username, password=passphrase)
except Exception, e:
return jsonify(ok=0, message=str(e), error_type=e.__class__.__name__)
def db(request, zeo_server):
zdb = zerodb.DB(zeo_server, username="******", password=TEST_PASSPHRASE, debug=True)
@request.addfinalizer
def fin():
zdb.disconnect() # I suppose, it's not really required
return zdb
def user_db_factory(n='0'):
return zerodb.DB(addr,
username='******',
key=user_key,
cert_file=pem_path('cert' + n) if user_cert else None,
key_file=pem_path('key' + n) if user_cert else None,
server_cert=ZEO.tests.testssl.server_cert,
password='******' + n if user_password else None,
wait_timeout=1)
def get_db(self):
"""Return the mongo connection from the environment."""
if self.zerodb_db:
return self.zerodb_db
db = zerodb.DB(self.sock, self.username, self.password, **self.kwargs)
if self.post_create:
db = self.post_create(db)
self.zerodb_db = db
return self.zerodb_db
def user_db_factory(n='0'):
return zerodb.DB(
addr,
username='******' + n,
key=user_key,
cert_file=pem_path('cert' + n),
key_file=pem_path('key' + n),
server_cert=ZEO.tests.testssl.server_cert,
)
def test_dbmodel(zeo_server):
db = zerodb.DB(zeo_server,
username="******",
password=TEST_PASSPHRASE,
debug=True)
assert db[ExampleModel]._model == ExampleModel
assert db[ExampleModel]._db == db
assert db[ExampleModel]._catalog_name == "catalog__examplemodel"
assert db[ExampleModel]._intid_name == "store__examplemodel"
db.disconnect()
def test_db(zeo_server):
db = zerodb.DB(zeo_server,
username="******",
password=TEST_PASSPHRASE,
debug=True)
assert len(db._models) == 0
assert isinstance(db[ExampleModel], zerodb.db.DbModel)
assert len(db._models) == 1
assert ExampleModel in db._models
db.disconnect()
def test_dbmodel(zeo_server):
db = zerodb.DB(zeo_server,
username="******",
password=TEST_PASSPHRASE,
debug=True)
assert db[TestMe]._model == TestMe
assert db[TestMe]._db == db
assert db[TestMe]._catalog_name == "catalog__testme"
assert db[TestMe]._intid_name == "store__testme"
db.disconnect()
def db_aes_v0(request, zeo_server):
# Use new zerodb.DB class here
zdb = zerodb.DB(zeo_server,
username="******",
password=TEST_PASSPHRASE,
debug=True)
@request.addfinalizer
def fin():
zdb.disconnect()
return zdb
def many_server(request, pass_file, tempdir):
sock = do_zeo_server(request, pass_file, tempdir)
db = zerodb.DB(sock, username="******", password=TEST_PASSPHRASE, debug=True)
with transaction.manager:
for i in range(2000):
db.add(
Page(title="hello %s" % i,
text="lorem ipsum dolor sit amet" * 2))
for i in range(1000):
# Variable length while keeping number of terms the same
# will cause variable scores
db.add(
Page(title="hello %s" % i,
text="this is something we're looking for" * int(i**0.5)))
db.add(Page(title="extra page", text="something else is here"))
db.disconnect()
return sock
def _test_basic(
root_cert=True,
root_password=False,
user_cert=True,
user_password=False,
):
if root_password:
root_pwd, _ = kdf.hash_password('root',
'root_password',
key_file=None,
cert_file=None,
appname='zerodb.com',
key=None)
# zerodb.server took care of setting up a databasw with a root
# user and starting a server for it. The root user's cert is from
# ZEO.testing. The server is using a server cert from ZEO.tests.
addr, stop = zerodb.server(init=dict(
cert=ZEO.tests.testssl.client_cert if root_cert else None,
password='******' if root_password else None,
), )
# Create an admin client. Admin data aren't encrypted, so we use
# a regular ZEO client.
# XXX this should be in zerodb.db
# XXX along with kdf
def admin_db_factory():
return ZEO.DB(
addr,
ssl=ZEO.tests.testssl.client_ssl() if root_cert else nobody_ssl(),
credentials=dict(name='root', password=root_pwd)
if root_password else None,
wait_timeout=19999,
)
admin_db = admin_db_factory()
with admin_db.transaction() as conn:
# The get_admin function gets us an admin object with CRUD methods.
admin = zerodb.permissions.base.get_admin(conn)
[root] = admin.users.values()
if root_cert:
[root_der] = root.certs
assert (set(
pem.strip()
for pem in admin.certs.data.strip().split('\n\n')) == set(
pem.strip() for pem in (nobody_pem, root.certs[root_der])))
assert admin.uids[root_der] == root.id
else:
assert admin.certs.data.strip() == nobody_pem.strip()
assert len(admin.uids) == 2 if root_cert else 1
assert len(admin.users_by_name) == 1
assert admin.users_by_name[root.name] is root
# Let's add a user:
admin.add_user(
'user0',
pem_data=(pem_data('cert0') if user_cert else None),
password=('password0' if user_password else None),
)
[uid0] = [uid for uid in admin.users if uid != root.id]
admin_db.close()
# Now, let's try connecting
def user_db_factory(n='0'):
return zerodb.DB(addr,
username='******',
key=user_key,
cert_file=pem_path('cert' + n) if user_cert else None,
key_file=pem_path('key' + n) if user_cert else None,
server_cert=ZEO.tests.testssl.server_cert,
password='******' + n if user_password else None,
wait_timeout=1)
db = user_db_factory()
# we can access the root object.
assert db._root._p_oid == uid0
# It's empty now:
assert len(db._root) == 0
# Let's put something it:
db._root['x'] = 1
db._root['s'] = db._root.__class__()
db._root['s']['x'] = 2
db._connection.transaction_manager.commit()
# Close the db and reopen:
db._db.close()
# Reopen, and make sure the data are there:
db = user_db_factory()
assert db._root._p_oid == uid0
assert len(db._root) == 2
assert db._root['x'] == 1
assert db._root['s']['x'] == 2
db._db.close()
# The admin user can no longer access the user's folder:
admin_db = admin_db_factory()
with admin_db.transaction() as conn:
admin = zerodb.permissions.base.get_admin(conn)
user_root = admin.users[uid0].root
with pytest.raises(ZODB.POSException.StorageError) as exc_info:
len(user_root)
assert ('Attempt to access encrypted data of others'
in str(exc_info.value))
# Note that we had to close and reopen the admin connection
# because invalidations aren't sent accross users. (Even clearing
# the cache doesn't work (maybe a misfeature))
# The user's data are encrypted:
server_server = zerodb.forker.last_server
storage = server_server.server.storages['1']
assert storage.loadBefore(uid0, maxtid)[0].startswith(b'.e')
# Let's change the user's credentials:
with admin_db.transaction() as conn:
admin = zerodb.permissions.base.get_admin(conn)
admin.change_cert(
'user0',
pem_data('cert1') if user_cert else None,
'password1' if user_password else None,
)
# Now login with the old cert will fail:
with pytest.raises(ZEO.Exceptions.ClientDisconnected):
user_db_factory()
# But login with the new one will work:
db = user_db_factory('1')
assert len(db._root) == 2
db._db.close()
# Finally, let's remove the user:
with admin_db.transaction() as conn:
admin = zerodb.permissions.base.get_admin(conn)
admin.del_user('user0')
# Now, they can't log in at all:
for i in '01':
with pytest.raises(ZEO.Exceptions.ClientDisconnected):
user_db_factory(i)
admin_db.close()
# The admin user can login as an ordinary ZeroDB user:
db = zerodb.DB(
addr,
username='******',
key=root_key,
cert_file=ZEO.tests.testssl.client_cert if root_cert else None,
key_file=ZEO.tests.testssl.client_key if root_cert else None,
server_cert=ZEO.tests.testssl.server_cert,
password='******' if root_password else None,
wait_timeout=1)
# They have an empty root
assert len(db._root) == 0
stop()
import zerodb
from zerodb.query import *
from models import Employee
PASSPHRASE = "very insecure passphrase - never use it"
SOCKET = ("localhost", 8001)
db = zerodb.DB(SOCKET, username="******", password=PASSPHRASE)
print("Connected")
print(len(db[Employee]))
johns = db[Employee].query(name="John", limit=10)
print(len(johns))
print(johns)
rich_johns = db[Employee].query(InRange("salary", 195000, 200000), name="John")
print(len(rich_johns))
print(rich_johns)
uk = db[Employee].query(Contains("description", "United Kingdom"))
print(len(uk))
if uk:
print(uk[0])
print(uk[0].description)
Performance Measurement
"""
"""
This script measures the amount of time that is required for zeroDB
to return the result of variety of queries that it supports.
"""
#Importing necessary packages:
import time
import zerodb
import pdb
from zerodb.query import *
from models import *
#Configuring the database which is in use:
PASSWORD = "******"
db = zerodb.DB(("localhost", 8001), username="******", password=PASSWORD)
#Perform queries of various kinds and natures, let the bashscript time it all:
for i in range(10000):
first_three_johns = db[Employee].query(name="John", limit=3)
rich_johns = db[Employee].query(InRange("salary", 195000, 200000),
name="John")
notrich_johns = db[Employee].query(NotInRange("salary", 0, 1))
poor_johns = db[Employee].query(NotEq("salary", 200000))
print "Batch number " + str(i) + " is finished."
print "All done."
print "Table length: " + str(len(db[Employee]))
import zerodb # ZeroDB itself
import transaction # Transaction manager
import models # ..and our data model
# Also we need to generate some random data
import names
import loremipsum
import random
username = "******"
passphrase = "very insecure passphrase - never use it"
db = zerodb.DB(("localhost", 8001), username=username, password=passphrase)
# Everything we record should be within a transaction manager
# or be ended with transaction.commit()
with transaction.manager:
for i in range(400):
if (i % 100) == 0:
# Random text generation is slow, so we report
# about progress here
print(i)
e = models.Employee(name=names.get_first_name(),
surname=names.get_last_name(),
salary=random.randrange(200000),
description=loremipsum.get_paragraph(),
extra=loremipsum.get_sentence())
db.add(e) # Don't forget to add created object to the db
# One special record
desc = """A theoretical physicist, cosmologist,
import zerodb
from models import Trade
from zerodb.query import InRange, Gt
from datetime import datetime, timedelta
db = zerodb.DB(("localhost", 8001), username="******", password="******")
print len(db[Trade])
print db[Trade].query(
InRange("timestamp", datetime(year=2015, month=2, day=1),
datetime(year=2015, month=2, day=2)))
print db[Trade].query(Gt("timestamp", datetime(year=2015, month=2, day=1)))
# Some graphs
from pandas import DataFrame
import pylab
t = datetime(year=2015, month=5, day=1)
dt = timedelta(hours=1)
data = db[Trade].query(InRange("timestamp", t, t + dt))
df = DataFrame(data.dictify())
df.plot(x="timestamp", y="last")
ax = pylab.twinx()
df.plot(x="timestamp", y="volume", ax=ax, c="red")
pylab.show()
high = db[Trade].query(Gt("last", 490), sort_index="timestamp")
print high