Lazily create expensive Optional default values. Fixes #294.

components/client/src/main/java/com/hotels/styx/client/OriginRestrictionLoadBalancingStrategy.java

@@ -72,7 +72,7 @@ public Optional<RemoteHost> choose(LoadBalancer.Preferences context) {
                             }
                         }
                 )
-                .orElse(delegate.choose(context));
+                .orElseGet(() -> delegate.choose(context));
     }
 
     private Predicate<RemoteHost> originIsAllowed(String cookieValue) {

components/client/src/main/java/com/hotels/styx/client/StyxBackendServiceClient.java

@@ -287,7 +287,7 @@ public Optional<String> preferredOrigins() {
                     return rewrittenRequest.cookie(originsRestrictionCookieName)
                             .map(RequestCookie::value)
                             .map(Optional::of)
-                            .orElse(rewrittenRequest.cookie("styx_origin_" + id).map(RequestCookie::value));
+                            .orElseGet(() -> rewrittenRequest.cookie("styx_origin_" + id).map(RequestCookie::value));
                 } else {
                     return rewrittenRequest.cookie("styx_origin_" + id).map(RequestCookie::value);
                 }

components/client/src/main/java/com/hotels/styx/client/stickysession/StickySessionLoadBalancingStrategy.java

@@ -40,7 +40,7 @@ public Optional<RemoteHost> choose(LoadBalancer.Preferences context) {
         return context.preferredOrigins()
                 .flatMap(preferredHost -> originById(activeOrigins.snapshot(), preferredHost))
                 .map(Optional::of)
-                .orElse(delegate.choose(context));
+                .orElseGet(() -> delegate.choose(context));
     }
 
     private Optional<RemoteHost> originById(Iterable<RemoteHost> origins, String id) {

components/client/src/test/unit/java/com/hotels/styx/client/OriginRestrictionLoadBalancingStrategyTest.java

@@ -113,6 +113,23 @@ public void usesSingleOriginMatchingRegularExpression() {
         assertThat(chosenOne.get(), is(origins.get(1)));
     }
 
+    @Test
+    public void dontDelegateWhenOriginRestrictionCookieMatches() {
+        Random mockRandom = mock(Random.class);
+        when(mockRandom.nextInt(eq(1))).thenReturn(0);
+
+        strategy = new OriginRestrictionLoadBalancingStrategy(() -> origins, delegate, mockRandom);
+
+        strategy.choose(lbPreference(Optional.of("origin-1")));
+        strategy.choose(lbPreference(Optional.of("origin-1")));
+        strategy.choose(lbPreference(Optional.of("origin-1")));
+        strategy.choose(lbPreference(Optional.of("origin-1")));
+        strategy.choose(lbPreference(Optional.of("origin-1")));
+        strategy.choose(lbPreference(Optional.of("origin-1")));
+
+        verify(delegate, never()).choose(any(LoadBalancer.Preferences.class));
+    }
+
     @Test
     public void usesMultipleOriginsMatchingRegularExpression() {
         Random mockRandom = mock(Random.class);

components/client/src/test/unit/java/com/hotels/styx/client/stickysession/StickySessionLoadBalancingStrategyTest.java

@@ -34,7 +34,10 @@
 import static java.util.Collections.EMPTY_LIST;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
+import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 
@@ -63,6 +66,18 @@ public void selectsThePreferredOrigin() {
         assertThat(chosenOne, is(Optional.of(ORIGIN_1)));
     }
 
+    @Test
+    public void dontDelegateWhenPreferredOriginIsFound() {
+        LoadBalancer delegate = mock(LoadBalancer.class);
+        StickySessionLoadBalancingStrategy aStrategy = new StickySessionLoadBalancingStrategy(activeOrigins, delegate);
+
+        when(activeOrigins.snapshot()).thenReturn(asList(ORIGIN_0, ORIGIN_1, ORIGIN_2));
+
+        aStrategy.choose(lbPreferences(Optional.of(ORIGIN_1.id())));
+
+        verify(delegate, never()).choose(any(LoadBalancer.Preferences.class));
+    }
+
     @Test
     public void failsOverToNextAvailableOriginSelectedByTheLoadBalancingStrategyIfRequestedOriginIsNotRegistered() {
         when(activeOrigins.snapshot()).thenReturn(asList(ORIGIN_0, ORIGIN_2));

components/proxy/src/main/java/com/hotels/styx/proxy/LoadBalancingStrategyFactoryProvider.java

@@ -50,7 +50,7 @@ public static LoadBalancingStrategyFactoryProvider newProvider(Configuration con
     public LoadBalancerFactory get() {
         return configurations.get(LOAD_BALANCING_STRATEGY_KEY)
                 .map(this::newFactoryInstance)
-                .orElse(busyConnectionBalancer());
+                .orElseGet(this::busyConnectionBalancer);
     }
 
     private LoadBalancerFactory busyConnectionBalancer() {

components/proxy/src/main/java/com/hotels/styx/proxy/backends/file/FileBackedBackendServicesRegistry.java

@@ -160,7 +160,7 @@ public Registry<BackendService> create(Environment environment, Configuration re
                             "missing [services.registry.factory.config.originsFile] config value for factory class FileBackedBackendServicesRegistry.Factory"));
 
             FileMonitorSettings monitorSettings = registryConfiguration.get("monitor", FileMonitorSettings.class)
-                    .orElse(new FileMonitorSettings());
+                    .orElseGet(FileMonitorSettings::new);
 
             return registry(originsFile, monitorSettings);
         }

system-tests/e2e-testsupport/src/main/java/com/hotels/styx/servers/WiremockStyxRequestAdapter.java

@@ -76,7 +76,7 @@ public HttpHeader header(String key) {
     public ContentTypeHeader contentTypeHeader() {
         return styxRequest.header(CONTENT_TYPE)
                 .map(ContentTypeHeader::new)
-                .orElse(ContentTypeHeader.absent());
+                .orElseGet(ContentTypeHeader::absent);
     }
 
     @Override
@@ -102,7 +102,7 @@ public Set<String> getAllHeaderKeys() {
     public QueryParameter queryParameter(String key) {
         return styxRequest.queryParam(key)
                 .map(value -> new QueryParameter(key, ImmutableList.of(value)))
-                .orElse(QueryParameter.absent(key));
+                .orElseGet(() -> QueryParameter.absent(key));
     }
 
     @Override