x/net/http2: It seems like frames are getting corrupted in HTTP/2 when using a Unix domain socket on Windows

Go version
go version go1.21.8 windows/amd64
Output of go env in your module/workspace:
set GO111MODULE=
set GOARCH=amd64
set GOBIN=C:\Users\dze\go\bin
set GOCACHE=C:\Users\dze\AppData\Local\go-build
set GOENV=C:\Users\dze\AppData\Roaming\go\env
set GOEXE=.exe
set GOEXPERIMENT=
set GOFLAGS=
set GOHOSTARCH=amd64
set GOHOSTOS=windows
set GOINSECURE=git.ncsoft.net/*
set GOMODCACHE=C:\Users\dze\go\pkg\mod
set GONOPROXY=git.ncsoft.net/*
set GONOSUMDB=git.ncsoft.net/*
set GOOS=windows
set GOPATH=C:\Users\dze\go
set GOPRIVATE=git.ncsoft.net/*
set GOPROXY=https://proxy.golang.org,direct
set GOROOT=C:\Program Files\Go
set GOSUMDB=sum.golang.org
set GOTMPDIR=
set GOTOOLCHAIN=auto
set GOTOOLDIR=C:\Program Files\Go\pkg\tool\windows_amd64
set GOVCS=
set GOVERSION=go1.21.8
set GCCGO=gccgo
set GOAMD64=v1
set AR=ar
set CC=gcc
set CXX=g++
set CGO_ENABLED=0
set GOMOD=D:\github.com\grpc-go\examples\go.mod
set GOWORK=
set CGO_CFLAGS=-O2 -g
set CGO_CPPFLAGS=
set CGO_CXXFLAGS=-O2 -g
set CGO_FFLAGS=-O2 -g
set CGO_LDFLAGS=-O2 -g
set PKG_CONFIG=pkg-config
set GOGCCFLAGS=-m64 -fno-caret-diagnostics -Qunused-arguments -Wl,--no-gc-sections -fmessage-length=0 -ffile-prefix-map=C:\Users\dze\AppData\Local\Temp\go-build297662695=/tmp/go-build -gno-record-gcc-switches

What did you do?
I initially observed these errors in Unix domain socket connection between daprd and its pluggable component. After modifying the RouteChat code in grpc-go/examples/route_guide, I was able to reproduce them.
The issue is reproducible on other machines as well, and it occurs consistently across different versions like go1.19 and go1.22. Additionally, it persists on Windows 11.
What I did
The changes to server.go and client.go can be found at this repository.
Use Unix domain socket
    // server.go
    os.Remove("D://temp/test.sock")
    lis, err := net.Listen("unix", "D://temp/test.sock")

    // client.go
    serverAddr = flag.String("addr", "unix:///temp/test.sock", "The server address in the format of host:port")

Include a dummy string in the Message for sizing purposes
    // client.go
    {Location: &pb.Point{Latitude: 0, Longitude: 1}, Message: "First message:<PHONE_NUMBER>123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"}

Continuously send requests without concurrency and log status
    // client.go
    for {
        for _, note := range notes {
            if err := stream.Send(note); err != nil {
                log.Fatalf("client.RouteChat: stream.Send(%v) failed: %v, outstanding: %d", note, err, outstanding)
            }

            atomic.AddInt64(&sent, 1)
            // current := atomic.AddInt64(&outstanding, 1)
            atomic.AddInt64(&outstanding, 1)
            if true {
                if sent%10000 == 1 {
                    log.Printf("client.RouteChat: a lot of outstandings:  %4d, sent: %d, recv: %d", outstanding, sent, recv)
                }
                // time.Sleep(time.Microsecond)
                if sent%10000 == 1 {
                    log.Printf("client.RouteChat: decreased outstandings: %4d, sent: %d, recv: %d", outstanding, sent, recv)
                }
            }

            //<-recvc
        }
    }

Respond to received requests as they are
// server.go
func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {
    for {
        in, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        if err := stream.Send(in); err != nil {
            return err
        }
    }
}

The line where the error occurred during debugging
D:\github.com\grpc-go\examples\vendor\golang.org\x\net\http2\frame.go
func (fr *Framer) ReadFrame() (Frame, error) {
	fr.errDetail = nil
	if fr.lastFrame != nil {
		fr.lastFrame.invalidate()
	}
	fh, err := readFrameHeader(fr.headerBuf[:], fr.r)
	if err != nil {
		return nil, err
	}
	if fh.Length > fr.maxReadSize {
		return nil, ErrFrameTooLarge    // <-----
	}
    ...

or
D:\github.com\grpc-go\examples\vendor\google.golang.org\grpc\internal\transport\http2_client.go
func (t *http2Client) reader(errCh chan<- error) {
	defer close(t.readerDone)

	if err := t.readServerPreface(); err != nil {
		errCh <- err
		return
	}
	close(errCh)
	if t.keepaliveEnabled {
		atomic.StoreInt64(&t.lastRead, time.Now().UnixNano())
	}

	// loop to keep reading incoming messages on this transport.
	for {
		t.controlBuf.throttle()
		frame, err := t.framer.fr.ReadFrame()
		if t.keepaliveEnabled {
			atomic.StoreInt64(&t.lastRead, time.Now().UnixNano())
		}
		if err != nil {
			// Abort an active stream if the http2.Framer returns a
			// http2.StreamError. This can happen only if the server's response
			// is malformed http2.
			if se, ok := err.(http2.StreamError); ok {
				t.mu.Lock()
				s := t.activeStreams[se.StreamID]
				t.mu.Unlock()
				if s != nil {
					// use error detail to provide better err message
					code := http2ErrConvTab[se.Code]
					errorDetail := t.framer.fr.ErrorDetail()
					var msg string
					if errorDetail != nil {
						msg = errorDetail.Error()
					} else {
						msg = "received invalid frame"
					}
					t.closeStream(s, status.Error(code, msg), true, http2.ErrCodeProtocol, status.New(code, msg), nil, false)
				}
				continue
			} else {
				// Transport error.
				t.Close(connectionErrorf(true, err, "error reading from server: %v", err))
				return
			}
		}
		switch frame := frame.(type) {
		case *http2.MetaHeadersFrame:
			t.operateHeaders(frame)
		case *http2.DataFrame:
			t.handleData(frame)
		case *http2.RSTStreamFrame:
			t.handleRSTStream(frame)
		case *http2.SettingsFrame:
			t.handleSettings(frame, false)
		case *http2.PingFrame:
			t.handlePing(frame)
		case *http2.GoAwayFrame:
			t.handleGoAway(frame)
		case *http2.WindowUpdateFrame:
			t.handleWindowUpdate(frame)
		default:
			if logger.V(logLevel) {
				logger.Errorf("transport: http2Client.reader got unhandled frame type %v.", frame) // <-----
			}
		}
	}
}

How to reproduce
Install go and set up environment variables

Install go1.21..windows-amd64.msi
Set the following environment variables.

GRPC_GO_LOG_SEVERITY_LEVEL: info
GRPC_GO_LOG_VERBOSITY_LEVEL: 99

And if 'GODEBUG: http2debug=2' is present, delete it. When printing this debug log, no errors were observed to occur.
Clone the repositories and compile for Unix domain socket
> mkdir github.com
> cd github.com
github.com> git clone --depth 1 --branch v1.62.1 https://github.com/grpc/grpc-go.git
github.com> git clone https://github.com/dizecto/grpc-go-uds-test.git
github.com> copy /Y .\grpc-go-uds-test\route_guide\unix\client\client.go .\grpc-go\examples\route_guide\client\client.go
github.com> copy /Y .\grpc-go-uds-test\route_guide\unix\server\server.go .\grpc-go\examples\route_guide\server\server.go
github.com> cd grpc-go\exmaples
github.com\grpc-go\exmaples> go mod vendor
github.com\grpc-go\exmaples> go build -mod vendor route_guide\server\server.go
github.com\grpc-go\exmaples> go build -mod vendor route_guide\client\client.go

Execute 'server.exe' and 'client.exe' in separate command windows.

Create a "temp" directory in the D drive

github.com\grpc-go\exmaples> mkdir D:\temp

Launch 'server.exe'

github.com\grpc-go\exmaples> server.exe
2024/03/14 10:13:40 INFO: [core] [Server #1] Server created
2024/03/14 10:13:41 INFO: [core] [Server #1 ListenSocket #2] ListenSocket created

Launch 'client.exe'

github.com\grpc-go\exmaples> client.exe
2024/03/14 10:14:28 INFO: [core] [Channel #1] Channel created
2024/03/14 10:14:28 INFO: [core] [Channel #1] original dial target is: "unix:///temp/test.sock"
2024/03/14 10:14:28 INFO: [core] [Channel #1] parsed dial target is: resolver.Target{URL:url.URL{Scheme:"unix", Opaque:"", User:(*url.Userinfo)(nil), Host:"", Path:"/temp/test.sock", RawPath:"", OmitHost:false, ForceQuery:false, RawQuery:"", Fragment:"", RawFragment:""}}

Wait for errors

Be prepared to wait for errors; they may occur after several minutes or even tens of minutes.
What did you see happen?
Try 1
Error occurred within 15 seconds.
server.exe logs
D:\github.com\grpc-go\examples>server.exe
2024/03/14 10:13:40 INFO: [core] [Server #1] Server created
2024/03/14 10:13:41 INFO: [core] [Server #1 ListenSocket #2] ListenSocket created
2024/03/14 10:14:28 INFO: [core] CPU time info is unavailable on non-linux environments.
2024/03/14 10:14:43 INFO: [transport] [server-transport 0xc0000841a0] Closing: http2: frame too large
2024/03/14 10:14:43 INFO: [transport] [server-transport 0xc0000841a0] loopyWriter exiting with error: transport closed by client

client.exe logs
D:\github.com\grpc-go\examples>client.exe
2024/03/14 10:14:28 INFO: [core] [Channel #1] Channel created
2024/03/14 10:14:28 INFO: [core] [Channel #1] original dial target is: "unix:///temp/test.sock"
2024/03/14 10:14:28 INFO: [core] [Channel #1] parsed dial target is: resolver.Target{URL:url.URL{Scheme:"unix", Opaque:"", User:(*url.Userinfo)(nil), Host:"", Path:"/temp/test.sock", RawPath:"", OmitHost:false, ForceQuery:false, RawQuery:"", Fragment:"", RawFragment:""}}
...
read unix @->/temp/test.sock: wsarecv: An existing connection was forcibly closed by the remote host."
2024/03/14 10:14:43 INFO: [core] [Channel #1 SubChannel #2] Subchannel Connectivity change to IDLE
2024/03/14 10:14:43 INFO: [transport] [client-transport 0xc0000e6000] loopyWriter exiting with error: transport closed by client
2024/03/14 10:14:43 client.RouteChat failed: rpc error: code = Unavailable desc = error reading from server: read unix @->/temp/test.sock: wsarecv: An existing connection was forcibly closed by the remote host.

Try 2
Error occurred within 1 seconds.
server.exe logs
D:\github.com\grpc-go\examples>server.exe
2024/03/14 11:18:32 INFO: [core] [Server #1] Server created
2024/03/14 11:18:33 INFO: [core] [Server #1 ListenSocket #2] ListenSocket created
2024/03/14 11:18:38 INFO: [core] CPU time info is unavailable on non-linux environments.
2024/03/14 11:18:39 INFO: [transport] [server-transport 0xc0001ae000] Closing: connection error: PROTOCOL_ERROR
2024/03/14 11:18:39 INFO: [transport] [server-transport 0xc0001ae000] loopyWriter exiting with error: transport closed by client

client.exe logs
D:\github.com\grpc-go\examples>client.exe
2024/03/14 11:18:38 INFO: [core] [Channel #1] Channel created
2024/03/14 11:18:38 INFO: [core] [Channel #1] original dial target is: "unix:///temp/test.sock"
2024/03/14 11:18:38 INFO: [core] [Channel #1] parsed dial target is: resolver.Target{URL:url.URL{Scheme:"unix", Opaque:"", User:(*url.Userinfo)(nil), Host:"", Path:"/temp/test.sock", RawPath:"", OmitHost:false, ForceQuery:false, RawQuery:"", Fragment:"", RawFragment:""}}
...
2024/03/14 11:18:39 client.RouteChat: decreased outstandings:  115, sent: 430001, recv: 429886
2024/03/14 11:18:39 INFO: [transport] [client-transport 0xc00012c480] Closing: connection error: desc = "error reading from server: read unix @->/temp/test.sock: wsarecv: An existing connection was forcibly closed by the remote host."
2024/03/14 11:18:39 INFO: [core] [Channel #1 SubChannel #2] Subchannel Connectivity change to IDLE
2024/03/14 11:18:39 INFO: [transport] [client-transport 0xc00012c480] loopyWriter exiting with error: transport closed by client
2024/03/14 11:18:39 client.RouteChat: stream.Send(location:{longitude:1} message:"Fourth message:<PHONE_NUMBER>123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890") failed: EOF, outstanding: 182

Try 3
Error occurred within 1 minute and 16 seconds.
server.exe logs
D:\github.com\grpc-go\examples>server.exe
2024/03/14 16:04:31 INFO: [core] [Server #1] Server created
2024/03/14 16:04:31 INFO: [core] [Server #1 ListenSocket #2] ListenSocket created
2024/03/14 16:04:34 INFO: [core] CPU time info is unavailable on non-linux environments.
2024/03/14 16:05:50 INFO: [transport] [server-transport 0xc0001ae000] Closing: http2: frame too large
2024/03/14 16:05:50 INFO: [transport] [server-transport 0xc0001ae000] loopyWriter exiting with error: connection error: desc = "transport is closing"

client.exe logs
D:\github.com\grpc-go\examples>client.exe
2024/03/14 16:04:34 INFO: [core] [Channel #1] Channel created
2024/03/14 16:04:34 INFO: [core] [Channel #1] original dial target is: "unix:///temp/test.sock"
2024/03/14 16:04:34 INFO: [core] [Channel #1] parsed dial target is: resolver.Target{URL:url.URL{Scheme:"unix", Opaque:"", User:(*url.Userinfo)(nil), Host:"", Path:"/temp/test.sock", RawPath:"", OmitHost:false, ForceQuery:false, RawQuery:"", Fragment:"", RawFragment:""}}
...
2024/03/14 16:05:50 client.RouteChat: decreased outstandings:  126, sent: 19350001, recv: 19349875
2024/03/14 16:05:50 INFO: [transport] [client-transport 0xc0000d2000] Closing: connection error: desc = "error reading from server: read unix @->/temp/test.sock: wsarecv: An existing connection was forcibly closed by the remote host."
2024/03/14 16:05:50 INFO: [core] [Channel #1 SubChannel #2] Subchannel Connectivity change to IDLE
2024/03/14 16:05:50 INFO: [transport] [client-transport 0xc0000d2000] loopyWriter exiting with error: transport closed by client
2024/03/14 16:05:50 INFO: [core] [pick-first-lb 0xc00019be60] Received SubConn state update: 0xc00019bf80, {ConnectivityState:IDLE ConnectionError:<nil>}
2024/03/14 16:05:50 INFO: [core] [Channel #1] Channel Connectivity change to IDLE
2024/03/14 16:05:50 client.RouteChat failed: rpc error: code = Unavailable desc = error reading from server: read unix @->/temp/test.sock: wsarecv: An existing connection was forcibly closed by the remote host.

Try 4 -  seconds later
Error occurred within 2 minutes and 27 seconds.
server.exe logs
D:\github.com\grpc-go\examples>server.exe
2024/03/14 16:09:59 INFO: [core] [Server #1] Server created
2024/03/14 16:09:59 INFO: [core] [Server #1 ListenSocket #2] ListenSocket created
2024/03/14 16:10:02 INFO: [core] CPU time info is unavailable on non-linux environments.
2024/03/14 16:12:29 INFO: [transport] [server-transport 0xc000084340] Closing: read unix D://temp/test.sock->@: wsarecv: An existing connection was forcibly closed by the remote host.
2024/03/14 16:12:29 INFO: [transport] [server-transport 0xc000084340] loopyWriter exiting with error: transport closed by client

client.exe logs
D:\github.com\grpc-go\examples>client.exe
2024/03/14 16:10:02 INFO: [core] [Channel #1] Channel created
2024/03/14 16:10:02 INFO: [core] [Channel #1] original dial target is: "unix:///temp/test.sock"
2024/03/14 16:10:02 INFO: [core] [Channel #1] parsed dial target is: resolver.Target{URL:url.URL{Scheme:"unix", Opaque:"", User:(*url.Userinfo)(nil), Host:"", Path:"/temp/test.sock", RawPath:"", OmitHost:false, ForceQuery:false, RawQuery:"", Fragment:"", RawFragment:""}}
...
2024/03/14 16:12:29 client.RouteChat: decreased outstandings:  136, sent: 37900001, recv: 37899865
2024/03/14 16:12:29 INFO: [transport] [client-transport 0xc0000c1200] Closing: connection error: desc = "error reading from server: http2: frame too large"
2024/03/14 16:12:29 INFO: [core] [Channel #1 SubChannel #2] Subchannel Connectivity change to IDLE
2024/03/14 16:12:29 INFO: [transport] [client-transport 0xc0000c1200] loopyWriter exiting with error: transport closed by client
2024/03/14 16:12:29 INFO: [core] [pick-first-lb 0xc00021a030] Received SubConn state update: 0xc00021a180, {ConnectivityState:IDLE ConnectionError:<nil>}
2024/03/14 16:12:29 client.RouteChat: stream.Send(location:{longitude:3} message:"Third message:<PHONE_NUMBER>123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890") failed: EOF, outstanding: 181

Try 5
Error occurred within 2 minutes and 3 seconds.
server.exe logs
D:\github.com\grpc-go\examples>server.exe
2024/03/14 16:40:26 INFO: [core] [Server #1] Server created
2024/03/14 16:40:26 INFO: [core] [Server #1 ListenSocket #2] ListenSocket created
2024/03/14 16:40:30 INFO: [core] CPU time info is unavailable on non-linux environments.
2024/03/14 16:42:33 INFO: [transport] [server-transport 0xc0001ae000] Closing: http2: frame too large
2024/03/14 16:42:33 INFO: [transport] [server-transport 0xc0001ae000] loopyWriter exiting with error: connection error: desc = "transport is closing"

client.exe logs
D:\github.com\grpc-go\examples>client.exe
2024/03/14 16:40:30 INFO: [core] [Channel #1] Channel created
2024/03/14 16:40:30 INFO: [core] [Channel #1] original dial target is: "unix:///temp/test.sock"
2024/03/14 16:40:30 INFO: [core] [Channel #1] parsed dial target is: resolver.Target{URL:url.URL{Scheme:"unix", Opaque:"", User:(*url.Userinfo)(nil), Host:"", Path:"/temp/test.sock", RawPath:"", OmitHost:false, ForceQuery:false, RawQuery:"", Fragment:"", RawFragment:""}}
...
2024/03/14 16:42:33 client.RouteChat: decreased outstandings:  137, sent: 31430001, recv: 31429864
2024/03/14 16:42:33 INFO: [transport] [client-transport 0xc000141680] Closing: connection error: desc = "error reading from server: read unix @->/temp/test.sock: wsarecv: An existing connection was forcibly closed by the remote host."
2024/03/14 16:42:33 INFO: [core] [Channel #1 SubChannel #2] Subchannel Connectivity change to IDLE
2024/03/14 16:42:33 INFO: [transport] [client-transport 0xc000141680] loopyWriter exiting with error: transport closed by client
2024/03/14 16:42:33 client.RouteChat: stream.Send(location:{longitude:2} message:"Second message:<PHONE_NUMBER>123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890") failed: EOF, outstanding: 169

Try 6
Error occurred within 2 minutes and 47 seconds.
This was debugging mode.
server.exe logs
Starting: C:\Users\dze\go\bin\dlv.exe dap --listen=<IP_ADDRESS>:63676 from d:\github.com\grpc-go\examples\route_guide\server
DAP server listening at: <IP_ADDRESS>:63676
Type 'dlv help' for list of commands.
2024/03/18 13:47:27 INFO: [core] [Server #1] Server created
2024/03/18 13:47:27 INFO: [core] [Server #1 ListenSocket #2] ListenSocket created
2024/03/18 13:47:46 INFO: [core] CPU time info is unavailable on non-linux environments.
2024/03/18 13:50:33 INFO: [transport] [server-transport 0xc000057ba0] Closing: read unix D://temp/test.sock->@: wsarecv: An existing connection was forcibly closed by the remote host.
2024/03/18 13:50:33 INFO: [transport] [server-transport 0xc000057ba0] loopyWriter exiting with error: write unix D://temp/test.sock->@: wsasend: An existing connection was forcibly closed by the remote host.

client.exe logs
Starting: C:\Users\dze\go\bin\dlv.exe dap --listen=<IP_ADDRESS>:63687 from d:\github.com\grpc-go\examples\route_guide\client
DAP server listening at: <IP_ADDRESS>:63687
Type 'dlv help' for list of commands.
2024/03/18 13:47:46 INFO: [core] [Channel #1] Channel created
2024/03/18 13:47:46 INFO: [core] [Channel #1] original dial target is: "unix:///temp/test.sock"
2024/03/18 13:47:46 INFO: [core] [Channel #1] parsed dial target is: resolver.Target{URL:url.URL{Scheme:"unix", Opaque:"", User:(*url.Userinfo)(nil), Host:"", Path:"/temp/test.sock", RawPath:"", OmitHost:false, ForceQuery:false, RawQuery:"", Fragment:"", RawFragment:""}}
2024/03/18 13:47:46 INFO: [core] [Channel #1] Channel authority set to "localhost"
...
2024/03/18 13:50:33 client.RouteChat: decreased outstandings:  168, sent: 16110001, recv: 16109833
2024/03/18 13:50:33 ERROR: [transport] transport: http2Client.reader got unhandled frame type [FrameHeader UNKNOWN_FRAME_TYPE_215 len=2].
2024/03/18 13:50:33 ERROR: [transport] transport: http2Client.reader got unhandled frame type [FrameHeader UNKNOWN_FRAME_TYPE_210 flags=0x2|0x8 stream=34603794 len=2].
2024/03/18 13:50:33 INFO: [transport] [client-transport 0xc0000d6000] Closing: connection error: desc = "error reading from server: http2: frame too large"
2024/03/18 13:50:33 INFO: [core] [Channel #1 SubChannel #2] Subchannel Connectivity change to IDLE
2024/03/18 13:50:33 INFO: [transport] [client-transport 0xc0000d6000] loopyWriter exiting with error: transport closed by client
2024/03/18 13:50:33 client.RouteChat: stream.Send(location:{longitude:3}  message:"Sixth message:<PHONE_NUMBER>123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890") failed: EOF, outstanding: 162
Process 63280 has exited with status 1
Detaching

What did you expect to see?
Continue running as if using a TCP socket connection.
When using TCP connection, there are no code differences besides the address specified in 'server.go' and 'client.go'. They can be found at this repository.

This is using grpc-go, which uses the HTTP/2 frame encoder/decoder from golang.org/x/net/http2 but no other parts of the HTTP/2 implementation.
The framer is reasonably straightforward. It reads from an io.Reader and writes to an io.Writer, and doesn't have any interactions with the network other than through those interfaces. So I think that it's unlikely that the root cause lies there (although perhaps there's something I'm not thinking of), since I'd expect to see any bugs to show up when the underlying transport is TCP as well.
I think the first thing I'd try is to dump all the bytes passing through the socket on both sides of the connection, to see if they're making it through as expected, and if not, what the variation is.

I also experienced this issue. After digging into the problem, I figured out that the problem is not the corruption of the reader buffer but the mismatch between the length of buffer actually copied and the value returned by the Read function.
The Read for the unix domain socket ultimately calls the Read method of FD in go/src/internal/poll/fd_windows.go, which calls system call WSARecv through execIO with o.qty pointer for bytes transfered parameter.
	n, err = execIO(o, func(o *operation) error {
		return syscall.WSARecv(o.fd.Sysfd, &o.buf, 1, &o.qty, &o.flags, &o.o, nil)
	})

https://github.com/golang/go/blob/a65a2bbd8e58cd77dbff8a751dbd6079424beb05/src/internal/poll/fd_windows.go#L437
The callback for the WSARecv is handled by netpoll using GetQueuedCompletionStatusEx in go/src/runtime/netpoll_windows.go.
https://github.com/golang/go/blob/a65a2bbd8e58cd77dbff8a751dbd6079424beb05/src/runtime/netpoll_windows.go#L120
And, at the handlecompletion function op.qty is written as the qty returned by WSAGetOverlappedResult.
func handlecompletion(toRun *gList, op *net_op, errno int32, qty uint32) int32 {
mode := op.mode
if mode != 'r' && mode != 'w' {
println("runtime: GetQueuedCompletionStatusEx returned invalid mode=", mode)
throw("runtime: netpoll failed")
}
op.errno = errno
op.qty = qty  // <- here
return netpollready(toRun, op.pd, mode)
}
The issue comes from the fact that when the execIO awakes from the waiting, the o.qty is somewhat changed to the different value from what was set in the handlecompletion.
To prove the theory, I added additional value op.pqty to keep the original value of op.qty in operation and net_op structure, and changed handlecompletion as follows.
func handlecompletion(toRun *gList, op *net_op, errno int32, qty uint32) int32 {
mode := op.mode
if mode != 'r' && mode != 'w' {
println("runtime: GetQueuedCompletionStatusEx returned invalid mode=", mode)
throw("runtime: netpoll failed")
}
op.errno = errno
op.qty = qty  //
op.pqty = op.qty // <- added
return netpollready(toRun, op.pd, mode)
}
And I checked the o.pqty and o.qty after execIO was executed as follows.
	n, err = execIO(o, func(o *operation) error {
		return syscall.WSARecv(o.fd.Sysfd, &o.buf, 1, &o.qty, &o.flags, &o.o, nil)
	})

	// added lines
	if (o.qty != o.pqty) {
		println("unexpected bytes transferred o.qty: ", o.qty,
			", o.pqty: ", o.pqty, ", n: ", n)
	}
	// added

	if race.Enabled {
		race.Acquire(unsafe.Pointer(&ioSync))
	}

As a result, I got the proof of the difference between two values.
unexpected bytes transferred o.qty:  1082 , o.pqty:  26 , n:  1082
I'm not the 100% sure about when the overwriting happens. But I'm suspicious about the way that passes the o.qty as the parameter of the WSARecv, which may lead to the possible overwritting the value set in the handlecompletion.
MSDN suggests that the bytesTransfered parameter of the WSARecv has not to be used or refered when the overlapped is used. In fact, WSARecv do sometimes set the value in unexpected way.
I believe passing the o.qty as the parameter of WSARecv with no use and using the same variable pointer for the result of overlapped result is not a good idea.
My workaround of passing the nil for the bytesTrasnfered parameter for the WSARecv seems to work.
	n, err = execIO(o, func(o *operation) error {
		return syscall.WSARecv(o.fd.Sysfd, &o.buf, 1, nil, &o.flags, &o.o, nil)
	})

But, in order to pinpoint the root cause of this issue, further investigation might be needed.

cc @golang/runtime @golang/windows

@seankhliao,
You've added WaitingForInfo label. If there's any information I need to provide, please let me know.
And, I noticed a difference in the FileCompletionNotificationModes used between TCP and Unix domain socket while running various tests, referring to @abarelk's comment. TCP utilizes syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS, whereas Unix domain socket do not. Therefore, after adding 'unix' as follows, it's functioning without the aforementioned issue. In this test, I did not include passing nil instead of &o.qty as tested by @abarelk.
// C:\Program Files\Go\src\internal\poll\fd_windows.go 	if pollable && useSetFileCompletionNotificationModes { 		// We do not use events, so we can skip them always. 		flags := uint8(syscall.FILE_SKIP_SET_EVENT_ON_HANDLE) 		switch net { 		case "tcp", "tcp4", "tcp6", 			"udp", "udp4", "udp6", 			"unix": 			flags |= syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS 		} 		err := syscall.SetFileCompletionNotificationModes(fd.Sysfd, flags) 		if err == nil && flags&syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS != 0 { 			fd.skipSyncNotif = true 		} 	}
Is there any reason why Unix domain socket do not use syscall.FILE_SKIP_COMPLETION_PORT_ON_SUCCESS?


Update register sparse model api

Description
We have support register sparse models as pretrain models in 2.12 (ref PR). Update the documentation to sync the info.
Issues Resolved
List any issues this PR will resolve, e.g. Closes [...].
Checklist

[ ] By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license and subject to the Developers Certificate of Origin.
For more information on following Developer Certificate of Origin and signing off your commits, please check here.

This PR should be backported to 2.12 and 2.x branch.


Separate backend API server from frontend SSR server

Once again, thanks for the fantastic boilerplate!  I've already integrated your Hails project locally (kind of a must if I want control over your abstraction, sorry :( ) and updated most packages to newer versions.
I think the most common production situation is a clear separation between frontend and backend servers.  That is, I don't need to shutdown the backend API to make tweaks to my frontend (and it's own Hapi SSR server).  I know you're doing something with Hails which already encapsulates the API server from the SSR part of the server, but I think being able to run them on different servers (physically, API on server 1, SSR server on 2) is better aimed at "production-ready".
I'll have to figure this out myself, any pointers would be welcome, I'll eventually get it :)
Thanks again!

Hi
What is most important thing to me, was ease of development. When I made multiple projects simaltaneously sometimes, I needed to open 10 and more terminals for only for the projects shipped with servers, clients with a proxy, debuggers and more.
To accomplish what you said, the project will have to provide something about separation. In my opinion for now, you can simply create two projects, one for the api and one for the client. And either CORS or an internal proxy will find a way to communicate with each other.
I'll keep thinking about it. Thank you for your feedback.


cargo build failed

Bug Report
Version
latest code in github master
Platform
Darwin xxx-mac.local 19.3.0 Darwin Kernel Version 19.3.0: Thu Jan  9 20:58:23 PST 2020; root:xnu-6153.81.5~1/RELEASE_X86_64 x86_64
Crates
Description
On my mac:

git clone https://github.com/hyperium/tonic.git
cd tonic
cargo build

output:
error[E0034]: multiple applicable items in scope
help: disambiguate the method call for candidate #1
|
418 |                 return tower_service::Service::poll_ready(&mut self.balance, cx);
|                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: disambiguate the method call for candidate #2
|
418 |                 return tower_make::make_service::MakeService::poll_ready(&mut self.balance, cx);
|                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: could not compile tower-balance.

This is a rustc bug, I would recommend using stable or updating to a newer nightly. If its still an issue on a newer nightly I would open an issue in rustc. Since, this is unrelated to tonic going to close this, feel free to reopen if you have any more questions.


Name regex doesn't match hyphen, dots and quote #41

Fixes #41
Update regex to match any name containing Unicode characters and names like Aravinda d'Silva,  Some Wierd Jolie-Pitt etc.,

Wait! let me un-mess this PR before you can do anything! Sorry!! my bad that I forgot I had messed with my fork :(


SpaceEye & NDVI Timelapse workflow creates rasters and lapses for future dates

My time range is from March 13 to April 12 (today is April 13), yet I get output for April 15th and 20th, 2023.
time_range = (datetime(2023, 3, 13), datetime(2023, 4, 12))

This this export of the jupyter notebook:
https://github.com/microsoft/farmvibes-ai/files/11227038/timelapse_visualization-Thomas40.pdf

Hi, @richstep. Great Scott! Seems like your FarmVibes instance is hitting 88 mph.
Jokes aside, thanks for raising this.
SpaceEye works with a window of 48 days by default (the parameter duration of the SpaceEye workflow, whose documentation can be seen by running client.document_workflow("data_ingestion/spaceeye/spaceeye_interpolation")).
If your time range is smaller than that, we add a padding to fill the whole temporal window. In your scenario, your time range has 33 days (March 13th to April 14th), so the difference (15 days) is added as padding. SpaceEye will generate a cloud-free image for each day of the window (with a damped interpolation approach, in the particular case of the workflow used in the timelapse notebook).
That is why you are seeing rasters outside your input time range. If you check the number of SpaceEye or NDVI outputs, there will be 48 of them. You will also see a number of rasters that are before your time range, which were not downloaded, but were instead generated by SpaceEye.
A few possibilities to consider:

Ignore the rasters outside your input time range.

Increase the time range to consider days before March 13th. Adding more days to fill the whole window will potentially improve the overall quality of the output rasters, as more data will be available for SpaceEye.

Decrease the duration value when running the workflow. This, in turn, means SpaceEye will have less available input data to generate the pixels originally occluded by clouds, which may decrease the quality of the results. This can be done directly altering the yaml file of the custom workflow, for example, if you want to change duration to 30 days:

name: spaceeye_ndvi
sources:
  user_input:
    - spaceeye.user_input
sinks:
  ndvi: ndvi.index_raster
  spaceeye_raster: spaceeye.raster
parameters:
  pc_key:
tasks:
  spaceeye:
    workflow: data_ingestion/spaceeye/spaceeye_interpolation
    parameters:
      pc_key: "@from(pc_key)"
      duration: 30
  ndvi:
    workflow: data_processing/index/index
    parameters:
      index: ndvi
edges:
  - origin: spaceeye.raster
    destination:
      - ndvi.raster

Hi @rafaspadilha, LOL and thanks for the detailed response! That makes a lot of sense. I ran it for 48 days and I got what you described. That leads me to another question, why didn't the clouds get removed for March 22 and April 1, 2023? Is this expected behavior sometimes?
# Define our workflow inputs.
geom = shpg.Point(-120.090833,36.574722).buffer(.01, cap_style=3)
time_range = (datetime(2023, 2, 27), datetime(2023, 4, 16))

https://user-images.githubusercontent.com/733563/232597703-895b08e4-6748-4f22-952f-55489944d671.mp4

Hi @richstep. Remaining clouds in the output are usually caused by a failure in the cloud detection step. We rely on cloud masks generated by separate machine learning models and, while they perform pretty well, they will occasionally miss some clouds. If a region is not marked as cloudy, we won't inpaint it, and the clouds will also be present in the output. If you are curious, you can check the cloud masks by running the data_ingestion/sentinel2/preprocess_s2_improved_masks workflow using the same inputs (this should run really fast because all the outputs will be fetched from the cache). More information is also available at the Sentinel/SpaceEye notebook.

Closing this issue for now. @richstep, feel free to reopen if you have more questions.


[needed example] streaming processing

An example like the following would be very valuable:
Fifty 1GB .csv files (each with their own copy of the headers on the first row need to be concatenated
What is the fastest, most reliable way? --- don't want to wait any longer than necessary, and need to guarantee never oom.
Question: Is it worth thinking about when a second copy wont fit on the disk? Or do we assume we can always have the pre-concat copies together with the big output? (seems safe)
Bonus points: some column in the middle is mm/dd/yyyy, convert to yyyy-mm-dd during the processing.
Extra bonus points: two arbitrary columns are (1) mm/dd (with year expressed in filename) and (2) hh:mm:ss.nnn (with TZ expressed in filename) --- convert to something TMD will make into an #inst automatically.
Question: Preserve pre-processed columns, or no?

https://cnuernber.github.io/charred/charred.bulk.html
Another operation in this space would be split-csv - left as an exercise to the reader for now :-)


kxkn - Apple m1 chip static build with signed or notarized app ?

Currently, when we run the darwin-arm64 binary on other Apple m1 it shows the below error.
“kn” can’t be opened because Apple cannot check it for malicious software.

This software needs to be updated. Contact the developer for more information.

If you want to run unsinged binary you need to follow this title steps in below link - "If you want to open an app that hasn’t been notarized or is from an unidentified developer"
More - https://support.apple.com/en-in/HT202491

Or You can build your own binary.

git clone https://github.com/koolwithk/kx-kn-rust.git
cd kx

## for statically linked binary
cargo build --target=aarch64-apple-darwin --release

## after the build binary will be in below directory
kx/target/release/aarch64-apple-darwin


Errors with the testing codes of "Quick Start"

Hi,
Thank you for sharing the MDRNN code. I am new to tensorflow and want to use MDRNN for my projects. I just downloaded the code and was running the testing code of Quick Start section. I tested the code in Anaconda and Spyder. First I got some errors with the simplest use:
rnn = MDRNN(units=16, input_shape=(5, 4, 10), activation='tanh', return_sequences=True)
output = rnn(np.zeros((1, 5, 4, 10)))

Later I found adding tf.compat.v1.enable_eager_execution() at the beginning makes it work fine.
However, when I was running
model = tf.keras.Sequential()
model.add(MDRNN(units=16, input_shape=(2, 3, 6), activation='tanh'))

I got long error information. I am not sure which parts are important and so pasted the most of the information below:
WARNING:tensorflow:Entity <bound method BaseMDRNN.call of <mdrnn._layers.simple_mdrnn.MDRNN object at 0x00000225EBAB4B08>> could not be transformed and will be executed as-is. Please report this to the AutgoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: converting <bound method BaseMDRNN.call of <mdrnn._layers.simple_mdrnn.MDRNN object at 0x00000225EBAB4B08>>: AttributeError: module 'gast' has no attribute 'Str'

Traceback (most recent call last):
  File "D:\multi-directional-mdrnn-master\trial0_quick_start.py", line 24, in <module>
    model.add(MDRNN(units=16, input_shape=(2, 3, 6), activation='tanh'))

  File "C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\training\tracking\base.py", line 457, in _method_wrapper
    result = method(self, *args, **kwargs)

  File "C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\keras\engine\sequential.py", line 174, in add
    layer(x)

  File "C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\keras\engine\base_layer.py", line 629, in __call__
    outputs = call_fn(inputs, *args, **kwargs)

  File "C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\autograph\impl\api.py", line 149, in wrapper
    raise e.ag_error_metadata.to_exception(type(e))

TypeError: in converted code:

    D:\multi-directional-mdrnn-master\mdrnn\_layers\simple_mdrnn.py:95 call
        outputs = self._make_graph(inp, initial_state)
    D:\multi-directional-mdrnn-master\mdrnn\_layers\simple_mdrnn.py:117 _make_graph
        outputs = self._create_grid(grid_shape=grid_shape, tensor_shape=tensor_shape)
    D:\multi-directional-mdrnn-master\mdrnn\_layers\simple_mdrnn.py:61 _create_grid
        return TensorGrid(grid_shape=grid_shape, tensor_shape=tensor_shape)
    D:\multi-directional-mdrnn-master\mdrnn\_util\grids.py:80 __init__
        zeros_tensor = tf.zeros(shape=tensor_shape)
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\ops\array_ops.py:1880 zeros
        shape = ops.convert_to_tensor(shape, dtype=dtypes.int32)
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\framework\ops.py:1087 convert_to_tensor
        return convert_to_tensor_v2(value, dtype, preferred_dtype, name)
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\framework\ops.py:1145 convert_to_tensor_v2
        as_ref=False)
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\framework\ops.py:1224 internal_convert_to_tensor
        ret = conversion_func(value, dtype=dtype, name=name, as_ref=as_ref)
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\framework\constant_op.py:305 _constant_tensor_conversion_function
        return constant(v, dtype=dtype, name=name)
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\framework\constant_op.py:246 constant
        allow_broadcast=True)
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\framework\constant_op.py:284 _constant_impl
        allow_broadcast=allow_broadcast))
    C:\Users\xsun403\Anaconda3\envs\tf2\lib\site-packages\tensorflow\python\framework\tensor_util.py:467 make_tensor_proto
        nparray = np.array(values, dtype=np_dt)

    TypeError: __int__ returned non-int (type NoneType)

Sorry for the long post, and I appreciate all the help!
Xiaohao

I think these errors are because I installed TensorFlow 1.x, I thought it was TF 2.x though. I re-installed TensorFlow using pip and the version is now shown as 2.8.0 and the testing codes work fine now!


Create tf-resnet.yaml

Created a simple manifest to deploy tensorflow server with resnet model

In order to test it we have to prepare the client env first:

Install python3 and pip
Install tfx and grpcio
git clone https://github.com/tensorflow/serving
cd serving

python \
  tensorflow_serving/example/resnet_client_grpc.py \
  --server=<YOUR LB IP>:8500

Added mxnet and mnist (have to check if mnist is okay and review samples)


canvas.clipPath(region.path, Region.Op. REPLACE); not allowed higher than api26

we can only see one image on screen

we can only see one image on screen


Publish to templates.accordproject.org

Create a build process that publishes the templates to templates.accordproject.org.

[x] Run unit tests for each template

[x] We can build archives for each template (which will resolve all the external dependencies, so they load fast and are validated).

[ ] We can name each archive using the fqn of the template model, plus the version number from package.json.

[ ] Save all versions of a valid template to cheap and reliable object/document storage

[x] Generate an HTML overview page for each archive in object store, based on the README, package.json (compatible Cicero version) model info etc (edited)

[x] We can link from the template HTML page to the model HTML page for external dependencies.

[x] We can also publish an index.json file with metadata so that tools can quickly find templates based on metadata. (edited)

[x] Add Template.fromArchive(url) to load a template from a URL

Quite a lot of this seems to be done (I checked those I believe are -- may need to be reviewed). A couple of things open:

I don't believe we use the FQN for naming archives
We don't have a dedicated storage, do we really need one?

Will close. We can open new issues as necessary.


Update indent.guide to indentGuide

Fleet has changed their naming for the indent guide.
From indent.guide -> indentGuide.
Source: Default Fleet Purple theme file

Thanks for the contribution!