ddsched_grpc.pb.go

// Copyright 2019-2022 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.

/// \author Gvozden Nešković, Frankfurt Institute for Advanced Studies and Goethe University Frankfurt

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v5.29.3
// source: protos/ddsched.proto

// Changelog:
//      2021-02-08: - Initial version
//                  - Support for a single partition/environment: PartitionID = EnvironmentID

package ddpb

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

const (
	DataDistributionControl_PartitionInitialize_FullMethodName = "/o2.DataDistribution.Control.DataDistributionControl/PartitionInitialize"
	DataDistributionControl_PartitionTerminate_FullMethodName  = "/o2.DataDistribution.Control.DataDistributionControl/PartitionTerminate"
	DataDistributionControl_PartitionStatus_FullMethodName     = "/o2.DataDistribution.Control.DataDistributionControl/PartitionStatus"
)

// DataDistributionControlClient is the client API for DataDistributionControl 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 DataDistributionControlClient interface {
	// Partition management requests
	PartitionInitialize(ctx context.Context, in *PartitionInitRequest, opts ...grpc.CallOption) (*PartitionResponse, error)
	PartitionTerminate(ctx context.Context, in *PartitionTermRequest, opts ...grpc.CallOption) (*PartitionResponse, error)
	PartitionStatus(ctx context.Context, in *PartitionInfo, opts ...grpc.CallOption) (*PartitionResponse, error)
}

type dataDistributionControlClient struct {
	cc grpc.ClientConnInterface
}

func NewDataDistributionControlClient(cc grpc.ClientConnInterface) DataDistributionControlClient {
	return &dataDistributionControlClient{cc}
}

func (c *dataDistributionControlClient) PartitionInitialize(ctx context.Context, in *PartitionInitRequest, opts ...grpc.CallOption) (*PartitionResponse, error) {
	out := new(PartitionResponse)
	err := c.cc.Invoke(ctx, DataDistributionControl_PartitionInitialize_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataDistributionControlClient) PartitionTerminate(ctx context.Context, in *PartitionTermRequest, opts ...grpc.CallOption) (*PartitionResponse, error) {
	out := new(PartitionResponse)
	err := c.cc.Invoke(ctx, DataDistributionControl_PartitionTerminate_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dataDistributionControlClient) PartitionStatus(ctx context.Context, in *PartitionInfo, opts ...grpc.CallOption) (*PartitionResponse, error) {
	out := new(PartitionResponse)
	err := c.cc.Invoke(ctx, DataDistributionControl_PartitionStatus_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DataDistributionControlServer is the server API for DataDistributionControl service.
// All implementations should embed UnimplementedDataDistributionControlServer
// for forward compatibility
type DataDistributionControlServer interface {
	// Partition management requests
	PartitionInitialize(context.Context, *PartitionInitRequest) (*PartitionResponse, error)
	PartitionTerminate(context.Context, *PartitionTermRequest) (*PartitionResponse, error)
	PartitionStatus(context.Context, *PartitionInfo) (*PartitionResponse, error)
}

// UnimplementedDataDistributionControlServer should be embedded to have forward compatible implementations.
type UnimplementedDataDistributionControlServer struct {
}

func (UnimplementedDataDistributionControlServer) PartitionInitialize(context.Context, *PartitionInitRequest) (*PartitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PartitionInitialize not implemented")
}
func (UnimplementedDataDistributionControlServer) PartitionTerminate(context.Context, *PartitionTermRequest) (*PartitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PartitionTerminate not implemented")
}
func (UnimplementedDataDistributionControlServer) PartitionStatus(context.Context, *PartitionInfo) (*PartitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PartitionStatus not implemented")
}

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

func RegisterDataDistributionControlServer(s grpc.ServiceRegistrar, srv DataDistributionControlServer) {
	s.RegisterService(&DataDistributionControl_ServiceDesc, srv)
}

func _DataDistributionControl_PartitionInitialize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PartitionInitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataDistributionControlServer).PartitionInitialize(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DataDistributionControl_PartitionInitialize_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataDistributionControlServer).PartitionInitialize(ctx, req.(*PartitionInitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataDistributionControl_PartitionTerminate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PartitionTermRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataDistributionControlServer).PartitionTerminate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DataDistributionControl_PartitionTerminate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataDistributionControlServer).PartitionTerminate(ctx, req.(*PartitionTermRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DataDistributionControl_PartitionStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PartitionInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DataDistributionControlServer).PartitionStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DataDistributionControl_PartitionStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DataDistributionControlServer).PartitionStatus(ctx, req.(*PartitionInfo))
	}
	return interceptor(ctx, in, info, handler)
}

// DataDistributionControl_ServiceDesc is the grpc.ServiceDesc for DataDistributionControl service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DataDistributionControl_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "o2.DataDistribution.Control.DataDistributionControl",
	HandlerType: (*DataDistributionControlServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PartitionInitialize",
			Handler:    _DataDistributionControl_PartitionInitialize_Handler,
		},
		{
			MethodName: "PartitionTerminate",
			Handler:    _DataDistributionControl_PartitionTerminate_Handler,
		},
		{
			MethodName: "PartitionStatus",
			Handler:    _DataDistributionControl_PartitionStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "protos/ddsched.proto",
}