Firebase Update

express-server/node_modules/grpc/src/common.js

@@ -0,0 +1,311 @@
+/**
+ * @license
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+'use strict';
+
+var _ = require('lodash');
+var constants = require('./constants');
+
+/**
+ * Wrap a function to pass null-like values through without calling it. If no
+ * function is given, just uses the identity.
+ * @private
+ * @param {?function} func The function to wrap
+ * @return {function} The wrapped function
+ */
+exports.wrapIgnoreNull = function wrapIgnoreNull(func) {
+  if (!func) {
+    return _.identity;
+  }
+  return function(arg) {
+    if (arg === null || arg === undefined) {
+      return null;
+    }
+    return func(arg);
+  };
+};
+
+/**
+ * The logger object for the gRPC module. Defaults to console.
+ * @private
+ */
+exports.logger = console;
+
+/**
+ * The current logging verbosity. 0 corresponds to logging everything
+ * @private
+ */
+exports.logVerbosity = 0;
+
+/**
+ * Log a message if the severity is at least as high as the current verbosity
+ * @private
+ * @param {Number} severity A value of the grpc.logVerbosity map
+ * @param {String} message The message to log
+ */
+exports.log = function log(severity, message) {
+  if (severity >= exports.logVerbosity) {
+    exports.logger.error(message);
+  }
+};
+
+/**
+ * Default options for loading proto files into gRPC
+ * @alias grpc~defaultLoadOptions
+ */
+exports.defaultGrpcOptions = {
+  convertFieldsToCamelCase: false,
+  binaryAsBase64: false,
+  longsAsStrings: true,
+  enumsAsStrings: true,
+  deprecatedArgumentOrder: false
+};
+
+/**
+ * Create an Error object from a status object
+ * @param {grpc~StatusObject} status The status object
+ * @return {Error} The resulting Error
+ */
+exports.createStatusError = function(status) {
+  let statusName = _.invert(constants.status)[status.code];
+  let message = `${status.code} ${statusName}: ${status.details}`;
+  let error = new Error(message);
+  error.code = status.code;
+  error.metadata = status.metadata;
+  error.details = status.details;
+  return error;
+};
+
+/**
+ * Get a method's type from its definition
+ * @param {grpc~MethodDefinition} method_definition
+ * @return {number}
+ */
+exports.getMethodType = function(method_definition) {
+  if (method_definition.requestStream) {
+    if (method_definition.responseStream) {
+      return constants.methodTypes.BIDI_STREAMING;
+    } else {
+      return constants.methodTypes.CLIENT_STREAMING;
+    }
+  } else {
+    if (method_definition.responseStream) {
+      return constants.methodTypes.SERVER_STREAMING;
+    } else {
+      return constants.methodTypes.UNARY;
+    }
+  }
+};
+
+// JSDoc definitions that are used in multiple other modules
+
+/**
+ * Represents the status of a completed request. If `code` is
+ * {@link grpc.status}.OK, then the request has completed successfully.
+ * Otherwise, the request has failed, `details` will contain a description of
+ * the error. Either way, `metadata` contains the trailing response metadata
+ * sent by the server when it finishes processing the call.
+ * @typedef {object} grpc~StatusObject
+ * @property {number} code The error code, a key of {@link grpc.status}
+ * @property {string} details Human-readable description of the status
+ * @property {grpc.Metadata} metadata Trailing metadata sent with the status,
+ *     if applicable
+ */
+
+/**
+ * Describes how a request has failed. The member `message` will be the same as
+ * `details` in {@link grpc~StatusObject}, and `code` and `metadata` are the
+ * same as in that object.
+ * @typedef {Error} grpc~ServiceError
+ * @property {number} code The error code, a key of {@link grpc.status} that is
+ *     not `grpc.status.OK`
+ * @property {grpc.Metadata} metadata Trailing metadata sent with the status,
+ *     if applicable
+ */
+
+/**
+ * The EventEmitter class in the event standard module
+ * @external EventEmitter
+ * @see https://nodejs.org/api/events.html#events_class_eventemitter
+ */
+
+/**
+ * The Readable class in the stream standard module
+ * @external Readable
+ * @see https://nodejs.org/api/stream.html#stream_readable_streams
+ */
+
+/**
+ * The Writable class in the stream standard module
+ * @external Writable
+ * @see https://nodejs.org/api/stream.html#stream_writable_streams
+ */
+
+/**
+ * The Duplex class in the stream standard module
+ * @external Duplex
+ * @see https://nodejs.org/api/stream.html#stream_class_stream_duplex
+ */
+
+/**
+ * A serialization function
+ * @callback grpc~serialize
+ * @param {*} value The value to serialize
+ * @return {Buffer} The value serialized as a byte sequence
+ */
+
+/**
+ * A deserialization function
+ * @callback grpc~deserialize
+ * @param {Buffer} data The byte sequence to deserialize
+ * @return {*} The data deserialized as a value
+ */
+
+/**
+ * The deadline of an operation. If it is a date, the deadline is reached at
+ * the date and time specified. If it is a finite number, it is treated as
+ * a number of milliseconds since the Unix Epoch. If it is Infinity, the
+ * deadline will never be reached. If it is -Infinity, the deadline has already
+ * passed.
+ * @typedef {(number|Date)} grpc~Deadline
+ */
+
+/**
+ * An object that completely defines a service method signature.
+ * @typedef {Object} grpc~MethodDefinition
+ * @property {string} path The method's URL path
+ * @property {boolean} requestStream Indicates whether the method accepts
+ *     a stream of requests
+ * @property {boolean} responseStream Indicates whether the method returns
+ *     a stream of responses
+ * @property {grpc~serialize} requestSerialize Serialization
+ *     function for request values
+ * @property {grpc~serialize} responseSerialize Serialization
+ *     function for response values
+ * @property {grpc~deserialize} requestDeserialize Deserialization
+ *     function for request data
+ * @property {grpc~deserialize} responseDeserialize Deserialization
+ *     function for repsonse data
+ */
+
+/**
+ * @function MetadataListener
+ * @param {grpc.Metadata} metadata The response metadata.
+ * @param {function} next Passes metadata to the next interceptor.
+ */
+
+/**
+ * @function MessageListener
+ * @param {jspb.Message} message The response message.
+ * @param {function} next Passes a message to the next interceptor.
+ */
+
+/**
+ * @function StatusListener
+ * @param {grpc~StatusObject} status The response status.
+ * @param {function} next Passes a status to the next interceptor.
+ */
+
+/**
+ * A set of interceptor functions triggered by responses
+ * @typedef {object} grpc~Listener
+ * @property {MetadataListener=} onReceiveMetadata A function triggered by
+ *     response metadata.
+ * @property {MessageListener=} onReceiveMessage A function triggered by a
+ *     response message.
+ * @property {StatusListener=} onReceiveStatus A function triggered by a
+ *     response status.
+ */
+
+/**
+ * @function MetadataRequester
+ * @param {grpc.Metadata} metadata The request metadata.
+ * @param {grpc~Listener} listener A listener wired to the previous layers
+ *     in the interceptor stack.
+ * @param {function} next Passes metadata and a listener to the next
+ *      interceptor.
+ */
+
+/**
+ * @function MessageRequester
+ * @param {jspb.Message} message The request message.
+ * @param {function} next Passes a message to the next interceptor.
+ */
+
+/**
+ * @function CloseRequester
+ * @param {function} next Calls the next interceptor.
+ */
+
+/**
+ * @function CancelRequester
+ * @param {function} next Calls the next interceptor.
+ */
+
+/**
+ * @function GetPeerRequester
+ * @param {function} next Calls the next interceptor.
+ * @return {string}
+ */
+
+/**
+ * @typedef {object} grpc~Requester
+ * @param {MetadataRequester=} start A function triggered when the call begins.
+ * @param {MessageRequester=} sendMessage A function triggered by the request
+ *     message.
+ * @param {CloseRequester=} halfClose A function triggered when the client
+ *     closes the call.
+ * @param {CancelRequester=} cancel A function triggered when the call is
+ *     cancelled.
+ * @param {GetPeerRequester=} getPeer A function triggered when the endpoint is
+ *     requested.
+ */
+
+/**
+ * An object that completely defines a service.
+ * @typedef {Object.<string, grpc~MethodDefinition>} grpc~ServiceDefinition
+ */
+
+/**
+ * An object that defines a package hierarchy with multiple services
+ * @typedef {Object.<string, grpc~ServiceDefinition>} grpc~PackageDefinition
+ */
+
+/**
+ * A function for dynamically assigning an interceptor to a call.
+ * @function InterceptorProvider
+ * @param {grpc~MethodDefinition} method_definition The method to provide
+ *     an interceptor for.
+ * @return {Interceptor|null} The interceptor to provide or nothing
+ */
+
+/**
+ * A function which can modify call options and produce methods to intercept
+ * RPC operations.
+ * @function Interceptor
+ * @param {object} options The grpc call options
+ * @param {NextCall} nextCall
+ * @return {InterceptingCall}
+ */
+
+/**
+ * A function which produces the next InterceptingCall.
+ * @function NextCall
+ * @param {object} options The grpc call options
+ * @return {InterceptingCall|null}
+ */

express-server/node_modules/grpc/src/constants.js

@@ -0,0 +1,266 @@
+/**
+ * @license
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* The comments about status codes are copied verbatim (with some formatting
+ * modifications) from include/grpc/impl/codegen/status.h, for the purpose of
+ * including them in generated documentation.
+ */
+/**
+ * Enum of status codes that gRPC can return
+ * @memberof grpc
+ * @alias grpc.status
+ * @readonly
+ * @enum {number}
+ */
+exports.status = {
+  /** Not an error; returned on success */
+  OK: 0,
+  /** The operation was cancelled (typically by the caller). */
+  CANCELLED: 1,
+  /**
+   * Unknown error.  An example of where this error may be returned is
+   * if a status value received from another address space belongs to
+   * an error-space that is not known in this address space.  Also
+   * errors raised by APIs that do not return enough error information
+   * may be converted to this error.
+   */
+  UNKNOWN: 2,
+  /**
+   * Client specified an invalid argument.  Note that this differs
+   * from FAILED_PRECONDITION.  INVALID_ARGUMENT indicates arguments
+   * that are problematic regardless of the state of the system
+   * (e.g., a malformed file name).
+   */
+  INVALID_ARGUMENT: 3,
+  /**
+   * Deadline expired before operation could complete.  For operations
+   * that change the state of the system, this error may be returned
+   * even if the operation has completed successfully.  For example, a
+   * successful response from a server could have been delayed long
+   * enough for the deadline to expire.
+   */
+  DEADLINE_EXCEEDED: 4,
+  /** Some requested entity (e.g., file or directory) was not found. */
+  NOT_FOUND: 5,
+  /**
+   * Some entity that we attempted to create (e.g., file or directory)
+   * already exists.
+   */
+  ALREADY_EXISTS: 6,
+  /**
+   * The caller does not have permission to execute the specified
+   * operation.  PERMISSION_DENIED must not be used for rejections
+   * caused by exhausting some resource (use RESOURCE_EXHAUSTED
+   * instead for those errors).  PERMISSION_DENIED must not be
+   * used if the caller can not be identified (use UNAUTHENTICATED
+   * instead for those errors).
+   */
+  PERMISSION_DENIED: 7,
+  /**
+   * Some resource has been exhausted, perhaps a per-user quota, or
+   * perhaps the entire file system is out of space.
+   */
+  RESOURCE_EXHAUSTED: 8,
+  /**
+   * Operation was rejected because the system is not in a state
+   * required for the operation's execution.  For example, directory
+   * to be deleted may be non-empty, an rmdir operation is applied to
+   * a non-directory, etc.
+   *
+   * A litmus test that may help a service implementor in deciding
+   * between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:
+   *
+   *  - Use UNAVAILABLE if the client can retry just the failing call.
+   *  - Use ABORTED if the client should retry at a higher-level
+   *    (e.g., restarting a read-modify-write sequence).
+   *  - Use FAILED_PRECONDITION if the client should not retry until
+   *    the system state has been explicitly fixed.  E.g., if an "rmdir"
+   *    fails because the directory is non-empty, FAILED_PRECONDITION
+   *    should be returned since the client should not retry unless
+   *    they have first fixed up the directory by deleting files from it.
+   *  - Use FAILED_PRECONDITION if the client performs conditional
+   *    REST Get/Update/Delete on a resource and the resource on the
+   *    server does not match the condition. E.g., conflicting
+   *    read-modify-write on the same resource.
+   */
+  FAILED_PRECONDITION: 9,
+  /**
+   * The operation was aborted, typically due to a concurrency issue
+   * like sequencer check failures, transaction aborts, etc.
+   *
+   * See litmus test above for deciding between FAILED_PRECONDITION,
+   * ABORTED, and UNAVAILABLE.
+   */
+  ABORTED: 10,
+  /**
+   * Operation was attempted past the valid range.  E.g., seeking or
+   * reading past end of file.
+   *
+   * Unlike INVALID_ARGUMENT, this error indicates a problem that may
+   * be fixed if the system state changes. For example, a 32-bit file
+   * system will generate INVALID_ARGUMENT if asked to read at an
+   * offset that is not in the range [0,2^32-1], but it will generate
+   * OUT_OF_RANGE if asked to read from an offset past the current
+   * file size.
+   *
+   * There is a fair bit of overlap between FAILED_PRECONDITION and
+   * OUT_OF_RANGE.  We recommend using OUT_OF_RANGE (the more specific
+   * error) when it applies so that callers who are iterating through
+   * a space can easily look for an OUT_OF_RANGE error to detect when
+   * they are done.
+   */
+  OUT_OF_RANGE: 11,
+  /** Operation is not implemented or not supported/enabled in this service. */
+  UNIMPLEMENTED: 12,
+  /**
+   * Internal errors.  Means some invariants expected by underlying
+   * system has been broken.  If you see one of these errors,
+   * something is very broken.
+   */
+  INTERNAL: 13,
+  /**
+   * The service is currently unavailable.  This is a most likely a
+   * transient condition and may be corrected by retrying with
+   * a backoff.
+   *
+   * See litmus test above for deciding between FAILED_PRECONDITION,
+   * ABORTED, and UNAVAILABLE.
+   */
+  UNAVAILABLE: 14,
+  /** Unrecoverable data loss or corruption. */
+  DATA_LOSS: 15,
+  /**
+   * The request does not have valid authentication credentials for the
+   * operation.
+   */
+  UNAUTHENTICATED: 16
+};
+
+/* The comments about propagation bit flags are copied from
+ * include/grpc/impl/codegen/propagation_bits.h for the purpose of including
+ * them in generated documentation.
+ */
+/**
+ * Propagation flags: these can be bitwise or-ed to form the propagation option
+ * for calls.
+ *
+ * Users are encouraged to write propagation masks as deltas from the default.
+ * i.e. write `grpc.propagate.DEFAULTS & ~grpc.propagate.DEADLINE` to disable
+ * deadline propagation.
+ * @memberof grpc
+ * @alias grpc.propagate
+ * @enum {number}
+ */
+exports.propagate = {
+  DEADLINE: 1,
+  CENSUS_STATS_CONTEXT: 2,
+  CENSUS_TRACING_CONTEXT: 4,
+  CANCELLATION: 8,
+  DEFAULTS: 65535
+};
+
+/* Many of the following comments are copied from
+ * include/grpc/impl/codegen/grpc_types.h
+ */
+/**
+ * Call error constants. Call errors almost always indicate bugs in the gRPC
+ * library, and these error codes are mainly useful for finding those bugs.
+ * @memberof grpc
+ * @readonly
+ * @enum {number}
+ */
+const callError = {
+  OK: 0,
+  ERROR: 1,
+  NOT_ON_SERVER: 2,
+  NOT_ON_CLIENT: 3,
+  ALREADY_INVOKED: 5,
+  NOT_INVOKED: 6,
+  ALREADY_FINISHED: 7,
+  TOO_MANY_OPERATIONS: 8,
+  INVALID_FLAGS: 9,
+  INVALID_METADATA: 10,
+  INVALID_MESSAGE: 11,
+  NOT_SERVER_COMPLETION_QUEUE: 12,
+  BATCH_TOO_BIG: 13,
+  PAYLOAD_TYPE_MISMATCH: 14
+};
+
+exports.callError = callError;
+
+/**
+ * Write flags: these can be bitwise or-ed to form write options that modify
+ * how data is written.
+ * @memberof grpc
+ * @alias grpc.writeFlags
+ * @readonly
+ * @enum {number}
+ */
+exports.writeFlags = {
+  /**
+   * Hint that the write may be buffered and need not go out on the wire
+   * immediately. GRPC is free to buffer the message until the next non-buffered
+   * write, or until writes_done, but it need not buffer completely or at all.
+   */
+  BUFFER_HINT: 1,
+  /**
+   * Force compression to be disabled for a particular write
+   */
+  NO_COMPRESS: 2
+};
+
+/**
+ * @memberof grpc
+ * @alias grpc.logVerbosity
+ * @readonly
+ * @enum {number}
+ */
+exports.logVerbosity = {
+  DEBUG: 0,
+  INFO: 1,
+  ERROR: 2
+};
+
+/**
+ * Method types: the supported RPC types
+ * @memberof grpc
+ * @alias grpc.methodTypes
+ * @readonly
+ * @enum {number}
+ */
+exports.methodTypes = {
+  UNARY: 0,
+  CLIENT_STREAMING: 1,
+  SERVER_STREAMING: 2,
+  BIDI_STREAMING: 3
+};
+
+/**
+ * Connectivity state values
+ * @memberof grpc
+ * @alias grpc.connectivityState
+ * @readonly
+ * @enum {number}
+ */
+exports.connectivityState = {
+  IDLE: 0,
+  CONNECTING: 1,
+  READY: 2,
+  TRANSIENT_FAILURE: 3,
+  SHUTDOWN: 4
+};

express-server/node_modules/grpc/src/credentials.js

@@ -0,0 +1,278 @@
+/**
+ * @license
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * Credentials module
+ *
+ * This module contains factory methods for two different credential types:
+ * CallCredentials and ChannelCredentials. ChannelCredentials are things like
+ * SSL credentials that can be used to secure a connection, and are used to
+ * construct a Client object. CallCredentials genrally modify metadata, so they
+ * can be attached to an individual method call.
+ *
+ * CallCredentials can be composed with other CallCredentials to create
+ * CallCredentials. ChannelCredentials can be composed with CallCredentials
+ * to create ChannelCredentials. No combined credential can have more than
+ * one ChannelCredentials.
+ *
+ * For example, to create a client secured with SSL that uses Google
+ * default application credentials to authenticate:
+ *
+ * @example
+ * var channel_creds = credentials.createSsl(root_certs);
+ * (new GoogleAuth()).getApplicationDefault(function(err, credential) {
+ *   var call_creds = credentials.createFromGoogleCredential(credential);
+ *   var combined_creds = credentials.combineChannelCredentials(
+ *       channel_creds, call_creds);
+ *   var client = new Client(address, combined_creds);
+ * });
+ *
+ * @namespace grpc.credentials
+ */
+
+'use strict';
+
+var grpc = require('./grpc_extension');
+
+/**
+ * This cannot be constructed directly. Instead, instances of this class should
+ * be created using the factory functions in {@link grpc.credentials}
+ * @constructor grpc.credentials~CallCredentials
+ */
+var CallCredentials = grpc.CallCredentials;
+
+/**
+ * This cannot be constructed directly. Instead, instances of this class should
+ * be created using the factory functions in {@link grpc.credentials}
+ * @constructor grpc.credentials~ChannelCredentials
+ */
+var ChannelCredentials = grpc.ChannelCredentials;
+
+var Metadata = require('./metadata.js');
+
+var common = require('./common.js');
+
+var constants = require('./constants');
+
+var _ = require('lodash');
+
+/**
+ * @external GoogleCredential
+ * @see https://github.com/google/google-auth-library-nodejs
+ */
+
+const PEM_CERT_HEADER = "-----BEGIN CERTIFICATE-----";
+const PEM_CERT_FOOTER = "-----END CERTIFICATE-----";
+
+function wrapCheckServerIdentityCallback(callback) {
+  return function(hostname, cert) {
+    // Parse cert from pem to a version that matches the tls.checkServerIdentity
+    // format.
+    // https://nodejs.org/api/tls.html#tls_tls_checkserveridentity_hostname_cert
+
+    var pemHeaderIndex = cert.indexOf(PEM_CERT_HEADER);
+    if (pemHeaderIndex === -1) {
+      return new Error("Unable to parse certificate PEM.");
+    }
+    cert = cert.substring(pemHeaderIndex);
+    var pemFooterIndex = cert.indexOf(PEM_CERT_FOOTER);
+    if (pemFooterIndex === -1) {
+      return new Error("Unable to parse certificate PEM.");
+    }
+    cert = cert.substring(PEM_CERT_HEADER.length, pemFooterIndex);
+    var rawBuffer = new Buffer(cert.replace("\n", "").replace(" ", ""), "base64");
+
+    return callback(hostname, { raw: rawBuffer });
+  }
+}
+
+/**
+ * Create an SSL Credentials object. If using a client-side certificate, both
+ * the second and third arguments must be passed. Additional peer verification
+ * options can be passed in the fourth argument as described below.
+ * @memberof grpc.credentials
+ * @alias grpc.credentials.createSsl
+ * @kind function
+ * @param {Buffer=} root_certs The root certificate data
+ * @param {Buffer=} private_key The client certificate private key, if
+ *     applicable
+ * @param {Buffer=} cert_chain The client certificate cert chain, if applicable
+ * @param {Function} verify_options.checkServerIdentity Optional callback
+ *     receiving the expected hostname and peer certificate for additional
+ *     verification. The callback should return an Error if verification
+ *     fails and otherwise return undefined.
+ * @return {grpc.credentials~ChannelCredentials} The SSL Credentials object
+ */
+exports.createSsl = function(root_certs, private_key, cert_chain, verify_options) {
+  // The checkServerIdentity callback from gRPC core will receive the cert as a PEM.
+  // To better match the checkServerIdentity callback of Node, we wrap the callback
+  // to decode the PEM and populate a cert object.
+  if (verify_options && verify_options.checkServerIdentity) {
+    if (typeof verify_options.checkServerIdentity !== 'function') {
+      throw new TypeError("Value of checkServerIdentity must be a function.");
+    }
+    // Make a shallow clone of verify_options so our modification of the callback
+    // isn't reflected to the caller
+    var updated_verify_options = Object.assign({}, verify_options);
+    updated_verify_options.checkServerIdentity = wrapCheckServerIdentityCallback(
+        verify_options.checkServerIdentity);
+    arguments[3] = updated_verify_options;
+  }
+  return ChannelCredentials.createSsl.apply(this, arguments);
+}
+
+
+/**
+ * @callback grpc.credentials~metadataCallback
+ * @param {Error} error The error, if getting metadata failed
+ * @param {grpc.Metadata} metadata The metadata
+ */
+
+/**
+ * @callback grpc.credentials~generateMetadata
+ * @param {Object} params Parameters that can modify metadata generation
+ * @param {string} params.service_url The URL of the service that the call is
+ *     going to
+ * @param {grpc.credentials~metadataCallback} callback
+ */
+
+/**
+ * Create a gRPC credentials object from a metadata generation function. This
+ * function gets the service URL and a callback as parameters. The error
+ * passed to the callback can optionally have a 'code' value attached to it,
+ * which corresponds to a status code that this library uses.
+ * @memberof grpc.credentials
+ * @alias grpc.credentials.createFromMetadataGenerator
+ * @param {grpc.credentials~generateMetadata} metadata_generator The function
+ *     that generates metadata
+ * @return {grpc.credentials~CallCredentials} The credentials object
+ */
+exports.createFromMetadataGenerator = function(metadata_generator) {
+  return CallCredentials.createFromPlugin(function(service_url, cb_data,
+                                                   callback) {
+    metadata_generator({service_url: service_url}, function(error, metadata) {
+      var code = constants.status.OK;
+      var message = '';
+      if (error) {
+        message = error.message;
+        if (error.hasOwnProperty('code') && _.isFinite(error.code)) {
+          code = error.code;
+        } else {
+          code = constants.status.UNAUTHENTICATED;
+        }
+        if (!metadata) {
+          metadata = new Metadata();
+        }
+      }
+      callback(code, message, metadata._getCoreRepresentation(), cb_data);
+    });
+  });
+};
+
+function getAuthorizationHeaderFromGoogleCredential(google_credential, url, callback) {
+  // google-auth-library pre-v2.0.0 does not have getRequestHeaders
+  // but has getRequestMetadata, which is deprecated in v2.0.0
+  if (typeof google_credential.getRequestHeaders === 'function') {
+    google_credential.getRequestHeaders(url)
+      .then(function(header) {
+        callback(null, header.Authorization);
+      })
+      .catch(function(err) {
+        callback(err);
+        return;
+      });
+  } else {
+    google_credential.getRequestMetadata(url, function(err, header) {
+      if (err) {
+        callback(err);
+        return;
+      }
+      callback(null, header.Authorization);
+    });
+  }
+}
+
+/**
+ * Create a gRPC credential from a Google credential object.
+ * @memberof grpc.credentials
+ * @alias grpc.credentials.createFromGoogleCredential
+ * @param {external:GoogleCredential} google_credential The Google credential
+ *     object to use
+ * @return {grpc.credentials~CallCredentials} The resulting credentials object
+ */
+exports.createFromGoogleCredential = function(google_credential) {
+  return exports.createFromMetadataGenerator(function(auth_context, callback) {
+    var service_url = auth_context.service_url;
+    getAuthorizationHeaderFromGoogleCredential(google_credential, service_url,
+      function(err, authHeader) {
+        if (err) {
+          common.log(constants.logVerbosity.INFO, 'Auth error:' + err);
+          callback(err);
+          return;
+        }
+        var metadata = new Metadata();
+        metadata.add('authorization', authHeader);
+        callback(null, metadata);
+      });
+  });
+};
+
+/**
+ * Combine a ChannelCredentials with any number of CallCredentials into a single
+ * ChannelCredentials object.
+ * @memberof grpc.credentials
+ * @alias grpc.credentials.combineChannelCredentials
+ * @param {grpc.credentials~ChannelCredentials} channel_credential The ChannelCredentials to
+ *     start with
+ * @param {...grpc.credentials~CallCredentials} credentials The CallCredentials to compose
+ * @return {grpc.credentials~ChannelCredentials} A credentials object that combines all of the
+ *     input credentials
+ */
+exports.combineChannelCredentials = function(channel_credential) {
+  var current = channel_credential;
+  for (var i = 1; i < arguments.length; i++) {
+    current = current.compose(arguments[i]);
+  }
+  return current;
+};
+
+/**
+ * Combine any number of CallCredentials into a single CallCredentials object
+ * @memberof grpc.credentials
+ * @alias grpc.credentials.combineCallCredentials
+ * @param {...grpc.credentials~CallCredentials} credentials The CallCredentials to compose
+ * @return {grpc.credentials~CallCredentials} A credentials object that combines all of the input
+ *     credentials
+ */
+exports.combineCallCredentials = function() {
+  var current = arguments[0];
+  for (var i = 1; i < arguments.length; i++) {
+    current = current.compose(arguments[i]);
+  }
+  return current;
+};
+
+/**
+ * Create an insecure credentials object. This is used to create a channel that
+ * does not use SSL. This cannot be composed with anything.
+ * @memberof grpc.credentials
+ * @alias grpc.credentials.createInsecure
+ * @kind function
+ * @return {grpc.credentials~ChannelCredentials} The insecure credentials object
+ */
+exports.createInsecure = ChannelCredentials.createInsecure;

express-server/node_modules/grpc/src/grpc_extension.js

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * @module
+ * @private
+ */
+
+'use strict';
+
+var binary = require('node-pre-gyp/lib/pre-binding');
+var path = require('path');
+var binding_path =
+    binary.find(path.resolve(path.join(__dirname, '../package.json')));
+var binding;
+try {
+  binding = require(binding_path);
+} catch (e) {
+  let fs = require('fs');
+  let searchPath = path.dirname(path.dirname(binding_path));
+  let searchName = path.basename(path.dirname(binding_path));
+  let foundNames;
+  try {
+    foundNames = fs.readdirSync(searchPath);
+  } catch (readDirError) {
+    let message = `The gRPC binary module was not installed. This may be fixed by running "npm rebuild"
+Original error: ${e.message}`;
+    let error = new Error(message);
+    error.code = e.code;
+    throw error;
+  }
+  if (foundNames.indexOf(searchName) === -1) {
+    let message = `Failed to load gRPC binary module because it was not installed for the current system
+Expected directory: ${searchName}
+Found: [${foundNames.join(', ')}]
+This problem can often be fixed by running "npm rebuild" on the current system
+Original error: ${e.message}`;
+    let error = new Error(message);
+    error.code = e.code;
+    throw error;
+  } else {
+    throw e;
+  }
+}
+
+module.exports = binding;

express-server/node_modules/grpc/src/metadata.js

@@ -0,0 +1,172 @@
+/**
+ * @license
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+'use strict';
+
+var _ = require('lodash');
+
+var grpc = require('./grpc_extension');
+
+/**
+ * Class for storing metadata. Keys are normalized to lowercase ASCII.
+ * @memberof grpc
+ * @constructor
+ * @example
+ * var metadata = new metadata_module.Metadata();
+ * metadata.set('key1', 'value1');
+ * metadata.add('key1', 'value2');
+ * metadata.get('key1') // returns ['value1', 'value2']
+ */
+function Metadata() {
+  this._internal_repr = {};
+}
+
+function normalizeKey(key) {
+  key = key.toLowerCase();
+  if (grpc.metadataKeyIsLegal(key)) {
+    return key;
+  } else {
+    throw new Error('Metadata key"' + key + '" contains illegal characters');
+  }
+}
+
+function validate(key, value) {
+  if (grpc.metadataKeyIsBinary(key)) {
+    if (!(value instanceof Buffer)) {
+      throw new Error('keys that end with \'-bin\' must have Buffer values');
+    }
+  } else {
+    if (!_.isString(value)) {
+      throw new Error(
+          'keys that don\'t end with \'-bin\' must have String values');
+    }
+    if (!grpc.metadataNonbinValueIsLegal(value)) {
+      throw new Error('Metadata string value "' + value +
+                      '" contains illegal characters');
+    }
+  }
+}
+
+/**
+ * Sets the given value for the given key, replacing any other values associated
+ * with that key. Normalizes the key.
+ * @param {String} key The key to set
+ * @param {String|Buffer} value The value to set. Must be a buffer if and only
+ *     if the normalized key ends with '-bin'
+ */
+Metadata.prototype.set = function(key, value) {
+  key = normalizeKey(key);
+  validate(key, value);
+  this._internal_repr[key] = [value];
+};
+
+/**
+ * Adds the given value for the given key. Normalizes the key.
+ * @param {String} key The key to add to.
+ * @param {String|Buffer} value The value to add. Must be a buffer if and only
+ *     if the normalized key ends with '-bin'
+ */
+Metadata.prototype.add = function(key, value) {
+  key = normalizeKey(key);
+  validate(key, value);
+  if (!this._internal_repr[key]) {
+    this._internal_repr[key] = [];
+  }
+  this._internal_repr[key].push(value);
+};
+
+/**
+ * Remove the given key and any associated values. Normalizes the key.
+ * @param {String} key The key to remove
+ */
+Metadata.prototype.remove = function(key) {
+  key = normalizeKey(key);
+  if (Object.prototype.hasOwnProperty.call(this._internal_repr, key)) {
+    delete this._internal_repr[key];
+  }
+};
+
+/**
+ * Gets a list of all values associated with the key. Normalizes the key.
+ * @param {String} key The key to get
+ * @return {Array.<String|Buffer>} The values associated with that key
+ */
+Metadata.prototype.get = function(key) {
+  key = normalizeKey(key);
+  if (Object.prototype.hasOwnProperty.call(this._internal_repr, key)) {
+    return this._internal_repr[key];
+  } else {
+    return [];
+  }
+};
+
+/**
+ * Get a map of each key to a single associated value. This reflects the most
+ * common way that people will want to see metadata.
+ * @return {Object.<String,String|Buffer>} A key/value mapping of the metadata
+ */
+Metadata.prototype.getMap = function() {
+  var result = {};
+  _.forOwn(this._internal_repr, function(values, key) {
+    if(values.length > 0) {
+      result[key] = values[0];
+    }
+  });
+  return result;
+};
+
+/**
+ * Clone the metadata object.
+ * @return {grpc.Metadata} The new cloned object
+ */
+Metadata.prototype.clone = function() {
+  var copy = new Metadata();
+  _.forOwn(this._internal_repr, function(value, key) {
+    copy._internal_repr[key] = _.clone(value);
+  });
+  return copy;
+};
+
+/**
+ * Gets the metadata in the format used by interal code. Intended for internal
+ * use only. API stability is not guaranteed.
+ * @private
+ * @return {Object.<String, Array.<String|Buffer>>} The metadata
+ */
+Metadata.prototype._getCoreRepresentation = function() {
+  return this._internal_repr;
+};
+
+/**
+ * Creates a Metadata object from a metadata map in the internal format.
+ * Intended for internal use only. API stability is not guaranteed.
+ * @private
+ * @param {Object.<String, Array.<String|Buffer>>} The metadata
+ * @return {Metadata} The new Metadata object
+ */
+Metadata._fromCoreRepresentation = function(metadata) {
+  var newMetadata = new Metadata();
+  if (metadata) {
+    _.forOwn(metadata, function(value, key) {
+      newMetadata._internal_repr[key] = _.clone(value);
+    });
+  }
+  return newMetadata;
+};
+
+module.exports = Metadata;

express-server/node_modules/grpc/src/protobuf_js_5_common.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * @module
+ * @private
+ */
+
+'use strict';
+
+var _ = require('lodash');
+var client = require('./client');
+
+/**
+ * Get a function that deserializes a specific type of protobuf.
+ * @param {function()} cls The constructor of the message type to deserialize
+ * @param {bool=} binaryAsBase64 Deserialize bytes fields as base64 strings
+ *     instead of Buffers. Defaults to false
+ * @param {bool=} longsAsStrings Deserialize long values as strings instead of
+ *     objects. Defaults to true
+ * @return {function(Buffer):cls} The deserialization function
+ */
+exports.deserializeCls = function deserializeCls(cls, options) {
+  /**
+   * Deserialize a buffer to a message object
+   * @param {Buffer} arg_buf The buffer to deserialize
+   * @return {cls} The resulting object
+   */
+  return function deserialize(arg_buf) {
+    // Convert to a native object with binary fields as Buffers (first argument)
+    // and longs as strings (second argument)
+    return cls.decode(arg_buf).toRaw(options.binaryAsBase64,
+                                     options.longsAsStrings);
+  };
+};
+
+var deserializeCls = exports.deserializeCls;
+
+/**
+ * Get a function that serializes objects to a buffer by protobuf class.
+ * @param {function()} Cls The constructor of the message type to serialize
+ * @return {function(Cls):Buffer} The serialization function
+ */
+exports.serializeCls = function serializeCls(Cls) {
+  /**
+   * Serialize an object to a Buffer
+   * @param {Object} arg The object to serialize
+   * @return {Buffer} The serialized object
+   */
+  return function serialize(arg) {
+    return new Buffer(new Cls(arg).encode().toBuffer());
+  };
+};
+
+var serializeCls = exports.serializeCls;
+
+/**
+ * Get the fully qualified (dotted) name of a ProtoBuf.Reflect value.
+ * @param {ProtoBuf.Reflect.Namespace} value The value to get the name of
+ * @return {string} The fully qualified name of the value
+ */
+exports.fullyQualifiedName = function fullyQualifiedName(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  var name = value.name;
+  var parent_name = fullyQualifiedName(value.parent);
+  if (parent_name !== '') {
+    name = parent_name + '.' + name;
+  }
+  return name;
+};
+
+var fullyQualifiedName = exports.fullyQualifiedName;
+
+/**
+ * Return a map from method names to method attributes for the service.
+ * @param {ProtoBuf.Reflect.Service} service The service to get attributes for
+ * @param {Object=} options Options to apply to these attributes
+ * @return {Object} The attributes map
+ */
+exports.getProtobufServiceAttrs = function getProtobufServiceAttrs(service,
+                                                                   options) {
+  var prefix = '/' + fullyQualifiedName(service) + '/';
+  var binaryAsBase64, longsAsStrings;
+  if (options) {
+    binaryAsBase64 = options.binaryAsBase64;
+    longsAsStrings = options.longsAsStrings;
+  }
+  /* This slightly awkward construction is used to make sure we only use
+     lodash@3.10.1-compatible functions. A previous version used
+     _.fromPairs, which would be cleaner, but was introduced in lodash
+     version 4 */
+  return _.zipObject(_.map(service.children, function(method) {
+    return _.camelCase(method.name);
+  }), _.map(service.children, function(method) {
+    return {
+      originalName: method.name,
+      path: prefix + method.name,
+      requestStream: method.requestStream,
+      responseStream: method.responseStream,
+      requestType: method.resolvedRequestType,
+      responseType: method.resolvedResponseType,
+      requestSerialize: serializeCls(method.resolvedRequestType.build()),
+      requestDeserialize: deserializeCls(method.resolvedRequestType.build(),
+                                         options),
+      responseSerialize: serializeCls(method.resolvedResponseType.build()),
+      responseDeserialize: deserializeCls(method.resolvedResponseType.build(),
+                                          options)
+    };
+  }));
+};
+
+var getProtobufServiceAttrs = exports.getProtobufServiceAttrs;
+
+/**
+ * Load a gRPC object from an existing ProtoBuf.Reflect object.
+ * @param {ProtoBuf.Reflect.Namespace} value The ProtoBuf object to load.
+ * @param {Object=} options Options to apply to the loaded object
+ * @return {Object<string, *>} The resulting gRPC object
+ */
+exports.loadObject = function loadObject(value, options) {
+  var result = {};
+  if (!value) {
+    return value;
+  }
+  if (value.hasOwnProperty('ns')) {
+    return loadObject(value.ns, options);
+  }
+  if (value.className === 'Namespace') {
+    _.each(value.children, function(child) {
+      result[child.name] = loadObject(child, options);
+    });
+    return result;
+  } else if (value.className === 'Service') {
+    return client.makeClientConstructor(getProtobufServiceAttrs(value, options),
+                                        options);
+  } else if (value.className === 'Message' || value.className === 'Enum') {
+    return value.build();
+  } else {
+    return value;
+  }
+};
+
+/**
+ * The primary purpose of this method is to distinguish between reflection
+ * objects from different versions of ProtoBuf.js. This is just a heuristic,
+ * checking for properties that are (currently) specific to this version of
+ * ProtoBuf.js
+ * @param {Object} obj The object to check
+ * @return {boolean} Whether the object appears to be a Protobuf.js 5
+ *   ReflectionObject
+ */
+exports.isProbablyProtobufJs5 = function isProbablyProtobufJs5(obj) {
+  return _.isArray(obj.children) && (typeof obj.build === 'function');
+};

express-server/node_modules/grpc/src/protobuf_js_6_common.js

@@ -0,0 +1,160 @@
+/**
+ * @license
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/**
+ * @module
+ * @private
+ */
+
+'use strict';
+
+var _ = require('lodash');
+var client = require('./client');
+
+/**
+ * Get a function that deserializes a specific type of protobuf.
+ * @param {function()} cls The constructor of the message type to deserialize
+ * @param {bool=} binaryAsBase64 Deserialize bytes fields as base64 strings
+ *     instead of Buffers. Defaults to false
+ * @param {bool=} longsAsStrings Deserialize long values as strings instead of
+ *     objects. Defaults to true
+ * @return {function(Buffer):cls} The deserialization function
+ */
+exports.deserializeCls = function deserializeCls(cls, options) {
+  var conversion_options = {
+    defaults: true,
+    bytes: options.binaryAsBase64 ? String : Buffer,
+    longs: options.longsAsStrings ? String : null,
+    enums: options.enumsAsStrings ? String : null,
+    oneofs: true
+  };
+  /**
+   * Deserialize a buffer to a message object
+   * @param {Buffer} arg_buf The buffer to deserialize
+   * @return {cls} The resulting object
+   */
+  return function deserialize(arg_buf) {
+    return cls.toObject(cls.decode(arg_buf), conversion_options);
+  };
+};
+
+var deserializeCls = exports.deserializeCls;
+
+/**
+ * Get a function that serializes objects to a buffer by protobuf class.
+ * @param {function()} Cls The constructor of the message type to serialize
+ * @return {function(Cls):Buffer} The serialization function
+ */
+exports.serializeCls = function serializeCls(cls) {
+  /**
+   * Serialize an object to a Buffer
+   * @param {Object} arg The object to serialize
+   * @return {Buffer} The serialized object
+   */
+  return function serialize(arg) {
+    var message = cls.fromObject(arg);
+    return cls.encode(message).finish();
+  };
+};
+
+var serializeCls = exports.serializeCls;
+
+/**
+ * Get the fully qualified (dotted) name of a ProtoBuf.Reflect value.
+ * @param {ProtoBuf.ReflectionObject} value The value to get the name of
+ * @return {string} The fully qualified name of the value
+ */
+exports.fullyQualifiedName = function fullyQualifiedName(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  var name = value.name;
+  var parent_fqn = fullyQualifiedName(value.parent);
+  if (parent_fqn !== '') {
+    name = parent_fqn + '.' + name;
+  }
+  return name;
+};
+
+var fullyQualifiedName = exports.fullyQualifiedName;
+
+/**
+ * Return a map from method names to method attributes for the service.
+ * @param {ProtoBuf.Service} service The service to get attributes for
+ * @param {Object=} options Options to apply to these attributes
+ * @return {Object} The attributes map
+ */
+exports.getProtobufServiceAttrs = function getProtobufServiceAttrs(service,
+                                                                   options) {
+  var prefix = '/' + fullyQualifiedName(service) + '/';
+  service.resolveAll();
+  return _.zipObject(_.map(service.methods, function(method) {
+    return _.camelCase(method.name);
+  }), _.map(service.methods, function(method) {
+    return {
+      originalName: method.name,
+      path: prefix + method.name,
+      requestStream: !!method.requestStream,
+      responseStream: !!method.responseStream,
+      requestType: method.resolvedRequestType,
+      responseType: method.resolvedResponseType,
+      requestSerialize: serializeCls(method.resolvedRequestType),
+      requestDeserialize: deserializeCls(method.resolvedRequestType, options),
+      responseSerialize: serializeCls(method.resolvedResponseType),
+      responseDeserialize: deserializeCls(method.resolvedResponseType, options)
+    };
+  }));
+};
+
+var getProtobufServiceAttrs = exports.getProtobufServiceAttrs;
+
+exports.loadObject = function loadObject(value, options) {
+  var result = {};
+  if (!value) {
+    return value;
+  }
+  if (value.hasOwnProperty('methods')) {
+    // It's a service object
+    var service_attrs = getProtobufServiceAttrs(value, options);
+    return client.makeClientConstructor(service_attrs);
+  }
+
+  if (value.hasOwnProperty('nested')) {
+    // It's a namespace or root object
+    _.each(value.nested, function(nested, name) {
+      result[name] = loadObject(nested, options);
+    });
+    return result;
+  }
+
+  // Otherwise, it's not something we need to change
+  return value;
+};
+
+/**
+ * The primary purpose of this method is to distinguish between reflection
+ * objects from different versions of ProtoBuf.js. This is just a heuristic,
+ * checking for properties that are (currently) specific to this version of
+ * ProtoBuf.js
+ * @param {Object} obj The object to check
+ * @return {boolean} Whether the object appears to be a Protobuf.js 6
+ *   ReflectionObject
+ */
+exports.isProbablyProtobufJs6 = function isProbablyProtobufJs6(obj) {
+  return (typeof obj.root === 'object') && (typeof obj.resolve === 'function');
+};

express-server/node_modules/grpc/src/server.js

@@ -0,0 +1,994 @@
+/**
+ * @license
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+'use strict';
+
+var _ = require('lodash');
+
+var grpc = require('./grpc_extension');
+
+var common = require('./common');
+
+var Metadata = require('./metadata');
+
+var constants = require('./constants');
+
+var stream = require('stream');
+
+var Readable = stream.Readable;
+var Writable = stream.Writable;
+var Duplex = stream.Duplex;
+var util = require('util');
+
+var EventEmitter = require('events').EventEmitter;
+
+/**
+ * Handle an error on a call by sending it as a status
+ * @private
+ * @param {grpc.internal~Call} call The call to send the error on
+ * @param {(Object|Error)} error The error object
+ */
+function handleError(call, error) {
+  var statusMetadata = new Metadata();
+  var status = {
+    code: constants.status.UNKNOWN,
+    details: 'Unknown Error'
+  };
+  if (error.hasOwnProperty('message')) {
+    status.details = error.message;
+  }
+  if (error.hasOwnProperty('code') && Number.isInteger(error.code)) {
+    status.code = error.code;
+    if (error.hasOwnProperty('details')) {
+      status.details = error.details;
+    }
+  }
+  if (error.hasOwnProperty('metadata')) {
+    statusMetadata = error.metadata;
+  }
+  status.metadata = statusMetadata._getCoreRepresentation();
+  var error_batch = {};
+  if (!call.metadataSent) {
+    error_batch[grpc.opType.SEND_INITIAL_METADATA] =
+        (new Metadata())._getCoreRepresentation();
+  }
+  error_batch[grpc.opType.SEND_STATUS_FROM_SERVER] = status;
+  call.startBatch(error_batch, function(){});
+}
+
+/**
+ * Send a response to a unary or client streaming call.
+ * @private
+ * @param {grpc.Call} call The call to respond on
+ * @param {*} value The value to respond with
+ * @param {grpc~serialize} serialize Serialization function for the
+ *     response
+ * @param {grpc.Metadata=} metadata Optional trailing metadata to send with
+ *     status
+ * @param {number=} [flags=0] Flags for modifying how the message is sent.
+ */
+function sendUnaryResponse(call, value, serialize, metadata, flags) {
+  var end_batch = {};
+  var statusMetadata = new Metadata();
+  var status = {
+    code: constants.status.OK,
+    details: 'OK'
+  };
+  if (metadata) {
+    statusMetadata = metadata;
+  }
+  var message;
+  try {
+    message = serialize(value);
+  } catch (e) {
+    e.code = constants.status.INTERNAL;
+    handleError(call, e);
+    return;
+  }
+  status.metadata = statusMetadata._getCoreRepresentation();
+  if (!call.metadataSent) {
+    end_batch[grpc.opType.SEND_INITIAL_METADATA] =
+        (new Metadata())._getCoreRepresentation();
+    call.metadataSent = true;
+  }
+  message.grpcWriteFlags = flags;
+  end_batch[grpc.opType.SEND_MESSAGE] = message;
+  end_batch[grpc.opType.SEND_STATUS_FROM_SERVER] = status;
+  call.startBatch(end_batch, function (){});
+}
+
+/**
+ * Initialize a writable stream. This is used for both the writable and duplex
+ * stream constructors.
+ * @private
+ * @param {Writable} stream The stream to set up
+ * @param {function(*):Buffer=} Serialization function for responses
+ */
+function setUpWritable(stream, serialize) {
+  stream.finished = false;
+  stream.status = {
+    code : constants.status.OK,
+    details : 'OK',
+    metadata : new Metadata()
+  };
+  stream.serialize = common.wrapIgnoreNull(serialize);
+  function sendStatus() {
+    var batch = {};
+    if (!stream.call.metadataSent) {
+      stream.call.metadataSent = true;
+      batch[grpc.opType.SEND_INITIAL_METADATA] =
+          (new Metadata())._getCoreRepresentation();
+    }
+
+    if (stream.status.metadata) {
+      stream.status.metadata = stream.status.metadata._getCoreRepresentation();
+    }
+    batch[grpc.opType.SEND_STATUS_FROM_SERVER] = stream.status;
+    stream.call.startBatch(batch, function(){});
+  }
+  stream.on('finish', sendStatus);
+  /**
+   * Set the pending status to a given error status. If the error does not have
+   * code or details properties, the code will be set to grpc.status.UNKNOWN
+   * and the details will be set to 'Unknown Error'.
+   * @param {Error} err The error object
+   */
+  function setStatus(err) {
+    var code = constants.status.UNKNOWN;
+    var details = 'Unknown Error';
+    var metadata = new Metadata();
+    if (err.hasOwnProperty('message')) {
+      details = err.message;
+    }
+    if (err.hasOwnProperty('code')) {
+      code = err.code;
+      if (err.hasOwnProperty('details')) {
+        details = err.details;
+      }
+    }
+    if (err.hasOwnProperty('metadata')) {
+      metadata = err.metadata;
+    }
+    stream.status = {code: code, details: details, metadata: metadata};
+  }
+  /**
+   * Terminate the call. This includes indicating that reads are done, draining
+   * all pending writes, and sending the given error as a status
+   * @param {Error} err The error object
+   * @this GrpcServerStream
+   */
+  function terminateCall(err) {
+    // Drain readable data
+    setStatus(err);
+    stream.end();
+  }
+  stream.on('error', terminateCall);
+  /**
+   * Override of Writable#end method that allows for sending metadata with a
+   * success status.
+   * @param {Metadata=} metadata Metadata to send with the status
+   */
+  stream.end = function(metadata) {
+    if (metadata) {
+      stream.status.metadata = metadata;
+    }
+    Writable.prototype.end.call(this);
+  };
+}
+
+/**
+ * Initialize a readable stream. This is used for both the readable and duplex
+ * stream constructors.
+ * @private
+ * @param {Readable} stream The stream to initialize
+ * @param {grpc~deserialize} deserialize Deserialization function for
+ *     incoming data.
+ */
+function setUpReadable(stream, deserialize) {
+  stream.deserialize = common.wrapIgnoreNull(deserialize);
+  stream.finished = false;
+  stream.reading = false;
+
+  stream.terminate = function() {
+    stream.finished = true;
+    stream.on('data', function() {});
+  };
+
+  stream.on('cancelled', function() {
+    stream.terminate();
+  });
+}
+
+/**
+ * Emitted when the call has been cancelled. After this has been emitted, the
+ * call's `cancelled` property will be set to `true`.
+ * @event grpc~ServerUnaryCall~cancelled
+ */
+
+util.inherits(ServerUnaryCall, EventEmitter);
+
+/**
+ * An EventEmitter. Used for unary calls.
+ * @constructor grpc~ServerUnaryCall
+ * @extends external:EventEmitter
+ * @param {grpc.internal~Call} call The call object associated with the request
+ * @param {grpc.Metadata} metadata The request metadata from the client
+ */
+function ServerUnaryCall(call, metadata) {
+  EventEmitter.call(this);
+  this.call = call;
+  /**
+   * Indicates if the call has been cancelled
+   * @member {boolean} grpc~ServerUnaryCall#cancelled
+   */
+  this.cancelled = false;
+  /**
+   * The request metadata from the client
+   * @member {grpc.Metadata} grpc~ServerUnaryCall#metadata
+   */
+  this.metadata = metadata;
+  /**
+   * The request message from the client
+   * @member {*} grpc~ServerUnaryCall#request
+   */
+  this.request = undefined;
+}
+
+/**
+ * Emitted when the call has been cancelled. After this has been emitted, the
+ * call's `cancelled` property will be set to `true`.
+ * @event grpc~ServerWritableStream~cancelled
+ */
+
+util.inherits(ServerWritableStream, Writable);
+
+/**
+ * A stream that the server can write to. Used for calls that are streaming from
+ * the server side.
+ * @constructor grpc~ServerWritableStream
+ * @extends external:Writable
+ * @borrows grpc~ServerUnaryCall#sendMetadata as
+ *     grpc~ServerWritableStream#sendMetadata
+ * @borrows grpc~ServerUnaryCall#getPeer as grpc~ServerWritableStream#getPeer
+ * @param {grpc.internal~Call} call The call object to send data with
+ * @param {grpc.Metadata} metadata The request metadata from the client
+ * @param {grpc~serialize} serialize Serialization function for writes
+ */
+function ServerWritableStream(call, metadata, serialize) {
+  Writable.call(this, {objectMode: true});
+  this.call = call;
+
+  this.finished = false;
+  setUpWritable(this, serialize);
+  /**
+   * Indicates if the call has been cancelled
+   * @member {boolean} grpc~ServerWritableStream#cancelled
+   */
+  this.cancelled = false;
+  /**
+   * The request metadata from the client
+   * @member {grpc.Metadata} grpc~ServerWritableStream#metadata
+   */
+  this.metadata = metadata;
+  /**
+   * The request message from the client
+   * @member {*} grpc~ServerWritableStream#request
+   */
+  this.request = undefined;
+}
+
+/**
+ * Start writing a chunk of data. This is an implementation of a method required
+ * for implementing stream.Writable.
+ * @private
+ * @param {Buffer} chunk The chunk of data to write
+ * @param {string} encoding Used to pass write flags
+ * @param {function(Error=)} callback Callback to indicate that the write is
+ *     complete
+ */
+function _write(chunk, encoding, callback) {
+  /* jshint validthis: true */
+  var batch = {};
+  var self = this;
+  var message;
+  try {
+    message = this.serialize(chunk);
+  } catch (e) {
+    e.code = constants.status.INTERNAL;
+    callback(e);
+    return;
+  }
+  if (!this.call.metadataSent) {
+    batch[grpc.opType.SEND_INITIAL_METADATA] =
+        (new Metadata())._getCoreRepresentation();
+    this.call.metadataSent = true;
+  }
+  if (_.isFinite(encoding)) {
+    /* Attach the encoding if it is a finite number. This is the closest we
+     * can get to checking that it is valid flags */
+    message.grpcWriteFlags = encoding;
+  }
+  batch[grpc.opType.SEND_MESSAGE] = message;
+  this.call.startBatch(batch, function(err, value) {
+    if (err) {
+      self.emit('error', err);
+      return;
+    }
+    callback();
+  });
+}
+
+ServerWritableStream.prototype._write = _write;
+
+/**
+ * Emitted when the call has been cancelled. After this has been emitted, the
+ * call's `cancelled` property will be set to `true`.
+ * @event grpc~ServerReadableStream~cancelled
+ */
+
+util.inherits(ServerReadableStream, Readable);
+
+/**
+ * A stream that the server can read from. Used for calls that are streaming
+ * from the client side.
+ * @constructor grpc~ServerReadableStream
+ * @extends external:Readable
+ * @borrows grpc~ServerUnaryCall#sendMetadata as
+ *     grpc~ServerReadableStream#sendMetadata
+ * @borrows grpc~ServerUnaryCall#getPeer as grpc~ServerReadableStream#getPeer
+ * @param {grpc.internal~Call} call The call object to read data with
+ * @param {grpc.Metadata} metadata The request metadata from the client
+ * @param {grpc~deserialize} deserialize Deserialization function for reads
+ */
+function ServerReadableStream(call, metadata, deserialize) {
+  Readable.call(this, {objectMode: true});
+  this.call = call;
+  setUpReadable(this, deserialize);
+  /**
+   * Indicates if the call has been cancelled
+   * @member {boolean} grpc~ServerReadableStream#cancelled
+   */
+  this.cancelled = false;
+  /**
+   * The request metadata from the client
+   * @member {grpc.Metadata} grpc~ServerReadableStream#metadata
+   */
+  this.metadata = metadata;
+}
+
+/**
+ * Start reading from the gRPC data source. This is an implementation of a
+ * method required for implementing stream.Readable
+ * @access private
+ * @param {number} size Ignored
+ */
+function _read(size) {
+  /* jshint validthis: true */
+  var self = this;
+  /**
+   * Callback to be called when a READ event is received. Pushes the data onto
+   * the read queue and starts reading again if applicable
+   * @param {grpc.Event} event READ event object
+   */
+  function readCallback(err, event) {
+    if (err) {
+      self.terminate();
+      return;
+    }
+    if (self.finished) {
+      self.push(null);
+      return;
+    }
+    var data = event.read;
+    var deserialized;
+    try {
+      deserialized = self.deserialize(data);
+    } catch (e) {
+      e.code = constants.status.INTERNAL;
+      self.emit('error', e);
+      return;
+    }
+    if (self.push(deserialized) && data !== null) {
+      var read_batch = {};
+      read_batch[grpc.opType.RECV_MESSAGE] = true;
+      self.call.startBatch(read_batch, readCallback);
+    } else {
+      self.reading = false;
+    }
+  }
+  if (self.finished) {
+    self.push(null);
+  } else {
+    if (!self.reading) {
+      self.reading = true;
+      var batch = {};
+      batch[grpc.opType.RECV_MESSAGE] = true;
+      self.call.startBatch(batch, readCallback);
+    }
+  }
+}
+
+ServerReadableStream.prototype._read = _read;
+
+/**
+ * Emitted when the call has been cancelled. After this has been emitted, the
+ * call's `cancelled` property will be set to `true`.
+ * @event grpc~ServerDuplexStream~cancelled
+ */
+
+util.inherits(ServerDuplexStream, Duplex);
+
+/**
+ * A stream that the server can read from or write to. Used for calls with
+ * duplex streaming.
+ * @constructor grpc~ServerDuplexStream
+ * @extends external:Duplex
+ * @borrows grpc~ServerUnaryCall#sendMetadata as
+ *     grpc~ServerDuplexStream#sendMetadata
+ * @borrows grpc~ServerUnaryCall#getPeer as grpc~ServerDuplexStream#getPeer
+ * @param {grpc.internal~Call} call Call object to proxy
+ * @param {grpc.Metadata} metadata The request metadata from the client
+ * @param {grpc~serialize} serialize Serialization function for requests
+ * @param {grpc~deserialize} deserialize Deserialization function for
+ *     responses
+ */
+function ServerDuplexStream(call, metadata, serialize, deserialize) {
+  Duplex.call(this, {objectMode: true});
+  this.call = call;
+  setUpWritable(this, serialize);
+  setUpReadable(this, deserialize);
+  /**
+   * Indicates if the call has been cancelled
+   * @member {boolean} grpc~ServerReadableStream#cancelled
+   */
+  this.cancelled = false;
+  /**
+   * The request metadata from the client
+   * @member {grpc.Metadata} grpc~ServerReadableStream#metadata
+   */
+  this.metadata = metadata;
+}
+
+ServerDuplexStream.prototype._read = _read;
+ServerDuplexStream.prototype._write = _write;
+
+/**
+ * Send the initial metadata for a writable stream.
+ * @alias grpc~ServerUnaryCall#sendMetadata
+ * @param {grpc.Metadata} responseMetadata Metadata to send
+ */
+function sendMetadata(responseMetadata) {
+  /* jshint validthis: true */
+  var self = this;
+  if (!this.call.metadataSent) {
+    this.call.metadataSent = true;
+    var batch = {};
+    batch[grpc.opType.SEND_INITIAL_METADATA] =
+        responseMetadata._getCoreRepresentation();
+    this.call.startBatch(batch, function(err) {
+      if (err) {
+        self.emit('error', err);
+        return;
+      }
+    });
+  }
+}
+
+ServerUnaryCall.prototype.sendMetadata = sendMetadata;
+ServerWritableStream.prototype.sendMetadata = sendMetadata;
+ServerReadableStream.prototype.sendMetadata = sendMetadata;
+ServerDuplexStream.prototype.sendMetadata = sendMetadata;
+
+/**
+ * Get the endpoint this call/stream is connected to.
+ * @alias grpc~ServerUnaryCall#getPeer
+ * @return {string} The URI of the endpoint
+ */
+function getPeer() {
+  /* jshint validthis: true */
+  return this.call.getPeer();
+}
+
+ServerUnaryCall.prototype.getPeer = getPeer;
+ServerReadableStream.prototype.getPeer = getPeer;
+ServerWritableStream.prototype.getPeer = getPeer;
+ServerDuplexStream.prototype.getPeer = getPeer;
+
+/**
+ * Wait for the client to close, then emit a cancelled event if the client
+ * cancelled.
+ * @private
+ */
+function waitForCancel() {
+  /* jshint validthis: true */
+  var self = this;
+  var cancel_batch = {};
+  cancel_batch[grpc.opType.RECV_CLOSE_ON_SERVER] = true;
+  self.call.startBatch(cancel_batch, function(err, result) {
+    if (err) {
+      self.emit('error', err);
+    }
+    if (result.cancelled) {
+      self.cancelled = true;
+      self.emit('cancelled');
+    }
+  });
+}
+
+ServerUnaryCall.prototype.waitForCancel = waitForCancel;
+ServerReadableStream.prototype.waitForCancel = waitForCancel;
+ServerWritableStream.prototype.waitForCancel = waitForCancel;
+ServerDuplexStream.prototype.waitForCancel = waitForCancel;
+
+/**
+ * Callback function passed to server handlers that handle methods with unary
+ * responses.
+ * @callback grpc.Server~sendUnaryData
+ * @param {grpc~ServiceError} error An error, if the call failed
+ * @param {*} value The response value. Must be a valid argument to the
+ *     `responseSerialize` method of the method that is being handled
+ * @param {grpc.Metadata=} trailer Trailing metadata to send, if applicable
+ * @param {grpc.writeFlags=} flags Flags to modify writing the response
+ */
+
+/**
+ * User-provided method to handle unary requests on a server
+ * @callback grpc.Server~handleUnaryCall
+ * @param {grpc~ServerUnaryCall} call The call object
+ * @param {grpc.Server~sendUnaryData} callback The callback to call to respond
+ *     to the request
+ */
+
+/**
+ * Fully handle a unary call
+ * @private
+ * @param {grpc.internal~Call} call The call to handle
+ * @param {Object} handler Request handler object for the method that was called
+ * @param {grpc~Server.handleUnaryCall} handler.func The handler function
+ * @param {grpc~deserialize} handler.deserialize The deserialization function
+ *     for request data
+ * @param {grpc~serialize} handler.serialize The serialization function for
+ *     response data
+ * @param {grpc.Metadata} metadata Metadata from the client
+ */
+function handleUnary(call, handler, metadata) {
+  var emitter = new ServerUnaryCall(call, metadata);
+  emitter.on('error', function(error) {
+    handleError(call, error);
+  });
+  emitter.waitForCancel();
+  var batch = {};
+  batch[grpc.opType.RECV_MESSAGE] = true;
+  call.startBatch(batch, function(err, result) {
+    if (err) {
+      handleError(call, err);
+      return;
+    }
+    try {
+      emitter.request = handler.deserialize(result.read);
+    } catch (e) {
+      e.code = constants.status.INTERNAL;
+      handleError(call, e);
+      return;
+    }
+    if (emitter.cancelled) {
+      return;
+    }
+    handler.func(emitter, function sendUnaryData(err, value, trailer, flags) {
+      if (err) {
+        if (trailer) {
+          err.metadata = trailer;
+        }
+        handleError(call, err);
+      } else {
+        sendUnaryResponse(call, value, handler.serialize, trailer, flags);
+      }
+    });
+  });
+}
+
+/**
+ * User provided method to handle server streaming methods on the server.
+ * @callback grpc.Server~handleServerStreamingCall
+ * @param {grpc~ServerWritableStream} call The call object
+ */
+
+/**
+ * Fully handle a server streaming call
+ * @private
+ * @param {grpc.internal~Call} call The call to handle
+ * @param {Object} handler Request handler object for the method that was called
+ * @param {grpc~Server.handleServerStreamingCall} handler.func The handler
+ *     function
+ * @param {grpc~deserialize} handler.deserialize The deserialization function
+ *     for request data
+ * @param {grpc~serialize} handler.serialize The serialization function for
+ *     response data
+ * @param {grpc.Metadata} metadata Metadata from the client
+ */
+function handleServerStreaming(call, handler, metadata) {
+  var stream = new ServerWritableStream(call, metadata, handler.serialize);
+  stream.waitForCancel();
+  var batch = {};
+  batch[grpc.opType.RECV_MESSAGE] = true;
+  call.startBatch(batch, function(err, result) {
+    if (err) {
+      stream.emit('error', err);
+      return;
+    }
+    try {
+      stream.request = handler.deserialize(result.read);
+    } catch (e) {
+      e.code = constants.status.INTERNAL;
+      stream.emit('error', e);
+      return;
+    }
+    handler.func(stream);
+  });
+}
+
+/**
+ * User provided method to handle client streaming methods on the server.
+ * @callback grpc.Server~handleClientStreamingCall
+ * @param {grpc~ServerReadableStream} call The call object
+ * @param {grpc.Server~sendUnaryData} callback The callback to call to respond
+ *     to the request
+ */
+
+/**
+ * Fully handle a client streaming call
+ * @access private
+ * @param {grpc.internal~Call} call The call to handle
+ * @param {Object} handler Request handler object for the method that was called
+ * @param {grpc~Server.handleClientStreamingCall} handler.func The handler
+ *     function
+ * @param {grpc~deserialize} handler.deserialize The deserialization function
+ *     for request data
+ * @param {grpc~serialize} handler.serialize The serialization function for
+ *     response data
+ * @param {grpc.Metadata} metadata Metadata from the client
+ */
+function handleClientStreaming(call, handler, metadata) {
+  var stream = new ServerReadableStream(call, metadata, handler.deserialize);
+  stream.on('error', function(error) {
+    handleError(call, error);
+  });
+  stream.waitForCancel();
+  handler.func(stream, function(err, value, trailer, flags) {
+    stream.terminate();
+    if (err) {
+      if (trailer) {
+        err.metadata = trailer;
+      }
+      handleError(call, err);
+    } else {
+      sendUnaryResponse(call, value, handler.serialize, trailer, flags);
+    }
+  });
+}
+
+/**
+ * User provided method to handle bidirectional streaming calls on the server.
+ * @callback grpc.Server~handleBidiStreamingCall
+ * @param {grpc~ServerDuplexStream} call The call object
+ */
+
+/**
+ * Fully handle a bidirectional streaming call
+ * @private
+ * @param {grpc.internal~Call} call The call to handle
+ * @param {Object} handler Request handler object for the method that was called
+ * @param {grpc~Server.handleBidiStreamingCall} handler.func The handler
+ *     function
+ * @param {grpc~deserialize} handler.deserialize The deserialization function
+ *     for request data
+ * @param {grpc~serialize} handler.serialize The serialization function for
+ *     response data
+ * @param {Metadata} metadata Metadata from the client
+ */
+function handleBidiStreaming(call, handler, metadata) {
+  var stream = new ServerDuplexStream(call, metadata, handler.serialize,
+                                      handler.deserialize);
+  stream.waitForCancel();
+  handler.func(stream);
+}
+
+var streamHandlers = {
+  unary: handleUnary,
+  server_stream: handleServerStreaming,
+  client_stream: handleClientStreaming,
+  bidi: handleBidiStreaming
+};
+
+/**
+ * Constructs a server object that stores request handlers and delegates
+ * incoming requests to those handlers
+ * @memberof grpc
+ * @constructor
+ * @param {Object=} options Options that should be passed to the internal server
+ *     implementation
+ * @example
+ * var server = new grpc.Server();
+ * server.addProtoService(protobuf_service_descriptor, service_implementation);
+ * server.bind('address:port', server_credential);
+ * server.start();
+ */
+function Server(options) {
+  this.handlers = {};
+  var server = new grpc.Server(options);
+  this._server = server;
+  this.started = false;
+}
+
+/**
+ * Start the server and begin handling requests
+ */
+Server.prototype.start = function() {
+  if (this.started) {
+    throw new Error('Server is already running');
+  }
+  var self = this;
+  this.started = true;
+  this._server.start();
+  /**
+   * Handles the SERVER_RPC_NEW event. If there is a handler associated with
+   * the requested method, use that handler to respond to the request. Then
+   * wait for the next request
+   * @param {grpc.internal~Event} event The event to handle with tag
+   *     SERVER_RPC_NEW
+   */
+  function handleNewCall(err, event) {
+    if (err) {
+      return;
+    }
+    var details = event.new_call;
+    var call = details.call;
+    var method = details.method;
+    var metadata = Metadata._fromCoreRepresentation(details.metadata);
+    if (method === null) {
+      return;
+    }
+    self._server.requestCall(handleNewCall);
+    var handler;
+    if (self.handlers.hasOwnProperty(method)) {
+      handler = self.handlers[method];
+    } else {
+      var batch = {};
+      batch[grpc.opType.SEND_INITIAL_METADATA] =
+          (new Metadata())._getCoreRepresentation();
+      batch[grpc.opType.SEND_STATUS_FROM_SERVER] = {
+        code: constants.status.UNIMPLEMENTED,
+        details: 'RPC method not implemented ' + method,
+        metadata: {}
+      };
+      batch[grpc.opType.RECV_CLOSE_ON_SERVER] = true;
+      call.startBatch(batch, function() {});
+      return;
+    }
+    streamHandlers[handler.type](call, handler, metadata);
+  }
+  this._server.requestCall(handleNewCall);
+};
+
+/**
+ * Unified type for application handlers for all types of calls
+ * @typedef {(grpc.Server~handleUnaryCall
+ *            |grpc.Server~handleClientStreamingCall
+ *            |grpc.Server~handleServerStreamingCall
+ *            |grpc.Server~handleBidiStreamingCall)} grpc.Server~handleCall
+ */
+
+/**
+ * Registers a handler to handle the named method. Fails if there already is
+ * a handler for the given method. Returns true on success
+ * @param {string} name The name of the method that the provided function should
+ *     handle/respond to.
+ * @param {grpc.Server~handleCall} handler Function that takes a stream of
+ *     request values and returns a stream of response values
+ * @param {grpc~serialize} serialize Serialization function for responses
+ * @param {grpc~deserialize} deserialize Deserialization function for requests
+ * @param {('unary'|'client_stream'|'server_stream'|'bidi')} type The streaming type of method that this handles
+ * @return {boolean} True if the handler was set. False if a handler was already
+ *     set for that name.
+ */
+Server.prototype.register = function(name, handler, serialize, deserialize,
+                                     type) {
+  if (this.handlers.hasOwnProperty(name)) {
+    return false;
+  }
+  this.handlers[name] = {
+    func: handler,
+    serialize: serialize,
+    deserialize: deserialize,
+    type: type
+  };
+  return true;
+};
+
+/**
+ * Gracefully shuts down the server. The server will stop receiving new calls,
+ * and any pending calls will complete. The callback will be called when all
+ * pending calls have completed and the server is fully shut down. This method
+ * is idempotent with itself and forceShutdown.
+ * @param {function()} callback The shutdown complete callback
+ */
+Server.prototype.tryShutdown = function(callback) {
+  this._server.tryShutdown(callback);
+};
+
+/**
+ * Forcibly shuts down the server. The server will stop receiving new calls
+ * and cancel all pending calls. When it returns, the server has shut down.
+ * This method is idempotent with itself and tryShutdown, and it will trigger
+ * any outstanding tryShutdown callbacks.
+ */
+Server.prototype.forceShutdown = function() {
+  this._server.forceShutdown();
+};
+
+var unimplementedStatusResponse = {
+  code: constants.status.UNIMPLEMENTED,
+  details: 'The server does not implement this method'
+};
+
+var defaultHandler = {
+  unary: function(call, callback) {
+    callback(unimplementedStatusResponse);
+  },
+  client_stream: function(call, callback) {
+    callback(unimplementedStatusResponse);
+  },
+  server_stream: function(call) {
+    call.emit('error', unimplementedStatusResponse);
+  },
+  bidi: function(call) {
+    call.emit('error', unimplementedStatusResponse);
+  }
+};
+
+/**
+ * Add a service to the server, with a corresponding implementation.
+ * @param {grpc~ServiceDefinition} service The service descriptor
+ * @param {Object<String, grpc.Server~handleCall>} implementation Map of method
+ *     names to method implementation for the provided service.
+ */
+Server.prototype.addService = function(service, implementation) {
+  if (!_.isObject(service) || !_.isObject(implementation)) {
+    throw new Error('addService requires two objects as arguments');
+  }
+  if (_.keys(service).length === 0) {
+    throw new Error('Cannot add an empty service to a server');
+  }
+  if (this.started) {
+    throw new Error('Can\'t add a service to a started server.');
+  }
+  var self = this;
+  _.forOwn(service, function(attrs, name) {
+    var method_type;
+    if (attrs.requestStream) {
+      if (attrs.responseStream) {
+        method_type = 'bidi';
+      } else {
+        method_type = 'client_stream';
+      }
+    } else {
+      if (attrs.responseStream) {
+        method_type = 'server_stream';
+      } else {
+        method_type = 'unary';
+      }
+    }
+    var impl;
+    if (implementation[name] === undefined) {
+      /* Handle the case where the method is passed with the name exactly as
+         written in the proto file, instead of using JavaScript function
+         naming style */
+      if (implementation[attrs.originalName] === undefined) {
+        common.log(constants.logVerbosity.ERROR, 'Method handler ' + name +
+            ' for ' + attrs.path + ' expected but not provided');
+        impl = defaultHandler[method_type];
+      } else {
+        impl = _.bind(implementation[attrs.originalName], implementation);
+      }
+    } else {
+      impl = _.bind(implementation[name], implementation);
+    }
+    var serialize = attrs.responseSerialize;
+    var deserialize = attrs.requestDeserialize;
+    var register_success = self.register(attrs.path, impl, serialize,
+                                         deserialize, method_type);
+    if (!register_success) {
+      throw new Error('Method handler for ' + attrs.path +
+          ' already provided.');
+    }
+  });
+};
+
+/**
+ * Add a proto service to the server, with a corresponding implementation
+ * @deprecated Use {@link grpc.Server#addService} instead
+ * @param {Protobuf.Reflect.Service} service The proto service descriptor
+ * @param {Object<String, grpc.Server~handleCall>} implementation Map of method
+ *     names to method implementation for the provided service.
+ */
+Server.prototype.addProtoService = util.deprecate(function(service,
+                                                           implementation) {
+  var options;
+  var protobuf_js_5_common = require('./protobuf_js_5_common');
+  var protobuf_js_6_common = require('./protobuf_js_6_common');
+  if (protobuf_js_5_common.isProbablyProtobufJs5(service)) {
+    options = _.defaults(service.grpc_options, common.defaultGrpcOptions);
+    this.addService(
+        protobuf_js_5_common.getProtobufServiceAttrs(service, options),
+        implementation);
+  } else if (protobuf_js_6_common.isProbablyProtobufJs6(service)) {
+    options = _.defaults(service.grpc_options, common.defaultGrpcOptions);
+    this.addService(
+        protobuf_js_6_common.getProtobufServiceAttrs(service, options),
+        implementation);
+  } else {
+    // We assume that this is a service attributes object
+    this.addService(service, implementation);
+  }
+}, 'Server#addProtoService: Use Server#addService instead');
+
+/**
+ * Binds the server to the given port, with SSL disabled if creds is an
+ * insecure credentials object
+ * @param {string} port The port that the server should bind on, in the format
+ *     "address:port"
+ * @param {grpc.ServerCredentials} creds Server credential object to be used for
+ *     SSL. Pass an insecure credentials object for an insecure port.
+ * @return {number} The bound port number. Negative if binding the port failed.
+ */
+Server.prototype.bind = function(port, creds) {
+  if (this.started) {
+    throw new Error('Can\'t bind an already running server to an address');
+  }
+  return this._server.addHttp2Port(port, creds);
+};
+
+/**
+ * Called with the result of attempting to bind a port
+ * @callback grpc.Server~bindCallback
+ * @param {Error=} error If non-null, indicates that binding the port failed.
+ * @param {number} port The bound port number. If binding the port fails, this
+ *     will be negative to match the output of bind.
+ */
+
+/**
+ * Binds the server to the given port, with SSL disabled if creds is an
+ * insecure credentials object. Provides the result asynchronously.
+ * @param {string} port The port that the server should bind on, in the format
+ *     "address:port"
+ * @param {grpc.ServerCredentials} creds Server credential object to be used for
+ *     SSL. Pass an insecure credentials object for an insecure port.
+ */
+Server.prototype.bindAsync = function(port, creds, callback) {
+  /* This can throw. We do not try to catch that error because it indicates an
+   * incorrect use of the function, which should not be surfaced asynchronously
+   */
+  const result = this.bind(port, creds)
+  if (result < 0) {
+    setImmediate(callback, new Error('Failed to bind port'), result);
+  } else {
+    setImmediate(callback, null, result);
+  }
+}
+
+exports.Server = Server;