← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/core/description/space.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/core/description/space.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package description
 
5
 
 
6
import (
 
7
        "github.com/juju/errors"
 
8
        "github.com/juju/schema"
 
9
)
 
10
 
 
11
type spaces struct {
 
12
        Version int      `yaml:"version"`
 
13
        Spaces_ []*space `yaml:"spaces"`
 
14
}
 
15
 
 
16
type space struct {
 
17
        Name_       string `yaml:"name"`
 
18
        Public_     bool   `yaml:"public"`
 
19
        ProviderID_ string `yaml:"provider-id,omitempty"`
 
20
}
 
21
 
 
22
// SpaceArgs is an argument struct used to create a new internal space
 
23
// type that supports the Space interface.
 
24
type SpaceArgs struct {
 
25
        Name       string
 
26
        Public     bool
 
27
        ProviderID string
 
28
}
 
29
 
 
30
func newSpace(args SpaceArgs) *space {
 
31
        return &space{
 
32
                Name_:       args.Name,
 
33
                Public_:     args.Public,
 
34
                ProviderID_: args.ProviderID,
 
35
        }
 
36
}
 
37
 
 
38
// Name implements Space.
 
39
func (s *space) Name() string {
 
40
        return s.Name_
 
41
}
 
42
 
 
43
// Public implements Space.
 
44
func (s *space) Public() bool {
 
45
        return s.Public_
 
46
}
 
47
 
 
48
// ProviderID implements Space.
 
49
func (s *space) ProviderID() string {
 
50
        return s.ProviderID_
 
51
}
 
52
 
 
53
func importSpaces(source map[string]interface{}) ([]*space, error) {
 
54
        checker := versionedChecker("spaces")
 
55
        coerced, err := checker.Coerce(source, nil)
 
56
        if err != nil {
 
57
                return nil, errors.Annotatef(err, "spaces version schema check failed")
 
58
        }
 
59
        valid := coerced.(map[string]interface{})
 
60
 
 
61
        version := int(valid["version"].(int64))
 
62
        importFunc, ok := spaceDeserializationFuncs[version]
 
63
        if !ok {
 
64
                return nil, errors.NotValidf("version %d", version)
 
65
        }
 
66
        sourceList := valid["spaces"].([]interface{})
 
67
        return importSpaceList(sourceList, importFunc)
 
68
}
 
69
 
 
70
func importSpaceList(sourceList []interface{}, importFunc spaceDeserializationFunc) ([]*space, error) {
 
71
        result := make([]*space, 0, len(sourceList))
 
72
        for i, value := range sourceList {
 
73
                source, ok := value.(map[string]interface{})
 
74
                if !ok {
 
75
                        return nil, errors.Errorf("unexpected value for space %d, %T", i, value)
 
76
                }
 
77
                space, err := importFunc(source)
 
78
                if err != nil {
 
79
                        return nil, errors.Annotatef(err, "space %d", i)
 
80
                }
 
81
                result = append(result, space)
 
82
        }
 
83
        return result, nil
 
84
}
 
85
 
 
86
type spaceDeserializationFunc func(map[string]interface{}) (*space, error)
 
87
 
 
88
var spaceDeserializationFuncs = map[int]spaceDeserializationFunc{
 
89
        1: importSpaceV1,
 
90
}
 
91
 
 
92
func importSpaceV1(source map[string]interface{}) (*space, error) {
 
93
        fields := schema.Fields{
 
94
                "name":        schema.String(),
 
95
                "public":      schema.Bool(),
 
96
                "provider-id": schema.String(),
 
97
        }
 
98
        // Some values don't have to be there.
 
99
        defaults := schema.Defaults{
 
100
                "provider-id": "",
 
101
        }
 
102
        checker := schema.FieldMap(fields, defaults)
 
103
 
 
104
        coerced, err := checker.Coerce(source, nil)
 
105
        if err != nil {
 
106
                return nil, errors.Annotatef(err, "space v1 schema check failed")
 
107
        }
 
108
        valid := coerced.(map[string]interface{})
 
109
        // From here we know that the map returned from the schema coercion
 
110
        // contains fields of the right type.
 
111
 
 
112
        return &space{
 
113
                Name_:       valid["name"].(string),
 
114
                Public_:     valid["public"].(bool),
 
115
                ProviderID_: valid["provider-id"].(string),
 
116
        }, nil
 
117
}