/** * Handles an event of type {@link AgentDeletedEvent}. * * @param event * the event instance */ private void handleAgentDeletedEvent(AgentDeletedEvent event) { clear(event.getPlatformId()); }
/** * {@inheritDoc} */ @Override @MethodLog public List<IAgentMessage<?>> fetchAgentMessages(long platformId) { return messageProvider.fetchMessages(platformId); }
/** * Puts the given {@link IAgentMessage} in the list which can be fetched by the agent. * * @param platformId * the id of the agent to receive the message * @param message * the {@link IAgentMessage} */ public synchronized void provideMessage(long platformId, IAgentMessage<?> message) { if (message == null) { throw new IllegalArgumentException("The agent message may not be null."); } List<IAgentMessage<?>> messageList = Arrays.<IAgentMessage<?>> asList(message); provideMessages(platformId, messageList); }
/** * {@inheritDoc} */ @Override public void onApplicationEvent(ApplicationEvent event) { if (event instanceof AgentDeletedEvent) { handleAgentDeletedEvent((AgentDeletedEvent) event); } else if (event instanceof AgentRegisteredEvent) { handleAgentRegisteredEvent((AgentRegisteredEvent) event); } }
@Test public void unknownEvent() { messageProvider.provideMessages(10L, Collections.<IAgentMessage<?>> singletonList(mock(IAgentMessage.class))); ApplicationEvent event = mock(ApplicationEvent.class); messageProvider.onApplicationEvent(event); assertThat(messageProvider.fetchMessages(10L), hasSize(1)); }
@Test public void successful() { IAgentMessage<?> messageOne = mock(IAgentMessage.class); IAgentMessage<?> messageTwo = mock(IAgentMessage.class); messageProvider.provideMessages(10L, Arrays.asList(messageOne, messageTwo)); messageProvider.clear(10L); assertThat(messageProvider.fetchMessages(10L), hasSize(0)); }
@Test(expectedExceptions = IllegalArgumentException.class) public void nullMessages() { try { messageProvider.provideMessages(10L, null); } finally { assertThat(messageProvider.fetchMessages(10L), hasSize(0)); } }
@Test @SuppressWarnings("unchecked") public void successful() { IAgentMessage<?> messageOne = mock(IAgentMessage.class); IAgentMessage<?> messageTwo = mock(IAgentMessage.class); IAgentMessage<?> messageThree = mock(IAgentMessage.class); messageProvider.provideMessages(10L, Arrays.asList(messageOne, messageTwo)); Collection<IAgentMessage<?>> resultOne = messageProvider.fetchMessages(10L); Collection<IAgentMessage<?>> resultTwo = messageProvider.fetchMessages(10L); messageProvider.provideMessage(10L, messageThree); Collection<IAgentMessage<?>> resultThree = messageProvider.fetchMessages(10L); assertThat(resultOne, contains(messageOne, messageTwo)); assertThat(resultTwo, is(empty())); assertThat(resultThree, hasSize(1)); assertThat(resultThree, hasItem(messageThree)); }
@Test(expectedExceptions = IllegalArgumentException.class) public void nullMessage() { try { messageProvider.provideMessage(10L, null); } finally { assertThat(messageProvider.fetchMessages(10L), hasSize(0)); } } }
/** * Creates an {@link UpdatedInstrumentationMessage} which contains all stored * {@link InstrumentationDefinition}. The created message is put in the message provider for the * agent to fetch. * * @param platformId * the id of the platform which {@link InstrumentationDefinition}s should be provided * for fetching */ public synchronized void flush(long platformId) { if (log.isDebugEnabled()) { log.debug("Flushing new instrumentations for agent {}.", platformId); } Map<String, InstrumentationDefinition> pendingDefinitions = definitionBuffer.put(platformId, new HashMap<String, InstrumentationDefinition>()); if (MapUtils.isNotEmpty(pendingDefinitions)) { UpdatedInstrumentationMessage message = new UpdatedInstrumentationMessage(); message.getMessageContent().addAll(pendingDefinitions.values()); messageProvider.provideMessage(platformId, message); } AgentStatusData agentStatusData = agentStatusDataProvider.getAgentStatusDataMap().get(platformId); if (agentStatusData != null) { agentStatusData.setInstrumentationStatus(InstrumentationStatus.UP_TO_DATE); } }
/** * Fetches all available messages for the agent with the given id. The returned list is an * ordered list, ordered by time (ascending -> index 0 is the oldest). * * @param platformId * the agent id * @return {@link List} of {@link IAgentMessage}s. */ public synchronized List<IAgentMessage<?>> fetchMessages(long platformId) { if (log.isTraceEnabled()) { log.trace("Fetch messages for agent {}.", platformId); } List<IAgentMessage<?>> currentList = agentMessageMap.put(platformId, new ArrayList<IAgentMessage<?>>()); if (CollectionUtils.isEmpty(currentList)) { currentList = Collections.emptyList(); } // update timestamp of method idents (resulting in a disabled method ident) updateMethodIdentTimestamps(platformId, currentList); return currentList; }
@Test public void nullEvent() { messageProvider.provideMessages(10L, Collections.<IAgentMessage<?>> singletonList(mock(IAgentMessage.class))); messageProvider.onApplicationEvent(null); assertThat(messageProvider.fetchMessages(10L), hasSize(1)); } }
@Test @SuppressWarnings("unchecked") public void unknownPlatformId() { IAgentMessage<?> messageOne = mock(IAgentMessage.class); IAgentMessage<?> messageTwo = mock(IAgentMessage.class); messageProvider.provideMessages(10L, Arrays.asList(messageOne, messageTwo)); messageProvider.clear(20L); assertThat(messageProvider.fetchMessages(10L), contains(messageOne, messageTwo)); } }
@Test(expectedExceptions = IllegalArgumentException.class) @SuppressWarnings("unchecked") public void emptyMessages() { try { messageProvider.provideMessages(10L, Collections.EMPTY_LIST); } finally { assertThat(messageProvider.fetchMessages(10L), hasSize(0)); } } }
@Test @SuppressWarnings("unchecked") public void successful() { IAgentMessage<?> messageOne = mock(IAgentMessage.class); IAgentMessage<?> messageTwo = mock(IAgentMessage.class); IAgentMessage<?> messageThree = mock(IAgentMessage.class); messageProvider.provideMessage(10L, messageOne); messageProvider.provideMessage(10L, messageTwo); messageProvider.provideMessage(10L, messageThree); assertThat(messageProvider.fetchMessages(10L), contains(messageOne, messageTwo, messageThree)); }
@Test @SuppressWarnings("rawtypes") public void successful() throws Exception { when(definition.getClassName()).thenReturn("class.one"); ClassInstrumentationChangedEvent event = new ClassInstrumentationChangedEvent(this, 10L, Arrays.asList(definition)); messageGate.onApplicationEvent(event); when(agentStatusDataProvider.getAgentStatusDataMap()).thenReturn(ImmutableMap.of(10L, statusData)); when(statusData.getInstrumentationStatus()).thenReturn(InstrumentationStatus.PENDING); assertThat(getDefinitionBuffer().get(10L).entrySet(), hasSize(1)); messageGate.flush(10L); ArgumentCaptor<IAgentMessage> messageCaptor = ArgumentCaptor.forClass(IAgentMessage.class); verify(messageProvider).provideMessage(eq(10L), messageCaptor.capture()); verify(statusData).setInstrumentationStatus(InstrumentationStatus.UP_TO_DATE); verifyNoMoreInteractions(statusData, messageProvider); assertThat(((UpdatedInstrumentationMessage) messageCaptor.getValue()).getMessageContent(), contains(definition)); assertThat(getDefinitionBuffer().get(10L).entrySet(), hasSize(0)); }
@Test public void agentDeletedEvent() { messageProvider.provideMessages(10L, Collections.<IAgentMessage<?>> singletonList(mock(IAgentMessage.class))); messageProvider.provideMessages(15L, Collections.<IAgentMessage<?>> singletonList(mock(IAgentMessage.class))); AgentDeletedEvent event = new AgentDeletedEvent(this, 10L); messageProvider.onApplicationEvent(event); assertThat(messageProvider.fetchMessages(10L), hasSize(0)); assertThat(messageProvider.fetchMessages(15L), hasSize(1)); }
@Test public void unknownPlatformId() { IAgentMessage<?> messageOne = mock(IAgentMessage.class); IAgentMessage<?> messageTwo = mock(IAgentMessage.class); messageProvider.provideMessages(10L, Arrays.asList(messageOne, messageTwo)); Collection<IAgentMessage<?>> result = messageProvider.fetchMessages(1L); assertThat(result, hasSize(0)); } }
@Test public void successful() throws Exception { agentService.fetchAgentMessages(10L); verify(messageProvider).fetchMessages(10L); verifyNoMoreInteractions(messageProvider); verifyZeroInteractions(instrumentationManager); } }
/** * Handles an event of type {@link AgentRegisteredEvent}. * * @param event * the event instance */ private void handleAgentRegisteredEvent(AgentRegisteredEvent event) { clear(event.getPlatformId()); } }