.circleci/config.yml

@@ -1,40 +0,0 @@
-shared_configs:
-  simple_job_steps: &simple_job_steps
-    - checkout
-    - run:
-        name: Run tests
-        command: |
-          make test
-
-# Use the latest 2.1 version of CircleCI pipeline process engine. See: https://circleci.com/docs/2.0/configuration-reference
-version: 2.1
-jobs:
-  build-1-23:
-    working_directory: ~/repo
-    docker:
-      - image: cimg/go:1.23
-    steps: *simple_job_steps
-
-  build-1-24:
-    working_directory: ~/repo
-    docker:
-      - image: cimg/go:1.24
-    steps: *simple_job_steps
-
-  build-1-25:
-    working_directory: ~/repo
-    docker:
-      - image: cimg/go:1.25
-    steps:
-      - checkout
-      - run:
-          name: Run tests and linters
-          command: |
-            make ci
-
-workflows:
-  pr-build-test:
-    jobs:
-      - build-1-23
-      - build-1-24
-      - build-1-25

.github/dependabot.yml

@@ -1,7 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "gomod"
-    directory: "/"
-    # Check for updates once a week
-    schedule:
-      interval: "weekly"

.github/workflows/codesee-arch-diagram.yml

@@ -1,22 +0,0 @@
-# This workflow was added by CodeSee. Learn more at https://codesee.io/
-# This is v2.0 of this workflow file
-on:
-  push:
-    branches:
-      - master
-  pull_request_target:
-    types: [opened, synchronize, reopened]
-
-name: CodeSee
-
-permissions: read-all
-
-jobs:
-  codesee:
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    name: Analyze the repo with CodeSee
-    steps:
-      - uses: Codesee-io/codesee-action@v2
-        with:
-          codesee-token: ${{ secrets.CODESEE_ARCH_DIAG_API_TOKEN }}

.gitignore

@@ -1,5 +1 @@
 dist/
-.idea/
-VERSION
-.tmp/
-*.snap

.goreleaser.yml

@@ -8,56 +8,17 @@ builds:
     goarch:
       - amd64
       - 386
-      - arm
-      - arm64
-      - s390x
-      - ppc64le
-    goarm:
-      - 5
-      - 6
-      - 7
-    ignore:
-      - goos: darwin
-        goarch: 386
-      - goos: windows
-        goarch: arm64
-      - goos: darwin
-        goarch: arm
-      - goos: windows
-        goarch: arm
-      - goos: darwin
-        goarch: s390x
-      - goos: windows
-        goarch: s390x
-      - goos: darwin
-        goarch: ppc64le
-      - goos: windows
-        goarch: ppc64le
     ldflags:
       - -s -w -X main.version=v{{.Version}}
 
-archives:
+archive:
-  - format: tar.gz
+  format: tar.gz
-    name_template: >-
-      {{ .Binary }}_{{ .Version }}_
-      {{- if eq .Os "darwin" }}osx{{ else }}{{ .Os }}{{ end }}_
-      {{- if eq .Arch "amd64" }}x86_64
-      {{- else if eq .Arch "386" }}x86_32
-      {{- else }}{{ .Arch }}{{ end }}
-      {{- with .Arm }}v{{ . }}{{ end }}{{ with .Mips }}_{{ . }}{{ end }}{{ if not (eq .Amd64 "v1") }}{{ .Amd64 }}{{ end }}
   format_overrides:
     - goos: windows
       format: zip
+  replacements:
+    amd64: x86_64
+    386: x86_32
+    darwin: osx
   files:
     - LICENSE
-
-nfpms:
-  - vendor: Fullstory
-    homepage: https://github.com/fullstorydev/grpcurl/
-    maintainer: Engineering at Fullstory  <fixme@fixme>
-    description: 'Like cURL, but for gRPC: Command-line tool for interacting with gRPC servers'
-    license: MIT
-    id: nfpms
-    formats:
-      - deb
-      - rpm

.travis.yml

@@ -0,0 +1,16 @@
+language: go
+sudo: false
+
+matrix:
+  include:
+    - go: "1.9"
+    - go: "1.10"
+      env: VET=1
+    - go: "1.11"
+      env: GO111MODULE=off
+    - go: "1.11"
+      env: GO111MODULE=on
+    - go: tip
+
+script:
+  - if [[ "$VET" = 1 ]]; then make; else make deps test; fi

Dockerfile

@@ -1,36 +0,0 @@
-FROM golang:1.25-alpine AS builder
-LABEL maintainer="Fullstory Engineering"
-
-# create non-privileged group and user
-RUN addgroup -S grpcurl && adduser -S grpcurl -G grpcurl
-
-WORKDIR /tmp/fullstorydev/grpcurl
-# copy just the files/sources we need to build grpcurl
-COPY VERSION *.go go.* /tmp/fullstorydev/grpcurl/
-COPY cmd /tmp/fullstorydev/grpcurl/cmd
-# and build a completely static binary (so we can use
-# scratch as basis for the final image)
-ENV CGO_ENABLED=0
-ENV GO111MODULE=on
-RUN go build -o /grpcurl \
-    -ldflags "-w -extldflags \"-static\" -X \"main.version=$(cat VERSION)\"" \
-    ./cmd/grpcurl
-
-FROM alpine:3 AS alpine
-WORKDIR /
-COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
-COPY --from=builder /etc/passwd /etc/passwd
-COPY --from=builder /grpcurl /bin/grpcurl
-USER grpcurl
-
-ENTRYPOINT ["/bin/grpcurl"]
-
-# New FROM so we have a nice'n'tiny image
-FROM scratch
-WORKDIR /
-COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
-COPY --from=builder /etc/passwd /etc/passwd
-COPY --from=builder /grpcurl /bin/grpcurl
-USER grpcurl
-
-ENTRYPOINT ["/bin/grpcurl"]

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Fullstory, Inc
+Copyright (c) 2017 FullStory, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,29 +1,20 @@
 dev_build_version=$(shell git describe --tags --always --dirty)
 
-export PATH := $(shell pwd)/.tmp/protoc/bin:$(PATH)
-export PROTOC_VERSION := 22.0
-# Disable CGO for improved compatibility across distros
-export CGO_ENABLED=0
-export GOFLAGS=-trimpath
-export GOWORK=off
-
 # TODO: run golint and errcheck, but only to catch *new* violations and
 # decide whether to change code or not (e.g. we need to be able to whitelist
 # violations already in the code). They can be useful to catch errors, but
 # they are just too noisy to be a requirement for a CI -- we don't even *want*
 # to fix some of the things they consider to be violations.
 .PHONY: ci
-ci: deps checkgofmt checkgenerate vet staticcheck ineffassign predeclared test
+ci: deps checkgofmt vet staticcheck unused ineffassign predeclared test
 
 .PHONY: deps
 deps:
 	go get -d -v -t ./...
-	go mod tidy
 
 .PHONY: updatedeps
 updatedeps:
 	go get -d -v -t -u -f ./...
-	go mod tidy
 
 .PHONY: install
 install:
@@ -31,30 +22,8 @@ install:
 
 .PHONY: release
 release:
-	@go install github.com/goreleaser/goreleaser@v1.21.0
+	@GO111MODULE=off go get github.com/goreleaser/goreleaser
-	goreleaser release --clean
+	goreleaser --rm-dist
-
-.PHONY: docker
-docker:
-	@echo $(dev_build_version) > VERSION
-	docker build -t fullstorydev/grpcurl:$(dev_build_version) .
-	@rm VERSION
-
-.PHONY: generate
-generate: .tmp/protoc/bin/protoc
-	@go install google.golang.org/protobuf/cmd/protoc-gen-go@a709e31e5d12
-	@go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.1.0
-	@go install github.com/jhump/protoreflect/desc/sourceinfo/cmd/protoc-gen-gosrcinfo@v1.14.1
-	go generate ./...
-	go mod tidy
-
-.PHONY: checkgenerate
-checkgenerate: generate
-	git status --porcelain -- '**/*.go'
-	@if [ -n "$$(git status --porcelain -- '**/*.go')" ]; then \
-		git diff -- '**/*.go'; \
-		exit 1; \
-	fi
 
 .PHONY: checkgofmt
 checkgofmt:
@@ -67,37 +36,46 @@ checkgofmt:
 vet:
 	go vet ./...
 
+# TODO: remove the ignored check; need it for now because it
+# is complaining about a deprecated comment added to grpc,
+# but it's not yet released. Once the new (non-deprecated)
+# API is included in a release, we can move to that new
+# version and fix the call site to no longer use deprecated
+# method.
+# This all works fine with Go modules, but without modules,
+# CI is just getting latest master for dependencies like grpc.
 .PHONY: staticcheck
 staticcheck:
-	@go install honnef.co/go/tools/cmd/staticcheck@2025.1.1
+	@go get honnef.co/go/tools/cmd/staticcheck
-	staticcheck -checks "inherit,-SA1019" ./...
+	staticcheck -ignore github.com/fullstorydev/grpcurl/tls_settings_test.go:SA1019 ./...
+
+.PHONY: unused
+unused:
+	@go get honnef.co/go/tools/cmd/unused
+	unused ./...
 
 .PHONY: ineffassign
 ineffassign:
-	@go install github.com/gordonklaus/ineffassign@7953dde2c7bf
+	@go get github.com/gordonklaus/ineffassign
 	ineffassign .
 
 .PHONY: predeclared
 predeclared:
-	@go install github.com/nishanths/predeclared@51e8c974458a0f93dc03fe356f91ae1a6d791e6f
+	@go get github.com/nishanths/predeclared
-	predeclared ./...
+	predeclared .
 
 # Intentionally omitted from CI, but target here for ad-hoc reports.
 .PHONY: golint
 golint:
-	@go install golang.org/x/lint/golint@v0.0.0-20210508222113-6edffad5e616
+	@go get golang.org/x/lint/golint
 	golint -min_confidence 0.9 -set_exit_status ./...
 
 # Intentionally omitted from CI, but target here for ad-hoc reports.
 .PHONY: errcheck
 errcheck:
-	@go install github.com/kisielk/errcheck@v1.2.0
+	@go get github.com/kisielk/errcheck
 	errcheck ./...
 
 .PHONY: test
-test: deps
+test:
-	CGO_ENABLED=1 go test -race ./...
+	go test -race ./...
-
-.tmp/protoc/bin/protoc: ./Makefile ./download_protoc.sh
-	./download_protoc.sh
-

README.md

@@ -1,7 +1,6 @@
 # gRPCurl
-[![Build Status](https://circleci.com/gh/fullstorydev/grpcurl/tree/master.svg?style=svg)](https://circleci.com/gh/fullstorydev/grpcurl/tree/master)
+[![Build Status](https://travis-ci.org/fullstorydev/grpcurl.svg?branch=master)](https://travis-ci.org/fullstorydev/grpcurl/branches)
 [![Go Report Card](https://goreportcard.com/badge/github.com/fullstorydev/grpcurl)](https://goreportcard.com/report/github.com/fullstorydev/grpcurl)
-[![Snap Release Status](https://snapcraft.io/grpcurl/badge.svg)](https://snapcraft.io/grpcurl)
 
 `grpcurl` is a command-line tool that lets you interact with gRPC servers. It's
 basically `curl` for gRPC servers.
@@ -15,7 +14,7 @@ This program accepts messages using JSON encoding, which is much more friendly f
 humans and scripts.
 
 With this tool you can also browse the schema for gRPC services, either by querying
-a server that supports [server reflection](https://github.com/grpc/grpc/blob/master/src/proto/grpc/reflection/v1/reflection.proto),
+a server that supports [server reflection](https://github.com/grpc/grpc/blob/master/src/proto/grpc/reflection/v1alpha/reflection.proto),
 by reading proto source files, or by loading in compiled "protoset" files (files that contain
 encoded file [descriptor protos](https://github.com/google/protobuf/blob/master/src/google/protobuf/descriptor.proto)).
 In fact, the way the tool transforms JSON request data into a binary encoded protobuf
@@ -36,9 +35,9 @@ See also the [`grpcurl` talk at GopherCon 2018](https://www.youtube.com/watch?v=
 operate bi-directional streaming methods interactively by running `grpcurl` from an
 interactive terminal and using stdin as the request body!
 
-`grpcurl` supports both secure/TLS servers _and_ plain-text servers (i.e. no TLS) and has
+`grpcurl` supports both plain-text and TLS servers and has numerous options for TLS
-numerous options for TLS configuration. It also supports mutual TLS, where the client is
+configuration. It also supports mutual TLS, where the client is required to present a
-required to present a client certificate.
+client certificate.
 
 As mentioned above, `grpcurl` works seamlessly if the server supports the reflection
 service. If not, you can supply the `.proto` source files or you can supply protoset
@@ -50,63 +49,27 @@ files (containing compiled descriptors, produced by `protoc`) to `grpcurl`.
 
 Download the binary from the [releases](https://github.com/fullstorydev/grpcurl/releases) page.
 
-### Homebrew (macOS)
-
-On macOS, `grpcurl` is available via Homebrew:
-```shell
-brew install grpcurl
-```
-
-### Docker
-
-For platforms that support Docker, you can download an image that lets you run `grpcurl`:
-```shell
-# Download image
-docker pull fullstorydev/grpcurl:latest
-# Run the tool
-docker run fullstorydev/grpcurl api.grpc.me:443 list
-```
-Note that there are some pitfalls when using docker:
-- If you need to interact with a server listening on the host's loopback network, you must specify the host as `host.docker.internal` instead of `localhost` (for Mac or Windows) _OR_ have the container use the host network with `-network="host"` (Linux only).
-- If you need to provide proto source files or descriptor sets, you must mount the folder containing the files as a volume (`-v $(pwd):/protos`) and adjust the import paths to container paths accordingly.
-- If you want to provide the request message via stdin, using the `-d @` option, you need to use the `-i` flag on the docker command.
-
-### Other Packages
-
-There are numerous other ways to install `grpcurl`, thanks to support from third parties that
-have created recipes/packages for it. These include other ways to install `grpcurl` on a variety
-of environments, including Windows and myriad Linux distributions.
-
-You can see more details and the full list of other packages for `grpcurl` at _repology.org_:
-https://repology.org/project/grpcurl/information
-
-### Snap
-
-You can install `grpcurl` using the snap package:
-
-`snap install grpcurl`
-
 ### From Source
-If you already have the [Go SDK](https://golang.org/doc/install) installed, you can use the `go`
+You can use the `go` tool to install `grpcurl`:
-tool to install `grpcurl`:
 ```shell
-go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest
+go get github.com/fullstorydev/grpcurl
+go install github.com/fullstorydev/grpcurl/cmd/grpcurl
 ```
 
 This installs the command into the `bin` sub-folder of wherever your `$GOPATH`
-environment variable points. (If you have no `GOPATH` environment variable set,
+environment variable points. If this directory is already in your `$PATH`, then
-the default install location is `$HOME/go/bin`). If this directory is already in
+you should be good to go.
-your `$PATH`, then you should be good to go.
 
 If you have already pulled down this repo to a location that is not in your
 `$GOPATH` and want to build from the sources, you can `cd` into the repo and then
 run `make install`.
 
-If you encounter compile errors and are using a version of the Go SDK older than 1.13,
+If you encounter compile errors, you could have out-dated versions of `grpcurl`'s
-you could have out-dated versions of `grpcurl`'s dependencies. You can update the
+dependencies. You can update the dependencies by running `make updatedeps`. You can
-dependencies by running `make updatedeps`. Or, if you are using Go 1.11 or 1.12, you
+also use [`vgo`](https://github.com/golang/vgo) to install, which will use the right
-can add `GO111MODULE=on` as a prefix to the commands above, which will also build using
+versions of dependencies. Or, if you are using Go 1.11, you can add `GO111MODULE=on`
-the right versions of dependencies (vs. whatever you may already have in your `GOPATH`).
+as a prefix to the commands above, which will also build using the right versions of
+dependencies (vs. whatever you may already in your `GOPATH`).
 
 ## Usage
 The usage doc for the tool explains the numerous options:
@@ -123,9 +86,6 @@ that requires no client certs and supports server reflection is the simplest thi
 do with `grpcurl`. This minimal invocation sends an empty request body:
 ```shell
 grpcurl grpc.server.com:443 my.custom.server.Service/Method
-
-# no TLS
-grpcurl -plaintext grpc.server.com:80 my.custom.server.Service/Method
 ```
 
 To send a non-empty request, use the `-d` argument. Note that all arguments must come
@@ -142,7 +102,7 @@ If you want to include `grpcurl` in a command pipeline, such as when using `jq`
 create a request body, you can use `-d @`, which tells `grpcurl` to read the actual
 request body from stdin:
 ```shell
-grpcurl -d @ grpc.server.com:443 my.custom.server.Service/Method <<EOM
+grpcurl -d @ grpc.server.com:443 my.custom.server.Service/Method <<<EOM
 {
   "id": 1234,
   "tags": [
@@ -152,13 +112,6 @@ grpcurl -d @ grpc.server.com:443 my.custom.server.Service/Method <<EOM
 }
 EOM
 ```
-### Adding Headers/Metadata to Request
-Adding of headers / metadata to a rpc request is possible via the `-H name:value` command line option. Multiple headers can be added in a similar fashion.
-Example :
-```shell
-grpcurl -H header1:value1 -H header2:value2 -d '{"id": 1234, "tags": ["foo","bar"]}' grpc.server.com:443 my.custom.server.Service/Method
-```
-For more usage guide, check out the help docs via `grpcurl -help`
 
 ### Listing Services
 To list all services exposed by a server, use the "list" verb. When using `.proto` source
@@ -173,13 +126,6 @@ grpcurl -protoset my-protos.bin list
 
 # Using proto sources
 grpcurl -import-path ../protos -proto my-stuff.proto list
-
-# Export proto files (use -proto-out-dir to specify the output directory)
-grpcurl -plaintext -proto-out-dir "out_protos" "localhost:8787" describe my.custom.server.Service
-
-# Export protoset file (use -protoset-out to specify the output file)
-grpcurl -plaintext -protoset-out "out.protoset" "localhost:8787" describe my.custom.server.Service
-
 ```
 
 The "list" verb also lets you see all methods in a particular service:
@@ -213,7 +159,7 @@ are needed to use them.
 
 ### Server Reflection
 
-Without any additional command-line flags, `grpcurl` will try to use [server reflection](https://github.com/grpc/grpc/blob/master/src/proto/grpc/reflection/v1/reflection.proto).
+Without any additional command-line flags, `grpcurl` will try to use [server reflection](https://github.com/grpc/grpc/blob/master/src/proto/grpc/reflection/v1alpha/reflection.proto).
 
 Examples for how to set up server reflection can be found [here](https://github.com/grpc/grpc/blob/master/doc/server-reflection.md#known-implementations).
 

cmd/grpcurl/go1_10.go

@@ -0,0 +1,9 @@
+// +build go1.10
+
+package main
+
+func indent() string {
+	// In Go 1.10 and up, the flag package automatically
+	// adds the right indentation.
+	return ""
+}

cmd/grpcurl/go1_9.go

@@ -0,0 +1,9 @@
+// +build !go1.10
+
+package main
+
+func indent() string {
+	// In Go 1.9 and older, we need to add indentation
+	// after newlines in the flag doc strings.
+	return "    \t"
+}

cmd/grpcurl/grpcurl.go

@@ -4,112 +4,67 @@
 package main
 
 import (
-	"context"
 	"flag"
 	"fmt"
 	"io"
-	"math"
 	"os"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
 
-	"github.com/jhump/protoreflect/desc" //lint:ignore SA1019 required to use APIs in other grpcurl package
+	"github.com/fullstorydev/grpcurl"
+	descpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	"github.com/jhump/protoreflect/desc"
 	"github.com/jhump/protoreflect/grpcreflect"
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/credentials/alts"
 	"google.golang.org/grpc/keepalive"
 	"google.golang.org/grpc/metadata"
-	"google.golang.org/grpc/status"
+	reflectpb "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
-	"google.golang.org/protobuf/types/descriptorpb"
-
-	// Register gzip compressor so compressed responses will work
-	_ "google.golang.org/grpc/encoding/gzip"
-	// Register xds so xds and xds-experimental resolver schemes work
-	_ "google.golang.org/grpc/xds"
-
-	"github.com/fullstorydev/grpcurl"
 )
 
-// To avoid confusion between program error codes and the gRPC response
+var version = "dev build <no version set>"
-// status codes 'Cancelled' and 'Unknown', 1 and 2 respectively,
-// the response status codes emitted use an offset of 64
-const statusCodeOffset = 64
-
-const noVersion = "dev build <no version set>"
-
-var version = noVersion
 
 var (
 	exit = os.Exit
 
 	isUnixSocket func() bool // nil when run on non-unix platform
 
-	flags = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+	help = flag.Bool("help", false, prettify(`
-
-	help = flags.Bool("help", false, prettify(`
 		Print usage instructions and exit.`))
-	printVersion = flags.Bool("version", false, prettify(`
+	printVersion = flag.Bool("version", false, prettify(`
 		Print version.`))
-
+	plaintext = flag.Bool("plaintext", false, prettify(`
-	plaintext = flags.Bool("plaintext", false, prettify(`
 		Use plain-text HTTP/2 when connecting to server (no TLS).`))
-	insecure = flags.Bool("insecure", false, prettify(`
+	insecure = flag.Bool("insecure", false, prettify(`
 		Skip server certificate and domain verification. (NOT SECURE!) Not
 		valid with -plaintext option.`))
-
+	cacert = flag.String("cacert", "", prettify(`
-	// TLS Options
-	cacert = flags.String("cacert", "", prettify(`
 		File containing trusted root certificates for verifying the server.
 		Ignored if -insecure is specified.`))
-	cert = flags.String("cert", "", prettify(`
+	cert = flag.String("cert", "", prettify(`
 		File containing client certificate (public key), to present to the
 		server. Not valid with -plaintext option. Must also provide -key option.`))
-	key = flags.String("key", "", prettify(`
+	key = flag.String("key", "", prettify(`
 		File containing client private key, to present to the server. Not valid
 		with -plaintext option. Must also provide -cert option.`))
-
-	// ALTS Options
-	usealts = flags.Bool("alts", false, prettify(`
-		Use Application Layer Transport Security (ALTS) when connecting to server.`))
-	altsHandshakerServiceAddress = flags.String("alts-handshaker-service", "", prettify(`If set, this server will be used to do the ATLS handshaking.`))
-	altsTargetServiceAccounts    multiString
-
 	protoset    multiString
 	protoFiles  multiString
 	importPaths multiString
 	addlHeaders multiString
 	rpcHeaders  multiString
 	reflHeaders multiString
-	expandHeaders = flags.Bool("expand-headers", false, prettify(`
+	authority   = flag.String("authority", "", prettify(`
-		If set, headers may use '${NAME}' syntax to reference environment
+		Value of :authority pseudo-header to be use with underlying HTTP/2
-		variables. These will be expanded to the actual environment variable
+		requests. It defaults to the given address.`))
-		value before sending to the server. For example, if there is an
+	data = flag.String("d", "", prettify(`
-		environment variable defined like FOO=bar, then a header of
-		'key: ${FOO}' would expand to 'key: bar'. This applies to -H,
-		-rpc-header, and -reflect-header options. No other expansion/escaping is
-		performed. This can be used to supply credentials/secrets without having
-		to put them in command-line arguments.`))
-	authority = flags.String("authority", "", prettify(`
-		The authoritative name of the remote server. This value is passed as the
-		value of the ":authority" pseudo-header in the HTTP/2 protocol. When TLS
-		is used, this will also be used as the server name when verifying the
-		server's certificate. It defaults to the address that is provided in the
-		positional arguments, or 'localhost' in the case of a unix domain
-		socket.`))
-	userAgent = flags.String("user-agent", "", prettify(`
-		If set, the specified value will be added to the User-Agent header set
-		by the grpc-go library.
-		`))
-	data = flags.String("d", "", prettify(`
 		Data for request contents. If the value is '@' then the request contents
 		are read from stdin. For calls that accept a stream of requests, the
 		contents should include all such request messages concatenated together
 		(possibly delimited; see -format).`))
-	format = flags.String("format", "json", prettify(`
+	format = flag.String("format", "json", prettify(`
 		The format of request data. The allowed values are 'json' or 'text'. For
 		'json', the input data must be in JSON format. Multiple request values
 		may be concatenated (messages with a JSON representation other than
@@ -119,78 +74,43 @@ var (
 		ASCII character: 0x1E. The stream should not end in a record separator.
 		If it does, it will be interpreted as a final, blank message after the
 		separator.`))
-	allowUnknownFields = flags.Bool("allow-unknown-fields", false, prettify(`
+	connectTimeout = flag.String("connect-timeout", "", prettify(`
-		When true, the request contents, if 'json' format is used, allows
-		unknown fields to be present. They will be ignored when parsing
-		the request.`))
-	connectTimeout = flags.Float64("connect-timeout", 0, prettify(`
 		The maximum time, in seconds, to wait for connection to be established.
 		Defaults to 10 seconds.`))
-	formatError = flags.Bool("format-error", false, prettify(`
+	keepaliveTime = flag.String("keepalive-time", "", prettify(`
-		When a non-zero status is returned, format the response using the
-		value set by the -format flag .`))
-	keepaliveTime = flags.Float64("keepalive-time", 0, prettify(`
 		If present, the maximum idle time in seconds, after which a keepalive
 		probe is sent. If the connection remains idle and no keepalive response
 		is received for this same period then the connection is closed and the
 		operation fails.`))
-	maxTime = flags.Float64("max-time", 0, prettify(`
+	maxTime = flag.String("max-time", "", prettify(`
-		The maximum total time the operation can take, in seconds. This sets a
+		The maximum total time the operation can take. This is useful for
-                timeout on the gRPC context, allowing both client and server to give up
+		preventing batch jobs that use grpcurl from hanging due to slow or bad
-		after the deadline has past. This is useful for preventing batch jobs
+		network links or due to incorrect stream method usage.`))
-                that use grpcurl from hanging due to slow or bad network links or due
+	emitDefaults = flag.Bool("emit-defaults", false, prettify(`
-		to incorrect stream method usage.`))
-	maxMsgSz = flags.Int("max-msg-sz", 0, prettify(`
-		The maximum encoded size of a response message, in bytes, that grpcurl
-		will accept. If not specified, defaults to 4,194,304 (4 megabytes).`))
-	emitDefaults = flags.Bool("emit-defaults", false, prettify(`
 		Emit default values for JSON-encoded responses.`))
-	protosetOut = flags.String("protoset-out", "", prettify(`
+	msgTemplate = flag.Bool("msg-template", false, prettify(`
-		The name of a file to be written that will contain a FileDescriptorSet
-		proto. With the list and describe verbs, the listed or described
-		elements and their transitive dependencies will be written to the named
-		file if this option is given. When invoking an RPC and this option is
-		given, the method being invoked and its transitive dependencies will be
-		included in the output file.`))
-	protoOut = flags.String("proto-out-dir", "", prettify(`
-		The name of a directory where the generated .proto files will be written.
-		With the list and describe verbs, the listed or described elements and
-		their transitive dependencies will be written as .proto files in the
-		specified directory if this option is given. When invoking an RPC and
-		this option is given, the method being invoked and its transitive
-		dependencies will be included in the generated .proto files in the
-		output directory.`))
-	msgTemplate = flags.Bool("msg-template", false, prettify(`
 		When describing messages, show a template of input data.`))
-	verbose = flags.Bool("v", false, prettify(`
+	verbose = flag.Bool("v", false, prettify(`
 		Enable verbose output.`))
-	veryVerbose = flags.Bool("vv", false, prettify(`
+	serverName = flag.String("servername", "", prettify(`
-		Enable very verbose output (includes timing data).`))
+		Override server name when validating TLS certificate.`))
-	serverName = flags.String("servername", "", prettify(`
-		Override server name when validating TLS certificate. This flag is
-		ignored if -plaintext or -insecure is used.
-		NOTE: Prefer -authority. This flag may be removed in the future. It is
-		an error to use both -authority and -servername (though this will be
-		permitted if they are both set to the same value, to increase backwards
-		compatibility with earlier releases that allowed both to be set).`))
-	reflection = optionalBoolFlag{val: true}
 )
 
 func init() {
-	flags.Var(&addlHeaders, "H", prettify(`
+	flag.Var(&addlHeaders, "H", prettify(`
 		Additional headers in 'name: value' format. May specify more than one
 		via multiple flags. These headers will also be included in reflection
-		requests to a server.`))
+		requests requests to a server.`))
-	flags.Var(&rpcHeaders, "rpc-header", prettify(`
+	flag.Var(&rpcHeaders, "rpc-header", prettify(`
 		Additional RPC headers in 'name: value' format. May specify more than
 		one via multiple flags. These headers will *only* be used when invoking
 		the requested RPC method. They are excluded from reflection requests.`))
-	flags.Var(&reflHeaders, "reflect-header", prettify(`
+	flag.Var(&reflHeaders, "reflect-header", prettify(`
 		Additional reflection headers in 'name: value' format. May specify more
 		than one via multiple flags. These headers will *only* be used during
 		reflection requests and will be excluded when invoking the requested RPC
 		method.`))
-	flags.Var(&protoset, "protoset", prettify(`
+	flag.Var(&protoset, "protoset", prettify(`
 		The name of a file containing an encoded FileDescriptorSet. This file's
 		contents will be used to determine the RPC schema instead of querying
 		for it from the remote server via the gRPC reflection API. When set: the
@@ -199,7 +119,7 @@ func init() {
 		symbols found in the given descriptors. May specify more than one via
 		multiple -protoset flags. It is an error to use both -protoset and
 		-proto flags.`))
-	flags.Var(&protoFiles, "proto", prettify(`
+	flag.Var(&protoFiles, "proto", prettify(`
 		The name of a proto source file. Source files given will be used to
 		determine the RPC schema instead of querying for it from the remote
 		server via the gRPC reflection API. When set: the 'list' action lists
@@ -209,27 +129,13 @@ func init() {
 		-proto flags. Imports will be resolved using the given -import-path
 		flags. Multiple proto files can be specified by specifying multiple
 		-proto flags. It is an error to use both -protoset and -proto flags.`))
-	flags.Var(&importPaths, "import-path", prettify(`
+	flag.Var(&importPaths, "import-path", prettify(`
 		The path to a directory from which proto sources can be imported, for
 		use with -proto flags. Multiple import paths can be configured by
 		specifying multiple -import-path flags. Paths will be searched in the
 		order given. If no import paths are given, all files (including all
 		imports) must be provided as -proto flags, and grpcurl will attempt to
 		resolve all import statements from the set of file names given.`))
-	flags.Var(&reflection, "use-reflection", prettify(`
-		When true, server reflection will be used to determine the RPC schema.
-		Defaults to true unless a -proto or -protoset option is provided. If
-		-use-reflection is used in combination with a -proto or -protoset flag,
-		the provided descriptor sources will be used in addition to server
-		reflection to resolve messages and extensions.`))
-	flags.Var(&altsTargetServiceAccounts, "alts-target-service-account", prettify(`
-		The full email address of the service account that the server is
-		expected to be using when ALTS is used. You can specify this option
-		multiple times to indicate multiple allowed service accounts. If the
-		server authenticates with a service account that is not one of the
-		expected accounts, the RPC will not be issued. If no such arguments are
-		provided, no check will be performed, and the RPC will be issued
-		regardless of the server's service account.`))
 }
 
 type multiString []string
@@ -243,132 +149,39 @@ func (s *multiString) Set(value string) error {
 	return nil
 }
 
-// Uses a file source as a fallback for resolving symbols and extensions, but
-// only uses the reflection source for listing services
-type compositeSource struct {
-	reflection grpcurl.DescriptorSource
-	file       grpcurl.DescriptorSource
-}
-
-func (cs compositeSource) ListServices() ([]string, error) {
-	return cs.reflection.ListServices()
-}
-
-func (cs compositeSource) FindSymbol(fullyQualifiedName string) (desc.Descriptor, error) {
-	d, err := cs.reflection.FindSymbol(fullyQualifiedName)
-	if err == nil {
-		return d, nil
-	}
-	return cs.file.FindSymbol(fullyQualifiedName)
-}
-
-func (cs compositeSource) AllExtensionsForType(typeName string) ([]*desc.FieldDescriptor, error) {
-	exts, err := cs.reflection.AllExtensionsForType(typeName)
-	if err != nil {
-		// On error fall back to file source
-		return cs.file.AllExtensionsForType(typeName)
-	}
-	// Track the tag numbers from the reflection source
-	tags := make(map[int32]bool)
-	for _, ext := range exts {
-		tags[ext.GetNumber()] = true
-	}
-	fileExts, err := cs.file.AllExtensionsForType(typeName)
-	if err != nil {
-		return exts, nil
-	}
-	for _, ext := range fileExts {
-		// Prioritize extensions found via reflection
-		if !tags[ext.GetNumber()] {
-			exts = append(exts, ext)
-		}
-	}
-	return exts, nil
-}
-
-type timingData struct {
-	Title  string
-	Start  time.Time
-	Value  time.Duration
-	Parent *timingData
-	Sub    []*timingData
-}
-
-func (d *timingData) Child(title string) *timingData {
-	if d == nil {
-		return nil
-	}
-	child := &timingData{Title: title, Start: time.Now()}
-	d.Sub = append(d.Sub, child)
-	return child
-}
-
-func (d *timingData) Done() {
-	if d == nil {
-		return
-	}
-	if d.Value == 0 {
-		d.Value = time.Since(d.Start)
-	}
-}
-
 func main() {
-	flags.Usage = usage
+	flag.CommandLine.Usage = usage
-	flags.Parse(os.Args[1:])
+	flag.Parse()
 	if *help {
 		usage()
 		os.Exit(0)
 	}
 	if *printVersion {
-		fmt.Fprintf(os.Stderr, "%s %s\n", filepath.Base(os.Args[0]), version)
+		fmt.Fprintf(os.Stderr, "%s %s\n", os.Args[0], version)
 		os.Exit(0)
 	}
 
-	// default behavior is to use tls
-	usetls := !*plaintext && !*usealts
-
 	// Do extra validation on arguments and figure out what user asked us to do.
-	if *connectTimeout < 0 {
+	if *plaintext && *insecure {
-		fail(nil, "The -connect-timeout argument must not be negative.")
+		fail(nil, "The -plaintext and -insecure arguments are mutually exclusive.")
 	}
-	if *keepaliveTime < 0 {
+	if *plaintext && *cert != "" {
-		fail(nil, "The -keepalive-time argument must not be negative.")
+		fail(nil, "The -plaintext and -cert arguments are mutually exclusive.")
 	}
-	if *maxTime < 0 {
+	if *plaintext && *key != "" {
-		fail(nil, "The -max-time argument must not be negative.")
+		fail(nil, "The -plaintext and -key arguments are mutually exclusive.")
-	}
-	if *maxMsgSz < 0 {
-		fail(nil, "The -max-msg-sz argument must not be negative.")
-	}
-	if *plaintext && *usealts {
-		fail(nil, "The -plaintext and -alts arguments are mutually exclusive.")
-	}
-	if *insecure && !usetls {
-		fail(nil, "The -insecure argument can only be used with TLS.")
-	}
-	if *cert != "" && !usetls {
-		fail(nil, "The -cert argument can only be used with TLS.")
-	}
-	if *key != "" && !usetls {
-		fail(nil, "The -key argument can only be used with TLS.")
 	}
 	if (*key == "") != (*cert == "") {
 		fail(nil, "The -cert and -key arguments must be used together and both be present.")
 	}
-	if *altsHandshakerServiceAddress != "" && !*usealts {
-		fail(nil, "The -alts-handshaker-service argument must be used with the -alts argument.")
-	}
-	if len(altsTargetServiceAccounts) > 0 && !*usealts {
-		fail(nil, "The -alts-target-service-account argument must be used with the -alts argument.")
-	}
 	if *format != "json" && *format != "text" {
-		fail(nil, "The -format option must be 'json' or 'text'.")
+		fail(nil, "The -format option must be 'json' or 'text.")
 	}
 	if *emitDefaults && *format != "json" {
 		warn("The -emit-defaults is only used when using json format.")
 	}
 
-	args := flags.Args()
+	args := flag.Args()
 
 	if len(args) == 0 {
 		fail(nil, "Too few arguments.")
@@ -393,22 +206,6 @@ func main() {
 		invoke = true
 	}
 
-	verbosityLevel := 0
-	if *verbose {
-		verbosityLevel = 1
-	}
-
-	var rootTiming *timingData
-	if *veryVerbose {
-		verbosityLevel = 2
-
-		rootTiming = &timingData{Title: "Timing Data", Start: time.Now()}
-		defer func() {
-			rootTiming.Done()
-			dumpTiming(rootTiming, 0)
-		}()
-	}
-
 	var symbol string
 	if invoke {
 		if len(args) == 0 {
@@ -447,177 +244,88 @@ func main() {
 	if len(importPaths) > 0 && len(protoFiles) == 0 {
 		warn("The -import-path argument is not used unless -proto files are used.")
 	}
-	if !reflection.val && len(protoset) == 0 && len(protoFiles) == 0 {
-		fail(nil, "No protoset files or proto files specified and -use-reflection set to false.")
-	}
-
-	// Protoset or protofiles provided and -use-reflection unset
-	if !reflection.set && (len(protoset) > 0 || len(protoFiles) > 0) {
-		reflection.val = false
-	}
 
 	ctx := context.Background()
-	if *maxTime > 0 {
+	if *maxTime != "" {
-		timeout := floatSecondsToDuration(*maxTime)
+		t, err := strconv.ParseFloat(*maxTime, 64)
-		var cancel context.CancelFunc
+		if err != nil {
-		ctx, cancel = context.WithTimeout(ctx, timeout)
+			fail(nil, "The -max-time argument must be a valid number.")
-		defer cancel()
+		}
+		timeout := time.Duration(t * float64(time.Second))
+		ctx, _ = context.WithTimeout(ctx, timeout)
 	}
 
 	dial := func() *grpc.ClientConn {
-		dialTiming := rootTiming.Child("Dial")
-		defer dialTiming.Done()
 		dialTime := 10 * time.Second
-		if *connectTimeout > 0 {
+		if *connectTimeout != "" {
-			dialTime = floatSecondsToDuration(*connectTimeout)
+			t, err := strconv.ParseFloat(*connectTimeout, 64)
+			if err != nil {
+				fail(nil, "The -connect-timeout argument must be a valid number.")
+			}
+			dialTime = time.Duration(t * float64(time.Second))
 		}
 		ctx, cancel := context.WithTimeout(ctx, dialTime)
 		defer cancel()
 		var opts []grpc.DialOption
-		if *keepaliveTime > 0 {
+		if *keepaliveTime != "" {
-			timeout := floatSecondsToDuration(*keepaliveTime)
+			t, err := strconv.ParseFloat(*keepaliveTime, 64)
+			if err != nil {
+				fail(nil, "The -keepalive-time argument must be a valid number.")
+			}
+			timeout := time.Duration(t * float64(time.Second))
 			opts = append(opts, grpc.WithKeepaliveParams(keepalive.ClientParameters{
 				Time:    timeout,
 				Timeout: timeout,
 			}))
 		}
-		if *maxMsgSz > 0 {
-			opts = append(opts, grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(*maxMsgSz)))
-		}
-		if isUnixSocket != nil && isUnixSocket() && !strings.HasPrefix(target, "unix://") {
-			// prepend unix:// to the address if it's not already there
-			// this is to maintain backwards compatibility because the custom dialer is replaced by
-			// the default dialer in grpc-go.
-			// https://github.com/fullstorydev/grpcurl/pull/480
-			target = "unix://" + target
-		}
-		var creds credentials.TransportCredentials
-		if *plaintext {
 		if *authority != "" {
 			opts = append(opts, grpc.WithAuthority(*authority))
 		}
-		} else if *usealts {
+		var creds credentials.TransportCredentials
-			clientOptions := alts.DefaultClientOptions()
+		if !*plaintext {
-			if len(altsTargetServiceAccounts) > 0 {
+			var err error
-				clientOptions.TargetServiceAccounts = altsTargetServiceAccounts
+			creds, err = grpcurl.ClientTransportCredentials(*insecure, *cacert, *cert, *key)
-			}
-			if *altsHandshakerServiceAddress != "" {
-				clientOptions.HandshakerServiceAddress = *altsHandshakerServiceAddress
-			}
-			creds = alts.NewClientCreds(clientOptions)
-		} else if usetls {
-			tlsTiming := dialTiming.Child("TLS Setup")
-			defer tlsTiming.Done()
-
-			tlsConf, err := grpcurl.ClientTLSConfig(*insecure, *cacert, *cert, *key)
 			if err != nil {
-				fail(err, "Failed to create TLS config")
+				fail(err, "Failed to configure transport credentials")
 			}
-
+			if *serverName != "" {
-			sslKeylogFile := os.Getenv("SSLKEYLOGFILE")
+				if err := creds.OverrideServerName(*serverName); err != nil {
-			if sslKeylogFile != "" {
+					fail(err, "Failed to override server name as %q", *serverName)
-				w, err := os.OpenFile(sslKeylogFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0600)
-				if err != nil {
-					fail(err, "Could not open SSLKEYLOGFILE %s", sslKeylogFile)
-				}
-				tlsConf.KeyLogWriter = w
-			}
-
-			creds = credentials.NewTLS(tlsConf)
-
-			// can use either -servername or -authority; but not both
-			if *serverName != "" && *authority != "" {
-				if *serverName == *authority {
-					warn("Both -servername and -authority are present; prefer only -authority.")
-				} else {
-					fail(nil, "Cannot specify different values for -servername and -authority.")
 				}
 			}
-			overrideName := *serverName
-			if overrideName == "" {
-				overrideName = *authority
 		}
-
+		network := "tcp"
-			if overrideName != "" {
+		if isUnixSocket != nil && isUnixSocket() {
-				opts = append(opts, grpc.WithAuthority(overrideName))
+			network = "unix"
 		}
-			tlsTiming.Done()
+		cc, err := grpcurl.BlockingDial(ctx, network, target, creds, opts...)
-		} else {
-			panic("Should have defaulted to use TLS.")
-		}
-
-		grpcurlUA := "grpcurl/" + version
-		if version == noVersion {
-			grpcurlUA = "grpcurl/dev-build (no version set)"
-		}
-		if *userAgent != "" {
-			grpcurlUA = *userAgent + " " + grpcurlUA
-		}
-		opts = append(opts, grpc.WithUserAgent(grpcurlUA))
-
-		blockingDialTiming := dialTiming.Child("BlockingDial")
-		defer blockingDialTiming.Done()
-		cc, err := grpcurl.BlockingDial(ctx, "", target, creds, opts...)
 		if err != nil {
 			fail(err, "Failed to dial target host %q", target)
 		}
 		return cc
 	}
-	printFormattedStatus := func(w io.Writer, stat *status.Status, formatter grpcurl.Formatter) {
-		formattedStatus, err := formatter(stat.Proto())
-		if err != nil {
-			fmt.Fprintf(w, "ERROR: %v", err.Error())
-		}
-		fmt.Fprint(w, formattedStatus)
-	}
-
-	if *expandHeaders {
-		var err error
-		addlHeaders, err = grpcurl.ExpandHeaders(addlHeaders)
-		if err != nil {
-			fail(err, "Failed to expand additional headers")
-		}
-		rpcHeaders, err = grpcurl.ExpandHeaders(rpcHeaders)
-		if err != nil {
-			fail(err, "Failed to expand rpc headers")
-		}
-		reflHeaders, err = grpcurl.ExpandHeaders(reflHeaders)
-		if err != nil {
-			fail(err, "Failed to expand reflection headers")
-		}
-	}
 
 	var cc *grpc.ClientConn
 	var descSource grpcurl.DescriptorSource
 	var refClient *grpcreflect.Client
-	var fileSource grpcurl.DescriptorSource
 	if len(protoset) > 0 {
 		var err error
-		fileSource, err = grpcurl.DescriptorSourceFromProtoSets(protoset...)
+		descSource, err = grpcurl.DescriptorSourceFromProtoSets(protoset...)
 		if err != nil {
 			fail(err, "Failed to process proto descriptor sets.")
 		}
 	} else if len(protoFiles) > 0 {
 		var err error
-		fileSource, err = grpcurl.DescriptorSourceFromProtoFiles(importPaths, protoFiles...)
+		descSource, err = grpcurl.DescriptorSourceFromProtoFiles(importPaths, protoFiles...)
 		if err != nil {
 			fail(err, "Failed to process proto source files.")
 		}
-	}
+	} else {
-	if reflection.val {
 		md := grpcurl.MetadataFromHeaders(append(addlHeaders, reflHeaders...))
 		refCtx := metadata.NewOutgoingContext(ctx, md)
 		cc = dial()
-		refClient = grpcreflect.NewClientAuto(refCtx, cc)
+		refClient = grpcreflect.NewClient(refCtx, reflectpb.NewServerReflectionClient(cc))
-		refClient.AllowMissingFileDescriptors()
+		descSource = grpcurl.DescriptorSourceFromServer(ctx, refClient)
-		reflSource := grpcurl.DescriptorSourceFromServer(ctx, refClient)
-		if fileSource != nil {
-			descSource = compositeSource{reflSource, fileSource}
-		} else {
-			descSource = reflSource
-		}
-	} else {
-		descSource = fileSource
 	}
 
 	// arrange for the RPCs to be cleanly shutdown
@@ -651,12 +359,6 @@ func main() {
 					fmt.Printf("%s\n", svc)
 				}
 			}
-			if err := writeProtoset(descSource, svcs...); err != nil {
-				fail(err, "Failed to write protoset to %s", *protosetOut)
-			}
-			if err := writeProtos(descSource, svcs...); err != nil {
-				fail(err, "Failed to write protos to %s", *protoOut)
-			}
 		} else {
 			methods, err := grpcurl.ListMethods(descSource, symbol)
 			if err != nil {
@@ -669,12 +371,6 @@ func main() {
 					fmt.Printf("%s\n", m)
 				}
 			}
-			if err := writeProtoset(descSource, symbol); err != nil {
-				fail(err, "Failed to write protoset to %s", *protosetOut)
-			}
-			if err := writeProtos(descSource, symbol); err != nil {
-				fail(err, "Failed to write protos to %s", *protoOut)
-			}
 		}
 
 	} else if describe {
@@ -721,7 +417,7 @@ func main() {
 					} else {
 						// see if it's a group
 						for _, f := range parent.GetFields() {
-							if f.GetType() == descriptorpb.FieldDescriptorProto_TYPE_GROUP && f.GetMessageType() == d {
+							if f.GetType() == descpb.FieldDescriptorProto_TYPE_GROUP && f.GetMessageType() == d {
 								// found it: describe the map field instead
 								elementType = "the type of a group field"
 								dsc = f
@@ -732,7 +428,7 @@ func main() {
 				}
 			case *desc.FieldDescriptor:
 				elementType = "a field"
-				if d.GetType() == descriptorpb.FieldDescriptorProto_TYPE_GROUP {
+				if d.GetType() == descpb.FieldDescriptorProto_TYPE_GROUP {
 					elementType = "a group field"
 				} else if d.IsExtension() {
 					elementType = "an extension"
@@ -763,8 +459,7 @@ func main() {
 				// for messages, also show a template in JSON, to make it easier to
 				// create a request to invoke an RPC
 				tmpl := grpcurl.MakeTemplate(dsc)
-				options := grpcurl.FormatOptions{EmitJSONDefaultFields: true}
+				_, formatter, err := grpcurl.RequestParserAndFormatterFor(grpcurl.Format(*format), descSource, true, false, nil)
-				_, formatter, err := grpcurl.RequestParserAndFormatter(grpcurl.Format(*format), descSource, nil, options)
 				if err != nil {
 					fail(err, "Failed to construct formatter for %q", *format)
 				}
@@ -776,12 +471,6 @@ func main() {
 				fmt.Println(str)
 			}
 		}
-		if err := writeProtoset(descSource, symbols...); err != nil {
-			fail(err, "Failed to write protoset to %s", *protosetOut)
-		}
-		if err := writeProtos(descSource, symbol); err != nil {
-			fail(err, "Failed to write protos to %s", *protoOut)
-		}
 
 	} else {
 		// Invoke an RPC
@@ -798,32 +487,17 @@ func main() {
 		// if not verbose output, then also include record delimiters
 		// between each message, so output could potentially be piped
 		// to another grpcurl process
-		includeSeparators := verbosityLevel == 0
+		includeSeparators := !*verbose
-		options := grpcurl.FormatOptions{
+		rf, formatter, err := grpcurl.RequestParserAndFormatterFor(grpcurl.Format(*format), descSource, *emitDefaults, includeSeparators, in)
-			EmitJSONDefaultFields: *emitDefaults,
-			IncludeTextSeparator:  includeSeparators,
-			AllowUnknownFields:    *allowUnknownFields,
-		}
-		rf, formatter, err := grpcurl.RequestParserAndFormatter(grpcurl.Format(*format), descSource, in, options)
 		if err != nil {
 			fail(err, "Failed to construct request parser and formatter for %q", *format)
 		}
-		h := &grpcurl.DefaultEventHandler{
+		h := grpcurl.NewDefaultEventHandler(os.Stdout, descSource, formatter, *verbose)
-			Out:            os.Stdout,
-			Formatter:      formatter,
-			VerbosityLevel: verbosityLevel,
-		}
 
-		invokeTiming := rootTiming.Child("InvokeRPC")
 		err = grpcurl.InvokeRPC(ctx, descSource, cc, symbol, append(addlHeaders, rpcHeaders...), h, rf.Next)
-		invokeTiming.Done()
 		if err != nil {
-			if errStatus, ok := status.FromError(err); ok && *formatError {
-				h.Status = errStatus
-			} else {
 			fail(err, "Error invoking method %q", symbol)
 		}
-		}
 		reqSuffix := ""
 		respSuffix := ""
 		reqCount := rf.NumRequests()
@@ -833,28 +507,13 @@ func main() {
 		if h.NumResponses != 1 {
 			respSuffix = "s"
 		}
-		if verbosityLevel > 0 {
+		if *verbose {
 			fmt.Printf("Sent %d request%s and received %d response%s\n", reqCount, reqSuffix, h.NumResponses, respSuffix)
 		}
 		if h.Status.Code() != codes.OK {
-			if *formatError {
+			fmt.Fprintf(os.Stderr, "ERROR:\n  Code: %s\n  Message: %s\n", h.Status.Code().String(), h.Status.Message())
-				printFormattedStatus(os.Stderr, h.Status, formatter)
+			exit(1)
-			} else {
-				grpcurl.PrintStatus(os.Stderr, h.Status, formatter)
 		}
-			exit(statusCodeOffset + int(h.Status.Code()))
-		}
-	}
-}
-
-func dumpTiming(td *timingData, lvl int) {
-	var ind strings.Builder
-	for x := 0; x < lvl; x++ {
-		ind.WriteString("  ")
-	}
-	fmt.Printf("%s%s: %s\n", ind.String(), td.Title, td.Value)
-	for _, sd := range td.Sub {
-		dumpTiming(sd, lvl+1)
 	}
 }
 
@@ -887,7 +546,7 @@ path to the domain socket.
 
 Available flags:
 `, os.Args[0])
-	flags.PrintDefaults()
+	flag.PrintDefaults()
 }
 
 func prettify(docString string) string {
@@ -905,7 +564,7 @@ func prettify(docString string) string {
 		j++
 	}
 
-	return strings.Join(parts[:j], "\n")
+	return strings.Join(parts[:j], "\n"+indent())
 }
 
 func warn(msg string, args ...interface{}) {
@@ -928,56 +587,3 @@ func fail(err error, msg string, args ...interface{}) {
 		exit(2)
 	}
 }
-
-func writeProtoset(descSource grpcurl.DescriptorSource, symbols ...string) error {
-	if *protosetOut == "" {
-		return nil
-	}
-	f, err := os.Create(*protosetOut)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-	return grpcurl.WriteProtoset(f, descSource, symbols...)
-}
-
-func writeProtos(descSource grpcurl.DescriptorSource, symbols ...string) error {
-	if *protoOut == "" {
-		return nil
-	}
-	return grpcurl.WriteProtoFiles(*protoOut, descSource, symbols...)
-}
-
-type optionalBoolFlag struct {
-	set, val bool
-}
-
-func (f *optionalBoolFlag) String() string {
-	if !f.set {
-		return "unset"
-	}
-	return strconv.FormatBool(f.val)
-}
-
-func (f *optionalBoolFlag) Set(s string) error {
-	v, err := strconv.ParseBool(s)
-	if err != nil {
-		return err
-	}
-	f.set = true
-	f.val = v
-	return nil
-}
-
-func (f *optionalBoolFlag) IsBoolFlag() bool {
-	return true
-}
-
-func floatSecondsToDuration(seconds float64) time.Duration {
-	durationFloat := seconds * float64(time.Second)
-	if durationFloat > math.MaxInt64 {
-		// Avoid overflow
-		return math.MaxInt64
-	}
-	return time.Duration(durationFloat)
-}

cmd/grpcurl/unix.go

@@ -1,10 +1,11 @@
-//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris windows
 
 package main
 
+import "flag"
+
 var (
-	unix = flags.Bool("unix", false, prettify(`
+	unix = flag.Bool("unix", false, prettify(`
 		Indicates that the server address is the path to a Unix domain socket.`))
 )
 

desc_source.go

@@ -1,23 +1,20 @@
 package grpcurl
 
 import (
-	"context"
 	"errors"
 	"fmt"
-	"io"
+	"io/ioutil"
-	"os"
-	"path/filepath"
 	"sync"
 
-	"github.com/golang/protobuf/proto"              //lint:ignore SA1019 we have to import these because some of their types appear in exported API
+	"github.com/golang/protobuf/proto"
-	"github.com/jhump/protoreflect/desc"            //lint:ignore SA1019 same as above
+	descpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
-	"github.com/jhump/protoreflect/desc/protoparse" //lint:ignore SA1019 same as above
+	"github.com/jhump/protoreflect/desc"
-	"github.com/jhump/protoreflect/desc/protoprint"
+	"github.com/jhump/protoreflect/desc/protoparse"
-	"github.com/jhump/protoreflect/dynamic" //lint:ignore SA1019 same as above
+	"github.com/jhump/protoreflect/dynamic"
 	"github.com/jhump/protoreflect/grpcreflect"
+	"golang.org/x/net/context"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"google.golang.org/protobuf/types/descriptorpb"
 )
 
 // ErrReflectionNotSupported is returned by DescriptorSource operations that
@@ -41,13 +38,13 @@ type DescriptorSource interface {
 // DescriptorSourceFromProtoSets creates a DescriptorSource that is backed by the named files, whose contents
 // are encoded FileDescriptorSet protos.
 func DescriptorSourceFromProtoSets(fileNames ...string) (DescriptorSource, error) {
-	files := &descriptorpb.FileDescriptorSet{}
+	files := &descpb.FileDescriptorSet{}
 	for _, fileName := range fileNames {
-		b, err := os.ReadFile(fileName)
+		b, err := ioutil.ReadFile(fileName)
 		if err != nil {
 			return nil, fmt.Errorf("could not load protoset file %q: %v", fileName, err)
 		}
-		var fs descriptorpb.FileDescriptorSet
+		var fs descpb.FileDescriptorSet
 		err = proto.Unmarshal(b, &fs)
 		if err != nil {
 			return nil, fmt.Errorf("could not parse contents of protoset file %q: %v", fileName, err)
@@ -61,14 +58,9 @@ func DescriptorSourceFromProtoSets(fileNames ...string) (DescriptorSource, error
 // whose contents are Protocol Buffer source files. The given importPaths are used to locate
 // any imported files.
 func DescriptorSourceFromProtoFiles(importPaths []string, fileNames ...string) (DescriptorSource, error) {
-	fileNames, err := protoparse.ResolveFilenames(importPaths, fileNames...)
-	if err != nil {
-		return nil, err
-	}
 	p := protoparse.Parser{
 		ImportPaths:      importPaths,
 		InferImportPaths: len(importPaths) == 0,
-		IncludeSourceCodeInfo: true,
 	}
 	fds, err := p.ParseFiles(fileNames...)
 	if err != nil {
@@ -78,8 +70,8 @@ func DescriptorSourceFromProtoFiles(importPaths []string, fileNames ...string) (
 }
 
 // DescriptorSourceFromFileDescriptorSet creates a DescriptorSource that is backed by the FileDescriptorSet.
-func DescriptorSourceFromFileDescriptorSet(files *descriptorpb.FileDescriptorSet) (DescriptorSource, error) {
+func DescriptorSourceFromFileDescriptorSet(files *descpb.FileDescriptorSet) (DescriptorSource, error) {
-	unresolved := map[string]*descriptorpb.FileDescriptorProto{}
+	unresolved := map[string]*descpb.FileDescriptorProto{}
 	for _, fd := range files.File {
 		unresolved[fd.GetName()] = fd
 	}
@@ -93,7 +85,7 @@ func DescriptorSourceFromFileDescriptorSet(files *descriptorpb.FileDescriptorSet
 	return &fileSource{files: resolved}, nil
 }
 
-func resolveFileDescriptor(unresolved map[string]*descriptorpb.FileDescriptorProto, resolved map[string]*desc.FileDescriptor, filename string) (*desc.FileDescriptor, error) {
+func resolveFileDescriptor(unresolved map[string]*descpb.FileDescriptorProto, resolved map[string]*desc.FileDescriptor, filename string) (*desc.FileDescriptor, error) {
 	if r, ok := resolved[filename]; ok {
 		return r, nil
 	}
@@ -117,7 +109,7 @@ func resolveFileDescriptor(unresolved map[string]*descriptorpb.FileDescriptorPro
 	return result, nil
 }
 
-// DescriptorSourceFromFileDescriptors creates a DescriptorSource that is backed by the given
+// DescriptorSourceFromFileDescriptorSet creates a DescriptorSource that is backed by the given
 // file descriptors
 func DescriptorSourceFromFileDescriptors(files ...*desc.FileDescriptor) (DescriptorSource, error) {
 	fds := map[string]*desc.FileDescriptor{}
@@ -254,116 +246,3 @@ func reflectionSupport(err error) error {
 	}
 	return err
 }
-
-// WriteProtoset will use the given descriptor source to resolve all of the given
-// symbols and write a proto file descriptor set with their definitions to the
-// given output. The output will include descriptors for all files in which the
-// symbols are defined as well as their transitive dependencies.
-func WriteProtoset(out io.Writer, descSource DescriptorSource, symbols ...string) error {
-	filenames, fds, err := getFileDescriptors(symbols, descSource)
-	if err != nil {
-		return err
-	}
-	// now expand that to include transitive dependencies in topologically sorted
-	// order (such that file always appears after its dependencies)
-	expandedFiles := make(map[string]struct{}, len(fds))
-	allFilesSlice := make([]*descriptorpb.FileDescriptorProto, 0, len(fds))
-	for _, filename := range filenames {
-		allFilesSlice = addFilesToSet(allFilesSlice, expandedFiles, fds[filename])
-	}
-	// now we can serialize to file
-	b, err := proto.Marshal(&descriptorpb.FileDescriptorSet{File: allFilesSlice})
-	if err != nil {
-		return fmt.Errorf("failed to serialize file descriptor set: %v", err)
-	}
-	if _, err := out.Write(b); err != nil {
-		return fmt.Errorf("failed to write file descriptor set: %v", err)
-	}
-	return nil
-}
-
-func addFilesToSet(allFiles []*descriptorpb.FileDescriptorProto, expanded map[string]struct{}, fd *desc.FileDescriptor) []*descriptorpb.FileDescriptorProto {
-	if _, ok := expanded[fd.GetName()]; ok {
-		// already seen this one
-		return allFiles
-	}
-	expanded[fd.GetName()] = struct{}{}
-	// add all dependencies first
-	for _, dep := range fd.GetDependencies() {
-		allFiles = addFilesToSet(allFiles, expanded, dep)
-	}
-	return append(allFiles, fd.AsFileDescriptorProto())
-}
-
-// WriteProtoFiles will use the given descriptor source to resolve all the given
-// symbols and write proto files with their definitions to the given output directory.
-func WriteProtoFiles(outProtoDirPath string, descSource DescriptorSource, symbols ...string) error {
-	filenames, fds, err := getFileDescriptors(symbols, descSource)
-	if err != nil {
-		return err
-	}
-	// now expand that to include transitive dependencies in topologically sorted
-	// order (such that file always appears after its dependencies)
-	expandedFiles := make(map[string]struct{}, len(fds))
-	allFileDescriptors := make([]*desc.FileDescriptor, 0, len(fds))
-	for _, filename := range filenames {
-		allFileDescriptors = addFilesToFileDescriptorList(allFileDescriptors, expandedFiles, fds[filename])
-	}
-	pr := protoprint.Printer{}
-	// now we can serialize to files
-	for i := range allFileDescriptors {
-		if err := writeProtoFile(outProtoDirPath, allFileDescriptors[i], &pr); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func writeProtoFile(outProtoDirPath string, fd *desc.FileDescriptor, pr *protoprint.Printer) error {
-	outFile := filepath.Join(outProtoDirPath, fd.GetFullyQualifiedName())
-	outDir := filepath.Dir(outFile)
-	if err := os.MkdirAll(outDir, 0777); err != nil {
-		return fmt.Errorf("failed to create directory %q: %w", outDir, err)
-	}
-
-	f, err := os.Create(outFile)
-	if err != nil {
-		return fmt.Errorf("failed to create proto file %q: %w", outFile, err)
-	}
-	defer f.Close()
-	if err := pr.PrintProtoFile(fd, f); err != nil {
-		return fmt.Errorf("failed to write proto file %q: %w", outFile, err)
-	}
-	return nil
-}
-
-func getFileDescriptors(symbols []string, descSource DescriptorSource) ([]string, map[string]*desc.FileDescriptor, error) {
-	// compute set of file descriptors
-	filenames := make([]string, 0, len(symbols))
-	fds := make(map[string]*desc.FileDescriptor, len(symbols))
-	for _, sym := range symbols {
-		d, err := descSource.FindSymbol(sym)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed to find descriptor for %q: %v", sym, err)
-		}
-		fd := d.GetFile()
-		if _, ok := fds[fd.GetName()]; !ok {
-			fds[fd.GetName()] = fd
-			filenames = append(filenames, fd.GetName())
-		}
-	}
-	return filenames, fds, nil
-}
-
-func addFilesToFileDescriptorList(allFiles []*desc.FileDescriptor, expanded map[string]struct{}, fd *desc.FileDescriptor) []*desc.FileDescriptor {
-	if _, ok := expanded[fd.GetName()]; ok {
-		// already seen this one
-		return allFiles
-	}
-	expanded[fd.GetName()] = struct{}{}
-	// add all dependencies first
-	for _, dep := range fd.GetDependencies() {
-		allFiles = addFilesToFileDescriptorList(allFiles, expanded, dep)
-	}
-	return append(allFiles, fd)
-}

desc_source_test.go

@@ -1,62 +0,0 @@
-package grpcurl
-
-import (
-	"bytes"
-	"os"
-	"testing"
-
-	"github.com/golang/protobuf/proto" //lint:ignore SA1019 we have to import this because it appears in exported API
-	"google.golang.org/protobuf/types/descriptorpb"
-)
-
-func TestWriteProtoset(t *testing.T) {
-	exampleProtoset, err := loadProtoset("./internal/testing/example.protoset")
-	if err != nil {
-		t.Fatalf("failed to load example.protoset: %v", err)
-	}
-	testProtoset, err := loadProtoset("./internal/testing/test.protoset")
-	if err != nil {
-		t.Fatalf("failed to load test.protoset: %v", err)
-	}
-
-	mergedProtoset := &descriptorpb.FileDescriptorSet{
-		File: append(exampleProtoset.File, testProtoset.File...),
-	}
-
-	descSrc, err := DescriptorSourceFromFileDescriptorSet(mergedProtoset)
-	if err != nil {
-		t.Fatalf("failed to create descriptor source: %v", err)
-	}
-
-	checkWriteProtoset(t, descSrc, exampleProtoset, "TestService")
-	checkWriteProtoset(t, descSrc, testProtoset, "testing.TestService")
-	checkWriteProtoset(t, descSrc, mergedProtoset, "TestService", "testing.TestService")
-}
-
-func loadProtoset(path string) (*descriptorpb.FileDescriptorSet, error) {
-	b, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	var protoset descriptorpb.FileDescriptorSet
-	if err := proto.Unmarshal(b, &protoset); err != nil {
-		return nil, err
-	}
-	return &protoset, nil
-}
-
-func checkWriteProtoset(t *testing.T, descSrc DescriptorSource, protoset *descriptorpb.FileDescriptorSet, symbols ...string) {
-	var buf bytes.Buffer
-	if err := WriteProtoset(&buf, descSrc, symbols...); err != nil {
-		t.Fatalf("failed to write protoset: %v", err)
-	}
-
-	var result descriptorpb.FileDescriptorSet
-	if err := proto.Unmarshal(buf.Bytes(), &result); err != nil {
-		t.Fatalf("failed to unmarshal written protoset: %v", err)
-	}
-
-	if !proto.Equal(protoset, &result) {
-		t.Fatalf("written protoset not equal to input:\nExpecting: %s\nActual: %s", protoset, &result)
-	}
-}

download_protoc.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-cd $(dirname $0)
-
-if [[ -z "$PROTOC_VERSION" ]]; then
-  echo "Set PROTOC_VERSION env var to indicate the version to download" >&2
-  exit 1
-fi
-PROTOC_OS="$(uname -s)"
-PROTOC_ARCH="$(uname -m)"
-case "${PROTOC_OS}" in
-  Darwin) PROTOC_OS="osx" ;;
-  Linux) PROTOC_OS="linux" ;;
-  *)
-    echo "Invalid value for uname -s: ${PROTOC_OS}" >&2
-    exit 1
-esac
-
-# This is for macs with M1 chips. Precompiled binaries for osx/amd64 are not available for download, so for that case
-# we download the x86_64 version instead. This will work as long as rosetta2 is installed.
-if [ "$PROTOC_OS" = "osx" ] && [ "$PROTOC_ARCH" = "arm64" ]; then
-  PROTOC_ARCH="x86_64"
-fi
-
-PROTOC="${PWD}/.tmp/protoc/bin/protoc"
-
-if [[ "$(${PROTOC} --version 2>/dev/null)" != "libprotoc 3.${PROTOC_VERSION}" ]]; then
-  rm -rf ./.tmp/protoc
-  mkdir -p .tmp/protoc
-  curl -L "https://github.com/google/protobuf/releases/download/v${PROTOC_VERSION}/protoc-${PROTOC_VERSION}-${PROTOC_OS}-${PROTOC_ARCH}.zip" > .tmp/protoc/protoc.zip
-  pushd ./.tmp/protoc && unzip protoc.zip && popd
-fi
-

format.go

@@ -3,19 +3,14 @@ package grpcurl
 import (
 	"bufio"
 	"bytes"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
-	"reflect"
-	"strings"
-	"sync"
 
-	"github.com/golang/protobuf/jsonpb"     //lint:ignore SA1019 we have to import these because some of their types appear in exported API
+	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"      //lint:ignore SA1019 same as above
+	"github.com/golang/protobuf/proto"
-	"github.com/jhump/protoreflect/desc"    //lint:ignore SA1019 same as above
+	"github.com/jhump/protoreflect/desc"
-	"github.com/jhump/protoreflect/dynamic" //lint:ignore SA1019 same as above
+	"github.com/jhump/protoreflect/dynamic"
-	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 )
@@ -55,15 +50,6 @@ func NewJSONRequestParser(in io.Reader, resolver jsonpb.AnyResolver) RequestPars
 	}
 }
 
-// NewJSONRequestParserWithUnmarshaler is like NewJSONRequestParser but
-// accepts a protobuf jsonpb.Unmarshaler instead of jsonpb.AnyResolver.
-func NewJSONRequestParserWithUnmarshaler(in io.Reader, unmarshaler jsonpb.Unmarshaler) RequestParser {
-	return &jsonRequestParser{
-		dec:         json.NewDecoder(in),
-		unmarshaler: unmarshaler,
-	}
-}
-
 func (f *jsonRequestParser) Next(m proto.Message) error {
 	var msg json.RawMessage
 	if err := f.dec.Decode(&msg); err != nil {
@@ -78,7 +64,7 @@ func (f *jsonRequestParser) NumRequests() int {
 }
 
 const (
-	textSeparatorChar = '\x1e'
+	textSeparatorChar = 0x1e
 )
 
 type textRequestParser struct {
@@ -136,25 +122,10 @@ type Formatter func(proto.Message) (string, error)
 func NewJSONFormatter(emitDefaults bool, resolver jsonpb.AnyResolver) Formatter {
 	marshaler := jsonpb.Marshaler{
 		EmitDefaults: emitDefaults,
+		Indent:       "  ",
 		AnyResolver:  resolver,
 	}
-	// Workaround for indentation issue in jsonpb with Any messages.
+	return marshaler.MarshalToString
-	// Bug was originally fixed in https://github.com/golang/protobuf/pull/834
-	// but later re-introduced before the module was deprecated and frozen.
-	// If jsonpb is ever replaced with google.golang.org/protobuf/encoding/protojson
-	// this workaround will no longer be needed.
-	formatter := func(message proto.Message) (string, error) {
-		output, err := marshaler.MarshalToString(message)
-		if err != nil {
-			return "", err
-		}
-		var buf bytes.Buffer
-		if err := json.Indent(&buf, []byte(output), "", "  "); err != nil {
-			return "", err
-		}
-		return buf.String(), nil
-	}
-	return formatter
 }
 
 // NewTextFormatter returns a formatter that returns strings in the protobuf
@@ -171,8 +142,6 @@ type textFormatter struct {
 	numFormatted int
 }
 
-var protoTextMarshaler = proto.TextMarshaler{ExpandAny: true}
-
 func (tf *textFormatter) format(m proto.Message) (string, error) {
 	var buf bytes.Buffer
 	if tf.useSeparator && tf.numFormatted > 0 {
@@ -197,13 +166,13 @@ func (tf *textFormatter) format(m proto.Message) (string, error) {
 		if _, err := buf.Write(b); err != nil {
 			return "", err
 		}
-	} else if err := protoTextMarshaler.Marshal(&buf, m); err != nil {
+	} else if err := proto.MarshalText(&buf, m); err != nil {
 		return "", err
 	}
 
 	// no trailing newline needed
 	str := buf.String()
-	if len(str) > 0 && str[len(str)-1] == '\n' {
+	if str[len(str)-1] == '\n' {
 		str = str[:len(str)-1]
 	}
 
@@ -212,209 +181,29 @@ func (tf *textFormatter) format(m proto.Message) (string, error) {
 	return str, nil
 }
 
-// Format of request data. The allowed values are 'json' or 'text'.
 type Format string
 
 const (
-	// FormatJSON specifies input data in JSON format. Multiple request values
-	// may be concatenated (messages with a JSON representation other than
-	// object must be separated by whitespace, such as a newline)
 	FormatJSON = Format("json")
-
-	// FormatText specifies input data must be in the protobuf text format.
-	// Multiple request values must be separated by the "record separator"
-	// ASCII character: 0x1E. The stream should not end in a record separator.
-	// If it does, it will be interpreted as a final, blank message after the
-	// separator.
 	FormatText = Format("text")
 )
 
-// AnyResolverFromDescriptorSource returns an AnyResolver that will search for
+func anyResolver(source DescriptorSource) (jsonpb.AnyResolver, error) {
-// types using the given descriptor source.
+	// TODO: instead of pro-actively downloading file descriptors to
-func AnyResolverFromDescriptorSource(source DescriptorSource) jsonpb.AnyResolver {
+	// build a dynamic resolver, it would be better if the resolver
-	return &anyResolver{source: source}
+	// impl was lazy, and simply downloaded the descriptors as needed
-}
+	// when asked to resolve a particular type URL
 
-// AnyResolverFromDescriptorSourceWithFallback returns an AnyResolver that will
+	// best effort: build resolver with whatever files we can
-// search for types using the given descriptor source and then fallback to a
+	// load, ignoring any errors
-// special message if the type is not found. The fallback type will render to
+	files, _ := GetAllFiles(source)
-// JSON with a "@type" property, just like an Any message, but also with a
-// custom "@value" property that includes the binary encoded payload.
-func AnyResolverFromDescriptorSourceWithFallback(source DescriptorSource) jsonpb.AnyResolver {
-	res := anyResolver{source: source}
-	return &anyResolverWithFallback{AnyResolver: &res}
-}
 
-type anyResolver struct {
+	var er dynamic.ExtensionRegistry
-	source DescriptorSource
+	for _, fd := range files {
-
+		er.AddExtensionsFromFile(fd)
-	er dynamic.ExtensionRegistry
-
-	mu       sync.RWMutex
-	mf       *dynamic.MessageFactory
-	resolved map[string]func() proto.Message
-}
-
-func (r *anyResolver) Resolve(typeUrl string) (proto.Message, error) {
-	mname := typeUrl
-	if slash := strings.LastIndex(mname, "/"); slash >= 0 {
-		mname = mname[slash+1:]
-	}
-
-	r.mu.RLock()
-	factory := r.resolved[mname]
-	r.mu.RUnlock()
-
-	// already resolved?
-	if factory != nil {
-		return factory(), nil
-	}
-
-	r.mu.Lock()
-	defer r.mu.Unlock()
-
-	// double-check, in case we were racing with another goroutine
-	// that resolved this one
-	factory = r.resolved[mname]
-	if factory != nil {
-		return factory(), nil
-	}
-
-	// use descriptor source to resolve message type
-	d, err := r.source.FindSymbol(mname)
-	if err != nil {
-		return nil, err
-	}
-	md, ok := d.(*desc.MessageDescriptor)
-	if !ok {
-		return nil, fmt.Errorf("unknown message: %s", typeUrl)
-	}
-	// populate any extensions for this message, too (if there are any)
-	if exts, err := r.source.AllExtensionsForType(mname); err == nil {
-		if err := r.er.AddExtension(exts...); err != nil {
-			return nil, err
-		}
-	}
-
-	if r.mf == nil {
-		r.mf = dynamic.NewMessageFactoryWithExtensionRegistry(&r.er)
-	}
-
-	factory = func() proto.Message {
-		return r.mf.NewMessage(md)
-	}
-	if r.resolved == nil {
-		r.resolved = map[string]func() proto.Message{}
-	}
-	r.resolved[mname] = factory
-	return factory(), nil
-}
-
-// anyResolverWithFallback can provide a fallback value for unknown
-// messages that will format itself to JSON using an "@value" field
-// that has the base64-encoded data for the unknown message value.
-type anyResolverWithFallback struct {
-	jsonpb.AnyResolver
-}
-
-func (r anyResolverWithFallback) Resolve(typeUrl string) (proto.Message, error) {
-	msg, err := r.AnyResolver.Resolve(typeUrl)
-	if err == nil {
-		return msg, err
-	}
-
-	// Try "default" resolution logic. This mirrors the default behavior
-	// of jsonpb, which checks to see if the given message name is registered
-	// in the proto package.
-	mname := typeUrl
-	if slash := strings.LastIndex(mname, "/"); slash >= 0 {
-		mname = mname[slash+1:]
-	}
-	//lint:ignore SA1019 new non-deprecated API requires other code changes; deferring...
-	mt := proto.MessageType(mname)
-	if mt != nil {
-		return reflect.New(mt.Elem()).Interface().(proto.Message), nil
-	}
-
-	// finally, fallback to a special placeholder that can marshal itself
-	// to JSON using a special "@value" property to show base64-encoded
-	// data for the embedded message
-	return &unknownAny{TypeUrl: typeUrl, Error: fmt.Sprintf("%s is not recognized; see @value for raw binary message data", mname)}, nil
-}
-
-type unknownAny struct {
-	TypeUrl string `json:"@type"`
-	Error   string `json:"@error"`
-	Value   string `json:"@value"`
-}
-
-func (a *unknownAny) MarshalJSONPB(jsm *jsonpb.Marshaler) ([]byte, error) {
-	if jsm.Indent != "" {
-		return json.MarshalIndent(a, "", jsm.Indent)
-	}
-	return json.Marshal(a)
-}
-
-func (a *unknownAny) Unmarshal(b []byte) error {
-	a.Value = base64.StdEncoding.EncodeToString(b)
-	return nil
-}
-
-func (a *unknownAny) Reset() {
-	a.Value = ""
-}
-
-func (a *unknownAny) String() string {
-	b, err := a.MarshalJSONPB(&jsonpb.Marshaler{})
-	if err != nil {
-		return fmt.Sprintf("ERROR: %v", err.Error())
-	}
-	return string(b)
-}
-
-func (a *unknownAny) ProtoMessage() {
-}
-
-var _ proto.Message = (*unknownAny)(nil)
-
-// FormatOptions is a set of flags that are passed to a JSON or text formatter.
-type FormatOptions struct {
-	// EmitJSONDefaultFields flag, when true, includes empty/default values in the output.
-	// FormatJSON only flag.
-	EmitJSONDefaultFields bool
-
-	// AllowUnknownFields is an option for the parser. When true,
-	// it accepts input which includes unknown fields. These unknown fields
-	// are skipped instead of returning an error.
-	// FormatJSON only flag.
-	AllowUnknownFields bool
-
-	// IncludeTextSeparator is true then, when invoked to format multiple messages,
-	// all messages after the first one will be prefixed with the
-	// ASCII 'Record Separator' character (0x1E).
-	// It might be useful when the output is piped to another grpcurl process.
-	// FormatText only flag.
-	IncludeTextSeparator bool
-}
-
-// RequestParserAndFormatter returns a request parser and formatter for the
-// given format. The given descriptor source may be used for parsing message
-// data (if needed by the format).
-// It accepts a set of options. The field EmitJSONDefaultFields and IncludeTextSeparator
-// are options for JSON and protobuf text formats, respectively. The AllowUnknownFields field
-// is a JSON-only format flag.
-// Requests will be parsed from the given in.
-func RequestParserAndFormatter(format Format, descSource DescriptorSource, in io.Reader, opts FormatOptions) (RequestParser, Formatter, error) {
-	switch format {
-	case FormatJSON:
-		resolver := AnyResolverFromDescriptorSource(descSource)
-		unmarshaler := jsonpb.Unmarshaler{AnyResolver: resolver, AllowUnknownFields: opts.AllowUnknownFields}
-		return NewJSONRequestParserWithUnmarshaler(in, unmarshaler), NewJSONFormatter(opts.EmitJSONDefaultFields, anyResolverWithFallback{AnyResolver: resolver}), nil
-	case FormatText:
-		return NewTextRequestParser(in), NewTextFormatter(opts.IncludeTextSeparator), nil
-	default:
-		return nil, nil, fmt.Errorf("unknown format: %s", format)
 	}
+	mf := dynamic.NewMessageFactoryWithExtensionRegistry(&er)
+	return dynamic.AnyResolver(mf, files...), nil
 }
 
 // RequestParserAndFormatterFor returns a request parser and formatter for the
@@ -422,25 +211,29 @@ func RequestParserAndFormatter(format Format, descSource DescriptorSource, in io
 // data (if needed by the format). The flags emitJSONDefaultFields and
 // includeTextSeparator are options for JSON and protobuf text formats,
 // respectively. Requests will be parsed from the given in.
-// This function is deprecated. Please use RequestParserAndFormatter instead.
-// DEPRECATED
 func RequestParserAndFormatterFor(format Format, descSource DescriptorSource, emitJSONDefaultFields, includeTextSeparator bool, in io.Reader) (RequestParser, Formatter, error) {
-	return RequestParserAndFormatter(format, descSource, in, FormatOptions{
+	switch format {
-		EmitJSONDefaultFields: emitJSONDefaultFields,
+	case FormatJSON:
-		IncludeTextSeparator:  includeTextSeparator,
+		resolver, err := anyResolver(descSource)
-	})
+		if err != nil {
+			return nil, nil, fmt.Errorf("error creating message resolver: %v", err)
+		}
+		return NewJSONRequestParser(in, resolver), NewJSONFormatter(emitJSONDefaultFields, resolver), nil
+	case FormatText:
+		return NewTextRequestParser(in), NewTextFormatter(includeTextSeparator), nil
+	default:
+		return nil, nil, fmt.Errorf("unknown format: %s", format)
+	}
 }
 
 // DefaultEventHandler logs events to a writer. This is not thread-safe, but is
 // safe for use with InvokeRPC as long as NumResponses and Status are not read
 // until the call to InvokeRPC completes.
 type DefaultEventHandler struct {
-	Out       io.Writer
+	out        io.Writer
-	Formatter Formatter
+	descSource DescriptorSource
-	// 0 = default
+	formatter  func(proto.Message) (string, error)
-	// 1 = verbose
+	verbose    bool
-	// 2 = very verbose
-	VerbosityLevel int
 
 	// NumResponses is the number of responses that have been received.
 	NumResponses int
@@ -452,103 +245,53 @@ type DefaultEventHandler struct {
 // NewDefaultEventHandler returns an InvocationEventHandler that logs events to
 // the given output. If verbose is true, all events are logged. Otherwise, only
 // response messages are logged.
-//
-// Deprecated: NewDefaultEventHandler exists for compatibility.
-// It doesn't allow fine control over the `VerbosityLevel`
-// and provides only 0 and 1 options (which corresponds to the `verbose` argument).
-// Use DefaultEventHandler{} initializer directly.
 func NewDefaultEventHandler(out io.Writer, descSource DescriptorSource, formatter Formatter, verbose bool) *DefaultEventHandler {
-	verbosityLevel := 0
-	if verbose {
-		verbosityLevel = 1
-	}
 	return &DefaultEventHandler{
-		Out:            out,
+		out:        out,
-		Formatter:      formatter,
+		descSource: descSource,
-		VerbosityLevel: verbosityLevel,
+		formatter:  formatter,
+		verbose:    verbose,
 	}
 }
 
 var _ InvocationEventHandler = (*DefaultEventHandler)(nil)
 
 func (h *DefaultEventHandler) OnResolveMethod(md *desc.MethodDescriptor) {
-	if h.VerbosityLevel > 0 {
+	if h.verbose {
-		txt, err := GetDescriptorText(md, nil)
+		txt, err := GetDescriptorText(md, h.descSource)
 		if err == nil {
-			fmt.Fprintf(h.Out, "\nResolved method descriptor:\n%s\n", txt)
+			fmt.Fprintf(h.out, "\nResolved method descriptor:\n%s\n", txt)
 		}
 	}
 }
 
 func (h *DefaultEventHandler) OnSendHeaders(md metadata.MD) {
-	if h.VerbosityLevel > 0 {
+	if h.verbose {
-		fmt.Fprintf(h.Out, "\nRequest metadata to send:\n%s\n", MetadataToString(md))
+		fmt.Fprintf(h.out, "\nRequest metadata to send:\n%s\n", MetadataToString(md))
 	}
 }
 
 func (h *DefaultEventHandler) OnReceiveHeaders(md metadata.MD) {
-	if h.VerbosityLevel > 0 {
+	if h.verbose {
-		fmt.Fprintf(h.Out, "\nResponse headers received:\n%s\n", MetadataToString(md))
+		fmt.Fprintf(h.out, "\nResponse headers received:\n%s\n", MetadataToString(md))
 	}
 }
 
 func (h *DefaultEventHandler) OnReceiveResponse(resp proto.Message) {
 	h.NumResponses++
-	if h.VerbosityLevel > 1 {
+	if h.verbose {
-		fmt.Fprintf(h.Out, "\nEstimated response size: %d bytes\n", proto.Size(resp))
+		fmt.Fprint(h.out, "\nResponse contents:\n")
 	}
-	if h.VerbosityLevel > 0 {
+	if respStr, err := h.formatter(resp); err != nil {
-		fmt.Fprint(h.Out, "\nResponse contents:\n")
+		fmt.Fprintf(h.out, "Failed to format response message %d: %v\n", h.NumResponses, err)
-	}
-	if respStr, err := h.Formatter(resp); err != nil {
-		fmt.Fprintf(h.Out, "Failed to format response message %d: %v\n", h.NumResponses, err)
 	} else {
-		fmt.Fprintln(h.Out, respStr)
+		fmt.Fprintln(h.out, respStr)
 	}
 }
 
 func (h *DefaultEventHandler) OnReceiveTrailers(stat *status.Status, md metadata.MD) {
 	h.Status = stat
-	if h.VerbosityLevel > 0 {
+	if h.verbose {
-		fmt.Fprintf(h.Out, "\nResponse trailers received:\n%s\n", MetadataToString(md))
+		fmt.Fprintf(h.out, "\nResponse trailers received:\n%s\n", MetadataToString(md))
-	}
-}
-
-// PrintStatus prints details about the given status to the given writer. The given
-// formatter is used to print any detail messages that may be included in the status.
-// If the given status has a code of OK, "OK" is printed and that is all. Otherwise,
-// "ERROR:" is printed along with a line showing the code, one showing the message
-// string, and each detail message if any are present. The detail messages will be
-// printed as proto text format or JSON, depending on the given formatter.
-func PrintStatus(w io.Writer, stat *status.Status, formatter Formatter) {
-	if stat.Code() == codes.OK {
-		fmt.Fprintln(w, "OK")
-		return
-	}
-	fmt.Fprintf(w, "ERROR:\n  Code: %s\n  Message: %s\n", stat.Code().String(), stat.Message())
-
-	statpb := stat.Proto()
-	if len(statpb.Details) > 0 {
-		fmt.Fprintf(w, "  Details:\n")
-		for i, det := range statpb.Details {
-			prefix := fmt.Sprintf("  %d)", i+1)
-			fmt.Fprintf(w, "%s\t", prefix)
-			prefix = strings.Repeat(" ", len(prefix)) + "\t"
-
-			output, err := formatter(det)
-			if err != nil {
-				fmt.Fprintf(w, "Error parsing detail message: %v\n", err)
-			} else {
-				lines := strings.Split(output, "\n")
-				for i, line := range lines {
-					if i == 0 {
-						// first line is already indented
-						fmt.Fprintf(w, "%s\n", line)
-					} else {
-						fmt.Fprintf(w, "%s%s\n", prefix, line)
-					}
-				}
-			}
-		}
 	}
 }

format_test.go

@@ -7,15 +7,15 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/golang/protobuf/jsonpb"  //lint:ignore SA1019 we have to import these because some of their types appear in exported API
+	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"   //lint:ignore SA1019 same as above
+	"github.com/golang/protobuf/proto"
-	"github.com/jhump/protoreflect/desc" //lint:ignore SA1019 same as above
+	"github.com/golang/protobuf/ptypes/struct"
+	"github.com/jhump/protoreflect/desc"
 	"google.golang.org/grpc/metadata"
-	"google.golang.org/protobuf/types/known/structpb"
 )
 
 func TestRequestParser(t *testing.T) {
-	source, err := DescriptorSourceFromProtoSets("internal/testing/example.protoset")
+	source, err := DescriptorSourceFromProtoSets("testing/example.protoset")
 	if err != nil {
 		t.Fatalf("failed to create descriptor source: %v", err)
 	}
@@ -69,7 +69,7 @@ func TestRequestParser(t *testing.T) {
 
 	for i, tc := range testCases {
 		name := fmt.Sprintf("#%d, %s, %d message(s)", i+1, tc.format, len(tc.expectedOutput))
-		rf, _, err := RequestParserAndFormatter(tc.format, source, strings.NewReader(tc.input), FormatOptions{})
+		rf, _, err := RequestParserAndFormatterFor(tc.format, source, false, false, strings.NewReader(tc.input))
 		if err != nil {
 			t.Errorf("Failed to create parser and formatter: %v", err)
 			continue
@@ -97,7 +97,7 @@ func TestRequestParser(t *testing.T) {
 // Handler prints response data (and headers/trailers in verbose mode).
 // This verifies that we get the right output in both JSON and proto text modes.
 func TestHandler(t *testing.T) {
-	source, err := DescriptorSourceFromProtoSets("internal/testing/example.protoset")
+	source, err := DescriptorSourceFromProtoSets("testing/example.protoset")
 	if err != nil {
 		t.Fatalf("failed to create descriptor source: %v", err)
 	}
@@ -120,26 +120,20 @@ func TestHandler(t *testing.T) {
 
 	for _, format := range []Format{FormatJSON, FormatText} {
 		for _, numMessages := range []int{1, 3} {
-			for verbosityLevel := 0; verbosityLevel <= 2; verbosityLevel++ {
+			for _, verbose := range []bool{true, false} {
 				name := fmt.Sprintf("%s, %d message(s)", format, numMessages)
-				if verbosityLevel > 0 {
+				if verbose {
-					name += fmt.Sprintf(", verbosityLevel=%d", verbosityLevel)
+					name += ", verbose"
 				}
 
-				verbose := verbosityLevel > 0
+				_, formatter, err := RequestParserAndFormatterFor(format, source, false, !verbose, nil)
-
-				_, formatter, err := RequestParserAndFormatter(format, source, nil, FormatOptions{IncludeTextSeparator: !verbose})
 				if err != nil {
 					t.Errorf("Failed to create parser and formatter: %v", err)
 					continue
 				}
 
 				var buf bytes.Buffer
-				h := &DefaultEventHandler{
+				h := NewDefaultEventHandler(&buf, source, formatter, verbose)
-					Out:            &buf,
-					Formatter:      formatter,
-					VerbosityLevel: verbosityLevel,
-				}
 
 				h.OnResolveMethod(md)
 				h.OnSendHeaders(reqHeaders)
@@ -154,9 +148,6 @@ func TestHandler(t *testing.T) {
 					expectedOutput += verbosePrefix
 				}
 				for i := 0; i < numMessages; i++ {
-					if verbosityLevel > 1 {
-						expectedOutput += verboseResponseSize
-					}
 					if verbose {
 						expectedOutput += verboseResponseHeader
 					}
@@ -235,9 +226,6 @@ Response trailers received:
 a: 1
 b: 2
 c: 3
-`
-	verboseResponseSize = `
-Estimated response size: 100 bytes
 `
 	verboseResponseHeader = `
 Response contents:

go.mod

@@ -1,32 +1,8 @@
 module github.com/fullstorydev/grpcurl
 
-go 1.24.0
-
-toolchain go1.24.1
-
 require (
-	github.com/golang/protobuf v1.5.4
+	github.com/golang/protobuf v1.1.0
-	github.com/jhump/protoreflect v1.18.0
+	github.com/jhump/protoreflect v1.1.0
-	google.golang.org/grpc v1.66.2
+	golang.org/x/net v0.0.0-20180530234432-1e491301e022
-	google.golang.org/protobuf v1.36.11
+	google.golang.org/grpc v1.12.0
-)
-
-require (
-	cel.dev/expr v0.15.0 // indirect
-	cloud.google.com/go/compute/metadata v0.3.0 // indirect
-	github.com/census-instrumentation/opencensus-proto v0.4.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/cncf/xds/go v0.0.0-20240423153145-555b57ec207b // indirect
-	github.com/envoyproxy/go-control-plane v0.12.1-0.20240621013728-1eb8caab5155 // indirect
-	github.com/envoyproxy/protoc-gen-validate v1.0.4 // indirect
-	github.com/jhump/protoreflect/v2 v2.0.0-beta.1 // indirect
-	github.com/petermattis/goid v0.0.0-20260113132338-7c7de50cc741 // indirect
-	github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect
-	golang.org/x/net v0.38.0 // indirect
-	golang.org/x/oauth2 v0.27.0 // indirect
-	golang.org/x/sync v0.12.0 // indirect
-	golang.org/x/sys v0.31.0 // indirect
-	golang.org/x/text v0.23.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240604185151-ef581f913117 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240604185151-ef581f913117 // indirect
 )

go.sum

@@ -1,56 +1,13 @@
-cel.dev/expr v0.15.0 h1:O1jzfJCQBfL5BFoYktaxwIhuttaQPsVWerH9/EEKx0w=
+github.com/golang/protobuf v1.1.0 h1:0iH4Ffd/meGoXqF2lSAhZHt8X+cPgkfn/cb6Cce5Vpc=
-cel.dev/expr v0.15.0/go.mod h1:TRSuuV7DlVCE/uwv5QbAiW/v8l5O8C4eEPHeu7gf7Sg=
+github.com/golang/protobuf v1.1.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-cloud.google.com/go/compute/metadata v0.3.0 h1:Tz+eQXMEqDIKRsmY3cHTL6FVaynIjX2QxYC4trgAKZc=
+github.com/jhump/protoreflect v1.1.0 h1:h+zsMrsiq0vIl7yWmeowmd8e8VtnWk75U04GgXA2s6Y=
-cloud.google.com/go/compute/metadata v0.3.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k=
+github.com/jhump/protoreflect v1.1.0/go.mod h1:kG/zRVeS2M91gYaCvvUbPkMjjtFQS4qqjcPFzFkh2zE=
-github.com/bufbuild/protocompile v0.14.1 h1:iA73zAf/fyljNjQKwYzUHD6AD4R8KMasmwa/FBatYVw=
+golang.org/x/net v0.0.0-20180530234432-1e491301e022 h1:MVYFTUmVD3/+ERcvRRI+P/C2+WOUimXh+Pd8LVsklZ4=
-github.com/bufbuild/protocompile v0.14.1/go.mod h1:ppVdAIhbr2H8asPk6k4pY7t9zB1OU5DoEw9xY/FUi1c=
+golang.org/x/net v0.0.0-20180530234432-1e491301e022/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-github.com/census-instrumentation/opencensus-proto v0.4.1 h1:iKLQ0xPNFxR/2hzXZMrBo8f1j86j5WHzznCCQxV/b8g=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
-github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+google.golang.org/genproto v0.0.0-20170818100345-ee236bd376b0 h1:jgaHBfsPDMBDKsth1hPtI1HcOyecWndWOFSGW21VgaM=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+google.golang.org/genproto v0.0.0-20170818100345-ee236bd376b0/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-github.com/cncf/xds/go v0.0.0-20240423153145-555b57ec207b h1:ga8SEFjZ60pxLcmhnThWgvH2wg8376yUJmPhEH4H3kw=
+google.golang.org/grpc v1.8.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
-github.com/cncf/xds/go v0.0.0-20240423153145-555b57ec207b/go.mod h1:W+zGtBO5Y1IgJhy4+A9GOqVhqLpfZi+vwmdNXUehLA8=
+google.golang.org/grpc v1.12.0 h1:Mm8atZtkT+P6R43n/dqNDWkPPu5BwRVu/1rJnJCeZH8=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/envoyproxy/go-control-plane v0.12.1-0.20240621013728-1eb8caab5155 h1:IgJPqnrlY2Mr4pYB6oaMKvFvwJ9H+X6CCY5x1vCTcpc=
-github.com/envoyproxy/go-control-plane v0.12.1-0.20240621013728-1eb8caab5155/go.mod h1:5Wkq+JduFtdAXihLmeTJf+tRYIT4KBc2vPXDhwVo1pA=
-github.com/envoyproxy/protoc-gen-validate v1.0.4 h1:gVPz/FMfvh57HdSJQyvBtF00j8JU4zdyUgIUNhlgg0A=
-github.com/envoyproxy/protoc-gen-validate v1.0.4/go.mod h1:qys6tmnRsYrQqIhm2bvKZH4Blx/1gTIZ2UKVY1M+Yew=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/jhump/protoreflect v1.18.0 h1:TOz0MSR/0JOZ5kECB/0ufGnC2jdsgZ123Rd/k4Z5/2w=
-github.com/jhump/protoreflect v1.18.0/go.mod h1:ezWcltJIVF4zYdIFM+D/sHV4Oh5LNU08ORzCGfwvTz8=
-github.com/jhump/protoreflect/v2 v2.0.0-beta.1 h1:Dw1rslK/VotaUGYsv53XVWITr+5RCPXfvvlGrM/+B6w=
-github.com/jhump/protoreflect/v2 v2.0.0-beta.1/go.mod h1:D9LBEowZyv8/iSu97FU2zmXG3JxVTmNw21mu63niFzU=
-github.com/petermattis/goid v0.0.0-20260113132338-7c7de50cc741 h1:KPpdlQLZcHfTMQRi6bFQ7ogNO0ltFT4PmtwTLW4W+14=
-github.com/petermattis/goid v0.0.0-20260113132338-7c7de50cc741/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
-github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 h1:GFCKgmp0tecUJ0sJuv4pzYCqS9+RGSn52M3FUwPs+uo=
-github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1:t/avpk3KcrXxUnYOhZhMXJlSEyie6gQbtLq5NM3loB8=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/net v0.38.0 h1:vRMAPTMaeGqVhG5QyLJHqNDwecKTomGeqbnfZyKlBI8=
-golang.org/x/net v0.38.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8=
-golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M=
-golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8=
-golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw=
-golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
-golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
-golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
-google.golang.org/genproto/googleapis/api v0.0.0-20240604185151-ef581f913117 h1:+rdxYoE3E5htTEWIe15GlN6IfvbURM//Jt0mmkmm6ZU=
-google.golang.org/genproto/googleapis/api v0.0.0-20240604185151-ef581f913117/go.mod h1:OimBR/bc1wPO9iV4NC2bpyjy3VnAwZh5EBPQdtaE5oo=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240604185151-ef581f913117 h1:1GBuWVLM/KMVUv1t1En5Gs+gFZCNd360GGb4sSxtrhU=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240604185151-ef581f913117/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0=
-google.golang.org/grpc v1.66.2 h1:3QdXkuq3Bkh7w+ywLdLvM56cmGvQHUMZpiCzt6Rqaoo=
-google.golang.org/grpc v1.66.2/go.mod h1:s3/l6xSSCURdVfAnL+TqCNMyTDAGN6+lZeVxnZR128Y=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

grpcurl.go

@@ -8,34 +8,29 @@ package grpcurl
 
 import (
 	"bytes"
-	"context"
 	"crypto/tls"
 	"crypto/x509"
 	"encoding/base64"
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"net"
-	"os"
-	"regexp"
-	"slices"
 	"sort"
 	"strings"
+	"time"
 
-	"github.com/golang/protobuf/proto"   //lint:ignore SA1019 we have to import these because some of their types appear in exported API
+	"github.com/golang/protobuf/proto"
-	"github.com/jhump/protoreflect/desc" //lint:ignore SA1019 same as above
+	descpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
+	"github.com/golang/protobuf/ptypes"
+	"github.com/golang/protobuf/ptypes/empty"
+	"github.com/golang/protobuf/ptypes/struct"
+	"github.com/jhump/protoreflect/desc"
 	"github.com/jhump/protoreflect/desc/protoprint"
-	"github.com/jhump/protoreflect/dynamic" //lint:ignore SA1019 same as above
+	"github.com/jhump/protoreflect/dynamic"
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
-	"google.golang.org/grpc/credentials/insecure"
-	xdsCredentials "google.golang.org/grpc/credentials/xds"
-	_ "google.golang.org/grpc/health" // import grpc/health to enable transparent client side checking
 	"google.golang.org/grpc/metadata"
-	protov2 "google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/descriptorpb"
-	"google.golang.org/protobuf/types/known/anypb"
-	"google.golang.org/protobuf/types/known/emptypb"
-	"google.golang.org/protobuf/types/known/structpb"
 )
 
 // ListServices uses the given descriptor source to return a sorted list of fully-qualified
@@ -167,36 +162,6 @@ func MetadataFromHeaders(headers []string) metadata.MD {
 	return md
 }
 
-var envVarRegex = regexp.MustCompile(`\${\w+}`)
-
-// ExpandHeaders expands environment variables contained in the header string.
-// If no corresponding environment variable is found an error is returned.
-// TODO: Add escaping for `${`
-func ExpandHeaders(headers []string) ([]string, error) {
-	expandedHeaders := make([]string, len(headers))
-	for idx, header := range headers {
-		if header == "" {
-			continue
-		}
-		results := envVarRegex.FindAllString(header, -1)
-		if len(results) == 0 {
-			expandedHeaders[idx] = headers[idx]
-			continue
-		}
-		expandedHeader := header
-		for _, result := range results {
-			envVarName := result[2 : len(result)-1] // strip leading `${` and trailing `}`
-			envVarValue, ok := os.LookupEnv(envVarName)
-			if !ok {
-				return nil, fmt.Errorf("header %q refers to missing environment variable %q", header, envVarName)
-			}
-			expandedHeader = strings.Replace(expandedHeader, result, envVarValue, -1)
-		}
-		expandedHeaders[idx] = expandedHeader
-	}
-	return expandedHeaders, nil
-}
-
 var base64Codecs = []*base64.Encoding{base64.StdEncoding, base64.URLEncoding, base64.RawStdEncoding, base64.RawURLEncoding}
 
 func decode(val string) (string, error) {
@@ -331,7 +296,7 @@ func fetchAllExtensions(source DescriptorSource, ext *dynamic.ExtensionRegistry,
 	return nil
 }
 
-// fullyConvertToDynamic attempts to convert the given message to a dynamic message as well
+// fullConvertToDynamic attempts to convert the given message to a dynamic message as well
 // as any nested messages it may contain as field values. If the given message factory has
 // extensions registered that were not known when the given message was parsed, this effectively
 // allows re-parsing to identify those extensions.
@@ -409,9 +374,8 @@ func makeTemplate(md *desc.MessageDescriptor, path []*desc.MessageDescriptor) pr
 	case "google.protobuf.Any":
 		// empty type URL is not allowed by JSON representation
 		// so we must give it a dummy type
-		var anyVal anypb.Any
+		msg, _ := ptypes.MarshalAny(&empty.Empty{})
-		_ = anypb.MarshalFrom(&anyVal, &emptypb.Empty{}, protov2.MarshalOptions{})
+		return msg
-		return &anyVal
 	case "google.protobuf.Value":
 		// unset kind is not allowed by JSON representation
 		// so we must give it something
@@ -451,10 +415,12 @@ func makeTemplate(md *desc.MessageDescriptor, path []*desc.MessageDescriptor) pr
 	dm := dynamic.NewMessage(md)
 
 	// if the message is a recursive structure, we don't want to blow the stack
-	if slices.Contains(path, md) {
+	for _, seen := range path {
+		if seen == md {
 			// already visited this type; avoid infinite recursion
 			return dm
 		}
+	}
 	path = append(path, dm.GetMessageDescriptor())
 
 	// for repeated fields, add a single element with default value
@@ -464,42 +430,42 @@ func makeTemplate(md *desc.MessageDescriptor, path []*desc.MessageDescriptor) pr
 	for _, fd := range dm.GetMessageDescriptor().GetFields() {
 		if fd.IsRepeated() {
 			switch fd.GetType() {
-			case descriptorpb.FieldDescriptorProto_TYPE_FIXED32,
+			case descpb.FieldDescriptorProto_TYPE_FIXED32,
-				descriptorpb.FieldDescriptorProto_TYPE_UINT32:
+				descpb.FieldDescriptorProto_TYPE_UINT32:
 				dm.AddRepeatedField(fd, uint32(0))
 
-			case descriptorpb.FieldDescriptorProto_TYPE_SFIXED32,
+			case descpb.FieldDescriptorProto_TYPE_SFIXED32,
-				descriptorpb.FieldDescriptorProto_TYPE_SINT32,
+				descpb.FieldDescriptorProto_TYPE_SINT32,
-				descriptorpb.FieldDescriptorProto_TYPE_INT32,
+				descpb.FieldDescriptorProto_TYPE_INT32,
-				descriptorpb.FieldDescriptorProto_TYPE_ENUM:
+				descpb.FieldDescriptorProto_TYPE_ENUM:
 				dm.AddRepeatedField(fd, int32(0))
 
-			case descriptorpb.FieldDescriptorProto_TYPE_FIXED64,
+			case descpb.FieldDescriptorProto_TYPE_FIXED64,
-				descriptorpb.FieldDescriptorProto_TYPE_UINT64:
+				descpb.FieldDescriptorProto_TYPE_UINT64:
 				dm.AddRepeatedField(fd, uint64(0))
 
-			case descriptorpb.FieldDescriptorProto_TYPE_SFIXED64,
+			case descpb.FieldDescriptorProto_TYPE_SFIXED64,
-				descriptorpb.FieldDescriptorProto_TYPE_SINT64,
+				descpb.FieldDescriptorProto_TYPE_SINT64,
-				descriptorpb.FieldDescriptorProto_TYPE_INT64:
+				descpb.FieldDescriptorProto_TYPE_INT64:
 				dm.AddRepeatedField(fd, int64(0))
 
-			case descriptorpb.FieldDescriptorProto_TYPE_STRING:
+			case descpb.FieldDescriptorProto_TYPE_STRING:
 				dm.AddRepeatedField(fd, "")
 
-			case descriptorpb.FieldDescriptorProto_TYPE_BYTES:
+			case descpb.FieldDescriptorProto_TYPE_BYTES:
 				dm.AddRepeatedField(fd, []byte{})
 
-			case descriptorpb.FieldDescriptorProto_TYPE_BOOL:
+			case descpb.FieldDescriptorProto_TYPE_BOOL:
 				dm.AddRepeatedField(fd, false)
 
-			case descriptorpb.FieldDescriptorProto_TYPE_FLOAT:
+			case descpb.FieldDescriptorProto_TYPE_FLOAT:
 				dm.AddRepeatedField(fd, float32(0))
 
-			case descriptorpb.FieldDescriptorProto_TYPE_DOUBLE:
+			case descpb.FieldDescriptorProto_TYPE_DOUBLE:
 				dm.AddRepeatedField(fd, float64(0))
 
-			case descriptorpb.FieldDescriptorProto_TYPE_MESSAGE,
+			case descpb.FieldDescriptorProto_TYPE_MESSAGE,
-				descriptorpb.FieldDescriptorProto_TYPE_GROUP:
+				descpb.FieldDescriptorProto_TYPE_GROUP:
 				dm.AddRepeatedField(fd, makeTemplate(fd.GetMessageType(), path))
 			}
 		} else if fd.GetMessageType() != nil {
@@ -509,25 +475,11 @@ func makeTemplate(md *desc.MessageDescriptor, path []*desc.MessageDescriptor) pr
 	return dm
 }
 
-// ClientTransportCredentials is a helper function that constructs a TLS config with
+// ClientTransportCredentials builds transport credentials for a gRPC client using the
-// the given properties (see ClientTLSConfig) and then constructs and returns gRPC
-// transport credentials using that config.
-//
-// Deprecated: Use grpcurl.ClientTLSConfig and credentials.NewTLS instead.
-func ClientTransportCredentials(insecureSkipVerify bool, cacertFile, clientCertFile, clientKeyFile string) (credentials.TransportCredentials, error) {
-	tlsConf, err := ClientTLSConfig(insecureSkipVerify, cacertFile, clientCertFile, clientKeyFile)
-	if err != nil {
-		return nil, err
-	}
-
-	return credentials.NewTLS(tlsConf), nil
-}
-
-// ClientTLSConfig builds transport-layer config for a gRPC client using the
 // given properties. If cacertFile is blank, only standard trusted certs are used to
 // verify the server certs. If clientCertFile is blank, the client will not use a client
 // certificate. If clientCertFile is not blank then clientKeyFile must not be blank.
-func ClientTLSConfig(insecureSkipVerify bool, cacertFile, clientCertFile, clientKeyFile string) (*tls.Config, error) {
+func ClientTransportCredentials(insecureSkipVerify bool, cacertFile, clientCertFile, clientKeyFile string) (credentials.TransportCredentials, error) {
 	var tlsConf tls.Config
 
 	if clientCertFile != "" {
@@ -544,7 +496,7 @@ func ClientTLSConfig(insecureSkipVerify bool, cacertFile, clientCertFile, client
 	} else if cacertFile != "" {
 		// Create a certificate pool from the certificate authority
 		certPool := x509.NewCertPool()
-		ca, err := os.ReadFile(cacertFile)
+		ca, err := ioutil.ReadFile(cacertFile)
 		if err != nil {
 			return nil, fmt.Errorf("could not read ca certificate: %v", err)
 		}
@@ -557,7 +509,7 @@ func ClientTLSConfig(insecureSkipVerify bool, cacertFile, clientCertFile, client
 		tlsConf.RootCAs = certPool
 	}
 
-	return &tlsConf, nil
+	return credentials.NewTLS(&tlsConf), nil
 }
 
 // ServerTransportCredentials builds transport credentials for a gRPC server using the
@@ -581,7 +533,7 @@ func ServerTransportCredentials(cacertFile, serverCertFile, serverKeyFile string
 	if cacertFile != "" {
 		// Create a certificate pool from the certificate authority
 		certPool := x509.NewCertPool()
-		ca, err := os.ReadFile(cacertFile)
+		ca, err := ioutil.ReadFile(cacertFile)
 		if err != nil {
 			return nil, fmt.Errorf("could not read ca certificate: %v", err)
 		}
@@ -608,24 +560,7 @@ func ServerTransportCredentials(cacertFile, serverCertFile, serverKeyFile string
 // BlockingDial is a helper method to dial the given address, using optional TLS credentials,
 // and blocking until the returned connection is ready. If the given credentials are nil, the
 // connection will be insecure (plain-text).
-// The network parameter should be left empty in most cases when your address is a RFC 3986
-// compliant URI. The resolver from grpc-go will resolve the correct network type.
 func BlockingDial(ctx context.Context, network, address string, creds credentials.TransportCredentials, opts ...grpc.DialOption) (*grpc.ClientConn, error) {
-	if creds == nil {
-		creds = insecure.NewCredentials()
-	}
-
-	var err error
-	if strings.HasPrefix(address, "xds:///") {
-		// The xds:/// prefix is used to signal to the gRPC client to use an xDS server to resolve the
-		// target. The relevant credentials will be automatically pulled from the GRPC_XDS_BOOTSTRAP or
-		// GRPC_XDS_BOOTSTRAP_CONFIG env vars.
-		creds, err = xdsCredentials.NewClientCredentials(xdsCredentials.ClientOptions{FallbackCreds: creds})
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	// grpc.Dial doesn't provide any information on permanent connection errors (like
 	// TLS handshake failures). So in order to provide good error messages, we need a
 	// custom dialer that can provide that info. That means we manage the TLS handshake.
@@ -639,53 +574,36 @@ func BlockingDial(ctx context.Context, network, address string, creds credential
 		}
 	}
 
-	// custom credentials and dialer will notify on error via the
+	dialer := func(address string, timeout time.Duration) (net.Conn, error) {
-	// writeResult function
+		ctx, cancel := context.WithTimeout(ctx, timeout)
-	creds = &errSignalingCreds{
+		defer cancel()
-		TransportCredentials: creds,
-		writeResult:          writeResult,
-	}
 
-	switch network {
+		conn, err := (&net.Dialer{Cancel: ctx.Done()}).Dial(network, address)
-	case "":
-		// no-op, use address as-is
-	case "tcp":
-		if strings.HasPrefix(address, "unix://") {
-			return nil, fmt.Errorf("tcp network type cannot use unix address %s", address)
-		}
-	case "unix":
-		if !strings.HasPrefix(address, "unix://") {
-			// prepend unix:// to the address if it's not already there
-			// this is to maintain backwards compatibility because the custom dialer is replaced by
-			// the default dialer in grpc-go.
-			// https://github.com/fullstorydev/grpcurl/pull/480
-			address = "unix://" + address
-		}
-	default:
-		// custom dialer for other networks
-		dialer := func(ctx context.Context, address string) (net.Conn, error) {
-			conn, err := (&net.Dialer{}).DialContext(ctx, network, address)
 		if err != nil {
-				// capture the error so we can provide a better message
 			writeResult(err)
+			return nil, err
 		}
-			return conn, err
+		if creds != nil {
+			conn, _, err = creds.ClientHandshake(ctx, address, conn)
+			if err != nil {
+				writeResult(err)
+				return nil, err
 			}
-		opts = append([]grpc.DialOption{grpc.WithContextDialer(dialer)}, opts...)
+		}
+		return conn, nil
 	}
 
 	// Even with grpc.FailOnNonTempDialError, this call will usually timeout in
 	// the face of TLS handshake errors. So we can't rely on grpc.WithBlock() to
 	// know when we're done. So we run it in a goroutine and then use result
-	// channel to either get the connection or fail-fast.
+	// channel to either get the channel or fail-fast.
 	go func() {
-		// We put grpc.FailOnNonTempDialError *before* the explicitly provided
+		opts = append(opts,
-		// options so that it could be overridden.
+			grpc.WithBlock(),
-		opts = append([]grpc.DialOption{grpc.FailOnNonTempDialError(true)}, opts...)
+			grpc.FailOnNonTempDialError(true),
-		// But we don't want caller to be able to override these two, so we put
+			grpc.WithDialer(dialer),
-		// them *after* the explicitly provided options.
+			grpc.WithInsecure(), // we are handling TLS, so tell grpc not to
-		opts = append(opts, grpc.WithBlock(), grpc.WithTransportCredentials(creds))
+		)
-
 		conn, err := grpc.DialContext(ctx, address, opts...)
 		var res interface{}
 		if err != nil {
@@ -706,18 +624,3 @@ func BlockingDial(ctx context.Context, network, address string, creds credential
 		return nil, ctx.Err()
 	}
 }
-
-// errSignalingCreds is a wrapper around a TransportCredentials value, but
-// it will use the writeResult function to notify on error.
-type errSignalingCreds struct {
-	credentials.TransportCredentials
-	writeResult func(res interface{})
-}
-
-func (c *errSignalingCreds) ClientHandshake(ctx context.Context, addr string, rawConn net.Conn) (net.Conn, credentials.AuthInfo, error) {
-	conn, auth, err := c.TransportCredentials.ClientHandshake(ctx, addr, rawConn)
-	if err != nil {
-		c.writeResult(err)
-	}
-	return conn, auth, err
-}

grpcurl_test.go

@@ -1,7 +1,6 @@
 package grpcurl_test
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -12,20 +11,22 @@ import (
 	"testing"
 	"time"
 
-	"github.com/golang/protobuf/jsonpb"  //lint:ignore SA1019 we have to import these because some of their types appear in exported API
+	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"   //lint:ignore SA1019 same as above
+	jsonpbtest "github.com/golang/protobuf/jsonpb/jsonpb_test_proto"
-	"github.com/jhump/protoreflect/desc" //lint:ignore SA1019 same as above
+	"github.com/golang/protobuf/proto"
+	"github.com/jhump/protoreflect/desc"
 	"github.com/jhump/protoreflect/grpcreflect"
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/interop/grpc_testing"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/reflection"
+	reflectpb "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
 	"google.golang.org/grpc/status"
 
 	. "github.com/fullstorydev/grpcurl"
-	grpcurl_testing "github.com/fullstorydev/grpcurl/internal/testing"
+	grpcurl_testing "github.com/fullstorydev/grpcurl/testing"
-	jsonpbtest "github.com/fullstorydev/grpcurl/internal/testing/jsonpb_test_proto"
 )
 
 var (
@@ -51,18 +52,18 @@ type descSourceCase struct {
 
 func TestMain(m *testing.M) {
 	var err error
-	sourceProtoset, err = DescriptorSourceFromProtoSets("internal/testing/test.protoset")
+	sourceProtoset, err = DescriptorSourceFromProtoSets("testing/test.protoset")
 	if err != nil {
 		panic(err)
 	}
-	sourceProtoFiles, err = DescriptorSourceFromProtoFiles([]string{"internal/testing"}, "test.proto")
+	sourceProtoFiles, err = DescriptorSourceFromProtoFiles(nil, "testing/test.proto")
 	if err != nil {
 		panic(err)
 	}
 
 	// Create a server that includes the reflection service
 	svrReflect := grpc.NewServer()
-	grpcurl_testing.RegisterTestServiceServer(svrReflect, grpcurl_testing.TestServer{})
+	grpc_testing.RegisterTestServiceServer(svrReflect, grpcurl_testing.TestServer{})
 	reflection.Register(svrReflect)
 	var portReflect int
 	if l, err := net.Listen("tcp", "127.0.0.1:0"); err != nil {
@@ -77,18 +78,18 @@ func TestMain(m *testing.M) {
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 	if ccReflect, err = grpc.DialContext(ctx, fmt.Sprintf("127.0.0.1:%d", portReflect),
-		grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock()); err != nil {
+		grpc.WithInsecure(), grpc.WithBlock()); err != nil {
 		panic(err)
 	}
 	defer ccReflect.Close()
-	refClient := grpcreflect.NewClientAuto(context.Background(), ccReflect)
+	refClient := grpcreflect.NewClient(context.Background(), reflectpb.NewServerReflectionClient(ccReflect))
 	defer refClient.Reset()
 
 	sourceReflect = DescriptorSourceFromServer(context.Background(), refClient)
 
 	// Also create a server that does *not* include the reflection service
 	svrProtoset := grpc.NewServer()
-	grpcurl_testing.RegisterTestServiceServer(svrProtoset, grpcurl_testing.TestServer{})
+	grpc_testing.RegisterTestServiceServer(svrProtoset, grpcurl_testing.TestServer{})
 	var portProtoset int
 	if l, err := net.Listen("tcp", "127.0.0.1:0"); err != nil {
 		panic(err)
@@ -102,7 +103,7 @@ func TestMain(m *testing.M) {
 	ctx, cancel = context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 	if ccNoReflect, err = grpc.DialContext(ctx, fmt.Sprintf("127.0.0.1:%d", portProtoset),
-		grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock()); err != nil {
+		grpc.WithInsecure(), grpc.WithBlock()); err != nil {
 		panic(err)
 	}
 	defer ccNoReflect.Close()
@@ -117,7 +118,7 @@ func TestMain(m *testing.M) {
 }
 
 func TestServerDoesNotSupportReflection(t *testing.T) {
-	refClient := grpcreflect.NewClientAuto(context.Background(), ccNoReflect)
+	refClient := grpcreflect.NewClient(context.Background(), reflectpb.NewServerReflectionClient(ccNoReflect))
 	defer refClient.Reset()
 
 	refSource := DescriptorSourceFromServer(context.Background(), refClient)
@@ -140,7 +141,7 @@ func TestServerDoesNotSupportReflection(t *testing.T) {
 }
 
 func TestProtosetWithImports(t *testing.T) {
-	sourceProtoset, err := DescriptorSourceFromProtoSets("internal/testing/example.protoset")
+	sourceProtoset, err := DescriptorSourceFromProtoSets("testing/example.protoset")
 	if err != nil {
 		t.Fatalf("failed to load protoset: %v", err)
 	}
@@ -177,11 +178,11 @@ func doTestListServices(t *testing.T, source DescriptorSource, includeReflection
 	var expected []string
 	if includeReflection {
 		// when using server reflection, we see the TestService as well as the ServerReflection service
-		expected = []string{"grpc.reflection.v1.ServerReflection", "grpc.reflection.v1alpha.ServerReflection", "testing.TestService"}
+		expected = []string{"grpc.reflection.v1alpha.ServerReflection", "grpc.testing.TestService"}
 	} else {
 		// without reflection, we see all services defined in the same test.proto file, which is the
 		// TestService as well as UnimplementedService
-		expected = []string{"testing.TestService", "testing.UnimplementedService"}
+		expected = []string{"grpc.testing.TestService", "grpc.testing.UnimplementedService"}
 	}
 	if !reflect.DeepEqual(expected, names) {
 		t.Errorf("ListServices returned wrong results: wanted %v, got %v", expected, names)
@@ -197,17 +198,17 @@ func TestListMethods(t *testing.T) {
 }
 
 func doTestListMethods(t *testing.T, source DescriptorSource, includeReflection bool) {
-	names, err := ListMethods(source, "testing.TestService")
+	names, err := ListMethods(source, "grpc.testing.TestService")
 	if err != nil {
 		t.Fatalf("failed to list methods for TestService: %v", err)
 	}
 	expected := []string{
-		"testing.TestService.EmptyCall",
+		"grpc.testing.TestService.EmptyCall",
-		"testing.TestService.FullDuplexCall",
+		"grpc.testing.TestService.FullDuplexCall",
-		"testing.TestService.HalfDuplexCall",
+		"grpc.testing.TestService.HalfDuplexCall",
-		"testing.TestService.StreamingInputCall",
+		"grpc.testing.TestService.StreamingInputCall",
-		"testing.TestService.StreamingOutputCall",
+		"grpc.testing.TestService.StreamingOutputCall",
-		"testing.TestService.UnaryCall",
+		"grpc.testing.TestService.UnaryCall",
 	}
 	if !reflect.DeepEqual(expected, names) {
 		t.Errorf("ListMethods returned wrong results: wanted %v, got %v", expected, names)
@@ -215,19 +216,19 @@ func doTestListMethods(t *testing.T, source DescriptorSource, includeReflection
 
 	if includeReflection {
 		// when using server reflection, we see the TestService as well as the ServerReflection service
-		names, err = ListMethods(source, "grpc.reflection.v1.ServerReflection")
+		names, err = ListMethods(source, "grpc.reflection.v1alpha.ServerReflection")
 		if err != nil {
 			t.Fatalf("failed to list methods for ServerReflection: %v", err)
 		}
-		expected = []string{"grpc.reflection.v1.ServerReflection.ServerReflectionInfo"}
+		expected = []string{"grpc.reflection.v1alpha.ServerReflection.ServerReflectionInfo"}
 	} else {
 		// without reflection, we see all services defined in the same test.proto file, which is the
 		// TestService as well as UnimplementedService
-		names, err = ListMethods(source, "testing.UnimplementedService")
+		names, err = ListMethods(source, "grpc.testing.UnimplementedService")
 		if err != nil {
 			t.Fatalf("failed to list methods for ServerReflection: %v", err)
 		}
-		expected = []string{"testing.UnimplementedService.UnimplementedCall"}
+		expected = []string{"grpc.testing.UnimplementedService.UnimplementedCall"}
 	}
 	if !reflect.DeepEqual(expected, names) {
 		t.Errorf("ListMethods returned wrong results: wanted %v, got %v", expected, names)
@@ -241,10 +242,10 @@ func doTestListMethods(t *testing.T, source DescriptorSource, includeReflection
 }
 
 func TestGetAllFiles(t *testing.T) {
-	expectedFiles := []string{"test.proto"}
+	expectedFiles := []string{"testing/test.proto"}
-	expectedFilesWithReflection := []string{
+	// server reflection picks up filename from linked in Go package,
-		"grpc/reflection/v1/reflection.proto", "grpc/reflection/v1alpha/reflection.proto", "test.proto",
+	// which indicates "grpc_testing/test.proto", not our local copy.
-	}
+	expectedFilesWithReflection := []string{"grpc_reflection_v1alpha/reflection.proto", "grpc_testing/test.proto"}
 
 	for _, ds := range descSources {
 		t.Run(ds.name, func(t *testing.T) {
@@ -253,26 +254,22 @@ func TestGetAllFiles(t *testing.T) {
 				t.Fatalf("failed to get all files: %v", err)
 			}
 			names := fileNames(files)
-			match := false
+			expected := expectedFiles
-			var expected []string
 			if ds.includeRefl {
 				expected = expectedFilesWithReflection
-			} else {
-				expected = expectedFiles
 			}
-			match = reflect.DeepEqual(expected, names)
+			if !reflect.DeepEqual(expected, names) {
-			if !match {
 				t.Errorf("GetAllFiles returned wrong results: wanted %v, got %v", expected, names)
 			}
 		})
 	}
 
 	// try cases with more complicated set of files
-	otherSourceProtoset, err := DescriptorSourceFromProtoSets("internal/testing/test.protoset", "internal/testing/example.protoset")
+	otherSourceProtoset, err := DescriptorSourceFromProtoSets("testing/test.protoset", "testing/example.protoset")
 	if err != nil {
 		t.Fatal(err.Error())
 	}
-	otherSourceProtoFiles, err := DescriptorSourceFromProtoFiles([]string{"internal/testing"}, "test.proto", "example.proto")
+	otherSourceProtoFiles, err := DescriptorSourceFromProtoFiles(nil, "testing/test.proto", "testing/example.proto")
 	if err != nil {
 		t.Fatal(err.Error())
 	}
@@ -281,13 +278,13 @@ func TestGetAllFiles(t *testing.T) {
 		{"proto[b]", otherSourceProtoFiles, false},
 	}
 	expectedFiles = []string{
-		"example.proto",
-		"example2.proto",
 		"google/protobuf/any.proto",
 		"google/protobuf/descriptor.proto",
 		"google/protobuf/empty.proto",
 		"google/protobuf/timestamp.proto",
-		"test.proto",
+		"testing/example.proto",
+		"testing/example2.proto",
+		"testing/test.proto",
 	}
 	for _, ds := range otherDescSources {
 		t.Run(ds.name, func(t *testing.T) {
@@ -303,33 +300,6 @@ func TestGetAllFiles(t *testing.T) {
 	}
 }
 
-func TestExpandHeaders(t *testing.T) {
-	inHeaders := []string{"key1: ${value}", "key2: bar", "key3: ${woo", "key4: woo}", "key5: ${TEST}",
-		"key6: ${TEST_VAR}", "${TEST}: ${TEST_VAR}", "key8: ${EMPTY}"}
-	os.Setenv("value", "value")
-	os.Setenv("TEST", "value5")
-	os.Setenv("TEST_VAR", "value6")
-	os.Setenv("EMPTY", "")
-	expectedHeaders := map[string]bool{"key1: value": true, "key2: bar": true, "key3: ${woo": true, "key4: woo}": true,
-		"key5: value5": true, "key6: value6": true, "value5: value6": true, "key8: ": true}
-
-	outHeaders, err := ExpandHeaders(inHeaders)
-	if err != nil {
-		t.Errorf("The ExpandHeaders function generated an unexpected error %s", err)
-	}
-	for _, expandedHeader := range outHeaders {
-		if _, ok := expectedHeaders[expandedHeader]; !ok {
-			t.Errorf("The ExpandHeaders function has returned an unexpected header. Received unexpected header %s", expandedHeader)
-		}
-	}
-
-	badHeaders := []string{"key: ${DNE}"}
-	_, err = ExpandHeaders(badHeaders)
-	if err == nil {
-		t.Errorf("The ExpandHeaders function should return an error for missing environment variables %q", badHeaders)
-	}
-}
-
 func fileNames(files []*desc.FileDescriptor) []string {
 	names := make([]string, len(files))
 	for i, f := range files {
@@ -392,7 +362,7 @@ func TestDescribe(t *testing.T) {
 }
 
 func doTestDescribe(t *testing.T, source DescriptorSource) {
-	sym := "testing.TestService.EmptyCall"
+	sym := "grpc.testing.TestService.EmptyCall"
 	dsc, err := source.FindSymbol(sym)
 	if err != nil {
 		t.Fatalf("failed to get descriptor for %q: %v", sym, err)
@@ -403,14 +373,14 @@ func doTestDescribe(t *testing.T, source DescriptorSource) {
 	txt := proto.MarshalTextString(dsc.AsProto())
 	expected :=
 		`name: "EmptyCall"
-input_type: ".testing.Empty"
+input_type: ".grpc.testing.Empty"
-output_type: ".testing.Empty"
+output_type: ".grpc.testing.Empty"
 `
 	if expected != txt {
 		t.Errorf("descriptor mismatch: expected %s, got %s", expected, txt)
 	}
 
-	sym = "testing.StreamingOutputCallResponse"
+	sym = "grpc.testing.StreamingOutputCallResponse"
 	dsc, err = source.FindSymbol(sym)
 	if err != nil {
 		t.Fatalf("failed to get descriptor for %q: %v", sym, err)
@@ -426,7 +396,7 @@ field: <
   number: 1
   label: LABEL_OPTIONAL
   type: TYPE_MESSAGE
-  type_name: ".testing.Payload"
+  type_name: ".grpc.testing.Payload"
   json_name: "payload"
 >
 `
@@ -482,12 +452,12 @@ func TestUnary(t *testing.T) {
 func doTestUnary(t *testing.T, cc *grpc.ClientConn, source DescriptorSource) {
 	// Success
 	h := &handler{reqMessages: []string{payload1}}
-	err := InvokeRpc(context.Background(), source, cc, "testing.TestService/UnaryCall", makeHeaders(codes.OK), h, h.getRequestData)
+	err := InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/UnaryCall", makeHeaders(codes.OK), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	if h.check(t, "testing.TestService.UnaryCall", codes.OK, 1, 1) {
+	if h.check(t, "grpc.testing.TestService.UnaryCall", codes.OK, 1, 1) {
 		if h.respMessages[0] != payload1 {
 			t.Errorf("unexpected response from RPC: expecting %s; got %s", payload1, h.respMessages[0])
 		}
@@ -495,12 +465,12 @@ func doTestUnary(t *testing.T, cc *grpc.ClientConn, source DescriptorSource) {
 
 	// Failure
 	h = &handler{reqMessages: []string{payload1}}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/UnaryCall", makeHeaders(codes.NotFound), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/UnaryCall", makeHeaders(codes.NotFound), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.UnaryCall", codes.NotFound, 1, 0)
+	h.check(t, "grpc.testing.TestService.UnaryCall", codes.NotFound, 1, 0)
 }
 
 func TestClientStream(t *testing.T) {
@@ -514,12 +484,12 @@ func TestClientStream(t *testing.T) {
 func doTestClientStream(t *testing.T, cc *grpc.ClientConn, source DescriptorSource) {
 	// Success
 	h := &handler{reqMessages: []string{payload1, payload2, payload3}}
-	err := InvokeRpc(context.Background(), source, cc, "testing.TestService/StreamingInputCall", makeHeaders(codes.OK), h, h.getRequestData)
+	err := InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/StreamingInputCall", makeHeaders(codes.OK), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	if h.check(t, "testing.TestService.StreamingInputCall", codes.OK, 3, 1) {
+	if h.check(t, "grpc.testing.TestService.StreamingInputCall", codes.OK, 3, 1) {
 		expected :=
 			`{
   "aggregatedPayloadSize": 61
@@ -531,21 +501,21 @@ func doTestClientStream(t *testing.T, cc *grpc.ClientConn, source DescriptorSour
 
 	// Fail fast (server rejects as soon as possible)
 	h = &handler{reqMessages: []string{payload1, payload2, payload3}}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/StreamingInputCall", makeHeaders(codes.InvalidArgument), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/StreamingInputCall", makeHeaders(codes.InvalidArgument), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.StreamingInputCall", codes.InvalidArgument, -3, 0)
+	h.check(t, "grpc.testing.TestService.StreamingInputCall", codes.InvalidArgument, -3, 0)
 
 	// Fail late (server waits until stream is complete to reject)
 	h = &handler{reqMessages: []string{payload1, payload2, payload3}}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/StreamingInputCall", makeHeaders(codes.Internal, true), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/StreamingInputCall", makeHeaders(codes.Internal, true), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.StreamingInputCall", codes.Internal, 3, 0)
+	h.check(t, "grpc.testing.TestService.StreamingInputCall", codes.Internal, 3, 0)
 }
 
 func TestServerStream(t *testing.T) {
@@ -557,9 +527,9 @@ func TestServerStream(t *testing.T) {
 }
 
 func doTestServerStream(t *testing.T, cc *grpc.ClientConn, source DescriptorSource) {
-	req := &grpcurl_testing.StreamingOutputCallRequest{
+	req := &grpc_testing.StreamingOutputCallRequest{
-		ResponseType: grpcurl_testing.PayloadType_COMPRESSABLE,
+		ResponseType: grpc_testing.PayloadType_COMPRESSABLE,
-		ResponseParameters: []*grpcurl_testing.ResponseParameters{
+		ResponseParameters: []*grpc_testing.ResponseParameters{
 			{Size: 10}, {Size: 20}, {Size: 30}, {Size: 40}, {Size: 50},
 		},
 	}
@@ -570,19 +540,19 @@ func doTestServerStream(t *testing.T, cc *grpc.ClientConn, source DescriptorSour
 
 	// Success
 	h := &handler{reqMessages: []string{payload}}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/StreamingOutputCall", makeHeaders(codes.OK), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/StreamingOutputCall", makeHeaders(codes.OK), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	if h.check(t, "testing.TestService.StreamingOutputCall", codes.OK, 1, 5) {
+	if h.check(t, "grpc.testing.TestService.StreamingOutputCall", codes.OK, 1, 5) {
-		resp := &grpcurl_testing.StreamingOutputCallResponse{}
+		resp := &grpc_testing.StreamingOutputCallResponse{}
 		for i, msg := range h.respMessages {
 			if err := jsonpb.UnmarshalString(msg, resp); err != nil {
 				t.Errorf("failed to parse response %d: %v", i+1, err)
 			}
-			if resp.Payload.GetType() != grpcurl_testing.PayloadType_COMPRESSABLE {
+			if resp.Payload.GetType() != grpc_testing.PayloadType_COMPRESSABLE {
-				t.Errorf("response %d has wrong payload type; expecting %v, got %v", i, grpcurl_testing.PayloadType_COMPRESSABLE, resp.Payload.Type)
+				t.Errorf("response %d has wrong payload type; expecting %v, got %v", i, grpc_testing.PayloadType_COMPRESSABLE, resp.Payload.Type)
 			}
 			if len(resp.Payload.Body) != (i+1)*10 {
 				t.Errorf("response %d has wrong payload size; expecting %d, got %d", i, (i+1)*10, len(resp.Payload.Body))
@@ -593,21 +563,21 @@ func doTestServerStream(t *testing.T, cc *grpc.ClientConn, source DescriptorSour
 
 	// Fail fast (server rejects as soon as possible)
 	h = &handler{reqMessages: []string{payload}}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/StreamingOutputCall", makeHeaders(codes.Aborted), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/StreamingOutputCall", makeHeaders(codes.Aborted), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.StreamingOutputCall", codes.Aborted, 1, 0)
+	h.check(t, "grpc.testing.TestService.StreamingOutputCall", codes.Aborted, 1, 0)
 
 	// Fail late (server waits until stream is complete to reject)
 	h = &handler{reqMessages: []string{payload}}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/StreamingOutputCall", makeHeaders(codes.AlreadyExists, true), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/StreamingOutputCall", makeHeaders(codes.AlreadyExists, true), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.StreamingOutputCall", codes.AlreadyExists, 1, 5)
+	h.check(t, "grpc.testing.TestService.StreamingOutputCall", codes.AlreadyExists, 1, 5)
 }
 
 func TestHalfDuplexStream(t *testing.T) {
@@ -623,12 +593,12 @@ func doTestHalfDuplexStream(t *testing.T, cc *grpc.ClientConn, source Descriptor
 
 	// Success
 	h := &handler{reqMessages: reqs}
-	err := InvokeRpc(context.Background(), source, cc, "testing.TestService/HalfDuplexCall", makeHeaders(codes.OK), h, h.getRequestData)
+	err := InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/HalfDuplexCall", makeHeaders(codes.OK), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	if h.check(t, "testing.TestService.HalfDuplexCall", codes.OK, 3, 3) {
+	if h.check(t, "grpc.testing.TestService.HalfDuplexCall", codes.OK, 3, 3) {
 		for i, resp := range h.respMessages {
 			if resp != reqs[i] {
 				t.Errorf("unexpected response %d from RPC:\nexpecting %q\ngot %q", i, reqs[i], resp)
@@ -638,21 +608,21 @@ func doTestHalfDuplexStream(t *testing.T, cc *grpc.ClientConn, source Descriptor
 
 	// Fail fast (server rejects as soon as possible)
 	h = &handler{reqMessages: reqs}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/HalfDuplexCall", makeHeaders(codes.Canceled), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/HalfDuplexCall", makeHeaders(codes.Canceled), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.HalfDuplexCall", codes.Canceled, -3, 0)
+	h.check(t, "grpc.testing.TestService.HalfDuplexCall", codes.Canceled, -3, 0)
 
 	// Fail late (server waits until stream is complete to reject)
 	h = &handler{reqMessages: reqs}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/HalfDuplexCall", makeHeaders(codes.DataLoss, true), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/HalfDuplexCall", makeHeaders(codes.DataLoss, true), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.HalfDuplexCall", codes.DataLoss, 3, 3)
+	h.check(t, "grpc.testing.TestService.HalfDuplexCall", codes.DataLoss, 3, 3)
 }
 
 func TestFullDuplexStream(t *testing.T) {
@@ -665,11 +635,11 @@ func TestFullDuplexStream(t *testing.T) {
 
 func doTestFullDuplexStream(t *testing.T, cc *grpc.ClientConn, source DescriptorSource) {
 	reqs := make([]string, 3)
-	req := &grpcurl_testing.StreamingOutputCallRequest{
+	req := &grpc_testing.StreamingOutputCallRequest{
-		ResponseType: grpcurl_testing.PayloadType_RANDOM,
+		ResponseType: grpc_testing.PayloadType_RANDOM,
 	}
 	for i := range reqs {
-		req.ResponseParameters = append(req.ResponseParameters, &grpcurl_testing.ResponseParameters{Size: int32((i + 1) * 10)})
+		req.ResponseParameters = append(req.ResponseParameters, &grpc_testing.ResponseParameters{Size: int32((i + 1) * 10)})
 		payload, err := (&jsonpb.Marshaler{}).MarshalToString(req)
 		if err != nil {
 			t.Fatalf("failed to construct request %d: %v", i, err)
@@ -679,13 +649,13 @@ func doTestFullDuplexStream(t *testing.T, cc *grpc.ClientConn, source Descriptor
 
 	// Success
 	h := &handler{reqMessages: reqs}
-	err := InvokeRpc(context.Background(), source, cc, "testing.TestService/FullDuplexCall", makeHeaders(codes.OK), h, h.getRequestData)
+	err := InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/FullDuplexCall", makeHeaders(codes.OK), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	if h.check(t, "testing.TestService.FullDuplexCall", codes.OK, 3, 6) {
+	if h.check(t, "grpc.testing.TestService.FullDuplexCall", codes.OK, 3, 6) {
-		resp := &grpcurl_testing.StreamingOutputCallResponse{}
+		resp := &grpc_testing.StreamingOutputCallResponse{}
 		i := 0
 		for j := 1; j < 3; j++ {
 			// three requests
@@ -695,8 +665,8 @@ func doTestFullDuplexStream(t *testing.T, cc *grpc.ClientConn, source Descriptor
 				if err := jsonpb.UnmarshalString(msg, resp); err != nil {
 					t.Errorf("failed to parse response %d: %v", i+1, err)
 				}
-				if resp.Payload.GetType() != grpcurl_testing.PayloadType_RANDOM {
+				if resp.Payload.GetType() != grpc_testing.PayloadType_RANDOM {
-					t.Errorf("response %d has wrong payload type; expecting %v, got %v", i, grpcurl_testing.PayloadType_RANDOM, resp.Payload.Type)
+					t.Errorf("response %d has wrong payload type; expecting %v, got %v", i, grpc_testing.PayloadType_RANDOM, resp.Payload.Type)
 				}
 				if len(resp.Payload.Body) != (k+1)*10 {
 					t.Errorf("response %d has wrong payload size; expecting %d, got %d", i, (k+1)*10, len(resp.Payload.Body))
@@ -710,21 +680,21 @@ func doTestFullDuplexStream(t *testing.T, cc *grpc.ClientConn, source Descriptor
 
 	// Fail fast (server rejects as soon as possible)
 	h = &handler{reqMessages: reqs}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/FullDuplexCall", makeHeaders(codes.PermissionDenied), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/FullDuplexCall", makeHeaders(codes.PermissionDenied), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.FullDuplexCall", codes.PermissionDenied, -3, 0)
+	h.check(t, "grpc.testing.TestService.FullDuplexCall", codes.PermissionDenied, -3, 0)
 
 	// Fail late (server waits until stream is complete to reject)
 	h = &handler{reqMessages: reqs}
-	err = InvokeRpc(context.Background(), source, cc, "testing.TestService/FullDuplexCall", makeHeaders(codes.ResourceExhausted, true), h, h.getRequestData)
+	err = InvokeRpc(context.Background(), source, cc, "grpc.testing.TestService/FullDuplexCall", makeHeaders(codes.ResourceExhausted, true), h, h.getRequestData)
 	if err != nil {
 		t.Fatalf("unexpected error during RPC: %v", err)
 	}
 
-	h.check(t, "testing.TestService.FullDuplexCall", codes.ResourceExhausted, 3, 6)
+	h.check(t, "grpc.testing.TestService.FullDuplexCall", codes.ResourceExhausted, 3, 6)
 }
 
 type handler struct {

internal/testing/cmd/bankdemo/bank_grpc.pb.go

@@ -1,374 +0,0 @@
-// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
-
-package main
-
-import (
-	context "context"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-	emptypb "google.golang.org/protobuf/types/known/emptypb"
-)
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
-
-// BankClient is the client API for Bank service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
-type BankClient interface {
-	// OpenAccount creates an account with the type and given initial deposit
-	// as its balance.
-	OpenAccount(ctx context.Context, in *OpenAccountRequest, opts ...grpc.CallOption) (*Account, error)
-	// CloseAccount closes the indicated account. An account can only be
-	// closed if its balance is zero.
-	CloseAccount(ctx context.Context, in *CloseAccountRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
-	// GetAccounts lists all accounts for the current customer.
-	GetAccounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetAccountsResponse, error)
-	// GetTransactions streams all transactions that match the given criteria.
-	// If the given start date is not specified, transactions since beginning
-	// of time are included. Similarly, if the given end date is not specified,
-	// transactions all the way to the presnet are included.
-	GetTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (Bank_GetTransactionsClient, error)
-	// Deposit increases the balance of an account by depositing funds into it.
-	Deposit(ctx context.Context, in *DepositRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
-	// Withdraw decreases the balance of an account by withdrawing funds from it.
-	Withdraw(ctx context.Context, in *WithdrawRequest, opts ...grpc.CallOption) (*BalanceResponse, error)
-	// Transfer moves money from one account to another. The source and destination
-	// accounts can be with this bank (e.g. "local" account numbers) or can be
-	// external accounts, identified by their ACH routing and account numbers.
-	Transfer(ctx context.Context, in *TransferRequest, opts ...grpc.CallOption) (*TransferResponse, error)
-}
-
-type bankClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewBankClient(cc grpc.ClientConnInterface) BankClient {
-	return &bankClient{cc}
-}
-
-func (c *bankClient) OpenAccount(ctx context.Context, in *OpenAccountRequest, opts ...grpc.CallOption) (*Account, error) {
-	out := new(Account)
-	err := c.cc.Invoke(ctx, "/Bank/OpenAccount", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *bankClient) CloseAccount(ctx context.Context, in *CloseAccountRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
-	out := new(emptypb.Empty)
-	err := c.cc.Invoke(ctx, "/Bank/CloseAccount", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *bankClient) GetAccounts(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*GetAccountsResponse, error) {
-	out := new(GetAccountsResponse)
-	err := c.cc.Invoke(ctx, "/Bank/GetAccounts", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *bankClient) GetTransactions(ctx context.Context, in *GetTransactionsRequest, opts ...grpc.CallOption) (Bank_GetTransactionsClient, error) {
-	stream, err := c.cc.NewStream(ctx, &Bank_ServiceDesc.Streams[0], "/Bank/GetTransactions", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &bankGetTransactionsClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type Bank_GetTransactionsClient interface {
-	Recv() (*Transaction, error)
-	grpc.ClientStream
-}
-
-type bankGetTransactionsClient struct {
-	grpc.ClientStream
-}
-
-func (x *bankGetTransactionsClient) Recv() (*Transaction, error) {
-	m := new(Transaction)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *bankClient) Deposit(ctx context.Context, in *DepositRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
-	out := new(BalanceResponse)
-	err := c.cc.Invoke(ctx, "/Bank/Deposit", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *bankClient) Withdraw(ctx context.Context, in *WithdrawRequest, opts ...grpc.CallOption) (*BalanceResponse, error) {
-	out := new(BalanceResponse)
-	err := c.cc.Invoke(ctx, "/Bank/Withdraw", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *bankClient) Transfer(ctx context.Context, in *TransferRequest, opts ...grpc.CallOption) (*TransferResponse, error) {
-	out := new(TransferResponse)
-	err := c.cc.Invoke(ctx, "/Bank/Transfer", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// BankServer is the server API for Bank service.
-// All implementations must embed UnimplementedBankServer
-// for forward compatibility
-type BankServer interface {
-	// OpenAccount creates an account with the type and given initial deposit
-	// as its balance.
-	OpenAccount(context.Context, *OpenAccountRequest) (*Account, error)
-	// CloseAccount closes the indicated account. An account can only be
-	// closed if its balance is zero.
-	CloseAccount(context.Context, *CloseAccountRequest) (*emptypb.Empty, error)
-	// GetAccounts lists all accounts for the current customer.
-	GetAccounts(context.Context, *emptypb.Empty) (*GetAccountsResponse, error)
-	// GetTransactions streams all transactions that match the given criteria.
-	// If the given start date is not specified, transactions since beginning
-	// of time are included. Similarly, if the given end date is not specified,
-	// transactions all the way to the presnet are included.
-	GetTransactions(*GetTransactionsRequest, Bank_GetTransactionsServer) error
-	// Deposit increases the balance of an account by depositing funds into it.
-	Deposit(context.Context, *DepositRequest) (*BalanceResponse, error)
-	// Withdraw decreases the balance of an account by withdrawing funds from it.
-	Withdraw(context.Context, *WithdrawRequest) (*BalanceResponse, error)
-	// Transfer moves money from one account to another. The source and destination
-	// accounts can be with this bank (e.g. "local" account numbers) or can be
-	// external accounts, identified by their ACH routing and account numbers.
-	Transfer(context.Context, *TransferRequest) (*TransferResponse, error)
-	mustEmbedUnimplementedBankServer()
-}
-
-// UnimplementedBankServer must be embedded to have forward compatible implementations.
-type UnimplementedBankServer struct {
-}
-
-func (UnimplementedBankServer) OpenAccount(context.Context, *OpenAccountRequest) (*Account, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method OpenAccount not implemented")
-}
-func (UnimplementedBankServer) CloseAccount(context.Context, *CloseAccountRequest) (*emptypb.Empty, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method CloseAccount not implemented")
-}
-func (UnimplementedBankServer) GetAccounts(context.Context, *emptypb.Empty) (*GetAccountsResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetAccounts not implemented")
-}
-func (UnimplementedBankServer) GetTransactions(*GetTransactionsRequest, Bank_GetTransactionsServer) error {
-	return status.Errorf(codes.Unimplemented, "method GetTransactions not implemented")
-}
-func (UnimplementedBankServer) Deposit(context.Context, *DepositRequest) (*BalanceResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Deposit not implemented")
-}
-func (UnimplementedBankServer) Withdraw(context.Context, *WithdrawRequest) (*BalanceResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Withdraw not implemented")
-}
-func (UnimplementedBankServer) Transfer(context.Context, *TransferRequest) (*TransferResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Transfer not implemented")
-}
-func (UnimplementedBankServer) mustEmbedUnimplementedBankServer() {}
-
-// UnsafeBankServer may be embedded to opt out of forward compatibility for this service.
-// Use of this interface is not recommended, as added methods to BankServer will
-// result in compilation errors.
-type UnsafeBankServer interface {
-	mustEmbedUnimplementedBankServer()
-}
-
-func RegisterBankServer(s grpc.ServiceRegistrar, srv BankServer) {
-	s.RegisterService(&Bank_ServiceDesc, srv)
-}
-
-func _Bank_OpenAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(OpenAccountRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BankServer).OpenAccount(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Bank/OpenAccount",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BankServer).OpenAccount(ctx, req.(*OpenAccountRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Bank_CloseAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(CloseAccountRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BankServer).CloseAccount(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Bank/CloseAccount",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BankServer).CloseAccount(ctx, req.(*CloseAccountRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Bank_GetAccounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(emptypb.Empty)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BankServer).GetAccounts(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Bank/GetAccounts",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BankServer).GetAccounts(ctx, req.(*emptypb.Empty))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Bank_GetTransactions_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(GetTransactionsRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(BankServer).GetTransactions(m, &bankGetTransactionsServer{stream})
-}
-
-type Bank_GetTransactionsServer interface {
-	Send(*Transaction) error
-	grpc.ServerStream
-}
-
-type bankGetTransactionsServer struct {
-	grpc.ServerStream
-}
-
-func (x *bankGetTransactionsServer) Send(m *Transaction) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func _Bank_Deposit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DepositRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BankServer).Deposit(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Bank/Deposit",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BankServer).Deposit(ctx, req.(*DepositRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Bank_Withdraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(WithdrawRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BankServer).Withdraw(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Bank/Withdraw",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BankServer).Withdraw(ctx, req.(*WithdrawRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Bank_Transfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(TransferRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BankServer).Transfer(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/Bank/Transfer",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BankServer).Transfer(ctx, req.(*TransferRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-// Bank_ServiceDesc is the grpc.ServiceDesc for Bank service.
-// It's only intended for direct use with grpc.RegisterService,
-// and not to be introspected or modified (even as a copy)
-var Bank_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "Bank",
-	HandlerType: (*BankServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "OpenAccount",
-			Handler:    _Bank_OpenAccount_Handler,
-		},
-		{
-			MethodName: "CloseAccount",
-			Handler:    _Bank_CloseAccount_Handler,
-		},
-		{
-			MethodName: "GetAccounts",
-			Handler:    _Bank_GetAccounts_Handler,
-		},
-		{
-			MethodName: "Deposit",
-			Handler:    _Bank_Deposit_Handler,
-		},
-		{
-			MethodName: "Withdraw",
-			Handler:    _Bank_Withdraw_Handler,
-		},
-		{
-			MethodName: "Transfer",
-			Handler:    _Bank_Transfer_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "GetTransactions",
-			Handler:       _Bank_GetTransactions_Handler,
-			ServerStreams: true,
-		},
-	},
-	Metadata: "bank.proto",
-}

internal/testing/cmd/bankdemo/support_grpc.pb.go

@@ -1,217 +0,0 @@
-// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
-
-package main
-
-import (
-	context "context"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
-
-// SupportClient is the client API for Support service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
-type SupportClient interface {
-	// ChatCustomer is used by a customer-facing app to send the customer's messages
-	// to a chat session. The customer is how initiates and terminates (via "hangup")
-	// a chat session. Only customers may invoke this method (e.g. requests must
-	// include customer auth credentials).
-	ChatCustomer(ctx context.Context, opts ...grpc.CallOption) (Support_ChatCustomerClient, error)
-	// ChatAgent is used by an agent-facing app to allow an agent to reply to a
-	// customer's messages in a chat session. The agent may accept a chat session,
-	// which defaults to the session awaiting an agent for the longest period of time
-	// (FIFO queue).
-	ChatAgent(ctx context.Context, opts ...grpc.CallOption) (Support_ChatAgentClient, error)
-}
-
-type supportClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewSupportClient(cc grpc.ClientConnInterface) SupportClient {
-	return &supportClient{cc}
-}
-
-func (c *supportClient) ChatCustomer(ctx context.Context, opts ...grpc.CallOption) (Support_ChatCustomerClient, error) {
-	stream, err := c.cc.NewStream(ctx, &Support_ServiceDesc.Streams[0], "/Support/ChatCustomer", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &supportChatCustomerClient{stream}
-	return x, nil
-}
-
-type Support_ChatCustomerClient interface {
-	Send(*ChatCustomerRequest) error
-	Recv() (*ChatCustomerResponse, error)
-	grpc.ClientStream
-}
-
-type supportChatCustomerClient struct {
-	grpc.ClientStream
-}
-
-func (x *supportChatCustomerClient) Send(m *ChatCustomerRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *supportChatCustomerClient) Recv() (*ChatCustomerResponse, error) {
-	m := new(ChatCustomerResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *supportClient) ChatAgent(ctx context.Context, opts ...grpc.CallOption) (Support_ChatAgentClient, error) {
-	stream, err := c.cc.NewStream(ctx, &Support_ServiceDesc.Streams[1], "/Support/ChatAgent", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &supportChatAgentClient{stream}
-	return x, nil
-}
-
-type Support_ChatAgentClient interface {
-	Send(*ChatAgentRequest) error
-	Recv() (*ChatAgentResponse, error)
-	grpc.ClientStream
-}
-
-type supportChatAgentClient struct {
-	grpc.ClientStream
-}
-
-func (x *supportChatAgentClient) Send(m *ChatAgentRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *supportChatAgentClient) Recv() (*ChatAgentResponse, error) {
-	m := new(ChatAgentResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// SupportServer is the server API for Support service.
-// All implementations must embed UnimplementedSupportServer
-// for forward compatibility
-type SupportServer interface {
-	// ChatCustomer is used by a customer-facing app to send the customer's messages
-	// to a chat session. The customer is how initiates and terminates (via "hangup")
-	// a chat session. Only customers may invoke this method (e.g. requests must
-	// include customer auth credentials).
-	ChatCustomer(Support_ChatCustomerServer) error
-	// ChatAgent is used by an agent-facing app to allow an agent to reply to a
-	// customer's messages in a chat session. The agent may accept a chat session,
-	// which defaults to the session awaiting an agent for the longest period of time
-	// (FIFO queue).
-	ChatAgent(Support_ChatAgentServer) error
-	mustEmbedUnimplementedSupportServer()
-}
-
-// UnimplementedSupportServer must be embedded to have forward compatible implementations.
-type UnimplementedSupportServer struct {
-}
-
-func (UnimplementedSupportServer) ChatCustomer(Support_ChatCustomerServer) error {
-	return status.Errorf(codes.Unimplemented, "method ChatCustomer not implemented")
-}
-func (UnimplementedSupportServer) ChatAgent(Support_ChatAgentServer) error {
-	return status.Errorf(codes.Unimplemented, "method ChatAgent not implemented")
-}
-func (UnimplementedSupportServer) mustEmbedUnimplementedSupportServer() {}
-
-// UnsafeSupportServer may be embedded to opt out of forward compatibility for this service.
-// Use of this interface is not recommended, as added methods to SupportServer will
-// result in compilation errors.
-type UnsafeSupportServer interface {
-	mustEmbedUnimplementedSupportServer()
-}
-
-func RegisterSupportServer(s grpc.ServiceRegistrar, srv SupportServer) {
-	s.RegisterService(&Support_ServiceDesc, srv)
-}
-
-func _Support_ChatCustomer_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SupportServer).ChatCustomer(&supportChatCustomerServer{stream})
-}
-
-type Support_ChatCustomerServer interface {
-	Send(*ChatCustomerResponse) error
-	Recv() (*ChatCustomerRequest, error)
-	grpc.ServerStream
-}
-
-type supportChatCustomerServer struct {
-	grpc.ServerStream
-}
-
-func (x *supportChatCustomerServer) Send(m *ChatCustomerResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *supportChatCustomerServer) Recv() (*ChatCustomerRequest, error) {
-	m := new(ChatCustomerRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func _Support_ChatAgent_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(SupportServer).ChatAgent(&supportChatAgentServer{stream})
-}
-
-type Support_ChatAgentServer interface {
-	Send(*ChatAgentResponse) error
-	Recv() (*ChatAgentRequest, error)
-	grpc.ServerStream
-}
-
-type supportChatAgentServer struct {
-	grpc.ServerStream
-}
-
-func (x *supportChatAgentServer) Send(m *ChatAgentResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *supportChatAgentServer) Recv() (*ChatAgentRequest, error) {
-	m := new(ChatAgentRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// Support_ServiceDesc is the grpc.ServiceDesc for Support service.
-// It's only intended for direct use with grpc.RegisterService,
-// and not to be introspected or modified (even as a copy)
-var Support_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "Support",
-	HandlerType: (*SupportServer)(nil),
-	Methods:     []grpc.MethodDesc{},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "ChatCustomer",
-			Handler:       _Support_ChatCustomer_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "ChatAgent",
-			Handler:       _Support_ChatAgent_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "support.proto",
-}

internal/testing/jsonpb_test_proto/test_objects.pb.go

@@ -1,344 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.25.0-devel
-// 	protoc        v3.14.0
-// source: test_objects.proto
-
-package jsonpb
-
-import (
-	proto "github.com/golang/protobuf/proto"
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-	anypb "google.golang.org/protobuf/types/known/anypb"
-	durationpb "google.golang.org/protobuf/types/known/durationpb"
-	structpb "google.golang.org/protobuf/types/known/structpb"
-	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
-	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
-	reflect "reflect"
-	sync "sync"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-// This is a compile-time assertion that a sufficiently up-to-date version
-// of the legacy proto package is being used.
-const _ = proto.ProtoPackageIsVersion4
-
-type KnownTypes struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	An    *anypb.Any              `protobuf:"bytes,14,opt,name=an" json:"an,omitempty"`
-	Dur   *durationpb.Duration    `protobuf:"bytes,1,opt,name=dur" json:"dur,omitempty"`
-	St    *structpb.Struct        `protobuf:"bytes,12,opt,name=st" json:"st,omitempty"`
-	Ts    *timestamppb.Timestamp  `protobuf:"bytes,2,opt,name=ts" json:"ts,omitempty"`
-	Lv    *structpb.ListValue     `protobuf:"bytes,15,opt,name=lv" json:"lv,omitempty"`
-	Val   *structpb.Value         `protobuf:"bytes,16,opt,name=val" json:"val,omitempty"`
-	Dbl   *wrapperspb.DoubleValue `protobuf:"bytes,3,opt,name=dbl" json:"dbl,omitempty"`
-	Flt   *wrapperspb.FloatValue  `protobuf:"bytes,4,opt,name=flt" json:"flt,omitempty"`
-	I64   *wrapperspb.Int64Value  `protobuf:"bytes,5,opt,name=i64" json:"i64,omitempty"`
-	U64   *wrapperspb.UInt64Value `protobuf:"bytes,6,opt,name=u64" json:"u64,omitempty"`
-	I32   *wrapperspb.Int32Value  `protobuf:"bytes,7,opt,name=i32" json:"i32,omitempty"`
-	U32   *wrapperspb.UInt32Value `protobuf:"bytes,8,opt,name=u32" json:"u32,omitempty"`
-	Bool  *wrapperspb.BoolValue   `protobuf:"bytes,9,opt,name=bool" json:"bool,omitempty"`
-	Str   *wrapperspb.StringValue `protobuf:"bytes,10,opt,name=str" json:"str,omitempty"`
-	Bytes *wrapperspb.BytesValue  `protobuf:"bytes,11,opt,name=bytes" json:"bytes,omitempty"`
-}
-
-func (x *KnownTypes) Reset() {
-	*x = KnownTypes{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_test_objects_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *KnownTypes) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*KnownTypes) ProtoMessage() {}
-
-func (x *KnownTypes) ProtoReflect() protoreflect.Message {
-	mi := &file_test_objects_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use KnownTypes.ProtoReflect.Descriptor instead.
-func (*KnownTypes) Descriptor() ([]byte, []int) {
-	return file_test_objects_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *KnownTypes) GetAn() *anypb.Any {
-	if x != nil {
-		return x.An
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetDur() *durationpb.Duration {
-	if x != nil {
-		return x.Dur
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetSt() *structpb.Struct {
-	if x != nil {
-		return x.St
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetTs() *timestamppb.Timestamp {
-	if x != nil {
-		return x.Ts
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetLv() *structpb.ListValue {
-	if x != nil {
-		return x.Lv
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetVal() *structpb.Value {
-	if x != nil {
-		return x.Val
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetDbl() *wrapperspb.DoubleValue {
-	if x != nil {
-		return x.Dbl
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetFlt() *wrapperspb.FloatValue {
-	if x != nil {
-		return x.Flt
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetI64() *wrapperspb.Int64Value {
-	if x != nil {
-		return x.I64
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetU64() *wrapperspb.UInt64Value {
-	if x != nil {
-		return x.U64
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetI32() *wrapperspb.Int32Value {
-	if x != nil {
-		return x.I32
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetU32() *wrapperspb.UInt32Value {
-	if x != nil {
-		return x.U32
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetBool() *wrapperspb.BoolValue {
-	if x != nil {
-		return x.Bool
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetStr() *wrapperspb.StringValue {
-	if x != nil {
-		return x.Str
-	}
-	return nil
-}
-
-func (x *KnownTypes) GetBytes() *wrapperspb.BytesValue {
-	if x != nil {
-		return x.Bytes
-	}
-	return nil
-}
-
-var File_test_objects_proto protoreflect.FileDescriptor
-
-var file_test_objects_proto_rawDesc = []byte{
-	0x0a, 0x12, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6f, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x73, 0x2e, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x12, 0x06, 0x6a, 0x73, 0x6f, 0x6e, 0x70, 0x62, 0x1a, 0x19, 0x67, 0x6f,
-	0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e,
-	0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f,
-	0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70,
-	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xba, 0x05, 0x0a, 0x0a, 0x4b, 0x6e, 0x6f, 0x77, 0x6e,
-	0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x24, 0x0a, 0x02, 0x61, 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28,
-	0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x02, 0x61, 0x6e, 0x12, 0x2b, 0x0a, 0x03, 0x64,
-	0x75, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c,
-	0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x52, 0x03, 0x64, 0x75, 0x72, 0x12, 0x27, 0x0a, 0x02, 0x73, 0x74, 0x18, 0x0c,
-	0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x02, 0x73,
-	0x74, 0x12, 0x2a, 0x0a, 0x02, 0x74, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
-	0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x02, 0x74, 0x73, 0x12, 0x2a, 0x0a,
-	0x02, 0x6c, 0x76, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67,
-	0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4c, 0x69, 0x73, 0x74,
-	0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x02, 0x6c, 0x76, 0x12, 0x28, 0x0a, 0x03, 0x76, 0x61, 0x6c,
-	0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03,
-	0x76, 0x61, 0x6c, 0x12, 0x2e, 0x0a, 0x03, 0x64, 0x62, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03,
-	0x64, 0x62, 0x6c, 0x12, 0x2d, 0x0a, 0x03, 0x66, 0x6c, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b,
-	0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
-	0x75, 0x66, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03, 0x66,
-	0x6c, 0x74, 0x12, 0x2d, 0x0a, 0x03, 0x69, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03, 0x69, 0x36,
-	0x34, 0x12, 0x2e, 0x0a, 0x03, 0x75, 0x36, 0x34, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c,
-	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03, 0x75, 0x36,
-	0x34, 0x12, 0x2d, 0x0a, 0x03, 0x69, 0x33, 0x32, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b,
-	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03, 0x69, 0x33, 0x32,
-	0x12, 0x2e, 0x0a, 0x03, 0x75, 0x33, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
-	0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03, 0x75, 0x33, 0x32,
-	0x12, 0x2e, 0x0a, 0x04, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a,
-	0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66,
-	0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x04, 0x62, 0x6f, 0x6f, 0x6c,
-	0x12, 0x2e, 0x0a, 0x03, 0x73, 0x74, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e,
-	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e,
-	0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x03, 0x73, 0x74, 0x72,
-	0x12, 0x31, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
-	0x66, 0x2e, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x05, 0x62, 0x79,
-	0x74, 0x65, 0x73, 0x42, 0x0a, 0x5a, 0x08, 0x2e, 0x3b, 0x6a, 0x73, 0x6f, 0x6e, 0x70, 0x62,
-}
-
-var (
-	file_test_objects_proto_rawDescOnce sync.Once
-	file_test_objects_proto_rawDescData = file_test_objects_proto_rawDesc
-)
-
-func file_test_objects_proto_rawDescGZIP() []byte {
-	file_test_objects_proto_rawDescOnce.Do(func() {
-		file_test_objects_proto_rawDescData = protoimpl.X.CompressGZIP(file_test_objects_proto_rawDescData)
-	})
-	return file_test_objects_proto_rawDescData
-}
-
-var file_test_objects_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_test_objects_proto_goTypes = []interface{}{
-	(*KnownTypes)(nil),             // 0: jsonpb.KnownTypes
-	(*anypb.Any)(nil),              // 1: google.protobuf.Any
-	(*durationpb.Duration)(nil),    // 2: google.protobuf.Duration
-	(*structpb.Struct)(nil),        // 3: google.protobuf.Struct
-	(*timestamppb.Timestamp)(nil),  // 4: google.protobuf.Timestamp
-	(*structpb.ListValue)(nil),     // 5: google.protobuf.ListValue
-	(*structpb.Value)(nil),         // 6: google.protobuf.Value
-	(*wrapperspb.DoubleValue)(nil), // 7: google.protobuf.DoubleValue
-	(*wrapperspb.FloatValue)(nil),  // 8: google.protobuf.FloatValue
-	(*wrapperspb.Int64Value)(nil),  // 9: google.protobuf.Int64Value
-	(*wrapperspb.UInt64Value)(nil), // 10: google.protobuf.UInt64Value
-	(*wrapperspb.Int32Value)(nil),  // 11: google.protobuf.Int32Value
-	(*wrapperspb.UInt32Value)(nil), // 12: google.protobuf.UInt32Value
-	(*wrapperspb.BoolValue)(nil),   // 13: google.protobuf.BoolValue
-	(*wrapperspb.StringValue)(nil), // 14: google.protobuf.StringValue
-	(*wrapperspb.BytesValue)(nil),  // 15: google.protobuf.BytesValue
-}
-var file_test_objects_proto_depIdxs = []int32{
-	1,  // 0: jsonpb.KnownTypes.an:type_name -> google.protobuf.Any
-	2,  // 1: jsonpb.KnownTypes.dur:type_name -> google.protobuf.Duration
-	3,  // 2: jsonpb.KnownTypes.st:type_name -> google.protobuf.Struct
-	4,  // 3: jsonpb.KnownTypes.ts:type_name -> google.protobuf.Timestamp
-	5,  // 4: jsonpb.KnownTypes.lv:type_name -> google.protobuf.ListValue
-	6,  // 5: jsonpb.KnownTypes.val:type_name -> google.protobuf.Value
-	7,  // 6: jsonpb.KnownTypes.dbl:type_name -> google.protobuf.DoubleValue
-	8,  // 7: jsonpb.KnownTypes.flt:type_name -> google.protobuf.FloatValue
-	9,  // 8: jsonpb.KnownTypes.i64:type_name -> google.protobuf.Int64Value
-	10, // 9: jsonpb.KnownTypes.u64:type_name -> google.protobuf.UInt64Value
-	11, // 10: jsonpb.KnownTypes.i32:type_name -> google.protobuf.Int32Value
-	12, // 11: jsonpb.KnownTypes.u32:type_name -> google.protobuf.UInt32Value
-	13, // 12: jsonpb.KnownTypes.bool:type_name -> google.protobuf.BoolValue
-	14, // 13: jsonpb.KnownTypes.str:type_name -> google.protobuf.StringValue
-	15, // 14: jsonpb.KnownTypes.bytes:type_name -> google.protobuf.BytesValue
-	15, // [15:15] is the sub-list for method output_type
-	15, // [15:15] is the sub-list for method input_type
-	15, // [15:15] is the sub-list for extension type_name
-	15, // [15:15] is the sub-list for extension extendee
-	0,  // [0:15] is the sub-list for field type_name
-}
-
-func init() { file_test_objects_proto_init() }
-func file_test_objects_proto_init() {
-	if File_test_objects_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_test_objects_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*KnownTypes); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_test_objects_proto_rawDesc,
-			NumEnums:      0,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_test_objects_proto_goTypes,
-		DependencyIndexes: file_test_objects_proto_depIdxs,
-		MessageInfos:      file_test_objects_proto_msgTypes,
-	}.Build()
-	File_test_objects_proto = out.File
-	file_test_objects_proto_rawDesc = nil
-	file_test_objects_proto_goTypes = nil
-	file_test_objects_proto_depIdxs = nil
-}

internal/testing/jsonpb_test_proto/test_objects.proto

@@ -1,30 +0,0 @@
-syntax = "proto2";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/duration.proto";
-import "google/protobuf/struct.proto";
-import "google/protobuf/timestamp.proto";
-import "google/protobuf/wrappers.proto";
-
-package jsonpb;
-
-option go_package=".;jsonpb";
-
-message KnownTypes {
-  optional google.protobuf.Any an = 14;
-  optional google.protobuf.Duration dur = 1;
-  optional google.protobuf.Struct st = 12;
-  optional google.protobuf.Timestamp ts = 2;
-  optional google.protobuf.ListValue lv = 15;
-  optional google.protobuf.Value val = 16;
-
-  optional google.protobuf.DoubleValue dbl = 3;
-  optional google.protobuf.FloatValue flt = 4;
-  optional google.protobuf.Int64Value i64 = 5;
-  optional google.protobuf.UInt64Value u64 = 6;
-  optional google.protobuf.Int32Value i32 = 7;
-  optional google.protobuf.UInt32Value u32 = 8;
-  optional google.protobuf.BoolValue bool = 9;
-  optional google.protobuf.StringValue str = 10;
-  optional google.protobuf.BytesValue bytes = 11;
-}

internal/testing/test_grpc.pb.go

@@ -1,523 +0,0 @@
-// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
-
-package testing
-
-import (
-	context "context"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
-
-// TestServiceClient is the client API for TestService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
-type TestServiceClient interface {
-	// One empty request followed by one empty response.
-	EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
-	// One request followed by one response.
-	// The server returns the client payload as-is.
-	UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
-	// One request followed by a sequence of responses (streamed download).
-	// The server returns the payload with client desired type and sizes.
-	StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error)
-	// A sequence of requests followed by one response (streamed upload).
-	// The server returns the aggregated size of client payload as the result.
-	StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error)
-	// A sequence of requests with each request served by the server immediately.
-	// As one request could lead to multiple responses, this interface
-	// demonstrates the idea of full duplexing.
-	FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error)
-	// A sequence of requests followed by a sequence of responses.
-	// The server buffers all the client requests and then serves them in order. A
-	// stream of responses are returned to the client when the server starts with
-	// first request.
-	HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error)
-}
-
-type testServiceClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewTestServiceClient(cc grpc.ClientConnInterface) TestServiceClient {
-	return &testServiceClient{cc}
-}
-
-func (c *testServiceClient) EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
-	out := new(Empty)
-	err := c.cc.Invoke(ctx, "/testing.TestService/EmptyCall", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
-	out := new(SimpleResponse)
-	err := c.cc.Invoke(ctx, "/testing.TestService/UnaryCall", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *testServiceClient) StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) {
-	stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[0], "/testing.TestService/StreamingOutputCall", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &testServiceStreamingOutputCallClient{stream}
-	if err := x.ClientStream.SendMsg(in); err != nil {
-		return nil, err
-	}
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	return x, nil
-}
-
-type TestService_StreamingOutputCallClient interface {
-	Recv() (*StreamingOutputCallResponse, error)
-	grpc.ClientStream
-}
-
-type testServiceStreamingOutputCallClient struct {
-	grpc.ClientStream
-}
-
-func (x *testServiceStreamingOutputCallClient) Recv() (*StreamingOutputCallResponse, error) {
-	m := new(StreamingOutputCallResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *testServiceClient) StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) {
-	stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[1], "/testing.TestService/StreamingInputCall", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &testServiceStreamingInputCallClient{stream}
-	return x, nil
-}
-
-type TestService_StreamingInputCallClient interface {
-	Send(*StreamingInputCallRequest) error
-	CloseAndRecv() (*StreamingInputCallResponse, error)
-	grpc.ClientStream
-}
-
-type testServiceStreamingInputCallClient struct {
-	grpc.ClientStream
-}
-
-func (x *testServiceStreamingInputCallClient) Send(m *StreamingInputCallRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *testServiceStreamingInputCallClient) CloseAndRecv() (*StreamingInputCallResponse, error) {
-	if err := x.ClientStream.CloseSend(); err != nil {
-		return nil, err
-	}
-	m := new(StreamingInputCallResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) {
-	stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[2], "/testing.TestService/FullDuplexCall", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &testServiceFullDuplexCallClient{stream}
-	return x, nil
-}
-
-type TestService_FullDuplexCallClient interface {
-	Send(*StreamingOutputCallRequest) error
-	Recv() (*StreamingOutputCallResponse, error)
-	grpc.ClientStream
-}
-
-type testServiceFullDuplexCallClient struct {
-	grpc.ClientStream
-}
-
-func (x *testServiceFullDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *testServiceFullDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
-	m := new(StreamingOutputCallResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func (c *testServiceClient) HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) {
-	stream, err := c.cc.NewStream(ctx, &TestService_ServiceDesc.Streams[3], "/testing.TestService/HalfDuplexCall", opts...)
-	if err != nil {
-		return nil, err
-	}
-	x := &testServiceHalfDuplexCallClient{stream}
-	return x, nil
-}
-
-type TestService_HalfDuplexCallClient interface {
-	Send(*StreamingOutputCallRequest) error
-	Recv() (*StreamingOutputCallResponse, error)
-	grpc.ClientStream
-}
-
-type testServiceHalfDuplexCallClient struct {
-	grpc.ClientStream
-}
-
-func (x *testServiceHalfDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
-	return x.ClientStream.SendMsg(m)
-}
-
-func (x *testServiceHalfDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
-	m := new(StreamingOutputCallResponse)
-	if err := x.ClientStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// TestServiceServer is the server API for TestService service.
-// All implementations must embed UnimplementedTestServiceServer
-// for forward compatibility
-type TestServiceServer interface {
-	// One empty request followed by one empty response.
-	EmptyCall(context.Context, *Empty) (*Empty, error)
-	// One request followed by one response.
-	// The server returns the client payload as-is.
-	UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
-	// One request followed by a sequence of responses (streamed download).
-	// The server returns the payload with client desired type and sizes.
-	StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
-	// A sequence of requests followed by one response (streamed upload).
-	// The server returns the aggregated size of client payload as the result.
-	StreamingInputCall(TestService_StreamingInputCallServer) error
-	// A sequence of requests with each request served by the server immediately.
-	// As one request could lead to multiple responses, this interface
-	// demonstrates the idea of full duplexing.
-	FullDuplexCall(TestService_FullDuplexCallServer) error
-	// A sequence of requests followed by a sequence of responses.
-	// The server buffers all the client requests and then serves them in order. A
-	// stream of responses are returned to the client when the server starts with
-	// first request.
-	HalfDuplexCall(TestService_HalfDuplexCallServer) error
-	mustEmbedUnimplementedTestServiceServer()
-}
-
-// UnimplementedTestServiceServer must be embedded to have forward compatible implementations.
-type UnimplementedTestServiceServer struct {
-}
-
-func (UnimplementedTestServiceServer) EmptyCall(context.Context, *Empty) (*Empty, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method EmptyCall not implemented")
-}
-func (UnimplementedTestServiceServer) UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method UnaryCall not implemented")
-}
-func (UnimplementedTestServiceServer) StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error {
-	return status.Errorf(codes.Unimplemented, "method StreamingOutputCall not implemented")
-}
-func (UnimplementedTestServiceServer) StreamingInputCall(TestService_StreamingInputCallServer) error {
-	return status.Errorf(codes.Unimplemented, "method StreamingInputCall not implemented")
-}
-func (UnimplementedTestServiceServer) FullDuplexCall(TestService_FullDuplexCallServer) error {
-	return status.Errorf(codes.Unimplemented, "method FullDuplexCall not implemented")
-}
-func (UnimplementedTestServiceServer) HalfDuplexCall(TestService_HalfDuplexCallServer) error {
-	return status.Errorf(codes.Unimplemented, "method HalfDuplexCall not implemented")
-}
-func (UnimplementedTestServiceServer) mustEmbedUnimplementedTestServiceServer() {}
-
-// UnsafeTestServiceServer may be embedded to opt out of forward compatibility for this service.
-// Use of this interface is not recommended, as added methods to TestServiceServer will
-// result in compilation errors.
-type UnsafeTestServiceServer interface {
-	mustEmbedUnimplementedTestServiceServer()
-}
-
-func RegisterTestServiceServer(s grpc.ServiceRegistrar, srv TestServiceServer) {
-	s.RegisterService(&TestService_ServiceDesc, srv)
-}
-
-func _TestService_EmptyCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Empty)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(TestServiceServer).EmptyCall(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/testing.TestService/EmptyCall",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(TestServiceServer).EmptyCall(ctx, req.(*Empty))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(SimpleRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(TestServiceServer).UnaryCall(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/testing.TestService/UnaryCall",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(TestServiceServer).UnaryCall(ctx, req.(*SimpleRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _TestService_StreamingOutputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
-	m := new(StreamingOutputCallRequest)
-	if err := stream.RecvMsg(m); err != nil {
-		return err
-	}
-	return srv.(TestServiceServer).StreamingOutputCall(m, &testServiceStreamingOutputCallServer{stream})
-}
-
-type TestService_StreamingOutputCallServer interface {
-	Send(*StreamingOutputCallResponse) error
-	grpc.ServerStream
-}
-
-type testServiceStreamingOutputCallServer struct {
-	grpc.ServerStream
-}
-
-func (x *testServiceStreamingOutputCallServer) Send(m *StreamingOutputCallResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func _TestService_StreamingInputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(TestServiceServer).StreamingInputCall(&testServiceStreamingInputCallServer{stream})
-}
-
-type TestService_StreamingInputCallServer interface {
-	SendAndClose(*StreamingInputCallResponse) error
-	Recv() (*StreamingInputCallRequest, error)
-	grpc.ServerStream
-}
-
-type testServiceStreamingInputCallServer struct {
-	grpc.ServerStream
-}
-
-func (x *testServiceStreamingInputCallServer) SendAndClose(m *StreamingInputCallResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *testServiceStreamingInputCallServer) Recv() (*StreamingInputCallRequest, error) {
-	m := new(StreamingInputCallRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream})
-}
-
-type TestService_FullDuplexCallServer interface {
-	Send(*StreamingOutputCallResponse) error
-	Recv() (*StreamingOutputCallRequest, error)
-	grpc.ServerStream
-}
-
-type testServiceFullDuplexCallServer struct {
-	grpc.ServerStream
-}
-
-func (x *testServiceFullDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *testServiceFullDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
-	m := new(StreamingOutputCallRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-func _TestService_HalfDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
-	return srv.(TestServiceServer).HalfDuplexCall(&testServiceHalfDuplexCallServer{stream})
-}
-
-type TestService_HalfDuplexCallServer interface {
-	Send(*StreamingOutputCallResponse) error
-	Recv() (*StreamingOutputCallRequest, error)
-	grpc.ServerStream
-}
-
-type testServiceHalfDuplexCallServer struct {
-	grpc.ServerStream
-}
-
-func (x *testServiceHalfDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
-	return x.ServerStream.SendMsg(m)
-}
-
-func (x *testServiceHalfDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
-	m := new(StreamingOutputCallRequest)
-	if err := x.ServerStream.RecvMsg(m); err != nil {
-		return nil, err
-	}
-	return m, nil
-}
-
-// TestService_ServiceDesc is the grpc.ServiceDesc for TestService service.
-// It's only intended for direct use with grpc.RegisterService,
-// and not to be introspected or modified (even as a copy)
-var TestService_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "testing.TestService",
-	HandlerType: (*TestServiceServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "EmptyCall",
-			Handler:    _TestService_EmptyCall_Handler,
-		},
-		{
-			MethodName: "UnaryCall",
-			Handler:    _TestService_UnaryCall_Handler,
-		},
-	},
-	Streams: []grpc.StreamDesc{
-		{
-			StreamName:    "StreamingOutputCall",
-			Handler:       _TestService_StreamingOutputCall_Handler,
-			ServerStreams: true,
-		},
-		{
-			StreamName:    "StreamingInputCall",
-			Handler:       _TestService_StreamingInputCall_Handler,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "FullDuplexCall",
-			Handler:       _TestService_FullDuplexCall_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-		{
-			StreamName:    "HalfDuplexCall",
-			Handler:       _TestService_HalfDuplexCall_Handler,
-			ServerStreams: true,
-			ClientStreams: true,
-		},
-	},
-	Metadata: "test.proto",
-}
-
-// UnimplementedServiceClient is the client API for UnimplementedService service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
-type UnimplementedServiceClient interface {
-	// A call that no server should implement
-	UnimplementedCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
-}
-
-type unimplementedServiceClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewUnimplementedServiceClient(cc grpc.ClientConnInterface) UnimplementedServiceClient {
-	return &unimplementedServiceClient{cc}
-}
-
-func (c *unimplementedServiceClient) UnimplementedCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
-	out := new(Empty)
-	err := c.cc.Invoke(ctx, "/testing.UnimplementedService/UnimplementedCall", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// UnimplementedServiceServer is the server API for UnimplementedService service.
-// All implementations must embed UnimplementedUnimplementedServiceServer
-// for forward compatibility
-type UnimplementedServiceServer interface {
-	// A call that no server should implement
-	UnimplementedCall(context.Context, *Empty) (*Empty, error)
-	mustEmbedUnimplementedUnimplementedServiceServer()
-}
-
-// UnimplementedUnimplementedServiceServer must be embedded to have forward compatible implementations.
-type UnimplementedUnimplementedServiceServer struct {
-}
-
-func (UnimplementedUnimplementedServiceServer) UnimplementedCall(context.Context, *Empty) (*Empty, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method UnimplementedCall not implemented")
-}
-func (UnimplementedUnimplementedServiceServer) mustEmbedUnimplementedUnimplementedServiceServer() {}
-
-// UnsafeUnimplementedServiceServer may be embedded to opt out of forward compatibility for this service.
-// Use of this interface is not recommended, as added methods to UnimplementedServiceServer will
-// result in compilation errors.
-type UnsafeUnimplementedServiceServer interface {
-	mustEmbedUnimplementedUnimplementedServiceServer()
-}
-
-func RegisterUnimplementedServiceServer(s grpc.ServiceRegistrar, srv UnimplementedServiceServer) {
-	s.RegisterService(&UnimplementedService_ServiceDesc, srv)
-}
-
-func _UnimplementedService_UnimplementedCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(Empty)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(UnimplementedServiceServer).UnimplementedCall(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/testing.UnimplementedService/UnimplementedCall",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(UnimplementedServiceServer).UnimplementedCall(ctx, req.(*Empty))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-// UnimplementedService_ServiceDesc is the grpc.ServiceDesc for UnimplementedService service.
-// It's only intended for direct use with grpc.RegisterService,
-// and not to be introspected or modified (even as a copy)
-var UnimplementedService_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "testing.UnimplementedService",
-	HandlerType: (*UnimplementedServiceServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "UnimplementedCall",
-			Handler:    _UnimplementedService_UnimplementedCall_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "test.proto",
-}

invoke.go

@@ -2,19 +2,19 @@ package grpcurl
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"io"
 	"strings"
 	"sync"
 	"sync/atomic"
 
-	"github.com/golang/protobuf/jsonpb"     //lint:ignore SA1019 we have to import these because some of their types appear in exported API
+	"github.com/golang/protobuf/jsonpb"
-	"github.com/golang/protobuf/proto"      //lint:ignore SA1019 same as above
+	"github.com/golang/protobuf/proto"
-	"github.com/jhump/protoreflect/desc"    //lint:ignore SA1019 same as above
+	"github.com/jhump/protoreflect/desc"
-	"github.com/jhump/protoreflect/dynamic" //lint:ignore SA1019 same as above
+	"github.com/jhump/protoreflect/dynamic"
 	"github.com/jhump/protoreflect/dynamic/grpcdynamic"
 	"github.com/jhump/protoreflect/grpcreflect"
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
@@ -93,17 +93,9 @@ func InvokeRPC(ctx context.Context, source DescriptorSource, ch grpcdynamic.Chan
 	if svc == "" || mth == "" {
 		return fmt.Errorf("given method name %q is not in expected format: 'service/method' or 'service.method'", methodName)
 	}
-
 	dsc, err := source.FindSymbol(svc)
 	if err != nil {
-		// return a gRPC status error if hasStatus is true
+		if isNotFoundError(err) {
-		errStatus, hasStatus := status.FromError(err)
-		switch {
-		case hasStatus && isNotFoundError(err):
-			return status.Errorf(errStatus.Code(), "target server does not expose service %q: %s", svc, errStatus.Message())
-		case hasStatus:
-			return status.Errorf(errStatus.Code(), "failed to query for service descriptor %q: %s", svc, errStatus.Message())
-		case isNotFoundError(err):
 			return fmt.Errorf("target server does not expose service %q", svc)
 		}
 		return fmt.Errorf("failed to query for service descriptor %q: %v", svc, err)
@@ -227,19 +219,15 @@ func invokeClientStream(ctx context.Context, stub grpcdynamic.Stub, md *desc.Met
 		return fmt.Errorf("grpc call for %q failed: %v", md.GetFullyQualifiedName(), err)
 	}
 
-	if str != nil {
 	if respHeaders, err := str.Header(); err == nil {
 		handler.OnReceiveHeaders(respHeaders)
 	}
-	}
 
 	if stat.Code() == codes.OK {
 		handler.OnReceiveResponse(resp)
 	}
 
-	if str != nil {
 	handler.OnReceiveTrailers(stat, str.Trailer())
-	}
 
 	return nil
 }
@@ -264,11 +252,9 @@ func invokeServerStream(ctx context.Context, stub grpcdynamic.Stub, md *desc.Met
 	// Now we can actually invoke the RPC!
 	str, err := stub.InvokeRpcServerStream(ctx, md, req)
 
-	if str != nil {
 	if respHeaders, err := str.Header(); err == nil {
 		handler.OnReceiveHeaders(respHeaders)
 	}
-	}
 
 	// Download each response message
 	for err == nil {
@@ -290,9 +276,7 @@ func invokeServerStream(ctx context.Context, stub grpcdynamic.Stub, md *desc.Met
 		return fmt.Errorf("grpc call for %q failed: %v", md.GetFullyQualifiedName(), err)
 	}
 
-	if str != nil {
 	handler.OnReceiveTrailers(stat, str.Trailer())
-	}
 
 	return nil
 }
@@ -327,7 +311,6 @@ func invokeBidi(ctx context.Context, stub grpcdynamic.Stub, md *desc.MethodDescr
 				}
 				if err != nil {
 					err = fmt.Errorf("error getting request data: %v", err)
-					cancel()
 					break
 				}
 
@@ -338,15 +321,14 @@ func invokeBidi(ctx context.Context, stub grpcdynamic.Stub, md *desc.MethodDescr
 
 			if err != nil {
 				sendErr.Store(err)
+				cancel()
 			}
 		}()
 	}
 
-	if str != nil {
 	if respHeaders, err := str.Header(); err == nil {
 		handler.OnReceiveHeaders(respHeaders)
 	}
-	}
 
 	// Download each response message
 	for err == nil {
@@ -372,9 +354,7 @@ func invokeBidi(ctx context.Context, stub grpcdynamic.Stub, md *desc.MethodDescr
 		return fmt.Errorf("grpc call for %q failed: %v", md.GetFullyQualifiedName(), err)
 	}
 
-	if str != nil {
 	handler.OnReceiveTrailers(stat, str.Trailer())
-	}
 
 	return nil
 }

mk-test-files.sh

@@ -15,9 +15,6 @@ protoc testing/example.proto \
 	--include_imports \
 	--descriptor_set_out=testing/example.protoset
 
-protoc testing/jsonpb_test_proto/test_objects.proto \
-	--go_out=paths=source_relative:.
-
 echo "Creating certs for TLS testing..."
 if ! hash certstrap 2>/dev/null; then
   # certstrap not found: try to install it

releasing/README.md

@@ -1,79 +0,0 @@
-# Releases of gRPCurl
-
-This document provides instructions for building a release of `grpcurl`.
-
-The release process consists of a handful of tasks:
-1. Drop a release tag in git.
-2. Build binaries for various platforms. This is done using the local `go` tool and uses `GOOS` and `GOARCH` environment variables to cross-compile for supported platforms.
-3. Creates a release in GitHub, uploads the binaries, and creates provisional release notes (in the form of a change log).
-4. Build a docker image for the new release.
-5. Push the docker image to Docker Hub, with both a version tag and the "latest" tag.
-6. Submits a PR to update the [Homebrew](https://brew.sh/) recipe with the latest version.
-
-Most of this is automated via a script in this same directory. The main thing you will need is a GitHub personal access token, which will be used for creating the release in GitHub (so you need write access to the fullstorydev/grpcurl repo) and to open a Homebrew pull request.
-
-## Creating a new release
-
-So, to actually create a new release, just run the script in this directory.
-
-First, you need a version number for the new release, following sem-ver format: `v<Major>.<Minor>.<Patch>`. Second, you need a personal access token for GitHub.
-
-We'll use `v2.3.4` as an example version and `abcdef0123456789abcdef` as an example GitHub token:
-
-```sh
-# from the root of the repo
-GITHUB_TOKEN=abcdef0123456789abcd \
-    ./releasing/do-release.sh v2.3.4
-```
-
-Wasn't that easy! There is one last step: update the release notes in GitHub. By default, the script just records a change log of commit descriptions. Use that log (and, if necessary, drill into individual PRs included in the release) to flesh out notes in the format of the `RELEASE_NOTES.md` file _in this directory_. Then login to GitHub, go to the new release, edit the notes, and paste in the markdown you just wrote.
-
-That should be all there is to it! If things go wrong and you have to re-do part of the process, see the sections below.
-
-----
-
-### GitHub Releases
-The GitHub release is the first step performed by the `do-release.sh` script. So generally, if there is an issue with that step, you can re-try the whole script.
-
-Note, if running the script did something wrong, you may have to first login to GitHub and remove uploaded artifacts for a botched release attempt. In general, this is _very undesirable_. Releases should usually be considered immutable. Instead of removing uploaded assets and providing new ones, it is often better to remove uploaded assets (to make bad binaries no longer available) and then _release a new patch version_. (You can edit the release notes for the botched version explaining why there are no artifacts for it.)
-
-The steps to do a GitHub-only release (vs. running the entire script) are the following:
-
-```sh
-# from the root of the repo
-git tag v2.3.4
-GITHUB_TOKEN=abcdef0123456789abcdef \
-    GO111MODULE=on \
-    make release
-```
-
-The `git tag ...` step is necessary because the release target requires that the current SHA have a sem-ver tag. That's the version it will use when creating the release.
-
-This will create the release in GitHub with provisional release notes that just include a change log of commit messages. You still need to login to GitHub and revise those notes to adhere to the recommended format. (See `RELEASE_NOTES.md` in this directory.)
-
-### Docker Hub Releases
-
-To re-run only the Docker Hub release steps, you can manually run through each step in the "Docker" section of `do_release.sh`.
-
-If the `docker push ...` steps fail, you may need to run `docker login`, enter your Docker Hub login credentials, and then try to push again.
-
-### Homebrew Releases
-
-The last step is to update the Homebrew recipe to use the latest version. First, we need to compute the SHA256 checksum for the source archive:
-
-```sh
-# download the source archive from GitHub
-URL=https://github.com/fullstorydev/grpcurl/archive/refs/tags/v2.3.4.tar.gz
-curl -L -o tmp.tgz $URL
-# and compute the SHA
-SHA="$(sha256sum < tmp.tgz | awk '{ print $1 }')"
-```
-
-To actually create the brew PR, you need your GitHub personal access token again, as well as the URL and SHA from the previous step:
-
-```sh
-HOMEBREW_GITHUB_API_TOKEN=abcdef0123456789abcdef \
-    brew bump-formula-pr --url $URL --sha256 $SHA grpcurl
-```
-
-This creates a PR to bump the formula to the new version. When this PR is merged by brew maintainers, the new version becomes available!

releasing/RELEASE_NOTES.md

@@ -1,11 +0,0 @@
-## Changes
-
-### Command-line tool
-
-* _In this list, describe the changes to the command-line tool._
-* _Use one bullet per change. Include both bug-fixes and improvements. Omit this section if there are no changes that impact the command-line tool._
-
-### Go package "github.com/fullstorydev/grpcurl"
-
-* _In this list, describe the changes to exported API in the main package in this repo: "github.com/fullstorydev/grpcurl". These will often be closely related to changes to the command-line tool, though not always: changes that only impact the cmd/grpcurl directory of this repo do not impact exported API._
-* _Use one bullet per change. Include both bug-fixes and improvements. Omit this section if there are no changes that impact the exported API._

releasing/do-release.sh

@@ -1,62 +0,0 @@
-#!/bin/bash
-
-# strict mode
-set -euo pipefail
-IFS=$'\n\t'
-
-if [[ -z ${DRY_RUN:-} ]]; then
-    PREFIX=""
-else
-    PREFIX="echo"
-fi
-
-# input validation
-if [[ -z ${GITHUB_TOKEN:-} ]]; then
-    echo "GITHUB_TOKEN environment variable must be set before running." >&2
-    exit 1
-fi
-if [[ $# -ne 1 || $1 == "" ]]; then
-    echo "This program requires one argument: the version number, in 'vM.N.P' format." >&2
-    exit 1
-fi
-VERSION=$1
-
-# Change to root of the repo
-cd "$(dirname "$0")/.."
-
-# GitHub release
-
-$PREFIX git tag "$VERSION"
-# make sure GITHUB_TOKEN is exported, for the benefit of this next command
-export GITHUB_TOKEN
-GO111MODULE=on $PREFIX make release
-# if that was successful, it could have touched go.mod and go.sum, so revert those
-$PREFIX git checkout go.mod go.sum
-
-# Docker release
-
-# make sure credentials are valid for later push steps; this might
-# be interactive since this will prompt for username and password
-# if there are no valid current credentials.
-$PREFIX docker login
-echo "$VERSION" > VERSION
-
-# Docker Buildx support is included in Docker 19.03
-# Below step installs emulators for different architectures on the host
-# This enables running and building containers for below architectures mentioned using --platforms
-$PREFIX docker run --privileged --rm tonistiigi/binfmt:qemu-v6.1.0 --install all
-# Create a new builder instance
-export DOCKER_CLI_EXPERIMENTAL=enabled
-$PREFIX docker buildx create --use --name multiarch-builder --node multiarch-builder0
-# push to docker hub, both the given version as a tag and for "latest" tag
-$PREFIX docker buildx build --platform linux/amd64,linux/s390x,linux/arm64,linux/ppc64le --tag fullstorydev/grpcurl:${VERSION} --tag fullstorydev/grpcurl:latest --push --progress plain --no-cache .
-$PREFIX docker buildx build --platform linux/amd64,linux/s390x,linux/arm64,linux/ppc64le --tag fullstorydev/grpcurl:${VERSION}-alpine --tag fullstorydev/grpcurl:latest-alpine --push --progress plain --no-cache --target alpine .
-rm VERSION
-
-# Homebrew release
-
-URL="https://github.com/fullstorydev/grpcurl/archive/refs/tags/${VERSION}.tar.gz"
-curl -L -o tmp.tgz "$URL"
-SHA="$(sha256sum < tmp.tgz | awk '{ print $1 }')"
-rm tmp.tgz
-HOMEBREW_GITHUB_API_TOKEN="$GITHUB_TOKEN" $PREFIX brew bump-formula-pr --url "$URL" --sha256 "$SHA" grpcurl

snap/README.md

@@ -1,23 +0,0 @@
-# packing and releasing
-To pack the current branch to a snap package:
-
-`snapcraft pack`
-
-To install the package locally:
-
-`snap install ./grpcurl_v[version tag]_amd64.snap --devmode`
-
-To upload the snap to the edge channel:
-
-`snapcraft upload --release edge ./grpcurl_v[version tag]_amd64.snap`
-
-(you need to own the package name registration for this!)
-
-# ownership
-The snap's current owner is `pietro.pasotti@canonical.com`; who is very happy to support with maintaining the snap distribution and/or transfer its ownership to the developers.
-
-Please reach out to me for questions regarding the snap; including:
-- adding support for other architectures
-- automating the release
-
-Cheers and thanks for the awesome tool!

snap/snapcraft.yaml

@@ -1,47 +0,0 @@
-name: grpcurl
-base: core24
-# allow grpcurl part to call craftctl set-version
-adopt-info: grpcurl
-summary: grpcurl is a command-line tool that lets you interact with gRPC servers.
-
-description: |
-  grpcurl is a command-line tool that lets you interact with gRPC servers. 
-  It's basically curl for gRPC servers.
-
-grade: stable
-confinement: strict
-license: MIT
-
-platforms:
-  amd64:
-    build-on:
-      - amd64
-    build-for:
-      - amd64
-  arm64:
-    build-on:
-      - amd64
-      - arm64
-    build-for:
-      - arm64
-
-apps:
-  grpcurl:
-    command: grpcurl
-    plugs:
-      - network
-
-parts:
-  grpcurl:
-    plugin: go
-    build-snaps: [go/latest/stable]
-    source: https://github.com/fullstorydev/grpcurl
-    source-type: git
-    override-build: |
-      tag="$(git describe --tags --abbrev=0)"
-      craftctl set version="$tag"
-
-      go build -o $CRAFT_PART_INSTALL/grpcurl ./cmd/grpcurl/grpcurl.go
-      
-      # adjust the permissions
-      chmod 0755 $CRAFT_PART_INSTALL/grpcurl

testing/cmd/bankdemo/auth.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	"context"
 	"strings"
 
+	"golang.org/x/net/context"
 	"google.golang.org/grpc/metadata"
 )
 

testing/cmd/bankdemo/bank.go

@@ -1,18 +1,18 @@
 package main
 
 import (
-	"context"
 	"fmt"
 	"time"
 
+	"github.com/golang/protobuf/ptypes"
 	"github.com/golang/protobuf/ptypes/empty"
+	"golang.org/x/net/context"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
 // bankServer implements the Bank gRPC service.
 type bankServer struct {
-	UnimplementedBankServer
 	allAccounts *accounts
 }
 
@@ -72,29 +72,26 @@ func (s *bankServer) GetTransactions(req *GetTransactionsRequest, stream Bank_Ge
 
 	var start, end time.Time
 	if req.Start != nil {
-		err := req.Start.CheckValid()
+		start, err = ptypes.Timestamp(req.Start)
 		if err != nil {
 			return err
 		}
-		start = req.Start.AsTime()
 	}
 	if req.End != nil {
-		err := req.End.CheckValid()
+		end, err = ptypes.Timestamp(req.End)
 		if err != nil {
 			return err
 		}
-		end = req.End.AsTime()
 	} else {
 		end = time.Date(9999, 12, 31, 23, 59, 59, 999999999, time.Local)
 	}
 
 	txns := acct.getTransactions()
 	for _, txn := range txns {
-		err := txn.Date.CheckValid()
+		t, err := ptypes.Timestamp(txn.Date)
 		if err != nil {
 			return err
 		}
-		t := txn.Date.AsTime()
 		if (t.After(start) || t.Equal(start)) &&
 			(t.Before(end) || t.Equal(end)) {
 

testing/cmd/bankdemo/bank.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-option go_package = ".;main";
+option go_package = "main";
 
 import "google/protobuf/empty.proto";
 import "google/protobuf/timestamp.proto";

testing/cmd/bankdemo/chat.go

@@ -1,21 +1,20 @@
 package main
 
 import (
-	"context"
 	"fmt"
 	"io"
 	"sync"
 
+	"github.com/golang/protobuf/ptypes"
+	"golang.org/x/net/context"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 // chatServer implements the Support gRPC service, for providing
 // a capability to connect customers and support agents in real-time
 // chat.
 type chatServer struct {
-	UnimplementedSupportServer
 	chatsBySession     map[string]*session
 	chatsAwaitingAgent []string
 	lastSession        int32
@@ -135,7 +134,7 @@ func (s *chatServer) ChatCustomer(stream Support_ChatCustomerServer) error {
 			}
 
 			entry := &ChatEntry{
-				Date: timestamppb.Now(),
+				Date: ptypes.TimestampNow(),
 				Entry: &ChatEntry_CustomerMsg{
 					CustomerMsg: req.Msg,
 				},
@@ -280,7 +279,7 @@ func (s *chatServer) ChatAgent(stream Support_ChatAgentServer) error {
 			}
 
 			entry := &ChatEntry{
-				Date: timestamppb.Now(),
+				Date: ptypes.TimestampNow(),
 				Entry: &ChatEntry_AgentMsg{
 					AgentMsg: &AgentMessage{
 						AgentName: agent,

testing/cmd/bankdemo/db.go

@@ -1,13 +1,14 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
 	"sync"
 
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/golang/protobuf/ptypes"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
-	"google.golang.org/protobuf/encoding/protojson"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 // In-memory database that is periodically saved to a JSON file.
@@ -42,7 +43,7 @@ func (a *accounts) openAccount(customer string, accountType Account_Type, initia
 	acct.Transactions = append(acct.Transactions, &Transaction{
 		AccountNumber: num,
 		SeqNumber:     1,
-		Date:          timestamppb.Now(),
+		Date:          ptypes.TimestampNow(),
 		AmountCents:   initialBalanceCents,
 		Desc:          "initial deposit",
 	})
@@ -129,7 +130,7 @@ func (a *account) newTransaction(amountCents int32, desc string) (newBalance int
 	a.BalanceCents = bal
 	a.Transactions = append(a.Transactions, &Transaction{
 		AccountNumber: a.AccountNumber,
-		Date:          timestamppb.Now(),
+		Date:          ptypes.TimestampNow(),
 		AmountCents:   amountCents,
 		SeqNumber:     uint64(len(a.Transactions) + 1),
 		Desc:          desc,
@@ -138,11 +139,16 @@ func (a *account) newTransaction(amountCents int32, desc string) (newBalance int
 }
 
 func (t *Transaction) MarshalJSON() ([]byte, error) {
-	return protojson.Marshal(t)
+	var jsm jsonpb.Marshaler
+	var buf bytes.Buffer
+	if err := jsm.Marshal(&buf, t); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
 }
 
 func (t *Transaction) UnmarshalJSON(b []byte) error {
-	return protojson.Unmarshal(b, t)
+	return jsonpb.Unmarshal(bytes.NewReader(b), t)
 }
 
 func (a *accounts) clone() *accounts {

testing/cmd/bankdemo/main.go

@@ -1,12 +1,12 @@
 package main
 
-//go:generate protoc --go_out=. --go-grpc_out=. bank.proto support.proto
+//go:generate protoc --go_out=plugins=grpc:./ bank.proto support.proto
 
 import (
-	"context"
 	"encoding/json"
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"net"
 	"os"
 	"os/signal"
@@ -14,6 +14,7 @@ import (
 	"syscall"
 	"time"
 
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/grpclog"
 	"google.golang.org/grpc/peer"
@@ -129,7 +130,7 @@ type svr struct {
 }
 
 func (s *svr) load() error {
-	accts, err := os.ReadFile(s.datafile)
+	accts, err := ioutil.ReadFile(s.datafile)
 	if err != nil && !os.IsNotExist(err) {
 		return err
 	}
@@ -161,7 +162,7 @@ func (s *svr) flush() {
 
 	if b, err := json.Marshal(accounts); err != nil {
 		grpclog.Errorf("failed to save data to %q", s.datafile)
-	} else if err := os.WriteFile(s.datafile, b, 0666); err != nil {
+	} else if err := ioutil.WriteFile(s.datafile, b, 0666); err != nil {
 		grpclog.Errorf("failed to save data to %q", s.datafile)
 	}
 }

testing/cmd/bankdemo/support.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-option go_package = ".;main";
+option go_package = "main";
 
 import "google/protobuf/timestamp.proto";
 

testing/cmd/testserver/testserver.go

@@ -2,7 +2,6 @@
 package main
 
 import (
-	"context"
 	"flag"
 	"fmt"
 	"net"
@@ -10,15 +9,17 @@ import (
 	"sync/atomic"
 	"time"
 
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/interop/grpc_testing"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/reflection"
 	"google.golang.org/grpc/status"
 
 	"github.com/fullstorydev/grpcurl"
-	grpcurl_testing "github.com/fullstorydev/grpcurl/internal/testing"
+	grpcurl_testing "github.com/fullstorydev/grpcurl/testing"
 )
 
 var (
@@ -95,7 +96,7 @@ func main() {
 
 	svr := grpc.NewServer(opts...)
 
-	grpcurl_testing.RegisterTestServiceServer(svr, grpcurl_testing.TestServer{})
+	grpc_testing.RegisterTestServiceServer(svr, grpcurl_testing.TestServer{})
 	if !*noreflect {
 		reflection.Register(svr)
 	}
@@ -119,7 +120,7 @@ func unaryLogger(ctx context.Context, req interface{}, info *grpc.UnaryServerInf
 	} else {
 		code = codes.Unknown
 	}
-	grpclog.Infof("completed <%d>: %v (%d) %v\n", i, code, code, time.Since(start))
+	grpclog.Infof("completed <%d>: %v (%d) %v\n", i, code, code, time.Now().Sub(start))
 	return rsp, err
 }
 
@@ -134,7 +135,7 @@ func streamLogger(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServer
 	} else {
 		code = codes.Unknown
 	}
-	grpclog.Infof("completed <%d>: %v(%d) %v\n", i, code, code, time.Since(start))
+	grpclog.Infof("completed <%d>: %v(%d) %v\n", i, code, code, time.Now().Sub(start))
 	return err
 }
 

testing/cmd/testserver/unix.go

@@ -1,4 +1,3 @@
-//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 package main

testing/example.proto

@@ -3,7 +3,7 @@ syntax = "proto3";
 import "google/protobuf/descriptor.proto";
 import "google/protobuf/empty.proto";
 import "google/protobuf/timestamp.proto";
-import "example2.proto";
+import "testing/example2.proto";
 
 message TestRequest {
 	repeated string file_names = 1;

testing/test.proto

@@ -18,9 +18,7 @@
 // of unary/streaming requests/responses.
 syntax = "proto3";
 
-package testing;
+package grpc.testing;
-
-option go_package = ".;testing";
 
 message Empty {}
 
@@ -174,5 +172,5 @@ service TestService {
 // that case.
 service UnimplementedService {
   // A call that no server should implement
-  rpc UnimplementedCall(Empty) returns (Empty);
+  rpc UnimplementedCall(grpc.testing.Empty) returns (grpc.testing.Empty);
 }

testing/test_server.go

@@ -1,17 +1,14 @@
 package testing
 
-//go:generate protoc --go_out=. --go-grpc_out=. test.proto
-//go:generate protoc --descriptor_set_out=./test.protoset test.proto
-//go:generate protoc --descriptor_set_out=./example.protoset --include_imports example.proto
-
 import (
-	"context"
 	"io"
 	"strconv"
 	"time"
 
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/interop/grpc_testing"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
 
@@ -19,12 +16,10 @@ import (
 )
 
 // TestServer implements the TestService interface defined in example.proto.
-type TestServer struct {
+type TestServer struct{}
-	UnimplementedTestServiceServer
-}
 
 // EmptyCall accepts one empty request and issues one empty response.
-func (TestServer) EmptyCall(ctx context.Context, req *Empty) (*Empty, error) {
+func (TestServer) EmptyCall(ctx context.Context, req *grpc_testing.Empty) (*grpc_testing.Empty, error) {
 	headers, trailers, failEarly, failLate := processMetadata(ctx)
 	grpc.SetHeader(ctx, headers)
 	grpc.SetTrailer(ctx, trailers)
@@ -40,7 +35,7 @@ func (TestServer) EmptyCall(ctx context.Context, req *Empty) (*Empty, error) {
 
 // UnaryCall accepts one request and issues one response. The response includes
 // the client's payload as-is.
-func (TestServer) UnaryCall(ctx context.Context, req *SimpleRequest) (*SimpleResponse, error) {
+func (TestServer) UnaryCall(ctx context.Context, req *grpc_testing.SimpleRequest) (*grpc_testing.SimpleResponse, error) {
 	headers, trailers, failEarly, failLate := processMetadata(ctx)
 	grpc.SetHeader(ctx, headers)
 	grpc.SetTrailer(ctx, trailers)
@@ -51,7 +46,7 @@ func (TestServer) UnaryCall(ctx context.Context, req *SimpleRequest) (*SimpleRes
 		return nil, status.Error(failLate, "fail")
 	}
 
-	return &SimpleResponse{
+	return &grpc_testing.SimpleResponse{
 		Payload: req.Payload,
 	}, nil
 }
@@ -59,7 +54,7 @@ func (TestServer) UnaryCall(ctx context.Context, req *SimpleRequest) (*SimpleRes
 // StreamingOutputCall accepts one request and issues a sequence of responses
 // (streamed download). The server returns the payload with client desired type
 // and sizes as specified in the request's ResponseParameters.
-func (TestServer) StreamingOutputCall(req *StreamingOutputCallRequest, str TestService_StreamingOutputCallServer) error {
+func (TestServer) StreamingOutputCall(req *grpc_testing.StreamingOutputCallRequest, str grpc_testing.TestService_StreamingOutputCallServer) error {
 	headers, trailers, failEarly, failLate := processMetadata(str.Context())
 	str.SetHeader(headers)
 	str.SetTrailer(trailers)
@@ -67,7 +62,7 @@ func (TestServer) StreamingOutputCall(req *StreamingOutputCallRequest, str TestS
 		return status.Error(failEarly, "fail")
 	}
 
-	rsp := &StreamingOutputCallResponse{Payload: &Payload{}}
+	rsp := &grpc_testing.StreamingOutputCallResponse{Payload: &grpc_testing.Payload{}}
 	for _, param := range req.ResponseParameters {
 		if str.Context().Err() != nil {
 			return str.Context().Err()
@@ -97,7 +92,7 @@ func (TestServer) StreamingOutputCall(req *StreamingOutputCallRequest, str TestS
 // StreamingInputCall accepts a sequence of requests and issues one response
 // (streamed upload). The server returns the aggregated size of client payloads
 // as the result.
-func (TestServer) StreamingInputCall(str TestService_StreamingInputCallServer) error {
+func (TestServer) StreamingInputCall(str grpc_testing.TestService_StreamingInputCallServer) error {
 	headers, trailers, failEarly, failLate := processMetadata(str.Context())
 	str.SetHeader(headers)
 	str.SetTrailer(trailers)
@@ -119,7 +114,7 @@ func (TestServer) StreamingInputCall(str TestService_StreamingInputCallServer) e
 			sz += len(req.Payload.Body)
 		}
 	}
-	if err := str.SendAndClose(&StreamingInputCallResponse{AggregatedPayloadSize: int32(sz)}); err != nil {
+	if err := str.SendAndClose(&grpc_testing.StreamingInputCallResponse{AggregatedPayloadSize: int32(sz)}); err != nil {
 		return err
 	}
 
@@ -132,7 +127,7 @@ func (TestServer) StreamingInputCall(str TestService_StreamingInputCallServer) e
 // FullDuplexCall accepts a sequence of requests with each request served by the
 // server immediately. As one request could lead to multiple responses, this
 // interface demonstrates the idea of full duplexing.
-func (TestServer) FullDuplexCall(str TestService_FullDuplexCallServer) error {
+func (TestServer) FullDuplexCall(str grpc_testing.TestService_FullDuplexCallServer) error {
 	headers, trailers, failEarly, failLate := processMetadata(str.Context())
 	str.SetHeader(headers)
 	str.SetTrailer(trailers)
@@ -140,7 +135,7 @@ func (TestServer) FullDuplexCall(str TestService_FullDuplexCallServer) error {
 		return status.Error(failEarly, "fail")
 	}
 
-	rsp := &StreamingOutputCallResponse{Payload: &Payload{}}
+	rsp := &grpc_testing.StreamingOutputCallResponse{Payload: &grpc_testing.Payload{}}
 	for {
 		if str.Context().Err() != nil {
 			return str.Context().Err()
@@ -175,7 +170,7 @@ func (TestServer) FullDuplexCall(str TestService_FullDuplexCallServer) error {
 // responses. The server buffers all the client requests and then serves them
 // in order. A stream of responses is returned to the client once the client
 // half-closes the stream.
-func (TestServer) HalfDuplexCall(str TestService_HalfDuplexCallServer) error {
+func (TestServer) HalfDuplexCall(str grpc_testing.TestService_HalfDuplexCallServer) error {
 	headers, trailers, failEarly, failLate := processMetadata(str.Context())
 	str.SetHeader(headers)
 	str.SetTrailer(trailers)
@@ -183,7 +178,7 @@ func (TestServer) HalfDuplexCall(str TestService_HalfDuplexCallServer) error {
 		return status.Error(failEarly, "fail")
 	}
 
-	var reqs []*StreamingOutputCallRequest
+	var reqs []*grpc_testing.StreamingOutputCallRequest
 	for {
 		if str.Context().Err() != nil {
 			return str.Context().Err()
@@ -197,7 +192,7 @@ func (TestServer) HalfDuplexCall(str TestService_HalfDuplexCallServer) error {
 			reqs = append(reqs, req)
 		}
 	}
-	rsp := &StreamingOutputCallResponse{}
+	rsp := &grpc_testing.StreamingOutputCallResponse{}
 	for _, req := range reqs {
 		rsp.Payload = req.Payload
 		if err := str.Send(rsp); err != nil {
@@ -256,4 +251,4 @@ func toCode(vals []string) codes.Code {
 	return codes.Code(i)
 }
 
-var _ TestServiceServer = TestServer{}
+var _ grpc_testing.TestServiceServer = TestServer{}

tls_settings_test.go

@@ -1,18 +1,19 @@
 package grpcurl_test
 
 import (
-	"context"
 	"fmt"
 	"net"
 	"strings"
 	"testing"
 	"time"
 
+	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/interop/grpc_testing"
 
 	. "github.com/fullstorydev/grpcurl"
-	grpcurl_testing "github.com/fullstorydev/grpcurl/internal/testing"
+	grpcurl_testing "github.com/fullstorydev/grpcurl/testing"
 )
 
 func TestPlainText(t *testing.T) {
@@ -26,11 +27,11 @@ func TestPlainText(t *testing.T) {
 }
 
 func TestBasicTLS(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", false)
+	serverCreds, err := ServerTransportCredentials("", "testing/tls/server.crt", "testing/tls/server.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "", "")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "", "")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
@@ -45,7 +46,7 @@ func TestBasicTLS(t *testing.T) {
 }
 
 func TestInsecureClientTLS(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", false)
+	serverCreds, err := ServerTransportCredentials("", "testing/tls/server.crt", "testing/tls/server.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
@@ -64,11 +65,11 @@ func TestInsecureClientTLS(t *testing.T) {
 }
 
 func TestClientCertTLS(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("internal/testing/tls/ca.crt", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", false)
+	serverCreds, err := ServerTransportCredentials("testing/tls/ca.crt", "testing/tls/server.crt", "testing/tls/server.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "internal/testing/tls/client.crt", "internal/testing/tls/client.key")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "testing/tls/client.crt", "testing/tls/client.key")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
@@ -83,11 +84,11 @@ func TestClientCertTLS(t *testing.T) {
 }
 
 func TestRequireClientCertTLS(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("internal/testing/tls/ca.crt", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", true)
+	serverCreds, err := ServerTransportCredentials("testing/tls/ca.crt", "testing/tls/server.crt", "testing/tls/server.key", true)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "internal/testing/tls/client.crt", "internal/testing/tls/client.key")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "testing/tls/client.crt", "testing/tls/client.key")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
@@ -102,53 +103,35 @@ func TestRequireClientCertTLS(t *testing.T) {
 }
 
 func TestBrokenTLS_ClientPlainText(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", false)
+	serverCreds, err := ServerTransportCredentials("", "testing/tls/server.crt", "testing/tls/server.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	// client connection (usually) succeeds since client is not waiting for TLS handshake
-	// (we try several times, but if we never get a connection and the error message is
+	e, err := createTestServerAndClient(serverCreds, nil)
-	// a known/expected possibility, we'll just bail)
+	if err != nil {
-	var e testEnv
+		if strings.Contains(err.Error(), "deadline exceeded") {
-	failCount := 0
+			// It is possible that connection never becomes healthy:
-	for {
-		e, err = createTestServerAndClient(serverCreds, nil)
-		if err == nil {
-			// success!
-			defer e.Close()
-			break
-		}
-
-		if strings.Contains(err.Error(), "deadline exceeded") ||
-			strings.Contains(err.Error(), "use of closed network connection") {
-			// It is possible that the connection never becomes healthy:
 			//   1) grpc connects successfully
 			//   2) grpc client tries to send HTTP/2 preface and settings frame
 			//   3) server, expecting handshake, closes the connection
 			//   4) in the client, the write fails, so the connection never
 			//      becomes ready
-			// The client will attempt to reconnect on transient errors, so
+			// More often than not, the connection becomes ready (presumably
-			// may eventually bump into the connect time limit. This used to
+			// the write to the socket succeeds before the server closes the
-			// result in a "deadline exceeded" error, but more recent versions
+			// connection). But when it does not, it is possible to observe
-			// of the grpc library report any underlying I/O error instead, so
+			// timeouts when setting up the connection.
-			// we also check for "use of closed network connection".
+			return
-			failCount++
-			if failCount > 5 {
-				return // bail...
 		}
-			// we'll try again
-
-		} else {
-			// some other error occurred, so we'll consider that a test failure
 		t.Fatalf("failed to setup server and client: %v", err)
 	}
-	}
+	defer e.Close()
 
 	// but request fails because server closes connection upon seeing request
 	// bytes that are not a TLS handshake
-	cl := grpcurl_testing.NewTestServiceClient(e.cc)
+	cl := grpc_testing.NewTestServiceClient(e.cc)
-	_, err = cl.UnaryCall(context.Background(), &grpcurl_testing.SimpleRequest{})
+	_, err = cl.UnaryCall(context.Background(), &grpc_testing.SimpleRequest{})
 	if err == nil {
 		t.Fatal("expecting failure")
 	}
@@ -163,15 +146,15 @@ func TestBrokenTLS_ClientPlainText(t *testing.T) {
 }
 
 func TestBrokenTLS_ServerPlainText(t *testing.T) {
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "", "")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "", "")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	e, err := createTestServerAndClient(nil, clientCreds)
 	if err == nil {
-		e.Close()
 		t.Fatal("expecting TLS failure setting up server and client")
+		e.Close()
 	}
 	if !strings.Contains(err.Error(), "first record does not look like a TLS handshake") {
 		t.Fatalf("expecting TLS handshake failure, got: %v", err)
@@ -179,19 +162,19 @@ func TestBrokenTLS_ServerPlainText(t *testing.T) {
 }
 
 func TestBrokenTLS_ServerUsesWrongCert(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("", "internal/testing/tls/other.crt", "internal/testing/tls/other.key", false)
+	serverCreds, err := ServerTransportCredentials("", "testing/tls/other.crt", "testing/tls/other.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "", "")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "", "")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	e, err := createTestServerAndClient(serverCreds, clientCreds)
 	if err == nil {
-		e.Close()
 		t.Fatal("expecting TLS failure setting up server and client")
+		e.Close()
 	}
 	if !strings.Contains(err.Error(), "certificate is valid for") {
 		t.Fatalf("expecting TLS certificate error, got: %v", err)
@@ -199,39 +182,39 @@ func TestBrokenTLS_ServerUsesWrongCert(t *testing.T) {
 }
 
 func TestBrokenTLS_ClientHasExpiredCert(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("internal/testing/tls/ca.crt", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", false)
+	serverCreds, err := ServerTransportCredentials("testing/tls/ca.crt", "testing/tls/server.crt", "testing/tls/server.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "internal/testing/tls/expired.crt", "internal/testing/tls/expired.key")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "testing/tls/expired.crt", "testing/tls/expired.key")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	e, err := createTestServerAndClient(serverCreds, clientCreds)
 	if err == nil {
-		e.Close()
 		t.Fatal("expecting TLS failure setting up server and client")
+		e.Close()
 	}
-	if !strings.Contains(err.Error(), "certificate") {
+	if !strings.Contains(err.Error(), "bad certificate") {
 		t.Fatalf("expecting TLS certificate error, got: %v", err)
 	}
 }
 
 func TestBrokenTLS_ServerHasExpiredCert(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("", "internal/testing/tls/expired.crt", "internal/testing/tls/expired.key", false)
+	serverCreds, err := ServerTransportCredentials("", "testing/tls/expired.crt", "testing/tls/expired.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "", "")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "", "")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	e, err := createTestServerAndClient(serverCreds, clientCreds)
 	if err == nil {
-		e.Close()
 		t.Fatal("expecting TLS failure setting up server and client")
+		e.Close()
 	}
 	if !strings.Contains(err.Error(), "certificate has expired or is not yet valid") {
 		t.Fatalf("expecting TLS certificate expired, got: %v", err)
@@ -239,78 +222,70 @@ func TestBrokenTLS_ServerHasExpiredCert(t *testing.T) {
 }
 
 func TestBrokenTLS_ClientNotTrusted(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("internal/testing/tls/ca.crt", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", true)
+	serverCreds, err := ServerTransportCredentials("testing/tls/ca.crt", "testing/tls/server.crt", "testing/tls/server.key", true)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "internal/testing/tls/wrong-client.crt", "internal/testing/tls/wrong-client.key")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "testing/tls/wrong-client.crt", "testing/tls/wrong-client.key")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	e, err := createTestServerAndClient(serverCreds, clientCreds)
 	if err == nil {
-		e.Close()
 		t.Fatal("expecting TLS failure setting up server and client")
+		e.Close()
 	}
-	// Check for either the old error (Go <=1.24) or the new one (Go 1.25+)
+	if !strings.Contains(err.Error(), "bad certificate") {
-	// Go 1.24: "bad certificate"
+		t.Fatalf("expecting TLS certificate error, got: %v", err)
-	// Go 1.25: "handshake failure"
-	errMsg := err.Error()
-	if !strings.Contains(errMsg, "bad certificate") && !strings.Contains(errMsg, "handshake failure") {
-		t.Fatalf("expecting a specific TLS certificate or handshake error, got: %v", err)
 	}
 }
 
 func TestBrokenTLS_ServerNotTrusted(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", false)
+	serverCreds, err := ServerTransportCredentials("", "testing/tls/server.crt", "testing/tls/server.key", false)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "", "internal/testing/tls/client.crt", "internal/testing/tls/client.key")
+	clientCreds, err := ClientTransportCredentials(false, "", "testing/tls/client.crt", "testing/tls/client.key")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	e, err := createTestServerAndClient(serverCreds, clientCreds)
 	if err == nil {
-		e.Close()
 		t.Fatal("expecting TLS failure setting up server and client")
+		e.Close()
 	}
-	if !strings.Contains(err.Error(), "certificate") {
+	if !strings.Contains(err.Error(), "certificate signed by unknown authority") {
 		t.Fatalf("expecting TLS certificate error, got: %v", err)
 	}
 }
 
 func TestBrokenTLS_RequireClientCertButNonePresented(t *testing.T) {
-	serverCreds, err := ServerTransportCredentials("internal/testing/tls/ca.crt", "internal/testing/tls/server.crt", "internal/testing/tls/server.key", true)
+	serverCreds, err := ServerTransportCredentials("testing/tls/ca.crt", "testing/tls/server.crt", "testing/tls/server.key", true)
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
-	clientCreds, err := ClientTransportCredentials(false, "internal/testing/tls/ca.crt", "", "")
+	clientCreds, err := ClientTransportCredentials(false, "testing/tls/ca.crt", "", "")
 	if err != nil {
 		t.Fatalf("failed to create server creds: %v", err)
 	}
 
 	e, err := createTestServerAndClient(serverCreds, clientCreds)
 	if err == nil {
-		e.Close()
 		t.Fatal("expecting TLS failure setting up server and client")
+		e.Close()
 	}
-	// Check for either the old error (Go <=1.24) or the new one (Go 1.25+)
+	if !strings.Contains(err.Error(), "bad certificate") {
-	// Go 1.24: "bad certificate"
+		t.Fatalf("expecting TLS certificate error, got: %v", err)
-	// Go 1.25: "handshake failure"
-	errMsg := err.Error()
-	if !strings.Contains(errMsg, "bad certificate") && !strings.Contains(errMsg, "handshake failure") {
-		t.Fatalf("expecting a specific TLS certificate or handshake error, got: %v", err)
 	}
 }
 
 func simpleTest(t *testing.T, cc *grpc.ClientConn) {
-	cl := grpcurl_testing.NewTestServiceClient(cc)
+	cl := grpc_testing.NewTestServiceClient(cc)
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 	defer cancel()
-	_, err := cl.UnaryCall(ctx, &grpcurl_testing.SimpleRequest{}, grpc.WaitForReady(true))
+	_, err := cl.UnaryCall(ctx, &grpc_testing.SimpleRequest{}, grpc.FailFast(false))
 	if err != nil {
 		t.Errorf("simple RPC failed: %v", err)
 	}
@@ -330,7 +305,7 @@ func createTestServerAndClient(serverCreds, clientCreds credentials.TransportCre
 		svrOpts = []grpc.ServerOption{grpc.Creds(serverCreds)}
 	}
 	svr := grpc.NewServer(svrOpts...)
-	grpcurl_testing.RegisterTestServiceServer(svr, grpcurl_testing.TestServer{})
+	grpc_testing.RegisterTestServiceServer(svr, grpcurl_testing.TestServer{})
 	l, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		return e, err
@@ -357,7 +332,7 @@ type testEnv struct {
 	cc  *grpc.ClientConn
 }
 
-func (e *testEnv) Close() {
+func (e testEnv) Close() {
 	if e.cc != nil {
 		e.cc.Close()
 		e.cc = nil