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_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_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_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 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.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 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]
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.mother = ModelCreator(self.store)
self.testUser = self.mother.make_test_user()
self.service = BiiService(self.store, self.testUser.ID)
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
def setUp(self):
unittest.TestCase.setUp(self)
tmp = MongoServerStore(self.conn, self.__class__.__name__)
self.store = AchievementDigestMongoStore(tmp)
class MongoStoreTest(TestWithMongo):
_multiprocess_shared_ = True
def setUp(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.user = self.mother.make_test_user()
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_dupe_user_name(self):
with self.assertRaises(AlreadyInStoreException):
self.store.create_user(self.user)
def test_insert_read_block(self):
name = BRLBlock('%s/%s/TestBlock/trunk' % (self.user.ID, self.user.ID))
mid = self.user.add_block(name)
block = Block(mid, name)
self.store.create_block(block)
retrieved1 = self.store.read_block(name)
self.assertEqual(block, retrieved1)
def test_insert_read_published_resource(self):
block = self.mother.make_block()
resource = model_creator.make_published_resource(
block, 'TestUser/geom/sphere.cpp')
self.store.create_published_cells([resource])
retrieved = self.store.read_published_cells([resource.ID])
self.assertEqual(resource, retrieved[resource.ID])
self.assertEqual(1, len(retrieved))
def test_insert_read_published_content(self):
block = self.mother.make_block(self.user)
brl = BlockCellName('%s/geom/sphere.cpp' % block.ID.owner)
content = model_creator.make_content(brl, False)
content.ID = ID((2, 3, 4)) # 'dummy_id'
self.store.create_published_contents([content])
retrieved = self.store.read_published_contents([content.ID])
self.assertEqual(content, retrieved[content.ID])
self.assertEqual(1, len(retrieved))
def test_two_publish_transactions(self):
brl = BRLBlock('user/user/block/master')
self.store.requestBlockTransaction(brl)
with self.assertRaises(BiiPendingTransactionException):
self.store.requestBlockTransaction(brl)
def test_dirty_object(self):
u1 = self.mother.make_test_user()
u_ = self.store.read_user(u1.ID)
u1_bis = self.store.read_user(u1.ID)
self.store.update_user(
u_) # Now b1_bis is dirty!! is not updated from database
self.assertRaises(MongoNotCurrentObjectException,
self.store.update_user, u1_bis)
def test_txn_multiple_updates_same_object(self):
for _ in range(10):
# Not dirty!! same memory object with up to date counter
self.store.update_user(self.user)
def test_txn_limit_counter(self):
bclean = self.store.read_user(self.user.ID)
bdirty = self.store.read_user(self.user.ID)
self.store.update_user(bclean)
# dirty!! same memory object with up to date counter
self.assertRaises(MongoNotCurrentObjectException,
self.store.update_user, bdirty)
def test_txn_limit_counter_overflow(self):
b1 = self.user
update_if_current.TXN_MAX_C = 10
logger.debug("CONTADOR MAXIMO:" + str(update_if_current.TXN_MAX_C))
bclean = self.store.read_user(b1.ID)
bdirty = self.store.read_user(b1.ID)
for _ in range(update_if_current.TXN_MAX_C):
# 10 updates in transaction (increments tx counter each)
self.store.update_user(bclean)
self.store.update_user(
bdirty) # dirty but cheated!! counter overflowed
def testTxnDecorator(self):
# Call this method, it will execute the code until not MongoDirtyObjectException raises
m = mock.Mock(return_value="ok, mock called")
self.i = 0
ret = self._transaction_method(m,
5,
max_uncouple_ms=50,
max_iterations=10)
self.assertEqual(ret, "OK!!!")
m.assert_called_with(4)
self.i = 0
ret = self._transaction_method(m,
9,
max_uncouple_ms=100,
max_iterations=10)
self.assertEqual(ret, "OK!!!")
m.assert_called_with(8)
self.i = 0
self.assertRaises(MongoStoreException,
self._transaction_method,
m,
30,
max_uncouple_ms=10,
max_iterations=30)
@safe_retry
def _transaction_method(self, mock_obj, n_times):
''' raises dirty object exception only N times '''
if self.i < n_times:
mock_obj(self.i)
self.i = self.i + 1
raise MongoNotCurrentObjectException("Oh!! an exception again...")
return "OK!!!"
def testUpdateNotExistingError(self):
# Not existing collection with not existing object
self.assertRaises(MongoNotFoundUpdatingException,
self.store._update_collection,
"notexitingcollection", {'a': 1},
set_statement={'a': 2},
upsert=False,
trx_record=False)
# Existing collection with not existing object
self.assertRaises(MongoNotFoundUpdatingException,
self.store._update_collection,
GenericServerStore.USER_ST, {'a': 1},
set_statement={'a': 2},
upsert=False,
trx_record=False)
# Existing object update
myblock = Block(ID((9, 2)), BRLBlock("user/user/myblock/master"))
self.store.create_block(myblock)
ret = self.store._update_collection(
GenericServerStore.BLOCK_ST,
{Block.SERIAL_ID_KEY: myblock.ID.serialize()},
set_statement={"$set": {
Block.SERIAL_CONTENT_COUNTER: 89
}},
upsert=False,
trx_record=False)
self.assertIsInstance(ret, dict)
# Existing object update but without changes
ret = self.store._update_collection(
GenericServerStore.BLOCK_ST,
{Block.SERIAL_ID_KEY: myblock.ID.serialize()},
set_statement={"$set": {
Block.SERIAL_CONTENT_COUNTER: 89
}},
upsert=False,
trx_record=False)
self.assertIsInstance(ret, dict)
# Upsert an existing object
the_id = ID((22, 33))
myblock = Block(the_id, BRLBlock("user/user/myblock2/master"))
self.store.create_block(myblock)
ret = self.store._update_collection(
GenericServerStore.BLOCK_ST,
{Block.SERIAL_ID_KEY: myblock.ID.serialize()},
set_statement={"$set": {
Block.SERIAL_CONTENT_COUNTER: 89
}},
upsert=True,
trx_record=False)
self.assertIsInstance(ret, dict)
def test_update_permissions(self):
myblock = self.mother.make_block(self.user)
# Check default permissions
access = self.store.read_block_permissions(myblock.ID)
perm = ElementPermissions(False)
self.assertTrue(access, perm)
# Update permissions
access.read.grant("pepe")
access.read.grant("jaunito")
access.write.grant("jaunito")
self.store.update_block_permissions(access)
perms = self.store.read_block_permissions(myblock.ID)
self.assertTrue(perms.read.is_granted("pepe"))
self.assertFalse(perms.write.is_granted("pepe"))
self.assertTrue(perms.read.is_granted("jaunito"))
self.assertTrue(perms.write.is_granted("jaunito"))
def setUp(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.user = self.mother.make_test_user()
class MongoStoreTest(TestWithMongo):
_multiprocess_shared_ = True
def setUp(self):
self.store = MongoServerStore(self.conn, self.__class__.__name__)
self.mother = ModelCreator(self.store)
self.user = self.mother.make_test_user()
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_dupe_user_name(self):
with self.assertRaises(AlreadyInStoreException):
self.store.create_user(self.user)
def test_insert_read_block(self):
name = BRLBlock('%s/%s/TestBlock/trunk' % (self.user.ID, self.user.ID))
mid = self.user.add_block(name)
block = Block(mid, name)
self.store.create_block(block)
retrieved1 = self.store.read_block(name)
self.assertEqual(block, retrieved1)
def test_insert_read_published_resource(self):
block = self.mother.make_block()
resource = model_creator.make_published_resource(block, 'TestUser/geom/sphere.cpp')
self.store.create_published_cells([resource])
retrieved = self.store.read_published_cells([resource.ID])
self.assertEqual(resource, retrieved[resource.ID])
self.assertEqual(1, len(retrieved))
def test_insert_read_published_content(self):
block = self.mother.make_block(self.user)
brl = BlockCellName('%s/geom/sphere.cpp' % block.ID.owner)
content = model_creator.make_content(brl, False)
content.ID = ID((2, 3, 4)) # 'dummy_id'
self.store.create_published_contents([content])
retrieved = self.store.read_published_contents([content.ID])
self.assertEqual(content, retrieved[content.ID])
self.assertEqual(1, len(retrieved))
def test_two_publish_transactions(self):
brl = BRLBlock('user/user/block/master')
self.store.requestBlockTransaction(brl)
with self.assertRaises(BiiPendingTransactionException):
self.store.requestBlockTransaction(brl)
def test_dirty_object(self):
u1 = self.mother.make_test_user()
u_ = self.store.read_user(u1.ID)
u1_bis = self.store.read_user(u1.ID)
self.store.update_user(u_) # Now b1_bis is dirty!! is not updated from database
self.assertRaises(MongoNotCurrentObjectException, self.store.update_user, u1_bis)
def test_txn_multiple_updates_same_object(self):
for _ in range(10):
# Not dirty!! same memory object with up to date counter
self.store.update_user(self.user)
def test_txn_limit_counter(self):
bclean = self.store.read_user(self.user.ID)
bdirty = self.store.read_user(self.user.ID)
self.store.update_user(bclean)
# dirty!! same memory object with up to date counter
self.assertRaises(MongoNotCurrentObjectException, self.store.update_user, bdirty)
def test_txn_limit_counter_overflow(self):
b1 = self.user
update_if_current.TXN_MAX_C = 10
logger.debug("CONTADOR MAXIMO:" + str(update_if_current.TXN_MAX_C))
bclean = self.store.read_user(b1.ID)
bdirty = self.store.read_user(b1.ID)
for _ in range(update_if_current.TXN_MAX_C):
# 10 updates in transaction (increments tx counter each)
self.store.update_user(bclean)
self.store.update_user(bdirty) # dirty but cheated!! counter overflowed
def testTxnDecorator(self):
# Call this method, it will execute the code until not MongoDirtyObjectException raises
m = mock.Mock(return_value="ok, mock called")
self.i = 0
ret = self._transaction_method(m, 5, max_uncouple_ms=50, max_iterations=10)
self.assertEqual(ret, "OK!!!")
m.assert_called_with(4)
self.i = 0
ret = self._transaction_method(m, 9, max_uncouple_ms=100, max_iterations=10)
self.assertEqual(ret, "OK!!!")
m.assert_called_with(8)
self.i = 0
self.assertRaises(MongoStoreException, self._transaction_method, m, 30, max_uncouple_ms=10,
max_iterations=30)
@safe_retry
def _transaction_method(self, mock_obj, n_times):
''' raises dirty object exception only N times '''
if self.i < n_times:
mock_obj(self.i)
self.i = self.i + 1
raise MongoNotCurrentObjectException("Oh!! an exception again...")
return "OK!!!"
def testUpdateNotExistingError(self):
# Not existing collection with not existing object
self.assertRaises(MongoNotFoundUpdatingException, self.store._update_collection,
"notexitingcollection", {'a': 1}, set_statement={'a': 2},
upsert=False, trx_record=False)
# Existing collection with not existing object
self.assertRaises(MongoNotFoundUpdatingException, self.store._update_collection,
GenericServerStore.USER_ST, {'a': 1}, set_statement={'a': 2},
upsert=False, trx_record=False)
# Existing object update
myblock = Block(ID((9, 2)), BRLBlock("user/user/myblock/master"))
self.store.create_block(myblock)
ret = self.store._update_collection(GenericServerStore.BLOCK_ST,
{Block.SERIAL_ID_KEY: myblock.ID.serialize()},
set_statement={"$set":
{Block.SERIAL_CONTENT_COUNTER: 89}},
upsert=False, trx_record=False)
self.assertIsInstance(ret, dict)
# Existing object update but without changes
ret = self.store._update_collection(GenericServerStore.BLOCK_ST,
{Block.SERIAL_ID_KEY: myblock.ID.serialize()},
set_statement={"$set":
{Block.SERIAL_CONTENT_COUNTER: 89}},
upsert=False, trx_record=False)
self.assertIsInstance(ret, dict)
# Upsert an existing object
the_id = ID((22, 33))
myblock = Block(the_id, BRLBlock("user/user/myblock2/master"))
self.store.create_block(myblock)
ret = self.store._update_collection(GenericServerStore.BLOCK_ST,
{Block.SERIAL_ID_KEY: myblock.ID.serialize()},
set_statement={"$set":
{Block.SERIAL_CONTENT_COUNTER: 89}},
upsert=True, trx_record=False)
self.assertIsInstance(ret, dict)
def test_update_permissions(self):
myblock = self.mother.make_block(self.user)
# Check default permissions
access = self.store.read_block_permissions(myblock.ID)
perm = ElementPermissions(False)
self.assertTrue(access, perm)
# Update permissions
access.read.grant("pepe")
access.read.grant("jaunito")
access.write.grant("jaunito")
self.store.update_block_permissions(access)
perms = self.store.read_block_permissions(myblock.ID)
self.assertTrue(perms.read.is_granted("pepe"))
self.assertFalse(perms.write.is_granted("pepe"))
self.assertTrue(perms.read.is_granted("jaunito"))
self.assertTrue(perms.write.is_granted("jaunito"))
# 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"
