servers_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.19.6
// source: servers.proto

package telemetry

import (
	context "context"
	v11 "go.opentelemetry.io/proto/otlp/logs/v1"
	v12 "go.opentelemetry.io/proto/otlp/metrics/v1"
	v1 "go.opentelemetry.io/proto/otlp/trace/v1"
	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

const (
	TracesSource_Subscribe_FullMethodName = "/telemetry.TracesSource/Subscribe"
)

// TracesSourceClient is the client API for TracesSource 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 TracesSourceClient interface {
	Subscribe(ctx context.Context, in *TelemetryRequest, opts ...grpc.CallOption) (TracesSource_SubscribeClient, error)
}

type tracesSourceClient struct {
	cc grpc.ClientConnInterface
}

func NewTracesSourceClient(cc grpc.ClientConnInterface) TracesSourceClient {
	return &tracesSourceClient{cc}
}

func (c *tracesSourceClient) Subscribe(ctx context.Context, in *TelemetryRequest, opts ...grpc.CallOption) (TracesSource_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &TracesSource_ServiceDesc.Streams[0], TracesSource_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &tracesSourceSubscribeClient{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 TracesSource_SubscribeClient interface {
	Recv() (*v1.TracesData, error)
	grpc.ClientStream
}

type tracesSourceSubscribeClient struct {
	grpc.ClientStream
}

func (x *tracesSourceSubscribeClient) Recv() (*v1.TracesData, error) {
	m := new(v1.TracesData)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// TracesSourceServer is the server API for TracesSource service.
// All implementations must embed UnimplementedTracesSourceServer
// for forward compatibility
type TracesSourceServer interface {
	Subscribe(*TelemetryRequest, TracesSource_SubscribeServer) error
	mustEmbedUnimplementedTracesSourceServer()
}

// UnimplementedTracesSourceServer must be embedded to have forward compatible implementations.
type UnimplementedTracesSourceServer struct {
}

func (UnimplementedTracesSourceServer) Subscribe(*TelemetryRequest, TracesSource_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedTracesSourceServer) mustEmbedUnimplementedTracesSourceServer() {}

// UnsafeTracesSourceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to TracesSourceServer will
// result in compilation errors.
type UnsafeTracesSourceServer interface {
	mustEmbedUnimplementedTracesSourceServer()
}

func RegisterTracesSourceServer(s grpc.ServiceRegistrar, srv TracesSourceServer) {
	s.RegisterService(&TracesSource_ServiceDesc, srv)
}

func _TracesSource_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TelemetryRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TracesSourceServer).Subscribe(m, &tracesSourceSubscribeServer{stream})
}

type TracesSource_SubscribeServer interface {
	Send(*v1.TracesData) error
	grpc.ServerStream
}

type tracesSourceSubscribeServer struct {
	grpc.ServerStream
}

func (x *tracesSourceSubscribeServer) Send(m *v1.TracesData) error {
	return x.ServerStream.SendMsg(m)
}

// TracesSource_ServiceDesc is the grpc.ServiceDesc for TracesSource service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TracesSource_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "telemetry.TracesSource",
	HandlerType: (*TracesSourceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Subscribe",
			Handler:       _TracesSource_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "servers.proto",
}

const (
	LogsSource_Subscribe_FullMethodName = "/telemetry.LogsSource/Subscribe"
)

// LogsSourceClient is the client API for LogsSource 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 LogsSourceClient interface {
	Subscribe(ctx context.Context, in *TelemetryRequest, opts ...grpc.CallOption) (LogsSource_SubscribeClient, error)
}

type logsSourceClient struct {
	cc grpc.ClientConnInterface
}

func NewLogsSourceClient(cc grpc.ClientConnInterface) LogsSourceClient {
	return &logsSourceClient{cc}
}

func (c *logsSourceClient) Subscribe(ctx context.Context, in *TelemetryRequest, opts ...grpc.CallOption) (LogsSource_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &LogsSource_ServiceDesc.Streams[0], LogsSource_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &logsSourceSubscribeClient{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 LogsSource_SubscribeClient interface {
	Recv() (*v11.LogsData, error)
	grpc.ClientStream
}

type logsSourceSubscribeClient struct {
	grpc.ClientStream
}

func (x *logsSourceSubscribeClient) Recv() (*v11.LogsData, error) {
	m := new(v11.LogsData)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// LogsSourceServer is the server API for LogsSource service.
// All implementations must embed UnimplementedLogsSourceServer
// for forward compatibility
type LogsSourceServer interface {
	Subscribe(*TelemetryRequest, LogsSource_SubscribeServer) error
	mustEmbedUnimplementedLogsSourceServer()
}

// UnimplementedLogsSourceServer must be embedded to have forward compatible implementations.
type UnimplementedLogsSourceServer struct {
}

func (UnimplementedLogsSourceServer) Subscribe(*TelemetryRequest, LogsSource_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedLogsSourceServer) mustEmbedUnimplementedLogsSourceServer() {}

// UnsafeLogsSourceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to LogsSourceServer will
// result in compilation errors.
type UnsafeLogsSourceServer interface {
	mustEmbedUnimplementedLogsSourceServer()
}

func RegisterLogsSourceServer(s grpc.ServiceRegistrar, srv LogsSourceServer) {
	s.RegisterService(&LogsSource_ServiceDesc, srv)
}

func _LogsSource_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TelemetryRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LogsSourceServer).Subscribe(m, &logsSourceSubscribeServer{stream})
}

type LogsSource_SubscribeServer interface {
	Send(*v11.LogsData) error
	grpc.ServerStream
}

type logsSourceSubscribeServer struct {
	grpc.ServerStream
}

func (x *logsSourceSubscribeServer) Send(m *v11.LogsData) error {
	return x.ServerStream.SendMsg(m)
}

// LogsSource_ServiceDesc is the grpc.ServiceDesc for LogsSource service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var LogsSource_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "telemetry.LogsSource",
	HandlerType: (*LogsSourceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Subscribe",
			Handler:       _LogsSource_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "servers.proto",
}

const (
	MetricsSource_Subscribe_FullMethodName = "/telemetry.MetricsSource/Subscribe"
)

// MetricsSourceClient is the client API for MetricsSource 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 MetricsSourceClient interface {
	Subscribe(ctx context.Context, in *TelemetryRequest, opts ...grpc.CallOption) (MetricsSource_SubscribeClient, error)
}

type metricsSourceClient struct {
	cc grpc.ClientConnInterface
}

func NewMetricsSourceClient(cc grpc.ClientConnInterface) MetricsSourceClient {
	return &metricsSourceClient{cc}
}

func (c *metricsSourceClient) Subscribe(ctx context.Context, in *TelemetryRequest, opts ...grpc.CallOption) (MetricsSource_SubscribeClient, error) {
	stream, err := c.cc.NewStream(ctx, &MetricsSource_ServiceDesc.Streams[0], MetricsSource_Subscribe_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &metricsSourceSubscribeClient{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 MetricsSource_SubscribeClient interface {
	Recv() (*v12.MetricsData, error)
	grpc.ClientStream
}

type metricsSourceSubscribeClient struct {
	grpc.ClientStream
}

func (x *metricsSourceSubscribeClient) Recv() (*v12.MetricsData, error) {
	m := new(v12.MetricsData)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// MetricsSourceServer is the server API for MetricsSource service.
// All implementations must embed UnimplementedMetricsSourceServer
// for forward compatibility
type MetricsSourceServer interface {
	Subscribe(*TelemetryRequest, MetricsSource_SubscribeServer) error
	mustEmbedUnimplementedMetricsSourceServer()
}

// UnimplementedMetricsSourceServer must be embedded to have forward compatible implementations.
type UnimplementedMetricsSourceServer struct {
}

func (UnimplementedMetricsSourceServer) Subscribe(*TelemetryRequest, MetricsSource_SubscribeServer) error {
	return status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedMetricsSourceServer) mustEmbedUnimplementedMetricsSourceServer() {}

// UnsafeMetricsSourceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to MetricsSourceServer will
// result in compilation errors.
type UnsafeMetricsSourceServer interface {
	mustEmbedUnimplementedMetricsSourceServer()
}

func RegisterMetricsSourceServer(s grpc.ServiceRegistrar, srv MetricsSourceServer) {
	s.RegisterService(&MetricsSource_ServiceDesc, srv)
}

func _MetricsSource_Subscribe_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TelemetryRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MetricsSourceServer).Subscribe(m, &metricsSourceSubscribeServer{stream})
}

type MetricsSource_SubscribeServer interface {
	Send(*v12.MetricsData) error
	grpc.ServerStream
}

type metricsSourceSubscribeServer struct {
	grpc.ServerStream
}

func (x *metricsSourceSubscribeServer) Send(m *v12.MetricsData) error {
	return x.ServerStream.SendMsg(m)
}

// MetricsSource_ServiceDesc is the grpc.ServiceDesc for MetricsSource service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var MetricsSource_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "telemetry.MetricsSource",
	HandlerType: (*MetricsSourceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Subscribe",
			Handler:       _MetricsSource_Subscribe_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "servers.proto",
}