SONAR-6837 Allow to configure WS read timeout from batch

5 files changed, 115 insertions, 88 deletions

diff --git a/sonar-batch/src/test/java/org/sonar/batch/analysis/AnalysisWSLoaderProviderTest.java b/sonar-batch/src/test/java/org/sonar/batch/analysis/AnalysisWSLoaderProviderTest.java
index 9e80507094b..7624edf7b28 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/analysis/AnalysisWSLoaderProviderTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/analysis/AnalysisWSLoaderProviderTest.java
@@ -19,22 +19,18 @@
  */
 package org.sonar.batch.analysis;
 
-import org.sonar.batch.analysis.AnalysisWSLoaderProvider;
-
-import org.sonar.batch.cache.WSLoader;
-import org.sonar.batch.cache.WSLoader.LoadStrategy;
-import org.sonar.batch.analysis.AnalysisProperties;
-import org.sonar.api.batch.AnalysisMode;
+import java.util.HashMap;
+import java.util.Map;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.sonar.api.batch.AnalysisMode;
 import org.sonar.batch.bootstrap.ServerClient;
+import org.sonar.batch.cache.WSLoader;
+import org.sonar.batch.cache.WSLoader.LoadStrategy;
 import org.sonar.home.cache.PersistentCache;
 
-import java.util.HashMap;
-import java.util.Map;
-
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class AnalysisWSLoaderProviderTest {
diff --git a/sonar-batch/src/test/java/org/sonar/batch/cache/StrategyWSLoaderProviderTest.java b/sonar-batch/src/test/java/org/sonar/batch/cache/StrategyWSLoaderProviderTest.java
index a7c613056bf..5d9ed445822 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/cache/StrategyWSLoaderProviderTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/cache/StrategyWSLoaderProviderTest.java
@@ -19,16 +19,17 @@
  */
 package org.sonar.batch.cache;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-import org.sonar.batch.cache.WSLoader.LoadStrategy;
-
 import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.sonar.batch.bootstrap.GlobalProperties;
 import org.sonar.batch.bootstrap.ServerClient;
-import org.mockito.Mock;
+import org.sonar.batch.cache.WSLoader.LoadStrategy;
 import org.sonar.home.cache.PersistentCache;
-import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 public class StrategyWSLoaderProviderTest {
   @Mock
@@ -37,15 +38,18 @@ public class StrategyWSLoaderProviderTest {
   @Mock
   private ServerClient client;
 
+  private GlobalProperties globalProps;
+
   @Before
   public void setUp() {
     MockitoAnnotations.initMocks(this);
+    globalProps = mock(GlobalProperties.class);
   }
 
   @Test
   public void testStrategy() {
     StrategyWSLoaderProvider provider = new StrategyWSLoaderProvider(LoadStrategy.CACHE_FIRST);
-    WSLoader wsLoader = provider.provide(cache, client);
+    WSLoader wsLoader = provider.provide(cache, client, globalProps);
 
     assertThat(wsLoader.getDefaultStrategy()).isEqualTo(LoadStrategy.CACHE_FIRST);
   }
@@ -53,8 +57,8 @@ public class StrategyWSLoaderProviderTest {
   @Test
   public void testSingleton() {
     StrategyWSLoaderProvider provider = new StrategyWSLoaderProvider(LoadStrategy.CACHE_FIRST);
-    WSLoader wsLoader = provider.provide(cache, client);
+    WSLoader wsLoader = provider.provide(cache, client, globalProps);
 
-    assertThat(provider.provide(null, null)).isEqualTo(wsLoader);
+    assertThat(provider.provide(null, null, null)).isEqualTo(wsLoader);
   }
 }
diff --git a/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderTest.java b/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderTest.java
index db9fe132fa9..c75259b5b36 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderTest.java
@@ -19,39 +19,39 @@
  */
 package org.sonar.batch.cache;
 
-import org.sonar.batch.bootstrap.ServerClient;
-import org.sonar.batch.cache.WSLoader;
-import org.sonar.batch.cache.WSLoader.LoadStrategy;
+import com.google.common.collect.ImmutableMap;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import org.apache.commons.io.IOUtils;
 import org.hamcrest.Matchers;
-import org.junit.rules.ExpectedException;
+import org.junit.Before;
 import org.junit.Rule;
-import org.sonar.api.utils.HttpDownloader;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
-import org.apache.commons.io.IOUtils;
-import org.mockito.Mockito;
-import org.mockito.InOrder;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URI;
+import org.sonar.api.utils.HttpDownloader;
+import org.sonar.batch.bootstrap.ServerClient;
+import org.sonar.batch.bootstrap.UserProperties;
+import org.sonar.batch.cache.WSLoader.LoadStrategy;
+import org.sonar.home.cache.PersistentCache;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.mock;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.fail;
 import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.anyInt;
-import org.junit.Test;
-import org.mockito.MockitoAnnotations;
-import org.junit.Before;
-import org.sonar.home.cache.PersistentCache;
-import org.mockito.Mock;
 
 public class WSLoaderTest {
   private final static String ID = "dummy";
@@ -64,6 +64,7 @@ public class WSLoaderTest {
   private PersistentCache cache;
   @Rule
   public ExpectedException exception = ExpectedException.none();
+  private UserProperties props;
 
   @Before
   public void setUp() throws IOException {
@@ -76,12 +77,13 @@ public class WSLoaderTest {
         return new URI((String) invocation.getArguments()[0]);
       }
     });
+    props = mock(UserProperties.class);
   }
 
   @Test
   public void dont_retry_server_offline() throws IOException {
     turnServerOffline();
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
 
     assertResult(loader.loadString(ID), cacheValue, true);
     assertResult(loader.loadString(ID), cacheValue, true);
@@ -94,7 +96,7 @@ public class WSLoaderTest {
   public void get_stream_from_cache() throws IOException {
     InputStream is = mock(InputStream.class);
     when(cache.getStream(ID)).thenReturn(is);
-    WSLoader loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client, props);
     WSLoaderResult<InputStream> result = loader.loadStream(ID);
     assertThat(result.get()).isEqualTo(is);
     verify(cache).getStream(ID);
@@ -110,7 +112,7 @@ public class WSLoaderTest {
     when(client.load(anyString(), anyString(), anyBoolean(), anyInt(), anyInt())).thenReturn(is1);
     when(cache.getStream(ID)).thenReturn(is2);
 
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
     WSLoaderResult<InputStream> result = loader.loadStream(ID);
     assertThat(result.get()).isEqualTo(is2);
 
@@ -122,9 +124,31 @@ public class WSLoaderTest {
   }
 
   @Test
+  public void default_timeout() throws IOException {
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
+    loader.loadStream(ID);
+
+    verify(client).load(anyString(), anyString(), anyBoolean(), anyInt(), eq(60_000));
+
+    verifyNoMoreInteractions(client);
+  }
+
+  @Test
+  public void change_timeout() throws IOException {
+    when(props.properties()).thenReturn(ImmutableMap.of(WSLoader.SONAR_WS_TIMEOUT_PROPS, "20"));
+    when(props.property(WSLoader.SONAR_WS_TIMEOUT_PROPS)).thenReturn("20");
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
+    loader.loadStream(ID);
+
+    verify(client).load(anyString(), anyString(), anyBoolean(), anyInt(), eq(20_000));
+
+    verifyNoMoreInteractions(client);
+  }
+
+  @Test
   public void test_cache_strategy_fallback() throws IOException {
     turnCacheEmpty();
-    WSLoader loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client, props);
 
     assertResult(loader.loadString(ID), serverValue, false);
 
@@ -136,7 +160,7 @@ public class WSLoaderTest {
   @Test
   public void test_server_strategy_fallback() throws IOException {
     turnServerOffline();
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
 
     assertResult(loader.loadString(ID), cacheValue, true);
 
@@ -147,7 +171,7 @@ public class WSLoaderTest {
 
   @Test
   public void test_put_cache() throws IOException {
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
     loader.loadString(ID);
     verify(cache).put(ID, serverValue.getBytes());
   }
@@ -157,7 +181,7 @@ public class WSLoaderTest {
     turnServerOffline();
 
     when(cache.getString(ID)).thenThrow(new NullPointerException());
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
 
     try {
       loader.loadString(ID);
@@ -172,7 +196,7 @@ public class WSLoaderTest {
   public void test_throw_cache_exception() throws IOException {
     when(cache.getString(ID)).thenThrow(new IllegalStateException());
 
-    WSLoader loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client, props);
 
     try {
       loader.loadString(ID);
@@ -190,7 +214,7 @@ public class WSLoaderTest {
 
     when(client.load(anyString(), anyString(), anyBoolean(), anyInt(), anyInt())).thenThrow(wrapperException);
 
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
 
     try {
       loader.loadString(ID);
@@ -208,7 +232,7 @@ public class WSLoaderTest {
     exception.expect(IllegalStateException.class);
     exception.expectMessage(Matchers.is("Server is not available"));
 
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client, props);
     loader.loadString(ID);
   }
 
@@ -220,7 +244,7 @@ public class WSLoaderTest {
     exception.expect(IllegalStateException.class);
     exception.expectMessage(Matchers.is("Server is not accessible and data is not cached"));
 
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
     loader.loadString(ID);
   }
 
@@ -231,13 +255,13 @@ public class WSLoaderTest {
     exception.expect(IllegalStateException.class);
     exception.expectMessage(Matchers.is("Data is not cached"));
 
-    WSLoader loader = new WSLoader(LoadStrategy.CACHE_ONLY, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.CACHE_ONLY, cache, client, props);
     loader.loadString(ID);
   }
 
   @Test
   public void test_server_strategy() throws IOException {
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
     assertResult(loader.loadString(ID), serverValue, false);
 
     // should not fetch from cache
@@ -248,13 +272,13 @@ public class WSLoaderTest {
   @Test(expected = IllegalStateException.class)
   public void test_server_only() throws IOException {
     turnServerOffline();
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client, props);
     loader.loadString(ID);
   }
 
   @Test
   public void test_string() {
-    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    WSLoader loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, props);
     assertResult(loader.loadString(ID), serverValue, false);
   }
 
diff --git a/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderTestWithServer.java b/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderWithServerTest.java
index def5566c274..cd5b2e3b052 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderTestWithServer.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/cache/WSLoaderWithServerTest.java
@@ -19,27 +19,27 @@
  */
 package org.sonar.batch.cache;
 
-import static org.mockito.Mockito.mock;
-
-import org.sonar.home.cache.TTLCacheInvalidation;
-
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
 import org.sonar.batch.bootstrap.GlobalProperties;
 import org.sonar.batch.bootstrap.MockHttpServer;
 import org.sonar.batch.bootstrap.ServerClient;
 import org.sonar.batch.bootstrap.Slf4jLogger;
-import org.sonar.batch.cache.WSLoader;
-import org.sonar.batch.cache.WSLoader.LoadStrategy;
-import org.junit.Rule;
-import org.junit.rules.TemporaryFolder;
-import static org.mockito.Mockito.when;
-import static org.assertj.core.api.Assertions.assertThat;
+import org.sonar.batch.bootstrap.UserProperties;
 import org.sonar.batch.bootstrapper.EnvironmentInformation;
+import org.sonar.batch.cache.WSLoader.LoadStrategy;
+import org.sonar.home.cache.DirectoryLock;
 import org.sonar.home.cache.PersistentCache;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.sonar.home.cache.TTLCacheInvalidation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
-public class WSLoaderTestWithServer {
+public class WSLoaderWithServerTest {
   private static final String RESPONSE_STRING = "this is the content";
   @Rule
   public TemporaryFolder temp = new TemporaryFolder();
@@ -48,6 +48,7 @@ public class WSLoaderTestWithServer {
   private PersistentCache cache;
   private ServerClient client;
   private WSLoader loader;
+  private UserProperties userProps;
 
   @Before
   public void setUp() throws Exception {
@@ -58,7 +59,8 @@ public class WSLoaderTestWithServer {
     when(bootstrapProps.property("sonar.host.url")).thenReturn("http://localhost:" + server.getPort());
 
     client = new ServerClient(bootstrapProps, new EnvironmentInformation("Junit", "4"));
-    cache = new PersistentCache(temp.getRoot().toPath(), new TTLCacheInvalidation(100_000L), new Slf4jLogger(), null);
+    cache = new PersistentCache(temp.getRoot().toPath(), new TTLCacheInvalidation(100_000L), new Slf4jLogger(), mock(DirectoryLock.class));
+    userProps = mock(UserProperties.class);
   }
 
   @After
@@ -70,31 +72,31 @@ public class WSLoaderTestWithServer {
 
   @Test
   public void testCacheOnly() {
-    loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client);
+    loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client, userProps);
     makeRequests();
 
-    loader = new WSLoader(LoadStrategy.CACHE_ONLY, cache, client);
+    loader = new WSLoader(LoadStrategy.CACHE_ONLY, cache, client, userProps);
     makeRequests();
     assertThat(server.getNumberRequests()).isEqualTo(3);
   }
 
   @Test
   public void testCacheFirst() {
-    loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client);
+    loader = new WSLoader(LoadStrategy.CACHE_FIRST, cache, client, userProps);
     makeRequests();
     assertThat(server.getNumberRequests()).isEqualTo(1);
   }
 
   @Test
   public void testServerFirst() {
-    loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client);
+    loader = new WSLoader(LoadStrategy.SERVER_FIRST, cache, client, userProps);
     makeRequests();
     assertThat(server.getNumberRequests()).isEqualTo(3);
   }
 
   @Test
   public void testCacheStrategyDisabled() {
-    loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client);
+    loader = new WSLoader(LoadStrategy.SERVER_ONLY, cache, client, userProps);
     makeRequests();
     assertThat(server.getNumberRequests()).isEqualTo(3);
   }
diff --git a/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java b/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java
index f459a341341..8a18f87a51d 100644
--- a/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java
+++ b/sonar-batch/src/test/java/org/sonar/batch/rule/ActiveRulesProviderTest.java
@@ -19,22 +19,23 @@
  */
 package org.sonar.batch.rule;
 
-import org.sonarqube.ws.QualityProfiles.WsSearchResponse.QualityProfile;
-
 import com.google.common.collect.ImmutableList;
+import java.util.LinkedList;
+import java.util.List;
+import org.apache.commons.lang.mutable.MutableBoolean;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.sonar.api.batch.rule.ActiveRules;
 import org.sonar.api.rule.RuleKey;
+import org.sonarqube.ws.QualityProfiles.WsSearchResponse.QualityProfile;
 
-import java.util.LinkedList;
-import java.util.List;
-
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verify;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
 public class ActiveRulesProviderTest {
@@ -59,9 +60,9 @@ public class ActiveRulesProviderTest {
     List<LoadedActiveRule> qp2Rules = ImmutableList.of(r2, r3);
     List<LoadedActiveRule> qp3Rules = ImmutableList.of(r1, r3);
 
-    when(loader.load("qp1", null)).thenReturn(qp1Rules);
-    when(loader.load("qp2", null)).thenReturn(qp2Rules);
-    when(loader.load("qp3", null)).thenReturn(qp3Rules);
+    when(loader.load(eq("qp1"), any(MutableBoolean.class))).thenReturn(qp1Rules);
+    when(loader.load(eq("qp2"), any(MutableBoolean.class))).thenReturn(qp2Rules);
+    when(loader.load(eq("qp3"), any(MutableBoolean.class))).thenReturn(qp3Rules);
 
     ModuleQProfiles profiles = mockProfiles("qp1", "qp2", "qp3");
     ActiveRules activeRules = provider.provide(loader, profiles);
@@ -70,9 +71,9 @@ public class ActiveRulesProviderTest {
     assertThat(activeRules.findAll()).extracting("ruleKey").containsOnly(
       RuleKey.of("rule1", "rule1"), RuleKey.of("rule2", "rule2"), RuleKey.of("rule3", "rule3"));
 
-    verify(loader).load("qp1", null);
-    verify(loader).load("qp2", null);
-    verify(loader).load("qp3", null);
+    verify(loader).load(eq("qp1"), any(MutableBoolean.class));
+    verify(loader).load(eq("qp2"), any(MutableBoolean.class));
+    verify(loader).load(eq("qp3"), any(MutableBoolean.class));
     verifyNoMoreInteractions(loader);
   }