grpc-node | 单独把官方地关于node例子拿出来使用

After some research, I did the following steps to resolve the issue

• I was missing node-gyp - which is Node.js native addon build tool. It can be installed by

  npm install -g node-gyp

• Install Python

• Install Visual C++ Build Environment

• Clean up node-modules

• Then do in the folder npm install

The following link talks the above steps in detail: https://github.com/nodejs/node-gyp#on-windows

Definitely you don't need to learn Golang for that. You just need to check how to use gRPC interceptors with node. In the interceptor code you will implement any of those features available in the gRPC middleware for Golang.

It would be something like that

Module version 83 corresponds to Node 14, not 13. Unfortunately, we have not yet published binaries for Node 14, so it's going to be difficult to get that working

Full answer - https://github.com/grpc/grpc-node/issues/1460#issuecomment-638965479

No matter what streaming type the request is, gRPC will use each single connection to open multiple streams. This is one major reason HTTP/2 was chosen as the underlying protocol for gRPC: multiplexing streams onto connections is already part of that protocol.

Of the classes you mentioned, the Channel is the API-level abstraction over connections. A Channel represents any number of connections to backends referred to by the target string. It will automatically establish connections as needed to handle any requests that are initiated.

The Resolver, which you didn't mention, determines what backend addresses are associated with the target string. For example, the DnsResolver will look up DNS records.

A LoadBalancer determines what specific connections to establish and how to distribute requests among those connections. The default load balancing policy, "pick first" just sends all requests to whichever connection is successfully established first. There is also the "round robin" load balancing policy, which tries to establish connections to multiple backends and then cycles through them when starting calls.

A Subchannel represents a connection to a single backend, that can be reestablished if it drops.

The filter stack applies some transformations to requests between when they are initiated at the top-level API and when they are sent out on the network.

As can be seen here:

The short answer is that a gRPC call will generally end with a status with status.code equal to grpc.status.UNAVAILABLE, so you should be able to accomplish what you want by listening for a status/error with that code and re-establishing the stream when that happens.

First, I want to explain the overall lifecycle of a gRPC request. After starting a request, you will usually first get a metadata event containing response headers. Then you will perform some number of write operations and receive some number of data events. Then the stream will end, and a few semi-redundant events will trigger. The end event indicates that there is no more data to read, but has no additional information. The close event might also trigger here, but I never use it. The status event provides a status object that says how the stream ended. A .code equal to grpc.status.OK indicates that the stream completed successfully. In any other case, an error event will also be emitted, and the error object will additionally have all of the same fields that the status has. You should always listen for the error event, because if you do not and one is emitted, Node will automatically bubble it up and throw it as a global exception.

If a stream ends for any reason, including a server disconnection, it will end with a status event. Network errors, including server disconnections, are usually indicated by the UNAVAILABLE status code. That code is also used when a connection could not be established at all.

For the most part, gRPC is an abstraction over connections anyway. A single gRPC client can be backed by multiple TCP connections, and if a connection is dropped gRPC will automatically try to re-establish the connection.

There is an API to do this, but it is a bit more awkward than what you were trying. And you don't actually need to use it to get what you want. The grpc library internally pools connections to the same server, as long as those connections were created with identical parameters. So, the Client objects created in your first code block will actually use the same TCP connection.

However, as mentioned, there is a way to do this explicitly. The third argument to the Client constructor is an optional object with various additional options, including channelOverride. That accepts a Channel object like the one you constructed at the beginning of your second code block. You still have to pass valid values for the first two arguments, but they will actually be ignored and the third argument will be used instead. You can see more information about that constructor's arguments in the API documentation.

The protobuf encoding doesn't distinguish between these two cases. Since protobuf is language-agnostic, it doesn't understand the conceptual nuance of "undefined" versus "[]" of Javascript.

You would need to pass additional information inside the proto message in order to distinguish between the two cases.

I would highly suggest reading the design documentations here: https://developers.google.com/protocol-buffers

The primary problem here is that the version of gRPC you are trying to install is not compatible with the version of Node that you are using. That error indicates that you are installing gRPC@1.10.1 with Node 10; the first version of gRPC that supports Node 10 is gRPC@1.11.1. So, in general the solution to this problem would be to either downgrade your Node version, or upgrade your gRPC version.

Your edit seems to indicate that you were able to solve this by downgrading the versions of the firebase, firebase-admin, and firebase-tools packages that you are using. This probably works because the specific versions you tried first pinned the gRPC dependency to the older version, and downgrading got you a version that didn't have the dependency pinned. However, each of those packages also has newer versions that don't pin the gRPC dependency and should give you the newest version.