fix:add cluster interface

adaptor/pcm_slurm/idl/node.proto

@@ -1,22 +0,0 @@
-syntax = "proto3";
-package slurm;
-
-option go_package = "/slurmpb";
-import "idl/static.proto";
-
-message ListNodesReq{
-  SlurmVersion slurm_version = 1;
-}
-
-message NodeInfo{
-  int32 boards = 1 ;
-  int32 cpus = 2 ;
-  string name = 3 ;
-  int32 real_memory = 4 ;
-  int32 sockets = 5 ;
-  int32 threads = 6 ;
-}
-
-message ListNodesResp {
-  repeated NodeInfo node_infos =1;
-}

adaptor/pcm_slurm/idl/slurm.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 package slurm;
 
 option go_package = "/slurmpb";
-import "idl/node.proto";
+import "idl/slurm_node.proto";
 import "idl/slurmdb_user.proto";
 import "idl/slurmdb_assoc.proto";
 import "idl/slurmdb_account.proto";

adaptor/pcm_slurm/idl/slurm_node.proto

@@ -0,0 +1,56 @@
+syntax = "proto3";
+package slurm;
+
+option go_package = "/slurmpb";
+import "idl/static.proto";
+
+message NodeInfo{
+  string Arch = 1 ;
+  uint32 Boards = 2 ;
+  int64 Boot_time = 3 ;
+  uint32 Cores = 4 ;
+  uint32 Cpu_load = 5 ;
+  uint32 Cpus = 6 ;
+  string Features = 7;
+  string Gres = 8 ;
+  string Name = 9 ;
+  string Node_addr = 10 ;
+  string Node_hostname = 11 ;
+  uint32 Node_state = 12 ;
+  string Os = 13 ;
+  uint64 Real_memory = 14 ;
+  string Reason = 15 ;
+  int64  Reason_time = 16 ;
+  uint32 Reason_uid = 17 ;
+  int64  Slurmd_start_time = 18 ;
+  uint32 Sockets = 19 ;
+  uint32 Threads = 20 ;
+  uint32 Tmp_disk = 21 ;
+  uint32 Weight = 22 ;
+}
+
+message ListNodesReq{
+  SlurmVersion slurm_version = 1;
+}
+
+
+message ListNodesResp {
+  repeated NodeInfo node_infos = 1;
+}
+
+message GetNodeReq{
+  SlurmVersion slurm_version = 1;
+  string node_name = 2;
+}
+
+message GetNodeResp {
+  repeated NodeInfo node_infos = 1;
+}
+
+/*message Nodes_info_msg{
+  int64 Last_update =1;
+  uint32 Record_count =2;
+  uint32 Error_code  =3;
+  repeated NodeInfo node_infos =4;
+}*/
+

adaptor/pcm_slurm/idl/slurm_partition.proto

@@ -0,0 +1,54 @@
+syntax = "proto3";
+package slurm;
+
+option go_package = "/slurmpb";
+import "idl/static.proto";
+
+message PartitionInfo{
+  string Allow_alloc_nodes =1;
+  string Allow_groups =2;
+  string Alternate =3;
+  uint32 Cr_type =4;
+  uint64 Def_mem_per_cpu =5;
+  uint32 Default_time = 6;
+  uint32 Flags =7;
+  uint32 Grace_time =8;
+  uint32 Max_cpus_per_node =9;
+  uint64 Max_mem_per_cpu =10;
+  uint32 Max_nodes =11;
+  uint32 Max_share =12;
+  uint32 Max_time =13;
+  uint32 Min_nodes =14;
+  string Name =15;
+  int32 Node_inx =16;
+  string Nodes =17;
+  uint32 Preempt_mode =18;
+  uint32 State_up =19;
+  uint32 Total_cpus =20;
+  uint32 Total_nodes =21;
+}
+
+message ListPartitionsReq{
+  SlurmVersion SlurmVersion = 1;
+}
+
+message ListPartitionsResp{
+  repeated PartitionInfo Partition_list =1;
+}
+
+message GetPartitionReq{
+  SlurmVersion slurm_version = 1;
+  string partition_name = 2;
+}
+
+message GetPartitionResp {
+  repeated PartitionInfo partition_infos = 1;
+}
+
+/*message Partition_info_msg{
+  int64 Last_update =1;
+  uint32 Record_count =2;
+  uint32 Error_code  =3;
+  repeated PartitionInfo Partition_list =4;
+}*/
+

adaptor/pcm_slurm/idl/slurm_ping.proto

@@ -0,0 +1,14 @@
+syntax = "proto3";
+package slurm;
+
+option go_package = "/slurmpb";
+import "idl/static.proto";
+
+message PingInfoMsgReq{
+  SlurmVersion SlurmVersion = 1;
+  int32 controller = 2;
+}
+
+message PingInfoMsgResp{
+  int32  Ping_result =1;
+}

adaptor/pcm_slurm/idl/slurm_reservation.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+package slurm;
+
+option go_package = "/slurmpb";
+import "idl/static.proto";
+
+message ReservationInfo{
+  string Accounts = 1;
+  int64 End_time =2;
+  string Features =3;
+  uint32 Flags =4;
+  string Licenses =5;
+  string Name =6;
+  uint32 Node_cnt =7;
+  uint32 Core_cnt =8;
+  int32 Node_inx =9;
+  string Node_list =10;
+  string Partition =11;
+  int64  Start_time =12;
+  string Users =13;
+}
+
+message ListReservationsReq{
+  SlurmVersion SlurmVersion = 1;
+}
+
+message ListReservationsResp{
+  repeated ReservationInfo Reservation_list =1;
+}
+
+message GetReservationReq{
+  SlurmVersion slurm_version = 1;
+  string reservation_name = 2;
+}
+
+message GetReservationResp {
+  repeated ReservationInfo reservation_infos = 1;
+}
+
+/*message Partition_info_msg{
+  int64 Last_update =1;
+  uint32 Record_count =2;
+  uint32 Error_code  =3;
+  repeated PartitionInfo Partition_list =4;
+}*/
+

adaptor/pcm_slurm/service/slurm_node.go

@@ -0,0 +1,198 @@
+package slurmer
+
+/*
+#cgo LDFLAGS: -lslurm
+#include<stdlib.h>
+#include<slurm/slurm.h>
+#include<slurm/slurm_errno.h>
+inline uint8_t uint8_ptr(uint8_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+inline int8_t int8_ptr(int8_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+uint16_t uint16_ptr(uint16_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+inline int16_t int16_ptr(int16_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+inline uint32_t uint32_ptr(uint32_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+inline int32_t int32_ptr(int32_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+inline uint64_t uint64_ptr(uint64_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+inline int64_t int64_ptr(int16_t* pointer) {
+    if (NULL == pointer) {
+    return -1;}
+    return *pointer;
+}
+ struct node_info_msg *get_node_info(){
+   	struct node_info_msg* node_buffer;
+       if(slurm_load_node ((time_t) NULL,
+		&node_buffer, SHOW_ALL))
+		return NULL;
+	return node_buffer;
+ }
+  struct node_info_msg *get_single_node_info(char* name){
+   	struct node_info_msg* node_buffer;
+	if( slurm_load_node_single (&node_buffer, name, SHOW_DETAIL))
+		return NULL;
+	return node_buffer;
+ }
+
+ struct node_info* node_from_list(struct node_info_msg *list, int i){
+	 return &list->node_array[i];
+}
+ void free_node_buffer(void* buffer){
+
+	slurm_free_node_info_msg ((struct node_info_msg*)buffer);
+  }
+
+
+*/
+import "C"
+import (
+	pbslurm "code.gitlink.org.cn/JCCE/PCM.git/adaptor/pcm_slurm/gen/idl"
+	"context"
+	"strings"
+)
+
+type NodeInfoMsg struct {
+	LastUpdate   int64
+	RecordCount  uint32
+	ErrorCode    uint32
+	NodeInfoList []pbslurm.NodeInfo
+}
+
+func Node_info_convert_c_to_go(c_struct *C.struct_node_info) pbslurm.NodeInfo {
+	var go_struct pbslurm.NodeInfo
+
+	go_struct.Arch = C.GoString(c_struct.arch)
+	go_struct.Boards = uint32(c_struct.boards)
+	go_struct.BootTime = int64(c_struct.boot_time)
+	go_struct.Cores = uint32(c_struct.cores)
+	go_struct.CpuLoad = uint32(c_struct.cpu_load)
+	go_struct.Cpus = uint32(c_struct.cpus)
+	go_struct.Features = C.GoString(c_struct.features)
+	go_struct.Gres = C.GoString(c_struct.gres)
+	go_struct.Name = C.GoString(c_struct.name)
+	go_struct.NodeAddr = C.GoString(c_struct.node_addr)
+	go_struct.NodeHostname = C.GoString(c_struct.node_hostname)
+	go_struct.NodeState = uint32(c_struct.node_state)
+	go_struct.Os = C.GoString(c_struct.os)
+	go_struct.RealMemory = uint64(c_struct.real_memory)
+	go_struct.Reason = C.GoString(c_struct.reason)
+	go_struct.ReasonTime = int64(c_struct.reason_time)
+	go_struct.ReasonUid = uint32(c_struct.reason_uid)
+	go_struct.SlurmdStartTime = int64(c_struct.slurmd_start_time)
+	go_struct.Sockets = uint32(c_struct.sockets)
+	go_struct.Threads = uint32(c_struct.threads)
+	go_struct.TmpDisk = uint32(c_struct.tmp_disk)
+	go_struct.Weight = uint32(c_struct.weight)
+	return go_struct
+}
+
+func (slurmStruct SlurmStruct) ListNodes(ctx context.Context, req *pbslurm.ListNodesReq) (*pbslurm.ListNodesResp, error) {
+	nodeList := Get_all_nodes()
+	var resp = pbslurm.ListNodesResp{}
+	for _, node := range nodeList.NodeInfoList {
+		nodeInfoResult := pbslurm.NodeInfo{}
+		nodeInfoResult.Cpus = uint32(node.Cpus)
+		nodeInfoResult.Boards = uint32(node.Boards)
+		nodeInfoResult.RealMemory = node.RealMemory
+		nodeInfoResult.Sockets = uint32(node.Sockets)
+		nodeInfoResult.Threads = uint32(node.Threads)
+		resp.NodeInfos = append(resp.NodeInfos, &nodeInfoResult)
+	}
+
+	return &resp, nil
+}
+
+func Get_all_nodes() NodeInfoMsg {
+	var go_node_buffer NodeInfoMsg
+	c_node_buffer := C.get_node_info()
+	if c_node_buffer == nil {
+		go_node_buffer.LastUpdate = int64(0)
+		go_node_buffer.RecordCount = uint32(0)
+		go_node_buffer.ErrorCode = uint32(C.slurm_get_errno())
+		return go_node_buffer
+	}
+	go_node_buffer.LastUpdate = int64(c_node_buffer.last_update)
+	go_node_buffer.RecordCount = uint32(c_node_buffer.record_count)
+	go_node_buffer.NodeInfoList = make([]pbslurm.NodeInfo, c_node_buffer.record_count, c_node_buffer.record_count)
+	for i := uint32(0); i < go_node_buffer.RecordCount; i++ {
+		node := C.node_from_list(c_node_buffer, C.int(i))
+		go_node := Node_info_convert_c_to_go(node)
+		go_node_buffer.NodeInfoList[i] = go_node
+	}
+	C.slurm_free_node_info_msg(c_node_buffer)
+
+	return go_node_buffer
+}
+
+func NodeDescriptorConvertCToGo(cStruct *C.struct_slurmdb_account_rec) pbslurm.NodeInfo {
+	var goStruct pbslurm.NodeInfo
+	goStruct.Name = C.GoString(cStruct.name)
+	return goStruct
+}
+
+func GetNodeInfo() NodeInfoMsg {
+	var goNodeBuffer NodeInfoMsg
+	cNodeBuffer := C.get_node_info()
+	goNodeBuffer.RecordCount = uint32(cNodeBuffer.record_count)
+	goNodeBuffer.NodeInfoList = make([]pbslurm.NodeInfo, cNodeBuffer.record_count, cNodeBuffer.record_count)
+
+	for i := uint32(0); i < goNodeBuffer.RecordCount; i++ {
+		Node := C.node_from_list(&cNodeBuffer, C.int(i))
+		goNode := NodeDescriptorConvertCToGo(Node)
+		goNodeBuffer.NodeInfoList[i] = goNode
+	}
+	return goNodeBuffer
+}
+
+func (slurmStruct SlurmStruct) GetNode(ctx context.Context, req *pbslurm.GetNodeReq) (*pbslurm.GetNodeResp, error) {
+	NodeList := GetNodeInfo()
+	resp := pbslurm.GetNodeResp{}
+	for _, node := range NodeList.NodeInfoList {
+		nodeInfoResult := node
+		if strings.Contains(node.Name, req.NodeName) {
+			resp.NodeInfos = append(resp.NodeInfos, &nodeInfoResult)
+		}
+	}
+	return &resp, nil
+}
+
+/*func (slurmStruct SlurmStruct) GetNodeByName(ctx context.Context, req *pbnode.NodeInfoMsgReq) (*pbnode.NodeInfoMsgResp, error) {
+	node := Get_node_info(req.NodeName)
+	var resp = pbnode.NodeInfoMsgResp{}
+	for _, node := range node.Node_list {
+		nodeInfoResult := pbnode.Node_Info{}
+		nodeInfoResult.Cpus = uint32(node.Cpus)
+		nodeInfoResult.Boards = uint32(node.Boards)
+		nodeInfoResult.RealMemory = node.RealMemory
+		nodeInfoResult.Sockets = uint32(node.Sockets)
+		nodeInfoResult.Threads = uint32(node.Threads)
+		resp.NodeList = append(resp.NodeList, &nodeInfoResult)
+	}
+
+	return &resp, nil
+}*/

adaptor/pcm_slurm/service/slurm_partition.go

@@ -0,0 +1,133 @@
+package slurmer
+
+/*
+#cgo LDFLAGS: -lslurm
+#include<stdlib.h>
+#include<slurm/slurm.h>
+
+
+
+ struct partition_info_msg *get_partition_info(){
+   	struct partition_info_msg* partition_buffer;
+        if( slurm_load_partitions ((time_t) NULL,
+		&partition_buffer, SHOW_ALL))
+		return NULL;
+	return partition_buffer;
+ }
+ struct partition_info* partition_from_list(struct partition_info_msg *list, int i){
+	 return &list->partition_array[i];
+}
+ void free_partition_buffer(void* buffer){
+
+	slurm_free_partition_info_msg ((struct partition_info_msg*)buffer);
+  }
+*/
+import "C"
+import (
+	pbslurm "code.gitlink.org.cn/JCCE/PCM.git/adaptor/pcm_slurm/gen/idl"
+	"context"
+	"strings"
+)
+
+func Partition_info_convert_c_to_go(c_struct *C.struct_partition_info) pbslurm.PartitionInfo {
+	var go_struct pbslurm.PartitionInfo
+
+	go_struct.AllowAllocNodes = C.GoString(c_struct.allow_alloc_nodes)
+	go_struct.AllowGroups = C.GoString(c_struct.allow_groups)
+	go_struct.Alternate = C.GoString(c_struct.alternate)
+	go_struct.CrType = uint32(c_struct.cr_type)
+	go_struct.DefMemPerCpu = uint64(c_struct.def_mem_per_cpu)
+	go_struct.DefaultTime = uint32(c_struct.default_time)
+	go_struct.Flags = uint32(c_struct.flags)
+	go_struct.GraceTime = uint32(c_struct.grace_time)
+	go_struct.MaxCpusPerNode = uint32(c_struct.max_cpus_per_node)
+	go_struct.MaxMemPerCpu = uint64(c_struct.max_mem_per_cpu)
+	go_struct.MaxNodes = uint32(c_struct.max_nodes)
+	go_struct.MaxShare = uint32(c_struct.max_share)
+	go_struct.MaxTime = uint32(c_struct.max_time)
+	go_struct.MinNodes = uint32(c_struct.min_nodes)
+	go_struct.Name = C.GoString(c_struct.name)
+	//go_struct.Node_inx = int32(C.int32_ptr(c_struct.node_inx))
+	/*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.Nodes = C.GoString(c_struct.nodes)
+	go_struct.PreemptMode = uint32(c_struct.preempt_mode)
+	go_struct.StateUp = uint32(c_struct.state_up)
+	go_struct.TotalCpus = uint32(c_struct.total_cpus)
+	go_struct.TotalNodes = uint32(c_struct.total_nodes)
+	return go_struct
+}
+
+type PartitionInfoMsg struct {
+	LastUpdate        int64
+	RecordCount       uint32
+	PartitionInfoList []pbslurm.PartitionInfo
+}
+
+func Get_partitions() PartitionInfoMsg {
+	var go_partition_buffer PartitionInfoMsg
+	c_partition_buffer := C.get_partition_info()
+	if c_partition_buffer == nil {
+		go_partition_buffer.LastUpdate = int64(0)
+		go_partition_buffer.RecordCount = uint32(0)
+		return go_partition_buffer
+	}
+	go_partition_buffer.LastUpdate = int64(c_partition_buffer.last_update)
+	go_partition_buffer.RecordCount = uint32(c_partition_buffer.record_count)
+	go_partition_buffer.PartitionInfoList = make([]pbslurm.PartitionInfo, c_partition_buffer.record_count, c_partition_buffer.record_count)
+	for i := uint32(0); i < go_partition_buffer.RecordCount; i++ {
+		partition := C.partition_from_list(c_partition_buffer, C.int(i))
+		go_partition := Partition_info_convert_c_to_go(partition)
+		go_partition_buffer.PartitionInfoList[i] = go_partition
+	}
+	C.slurm_free_partition_info_msg(c_partition_buffer)
+
+	return go_partition_buffer
+}
+
+func (slurmStruct SlurmStruct) ListPartitions(ctx context.Context, req *pbslurm.ListPartitionsReq) (*pbslurm.ListPartitionsResp, error) {
+	partitionList := Get_partitions()
+	var resp = pbslurm.ListPartitionsResp{}
+	for _, partition := range partitionList.PartitionInfoList {
+		partitionInfoResult := partition
+		resp.PartitionList = append(resp.PartitionList, &partitionInfoResult)
+	}
+	return &resp, nil
+}
+
+func GetPartitionsInfo() PartitionInfoMsg {
+	var goPartitionBuffer PartitionInfoMsg
+	cPartitionBuffer := C.get_partition_info()
+	goPartitionBuffer.RecordCount = uint32(cPartitionBuffer.record_count)
+	goPartitionBuffer.PartitionInfoList = make([]pbslurm.PartitionInfo, cPartitionBuffer.record_count, cPartitionBuffer.record_count)
+
+	for i := uint32(0); i < goPartitionBuffer.RecordCount; i++ {
+		partition := C.partition_from_list(&cPartitionBuffer, C.int(i))
+		goPartition := PartitionDescriptorConvertCToGo(partition)
+		goPartitionBuffer.PartitionInfoList[i] = goPartition
+	}
+	return goPartitionBuffer
+}
+
+func PartitionDescriptorConvertCToGo(cStruct *C.struct_slurmdb_partition_rec) pbslurm.PartitionInfo {
+	var goStruct pbslurm.PartitionInfo
+	goStruct.Name = C.GoString(cStruct.name)
+	return goStruct
+}
+
+func (slurmStruct SlurmStruct) GetPartition(ctx context.Context, req *pbslurm.GetPartitionReq) (*pbslurm.GetPartitionResp, error) {
+	PartitionList := GetPartitionsInfo()
+	resp := pbslurm.GetPartitionResp{}
+	for _, partition := range PartitionList.PartitionInfoList {
+		partitionInfoResult := partition
+		if strings.Contains(partition.Name, req.PartitionName) {
+			resp.PartitionInfos = append(resp.PartitionInfos, &partitionInfoResult)
+		}
+	}
+	return &resp, nil
+}

adaptor/pcm_slurm/service/slurm_ping.go

@@ -0,0 +1,31 @@
+package slurmer
+
+/*
+#cgo LDFLAGS: -lslurm
+#include<stdlib.h>
+#include<slurm/slurm.h>
+#include<slurm/slurm_errno.h>
+
+   // int ping_result;
+   // ping_result = slurm_ping(int ping)
+   int slurm_ping(int controller){
+    int ping_result;
+    ping_result = slurm_ping(controller);
+    return ping_result;
+ }
+
+*/
+import "C"
+import (
+	pbslurm "code.gitlink.org.cn/JCCE/PCM.git/adaptor/pcm_slurm/gen/idl"
+	"context"
+)
+
+func (slurmStruct SlurmStruct) GetPingResult(ctx context.Context, req *pbslurm.PingInfoMsgReq) (*pbslurm.PingInfoMsgResp, error) {
+	cgoIntA := C.int(req.Controller)
+	Ping_result := C.slurm_ping(cgoIntA)
+	//C.free(unsafe.Pointer(cgoIntA))
+	var resp = pbslurm.PingInfoMsgResp{}
+	resp.PingResult = int32(Ping_result)
+	return &resp, nil
+}

adaptor/pcm_slurm/service/slurm_reservation.go

@@ -0,0 +1,161 @@
+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
+
+}*/

adaptor/pcm_slurm/service/slurmdb_cluster.go

@@ -80,7 +80,7 @@ func GetClusterInfo() ClusterInfoMsg {
 	return go_cluster_buffer
 }
 
-func (slurmStruct SlurmStruct) GetAllClusters(ctx context.Context, req *pbslurm.ListClustersReq) (*pbslurm.ListClustersResp, error) {
+func (slurmStruct SlurmStruct) ListClusters(ctx context.Context, req *pbslurm.ListClustersReq) (*pbslurm.ListClustersResp, error) {
 
 	clusterList := GetClusterInfo()
 

adaptor/pcm_slurm/service/slurmer.go

@@ -19,6 +19,16 @@ type Slurmer interface {
 	ListQoss(ctx context.Context, req *pbslurm.ListQossReq) (resp *pbslurm.ListQossResp, err error)                         //list slurm qoss
 	ListWckeys(ctx context.Context, req *pbslurm.ListWckeysReq) (resp *pbslurm.ListWckeysResp, err error)                   //list slurm wckeys
 	GetWckey(ctx context.Context, req *pbslurm.GetWckeyReq) (resp *pbslurm.GetWckeyResp, err error)                         //list slurm wckeys
+	ListClusters(ctx context.Context, req *pbslurm.ListClustersReq) (resp *pbslurm.ListClustersResp, err error)
+	GetCluster(ctx context.Context, req *pbslurm.GetClusterReq) (resp *pbslurm.GetClusterResp, err error)
+	DeleteCluster(ctx context.Context, req *pbslurm.DeleteClusterReq) (resp *pbslurm.DeleteClusterResp, err error)
+	AddCluster(ctx context.Context, req *pbslurm.AddClusterReq) (resp *pbslurm.AddClusterResp, err error)
+	ListNodes(ctx context.Context, req *pbslurm.ListNodesReq) (resp *pbslurm.ListNodesResp, err error)
+	GetNode(ctx context.Context, req *pbslurm.GetNodeResp) (resp *pbslurm.GetNodeResp, err error)
+	ListPartitions(ctx context.Context, req *pbslurm.ListPartitionsReq) (resp *pbslurm.ListPartitionsResp, err error)
+	GetPartition(ctx context.Context, req *pbslurm.GetPartitionReq) (resp *pbslurm.GetPartitionResp, err error)
+	ListReservations(ctx context.Context, req *pbslurm.ListReservationsReq) (resp *pbslurm.ListReservationsResp, err error)
+	GetReservation(ctx context.Context, req *pbslurm.GetReservationReq) (resp *pbslurm.GetReservationResp, err error)
 }
 
 func SelectSlurmVersion(slurmVersion pbslurm.SlurmVersion) (slurmer Slurmer, err error) {