@Override public Map<String, Long> getIndexedUptoPerLane() { Map<String, Long> result = new HashMap<>(); for (AsyncIndexInfo info : infos.values()) { result.put(info.getName(), info.getLastIndexedTo()); } return result; }
public void addInfo(String name, long lastIndexedTo) { infos.put(name, new AsyncIndexInfo(name, lastIndexedTo, 0, false, null)); } }
private IndexStatsMBean getIndexStatsMBean(String asyncIndexerLane) { AsyncIndexInfo info = infoService.getInfo(asyncIndexerLane); checkNotNull(info, "No AsyncIndexInfo found for lane [%s]", asyncIndexerLane); IndexStatsMBean mbean = info.getStatsMBean(); return checkNotNull(mbean, "No IndexStatsMBean associated with [%s]", asyncIndexerLane); }
private void printAsyncIndexInfo(PrintWriter pw) { List<String> asyncLanes = ImmutableList.copyOf(asyncIndexInfoService.getAsyncLanes()); String title = "Async Indexers State"; printTitle(pw, title); pw.printf("Number of async indexer lanes : %d%n", asyncLanes.size()); pw.println(); for (String lane : asyncLanes) { pw.println(lane); AsyncIndexInfo info = asyncIndexInfoService.getInfo(lane); if (info != null) { pw.printf(" Last indexed to : %s%n", formatTime(info.getLastIndexedTo())); IndexStatsMBean stats = info.getStatsMBean(); if (stats != null) { pw.printf(" Status : %s%n", stats.getStatus()); pw.printf(" Failing : %s%n", stats.isFailing()); pw.printf(" Paused : %s%n", stats.isPaused()); if (stats.isFailing()) { pw.printf(" Failing since : %s%n", stats.getFailingSince()); pw.printf(" Latest error : %s%n", stats.getLatestError()); } } pw.println(); } } }
@Test public void info() throws Exception{ AsyncIndexUpdate async = new AsyncIndexUpdate("foo-async", store, provider); async.run(); Set<String> names = ImmutableSet.copyOf(service.getAsyncLanes()); assertThat(names, containsInAnyOrder("foo-async")); service.bindStatsMBeans(async.getIndexStats()); AsyncIndexInfo info = service.getInfo("foo-async"); assertNotNull(info); assertEquals("foo-async", info.getName()); assertNotNull(info.getStatsMBean()); assertTrue(info.getLastIndexedTo() > -1); assertFalse(info.isRunning()); assertEquals(-1, info.getLeaseExpiryTime()); System.out.println(info); service.unbindStatsMBeans(async.getIndexStats()); AsyncIndexInfo info2 = service.getInfo("foo-async"); assertNull(info2.getStatsMBean()); }
private void computeAsyncIndexInfo(NodeState idxState, String indexPath, LuceneIndexInfo info) { String asyncName = IndexUtils.getAsyncLaneName(idxState, indexPath); if (asyncName == null) { log.warn("No 'async' value for index definition at [{}]. Definition {}", indexPath, idxState); return; } AsyncIndexInfo asyncInfo = asyncInfoService.getInfo(asyncName); checkNotNull(asyncInfo, "No async info found for name [%s] " + "for index at [%s]", asyncName, indexPath); info.indexedUptoTime = asyncInfo.getLastIndexedTo(); info.asyncName = asyncName; }
private void printAsyncIndexInfo(PrintWriter pw) { List<String> asyncLanes = ImmutableList.copyOf(asyncIndexInfoService.getAsyncLanes()); String title = "Async Indexers State"; printTitle(pw, title); pw.printf("Number of async indexer lanes : %d%n", asyncLanes.size()); pw.println(); for (String lane : asyncLanes) { pw.println(lane); AsyncIndexInfo info = asyncIndexInfoService.getInfo(lane); if (info != null) { pw.printf(" Last indexed to : %s%n", formatTime(info.getLastIndexedTo())); IndexStatsMBean stats = info.getStatsMBean(); if (stats != null) { pw.printf(" Status : %s%n", stats.getStatus()); pw.printf(" Failing : %s%n", stats.isFailing()); pw.printf(" Paused : %s%n", stats.isPaused()); if (stats.isFailing()) { pw.printf(" Failing since : %s%n", stats.getFailingSince()); pw.printf(" Latest error : %s%n", stats.getLatestError()); } } pw.println(); } } }
private void computeAsyncIndexInfo(NodeState idxState, String indexPath, LuceneIndexInfo info) { String asyncName = IndexUtils.getAsyncLaneName(idxState, indexPath); if (asyncName == null) { log.warn("No 'async' value for index definition at [{}]. Definition {}", indexPath, idxState); return; } AsyncIndexInfo asyncInfo = asyncInfoService.getInfo(asyncName); checkNotNull(asyncInfo, "No async info found for name [%s] " + "for index at [%s]", asyncName, indexPath); info.indexedUptoTime = asyncInfo.getLastIndexedTo(); info.asyncName = asyncName; }
private void printAsyncIndexInfo(PrintWriter pw) { List<String> asyncLanes = ImmutableList.copyOf(asyncIndexInfoService.getAsyncLanes()); String title = "Async Indexers State"; printTitle(pw, title); pw.printf("Number of async indexer lanes : %d%n", asyncLanes.size()); pw.println(); for (String lane : asyncLanes) { pw.println(lane); AsyncIndexInfo info = asyncIndexInfoService.getInfo(lane); if (info != null) { pw.printf(" Last indexed to : %s%n", formatTime(info.getLastIndexedTo())); IndexStatsMBean stats = info.getStatsMBean(); if (stats != null) { pw.printf(" Status : %s%n", stats.getStatus()); pw.printf(" Failing : %s%n", stats.isFailing()); pw.printf(" Paused : %s%n", stats.isPaused()); if (stats.isFailing()) { pw.printf(" Failing since : %s%n", stats.getFailingSince()); pw.printf(" Latest error : %s%n", stats.getLatestError()); } } pw.println(); } } }
@Before public void setup(){ infoService = mock(AsyncIndexInfoService.class); AsyncIndexInfo info = new AsyncIndexInfo("async", -1,-1, false, statsMBean); when(infoService.getInfo("async")).thenReturn(info); }
private IndexStatsMBean getIndexStatsMBean(String asyncIndexerLane) { AsyncIndexInfo info = infoService.getInfo(asyncIndexerLane); checkNotNull(info, "No AsyncIndexInfo found for lane [%s]", asyncIndexerLane); IndexStatsMBean mbean = info.getStatsMBean(); return checkNotNull(mbean, "No IndexStatsMBean associated with [%s]", asyncIndexerLane); }
@Test public void asyncIndexInfo() throws Exception { when(indexInfo.getAllIndexInfo()).thenReturn(emptyList()); when(asyncInfo.getAsyncLanes()).thenReturn(asList("foo-async", "bar-async")); when(asyncInfo.getInfo("foo-async")) .thenReturn(new AsyncIndexInfo("foo-async", 0, 0, false, null)); String output = getPrintOutput(); assertThat(output, containsString("foo-async")); }
private IndexStatsMBean getIndexStatsMBean(String asyncIndexerLane) { AsyncIndexInfo info = infoService.getInfo(asyncIndexerLane); checkNotNull(info, "No AsyncIndexInfo found for lane [%s]", asyncIndexerLane); IndexStatsMBean mbean = info.getStatsMBean(); return checkNotNull(mbean, "No IndexStatsMBean associated with [%s]", asyncIndexerLane); }
@Override public AsyncIndexInfo getInfo(String name, NodeState root) { NodeState async = getAsyncState(root); if (async.hasProperty(name)) { long lastIndexedTo = getLastIndexedTo(name, async); long leaseEnd = -1; boolean running = false; if (async.hasProperty(AsyncIndexUpdate.leasify(name))) { running = true; leaseEnd = async.getLong(AsyncIndexUpdate.leasify(name)); } IndexStatsMBean mbean = statsMBeans.get(name); return new AsyncIndexInfo(name, lastIndexedTo, leaseEnd, running, mbean); } return null; }
Map<IndexStatsMBean, Long> origIndexLaneToExecutinoCountMap = Maps.asMap( Sets.newHashSet(StreamSupport.stream(asyncIndexInfoService.getAsyncLanes().spliterator(), false) .map(lane -> asyncIndexInfoService.getInfo(lane).getStatsMBean()) .filter(bean -> { String beanStatus;
@Override public AsyncIndexInfo getInfo(String name, NodeState root) { NodeState async = getAsyncState(root); if (async.hasProperty(name)) { long lastIndexedTo = getLastIndexedTo(name, async); long leaseEnd = -1; boolean running = false; if (async.hasProperty(AsyncIndexUpdate.leasify(name))) { running = true; leaseEnd = async.getLong(AsyncIndexUpdate.leasify(name)); } IndexStatsMBean mbean = statsMBeans.get(name); return new AsyncIndexInfo(name, lastIndexedTo, leaseEnd, running, mbean); } return null; }
Map<IndexStatsMBean, Long> origIndexLaneToExecutinoCountMap = Maps.asMap( Sets.newHashSet(StreamSupport.stream(asyncIndexInfoService.getAsyncLanes().spliterator(), false) .map(lane -> asyncIndexInfoService.getInfo(lane).getStatsMBean()) .filter(bean -> { String beanStatus;
@Override public AsyncIndexInfo getInfo(String name, NodeState root) { NodeState async = getAsyncState(root); if (async.hasProperty(name)) { long lastIndexedTo = getLastIndexedTo(name, async); long leaseEnd = -1; boolean running = false; if (async.hasProperty(AsyncIndexUpdate.leasify(name))) { running = true; leaseEnd = async.getLong(AsyncIndexUpdate.leasify(name)); } IndexStatsMBean mbean = statsMBeans.get(name); return new AsyncIndexInfo(name, lastIndexedTo, leaseEnd, running, mbean); } return null; }
static AsyncIndexInfoService getAsyncIndexInfoService(List<IndexMBeanInfoSupplier> infoSuppliers) { AsyncIndexInfoService service = mock(AsyncIndexInfoService.class); List<String> asyncLanes = Lists.newArrayList(); for (IndexMBeanInfoSupplier info : infoSuppliers) { String lane = info.getName(); IndexStatsMBean bean = mock(IndexStatsMBean.class); when(bean.getName()).thenReturn(lane); when(bean.getStatus()).then(mockObj -> info.getStatus()); when(bean.getTotalExecutionCount()).then(mockObj -> info.getExecCnt()); when(service.getInfo(lane)).then(mockObj -> new AsyncIndexInfo( lane, 1324L, 4567L, STATUS_RUNNING.equals(info.getStatus()), bean )); asyncLanes.add(lane); } when(service.getAsyncLanes()).thenReturn(asyncLanes); return service; }
@Test public void info() throws Exception { IndexDefinitionBuilder defnBuilder = new IndexDefinitionBuilder(); NodeBuilder builder = store.getRoot().builder(); builder.child("oak:index").setChildNode("fooIndex", defnBuilder.build()); store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY); when(asyncService.getInfo("async")) .thenReturn(new AsyncIndexInfo("async", 0,0, false, null)); IndexInfo info = provider.getInfo("/oak:index/fooIndex"); assertNotNull(info); }