← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/core/description/ipaddress.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/core/description/ipaddress.go
10
10
 
11
11
type ipaddresses struct {
12
12
        Version      int          `yaml:"version"`
13
 
        IPAddresses_ []*ipaddress `yaml:"ipaddresses"`
 
13
        IPAddresses_ []*ipaddress `yaml:"ip-addresses"`
14
14
}
15
15
 
16
16
type ipaddress struct {
17
17
        ProviderID_       string   `yaml:"provider-id,omitempty"`
18
 
        DeviceName_       string   `yaml:"devicename"`
19
 
        MachineID_        string   `yaml:"machineid"`
20
 
        SubnetCIDR_       string   `yaml:"subnetcidr"`
21
 
        ConfigMethod_     string   `yaml:"configmethod"`
 
18
        DeviceName_       string   `yaml:"device-name"`
 
19
        MachineID_        string   `yaml:"machine-id"`
 
20
        SubnetCIDR_       string   `yaml:"subnet-cidr"`
 
21
        ConfigMethod_     string   `yaml:"config-method"`
22
22
        Value_            string   `yaml:"value"`
23
 
        DNSServers_       []string `yaml:"dnsservers"`
24
 
        DNSSearchDomains_ []string `yaml:"dnssearchdomains"`
25
 
        GatewayAddress_   string   `yaml:"gatewayaddress"`
 
23
        DNSServers_       []string `yaml:"dns-servers"`
 
24
        DNSSearchDomains_ []string `yaml:"dns-search-domains"`
 
25
        GatewayAddress_   string   `yaml:"gateway-address"`
26
26
}
27
27
 
28
28
// ProviderID implements IPAddress.
99
99
}
100
100
 
101
101
func importIPAddresses(source map[string]interface{}) ([]*ipaddress, error) {
102
 
        checker := versionedChecker("ipaddresses")
 
102
        checker := versionedChecker("ip-addresses")
103
103
        coerced, err := checker.Coerce(source, nil)
104
104
        if err != nil {
105
 
                return nil, errors.Annotatef(err, "ipaddresses version schema check failed")
 
105
                return nil, errors.Annotatef(err, "ip-addresses version schema check failed")
106
106
        }
107
107
        valid := coerced.(map[string]interface{})
108
108
 
111
111
        if !ok {
112
112
                return nil, errors.NotValidf("version %d", version)
113
113
        }
114
 
        sourceList := valid["ipaddresses"].([]interface{})
 
114
        sourceList := valid["ip-addresses"].([]interface{})
115
115
        return importIPAddressList(sourceList, importFunc)
116
116
}
117
117
 
120
120
        for i, value := range sourceList {
121
121
                source, ok := value.(map[string]interface{})
122
122
                if !ok {
123
 
                        return nil, errors.Errorf("unexpected value for ipaddress %d, %T", i, value)
 
123
                        return nil, errors.Errorf("unexpected value for ip-address %d, %T", i, value)
124
124
                }
125
125
                ipaddress, err := importFunc(source)
126
126
                if err != nil {
127
 
                        return nil, errors.Annotatef(err, "ipaddress %d", i)
 
127
                        return nil, errors.Annotatef(err, "ip-address %d", i)
128
128
                }
129
129
                result = append(result, ipaddress)
130
130
        }
139
139
 
140
140
func importIPAddressV1(source map[string]interface{}) (*ipaddress, error) {
141
141
        fields := schema.Fields{
142
 
                "provider-id":      schema.String(),
143
 
                "devicename":       schema.String(),
144
 
                "machineid":        schema.String(),
145
 
                "subnetcidr":       schema.String(),
146
 
                "configmethod":     schema.String(),
147
 
                "value":            schema.String(),
148
 
                "dnsservers":       schema.List(schema.String()),
149
 
                "dnssearchdomains": schema.List(schema.String()),
150
 
                "gatewayaddress":   schema.String(),
 
142
                "provider-id":        schema.String(),
 
143
                "device-name":        schema.String(),
 
144
                "machine-id":         schema.String(),
 
145
                "subnet-cidr":        schema.String(),
 
146
                "config-method":      schema.String(),
 
147
                "value":              schema.String(),
 
148
                "dns-servers":        schema.List(schema.String()),
 
149
                "dns-search-domains": schema.List(schema.String()),
 
150
                "gateway-address":    schema.String(),
151
151
        }
152
152
        // Some values don't have to be there.
153
153
        defaults := schema.Defaults{
157
157
 
158
158
        coerced, err := checker.Coerce(source, nil)
159
159
        if err != nil {
160
 
                return nil, errors.Annotatef(err, "ipaddress v1 schema check failed")
 
160
                return nil, errors.Annotatef(err, "ip address v1 schema check failed")
161
161
        }
162
162
        valid := coerced.(map[string]interface{})
163
 
        dnsserversInterface := valid["dnsservers"].([]interface{})
 
163
        dnsserversInterface := valid["dns-servers"].([]interface{})
164
164
        dnsservers := make([]string, len(dnsserversInterface))
165
165
        for i, d := range dnsserversInterface {
166
166
                dnsservers[i] = d.(string)
167
167
        }
168
 
        dnssearchInterface := valid["dnssearchdomains"].([]interface{})
 
168
        dnssearchInterface := valid["dns-search-domains"].([]interface{})
169
169
        dnssearch := make([]string, len(dnssearchInterface))
170
170
        for i, d := range dnssearchInterface {
171
171
                dnssearch[i] = d.(string)
172
172
        }
173
173
        return &ipaddress{
174
174
                ProviderID_:       valid["provider-id"].(string),
175
 
                DeviceName_:       valid["devicename"].(string),
176
 
                MachineID_:        valid["machineid"].(string),
177
 
                SubnetCIDR_:       valid["subnetcidr"].(string),
178
 
                ConfigMethod_:     valid["configmethod"].(string),
 
175
                DeviceName_:       valid["device-name"].(string),
 
176
                MachineID_:        valid["machine-id"].(string),
 
177
                SubnetCIDR_:       valid["subnet-cidr"].(string),
 
178
                ConfigMethod_:     valid["config-method"].(string),
179
179
                Value_:            valid["value"].(string),
180
180
                DNSServers_:       dnsservers,
181
181
                DNSSearchDomains_: dnssearch,
182
 
                GatewayAddress_:   valid["gatewayaddress"].(string),
 
182
                GatewayAddress_:   valid["gateway-address"].(string),
183
183
        }, nil
184
184
}