src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
BluefloodTimerRollup implements Rollup, IBaseRollup { public static Number avg(Collection<Number> numbers) { Number sum = BluefloodTimerRollup.sum(numbers); if (sum instanceof Long || sum instanceof Integer) return (Long)sum / numbers.size(); else return (Double)sum / (double)numbers.size(); } BluefloodTimerRollup(); BluefloodTimerRollup withSum(double sum); BluefloodTimerRollup withCount(long count); BluefloodTimerRollup withCountPS(double count_ps); BluefloodTimerRollup withSampleCount(int sampleCount); BluefloodTimerRollup withMinValue(MinValue min); BluefloodTimerRollup withMinValue(Number num); BluefloodTimerRollup withMaxValue(MaxValue max); BluefloodTimerRollup withMaxValue(Number num); BluefloodTimerRollup withAverage(Average average); BluefloodTimerRollup withAverage(Number average); BluefloodTimerRollup withVariance(Variance variance); BluefloodTimerRollup withVariance(Number variance); Average getAverage(); MaxValue getMaxValue(); MinValue getMinValue(); Variance getVariance(); void setPercentile(String label, Number mean); @Override Boolean hasData(); double getRate(); double getSum(); long getCount(); int getSampleCount(); String toString(); @Override RollupType getRollupType(); boolean equals(Object obj); static Number sum(Collection<Number> numbers); static Number avg(Collection<Number> numbers); static Number max(Collection<Number> numbers); static double calculatePerSecond(long countA, double countPerSecA, long countB, double countPerSecB); Map<String, Percentile> getPercentiles(); static BluefloodTimerRollup buildRollupFromTimerRollups(Points<BluefloodTimerRollup> input); } | @Test public void testAverage() { Assert.assertEquals(2L, BluefloodTimerRollup.avg(longs)); Assert.assertEquals(2.0d, BluefloodTimerRollup.avg(doubles)); Assert.assertEquals(2.0d, BluefloodTimerRollup.avg(mixed)); Assert.assertEquals(2.0d, BluefloodTimerRollup.avg(alsoMixed)); } |
BluefloodTimerRollup implements Rollup, IBaseRollup { public static Number max(Collection<Number> numbers) { long longMax = numbers.iterator().next().longValue(); double doubleMax = numbers.iterator().next().doubleValue(); boolean useDouble = false; for (Number number : numbers) { if (useDouble || number instanceof Double || number instanceof Float) { if (!useDouble) { useDouble = true; doubleMax = Math.max(doubleMax, (double)longMax); } doubleMax = Math.max(doubleMax, number.doubleValue()); } else { longMax = Math.max(longMax, number.longValue()); } } if (useDouble) return doubleMax; else return longMax; } BluefloodTimerRollup(); BluefloodTimerRollup withSum(double sum); BluefloodTimerRollup withCount(long count); BluefloodTimerRollup withCountPS(double count_ps); BluefloodTimerRollup withSampleCount(int sampleCount); BluefloodTimerRollup withMinValue(MinValue min); BluefloodTimerRollup withMinValue(Number num); BluefloodTimerRollup withMaxValue(MaxValue max); BluefloodTimerRollup withMaxValue(Number num); BluefloodTimerRollup withAverage(Average average); BluefloodTimerRollup withAverage(Number average); BluefloodTimerRollup withVariance(Variance variance); BluefloodTimerRollup withVariance(Number variance); Average getAverage(); MaxValue getMaxValue(); MinValue getMinValue(); Variance getVariance(); void setPercentile(String label, Number mean); @Override Boolean hasData(); double getRate(); double getSum(); long getCount(); int getSampleCount(); String toString(); @Override RollupType getRollupType(); boolean equals(Object obj); static Number sum(Collection<Number> numbers); static Number avg(Collection<Number> numbers); static Number max(Collection<Number> numbers); static double calculatePerSecond(long countA, double countPerSecA, long countB, double countPerSecB); Map<String, Percentile> getPercentiles(); static BluefloodTimerRollup buildRollupFromTimerRollups(Points<BluefloodTimerRollup> input); } | @Test public void testMax() { Assert.assertEquals(3L, BluefloodTimerRollup.max(longs)); Assert.assertEquals(3.0d, BluefloodTimerRollup.max(doubles)); Assert.assertEquals(3.0d, BluefloodTimerRollup.max(mixed)); Assert.assertEquals(3.0d, BluefloodTimerRollup.max(alsoMixed)); } |
Average extends AbstractRollupStat { public void add(Long input) { count++; final long longAvgUntilNow = toLong(); setLongValue(toLong() + ((input + longRemainder - longAvgUntilNow) / count)); longRemainder = (input + longRemainder - longAvgUntilNow) % count; } Average(); @SuppressWarnings("unused") // used by Jackson Average(long value); @SuppressWarnings("unused") // used by Jackson Average(double value); Average(int count, Object value); void add(Long input); void addBatch(Long input, long dataPoints); void add(Double input); void addBatch(Double input, long dataPoints); @Override byte getStatType(); } | @Test public void testLongAverage() { Average avg = new Average(); avg.add(2L); avg.add(4L); avg.add(4L); Assert.assertEquals(3L, avg.toLong()); }
@Test public void testDoubleAverage() { Average avg = new Average(); avg.add(2.0D); avg.add(4.0D); avg.add(4.0D); Assert.assertEquals(3.3333333333333335D, avg.toDouble(), 0); Assert.assertEquals(3.3333333333333335D, avg.toDouble(), 0); } |
RollupService implements Runnable, RollupServiceMBean { public Collection<Integer> getManagedShards() { return new TreeSet<Integer>(shardStateManager.getManagedShards()); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | @Test public void getManagedShardsGetsCollectionFromManager() { HashSet<Integer> managedShards = new HashSet<Integer>(); managedShards.add(0); managedShards.add(1); managedShards.add(2); doReturn(managedShards).when(shardStateManager).getManagedShards(); Collection<Integer> actual = service.getManagedShards(); assertEquals(managedShards.size(), actual.size()); assertTrue(actual.containsAll(managedShards)); verify(shardStateManager).getManagedShards(); verifyNoMoreInteractions(shardStateManager); } |
BluefloodCounterRollup implements Rollup { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof BluefloodCounterRollup)) return false; BluefloodCounterRollup other = (BluefloodCounterRollup)obj; return this.getCount().equals(other.getCount()) && this.rate == other.rate && this.getSampleCount() == other.getSampleCount(); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | @Test public void equalsOtherNullReturnsFalse() { BluefloodCounterRollup rollup = new BluefloodCounterRollup(); assertFalse(rollup.equals(null)); }
@Test public void equalsOtherNotRollupReturnsFalse() { BluefloodCounterRollup rollup = new BluefloodCounterRollup(); assertFalse(rollup.equals("")); } |
BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input) throws IOException { long minTime = Long.MAX_VALUE; long maxTime = Long.MIN_VALUE; BluefloodCounterRollup rollup = new BluefloodCounterRollup(); Number count = 0L; for (Points.Point<SimpleNumber> point : input.getPoints().values()) { count = sum(count, point.getData().getValue()); minTime = Math.min(minTime, point.getTimestamp()); maxTime = Math.max(maxTime, point.getTimestamp()); } double numSeconds = (double)(maxTime - minTime); double rate = count.doubleValue() / numSeconds; return rollup.withCount(count).withRate(rate).withSampleCount(input.getPoints().size()); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | @Test(expected = NullPointerException.class) public void rawSampleBuilderWithNullInputsThrowsException() throws IOException { BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromRawSamples(null); } |
BluefloodCounterRollup implements Rollup { public static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input) throws IOException { Number count = 0L; double seconds = 0; int sampleCount = 0; for (Points.Point<BluefloodCounterRollup> point : input.getPoints().values()) { count = sum(count, point.getData().getCount()); sampleCount = sampleCount + point.getData().getSampleCount(); seconds += Util.safeDiv(point.getData().getCount().doubleValue(), point.getData().getRate()); } double aggregateRate = Util.safeDiv(count.doubleValue(), seconds); return new BluefloodCounterRollup().withCount(count).withRate(aggregateRate).withSampleCount(sampleCount); } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | @Test(expected = NullPointerException.class) public void counterRollupBuilderWithNullRollupInputThrowsException() throws IOException { Points<BluefloodCounterRollup> combined = new Points<BluefloodCounterRollup>(); combined.add(new Points.Point<BluefloodCounterRollup>(1234L, null)); BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromCounterRollups(combined); }
@Test(expected = NullPointerException.class) public void counterRollupBuilderWithNullCombinedInputThrowsException() throws IOException { BluefloodCounterRollup rollup = BluefloodCounterRollup.buildRollupFromCounterRollups(null); } |
BluefloodCounterRollup implements Rollup { @Override public RollupType getRollupType() { return RollupType.COUNTER; } BluefloodCounterRollup(); BluefloodCounterRollup withCount(Number count); BluefloodCounterRollup withRate(double rate); BluefloodCounterRollup withSampleCount(int sampleCount); Number getCount(); double getRate(); int getSampleCount(); @Override String toString(); @Override boolean equals(Object obj); static BluefloodCounterRollup buildRollupFromRawSamples(Points<SimpleNumber> input); static BluefloodCounterRollup buildRollupFromCounterRollups(Points<BluefloodCounterRollup> input); @Override Boolean hasData(); @Override RollupType getRollupType(); } | @Test public void getRollupTypeReturnsCounter() { BluefloodCounterRollup rollup = new BluefloodCounterRollup(); assertEquals(RollupType.COUNTER, rollup.getRollupType()); } |
Event { public Map<String, Object> toMap() { return new HashMap<String, Object>() { { put(FieldLabels.when.name(), getWhen()); put(FieldLabels.what.name(), getWhat()); put(FieldLabels.data.name(), getData()); put(FieldLabels.tags.name(), getTags()); } }; } Event(); @VisibleForTesting Event(long when, String what); Map<String, Object> toMap(); long getWhen(); void setWhen(long when); String getWhat(); void setWhat(String what); String getData(); void setData(String data); String getTags(); void setTags(String tags); static final String untilParameterName; static final String fromParameterName; static final String tagsParameterName; } | @Test public void testConvertToMap() { Map<String, Object> properties = event.toMap(); Assert.assertEquals(properties.get(Event.FieldLabels.when.name()), 1L); Assert.assertEquals(properties.get(Event.FieldLabels.data.name()), "2"); Assert.assertEquals(properties.get(Event.FieldLabels.tags.name()), "3"); Assert.assertEquals(properties.get(Event.FieldLabels.what.name()), "4"); } |
ElasticTokensIO implements TokenDiscoveryIO { protected String[] getIndexesToSearch() { return new String[] {ELASTICSEARCH_TOKEN_INDEX_NAME_READ}; } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } | @Test public void testGetIndexesToSearch() throws IOException { String[] indices = elasticTokensIO.getIndexesToSearch(); assertEquals(1, indices.length); assertEquals("metric_tokens", indices[0]); } |
ElasticTokensIO implements TokenDiscoveryIO { protected String getRegexToHandleTokens(GlobPattern globPattern) { String[] queryRegexParts = globPattern.compiled().toString().split("\\\\."); return Arrays.stream(queryRegexParts) .map(this::convertRegexToCaptureUptoNextToken) .collect(joining(Locator.METRIC_TOKEN_SEPARATOR_REGEX)); } ElasticTokensIO(); @Override void insertDiscovery(Token token); @Override void insertDiscovery(List<Token> tokens); @Override List<MetricName> getMetricNames(String tenantId, String query); static final String ES_DOCUMENT_TYPE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_WRITE; static String ELASTICSEARCH_TOKEN_INDEX_NAME_READ; public ElasticsearchRestHelper elasticsearchRestHelper; } | @Test public void testRegexLevel0() { List<String> terms = Arrays.asList("", "foo", "bar", "b", "foo.bar", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(3, matchingTerms.size()); assertEquals("foo", matchingTerms.get(0)); assertEquals("bar", matchingTerms.get(1)); assertEquals("b", matchingTerms.get(2)); }
@Test public void testRegexLevel0WildCard() { List<String> terms = Arrays.asList("", "foo", "bar", "baz", "b", "foo.bar", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("b*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(3, matchingTerms.size()); assertEquals("bar", matchingTerms.get(0)); assertEquals("baz", matchingTerms.get(1)); assertEquals("b", matchingTerms.get(2)); }
@Test public void testRegexLevel1() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.b", "foo.xxx", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(3, matchingTerms.size()); assertEquals("foo.bar", matchingTerms.get(0)); assertEquals("foo.b", matchingTerms.get(1)); assertEquals("foo.xxx", matchingTerms.get(2)); }
@Test public void testRegexLevel1WildCard() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.b", "foo.xxx", "foo.bar.baz", "foo.bar.baz.aux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.b*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(2, matchingTerms.size()); assertEquals("foo.bar", matchingTerms.get(0)); assertEquals("foo.b", matchingTerms.get(1)); }
@Test public void testRegexLevel2() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.bar.baz", "foo.bar.baz.qux", "foo.bar.baz.qux.quux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.bar.*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(1, matchingTerms.size()); assertEquals("foo.bar.baz", matchingTerms.get(0)); }
@Test public void testRegexLevel3() { List<String> terms = Arrays.asList("foo", "bar", "baz", "foo.bar", "foo.bar.baz", "foo.bar.baz.qux", "foo.bar.baz.qux.quux"); List<String> matchingTerms = new ArrayList<>(); Pattern patternToGet2Levels = Pattern.compile(elasticTokensIO.getRegexToHandleTokens(new GlobPattern("foo.bar.baz.*"))); for (String term: terms) { Matcher matcher = patternToGet2Levels.matcher(term); if (matcher.matches()) { matchingTerms.add(term); } } assertEquals(1, matchingTerms.size()); assertEquals("foo.bar.baz.qux", matchingTerms.get(0)); } |
RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<Integer> getRecentlyScheduledShards() { return context.getRecentlyScheduledShards(); } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | @Test public void getRecentlyScheduledShardsGetsFromContext() { Collection<Integer> recent = service.getRecentlyScheduledShards(); assertNotNull(recent); verify(context).getRecentlyScheduledShards(); verifyNoMoreInteractions(context); verifyZeroInteractions(shardStateManager); } |
EventElasticSearchIO implements EventsIO { @Override public List<Map<String, Object>> search(String tenant, Map<String, List<String>> query) { ArrayList<Map<String, Object>> searchResults = new ArrayList<>(); Timer.Context eventSearchTimerContext = eventSearchTimer.time(); try { String result = elasticsearchRestHelper.fetchEvents(tenant, query); searchResults.addAll(getEventResults(result)); } catch(IOException e){ String format = "Query for given event in elasticsearch failed. Exception message: %s"; log.error(String.format(format, e.getMessage())); throw new RuntimeException(String.format(format, e.getMessage()), e); } finally{ eventSearchTimerContext.stop(); } return searchResults; } EventElasticSearchIO(); @Override void insert(String tenantId, Map<String, Object> event); @Override List<Map<String, Object>> search(String tenant, Map<String, List<String>> query); static final String EVENT_INDEX; static final String ES_TYPE; public ElasticsearchRestHelper elasticsearchRestHelper; } | @Test public void testNonCrossTenantSearch() throws Exception { Map<String, List<String>> query = new HashMap<>(); query.put(Event.tagsParameterName, Arrays.asList("event")); List<Map<String, Object>> results = searchIO.search(TENANT_1, query); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); results = searchIO.search(TENANT_2, query); Assert.assertEquals(TENANT_2_EVENTS_NUM, results.size()); results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(TENANT_RANGE_EVENTS_NUM, results.size()); results = searchIO.search(TENANT_WITH_SYMBOLS, query); Assert.assertEquals(TENANT_WITH_SYMBOLS_NUM, results.size()); }
@Test public void testEmptyQueryParameters() throws Exception { Map<String, List<String>> query = new HashMap<>(); query.put(Event.tagsParameterName, new ArrayList<>()); query.put(Event.fromParameterName, new ArrayList<>()); query.put(Event.untilParameterName, new ArrayList<>()); List<Map<String, Object>> results = searchIO.search(TENANT_1, query); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); }
@Test public void testEventTagsOnlySearch() throws Exception { Map<String, List<String>> query = new HashMap<>(); query.put(Event.tagsParameterName, Arrays.asList("sample")); List<Map<String, Object>> results = searchIO.search(TENANT_1, query); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); query.put(Event.tagsParameterName, Arrays.asList("1")); results = searchIO.search(TENANT_1, query); Assert.assertEquals(1, results.size()); query.put(Event.tagsParameterName, Arrays.asList("database")); results = searchIO.search(TENANT_1, query); Assert.assertEquals(0, results.size()); }
@Test public void testEmptyQuery() throws Exception { List<Map<String, Object>> results = searchIO.search(TENANT_1, null); Assert.assertEquals(TENANT_1_EVENTS_NUM, results.size()); }
@Test public void testRangeOnlySearch() throws Exception { Map<String, List<String>> query = new HashMap<>(); final int eventCountToCapture = TENANT_RANGE_EVENTS_NUM / 2; final int secondsDelta = 10; DateTime fromDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS * eventCountToCapture - secondsDelta); query.put(Event.fromParameterName, Arrays.asList(Long.toString(fromDateTime.getMillis()))); List<Map<String, Object>> results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(eventCountToCapture, results.size()); DateTime untilDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS * eventCountToCapture - secondsDelta); query.clear(); query.put(Event.untilParameterName, Arrays.asList(Long.toString(untilDateTime.getMillis()))); results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(eventCountToCapture, results.size()); query.clear(); fromDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS * 2 - secondsDelta); untilDateTime = new DateTime().minusSeconds(RANGE_STEP_IN_SECONDS - secondsDelta); query.put(Event.fromParameterName, Arrays.asList(Long.toString(fromDateTime.getMillis()))); query.put(Event.untilParameterName, Arrays.asList(Long.toString(untilDateTime.getMillis()))); results = searchIO.search(TENANT_RANGE, query); Assert.assertEquals(1, results.size()); } |
MetricIndexData { public void add(String metricIndex, long docCount) { final String[] tokens = metricIndex.split(METRIC_TOKEN_SEPARATOR_REGEX); switch (tokens.length - baseLevel) { case 1: if (baseLevel > 0) { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.lastIndexOf("."))); } else { metricNamesWithNextLevelSet.add(metricIndex.substring(0, metricIndex.indexOf("."))); } addChildrenDocCount(metricNameBaseLevelMap, metricIndex.substring(0, metricIndex.lastIndexOf(".")), docCount); break; case 0: setActualDocCount(metricNameBaseLevelMap, metricIndex, docCount); break; default: break; } } MetricIndexData(int baseLevel); void add(String metricIndex, long docCount); Set<String> getMetricNamesWithNextLevel(); Set<String> getCompleteMetricNamesAtBaseLevel(); } | @Test public void testMetricIndexesBuilderSingleMetricName() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); }
@Test public void testMetricIndexesBuilderSingleMetricNameSecondTokenQuery() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|1"); add("foo.bar.baz|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); }
@Test (expected = IllegalArgumentException.class) public void testMetricIndexesBuilderSingleMetricName1() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo"); }}; buildMetricIndexesSimilarToES(metricNames, ""); }
@Test public void testMetricIndexesBuilderLongMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux.x.y"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.bar"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|1"); add("foo.bar.baz|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); }
@Test public void testMetricIndexesBuilderLongMetricsWildcard() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux.x.y"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.bar.*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar.baz|1"); add("foo.bar.baz.qux|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); }
@Test public void testMetricIndexesBuilderMultipleMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.qux.x"); add("foo.bar.baz.qux"); add("foo.bar.baz"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo.bar.*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar.baz|3"); add("foo.bar.baz.qux|2"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); }
@Test public void testSingleLevelQueryMultipleMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.x.y.z"); add("foo.bar"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "foo"); Set<String> expectedIndexes = new HashSet<String>() {{ add("foo.bar|2"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); }
@Test public void testSingleLevelWildcardQueryMultipleMetrics() { ArrayList<String> metricNames = new ArrayList<String>() {{ add("foo.bar.baz.x.y.z"); add("moo.bar"); }}; Map<String, Long> metricIndexMap = buildMetricIndexesSimilarToES(metricNames, "*"); Set<String> expectedIndexes = new HashSet<String>() {{ add("moo.bar|1"); add("foo.bar|1"); }}; verifyMetricIndexes(metricIndexMap, expectedIndexes); } |
RollupService implements Runnable, RollupServiceMBean { public synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard) { final Set<String> results = new HashSet<String>(); for (Granularity g : Granularity.rollupGranularities()) { final Map<Integer, UpdateStamp> stateTimestamps = context.getSlotStamps(g, shard); if (stateTimestamps == null || stateTimestamps.isEmpty()) { continue; } SlotState minSlot = new SlotState().withTimestamp(System.currentTimeMillis()); boolean add = false; for (Map.Entry<Integer, UpdateStamp> entry : stateTimestamps.entrySet()) { final UpdateStamp stamp = entry.getValue(); if (stamp.getState() != UpdateStamp.State.Rolled && stamp.getTimestamp() < minSlot.getTimestamp()) { minSlot = new SlotState(g, entry.getKey(), stamp.getState()).withTimestamp(stamp.getTimestamp()); add = true; } } if (add) { results.add(minSlot.toString()); } } return results; } RollupService(ScheduleContext context); @VisibleForTesting RollupService(ScheduleContext context,
ShardStateManager shardStateManager,
ThreadPoolExecutor locatorFetchExecutors,
ThreadPoolExecutor rollupReadExecutors,
ThreadPoolExecutor rollupWriteExecutors,
long rollupDelayMillis,
long rollupDelayForMetricsWithShortDelay,
long rollupWaitForMetricsWithLongDelay,
long pollerPeriod,
long configRefreshInterval); void initializeGauges(); void forcePoll(); void run(); synchronized void setServerTime(long millis); synchronized long getServerTime(); synchronized void setKeepingServerTime(boolean b); synchronized boolean getKeepingServerTime(); synchronized void setPollerPeriod(long l); synchronized long getPollerPeriod(); synchronized int getScheduledSlotCheckCount(); synchronized int getSecondsSinceLastSlotCheck(); synchronized int getSlotCheckConcurrency(); synchronized void setSlotCheckConcurrency(int i); synchronized int getRollupConcurrency(); synchronized void setRollupConcurrency(int i); synchronized int getQueuedRollupCount(); synchronized int getInFlightRollupCount(); synchronized boolean getActive(); synchronized void setActive(boolean b); void addShard(Integer shard); void removeShard(Integer shard); Collection<Integer> getManagedShards(); synchronized Collection<Integer> getRecentlyScheduledShards(); synchronized Collection<String> getOldestUnrolledSlotPerGranularity(int shard); } | @Test public void getOldestWithNullStampsReturnsEmptyCollection() { doReturn(null).when(context).getSlotStamps(Matchers.<Granularity>any(), anyInt()); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(0, result.size()); }
@Test public void getOldestWithEmptyStampsReturnsEmptyCollection() { HashMap<Integer, UpdateStamp> empty = new HashMap<Integer, UpdateStamp>(); doReturn(empty).when(context).getSlotStamps(Matchers.<Granularity>any(), anyInt()); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(0, result.size()); }
@Test public void getOldestWithSingleStampReturnsSame() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time = 1234L; UpdateStamp stamp = new UpdateStamp(time, UpdateStamp.State.Active, false); stamps.put(0, stamp); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); SlotState slotState = new SlotState(Granularity.MIN_5, 0, stamp.getState()) .withTimestamp(time); String expected = slotState.toString(); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(1, result.size()); assertTrue(result.contains(expected)); }
@Test public void getOldestWithTimeInFutureReturnsEmpty() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time = System.currentTimeMillis() + 1234L; UpdateStamp stamp = new UpdateStamp(time, UpdateStamp.State.Active, false); stamps.put(0, stamp); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(0, result.size()); }
@Test public void getOldestWithTwoStampsTimeInFutureReturnsOlderOfTheTwo() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time1 = 1234L; UpdateStamp stamp1 = new UpdateStamp(time1, UpdateStamp.State.Active, false); stamps.put(0, stamp1); long time2 = 1233L; UpdateStamp stamp2 = new UpdateStamp(time2, UpdateStamp.State.Active, false); stamps.put(1, stamp2); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); SlotState slotState = new SlotState(Granularity.MIN_5, 1, stamp2.getState()) .withTimestamp(time2); String expected = slotState.toString(); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(1, result.size()); assertTrue(result.contains(expected)); }
@Test public void getOldestSkipsRolledStamps() { HashMap<Integer, UpdateStamp> stamps = new HashMap<Integer, UpdateStamp>(); long time1 = 1234L; UpdateStamp stamp1 = new UpdateStamp(time1, UpdateStamp.State.Active, false); stamps.put(0, stamp1); long time2 = 1233L; UpdateStamp stamp2 = new UpdateStamp(time2, UpdateStamp.State.Rolled, false); stamps.put(1, stamp2); when(context.getSlotStamps(Matchers.<Granularity>any(), anyInt())) .thenReturn(stamps) .thenReturn(null); SlotState slotState = new SlotState(Granularity.MIN_5, 0, stamp1.getState()) .withTimestamp(time1); String expected = slotState.toString(); Collection<String> result = service.getOldestUnrolledSlotPerGranularity(0); assertNotNull(result); assertEquals(1, result.size()); assertTrue(result.contains(expected)); } |
MediaTypeChecker { public boolean isContentTypeValid(HttpHeaders headers) { String contentType = headers.get(HttpHeaders.Names.CONTENT_TYPE); return (Strings.isNullOrEmpty(contentType) || contentType.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | @Test public void contentTypeEmptyShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn(""); assertTrue("empty content-type should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); }
@Test public void contentTypeJsonShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("application/json"); assertTrue("content-type application/json should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); }
@Test public void contentTypeJsonMixedCaseShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("aPpLiCaTiOn/JSON"); assertTrue("content-type aPpLiCaTiOn/JSON should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); }
@Test public void contentTypeJsonWithCharsetShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("application/json; charset=wtf-8"); assertTrue("content-type application/json should be valid", mediaTypeChecker.isContentTypeValid(mockHeaders)); }
@Test public void contentTypePdfShouldBeInvalid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.CONTENT_TYPE)).thenReturn("application/pdf"); assertFalse("content-type application/pdf should be invalid", mediaTypeChecker.isContentTypeValid(mockHeaders)); } |
MediaTypeChecker { public boolean isAcceptValid(HttpHeaders headers) { String accept = headers.get(HttpHeaders.Names.ACCEPT); return ( Strings.isNullOrEmpty(accept) || accept.contains(ACCEPT_ALL) || accept.toLowerCase().contains(MEDIA_TYPE_APPLICATION_JSON)); } boolean isContentTypeValid(HttpHeaders headers); boolean isAcceptValid(HttpHeaders headers); } | @Test public void acceptEmptyShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn(""); assertTrue("empty accept should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); }
@Test public void acceptAllShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("** should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); }
@Test public void acceptJsonShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("application/json"); assertTrue("accept application/json should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); }
@Test public void acceptAllWithCharsetQualityShouldBeValid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("text/html,application/xhtml+xml,application/xml;q=0.9,**;q=0.8 should be valid", mediaTypeChecker.isAcceptValid(mockHeaders)); }
@Test public void acceptXmlShouldBeInvalid() { HttpHeaders mockHeaders = mock(HttpHeaders.class); when(mockHeaders.get(HttpHeaders.Names.ACCEPT)).thenReturn("text/html,application/xhtml+xml,application/xml;q=0.9"); assertFalse("accept text/html,application/xhtml+xml,application/xml;q=0.9 should be invalid", mediaTypeChecker.isAcceptValid(mockHeaders)); } |
HttpResponder { public void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status) { respond(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, status)); } @VisibleForTesting HttpResponder(); @VisibleForTesting HttpResponder(int httpConnIdleTimeout); static HttpResponder getInstance(); void respond(ChannelHandlerContext ctx, FullHttpRequest req, HttpResponseStatus status); void respond(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res); } | @Test public void testDefaultHttpConnIdleTimeout_RequestKeepAlive_ShouldHaveResponseKeepAlive() { HttpResponder responder = new HttpResponder(); ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); FullHttpRequest request = mock(FullHttpRequest.class); FullHttpResponse response = mock(FullHttpResponse.class); HttpHeaders headers = mock(HttpHeaders.class); Channel channel = mock(Channel.class); when(ctx.channel()).thenReturn(channel); when(request.content()).thenReturn(null); when(request.headers()).thenReturn(headers); when(headers.get(HttpHeaders.Names.CONNECTION)).thenReturn(HttpHeaders.Values.KEEP_ALIVE); when(request.getProtocolVersion()).thenReturn(HttpVersion.HTTP_1_1); HttpHeaders responseHeaders = new DefaultHttpHeaders(); when(response.headers()).thenReturn(responseHeaders); responder.respond(ctx, request, response); assertEquals("Connection: response header", HttpHeaders.Values.KEEP_ALIVE, responseHeaders.get(HttpHeaders.Names.CONNECTION)); }
@Test public void testNonZeroHttpConnIdleTimeout_RequestKeepAlive_ShouldHaveResponseKeepAliveTimeout() { int idleTimeout = 300; HttpResponder responder = new HttpResponder(idleTimeout); ChannelHandlerContext ctx = mock(ChannelHandlerContext.class); FullHttpRequest request = mock(FullHttpRequest.class); FullHttpResponse response = mock(FullHttpResponse.class); HttpHeaders headers = mock(HttpHeaders.class); Channel channel = mock(Channel.class); ChannelFuture future = mock(ChannelFuture.class); when(ctx.channel()).thenReturn(channel); when(ctx.writeAndFlush(any())).thenReturn(future); when(request.content()).thenReturn(null); when(request.headers()).thenReturn(headers); when(headers.get(HttpHeaders.Names.CONNECTION)).thenReturn(HttpHeaders.Values.KEEP_ALIVE); when(request.getProtocolVersion()).thenReturn(HttpVersion.HTTP_1_1); HttpHeaders responseHeaders = new DefaultHttpHeaders(); when(response.headers()).thenReturn(responseHeaders); responder.respond(ctx, request, response); assertEquals("Connection: response header", HttpHeaders.Values.KEEP_ALIVE, responseHeaders.get(HttpHeaders.Names.CONNECTION)); assertEquals("Keep-Alive: response header", "timeout="+idleTimeout, responseHeaders.get("Keep-Alive")); } |
RouteMatcher { public void get(String pattern, HttpRequestHandler handler) { addBinding(pattern, HttpMethod.GET.name(), handler, getBindings); } RouteMatcher(); RouteMatcher withNoRouteHandler(HttpRequestHandler noRouteHandler); void route(ChannelHandlerContext context, FullHttpRequest request); void get(String pattern, HttpRequestHandler handler); void put(String pattern, HttpRequestHandler handler); void post(String pattern, HttpRequestHandler handler); void delete(String pattern, HttpRequestHandler handler); void head(String pattern, HttpRequestHandler handler); void options(String pattern, HttpRequestHandler handler); void connect(String pattern, HttpRequestHandler handler); void patch(String pattern, HttpRequestHandler handler); Set<String> getSupportedMethodsForURL(String URL); } | @Test public void testValidRoutePatterns() throws Exception { FullHttpRequest modifiedReq = testPattern("/metrics/:metricId", "/metrics/foo"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(1, modifiedReq.headers().names().size()); Assert.assertEquals("metricId", modifiedReq.headers().entries().get(0).getKey()); Assert.assertEquals("foo", modifiedReq.headers().entries().get(0).getValue()); testRouteHandlerCalled = false; modifiedReq = testPattern("/tenants/:tenantId/entities/:entityId", "/tenants/acFoo/entities/enBar"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("tenantId").equals("acFoo")); Assert.assertTrue(modifiedReq.headers().get("entityId").equals("enBar")); testRouteHandlerCalled = false; modifiedReq = testPattern("/tenants/:tenantId/entities/:entityId/checks/:checkId/metrics/:metricId/plot", "/tenants/acFoo/entities/enBar/checks/chFoo/metrics/myMetric/plot"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(4, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("tenantId").equals("acFoo")); Assert.assertTrue(modifiedReq.headers().get("entityId").equals("enBar")); Assert.assertTrue(modifiedReq.headers().get("entityId").equals("enBar")); Assert.assertTrue(modifiedReq.headers().get("checkId").equals("chFoo")); Assert.assertTrue(modifiedReq.headers().get("metricId").equals("myMetric")); testRouteHandlerCalled = false; modifiedReq = testPattern("/software/:name/:version", "/software/blueflood/v0.1"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("name").equals("blueflood")); Assert.assertTrue(modifiedReq.headers().get("version").equals("v0.1")); testRouteHandlerCalled = false; modifiedReq = testPattern("/software/:name/:version/", "/software/blueflood/v0.1/"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("name").equals("blueflood")); Assert.assertTrue(modifiedReq.headers().get("version").equals("v0.1")); testRouteHandlerCalled = false; modifiedReq = testPattern("/:name/:version","/blueflood/v0.1"); Assert.assertTrue(testRouteHandlerCalled); Assert.assertEquals(2, modifiedReq.headers().names().size()); Assert.assertTrue(modifiedReq.headers().get("name").equals("blueflood")); Assert.assertTrue(modifiedReq.headers().get("version").equals("v0.1")); testRouteHandlerCalled = false; } |
HttpAggregatedIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); String body = null; String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); int metricsCount = 0; int delayedMetricsCount = 0; try { body = request.content().toString(Constants.DEFAULT_CHARSET); MetricsCollection collection = new MetricsCollection(); AggregatedPayload payload = AggregatedPayload.create(body); long ingestTime = clock.now().getMillis(); if (payload.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(payload.getTenantId(), payload.getTimestamp(), payload.getDelayTime(ingestTime), payload.getAllMetricNames()); payload.markDelayMetricsReceived(ingestTime); delayedMetricsCount += payload.getAllMetricNames().size(); } else { metricsCount += payload.getAllMetricNames().size(); } List<ErrorResponse.ErrorData> validationErrors = payload.getValidationErrors(); if ( validationErrors.isEmpty() ) { collection.add( PreaggregateConversions.buildMetricsCollection( payload ) ); ListenableFuture<List<Boolean>> futures = processor.apply( collection ); List<Boolean> persisteds = futures.get( timeout.getValue(), timeout.getUnit() ); for ( Boolean persisted : persisteds ) { if (!persisted) { log.error("Internal error persisting data for tenantId:" + payload.getTenantId()); DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); DefaultHandler.sendResponse( ctx, request, null, HttpResponseStatus.OK ); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("JSON request payload: %s", body)); log.error("Error saving data", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | @Test public void testEmptyRequest() throws IOException { String requestBody = ""; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid request body", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyJsonRequest() throws IOException { String requestBody = "{}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 3, errorResponse.getErrors().size()); assertEquals("Invalid tenant", "", errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyTenantId() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody("", new DefaultClockImpl().now().getMillis(), 0 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "tenantId", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", "", errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testInvalidFlushInterval() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), -1 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "must be between 0 and 9223372036854775807", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "flushInterval", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testCollectionTimeInPast() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); long collectionTimeInPast = new DefaultClockImpl().now().getMillis() - 1000 - Configuration.getInstance().getLongProperty( CoreConfig.BEFORE_CURRENT_COLLECTIONTIME_MS ); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, collectionTimeInPast, 0 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past. " + "Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timestamp", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testCollectionTimeInFuture() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); long collectionTimeInFuture = new DefaultClockImpl().now().getMillis() + 1000 + Configuration.getInstance().getLongProperty( CoreConfig.AFTER_CURRENT_COLLECTIONTIME_MS ); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, collectionTimeInFuture, 0 , new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past. " + "Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timestamp", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testAggregatedMetricsNotSet() throws IOException { FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0 , null, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "At least one of the aggregated metrics(gauges, counters, timers, sets) " + "are expected", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testGaugeEmptyMetricName() throws IOException { BluefloodGauge gauge = new BluefloodGauge("", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "gauges[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testGaugeEmptyMetricValue() throws IOException { String metricName = "gauge.a.b"; BluefloodGauge gauge = new BluefloodGauge(metricName, null); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "gauges[0].value", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testCounterEmptyMetricName() throws IOException { BluefloodCounter counter = new BluefloodCounter("", 5, 0.1); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "counters[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testCounterEmptyMetricValue() throws IOException { String metricName = "counter.a.b"; BluefloodCounter counter = new BluefloodCounter(metricName, null, 0.1); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "counters[0].value", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testCounterEmptyMetricRate() throws IOException { String metricName = "counter.a.b"; BluefloodCounter counter = new BluefloodCounter(metricName, 5, null); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "counters[0].rate", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testTimerEmptyMetricName() throws IOException { BluefloodTimer timer = new BluefloodTimer("", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, new BluefloodTimer[]{timer}, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timers[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testTimerEmptyMetricCount() throws IOException { String metricName = "timer.a.b"; BluefloodTimer timer = new BluefloodTimer(metricName, null); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, new BluefloodTimer[]{timer}, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be null", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "timers[0].count", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testSetEmptyMetricName() throws IOException { BluefloodSet sets = new BluefloodSet("", new String[]{}); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, null, new BluefloodSet[]{sets})); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid source", "sets[0].name", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testValidGauge() throws IOException { BluefloodGauge gauge = new BluefloodGauge("gauge.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, new BluefloodGauge[]{gauge}, null, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); }
@Test public void testValidCounter() throws IOException { BluefloodCounter counter = new BluefloodCounter("counter.a.b", 5, 0.1); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, new BluefloodCounter[]{counter}, null, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); }
@Test public void testValidTimer() throws IOException { BluefloodTimer timer = new BluefloodTimer("timer.a.b", 5); FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, new BluefloodTimer[]{timer}, null)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); }
@Test public void testValidSet() throws IOException { BluefloodSet set = new BluefloodSet("set.a.b", new String[]{"", ""});; FullHttpRequest request = createIngestRequest(createRequestBody(TENANT, new DefaultClockImpl().now().getMillis(), 0, null, null, null, new BluefloodSet[]{set})); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "", responseBody); assertEquals("Invalid status", HttpResponseStatus.OK, argument.getValue().getStatus()); } |
HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { public static List<AggregatedPayload> createBundleList(String json) { Gson gson = new Gson(); JsonParser parser = new JsonParser(); JsonElement element = parser.parse(json); if (!element.isJsonArray()) { throw new InvalidDataException("Invalid request body"); } JsonArray jArray = element.getAsJsonArray(); ArrayList<AggregatedPayload> bundleList = new ArrayList<AggregatedPayload>(); for(JsonElement obj : jArray ) { AggregatedPayload bundle = AggregatedPayload.create(obj); bundleList.add(bundle); } return bundleList; } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } | @Test public void testEmptyButValidMultiJSON() { String badJson = "[]"; List<AggregatedPayload> bundle = HttpAggregatedMultiIngestionHandler.createBundleList(badJson); } |
HttpAggregatedMultiIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); requestCount.inc(); final Timer.Context timerContext = handlerTimer.time(); long ingestTime = clock.now().getMillis(); String body = null; try { String submitterTenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); body = request.content().toString(Constants.DEFAULT_CHARSET); List<AggregatedPayload> bundleList = createBundleList(body); if (bundleList.size() > 0) { MetricsCollection collection = new MetricsCollection(); List<ErrorResponse.ErrorData> errors = new ArrayList<ErrorResponse.ErrorData>(); int delayedMetricsCount = 0; int metricsCount = 0; for (AggregatedPayload bundle : bundleList) { List<ErrorResponse.ErrorData> bundleValidationErrors = bundle.getValidationErrors(); if (bundleValidationErrors.isEmpty()) { collection.add(PreaggregateConversions.buildMetricsCollection(bundle)); } else { errors.addAll(bundleValidationErrors); } if (bundle.hasDelayedMetrics(ingestTime)) { Tracker.getInstance().trackDelayedAggregatedMetricsTenant(bundle.getTenantId(), bundle.getTimestamp(), bundle.getDelayTime(ingestTime), bundle.getAllMetricNames()); bundle.markDelayMetricsReceived(ingestTime); delayedMetricsCount += bundle.getAllMetricNames().size(); } else { metricsCount += bundle.getAllMetricNames().size(); } } if (!errors.isEmpty() && collection.size() == 0) { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.BAD_REQUEST); return; } ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { DefaultHandler.sendErrorResponse(ctx, request, "Internal error persisting data", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(submitterTenantId, metricsCount, delayedMetricsCount); if (errors.isEmpty()) { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); return; } else { DefaultHandler.sendErrorResponse(ctx, request, errors, HttpResponseStatus.MULTI_STATUS); return; } } else { DefaultHandler.sendResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); return; } } catch (JsonParseException ex) { log.debug(String.format("BAD JSON: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException ex) { log.debug(String.format("Invalid request body: %s", body)); DefaultHandler.sendErrorResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (TimeoutException ex) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception ex) { log.debug(String.format("Exception processing: %s", body)); log.error("Other exception while trying to parse content", ex); DefaultHandler.sendErrorResponse(ctx, request, "Internal error saving data", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { timerContext.stop(); requestCount.dec(); } } HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpAggregatedMultiIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static List<AggregatedPayload> createBundleList(String json); } | @Test public void testEmptyRequest() throws IOException { String requestBody = ""; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid request body", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testNonArrayJsonRequest() throws IOException { String requestBody = "{}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid request body", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyArrayJsonRequest() throws IOException { String requestBody = "[]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String responseBody = argument.getValue().content().toString(Charset.defaultCharset()); assertEquals("Invalid response", "No valid metrics", responseBody); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } |
HttpEventsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { final String tenantId = request.headers().get(Event.FieldLabels.tenantId.name()); String response = ""; ObjectMapper objectMapper = new ObjectMapper(); final Timer.Context httpEventsIngestTimerContext = httpEventsIngestTimer.time(); try { String body = request.content().toString(0, request.content().writerIndex(), CharsetUtil.UTF_8); Event event = objectMapper.readValue(body, Event.class); Iterator<Event> iterator = objectMapper.reader(Event.class).readValues(body); if (iterator.hasNext()) { iterator.next(); if (iterator.hasNext()) { throw new InvalidDataException("Only one event is allowed per request"); } } Set<ConstraintViolation<Event>> constraintViolations = validator.validate(event); List<ErrorResponse.ErrorData> validationErrors = new ArrayList<ErrorResponse.ErrorData>(); for (ConstraintViolation<Event> constraintViolation : constraintViolations) { validationErrors.add( new ErrorResponse.ErrorData(tenantId, "", constraintViolation.getPropertyPath().toString(), constraintViolation.getMessage(), event.getWhen())); } if (!validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); return; } searchIO.insert(tenantId, event.toMap()); DefaultHandler.sendResponse(ctx, request, response, HttpResponseStatus.OK); } catch (JsonMappingException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (JsonParseException e){ log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (InvalidDataException e) { log.debug(String.format("Exception %s", e.toString())); response = String.format("Invalid Data: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); response = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, response, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsIngestTimerContext.stop(); } } HttpEventsIngestionHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | @Test public void testElasticSearchInsertCalledWhenPut() throws Exception { Map<String, Object> event = createRandomEvent(); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO).insert(TENANT, event); }
@Test public void testInvalidRequestBody() throws Exception { ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createRequest(HttpMethod.POST, "", "{\"xxx\": \"yyy\"}")); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testMalformedEventPut() throws Exception { final String malformedJSON = "{\"when\":, what]}"; handler.handle(context, createRequest(HttpMethod.POST, "", malformedJSON)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyPut() throws Exception { Map<String, Object> event = new HashMap<String, Object>(); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); System.out.println(errorResponse); assertEquals("Number of errors invalid", 2, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyWhatField() throws Exception { Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.what.name(), ""); event.put(Event.FieldLabels.when.name(), System.currentTimeMillis()); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testWhenFieldInThePast() throws Exception { long collectionTimeInPast = new DefaultClockImpl().now().getMillis() - 10000 - Configuration.getInstance().getLongProperty( CoreConfig.BEFORE_CURRENT_COLLECTIONTIME_MS ); Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.what.name(), "xxxx"); event.put(Event.FieldLabels.when.name(), collectionTimeInPast); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testWhenFieldInTheFuture() throws Exception { long collectionTimeInFuture = new DefaultClockImpl().now().getMillis() + 10000 + Configuration.getInstance().getLongProperty( CoreConfig.AFTER_CURRENT_COLLECTIONTIME_MS ); Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.what.name(), "xxxx"); event.put(Event.FieldLabels.when.name(), collectionTimeInFuture); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testMinimumEventPut() throws Exception { Map<String, Object> event = new HashMap<String, Object>(); event.put(Event.FieldLabels.data.name(), "data"); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createPutOneEventRequest(event)); verify(searchIO, never()).insert(anyString(), anyMap()); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 2, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } |
HttpMetricsIngestionHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { try { requestsReceived.mark(); Tracker.getInstance().track(request); requestCount.inc(); final String tenantId = request.headers().get(HttpMetricsIngestionServer.TENANT_ID_HEADER); JSONMetricsContainer jsonMetricsContainer; List<Metric> validMetrics; final Timer.Context jsonTimerContext = jsonTimer.time(); final String body = request.content().toString(Constants.DEFAULT_CHARSET); try { jsonMetricsContainer = createContainer(body, tenantId); if (jsonMetricsContainer.areDelayedMetricsPresent()) { Tracker.getInstance().trackDelayedMetricsTenant(tenantId, jsonMetricsContainer.getDelayedMetrics()); } validMetrics = jsonMetricsContainer.getValidMetrics(); forceTTLsIfConfigured(validMetrics); } catch (JsonParseException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (JsonMappingException e) { log.warn("Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (InvalidDataException ex) { log.warn(ctx.channel().remoteAddress() + " " + ex.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, "Invalid data " + ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } catch (IOException e) { log.warn("IO Exception parsing content", e); DefaultHandler.sendErrorResponse(ctx, request, "Cannot parse content", HttpResponseStatus.BAD_REQUEST); return; } catch (Exception e) { log.warn("Other exception while trying to parse content", e); DefaultHandler.sendErrorResponse(ctx, request, "Failed parsing content", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } finally { jsonTimerContext.stop(); } List<ErrorResponse.ErrorData> validationErrors = jsonMetricsContainer.getValidationErrors(); if (validMetrics.isEmpty()) { log.warn(ctx.channel().remoteAddress() + " No valid metrics"); if (validationErrors.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "No valid metrics", HttpResponseStatus.BAD_REQUEST); } else { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.BAD_REQUEST); } return; } final MetricsCollection collection = new MetricsCollection(); collection.add(new ArrayList<IMetric>(validMetrics)); final Timer.Context persistingTimerContext = persistingTimer.time(); try { ListenableFuture<List<Boolean>> futures = processor.apply(collection); List<Boolean> persisteds = futures.get(timeout.getValue(), timeout.getUnit()); for (Boolean persisted : persisteds) { if (!persisted) { log.warn("Trouble persisting metrics:"); log.warn(String.format("%s", Arrays.toString(validMetrics.toArray()))); DefaultHandler.sendErrorResponse(ctx, request, "Persisted failed for metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); return; } } recordPerTenantMetrics(tenantId, jsonMetricsContainer.getNonDelayedMetricsCount(), jsonMetricsContainer.getDelayedMetricsCount()); if( !validationErrors.isEmpty() ) { DefaultHandler.sendErrorResponse(ctx, request, validationErrors, HttpResponseStatus.MULTI_STATUS); } else { DefaultHandler.sendResponse(ctx, request, null, HttpResponseStatus.OK); } } catch (TimeoutException e) { DefaultHandler.sendErrorResponse(ctx, request, "Timed out persisting metrics", HttpResponseStatus.ACCEPTED); } catch (Exception e) { log.error("Exception persisting metrics", e); DefaultHandler.sendErrorResponse(ctx, request, "Error persisting metrics", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { persistingTimerContext.stop(); } } finally { requestCount.dec(); } } HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout); HttpMetricsIngestionHandler(HttpMetricsIngestionServer.Processor processor, TimeValue timeout, boolean enablePerTenantMetrics); static String getResponseBody( List<String> errors ); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static final String ERROR_HEADER; } | @Test public void emptyRequest_shouldGenerateErrorResponse() throws IOException { String requestBody = ""; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Cannot parse content", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyJsonRequest() throws IOException { String requestBody = "{}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Cannot parse content", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testInvalidJsonRequest() throws IOException { String requestBody = "{\"xxxx\": yyyy}"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Cannot parse content", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyJsonArrayRequest() throws IOException { String requestBody = "[]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "No valid metrics", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testEmptyMetricRequest() throws IOException { String requestBody = "[{}]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 3, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testSingleMetricInvalidMetricName() throws IOException { String metricName = ""; String singleMetric = createRequestBody(metricName, new DefaultClockImpl().now().getMillis(), 24 * 60 * 60, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "metricName", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "may not be empty", errorResponse.getErrors().get(0).getMessage()); }
@Test public void testSingleMetricCollectionTimeInPast() throws IOException { long collectionTimeInPast = new DefaultClockImpl().now().getMillis() - 1000 - Configuration.getInstance().getLongProperty( CoreConfig.BEFORE_CURRENT_COLLECTIONTIME_MS ); String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, collectionTimeInPast, 24 * 60 * 60, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "collectionTime", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); }
@Test public void testSingleMetricCollectionTimeInFuture() throws IOException { long collectionTimeInFuture = new DefaultClockImpl().now().getMillis() + 1000 + Configuration.getInstance().getLongProperty( CoreConfig.AFTER_CURRENT_COLLECTIONTIME_MS ); String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, collectionTimeInFuture, 24 * 60 * 60, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "collectionTime", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(0).getMessage()); }
@Test public void testSingleMetricInvalidTTL() throws IOException { String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, new DefaultClockImpl().now().getMillis(), 0, 1); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", metricName, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid error source", "ttlInSeconds", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "must be between 1 and 2147483647", errorResponse.getErrors().get(0).getMessage()); }
@Test public void testSingleMetricInvalidMetricValue() throws IOException { String metricName = "a.b.c"; String singleMetric = createRequestBody(metricName, new DefaultClockImpl().now().getMillis(), 24 * 60 * 60, null); String requestBody = "[" + singleMetric + "]"; FullHttpRequest request = createIngestRequest(requestBody); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); System.out.println(errorResponse); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid metric name", "", errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertNull("Invalid error source", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "No valid metrics", errorResponse.getErrors().get(0).getMessage()); }
@Test public void testMultiMetricsInvalidRequest() throws IOException { String metricName1 = "a.b.c.1"; String metricName2 = "a.b.c.2"; FullHttpRequest request = createIngestRequest(generateInvalidMetrics(metricName1, metricName2)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 2, errorResponse.getErrors().size()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid tenant", metricName1, errorResponse.getErrors().get(0).getMetricName()); assertEquals("Invalid error source", "ttlInSeconds", errorResponse.getErrors().get(0).getSource()); assertEquals("Invalid error message", "must be between 1 and 2147483647", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(1).getTenantId()); assertEquals("Invalid tenant", metricName2, errorResponse.getErrors().get(1).getMetricName()); assertEquals("Invalid error source", "collectionTime", errorResponse.getErrors().get(1).getSource()); assertEquals("Invalid error message", "Out of bounds. Cannot be more than 259200000 milliseconds into the past." + " Cannot be more than 600000 milliseconds into the future", errorResponse.getErrors().get(1).getMessage()); } |
RollupBatchWriter { public void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext) { rollupQueue.add(rollupWriteContext); context.incrementWriteCounter(); if (rollupQueue.size() >= ROLLUP_BATCH_MIN_SIZE) { if (executor.getActiveCount() < executor.getPoolSize() || rollupQueue.size() >= ROLLUP_BATCH_MAX_SIZE) { drainBatch(); } } } RollupBatchWriter(ThreadPoolExecutor executor, RollupExecutionContext context); void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext); synchronized void drainBatch(); } | @Test public void enqueueIncrementsWriterCounter() { SingleRollupWriteContext srwc = mock(SingleRollupWriteContext.class); rbw.enqueueRollupForWrite(srwc); verify(ctx).incrementWriteCounter(); verifyNoMoreInteractions(ctx); verifyZeroInteractions(srwc); }
@Test public void enqueuingLessThanMinSizeDoesNotTriggerBatching() { SingleRollupWriteContext srwc1 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc2 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc3 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc4 = mock(SingleRollupWriteContext.class); rbw.enqueueRollupForWrite(srwc1); rbw.enqueueRollupForWrite(srwc2); rbw.enqueueRollupForWrite(srwc3); rbw.enqueueRollupForWrite(srwc4); verify(ctx, times(4)).incrementWriteCounter(); verifyNoMoreInteractions(ctx); verifyZeroInteractions(srwc1); verifyZeroInteractions(srwc2); verifyZeroInteractions(srwc3); verifyZeroInteractions(srwc4); verifyZeroInteractions(executor); }
@Test public void enqueuingMinSizeTriggersCheckOnExecutor() { doReturn(1).when(executor).getActiveCount(); doReturn(1).when(executor).getPoolSize(); SingleRollupWriteContext srwc1 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc2 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc3 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc4 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc5 = mock(SingleRollupWriteContext.class); rbw.enqueueRollupForWrite(srwc1); rbw.enqueueRollupForWrite(srwc2); rbw.enqueueRollupForWrite(srwc3); rbw.enqueueRollupForWrite(srwc4); rbw.enqueueRollupForWrite(srwc5); verify(ctx, times(5)).incrementWriteCounter(); verifyNoMoreInteractions(ctx); verifyZeroInteractions(srwc1); verifyZeroInteractions(srwc2); verifyZeroInteractions(srwc3); verifyZeroInteractions(srwc4); verifyZeroInteractions(srwc5); verify(executor).getActiveCount(); verify(executor).getPoolSize(); verifyNoMoreInteractions(executor); }
@Test public void enqueuingMinSizeAndThreadPoolNotSaturatedTriggersBatching() throws Exception { doReturn(0).when(executor).getActiveCount(); doReturn(1).when(executor).getPoolSize(); SingleRollupWriteContext srwc1 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc2 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc3 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc4 = mock(SingleRollupWriteContext.class); SingleRollupWriteContext srwc5 = mock(SingleRollupWriteContext.class); Points<SimpleNumber> points = new Points<SimpleNumber>(); Rollup rollup = Rollup.BasicFromRaw.compute(points); doReturn(rollup).when(srwc1).getRollup(); doReturn(rollup).when(srwc2).getRollup(); doReturn(rollup).when(srwc3).getRollup(); doReturn(rollup).when(srwc4).getRollup(); doReturn(rollup).when(srwc5).getRollup(); rbw.enqueueRollupForWrite(srwc1); rbw.enqueueRollupForWrite(srwc2); rbw.enqueueRollupForWrite(srwc3); rbw.enqueueRollupForWrite(srwc4); rbw.enqueueRollupForWrite(srwc5); verify(ctx, times(5)).incrementWriteCounter(); verifyNoMoreInteractions(ctx); verify(executor).getActiveCount(); verify(executor).getPoolSize(); verify(executor).execute(Matchers.<Runnable>any()); verifyNoMoreInteractions(executor); }
@Test public void enqueuingMaxSizeTriggersBatching() throws Exception { doReturn(1).when(executor).getActiveCount(); doReturn(1).when(executor).getPoolSize(); SingleRollupWriteContext[] srwcs = new SingleRollupWriteContext[100]; int i; for (i = 0; i < 100; i++) { srwcs[i] = mock(SingleRollupWriteContext.class); Points<SimpleNumber> points = new Points<SimpleNumber>(); Rollup rollup = Rollup.BasicFromRaw.compute(points); doReturn(rollup).when(srwcs[i]).getRollup(); } for (i = 0; i < 100; i++) { rbw.enqueueRollupForWrite(srwcs[i]); } verify(ctx, times(100)).incrementWriteCounter(); verifyNoMoreInteractions(ctx); verify(executor, times(96)).getActiveCount(); verify(executor, times(96)).getPoolSize(); verify(executor).execute(Matchers.<Runnable>any()); verifyNoMoreInteractions(executor); } |
SlotStateSerDes { protected static Granularity granularityFromStateCol(String s) { String field = s.split(",", -1)[0]; for (Granularity g : Granularity.granularities()) if (g.name().startsWith(field)) return g; return null; } static SlotState deserialize(String stateStr); String serialize(SlotState state); String serialize(Granularity gran, int slot, UpdateStamp.State state); } | @Test public void testGranularityFromStateCol() { Granularity myGranularity = serDes.granularityFromStateCol("metrics_full,1,okay"); Assert.assertNotNull(myGranularity); Assert.assertEquals(myGranularity, Granularity.FULL); myGranularity = serDes.granularityFromStateCol("FULL"); Assert.assertNull(myGranularity); } |
HttpRollupsQueryHandler extends RollupHandler implements MetricDataQueryInterface<MetricData>, HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); final String metricName = request.headers().get("metricName"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpMetricsFetchTimerContext = httpMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); JSONObject metricData; if (params.isGetByPoints()) { metricData = GetDataByPoints(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getPoints(), params.getStats()); } else if (params.isGetByResolution()) { metricData = GetDataByResolution(tenantId, metricName, params.getRange().getStart(), params.getRange().getStop(), params.getResolution(), params.getStats()); } else { throw new InvalidRequestException("Invalid rollups query. Neither points nor resolution specified."); } final JsonElement element = parser.parse(metricData.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricsFetchTimerContext.stop(); } } HttpRollupsQueryHandler(); @VisibleForTesting HttpRollupsQueryHandler(BasicRollupsOutputSerializer<JSONObject> serializer); @Override MetricData GetDataByPoints(String tenantId,
String metric,
long from,
long to,
int points); @Override MetricData GetDataByResolution(String tenantId,
String metric,
long from,
long to,
Resolution resolution); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | @Test public void testWithNoQueryParams() throws IOException { FullHttpRequest request = createQueryRequest(""); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "No query parameters present.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testMissingRequiredQueryParams() throws IOException { FullHttpRequest request = createQueryRequest("?from=111111"); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Either 'points' or 'resolution' is required.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testRequestWithSerializationException() throws IOException { FullHttpRequest request = createQueryRequest("?points=10&from=1&to=2"); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); String message = "mock exception message"; when(serializer.transformRollupData(any(MetricData.class), anySet())).thenThrow(new SerializationException(message)); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", message, errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.INTERNAL_SERVER_ERROR, argument.getValue().getStatus()); } |
HttpMultiRollupsQueryHandler extends RollupHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); if (!(request instanceof HttpRequestWithDecodedQueryParams)) { DefaultHandler.sendErrorResponse(ctx, request, "Missing query params: from, to, points", HttpResponseStatus.BAD_REQUEST); return; } final String body = request.content().toString(Constants.DEFAULT_CHARSET); if (body == null || body.isEmpty()) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid body. Expected JSON array of metrics.", HttpResponseStatus.BAD_REQUEST); return; } List<String> locators = new ArrayList<String>(); try { locators.addAll(getLocatorsFromJSONBody(tenantId, body)); } catch (Exception ex) { log.debug(ex.getMessage(), ex); sendResponse(ctx, request, ex.getMessage(), HttpResponseStatus.BAD_REQUEST); return; } if (locators.size() > maxMetricsPerRequest) { DefaultHandler.sendErrorResponse(ctx, request, "Too many metrics fetch in a single call. Max limit is " + maxMetricsPerRequest + ".", HttpResponseStatus.BAD_REQUEST); return; } HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; final Timer.Context httpBatchMetricsFetchTimerContext = httpBatchMetricsFetchTimer.time(); try { RollupsQueryParams params = PlotRequestParser.parseParams(requestWithParams.getQueryParams()); Map<Locator, MetricData> results = getRollupByGranularity(tenantId, locators, params.getRange().getStart(), params.getRange().getStop(), params.getGranularity(tenantId)); JSONObject metrics = serializer.transformRollupData(results, params.getStats()); final JsonElement element = parser.parse(metrics.toString()); final String jsonStringRep = gson.toJson(element); sendResponse(ctx, request, jsonStringRep, HttpResponseStatus.OK); } catch (InvalidRequestException e) { log.debug(e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.BAD_REQUEST); } catch (SerializationException e) { log.debug(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } catch (Exception e) { log.error(e.getMessage(), e); DefaultHandler.sendErrorResponse(ctx, request, e.getMessage(), HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpBatchMetricsFetchTimerContext.stop(); } } HttpMultiRollupsQueryHandler(); @VisibleForTesting HttpMultiRollupsQueryHandler(BatchedMetricsOutputSerializer<JSONObject> serializer); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | @Test public void testWithNoRequestBody() throws IOException { FullHttpRequest request = createQueryRequest("", ""); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid body. Expected JSON array of metrics.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testWithTooMayLocatorsInRequestBody() throws IOException { int maxLimit = Configuration.getInstance().getIntegerProperty(HttpConfig.MAX_METRICS_PER_BATCH_QUERY); FullHttpRequest request = createQueryRequest("", createRequestBody(maxLimit + 1)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Too many metrics fetch in a single call. Max limit is " + maxLimit + ".", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testWithNoQueryParams() throws IOException { FullHttpRequest request = createQueryRequest("", createRequestBody(1)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "No query parameters present.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testMissingRequiredQueryParams() throws IOException { FullHttpRequest request = createQueryRequest("?from=111111", createRequestBody(1)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Either 'points' or 'resolution' is required.", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void testRequestWithSerializationException() throws IOException { FullHttpRequest request = createQueryRequest("?points=10&from=1&to=2", createRequestBody(1)); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); String message = "mock exception message"; when(serializer.transformRollupData(anyMap(), anySet())).thenThrow(new SerializationException(message)); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", message, errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.INTERNAL_SERVER_ERROR, argument.getValue().getStatus()); } |
HttpMetricsIndexHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; List<String> query = requestWithParams.getQueryParams().get("query"); if (query == null || query.size() != 1) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid Query String", HttpResponseStatus.BAD_REQUEST); return; } discoveryHandle = (DiscoveryIO) ModuleLoader.getInstance(DiscoveryIO.class, CoreConfig.DISCOVERY_MODULES); if (discoveryHandle == null) { sendResponse(ctx, request, null, HttpResponseStatus.NOT_FOUND); return; } try { List<SearchResult> searchResults = discoveryHandle.search(tenantId, query.get(0)); sendResponse(ctx, request, getSerializedJSON(searchResults), HttpResponseStatus.OK); } catch (Exception e) { log.error(String.format("Exception occurred while trying to get metrics index for %s", tenantId), e); DefaultHandler.sendErrorResponse(ctx, request, "Error getting metrics index", HttpResponseStatus.INTERNAL_SERVER_ERROR); } } @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); static String getSerializedJSON(List<SearchResult> searchResults); } | @Test public void testWithNoQueryParams() throws IOException { FullHttpRequest request = createQueryRequest(""); ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, request); verify(channel).write(argument.capture()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid Query String", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } |
HttpMetricNamesHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final Timer.Context httpMetricNamesHandlerTimerContext = HttpMetricNamesHandlerTimer.time(); final String tenantId = request.headers().get("tenantId"); HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; List<String> query = requestWithParams.getQueryParams().get("query"); if (query == null || query.size() != 1) { DefaultHandler.sendErrorResponse(ctx, request, "Invalid Query String", HttpResponseStatus.BAD_REQUEST); return; } if (discoveryHandle == null) { sendResponse(ctx, request, null, HttpResponseStatus.NOT_FOUND); return; } try { List<MetricName> metricNames = discoveryHandle.getMetricNames(tenantId, query.get(0)); sendResponse(ctx, request, getSerializedJSON(metricNames), HttpResponseStatus.OK); } catch (Exception e) { log.error(String.format("Exception occurred while trying to get metrics index for %s", tenantId), e); DefaultHandler.sendErrorResponse(ctx, request, "Error getting metrics index", HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpMetricNamesHandlerTimerContext.stop(); } } HttpMetricNamesHandler(); HttpMetricNamesHandler(DiscoveryIO discoveryHandle); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); String getSerializedJSON(final List<MetricName> metricNames); static boolean EXP_TOKEN_SEARCH_IMPROVEMENTS; } | @Test public void emptyPrefix() throws Exception { ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createGetRequest("/v2.0/" + TENANT + "/metric_name/search")); verify(channel).write(argument.capture()); verify(mockDiscoveryHandle, never()).getMetricNames(anyString(), anyString()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid Query String", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void invalidQuerySize() throws Exception { ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createGetRequest("/v2.0/" + TENANT + "/metric_name/search?query=foo&query=bar")); verify(channel).write(argument.capture()); verify(mockDiscoveryHandle, never()).getMetricNames(anyString(), anyString()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Invalid Query String", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); }
@Test public void validQuery() throws Exception { handler.handle(context, createGetRequest("/v2.0/" + TENANT + "/metric_name/search?query=foo")); verify(mockDiscoveryHandle, times(1)).getMetricNames(anyString(), anyString()); } |
HttpMetricNamesHandler implements HttpRequestHandler { public String getSerializedJSON(final List<MetricName> metricNames) { ArrayNode tokenInfoArrayNode = JsonNodeFactory.instance.arrayNode(); for (MetricName metricName : metricNames) { ObjectNode metricNameInfoNode = JsonNodeFactory.instance.objectNode(); metricNameInfoNode.put(metricName.getName(), JsonNodeFactory.instance.booleanNode(metricName.isCompleteName())); tokenInfoArrayNode.add(metricNameInfoNode); } return tokenInfoArrayNode.toString(); } HttpMetricNamesHandler(); HttpMetricNamesHandler(DiscoveryIO discoveryHandle); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); String getSerializedJSON(final List<MetricName> metricNames); static boolean EXP_TOKEN_SEARCH_IMPROVEMENTS; } | @Test public void testOutput() throws ParseException { List<MetricName> inputMetricNames = new ArrayList<MetricName>() {{ add(new MetricName("foo", false)); add(new MetricName("bar", false)); }}; String output = handler.getSerializedJSON(inputMetricNames); JSONParser jsonParser = new JSONParser(); JSONArray tokenInfos = (JSONArray) jsonParser.parse(output); Assert.assertEquals("Unexpected result size", 2, tokenInfos.size()); Set<String> expectedOutputSet = new HashSet<String>(); for (MetricName metricName : inputMetricNames) { expectedOutputSet.add(metricName.getName() + "|" + metricName.isCompleteName()); } Set<String> outputSet = new HashSet<String>(); for (int i = 0; i< inputMetricNames.size(); i++) { JSONObject object = (JSONObject) tokenInfos.get(i); Iterator it = object.entrySet().iterator(); while (it.hasNext()) { Map.Entry entry = (Map.Entry) it.next(); outputSet.add(entry.getKey() + "|" + entry.getValue()); } } Assert.assertEquals("Unexpected size", expectedOutputSet.size(), outputSet.size()); Assert.assertTrue("Output contains no more elements than expected", expectedOutputSet.containsAll(outputSet)); Assert.assertTrue("Output contains no less elements than expected", outputSet.containsAll(expectedOutputSet)); }
@Test public void testEmptyOutput() throws ParseException { List<MetricName> inputMetricNames = new ArrayList<MetricName>(); String output = handler.getSerializedJSON(inputMetricNames); JSONParser jsonParser = new JSONParser(); JSONArray tokenInfos = (JSONArray) jsonParser.parse(output); Assert.assertEquals("Unexpected result size", 0, tokenInfos.size()); } |
HttpEventsQueryHandler implements HttpRequestHandler { @Override public void handle(ChannelHandlerContext ctx, FullHttpRequest request) { Tracker.getInstance().track(request); final String tenantId = request.headers().get("tenantId"); ObjectMapper objectMapper = new ObjectMapper(); String responseBody = null; final Timer.Context httpEventsFetchTimerContext = httpEventsFetchTimer.time(); try { HttpRequestWithDecodedQueryParams requestWithParams = (HttpRequestWithDecodedQueryParams) request; Map<String, List<String>> params = requestWithParams.getQueryParams(); if (params == null || params.size() == 0) { throw new InvalidDataException("Query should contain at least one query parameter"); } parseDateFieldInQuery(params, "from"); parseDateFieldInQuery(params, "until"); List<Map<String, Object>> searchResult = searchIO.search(tenantId, params); responseBody = objectMapper.writeValueAsString(searchResult); DefaultHandler.sendResponse(ctx, request, responseBody, HttpResponseStatus.OK, null); } catch (InvalidDataException e) { log.error(String.format("Exception %s", e.toString())); responseBody = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, responseBody, HttpResponseStatus.BAD_REQUEST); } catch (Exception e) { log.error(String.format("Exception %s", e.toString())); responseBody = String.format("Error: %s", e.getMessage()); DefaultHandler.sendErrorResponse(ctx, request, responseBody, HttpResponseStatus.INTERNAL_SERVER_ERROR); } finally { httpEventsFetchTimerContext.stop(); } } HttpEventsQueryHandler(EventsIO searchIO); @Override void handle(ChannelHandlerContext ctx, FullHttpRequest request); } | @Test public void testElasticSearchSearchNotCalledEmptyQuery() throws Exception { ArgumentCaptor<FullHttpResponse> argument = ArgumentCaptor.forClass(FullHttpResponse.class); handler.handle(context, createGetRequest("/v2.0/" + TENANT + "/events/")); verify(channel).write(argument.capture()); verify(searchIO, never()).search(TENANT, new HashMap<String, List<String>>()); String errorResponseBody = argument.getValue().content().toString(Charset.defaultCharset()); ErrorResponse errorResponse = getErrorResponse(errorResponseBody); assertEquals("Number of errors invalid", 1, errorResponse.getErrors().size()); assertEquals("Invalid error message", "Error: Query should contain at least one query parameter", errorResponse.getErrors().get(0).getMessage()); assertEquals("Invalid tenant", TENANT, errorResponse.getErrors().get(0).getTenantId()); assertEquals("Invalid status", HttpResponseStatus.BAD_REQUEST, argument.getValue().getStatus()); } |
BatchedMetricsJSONOutputSerializer extends JSONBasicRollupsOutputSerializer implements BatchedMetricsOutputSerializer<JSONObject> { @Override public JSONObject transformRollupData(Map<Locator, MetricData> metricData, Set<MetricStat> filterStats) throws SerializationException { final JSONObject globalJSON = new JSONObject(); final JSONArray metricsArray = new JSONArray(); for (Map.Entry<Locator, MetricData> one : metricData.entrySet()) { final JSONObject singleMetricJSON = new JSONObject(); singleMetricJSON.put("metric", one.getKey().getMetricName()); singleMetricJSON.put("unit", one.getValue().getUnit() == null ? Util.UNKNOWN : one.getValue().getUnit()); singleMetricJSON.put("type", one.getValue().getType()); Set<MetricStat> oneFilterStats = fixFilterStats(one.getValue(), filterStats); JSONArray values = transformDataToJSONArray(one.getValue(), oneFilterStats); singleMetricJSON.put("data", values); metricsArray.add(singleMetricJSON); } globalJSON.put("metrics", metricsArray); return globalJSON; } @Override JSONObject transformRollupData(Map<Locator, MetricData> metricData, Set<MetricStat> filterStats); } | @Test public void testBatchedMetricsSerialization() throws Exception { final BatchedMetricsJSONOutputSerializer serializer = new BatchedMetricsJSONOutputSerializer(); final Map<Locator, MetricData> metrics = new HashMap<Locator, MetricData>(); for (int i = 0; i < 2; i++) { final MetricData metricData = new MetricData(FakeMetricDataGenerator.generateFakeRollupPoints(), "unknown"); metrics.put(Locator.createLocatorFromPathComponents(tenantId, String.valueOf(i)), metricData); } JSONObject jsonMetrics = serializer.transformRollupData(metrics, filterStats); Assert.assertTrue(jsonMetrics.get("metrics") != null); JSONArray jsonMetricsArray = (JSONArray) jsonMetrics.get("metrics"); Iterator<JSONObject> metricsObjects = jsonMetricsArray.iterator(); Assert.assertTrue(metricsObjects.hasNext()); while (metricsObjects.hasNext()) { JSONObject singleMetricObject = metricsObjects.next(); Assert.assertTrue(singleMetricObject.get("unit").equals("unknown")); Assert.assertTrue(singleMetricObject.get("type").equals("number")); JSONArray data = (JSONArray) singleMetricObject.get("data"); Assert.assertTrue(data != null); } } |
DateTimeParser { public static DateTime parse(String dateTimeOffsetString) { String stringToParse = dateTimeOffsetString.replace(" ", "").replace(",", "").replace("_", ""); if (StringUtils.isNumeric(stringToParse) && !isLikelyDateTime(stringToParse)) return dateTimeFromTimestamp(stringToParse); DateTime dateTime = tryParseDateTime("HH:mmyyyyMMdd", stringToParse); if (dateTime != null) return dateTime; List<String> splitList = splitDateTimeAndOffset(stringToParse); String offset = splitList.get(1); String dateTimeString = splitList.get(0); DateTimeOffsetParser parser = new DateTimeOffsetParser(dateTimeString, offset); return parser.updateDateTime(new DateTime()); } static DateTime parse(String dateTimeOffsetString); } | @Test public void testFromUnixTimestamp() { long unixTimestamp = nowDateTime().getMillis() / 1000; Assert.assertEquals(DateTimeParser.parse(Long.toString(unixTimestamp)), nowDateTime()); }
@Test public void testPlainTimeDateFormat() { DateTimeFormatter formatter = DateTimeFormat.forPattern("HH:mmyyyyMMdd"); String dateTimeWithSpace = "10:55 2014 12 20"; String dateTimeWithUnderscore = "10:55_2014_12_20"; Assert.assertEquals(DateTimeParser.parse(dateTimeWithSpace), new DateTime(formatter.parseDateTime(dateTimeWithSpace.replace(" ", "")))); Assert.assertEquals(DateTimeParser.parse(dateTimeWithUnderscore), new DateTime(formatter.parseDateTime(dateTimeWithUnderscore.replace("_", "")))); }
@Test public void testNowKeyword() { String nowTimestamp = "now"; Assert.assertEquals(DateTimeParser.parse(nowTimestamp), nowDateTime()); }
@Test public void testRegularHourMinute() { String hourMinuteTimestamp = "12:24"; String hourMinuteWithAm = "9:13am"; String hourMinuteWithPm = "09:13pm"; Assert.assertEquals(DateTimeParser.parse(hourMinuteTimestamp), referenceDateTime().withHourOfDay(12).withMinuteOfHour(24)); Assert.assertEquals(DateTimeParser.parse(hourMinuteWithAm), referenceDateTime().withHourOfDay(9).withMinuteOfHour(13)); Assert.assertEquals(DateTimeParser.parse(hourMinuteWithPm), referenceDateTime().withHourOfDay(21).withMinuteOfHour(13)); }
@Test public void testHourMinuteKeywords() { String noonTimestamp = "noon"; String teatimeTimestamp = "teatime"; String midnightTimestamp = "midnight"; Assert.assertEquals(DateTimeParser.parse(noonTimestamp), referenceDateTime().withHourOfDay(12).withMinuteOfHour(0)); Assert.assertEquals(DateTimeParser.parse(teatimeTimestamp), referenceDateTime().withHourOfDay(16).withMinuteOfHour(0)); Assert.assertEquals(DateTimeParser.parse(midnightTimestamp), referenceDateTime().withHourOfDay(0).withMinuteOfHour(0)); }
@Test public void testDayKeywords() { String todayTimestamp = "today"; String yesterdayTimestamp = "yesterday"; String tomorrowTimeStamp = "tomorrow"; Assert.assertEquals(DateTimeParser.parse(todayTimestamp), referenceDateTime()); Assert.assertEquals(DateTimeParser.parse(yesterdayTimestamp), referenceDateTime().minusDays(1)); Assert.assertEquals(DateTimeParser.parse(tomorrowTimeStamp), referenceDateTime().plusDays(1)); }
@Test public void testDayOfWeekFormat() { DateTime todayDate = referenceDateTime(); for (String dateTimeString: Arrays.asList("Fri", "14:42 Fri", "noon Fri")) { DateTime date = DateTimeParser.parse(dateTimeString); Assert.assertEquals(date.getDayOfWeek(), 5); Assert.assertTrue(todayDate.getDayOfYear() - date.getDayOfYear() <= 7); } } |
Tracker implements TrackerMBean { public synchronized void register() { if (isRegistered) return; try { ObjectName objectName = new ObjectName(trackerName); MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer(); if (!mBeanServer.isRegistered(objectName)) { ManagementFactory.getPlatformMBeanServer().registerMBean(instance, objectName); } isRegistered = true; log.info("MBean registered as " + trackerName); } catch (Exception exc) { log.error("Unable to register MBean " + trackerName, exc); } } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testRegister() { tracker.register(); verify(loggerMock, times(1)).info("MBean registered as com.rackspacecloud.blueflood.tracker:type=Tracker"); } |
Tracker implements TrackerMBean { public void addTenant(String tenantId) { tenantIds.add(tenantId); log.info("[TRACKER] tenantId " + tenantId + " added."); } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testAddTenant() { tracker.addTenant(testTenant1); Set tenants = tracker.getTenants(); assertTrue( "tenant " + testTenant1 + " not added", tracker.isTracking( testTenant1 ) ); assertTrue( "tenants.size not 1", tenants.size() == 1 ); assertTrue( "tenants does not contain " + testTenant1, tenants.contains( testTenant1 ) ); } |
Tracker implements TrackerMBean { public void removeTenant(String tenantId) { tenantIds.remove(tenantId); log.info("[TRACKER] tenantId " + tenantId + " removed."); } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testRemoveTenant() { tracker.addTenant(testTenant1); assertTrue( "tenant " + testTenant1 + " not added", tracker.isTracking( testTenant1 ) ); tracker.removeTenant(testTenant1); Set tenants = tracker.getTenants(); assertFalse( "tenant " + testTenant1 + " not removed", tracker.isTracking( testTenant1 ) ); assertEquals( "tenants.size not 0", tenants.size(), 0 ); assertFalse( "tenants contains " + testTenant1, tenants.contains( testTenant1 ) ); } |
Tracker implements TrackerMBean { public void removeAllMetricNames() { metricNames.clear(); log.info("[TRACKER] All metric names removed."); } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testRemoveAllMetricNames() { tracker.addMetricName("metricName"); tracker.addMetricName("anotherMetricNom"); assertTrue("metricName not being logged",tracker.doesMessageContainMetricNames("Track.this.metricName")); assertTrue("anotherMetricNom not being logged",tracker.doesMessageContainMetricNames("Track.this.anotherMetricNom")); assertFalse("randomMetricNameNom should not be logged", tracker.doesMessageContainMetricNames("Track.this.randomMetricNameNom")); tracker.removeAllMetricNames(); assertTrue("Everything should be logged", tracker.doesMessageContainMetricNames("Track.this.metricName")); assertTrue("Everything should be logged", tracker.doesMessageContainMetricNames("Track.this.anotherMetricNom")); assertTrue("Everything should be logged", tracker.doesMessageContainMetricNames("Track.this.randomMetricNameNom")); } |
Tracker implements TrackerMBean { String findTid( String uri ) { Matcher m = patternGetTid.matcher( uri ); if( m.matches() ) return m.group( 1 ); else return null; } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testFindTidFound() { assertEquals( tracker.findTid( "/v2.0/6000/views" ), "6000" ); }
@Test public void testTrackTenantNoVersion() { assertEquals( tracker.findTid( "/6000/views" ), null ); }
@Test public void testTrackTenantBadVersion() { assertEquals( tracker.findTid( "blah/6000/views" ), null ); }
@Test public void testTrackTenantTrailingSlash() { assertEquals( tracker.findTid( "/v2.0/6000/views/" ), "6000" ); } |
Tracker implements TrackerMBean { public void setIsTrackingDelayedMetrics() { isTrackingDelayedMetrics = true; log.info("[TRACKER] Tracking delayed metrics started"); } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testSetIsTrackingDelayedMetrics() { tracker.resetIsTrackingDelayedMetrics(); tracker.setIsTrackingDelayedMetrics(); Assert.assertTrue("isTrackingDelayedMetrics should be true from setIsTrackingDelayedMetrics", tracker.getIsTrackingDelayedMetrics()); } |
Tracker implements TrackerMBean { public void trackResponse(HttpRequest request, FullHttpResponse response) { if (request == null) return; if (response == null) return; String tenantId = findTid( request.getUri() ); if (isTracking(tenantId)) { HttpResponseStatus status = response.getStatus(); String messageBody = response.content().toString(Constants.DEFAULT_CHARSET); String queryParams = getQueryParameters(request); String headers = ""; for (String headerName : response.headers().names()) { headers += "\n" + headerName + "\t" + response.headers().get(headerName); } String responseContent = ""; if ((messageBody != null) && (!messageBody.isEmpty())) { responseContent = "\nRESPONSE_CONTENT:\n" + messageBody; } String logMessage = "[TRACKER] " + "Response for tenantId " + tenantId + " " + request.getMethod() + " request " + request.getUri() + queryParams + "\nRESPONSE_STATUS: " + status.code() + "\nRESPONSE HEADERS: " + headers + responseContent; log.info(logMessage); } } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testTrackResponse() throws Exception { String requestUri = "/v2.0/" + tenantId + "/metrics/search"; when(httpRequestMock.getUri()).thenReturn(requestUri); when(httpMethodMock.toString()).thenReturn("GET"); when(httpRequestMock.getMethod()).thenReturn(httpMethodMock); List<String> paramValues = new ArrayList<String>(); paramValues.add("locator1"); queryParams.put("query", paramValues); when((httpRequestMock).getQueryParams()).thenReturn(queryParams); when(httpResponseStatusMock.code()).thenReturn(200); when(httpResponseMock.getStatus()).thenReturn(httpResponseStatusMock); String result = "[TRACKER] Response for tenantId " + tenantId; when(httpResponseMock.content()).thenReturn(Unpooled.copiedBuffer(result.getBytes("UTF-8"))); tracker.addTenant(tenantId); tracker.trackResponse(httpRequestMock, httpResponseMock); verify(loggerMock, atLeastOnce()).info("[TRACKER] tenantId " + tenantId + " added."); verify(loggerMock, times(1)).info("[TRACKER] Response for tenantId " + tenantId + " GET request " + requestUri + "?query=locator1\n" + "RESPONSE_STATUS: 200\n" + "RESPONSE HEADERS: \n" + "RESPONSE_CONTENT:\n" + "[TRACKER] Response for tenantId " + tenantId); } |
Tracker implements TrackerMBean { public void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics) { if (isTrackingDelayedMetrics) { String logMessage = String.format("[TRACKER][DELAYED METRIC] Tenant sending delayed metrics %s", tenantid); log.info(logMessage); double delayedMinutes; long nowMillis = System.currentTimeMillis(); for (Metric metric : delayedMetrics) { delayedMinutes = (double)(nowMillis - metric.getCollectionTime()) / 1000 / 60; logMessage = String.format("[TRACKER][DELAYED METRIC] %s has collectionTime %s which is delayed by %.2f minutes", metric.getLocator().toString(), dateFormatter.format(new Date(metric.getCollectionTime())), delayedMinutes); log.info(logMessage); } } } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testTrackDelayedMetricsTenant() { tracker.setIsTrackingDelayedMetrics(); tracker.trackDelayedMetricsTenant(tenantId, delayedMetrics); verify(loggerMock, atLeastOnce()).info("[TRACKER] Tracking delayed metrics started"); verify(loggerMock, atLeastOnce()).info("[TRACKER][DELAYED METRIC] Tenant sending delayed metrics " + tenantId); verify(loggerMock, atLeastOnce()).info(contains("[TRACKER][DELAYED METRIC] " + tenantId + ".delayed.metric1 has collectionTime 2016-01-01 00:00:00 which is delayed")); verify(loggerMock, atLeastOnce()).info(contains("[TRACKER][DELAYED METRIC] " + tenantId + ".delayed.metric2 has collectionTime 2016-01-01 00:00:00 which is delayed")); } |
Tracker implements TrackerMBean { public void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames) { if (isTrackingDelayedMetrics) { String logMessage = String.format("[TRACKER][DELAYED METRIC] Tenant sending delayed metrics %s", tenantId); log.info(logMessage); double delayMin = delayTimeMs / 1000 / 60; logMessage = String.format("[TRACKER][DELAYED METRIC] %s have collectionTime %s which is delayed by %.2f minutes", StringUtils.join(delayedMetricNames, ","), dateFormatter.format(new Date(collectionTimeMs)), delayMin); log.info(logMessage); } } private Tracker(); static Tracker getInstance(); synchronized void register(); void addTenant(String tenantId); void removeTenant(String tenantId); void removeAllTenants(); Set getTenants(); void addMetricName(String metricName); void removeMetricName(String metricName); void removeAllMetricNames(); Set<String> getMetricNames(); void setIsTrackingDelayedMetrics(); void resetIsTrackingDelayedMetrics(); boolean getIsTrackingDelayedMetrics(); boolean isTracking(String tenantId); boolean doesMessageContainMetricNames(String logmessage); void track(HttpRequest request); void trackResponse(HttpRequest request, FullHttpResponse response); void trackDelayedMetricsTenant(String tenantid, final List<Metric> delayedMetrics); void trackDelayedAggregatedMetricsTenant(String tenantId, long collectionTimeMs, long delayTimeMs, List<String> delayedMetricNames); static final String trackerName; } | @Test public void testTrackDelayedAggregatedMetricsTenant() { tracker.setIsTrackingDelayedMetrics(); List<String> delayedMetricNames = new ArrayList<String>() {{ for ( Metric metric : delayedMetrics ) { add(metric.getLocator().toString()); } }}; long ingestTime = System.currentTimeMillis(); tracker.trackDelayedAggregatedMetricsTenant(tenantId, delayedMetrics.get(0).getCollectionTime(), ingestTime, delayedMetricNames); verify(loggerMock, atLeastOnce()).info("[TRACKER] Tracking delayed metrics started"); verify(loggerMock, atLeastOnce()).info("[TRACKER][DELAYED METRIC] Tenant sending delayed metrics " + tenantId); verify(loggerMock, atLeastOnce()).info(contains("[TRACKER][DELAYED METRIC] " + tenantId + ".delayed.metric1" + "," + tenantId + ".delayed.metric2 have collectionTime 2016-01-01 00:00:00 which is delayed")); } |
RollupBatchWriter { public synchronized void drainBatch() { List<SingleRollupWriteContext> writeBasicContexts = new ArrayList<SingleRollupWriteContext>(); List<SingleRollupWriteContext> writePreAggrContexts = new ArrayList<SingleRollupWriteContext>(); try { for (int i=0; i<=ROLLUP_BATCH_MAX_SIZE; i++) { SingleRollupWriteContext context = rollupQueue.remove(); if ( context.getRollup().getRollupType() == RollupType.BF_BASIC ) { writeBasicContexts.add(context); } else { writePreAggrContexts.add(context); } } } catch (NoSuchElementException e) { } if (writeBasicContexts.size() > 0) { LOG.debug( String.format("drainBatch(): kicking off RollupBatchWriteRunnables for %d basic contexts", writeBasicContexts.size())); executor.execute(new RollupBatchWriteRunnable(writeBasicContexts, context, basicMetricsRW)); } if (writePreAggrContexts.size() > 0) { LOG.debug( String.format("drainBatch(): kicking off RollupBatchWriteRunnables for %d preAggr contexts", writePreAggrContexts.size())); executor.execute(new RollupBatchWriteRunnable(writePreAggrContexts, context, preAggregatedRW)); } } RollupBatchWriter(ThreadPoolExecutor executor, RollupExecutionContext context); void enqueueRollupForWrite(SingleRollupWriteContext rollupWriteContext); synchronized void drainBatch(); } | @Test public void drainBatchWithNoItemsDoesNotTriggerBatching() { rbw.drainBatch(); verifyZeroInteractions(ctx); verifyZeroInteractions(executor); } |
Configuration { private Configuration() { try { init(); } catch (IOException ex) { throw new RuntimeException(ex); } } private Configuration(); static Configuration getInstance(); void loadDefaults(ConfigDefaults[] configDefaults); void init(); Map<Object,Object> getProperties(); Map<Object, Object> getAllProperties(); String getStringProperty(Enum<? extends ConfigDefaults> name); String getStringProperty(String name); String getRawStringProperty(Enum<? extends ConfigDefaults> name); String getRawStringProperty(String name); boolean containsKey(String key); int getIntegerProperty(Enum<? extends ConfigDefaults> name); int getIntegerProperty(String name); static int intFromString(String value); float getFloatProperty(Enum<? extends ConfigDefaults> name); float getFloatProperty(String name); static float floatFromString(String value); long getLongProperty(Enum<? extends ConfigDefaults> name); long getLongProperty(String name); static long longFromString(String value); boolean getBooleanProperty(Enum<? extends ConfigDefaults> name); boolean getBooleanProperty(String name); static boolean booleanFromString(String value); List<String> getListProperty(Enum<? extends ConfigDefaults> name); List<String> getListProperty(String name); static List<String> stringListFromString(String value); void setProperty(String name, String val); void setProperty(Enum<? extends ConfigDefaults> name, String value); void clearProperty(String name); void clearProperty(Enum<? extends ConfigDefaults> name); } | @Test public void testConfiguration() { try { Configuration config = Configuration.getInstance(); Map<Object, Object> properties = config.getProperties(); Assert.assertNotNull(properties); Assert.assertEquals("127.0.0.1:19180", config.getStringProperty(CoreConfig.CASSANDRA_HOSTS)); System.setProperty("CASSANDRA_HOSTS", "127.0.0.2"); Assert.assertEquals("127.0.0.2", config.getStringProperty(CoreConfig.CASSANDRA_HOSTS)); Assert.assertEquals(60000, config.getIntegerProperty(CoreConfig.SCHEDULE_POLL_PERIOD)); } finally { System.clearProperty("CASSANDRA_HOSTS"); } } |
Configuration { public static List<String> stringListFromString(String value) { List<String> list = Lists.newArrayList(value.split("\\s*,\\s*")); list.removeAll(Arrays.asList("", null)); return list; } private Configuration(); static Configuration getInstance(); void loadDefaults(ConfigDefaults[] configDefaults); void init(); Map<Object,Object> getProperties(); Map<Object, Object> getAllProperties(); String getStringProperty(Enum<? extends ConfigDefaults> name); String getStringProperty(String name); String getRawStringProperty(Enum<? extends ConfigDefaults> name); String getRawStringProperty(String name); boolean containsKey(String key); int getIntegerProperty(Enum<? extends ConfigDefaults> name); int getIntegerProperty(String name); static int intFromString(String value); float getFloatProperty(Enum<? extends ConfigDefaults> name); float getFloatProperty(String name); static float floatFromString(String value); long getLongProperty(Enum<? extends ConfigDefaults> name); long getLongProperty(String name); static long longFromString(String value); boolean getBooleanProperty(Enum<? extends ConfigDefaults> name); boolean getBooleanProperty(String name); static boolean booleanFromString(String value); List<String> getListProperty(Enum<? extends ConfigDefaults> name); List<String> getListProperty(String name); static List<String> stringListFromString(String value); void setProperty(String name, String val); void setProperty(Enum<? extends ConfigDefaults> name, String value); void clearProperty(String name); void clearProperty(Enum<? extends ConfigDefaults> name); } | @Test public void testMultipleCommaSeparatedItemsShouldYieldTheSameNumberOfElements() { String[] expected = { "a", "b", "c" }; List<String> actual = Configuration.stringListFromString("a,b,c"); Assert.assertArrayEquals(expected, actual.toArray()); }
@Test public void testWhitespaceBetweenElementsIsNotSignificant() { String[] expected = { "a", "b", "c" }; List<String> actual = Configuration.stringListFromString("a, b,c"); Assert.assertArrayEquals(expected, actual.toArray()); }
@Test public void testLeadingWhitespaceIsKept() { String[] expected = { " a", "b", "c" }; List<String> actual = Configuration.stringListFromString(" a,b,c"); Assert.assertArrayEquals(expected, actual.toArray()); }
@Test public void testTrailingWhitespaceIsKept() { String[] expected = { "a", "b", "c " }; List<String> actual = Configuration.stringListFromString("a,b,c "); Assert.assertArrayEquals(expected, actual.toArray()); }
@Test public void testConsecutiveCommasDontProduceEmptyElements() { String[] expected = { "a", "b", "c" }; List<String> actual = Configuration.stringListFromString("a,,,b,c"); Assert.assertArrayEquals(expected, actual.toArray()); } |
SlotStateSerDes { protected static int slotFromStateCol(String s) { return Integer.parseInt(s.split(",", -1)[1]); } static SlotState deserialize(String stateStr); String serialize(SlotState state); String serialize(Granularity gran, int slot, UpdateStamp.State state); } | @Test public void testSlotFromStateCol() { Assert.assertEquals(1, serDes.slotFromStateCol("metrics_full,1,okay")); } |
Configuration { public static boolean booleanFromString(String value) { return "true".equalsIgnoreCase(value); } private Configuration(); static Configuration getInstance(); void loadDefaults(ConfigDefaults[] configDefaults); void init(); Map<Object,Object> getProperties(); Map<Object, Object> getAllProperties(); String getStringProperty(Enum<? extends ConfigDefaults> name); String getStringProperty(String name); String getRawStringProperty(Enum<? extends ConfigDefaults> name); String getRawStringProperty(String name); boolean containsKey(String key); int getIntegerProperty(Enum<? extends ConfigDefaults> name); int getIntegerProperty(String name); static int intFromString(String value); float getFloatProperty(Enum<? extends ConfigDefaults> name); float getFloatProperty(String name); static float floatFromString(String value); long getLongProperty(Enum<? extends ConfigDefaults> name); long getLongProperty(String name); static long longFromString(String value); boolean getBooleanProperty(Enum<? extends ConfigDefaults> name); boolean getBooleanProperty(String name); static boolean booleanFromString(String value); List<String> getListProperty(Enum<? extends ConfigDefaults> name); List<String> getListProperty(String name); static List<String> stringListFromString(String value); void setProperty(String name, String val); void setProperty(Enum<? extends ConfigDefaults> name, String value); void clearProperty(String name); void clearProperty(Enum<? extends ConfigDefaults> name); } | @Test public void testNullShouldBeInterpretedAsBooleanFalse() { Assert.assertFalse(Configuration.booleanFromString(null)); }
@Test public void test_TRUE_ShouldBeInterpretedAsBooleanTrue() { Assert.assertTrue(Configuration.booleanFromString("TRUE")); } |
Configuration { public static int intFromString(String value) { return Integer.parseInt(value); } private Configuration(); static Configuration getInstance(); void loadDefaults(ConfigDefaults[] configDefaults); void init(); Map<Object,Object> getProperties(); Map<Object, Object> getAllProperties(); String getStringProperty(Enum<? extends ConfigDefaults> name); String getStringProperty(String name); String getRawStringProperty(Enum<? extends ConfigDefaults> name); String getRawStringProperty(String name); boolean containsKey(String key); int getIntegerProperty(Enum<? extends ConfigDefaults> name); int getIntegerProperty(String name); static int intFromString(String value); float getFloatProperty(Enum<? extends ConfigDefaults> name); float getFloatProperty(String name); static float floatFromString(String value); long getLongProperty(Enum<? extends ConfigDefaults> name); long getLongProperty(String name); static long longFromString(String value); boolean getBooleanProperty(Enum<? extends ConfigDefaults> name); boolean getBooleanProperty(String name); static boolean booleanFromString(String value); List<String> getListProperty(Enum<? extends ConfigDefaults> name); List<String> getListProperty(String name); static List<String> stringListFromString(String value); void setProperty(String name, String val); void setProperty(Enum<? extends ConfigDefaults> name, String value); void clearProperty(String name); void clearProperty(Enum<? extends ConfigDefaults> name); } | @Test public void testIntegerOneShouldBeInterpretedAsOne() { Assert.assertEquals(1, Configuration.intFromString("1")); }
@Test(expected=NumberFormatException.class) public void testIntegerLeadingWhitespaceShouldBeIgnored() { int value = Configuration.intFromString(" 1"); }
@Test(expected=NumberFormatException.class) public void testIntegerTrailingWhitespaceShouldBeIgnored() { int value = Configuration.intFromString("1 "); } |
Configuration { public static long longFromString(String value) { return Long.parseLong(value); } private Configuration(); static Configuration getInstance(); void loadDefaults(ConfigDefaults[] configDefaults); void init(); Map<Object,Object> getProperties(); Map<Object, Object> getAllProperties(); String getStringProperty(Enum<? extends ConfigDefaults> name); String getStringProperty(String name); String getRawStringProperty(Enum<? extends ConfigDefaults> name); String getRawStringProperty(String name); boolean containsKey(String key); int getIntegerProperty(Enum<? extends ConfigDefaults> name); int getIntegerProperty(String name); static int intFromString(String value); float getFloatProperty(Enum<? extends ConfigDefaults> name); float getFloatProperty(String name); static float floatFromString(String value); long getLongProperty(Enum<? extends ConfigDefaults> name); long getLongProperty(String name); static long longFromString(String value); boolean getBooleanProperty(Enum<? extends ConfigDefaults> name); boolean getBooleanProperty(String name); static boolean booleanFromString(String value); List<String> getListProperty(Enum<? extends ConfigDefaults> name); List<String> getListProperty(String name); static List<String> stringListFromString(String value); void setProperty(String name, String val); void setProperty(Enum<? extends ConfigDefaults> name, String value); void clearProperty(String name); void clearProperty(Enum<? extends ConfigDefaults> name); } | @Test public void testLongOneShouldBeInterpretedAsOne() { Assert.assertEquals(1L, Configuration.longFromString("1")); }
@Test(expected=NumberFormatException.class) public void testLongLeadingWhitespaceShouldBeRejected() { long value = Configuration.longFromString(" 1"); }
@Test(expected=NumberFormatException.class) public void testLongTrailingWhitespaceShouldBeRejected() { long value = Configuration.longFromString("1 "); } |
Configuration { public static float floatFromString(String value) { return Float.parseFloat(value); } private Configuration(); static Configuration getInstance(); void loadDefaults(ConfigDefaults[] configDefaults); void init(); Map<Object,Object> getProperties(); Map<Object, Object> getAllProperties(); String getStringProperty(Enum<? extends ConfigDefaults> name); String getStringProperty(String name); String getRawStringProperty(Enum<? extends ConfigDefaults> name); String getRawStringProperty(String name); boolean containsKey(String key); int getIntegerProperty(Enum<? extends ConfigDefaults> name); int getIntegerProperty(String name); static int intFromString(String value); float getFloatProperty(Enum<? extends ConfigDefaults> name); float getFloatProperty(String name); static float floatFromString(String value); long getLongProperty(Enum<? extends ConfigDefaults> name); long getLongProperty(String name); static long longFromString(String value); boolean getBooleanProperty(Enum<? extends ConfigDefaults> name); boolean getBooleanProperty(String name); static boolean booleanFromString(String value); List<String> getListProperty(Enum<? extends ConfigDefaults> name); List<String> getListProperty(String name); static List<String> stringListFromString(String value); void setProperty(String name, String val); void setProperty(Enum<? extends ConfigDefaults> name, String value); void clearProperty(String name); void clearProperty(Enum<? extends ConfigDefaults> name); } | @Test public void testFloatOneShouldBeInterpretedAsOne() { Assert.assertEquals(1.0f, Configuration.floatFromString("1"), 0.00001f); }
@Test public void testFloatExtendedFormat() { Assert.assertEquals(-1100.0f, Configuration.floatFromString("-1.1e3"), 0.00001f); }
@Test(expected=NumberFormatException.class) public void testFloatExtendedFormatSpaceBeforeDotIsInvalid() { Assert.assertEquals(-1100.0f, Configuration.floatFromString("-1 .1e3"), 0.00001f); }
@Test(expected=NumberFormatException.class) public void testFloatExtendedFormatSpaceAfterDotIsInvalid() { Assert.assertEquals(-1100.0f, Configuration.floatFromString("-1. 1e3"), 0.00001f); }
@Test(expected=NumberFormatException.class) public void testFloatExtendedFormatSpaceBeforeExponentMarkerIsInvalid() { Assert.assertEquals(-1100.0f, Configuration.floatFromString("-1.1 e3"), 0.00001f); }
@Test(expected=NumberFormatException.class) public void testFloatExtendedFormatSpaceAfterExponentMarkerIsInvalid() { Assert.assertEquals(-1100.0f, Configuration.floatFromString("-1.1e 3"), 0.00001f); }
@Test public void testFloatLeadingWhitespaceShouldBeIgnored() { Assert.assertEquals(1.0f, Configuration.floatFromString(" 1"), 0.00001f); }
@Test public void testFloatTrailingWhitespaceShouldBeIgnored() { Assert.assertEquals(1.0f, Configuration.floatFromString("1 "), 0.00001f); } |
SlotStateSerDes { protected static String stateCodeFromStateCol(String s) { return s.split(",", -1)[2]; } static SlotState deserialize(String stateStr); String serialize(SlotState state); String serialize(Granularity gran, int slot, UpdateStamp.State state); } | @Test public void testStateFromStateCol() { Assert.assertEquals("okay", serDes.stateCodeFromStateCol("metrics_full,1,okay")); } |
SlotState { public String toString() { return new StringBuilder().append(granularity == null ? "null" : granularity.name()) .append(",").append(slot) .append(",").append(state == null ? "null" : state.code()) .append(": ").append(getTimestamp() == null ? "" : getTimestamp()) .toString(); } SlotState(Granularity g, int slot, UpdateStamp.State state); SlotState(); SlotState withTimestamp(long timestamp); SlotState withLastUpdatedTimestamp(long lastUpdatedTimestamp); String toString(); boolean equals(Object other); Granularity getGranularity(); int getSlot(); UpdateStamp.State getState(); Long getTimestamp(); long getLastUpdatedTimestamp(); } | @Test public void testStringConversion() { Assert.assertEquals(s1 + ": ", ss1.toString()); Assert.assertEquals(s2 + ": " + time, ss2.toString()); Assert.assertEquals(s3 + ": " + time, ss3.toString()); } |
SlotState { public SlotState withTimestamp(long timestamp) { this.timestamp = timestamp; return this; } SlotState(Granularity g, int slot, UpdateStamp.State state); SlotState(); SlotState withTimestamp(long timestamp); SlotState withLastUpdatedTimestamp(long lastUpdatedTimestamp); String toString(); boolean equals(Object other); Granularity getGranularity(); int getSlot(); UpdateStamp.State getState(); Long getTimestamp(); long getLastUpdatedTimestamp(); } | @Test public void testEquality() { Assert.assertEquals(ss1, fromString(s1)); Assert.assertEquals(ss2, fromString(s2).withTimestamp(time)); Assert.assertEquals(new SlotState(Granularity.FULL, 1, UpdateStamp.State.Active), new SlotState(Granularity.FULL, 1, UpdateStamp.State.Running)); Assert.assertNotSame(new SlotState(Granularity.FULL, 1, UpdateStamp.State.Active), new SlotState(Granularity.FULL, 1, UpdateStamp.State.Rolled)); SlotState timestampedState = fromString(s1).withTimestamp(time); Assert.assertNotSame(timestampedState, fromString(s1)); } |
SlotState { public Granularity getGranularity() { return granularity; } SlotState(Granularity g, int slot, UpdateStamp.State state); SlotState(); SlotState withTimestamp(long timestamp); SlotState withLastUpdatedTimestamp(long lastUpdatedTimestamp); String toString(); boolean equals(Object other); Granularity getGranularity(); int getSlot(); UpdateStamp.State getState(); Long getTimestamp(); long getLastUpdatedTimestamp(); } | @Test public void testGranularity() { Assert.assertEquals(Granularity.FULL, fromString(s1).getGranularity()); Assert.assertNull(fromString("FULL,1,X").getGranularity()); } |
SlotStateSerDes { protected static UpdateStamp.State stateFromCode(String stateCode) { if (stateCode.equals(UpdateStamp.State.Rolled.code())) { return UpdateStamp.State.Rolled; } else { return UpdateStamp.State.Active; } } static SlotState deserialize(String stateStr); String serialize(SlotState state); String serialize(Granularity gran, int slot, UpdateStamp.State state); } | @Test public void testStateFromStateCode() { Assert.assertEquals(UpdateStamp.State.Active, serDes.stateFromCode("foo")); Assert.assertEquals(UpdateStamp.State.Active, serDes.stateFromCode("A")); Assert.assertEquals(UpdateStamp.State.Rolled, serDes.stateFromCode("X")); } |
BluefloodServiceStarter { public static void run() { Configuration config = Configuration.getInstance(); String log4jConfig = System.getProperty("log4j.configuration"); if (log4jConfig != null && log4jConfig.startsWith("file:")) { PropertyConfigurator.configureAndWatch(log4jConfig.substring("file:".length()), 5000); } validateCassandraHosts(); boolean usePersistedCache = Configuration.getInstance().getBooleanProperty(CoreConfig.METADATA_CACHE_PERSISTENCE_ENABLED); if (usePersistedCache) { String path = Configuration.getInstance().getStringProperty(CoreConfig.METADATA_CACHE_PERSISTENCE_PATH); final File cacheLocation = new File(path); if (cacheLocation.exists()) { try { DataInputStream in = new DataInputStream(new FileInputStream(cacheLocation)); MetadataCache.getInstance().load(in); in.close(); } catch (IOException ex) { log.error(ex.getMessage(), ex); } } else { log.info("Wanted to load metadata cache, but it did not exist: " + path); } Timer cachePersistenceTimer = new Timer("Metadata-Cache-Persistence"); int savePeriodMins = Configuration.getInstance().getIntegerProperty(CoreConfig.METADATA_CACHE_PERSISTENCE_PERIOD_MINS); cachePersistenceTimer.schedule(new TimerTask() { @Override public void run() { try { DataOutputStream out = new DataOutputStream(new FileOutputStream(cacheLocation, false)); MetadataCache.getInstance().save(out); out.close(); } catch (IOException ex) { log.error(ex.getMessage(), ex); } } }, TimeUnit.MINUTES.toMillis(savePeriodMins), TimeUnit.MINUTES.toMillis(savePeriodMins)); } new RestartGauge(getRegistry(), RollupService.class); final Collection<Integer> shards = Collections.unmodifiableCollection( Util.parseShards(config.getStringProperty(CoreConfig.SHARDS))); final String zkCluster = config.getStringProperty(CoreConfig.ZOOKEEPER_CLUSTER); final boolean rollupMode = config.getBooleanProperty(CoreConfig.ROLLUP_MODE); final ScheduleContext rollupContext = !"NONE".equals(zkCluster) && rollupMode ? new ScheduleContext(System.currentTimeMillis(), shards, zkCluster) : new ScheduleContext(System.currentTimeMillis(), shards); log.info("Starting blueflood services"); startShardStateServices(rollupContext); startIngestServices(rollupContext); startQueryServices(); startRollupService(rollupContext); startEventListenerModules(); log.info("All blueflood services started"); } static void validateCassandraHosts(); static void main(String args[]); static void run(); static MetricRegistry getRegistry(); } | @Test public void testAllModesDisabled() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.INGEST_MODE, "false"); config.setProperty(CoreConfig.QUERY_MODE, "false"); config.setProperty(CoreConfig.ROLLUP_MODE, "false"); BluefloodServiceStarter.run(); }
@Test(expected = BluefloodServiceStarterException.class) public void testIngestModeEnabledWithoutModules() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.INGEST_MODE, "true"); config.setProperty(CoreConfig.INGESTION_MODULES, ""); BluefloodServiceStarter.run(); }
@Test public void testIngestModeEnabledWithModules() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.INGEST_MODE, "true"); config.setProperty(CoreConfig.INGESTION_MODULES, "com.rackspacecloud.blueflood.service.DummyIngestionService"); BluefloodServiceStarter.run(); assertNotNull(DummyIngestionService.getInstances()); assertEquals(1, DummyIngestionService.getInstances().size()); assertNotNull(DummyIngestionService.getMostRecentInstance()); assertTrue(DummyIngestionService.getMostRecentInstance().getStartServiceCalled()); assertFalse(DummyIngestionService.getMostRecentInstance().getShutdownServiceCalled()); }
@Test(expected = BluefloodServiceStarterException.class) public void testQueryModeEnabledWithoutModules() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.QUERY_MODE, "true"); config.setProperty(CoreConfig.QUERY_MODULES, ""); BluefloodServiceStarter.run(); }
@Test public void testQueryModeEnabledWithDummyModule() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.QUERY_MODE, "true"); config.setProperty(CoreConfig.QUERY_MODULES, "com.rackspacecloud.blueflood.service.DummyQueryService"); BluefloodServiceStarter.run(); assertNotNull(DummyQueryService.getInstances()); assertEquals(1, DummyQueryService.getInstances().size()); assertNotNull(DummyQueryService.getMostRecentInstance()); assertTrue(DummyQueryService.getMostRecentInstance().getStartServiceCalled()); }
@Test public void testRollupModeEnabled() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.ROLLUP_MODE, "true"); BluefloodServiceStarter.run(); }
@Test public void testEventListenerServiceEnabledWithDummyModule() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.EVENT_LISTENER_MODULES, "com.rackspacecloud.blueflood.service.DummyEventListenerService"); BluefloodServiceStarter.run(); assertNotNull(DummyEventListenerService.getInstances()); assertEquals(1, DummyEventListenerService.getInstances().size()); assertNotNull(DummyEventListenerService.getMostRecentInstance()); assertTrue(DummyEventListenerService.getMostRecentInstance().getStartServiceCalled()); } |
BluefloodServiceStarter { public static void validateCassandraHosts() { String hosts = Configuration.getInstance().getStringProperty(CoreConfig.CASSANDRA_HOSTS); if (!(hosts.length() >= 3)) { log.error("No cassandra hosts found in configuration option 'CASSANDRA_HOSTS'"); throw new BluefloodServiceStarterException(-1, "No cassandra hosts found in configuration option 'CASSANDRA_HOSTS'"); } for (String host : hosts.split(",")) { if (!host.matches("[\\d\\w\\.\\-_]+:\\d+")) { log.error("Invalid Cassandra host found in Configuration option 'CASSANDRA_HOSTS' -- Should be of the form <hostname>:<port>"); throw new BluefloodServiceStarterException(-1, "Invalid Cassandra host found in Configuration option 'CASSANDRA_HOSTS' -- Should be of the form <hostname>:<port>"); } } } static void validateCassandraHosts(); static void main(String args[]); static void run(); static MetricRegistry getRegistry(); } | @Test(expected = BluefloodServiceStarterException.class) public void testNoCassandraHostsFailsValidation() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.CASSANDRA_HOSTS, ""); BluefloodServiceStarter.validateCassandraHosts(); }
@Test(expected = BluefloodServiceStarterException.class) public void testInvalidCassandraHostsFailsValidation() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.CASSANDRA_HOSTS, "something"); BluefloodServiceStarter.validateCassandraHosts(); }
@Test(expected = BluefloodServiceStarterException.class) public void testCassandraHostWithoutPortFailsValidation() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.CASSANDRA_HOSTS, "127.0.0.1"); BluefloodServiceStarter.validateCassandraHosts(); }
@Test public void testCassandraHostWithHyphenSucceedsValidation() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.CASSANDRA_HOSTS, "my-hostname:9160"); BluefloodServiceStarter.validateCassandraHosts(); }
@Test public void testCassandraHostWithUnderscoreSucceedsValidation() { Configuration config = Configuration.getInstance(); config.setProperty(CoreConfig.CASSANDRA_HOSTS, "my_hostname:9160"); BluefloodServiceStarter.validateCassandraHosts(); } |
SearchResult { public boolean equals(Object obj) { if (this == obj) { return true; } else if (obj == null) { return false; } else if (!getClass().equals(obj.getClass())) { return false; } return equals((SearchResult) obj); } SearchResult(String tenantId, String name, String unit); String getTenantId(); String getMetricName(); String getUnit(); @Override String toString(); @Override int hashCode(); boolean equals(Object obj); boolean equals(SearchResult other); } | @Test public void testEquals() { SearchResult result1 = new SearchResult(TENANT_ID, METRIC_NAME, null); SearchResult result2 = new SearchResult(TENANT_ID, METRIC_NAME, null); Assert.assertTrue("result1 should equal self", result1.equals(result1)); Assert.assertTrue("result1 should equal result2", result1.equals(result2)); Assert.assertTrue("result1 should not equal null", !result1.equals(null)); String METRIC_NAME2 = "metric2"; SearchResult result3 = new SearchResult(TENANT_ID, METRIC_NAME2, UNIT); SearchResult result4 = new SearchResult(TENANT_ID, METRIC_NAME2, UNIT); Assert.assertTrue("result3 should equal result4", result3.equals(result4)); Assert.assertTrue("result1 should not equal result3", !result1.equals(result3)); } |
ShardStateManager { public void updateSlotOnRead(int shard, SlotState slotState) { getSlotStateManager(shard, slotState.getGranularity()).updateSlotOnRead(slotState); } protected ShardStateManager(Collection<Integer> shards, Ticker ticker); protected ShardStateManager(Collection<Integer> shards, Ticker ticker, Clock clock); SlotStateManager getSlotStateManager(int shard, Granularity granularity); void updateSlotOnRead(int shard, SlotState slotState); void setAllCoarserSlotsDirtyForSlot(SlotKey slotKey); static final long REROLL_TIME_SPAN_ASSUMED_VALUE; } | @Test public void testUpdateSlotsOnReadWithIncomingActiveState() { establishCurrentState(); final long lastRollupTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastRollupTimestamp(); final long lastCollectionTime = System.currentTimeMillis(); final long lastUpdatedTime = System.currentTimeMillis(); SlotState newUpdateForActiveSlot = createSlotState(Granularity.MIN_5, UpdateStamp.State.Active, lastCollectionTime, lastUpdatedTime); slotStateManager.updateSlotOnRead(newUpdateForActiveSlot); Map<Integer, UpdateStamp> slotStamps = slotStateManager.getSlotStamps(); UpdateStamp updateStamp = slotStamps.get(TEST_SLOT); assertEquals("Unexpected state", UpdateStamp.State.Active, updateStamp.getState()); assertEquals("Last collection timestamp is incorrect", lastCollectionTime, updateStamp.getTimestamp()); assertEquals("Last rollup timestamp is incorrect", lastRollupTime, updateStamp.getLastRollupTimestamp()); assertEquals("Last ingest timestamp is incorrect", lastUpdatedTime, updateStamp.getLastIngestTimestamp()); }
@Test public void testUpdateSlotsOnReadWithIncomingActiveStateButOlderData() { establishCurrentState(); final long lastRollupTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastRollupTimestamp(); final long existingLastCollectionTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getTimestamp(); final long existingLastIngestTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastIngestTimestamp(); long lastCollectionTime = existingLastCollectionTime - 60 * 1000; long lastUpdatedTime = System.currentTimeMillis(); SlotState newUpdateForActiveSlot = createSlotState(Granularity.MIN_5, UpdateStamp.State.Active, lastCollectionTime, lastUpdatedTime); slotStateManager.updateSlotOnRead(newUpdateForActiveSlot); Map<Integer, UpdateStamp> slotStamps = slotStateManager.getSlotStamps(); UpdateStamp updateStamp = slotStamps.get(TEST_SLOT); assertEquals("Unexpected state", UpdateStamp.State.Active, updateStamp.getState()); assertEquals("Last collection timestamp is incorrect", existingLastCollectionTime, updateStamp.getTimestamp()); assertEquals("Last rollup timestamp is incorrect", lastRollupTime, updateStamp.getLastRollupTimestamp()); assertEquals("Dirty flag is incorrect", true, updateStamp.isDirty()); assertEquals("Last ingest timestamp is incorrect", existingLastIngestTime, updateStamp.getLastIngestTimestamp()); }
@Test public void testUpdateSlotsOnReadWithIncomingActiveStateButInMemoryDirtyData() { establishCurrentState(); final long lastRollupTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastRollupTimestamp(); final long existingLastCollectionTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getTimestamp(); final long existingLastIngestTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastIngestTimestamp(); slotStateManager.getSlotStamps().get(TEST_SLOT).setDirty(true); long lastCollectionTime = existingLastCollectionTime + 60 * 1000; long lastUpdatedTime = System.currentTimeMillis(); SlotState newUpdateForActiveSlot = createSlotState(Granularity.MIN_5, UpdateStamp.State.Active, lastCollectionTime, lastUpdatedTime); slotStateManager.updateSlotOnRead(newUpdateForActiveSlot); Map<Integer, UpdateStamp> slotStamps = slotStateManager.getSlotStamps(); UpdateStamp updateStamp = slotStamps.get(TEST_SLOT); assertEquals("Unexpected state", UpdateStamp.State.Active, updateStamp.getState()); assertEquals("Last collection timestamp is incorrect", existingLastCollectionTime, updateStamp.getTimestamp()); assertEquals("Last rollup timestamp is incorrect", lastRollupTime, updateStamp.getLastRollupTimestamp()); assertEquals("Dirty flag is incorrect", true, updateStamp.isDirty()); assertEquals("Last ingest timestamp is incorrect", existingLastIngestTime, updateStamp.getLastIngestTimestamp()); }
@Test public void testUpdateSlotsOnReadIncomingRolledStateSameTimestamp() { establishCurrentState(); final long existingLastCollectionTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getTimestamp(); final long existingLastIngestTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastIngestTimestamp(); final long newRolledSlotLastUpdatedTime = System.currentTimeMillis(); SlotState newUpdateForActiveSlot = createSlotState(Granularity.MIN_5, UpdateStamp.State.Rolled, existingLastCollectionTime, newRolledSlotLastUpdatedTime); slotStateManager.updateSlotOnRead(newUpdateForActiveSlot); Map<Integer, UpdateStamp> slotStamps = slotStateManager.getSlotStamps(); UpdateStamp updateStamp = slotStamps.get(TEST_SLOT); assertEquals("Unexpected state", UpdateStamp.State.Rolled, updateStamp.getState()); assertEquals("Last collection timestamp is incorrect", existingLastCollectionTime, updateStamp.getTimestamp()); assertEquals("Last rollup timestamp is incorrect", newRolledSlotLastUpdatedTime, updateStamp.getLastRollupTimestamp()); assertEquals("Last ingest timestamp is incorrect", existingLastIngestTime, updateStamp.getLastIngestTimestamp()); }
@Test public void testUpdateSlotsOnReadIncomingRolledStateDifferentTimestamp() { establishCurrentState(); final long existingLastCollectionTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getTimestamp(); final long existingLastIngestTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastIngestTimestamp(); final long newLastRolledCollectionTime = existingLastCollectionTime - 1; final long newRolledSlotLastUpdatedTime = System.currentTimeMillis(); SlotState newUpdateForActiveSlot = createSlotState(Granularity.MIN_5, UpdateStamp.State.Rolled, newLastRolledCollectionTime, newRolledSlotLastUpdatedTime); slotStateManager.updateSlotOnRead(newUpdateForActiveSlot); Map<Integer, UpdateStamp> slotStamps = slotStateManager.getSlotStamps(); UpdateStamp updateStamp = slotStamps.get(TEST_SLOT); assertEquals("Unexpected state", UpdateStamp.State.Active, updateStamp.getState()); assertEquals("Last collection timestamp is incorrect", existingLastCollectionTime, updateStamp.getTimestamp()); assertEquals("Last rollup timestamp is incorrect", newRolledSlotLastUpdatedTime, updateStamp.getLastRollupTimestamp()); assertEquals("Last ingest timestamp is incorrect", existingLastIngestTime, updateStamp.getLastIngestTimestamp()); }
@Test public void testUpdateSlotsOnReadIncomingOldRolledState() { establishCurrentState(); final long existingLastCollectionTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getTimestamp(); final long existingLastRollupTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastRollupTimestamp(); final long existingLastIngestTime = slotStateManager.getSlotStamps().get(TEST_SLOT).getLastIngestTimestamp(); final long oldLastRolledCollectionTime = existingLastCollectionTime - 1; final long oldRolledSlotLastUpdatedTime = System.currentTimeMillis() - 14 * 24 * 60 * 60 * 1000; SlotState newUpdateForActiveSlot = createSlotState(Granularity.MIN_5, UpdateStamp.State.Rolled, oldLastRolledCollectionTime, oldRolledSlotLastUpdatedTime); slotStateManager.updateSlotOnRead(newUpdateForActiveSlot); Map<Integer, UpdateStamp> slotStamps = slotStateManager.getSlotStamps(); UpdateStamp updateStamp = slotStamps.get(TEST_SLOT); assertEquals("Unexpected state", UpdateStamp.State.Active, updateStamp.getState()); assertEquals("Last collection timestamp is incorrect", existingLastCollectionTime, updateStamp.getTimestamp()); assertEquals("Last rollup timestamp is incorrect", existingLastRollupTime, updateStamp.getLastRollupTimestamp()); assertEquals("Last ingest timestamp is incorrect", existingLastIngestTime, updateStamp.getLastIngestTimestamp()); } |
RollupBatchWriteRunnable implements Runnable { @Override public void run() { Timer.Context ctx = batchWriteTimer.time(); try { metricsRW.insertRollups(writeContexts); } catch (Exception e) { LOG.warn("not able to insert rollups", e); executionContext.markUnsuccessful(e); } finally { executionContext.decrementWriteCounter(writeContexts.size()); rollupsPerBatch.update(writeContexts.size()); rollupsWriteRate.mark(writeContexts.size()); RollupService.lastRollupTime.set(System.currentTimeMillis()); ctx.stop(); } } RollupBatchWriteRunnable(List<SingleRollupWriteContext> writeContexts,
RollupExecutionContext executionContext,
AbstractMetricsRW metricsRW); @Override void run(); } | @Test public void runSendsRollupsToWriterAndDecrementsCount() throws Exception { final AtomicLong decrementCount = new AtomicLong(0); Answer contextAnswer = new Answer() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { decrementCount.set((Long)invocation.getArguments()[0]); return null; } }; doAnswer(contextAnswer).when(ctx).decrementWriteCounter(anyLong()); final Object[] insertRollupsArg = new Object[1]; Answer writerAnswer = new Answer() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { insertRollupsArg[0] = invocation.getArguments()[0]; return null; } }; doAnswer(writerAnswer).when(writer).insertRollups( Matchers.<ArrayList<SingleRollupWriteContext>>any()); rbwr.run(); verify(writer).insertRollups(Matchers.<ArrayList<SingleRollupWriteContext>>any()); assertSame(wcs, insertRollupsArg[0]); verifyNoMoreInteractions(writer); verify(ctx).decrementWriteCounter(anyLong()); assertEquals(wcs.size(), decrementCount.get()); verifyNoMoreInteractions(ctx); }
@Test public void connectionExceptionMarksUnsuccessful() throws Exception { Throwable cause = new IOException("exception for testing purposes") { }; doThrow(cause).when(writer).insertRollups( Matchers.<ArrayList<SingleRollupWriteContext>>any()); rbwr.run(); verify(writer).insertRollups(Matchers.<ArrayList<SingleRollupWriteContext>>any()); verifyNoMoreInteractions(writer); verify(ctx).markUnsuccessful(Matchers.<Throwable>any()); verify(ctx).decrementWriteCounter(anyLong()); verifyNoMoreInteractions(ctx); } |
RetryNTimes implements RetryPolicy { @Override public RetryDecision onReadTimeout(Statement stmnt, ConsistencyLevel cl, int requiredResponses, int receivedResponses, boolean dataReceived, int rTime) { if (dataReceived) { return RetryDecision.ignore(); } else if (rTime < readAttempts) { LOG.info(String.format("Retrying on ReadTimeout: stmnt %s, " + "consistency %s, requiredResponse %d, " + "receivedResponse %d, dataReceived %s, rTime %d", stmnt, cl, requiredResponses, receivedResponses, dataReceived, rTime)); return RetryDecision.retry(cl); } else { return RetryDecision.rethrow(); } } RetryNTimes(int readAttempts, int writeAttempts, int unavailableAttempts); @Override RetryDecision onReadTimeout(Statement stmnt, ConsistencyLevel cl,
int requiredResponses, int receivedResponses,
boolean dataReceived, int rTime); @Override RetryDecision onWriteTimeout(Statement stmnt, ConsistencyLevel cl,
WriteType wt, int requiredResponses,
int receivedResponses, int wTime); @Override RetryDecision onUnavailable(Statement stmnt, ConsistencyLevel cl,
int requiredResponses, int receivedResponses, int uTime); @Override RetryDecision onRequestError(Statement statement, ConsistencyLevel cl, DriverException e, int nbRetry); @Override void init(Cluster cluster); @Override void close(); } | @Test public void firstTimeRetryOnReadTimeout_shouldRetry() throws Exception { RetryNTimes retryPolicy = new RetryNTimes(3, 3, 3); Statement mockStatement = mock( Statement.class ); RetryPolicy.RetryDecision retryResult = retryPolicy.onReadTimeout(mockStatement, ConsistencyLevel.LOCAL_ONE, 1, 0, false, 0); RetryPolicy.RetryDecision retryExpected = RetryPolicy.RetryDecision.retry(ConsistencyLevel.LOCAL_ONE); assertRetryDecisionEquals(retryExpected, retryResult); }
@Test public void maxTimeRetryOnReadTimeout_shouldRethrow() throws Exception { RetryNTimes retryPolicy = new RetryNTimes(3, 3, 3); Statement mockStatement = mock( Statement.class ); RetryPolicy.RetryDecision retryResult = retryPolicy.onReadTimeout(mockStatement, ConsistencyLevel.LOCAL_ONE, 1, 0, false, 3); RetryPolicy.RetryDecision retryExpected = RetryPolicy.RetryDecision.rethrow(); assertRetryDecisionEquals(retryExpected, retryResult); } |
LocatorFetchRunnable implements Runnable { public void executeRollupForLocator(RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator) { executionContext.incrementReadCounter(); final SingleRollupReadContext singleRollupReadContext = new SingleRollupReadContext(locator, parentRange, getGranularity()); RollupRunnable rollupRunnable = new RollupRunnable(executionContext, singleRollupReadContext, rollupBatchWriter); rollupReadExecutor.execute(rollupRunnable); } LocatorFetchRunnable(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); @VisibleForTesting void initialize(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); void run(); void drainExecutionContext(long waitStart, int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter); void finishExecution(long waitStart, RollupExecutionContext executionContext); int processLocator(int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); void executeRollupForLocator(RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); Set<Locator> getDelayedLocators(RollupExecutionContext executionContext, SlotKey slotkey); Set<Locator> getLocators(RollupExecutionContext executionContext); } | @Test public void executeRollupForLocatorTriggersExecutionOfRollupRunnable() { lfr.executeRollupForLocator(executionContext, rollupBatchWriter, locators.get(0)); verify(rollupReadExecutor, times(1)).execute(Matchers.<RollupRunnable>any()); verifyNoMoreInteractions(rollupReadExecutor); verify(executionContext, times(1)).incrementReadCounter(); verifyNoMoreInteractions(executionContext); verifyZeroInteractions(rollupBatchWriter); } |
LocatorFetchRunnable implements Runnable { public int processLocator(int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator) { if (log.isTraceEnabled()) log.trace("Rolling up (check,metric,dimension) {} for (gran,slot,shard) {}", locator, parentSlotKey); try { executeRollupForLocator(executionContext, rollupBatchWriter, locator); rollCount += 1; } catch (Throwable any) { executionContext.markUnsuccessful(any); executionContext.decrementReadCounter(); log.error(String.format( "BasicRollup failed for %s, locator %s, at %d", parentSlotKey, locator, serverTime), any); } return rollCount; } LocatorFetchRunnable(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); @VisibleForTesting void initialize(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); void run(); void drainExecutionContext(long waitStart, int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter); void finishExecution(long waitStart, RollupExecutionContext executionContext); int processLocator(int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); void executeRollupForLocator(RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); Set<Locator> getDelayedLocators(RollupExecutionContext executionContext, SlotKey slotkey); Set<Locator> getLocators(RollupExecutionContext executionContext); } | @Test public void processLocatorTriggersRunnable() { int count = lfr.processLocator(0, executionContext, rollupBatchWriter, locators.get(0)); Assert.assertEquals(1, count); verify(executionContext, never()).markUnsuccessful(Matchers.<Throwable>any()); verify(executionContext, never()).decrementReadCounter(); }
@Test public void processLocatorIncrementsCount() { int count = lfr.processLocator(1, executionContext, rollupBatchWriter, locators.get(0)); Assert.assertEquals(2, count); verify(executionContext, never()).markUnsuccessful(Matchers.<Throwable>any()); verify(executionContext, never()).decrementReadCounter(); }
@Test public void processLocatorExceptionCausesRollupToFail() { Throwable cause = new UnsupportedOperationException("exception for testing purposes"); doThrow(cause).when(rollupReadExecutor).execute(Matchers.<Runnable>any()); int count = lfr.processLocator(0, executionContext, rollupBatchWriter, locators.get(0)); Assert.assertEquals(0, count); verify(executionContext, times(1)).markUnsuccessful(Matchers.<Throwable>any()); verify(executionContext, times(1)).decrementReadCounter(); } |
LocatorFetchRunnable implements Runnable { public void finishExecution(long waitStart, RollupExecutionContext executionContext) { if (executionContext.wasSuccessful()) { this.scheduleCtx.clearFromRunning(parentSlotKey); log.info("Successful completion of rollups for (gran,slot,shard) {} in {} ms", new Object[]{parentSlotKey, System.currentTimeMillis() - waitStart}); } else { log.error("Performing BasicRollups for {} failed", parentSlotKey); this.scheduleCtx.pushBackToScheduled(parentSlotKey, false); } } LocatorFetchRunnable(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); @VisibleForTesting void initialize(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); void run(); void drainExecutionContext(long waitStart, int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter); void finishExecution(long waitStart, RollupExecutionContext executionContext); int processLocator(int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); void executeRollupForLocator(RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); Set<Locator> getDelayedLocators(RollupExecutionContext executionContext, SlotKey slotkey); Set<Locator> getLocators(RollupExecutionContext executionContext); } | @Test public void finishExecutionWhenSuccessful() { when(executionContext.wasSuccessful()).thenReturn(true); lfr.finishExecution(0, executionContext); verify(executionContext, times(1)).wasSuccessful(); verifyNoMoreInteractions(executionContext); verify(scheduleCtx, times(1)).clearFromRunning(Matchers.<SlotKey>any()); verify(scheduleCtx).getCurrentTimeMillis(); verifyNoMoreInteractions(scheduleCtx); }
@Test public void finishExecutionWhenNotSuccessful() { when(executionContext.wasSuccessful()).thenReturn(false); lfr.finishExecution(0, executionContext); verify(executionContext, times(1)).wasSuccessful(); verifyNoMoreInteractions(executionContext); verify(scheduleCtx, times(1)).pushBackToScheduled(Matchers.<SlotKey>any(), eq(false)); verify(scheduleCtx).getCurrentTimeMillis(); verifyNoMoreInteractions(scheduleCtx); } |
LocatorFetchRunnable implements Runnable { protected RollupExecutionContext createRollupExecutionContext() { return new RollupExecutionContext(Thread.currentThread()); } LocatorFetchRunnable(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); @VisibleForTesting void initialize(ScheduleContext scheduleCtx,
SlotKey destSlotKey,
ExecutorService rollupReadExecutor,
ThreadPoolExecutor rollupWriteExecutor); void run(); void drainExecutionContext(long waitStart, int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter); void finishExecution(long waitStart, RollupExecutionContext executionContext); int processLocator(int rollCount, RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); void executeRollupForLocator(RollupExecutionContext executionContext, RollupBatchWriter rollupBatchWriter, Locator locator); Set<Locator> getDelayedLocators(RollupExecutionContext executionContext, SlotKey slotkey); Set<Locator> getLocators(RollupExecutionContext executionContext); } | @Test public void createRollupExecutionContextReturnsValidObject() { RollupExecutionContext execCtx = lfr.createRollupExecutionContext(); assertNotNull(execCtx); } |
MavenRepositories { public static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings) { Set<RemoteRepository> remoteRepos = new HashSet<>(); remoteRepos.addAll(container.getEnabledRepositoriesFromProfile(settings)); String centralRepoURL = getCentralMirrorURL(settings).orElse(MAVEN_CENTRAL_REPO); remoteRepos.add(convertToMavenRepo("central", centralRepoURL, settings)); return new ArrayList<>(remoteRepos); } static List<RemoteRepository> getRemoteRepositories(MavenContainer container, Settings settings); } | @Test public void testMirrorCentralWithoutProfiles() throws Exception { SettingsBuilder settingsBuilder = new DefaultSettingsBuilderFactory().newInstance(); SettingsBuildingRequest settingsRequest = new DefaultSettingsBuildingRequest(); settingsRequest.setUserSettingsFile(new File("src/test/resources/profiles/mirror-settings.xml")); Settings settings = settingsBuilder.build(settingsRequest).getEffectiveSettings(); MavenContainer container = new MavenContainer(); List<RemoteRepository> remoteRepositories = MavenRepositories.getRemoteRepositories(container, settings); Assert.assertThat(remoteRepositories.size(), equalTo(1)); Assert.assertThat(remoteRepositories.get(0).getId(), equalTo("central")); Assert.assertThat(remoteRepositories.get(0).getUrl(), equalTo("http: }
@Test public void testCentralWithProfiles() throws Exception { SettingsBuilder settingsBuilder = new DefaultSettingsBuilderFactory().newInstance(); SettingsBuildingRequest settingsRequest = new DefaultSettingsBuildingRequest(); settingsRequest.setUserSettingsFile(new File("src/test/resources/profiles/settings.xml")); Settings settings = settingsBuilder.build(settingsRequest).getEffectiveSettings(); MavenContainer container = new MavenContainer(); List<RemoteRepository> remoteRepositories = MavenRepositories.getRemoteRepositories(container, settings); Assert.assertEquals(2, remoteRepositories.size()); Assert.assertEquals("test-repository", remoteRepositories.get(1).getId()); List<RemoteRepository> centralRepos = remoteRepositories.stream().filter(repo -> repo.getId().equals("central")).collect(Collectors.toList()); Assert.assertEquals(1, centralRepos.size()); Assert.assertEquals(MavenRepositories.MAVEN_CENTRAL_REPO, centralRepos.get(0).getUrl()); } |
Versions { public static VersionRange parseVersionRange(String range) throws VersionException { Assert.notNull(range, "Version range must not be null."); boolean lowerBoundInclusive = range.startsWith("["); boolean upperBoundInclusive = range.endsWith("]"); String process = range.substring(1, range.length() - 1).trim(); VersionRange result; int index = process.indexOf(","); if (index < 0) { if (!lowerBoundInclusive || !upperBoundInclusive) { throw new VersionException("Single version must be surrounded by []: " + range); } Version version = SingleVersion.valueOf(process); result = new DefaultVersionRange(version, lowerBoundInclusive, version, upperBoundInclusive); } else { String lowerBound = process.substring(0, index).trim(); String upperBound = process.substring(index + 1).trim(); if (lowerBound.equals(upperBound)) { throw new VersionException("Range cannot have identical boundaries: " + range); } Version lowerVersion = null; if (lowerBound.length() > 0) { lowerVersion = SingleVersion.valueOf(lowerBound); } Version upperVersion = null; if (upperBound.length() > 0) { upperVersion = SingleVersion.valueOf(upperBound); } if (upperVersion != null && lowerVersion != null && upperVersion.compareTo(lowerVersion) < 0) { throw new VersionException("Range defies version ordering: " + range); } result = new DefaultVersionRange(lowerVersion, lowerBoundInclusive, upperVersion, upperBoundInclusive); } return result; } static boolean isApiCompatible(Version runtimeVersion, Version addonApiVersion); static VersionRange parseVersionRange(String range); static MultipleVersionRange parseMultipleVersionRange(String intersection); static VersionRange intersection(VersionRange... ranges); static VersionRange intersection(Collection<VersionRange> ranges); static boolean isSnapshot(Version version); static Version getSpecificationVersionFor(Class<?> type); static Version getImplementationVersionFor(Class<?> type); } | @Test public void testVersionRangeSame() throws Exception { VersionRange range = Versions.parseVersionRange("[7]"); Assert.assertEquals(SingleVersion.valueOf("7"), range.getMin()); Assert.assertEquals(SingleVersion.valueOf("7"), range.getMax()); Assert.assertEquals("[7]", range.toString()); }
@Test public void testParseVersionRange() throws Exception { VersionRange range = Versions.parseVersionRange("[0,15]"); Assert.assertEquals(SingleVersion.valueOf("0"), range.getMin()); Assert.assertEquals(SingleVersion.valueOf("15"), range.getMax()); Assert.assertTrue(range.isMinInclusive()); Assert.assertTrue(range.isMaxInclusive()); } |
Versions { public static boolean isSnapshot(Version version) { Assert.notNull(version, "Version must not be null."); return version.toString().endsWith(SNAPSHOT_SUFFIX); } static boolean isApiCompatible(Version runtimeVersion, Version addonApiVersion); static VersionRange parseVersionRange(String range); static MultipleVersionRange parseMultipleVersionRange(String intersection); static VersionRange intersection(VersionRange... ranges); static VersionRange intersection(Collection<VersionRange> ranges); static boolean isSnapshot(Version version); static Version getSpecificationVersionFor(Class<?> type); static Version getImplementationVersionFor(Class<?> type); } | @Test public void testVersionSnapshot() throws Exception { Version nonSnapshot = SingleVersion.valueOf("1.1.1"); Assert.assertFalse(Versions.isSnapshot(nonSnapshot)); Version snapshot = SingleVersion.valueOf("1.1.1-SNAPSHOT"); Assert.assertTrue(Versions.isSnapshot(snapshot)); } |
Versions { public static boolean isApiCompatible(Version runtimeVersion, Version addonApiVersion) { if (addonApiVersion == null || addonApiVersion.toString().length() == 0 || runtimeVersion == null || runtimeVersion.toString().length() == 0) return true; int runtimeMajorVersion = runtimeVersion.getMajorVersion(); int runtimeMinorVersion = runtimeVersion.getMinorVersion(); int addonApiMajorVersion = addonApiVersion.getMajorVersion(); int addonApiMinorVersion = addonApiVersion.getMinorVersion(); return (addonApiMajorVersion == runtimeMajorVersion && addonApiMinorVersion <= runtimeMinorVersion); } static boolean isApiCompatible(Version runtimeVersion, Version addonApiVersion); static VersionRange parseVersionRange(String range); static MultipleVersionRange parseMultipleVersionRange(String intersection); static VersionRange intersection(VersionRange... ranges); static VersionRange intersection(Collection<VersionRange> ranges); static boolean isSnapshot(Version version); static Version getSpecificationVersionFor(Class<?> type); static Version getImplementationVersionFor(Class<?> type); } | @Test public void testIsApiCompatible0() throws Exception { Assert.assertTrue(Versions.isApiCompatible( SingleVersion.valueOf("2.18.2-SNAPSHOT"), SingleVersion.valueOf("2.16.1.Final"))); }
@Test public void testIsApiCompatible1() throws Exception { Assert.assertTrue(Versions.isApiCompatible( SingleVersion.valueOf("2.18.2.Final"), SingleVersion.valueOf("2.16.1.Final"))); } |
SingleVersion implements Version { public static final SingleVersion valueOf(String version) { SingleVersion singleVersion = CACHE.get(version); if (singleVersion == null) { singleVersion = new SingleVersion(version); CACHE.put(version, singleVersion); } return singleVersion; } @Deprecated SingleVersion(String version); static final SingleVersion valueOf(String version); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(Version otherVersion); @Override int getMajorVersion(); @Override int getMinorVersion(); @Override int getIncrementalVersion(); @Override int getBuildNumber(); @Override String getQualifier(); @Override String toString(); } | @Test(expected = IllegalArgumentException.class) public void testVersionMustNotBeNull() { SingleVersion.valueOf(null); } |
Arrays { public static <ELEMENTTYPE> ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index) { Assert.isTrue(array.length > 0, "Cannot remove an element from an already empty array."); ELEMENTTYPE[] result = java.util.Arrays.copyOf(array, array.length - 1); if (result.length > 0 && array.length + 1 != index && index != result.length) System.arraycopy(array, index + 1, result, index, array.length - (array.length - index)); return result; } @SafeVarargs static ELEMENTTYPE[] append(ELEMENTTYPE[] array, ELEMENTTYPE... elements); @SafeVarargs static ELEMENTTYPE[] prepend(ELEMENTTYPE[] array, ELEMENTTYPE... elements); static ELEMENTTYPE[] copy(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static ELEMENTTYPE[] shiftLeft(ELEMENTTYPE[] source, ELEMENTTYPE[] target); static boolean contains(ELEMENTTYPE[] array, ELEMENTTYPE value); static int indexOf(ELEMENTTYPE[] array, ELEMENTTYPE value); static ELEMENTTYPE[] removeElementAtIndex(ELEMENTTYPE[] array, int index); } | @Test public void testSingleValue() { String[] data = new String[] { "a" }; int index = 0; String[] result = Arrays.removeElementAtIndex(data, index); Assert.assertEquals(1, data.length); Assert.assertEquals(0, result.length); }
@Test public void testRemoveElementAtIndex() { String[] data = new String[] { "a", "b", "c", "d", "e" }; int index = 2; String[] result = Arrays.removeElementAtIndex(data, index); Assert.assertEquals(data[0], result[0]); Assert.assertEquals(data[1], result[1]); Assert.assertEquals(data[3], result[2]); Assert.assertEquals(data[4], result[3]); }
@Test public void testRemoveElementAtLastIndex() { String[] data = new String[] { "a", "b", "c", "d", "e" }; int index = 4; String[] result = Arrays.removeElementAtIndex(data, index); Assert.assertEquals(data[0], result[0]); Assert.assertEquals(data[1], result[1]); Assert.assertEquals(data[2], result[2]); Assert.assertEquals(data[3], result[3]); Assert.assertEquals(4, result.length); } |
ProxyTypeInspector { public static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin) { Set<Class<?>> hierarchy = new LinkedHashSet<Class<?>>(); Class<?> baseClass = origin; while (baseClass != null && Modifier.isFinal(baseClass.getModifiers())) { baseClass = baseClass.getSuperclass(); } while (baseClass != null && !baseClass.isInterface() && baseClass.getSuperclass() != null && !baseClass.getSuperclass().equals(Object.class) && !Proxies.isInstantiable(baseClass)) { baseClass = baseClass.getSuperclass(); } if (baseClass != null && ClassLoaders.containsClass(loader, baseClass.getName()) && !Object.class.equals(baseClass) && (Proxies.isInstantiable(baseClass) || baseClass.isInterface())) { hierarchy.add(ClassLoaders.loadClass(loader, baseClass)); } baseClass = origin; while (baseClass != null) { for (Class<?> type : baseClass.getInterfaces()) { if (ClassLoaders.containsClass(loader, type.getName())) hierarchy.add(ClassLoaders.loadClass(loader, type)); else hierarchy.addAll(java.util.Arrays.asList(getCompatibleClassHierarchy(loader, type))); } baseClass = baseClass.getSuperclass(); } return hierarchy.toArray(new Class<?>[hierarchy.size()]); } static Class<?>[] getCompatibleClassHierarchy(ClassLoader loader, Class<?> origin); static boolean superclassHierarchyContains(Class<?> haystack, Class<?> needle); } | @Test public void testExceptionHierarchyFindsThrowable() throws Exception { Class<?>[] hierarchy = ProxyTypeInspector.getCompatibleClassHierarchy(getClass().getClassLoader(), MockException.class); Assert.assertEquals(2, hierarchy.length); Assert.assertEquals(Exception.class, hierarchy[0]); Assert.assertEquals(Serializable.class, hierarchy[1]); }
@Test public void testClassWithInstantiableBaseClass() throws Exception { Class<?>[] hierarchy = ProxyTypeInspector.getCompatibleClassHierarchy(getClass().getClassLoader(), MockExtendsImplementsExternal.class); Assert.assertEquals(MockBaseClassExternal.class, hierarchy[0]); Assert.assertEquals(MockInterface.class, hierarchy[1]); Assert.assertEquals(MockNestedInterface.class, hierarchy[2]); }
@Test public void testInnerClassWithNonInstantiableBaseClass() throws Exception { Class<?>[] hierarchy = ProxyTypeInspector.getCompatibleClassHierarchy(getClass().getClassLoader(), MockExtendsImplementsInternal.class); Assert.assertEquals(MockInterface.class, hierarchy[0]); Assert.assertEquals(MockNestedInterface.class, hierarchy[1]); } |
OperatingSystemUtils { public static File createTempDir() throws IllegalStateException { File baseDir = getTempDirectory(); try { return Files.createTempDirectory(baseDir.toPath(), "tmpdir").toFile(); } catch (IOException e) { throw new IllegalStateException("Error while creating temporary directory", e); } } static String getOsName(); static boolean isWindows(); static boolean isOSX(); static boolean isLinux(); static File getWorkingDir(); static File getForgeHomeDir(); static File getUserHomeDir(); static String getUserHomePath(); static File getUserForgeDir(); static void setPretendWindows(boolean value); static String getLineSeparator(); static String getSafeFilename(String filename); static File createTempDir(); static File getTempDirectory(); static boolean isJava8(); } | @Test public void testCreateTempDir() { File tmpDir = OperatingSystemUtils.createTempDir(); tmpDir.deleteOnExit(); Assert.assertThat(tmpDir.isDirectory(), is(true)); } |
StateMachine { public void nextCameraState() { switch (cameraState) { case BLOCKED: cameraState = CameraState.BLACK_PICTURE; jsonParser.setCameraState("softBlackPicture"); break; case BLACK_PICTURE: cameraState = CameraState.NEUTRAL_PICTURE; jsonParser.setCameraState("softNeutralPicture"); break; } } StateMachine(); MicrophoneState getMicrophoneState(); CameraState getCameraState(); void nextMicrophoneState(); void nextCameraState(); } | @Test public void nextCameraState() { assertEquals(CameraState.BLOCKED, stateMachine.getCameraState()); stateMachine.nextCameraState(); assertEquals(CameraState.BLACK_PICTURE, stateMachine.getCameraState()); stateMachine.nextCameraState(); assertEquals(CameraState.NEUTRAL_PICTURE, stateMachine.getCameraState()); stateMachine.nextCameraState(); assertEquals(CameraState.PIXEL_PERSONS, stateMachine.getCameraState()); stateMachine.nextCameraState(); } |
StateMachine { public void nextMicrophoneState() { switch (getMicrophoneState()) { case BLOCKED: microphoneState = MicrophoneState.NO_SOUND; jsonParser.setMicrophoneState("softEmptyNoise"); break; case NO_SOUND: microphoneState = MicrophoneState.NEUTRAL_SOUND; jsonParser.setMicrophoneState("softSignalNoise"); break; } } StateMachine(); MicrophoneState getMicrophoneState(); CameraState getCameraState(); void nextMicrophoneState(); void nextCameraState(); } | @Test public void nextMicrophoneState() { assertEquals(MicrophoneState.BLOCKED, stateMachine.getMicrophoneState()); stateMachine.nextMicrophoneState(); assertEquals(MicrophoneState.NO_SOUND, stateMachine.getMicrophoneState()); stateMachine.nextMicrophoneState(); assertEquals(MicrophoneState.NEUTRAL_SOUND, stateMachine.getMicrophoneState()); stateMachine.nextMicrophoneState(); } |
ClearanceService { public void cleanDatabase() { Calendar cal = GregorianCalendar.getInstance(Locale.GERMANY); cal.set(Calendar.DATE, cal.get(Calendar.DATE) - (30 * monthsBeforeDeletion)); System.out.println("************************************************"); System.out.println("\t Clearance-Prozess gestartet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); Iterable<Profile> unusedProfiles = profileRepository.findAllByLastProfileContactBefore(cal.getTime()); System.out.println("\t Anzahl geloeschter Profile: " + unusedProfiles.spliterator().getExactSizeIfKnown()); profileRepository.delete(unusedProfiles); try { RestTemplate restTemplate = new RestTemplate(); String url = adress + ":" + port + "/" + databaseName + "/" + "_compact"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<String> entity = new HttpEntity<String>("", headers); restTemplate.exchange(url, HttpMethod.POST, entity, String.class); System.out.println("\t Compact-Befehl durchgeführt: true"); } catch (Exception e) { System.out.println("\t Compact-Befehl durchgeführt: false"); e.printStackTrace(); } System.out.println("\t Clearance-Prozess beendet um " + GregorianCalendar.getInstance(Locale.GERMANY).getTime()); System.out.println("************************************************"); } ClearanceService(); void cleanDatabase(); } | @Test public void testCleanDatabase() { assertThat(profileRepository.count()).isEqualTo(this.outdatedProfiles.length + this.upToDateProfiles.length); clearanceService.cleanDatabase(); assertThat(profileRepository.count()).isEqualTo(this.upToDateProfiles.length); Iterable<Profile> listUpToDateProfilesInDB = profileRepository.findAll(); assertThat(listUpToDateProfilesInDB.toString()).isEqualTo(Arrays.asList(this.upToDateProfiles).toString()); String[] outdatedProfilesIds = new String[outdatedProfiles.length]; for (int i = 0; i < outdatedProfiles.length; ++i) { outdatedProfilesIds[i] = outdatedProfiles[i].get_id(); } Iterable<Profile> listOutdatedProfilesInDB = profileRepository.findAll(Arrays.asList(outdatedProfilesIds)); assertThat(listOutdatedProfilesInDB).isNullOrEmpty(); } |
Cookie { public static Cookie parse(String setCookie) { return parse(System.currentTimeMillis(), setCookie); } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void noEqualsSign() throws Exception { assertThat(Cookie.parse("foo")).isNull(); assertThat(Cookie.parse("foo; Path=/")).isNull(); }
@Test public void emptyName() throws Exception { assertThat(Cookie.parse("=b")).isNull(); assertThat(Cookie.parse(" =b")).isNull(); assertThat(Cookie.parse("\r\t \n=b")).isNull(); }
@Test public void invalidCharacters() throws Exception { assertThat(Cookie.parse("a\u0000b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0000d")).isNull(); assertThat(Cookie.parse("a\u0001b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0001d")).isNull(); assertThat(Cookie.parse("a\u0009b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0009d")).isNull(); assertThat(Cookie.parse("a\u001fb=cd")).isNull(); assertThat(Cookie.parse("ab=c\u001fd")).isNull(); assertThat(Cookie.parse("a\u007fb=cd")).isNull(); assertThat(Cookie.parse("ab=c\u007fd")).isNull(); assertThat(Cookie.parse("a\u0080b=cd")).isNull(); assertThat(Cookie.parse("ab=c\u0080d")).isNull(); assertThat(Cookie.parse("a\u00ffb=cd")).isNull(); assertThat(Cookie.parse("ab=c\u00ffd")).isNull(); } |
Cookie { @Override public String toString() { StringBuilder result = new StringBuilder(); result.append(name); result.append('='); result.append(value); if (persistent) { if (expiresAt == Long.MIN_VALUE) { result.append("; max-age=0"); } else { result.append("; expires=").append(STANDARD_DATE_FORMAT.format(new Date(expiresAt))); } } if (!hostOnly) { result.append("; domain="); result.append(domain); } result.append("; path=").append(path); if (secure) { result.append("; secure"); } if (httpOnly) { result.append("; httponly"); } return result.toString(); } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void builderExpiresAt() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .expiresAt(date("1970-01-01T00:00:01.000+0000").getTime()) .build(); assertThat(cookie.toString()).isEqualTo( "a=b; expires=Thu, 01 Jan 1970 00:00:01 GMT; path=/"); }
@Test public void builderClampsMinDate() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .expiresAt(date("1970-01-01T00:00:00.000+0000").getTime()) .build(); assertThat(cookie.toString()).isEqualTo("a=b; max-age=0; path=/"); }
@Test public void builderClampsMaxDate() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .expiresAt(Long.MAX_VALUE) .build(); assertThat(cookie.toString()).isEqualTo( "a=b; expires=Fri, 31 Dec 9999 23:59:59 GMT; path=/"); } |
Cookie { public String getPath() { return path; } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void builderPath() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .path("/foo") .build(); assertThat(cookie.getPath()).isEqualTo("/foo"); } |
Cookie { public boolean getSecure() { return secure; } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void builderSecure() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .secure(true) .build(); assertThat(cookie.getSecure()).isTrue(); } |
Cookie { public boolean getHttpOnly() { return httpOnly; } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void builderHttpOnly() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .hostOnlyDomain("example.com") .httpOnly(true) .build(); assertThat(cookie.getHttpOnly()).isTrue(); } |
Cookie { public String getDomain() { return domain; } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void builderIpv6() throws Exception { Cookie cookie = new Cookie.Builder() .name("a") .value("b") .domain("0:0:0:0:0:0:0:1") .build(); assertThat(cookie.getDomain()).isEqualTo("0:0:0:0:0:0:0:1"); } |
Cookie { public long getExpiresAt() { return expiresAt; } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void maxAge() throws Exception { assertThat(parseCookie(50000L, "a=b; Max-Age=1").getExpiresAt()) .isEqualTo(51000L); assertThat(parseCookie(50000L, "a=b; Max-Age=9223372036854724").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=9223372036854725").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=9223372036854726").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(9223372036854773807L, "a=b; Max-Age=1").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(9223372036854773807L, "a=b; Max-Age=2").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(9223372036854773807L, "a=b; Max-Age=3").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=10000000000000000000").getExpiresAt()) .isEqualTo(MAX_DATE); assertThat(parseCookie(50000L, "a=b; Max-Age=For-Eva").getExpiresAt()) .isEqualTo(MAX_DATE); }
@Test public void maxAgeNonPositive() throws Exception { assertThat(parseCookie(50000L, "a=b; Max-Age=-1").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=0").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=-9223372036854775808").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=-9223372036854775809").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); assertThat(parseCookie(50000L, "a=b; Max-Age=-10000000000000000000").getExpiresAt()) .isEqualTo(Long.MIN_VALUE); }
@Test public void maxAgeTakesPrecedenceOverExpires() throws Exception { assertThat(parseCookie( 0L, "a=b; Max-Age=1; Expires=Thu, 01 Jan 1970 00:00:02 GMT").getExpiresAt()).isEqualTo( 1000L); assertThat(parseCookie( 0L, "a=b; Expires=Thu, 01 Jan 1970 00:00:02 GMT; Max-Age=1").getExpiresAt()).isEqualTo( 1000L); assertThat(parseCookie( 0L, "a=b; Max-Age=2; Expires=Thu, 01 Jan 1970 00:00:01 GMT").getExpiresAt()).isEqualTo( 2000L); assertThat(parseCookie( 0L, "a=b; Expires=Thu, 01 Jan 1970 00:00:01 GMT; Max-Age=2").getExpiresAt()).isEqualTo( 2000L); }
@Test public void lastMaxAgeWins() throws Exception { assertThat(parseCookie( 0L, "a=b; Max-Age=2; Max-Age=4; Max-Age=1; Max-Age=3").getExpiresAt()).isEqualTo(3000L); }
@Test public void lastExpiresAtWins() throws Exception { assertThat(parseCookie(0L, "a=b; " + "Expires=Thu, 01 Jan 1970 00:00:02 GMT; " + "Expires=Thu, 01 Jan 1970 00:00:04 GMT; " + "Expires=Thu, 01 Jan 1970 00:00:01 GMT; " + "Expires=Thu, 01 Jan 1970 00:00:03 GMT").getExpiresAt()).isEqualTo(3000L); } |
Cookie { public boolean getPersistent() { return persistent; } private Cookie(String name, String value, long expiresAt, String domain, String path,
boolean secure, boolean httpOnly, boolean hostOnly, boolean persistent); private Cookie(Builder builder); String getName(); String getValue(); boolean getPersistent(); long getExpiresAt(); boolean getHostOnly(); String getDomain(); String getPath(); boolean getHttpOnly(); boolean getSecure(); static List<Cookie> parseAll(List<String> cookieStrings); static Cookie parse(String setCookie); @Override String toString(); boolean similarTo(Cookie other); @Override boolean equals(Object other); @Override int hashCode(); } | @Test public void maxAgeOrExpiresMakesCookiePersistent() throws Exception { assertThat(parseCookie(0L, "a=b").getPersistent()).isFalse(); assertThat(parseCookie(0L, "a=b; Max-Age=1").getPersistent()).isTrue(); assertThat(parseCookie(0L, "a=b; Expires=Thu, 01 Jan 1970 00:00:01 GMT").getPersistent()) .isTrue(); } |
Segment2D extends Geometry2D { public ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon) { ArrayList<Segment2D> segmentList = new ArrayList<>(); ArrayList<Vector2D> segmentListPoints = new ArrayList<>(); segmentListPoints.add(this.getFirstPoint()); segmentListPoints.addAll(this.getIntersection(polygon)); segmentListPoints.add(this.getLastPoint()); Comparator<Vector2D> byDistance = (e1, e2) -> Double.compare( e1.distance(this.getFirstPoint()), e2.distance(this.getFirstPoint())); segmentListPoints = segmentListPoints.stream() .sorted(byDistance) .collect(Collectors.toCollection(ArrayList::new)); Vector2D tempPosPrevious = null; for(Vector2D tempPosCurrent : segmentListPoints) { if(tempPosPrevious == null) { tempPosPrevious = tempPosCurrent; continue; } if(!tempPosPrevious.equals(tempPosCurrent)) { segmentList.add(GeometryFactory.createSegment(tempPosPrevious, tempPosCurrent)); tempPosPrevious = tempPosCurrent; } } return segmentList; } Segment2D(Vector2D point1, Vector2D point2); Segment2D(List<Vector2D> nodeArray); Segment2D(Vector2D[] nodeArray); List<Segment2D> getLineSegments(); @Override boolean equals(Object other); @Override synchronized List<Vector2D> getVertices(); double getLength(); double getLenghtDistance(); ArrayList<Vector2D> getIntersection(Segment2D openPolygon); ArrayList<Segment2D> getSegmentSplitByPolygon(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Cycle2D cycle); Vector2D getFirstPoint(); Vector2D getLastPoint(); @Override boolean contains(Vector2D point); @Override boolean contains(Vector2D point, Transform transform); Vector2D getPointOnSegmentClosestToVector(Vector2D point); @Override void rotate(double theta, double x, double y); @Override void rotate(double theta); @Override void rotate(double theta, Vector2D point); @Override void translate(double x, double y); @Override void translate(Vector2D vector); @Override double distanceBetween(Vector2D point); @Override double minimalDistanceBetween(List<Vector2D> points); @Override Vector2D vectorBetween(Vector2D point); @Override Mass createMass(double density); @Override List<Segment2D> getSegments(); @Override double getRadius(); @Override double getRadius(Vector2D vector); @Override Vector2D getCenter(); @Override Vector2D getPointClosestToVector(Vector2D toVector); @Override boolean isOnLines(Vector2D vector, double precision); @Override boolean isOnCorners(Vector2D vector, double precision); List<Vector2D> getNormals(); List<Segment2D> getLineSegmentsSplit(double maxLength); List<Segment2D> getLineSegmentsSplitEqually(double maxLength, Double roundPrecision); ArrayList<Segment2D> calculateLineSegmentsToEquallySplit(double maxLength, Double roundPrecision); Double getSmallestVertixValueOfX(); Double getSmallestVertixValueOfY(); Double getLargestVertixValueOfX(); Double getLargestVertixValueOfY(); @Override double area(); } | @Test public void getSegmentSplitByPolygon() throws Exception { Vector2D start = GeometryFactory.createVector(-5,0); Vector2D end = GeometryFactory.createVector(5,0); Segment2D segment = GeometryFactory.createSegment(start, end); ArrayList<Vector2D> nodeArray = new ArrayList<>(); nodeArray.add(GeometryFactory.createVector(-2, -2)); nodeArray.add(GeometryFactory.createVector(2, -2)); nodeArray.add(GeometryFactory.createVector(2, 2)); nodeArray.add(GeometryFactory.createVector(-2, 2)); Polygon2D polygon = GeometryFactory.createPolygon(nodeArray); ArrayList<Segment2D> splittedSegment = segment.getSegmentSplitByPolygon(polygon); assertEquals(3, splittedSegment.size()); assertEquals(-5, splittedSegment.get(0).getFirstPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(0).getFirstPoint().getYComponent(), PRECISION); assertEquals(-2, splittedSegment.get(0).getLastPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(0).getLastPoint().getYComponent(), PRECISION); assertEquals(-2, splittedSegment.get(1).getFirstPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(1).getFirstPoint().getYComponent(), PRECISION); assertEquals(2, splittedSegment.get(1).getLastPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(1).getLastPoint().getYComponent(), PRECISION); assertEquals(2, splittedSegment.get(2).getFirstPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(2).getFirstPoint().getYComponent(), PRECISION); assertEquals(5, splittedSegment.get(2).getLastPoint().getXComponent(), PRECISION); assertEquals(0, splittedSegment.get(2).getLastPoint().getYComponent(), PRECISION); System.out.println(splittedSegment.toString()); } |
Ray2D { public Segment2D intersectionSegment(Ray2D other) { if(this.contains(other.getStart()) && other.contains(this.getStart())) { return new Segment2D(this.getStart(), other.getStart()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); } | @Test public void intersectionSegment() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(5,0); bDirection = GeometryFactory.createVector(-1,0); b = GeometryFactory.createRay2D(bStart, bDirection); Segment2D intersectionSegment = a.intersectionSegment(b); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getXComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getYComponent(), PRECISION); Assert.assertEquals(5, intersectionSegment.getLastPoint().getXComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getLastPoint().getYComponent(), PRECISION); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(0,1); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,7); bDirection = GeometryFactory.createVector(0,-0.1); b = GeometryFactory.createRay2D(bStart, bDirection); intersectionSegment = a.intersectionSegment(b); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getXComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getFirstPoint().getYComponent(), PRECISION); Assert.assertEquals(0, intersectionSegment.getLastPoint().getXComponent(), PRECISION); Assert.assertEquals(7, intersectionSegment.getLastPoint().getYComponent(), PRECISION); bStart = GeometryFactory.createVector(5,5); bDirection = GeometryFactory.createVector(-1,0); b = GeometryFactory.createRay2D(bStart, bDirection); intersectionSegment = a.intersectionSegment(b); assertNull(intersectionSegment); } |
FromConfigurationOperation extends GraphOperation { @Override public void callPreProcessing(SimulationState simulationState) { Integer graphId = this.properties.getIntegerProperty(graphIdName); Double precisionSeed = this.properties.getDoubleProperty(precisionSeedName); Boolean insideAreaSeed = this.properties.getBooleanProperty(insideAreaSeedName); GraphScenarioConfiguration graphConfiguration = null; for(GraphScenarioConfiguration graphScenarioConfiguration : configurations.get(0).getGraphs()) { if(graphScenarioConfiguration.getId().intValue() == graphId) { graphConfiguration = graphScenarioConfiguration; } } HashSet<Area> alreadySeedAreas = new HashSet<>(); Graph graph = GraphTheoryFactory.createGraph(graphConfiguration.getName()); graph.setId(graphConfiguration.getId()); this.scenarioManager.getGraphs().add(graph); for(VertexConfiguration vertexConfiguration : graphConfiguration.getVertices()) { Vertex newVertex = null; Vector2D center = GeometryFactory.createVector(vertexConfiguration.getPoint().getX(), vertexConfiguration.getPoint().getY()); boolean isSeed = this.scenarioManager.getAreas() .stream() .filter(area -> { if(precisionSeed != null && FastMath.abs(area.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && area.getGeometry().contains(center)) { return true; } return false; }) .count() > 0; if(isSeed) { Area area = this.scenarioManager.getAreas() .stream() .filter(existingArea -> { if(!alreadySeedAreas.contains(existingArea)) { if(precisionSeed != null && FastMath.abs(existingArea.getPointOfInterest().distance(center)) < precisionSeed) { return true; } else if (insideAreaSeed != null && insideAreaSeed && existingArea.getGeometry().contains(center)) { return true; } } return false; }) .findFirst() .orElse(null); if(area != null) { alreadySeedAreas.add(area); newVertex = GraphTheoryFactory.createVertex(area.getGeometry(), true, vertexConfiguration.getId()); } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } } else { newVertex = GraphTheoryFactory.createVertexCyleBased(center, vertexConfiguration.getId()); } graph.addVertex(newVertex); } for(EdgeConfiguration edgeConfiguration : graphConfiguration.getEdges()) { Vertex left = graph.getVertex(edgeConfiguration.getIdLeft()); Vertex right = graph.getVertex(edgeConfiguration.getIdRight()); graph.doublyConnectVertices(left, right); } } FromConfigurationOperation(ArrayList<ScenarioConfiguration> scenarioConfigurations); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); } | @Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_loadsSingleVertexInsideArea_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(6); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = scenarioManager.getArea(2).getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); assertTrue(isSeed && isInArea); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_loadsOnlySingleVertexInsideArea_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideAreaFirst = scenarioManager.getGraph().getVertex(1); Vertex vertexInSideAreaSecond = scenarioManager.getGraph().getVertex(2); boolean isFirstSeed = vertexInSideAreaFirst.isSeed(); boolean isFirstInArea = scenarioManager.getArea(3).getGeometry().contains(vertexInSideAreaFirst.getGeometry().getCenter()); boolean isSecSeed = vertexInSideAreaSecond.isSeed(); boolean isSecInArea = scenarioManager.getArea(3).getGeometry().contains(vertexInSideAreaSecond.getGeometry().getCenter()); assertTrue( (isFirstSeed && isFirstInArea && !isSecSeed && isSecInArea) || (!isFirstSeed && isFirstInArea && isSecSeed && isSecInArea) ); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_ignoresVertexOutsideArea_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(3); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = false; for(Area area : scenarioManager.getAreas()) { isInArea = isInArea || area.getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); } assertTrue(!isSeed && !isInArea); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_insideArea_test.xml"}) public void fromConfiguration_loadsSingleVertexOnBorderOfArea_WithoutSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(5); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = scenarioManager.getArea(1).getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); assertTrue(!isSeed && !isInArea); }
@Test @Parameters({"/layout_graph_test/FromGraphConfigurationOperation_withPrecisionSeed_test.xml"}) public void fromConfiguration_loadsSingleVertexWithPrecision_WithSuccess(String configurationFile) throws Exception { createConfiguration(configurationFile); createConfiguration(configurationFile); SimulationState state = mock(SimulationState.class); graphOperation.callPreProcessing(state); Vertex vertexInSideArea = scenarioManager.getGraph().getVertex(4); boolean isSeed = vertexInSideArea.isSeed(); boolean isInArea = scenarioManager.getArea(1).getGeometry().contains(vertexInSideArea.getGeometry().getCenter()); assertTrue(isSeed && isInArea); } |
ZengAdditionalComputations { public static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity) { if(currentVelocity.isZero() || otherVelocity.isZero()) { return Double.POSITIVE_INFINITY; } Ray2D currentRay = GeometryFactory.createRay2D(currentPosition, currentVelocity); Ray2D otherRay = GeometryFactory.createRay2D(otherPosition, otherVelocity); Vector2D conflictPoint = currentRay.intersectionPoint(otherRay); if(conflictPoint != null) { double curTimeToConflictPoint = (conflictPoint.subtract(currentPosition).getMagnitude() / currentVelocity.getMagnitude()); double othTimeToConflictPoint = (conflictPoint.subtract(otherPosition).getMagnitude() / otherVelocity.getMagnitude()); return Math.abs(curTimeToConflictPoint - othTimeToConflictPoint); } Segment2D conflictSegment = currentRay.intersectionSegment(otherRay); if(conflictSegment != null) { return 0.0; } Ray2D conflictRay = currentRay.intersectionRay(otherRay); if(conflictRay != null) { return 0.0; } return Double.POSITIVE_INFINITY; } static Vector2D computeRepulsiveForceConflictingPedestrians(IOperationalPedestrian pedestrian, Collection<IPedestrian> otherPedestrians, double timeStepDuration,
double interaction_strength_for_repulsive_force_from_surrounding_pedestrians, double interaction_range_for_relative_distance,
double range_for_relative_conflicting_time, double strength_of_forces_exerted_from_other_pedestrians); static Double calculateTimeToConflictPoint(Vector2D currentPosition, Vector2D currentVelocity, Vector2D otherPosition, Vector2D otherVelocity); static double calculateInteractionAngleFactor(Vector2D currentVelocity, Vector2D distance, double influenceStrength); static TaggedArea findCorrespondingCrosswalk(IOperationalPedestrian pedestrian, List<TaggedArea> crosswalkAreas); static Vector2D findNearestCrosswalkBoundaryPoint(IOperationalPedestrian pedestrian, TaggedArea nextCrosswalk, double epsilon); } | @Test public void calculateTimeToConflictPoint() throws Exception { Vector2D curPosition, curVelocity, othPosition, othVelocity; curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(0, 1); othPosition = GeometryFactory.createVector(2, 2); othVelocity = GeometryFactory.createVector(-1, 0); Assert.assertEquals(0.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(1, 1); othPosition = GeometryFactory.createVector(2, 0); othVelocity = GeometryFactory.createVector(-1, 1); Assert.assertEquals(0.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(0, 1); othPosition = GeometryFactory.createVector(1, 0); othVelocity = GeometryFactory.createVector(-1, -1); Assert.assertEquals(Double.POSITIVE_INFINITY, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(1, 0); othPosition = GeometryFactory.createVector(11, 1); othVelocity = GeometryFactory.createVector(0, -1); Assert.assertEquals(10.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); curPosition = GeometryFactory.createVector(0, 0); curVelocity = GeometryFactory.createVector(0, 1); othPosition = GeometryFactory.createVector(0, 10); othVelocity = GeometryFactory.createVector(0, -1); Assert.assertEquals(0.0, ZengAdditionalComputations.calculateTimeToConflictPoint(curPosition, curVelocity, othPosition, othVelocity), PRECISION); } |
SightConePerceptionModel extends PerceptionalModel { @Override public boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian) { return isVisible(currentPedestrian, otherPedestrian.getPosition()); } void setRadius(double radius); void setAngle(double angle); @Override void callPreProcessing(SimulationState simulationState); @Override void callPostProcessing(SimulationState simulationState); @Override List<IPedestrian> getPerceptedPedestrians(IPedestrian currentPedestrian, SimulationState simulationState); @Override boolean isVisible(IPedestrian currentPedestrian, IPedestrian otherPedestrian); @Override boolean isVisible(IPedestrian pedestrian, Vector2D position); @Override boolean isVisible(IPedestrian pedestrian, Area area); @Override boolean isVisible(IPedestrian pedestrian, Vertex vertex); @Override boolean isVisible(IPedestrian pedestrian, Edge edge); @Override boolean isVisible(Vector2D viewPort, Vector2D position); @Override double getPerceptionDistance(); @Override List<Vector2D> getPerceptedObstaclePositions(IPedestrian pedestrian, SimulationState simulationState); @Override List<IPedestrian> getPerceptedPedestrianPositions(IPedestrian pedestrian, SimulationState simulationState); @Override List<Vector2D> getPerceptedFreePositions(IPedestrian pedestrian, SimulationState simulationState); } | @Test public void isVisible() throws Exception { SightConePerceptionModel sightConePerceptionModelModel = new SightConePerceptionModel(); sightConePerceptionModelModel.setAngle(90); sightConePerceptionModelModel.setRadius(30); Vector2D curPedPos, curPedHead, otherPedPos, otherPedHead; curPedPos = GeometryFactory.createVector(0,0); curPedHead = GeometryFactory.createVector(1,0); otherPedPos = GeometryFactory.createVector(20,0); otherPedHead = GeometryFactory.createVector(1,0); currentPedestrian.setWalkingState(new WalkingState(curPedPos, curPedHead, curPedHead)); otherPedestrian.setWalkingState(new WalkingState(otherPedPos, otherPedHead, otherPedHead)); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(30.1, 0); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(20, 20); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(0, 20); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(Math.cos(Math.toRadians(-46)), Math.sin(Math.toRadians(-46))); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(Math.cos(Math.toRadians(-44)), Math.sin(Math.toRadians(-44))); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); curPedPos.set(10,10); curPedHead.set(0,-1); otherPedPos.set(10, 11); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10, 11); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10, 9); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10 + Math.cos(-46), 10 + Math.sin(-46)); assertTrue(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); otherPedPos.set(10 + Math.cos(-44.5)*5, 10 + Math.sin(-44.5)*5); assertFalse(sightConePerceptionModelModel.isVisible(currentPedestrian, otherPedestrian)); } |
Ellipse2D { public Vector2D closestPoint(Vector2D point) { return null; } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); } | @Test public void closestPoint() throws Exception { F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 0); minorAxis = 2; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(1, 3); closestPoint = ellipse.closestPoint(point); Assert.assertEquals(1, closestPoint.getXComponent(), PRECISION); Assert.assertEquals(2, closestPoint.getYComponent(), PRECISION); ellipse = GeometryFactory.createEllipse(new Vector2D(10, 10), new Vector2D(1, 0), 1, 1); point = new Vector2D(12, 12); Assert.assertEquals(10+Math.sqrt(2)/2, ellipse.closestPoint(point).getXComponent(), PRECISION); Assert.assertEquals(10+Math.sqrt(2)/2, ellipse.closestPoint(point).getXComponent(), PRECISION); } |
Ellipse2D { public Vector2D vectorBetween(Vector2D point) { Vector2D closestPoint = closestPoint(point); return point.subtract(closestPoint); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); } | @Test public void vectorBetween() throws Exception { Vector2D vectorBetween; F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 0); minorAxis = 2; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(1, 3); vectorBetween = ellipse.vectorBetween(point); Assert.assertEquals(0, vectorBetween.getXComponent(), PRECISION); Assert.assertEquals(1, vectorBetween.getYComponent(), PRECISION); ellipse = GeometryFactory.createEllipse(new Vector2D(10, 10), new Vector2D(1, 0), 1, 1); Assert.assertEquals(0, ellipse.getOrientation(), PRECISION); point = new Vector2D(12,12); closestPoint = ellipse.closestPoint(point); vectorBetween = ellipse.vectorBetween(point); Assert.assertEquals(2 - Math.sqrt(2)/2, vectorBetween.getXComponent(), PRECISION); Assert.assertEquals(2 - Math.sqrt(2)/2, vectorBetween.getYComponent(), PRECISION); } |
Ellipse2D { public Vector2D normal(Vector2D point) { Vector2D pointOnEllipse = closestPoint(point); pointOnEllipse = pointOnEllipse.subtract(this.getCenter()).rotate(-this.getOrientation()); Vector2D normal = new Vector2D(pointOnEllipse.getXComponent() * getMinorAxis()/getMajorAxis(), pointOnEllipse.getYComponent() * getMajorAxis()/getMinorAxis()); return normal.rotate(this.getOrientation()).getNormalized(); } Ellipse2D(Vector2D center, Vector2D direction, double majorAxis, double minorAxis); Vector2D closestPoint(Vector2D point); Vector2D vectorBetween(Vector2D point); Vector2D normal(Vector2D point); Vector2D getCenter(); void setCenter(Vector2D center); double getOrientation(); double getMajorAxis(); double getMinorAxis(); void translate(double x, double y); void translate(Vector2D vector); } | @Test public void normal() throws Exception { center = GeometryFactory.createVector(1, 1); direction = GeometryFactory.createVector(1, 1); minorAxis = 2; majorAxis = 5; ellipse = GeometryFactory.createEllipse(center, direction, majorAxis, minorAxis); point = GeometryFactory.createVector(1-1/Math.sqrt(2), 1+1/Math.sqrt(2)); normal = ellipse.normal(point); Assert.assertEquals(-1/Math.sqrt(2), normal.getXComponent(), PRECISION); Assert.assertEquals(1/Math.sqrt(2), normal.getYComponent(), PRECISION); F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 0); minorAxis = 2; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(1, 3); normal = ellipse.normal(point); Assert.assertEquals(0, normal.getXComponent(), PRECISION); Assert.assertEquals(1, normal.getYComponent(), PRECISION); F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 2); minorAxis = 1; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); Assert.assertEquals(Math.sqrt(3), ellipse.getMajorAxis(), PRECISION); point = GeometryFactory.createVector(2.5, 2.5); normal = ellipse.normal(point); Assert.assertEquals(Math.sqrt(2)/2, normal.getXComponent(), PRECISION); Assert.assertEquals(Math.sqrt(2)/2, normal.getYComponent(), PRECISION); F1 = GeometryFactory.createVector(0, 0); F2 = GeometryFactory.createVector(2, 2); minorAxis = 1; ellipse = GeometryFactory.createEllipse(F1, F2, minorAxis); point = GeometryFactory.createVector(-1, -1); normal = ellipse.normal(point); Assert.assertEquals(-Math.sqrt(2)/2, normal.getXComponent(), PRECISION); Assert.assertEquals(-Math.sqrt(2)/2, normal.getYComponent(), PRECISION); center = GeometryFactory.createVector(1, 0); direction = GeometryFactory.createVector(1, 0); minorAxis = 2; majorAxis = 5; ellipse = GeometryFactory.createEllipse(center, direction, majorAxis, minorAxis); point = GeometryFactory.createVector(1, 5); normal = ellipse.normal(point); Assert.assertEquals(0, normal.getXComponent(), PRECISION); Assert.assertEquals(1, normal.getYComponent(), PRECISION); } |
Rectangle2D extends Geometry2D { @Override public Vector2D vectorBetween(Vector2D point) { return this.rectangleAsSegments().vectorBetween(point); } Rectangle2D(Vector2D center, Vector2D direction, double width, double height); @Override double distanceBetween(Vector2D point); @Override double minimalDistanceBetween(List<Vector2D> points); @Override Vector2D vectorBetween(Vector2D point); @Override ArrayList<Vector2D> getIntersection(Segment2D segment); @Override ArrayList<Vector2D> getIntersection(Polygon2D polygon); @Override ArrayList<Vector2D> getIntersection(Cycle2D segment); @Override boolean isOnCorners(Vector2D vector, double precision); @Override boolean isOnLines(Vector2D vector, double precision); @Override List<Vector2D> getVertices(); synchronized Segment2D rectangleAsSegments(); @Override List<Segment2D> getSegments(); @Override Vector2D getPointClosestToVector(Vector2D toVector); @Override double area(); @Override boolean contains(Vector2D point); @Override boolean contains(Vector2D point, Transform transform); @Override Mass createMass(double density); @Override double getRadius(); @Override double getRadius(Vector2D vector); @Override Vector2D getCenter(); @Override void rotate(double theta); @Override void rotate(double theta, double x, double y); @Override void rotate(double theta, Vector2D vector); @Override void translate(double x, double y); @Override void translate(Vector2D vector); } | @Test public void vectorBetween() throws Exception { center = GeometryFactory.createVector(0, 0); direction = GeometryFactory.createVector(1, 0); width = 2; height = 6; rectangle = new Rectangle2D(center, direction, width, height); point = GeometryFactory.createVector(3, 2); Assert.assertEquals(1, rectangle.distanceBetween(point), PRECISION); point = GeometryFactory.createVector(-4, 2); Assert.assertEquals(Math.sqrt(2), rectangle.distanceBetween(point), PRECISION); point = GeometryFactory.createVector(3, 2); Vector2D between = rectangle.vectorBetween(point); Assert.assertEquals(0, between.getXComponent(), PRECISION); Assert.assertEquals(-1, between.getYComponent(), PRECISION); } |
Ray2D { public Vector2D intersectionPoint(Ray2D other) { double dx = other.getStart().getXComponent() - this.getStart().getXComponent(); double dy = other.getStart().getYComponent() - this.getStart().getYComponent(); double det = other.getDirection().getXComponent() * this.getDirection().getYComponent() - other.getDirection().getYComponent() * this.getDirection().getXComponent(); if(det == 0) { return null; } double u = (dy * other.getDirection().getXComponent() - dx * other.getDirection().getYComponent()) / det; double v = (dy * this.getDirection().getXComponent() - dx * this.getDirection().getYComponent()) / det; if(u >= 0 && v >= 0) { return this.getStart().sum(this.getDirection().multiply(u)); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); } | @Test public void intersectionPoint() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionPoint(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); b = GeometryFactory.createRay2D(aStart, aDirection); assertNull(a.intersectionPoint(b)); aStart = GeometryFactory.createVector(1,1); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(2,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionPoint(b)); aStart = GeometryFactory.createVector(5,0); aDirection = GeometryFactory.createVector(-1,0); bStart = GeometryFactory.createVector(0,5); bDirection = GeometryFactory.createVector(0,-1); a = GeometryFactory.createRay2D(aStart, aDirection); b = GeometryFactory.createRay2D(bStart, bDirection); intersection = a.intersectionPoint(b); Assert.assertEquals(0, intersection.getXComponent(), PRECISION); Assert.assertEquals(0, intersection.getXComponent(), PRECISION); aStart = GeometryFactory.createVector(2,0); aDirection = GeometryFactory.createVector(1,2); bStart = GeometryFactory.createVector(0,2); bDirection = GeometryFactory.createVector(2,1); a = GeometryFactory.createRay2D(aStart, aDirection); b = GeometryFactory.createRay2D(bStart, bDirection); intersection = a.intersectionPoint(b); Assert.assertEquals(4, intersection.getXComponent(), PRECISION); Assert.assertEquals(4, intersection.getXComponent(), PRECISION); } |
Ray2D { public boolean isParallel(Ray2D other) { return this.getDirection().cross(other.getDirection()) == 0; } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); } | @Test public void isParallel() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(1,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertTrue(a.isParallel(b)); bStart = GeometryFactory.createVector(1,1); bDirection = GeometryFactory.createVector(1,1.0001); b = GeometryFactory.createRay2D(bStart, bDirection); assertFalse(a.isParallel(b)); bStart = GeometryFactory.createVector(0,0); bDirection = GeometryFactory.createVector(0,1); b = GeometryFactory.createRay2D(bStart, bDirection); assertFalse(a.isParallel(b)); } |
Ray2D { public boolean equals(Ray2D other) { return this.getStart().equals(other.getStart()) && this.getDirection().getNormalized().equals(other.getDirection().getNormalized()); } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); } | @Test public void equals() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(1,1); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertFalse(a.equals(b)); bStart = GeometryFactory.createVector(0,0); bDirection = GeometryFactory.createVector(2,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertTrue(a.equals(b)); } |
Ray2D { public boolean contains(Vector2D point) { Vector2D newNorm = point.subtract(this.getStart()).getNormalized(); double dotProduct = newNorm.dot(this.getDirection().getNormalized()); return Math.abs(1.0 - dotProduct) < EPSILON; } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); } | @Test public void contains() throws Exception { aStart = GeometryFactory.createVector(5,5); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); point = GeometryFactory.createVector(7,0); assertFalse(a.contains(point)); point = GeometryFactory.createVector(7,5); assertTrue(a.contains(point)); point = GeometryFactory.createVector(4,5); assertFalse(a.contains(point)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(0,1); a = GeometryFactory.createRay2D(aStart, aDirection); point = GeometryFactory.createVector(0,1); assertTrue(a.contains(point)); point = GeometryFactory.createVector(0,-2); assertFalse(a.contains(point)); aStart = GeometryFactory.createVector(1,0); aDirection = GeometryFactory.createVector(1,1); a = GeometryFactory.createRay2D(aStart, aDirection); point = GeometryFactory.createVector(3,2); assertTrue(a.contains(point)); point = GeometryFactory.createVector(0,-1); assertFalse(a.contains(point)); } |
Ray2D { public Ray2D intersectionRay(Ray2D other) { double dotProduct = this.getDirection().getNormalized().dot(other.getDirection().getNormalized()); if(this.contains(other.getStart()) && !other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(other.getStart(), other.getDirection()); } else if(!this.contains(other.getStart()) && other.contains(this.getStart()) && Math.abs(1.0 - dotProduct) < EPSILON) { return new Ray2D(this.getStart(), this.getDirection()); } else { return null; } } Ray2D(Vector2D start, Vector2D direction); Vector2D getStart(); void setStart(Vector2D start); Vector2D getDirection(); void setDirection(Vector2D direction); Vector2D intersectionPoint(Ray2D other); Ray2D intersectionRay(Ray2D other); Segment2D intersectionSegment(Ray2D other); boolean contains(Vector2D point); boolean isParallel(Ray2D other); boolean equals(Ray2D other); String toString(); } | @Test public void intersectionRay() throws Exception { aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(5,0); bDirection = GeometryFactory.createVector(1,0); b = GeometryFactory.createRay2D(bStart, bDirection); Ray2D intersectionRay = a.intersectionRay(b); assertTrue(intersectionRay.equals(b)); intersectionRay = b.intersectionRay(a); assertTrue(intersectionRay.equals(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(0,5); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,3); bDirection = GeometryFactory.createVector(0,0.1); b = GeometryFactory.createRay2D(bStart, bDirection); intersectionRay = a.intersectionRay(b); assertTrue(intersectionRay.equals(b)); intersectionRay = b.intersectionRay(a); assertTrue(intersectionRay.equals(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(5,0); bDirection = GeometryFactory.createVector(-1,0); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionRay(b)); aStart = GeometryFactory.createVector(0,0); aDirection = GeometryFactory.createVector(1,0); a = GeometryFactory.createRay2D(aStart, aDirection); bStart = GeometryFactory.createVector(0,5); bDirection = GeometryFactory.createVector(0,-1); b = GeometryFactory.createRay2D(bStart, bDirection); assertNull(a.intersectionRay(b)); } |
OpenAPIStyleValidatorGradlePlugin implements Plugin<Project> { public void apply(Project project) { project.getTasks().register("openAPIStyleValidator", OpenAPIStyleValidatorTask.class); } void apply(Project project); } | @Test public void pluginRegistersATask() { Project project = ProjectBuilder.builder().build(); project.getPlugins().apply("org.openapitools.openapistylevalidator"); assertNotNull(project.getTasks().findByName("openAPIStyleValidator")); } |
Subsets and Splits