/** * Base class for getting BasicMetricsRW implementations for writing/reading basic metrics * (SimpleNumber). This class mostly creates: * * <ul> * <li>the sample data which is read and written using the MetricsRW implementations * <li>helper methods for creating {@link * com.rackspacecloud.blueflood.service.SingleRollupWriteContext} * </ul> */ public class BasicMetricsRWIntegrationTest extends IntegrationTestBase { protected static final double EPSILON = .5; private static final String TENANT1 = "123456"; private static final String TENANT2 = "987654"; private static final String TENANT3 = "123789"; protected LocatorIO locatorIO = new DLocatorIO(); protected DelayedLocatorIO delayedLocatorIO = new DDelayedLocatorIO(); protected MetricsRW datastaxMetricsRW = new DBasicMetricsRW(locatorIO, delayedLocatorIO, false, new DefaultClockImpl()); protected MetricsRW astyanaxMetricsRW = new ABasicMetricsRW(false, new DefaultClockImpl()); protected Map<Locator, IMetric> numericMap = new HashMap<Locator, IMetric>(); protected Map<Locator, IMetric> stringMap = new HashMap<Locator, IMetric>(); protected Map<Locator, IMetric> boolMap = new HashMap<Locator, IMetric>(); protected static final long MAX_AGE_ALLOWED = Configuration.getInstance().getLongProperty(CoreConfig.ROLLUP_DELAY_MILLIS); protected static Granularity DELAYED_METRICS_STORAGE_GRANULARITY = Granularity.getRollupGranularity( Configuration.getInstance() .getStringProperty(CoreConfig.DELAYED_METRICS_STORAGE_GRANULARITY)); /** * Generate numeric metrics to be used by the tests. * * @throws CacheException */ @Before public void generateMetrics() throws CacheException { String className = getClass().getSimpleName(); for (String tid : Arrays.asList(TENANT1, TENANT2, TENANT3)) { // Numeric Locator locator = Locator.createLocatorFromPathComponents( tid, className + ".numeric.metric." + System.currentTimeMillis()); Metric metric = new Metric( locator, new Long(System.currentTimeMillis() % 100), System.currentTimeMillis(), new TimeValue(1, TimeUnit.DAYS), "unit"); numericMap.put(locator, metric); } } /** * This method is to supply the granularity parameter to some test methods below * * @return */ protected Object getGranularitiesToTest() { return Arrays.copyOfRange( Granularity.granularities(), 1, Granularity.granularities().length - 1); } /** * Converts the input metrics from a map of locator -> IMetric to a list of {@link * com.rackspacecloud.blueflood.service.SingleRollupWriteContext} objects * * @param inputMetrics * @return */ protected List<SingleRollupWriteContext> toWriteContext( Collection<IMetric> inputMetrics, Granularity destGran) throws IOException { List<SingleRollupWriteContext> resultList = new ArrayList<SingleRollupWriteContext>(); for (IMetric metric : inputMetrics) { SingleRollupWriteContext writeContext = createSingleRollupWriteContext(destGran, metric); resultList.add(writeContext); } return resultList; } /** * Convert a list of {@link com.rackspacecloud.blueflood.types.Points} into a list of {@link * com.rackspacecloud.blueflood.service.SingleRollupWriteContext} for the given Granularity and * Locator. * * @param locator * @param points * @param gran * @return */ protected List<SingleRollupWriteContext> toWriteContext( Locator locator, Points<Rollup> points, Granularity gran) { List<SingleRollupWriteContext> resultList = new ArrayList<SingleRollupWriteContext>(); for (Map.Entry<Long, Points.Point<Rollup>> entry : points.getPoints().entrySet()) { resultList.add( new SingleRollupWriteContext( entry.getValue().getData(), locator, gran, CassandraModel.getBasicColumnFamily(gran), entry.getKey())); } return resultList; } /** * Create a single {@link com.rackspacecloud.blueflood.service.SingleRollupWriteContext} from the * given {@link com.rackspacecloud.blueflood.types.IMetric} and Granularity. * * @param destGran * @param metric * @return * @throws IOException */ protected SingleRollupWriteContext createSingleRollupWriteContext( Granularity destGran, IMetric metric) throws IOException { Locator locator = metric.getLocator(); Points<SimpleNumber> points = new Points<SimpleNumber>(); points.add( new Points.Point<SimpleNumber>( metric.getCollectionTime(), new SimpleNumber(metric.getMetricValue()))); BasicRollup rollup = BasicRollup.buildRollupFromRawSamples(points); return new SingleRollupWriteContext( rollup, locator, destGran, CassandraModel.getBasicColumnFamily(destGran), metric.getCollectionTime()); } /** * For a given list of locators, figure the shard they belong to and for all those shards get all * the locators in metric_locator column family * * @param ingestedLocators * @return * @throws IOException */ protected Set<Locator> retrieveLocators(Set<Locator> ingestedLocators) throws IOException { Set<Long> shards = new HashSet<Long>(); for (Locator locator : ingestedLocators) { long shard = (long) Util.getShard(locator.toString()); shards.add(shard); } Set<Locator> locatorsFromDB = new HashSet<Locator>(); for (Long shard : shards) { locatorsFromDB.addAll(locatorIO.getLocators(shard)); } return locatorsFromDB; } /** * For a given list of metrics, figure out the shard and slot they belong to and for those shard * and slot combinations, get all the locators from metrics_delayed_locator column family. * * @param metrics * @return * @throws IOException */ protected Set<Locator> retrieveLocatorsByShardAndSlot(List<IMetric> metrics) throws IOException { Set<String> slotKeys = new HashSet<String>(); for (IMetric metric : metrics) { int shard = Util.getShard(metric.getLocator().toString()); int slot = DELAYED_METRICS_STORAGE_GRANULARITY.slot(metric.getCollectionTime()); SlotKey slotKey = SlotKey.of(DELAYED_METRICS_STORAGE_GRANULARITY, slot, shard); slotKeys.add(slotKey.toString()); } Set<Locator> locatorsFromDB = new HashSet<Locator>(); for (String slotKeyStr : slotKeys) { locatorsFromDB.addAll(delayedLocatorIO.getLocators(SlotKey.parse(slotKeyStr))); } return locatorsFromDB; } }