Add IsDefaultGateway field to IpAddress

ipaddress.go

@@ -23,6 +23,7 @@ type ipaddress struct {
 	DNSServers_       []string `yaml:"dns-servers"`
 	DNSSearchDomains_ []string `yaml:"dns-search-domains"`
 	GatewayAddress_   string   `yaml:"gateway-address"`
+	IsDefaultGateway_ bool     `yaml:"is-default-gateway"`
 }
 
 // ProviderID implements IPAddress.
@@ -70,6 +71,11 @@ func (i *ipaddress) GatewayAddress() string {
 	return i.GatewayAddress_
 }
 
+// IsDefaultGateway implements IPAddress.
+func (i *ipaddress) IsDefaultGateway() bool {
+	return i.IsDefaultGateway_
+}
+
 // IPAddressArgs is an argument struct used to create a
 // new internal ipaddress type that supports the IPAddress interface.
 type IPAddressArgs struct {
@@ -82,6 +88,7 @@ type IPAddressArgs struct {
 	DNSServers       []string
 	DNSSearchDomains []string
 	GatewayAddress   string
+	IsDefaultGateway bool
 }
 
 func newIPAddress(args IPAddressArgs) *ipaddress {
@@ -95,6 +102,7 @@ func newIPAddress(args IPAddressArgs) *ipaddress {
 		DNSServers_:       args.DNSServers,
 		DNSSearchDomains_: args.DNSSearchDomains,
 		GatewayAddress_:   args.GatewayAddress,
+		IsDefaultGateway_: args.IsDefaultGateway,
 	}
 }
 
@@ -135,6 +143,21 @@ type ipaddressDeserializationFunc func(map[string]interface{}) (*ipaddress, erro
 
 var ipaddressDeserializationFuncs = map[int]ipaddressDeserializationFunc{
 	1: importIPAddressV1,
+	2: importIPAddressV2,
+}
+
+func parseDnsFields(valid map[string]interface{}) ([]string, []string) {
+	dnsserversInterface := valid["dns-servers"].([]interface{})
+	dnsservers := make([]string, len(dnsserversInterface))
+	for i, d := range dnsserversInterface {
+		dnsservers[i] = d.(string)
+	}
+	dnssearchInterface := valid["dns-search-domains"].([]interface{})
+	dnssearch := make([]string, len(dnssearchInterface))
+	for i, d := range dnssearchInterface {
+		dnssearch[i] = d.(string)
+	}
+	return dnsservers, dnssearch
 }
 
 func importIPAddressV1(source map[string]interface{}) (*ipaddress, error) {
@@ -160,16 +183,46 @@ func importIPAddressV1(source map[string]interface{}) (*ipaddress, error) {
 		return nil, errors.Annotatef(err, "ip address v1 schema check failed")
 	}
 	valid := coerced.(map[string]interface{})
-	dnsserversInterface := valid["dns-servers"].([]interface{})
-	dnsservers := make([]string, len(dnsserversInterface))
-	for i, d := range dnsserversInterface {
-		dnsservers[i] = d.(string)
+	dnsservers, dnssearch := parseDnsFields(valid)
+	return &ipaddress{
+		ProviderID_:       valid["provider-id"].(string),
+		DeviceName_:       valid["device-name"].(string),
+		MachineID_:        valid["machine-id"].(string),
+		SubnetCIDR_:       valid["subnet-cidr"].(string),
+		ConfigMethod_:     valid["config-method"].(string),
+		Value_:            valid["value"].(string),
+		DNSServers_:       dnsservers,
+		DNSSearchDomains_: dnssearch,
+		GatewayAddress_:   valid["gateway-address"].(string),
+	}, nil
+}
+
+func importIPAddressV2(source map[string]interface{}) (*ipaddress, error) {
+	fields := schema.Fields{
+		"provider-id":        schema.String(),
+		"device-name":        schema.String(),
+		"machine-id":         schema.String(),
+		"subnet-cidr":        schema.String(),
+		"config-method":      schema.String(),
+		"value":              schema.String(),
+		"dns-servers":        schema.List(schema.String()),
+		"dns-search-domains": schema.List(schema.String()),
+		"gateway-address":    schema.String(),
+		"is-default-gateway": schema.Bool(),
 	}
-	dnssearchInterface := valid["dns-search-domains"].([]interface{})
-	dnssearch := make([]string, len(dnssearchInterface))
-	for i, d := range dnssearchInterface {
-		dnssearch[i] = d.(string)
+	// Some values don't have to be there.
+	defaults := schema.Defaults{
+		"provider-id":        "",
+		"is-default-gateway": false,
 	}
+	checker := schema.FieldMap(fields, defaults)
+
+	coerced, err := checker.Coerce(source, nil)
+	if err != nil {
+		return nil, errors.Annotatef(err, "ip address v1 schema check failed")
+	}
+	valid := coerced.(map[string]interface{})
+	dnsservers, dnssearch := parseDnsFields(valid)
 	return &ipaddress{
 		ProviderID_:       valid["provider-id"].(string),
 		DeviceName_:       valid["device-name"].(string),
@@ -180,5 +233,6 @@ func importIPAddressV1(source map[string]interface{}) (*ipaddress, error) {
 		DNSServers_:       dnsservers,
 		DNSSearchDomains_: dnssearch,
 		GatewayAddress_:   valid["gateway-address"].(string),
+		IsDefaultGateway_: valid["is-default-gateway"].(bool),
 	}, nil
 }

ipaddress_test.go

@@ -38,6 +38,7 @@ func (s *IPAddressSerializationSuite) TestNewIPAddress(c *gc.C) {
 		DNSServers:       []string{"10.1.0.1", "10.2.0.1"},
 		DNSSearchDomains: []string{"bam", "mam"},
 		GatewayAddress:   "10.0.0.1",
+		IsDefaultGateway: true,
 	}
 	address := newIPAddress(args)
 	c.Assert(address.SubnetCIDR(), gc.Equals, args.SubnetCIDR)
@@ -49,9 +50,10 @@ func (s *IPAddressSerializationSuite) TestNewIPAddress(c *gc.C) {
 	c.Assert(address.DNSServers(), jc.DeepEquals, args.DNSServers)
 	c.Assert(address.DNSSearchDomains(), jc.DeepEquals, args.DNSSearchDomains)
 	c.Assert(address.GatewayAddress(), gc.Equals, args.GatewayAddress)
+	c.Assert(address.IsDefaultGateway(), gc.Equals, args.IsDefaultGateway)
 }
 
-func (s *IPAddressSerializationSuite) TestParsingSerializedData(c *gc.C) {
+func (s *IPAddressSerializationSuite) TestParsingSerializedDataV1(c *gc.C) {
 	initial := ipaddresses{
 		Version: 1,
 		IPAddresses_: []*ipaddress{
@@ -82,3 +84,36 @@ func (s *IPAddressSerializationSuite) TestParsingSerializedData(c *gc.C) {
 
 	c.Assert(addresses, jc.DeepEquals, initial.IPAddresses_)
 }
+
+func (s *IPAddressSerializationSuite) TestParsingSerializedDataV2(c *gc.C) {
+	initial := ipaddresses{
+		Version: 2,
+		IPAddresses_: []*ipaddress{
+			newIPAddress(IPAddressArgs{
+				SubnetCIDR:       "10.0.0.0/24",
+				ProviderID:       "magic",
+				DeviceName:       "foo",
+				MachineID:        "bar",
+				ConfigMethod:     "static",
+				Value:            "10.0.0.4",
+				DNSServers:       []string{"10.1.0.1", "10.2.0.1"},
+				DNSSearchDomains: []string{"bam", "mam"},
+				GatewayAddress:   "10.0.0.1",
+				IsDefaultGateway: true,
+			}),
+			newIPAddress(IPAddressArgs{Value: "10.0.0.5"}),
+		},
+	}
+
+	bytes, err := yaml.Marshal(initial)
+	c.Assert(err, jc.ErrorIsNil)
+
+	var source map[string]interface{}
+	err = yaml.Unmarshal(bytes, &source)
+	c.Assert(err, jc.ErrorIsNil)
+
+	addresses, err := importIPAddresses(source)
+	c.Assert(err, jc.ErrorIsNil)
+
+	c.Assert(addresses, jc.DeepEquals, initial.IPAddresses_)
+}

model.go

@@ -505,7 +505,7 @@ func (m *model) AddIPAddress(args IPAddressArgs) IPAddress {
 
 func (m *model) setIPAddresses(addressesList []*ipaddress) {
 	m.IPAddresses_ = ipaddresses{
-		Version:      1,
+		Version:      2,
 		IPAddresses_: addressesList,
 	}
 }

model_test.go

@@ -561,11 +561,12 @@ func (s *ModelSerializationSuite) TestModelValidationChecksAddressGatewayAddress
 func (s *ModelSerializationSuite) TestModelValidationChecksAddressGatewayAddressValid(c *gc.C) {
 	model := s.newModel(ModelArgs{Owner: names.NewUserTag("owner")})
 	args := IPAddressArgs{
-		MachineID:      "42",
-		DeviceName:     "foo",
-		Value:          "192.168.1.2",
-		SubnetCIDR:     "192.168.1.0/24",
-		GatewayAddress: "192.168.1.1",
+		MachineID:        "42",
+		DeviceName:       "foo",
+		Value:            "192.168.1.2",
+		SubnetCIDR:       "192.168.1.0/24",
+		GatewayAddress:   "192.168.1.1",
+		IsDefaultGateway: true,
 	}
 	model.AddIPAddress(args)
 	s.addMachineToModel(model, "42")