func newInsertSFlowProbeOP(probe OvsSFlowProbe) (*libovsdb.Operation, error) {
sFlowRow := make(map[string]interface{})
sFlowRow["agent"] = probe.Interface
sFlowRow["targets"] = probe.Target
sFlowRow["header"] = probe.HeaderSize
sFlowRow["sampling"] = probe.Sampling
sFlowRow["polling"] = probe.Polling
extIds := make(map[string]string)
extIds["probe-id"] = probe.ID
ovsMap, err := libovsdb.NewOvsMap(extIds)
if err != nil {
return nil, err
}
sFlowRow["external_ids"] = ovsMap
insertOp := libovsdb.Operation{
Op: "insert",
Table: "sFlow",
Row: sFlowRow,
UUIDName: probe.ID,
}
return &insertOp, nil
}
// This does not cover all cases, they should just be added as needed
func newMutation(column, mutator string, value interface{}) mutation {
switch typedValue := value.(type) {
case ovs.UUID:
uuidSlice := []ovs.UUID{typedValue}
mutateValue, _ := ovs.NewOvsSet(uuidSlice)
return ovs.NewMutation(column, mutator, mutateValue)
default:
var mutateValue interface{}
var err error
switch reflect.ValueOf(typedValue).Kind() {
case reflect.Slice:
mutateValue, err = ovs.NewOvsSet(typedValue)
case reflect.Map:
mutateValue, err = ovs.NewOvsMap(typedValue)
default:
panic(fmt.Sprintf(
"unhandled value in mutation: value %s, type %s",
value, typedValue))
}
if err != nil {
return err
}
return ovs.NewMutation(column, mutator, mutateValue)
}
}
// This does not cover all cases, they should just be added as needed
func newMutation(column, mutator string, value interface{}) mutation {
switch typedValue := value.(type) {
case ovs.UUID:
uuidSlice := []ovs.UUID{typedValue}
mutateValue, err := ovs.NewOvsSet(uuidSlice)
if err != nil {
// An error can only occur if the input is not a slice
panic("newMutation(): an impossible error occurred")
}
return ovs.NewMutation(column, mutator, mutateValue)
default:
var mutateValue interface{}
var err error
switch reflect.ValueOf(typedValue).Kind() {
case reflect.Slice:
mutateValue, err = ovs.NewOvsSet(typedValue)
case reflect.Map:
mutateValue, err = ovs.NewOvsMap(typedValue)
default:
panic(fmt.Sprintf(
"unhandled value in mutation: value %s, type %s",
value, typedValue))
}
if err != nil {
return err
}
return ovs.NewMutation(column, mutator, mutateValue)
}
}
func (ovsdber *ovsdber) addVxlanPort(bridgeName string, portName string, peerAddress string) {
namedPortUUID := "port"
namedIntfUUID := "intf"
options := make(map[string]interface{})
options["remote_ip"] = peerAddress
// intf row to insert
intf := make(map[string]interface{})
intf["name"] = portName
intf["type"] = `vxlan`
intf["options"], _ = libovsdb.NewOvsMap(options)
insertIntfOp := libovsdb.Operation{
Op: "insert",
Table: "Interface",
Row: intf,
UUIDName: namedIntfUUID,
}
// port row to insert
port := make(map[string]interface{})
port["name"] = portName
port["interfaces"] = libovsdb.UUID{namedIntfUUID}
insertPortOp := libovsdb.Operation{
Op: "insert",
Table: "Port",
Row: port,
UUIDName: namedPortUUID,
}
// Inserting a row in Port table requires mutating the bridge table.
mutateUUID := []libovsdb.UUID{libovsdb.UUID{namedPortUUID}}
mutateSet, _ := libovsdb.NewOvsSet(mutateUUID)
mutation := libovsdb.NewMutation("ports", "insert", mutateSet)
condition := libovsdb.NewCondition("name", "==", bridgeName)
// simple mutate operation
mutateOp := libovsdb.Operation{
Op: "mutate",
Table: "Bridge",
Mutations: []interface{}{mutation},
Where: []interface{}{condition},
}
operations := []libovsdb.Operation{insertIntfOp, insertPortOp, mutateOp}
reply, _ := ovsdber.ovsdb.Transact("Open_vSwitch", operations...)
if len(reply) < len(operations) {
fmt.Println("Number of Replies should be atleast equal to number of Operations")
}
for i, o := range reply {
if o.Error != "" && i < len(operations) {
fmt.Println("Transaction Failed due to an error :", o.Error, " details:", o.Details, " in ", operations[i])
} else if o.Error != "" {
fmt.Println("Transaction Failed due to an error :", o.Error)
}
}
}
func insertRoute(vrfId uuid.UUID, opsRoute map[string]interface{}) (ovsdb.Operation, error) {
v := []ovsdb.UUID{ovsdb.UUID{vrfId.String()}}
vrfSet, _ := ovsdb.NewOvsSet(v)
opsRoute["vrf"] = vrfSet
nexthop := []ovsdb.UUID{ovsdb.UUID{NEXTHOP_TRANSACT_NUUID}}
nexthopSet, _ := ovsdb.NewOvsSet(nexthop)
opsRoute["bgp_nexthops"] = nexthopSet
attrMap, err := ovsdb.NewOvsMap(opsRoute["path_attributes"])
if err != nil {
return ovsdb.Operation{}, err
}
opsRoute["path_attributes"] = attrMap
insRouteOp := ovsdb.Operation{
Op: "insert",
Table: "BGP_Route",
Row: opsRoute,
UUIDName: ROUTE_TRANSACT_NUUID,
}
return insRouteOp, nil
}
// Silently fails :/
func (ovsdber *ovsdber) addOvsVethPort(bridgeName string, portName string, tag uint) error {
namedPortUUID := "port"
namedIntfUUID := "intf"
// intf row to insert
intf := make(map[string]interface{})
intf["name"] = portName
status := make(map[string]string)
status["driver_name"] = "veth"
status["driver_version"] = "1.0"
statColumn, _ := libovsdb.NewOvsMap(status)
// bridge row to insert
intf["name"] = bridgeName
intf["status"] = statColumn
insertIntfOp := libovsdb.Operation{
Op: "insert",
Table: "Interface",
Row: intf,
UUIDName: namedIntfUUID,
}
// port row to insert
port := make(map[string]interface{})
port["name"] = portName
port["interfaces"] = libovsdb.UUID{namedIntfUUID}
insertPortOp := libovsdb.Operation{
Op: "insert",
Table: "Port",
Row: port,
UUIDName: namedPortUUID,
}
// Inserting a row in Port table requires mutating the bridge table.
mutateUUID := []libovsdb.UUID{libovsdb.UUID{namedPortUUID}}
mutateSet, _ := libovsdb.NewOvsSet(mutateUUID)
mutation := libovsdb.NewMutation("ports", "insert", mutateSet)
condition := libovsdb.NewCondition("name", "==", bridgeName)
// Mutate operation
mutateOp := libovsdb.Operation{
Op: "mutate",
Table: "Bridge",
Mutations: []interface{}{mutation},
Where: []interface{}{condition},
}
operations := []libovsdb.Operation{insertIntfOp, insertPortOp, mutateOp}
reply, _ := ovsdber.ovsdb.Transact("Open_vSwitch", operations...)
if len(reply) < len(operations) {
log.Error("Number of Replies should be atleast equal to number of Operations")
}
for i, o := range reply {
if o.Error != "" && i < len(operations) {
log.Error("Transaction Failed due to an error ]", o.Error, " details:", o.Details, " in ", operations[i])
} else if o.Error != "" {
log.Warn("Transaction Failed due to an error :", o.Error)
}
}
return nil
}
