pcm-coordinator/adaptor/pcm_slurm/service/slurm_reservation.go

package slurmer

/*
#cgo LDFLAGS: -lslurm
#include<stdlib.h>
#include<slurm/slurm.h>
#include<slurm/slurm_errno.h>
 struct reserve_info_msg *get_reserve_info(){
   	struct reserve_info_msg* reservation_buffer;
       if(slurm_load_reservations ((time_t) NULL,
		&reservation_buffer))
		return NULL;
	return reservation_buffer;
 }
 struct reserve_info* reservation_from_list(struct reserve_info_msg *list, int i){
    return &list->reservation_array[i];
}
 void free_reservation_buffer(void* buffer){
	slurm_free_reservation_info_msg ((struct reserve_info_msg*)buffer);
  }
*/
import "C"
import (
	pbslurm "code.gitlink.org.cn/JCCE/PCM.git/adaptor/pcm_slurm/gen/idl"
	"context"
	"strings"
)

type ReservationInfoMsg struct {
	LastUpdate      int64
	RecordCount     uint32
	ReservationList []pbslurm.ReservationInfo
	ErrorCode       uint32
}

func Reservation_info_convert_c_to_go(c_struct *C.struct_reserve_info) pbslurm.ReservationInfo {
	var go_struct pbslurm.ReservationInfo

	go_struct.Accounts = C.GoString(c_struct.accounts)
	go_struct.EndTime = int64(c_struct.end_time)
	go_struct.Features = C.GoString(c_struct.features)
	go_struct.Flags = uint32(c_struct.flags)
	go_struct.Licenses = C.GoString(c_struct.licenses)
	go_struct.Name = C.GoString(c_struct.name)
	go_struct.Features = C.GoString(c_struct.features)
	go_struct.NodeCnt = uint32(c_struct.node_cnt)
	go_struct.CoreCnt = uint32(c_struct.core_cnt)
	/*t := C.find_node_inx(c_struct.node_inx)

	fmt.Printf("%d", t)
	go_struct.Node_inx = make([]int32, t, t)
	for i := int32(0); i < int32(t); i++ {
		go_struct.Node_inx[i] = int32(C.int32_ptr(c_struct.node_inx, C.int(i)))

	}*/
	go_struct.NodeList = C.GoString(c_struct.node_list)
	go_struct.Partition = C.GoString(c_struct.partition)
	go_struct.StartTime = int64(c_struct.start_time)
	//go_struct.clusters = C.GoString(c_struct.clusters)
	return go_struct
}

func Get_all_reservation() ReservationInfoMsg {
	var go_reservation_buffer ReservationInfoMsg
	c_reservation_buffer := C.get_reserve_info()
	if c_reservation_buffer == nil {
		go_reservation_buffer.LastUpdate = int64(0)
		go_reservation_buffer.RecordCount = uint32(0)
		go_reservation_buffer.ErrorCode = uint32(C.slurm_get_errno())
		return go_reservation_buffer
	}
	go_reservation_buffer.LastUpdate = int64(c_reservation_buffer.last_update)
	go_reservation_buffer.RecordCount = uint32(c_reservation_buffer.record_count)
	go_reservation_buffer.ReservationList = make([]pbslurm.ReservationInfo, c_reservation_buffer.record_count, c_reservation_buffer.record_count)
	for i := uint32(0); i < go_reservation_buffer.RecordCount; i++ {
		reservation := C.reservation_from_list(c_reservation_buffer, C.int(i))
		go_reservation := Reservation_info_convert_c_to_go(reservation)
		go_reservation_buffer.ReservationList[i] = go_reservation
	}
	C.slurm_free_reservation_info_msg(c_reservation_buffer)

	return go_reservation_buffer
}

func (slurmStruct SlurmStruct) ListReservations(ctx context.Context, req *pbslurm.ListReservationsReq) (*pbslurm.ListReservationsResp, error) {
	reservationList := Get_all_reservation()

	var resp = pbslurm.ListReservationsResp{}
	for _, reservation := range reservationList.ReservationList {
		reservationInfoResult := reservation
		resp.ReservationList = append(resp.ReservationList, &reservationInfoResult)
	}
	return &resp, nil
}

func GetReservationsInfo() ReservationInfoMsg {
	var goReservationBuffer ReservationInfoMsg
	cReservationBuffer := C.get_reservation_info()
	goReservationBuffer.RecordCount = uint32(cReservationBuffer.record_count)
	goReservationBuffer.ReservationList = make([]pbslurm.ReservationInfo, cReservationBuffer.record_count, cReservationBuffer.record_count)

	for i := uint32(0); i < goReservationBuffer.RecordCount; i++ {
		Reservation := C.reservation_from_list(&cReservationBuffer, C.int(i))
		goReservation := ReservationDescriptorConvertCToGo(Reservation)
		goReservationBuffer.ReservationList[i] = goReservation
	}
	return goReservationBuffer
}

func ReservationDescriptorConvertCToGo(cStruct *C.struct_slurmdb_reservation_rec) pbslurm.ReservationInfo {
	var goStruct pbslurm.ReservationInfo
	goStruct.Name = C.GoString(cStruct.name)
	return goStruct
}

func (slurmStruct SlurmStruct) GetReservation(ctx context.Context, req *pbslurm.GetReservationReq) (*pbslurm.GetReservationResp, error) {
	ReservationList := GetReservationsInfo()
	resp := pbslurm.GetReservationResp{}
	for _, reservation := range ReservationList.ReservationList {
		reservationInfoResult := reservation
		if strings.Contains(reservation.Name, req.ReservationName) {
			resp.ReservationInfos = append(resp.ReservationInfos, &reservationInfoResult)
		}
	}
	return &resp, nil
}

/*func (slurmStruct SlurmStruct) GetReservationByName(ctx context.Context, req *pbslurm.ReservationInfoMsgReq) (*pbslurm.ReservationInfoMsgResp, error) {
	reservation := Get_reservation_info(req.ReservationName)
	var resp = pbslurm.ReservationInfoMsgResp{}
	for _, reservation := range reservation.Reservation_list {
		reservationInfoResult := pbslurm.Reservation_Info{}
		reservationInfoResult.Name = reservation.Name
		/*nodeInfoResult.Boards = uint32(node.Boards)
		nodeInfoResult.RealMemory = node.Real_memory
		nodeInfoResult.Sockets = uint32(node.Sockets)
		nodeInfoResult.Threads = uint32(node.Threads)*
		resp.ReservationList = append(resp.ReservationList, &reservationInfoResult)
	}
	return &resp, nil
}

func Get_reservation_info(name string) ReserveInfoMsg {
	go_reservation_buffer := Get_all_reservation()
	//partitionList := list.New()
	for i := range go_reservation_buffer.ReservationList {
		//遍历nodeList集合
		reservation := go_reservation_buffer.ReservationList[i]
		fmt.Println("reservationName: " + reservation.Name)
		//当集合中的名字等于传过来的值
		if name == reservation.Name {
			/*partitionList.PushFront(partition.Name)
			partitionList.PushFront(partition.Nodes)*
		} else {

		}
		//fmt.Println(partition.Node_inx)
	}
	return go_reservation_buffer

}*/