github.com/hustcat/docker@v1.3.3-0.20160314103604-901c67a8eeab/volume/drivers/proxy.go (about)

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