← Back to branch summary

~ubuntu-branches/ubuntu/trusty/juju-core/trusty

« back to all changes in this revision

Viewing changes to src/launchpad.net/juju-core/state/apiserver/usermanager/usermanager.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-03-24 16:05:44 UTC
  • mfrom: (1.1.20)
  • Revision ID: package-import@ubuntu.com-20140324160544-g8lsfufby18d5fj4
Tags: 1.17.6-0ubuntu1
https://launchpad.net/bugs/1271144
https://launchpad.net/bugs/1273769
https://launchpad.net/bugs/1248283
https://launchpad.net/bugs/1276909
https://launchpad.net/bugs/1129720
https://launchpad.net/bugs/1240260
* New upstream point release, including fixes for:
  - br0 not bought up by cloud-init with MAAS provider (LP: #1271144).
  - ppc64el enablement for juju/lxc (LP: #1273769).
  - juju userdata should not restart networking (LP: #1248283).
  - error detecting hardware characteristics (LP: #1276909).
  - juju instances not including the default security group (LP: #1129720).
  - juju bootstrap does not honor https_proxy (LP: #1240260).
* d/control,rules: Drop BD on bash-completion, install bash-completion
  direct from upstream source code.
* d/rules: Set HOME prior to generating man pages.
* d/control: Drop alternative dependency on mongodb-server; juju now only
  works on trusty with juju-mongodb.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/launchpad.net/juju-core/state/apiserver/usermanager/usermanager.go
 
1
// Copyright 2014 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package usermanager
 
5
 
 
6
import (
 
7
        "fmt"
 
8
 
 
9
        "github.com/loggo/loggo"
 
10
 
 
11
        "launchpad.net/juju-core/state"
 
12
        "launchpad.net/juju-core/state/api/params"
 
13
        "launchpad.net/juju-core/state/apiserver/common"
 
14
)
 
15
 
 
16
var logger = loggo.GetLogger("juju.state.apiserver.usermanager")
 
17
 
 
18
// UserManager defines the methods on the usermanager API end point.
 
19
type UserManager interface {
 
20
        AddUser(arg params.EntityPasswords) (params.ErrorResults, error)
 
21
        RemoveUser(arg params.Entities) (params.ErrorResults, error)
 
22
}
 
23
 
 
24
// UserManagerAPI implements the user manager interface and is the concrete
 
25
// implementation of the api end point.
 
26
type UserManagerAPI struct {
 
27
        state       *state.State
 
28
        authorizer  common.Authorizer
 
29
        getCanWrite common.GetAuthFunc
 
30
}
 
31
 
 
32
var _ UserManager = (*UserManagerAPI)(nil)
 
33
 
 
34
func NewUserManagerAPI(
 
35
        st *state.State,
 
36
        authorizer common.Authorizer,
 
37
) (*UserManagerAPI, error) {
 
38
        if !authorizer.AuthClient() {
 
39
                return nil, common.ErrPerm
 
40
        }
 
41
 
 
42
        // TODO(mattyw) - replace stub with real canWrite function
 
43
        getCanWrite := common.AuthAlways(true)
 
44
        return &UserManagerAPI{
 
45
                        state:       st,
 
46
                        authorizer:  authorizer,
 
47
                        getCanWrite: getCanWrite},
 
48
                nil
 
49
}
 
50
 
 
51
func (api *UserManagerAPI) AddUser(args params.EntityPasswords) (params.ErrorResults, error) {
 
52
        result := params.ErrorResults{
 
53
                Results: make([]params.ErrorResult, len(args.Changes)),
 
54
        }
 
55
        if len(args.Changes) == 0 {
 
56
                return result, nil
 
57
        }
 
58
        canWrite, err := api.getCanWrite()
 
59
        if err != nil {
 
60
                result.Results[0].Error = common.ServerError(err)
 
61
                return result, err
 
62
        }
 
63
        for i, arg := range args.Changes {
 
64
                if !canWrite(arg.Tag) {
 
65
                        result.Results[0].Error = common.ServerError(common.ErrPerm)
 
66
                        continue
 
67
                }
 
68
                _, err := api.state.AddUser(arg.Tag, arg.Password)
 
69
                if err != nil {
 
70
                        result.Results[i].Error = common.ServerError(fmt.Errorf("Failed to create user: %s", err))
 
71
                        continue
 
72
                }
 
73
        }
 
74
        return result, nil
 
75
}
 
76
 
 
77
func (api *UserManagerAPI) RemoveUser(args params.Entities) (params.ErrorResults, error) {
 
78
        result := params.ErrorResults{
 
79
                Results: make([]params.ErrorResult, len(args.Entities)),
 
80
        }
 
81
        if len(args.Entities) == 0 {
 
82
                return result, nil
 
83
        }
 
84
        canWrite, err := api.getCanWrite()
 
85
        if err != nil {
 
86
                return result, err
 
87
        }
 
88
        for i, arg := range args.Entities {
 
89
                if !canWrite(arg.Tag) {
 
90
                        result.Results[i].Error = common.ServerError(common.ErrPerm)
 
91
                        continue
 
92
                }
 
93
                user, err := api.state.User(arg.Tag)
 
94
                if err != nil {
 
95
                        result.Results[i].Error = common.ServerError(common.ErrPerm)
 
96
                        continue
 
97
                }
 
98
                err = user.Deactivate()
 
99
                if err != nil {
 
100
                        result.Results[i].Error = common.ServerError(fmt.Errorf("Failed to remove user: %s", err))
 
101
                        continue
 
102
                }
 
103
        }
 
104
        return result, nil
 
105
}