← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/discoverspaces/discoverspaces.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/apiserver/discoverspaces/discoverspaces.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package discoverspaces
 
5
 
 
6
import (
 
7
        "github.com/juju/errors"
 
8
        "github.com/juju/juju/apiserver/common"
 
9
        "github.com/juju/juju/apiserver/common/networkingcommon"
 
10
        "github.com/juju/juju/apiserver/facade"
 
11
        "github.com/juju/juju/apiserver/params"
 
12
        "github.com/juju/juju/state"
 
13
)
 
14
 
 
15
func init() {
 
16
        common.RegisterStandardFacade("DiscoverSpaces", 2, NewDiscoverSpacesAPI)
 
17
}
 
18
 
 
19
// DiscoverSpacesAPI implements the API used by the discoverspaces worker.
 
20
type DiscoverSpacesAPI struct {
 
21
        st         networkingcommon.NetworkBacking
 
22
        resources  facade.Resources
 
23
        authorizer facade.Authorizer
 
24
}
 
25
 
 
26
// NewDiscoverSpacesAPI creates a new instance of the DiscoverSpaces API.
 
27
func NewDiscoverSpacesAPI(st *state.State, resources facade.Resources, authorizer facade.Authorizer) (*DiscoverSpacesAPI, error) {
 
28
        return NewDiscoverSpacesAPIWithBacking(networkingcommon.NewStateShim(st), resources, authorizer)
 
29
}
 
30
 
 
31
func NewDiscoverSpacesAPIWithBacking(st networkingcommon.NetworkBacking, resources facade.Resources, authorizer facade.Authorizer) (*DiscoverSpacesAPI, error) {
 
32
        if !authorizer.AuthModelManager() {
 
33
                return nil, common.ErrPerm
 
34
        }
 
35
        return &DiscoverSpacesAPI{
 
36
                st:         st,
 
37
                authorizer: authorizer,
 
38
                resources:  resources,
 
39
        }, nil
 
40
}
 
41
 
 
42
// ModelConfig returns the current model's configuration.
 
43
func (api *DiscoverSpacesAPI) ModelConfig() (params.ModelConfigResult, error) {
 
44
        result := params.ModelConfigResult{}
 
45
 
 
46
        config, err := api.st.ModelConfig()
 
47
        if err != nil {
 
48
                return result, err
 
49
        }
 
50
        allAttrs := config.AllAttrs()
 
51
        // No need to obscure any secrets as caller needs to be a ModelManager to
 
52
        // call any api methods.
 
53
        result.Config = allAttrs
 
54
        return result, nil
 
55
}
 
56
 
 
57
// CreateSpaces creates a new Juju network space, associating the
 
58
// specified subnets with it (optional; can be empty).
 
59
func (api *DiscoverSpacesAPI) CreateSpaces(args params.CreateSpacesParams) (results params.ErrorResults, err error) {
 
60
        return networkingcommon.CreateSpaces(api.st, args)
 
61
}
 
62
 
 
63
// ListSpaces lists all the available spaces and their associated subnets.
 
64
func (api *DiscoverSpacesAPI) ListSpaces() (results params.DiscoverSpacesResults, err error) {
 
65
        spaces, err := api.st.AllSpaces()
 
66
        if err != nil {
 
67
                return results, errors.Trace(err)
 
68
        }
 
69
 
 
70
        results.Results = make([]params.ProviderSpace, len(spaces))
 
71
        for i, space := range spaces {
 
72
                result := params.ProviderSpace{}
 
73
                result.ProviderId = string(space.ProviderId())
 
74
                result.Name = space.Name()
 
75
 
 
76
                subnets, err := space.Subnets()
 
77
                if err != nil {
 
78
                        err = errors.Annotatef(err, "fetching subnets")
 
79
                        result.Error = common.ServerError(err)
 
80
                        results.Results[i] = result
 
81
                        continue
 
82
                }
 
83
 
 
84
                result.Subnets = make([]params.Subnet, len(subnets))
 
85
                for i, subnet := range subnets {
 
86
                        result.Subnets[i] = networkingcommon.BackingSubnetToParamsSubnet(subnet)
 
87
                }
 
88
                results.Results[i] = result
 
89
        }
 
90
        return results, nil
 
91
}
 
92
 
 
93
// AddSubnets is defined on the API interface.
 
94
func (api *DiscoverSpacesAPI) AddSubnets(args params.AddSubnetsParams) (params.ErrorResults, error) {
 
95
        return networkingcommon.AddSubnets(api.st, args)
 
96
}
 
97
 
 
98
// ListSubnets lists all the available subnets or only those matching
 
99
// all given optional filters.
 
100
func (api *DiscoverSpacesAPI) ListSubnets(args params.SubnetsFilters) (results params.ListSubnetsResults, err error) {
 
101
        return networkingcommon.ListSubnets(api.st, args)
 
102
}