();
78 | }
79 | }
80 |
81 | /****
82 | * {@link GtfsRealtimeSink} Interface
83 | ****/
84 |
85 | @Override
86 | public synchronized void setFeedHeaderDefaults(FeedHeader header) {
87 | _header = header;
88 | _cachedFeed = null;
89 | }
90 |
91 | @Override
92 | public synchronized void handleFullUpdate(GtfsRealtimeFullUpdate update) {
93 | _cachedFeed = null;
94 | _feedEntities.clear();
95 | for (FeedEntity entity : update.getEntities()) {
96 | _feedEntities.put(entity.getId(), entity);
97 | }
98 | _incrementalIndex++;
99 | FeedMessage feed = getFeed();
100 | for (GtfsRealtimeIncrementalListener listener : _listeners) {
101 | listener.handleFeed(feed);
102 | }
103 | }
104 |
105 | @Override
106 | public synchronized void handleIncrementalUpdate(
107 | GtfsRealtimeIncrementalUpdate update) {
108 | _cachedFeed = null;
109 |
110 | for (FeedEntity toAdd : update.getUpdatedEntities()) {
111 | _feedEntities.put(toAdd.getId(), toAdd);
112 | }
113 | for (String toRemove : update.getDeletedEntities()) {
114 | _feedEntities.remove(toRemove);
115 | }
116 |
117 | FeedMessage.Builder feed = FeedMessage.newBuilder();
118 | feed.setHeader(createIncrementalHeader());
119 | feed.addAllEntity(update.getUpdatedEntities());
120 | for (String toRemove : update.getDeletedEntities()) {
121 | FeedEntity.Builder entity = FeedEntity.newBuilder();
122 | entity.setIsDeleted(true);
123 | entity.setId(toRemove);
124 | feed.addEntity(entity);
125 | }
126 |
127 | FeedMessage differentialFeed = feed.build();
128 | for (GtfsRealtimeIncrementalListener listener : _listeners) {
129 | listener.handleFeed(differentialFeed);
130 | }
131 | _incrementalIndex++;
132 | }
133 |
134 | /****
135 | * {@link GtfsRealtimeSource} Interface
136 | ****/
137 |
138 | @Override
139 | public synchronized FeedMessage getFeed() {
140 | if (_cachedFeed == null) {
141 | FeedHeader.Builder header = FeedHeader.newBuilder();
142 | if (_header != null) {
143 | header.mergeFrom(_header);
144 | }
145 | header.setIncrementality(Incrementality.FULL_DATASET);
146 | header.setTimestamp(System.currentTimeMillis() / 1000);
147 | header.setGtfsRealtimeVersion(GtfsRealtimeConstants.VERSION);
148 |
149 | setIncrementalIndex(header, _incrementalIndex - 1);
150 |
151 | FeedMessage.Builder feed = FeedMessage.newBuilder();
152 | feed.setHeader(header);
153 | feed.addAllEntity(_feedEntities.values());
154 | _cachedFeed = feed.build();
155 | }
156 | return _cachedFeed;
157 | }
158 |
159 | @Override
160 | public void addIncrementalListener(GtfsRealtimeIncrementalListener listener) {
161 | _listeners.add(listener);
162 | listener.handleFeed(getFeed());
163 | }
164 |
165 | @Override
166 | public void removeIncrementalListener(GtfsRealtimeIncrementalListener listener) {
167 | _listeners.remove(listener);
168 | }
169 |
170 | /***
171 | * Private Methods
172 | ****/
173 |
174 | private FeedHeader createIncrementalHeader() {
175 | FeedHeader.Builder header = FeedHeader.newBuilder();
176 | if (_header != null) {
177 | header.mergeFrom(_header);
178 | }
179 | header.setIncrementality(Incrementality.DIFFERENTIAL);
180 | header.setTimestamp(System.currentTimeMillis() / 1000);
181 | header.setGtfsRealtimeVersion(GtfsRealtimeConstants.VERSION);
182 |
183 | setIncrementalIndex(header, _incrementalIndex);
184 |
185 | return header.build();
186 | }
187 |
188 | private void setIncrementalIndex(FeedHeader.Builder header,
189 | long incrementalIndex) {
190 | OneBusAwayFeedHeader.Builder obaHeader = OneBusAwayFeedHeader.newBuilder();
191 | obaHeader.setIncrementalIndex(incrementalIndex);
192 | obaHeader.setIncrementalHeartbeatInterval(_incrementalHeartbeatInterval);
193 | header.setExtension(GtfsRealtimeOneBusAway.obaFeedHeader, obaHeader.build());
194 | }
195 | }
196 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeExporterModule.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2012 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import java.util.Properties;
19 | import java.util.Set;
20 | import java.util.concurrent.Executors;
21 | import java.util.concurrent.ScheduledExecutorService;
22 |
23 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeExporter.AlertsExporter;
24 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeExporter.MixedFeedExporter;
25 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeExporter.TripUpdatesExporter;
26 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeExporter.VehiclePositionsExporter;
27 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeGuiceBindingTypes.Alerts;
28 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeGuiceBindingTypes.MixedFeed;
29 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeGuiceBindingTypes.TripUpdates;
30 | import org.onebusaway.gtfs_realtime.exporter.GtfsRealtimeGuiceBindingTypes.VehiclePositions;
31 | import org.onebusaway.guice.jetty_exporter.JettyExporterModule;
32 |
33 | import com.google.inject.AbstractModule;
34 | import com.google.inject.Module;
35 | import com.google.inject.Singleton;
36 | import com.google.inject.name.Names;
37 |
38 | /**
39 | * Provides Guice support for wiring up the services provided by the
40 | * onebusaway-gtfs-realtime-exporter library, along with all its dependencies.
41 | *
42 | * Here's a quick example of the library in use:
43 | *
44 | *
45 | * {@code
46 | * Set modules = new HashSet();
47 | * GtfsRealtimeExporterModule.addModuleAndDependencies(modules);
48 | * Injector injector = Guice.createInjector(modules);
49 | * }
50 | *
51 | *
52 | * @author bdferris
53 | */
54 | public class GtfsRealtimeExporterModule extends AbstractModule {
55 |
56 | public static final String NAME_EXECUTOR = "org.onebusway.gtfs_realtime.exporter.GtfsRealtimeExporterModule.executor";
57 |
58 | /**
59 | * Adds a {@link GtfsRealtimeExporterModule} instance to the specified set of
60 | * modules, along with all its dependencies.
61 | *
62 | * @param modules the resulting set of Guice modules
63 | */
64 | public static void addModuleAndDependencies(Set modules) {
65 | modules.add(new GtfsRealtimeExporterModule());
66 | JettyExporterModule.addModuleAndDependencies(modules);
67 | }
68 |
69 | /**
70 | * See {@link GtfsRealtimeExporter} for a discussion of the somewhat
71 | * convoluted binding scheme used here.
72 | */
73 | @Override
74 | protected void configure() {
75 |
76 | bind(GtfsRealtimeSink.class).annotatedWith(Alerts.class).to(
77 | AlertsExporter.class);
78 | bind(GtfsRealtimeSource.class).annotatedWith(Alerts.class).to(
79 | AlertsExporter.class);
80 | bind(GtfsRealtimeExporter.class).annotatedWith(Alerts.class).to(
81 | AlertsExporter.class);
82 | bind(AlertsExporter.class).to(GtfsRealtimeExporterImpl.class).in(
83 | Singleton.class);
84 |
85 | bind(GtfsRealtimeSink.class).annotatedWith(TripUpdates.class).to(
86 | TripUpdatesExporter.class);
87 | bind(GtfsRealtimeSource.class).annotatedWith(TripUpdates.class).to(
88 | TripUpdatesExporter.class);
89 | bind(GtfsRealtimeExporter.class).annotatedWith(TripUpdates.class).to(
90 | TripUpdatesExporter.class);
91 | bind(TripUpdatesExporter.class).to(GtfsRealtimeExporterImpl.class).in(
92 | Singleton.class);
93 |
94 | bind(GtfsRealtimeSink.class).annotatedWith(VehiclePositions.class).to(
95 | VehiclePositionsExporter.class);
96 | bind(GtfsRealtimeSource.class).annotatedWith(VehiclePositions.class).to(
97 | VehiclePositionsExporter.class);
98 | bind(GtfsRealtimeExporter.class).annotatedWith(VehiclePositions.class).to(
99 | VehiclePositionsExporter.class);
100 | bind(VehiclePositionsExporter.class).to(GtfsRealtimeExporterImpl.class).in(
101 | Singleton.class);
102 |
103 | bind(GtfsRealtimeSink.class).annotatedWith(MixedFeed.class).to(
104 | MixedFeedExporter.class);
105 | bind(GtfsRealtimeSource.class).annotatedWith(MixedFeed.class).to(
106 | MixedFeedExporter.class);
107 | bind(MixedFeedExporter.class).to(GtfsRealtimeExporterImpl.class).in(
108 | Singleton.class);
109 |
110 | bind(ScheduledExecutorService.class).annotatedWith(
111 | Names.named(NAME_EXECUTOR)).toInstance(
112 | Executors.newSingleThreadScheduledExecutor());
113 |
114 | String expire = System.getProperty("cache.expire.secs", "0");
115 | bindConstant().annotatedWith(Names.named("cache.expire.secs")).to(expire);
116 | }
117 |
118 | /**
119 | * Implement hashCode() and equals() such that two instances of the module
120 | * will be equal.
121 | */
122 | @Override
123 | public int hashCode() {
124 | return this.getClass().hashCode();
125 | }
126 |
127 | @Override
128 | public boolean equals(Object o) {
129 | if (this == o)
130 | return true;
131 | if (o == null)
132 | return false;
133 | return this.getClass().equals(o.getClass());
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeFileWriter.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2012 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import java.io.BufferedOutputStream;
19 | import java.io.File;
20 | import java.io.FileOutputStream;
21 | import java.io.IOException;
22 | import java.io.OutputStream;
23 | import java.util.concurrent.ScheduledExecutorService;
24 | import java.util.concurrent.ScheduledFuture;
25 | import java.util.concurrent.TimeUnit;
26 |
27 | import javax.annotation.PostConstruct;
28 | import javax.annotation.PreDestroy;
29 | import javax.inject.Inject;
30 | import javax.inject.Named;
31 |
32 | import org.slf4j.Logger;
33 | import org.slf4j.LoggerFactory;
34 |
35 | import com.google.protobuf.Message;
36 |
37 | /**
38 | * Provides functionality for periodically writing a GTFS-realtime feed to an
39 | * output file.
40 | *
41 | * @author bdferris
42 | *
43 | */
44 | public class GtfsRealtimeFileWriter {
45 |
46 | private static final Logger _log = LoggerFactory.getLogger(GtfsRealtimeFileWriter.class);
47 |
48 | protected GtfsRealtimeSource _source;
49 |
50 | private ScheduledExecutorService _executor;
51 |
52 | private File _path;
53 |
54 | private int _period = 5;
55 |
56 | private ScheduledFuture _task;
57 |
58 | public void setSource(GtfsRealtimeSource source) {
59 | _source = source;
60 | }
61 |
62 | @Inject
63 | public void setExecutor(@Named(GtfsRealtimeExporterModule.NAME_EXECUTOR)
64 | ScheduledExecutorService executor) {
65 | _executor = executor;
66 | }
67 |
68 | /**
69 | * @param path the output path where the feed will be written
70 | */
71 | public void setPath(File path) {
72 | _path = path;
73 | }
74 |
75 | public int getPeriod() {
76 | return _period;
77 | }
78 |
79 | public void setPeriod(int timeInSeconds) {
80 | _period = timeInSeconds;
81 | }
82 |
83 | @PostConstruct
84 | public void start() {
85 | _task = _executor.scheduleAtFixedRate(new TaskEntryPoint(), 0, _period,
86 | TimeUnit.SECONDS);
87 | }
88 |
89 | @PreDestroy
90 | public void stop() {
91 | if (_task != null) {
92 | _task.cancel(false);
93 | _task = null;
94 | }
95 | }
96 |
97 | protected void writeMessageToFile() throws IOException {
98 | Message message = _source.getFeed();
99 | OutputStream out = new BufferedOutputStream(new FileOutputStream(_path));
100 | message.writeTo(out);
101 | out.close();
102 | }
103 |
104 | private class TaskEntryPoint implements Runnable {
105 |
106 | @Override
107 | public void run() {
108 | try {
109 | writeMessageToFile();
110 | } catch (IOException ex) {
111 | _log.error("Error writing message to output file: " + _path, ex);
112 | }
113 | }
114 | }
115 |
116 | }
117 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeFullUpdate.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2013 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import java.util.ArrayList;
19 | import java.util.List;
20 |
21 | import com.google.transit.realtime.GtfsRealtime.FeedEntity;
22 |
23 | /**
24 | * Specifies a full update to a GTFS-realtime feed, such that all previous
25 | * entities are replaced by the new entities contained in the update.
26 | *
27 | * @author bdferris
28 | * @see GtfsRealtimeIncrementalUpdate
29 | * @see GtfsRealtimeSink
30 | */
31 | public class GtfsRealtimeFullUpdate {
32 |
33 | private List entities = new ArrayList();
34 |
35 | public void addEntity(FeedEntity entity) {
36 | entities.add(entity);
37 | }
38 |
39 | public List getEntities() {
40 | return entities;
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeGuiceBindingTypes.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2013 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import static java.lang.annotation.ElementType.FIELD;
19 | import static java.lang.annotation.ElementType.METHOD;
20 | import static java.lang.annotation.ElementType.PARAMETER;
21 | import static java.lang.annotation.RetentionPolicy.RUNTIME;
22 |
23 | import java.lang.annotation.Retention;
24 | import java.lang.annotation.Target;
25 |
26 | import com.google.inject.BindingAnnotation;
27 |
28 | /**
29 | * We use Guice for wiring up dependices in the
30 | * onebusaway-gtfs-realtime-exporter library. For most clients, that means
31 | * injecting instances of {@link GtfsRealtimeSink}, {@link GtfsRealtimeSource},
32 | * and {@link GtfsRealtimeExporter}. Typically, clients may produce different
33 | * combinations of GTFS-realtime feeds: alerts, trip-updates, and
34 | * vehicles-positions, each modeled with a separate feed. Each feed type needs
35 | * shared instances of {@link GtfsRealtimeSink} or {@link GtfsRealtimeSource}
36 | * specific to that feed type.
37 | *
38 | * To achieve this, we use Guice Binding Annotations to indicate which type of
39 | * feed we'd like. For example, for a {@link GtfsRealtimeSink} for trip-updates,
40 | * we'd use the following:
41 | *
42 | *
43 | * {@literal @}Inject
44 | * void setTripUpdatesSink({@literal @}TripUpdates GtfsRealtimeSink tripUpdatesSink) {
45 | * ...
46 | * }
47 | *
48 | *
49 | * Note the use of the {@link TripUpdates} annotation on the injection
50 | * parameter. Any instance of {@link GtfsRealtimeSink},
51 | * {@link GtfsRealtimeSource}, or {@link GtfsRealtimeExporter} that is annotated
52 | * with the {@link TripUpdates} annotation will receive the same underlying
53 | * instance. We provide annotations for {@link Alerts}, {@link VehiclePositions}
54 | * , and finally a {@link MixedFeed} if you wish to mix different GTFS-realtime
55 | * feed entity types in the same feed.
56 | *
57 | * Note: one limitation of this approach is that it's tricky to exporter
58 | * multiple different feeds of the same type using the library (eg. two
59 | * trip-updates feeds).
60 | *
61 | * @author bdferris
62 | */
63 | public class GtfsRealtimeGuiceBindingTypes {
64 |
65 | /**
66 | * Annotation to indicate that a wired instance of {@link GtfsRealtimeSink},
67 | * {@link GtfsRealtimeSource}, or {@link GtfsRealtimeExporter} must support
68 | * trip updates data.
69 | *
70 | * @author bdferris
71 | * @see GtfsRealtimeGuiceBindingTypes
72 | */
73 | @BindingAnnotation
74 | @Target({FIELD, PARAMETER, METHOD})
75 | @Retention(RUNTIME)
76 | public @interface TripUpdates {
77 | }
78 |
79 | /**
80 | * Annotation to indicate that a wired instance of {@link GtfsRealtimeSink},
81 | * {@link GtfsRealtimeSource}, or {@link GtfsRealtimeExporter} must support
82 | * vehicle positions data.
83 | *
84 | * @author bdferris
85 | * @see GtfsRealtimeGuiceBindingTypes
86 | */
87 | @BindingAnnotation
88 | @Target({FIELD, PARAMETER, METHOD})
89 | @Retention(RUNTIME)
90 | public @interface VehiclePositions {
91 | }
92 |
93 | /**
94 | * Annotation to indicate that a wired instance of {@link GtfsRealtimeSink},
95 | * {@link GtfsRealtimeSource}, or {@link GtfsRealtimeExporter} must support
96 | * alerts data.
97 | *
98 | * @author bdferris
99 | * @see GtfsRealtimeGuiceBindingTypes
100 | */
101 | @BindingAnnotation
102 | @Target({FIELD, PARAMETER, METHOD})
103 | @Retention(RUNTIME)
104 | public @interface Alerts {
105 | }
106 |
107 | /**
108 | * Annotation to indicate that a wired instance of {@link GtfsRealtimeSink},
109 | * {@link GtfsRealtimeSource}, or {@link GtfsRealtimeExporter} must support a
110 | * mixture of trip updates, vehicle positions, and alerts data.
111 | *
112 | * @author bdferris
113 | * @see GtfsRealtimeGuiceBindingTypes
114 | */
115 | @BindingAnnotation
116 | @Target({FIELD, PARAMETER, METHOD})
117 | @Retention(RUNTIME)
118 | public @interface MixedFeed {
119 | }
120 | }
121 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeIncrementalListener.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2013 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import com.google.transit.realtime.GtfsRealtime.FeedMessage;
19 | import com.google.transit.realtime.GtfsRealtime.FeedHeader.Incrementality;
20 |
21 | /**
22 | * Defines an interface for receiving incremental GTFS-realtime updates.
23 | *
24 | * @author bdferris
25 | *
26 | */
27 | public interface GtfsRealtimeIncrementalListener {
28 |
29 | /**
30 | * Handle a feed update. Updates can either be full datasets (as indicated by
31 | * a {@link Incrementality#FULL_DATASET} value in the header) or incremental
32 | * updates to the most-recent full dataset (as indicated by a
33 | * {@link Incrementality#DIFFERENTIAL} value in the header).
34 | *
35 | * @param feed the feed update
36 | */
37 | public void handleFeed(FeedMessage feed);
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeIncrementalUpdate.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2013 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import java.util.ArrayList;
19 | import java.util.List;
20 |
21 | import com.google.transit.realtime.GtfsRealtime.FeedEntity;
22 |
23 | /**
24 | * Specifies an incremental update to a GTFS-realtime feed, such that new feed
25 | * entities will selectively replace any previously updated feed entities. It is
26 | * important to use stable {@link FeedEntity#getId()} id values across updates
27 | * in order for incremental updates to function properly.
28 | *
29 | * @author bdferris
30 | * @see GtfsRealtimeFullUpdate
31 | * @see GtfsRealtimeSink
32 | */
33 | public class GtfsRealtimeIncrementalUpdate {
34 |
35 | private List updatedEntities = new ArrayList();
36 |
37 | private List deletedEntities = new ArrayList();
38 |
39 | private long expirationTime = -1;
40 |
41 | public void addUpdatedEntity(FeedEntity entity) {
42 | updatedEntities.add(entity);
43 | }
44 |
45 | public List getUpdatedEntities() {
46 | return updatedEntities;
47 | }
48 |
49 | public void addDeletedEntity(String entityId) {
50 | deletedEntities.add(entityId);
51 | }
52 |
53 | public List getDeletedEntities() {
54 | return deletedEntities;
55 | }
56 |
57 | public long getExpirationTime() {
58 | return expirationTime;
59 | }
60 |
61 | public void setExpirationTime(long expirationTimeInMilliseconds) {
62 | this.expirationTime = expirationTimeInMilliseconds;
63 | }
64 |
65 | }
66 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeLibrary.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2012 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import com.google.transit.realtime.GtfsRealtime.TranslatedString;
19 | import com.google.transit.realtime.GtfsRealtime.TranslatedString.Translation;
20 | import com.google.transit.realtime.GtfsRealtimeConstants;
21 | import com.google.transit.realtime.GtfsRealtime.FeedHeader;
22 | import com.google.transit.realtime.GtfsRealtime.FeedMessage;
23 | import com.google.transit.realtime.GtfsRealtime.FeedHeader.Incrementality;
24 |
25 | /**
26 | * Provides a number of convenience methods for working with GTFS-realtime data.
27 | *
28 | * @author bdferris
29 | *
30 | */
31 | public class GtfsRealtimeLibrary {
32 |
33 | /**
34 | * Constructs a new {@link FeedMessage.Builder} that can be used to build a
35 | * new GTFS-realtime feed message. The {@link FeedHeader} will already be
36 | * filled in as a {@link Incrementality#FULL_DATASET} and the timestamp of the
37 | * feed will be set to NOW. This is the minimal requirement for an empty feed
38 | * so the feed could be returned 'as-is' at this point.
39 | *
40 | *
41 | * @return a new feed message builder with a header already populated
42 | */
43 | public static FeedMessage.Builder createFeedMessageBuilder() {
44 | long now = System.currentTimeMillis();
45 | FeedHeader.Builder header = FeedHeader.newBuilder();
46 | header.setTimestamp(now / 1000);
47 | header.setIncrementality(Incrementality.FULL_DATASET);
48 | header.setGtfsRealtimeVersion(GtfsRealtimeConstants.VERSION);
49 | FeedMessage.Builder feedMessageBuilder = FeedMessage.newBuilder();
50 | feedMessageBuilder.setHeader(header);
51 | return feedMessageBuilder;
52 | }
53 |
54 | /**
55 | * @param text the text to include in the translated string
56 | * @return a new {@link TranslatedString} with just a single translation in
57 | * the default language of the feed using the specified text.
58 | */
59 | public static TranslatedString getTextAsTranslatedString(String text) {
60 | TranslatedString.Builder builder = TranslatedString.newBuilder();
61 | Translation.Builder translation = Translation.newBuilder();
62 | translation.setText(text);
63 | builder.addTranslation(translation);
64 | return builder.build();
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeServlet.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2011 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import java.io.ByteArrayOutputStream;
19 | import java.io.IOException;
20 | import java.net.URL;
21 | import java.nio.ByteBuffer;
22 |
23 | import javax.servlet.Servlet;
24 | import javax.servlet.ServletException;
25 | import javax.servlet.http.HttpServlet;
26 | import javax.servlet.http.HttpServletRequest;
27 | import javax.servlet.http.HttpServletResponse;
28 |
29 | import org.eclipse.jetty.websocket.api.RemoteEndpoint;
30 | import org.eclipse.jetty.websocket.api.Session;
31 | import org.eclipse.jetty.websocket.api.UpgradeRequest;
32 | import org.eclipse.jetty.websocket.api.UpgradeResponse;
33 | import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
34 | import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
35 | import org.eclipse.jetty.websocket.api.annotations.WebSocket;
36 | import org.eclipse.jetty.websocket.servlet.WebSocketCreator;
37 | import org.eclipse.jetty.websocket.servlet.WebSocketServlet;
38 | import org.eclipse.jetty.websocket.servlet.WebSocketServletFactory;
39 | import org.onebusaway.guice.jetty_exporter.ServletSource;
40 | import org.slf4j.Logger;
41 | import org.slf4j.LoggerFactory;
42 |
43 | import com.google.protobuf.Message;
44 | import com.google.transit.realtime.GtfsRealtime.FeedMessage;
45 |
46 | /**
47 | * Provides functionality to export a GTFS-realtime feed via HTTP, with support
48 | * for both traditional HTTP GET requests and also incremental requests via
49 | * WebSockets.
50 | *
51 | * @author bdferris
52 | */
53 | public class GtfsRealtimeServlet extends WebSocketServlet implements
54 | ServletSource {
55 |
56 | private static final long serialVersionUID = 1L;
57 |
58 | private static final String CONTENT_TYPE = "application/x-google-protobuf";
59 |
60 | private static final Logger _log = LoggerFactory.getLogger(GtfsRealtimeServlet.class);
61 |
62 | protected GtfsRealtimeSource _source;
63 |
64 | private URL _url;
65 |
66 | public void setSource(GtfsRealtimeSource source) {
67 | _source = source;
68 | }
69 |
70 | public void setUrl(URL url) {
71 | _url = url;
72 | }
73 |
74 | /****
75 | * {@link WebSocketServlet} Interface
76 | ****/
77 |
78 | @Override
79 | public void configure(WebSocketServletFactory factory) {
80 | factory.setCreator(new WebsocketCreatorImpl());
81 | }
82 |
83 | /****
84 | * {@link HttpServlet} Interface
85 | ****/
86 |
87 | @Override
88 | protected void doGet(HttpServletRequest req, HttpServletResponse resp)
89 | throws ServletException, IOException {
90 | boolean debug = req.getParameter("debug") != null;
91 | Message message = _source.getFeed();
92 | if (debug) {
93 | resp.getWriter().print(message);
94 | } else {
95 | resp.setContentType(CONTENT_TYPE);
96 | message.writeTo(resp.getOutputStream());
97 | }
98 | }
99 |
100 | /****
101 | * {@link ServletSource} Interface
102 | ****/
103 |
104 | @Override
105 | public URL getUrl() {
106 | return _url;
107 | }
108 |
109 | @Override
110 | public Servlet getServlet() {
111 | return this;
112 | }
113 |
114 | /****
115 | * Protected Methods
116 | ****/
117 |
118 | class WebsocketCreatorImpl implements WebSocketCreator {
119 | @Override
120 | public Object createWebSocket(UpgradeRequest req, UpgradeResponse resp) {
121 | return new DataWebSocket();
122 | }
123 |
124 | }
125 |
126 | @WebSocket
127 | public class DataWebSocket implements GtfsRealtimeIncrementalListener {
128 |
129 | private Session _session;
130 |
131 | @OnWebSocketConnect
132 | public void onOpen(Session session) {
133 | _log.info("client connect");
134 | _session = session;
135 | _source.addIncrementalListener(this);
136 | }
137 |
138 | @OnWebSocketClose
139 | public void onClose(Session session, int closeCode, String message) {
140 | _session = null;
141 | _source.removeIncrementalListener(this);
142 | }
143 |
144 | /****
145 | * {@link GtfsRealtimeIncrementalListener} Interface
146 | ****/
147 |
148 | @Override
149 | public void handleFeed(FeedMessage feed) {
150 | byte[] buffer = null;
151 | try {
152 | ByteArrayOutputStream out = new ByteArrayOutputStream();
153 | feed.writeTo(out);
154 | buffer = out.toByteArray();
155 | } catch (IOException ex) {
156 | throw new IllegalStateException(ex);
157 | }
158 |
159 | sendMessage(buffer);
160 | }
161 |
162 | private synchronized void sendMessage(byte[] buffer) {
163 | Session session = _session; // copy handle to remove synch issues
164 | if (session == null || !session.isOpen()) {
165 | return;
166 | }
167 | try {
168 | RemoteEndpoint remote = session.getRemote();
169 | remote.sendBytes(ByteBuffer.wrap(buffer));
170 | } catch (Exception ex) {
171 | // If anything goes wrong, we close the connection.
172 | _log.error("error sending message to remote WebSocket client", ex);
173 | try {
174 | // The @OnWebSocketClose event might have already been trigger during
175 | // our attempt to write, but if not, let's close the connection
176 | // ourselves.
177 | if (session != null) {
178 | // This should automatically trigger an @OnWebSocketClose event.
179 | session.close();
180 | }
181 | } catch (IOException ex2) {
182 | _log.error("error closing remote WebSocket connection", ex2);
183 | }
184 | }
185 | }
186 | }
187 | }
188 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeSink.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2013 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import com.google.transit.realtime.GtfsRealtime.FeedEntity;
19 | import com.google.transit.realtime.GtfsRealtime.FeedHeader;
20 |
21 | public interface GtfsRealtimeSink {
22 |
23 | /**
24 | * The exporter library will automatically fill in necessary
25 | * {@link FeedHeader} fields when exporting a feed. However, you may wish to
26 | * specify some additional fields to be included by default (eg. extensions).
27 | * You may specify a partially constructed {@link FeedHeader} object here that
28 | * will be used as a basis for constructing the actual headers sent to
29 | * clients.
30 | *
31 | * @param header a partially constructed header
32 | */
33 | public void setFeedHeaderDefaults(FeedHeader header);
34 |
35 | /**
36 | * Send a full dataset update. The feed entities in the update will replace
37 | * all previous updates received so far.
38 | *
39 | * @param update
40 | */
41 | public void handleFullUpdate(GtfsRealtimeFullUpdate update);
42 |
43 | /**
44 | * Send an incremental update. The feed entities will selectively replace any
45 | * previously updated feed entities. It is important to use stable
46 | * {@link FeedEntity#getId()} id values across updates in order for
47 | * incremental updates to function properly.
48 | *
49 | * @param update
50 | */
51 | public void handleIncrementalUpdate(GtfsRealtimeIncrementalUpdate update);
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/java/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeSource.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Copyright (C) 2012 Google, Inc.
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 | package org.onebusaway.gtfs_realtime.exporter;
17 |
18 | import com.google.transit.realtime.GtfsRealtime.FeedMessage;
19 |
20 | /**
21 | * Provides a source of GTFS-realtime data, providing methods to receive a full
22 | * data set view of a feed, along with incremental updates as well.
23 | *
24 | * @author bdferris
25 | * @see GtfsRealtimeIncrementalListener
26 | */
27 | public interface GtfsRealtimeSource {
28 |
29 | /**
30 | * @return the full-dataset view of a GTFS-realtime feed
31 | */
32 | public FeedMessage getFeed();
33 |
34 | /**
35 | * Register a new incremental GTFS-realtime listener.
36 | *
37 | * @param listener
38 | */
39 | public void addIncrementalListener(GtfsRealtimeIncrementalListener listener);
40 |
41 | /**
42 | * Un-register a new incremental GTFS-realtime listener.
43 | *
44 | * @param listener
45 | */
46 | public void removeIncrementalListener(GtfsRealtimeIncrementalListener listener);
47 | }
48 |
--------------------------------------------------------------------------------
/src/site/markdown/index.md.vm:
--------------------------------------------------------------------------------
1 | # OneBusAway GTFS-realtime Exporter
2 |
3 | #set( $H = '#' ) ## When using velocity templating (a .vm file), the ## indicates a Velocity comment, which makes Markdown section headers tricky
4 |
5 | Project documentation for the `onebusaway-gtfs-realtime-exporter`, which provides a Java library for easily sharing
6 | [GTFS-realtime](https://developers.google.com/transit/gtfs-realtime) data via an embedded web-server or by writing the
7 | data to file.
8 |
9 | **Current Version:** ${currentVersion}
10 |
11 | $H$H Getting the Library
12 |
13 | If you are using Maven to manage your project, it's easy to add a dependency for the library. First, add the
14 | [OneBusAway Maven repository](https://github.com/OneBusAway/onebusaway/wiki/Maven-Repository) to your project's `pom.xml`.
15 | Then, add a dependency for the library itself. Note that we also add a dependency on `onebusaway-guice-jsr250`, which we
16 | use for starting / stopping services.
17 |
18 | ~~~
19 |
20 |
21 | org.onebusaway
22 | onebusaway-gtfs-realtime-exporter
23 | ${currentVersion}
24 |
25 |
26 | org.onebusaway
27 | onebusaway-guice-jsr250
28 | ${onebusaway_guice_jsr250_version}
29 |
30 |
31 | ~~~
32 |
33 | $H$H Using the Library
34 |
35 | We make heavy use of [Guice](https://code.google.com/p/google-guice/) for dependency injection and management.
36 |
37 | $H$H Example Code
38 |
39 | First, we introduce a `VehiclePositionsProducer`, which is responsible for actually generating GTFS-realtime data about
40 | transit vehicles. Typically, that data comes from some other, internal data stream. The producer asks that an instance
41 | of [GtfsRealtimeSink](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeSink.html) be injected into the class,
42 | annotating with [@VehiclePositions](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeGuiceBindingTypes.VehiclePositions.html)
43 | to indicate that the GTFS-realtime sink should be for vehicle position data.
44 |
45 | The producer spawns a thread that repeatedly generates incremental vehicle position updates. Specifically, the producer
46 | sends [GtfsRealtimeIncrementalUpdate](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeIncrementalUpdate.html)
47 | objects to the sink every time it wants to send a batch of incremental updates. If you'd rather not send incremental
48 | updates, but instead to perform full feed updates, see [GtfsRealtimeFullUpdate](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeFullUpdate.html)
49 | instead.
50 |
51 | ~~~
52 | @Singleton
53 | public class VehiclePositionsProducer {
54 |
55 | private GtfsRealtimeSink _vehiclePositionsSink;
56 |
57 | @Inject
58 | public void setVehiclePositionsSink(@vehiclePositions GtfsRealtimeSink vehiclePositionsSink) {
59 | _vehiclePositionsSink = vehiclePositionsSink;
60 | }
61 |
62 | @PostConstruct
63 | public void start() {
64 | ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
65 | executor.submit(new Runnable() {
66 | @Override
67 | public void run() {
68 | runLoop();
69 | }
70 | });
71 | }
72 |
73 | private void runLoop() {
74 | while(true) {
75 | GtfsRealtimeIncrementalUpdate update = new GtfsRealtimeIncrementalUpdate();
76 | FeedEntity.Builder entity = FeedEntity.newBuilder();
77 | entity.setId("v123");
78 | VehiclePosition.Builder vehicle = VehiclePosition.newBuilder();
79 | // ... fill in vehicle position data here ...
80 | entity.setVehicle(vehicle);
81 | update.addUpdatedEntity(entity.build());
82 | _vehiclePositionsSink.handleIncrementalUpdate(update);
83 | }
84 | }
85 | }
86 | ~~~
87 |
88 | Once we have our GTFS-realtime producer, we need to wire it up with other modules and start everything running.
89 | Here, we show the `GtfsRealtimeProducerDemo` class, which is responsible for configuring a Guice Injector
90 | with all the necessary dependencies, wiring up our GTFS-realtime. We then inject a couple of classe instances:
91 |
92 | * [GtfsRealtimeSource](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeSource.html) - a source of
93 | GTFS-realtime data that we'll wire up to various export options. Again, we annotate with [@VehiclePositions](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeGuiceBindingTypes.VehiclePositions.html)
94 | to indicate that we care about vehicle position data.
95 | * [VehiclePositionsProducer] - we inject an instance to make sure it gets created
96 | * LifecycleService - we use this to start up all services annotated with @PostConstruct
97 |
98 | Next, we wire up our GTFS-realtime data source to a [GtfsRealtimeServlet](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeServlet.html)
99 | in order to share the feed via HTTP. We also connect the source to a [GtfsRealtimeFileWriter](./apidocs/org/onebusaway/gtfs_realtime/exporter/GtfsRealtimeFileWriter.html)
100 | in order to periodically write the feed to an output file. Finally, we start everything up.
101 |
102 | ~~~
103 | public class GtfsRealtimeProducerDemo {
104 |
105 | private GtfsRealtimeSource _vehiclePositionsSource;
106 | private LifecycleService _lifecycleService;
107 |
108 | @Inject
109 | public void setVehiclePositionsProducer(VehiclePositionsProducer producer) {
110 | // This is just here to make sure VehiclePositionsProducer gets instantiated.
111 | }
112 |
113 | @Inject
114 | public void setVehiclePositionsSource(@VehiclePositions GtfsRealtimeSource vehiclePositionsSource) {
115 | _vehiclePositionsSource = vehiclePositionsSource;
116 | }
117 |
118 | @Inject
119 | public void setLifecycleService(LifecycleService lifecycleService) {
120 | _lifecycleService = lifecycleService;
121 | }
122 |
123 | public void run() {
124 | Set modules = new HashSet();
125 | GtfsRealtimeExporterModule.addModuleAndDependencies(modules);
126 | JSR250Module.addModuleAndDependencies(modules);
127 | Injector injector = Guice.createInjector(modules);
128 | injector.injectMembers(this);
129 |
130 | GtfsRealtimeServlet servlet = injector.getInstance(GtfsRealtimeServlet.class);
131 | servlet.setSource(_vehiclePositionsSource);
132 | servlet.setUrl(new URL("http://localhost:8080/trip-updates"));
133 |
134 | GtfsRealtimeFileWriter fileWriter = injector.getInstance(GtfsRealtimeFileWriter.class);
135 | fileWriter.setSource(_vehiclePositionsSource);
136 | fileWriter.setPath(new File("/tmp/trip-updates.pd"));
137 |
138 | _lifecycleService.start();
139 | }
140 | }
141 | ~~~
142 |
--------------------------------------------------------------------------------
/src/site/markdown/release-notes.md.vm:
--------------------------------------------------------------------------------
1 | # Release Notes
2 |
3 | #set( $H = '#' ) ## When using velocity templating (a .vm file), the ## indicates a Velocity comment, which makes Markdown section headers tricky
4 |
5 | $H$H ${currentVersion}
6 |
7 | * Full Documentation: ${site_base_url}/onebusaway-gtfs-realtime-from-siri-cli/${currentVersion}/
8 |
9 | $H$H 1.1.0
10 |
11 | * Add a listener method to GtfsRealtimeProvider for receiving notification of updates. Also provide a default
12 | implementation of that behavior.
13 |
14 | * Bump onebusaway-gtfs-realtime-api to 1.1.0.
15 |
16 | * Full Documentation: ${site_base_url}/onebusaway-gtfs-realtime-from-siri-cli/1.1.0/
17 |
18 | $H$H 1.0.1
19 |
20 | * Fix a bug with the timestamp value in the GTFS-realtime FeedHeader.
21 | * Full Documentation: ${site_base_url}/onebusaway-gtfs-realtime-from-siri-cli/1.0.1/
22 |
23 | $H$H 1.0.0
24 |
25 | * Initial release
26 | * Full Documentation: ${site_base_url}/onebusaway-gtfs-realtime-from-siri-cli/1.0.0/
--------------------------------------------------------------------------------
/src/site/site.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |