func main() {
// Set up a connection to the server.
conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithCodec(&codec.Buffer{}))
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := fb.NewWorkerClient(conn)
// Contact the server and print out its response.
r, err := c.Hello(context.Background(), &fb.Payload{Data: []byte("Client")})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", string(r.Data))
}
func (g *grpcClient) stream(ctx context.Context, address string, req client.Request, opts client.CallOptions) (client.Streamer, error) {
header := make(map[string]string)
if md, ok := metadata.FromContext(ctx); ok {
for k, v := range md {
header[k] = v
}
}
// set timeout in nanoseconds
header["timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
// set the content type for the request
header["x-content-type"] = req.ContentType()
md := gmetadata.New(header)
ctx = gmetadata.NewContext(ctx, md)
cf, err := g.newGRPCCodec(req.ContentType())
if err != nil {
return nil, errors.InternalServerError("go.micro.client", err.Error())
}
// TODO: do not use insecure
cc, err := grpc.Dial(address, grpc.WithCodec(cf), grpc.WithTimeout(opts.DialTimeout), grpc.WithInsecure())
if err != nil {
return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
}
desc := &grpc.StreamDesc{
StreamName: req.Service() + req.Method(),
ClientStreams: true,
ServerStreams: true,
}
st, err := grpc.NewClientStream(ctx, desc, cc, req.Method())
if err != nil {
return nil, errors.InternalServerError("go.micro.client", fmt.Sprintf("Error creating stream: %v", err))
}
return &grpcStream{
context: ctx,
request: req,
closed: make(chan bool),
stream: st,
conn: cc,
}, nil
}
// createConns creates connections according to given config.
// It returns the connections and corresponding function to close them.
// It returns non-nil error if there is anything wrong.
func createConns(config *testpb.ClientConfig) ([]*grpc.ClientConn, func(), error) {
var opts []grpc.DialOption
// Sanity check for client type.
switch config.ClientType {
case testpb.ClientType_SYNC_CLIENT:
case testpb.ClientType_ASYNC_CLIENT:
default:
return nil, nil, grpc.Errorf(codes.InvalidArgument, "unknow client type: %v", config.ClientType)
}
// Check and set security options.
if config.SecurityParams != nil {
creds, err := credentials.NewClientTLSFromFile(abs(caFile), config.SecurityParams.ServerHostOverride)
if err != nil {
return nil, nil, grpc.Errorf(codes.InvalidArgument, "failed to create TLS credentials %v", err)
}
opts = append(opts, grpc.WithTransportCredentials(creds))
} else {
opts = append(opts, grpc.WithInsecure())
}
// Use byteBufCodec if it is required.
if config.PayloadConfig != nil {
switch config.PayloadConfig.Payload.(type) {
case *testpb.PayloadConfig_BytebufParams:
opts = append(opts, grpc.WithCodec(byteBufCodec{}))
case *testpb.PayloadConfig_SimpleParams:
default:
return nil, nil, grpc.Errorf(codes.InvalidArgument, "unknow payload config: %v", config.PayloadConfig)
}
}
// Create connections.
connCount := int(config.ClientChannels)
conns := make([]*grpc.ClientConn, connCount, connCount)
for connIndex := 0; connIndex < connCount; connIndex++ {
conns[connIndex] = benchmark.NewClientConn(config.ServerTargets[connIndex%len(config.ServerTargets)], opts...)
}
return conns, func() {
for _, conn := range conns {
conn.Close()
}
}, nil
}
func (g *grpcClient) call(ctx context.Context, address string, req client.Request, rsp interface{}, opts client.CallOptions) error {
header := make(map[string]string)
if md, ok := metadata.FromContext(ctx); ok {
for k, v := range md {
header[k] = v
}
}
// set timeout in nanoseconds
header["timeout"] = fmt.Sprintf("%d", opts.RequestTimeout)
// set the content type for the request
header["x-content-type"] = req.ContentType()
md := gmetadata.New(header)
ctx = gmetadata.NewContext(ctx, md)
cf, err := g.newGRPCCodec(req.ContentType())
if err != nil {
return errors.InternalServerError("go.micro.client", err.Error())
}
var grr error
// TODO: do not use insecure
cc, err := grpc.Dial(address, grpc.WithCodec(cf), grpc.WithTimeout(opts.DialTimeout), grpc.WithInsecure())
if err != nil {
return errors.InternalServerError("go.micro.client", fmt.Sprintf("Error sending request: %v", err))
}
defer cc.Close()
ch := make(chan error, 1)
go func() {
ch <- grpc.Invoke(ctx, req.Method(), req.Request(), rsp, cc)
}()
select {
case err := <-ch:
grr = err
case <-ctx.Done():
grr = ctx.Err()
}
return grr
}
func clientMetadataFromContext(ctx context.Context) map[string]string {
cred, ok := ctx.Value(clientMetadataKey).(map[string]string)
if !ok {
return nil
}
return cred
}
var maxDialTimeout = 10 * time.Second
// NewClientFromContext returns a Sourcegraph API client that
// communicates with the Sourcegraph gRPC endpoint in ctx (i.e.,
// GRPCEndpoint(ctx)).
var NewClientFromContext = func(ctx context.Context) *Client {
opts := []grpc.DialOption{
grpc.WithCodec(GRPCCodec),
}
grpcEndpoint := GRPCEndpoint(ctx)
if grpcEndpoint.Scheme == "https" {
creds := credentials.NewClientTLSFromCert(nil, "")
if host, _, _ := net.SplitHostPort(grpcEndpoint.Host); host == "localhost" {
creds = credentials.NewTLS(&tls.Config{InsecureSkipVerify: true})
}
opts = append(opts, grpc.WithTransportCredentials(creds))
}
// Use contextCredentials instead of directly using the cred
// so that we can use different credentials for the same
// connection (in the pool).
opts = append(opts, grpc.WithPerRPCCredentials(contextCredentials{}))