/
init.go
122 lines (105 loc) · 3.11 KB
/
init.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package daemon
import (
"context"
"fmt"
"net"
"strings"
"time"
"github.com/alauda/kube-ovn/pkg/util"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/klog"
)
// InitNodeGateway init ovn0
func InitNodeGateway(config *Configuration) error {
var portName, ip, cidr, macAddr, gw, ipAddr string
for {
nodeName := config.NodeName
node, err := config.KubeClient.CoreV1().Nodes().Get(context.Background(), nodeName, metav1.GetOptions{})
if err != nil {
klog.Errorf("failed to get node %s info %v", nodeName, err)
return err
}
if node.Annotations[util.IpAddressAnnotation] == "" {
klog.Errorf("no ovn0 address for node %s, please check kube-ovn-controller logs", nodeName)
time.Sleep(3 * time.Second)
continue
}
if err := util.ValidatePodNetwork(node.Annotations); err != nil {
klog.Errorf("validate node %s address annotation failed, %v", nodeName, err)
time.Sleep(3 * time.Second)
continue
} else {
macAddr = node.Annotations[util.MacAddressAnnotation]
ip = node.Annotations[util.IpAddressAnnotation]
cidr = node.Annotations[util.CidrAnnotation]
portName = node.Annotations[util.PortNameAnnotation]
gw = node.Annotations[util.GatewayAnnotation]
ipAddr = fmt.Sprintf("%s/%s", ip, strings.Split(cidr, "/")[1])
break
}
}
mac, err := net.ParseMAC(macAddr)
if err != nil {
return fmt.Errorf("failed to parse mac %s %v", mac, err)
}
ipAddr = util.GetIpAddrWithMask(ip, cidr)
return configureNodeNic(portName, ipAddr, gw, mac, config.MTU)
}
func InitMirror(config *Configuration) error {
if config.EnableMirror {
return configureMirror(config.MirrorNic, config.MTU)
} else {
return removeMirror(config.MirrorNic)
}
}
func InitVlan(config *Configuration) error {
if util.IsProviderVlan(config.NetworkType, config.DefaultProviderName) {
//create patch port
exists, err := providerBridgeExists()
if err != nil {
errMsg := fmt.Errorf("check provider bridge exists failed, %v", err)
klog.Error(errMsg)
return err
}
if !exists {
//create br-provider
if err = configProviderPort(config.DefaultProviderName); err != nil {
errMsg := fmt.Errorf("configure patch port br-provider failed %v", err)
klog.Error(errMsg)
return errMsg
}
//add a host nic to br-provider
ifName := config.getInterfaceName()
if ifName == "" {
errMsg := fmt.Errorf("failed get host nic to add ovs br-provider")
klog.Error(errMsg)
return errMsg
}
if err = configProviderNic(ifName); err != nil {
errMsg := fmt.Errorf("add nic %s to port br-provider failed %v", ifName, err)
klog.Error(errMsg)
return errMsg
}
}
}
return nil
}
//get host nic name
func (config *Configuration) getInterfaceName() string {
var interfaceName string
node, err := config.KubeClient.CoreV1().Nodes().Get(context.Background(), config.NodeName, metav1.GetOptions{})
if err == nil {
labels := node.GetLabels()
interfaceName = labels[util.HostInterfaceName]
}
if interfaceName != "" {
return interfaceName
}
if config.DefaultInterfaceName != "" {
return config.DefaultInterfaceName
}
if config.Iface != "" {
return config.Iface
}
return ""
}