~rogpeppe/juju-core/438-local-instance-Addresses

« back to all changes in this revision

Viewing changes to state/apiserver/upgrader/upgrader.go

[r=fwereade],[bug=1234035] Fix upgrade 1.14 -> 1.15

This adds a Tools() API call to provisioner API,
similarly to the upgrader API. Common code factored
out into apiserver/common/tools.go.

SetAgentTools() renamed to SetAgentVersion() in
machine and unit state types. Also renamed a few
types in params to be shorter or better reflect
what are they about. Added DEPRECATE(v1.18) tags
to bits of the API that need cleanup.

Live tested on EC2 - after copying the tools from
/tools/releases/ to /tools/ the upgrade proceeds
and finishes successfully.

https://codereview.appspot.com/14231044/

R=fwereade, jameinel

Show diffs side-by-side

added added

removed removed

Lines of Context:
6
6
import (
7
7
        "errors"
8
8
 
9
 
        "launchpad.net/juju-core/environs"
10
9
        "launchpad.net/juju-core/environs/config"
11
 
        envtools "launchpad.net/juju-core/environs/tools"
12
10
        "launchpad.net/juju-core/state"
13
11
        "launchpad.net/juju-core/state/api/params"
14
12
        "launchpad.net/juju-core/state/apiserver/common"
15
13
        "launchpad.net/juju-core/state/watcher"
16
 
        agenttools "launchpad.net/juju-core/tools"
17
14
        "launchpad.net/juju-core/version"
18
15
)
19
16
 
20
17
// UpgraderAPI provides access to the Upgrader API facade.
21
18
type UpgraderAPI struct {
 
19
        *common.ToolsGetter
 
20
 
22
21
        st         *state.State
23
22
        resources  *common.Resources
24
23
        authorizer common.Authorizer
33
32
        if !authorizer.AuthMachineAgent() && !authorizer.AuthUnitAgent() {
34
33
                return nil, common.ErrPerm
35
34
        }
36
 
        return &UpgraderAPI{st: st, resources: resources, authorizer: authorizer}, nil
 
35
        getCanRead := func() (common.AuthFunc, error) {
 
36
                return authorizer.AuthOwner, nil
 
37
        }
 
38
        return &UpgraderAPI{
 
39
                ToolsGetter: common.NewToolsGetter(st, getCanRead),
 
40
                st:          st,
 
41
                resources:   resources,
 
42
                authorizer:  authorizer,
 
43
        }, nil
37
44
}
38
45
 
39
46
// WatchAPIVersion starts a watcher to track if there is a new version
62
69
        return result, nil
63
70
}
64
71
 
65
 
func (u *UpgraderAPI) oneAgentTools(tag string, agentVersion version.Number, env environs.Environ) (*agenttools.Tools, error) {
66
 
        if !u.authorizer.AuthOwner(tag) {
67
 
                return nil, common.ErrPerm
68
 
        }
69
 
        entity0, err := u.findEntity(tag)
70
 
        if err != nil {
71
 
                return nil, err
72
 
        }
73
 
        entity, ok := entity0.(state.AgentTooler)
74
 
        if !ok {
75
 
                return nil, common.NotSupportedError(tag, "agent tools")
76
 
        }
77
 
 
78
 
        existingTools, err := entity.AgentTools()
79
 
        if err != nil {
80
 
                return nil, err
81
 
        }
82
 
        // TODO(jam): Avoid searching the provider for every machine
83
 
        // that wants to upgrade. The information could just be cached
84
 
        // in state, or even in the API servers
85
 
        return envtools.FindExactTools(env, agentVersion, existingTools.Version.Series, existingTools.Version.Arch)
86
 
}
87
 
 
88
72
func (u *UpgraderAPI) getGlobalAgentVersion() (version.Number, *config.Config, error) {
89
73
        // Get the Agent Version requested in the Environment Config
90
74
        cfg, err := u.st.EnvironConfig()
99
83
}
100
84
 
101
85
// DesiredVersion reports the Agent Version that we want that agent to be running
102
 
func (u *UpgraderAPI) DesiredVersion(args params.Entities) (params.AgentVersionResults, error) {
103
 
        results := make([]params.AgentVersionResult, len(args.Entities))
 
86
func (u *UpgraderAPI) DesiredVersion(args params.Entities) (params.VersionResults, error) {
 
87
        results := make([]params.VersionResult, len(args.Entities))
104
88
        if len(args.Entities) == 0 {
105
 
                return params.AgentVersionResults{}, nil
 
89
                return params.VersionResults{}, nil
106
90
        }
107
91
        agentVersion, _, err := u.getGlobalAgentVersion()
108
92
        if err != nil {
109
 
                return params.AgentVersionResults{}, common.ServerError(err)
 
93
                return params.VersionResults{}, common.ServerError(err)
110
94
        }
111
95
        for i, entity := range args.Entities {
112
96
                err := common.ErrPerm
116
100
                }
117
101
                results[i].Error = common.ServerError(err)
118
102
        }
119
 
        return params.AgentVersionResults{results}, nil
120
 
}
121
 
 
122
 
// Tools finds the Tools necessary for the given agents.
123
 
func (u *UpgraderAPI) Tools(args params.Entities) (params.AgentToolsResults, error) {
124
 
        results := make([]params.AgentToolsResult, len(args.Entities))
125
 
        if len(args.Entities) == 0 {
126
 
                return params.AgentToolsResults{}, nil
127
 
        }
128
 
        agentVersion, cfg, err := u.getGlobalAgentVersion()
129
 
        if err != nil {
130
 
                return params.AgentToolsResults{}, common.ServerError(err)
131
 
        }
132
 
        env, err := environs.New(cfg)
133
 
        if err != nil {
134
 
                return params.AgentToolsResults{}, err
135
 
        }
136
 
        for i, entity := range args.Entities {
137
 
                agentTools, err := u.oneAgentTools(entity.Tag, agentVersion, env)
138
 
                if err == nil {
139
 
                        results[i].Tools = agentTools
140
 
                }
141
 
                results[i].Error = common.ServerError(err)
142
 
        }
143
 
        return params.AgentToolsResults{results}, nil
 
103
        return params.VersionResults{results}, nil
144
104
}
145
105
 
146
106
// SetTools updates the recorded tools version for the agents.
147
 
func (u *UpgraderAPI) SetTools(args params.SetAgentsTools) (params.ErrorResults, error) {
 
107
func (u *UpgraderAPI) SetTools(args params.EntitiesVersion) (params.ErrorResults, error) {
148
108
        results := params.ErrorResults{
149
109
                Results: make([]params.ErrorResult, len(args.AgentTools)),
150
110
        }
151
111
        for i, agentTools := range args.AgentTools {
152
 
                err := u.setOneAgentTools(agentTools.Tag, agentTools.Tools)
 
112
                err := u.setOneAgentVersion(agentTools.Tag, agentTools.Tools.Version)
153
113
                results.Results[i].Error = common.ServerError(err)
154
114
        }
155
115
        return results, nil
156
116
}
157
117
 
158
 
func (u *UpgraderAPI) setOneAgentTools(tag string, tools *agenttools.Tools) error {
 
118
func (u *UpgraderAPI) setOneAgentVersion(tag string, vers version.Binary) error {
159
119
        if !u.authorizer.AuthOwner(tag) {
160
120
                return common.ErrPerm
161
121
        }
163
123
        if err != nil {
164
124
                return err
165
125
        }
166
 
        return entity.SetAgentTools(tools)
 
126
        return entity.SetAgentVersion(vers)
167
127
}
168
128
 
169
129
func (u *UpgraderAPI) findEntity(tag string) (state.AgentTooler, error) {