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