gtfs: move realtime init code to where the rest is

Author: michaz

web-bundle/src/main/java/com/graphhopper/http/GraphHopperBundle.java

@@ -36,13 +36,16 @@
 import com.graphhopper.util.PMap;
 import com.graphhopper.util.TranslationMap;
 import com.graphhopper.util.details.PathDetailsBuilderFactory;
+import io.dropwizard.client.HttpClientBuilder;
 import io.dropwizard.core.ConfiguredBundle;
 import io.dropwizard.core.setup.Bootstrap;
 import io.dropwizard.core.setup.Environment;
+import org.apache.hc.client5.http.classic.HttpClient;
 import org.glassfish.hk2.api.Factory;
 import org.glassfish.hk2.utilities.binding.AbstractBinder;
 
 import javax.inject.Inject;
+import javax.inject.Singleton;
 
 public class GraphHopperBundle implements ConfiguredBundle<GraphHopperBundleConfiguration> {
 
@@ -205,6 +208,26 @@ public void dispose(Boolean instance) {
         }
     }
 
+    private static class EmptyRealtimeFeedFactory implements Factory<RealtimeFeed> {
+
+        private final GtfsStorage staticGtfs;
+
+        @Inject
+        EmptyRealtimeFeedFactory(GtfsStorage staticGtfs) {
+            this.staticGtfs = staticGtfs;
+        }
+
+        @Override
+        public RealtimeFeed provide() {
+            return RealtimeFeed.empty();
+        }
+
+        @Override
+        public void dispose(RealtimeFeed realtimeFeed) {
+
+        }
+    }
+
     @Override
     public void initialize(Bootstrap<?> bootstrap) {
         // See #1440: avoids warning regarding com.fasterxml.jackson.module.afterburner.util.MyClassLoader
@@ -307,5 +330,27 @@ protected void configure() {
         environment.healthChecks().register("graphhopper", new GraphHopperHealthCheck(graphHopper));
         environment.jersey().register(environment.healthChecks());
         environment.jersey().register(HealthCheckResource.class);
+
+        if (configuration.gtfsrealtime().getFeeds().isEmpty()) {
+            environment.jersey().register(new AbstractBinder() {
+                @Override
+                protected void configure() {
+                    bindFactory(EmptyRealtimeFeedFactory.class).to(RealtimeFeed.class).in(Singleton.class);
+                }
+            });
+        } else {
+            final HttpClient httpClient = new HttpClientBuilder(environment)
+                    .using(configuration.gtfsrealtime().getHttpClientConfiguration())
+                    .build("gtfs-realtime-feed-loader");
+            RealtimeFeedLoadingCache realtimeFeedLoadingCache = new RealtimeFeedLoadingCache(((GraphHopperGtfs) graphHopper), httpClient, configuration);
+            environment.lifecycle().manage(realtimeFeedLoadingCache);
+            environment.jersey().register(new AbstractBinder() {
+                @Override
+                protected void configure() {
+                    bind(httpClient).to(HttpClient.class);
+                    bindFactory(realtimeFeedLoadingCache).to(RealtimeFeed.class);
+                }
+            });
+        }
     }
 }

web-bundle/src/main/java/com/graphhopper/http/GraphHopperBundleConfiguration.java

@@ -24,4 +24,6 @@ public interface GraphHopperBundleConfiguration {
 
     GraphHopperConfig getGraphHopperConfiguration();
 
+    RealtimeConfiguration gtfsrealtime();
+
 }

web-bundle/src/main/java/com/graphhopper/http/RealtimeBundle.java

@@ -25,11 +25,9 @@
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFutureTask;
 import com.google.transit.realtime.GtfsRealtime;
-import com.graphhopper.gtfs.GtfsStorage;
+import com.graphhopper.gtfs.GraphHopperGtfs;
 import com.graphhopper.gtfs.RealtimeFeed;
 import com.graphhopper.gtfs.Transfers;
-import com.graphhopper.routing.util.EncodingManager;
-import com.graphhopper.storage.BaseGraph;
 import io.dropwizard.lifecycle.Managed;
 import org.apache.hc.client5.http.classic.HttpClient;
 import org.apache.hc.client5.http.classic.methods.HttpGet;
@@ -48,27 +46,24 @@
 public class RealtimeFeedLoadingCache implements Factory<RealtimeFeed>, Managed {
 
     private final HttpClient httpClient;
-    private final BaseGraph baseGraph;
-    private final EncodingManager encodingManager;
-    private final GtfsStorage gtfsStorage;
-    private final RealtimeBundleConfiguration bundleConfiguration;
+    private final GraphHopperGtfs graphHopper;
+    private final GraphHopperBundleConfiguration bundleConfiguration;
     private ExecutorService executor;
     private LoadingCache<String, RealtimeFeed> cache;
     private Map<String, Transfers> transfers;
 
     @Inject
-    RealtimeFeedLoadingCache(BaseGraph baseGraph, EncodingManager encodingManager, GtfsStorage gtfsStorage, HttpClient httpClient, RealtimeBundleConfiguration bundleConfiguration) {
-        this.baseGraph = baseGraph;
-        this.encodingManager = encodingManager;
-        this.gtfsStorage = gtfsStorage;
+    RealtimeFeedLoadingCache(GraphHopperGtfs graphHopper, HttpClient httpClient, GraphHopperBundleConfiguration bundleConfiguration) {
+        this.graphHopper = graphHopper;
         this.bundleConfiguration = bundleConfiguration;
         this.httpClient = httpClient;
     }
 
     @Override
     public void start() {
+        System.out.println("Starting RealtimeFeedLoadingCache");
         this.transfers = new HashMap<>();
-        for (Map.Entry<String, GTFSFeed> entry : this.gtfsStorage.getGtfsFeeds().entrySet()) {
+        for (Map.Entry<String, GTFSFeed> entry : this.graphHopper.getGtfsStorage().getGtfsFeeds().entrySet()) {
             this.transfers.put(entry.getKey(), new Transfers(entry.getValue()));
         }
         this.executor = Executors.newSingleThreadExecutor();
@@ -112,14 +107,24 @@ private RealtimeFeed fetchFeedsAndCreateGraph() {
         Map<String, GtfsRealtime.FeedMessage> feedMessageMap = new HashMap<>();
         for (FeedConfiguration configuration : bundleConfiguration.gtfsrealtime().getFeeds()) {
             try {
-                GtfsRealtime.FeedMessage feedMessage = httpClient.execute(new HttpGet(configuration.getUrl().toURI()),
-                        response -> GtfsRealtime.FeedMessage.parseFrom(response.getEntity().getContent()));
-                feedMessageMap.put(configuration.getFeedId(), feedMessage);
+                switch (configuration.getUrl().getProtocol()) {
+                    case "http": {
+                        GtfsRealtime.FeedMessage feedMessage = httpClient.execute(new HttpGet(configuration.getUrl().toURI()),
+                                response -> GtfsRealtime.FeedMessage.parseFrom(response.getEntity().getContent()));
+                        feedMessageMap.put(configuration.getFeedId(), feedMessage);
+                        break;
+                    }
+                    case "file": {
+                        GtfsRealtime.FeedMessage feedMessage = GtfsRealtime.FeedMessage.parseFrom(configuration.getUrl().openStream());
+                        feedMessageMap.put(configuration.getFeedId(), feedMessage);
+                        break;
+                    }
+                }
             } catch (IOException | URISyntaxException e) {
                 throw new RuntimeException(e);
             }
         }
-        return RealtimeFeed.fromProtobuf(gtfsStorage, this.transfers, feedMessageMap);
+        return RealtimeFeed.fromProtobuf(graphHopper.getGtfsStorage(), this.transfers, feedMessageMap);
     }
 
 }

web-bundle/src/main/java/com/graphhopper/http/RealtimeBundleConfiguration.java

@@ -22,7 +22,6 @@
 import com.graphhopper.application.resources.RootResource;
 import com.graphhopper.http.CORSFilter;
 import com.graphhopper.http.GraphHopperBundle;
-import com.graphhopper.http.RealtimeBundle;
 import com.graphhopper.navigation.NavigateResource;
 import io.dropwizard.assets.AssetsBundle;
 import io.dropwizard.core.Application;
@@ -41,7 +40,6 @@ public static void main(String[] args) throws Exception {
     @Override
     public void initialize(Bootstrap<GraphHopperServerConfiguration> bootstrap) {
         bootstrap.addBundle(new GraphHopperBundle());
-        bootstrap.addBundle(new RealtimeBundle());
         bootstrap.addCommand(new ImportCommand());
         bootstrap.addCommand(new MatchCommand());
         bootstrap.addBundle(new AssetsBundle("/com/graphhopper/maps/", "/maps/", "index.html"));

web-bundle/src/main/java/com/graphhopper/http/RealtimeFeedLoadingCache.java

@@ -20,13 +20,12 @@
 import com.fasterxml.jackson.annotation.JsonProperty;
 import com.graphhopper.GraphHopperConfig;
 import com.graphhopper.http.GraphHopperBundleConfiguration;
-import com.graphhopper.http.RealtimeBundleConfiguration;
 import com.graphhopper.http.RealtimeConfiguration;
 import io.dropwizard.core.Configuration;
 
 import javax.validation.constraints.NotNull;
 
-public class GraphHopperServerConfiguration extends Configuration implements GraphHopperBundleConfiguration, RealtimeBundleConfiguration {
+public class GraphHopperServerConfiguration extends Configuration implements GraphHopperBundleConfiguration {
 
     @NotNull
     @JsonProperty
@@ -43,7 +42,6 @@ public GraphHopperConfig getGraphHopperConfiguration() {
         return graphhopper;
     }
 
-    @Override
     public RealtimeConfiguration gtfsrealtime() {
         return gtfsRealtime;
     }