rancher/types
1
0
Fork 0
mirror of https://github.com/rancher/types.git synced 2025-08-31 21:00:16 +00:00
Code Issues Releases Wiki Activity

Add dnsRecord type

Browse Source
This commit is contained in:
Darren Shepherd
2017-12-28 11:31:33 -07:00
parent 5b4b8b0b24
commit 5773f84304
6 changed files with 57 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

124
apis/project.cattle.io/v3/schema/endpoint_address.go
View File

@@ -1,124 +0,0 @@
package schema
import (
"fmt"
"github.com/rancher/norman/types"
"github.com/rancher/norman/types/convert"
"github.com/rancher/norman/types/mapper"
"k8s.io/api/core/v1"
)
type EndpointAddressMapper struct {
}
func (e EndpointAddressMapper) FromInternal(data map[string]interface{}) {
if data == nil {
return
}
var subsets []v1.EndpointSubset
if err := convert.ToObj(data["subsets"], &subsets); err != nil {
log.Errorf("Failed to convert subset: %v", err)
return
}
var noPortsIPs []string
var noPortsUnavailIPs []string
var podIDs []string
var result []interface{}
for _, subset := range subsets {
var ips []string
var unAvailIPs []string
for _, ip := range subset.Addresses {
if ip.IP != "" {
ips = append(ips, ip.IP)
}
if ip.Hostname != "" {
ips = append(ips, ip.Hostname)
}
if ip.TargetRef != nil && ip.TargetRef.Kind == "Pod" {
podIDs = append(podIDs, fmt.Sprintf("%s:%s", ip.TargetRef.Namespace,
ip.TargetRef.Name))
}
}
for _, ip := range subset.NotReadyAddresses {
if ip.IP != "" {
unAvailIPs = append(ips, ip.IP)
}
if ip.Hostname != "" {
unAvailIPs = append(ips, ip.Hostname)
}
}
if len(subset.Ports) == 0 {
noPortsIPs = append(noPortsIPs, ips...)
noPortsUnavailIPs = append(noPortsIPs, unAvailIPs...)
} else {
for _, port := range subset.Ports {
if len(ips) > 0 {
result = append(result, map[string]interface{}{
"addresses": ips,
"notReadyAddresses": unAvailIPs,
"port": port.Port,
"protocol": port.Protocol,
})
}
}
}
}
if len(noPortsIPs) > 0 {
result = append(result, map[string]interface{}{
"addresses": noPortsIPs,
"notReadyAddresses": noPortsUnavailIPs,
})
}
if len(result) > 0 {
data["targets"] = result
}
if len(podIDs) > 0 {
data["podIds"] = podIDs
}
}
func (e EndpointAddressMapper) ToInternal(data map[string]interface{}) {
if data == nil {
return
}
var addresses []Target
var subsets []v1.EndpointSubset
if err := convert.ToObj(data["targets"], &addresses); err != nil {
log.Errorf("Failed to convert addresses: %v", err)
return
}
for _, address := range addresses {
subset := v1.EndpointSubset{}
for _, ip := range address.Addresses {
subset.Addresses = append(subset.Addresses, v1.EndpointAddress{
IP: ip,
})
}
if address.Port != nil {
subset.Ports = append(subset.Ports, v1.EndpointPort{
Port: *address.Port,
Protocol: v1.Protocol(address.Protocol),
})
}
subsets = append(subsets, subset)
}
if len(subsets) > 0 {
data["subsets"] = subsets
}
}
func (e EndpointAddressMapper) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
mapper.ValidateField("subsets", schema)
delete(schema.ResourceFields, "subsets")
return nil
}

51
apis/project.cattle.io/v3/schema/schema.go
View File

@@ -311,34 +311,45 @@ func podTypes(schemas *types.Schemas) *types.Schemas {
func serviceTypes(schemas *types.Schemas) *types.Schemas {
return schemas.
TypeName("endpoint", v1.Endpoints{}).
TypeName("dnsRecord", v1.Service{}).
AddMapperForType(&Version, v1.ServiceSpec{},
&m.Move{From: "type", To: "serviceKind"},
&m.Move{From: "externalName", To: "hostname"},
&ServiceSpecMapper{},
&m.Drop{Field: "type"},
&m.SetValue{
Field: "clusterIP",
IfEq: "None",
Value: nil,
},
&m.Move{From: "clusterIP", To: "clusterIp"},
ServiceKindMapper{},
).
AddMapperForType(&Version, v1.Service{},
&m.LabelField{Field: "workloadId"},
&m.Drop{Field: "externalIPs"},
&m.Drop{Field: "externalTrafficPolicy"},
&m.Drop{Field: "healthCheckNodePort"},
&m.Drop{Field: "loadBalancerIP"},
&m.Drop{Field: "loadBalancerSourceRanges"},
&m.Drop{Field: "ports"},
&m.Drop{Field: "publishNotReadyAddresses"},
&m.Drop{Field: "sessionAffinity"},
&m.Drop{Field: "sessionAffinityConfig"},
&m.Drop{Field: "status"},
&m.Move{From: "serviceKind", To: "kind"},
&m.AnnotationField{Field: "targetWorkloadIds", Object: true},
&m.AnnotationField{Field: "targetServiceIds", Object: true},
&m.LabelField{Field: "workloadId"},
&m.AnnotationField{Field: "ipAddresses", List: true},
&m.AnnotationField{Field: "targetWorkloadIds", List: true},
&m.AnnotationField{Field: "targetDnsRecordIds", List: true},
).
AddMapperForType(&Version, v1.Endpoints{},
&EndpointAddressMapper{},
).
MustImport(&Version, v1.Service{}, projectOverride{}, struct {
WorkloadID string `json:"workloadId" norman:"type=reference[workload]"`
TargetWorkloadIDs string `json:"targetWorkloadIds" norman:"type=array[reference[workload]]"`
TargetServiceIDs string `json:"targetServiceIds" norman:"type=array[reference[service]]"`
Kind string `json:"kind" norman:"type=enum,options=Alias|ARecord|CName|ClusterIP|NodeIP|LoadBalancer"`
}{}).
MustImportAndCustomize(&Version, v1.Endpoints{}, func(schema *types.Schema) {
schema.CodeName = "Endpoint"
MustImportAndCustomize(&Version, v1.Service{}, func(schema *types.Schema) {
schema.MustCustomizeField("clusterIp", func(f types.Field) types.Field {
f.Create = false
f.Update = false
return f
})
}, projectOverride{}, struct {
Targets []Target `json:"targets"`
PodIDs []string `json:"podIds" norman:"type=array[reference[pod]]"`
IPAddresses []string `json:"ipAddresses"`
WorkloadID string `json:"workloadId" norman:"type=reference[workload],nocreate,noupdate"`
TargetWorkloadIDs string `json:"targetWorkloadIds" norman:"type=array[reference[workload]]"`
TargetDNSRecordIDs string `json:"targetDnsRecordIds" norman:"type=array[reference[dnsRecord]]"`
}{})
}

54
apis/project.cattle.io/v3/schema/service_kind.go
View File

@@ -1,54 +0,0 @@
package schema
import (
"github.com/rancher/norman/types"
"github.com/rancher/norman/types/convert"
)
type ServiceKindMapper struct {
}
func (s ServiceKindMapper) FromInternal(data map[string]interface{}) {
if data == nil {
return
}
targetWorkloadIds := data["targetWorkloadIds"]
targetServiceIds := data["targetServiceIds"]
clusterIP := data["clusterIp"]
hostname := data["hostname"]
if !convert.IsEmpty(targetWorkloadIds) || !convert.IsEmpty(targetServiceIds) {
data["serviceKind"] = "Alias"
} else if !convert.IsEmpty(hostname) {
data["serviceKind"] = "CName"
} else if clusterIP == "None" {
data["serviceKind"] = "ARecord"
}
}
func (s ServiceKindMapper) ToInternal(data map[string]interface{}) {
if data == nil {
return
}
str := convert.ToString(data["serviceKind"])
switch str {
case "Alias":
fallthrough
case "ARecord":
fallthrough
case "CName":
data["serviceKind"] = "ClusterIP"
data["clusterIp"] = "None"
}
if !convert.IsEmpty(data["hostname"]) {
data["kind"] = "ExternalName"
data["clusterIp"] = "None"
}
}
func (s ServiceKindMapper) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
return nil
}

24
apis/project.cattle.io/v3/schema/service_spec_mapper.go Normal file
View File

@@ -0,0 +1,24 @@
package schema
import (
"github.com/rancher/norman/types"
)
type ServiceSpecMapper struct {
}
func (e ServiceSpecMapper) FromInternal(data map[string]interface{}) {
}
func (e ServiceSpecMapper) ToInternal(data map[string]interface{}) {
if data == nil {
return
}
data["clusterIp"] = "None"
data["type"] = "ClusterIP"
}
func (e ServiceSpecMapper) ModifySchema(schema *types.Schema, schemas *types.Schemas) error {
return nil
}

2
apis/project.cattle.io/v3/schema/types.go
View File

@@ -79,7 +79,7 @@ type deployOverride struct {
type projectOverride struct {
types.Namespaced
ProjectID string `norman:"type=reference[/v3/schemas/project]"`
ProjectID string `norman:"type=reference[/v3/schemas/project],noupdate"`
}
type Target struct {

1
mapper/namespace.go
View File

@@ -29,6 +29,7 @@ func (n *NamespaceIDMapper) ModifySchema(schema *types.Schema, schemas *types.Sc
field.Type = "reference[namespace]"
field.Required = true
field.Update = false
schema.ResourceFields["namespace"] = field
n.Move = &mapper.Move{