github.com/olljanat/moby@v1.13.1/volume/drivers/proxy.go (about)

     1  // generated code - DO NOT EDIT
     2  
     3  package volumedrivers
     4  
     5  import (
     6  	"errors"
     7  
     8  	"github.com/docker/docker/volume"
     9  )
    10  
    11  type client interface {
    12  	Call(string, interface{}, interface{}) error
    13  }
    14  
    15  type volumeDriverProxy struct {
    16  	client
    17  }
    18  
    19  type volumeDriverProxyCreateRequest struct {
    20  	Name string
    21  	Opts map[string]string
    22  }
    23  
    24  type volumeDriverProxyCreateResponse struct {
    25  	Err string
    26  }
    27  
    28  func (pp *volumeDriverProxy) Create(name string, opts map[string]string) (err error) {
    29  	var (
    30  		req volumeDriverProxyCreateRequest
    31  		ret volumeDriverProxyCreateResponse
    32  	)
    33  
    34  	req.Name = name
    35  	req.Opts = opts
    36  	if err = pp.Call("VolumeDriver.Create", req, &ret); err != nil {
    37  		return
    38  	}
    39  
    40  	if ret.Err != "" {
    41  		err = errors.New(ret.Err)
    42  	}
    43  
    44  	return
    45  }
    46  
    47  type volumeDriverProxyRemoveRequest struct {
    48  	Name string
    49  }
    50  
    51  type volumeDriverProxyRemoveResponse struct {
    52  	Err string
    53  }
    54  
    55  func (pp *volumeDriverProxy) Remove(name string) (err error) {
    56  	var (
    57  		req volumeDriverProxyRemoveRequest
    58  		ret volumeDriverProxyRemoveResponse
    59  	)
    60  
    61  	req.Name = name
    62  	if err = pp.Call("VolumeDriver.Remove", req, &ret); err != nil {
    63  		return
    64  	}
    65  
    66  	if ret.Err != "" {
    67  		err = errors.New(ret.Err)
    68  	}
    69  
    70  	return
    71  }
    72  
    73  type volumeDriverProxyPathRequest struct {
    74  	Name string
    75  }
    76  
    77  type volumeDriverProxyPathResponse struct {
    78  	Mountpoint string
    79  	Err        string
    80  }
    81  
    82  func (pp *volumeDriverProxy) Path(name string) (mountpoint string, err error) {
    83  	var (
    84  		req volumeDriverProxyPathRequest
    85  		ret volumeDriverProxyPathResponse
    86  	)
    87  
    88  	req.Name = name
    89  	if err = pp.Call("VolumeDriver.Path", req, &ret); err != nil {
    90  		return
    91  	}
    92  
    93  	mountpoint = ret.Mountpoint
    94  
    95  	if ret.Err != "" {
    96  		err = errors.New(ret.Err)
    97  	}
    98  
    99  	return
   100  }
   101  
   102  type volumeDriverProxyMountRequest struct {
   103  	Name string
   104  	ID   string
   105  }
   106  
   107  type volumeDriverProxyMountResponse struct {
   108  	Mountpoint string
   109  	Err        string
   110  }
   111  
   112  func (pp *volumeDriverProxy) Mount(name string, id string) (mountpoint string, err error) {
   113  	var (
   114  		req volumeDriverProxyMountRequest
   115  		ret volumeDriverProxyMountResponse
   116  	)
   117  
   118  	req.Name = name
   119  	req.ID = id
   120  	if err = pp.Call("VolumeDriver.Mount", req, &ret); err != nil {
   121  		return
   122  	}
   123  
   124  	mountpoint = ret.Mountpoint
   125  
   126  	if ret.Err != "" {
   127  		err = errors.New(ret.Err)
   128  	}
   129  
   130  	return
   131  }
   132  
   133  type volumeDriverProxyUnmountRequest struct {
   134  	Name string
   135  	ID   string
   136  }
   137  
   138  type volumeDriverProxyUnmountResponse struct {
   139  	Err string
   140  }
   141  
   142  func (pp *volumeDriverProxy) Unmount(name string, id string) (err error) {
   143  	var (
   144  		req volumeDriverProxyUnmountRequest
   145  		ret volumeDriverProxyUnmountResponse
   146  	)
   147  
   148  	req.Name = name
   149  	req.ID = id
   150  	if err = pp.Call("VolumeDriver.Unmount", req, &ret); err != nil {
   151  		return
   152  	}
   153  
   154  	if ret.Err != "" {
   155  		err = errors.New(ret.Err)
   156  	}
   157  
   158  	return
   159  }
   160  
   161  type volumeDriverProxyListRequest struct {
   162  }
   163  
   164  type volumeDriverProxyListResponse struct {
   165  	Volumes []*proxyVolume
   166  	Err     string
   167  }
   168  
   169  func (pp *volumeDriverProxy) List() (volumes []*proxyVolume, err error) {
   170  	var (
   171  		req volumeDriverProxyListRequest
   172  		ret volumeDriverProxyListResponse
   173  	)
   174  
   175  	if err = pp.Call("VolumeDriver.List", req, &ret); err != nil {
   176  		return
   177  	}
   178  
   179  	volumes = ret.Volumes
   180  
   181  	if ret.Err != "" {
   182  		err = errors.New(ret.Err)
   183  	}
   184  
   185  	return
   186  }
   187  
   188  type volumeDriverProxyGetRequest struct {
   189  	Name string
   190  }
   191  
   192  type volumeDriverProxyGetResponse struct {
   193  	Volume *proxyVolume
   194  	Err    string
   195  }
   196  
   197  func (pp *volumeDriverProxy) Get(name string) (volume *proxyVolume, err error) {
   198  	var (
   199  		req volumeDriverProxyGetRequest
   200  		ret volumeDriverProxyGetResponse
   201  	)
   202  
   203  	req.Name = name
   204  	if err = pp.Call("VolumeDriver.Get", req, &ret); err != nil {
   205  		return
   206  	}
   207  
   208  	volume = ret.Volume
   209  
   210  	if ret.Err != "" {
   211  		err = errors.New(ret.Err)
   212  	}
   213  
   214  	return
   215  }
   216  
   217  type volumeDriverProxyCapabilitiesRequest struct {
   218  }
   219  
   220  type volumeDriverProxyCapabilitiesResponse struct {
   221  	Capabilities volume.Capability
   222  	Err          string
   223  }
   224  
   225  func (pp *volumeDriverProxy) Capabilities() (capabilities volume.Capability, err error) {
   226  	var (
   227  		req volumeDriverProxyCapabilitiesRequest
   228  		ret volumeDriverProxyCapabilitiesResponse
   229  	)
   230  
   231  	if err = pp.Call("VolumeDriver.Capabilities", req, &ret); err != nil {
   232  		return
   233  	}
   234  
   235  	capabilities = ret.Capabilities
   236  
   237  	if ret.Err != "" {
   238  		err = errors.New(ret.Err)
   239  	}
   240  
   241  	return
   242  }