github.com/cloud-green/juju@v0.0.0-20151002100041-a00291338d3d/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  	"github.com/juju/loggo"
     9  	"github.com/juju/names"
    10  
    11  	"github.com/juju/juju/api/base"
    12  	"github.com/juju/juju/apiserver/params"
    13  )
    14  
    15  var logger = loggo.GetLogger("juju.api.storage")
    16  
    17  // Client allows access to the storage API end point.
    18  type Client struct {
    19  	base.ClientFacade
    20  	facade base.FacadeCaller
    21  }
    22  
    23  // NewClient creates a new client for accessing the storage API.
    24  func NewClient(st base.APICallCloser) *Client {
    25  	frontend, backend := base.NewClientFacade(st, "Storage")
    26  	logger.Debugf("\nSTORAGE FRONT-END: %#v", frontend)
    27  	logger.Debugf("\nSTORAGE BACK-END: %#v", backend)
    28  	return &Client{ClientFacade: frontend, facade: backend}
    29  }
    30  
    31  // Show retrieves information about desired storage instances.
    32  func (c *Client) Show(tags []names.StorageTag) ([]params.StorageDetailsResult, error) {
    33  	found := params.StorageDetailsResults{}
    34  	entities := make([]params.Entity, len(tags))
    35  	for i, tag := range tags {
    36  		entities[i] = params.Entity{Tag: tag.String()}
    37  	}
    38  	if err := c.facade.FacadeCall("Show", params.Entities{Entities: entities}, &found); err != nil {
    39  		return nil, errors.Trace(err)
    40  	}
    41  	return found.Results, nil
    42  }
    43  
    44  // List lists all storage.
    45  func (c *Client) List() ([]params.StorageDetailsResult, error) {
    46  	found := params.StorageDetailsResults{}
    47  	if err := c.facade.FacadeCall("List", nil, &found); err != nil {
    48  		return nil, errors.Trace(err)
    49  	}
    50  	return found.Results, nil
    51  }
    52  
    53  // ListPools returns a list of pools that matches given filter.
    54  // If no filter was provided, a list of all pools is returned.
    55  func (c *Client) ListPools(providers, names []string) ([]params.StoragePool, error) {
    56  	args := params.StoragePoolFilter{
    57  		Names:     names,
    58  		Providers: providers,
    59  	}
    60  	found := params.StoragePoolsResult{}
    61  	if err := c.facade.FacadeCall("ListPools", args, &found); err != nil {
    62  		return nil, errors.Trace(err)
    63  	}
    64  	return found.Results, nil
    65  }
    66  
    67  // CreatePool creates pool with specified parameters.
    68  func (c *Client) CreatePool(pname, provider string, attrs map[string]interface{}) error {
    69  	args := params.StoragePool{
    70  		Name:     pname,
    71  		Provider: provider,
    72  		Attrs:    attrs,
    73  	}
    74  	return c.facade.FacadeCall("CreatePool", args, nil)
    75  }
    76  
    77  // ListVolumes lists volumes for desired machines.
    78  // If no machines provided, a list of all volumes is returned.
    79  func (c *Client) ListVolumes(machines []string) ([]params.VolumeDetailsResult, error) {
    80  	tags := make([]string, len(machines))
    81  	for i, one := range machines {
    82  		tags[i] = names.NewMachineTag(one).String()
    83  	}
    84  	args := params.VolumeFilter{Machines: tags}
    85  	found := params.VolumeDetailsResults{}
    86  	if err := c.facade.FacadeCall("ListVolumes", args, &found); err != nil {
    87  		return nil, errors.Trace(err)
    88  	}
    89  	return found.Results, nil
    90  }
    91  
    92  // ListFilesystems lists filesystems for desired machines.
    93  // If no machines provided, a list of all filesystems is returned.
    94  func (c *Client) ListFilesystems(machines []string) ([]params.FilesystemDetailsResult, error) {
    95  	tags := make([]string, len(machines))
    96  	for i, one := range machines {
    97  		tags[i] = names.NewMachineTag(one).String()
    98  	}
    99  	args := params.FilesystemFilter{Machines: tags}
   100  	found := params.FilesystemDetailsResults{}
   101  	if err := c.facade.FacadeCall("ListFilesystems", args, &found); err != nil {
   102  		return nil, errors.Trace(err)
   103  	}
   104  	return found.Results, nil
   105  }
   106  
   107  // AddToUnit adds specified storage to desired units.
   108  func (c *Client) AddToUnit(storages []params.StorageAddParams) ([]params.ErrorResult, error) {
   109  	out := params.ErrorResults{}
   110  	in := params.StoragesAddParams{Storages: storages}
   111  	err := c.facade.FacadeCall("AddToUnit", in, &out)
   112  	if err != nil {
   113  		return nil, errors.Trace(err)
   114  	}
   115  	return out.Results, nil
   116  }