The Dart language implementation of gRPC.

See the gRPC-Web protocol document for details.

We should be able to support this by making a GrpcWebChannel that implements the ClientChannel interface.

This is a work in progress, and I haven't gone down the path of implementing grpc-web yet, but I wanted to get some feedback on this refactor while I work on a GrpcWebTransport.

Depending on feedback, I can abandon this PR and create another once that transport is done.

One thing that needs to be done is there are no unit tests for the Http2Transport, only generalized transport.

When host start with "unix://", it will be parsed as unix socket, in other situations, it keep coincide with current code.

Admin comment: Fixes https://github.com/grpc/grpc-dart/issues/299

Currently there is no way to access the details of a GrpcError in the Dart implementation. This PR adds the fully-typed details into the dart exception that gets thrown.

This implements what's requested in #209.

cc @jakobr-google as I saw you had a TODO comment in call.dart to do this someday.

• Fixes bug when a ResponseStream is cancelled the underlying HTTP/2 stream is not disconnected so the transport never goes inactive/idle.
• ~~Add connectTimeout to socket connections.~~
• Fixes bug where connect state is mismanaged on socket error.

I use grpc-0.6.5 with the following code:

main(List<String> args) async {
  await Server([Service()]).serve(port: 8022);

  final client = ServiceClient(ClientChannel(
    'localhost',
    port: 8022,
    options: const ChannelOptions(credentials: ChannelCredentials.insecure()),
  ));

  print(await client.method(Empty()).isEmpty);
  print(await client.method(Empty()).isEmpty); // line 18
}

class Service extends ServiceBase {
  @override
  Stream<Empty> method(ServiceCall call, Empty request) async* {
    yield request;
    yield request;
  }
}

and the proto:

syntax = "proto3";
import "google/protobuf/empty.proto";
service Service {
  rpc Method (google.protobuf.Empty) returns (stream google.protobuf.Empty);
}

When I run the code (with Dart-2.0.0) I get the following output:

false
Unhandled exception:
gRPC Error (14, Error making call: Bad state: The http/2 connection is no longer active and can therefore not be used to make new streams.)
#0      main (file:///home/me/sample/bin/issue-grpc-stream.dart:18:9)
<asynchronous suspension>
#1      _startIsolate.<anonymous closure> (dart:isolate/runtime/libisolate_patch.dart:277:32)
#2      _RawReceivePortImpl._handleMessage (dart:isolate/runtime/libisolate_patch.dart:165:12)
Exited (255)

Basically the code starts a server that provides a stream method. I call the method 2 times and use a .isEmpty on the resulting stream.

It looks like the problem is about cancelling a stream (because .isEmpty cancel its subscription directly after receiving the first event).

(I had a hard time to find what was the issue and I think it's an important issue)

Support client-side unary and streaming interceptors with similar interface to JS grpc-web interface. Interceptors are executed by Client.$createStreamingCall and Client.$createUnaryCall.

Is there a shelf middleware equivalent ? I would like to know how much time is passed inside my endpoint. And maybe also get and release db connection from a pool inside it.

When i launch this command : protoc --dart_out=grpc:lib/src/generated -Iprotos protos/metadata.proto i got the following error :

protoc-gen-dart: program not found or is not executable
--dart_out: protoc-gen-dart: Plugin failed with status code 1.

i have installed everything (protoc and the protoc_plugin)

Closes #413

This PR allows to make future chain request with ResponseFuture:

  @override
  ResponseFuture<R> interceptUnary<Q, R>(ClientMethod<Q, R> method, Q request,
      CallOptions options, ClientUnaryInvoker<Q, R> invoker) {
    _invocations.add(InterceptorInvocation(_id, ++_unary, _streaming));
    return ResponseFuture.wrap(
            Future.delayed(Duration(seconds: 1), () => 'dummy'))
        .then((_) => invoker(method, request, _inject(options)))
        .then((foo) async => foo)
        .whenComplete(() => 'complete')
        .then((bar) => bar)
        .catchError((e, s) => print('$e at $s'))
        .timeout(Duration(seconds: 5));
  }

Bumps actions/checkout from 3.1.0 to 3.2.0.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Interested in supporting external ASIO/gRPC C++, with a connection to Dart via isolate bridge.

It's there an easy way to pass off a serialized gRPC messages in Dart to a virtual isolate, and parse incoming message from an isolate?

I have an isolate zero-copy "bridge" working in both C++ and Rust.

Observation 1: As per the spec, "header field names MUST be converted to lowercase prior to their encoding in HTTP/2." This is enforced silently client-side in the _sanitizeMetadata method.

Observation 2: On the server side, in ServiceCall the clientMetadata property is of type Map<String, String>.

Consequence: If

1. A user is not aware of the lower-case metadata key requirement; and
2. is not aware of the Dart gRPC client's lower-casing of metadata keys; and
3. uses metadata key names with upper case letters on the client/server

then those metadata key names with upper case letters will not be retrieved on the server side, because there will be no keys with upper case letters in the clientMetadata map.

Thus, it is humbly suggested to implement one of the following enhancements:

1. Require that key names on the client side be provided by the user already lower case. In other words, rather than silently adjust them to lower case, throw i.e. an ArgumentError. (Obviously a potentially breaking change.)
2. On the server side, use something other than vanilla Map for clientMetadata. This could be a map that treats keys as case-insensitive, or one that lower-cases incoming keys (i.e. in operator[]).

P.S. Not just academic, I am the aforementioned unaware and surprised user. 😅

Hello, I'd like to see something like Interceptors on the server side, but more akin to the UnaryInterceptor of gRPC-Web. This is something I have appreciated from other server frameworks. This style of interceptor would "wrap" around the service call, which yields the existing functionality of Interceptors (such as vetoing a request) and more. Such "wrapping" interceptors would be able to manipulate both the incoming request as well as the outgoing response.

There are several interesting use cases for this. One such use case would be instrumenting all service calls in a uniform way.

Interceptor 1
|   Interceptor 2
|   |   Interceptor 3
|   |   |   service call
|   |   Interceptor 3
|   Interceptor 2
Interceptor 1

No stack trace shown for dealine exceeded errors.

(version: "3.1.0-dev")

Repro steps

1. checkout timeout branch from https://github.com/tarobins/grpc-dart/tree/timeout
2. start helloworld example server
3. run helloworld example client

Expected result:

Caught error: gRPC Error (code: 4, codeName: DEADLINE_EXCEEDED, message: Deadline exceeded, details: null, rawResponse: null, trailers: {})
Stack trace

That's all folks.
robinsontom-macbookpro1 example/helloworld$ dart bin/client.dart
Caught error: gRPC Error (code: 4, codeName: DEADLINE_EXCEEDED, message: Deadline exceeded, details: null, rawResponse: null, trailers: {})
Stack trace
#0      ClientCall._onTimedOut (package:grpc/src/client/call.dart:303:43)
#1      Timer._createTimer.<anonymous closure> (dart:async-patch/timer_patch.dart:18:15)
#2      _Timer._runTimers (dart:isolate-patch/timer_impl.dart:398:19)
#3      _Timer._handleMessage (dart:isolate-patch/timer_impl.dart:429:5)
#4      _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:192:12)

That's all folks.

Actual result:

Caught error: gRPC Error (code: 4, codeName: DEADLINE_EXCEEDED, message: Deadline exceeded, details: null, rawResponse: null, trailers: {})
Stack trace

That's all folks.

Using v3.0.2

Repro steps

1. Write a proto file using Google GRPC annotations + Kalix annotations
2. Setup a service in Kalix and add client certificate
3. Use curl and grpcurl like so to see expected response from service:

% curl https://my.host.name:443/KalixRoute --key client.private.pem --cert client.crt -d '{"data_type":{}}' -H "Content-Type: application/json"
[ExpectedError1]

% grpcurl -cert client.crt -key iclient.private.pem my.host.name:443 com.my.service.SerivceName/ProtoRoute
[ExpectedError2]

4. Generate client using protoc
5. See clients.dart code below
6. In a ChangeNotifier:

final RouteCommand request = RouteCommand(param: data!.toService());  //toService is a handrolled function to translate from FE domain to client domain
serviceClient!.establishOrganization(request).then((reply) {     //serviceClient was setup in ChangeNotifier constructor succesfully
   print(reply)
   data = [...data, domain.DataType.fromService(reply)];  //fromService is another handrolled function to translate the other way
});

Expected result: being able to see the same kinds of expected errors as in step3, which are programmed into the Kalix service, printed in step 6 - or else the valid response when provided (both have been attempted) Actual result:

Unhandled Exception: gRPC Error (code: 2, codeName: UNKNOWN, message: HTTP/2 error: Connection error: Connection is being forcefully terminated. (errorCode: 10), details: null, rawResponse: null, trailers: {})

Details

Since the Kalix service can be called with both curl and grpcurl to generate expected error messages, it seems my Dart code is likely the issue here. It is cobbled together from various examples and StackOverflows, so it is likely not all correct.

#clients.dart

ChannelCredentials creds = const ChannelCredentials.secure(authority: 'my.host.name');

Future<Client> setupClient() async {
  ByteData caCert = await rootBundle.load('cert/ca.crt');
  ByteData cert = await rootBundle.load('cert/client.chain.crt');
  ByteData key = await rootBundle.load('cert/client.private.pem');

  creds.securityContext!.setTrustedCertificatesBytes(caCert.buffer.asUint8List(caCert.offsetInBytes, caCert.lengthInBytes,)
      .map((uint8) => uint8.toInt())
      .toList());
  creds.securityContext!.useCertificateChainBytes(cert.buffer.asUint8List(cert.offsetInBytes, cert.lengthInBytes,)
      .map((uint8) => uint8.toInt())
      .toList());
  creds.securityContext!.usePrivateKeyBytes(key.buffer.asUint8List(key.offsetInBytes, key.lengthInBytes,)
      .map((uint8) => uint8.toInt())
      .toList());
  creds.securityContext!.setAlpnProtocols(supportedAlpnProtocols, false);


  ClientChannel channel = ClientChannel(
    'my.host.name',
    port: 443,
    options: ChannelOptions(credentials: creds),
  );
  return MyServiceClient(channel);
}