DAOS-16038 pool: Enable pool list for clients

src/client/api/init.c

@@ -37,7 +37,7 @@ const struct daos_task_api dc_funcs[] = {
 	/** Management */
 	{dc_deprecated, 0},
 	{dc_deprecated, 0},
-	{dc_deprecated, 0},
+	{dc_mgmt_pool_list, sizeof(daos_mgmt_pool_list_t)},
 	{dc_debug_set_params, sizeof(daos_set_params_t)},
 	{dc_mgmt_get_bs_state, sizeof(daos_mgmt_get_bs_state_t)},
 

src/client/api/mgmt.c

@@ -79,3 +79,29 @@ daos_mgmt_put_sys_info(struct daos_sys_info *info)
 {
 	dc_mgmt_put_sys_info(info);
 }
+
+int
+daos_mgmt_list_pools(const char *group, daos_size_t *npools, daos_mgmt_pool_info_t *pools,
+		     daos_event_t *ev)
+{
+	daos_mgmt_pool_list_t  *args;
+	tse_task_t             *task;
+	int                     rc;
+
+	DAOS_API_ARG_ASSERT(*args, MGMT_LIST_POOLS);
+
+	if (npools == NULL) {
+		D_ERROR("npools must be non-NULL\n");
+		return -DER_INVAL;
+	}
+
+	rc = dc_task_create(dc_mgmt_pool_list, NULL, ev, &task);
+	if (rc)
+		return rc;
+	args         = dc_task_get_args(task);
+	args->grp    = group;
+	args->pools  = pools;
+	args->npools = npools;
+
+	return dc_task_schedule(task, true);
+}

src/control/cmd/daos/pool.go

@@ -18,8 +18,8 @@ import (
 	"github.com/daos-stack/daos/src/control/cmd/daos/pretty"
 	"github.com/daos-stack/daos/src/control/common"
 	"github.com/daos-stack/daos/src/control/lib/daos"
-	"github.com/daos-stack/daos/src/control/lib/ranklist"
 	"github.com/daos-stack/daos/src/control/lib/ui"
+	"github.com/daos-stack/daos/src/control/logging"
 )
 
 /*
@@ -180,6 +180,7 @@ func (cmd *poolBaseCmd) getAttr(name string) (*attribute, error) {
 }
 
 type poolCmd struct {
+	List         poolListCmd         `command:"list" description:"list pools to which this user has access"`
 	Query        poolQueryCmd        `command:"query" description:"query pool info"`
 	QueryTargets poolQueryTargetsCmd `command:"query-targets" description:"query pool target info"`
 	ListConts    containerListCmd    `command:"list-containers" alias:"list-cont" description:"list all containers in pool"`
@@ -263,21 +264,43 @@ func convertPoolInfo(pinfo *C.daos_pool_info_t) (*daos.PoolInfo, error) {
 	return poolInfo, nil
 }
 
-func generateRankSet(ranklist *C.d_rank_list_t) string {
-	if ranklist.rl_nr == 0 {
-		return ""
+func queryPool(poolHdl C.daos_handle_t, queryMask daos.PoolQueryMask) (*daos.PoolInfo, error) {
+	var rlPtr **C.d_rank_list_t = nil
+	var rl *C.d_rank_list_t = nil
+
+	if queryMask.HasOption(daos.PoolQueryOptionEnabledEngines) || queryMask.HasOption(daos.PoolQueryOptionDisabledEngines) {
+		rlPtr = &rl
+	}
+
+	cPoolInfo := C.daos_pool_info_t{
+		pi_bits: C.uint64_t(queryMask),
+	}
+
+	rc := C.daos_pool_query(poolHdl, rlPtr, &cPoolInfo, nil, nil)
+	defer C.d_rank_list_free(rl)
+	if err := daosError(rc); err != nil {
+		return nil, err
+	}
+
+	poolInfo, err := convertPoolInfo(&cPoolInfo)
+	if err != nil {
+		return nil, err
 	}
-	ranks := uintptr(unsafe.Pointer(ranklist.rl_ranks))
-	const size = unsafe.Sizeof(uint32(0))
-	rankset := "["
-	for i := 0; i < int(ranklist.rl_nr); i++ {
-		if i > 0 {
-			rankset += ","
+
+	if rlPtr != nil {
+		rs, err := rankSetFromC(rl)
+		if err != nil {
+			return nil, err
+		}
+		if queryMask.HasOption(daos.PoolQueryOptionEnabledEngines) {
+			poolInfo.EnabledRanks = rs
+		}
+		if queryMask.HasOption(daos.PoolQueryOptionDisabledEngines) {
+			poolInfo.DisabledRanks = rs
 		}
-		rankset += fmt.Sprint(*(*uint32)(unsafe.Pointer(ranks + uintptr(i)*size)))
 	}
-	rankset += "]"
-	return rankset
+
+	return poolInfo, nil
 }
 
 func (cmd *poolQueryCmd) Execute(_ []string) error {
@@ -295,42 +318,15 @@ func (cmd *poolQueryCmd) Execute(_ []string) error {
 		queryMask.SetOptions(daos.PoolQueryOptionDisabledEngines)
 	}
 
-	var rlPtr **C.d_rank_list_t = nil
-	var rl *C.d_rank_list_t = nil
-
-	if cmd.ShowEnabledRanks || cmd.ShowDisabledRanks {
-		rlPtr = &rl
-	}
-
 	cleanup, err := cmd.resolveAndConnect(C.DAOS_PC_RO, nil)
 	if err != nil {
 		return err
 	}
 	defer cleanup()
 
-	cPoolInfo := C.daos_pool_info_t{
-		pi_bits: C.uint64_t(queryMask),
-	}
-
-	rc := C.daos_pool_query(cmd.cPoolHandle, rlPtr, &cPoolInfo, nil, nil)
-	defer C.d_rank_list_free(rl)
-	if err := daosError(rc); err != nil {
-		return errors.Wrapf(err,
-			"failed to query pool %s", cmd.poolUUID)
-	}
-
-	poolInfo, err := convertPoolInfo(&cPoolInfo)
+	poolInfo, err := queryPool(cmd.cPoolHandle, queryMask)
 	if err != nil {
-		return err
-	}
-
-	if rlPtr != nil {
-		if cmd.ShowEnabledRanks {
-			poolInfo.EnabledRanks = ranklist.MustCreateRankSet(generateRankSet(rl))
-		}
-		if cmd.ShowDisabledRanks {
-			poolInfo.DisabledRanks = ranklist.MustCreateRankSet(generateRankSet(rl))
-		}
+		return errors.Wrapf(err, "failed to query pool %q", cmd.PoolID())
 	}
 
 	if cmd.JSONOutputEnabled() {
@@ -601,3 +597,134 @@ func (cmd *poolAutoTestCmd) Execute(_ []string) error {
 
 	return nil
 }
+
+func getPoolList(log logging.Logger, sysName string, queryEnabled bool) ([]*daos.PoolInfo, error) {
+	var cSysName *C.char
+	if sysName != "" {
+		cSysName := C.CString(sysName)
+		defer freeString(cSysName)
+	}
+
+	var cPools []C.daos_mgmt_pool_info_t
+	for {
+		var rc C.int
+		var poolCount C.size_t
+
+		// First, fetch the total number of pools in the system.
+		// We may not have access to all of them, so this is an upper bound.
+		rc = C.daos_mgmt_list_pools(cSysName, &poolCount, nil, nil)
+		if err := daosError(rc); err != nil {
+			return nil, err
+		}
+		log.Debugf("pools in system: %d", poolCount)
+
+		if poolCount < 1 {
+			return nil, nil
+		}
+
+		// Now, we actually fetch the pools into the buffer that we've created.
+		cPools = make([]C.daos_mgmt_pool_info_t, poolCount)
+		rc = C.daos_mgmt_list_pools(cSysName, &poolCount, &cPools[0], nil)
+		err := daosError(rc)
+		if err == nil {
+			cPools = cPools[:poolCount] // adjust the slice to the number of pools retrieved
+			log.Debugf("fetched %d pools", len(cPools))
+			break
+		}
+		if err == daos.StructTooSmall {
+			log.Notice("server-side pool list changed; re-fetching")
+			continue
+		}
+		log.Errorf("failed to fetch pool list: %s", err)
+		return nil, err
+	}
+
+	pools := make([]*daos.PoolInfo, 0, len(cPools))
+	for i := 0; i < len(cPools); i++ {
+		cPool := &cPools[i]
+
+		svcRanks, err := rankSetFromC(cPool.mgpi_svc)
+		if err != nil {
+			return nil, err
+		}
+		poolUUID, err := uuidFromC(cPool.mgpi_uuid)
+		if err != nil {
+			return nil, err
+		}
+
+		poolLabel := C.GoString(cPool.mgpi_label)
+
+		var pool *daos.PoolInfo
+		if queryEnabled {
+			var poolInfo C.daos_pool_info_t
+			var poolHandle C.daos_handle_t
+			cPoolUUID := C.CString(poolUUID.String())
+			defer freeString(cPoolUUID)
+
+			if err := daosError(C.daos_pool_connect(cPoolUUID, cSysName, C.DAOS_PC_RO,
+				&poolHandle, &poolInfo, nil)); err != nil {
+				log.Errorf("failed to connect to pool %q: %s", poolLabel, err)
+				continue
+			}
+
+			var qErr error
+			pool, qErr = queryPool(poolHandle, daos.DefaultPoolQueryMask)
+			if qErr != nil {
+				log.Errorf("failed to query pool %q: %s", poolLabel, qErr)
+			}
+			if err := daosError(C.daos_pool_disconnect(poolHandle, nil)); err != nil {
+				log.Errorf("failed to disconnect from pool %q: %s", poolLabel, err)
+			}
+			if qErr != nil {
+				continue
+			}
+
+			// Add a few missing pieces that the query doesn't fill in.
+			pool.Label = poolLabel
+			pool.ServiceReplicas = svcRanks.Ranks()
+		} else {
+			// Just populate the basic info.
+			pool = &daos.PoolInfo{
+				UUID:            poolUUID,
+				Label:           poolLabel,
+				ServiceReplicas: svcRanks.Ranks(),
+				State:           daos.PoolServiceStateReady,
+			}
+		}
+
+		pools = append(pools, pool)
+	}
+
+	log.Debugf("fetched %d/%d pools", len(pools), len(cPools))
+	return pools, nil
+}
+
+type poolListCmd struct {
+	daosCmd
+	SysName string `long:"sys-name" short:"G" description:"DAOS system name"`
+	Verbose bool   `short:"v" long:"verbose" description:"Add pool UUIDs and service replica lists to display"`
+	NoQuery bool   `short:"n" long:"no-query" description:"Disable query of listed pools"`
+}
+
+func (cmd *poolListCmd) Execute(_ []string) error {
+	pools, err := getPoolList(cmd.Logger, cmd.SysName, !cmd.NoQuery)
+	if err != nil {
+		return err
+	}
+
+	if cmd.JSONOutputEnabled() {
+		return cmd.OutputJSON(struct {
+			Pools []*daos.PoolInfo `json:"pools"` // compatibility with dmg
+		}{
+			Pools: pools,
+		}, nil)
+	}
+
+	var buf strings.Builder
+	if err := pretty.PrintPoolList(pools, &buf, cmd.Verbose); err != nil {
+		return err
+	}
+	cmd.Info(buf.String())
+
+	return nil
+}