github.com/altoros/juju-vmware@v0.0.0-20150312064031-f19ae857ccca/api/leadership/client.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  /*
     5  Package leadership implements the client to the analog leadership
     6  service.
     7  */
     8  package leadership
     9  
    10  import (
    11  	"time"
    12  
    13  	"github.com/juju/errors"
    14  	"github.com/juju/loggo"
    15  	"github.com/juju/names"
    16  
    17  	"github.com/juju/juju/api/base"
    18  	"github.com/juju/juju/apiserver/params"
    19  )
    20  
    21  var logger = loggo.GetLogger("juju.api.leadership")
    22  
    23  type facadeCaller interface {
    24  	FacadeCall(request string, params, response interface{}) error
    25  }
    26  
    27  type client struct {
    28  	base.ClientFacade
    29  	facadeCaller
    30  }
    31  
    32  // NewClient returns a new LeadershipClient instance.
    33  func NewClient(facade base.ClientFacade, caller facadeCaller) LeadershipClient {
    34  	return &client{facade, caller}
    35  }
    36  
    37  // ClaimLeadership implements LeadershipManager.
    38  func (c *client) ClaimLeadership(serviceId, unitId string) (time.Duration, error) {
    39  
    40  	results, err := c.bulkClaimLeadership(c.prepareClaimLeadership(serviceId, unitId))
    41  	if err != nil {
    42  		return 0, err
    43  	}
    44  
    45  	// We should have our 1 result. If not, we rightfully panic.
    46  	result := results.Results[0]
    47  	return time.Duration(result.ClaimDurationInSec) * time.Second, result.Error
    48  }
    49  
    50  // ReleaseLeadership implements LeadershipManager.
    51  func (c *client) ReleaseLeadership(serviceId, unitId string) error {
    52  	results, err := c.bulkReleaseLeadership(c.prepareReleaseLeadership(serviceId, unitId))
    53  	if err != nil {
    54  		return err
    55  	}
    56  
    57  	// We should have our 1 result. If not, we rightfully panic.
    58  	return results.Results[0].Error
    59  }
    60  
    61  // BlockUntilLeadershipReleased implements LeadershipManager.
    62  func (c *client) BlockUntilLeadershipReleased(serviceId string) error {
    63  	const friendlyErrMsg = "error blocking on leadership release"
    64  	var result params.ErrorResult
    65  	err := c.FacadeCall("BlockUntilLeadershipReleased", names.NewServiceTag(serviceId), &result)
    66  	if err != nil {
    67  		return errors.Annotate(err, friendlyErrMsg)
    68  	} else if result.Error != nil {
    69  		return errors.Annotate(result.Error, friendlyErrMsg)
    70  	}
    71  	return nil
    72  }
    73  
    74  //
    75  // Prepare functions for building bulk-calls.
    76  //
    77  
    78  // prepareClaimLeadership creates a single set of params in
    79  // preperation for making a bulk call.
    80  func (c *client) prepareClaimLeadership(serviceId, unitId string) params.ClaimLeadershipParams {
    81  	return params.ClaimLeadershipParams{
    82  		names.NewServiceTag(serviceId).String(),
    83  		names.NewUnitTag(unitId).String(),
    84  	}
    85  }
    86  
    87  // prepareReleaseLeadership creates a single set of params in
    88  // preperation for making a bulk call.
    89  func (c *client) prepareReleaseLeadership(serviceId, unitId string) params.ReleaseLeadershipParams {
    90  	return params.ReleaseLeadershipParams{
    91  		names.NewServiceTag(serviceId).String(),
    92  		names.NewUnitTag(unitId).String(),
    93  	}
    94  }
    95  
    96  //
    97  // Bulk calls.
    98  //
    99  
   100  func (c *client) bulkClaimLeadership(args ...params.ClaimLeadershipParams) (*params.ClaimLeadershipBulkResults, error) {
   101  	// Don't make the jump over the network if we don't have to.
   102  	if len(args) <= 0 {
   103  		return &params.ClaimLeadershipBulkResults{}, nil
   104  	}
   105  
   106  	bulkParams := params.ClaimLeadershipBulkParams{args}
   107  	var results params.ClaimLeadershipBulkResults
   108  	if err := c.FacadeCall("ClaimLeadership", bulkParams, &results); err != nil {
   109  		return nil, errors.Annotate(err, "error making a leadership claim")
   110  	}
   111  	return &results, nil
   112  }
   113  
   114  func (c *client) bulkReleaseLeadership(args ...params.ReleaseLeadershipParams) (*params.ReleaseLeadershipBulkResults, error) {
   115  	// Don't make the jump over the network if we don't have to.
   116  	if len(args) <= 0 {
   117  		return &params.ReleaseLeadershipBulkResults{}, nil
   118  	}
   119  
   120  	bulkParams := params.ReleaseLeadershipBulkParams{args}
   121  	var results params.ReleaseLeadershipBulkResults
   122  	if err := c.FacadeCall("ReleaseLeadership", bulkParams, &results); err != nil {
   123  		return nil, errors.Annotate(err, "cannot release leadership")
   124  	}
   125  
   126  	return &results, nil
   127  }