pcm-coordinator/adaptor/pcm_slurm/server/slurm.go

package server

import (
	slurmpb "code.gitlink.org.cn/JCCE/PCM.git/adaptor/pcm_slurm/gen/idl"
	"context"
	"github.com/golang/glog"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

type Server struct {
	slurmpb.UnimplementedSlurmServiceServer
}

// ListUsers return all slurm users
func (s *Server) ListUsers(ctx context.Context, req *slurmpb.ListUsersReq) (*slurmpb.ListUsersResp, error) {
	resp, err := ListUsers(ctx, req)
	if err != nil {
		glog.Errorf("ListSlurmUsers error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetUser return specific slurm user
func (s *Server) GetUser(ctx context.Context, req *slurmpb.GetUserReq) (*slurmpb.GetUserResp, error) {
	resp, err := GetUser(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmUser error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// AddUser add slurm user
func (s *Server) AddUser(ctx context.Context, req *slurmpb.AddUserReq) (*slurmpb.AddUserResp, error) {
	resp, err := AddUser(ctx, req)
	if err != nil {
		glog.Errorf("AddSlurmUser error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// DeleteUser delete specific slurm user
func (s *Server) DeleteUser(ctx context.Context, req *slurmpb.DeleteUserReq) (*slurmpb.DeleteUserResp, error) {
	resp, err := DeleteUser(ctx, req)
	if err != nil {
		glog.Errorf("DeleteSlurmUser error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListAssociations return all slurm associations
func (s *Server) ListAssociations(ctx context.Context, req *slurmpb.ListAssociationsReq) (*slurmpb.ListAssociationsResp, error) {
	resp, err := ListAssociations(ctx, req)
	if err != nil {
		glog.Errorf("ListSlurmAssociations error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetAssociation return specific slurm associations
func (s *Server) GetAssociation(ctx context.Context, req *slurmpb.GetAssociationReq) (*slurmpb.GetAssociationResp, error) {
	resp, err := GetAssociation(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmAssociations error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListAccounts return all slurm accounts
func (s *Server) ListAccounts(ctx context.Context, req *slurmpb.ListAccountsReq) (*slurmpb.ListAccountsResp, error) {
	resp, err := ListAccounts(ctx, req)
	if err != nil {
		glog.Errorf("ListSlurmAccounts error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetAccount return specific slurm account
func (s *Server) GetAccount(ctx context.Context, req *slurmpb.GetAccountReq) (*slurmpb.GetAccountResp, error) {
	resp, err := GetAccount(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmAccount error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// AddAccount return result
func (s *Server) AddAccount(ctx context.Context, req *slurmpb.AddAccountReq) (*slurmpb.AddAccountResp, error) {
	resp, err := AddAccount(ctx, req)
	if err != nil {
		glog.Errorf("Add error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// DeleteAccount return result
func (s *Server) DeleteAccount(ctx context.Context, req *slurmpb.DeleteAccountReq) (*slurmpb.DeleteAccountResp, error) {
	resp, err := DeleteAccount(ctx, req)
	if err != nil {
		glog.Errorf("Delete error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListQoss return all slurm qos
func (s *Server) GetQos(ctx context.Context, req *slurmpb.QosReq) (*slurmpb.QosResp, error) {
	resp, err := GetQos(ctx, req)
	if err != nil {
		glog.Errorf("ListSlurmQoss error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListWckeys return all slurm wckeys
func (s *Server) ListWckeys(ctx context.Context, req *slurmpb.ListWckeysReq) (*slurmpb.ListWckeysResp, error) {
	resp, err := ListWckeys(ctx, req)
	if err != nil {
		glog.Errorf("ListSlurmWckeys error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetWckey return specific slurm wckey
func (s *Server) GetWckey(ctx context.Context, req *slurmpb.GetWckeyReq) (*slurmpb.GetWckeyResp, error) {
	resp, err := GetWckey(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmWckey error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListUsers return all slurm Clusters
func (s *Server) ListClusters(ctx context.Context, req *slurmpb.ListClustersReq) (*slurmpb.ListClustersResp, error) {
	resp, err := ListClusters(ctx, req)
	if err != nil {
		glog.Errorf("ListSlurmUsers error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetUser return specific slurm user
func (s *Server) GetCluster(ctx context.Context, req *slurmpb.GetClusterReq) (*slurmpb.GetClusterResp, error) {
	resp, err := GetCluster(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmUser error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// DeleteUser delete specific slurm user
func (s *Server) DeleteCluster(ctx context.Context, req *slurmpb.DeleteClusterReq) (*slurmpb.DeleteClusterResp, error) {
	resp, err := DeleteCluster(ctx, req)
	if err != nil {
		glog.Errorf("DeleteSlurmUser error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// AddCluster add slurm user
func (s *Server) AddCluster(ctx context.Context, req *slurmpb.AddClusterReq) (*slurmpb.AddClusterResp, error) {
	resp, err := AddCluster(ctx, req)
	if err != nil {
		glog.Errorf("AddSlurmCluster error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetNode return specific slurm user
func (s *Server) GetNode(ctx context.Context, req *slurmpb.GetNodeReq) (*slurmpb.GetNodeResp, error) {
	resp, err := GetNode(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmUser error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListUsers return all slurm Clusters
func (s *Server) ListNodes(ctx context.Context, req *slurmpb.ListNodesReq) (*slurmpb.ListNodesResp, error) {
	resp, err := ListNodes(ctx, req)
	if err != nil {
		glog.Errorf("ListSlurmNodes error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListUsers return all slurm Clusters
func (s *Server) ListPartitions(ctx context.Context, req *slurmpb.ListPartitionsReq) (*slurmpb.ListPartitionsResp, error) {
	resp, err := ListPartitions(ctx, req)
	if err != nil {
		glog.Errorf("ListPartitions error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetNode return specific slurm user
func (s *Server) GetPartition(ctx context.Context, req *slurmpb.GetPartitionReq) (*slurmpb.GetPartitionResp, error) {
	resp, err := GetPartition(ctx, req)
	if err != nil {
		glog.Errorf("GetPartition error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// GetReservation return specific slurm user
func (s *Server) GetReservation(ctx context.Context, req *slurmpb.GetReservationReq) (*slurmpb.GetReservationResp, error) {
	resp, err := GetReservation(ctx, req)
	if err != nil {
		glog.Errorf("GetPartition error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

// ListUsers return all slurm Clusters
func (s *Server) ListReservations(ctx context.Context, req *slurmpb.ListReservationsReq) (*slurmpb.ListReservationsResp, error) {
	resp, err := ListReservations(ctx, req)
	if err != nil {
		glog.Errorf("ListReservations error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) GetAllJobs(ctx context.Context, req *slurmpb.JobInfoMsgReq) (*slurmpb.JobInfoMsgResp, error) {
	resp, err := GetAllJobs(ctx, req)
	if err != nil {
		glog.Errorf("GetAllJobs error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) GetJob(ctx context.Context, req *slurmpb.JobInfoMsgReq) (*slurmpb.JobInfoMsgResp, error) {
	resp, err := GetJob(ctx, req)
	if err != nil {
		glog.Errorf("GetJob error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) SubmitJob(ctx context.Context, req *slurmpb.SubmitJobReq) (*slurmpb.SubmitJobResp, error) {
	resp, err := SubmitJob(ctx, req)
	if err != nil {
		glog.Errorf("SubmitJob error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) DeleteJob(ctx context.Context, req *slurmpb.DeleteJobReq) (*slurmpb.DeleteJobResp, error) {
	resp, err := DeleteJob(ctx, req)
	if err != nil {
		glog.Errorf("DeleteJob error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) UpdateJob(ctx context.Context, req *slurmpb.UpdateJobReq) (*slurmpb.UpdateJobResp, error) {
	resp, err := UpdateJob(ctx, req)
	if err != nil {
		glog.Errorf("UpdateJob error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) GetDiag(ctx context.Context, req *slurmpb.DiagReq) (*slurmpb.DiagResp, error) {
	resp, err := GetDiag(ctx, req)
	if err != nil {
		glog.Errorf("GetDiag error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) GetSlurmdbJobs(ctx context.Context, req *slurmpb.SlurmDbJobReq) (*slurmpb.SlurmDbJobResp, error) {
	resp, err := GetSlurmdbJobs(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmdbJobs error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) GetSlurmdbJobById(ctx context.Context, req *slurmpb.SlurmDbJobReq) (*slurmpb.SlurmDbJobResp, error) {
	resp, err := GetSlurmdbJobById(ctx, req)
	if err != nil {
		glog.Errorf("GetSlurmdbJobById error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) DeleteQos(ctx context.Context, req *slurmpb.DeleteQosReq) (*slurmpb.DeleteQosResp, error) {
	resp, err := DeleteQos(ctx, req)
	if err != nil {
		glog.Errorf("DeleteQos error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) AddQos(ctx context.Context, req *slurmpb.AddQosReq) (*slurmpb.AddQosResp, error) {
	resp, err := AddQos(ctx, req)
	if err != nil {
		glog.Errorf("AddQos error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}

func (s *Server) GetQosByName(ctx context.Context, req *slurmpb.QosReq) (*slurmpb.QosResp, error) {
	resp, err := GetQosByName(ctx, req)
	if err != nil {
		glog.Errorf("GetQosByName error %+v", err)
		return nil, status.Errorf(codes.Internal, err.Error())
	}
	return resp, nil
}