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

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package block
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  
     9  	"github.com/juju/juju/apiserver/common"
    10  	"github.com/juju/juju/apiserver/facade"
    11  	"github.com/juju/juju/apiserver/params"
    12  	"github.com/juju/juju/permission"
    13  	"github.com/juju/juju/state"
    14  )
    15  
    16  func init() {
    17  	common.RegisterStandardFacade("Block", 2, NewAPI)
    18  }
    19  
    20  // Block defines the methods on the block API end point.
    21  type Block interface {
    22  	// List returns all current blocks for this environment.
    23  	List() (params.BlockResults, error)
    24  
    25  	// SwitchBlockOn switches desired block type on for this
    26  	// environment.
    27  	SwitchBlockOn(params.BlockSwitchParams) params.ErrorResult
    28  
    29  	// SwitchBlockOff switches desired block type off for this
    30  	// environment.
    31  	SwitchBlockOff(params.BlockSwitchParams) params.ErrorResult
    32  }
    33  
    34  // API implements Block interface and is the concrete
    35  // implementation of the api end point.
    36  type API struct {
    37  	access     blockAccess
    38  	authorizer facade.Authorizer
    39  }
    40  
    41  // NewAPI returns a new block API facade.
    42  func NewAPI(
    43  	st *state.State,
    44  	resources facade.Resources,
    45  	authorizer facade.Authorizer,
    46  ) (*API, error) {
    47  
    48  	if !authorizer.AuthClient() {
    49  		return nil, common.ErrPerm
    50  	}
    51  
    52  	return &API{
    53  		access:     getState(st),
    54  		authorizer: authorizer,
    55  	}, nil
    56  }
    57  
    58  var getState = func(st *state.State) blockAccess {
    59  	return stateShim{st}
    60  }
    61  
    62  func (a *API) checkCanRead() error {
    63  	canRead, err := a.authorizer.HasPermission(permission.ReadAccess, a.access.ModelTag())
    64  	if err != nil && !errors.IsNotFound(err) {
    65  		return errors.Trace(err)
    66  	}
    67  	if !canRead {
    68  		return common.ErrPerm
    69  	}
    70  	return nil
    71  }
    72  
    73  func (a *API) checkCanWrite() error {
    74  	canWrite, err := a.authorizer.HasPermission(permission.WriteAccess, a.access.ModelTag())
    75  	if err != nil && !errors.IsNotFound(err) {
    76  		return errors.Trace(err)
    77  	}
    78  	if !canWrite {
    79  		return common.ErrPerm
    80  	}
    81  	return nil
    82  }
    83  
    84  // List implements Block.List().
    85  func (a *API) List() (params.BlockResults, error) {
    86  	if err := a.checkCanRead(); err != nil {
    87  		return params.BlockResults{}, err
    88  	}
    89  
    90  	all, err := a.access.AllBlocks()
    91  	if err != nil {
    92  		return params.BlockResults{}, common.ServerError(err)
    93  	}
    94  	found := make([]params.BlockResult, len(all))
    95  	for i, one := range all {
    96  		found[i] = convertBlock(one)
    97  	}
    98  	return params.BlockResults{Results: found}, nil
    99  }
   100  
   101  func convertBlock(b state.Block) params.BlockResult {
   102  	result := params.BlockResult{}
   103  	tag, err := b.Tag()
   104  	if err != nil {
   105  		err := errors.Annotatef(err, "getting block %v", b.Type().String())
   106  		result.Error = common.ServerError(err)
   107  	}
   108  	result.Result = params.Block{
   109  		Id:      b.Id(),
   110  		Tag:     tag.String(),
   111  		Type:    b.Type().String(),
   112  		Message: b.Message(),
   113  	}
   114  	return result
   115  }
   116  
   117  // SwitchBlockOn implements Block.SwitchBlockOn().
   118  func (a *API) SwitchBlockOn(args params.BlockSwitchParams) params.ErrorResult {
   119  	if err := a.checkCanWrite(); err != nil {
   120  		return params.ErrorResult{Error: common.ServerError(err)}
   121  	}
   122  
   123  	err := a.access.SwitchBlockOn(state.ParseBlockType(args.Type), args.Message)
   124  	return params.ErrorResult{Error: common.ServerError(err)}
   125  }
   126  
   127  // SwitchBlockOff implements Block.SwitchBlockOff().
   128  func (a *API) SwitchBlockOff(args params.BlockSwitchParams) params.ErrorResult {
   129  	if err := a.checkCanWrite(); err != nil {
   130  		return params.ErrorResult{Error: common.ServerError(err)}
   131  	}
   132  
   133  	err := a.access.SwitchBlockOff(state.ParseBlockType(args.Type))
   134  	return params.ErrorResult{Error: common.ServerError(err)}
   135  }