github.com/containers/libpod@v1.9.4-0.20220419124438-4284fd425507/pkg/domain/infra/abi/volumes.go (about)

     1  // +build ABISupport
     2  
     3  package abi
     4  
     5  import (
     6  	"context"
     7  
     8  	"github.com/containers/libpod/libpod"
     9  	"github.com/containers/libpod/pkg/domain/entities"
    10  	"github.com/containers/libpod/pkg/domain/filters"
    11  	"github.com/containers/libpod/pkg/domain/infra/abi/parse"
    12  	"github.com/pkg/errors"
    13  )
    14  
    15  func (ic *ContainerEngine) VolumeCreate(ctx context.Context, opts entities.VolumeCreateOptions) (*entities.IdOrNameResponse, error) {
    16  	var (
    17  		volumeOptions []libpod.VolumeCreateOption
    18  	)
    19  	if len(opts.Name) > 0 {
    20  		volumeOptions = append(volumeOptions, libpod.WithVolumeName(opts.Name))
    21  	}
    22  	if len(opts.Driver) > 0 {
    23  		volumeOptions = append(volumeOptions, libpod.WithVolumeDriver(opts.Driver))
    24  	}
    25  	if len(opts.Label) > 0 {
    26  		volumeOptions = append(volumeOptions, libpod.WithVolumeLabels(opts.Label))
    27  	}
    28  	if len(opts.Options) > 0 {
    29  		parsedOptions, err := parse.ParseVolumeOptions(opts.Options)
    30  		if err != nil {
    31  			return nil, err
    32  		}
    33  		volumeOptions = append(volumeOptions, parsedOptions...)
    34  	}
    35  	vol, err := ic.Libpod.NewVolume(ctx, volumeOptions...)
    36  	if err != nil {
    37  		return nil, err
    38  	}
    39  	return &entities.IdOrNameResponse{IdOrName: vol.Name()}, nil
    40  }
    41  
    42  func (ic *ContainerEngine) VolumeRm(ctx context.Context, namesOrIds []string, opts entities.VolumeRmOptions) ([]*entities.VolumeRmReport, error) {
    43  	var (
    44  		err     error
    45  		reports []*entities.VolumeRmReport
    46  		vols    []*libpod.Volume
    47  	)
    48  	if opts.All {
    49  		vols, err = ic.Libpod.Volumes()
    50  		if err != nil {
    51  			return nil, err
    52  		}
    53  	} else {
    54  		for _, id := range namesOrIds {
    55  			vol, err := ic.Libpod.LookupVolume(id)
    56  			if err != nil {
    57  				reports = append(reports, &entities.VolumeRmReport{
    58  					Err: err,
    59  					Id:  id,
    60  				})
    61  				continue
    62  			}
    63  			vols = append(vols, vol)
    64  		}
    65  	}
    66  	for _, vol := range vols {
    67  		reports = append(reports, &entities.VolumeRmReport{
    68  			Err: ic.Libpod.RemoveVolume(ctx, vol, opts.Force),
    69  			Id:  vol.Name(),
    70  		})
    71  	}
    72  	return reports, nil
    73  }
    74  
    75  func (ic *ContainerEngine) VolumeInspect(ctx context.Context, namesOrIds []string, opts entities.VolumeInspectOptions) ([]*entities.VolumeInspectReport, error) {
    76  	var (
    77  		err     error
    78  		reports []*entities.VolumeInspectReport
    79  		vols    []*libpod.Volume
    80  	)
    81  
    82  	// Note: as with previous implementation, a single failure here
    83  	// results a return.
    84  	if opts.All {
    85  		vols, err = ic.Libpod.GetAllVolumes()
    86  		if err != nil {
    87  			return nil, err
    88  		}
    89  	} else {
    90  		for _, v := range namesOrIds {
    91  			vol, err := ic.Libpod.LookupVolume(v)
    92  			if err != nil {
    93  				return nil, errors.Wrapf(err, "error inspecting volume %s", v)
    94  			}
    95  			vols = append(vols, vol)
    96  		}
    97  	}
    98  	for _, v := range vols {
    99  		config := entities.VolumeConfigResponse{
   100  			Name:       v.Name(),
   101  			Driver:     v.Driver(),
   102  			Mountpoint: v.MountPoint(),
   103  			CreatedAt:  v.CreatedTime(),
   104  			Labels:     v.Labels(),
   105  			Scope:      v.Scope(),
   106  			Options:    v.Options(),
   107  			UID:        v.UID(),
   108  			GID:        v.GID(),
   109  		}
   110  		reports = append(reports, &entities.VolumeInspectReport{VolumeConfigResponse: &config})
   111  	}
   112  	return reports, nil
   113  }
   114  
   115  func (ic *ContainerEngine) VolumePrune(ctx context.Context, opts entities.VolumePruneOptions) ([]*entities.VolumePruneReport, error) {
   116  	var (
   117  		reports []*entities.VolumePruneReport
   118  	)
   119  	pruned, err := ic.Libpod.PruneVolumes(ctx)
   120  	if err != nil {
   121  		return nil, err
   122  	}
   123  	for k, v := range pruned {
   124  		reports = append(reports, &entities.VolumePruneReport{
   125  			Err: v,
   126  			Id:  k,
   127  		})
   128  	}
   129  	return reports, nil
   130  }
   131  
   132  func (ic *ContainerEngine) VolumeList(ctx context.Context, opts entities.VolumeListOptions) ([]*entities.VolumeListReport, error) {
   133  	var (
   134  		reports []*entities.VolumeListReport
   135  	)
   136  	volumeFilters, err := filters.GenerateVolumeFilters(opts.Filter)
   137  	if err != nil {
   138  		return nil, err
   139  	}
   140  	vols, err := ic.Libpod.Volumes(volumeFilters...)
   141  	if err != nil {
   142  		return nil, err
   143  	}
   144  	for _, v := range vols {
   145  		config := entities.VolumeConfigResponse{
   146  			Name:       v.Name(),
   147  			Driver:     v.Driver(),
   148  			Mountpoint: v.MountPoint(),
   149  			CreatedAt:  v.CreatedTime(),
   150  			Labels:     v.Labels(),
   151  			Scope:      v.Scope(),
   152  			Options:    v.Options(),
   153  			UID:        v.UID(),
   154  			GID:        v.GID(),
   155  		}
   156  		reports = append(reports, &entities.VolumeListReport{VolumeConfigResponse: config})
   157  	}
   158  	return reports, nil
   159  }