def auth(client):
yield client.dummy_authenticate('open sesame')
d = defer.Deferred()
client.connectionLostHandler = d.callback
# add the log handler
logger = logging.getLogger('storage.server')
hdlr = MementoHandler()
hdlr.setLevel(logging.INFO)
logger.addHandler(hdlr)
# patch the looping ping values
server = self.service.factory.protocols[0]
server.ping_loop.interval = 0.1
server.ping_loop.idle_timeout = 0.3
# reschedule the ping loop
server.ping_loop.reset()
try:
yield d
except ConnectionDone:
msg = "Disconnecting - idle timeout"
self.assertTrue(hdlr.check_info(msg))
else:
self.fail("Should get disconnected.")
finally:
logger.removeHandler(hdlr)
def test_disconnect_with_user_locked_after_auth(self):
"""Client gets disconnected if the user is locked after auth."""
# add the log handler
logger = logging.getLogger('storage.server')
hdlr = MementoHandler()
hdlr.setLevel(logging.INFO)
logger.addHandler(hdlr)
# define a connectionLostHandler to know when the client
# gets disconnected.
d = defer.Deferred()
def conn_lost_handler(r):
"""Connection lost!"""
d.callback(None)
@defer.inlineCallbacks
def dummy(client):
# set the connection lost handler
client.connectionLostHandler = conn_lost_handler
# trigger an operation, which should
yield client.dummy_authenticate("open sesame")
root_id = yield client.get_root()
# lock the user:
usr = self.user_store.get(model.StorageUser, 0)
usr.locked = True
self.user_store.commit()
client.make_dir(request.ROOT, root_id, u"open sesame")
yield d
# check we logged a warning about this.
self.assertTrue(
hdlr.check_warning("Shutting down protocol: user locked"))
return self.callback_test(dummy, add_default_callbacks=True)
def test_retryable_transaction_InternalError(self):
"""Retryable_transaction retry and log on InternalError."""
sleep = self.mocker.replace('time.sleep')
self.expect(sleep(mocker.ANY)).count(2)
self.mocker.replay()
logger = logging.getLogger('storage.server.txn')
h = MementoHandler()
logger.addHandler(h)
calls = []
@retryable_transaction()
def function():
"""Fail with InternalError."""
if len(calls) < 1:
calls.append('function')
raise InternalError('internal error')
else:
calls.append('function')
function()
logger.removeHandler(h)
self.assertEqual(calls, ['function'] * 2)
self.assertEqual(1, len(h.records))
self.assertIn('Got an InternalError, retrying',
h.records[0].getMessage())
self.assertEqual('internal error', h.records[0].exc_info[1].message)
def setUp(self):
yield super(TestServerScan, self).setUp()
yield self.get_client()
yield self.do_create_lots_of_files('_pre')
self.handler = handler = MementoHandler()
handler.setLevel(logging.DEBUG)
logging.getLogger('fsyncsrvr.SyncDaemon').addHandler(handler)
def configure_logging(self):
"""Configure logging for the tests."""
logger = logging.getLogger("ssl_proxy")
logger.setLevel(logging.DEBUG)
logger.propagate = False
self.handler = MementoHandler()
logger.addHandler(self.handler)
self.addCleanup(logger.removeHandler, self.handler)
def setUp(self):
yield super(ClientDummyAuthTests, self).setUp()
self.creds = 'open sesame'
self.bad_creds = 'not my secret'
self.handler = MementoHandler()
logger = logging.getLogger('storage.server')
logger.addHandler(self.handler)
self.addCleanup(logger.removeHandler, self.handler)
self.handler.setLevel(logging.DEBUG)
def setUp(self):
yield super(HeartbeatWriterTest, self).setUp()
self.logger = logging.Logger("HeartbeatWriter.test")
self.handler = MementoHandler()
self.logger.addHandler(self.handler)
self.addCleanup(self.logger.removeHandler, self.handler)
self.clock = task.Clock()
self.hw = HeartbeatWriter(self.interval,
self.logger,
reactor=self.clock)
def setUp(self):
super(RestHelperTestCase, self).setUp()
self.handler = MementoHandler()
self.user = self.obj_factory.make_user(1, u"bob", u"bobby boo",
2 * (2**30))
self.mapper = ResourceMapper()
logger = logging.getLogger("test")
logger.addHandler(self.handler)
logger.setLevel(logging.INFO)
logger.propagate = False
self.helper = RestHelper(self.mapper, logger=logger)
self.store = self.get_shard_store(self.user.shard_id)
def setUp(self):
super(StatsWorkerTestCase, self).setUp()
self.mocker = Mocker()
self.rpc = self.mocker.mock()
self.worker = stats_worker.StatsWorker(10, '', self.rpc)
# logging setup
self.handler = MementoHandler()
self.worker.logger.addHandler(self.handler)
self.addCleanup(self.worker.logger.removeHandler, self.handler)
self.worker.logger.setLevel(logging.DEBUG)
self.handler.setLevel(logging.DEBUG)
self.worker.logger.propagate = False
self.handler.debug = True
def test__check_stores_and_invalidate(self):
"""Test _check_stores_and_invalidate invalidate case."""
from backends.filesync.data.services import make_storage_user
from backends.filesync.data.model import StorageObject
logger = logging.getLogger('storage.server.noninv')
h = MementoHandler()
logger.addHandler(h)
make_storage_user(1, u'foo', u'foo', 10000, u'shard2')
sto = get_store('shard2', storage_zstorm)
self._sto = sto # for later cleanup
obj = StorageObject(1, u'foo', u'File')
sto.add(obj)
sto.flush()
self.assertFalse(obj.__storm_object_info__.get("invalidated", False))
_check_stores_and_invalidate(storage_zstorm)
self.assertTrue(obj.__storm_object_info__.get("invalidated", False))
self.assertEqual(1, len(h.records))
self.assertEqual((obj, ), h.records[0].args)
def setUp(self):
super(HeartbeatListenerTestCase, self).setUp()
self.stdin = StringIO()
self.stdout = StringIO()
self.stderr = StringIO()
self.mocker = Mocker()
self.rpc = self.mocker.mock()
self.listener = HeartbeatListener(1,
10, ['foo'], [],
self.rpc,
stdin=self.stdin,
stdout=self.stdout,
stderr=self.stderr)
self.next_fail = {}
self.handler = MementoHandler()
self.listener.logger.addHandler(self.handler)
self.listener.logger.setLevel(logging.DEBUG)
self.handler.setLevel(logging.DEBUG)
self.listener.logger.propagate = False
self.processes = [
dict(name="heartbeat", group="heartbeat", pid="101", state=RUNNING)
]
self.handler.debug = True
