func LeaveDatastore() error {
if err := ecc.Leave(); err != nil {
log.Error(err)
return err
}
if err := os.RemoveAll(dataDir); err != nil {
log.Errorf("Error deleting data directory %s", err)
return err
}
return nil
}
func OvsInit() {
var err error
ovs, err = ovs_connect()
if err != nil {
log.Error("Error connecting OVS ", err)
} else {
ovs.Register(notifier{})
}
ContextCache = make(map[string]string)
populateContextCache()
}
func deletePort(ovs *libovsdb.OvsdbClient, bridgeName string, portName string) {
condition := libovsdb.NewCondition("name", "==", portName)
deleteOp := libovsdb.Operation{
Op: "delete",
Table: "Port",
Where: []interface{}{condition},
}
portUuid := portUuidForName(portName)
if portUuid == "" {
log.Error("Unable to find a matching Port : ", portName)
return
}
// Deleting a Bridge row in Bridge table requires mutating the open_vswitch table.
mutateUuid := []libovsdb.UUID{libovsdb.UUID{portUuid}}
mutateSet, _ := libovsdb.NewOvsSet(mutateUuid)
mutation := libovsdb.NewMutation("ports", "delete", 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{deleteOp, mutateOp}
reply, _ := ovs.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, " in ", operations[i])
} else if o.Error != "" {
log.Error("Transaction Failed due to an error :", o.Error)
}
}
}
func AddInternalPort(ovs *libovsdb.OvsdbClient, bridgeName string, portName string, tag uint) error {
namedPortUuid := "port"
namedIntfUuid := "intf"
// intf row to insert
intf := make(map[string]interface{})
intf["name"] = portName
intf["type"] = `internal`
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}
if tag != 0 {
port["tag"] = tag
}
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, _ := ovs.Transact("Open_vSwitch", operations...)
if len(reply) < len(operations) {
log.Error("Number of Replies should be atleast equal to number of Operations")
return errors.New("Number of Replies should be atleast equal to number of Operations")
}
for i, o := range reply {
if o.Error != "" && i < len(operations) {
msg := fmt.Sprintf("Transaction Failed due to an error : %v details: %v in %v", o.Error, o.Details, operations[i])
return errors.New(msg)
} else if o.Error != "" {
msg := fmt.Sprintf("Transaction Failed due to an error : %v", o.Error)
return errors.New(msg)
}
}
return nil
}
func (n notifier) Disconnected(ovsClient *libovsdb.OvsdbClient) {
log.Error("OVS Disconnected. Retrying...")
ovs = nil
go OvsInit()
}
func (d *Daemon) Run(ctx *cli.Context) {
if isDebugEnabled(ctx) {
log.SetLevel(log.DebugLevel)
}
d.bootstrapNode = isBootstrapNode(ctx)
if err := os.Mkdir("/var/run/netns", 0777); err != nil {
fmt.Println("mkdir /var/run/netns failed", err)
}
go ServeAPI(d)
go func() {
var bindInterface string
if ctx.String("iface") != "auto" {
bindInterface = ctx.String("iface")
} else {
intf := d.identifyInterfaceToBind()
if intf != nil {
bindInterface = intf.Name
}
}
if bindInterface != "" {
log.Printf("Binding to %s", bindInterface)
d.clusterListener = bindInterface
} else {
log.Errorf("Unable to identify any Interface to Bind to. Going with Defaults")
}
InitDatastore(bindInterface, d.bootstrapNode)
Bonjour(bindInterface)
if !d.bootstrapNode {
d.serialChan <- true
}
}()
go ClusterRPCHandler(d)
go func() {
if !d.bootstrapNode {
log.Printf("Non-Bootstrap node waiting on peer discovery")
<-d.serialChan
log.Printf("Non-Bootstrap node admitted into cluster")
}
err := CreateBridge()
if err != nil {
log.Error(err.Error)
}
d.populateConnections()
_, err = CreateDefaultNetwork()
if err != nil {
log.Error(err.Error)
}
}()
go ConnectionRPCHandler(d)
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
for _ = range c {
os.Exit(0)
}
}()
select {}
}
