| /* |
| * |
| * Copyright 2015, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| var PROTO_PATH = __dirname + '/../../protos/route_guide.proto'; |
| |
| var fs = require('fs'); |
| var parseArgs = require('minimist'); |
| var path = require('path'); |
| var _ = require('lodash'); |
| var grpc = require('grpc'); |
| var routeguide = grpc.load(PROTO_PATH).routeguide; |
| |
| var COORD_FACTOR = 1e7; |
| |
| /** |
| * For simplicity, a point is a record type that looks like |
| * {latitude: number, longitude: number}, and a feature is a record type that |
| * looks like {name: string, location: point}. feature objects with name==='' |
| * are points with no feature. |
| */ |
| |
| /** |
| * List of feature objects at points that have been requested so far. |
| */ |
| var feature_list = []; |
| |
| /** |
| * Get a feature object at the given point, or creates one if it does not exist. |
| * @param {point} point The point to check |
| * @return {feature} The feature object at the point. Note that an empty name |
| * indicates no feature |
| */ |
| function checkFeature(point) { |
| var feature; |
| // Check if there is already a feature object for the given point |
| for (var i = 0; i < feature_list.length; i++) { |
| feature = feature_list[i]; |
| if (feature.location.latitude === point.latitude && |
| feature.location.longitude === point.longitude) { |
| return feature; |
| } |
| } |
| var name = ''; |
| feature = { |
| name: name, |
| location: point |
| }; |
| return feature; |
| } |
| |
| /** |
| * getFeature request handler. Gets a request with a point, and responds with a |
| * feature object indicating whether there is a feature at that point. |
| * @param {EventEmitter} call Call object for the handler to process |
| * @param {function(Error, feature)} callback Response callback |
| */ |
| function getFeature(call, callback) { |
| callback(null, checkFeature(call.request)); |
| } |
| |
| /** |
| * listFeatures request handler. Gets a request with two points, and responds |
| * with a stream of all features in the bounding box defined by those points. |
| * @param {Writable} call Writable stream for responses with an additional |
| * request property for the request value. |
| */ |
| function listFeatures(call) { |
| var lo = call.request.lo; |
| var hi = call.request.hi; |
| var left = _.min([lo.longitude, hi.longitude]); |
| var right = _.max([lo.longitude, hi.longitude]); |
| var top = _.max([lo.latitude, hi.latitude]); |
| var bottom = _.min([lo.latitude, hi.latitude]); |
| // For each feature, check if it is in the given bounding box |
| _.each(feature_list, function(feature) { |
| if (feature.name === '') { |
| return; |
| } |
| if (feature.location.longitude >= left && |
| feature.location.longitude <= right && |
| feature.location.latitude >= bottom && |
| feature.location.latitude <= top) { |
| call.write(feature); |
| } |
| }); |
| call.end(); |
| } |
| |
| /** |
| * Calculate the distance between two points using the "haversine" formula. |
| * This code was taken from http://www.movable-type.co.uk/scripts/latlong.html. |
| * @param start The starting point |
| * @param end The end point |
| * @return The distance between the points in meters |
| */ |
| function getDistance(start, end) { |
| function toRadians(num) { |
| return num * Math.PI / 180; |
| } |
| var lat1 = start.latitude / COORD_FACTOR; |
| var lat2 = end.latitude / COORD_FACTOR; |
| var lon1 = start.longitude / COORD_FACTOR; |
| var lon2 = end.longitude / COORD_FACTOR; |
| var R = 6371000; // metres |
| var φ1 = toRadians(lat1); |
| var φ2 = toRadians(lat2); |
| var Δφ = toRadians(lat2-lat1); |
| var Δλ = toRadians(lon2-lon1); |
| |
| var a = Math.sin(Δφ/2) * Math.sin(Δφ/2) + |
| Math.cos(φ1) * Math.cos(φ2) * |
| Math.sin(Δλ/2) * Math.sin(Δλ/2); |
| var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a)); |
| |
| return R * c; |
| } |
| |
| /** |
| * recordRoute handler. Gets a stream of points, and responds with statistics |
| * about the "trip": number of points, number of known features visited, total |
| * distance traveled, and total time spent. |
| * @param {Readable} call The request point stream. |
| * @param {function(Error, routeSummary)} callback The callback to pass the |
| * response to |
| */ |
| function recordRoute(call, callback) { |
| var point_count = 0; |
| var feature_count = 0; |
| var distance = 0; |
| var previous = null; |
| // Start a timer |
| var start_time = process.hrtime(); |
| call.on('data', function(point) { |
| point_count += 1; |
| if (checkFeature(point).name !== '') { |
| feature_count += 1; |
| } |
| /* For each point after the first, add the incremental distance from the |
| * previous point to the total distance value */ |
| if (previous != null) { |
| distance += getDistance(previous, point); |
| } |
| previous = point; |
| }); |
| call.on('end', function() { |
| callback(null, { |
| point_count: point_count, |
| feature_count: feature_count, |
| // Cast the distance to an integer |
| distance: distance|0, |
| // End the timer |
| elapsed_time: process.hrtime(start_time)[0] |
| }); |
| }); |
| } |
| |
| var route_notes = {}; |
| |
| /** |
| * Turn the point into a dictionary key. |
| * @param {point} point The point to use |
| * @return {string} The key for an object |
| */ |
| function pointKey(point) { |
| return point.latitude + ' ' + point.longitude; |
| } |
| |
| /** |
| * routeChat handler. Receives a stream of message/location pairs, and responds |
| * with a stream of all previous messages at each of those locations. |
| * @param {Duplex} call The stream for incoming and outgoing messages |
| */ |
| function routeChat(call) { |
| call.on('data', function(note) { |
| var key = pointKey(note.location); |
| /* For each note sent, respond with all previous notes that correspond to |
| * the same point */ |
| if (route_notes.hasOwnProperty(key)) { |
| _.each(route_notes[key], function(note) { |
| call.write(note); |
| }); |
| } else { |
| route_notes[key] = []; |
| } |
| // Then add the new note to the list |
| route_notes[key].push(JSON.parse(JSON.stringify(note))); |
| }); |
| call.on('end', function() { |
| call.end(); |
| }); |
| } |
| |
| /** |
| * Get a new server with the handler functions in this file bound to the methods |
| * it serves. |
| * @return {Server} The new server object |
| */ |
| function getServer() { |
| var server = new grpc.Server(); |
| server.addProtoService(routeguide.RouteGuide.service, { |
| getFeature: getFeature, |
| listFeatures: listFeatures, |
| recordRoute: recordRoute, |
| routeChat: routeChat |
| }); |
| return server; |
| } |
| |
| if (require.main === module) { |
| // If this is run as a script, start a server on an unused port |
| var routeServer = getServer(); |
| routeServer.bind('0.0.0.0:50051', grpc.ServerCredentials.createInsecure()); |
| var argv = parseArgs(process.argv, { |
| string: 'db_path' |
| }); |
| fs.readFile(path.resolve(argv.db_path), function(err, data) { |
| if (err) throw err; |
| feature_list = JSON.parse(data); |
| routeServer.start(); |
| }); |
| } |
| |
| exports.getServer = getServer; |