public long backOffCurrentSenderThreadValue() { SenderThreadLocalBackOffData currentThreadData = this.get(); return currentThreadData.backOffTimerValue(); }
public void onDoneSending() { SenderThreadLocalBackOffData currentThreadData = this.get(); currentThreadData.onDoneSending(); }
private void testFlushWithData(int expectedTelemetriesNumberInSendNow) { MockSender mockSender = new MockSender() .setExpectedNumberOfScheduleSendCalls(1) .setExpectedNumberOfSendNowCalls(1) .setExpectedTelemetriesNumberInScheduleSend(0) .setExpectedTelemetriesNumberInSendNow(expectedTelemetriesNumberInSendNow); // Create a buffer with max buffer size of 10 and timeout of 10 seconds LimitsEnforcer maxEnforcer = createEnforcerWithCurrentValue(1, 10); LimitsEnforcer sendEnforcer = createEnforcerWithCurrentValue(1, 3); TelemetryBuffer testedBuffer = new TelemetryBuffer(mockSender, maxEnforcer, sendEnforcer); for (int i = 0; i < expectedTelemetriesNumberInSendNow; ++i) { testedBuffer.add("mockTelemetry"); } testedBuffer.flush(); mockSender.waitForFinish(6L); }
private boolean generateTransmissionWithStatusCode(int code) { TransmissionPolicyManager tpm = new TransmissionPolicyManager(true); TransmissionDispatcher mockedDispatcher = Mockito.mock(TransmissionDispatcher.class); TransmissionHandlerArgs args = new TransmissionHandlerArgs(); args.setResponseCode(code); args.setTransmission(new Transmission(new byte[] { 0 }, "testcontent", "testencoding")); args.setTransmissionDispatcher(mockedDispatcher); ThrottlingHandler eh = new ThrottlingHandler(tpm); boolean result = eh.validateTransmissionAndSend(args); return result; }
private boolean generateTransmissionWithStatusCode(int code) { TransmissionPolicyManager tpm = new TransmissionPolicyManager(true); TransmissionDispatcher mockedDispatcher = Mockito.mock(TransmissionDispatcher.class); TransmissionHandlerArgs args = new TransmissionHandlerArgs(); args.setResponseCode(code); args.setTransmission(new Transmission(new byte[] { 0 }, "testcontent", "testencoding")); args.setTransmissionDispatcher(mockedDispatcher); ErrorHandler eh = new ErrorHandler(tpm); boolean result = eh.validateTransmissionAndSend(args); return result; }
/** * Suspend the transmission thread according to the current back off policy. */ public void backoff() { policyState.setCurrentState(TransmissionPolicy.BACKOFF); long backOffMillis = backoffManager.backOffCurrentSenderThreadValue(); if (backOffMillis > 0) { long backOffSeconds = backOffMillis / 1000; InternalLogger.INSTANCE.info("App is throttled, telemetry will be blocked for %s seconds.", backOffSeconds); this.suspendInSeconds(TransmissionPolicy.BACKOFF, backOffSeconds); } }
/** * Create the {@link TransmissionPolicyManager} and set the ability to throttle. * @param throttlingIsEnabled Set whether the {@link TransmissionPolicyManager} can be throttled. */ public TransmissionPolicyManager(boolean throttlingIsEnabled) { suspensionDate = null; this.throttlingIsEnabled = throttlingIsEnabled; this.transmissionHandlers = new ArrayList<TransmissionHandler>(); this.backoffManager = new SenderThreadsBackOffManager(new ExponentialBackOffTimesPolicy()); }
@Test(expected = NullPointerException.class) public void testNoSenderIsSet() throws Exception { LimitsEnforcer maxEnforcer = createDefaultBatchSizeEnforcer(); LimitsEnforcer sendEnforcer = createDefaultSenderTimeoutEnforcer(); new TelemetryBuffer(null, maxEnforcer, sendEnforcer); }
@Override protected SenderThreadLocalBackOffData initialValue() { int addSeconds = threadsSecondsDifference.incrementAndGet(); senderThreadLocalData = new SenderThreadLocalBackOffData(backOffTimeoutsInMilliseconds, addSeconds * 1000); registerSenderData(senderThreadLocalData); return senderThreadLocalData; }
public synchronized void stopAllSendersBackOffActivities() { for (SenderThreadLocalBackOffData sender : allSendersData) { sender.stop(); } stopped = true; }
/** * Flushes the data that the channel might have internally. */ @Override public void flush() { telemetryBuffer.flush(); }
/** * Sets the buffer size * * @param maxTelemetriesInBatch * should be between MIN_MAX_TELEMETRY_BUFFER_CAPACITY and * MAX_MAX_TELEMETRY_BUFFER_CAPACITY inclusive if the number is lower * than the minimum then the minimum will be used if the number is * higher than the maximum then the maximum will be used */ public void setMaxTelemetriesInBatch(int maxTelemetriesInBatch) { telemetryBuffer.setMaxTelemetriesInBatch(maxTelemetriesInBatch); }
/** * Sets the time tow wait before flushing the internal buffer * * @param transmitBufferTimeoutInSeconds * should be between MIN_FLUSH_BUFFER_TIMEOUT_IN_SECONDS and * MAX_FLUSH_BUFFER_TIMEOUT_IN_SECONDS inclusive if the number is * lower than the minimum then the minimum will be used if the number * is higher than the maximum then the maximum will be used */ public void setTransmitBufferTimeoutInSeconds(int transmitBufferTimeoutInSeconds) { telemetryBuffer.setTransmitBufferTimeoutInSeconds(transmitBufferTimeoutInSeconds); }
private static Transmission createMockTransmission() { byte[] mockContent = new byte[2]; Transmission tested = new Transmission(mockContent, MOCK_WEB_CONTENT_TYPE, MOCK_WEB_ENCODING_TYPE); return tested; } }
private static void verifyMultipleThreadsStoppedBeforeBackOff(SenderThreadsBackOffManager manager, int numberOfThreads, int expectedMaxSeconds) throws InterruptedException { verifyMultipleThreadsWithStopBackOff(manager, numberOfThreads, expectedMaxSeconds, true); }
@Override public void run() { dispatch(telemetries); } }
private static void verifyBackOff(SenderThreadsBackOffManager manager, int backOffTimes, long expectedMilliseconds, boolean... expectedBackOffResult) throws InterruptedException { verifyBackOffWithDoneSending(manager, backOffTimes, expectedMilliseconds, null, expectedBackOffResult); }
@Override public void run() { sender.stop(); } });
private static void verifyMultipleThreadsStoppedWhileBackOff(SenderThreadsBackOffManager manager, int numberOfThreads, long expectedMaxMilliseconds) throws InterruptedException { verifyMultipleThreadsWithStopBackOff(manager, numberOfThreads, expectedMaxMilliseconds, false); }