/** * Notifies listeners about profile update. * * @param old * Old profile instance. * @param updated * Updated profile instance. */ private void publishProfileUpdateEvent(Profile old, Profile updated) { ProfileUpdateEvent profileUpdateEvent = new ProfileUpdateEvent(this, old, updated); eventPublisher.publishEvent(profileUpdateEvent); }
/** * {@inheritDoc} */ @Override protected Collection<ImmutableType> execute() { // always update configuration getConfigurationHolder().update(getEnvironment(), getAgentId()); Collection<ImmutableType> changedClassTypes = new HashSet<>(); // first process all removed and added assignments changedClassTypes.addAll(super.processRemovedAssignments(profileUpdateEvent.getRemovedSensorAssignments())); changedClassTypes.addAll(super.processAddedAssignments(profileUpdateEvent.getAddedSensorAssignments())); return changedClassTypes; }
@Test public void emptyCacheMap() { when(event.isProfileActive()).thenReturn(true); when(event.getProfileId()).thenReturn("id_1"); eventListener.onApplicationEvent(event); verify(event).isProfileActive(); verify(nextGenInstrumentationManager).getAgentCacheMap(); verifyNoMoreInteractions(event, nextGenInstrumentationManager); verifyZeroInteractions(cacheEntry, configurationHolder, environment, updateJob, future, objectFactory, executor); }
/** * Returns all {@link AbstractClassSensorAssignment} that are "added" as result of this update. * If profile was activated then it means that all assignments after the update are considered * for adding. * * @return Returns all {@link AbstractClassSensorAssignment} that are "removed". */ public Collection<AbstractClassSensorAssignment<?>> getAddedSensorAssignments() { if (isProfileDeactivated()) { // if it was deactivated then nothing is for adding return Collections.emptyList(); } else if (isProfileActivated()) { // if activated then we consider all new assignment to be for adding return getAllSensorAssignments(after); } else { // otherwise find the difference return getAssignmentsDifference(after, before); } }
@Test public void profileNotActive() { cacheMap.put(1L, cacheEntry); eventListener.onApplicationEvent(event); verify(event).isProfileActive(); verify(event).isProfileDeactivated(); verifyNoMoreInteractions(event); verifyZeroInteractions(cacheEntry, configurationHolder, environment, updateJob, future, nextGenInstrumentationManager, objectFactory, executor); }
@Test public void activated() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); doReturn(Collections.singletonList(assignment)).when(oldProfileData).getData(SensorAssignmentProfileData.class); doReturn(Collections.singletonList(assignment)).when(updatedProfileData).getData(SensorAssignmentProfileData.class); when(old.isActive()).thenReturn(false); when(updated.isActive()).thenReturn(true); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); Collection<AbstractClassSensorAssignment<?>> removed = event.getRemovedSensorAssignments(); assertThat(removed, is(empty())); }
@Test public void noChange() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); doReturn(Collections.singletonList(assignment)).when(oldProfileData).getData(SensorAssignmentProfileData.class); doReturn(Collections.singletonList(assignment)).when(updatedProfileData).getData(SensorAssignmentProfileData.class); when(old.isActive()).thenReturn(true); when(updated.isActive()).thenReturn(true); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); Collection<AbstractClassSensorAssignment<?>> added = event.getAddedSensorAssignments(); assertThat(added, is(empty())); }
public void onApplicationEvent(ProfileUpdateEvent event) { if (!event.isProfileActive() && !event.isProfileDeactivated()) { return; if (CollectionUtils.isEmpty(environment.getProfileIds()) || !environment.getProfileIds().contains(event.getProfileId())) { continue;
@Test public void stillActive() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); when(old.isActive()).thenReturn(true); when(updated.isActive()).thenReturn(true); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); boolean deactivated = event.isProfileDeactivated(); assertThat(deactivated, is(false)); } }
@Test public void wasActive() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); when(old.isActive()).thenReturn(true); when(updated.isActive()).thenReturn(true); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); boolean activated = event.isProfileActivated(); assertThat(activated, is(false)); }
@Test public void removedAssignmentNoChange() throws RemoteException { Collection<ClassType> types = ImmutableList.of(classTypeOne, classTypeTwo); doReturn(instrumentationApplier).when(configurationResolver).getInstrumentationApplier(sensorAssignment, environment); doReturn(types).when(classCacheSearchNarrower).narrowByClassSensorAssignment(classCache, sensorAssignment); doReturn(Collections.emptyList()).when(instrumentationService).removeInstrumentationPoints(eq(types), Matchers.<Collection<IInstrumentationApplier>> any()); doReturn(Collections.singleton(sensorAssignment)).when(event).getRemovedSensorAssignments(); job.setProfileUpdateEvent(event); job.run(); ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class); verify(instrumentationService, times(1)).removeInstrumentationPoints(eq(types), captor.capture()); assertThat((Collection<IInstrumentationApplier>) captor.getValue(), hasSize(1)); assertThat(((Collection<IInstrumentationApplier>) captor.getValue()).iterator().next(), is(instrumentationApplier)); verifyNoMoreInteractions(instrumentationService); verifyZeroInteractions(environment, eventPublisher); } }
@Test public void addedAssignment() throws RemoteException { Collection<ClassType> types = ImmutableList.of(classTypeOne, classTypeTwo); doReturn(instrumentationApplier).when(configurationResolver).getInstrumentationApplier(sensorAssignment, environment); doReturn(types).when(classCacheSearchNarrower).narrowByClassSensorAssignment(classCache, sensorAssignment); doReturn(types).when(instrumentationService).addInstrumentationPoints(eq(types), eq(agentConfiguration), Matchers.<Collection<IInstrumentationApplier>> any()); doReturn(Collections.singleton(sensorAssignment)).when(event).getAddedSensorAssignments(); job.setProfileUpdateEvent(event); job.run(); ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class); verify(instrumentationService, times(1)).addInstrumentationPoints(eq(types), eq(agentConfiguration), captor.capture()); assertThat((Collection<IInstrumentationApplier>) captor.getValue(), hasSize(1)); assertThat(((Collection<IInstrumentationApplier>) captor.getValue()).iterator().next(), is(instrumentationApplier)); ArgumentCaptor<Collection> typeCaptor = ArgumentCaptor.forClass(Collection.class); verify(instrumentationService).getInstrumentationResults(typeCaptor.capture()); assertThat((Collection<ClassType>) typeCaptor.getValue(), hasItems(classTypeOne, classTypeTwo)); ArgumentCaptor<ClassInstrumentationChangedEvent> eventCaptor = ArgumentCaptor.forClass(ClassInstrumentationChangedEvent.class); verify(eventPublisher).publishEvent(eventCaptor.capture()); assertThat(eventCaptor.getValue().getAgentId(), is(equalTo(10L))); Matcher<InstrumentationDefinition> matcherOne = org.hamcrest.Matchers.<InstrumentationDefinition> hasProperty("className", equalTo("fqnOne")); Matcher<InstrumentationDefinition> matcherTwo = org.hamcrest.Matchers.<InstrumentationDefinition> hasProperty("className", equalTo("fqnTwo")); assertThat(eventCaptor.getValue().getInstrumentationDefinitions(), hasItems(matcherOne, matcherTwo)); verifyNoMoreInteractions(instrumentationService, eventPublisher); verifyZeroInteractions(environment); }
/** * Finds {@link AbstractClassSensorAssignment}s that exists in first profile and not in the * second one. * * @param p1 * First profile * @param p2 * Second profile * @return {@link AbstractClassSensorAssignment}s that exists in first profile and not in the * second one. */ private Collection<AbstractClassSensorAssignment<?>> getAssignmentsDifference(Profile p1, Profile p2) { Collection<AbstractClassSensorAssignment<?>> results1 = getAllSensorAssignments(p1); Collection<AbstractClassSensorAssignment<?>> results2 = getAllSensorAssignments(p2); return CollectionSubtractUtils.subtractSafe(results1, results2); }
@Test public void noChange() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); doReturn(Collections.singletonList(assignment)).when(oldProfileData).getData(SensorAssignmentProfileData.class); doReturn(Collections.singletonList(assignment)).when(updatedProfileData).getData(SensorAssignmentProfileData.class); when(old.isActive()).thenReturn(true); when(updated.isActive()).thenReturn(true); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); Collection<AbstractClassSensorAssignment<?>> removed = event.getRemovedSensorAssignments(); assertThat(removed, is(empty())); }
@Test public void deactivated() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); doReturn(Collections.singletonList(assignment)).when(oldProfileData).getData(SensorAssignmentProfileData.class); doReturn(Collections.singletonList(assignment)).when(updatedProfileData).getData(SensorAssignmentProfileData.class); when(old.isActive()).thenReturn(true); when(updated.isActive()).thenReturn(false); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); Collection<AbstractClassSensorAssignment<?>> added = event.getAddedSensorAssignments(); assertThat(added, is(empty())); }
/** * Returns all {@link AbstractClassSensorAssignment} that are "removed" as result of this * update. If profile was deactivated then it means that all assignments before the update are * considered for removal. * * @return Returns all {@link AbstractClassSensorAssignment} that are "removed". */ public Collection<AbstractClassSensorAssignment<?>> getRemovedSensorAssignments() { if (isProfileDeactivated()) { // if deactivated then we consider all old assignment to be for removal return getAllSensorAssignments(before); } else if (isProfileActivated()) { // if it was activated then nothing is for removal return Collections.emptyList(); } else { // otherwise find the difference return getAssignmentsDifference(before, after); } }
@Test @SuppressWarnings({ "unchecked", "rawtypes" }) public void profileWasDeactivated() throws InterruptedException, ExecutionException, TimeoutException { cacheMap.put(1L, cacheEntry); when(event.isProfileDeactivated()).thenReturn(true); when(event.getProfileId()).thenReturn("id_1"); when(configurationHolder.isInitialized()).thenReturn(true); when(environment.getProfileIds()).thenReturn(Sets.newHashSet("id_1")); when(objectFactory.getObject()).thenReturn(updateJob); when(executor.submit(updateJob)).thenReturn((Future) future); eventListener.onApplicationEvent(event); verify(event).isProfileActive(); verify(event).isProfileDeactivated(); verify(event).getProfileId(); verify(nextGenInstrumentationManager).getAgentCacheMap(); verify(cacheEntry).getConfigurationHolder(); verify(configurationHolder).getEnvironment(); verify(configurationHolder).isInitialized(); verify(environment, times(2)).getProfileIds(); verify(objectFactory).getObject(); verify(executor).submit(updateJob); verify(updateJob).setAgentCacheEntry(cacheEntry); verify(updateJob).setProfileUpdateEvent(event); verify(future).get(1L, TimeUnit.MINUTES); verifyNoMoreInteractions(event, cacheEntry, configurationHolder, environment, updateJob, future, nextGenInstrumentationManager, objectFactory, executor); }
@Test public void deactivated() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); when(old.isActive()).thenReturn(true); when(updated.isActive()).thenReturn(false); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); boolean deactivated = event.isProfileDeactivated(); assertThat(deactivated, is(true)); }
@Test public void stillNotActive() { when(old.getId()).thenReturn(ID); when(updated.getId()).thenReturn(ID); when(old.isActive()).thenReturn(false); when(updated.isActive()).thenReturn(false); ProfileUpdateEvent event = new ProfileUpdateEvent(this, old, updated); boolean activated = event.isProfileActivated(); assertThat(activated, is(false)); } }
@Test public void removedAssignment() throws RemoteException { Collection<ClassType> types = ImmutableList.of(classTypeOne, classTypeTwo); doReturn(instrumentationApplier).when(configurationResolver).getInstrumentationApplier(sensorAssignment, environment); doReturn(types).when(classCacheSearchNarrower).narrowByClassSensorAssignment(classCache, sensorAssignment); doReturn(types).when(instrumentationService).removeInstrumentationPoints(eq(types), Matchers.<Collection<IInstrumentationApplier>> any()); doReturn(Collections.singleton(sensorAssignment)).when(event).getRemovedSensorAssignments(); job.setProfileUpdateEvent(event); job.run(); ArgumentCaptor<Collection> captor = ArgumentCaptor.forClass(Collection.class); verify(instrumentationService, times(1)).removeInstrumentationPoints(eq(types), captor.capture()); assertThat((Collection<IInstrumentationApplier>) captor.getValue(), hasSize(1)); assertThat(((Collection<IInstrumentationApplier>) captor.getValue()).iterator().next(), is(instrumentationApplier)); ArgumentCaptor<Collection> typeCaptor = ArgumentCaptor.forClass(Collection.class); verify(instrumentationService).getInstrumentationResults(typeCaptor.capture()); assertThat((Collection<ClassType>) typeCaptor.getValue(), hasItems(classTypeOne, classTypeTwo)); Collection<IInstrumentationApplier> appliers = configurationHolder.getInstrumentationAppliers(); verify(instrumentationService, times(1)).addInstrumentationPoints(captor.capture(), eq(agentConfiguration), eq(appliers)); assertThat((Collection<ClassType>) captor.getValue(), hasSize(2)); assertThat(((Collection<ClassType>) captor.getValue()).iterator().next(), is(classTypeOne)); ArgumentCaptor<ClassInstrumentationChangedEvent> eventCaptor = ArgumentCaptor.forClass(ClassInstrumentationChangedEvent.class); verify(eventPublisher).publishEvent(eventCaptor.capture()); assertThat(eventCaptor.getValue().getAgentId(), is(equalTo(10L))); Matcher<InstrumentationDefinition> matcherOne = org.hamcrest.Matchers.<InstrumentationDefinition> hasProperty("className", equalTo("fqnOne")); Matcher<InstrumentationDefinition> matcherTwo = org.hamcrest.Matchers.<InstrumentationDefinition> hasProperty("className", equalTo("fqnTwo")); assertThat(eventCaptor.getValue().getInstrumentationDefinitions(), hasItems(matcherOne, matcherTwo)); verifyNoMoreInteractions(instrumentationService, eventPublisher); verifyZeroInteractions(environment); }