def test_two_connections_sharing_data(self):
connection2 = MongoStore.makeConnection('localhost', MONGODB_TEST_PORT)
store2 = MongoServerStore(connection2, self.__class__.__name__)
user = self.mother.make_test_user()
user2 = store2.read_user(user.ID)
self.assertEqual(user.ID, user2.ID)
def test_performance_breadth(self):
store = MongoServerStore(self.conn, self.__class__.__name__)
store.create_user(User("user2"))
publisher = TestPublisher("user2", store)
brl_block = BRLBlock('user2/user2/block/master')
count = 1000
resource_info = {}
for i in xrange(count):
deps = DependencySet()
if i > 0:
deps = DependencySet()
for j in range(max(0, i - 25), i):
deps.explicit.add(BlockCellName('user2/block/cell%d.h' %
j))
deps.resolved.add(
CPPDeclaration('user2/block/cell%d.h' % j))
deps.unresolved.add(CPPDeclaration('path/to/file.h'))
deps.implicit.add(BlockCellName('user2/block/cell%d.h' % j))
resource_info['cell%d.h' % i] = 'content %d' % i, deps
publisher.publish(brl_block, resource_info)
timer = self.get_timer()
start_time = timer()
store = MemServerStore(store)
#print 'MEMSTORE SIZE 0', asizeof(store) / 1000000.0
translator = ReferenceTranslatorService(store, "user2")
version = BlockVersion(brl_block, 0)
missing = References()
missing[version].add('cell%d.h' % (count - 1))
closure = CompatibilityClosure(missing)
full_graph = BlockVersionGraph()
full_graph.add_nodes([version])
build_compatibility_closure(translator, closure, [version], full_graph)
elapsed_time = timer() - start_time
#print 'Closure time', elapsed_time
#print 'CLOSURE SIZE ', asizeof(closure) / 1000000.0
#print 'MEMSTORE SIZE ', asizeof(store) / 1000000.0
# print 'MINCELLS SIZE ', asizeof(store.min_cells)/1000000.0
self.assertEqual({brl_block.block_name + c
for c in resource_info}, closure.block_cell_names)
self.assertLess(elapsed_time, 7)
def test_read_published_blocks_info(self, store_cls):
"""Insert a block and read all published blocks info (brl, lastpubdate)"""
if store_cls == MongoServerStore:
store = MongoServerStore(self.conn, self.__class__.__name__)
else:
store = TestingMemServerStore()
block = Block(ID((23, 23)), BRLBlock("bonjovi/bonjovi/itsmylife/master"))
ppack = PublishRequest(block.last_version())
r1 = SimpleCell('user/block/r1.h')
ppack.cells.append(r1)
ppack.contents['r1.h'] = Content(id_=None, load=Blob('hola'))
block.add_publication(ppack)
store.create_block(block, False)
ret = store.read_published_blocks_info()
first = ret.next()
self.assertEquals(first[0], "bonjovi/bonjovi/itsmylife/master")
self.assertEquals(first[1].__class__, datetime.datetime)
def setUp(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.store = ReverseDependencyMongoStore(self.store)
bver = BlockVersion.loads("creator/block(owner/branch):2")
self.bv2 = BlockVersion.loads("creator2/block(owner2/branch):2")
self.bv3 = BlockVersion.loads("creator3/block(owner3/branch):3")
self.reverse = ReverseDependency(bver)
self.reverse.add_dependant_version(self.bv2)
self.reverse.add_dependant_version(self.bv3)
self.store.upsert_reverse_dependencies(self.reverse)
# Other version of same block
bver2 = BlockVersion.loads("creator/block(owner/branch):3")
self.reverse2 = ReverseDependency(bver2)
self.reverse2.add_dependant_version(self.bv2)
self.reverse2.add_dependant_version(self.bv3)
self.store.upsert_reverse_dependencies(self.reverse2)
def launch():
# Default MongoClient params are:
# w=1 perform a write acknowledgement only in primary
# j=False the driver does not add j to the getlasterror command
# fsync=False the server does not add Sync to disk. to the getlasterror command
mongo_connection = MongoClient(BII_MONGO_URI, max_pool_size=BII_MAX_MONGO_POOL_SIZE)
migration_store = MigrationStore(mongo_connection)
server_store = MongoServerStore(mongo_connection)
biiout = OutputStream()
manager = MigrationManager(migration_store, SERVER_MIGRATIONS, biiout)
# Pass in kwargs all variables migrations can need
n1 = time.time()
manager.migrate(server_store=server_store)
n2 = time.time()
biiout.info('All took %s seconds' % str(n2 - n1))
# DO NOT REMOVE THIS PRINT NOR REPLACE WITH LOGGER, ITS A CONSOLE SCRIPT
# INVOKED IN DEPLOYMENT PROCESS AND ITS NECESSARY IT PRINTS TO OUTPUT
print biiout
def test_performance_depth(self):
brl_user = '******'
store = MongoServerStore(self.conn, self.__class__.__name__)
store.create_user(User(brl_user))
publisher = TestPublisher(brl_user, store)
brl_block = BRLBlock('user/user/block/master')
count = 500
resource_info = {
'cell%d.h' % i:
('content %d' % i, ['user/block/cell%d.h' % (i - 1)] if i else [])
for i in range(count)
}
publisher.publish(brl_block, resource_info)
timer = self.get_timer()
start_time = timer()
# prof = cProfile.Profile()
# prof.enable()
store = MemServerStore(store)
# print 'MEMSTORE DEPTH SIZE 0', asizeof(store) / 1000000.0
translator = ReferenceTranslatorService(store, brl_user)
version = BlockVersion(brl_block, 0)
missing = References()
missing[version].add('cell%d.h' % (count - 1))
closure = CompatibilityClosure(missing)
full_graph = BlockVersionGraph()
full_graph.add_nodes([version])
build_compatibility_closure(translator, closure, [version], full_graph)
self.assertEqual(References(), closure.broken)
#print 'CLOSURE SIZE ', asizeof(closure) / 1000000.0
#print 'MEMSTORE SIZE ', asizeof(store) / 1000000.0
elapsed_time = timer() - start_time
#print 'Closure time', elapsed_time
self.assertEqual({brl_block.block_name + c
for c in resource_info}, closure.block_cell_names)
self.assertLess(elapsed_time, 5)
def setUp(self):
self.conn.drop_database(self._testMethodName)
self.store = MongoServerStore(self.conn, self._testMethodName)
self.mother = ModelCreator(self.store)
self.user = self.mother.make_test_user()
self.p = PublishService(self.store, self.user.ID)
self.brl = BRLBlock('%s/%s/block/master' %
(self.user.ID, self.user.ID))
pack = PublishRequest(BlockVersion(self.brl, -1))
pack.cells.append(SimpleCell('%s/block/r1.h' % self.user.ID))
pack.cells.append(SimpleCell('%s/block/r2.h' % self.user.ID))
pack.cells.append(SimpleCell('%s/block/r3.h' % self.user.ID))
pack.contents['r1.h'] = Content(id_=None, load=Blob('r1'))
pack.contents['r2.h'] = Content(id_=None, load=Blob('r2'))
pack.contents['r3.h'] = Content(id_=None, load=Blob('r3'))
pack.deptable = BlockVersionTable()
self.pack = pack
self.cell_collection = self.store.db[
GenericServerStore.PUBLISHED_CELL_ST]
self.content_collection = self.store.db[
GenericServerStore.PUBLISHED_CONTENT_ST]
self.block_collection = self.store.db[GenericServerStore.BLOCK_ST]
import sys
from biicode.server.rest.rest_api_server import RestApiServer
from biicode.server.conf import BII_MONGO_URI, BII_MEMCACHE_SERVERS,\
BII_MEMCACHE_USERNAME, BII_MEMCACHE_PASSWORD, BII_MAX_MONGO_POOL_SIZE
from biicode.server.store.mongo_server_store import MongoServerStore
from biicode.server.store.mongo_store import MongoStore
store = MongoServerStore(MongoStore.makeConnection(BII_MONGO_URI,
max_pool_size=BII_MAX_MONGO_POOL_SIZE))
if BII_MEMCACHE_SERVERS:
from biicode.server.store.memcache_proxy_store import MemCacheProxyStore
import pylibmc
client = pylibmc.Client(servers=[BII_MEMCACHE_SERVERS],
username=BII_MEMCACHE_USERNAME,
password=BII_MEMCACHE_PASSWORD,
binary=True)
proxy = MemCacheProxyStore(store, client)
else:
proxy = store
# Run with: gunicorn -b 0.0.0.0:9000 -k gevent_pywsgi biicode.server.rest.production_server:app
ra = RestApiServer(proxy)
app = ra.root_app
# Script for create users in command line
from biicode.server.store.mongo_store import MongoStore
from biicode.server.store.mongo_server_store import MongoServerStore
from biicode.server.conf import BII_MONGO_URI
from biicode.server.user.user_service import UserService
import sys
from biicode.common.model.brl.brl_user import BRLUser
import getpass
connection = MongoStore.makeConnection(BII_MONGO_URI)
database_name = BII_MONGO_URI.split("/").pop()
server_store = MongoServerStore(connection, database_name)
def new_user(login, email, password):
service = UserService(server_store, login)
service.register(login, email, password, True)
user = server_store.read_user(login)
user.active = True
server_store.update_user(user)
def change_password(login, password):
user = server_store.read_user(login)
user.password = password
server_store.update_user(user)
def input_new_user():
print "\n--------new user---------\n"
def setUp(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.testUser = self.mother.make_test_user()
self.service = BiiService(self.store, self.testUser.ID)
def setUp(self):
unittest.TestCase.setUp(self)
tmp = MongoServerStore(self.conn, self.__class__.__name__)
self.store = AchievementDigestMongoStore(tmp)
