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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
package main
import (
"context"
"flag"
"fmt"
"log"
"github.com/ovn-org/libovsdb/cache"
"github.com/ovn-org/libovsdb/client"
"github.com/ovn-org/libovsdb/example/vswitchd"
"github.com/ovn-org/libovsdb/model"
"github.com/ovn-org/libovsdb/ovsdb"
)
// Silly game that detects creation of Bridge named "stop" and exits
// Just a demonstration of how an app can use libovsdb library to configure and manage OVS
const (
bridgeTable = "Bridge"
ovsTable = "Open_vSwitch"
)
var quit chan bool
var update chan model.Model
var rootUUID string
var connection = flag.String("ovsdb", "unix:/var/run/openvswitch/db.sock", "OVSDB connection string")
func play(ovs client.Client) {
go processInput(ovs)
for model := range update {
bridge := model.(*vswitchd.Bridge)
if bridge.Name == "stop" {
fmt.Printf("Bridge stop detected: %+v\n", *bridge)
ovs.Disconnect()
quit <- true
} else {
fmt.Printf("Current list of bridges:\n")
var bridges []vswitchd.Bridge
if err := ovs.List(context.Background(), &bridges); err != nil {
log.Fatal(err)
}
for _, b := range bridges {
fmt.Printf("UUID: %s Name: %s\n", b.UUID, b.Name)
}
}
}
}
func createBridge(ovs client.Client, bridgeName string) {
bridge := vswitchd.Bridge{
UUID: "gopher",
Name: bridgeName,
}
insertOp, err := ovs.Create(&bridge)
if err != nil {
log.Fatal(err)
}
ovsRow := vswitchd.OpenvSwitch{
UUID: rootUUID,
}
mutateOps, err := ovs.Where(&ovsRow).Mutate(&ovsRow, model.Mutation{
Field: &ovsRow.Bridges,
Mutator: "insert",
Value: []string{bridge.UUID},
})
if err != nil {
log.Fatal(err)
}
operations := append(insertOp, mutateOps...)
reply, err := ovs.Transact(context.TODO(), operations...)
if err != nil {
log.Fatal(err)
}
if _, err := ovsdb.CheckOperationResults(reply, operations); err != nil {
log.Fatal(err)
}
fmt.Println("Bridge Addition Successful : ", reply[0].UUID.GoUUID)
}
func processInput(ovs client.Client) {
for {
fmt.Printf("\n Enter a Bridge Name : ")
var bridgeName string
fmt.Scanf("%s", &bridgeName)
if bridgeName == "" {
continue
}
createBridge(ovs, bridgeName)
}
}
func main() {
flag.Parse()
quit = make(chan bool)
update = make(chan model.Model)
clientDBModel, err := model.NewClientDBModel("Open_vSwitch",
map[string]model.Model{bridgeTable: &vswitchd.Bridge{}, ovsTable: &vswitchd.OpenvSwitch{}})
if err != nil {
log.Fatal("Unable to create DB model ", err)
}
ovs, err := client.NewOVSDBClient(clientDBModel, client.WithEndpoint(*connection))
if err != nil {
log.Fatal(err)
}
err = ovs.Connect(context.Background())
if err != nil {
log.Fatal(err)
}
defer ovs.Disconnect()
ovs.Cache().AddEventHandler(&cache.EventHandlerFuncs{
AddFunc: func(table string, model model.Model) {
if table == bridgeTable {
update <- model
}
},
})
_, err = ovs.Monitor(
context.TODO(),
ovs.NewMonitor(
client.WithTable(&vswitchd.OpenvSwitch{}),
client.WithTable(&vswitchd.Bridge{}),
),
)
if err != nil {
log.Fatal(err)
}
// Get root UUID
for uuid := range ovs.Cache().Table("Open_vSwitch").Rows() {
rootUUID = uuid
}
fmt.Println(`Silly game of stopping this app when a Bridge with name "stop" is monitored !`)
go play(ovs)
<-quit
}
|
