credentials/alts/internal/proto/grpc_gcp/handshaker_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package grpc_gcp

import (
	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.
const _ = grpc.SupportPackageIsVersion7

// HandshakerServiceService is the service API for HandshakerService service.
// Fields should be assigned to their respective handler implementations only before
// RegisterHandshakerServiceService is called.  Any unassigned fields will result in the
// handler for that method returning an Unimplemented error.
type HandshakerServiceService struct {
	// Handshaker service accepts a stream of handshaker request, returning a
	// stream of handshaker response. Client is expected to send exactly one
	// message with either client_start or server_start followed by one or more
	// messages with next. Each time client sends a request, the handshaker
	// service expects to respond. Client does not have to wait for service's
	// response before sending next request.
	DoHandshake func(HandshakerService_DoHandshakeServer) error
}

func (s *HandshakerServiceService) doHandshake(_ interface{}, stream grpc.ServerStream) error {
	if s.DoHandshake == nil {
		return status.Errorf(codes.Unimplemented, "method DoHandshake not implemented")
	}
	return s.DoHandshake(&handshakerServiceDoHandshakeServer{stream})
}

// RegisterHandshakerServiceService registers a service implementation with a gRPC server.
func RegisterHandshakerServiceService(s grpc.ServiceRegistrar, srv *HandshakerServiceService) {
	sd := grpc.ServiceDesc{
		ServiceName: "grpc.gcp.HandshakerService",
		Methods:     []grpc.MethodDesc{},
		Streams: []grpc.StreamDesc{
			{
				StreamName:    "DoHandshake",
				Handler:       srv.doHandshake,
				ServerStreams: true,
				ClientStreams: true,
			},
		},
		Metadata: "grpc/gcp/handshaker.proto",
	}

	s.RegisterService(&sd, nil)
}

// NewHandshakerServiceService creates a new HandshakerServiceService containing the
// implemented methods of the HandshakerService service in s.  Any unimplemented
// methods will result in the gRPC server returning an UNIMPLEMENTED status to the client.
// This includes situations where the method handler is misspelled or has the wrong
// signature.  For this reason, this function should be used with great care and
// is not recommended to be used by most users.
func NewHandshakerServiceService(s interface{}) *HandshakerServiceService {
	ns := &HandshakerServiceService{}
	if h, ok := s.(interface {
		DoHandshake(HandshakerService_DoHandshakeServer) error
	}); ok {
		ns.DoHandshake = h.DoHandshake
	}
	return ns
}

// UnstableHandshakerServiceService is the service API for HandshakerService service.
// New methods may be added to this interface if they are added to the service
// definition, which is not a backward-compatible change.  For this reason,
// use of this type is not recommended.
type UnstableHandshakerServiceService interface {
	// Handshaker service accepts a stream of handshaker request, returning a
	// stream of handshaker response. Client is expected to send exactly one
	// message with either client_start or server_start followed by one or more
	// messages with next. Each time client sends a request, the handshaker
	// service expects to respond. Client does not have to wait for service's
	// response before sending next request.
	DoHandshake(HandshakerService_DoHandshakeServer) error
}