github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/api/storage/client.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package storage
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"gopkg.in/juju/names.v2"
     9  
    10  	"github.com/juju/juju/api/base"
    11  	"github.com/juju/juju/apiserver/params"
    12  )
    13  
    14  // Client allows access to the storage API end point.
    15  type Client struct {
    16  	base.ClientFacade
    17  	facade base.FacadeCaller
    18  }
    19  
    20  // NewClient creates a new client for accessing the storage API.
    21  func NewClient(st base.APICallCloser) *Client {
    22  	frontend, backend := base.NewClientFacade(st, "Storage")
    23  	return &Client{ClientFacade: frontend, facade: backend}
    24  }
    25  
    26  // StorageDetails retrieves details about desired storage instances.
    27  func (c *Client) StorageDetails(tags []names.StorageTag) ([]params.StorageDetailsResult, error) {
    28  	found := params.StorageDetailsResults{}
    29  	entities := make([]params.Entity, len(tags))
    30  	for i, tag := range tags {
    31  		entities[i] = params.Entity{Tag: tag.String()}
    32  	}
    33  	if err := c.facade.FacadeCall("StorageDetails", params.Entities{Entities: entities}, &found); err != nil {
    34  		return nil, errors.Trace(err)
    35  	}
    36  	return found.Results, nil
    37  }
    38  
    39  // ListStorageDetails lists all storage.
    40  func (c *Client) ListStorageDetails() ([]params.StorageDetails, error) {
    41  	args := params.StorageFilters{
    42  		[]params.StorageFilter{{}}, // one empty filter
    43  	}
    44  	var results params.StorageDetailsListResults
    45  	if err := c.facade.FacadeCall("ListStorageDetails", args, &results); err != nil {
    46  		return nil, errors.Trace(err)
    47  	}
    48  	if len(results.Results) != 1 {
    49  		return nil, errors.Errorf(
    50  			"expected 1 result, got %d",
    51  			len(results.Results),
    52  		)
    53  	}
    54  	if results.Results[0].Error != nil {
    55  		return nil, errors.Trace(results.Results[0].Error)
    56  	}
    57  	return results.Results[0].Result, nil
    58  }
    59  
    60  // ListPools returns a list of pools that matches given filter.
    61  // If no filter was provided, a list of all pools is returned.
    62  func (c *Client) ListPools(providers, names []string) ([]params.StoragePool, error) {
    63  	args := params.StoragePoolFilters{
    64  		Filters: []params.StoragePoolFilter{{
    65  			Names:     names,
    66  			Providers: providers,
    67  		}},
    68  	}
    69  	var results params.StoragePoolsResults
    70  	if err := c.facade.FacadeCall("ListPools", args, &results); err != nil {
    71  		return nil, errors.Trace(err)
    72  	}
    73  	if len(results.Results) != 1 {
    74  		return nil, errors.Errorf("expected 1 result, got %d", len(results.Results))
    75  	}
    76  	if err := results.Results[0].Error; err != nil {
    77  		return nil, err
    78  	}
    79  	return results.Results[0].Result, nil
    80  }
    81  
    82  // CreatePool creates pool with specified parameters.
    83  func (c *Client) CreatePool(pname, provider string, attrs map[string]interface{}) error {
    84  	args := params.StoragePool{
    85  		Name:     pname,
    86  		Provider: provider,
    87  		Attrs:    attrs,
    88  	}
    89  	return c.facade.FacadeCall("CreatePool", args, nil)
    90  }
    91  
    92  // ListVolumes lists volumes for desired machines.
    93  // If no machines provided, a list of all volumes is returned.
    94  func (c *Client) ListVolumes(machines []string) ([]params.VolumeDetailsListResult, error) {
    95  	filters := make([]params.VolumeFilter, len(machines))
    96  	for i, machine := range machines {
    97  		filters[i].Machines = []string{names.NewMachineTag(machine).String()}
    98  	}
    99  	if len(filters) == 0 {
   100  		filters = []params.VolumeFilter{{}}
   101  	}
   102  	args := params.VolumeFilters{filters}
   103  	var results params.VolumeDetailsListResults
   104  	if err := c.facade.FacadeCall("ListVolumes", args, &results); err != nil {
   105  		return nil, errors.Trace(err)
   106  	}
   107  	if len(results.Results) != len(filters) {
   108  		return nil, errors.Errorf(
   109  			"expected %d result(s), got %d",
   110  			len(filters), len(results.Results),
   111  		)
   112  	}
   113  	return results.Results, nil
   114  }
   115  
   116  // ListFilesystems lists filesystems for desired machines.
   117  // If no machines provided, a list of all filesystems is returned.
   118  func (c *Client) ListFilesystems(machines []string) ([]params.FilesystemDetailsListResult, error) {
   119  	filters := make([]params.FilesystemFilter, len(machines))
   120  	for i, machine := range machines {
   121  		filters[i].Machines = []string{names.NewMachineTag(machine).String()}
   122  	}
   123  	if len(filters) == 0 {
   124  		filters = []params.FilesystemFilter{{}}
   125  	}
   126  	args := params.FilesystemFilters{filters}
   127  	var results params.FilesystemDetailsListResults
   128  	if err := c.facade.FacadeCall("ListFilesystems", args, &results); err != nil {
   129  		return nil, errors.Trace(err)
   130  	}
   131  	if len(results.Results) != len(filters) {
   132  		return nil, errors.Errorf(
   133  			"expected %d result(s), got %d",
   134  			len(filters), len(results.Results),
   135  		)
   136  	}
   137  	return results.Results, nil
   138  }
   139  
   140  // AddToUnit adds specified storage to desired units.
   141  func (c *Client) AddToUnit(storages []params.StorageAddParams) ([]params.ErrorResult, error) {
   142  	out := params.ErrorResults{}
   143  	in := params.StoragesAddParams{Storages: storages}
   144  	err := c.facade.FacadeCall("AddToUnit", in, &out)
   145  	if err != nil {
   146  		return nil, errors.Trace(err)
   147  	}
   148  	return out.Results, nil
   149  }