github.com/mattyw/juju@v0.0.0-20140610034352-732aecd63861/state/api/upgrader/upgrader.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package upgrader
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/juju/utils"
    10  
    11  	"github.com/juju/juju/state/api/base"
    12  	"github.com/juju/juju/state/api/params"
    13  	"github.com/juju/juju/state/api/watcher"
    14  	"github.com/juju/juju/tools"
    15  	"github.com/juju/juju/version"
    16  )
    17  
    18  // State provides access to an upgrader worker's view of the state.
    19  type State struct {
    20  	caller base.Caller
    21  }
    22  
    23  func (st *State) call(method string, params, result interface{}) error {
    24  	return st.caller.Call("Upgrader", "", method, params, result)
    25  }
    26  
    27  // NewState returns a version of the state that provides functionality
    28  // required by the upgrader worker.
    29  func NewState(caller base.Caller) *State {
    30  	return &State{caller}
    31  }
    32  
    33  // SetVersion sets the tools version associated with the entity with
    34  // the given tag, which must be the tag of the entity that the
    35  // upgrader is running on behalf of.
    36  func (st *State) SetVersion(tag string, v version.Binary) error {
    37  	var results params.ErrorResults
    38  	args := params.EntitiesVersion{
    39  		AgentTools: []params.EntityVersion{{
    40  			Tag:   tag,
    41  			Tools: &params.Version{v},
    42  		}},
    43  	}
    44  	err := st.call("SetTools", args, &results)
    45  	if err != nil {
    46  		// TODO: Not directly tested
    47  		return err
    48  	}
    49  	return results.OneError()
    50  }
    51  
    52  func (st *State) DesiredVersion(tag string) (version.Number, error) {
    53  	var results params.VersionResults
    54  	args := params.Entities{
    55  		Entities: []params.Entity{{Tag: tag}},
    56  	}
    57  	err := st.call("DesiredVersion", args, &results)
    58  	if err != nil {
    59  		// TODO: Not directly tested
    60  		return version.Number{}, err
    61  	}
    62  	if len(results.Results) != 1 {
    63  		// TODO: Not directly tested
    64  		return version.Number{}, fmt.Errorf("expected 1 result, got %d", len(results.Results))
    65  	}
    66  	result := results.Results[0]
    67  	if err := result.Error; err != nil {
    68  		return version.Number{}, err
    69  	}
    70  	if result.Version == nil {
    71  		// TODO: Not directly tested
    72  		return version.Number{}, fmt.Errorf("received no error, but got a nil Version")
    73  	}
    74  	return *result.Version, nil
    75  }
    76  
    77  // Tools returns the agent tools that should run on the given entity,
    78  // along with a flag whether to disable SSL hostname verification.
    79  func (st *State) Tools(tag string) (*tools.Tools, utils.SSLHostnameVerification, error) {
    80  	var results params.ToolsResults
    81  	args := params.Entities{
    82  		Entities: []params.Entity{{Tag: tag}},
    83  	}
    84  	err := st.call("Tools", args, &results)
    85  	if err != nil {
    86  		// TODO: Not directly tested
    87  		return nil, false, err
    88  	}
    89  	if len(results.Results) != 1 {
    90  		// TODO: Not directly tested
    91  		return nil, false, fmt.Errorf("expected 1 result, got %d", len(results.Results))
    92  	}
    93  	result := results.Results[0]
    94  	if err := result.Error; err != nil {
    95  		return nil, false, err
    96  	}
    97  	hostnameVerification := utils.VerifySSLHostnames
    98  	if result.DisableSSLHostnameVerification {
    99  		hostnameVerification = utils.NoVerifySSLHostnames
   100  	}
   101  	return result.Tools, hostnameVerification, nil
   102  }
   103  
   104  func (st *State) WatchAPIVersion(agentTag string) (watcher.NotifyWatcher, error) {
   105  	var results params.NotifyWatchResults
   106  	args := params.Entities{
   107  		Entities: []params.Entity{{Tag: agentTag}},
   108  	}
   109  	err := st.call("WatchAPIVersion", args, &results)
   110  	if err != nil {
   111  		// TODO: Not directly tested
   112  		return nil, err
   113  	}
   114  	if len(results.Results) != 1 {
   115  		// TODO: Not directly tested
   116  		return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
   117  	}
   118  	result := results.Results[0]
   119  	if result.Error != nil {
   120  		//  TODO: Not directly tested
   121  		return nil, result.Error
   122  	}
   123  	w := watcher.NewNotifyWatcher(st.caller, result)
   124  	return w, nil
   125  }