Re: [grpc-io] node.js multiplexing client channels, [is this hack safe?]

I believe that we use PING frames to keep connections alive while they are otherwise idle. I wouldn't expect to need any PINGs when other data is moving across the connection. Have you tried observing an otherwise idle channel for PING frames? On Fri, Feb 17, 2017 at 11:08 AM Francesco Lazzarino

[grpc-io] Re: gRFC for C-core endpoint extension API

It has been pointed out to me that most endpoints that would be supported by this change would also require changes to other parts of the event handling code. I think I should modify this proposal to expose most of the rest of the APIs in src/core/lib/iomgr. On Friday, January 27, 2017 at

Re: [grpc-io] node.js multiplexing client channels, [is this hack safe?]

You should have no problems with this approach, but it also shouldn't be necessary. gRPC already uses HTTP2 pings to keep channels alive while they're otherwise idle. If you're still seeing disconnects, there are a couple of channel options you can set (they go into an object in the third argument

[grpc-io] Re: gRFC: NodeJS Client Interceptors

I do not like the idea of directly exposing the internal grpc.Call API. It is internal for a reason, and it is not currently guaranteed to be stable. I would strongly prefer that the "outbound interceptor" and "inbound interceptor" APIs be the fundamental building blocks of this interceptor

Re: [grpc-io] How to read grpc command line tool error messages from the responses?

You did get error information: "Rpc failed with status code 12 error message unknown service my_agent.MyServiceAPI " The part that says "unknown service my_agent.MyServiceAPI" means that the server does not have an implementation of a service with that name, and status code 12 means

Re: [grpc-io] node.js closing a client, is it possible?

It's a little awkward, but you can close a client with grpc.closeClient(client). That just closes the channel, though, so if that didn't work, that's a bug. I don't recognize the names "CloseWait" and "FinWait2", can you be more specific about how this is failing? On Tue, Feb 14, 2017 at 7:54 PM

Re: [grpc-io] protobuf-c-rpc server and grpc client

protobuf-c-rpc and protobuf-rpc are not related to gRPC. Based on your use of ProtoBuf.Rpc.Transport.Xhr, it looks like they are using XML HTTP Requests instead. The C++ gRPC client will not work with one of those servers because it uses a completely different protocol. On Thu, Aug 18, 2016 at

Re: [grpc-io] Handling client and server error on grpc java/node

On the Node side, that is surfaced as a non-OK status. You can handle those by listening to the 'error' event on the stream object that is created when you start the call. On Tue, Nov 8, 2016 at 11:35 AM Harshal Jethwa wrote: > I am using grpc to communicate between a Java

Re: [grpc-io] Using a single CompletionQueue for server and client objects

Yes, you can do that. In fact, the Node.js library automatically uses a single completion queue for all operations and it is able to handle any number of simultaneous clients and servers (in principle). On Tue, Oct 18, 2016 at 12:59 PM wrote: > Hi, > > I'm implementing a

Re: [grpc-io] Can I send a custom Error message from server to client GRPC?

You can send a custom status message to the client using the Error object's message property. In your example, that is "MY_ERROR". The status code should be in the "code" property, just like how you see it on the client side. If you want to use the gRPC status structure instead of a JavaScript

Re: [grpc-io] Re: Hopefully you can help....

I see the problem now. The link you clicked surprisingly goes to the artifacts from the latest build, not that specific build. To get the file from that branch, you should go to

Re: [grpc-io] [Node.js] Does the Node implementation with Angular2?

The Node.js gRPC library is a server-side library, written primarily in C and compiled against the Node.js runtime. It does not work in a browser environment. There is ongoing development on a gRPC library that works in the browser, but it has not yet been released. On Thu, Mar 23, 2017 at 9:35

Re: [grpc-io] Re: Connect to a Go GRPC Server running with TLS enabled using node js grpc client

One possibility is that the client is not set up to use SSL. Can you show the code you use to initialize the clients? On Tue, Mar 14, 2017 at 5:03 PM 'Menghan Li' via grpc.io < grpc-io@googlegroups.com> wrote: > gRPC server expects http2.ClientPreface( >

Re: [grpc-io] Re: gRFC: NodeJS Client Interceptors

It's probably fine to leave all of the options as they are now, but options.credentials is a CallCredentials, not a ChannelCredentials. I think that threw me off. On Thu, Mar 9, 2017 at 2:38 PM dduke via grpc.io wrote: > The proposal says "The interceptCall method

Re: [grpc-io] Re: gRFC: NodeJS Client Interceptors

Overall, I think it looks better now, but I have a few nitpicks. The proposal says "The interceptCall method allows developers to modify the call options". What are the semantics of modifying these options, particularly the ones that apply to an entire client, not a single method

Re: [grpc-io] error when use command npm install on windows

What version of Node do you have (node --version)? What version of npm do you have (npm --version)? Are you able to install any packages? Also, installing grpc with the -g flag probably won't do you any good. It's a library, not a command line tool. On Wed, Mar 1, 2017 at 10:06 PM Jyoti Rawat

Re: [grpc-io] Re: Detecting client disconnections in the server side

I don't understand what the problem is. You say that you get the 'end' event on the server side when the client disconnects. What else do you need? Also, with streaming calls, you need to call call.end() on the server side too. The callback for the 'end' event is usually a good place to do that.

Re: [grpc-io] Re: gRFC: NodeJS Client Interceptors

Can you show in the proposal what the trivial implementation of all of the interception methods would look like without the builders? On Mon, Mar 13, 2017 at 12:30 PM dduke via grpc.io wrote: > I've updated the gRPC PR and the proposal to promote the `interceptCall` >

Re: [grpc-io] NodeJS: Handling write errors on BiDi streams

As that documentation says, if a write fails due to a serialization error, the call is cancelled. If the write fails for some other reason, that means that the call has already ended in some way. Either way, you should not continue writing after a write failure. On Thu, Jul 20, 2017 at 2:54 PM

[grpc-io] Re: gRPC C interface

+grpc-io@googlegroups.com On Tue, Jul 4, 2017 at 1:57 PM Brian Leeson wrote: > Hello, > > My name is Brian Leeson and I attend the University of Oregon and work in > the Computer Science department. My adviser has tasked me with a project >

Re: [grpc-io] New npm module: Promisify grpc client for NodeJS for all Request types (standard and stream)

I think this is an interesting library, but I had a couple of concerns about the API, particularly regarding streaming requests. First, I noticed that in your server streaming example, the response messages appear to be coalesced into an array before being returned to the user, which seems to

Re: [grpc-io] gRPC authenticated channel using custom access token

>From that error output, I suspect that you called a method on a client object with incorrect arguments. What is the code that resulted in that error? You should also keep in mind that the specific function grpc.credentials.createFromGoogleCredential should only be used with credentials objects

Re: [grpc-io] gRPC authenticated channel using custom access token

The createFromMetadataGenerator function takes as its argument a function. The first argument to that function is an object, which currently just contains the key "service_url", which is probably not relevant to your use case. The second argument to that function is a callback, which has the

Re: [grpc-io] gRPC authenticated channel using custom access token

You got an error that says "Invalid Authorization Token". That error was thrown by the call's "error" event handler, which means that that the call ended with that error. That error message probably came from the server. So, there is some problem with your access_token. On Tue, May 23, 2017 at

Re: [grpc-io] Cross-Compile GRPC

We already distribute the extension precompiled for electron on Mac, Linux, and Windows. If you want to download binaries for a different system, you should be able to do "npm install grpc --update-binary --target-platform=win32" for windows, and replace "win32" with "linux" for linux. On Tue,

Re: [grpc-io] Re: grpc streaming and loadbalancer close connections?

For the Node client, I think you can enable keepalive HTTP2 pings using the channel argument "grpc.keepalive_time_ms" as defined at https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/grpc_types.h#L230. This argument is passed in the options object, which is the third argument to

Re: [grpc-io] gRPC frozen state

As far as I understand, your original problem was that completion_queue_pluck was occasionally blocking indefinitely. The use-after-free issue that you reported is caused by freeing memory blocks that were passed to the gRPC core before the core was done using them. The gRPC C core requires that

Re: [grpc-io] gRPC frozen state

The primary cause of your problem is that you're calling completion_queue_pluck after calling cancel_with_status. Assuming you're following the model of the current PHP wrapper and calling pluck with an infinite timeout, you should only do so exactly once for each operation that creates a tag on

Re: [grpc-io] Re: Is gRPC (or http2) resumable?

We do plan to implement a pure JavaScript server, but we're prioritizing the client and there is a lot of client work to do first. Regarding the npm "http2" module, its own README on GitHub says that it is deprecated in favor of the new built in http2 module. In addition, that module did not

[grpc-io] Re: Request for Node gRPC API Feedback

It should be accessible now. On Thu, Aug 24, 2017 at 4:58 AM wrote: > Is this still open? I get permission issues when trying to fill it out > inline here. And the form is not accessible once I click the button with > similar permission errors. > > > On Monday, 7 August 2017

[grpc-io] gRFC Proposal L12: Node.js gRPC 2.0 API changes

I have created a proposal that describes changes that will be made to the Node.js gRPC API for the major version bump to 2.0: https://github.com/grpc/proposal/pull/46. If you have any comments or suggestions, please discuss them in this thread. -- You received this message because you are

Re: [grpc-io] Re: gRFC Proposal L12: Node.js gRPC 2.0 API changes

Thank you for your input. Regarding the Protobuf.js changes, one of the primary goals of this API change is to decouple gRPC from Protobuf.js as much as possible, because the existing tight coupling has prevented us from upgrading the dependency from Protobuf.js 5 to 6 without breaking the API.

Re: [grpc-io] [Js/Ts/Node.js] Questions on the state of the Js/Ts implementation

1. Recently, development on the Node gRPC implementation has moved entirely to https://github.com/grpc/grpc-node. Issues and PRs specifically related to the Node implementation should be filed there. It is still implemented using code in grpc/grpc, so it has a submodule reference to

Re: [grpc-io] libuv, C++, gRPC

In principle, I think this should work, but it will probably be a little awkward because the libuv code was written to work with Node, and specifically with our own Node extension. So, there are a few caveats: 1. The Makefile isn't set up to build the libuv code, so you'll have to set

Re: [grpc-io] npm install grpc is failing on ubuntu 16.04.

This is a known bug in node-pre-gyp: https://github.com/mapbox/node-pre-gyp/issues/367. Currently there is no given solution. On Thu, May 10, 2018 at 3:21 AM wrote: > Hi guys, > > I'm trying to install grpc on ubuntu 16.04. But it is failing with below > error. I have

Re: [grpc-io] DNS requery not happening with round_robin load balancing in docker swarm

To clarify, are you saying that after your client loses its connection to every server, it never reestablishes a connection with any of them? On Wed, Oct 25, 2017 at 10:42 PM wrote: > I'm trying to get a gRPC client/server running using nodejs under Docker > swarm. > >

[grpc-io] gRFC L23: Standalone Node.js gRPC+Protobuf.js Library API

Discussion of https://github.com/grpc/proposal/pull/58 -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails from it, send an email to grpc-io+unsubscr...@googlegroups.com. To post to this group,

Re: [grpc-io] Streamed ve non Streamed services speed

The behavior you are seeing is expected. A stream request is a single RPC in which messages are sent and received in order. But when you do your "non-streamed" requests, what you are really doing is making several independent parallel request. This is why you are seeing those messages arrive out

Re: [grpc-io] Re: gRFC Proposal L12: Node.js gRPC 2.0 API changes

I like your suggestion of matching the http2session.shutdown API, but I don't think it should return a promise, because none of the rest of the API uses promises, and I would prefer to be consistent. That rxjs API concept is interesting, but I think there are some significant issues. Most

Re: [grpc-io] Using grpc from Electron / Node main and renderer...

gRPC on Node uses the Node event loop, and it does all of its work on the main thread. On Fri, Sep 7, 2018 at 11:32 AM Kevin Burton wrote: > >> Given that information, gRPC does not seem to solve most of those >> problems. You could use it to offload computationally expensive work to >>

Re: [grpc-io] Using grpc from Electron / Node main and renderer...

Before I address this question I want to be sure that we have the same understanding of how Electron works at a low level. Electron is a single process with a single thread. It contains two separate sets of JavaScript execution state. One is a Chromium environment that is called the "renderer

Re: [grpc-io] Using grpc from Electron / Node main and renderer...

If you want to use gRPC with electron you have to pass some extra arguments at installation time to indicate that you want the electron binaries. So it would look something like this: npm install grpc --runtime=electron --target=. Just replace "" with whatever version of electron you are using.

Re: [grpc-io] Using grpc from Electron / Node main and renderer...

Yes, the README has a section about it. You can find that on the npm package page , and in the repository . On Fri, Sep 7, 2018 at 3:33 PM Kevin Burton wrote: > Ah.. nice.. is that

[grpc-io] Re: grpc-node Any support

That pull request is good to see. I think it means that "Any" types will probably work well with the new package. We generally make announcements on our mailing list grpc-io@googlegroups.com, and we will make announcements about that package. On Mon, Mar 5, 2018 at 7:42 PM Adrien Pajot

Re: [grpc-io] How to know if a HTTP2 DATA frame contains an entire protobuf message or there will be more segments

The requests stream is a stream of Length-Prefixed-Message, and that length prefix tells you how much data to expect for each message. On Sun, Apr 1, 2018 at 5:53 PM yihao yang wrote: > Hi, all: > > The title is my question. In this spec, >

[grpc-io] Re: When can I start sending request?

You can start sending requests as soon as you initialize the client. Nothing will actually be sent over the network until the connection is properly established. On Sunday, December 17, 2017 at 11:50:09 PM UTC-8, Manu wrote: > > Hi, > > I have a C++ server and a node.js client. I've observed

[grpc-io] gRFC L40: Node Call Invocation Transformer API

Discussion thread for gRFC L40: https://github.com/grpc/proposal/pull/107 This gRFC proposes a new Client option for modifying how calls are invoked. -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving

[grpc-io] Re: gRFC L43: Node Message Type Information

This is a final call for comments on this proposal. If there are still no suggested changes tomorrow I will merge it. On Mon, Nov 19, 2018 at 2:43 PM Michael Lumish wrote: > This is the discussion thread for gRFC L43: > https://github.com/grpc/proposal/pull/116. > > This gRFC proposes a new

Re: [grpc-io] libgrpc++: Enabling debug trace on Android

Have you tried "GRPC_VERBOSITY=DEBUG"? Our environment variables are unfortunately case-sensitive with varying casing conventions On Thu, Nov 29, 2018 at 4:18 PM David Collins wrote: > Hi all, > > I have cross-compiled version 1.17.0 of the libgrpc++ library for the > Android platform. When I

[grpc-io] gRFC L43: Node Message Type Information

This is the discussion thread for gRFC L43: https://github.com/grpc/proposal/pull/116. This gRFC proposes a new standard for sharing/handling message type information for gRPC methods in the Node libraries. -- You received this message because you are subscribed to the Google Groups "grpc.io"

[grpc-io] Re: Does gRPC use only http2? tcpdump from a particular client does not show it as http2

What language(s) are you using gRPC with? In any case, it will be very hard for us to help with such an old version; is there any way for you to update it? On Wednesday, November 28, 2018 at 6:37:25 AM UTC-8, Pramma wrote: > > > While analysing tcpdump of gRPC comm between our client

[grpc-io] L48: Node types package

Discussion thread for proposal: https://github.com/grpc/proposal/pull/126 -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails from it, send an email to grpc-io+unsubscr...@googlegroups.com. To

[grpc-io] Re: L48: Node types package

Correction: this is L47 On Thu, Feb 28, 2019 at 4:56 PM Michael Lumish wrote: > Discussion thread for proposal: https://github.com/grpc/proposal/pull/126 > -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop

[grpc-io] L48: Node Metadata options

Discussion thread for proposal: https://github.com/grpc/proposal/pull/127 -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails from it, send an email to grpc-io+unsubscr...@googlegroups.com. To

Re: [grpc-io] Frustrated with Grpc-node

Can you try updating your dependencies? I just tried running the given code with the latest versions of grpc and @grpc/proto-loader and it worked. There was previously an issue that the library would not accept method names with the same casing as in the original proto file, but that was fixed a

Re: [grpc-io] Frustrated with Grpc-node

Can you make sure you don't have any other servers running on that same machine? One possibility here is that another gRPC service without that method implemented is bound to this port and either the bind call is failing (the example code does not check the return value), or they are both binding

Re: [grpc-io] HTTP/2 Stream

The parent frame identifier, also called the stream dependency, is part of the HEADERS frame payload. The HEADERS frame still has the same general frame header with the stream identifier. On Fri, Apr 12, 2019 at 9:46 AM chirag shah wrote: > Hello, > > I am seeking one clarification about the

Re: [grpc-io] HTTP/2 Stream

Here's how it works: every frame starts with a 9-byte header, consisting of 3 bytes for the payload length, 1 byte for the frame type, 1 byte for the flags, and 4 bytes for the stream identifier plus reserved bit. This is followed by the frame payload. The HEADER frame payload starts with an

Re: [grpc-io] Frustrated with Grpc-node

There is an option on Linux called SO_REUSEPORT, which allows two processes to bind to the same port as long as they set the same options. The gRPC libraries set this option to allow users to get a very basic kind of multiprocessing/load balancing by simply spawning multiple copies of the server

Re: [grpc-io] Parses gRPC's raw HTTP2 traffic in the HTTP2 DATA frame

You can find the relevant part of the protocol specification doc you linked to by looking for "Length-Prefixed-Message". The sequence of DATA frames is treated as a byte stream containing one or more of those Length-Prefixed-Message. Then each message is arbitrary binary data. If it is a protobuf

Re: [grpc-io] Does gRPC uses any reserved headers other than :method :scheme :path :authority?

The protocol definition document lists all of the HTTP/2 headers that are given specific meanings by the gRPC protocol. Make sure you check both the "Requests" and "Responses" sections. On Wed, Aug 14, 2019 at 11:17 AM Yaxiong Zhao

Re: [grpc-io] gRPC Node.js OS Question

This is one area where our API documentation is not great. interceptorProvider is a function type, not an exported function. In the Client constructor options parameter, two of the available options are "interceptors" and "interceptor_providers", which take an array of Interceptors and an array of

Re: [grpc-io] NodeJS Server Interceptors

In the time since that issue was filed, it is still unclear what a server interceptors API would look like, or even what problems it should solve. The first thing that would be needed to add this kind of feature would be a proposal similar to

Re: [grpc-io] Node - Access to TLS client certificate server side

Currently this feature is not available in the Node library. There is an open PR working towards implementing it ( https://github.com/grpc/grpc-node/pull/508), but it is not complete and that work has not been prioritized recently. On Wed, Nov 6, 2019 at 1:59 AM wrote: > Hi All, > > I would

Re: [grpc-io] Keeping messages order

If you want messages to arrive in a particular order, you should send all of those messages on the same stream. If for some reason that is not an option, you could instead define the order in the RPC method definition. For example, you could add a sequence number that is shared across both

Re: [grpc-io] does latest grpc@1.24.2 support with node version v10.16.0 ?

Yes, the latest version of grpc supports Node 10.x. The most important error message there is "Hit error EACCES: permission denied, mkdir '/root/ram/grpc/examples/node/node_modules/grpc/src/node'". These indicate that the filesystem permissions are preventing node-pre-gyp from accessing the

Re: [grpc-io] Problems to send arrays to grpc client

There's a lot of code in that repository so it's hard to tell what exactly is happening. One thing that stands out is that your server is constructing message objects using types generated with protoc, then calling toObject and passing it to a service callback generated using @grpc/proto-loader.

Re: [grpc-io] Issue starting grpc-node server on hosts with IPv6 disabled

I would have thought that binding to the IPv4 address explicitly would work. Alternatively, binding to the pod's hostname might work. On Fri, Mar 27, 2020 at 9:55 AM 'Mya Pitzeruse' via grpc.io < grpc-io@googlegroups.com> wrote: > Hey folks! > > I'm reaching out because I've encountered some

Re: [grpc-io] Issue starting grpc-node server on hosts with IPv6 disabled

Alternatively, have you tried @grpc/grpc-js? It has essentially all of the same server functionality, and it doesn't have that bug. The one significant difference is that you have to use bindAsync instead of bind. On Fri, Mar 27, 2020 at 10:43 AM Michael Lumish wrote: > I would have thought

[grpc-io] Node gRPC deprecation plan announcement

With the 1.0 release of the @grpc/grpc-js library, we have decided to focus our future feature development work in Node.js on this library. As a result, we will not be adding any new features to the original grpc

Re: [grpc-io] Possible Parameter Pollution Vulnerability

The existing behavior you describe is correct. The spec ( https://developers.google.com/protocol-buffers/docs/encoding#optional) says "For numeric types and strings, if the same field appears multiple times, the parser accepts the *last* value it sees. For embedded message fields, the parser

Re: [grpc-io] Aggregation/Parallel Asynchronous Calling

What you are describing is a normal thing to do with gRPC, using either unary or streaming methods. Each of those operations is independent and can be started independently, and then when they finish you can aggregate the results. The exact way to do this depends on what features the specific

Re: [grpc-io] Aggregation/Parallel Asynchronous Calling

I primarily work on the Node.js libraries. Maybe someone on the Java team like +Eric Anderson can comment on how this sort of thing can be done in Java. On Thu, Sep 24, 2020 at 12:00 AM Nicholas Bunn wrote: > For the aggregation services, I was thinking of going with Java (only > because I'm

[grpc-io] gRFC L70: @grpc/proto-loader TypeScript Type Generator CLI Tool

https://github.com/grpc/proposal/pull/183 -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails from it, send an email to grpc-io+unsubscr...@googlegroups.com. To view this discussion on the web

Re: [grpc-io] gRPC - node.js simultaneous client calls - reverse ordered

I just want to make sure it's clear that the ordering behavior you have observed here is not guaranteed. Requests made before a connection is established are not necessarily reversed, the connection state internally may change after a connection is established, and requests on the same client may

Re: [grpc-io] gRPC - node.js simultaneous client calls - reverse ordered

Those requests all happen independently. We don't make any guarantees about their order, so the library internals are free to reorder them before sending them out. In this case, the first requests you make after you construct the client object cause it to start connecting, so those requests will

Re: [grpc-io] Re: Is it possible to make GRPC_OP_RECV_MESSAGE optional on client side

The simplest way to handle this is to put the GRPC_OP_RECV_MESSAGE into a separate batch. You can wait for the batch with the metadata, then wait for the message batch. If the server ends the call without sending a message, the message batch will end with a null message. On Fri, Jul 24, 2020 at

Re: [grpc-io] Extrapolating a node.js client call from a grpcurl call?

First, assuming that that is a protobuf service, you will need to have a proto file that describes it in order to make the requests. You should be able to get that file from the service provider. Once you have that, there are two main packages for using proto files with the Node gRPC libraries:

Re: [grpc-io] NodeJS gRPC server in k8s QUEUE_TIMEOUT

Those QUEUE_TIMEOUT events don't really mean anything. They just show the library polling for new events and not finding any at that time. If there's nothing else in the log, that probably implies that the client can't establish a connection to the server at all. If you enable tracing on the

Re: [grpc-io] NodeJS gRPC server in k8s QUEUE_TIMEOUT

OK, what's in the rest of the client log? The earlier part probably shows what happened when it tried to establish a connection to the server. On Mon, May 3, 2021 at 12:27 PM Chris Tyler wrote: > Michael, > > Thanks for the response. I did run client tracing as well. Again, after > getting

[grpc-io] gRFC A50: gRPC xDS Outlier Detection Support

I have opened a gRFC for xDS Outlier Detection support: https://github.com/grpc/proposal/pull/281 -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails from it, send an email to

Re: [grpc-io] [grpc-js] Setting a channel's idle timeout

grpc-js does not currently support that functionality, so it also does not currently recognize that option. On Sun, Feb 13, 2022 at 8:41 PM Joshua Karp wrote: > I'm wanting to adjust the idle timeout for a gRPC channel (i.e. the time > required for the channel to move from a READY state to an

[grpc-io] gRFC L109: Node: Server API to unbind ports

I have published a gRFC to add a new method to the Server class in Node gRPC. https://github.com/grpc/proposal/pull/398 Comments are welcome. -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails

[grpc-io] gRFC L107: Node: Make Server#start a no-op

I have published a gRFC to make a small behavior change in Node servers: https://github.com/grpc/proposal/pull/395 Comments welcome Note: this proposal is based on the assumption that there is no value in calling bindAsync but not start. If you intentionally do that please comment so that we

[grpc-io] gRFC L106: L106: Node Heath Check Library 2.0

https://github.com/grpc/proposal/pull/391 is a gRFC for defining a new API for the Node gRPC health check library. Feedback welcome. -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails from it,

[grpc-io] gRFC L111: Node: Server API to drain connections on a port

I have published a gRFC to add a new method to the Server class in Node gRPC. https://github.com/grpc/proposal/pull/401 Comments are welcome. -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and stop receiving emails

Re: [grpc-io] Multiple async connections in nodejs gRPC

This is a DNS error that is occurring when making an HTTP request. gRPC is not involved here. On Sun, Apr 2, 2023 at 5:32 AM 0xvoid wrote: > when sending one request the gRPC server from a rest api (that acts as a > gRPC client), the server returns it successfully, but when sending multiple >

Re: [grpc-io] Grpc does not reconnect

I assume you are using the grpc-js library. If not, you should be, because the other implementation is deprecated. The best way to determine what is happening is with gRPC trace logs. In particular, please run the "Service A" process with the following environment variables and share the output

Re: [grpc-io] Missing node-v108-linux-x64-glibc precompiled binary

The grpc package has been deprecated since April 2021, and the suggested replacement is @grpc/grpc-js. As noted in the README , the grpc package only supports Node version up to 14, while you are trying to install it on Node 18. We have never published

Re: [grpc-io] gRPC connection not working after server restarted

The diagnosis here depends partly on what you mean by "the connection doesn't work anymore". What symptoms are you observing on service A that are leading you to that conclusion? You said "this client is reused, makeClient is called when RPC call has error". If you are observing request errors on

Re: [grpc-io] Does every data frame contains exactly one grpc message?

Yes, it is common in bidirectional streaming RPCs for the server to send messages before the client ends its side of the stream. For example, the server could respond to each message the client sends with a message, indefinitely, without the stream ever intentionally closing. On Mon, Jan 22, 2024

[grpc-io] gRFC L114: Node Server Connection Injection

I have written a gRFC proposing to add a new connection injection API to the Node gRPC Server class: https://github.com/grpc/proposal/pull/418 Comments welcome. -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and

Re: [grpc-io] Questions about grpc-node client streaming

>From that trace log, it looks like this is the same error as in https://github.com/grpc/grpc-node/issues/2625. It would be helpful to consolidate further discussions of this error in that issue. You do need a 'status' event handler if you want to always see trailers, and it looks like you do

Re: [grpc-io] Questions about grpc-node client streaming

You do need to call the callback on the server to end the call. If I am understanding correctly that those trace logs are from the test where you removed that call. In that case they will not be helpful. It would be helpful to have the logs that show the original error you were experiencing. On

[grpc-io] gRFC L112: Node Server Interceptors

I have written a gRFC proposing the addition of a new server interceptors API to the Node gRPC library. https://github.com/grpc/proposal/pull/406 Feedback welcome. -- You received this message because you are subscribed to the Google Groups "grpc.io" group. To unsubscribe from this group and

Re: [grpc-io] Node GRPC: Please Help a Newbie w Client Interceptors

1. We generally consider a single call to be a single stream in which messages and metadata are sent both from the client to the server and from the server to the client. In general, requests and responses can be separated in time, and there can even be back-and-forth interactions in a single

Re: [grpc-io] Does every data frame contains exactly one grpc message?

No. In a stream, the contents of all of the DATA frames sent in one direction are collectively treated as a byte stream that contains length-delimited gRPC messages, independent of the DATA frame boundaries. In other words, any single DATA frame can contain only part of a message, or multiple

[grpc-io] Re: String deduplication in grpc-go RPC message stream

Can you clarify what language you are using? Have you tried using compression? On Wednesday, March 27, 2024 at 7:15:33 AM UTC-7 Giedrius Statkevičius wrote: > Hello, > > We have a stream of messages with map. It is guaranteed > that a lot of strings repeat themselves over multiple messages. I