Cancelling task or shutting down streaming server does not send client RST_STREAM anymore.

[ericdusel-tri]

I had code working on the following versions:

grpc-swift v2.1.1
grpc-swift-nio-transport v1.0.2
grpc-swift-protobuf v1.1.0

and I upgraded to:

grpc-swift-2 v2.1.0
grpc-swift-nio-transport v2.1.1
grpc-swift-protobuf v2.1.1

Before, when I cancelled the Task that the server is running in, I would get an error on the client side saying "Received RST_STREAM with error code 8" in python or "Stream unexpectedly closed: received RST_STREAM frame (0x8: cancel)" in swift.

Now when I cancel, I get no indication on the client that the stream has stopped.

I am not sure if this is intended behavior but it makes it difficult to troubleshoot if the server side has been shutdown or cancelled based on the status of the client.

My server definition looks like:

  func runServer() async throws {
      let features = try self.loadFeatures()
      let service = RouteGuideService(features: features)
    let server = GRPCServer(
      transport: HTTP2ServerTransport.Posix(
        address: .ipv4(host: "0.0.0.0", port: 12345),
        transportSecurity: .plaintext
      ),
      services: [service]
    )

          try await withTaskCancellationHandler {
              try await server.serve()
          } onCancel: {
              print("Shutting down")
              server.beginGracefulShutdown()
          }

      if let address = try await server.listeningAddress {
          print("Tracker server listening on \(address)")
      }
  }
    private func loadFeatures() throws -> [Routeguide_Feature] {
      guard let url = Bundle.main.url(forResource: "route_guide_db", withExtension: "json") else {
        throw RPCError(code: .internalError, message: "Couldn't find 'route_guide_db.json")
      }

      let data = try Data(contentsOf: url)
      return try Routeguide_Feature.array(fromJSONUTF8Bytes: data)
    }

struct RouteGuideService: Routeguide_RouteGuide.SimpleServiceProtocol {
    private let features: [Routeguide_Feature]
    /// - Parameter features: Known features.
    init(features: [Routeguide_Feature]) {
      self.features = features

    }

    func listFeatures(
      request: Routeguide_Rectangle,
      response: RPCWriter<Routeguide_Feature>,
      context: ServerContext
    ) async throws {
      let featuresWithinBounds = self.features.filter { feature in
        !feature.name.isEmpty && feature.isContained(by: request)
      }

      // try await response.write(contentsOf: featuresWithinBounds)
      for f in features {
        try await response.write(f)
        try await Task.sleep(nanoseconds: UInt64(2 * Double(NSEC_PER_SEC)))
      }
    }

}

[glbrntt]

Before, when I cancelled the Task that the server is running in, I would get an error on the client side saying "Received RST_STREAM with error code 8" in python or "Stream unexpectedly closed: received RST_STREAM frame (0x8: cancel)" in swift.

That's not the expected behaviour for the code you shared. When you cancel your server task you're beginning graceful shutdown:

          try await withTaskCancellationHandler {
              try await server.serve()
          } onCancel: {
              print("Shutting down")
              server.beginGracefulShutdown()
          }

Graceful shutdown allows for existing RPCs to run until completion but new RPCs should fail. The client shouldn't receive a RST_STREAM for existing RPCs.

[ericdusel-tri]

I understand now, unfortunately I only added that line while troubleshooting. Originally, I was not calling the cancellation handler.

  func runServer() async throws {
      let features = try self.loadFeatures()
      let service = RouteGuideService(features: features)
    let server = GRPCServer(
      transport: HTTP2ServerTransport.Posix(
        address: .ipv4(host: "0.0.0.0", port: 12345),
        transportSecurity: .plaintext
      ),
      services: [service]
    )

        try await server.serve()
  }
    private func loadFeatures() throws -> [Routeguide_Feature] {
      guard let url = Bundle.main.url(forResource: "route_guide_db", withExtension: "json") else {
        throw RPCError(code: .internalError, message: "Couldn't find 'route_guide_db.json")
      }

      let data = try Data(contentsOf: url)
      return try Routeguide_Feature.array(fromJSONUTF8Bytes: data)
    }

Furthermore, when I remove the graceful shutdown, the behavior is even worse. I follow this pattern:

1. Run serve() inside a task.
2. Run client.
3. Cancel task containing server, should be stopped abruptly according to documentation (this is when I would expect the RST_STREAM error sent to the client to alert it of the shut down)
4. I can no longer restart the server, when I do, it says transportError: "Server transport threw an error." (cause: "bind(descriptor:ptr:bytes:): Address already in use (errno: 48)") It did NOT do this before.
5. If I try and start a second client (without stopping the one that is now hanging), I get the following error on the server side NIOCore/NIOAsyncWriter.swift:177: Fatal error: Deinited NIOAsyncWriter without calling finish()
6. App crashes
   -OR-
   5b. I can fix everything by stopping the existing first client, and I can restart the server like I did before, however there is no clear indication that the server was killed from the client so my users have no idea when they are supposed to shut down the client.

Is there a suggested way for the server to send the client an error like it did before?

More context: I am using this inside a visionOS app. Everything worked great before but when the user takes off the headset, the socket is closed. So I added a toggle which is what controls the state of the Task containing the server. This way I can cancel the Task when the headset is removed and reset the Toggle state so the user knows they need to restart the Task (and subsequently the server).

[glbrntt]

Awesome, thanks for providing more context. I've identified the cause of this in the transport. I'll try to get a fix up soon-ish.

In the meantime I can't think of a simple workaround beyond shutting down gracefully. If you need to terminate your RPC when the server shuts down you should be able to use the rpc cancellation handle on the context passed to your RPC.