// InitPolicyMgr initializes the policy manager
func InitPolicyMgr() error {
ofnetMaster = ofnet.NewOfnetMaster(ofnet.OFNET_MASTER_PORT)
if ofnetMaster == nil {
log.Fatalf("Error creating ofnet master")
}
return nil
}
// RunMasterFsm runs netmaster FSM
func (d *MasterDaemon) RunMasterFsm() {
var err error
// Get the address to be used for local communication
localIP, err := getLocalAddr()
if err != nil {
log.Fatalf("Error getting local IP address. Err: %v", err)
}
// create new ofnet master
d.ofnetMaster = ofnet.NewOfnetMaster(localIP, ofnet.OFNET_MASTER_PORT)
if d.ofnetMaster == nil {
log.Fatalf("Error creating ofnet master")
}
// Register all existing netplugins in the background
go d.agentDiscoveryLoop()
// Create the lock
leaderLock, err = d.objdbClient.NewLock("netmaster/leader", localIP, leaderLockTTL)
if err != nil {
log.Fatalf("Could not create leader lock. Err: %v", err)
}
// Try to acquire the lock
err = leaderLock.Acquire(0)
if err != nil {
// We dont expect any error during acquire.
log.Fatalf("Error while acquiring lock. Err: %v", err)
}
// Initialize the stop channel
d.stopLeaderChan = make(chan bool, 1)
d.stopFollowerChan = make(chan bool, 1)
// set current state
d.currState = "follower"
// Start off being a follower
go d.runFollower()
// Main run loop waiting on leader lock
for {
// Wait for lock events
select {
case event := <-leaderLock.EventChan():
if event.EventType == objdb.LockAcquired {
log.Infof("Leader lock acquired")
d.becomeLeader()
} else if event.EventType == objdb.LockLost {
log.Infof("Leader lock lost. Becoming follower")
d.becomeFollower()
}
}
}
}
// InitPolicyMgr initializes the policy manager
func InitPolicyMgr(stateDriver core.StateDriver) error {
ofnetMaster = ofnet.NewOfnetMaster(ofnet.OFNET_MASTER_PORT)
if ofnetMaster == nil {
log.Fatalf("Error creating ofnet master")
}
stateStore = stateDriver
// restore all existing epg policies
err := restoreEpgPolicies(stateDriver)
if err != nil {
log.Errorf("Error restoring EPG policies. ")
}
return nil
}
// setup the test netmaster REST server and client
func TestMain(m *testing.M) {
var err error
// Setup state store
stateStore, err = initStateDriver()
if err != nil {
log.Fatalf("Error initializing state store. Err: %v", err)
}
// little hack to clear all state from etcd
stateStore.(*state.EtcdStateDriver).Client.Delete("/contiv.io", true)
// Setup resource manager
if _, err = resources.NewStateResourceManager(stateStore); err != nil {
log.Fatalf("Failed to init resource manager. Error: %s", err)
}
router := mux.NewRouter()
// Create a new api controller
apiController = NewAPIController(router)
ofnetMaster := ofnet.NewOfnetMaster(ofnet.OFNET_MASTER_PORT)
if ofnetMaster == nil {
log.Fatalf("Error creating ofnet master")
}
// initialize policy manager
mastercfg.InitPolicyMgr(stateStore, ofnetMaster)
// Create HTTP server
go http.ListenAndServe(netmasterTestListenURL, router)
time.Sleep(time.Second)
// create a new contiv client
contivClient, err = client.NewContivClient(netmasterTestURL)
if err != nil {
log.Fatalf("Error creating contiv client. Err: %v", err)
}
// Create default tenant
createDefaultTenant()
exitCode := m.Run()
if exitCode == 0 {
cleanupState()
}
os.Exit(exitCode)
}
// NewOvsSwitch Creates a new OVS switch instance
func NewOvsSwitch(bridgeName, netType, localIP string) (*OvsSwitch, error) {
var err error
sw := new(OvsSwitch)
sw.bridgeName = bridgeName
sw.netType = netType
// Determine the failure mode
failMode := ""
if netType == "vxlan" {
failMode = "secure"
}
// Create OVS db driver
sw.ovsdbDriver, err = NewOvsdbDriver(bridgeName, failMode)
if err != nil {
log.Fatalf("Error creating ovsdb driver. Err: %v", err)
}
// For Vxlan, initialize ofnet. For VLAN mode, we use OVS normal forwarding
if netType == "vxlan" {
// Create ofnet master
// FIXME: Move ofnet master to netmaster.
sw.ofnetMaster = ofnet.NewOfnetMaster(ofnet.OFNET_MASTER_PORT)
if sw.ofnetMaster == nil {
log.Fatalf("Error creating ofnet master")
}
// Create an ofnet agent
sw.ofnetAgent, err = ofnet.NewOfnetAgent("vxlan", net.ParseIP(localIP),
ofnet.OFNET_AGENT_PORT, 6633)
if err != nil {
log.Fatalf("Error initializing ofnet")
return nil, err
}
// Add controller to the OVS
ctrlerIP := "127.0.0.1"
ctrlerPort := uint16(6633)
target := fmt.Sprintf("tcp:%s:%d", ctrlerIP, ctrlerPort)
if !sw.ovsdbDriver.IsControllerPresent(target) {
err = sw.ovsdbDriver.AddController(ctrlerIP, ctrlerPort)
if err != nil {
log.Fatalf("Error adding controller to OVS. Err: %v", err)
return nil, err
}
}
// Wait a little for master to be ready before we connect
time.Sleep(300 * time.Millisecond)
// Let local ofnet agent connect to local master too.
var resp bool
masterInfo := ofnet.OfnetNode{
HostAddr: localIP,
HostPort: ofnet.OFNET_MASTER_PORT,
}
err = sw.ofnetAgent.AddMaster(&masterInfo, &resp)
if err != nil {
log.Errorf("Error adding %s as ofnet master. Err: %v", localIP, err)
}
log.Infof("Waiting for OVS switch to connect..")
// Wait for a while for OVS switch to connect to ofnet agent
for i := 0; i < 10; i++ {
time.Sleep(1 * time.Second)
if sw.ofnetAgent.IsSwitchConnected() {
break
}
}
log.Infof("Switch connected.")
}
return sw, nil
}