list.go

package zfs

// #include <stdlib.h>
// #include <libzfs.h>
// #include "common.h"
// #include "zpool.h"
// #include "zfs.h"
import "C"

type ListOptions struct {
	Types     DatasetType
	Recursive bool
	Depth     int32
	Paths     []string
}

func listChildren(d Dataset, opts ListOptions) (datasets []Dataset, err error) {
	var tempDatasets []Dataset
	defer DatasetCloseAll(tempDatasets)

	if err := d.openHdl(); err != nil {
		return nil, err
	}
	defer d.closeHdl()

	list := C.dataset_list_children(d.zh)
	if list == nil {
		//no children
		return nil, nil
	}
	defer C.dataset_list_free(list)

	pItem := list
	for pItem != nil {

		dataset, err := loadDatasetFromZfsHdl(pItem.zh)
		if err != nil {
			return nil, err
		} else if (dataset.Type & opts.Types) == 0 {
			if opts.Types == DatasetTypeSnapshot || opts.Types == DatasetTypeBookmark {
				tempDatasets = append(tempDatasets, *dataset)
			}
		} else {
			datasets = append(datasets, *dataset)
		}
		pItem = C.dataset_list_next(pItem)
	}

	if !opts.Recursive {
		return
	}

	if opts.Depth > 0 {
		opts.Depth--
		if opts.Depth == 0 {
			opts.Recursive = false
		}
	}

	var childrenDatasets []Dataset
	for _, d := range datasets {
		var dts []Dataset
		dts, err = listChildren(d, opts)
		if err != nil {
			break
		}
		childrenDatasets = append(childrenDatasets, dts...)
	}
	if err == nil {
		for _, d := range tempDatasets {
			var dts []Dataset
			dts, err = listChildren(d, opts)
			if err != nil {
				break
			}
			childrenDatasets = append(childrenDatasets, dts...)
		}
	}
	datasets = append(datasets, childrenDatasets...)
	if err != nil {
		DatasetCloseAll(datasets)
		datasets = nil
	}
	return
}

func listRoot(opts ListOptions) (datasets []Dataset, err error) {
	var tempDatasets []Dataset
	defer DatasetCloseAll(tempDatasets)

	listItem := C.dataset_list_root()
	if listItem == nil {
		return nil, nil
	}

	list := listItem
	defer C.dataset_list_free(list)

	// Retrieve all datasets
	for listItem != nil {
		dataset, _ := loadDatasetFromZfsHdl(listItem.zh)
		//
		if (dataset.Type & opts.Types) == 0 {
			if opts.Types == DatasetTypeSnapshot || opts.Types == DatasetTypeBookmark {
				if dataset.Type == DatasetTypeFilesystem || dataset.Type == DatasetTypeVolume {
					tempDatasets = append(tempDatasets, *dataset)
				}
			}
		} else {
			datasets = append(datasets, *dataset)
		}
		listItem = C.dataset_list_next(listItem)
	}

	// if !opts.Recursive {
	// 	return
	// }

	if opts.Depth > 0 {
		opts.Depth--
		if opts.Depth == 0 {
			opts.Recursive = false
		}
	}

	var childrenDatasets []Dataset
	for _, d := range datasets {
		var dts []Dataset
		dts, err = listChildren(d, opts)
		if err != nil {
			break
		}
		childrenDatasets = append(childrenDatasets, dts...)
	}
	if err == nil {
		for _, d := range tempDatasets {
			var dts []Dataset
			dts, err = listChildren(d, opts)
			if err != nil {
				break
			}
			childrenDatasets = append(childrenDatasets, dts...)
		}
	}
	datasets = append(datasets, childrenDatasets...)
	if err != nil {
		DatasetCloseAll(datasets)
		datasets = nil
	}
	return
}

func listPath(path string, opts ListOptions) (datasets []Dataset, err error) {
	var tempDatasets []Dataset
	defer DatasetCloseAll(tempDatasets)
	dataset, err := DatasetOpenSingle(path)
	if err != nil {
		return nil, err
	}
	if dataset.Type&opts.Types == 0 {
		if opts.Types == DatasetTypeSnapshot || opts.Types == DatasetTypeBookmark {
			tempDatasets = append(tempDatasets, *dataset)
		} else {
			dataset.Close()
			return
		}
	} else {
		datasets = append(datasets, *dataset)
	}

	if !opts.Recursive {
		return
	}

	if opts.Depth > 0 {
		opts.Depth--
		if opts.Depth == 0 {
			opts.Recursive = false
		}
	}

	var childrenDatasets []Dataset
	for _, d := range datasets {
		var dts []Dataset
		dts, err = listChildren(d, opts)
		if err == nil {
			childrenDatasets = append(childrenDatasets, dts...)
		} else {
			break
		}
	}
	if err == nil {
		for _, d := range tempDatasets {
			var dts []Dataset
			dts, err = listChildren(d, opts)
			if err == nil {
				childrenDatasets = append(childrenDatasets, dts...)
			} else {
				break
			}
		}
	}

	datasets = append(datasets, childrenDatasets...)
	if err != nil {
		DatasetCloseAll(datasets)
		datasets = nil
	}
	return
}

func List(opts ListOptions) (datasets []Dataset, err error) {
	if opts.Paths == nil {
		return listRoot(opts)
	}

	for _, path := range opts.Paths {
		var dts []Dataset
		dts, err = listPath(path, opts)
		if err == nil {
			datasets = append(datasets, dts...)
		} else {
			DatasetCloseAll(datasets)
			break
		}
	}
	return
}