reapi: add match options for go bindings

Problem: reapi go bindings only use 2 of the 4 match options for
match allocate.

Create new functions match and match_satisfy where match is a
general purpose match allocate function that can use all 4 match
options. match_satisfy and match_allocate both call match for with
their corresponding match options.

Author: zekemorton

resource/reapi/bindings/go/src/fluxcli/reapi_cli.go

@@ -16,6 +16,14 @@ package fluxcli
 import "C"
 import (
 	"fmt"
+	"unsafe"
+)
+
+const (
+	matchAllocate                = "allocate"
+	matchAllocateOrelseReserve   = "allocate_orelse_reserve"
+	matchAllocateWSatisfiability = "allocate_with_satisfiability"
+	matchSatisfiability          = "satisfiability"
 )
 
 type (
@@ -72,14 +80,13 @@ func (cli *ReapiClient) InitContext(jgf string, options string) (err error) {
 	return retvalToError(fluxerr, "issue initializing resource api client")
 }
 
-// MatchAllocate matches a jobspec to the "best" resources and either allocate
-//
-//	orelse reserve them. The best resources are determined by
-//	the selected match policy.
+// Match matches a jobspec to the "best" resources based on match option.
+
+//	The best resources are determined by the selected match policy.
 //
-//	\param orelse_reserve
-//	                 Boolean: if false, only allocate; otherwise, first try
-//	                 to allocate and if that fails, reserve.
+//	\param match_op  String to indicate the match type. Options include:
+//					 allocate, allocate_orelse_reserve, satisfiability,
+// 				     allocate_with_satsfiability
 //	\param jobspec   jobspec string.
 //	\param jobid     jobid of the uint64_t type.
 //	\param reserved  Boolean into which to return true if this job has been
@@ -92,15 +99,15 @@ func (cli *ReapiClient) InitContext(jgf string, options string) (err error) {
 //	                 in terms of elapse time needed to complete
 //	                 the match operation.
 //	\return          0 on success; -1 on error.
-func (cli *ReapiClient) MatchAllocate(
-	orelse_reserve bool,
+func (cli *ReapiClient) Match(
+	match_op string,
 	jobspec string,
 ) (reserved bool, allocated string, at int64, overhead float64, jobid uint64, err error) {
 	var r = C.CString("")
 	spec := C.CString(jobspec)
 
-	fluxerr := (int)(C.reapi_cli_match_allocate((*C.struct_reapi_cli_ctx)(cli.ctx),
-		(C.bool)(orelse_reserve),
+	fluxerr := (int)(C.reapi_cli_match((*C.struct_reapi_cli_ctx)(cli.ctx),
+		(C.CString)(match_op),
 		spec,
 		(*C.ulong)(&jobid),
 		(*C.bool)(&reserved),
@@ -110,11 +117,77 @@ func (cli *ReapiClient) MatchAllocate(
 
 	allocated = C.GoString(r)
 
+	defer C.free(unsafe.Pointer(r))
+	defer C.free(unsafe.Pointer(spec))
+
 	err = retvalToError(fluxerr, "issue resource api client matching allocate")
 	return reserved, allocated, at, overhead, jobid, err
 
 }
 
+// MatchAllocate matches a jobspec to the "best" resources and either allocate
+//
+//	orelse reserve them. The best resources are determined by
+//	the selected match policy.
+//
+//	\param orelse_reserve
+//	                 Boolean: if false, only allocate; otherwise, first try
+//	                 to allocate and if that fails, reserve.
+//	\param jobspec   jobspec string.
+//	\param jobid     jobid of the uint64_t type.
+//	\param reserved  Boolean into which to return true if this job has been
+//	                 reserved instead of allocated.
+//	\param R         String into which to return the resource set either
+//	                 allocated or reserved.
+//	\param at        If allocated, 0 is returned; if reserved, actual time
+//	                 at which the job is reserved.
+//	\param ov        Double into which to return performance overhead
+//	                 in terms of elapse time needed to complete
+//	                 the match operation.
+//	\return          0 on success; -1 on error.
+func (cli *ReapiClient) MatchAllocate(
+	orelse_reserve bool,
+	jobspec string,
+) (reserved bool, allocated string, at int64, overhead float64, jobid uint64, err error) {
+	var match_op string
+
+	if orelse_reserve {
+		match_op = matchAllocateOrelseReserve
+	} else {
+		match_op = matchAllocate
+	}
+
+	return cli.Match(match_op, jobspec)
+}
+
+// MatchSatisfy runs satisfiability check on jobspec.
+//
+//	\param jobspec   jobspec string.
+//	\param jobid     jobid of the uint64_t type.
+//	\param reserved  Boolean into which to return true if this job has been
+//	                 reserved instead of allocated.
+//	\param R         String into which to return the resource set either
+//	                 allocated or reserved.
+//	\param at        If allocated, 0 is returned; if reserved, actual time
+//	                 at which the job is reserved.
+//	\param ov        Double into which to return performance overhead
+//	                 in terms of elapse time needed to complete
+//	                 the match operation.
+//	\return          0 on success; -1 on error.
+func (cli *ReapiClient) MatchSatisfy(
+	jobspec string,
+) (sat bool, overhead float64, err error) {
+	spec := C.CString(jobspec)
+
+	fluxerr := (int)(C.reapi_cli_match_satisfy((*C.struct_reapi_cli_ctx)(cli.ctx),
+		spec,
+		(*C.bool)(&sat),
+		(*C.double)(&overhead)))
+
+	err = retvalToError(fluxerr, "issue resource api client matching satisfy")
+	return sat, overhead, err
+}
+
 // UpdateAllocate updates the resource state with R.
 //
 //	\param jobid     jobid of the uint64_t type.

resource/reapi/bindings/go/src/fluxmodule/reapi_module.go

@@ -17,6 +17,13 @@ import (
 	"unsafe"
 )
 
+const (
+	matchAllocate                = "allocate"
+	matchAllocateOrelseReserve   = "allocate_orelse_reserve"
+	matchAllocateWSatisfiability = "allocate_with_satisfiability"
+	matchSatisfiability          = "satisfiability"
+)
+
 type (
 	ReapiCtx    C.struct_reapi_module_ctx_t
 	ReapiModule struct {
@@ -51,11 +58,11 @@ func (m *ReapiModule) Destroy() {
 	C.reapi_module_destroy((*C.struct_reapi_module_ctx)(m.ctx))
 }
 
-// MatchAllocate matches and allocates resources
-// int reapi_module_match_allocate (reapi_module_ctx_t *ctx, bool orelse_reserve,
+// Match matches and allocates resources
+// int reapi_module_match_allocate (reapi_module_ctx_t *ctx, char *match_op,
 // at: is the scheduled time "at"
-func (m *ReapiModule) MatchAllocate(
-	orelse_reserve bool,
+func (m *ReapiModule) Match(
+	match_op string,
 	jobspec string,
 	jobid int,
 ) (reserved bool, allocated string, at int64, overhead float64, err error) {
@@ -65,8 +72,8 @@ func (m *ReapiModule) MatchAllocate(
 	// Jobspec as a CString
 	spec := C.CString(jobspec)
 
-	fluxerr := (int)(C.reapi_module_match_allocate((*C.struct_reapi_module_ctx)(m.ctx),
-		(C.bool)(orelse_reserve),
+	fluxerr := (int)(C.reapi_module_match((*C.struct_reapi_module_ctx)(m.ctx),
+		(C.CString)(match_op),
 		spec,
 		(C.ulong)(jobid),
 		(*C.bool)(&reserved),
@@ -76,10 +83,39 @@ func (m *ReapiModule) MatchAllocate(
 
 	allocated = C.GoString(r)
 
+	defer C.free(unsafe.Pointer(r))
+	defer C.free(unsafe.Pointer(spec))
+
 	err = retvalToError(fluxerr, "issue matching allocation for resource api")
 	return reserved, allocated, at, overhead, err
 }
 
+// MatchAllocate matches and allocates resources
+func (m *ReapiModule) MatchAllocate(
+	orelse_reserve bool,
+	jobspec string,
+	jobid int,
+) (reserved bool, allocated string, at int64, overhead float64, err error) {
+	var match_op string
+
+	if orelse_reserve {
+		match_op = matchAllocateOrelseReserve
+	} else {
+		match_op = matchAllocate
+	}
+
+	return m.Match(match_op, jobspec, jobid)
+}
+
+// MatchSatisfy runs satisfiability check on jobspec
+func (m *ReapiModule) MatchSatisfy(
+	jobspec string,
+	jobid int,
+) (reserved bool, allocated string, at int64, overhead float64, err error) {
+	match_op := matchSatisfiability
+	return m.Match(match_op, jobspec, jobid)
+}
+
 // Info gets the information on the allocation or reservation corresponding
 // to jobid.
 //
@@ -123,4 +159,4 @@ func (m *ReapiModule) Cancel(jobid int64, noent_ok bool) (err error) {
 		(C.ulong)(jobid),
 		(C.bool)(noent_ok)))
 	return retvalToError(fluxerr, "issue with cancel")
-}
+}