def setUp(self):
"""Set up a Downsampler, aggregating with the sum and average function."""
capacity_precisions = (self.CAPACITY, self.PRECISION, self.CAPACITY,
self.PRECISION**2)
retention_string = "%d*%ds:%d*%ds" % (capacity_precisions)
retention = bg_accessor.Retention.from_string(retention_string)
self.stage_0 = retention.stages[0]
self.stage_1 = retention.stages[1]
uid = uuid.uuid4()
metric_metadata = bg_accessor.MetricMetadata(
aggregator=bg_accessor.Aggregator.total, retention=retention)
self.metric_sum = bg_accessor.Metric(self.METRIC_NAME_SUM, uid,
metric_metadata)
uid = uuid.uuid4()
metric_metadata = bg_accessor.MetricMetadata(
aggregator=bg_accessor.Aggregator.average, retention=retention)
self.metric_avg = bg_accessor.Metric(self.METRIC_NAME_AVG, uid,
metric_metadata)
self.ds = bg_ds.Downsampler(self.CAPACITY)
def make_metric(self, name, metadata):
"""See bg_accessor.Accessor."""
# Cleanup name (avoid double dots)
name = ".".join(self._components_from_name(name))
uid = uuid.uuid5(self._UUID_NAMESPACE, name)
now = datetime.datetime.now()
return bg_accessor.Metric(
name,
uid,
metadata,
created_on=now,
updated_on=now,
read_on=None,
)
def _cache_get(self, metric_name):
"""Return a Metric from a the cache, None if no such metric."""
encoded_metric_name = self._encode(metric_name)
with self.__env.begin(self.__metric_to_metadata_db,
write=False) as txn:
payload = txn.get(encoded_metric_name)
if payload == self._EMPTY:
return None, True
if payload is not None:
payload = self._decode(payload)
if not payload:
# cache miss
return None, False
# found something in the cache
split = self.__split_payload(payload)
if split is None:
# invalid string => evict from cache
with self.__env.begin(self.__metric_to_metadata_db,
write=True) as txn:
txn.delete(key=encoded_metric_name)
return None, False
# valid value => get id and metadata string
# TODO: optimization: id is a UUID (known length)
id_str, metadata_str, timestamp = split
try:
id = uuid.UUID(id_str)
except Exception as e:
logging.debug(str(e))
with self.__env.begin(self.__metric_to_metadata_db,
write=True) as txn:
txn.delete(key=encoded_metric_name)
return None, False
# if the timestamp expired evict it in order to force
# its recreation for the next time
if self.__expired_timestamp(timestamp):
with self.__env.begin(self.__metric_to_metadata_db,
write=True) as txn:
txn.delete(key=encoded_metric_name)
metadata = self.metadata_from_str(metadata_str)
return bg_accessor.Metric(metric_name, id, metadata), True
def make_metric(name, metadata=None, accessor=None, **kwargs):
"""Create a bg_accessor.Metric with specified metadata."""
encoded_name = bg_accessor.encode_metric_name(name)
retention = kwargs.get("retention")
if isinstance(retention, basestring):
kwargs["retention"] = bg_accessor.Retention.from_string(retention)
if metadata:
assert isinstance(metadata, bg_accessor.MetricMetadata)
assert not kwargs
else:
metadata = bg_accessor.MetricMetadata(**kwargs)
if not accessor:
uid = uuid.uuid5(_UUID_NAMESPACE, encoded_name)
return bg_accessor.Metric(name, uid, metadata)
else:
return accessor.make_metric(name, metadata)
def make_metric(self, name, metadata):
"""See bg_accessor.Accessor."""
# Cleanup name (avoid double dots)
name = ".".join(self._components_from_name(name))
uid = uuid.uuid5(self._UUID_NAMESPACE, name)
return bg_accessor.Metric(name, uid, metadata)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
from mock import Mock
from biggraphite import accessor as bg_accessor
from biggraphite.drivers import hybrid
DEFAULT_METRIC_NAME = "foo.bar"
DEFAULT_METADATA = bg_accessor.MetricMetadata()
DEFAULT_METRIC = bg_accessor.Metric(DEFAULT_METRIC_NAME, "id",
DEFAULT_METADATA)
DEFAULT_GLOB = "foo.bar.**"
class TestHybridAccessor(unittest.TestCase):
def setUp(self):
self._metadata_accessor = Mock()
self._data_accessor = Mock()
self._accessor = hybrid.HybridAccessor("test_hybrid",
self._metadata_accessor,
self._data_accessor)
def test_connect_should_be_called_on_both_accessors(self):
self._accessor.connect()