def setUp(self):
"""Setup the test."""
yield super(TestStats, self).setUp()
self.obj_factory.make_user(999, u'test user999', u'', 2**20)
self.metrics = FakeMetrics()
MetricsConnector.register_metrics("root", instance=self.metrics)
self.service.stats_worker.stop()
def setUp(self):
"""Setup the test."""
yield super(TestStats, self).setUp()
self.obj_factory.make_user(999, u'test user999', u'', 2 ** 20)
self.metrics = FakeMetrics()
MetricsConnector.register_metrics("root", instance=self.metrics)
self.service.stats_worker.stop()
def test_register_mock_metrics(self):
"""Test that we can register a mock for testing."""
mocker = Mocker()
mock_metrics = mocker.mock(ExtendedMetrics)
mock_metrics.meter("abc", 123)
MetricsConnector.register_metrics("x", instance=mock_metrics)
with mocker:
MetricsConnector.get_metrics("x").meter("abc", 123)
def test_register_mock_metrics(self):
"""Test that we can register a mock for testing."""
mocker = Mocker()
mock_metrics = mocker.mock(ExtendedMetrics)
mock_metrics.meter("abc", 123)
MetricsConnector.register_metrics("x", instance=mock_metrics)
with mocker:
MetricsConnector.get_metrics("x").meter("abc", 123)
def setUp(self):
yield super(SSLProxyServiceTest, self).setUp()
self.configure_logging()
self.metrics = MetricReceiver()
namespace = settings.ssl_proxy.METRICS_NAMESPACE
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self.patch(settings.ssl_proxy, 'HEARTBEAT_INTERVAL',
self.ssl_proxy_heartbeat_interval)
def setUp(self):
yield super(SSLProxyServiceTest, self).setUp()
self.configure_logging()
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
def setUp(self):
yield super(SSLProxyServiceTest, self).setUp()
self.configure_logging()
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
def startFactory(self):
"""Start any other stuff we need."""
logger.info("listening on %d -> %s:%d",
self.listen_port, self.host, self.port)
try:
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
except ComponentLookupError:
namespace = config.ssl_proxy.metrics_namespace
MetricsConnector.register_metrics("ssl-proxy", namespace)
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
self.metrics.meter("server_start", 1)
def startFactory(self):
"""Start any other stuff we need."""
logger.info("listening on %d -> %s:%d", self.listen_port, self.host,
self.port)
try:
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
except ComponentLookupError:
namespace = config.ssl_proxy.metrics_namespace
MetricsConnector.register_metrics("ssl-proxy", namespace)
self.metrics = MetricsConnector.get_metrics("ssl-proxy")
self.metrics.meter("server_start", 1)
def setUp(self):
"""Set up."""
class Helper(object):
"""Fake object with a controllable call."""
def __init__(self):
self.call_count = 1
self.calls = []
self.ri = None
def call(self, func):
"""Call function when counter is 0, then stop running."""
self.call_count -= 1
self.calls.append(func)
if self.call_count == 0:
for f in self.calls:
f()
if self.call_count <= 0:
self.ri.stop()
class FakeMetrics(object):
"""Fake Metrics object that records calls."""
def __init__(self):
"""Initialize calls."""
self.calls = []
def meter(self, name, count):
"""Record call to meter()."""
self.calls.append(("meter", name, count))
def gauge(self, name, val):
"""Record call to gauge()."""
self.calls.append(("gauge", name, val))
logger = logging.getLogger("storage.server")
logger.propagate = False
logger.setLevel(TRACE)
self.handler = MementoHandler()
self.handler.setLevel(TRACE)
logger.addHandler(self.handler)
self.addCleanup(logger.removeHandler, self.handler)
self.helper = Helper()
self.fake_metrics = FakeMetrics()
MetricsConnector.register_metrics("reactor_inspector",
instance=self.fake_metrics)
self.addCleanup(MetricsConnector.unregister_metrics)
self.ri = ReactorInspector(logger, self.helper.call, loop_time=.1)
self.helper.ri = self.ri
def setUp(self):
yield super(SSLProxyTestCase, self).setUp()
self.configure_logging()
self.ssl_service = ssl_proxy.ProxyService(self.ssl_cert,
self.ssl_key,
self.ssl_cert_chain,
0, # port
"localhost", self.port,
"ssl-proxy-test", 0)
# keep metrics in our MetricReceiver
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
yield self.ssl_service.startService()
def test_register_and_lookup(self):
"""Test that we can look up different instances and record metrics."""
MetricsConnector.register_metrics("one")
MetricsConnector.register_metrics("two")
self.assertEqual("fake_one", MetricsConnector.get_metrics("one"))
self.assertEqual("fake_two", MetricsConnector.get_metrics("two"))
self.assertIdentical(MetricsConnector.get_metrics("one"),
MetricsConnector.get_metrics("one"))
self.assertRaises(ComponentLookupError,
MetricsConnector.get_metrics, "three")
MetricsConnector.unregister_metrics()
self.assertRaises(ComponentLookupError,
MetricsConnector.get_metrics, "one")
self.assertRaises(ComponentLookupError,
MetricsConnector.get_metrics, "two")
def setUp(self):
yield super(SSLProxyTestCase, self).setUp()
self.configure_logging()
self.ssl_service = ssl_proxy.ProxyService(self.ssl_cert,
self.ssl_key,
self.ssl_cert_chain,
0, # port
"localhost", self.port,
"ssl-proxy-test", 0)
# keep metrics in our MetricReceiver
self.metrics = MetricReceiver()
namespace = settings.ssl_proxy.METRICS_NAMESPACE
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self.patch(settings.ssl_proxy, 'HEARTBEAT_INTERVAL',
self.ssl_proxy_heartbeat_interval)
yield self.ssl_service.startService()
def test_register_and_lookup(self):
"""Test that we can look up different instances and record metrics."""
MetricsConnector.register_metrics("one")
MetricsConnector.register_metrics("two")
self.assertEqual("fake_one", MetricsConnector.get_metrics("one"))
self.assertEqual("fake_two", MetricsConnector.get_metrics("two"))
self.assertIdentical(MetricsConnector.get_metrics("one"),
MetricsConnector.get_metrics("one"))
self.assertRaises(ComponentLookupError, MetricsConnector.get_metrics,
"three")
MetricsConnector.unregister_metrics()
self.assertRaises(ComponentLookupError, MetricsConnector.get_metrics,
"one")
self.assertRaises(ComponentLookupError, MetricsConnector.get_metrics,
"two")
def setUp(self):
yield super(SSLProxyTestCase, self).setUp()
self.configure_logging()
self.ssl_service = ssl_proxy.ProxyService(
self.ssl_cert,
self.ssl_key,
self.ssl_cert_chain,
0, # port
"localhost",
self.port,
"ssl-proxy-test",
0)
# keep metrics in our MetricReceiver
self.metrics = MetricReceiver()
namespace = config.ssl_proxy.metrics_namespace
instance = MetricsConnector.new_txmetrics(connection=self.metrics,
namespace=namespace)
MetricsConnector.register_metrics("ssl-proxy", namespace, instance)
self._old_heartbeat_interval = config.ssl_proxy.heartbeat_interval
config.ssl_proxy.heartbeat_interval = self.ssl_proxy_heartbeat_interval
yield self.ssl_service.startService()
def setUp(self):
"""Set up test."""
yield super(TestDelivery, self).setUp()
self.mocker = Mocker()
self.fake_reactor = DummyReactor()
self.content = self.mocker.mock()
self.node_owner_id = 1
self.node_uuid = uuid.uuid4()
self.node_hash = "hash:blah"
self.owner_id = 0
self.free_bytes = 0
self.node_shard_id = 'shard1'
self.node_volume_id = uuid.uuid4()
self.content_node = self.mocker.mock()
content_class = lambda _: self.content
MetricsConnector.register_metrics("sli", instance=ExtendedMetrics())
MetricsConnector.register_metrics("root", instance=ExtendedMetrics())
MetricsConnector.register_metrics("user", instance=ExtendedMetrics())
self.factory = StorageServerFactory(s3_host=None,
s3_port=None,
s3_key=None,
s3_ssl=False,
s3_secret=None,
content_class=content_class,
reactor=self.fake_reactor)
def setUp(self):
"""Set up test."""
yield super(TestDelivery, self).setUp()
self.mocker = Mocker()
self.fake_reactor = DummyReactor()
self.content = self.mocker.mock()
self.node_owner_id = 1
self.node_uuid = uuid.uuid4()
self.node_hash = "hash:blah"
self.owner_id = 0
self.free_bytes = 0
self.node_volume_id = uuid.uuid4()
self.content_node = self.mocker.mock()
content_class = lambda _: self.content
MetricsConnector.register_metrics("sli", instance=ExtendedMetrics())
MetricsConnector.register_metrics("root", instance=ExtendedMetrics())
MetricsConnector.register_metrics("user", instance=ExtendedMetrics())
self.factory = StorageServerFactory(
s3_host=None, s3_port=None, s3_key=None, s3_ssl=False,
s3_secret=None, content_class=content_class,
reactor=self.fake_reactor)
def tearDown(self):
"""Tear down the test."""
# restore the original instance
MetricsConnector.register_metrics(
"root", instance=self.service.factory.metrics)
return super(TestStats, self).tearDown()
def tearDown(self):
"""Tear down the test."""
# restore the original instance
MetricsConnector.register_metrics(
"root", instance=self.service.factory.metrics)
return super(TestStats, self).tearDown()
def test_register_with_different_namespace(self):
"""Register an instance with an aribrary lookup key."""
MetricsConnector.register_metrics("abc", "root.a.b.c")
self.assertEqual("fake_root.a.b.c",
MetricsConnector.get_metrics("abc"))
def test_register_fake_metrics(self):
"""Test that we can switch out a different metrics instance."""
MetricsConnector.register_metrics("abc", instance="totally_fake")
self.assertEqual("totally_fake", MetricsConnector.get_metrics("abc"))
def test_register_fake_metrics(self):
"""Test that we can switch out a different metrics instance."""
MetricsConnector.register_metrics("abc", instance="totally_fake")
self.assertEqual("totally_fake", MetricsConnector.get_metrics("abc"))
def test_register_with_different_namespace(self):
"""Register an instance with an aribrary lookup key."""
MetricsConnector.register_metrics("abc", "root.a.b.c")
self.assertEqual("fake_root.a.b.c",
MetricsConnector.get_metrics("abc"))
