VOL-1305 Separation of DHCP/AAA emulation part from OLT/ONUs emulation part
Change-Id: Idd2c6fb9bee7b7dca967b9bd49f6189343d1357f
diff --git a/bbsim.go b/bbsim.go
index a25d4ec..13f95f1 100644
--- a/bbsim.go
+++ b/bbsim.go
@@ -17,20 +17,12 @@
package main
import (
- "flag"
- "fmt"
- "log"
- "os"
- "os/signal"
- "strconv"
- "strings"
- "sync"
- "time"
- "gerrit.opencord.org/voltha-bbsim/common"
"gerrit.opencord.org/voltha-bbsim/core"
- "gerrit.opencord.org/voltha-bbsim/protos"
+ "log"
)
+
+
func printBanner() {
log.Println(" ________ _______ ________ ")
log.Println(" / ____ | / ____ | / ______/ __ ")
@@ -40,64 +32,11 @@
log.Println("/________/ /________/ /________/ /_/ /_/ /_/ /_/ ")
}
-func getOptions() (uint32, string, uint32, uint32, uint32, int, int, string, int, core.Mode) {
- addressport := flag.String("H", ":50060", "IP address:port")
- oltid := flag.Int("id", 0, "OLT-ID")
- nintfs := flag.Int("i", 1, "Number of PON-IF ports")
- nonus := flag.Int("n", 1, "Number of ONUs per PON-IF port")
- modeopt := flag.String("m", "default", "Emulation mode (default, aaa, both (aaa & dhcp))")
- aaawait := flag.Int("a", 30, "Wait time (sec) for activation WPA supplicants")
- dhcpwait := flag.Int("d", 10, "Wait time (sec) for activation DHCP clients")
- dhcpservip := flag.String("s", "182.21.0.1", "DHCP Server IP Address")
- delay := flag.Int("delay", 1, "Delay between ONU events")
- mode := core.DEFAULT
- flag.Parse()
- if *modeopt == "aaa" {
- mode = core.AAA
- } else if *modeopt == "both" {
- mode = core.BOTH
- }
- address := strings.Split(*addressport, ":")[0]
- tmp, _ := strconv.Atoi(strings.Split(*addressport, ":")[1])
- port := uint32(tmp)
- return uint32(*oltid), address, port, uint32(*nintfs), uint32(*nonus), *aaawait, *dhcpwait, *dhcpservip, *delay, mode
-}
-
func main() {
// CLI Shows up
printBanner()
- oltid, ip, port, npon, nonus, aaawait, dhcpwait, dhcpservip, delay, mode := getOptions()
- logger.Debug("ip:%s, baseport:%d, npon:%d, nonus:%d, mode:%d\n", ip, port, npon, nonus, mode)
+ opt := core.GetOptions()
- // Set up gRPC Server
- var wg sync.WaitGroup
-
- addressport := ip + ":" + strconv.Itoa(int(port))
- endchan := make(chan int, 1)
- listener, gserver, err := core.CreateGrpcServer(oltid, npon, nonus, addressport)
- server := core.Create(oltid, npon, nonus, aaawait, dhcpwait, dhcpservip, delay, gserver, mode, endchan)
- if err != nil {
- logger.Error("Failed to create gRPC server", err)
- }
- openolt.RegisterOpenoltServer(gserver, server)
-
- wg.Add(1)
- go func() {
- defer wg.Done()
- gserver.Serve(listener)
- }()
-
- c := make(chan os.Signal, 1)
- signal.Notify(c, os.Interrupt)
- go func() {
- for sig := range c {
- fmt.Println("SIGINT", sig)
- close(c)
- close(server.Endchan)
- gserver.Stop()
- }
- }()
- wg.Wait()
- time.Sleep(5 * time.Second)
- logger.Debug("Reach to the end line")
+ mediator := core.NewMediator(opt)
+ mediator.Start()
}
diff --git a/common/logger.go b/common/logger.go
index b2701e1..c707601 100644
--- a/common/logger.go
+++ b/common/logger.go
@@ -17,36 +17,36 @@
package logger
import (
- "strings"
"log"
+ "strings"
)
-func Error(s string, opts ...interface{}){
+func Error(s string, opts ...interface{}) {
trimmed := strings.TrimRight(s, "\n")
- if len(opts) == 0{
+ if len(opts) == 0 {
log.Printf("[ERROR]:%s\n", trimmed)
- }else{
+ } else {
fmt := "[ERROR]:" + trimmed + "\n"
log.Printf(fmt, opts...)
}
}
-func Debug(s string, opts ...interface{}){
+func Debug(s string, opts ...interface{}) {
trimmed := strings.TrimRight(s, "\n")
- if len(opts) == 0{
+ if len(opts) == 0 {
log.Printf("[DEBUG]:%s\n", trimmed)
- }else{
+ } else {
fmt := "[DEBUG]:" + trimmed + "\n"
log.Printf(fmt, opts...)
}
}
-func Info(s string, opts ...interface{}){
+func Info(s string, opts ...interface{}) {
trimmed := strings.TrimRight(s, "\n")
- if len(opts) == 0{
+ if len(opts) == 0 {
log.Printf("[INFO]:%s\n", trimmed)
- }else{
+ } else {
fmt := "[INFO]:" + trimmed + "\n"
log.Printf(fmt, opts...)
}
-}
\ No newline at end of file
+}
diff --git a/core/core_server.go b/core/core_server.go
index bb02c17..0e0ea1b 100644
--- a/core/core_server.go
+++ b/core/core_server.go
@@ -17,46 +17,43 @@
package core
import (
+ "context"
"errors"
- "strconv"
- "sync"
- "time"
+ "gerrit.opencord.org/voltha-bbsim/common"
"gerrit.opencord.org/voltha-bbsim/device"
"gerrit.opencord.org/voltha-bbsim/protos"
- "gerrit.opencord.org/voltha-bbsim/common"
- "gerrit.opencord.org/voltha-bbsim/setup"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/google/gopacket/pcap"
"google.golang.org/grpc"
+ "strconv"
+ "sync"
)
-type Mode int
-
-const MAX_ONUS_PER_PON = 64 // This value should be the same with the value in AdapterPlatrorm class
-
const (
- DEFAULT Mode = iota
- AAA
- BOTH
+ UNI_VETH_UP_PFX = "sim_uu"
+ UNI_VETH_DW_PFX = "sim_ud"
+ NNI_VETH_UP_PFX = "sim_nu"
+ NNI_VETH_DW_PFX = "sim_nd"
+ MAX_ONUS_PER_PON = 64 // This value should be the same with the value in AdapterPlatrorm class
)
type Server struct {
+ wg *sync.WaitGroup
Olt *device.Olt
Onumap map[uint32][]*device.Onu
Ioinfos []*Ioinfo
- Endchan chan int
- Mode Mode
- AAAWait int
- DhcpWait int
- DhcpServerIP string
- Delay int
gRPCserver *grpc.Server
- VethEnv []string
- TestFlag bool
+ gRPCAddress string
+ gRPCPort uint32
+ Vethnames []string
+ IndInterval int
Processes []string
EnableServer *openolt.Openolt_EnableIndicationServer
CtagMap map[string]uint32
+ cancel context.CancelFunc
+ state coreState
+ stateChan chan coreState
}
type Packet struct {
@@ -64,51 +61,142 @@
Pkt gopacket.Packet
}
-func (s *Server) Initialize() {
- s.VethEnv = []string{}
- s.Endchan = make(chan int)
- s.TestFlag = false
- s.Processes = []string{}
- s.Ioinfos = []*Ioinfo{}
-}
+type coreState int
-func Create(oltid uint32, npon uint32, nonus uint32, aaawait int, dhcpwait int, ip string, delay int, g *grpc.Server, mode Mode, e chan int) *Server {
- s := new(Server)
- s.Olt = device.CreateOlt(oltid, npon, 1)
+const (
+ INACTIVE = iota // OLT/ONUs are not instantiated
+ PRE_ACTIVE // Before PacketInDaemon Running
+ ACTIVE // After PacketInDaemon Running
+)
+
+/* coreState
+INACTIVE -> PRE_ACTIVE -> ACTIVE
+ (ActivateOLT) (Enable)
+ <- <-
+ */
+
+
+func NewCore(opt *option) (*Server) {
+ // TODO: make it decent
+ oltid := opt.oltid
+ npon := opt.npon
+ nonus := opt.nonus
+ s := Server{
+ Olt: device.NewOlt(oltid, npon, 1),
+ Onumap: make(map[uint32][]*device.Onu),
+ Ioinfos: []*Ioinfo{},
+ gRPCAddress: opt.address,
+ gRPCPort: opt.port,
+ Vethnames: []string{},
+ IndInterval: opt.intvl,
+ Processes: []string{},
+ EnableServer: new(openolt.Openolt_EnableIndicationServer),
+ state: INACTIVE,
+ stateChan: make(chan coreState, 8),
+ }
+
nnni := s.Olt.NumNniIntf
logger.Info("OLT ID: %d was retrieved.\n", s.Olt.ID)
- s.Onumap = make(map[uint32][]*device.Onu)
- s.AAAWait = aaawait
- s.DhcpWait = dhcpwait
- s.DhcpServerIP = ip
- s.gRPCserver = g
- s.Delay = delay
- s.Mode = mode
- s.Endchan = e
- s.VethEnv = []string{}
- s.TestFlag = false
for intfid := nnni; intfid < npon+nnni; intfid++ {
- s.Onumap[intfid] = device.CreateOnus(oltid, intfid, nonus, nnni)
+ s.Onumap[intfid] = device.NewOnus(oltid, intfid, nonus, nnni)
}
- s.EnableServer = new(openolt.Openolt_EnableIndicationServer)
- //TODO: To be fixed
+ //TODO: To be fixed because it is hardcoded
s.CtagMap = make(map[string]uint32)
for i := 0; i < MAX_ONUS_PER_PON; i++ {
oltid := s.Olt.ID
intfid := uint32(1)
- sn := convB2S(device.CreateSN(oltid, intfid, uint32(i)))
+ sn := convB2S(device.NewSN(oltid, intfid, uint32(i)))
s.CtagMap[sn] = uint32(900 + i) // This is hard coded for BBWF
}
- return s
+ return &s
+}
+
+//Blocking
+func (s *Server) Start () error {
+ s.wg = &sync.WaitGroup{}
+ logger.Debug("Start() Start")
+ defer func(){
+ close(s.stateChan)
+ logger.Debug("Start() Done")
+ }()
+ addressport := s.gRPCAddress + ":" + strconv.Itoa(int(s.gRPCPort))
+ listener, gserver, err := NewGrpcServer(addressport)
+ if err != nil {
+ logger.Error("Failed to create gRPC server", err)
+ return err
+ }
+ s.gRPCserver = gserver
+ openolt.RegisterOpenoltServer(gserver, s)
+ if err := gserver.Serve(listener); err != nil {
+ logger.Error("Failed to run gRPC server", err)
+ return err
+ }
+ s.wg.Wait()
+ return nil
+}
+
+//Non-Blocking
+func (s *Server) Stop () {
+ logger.Debug("Stop() Start")
+ defer logger.Debug("Stop() Done")
+ if s.gRPCserver != nil {
+ s.gRPCserver.Stop()
+ logger.Debug("gRPCserver.Stop()")
+ }
+ s.StopPktInDaemon()
+ return
+}
+
+// Blocking
+func (s *Server) Enable(sv *openolt.Openolt_EnableIndicationServer) error {
+ defer func(){
+ olt := s.Olt
+ olt.InitializeStatus()
+ for intfid, _ := range s.Onumap {
+ for _, onu := range s.Onumap[intfid] {
+ onu.InitializeStatus()
+ }
+ }
+ s.updateState(INACTIVE)
+ logger.Debug("Enable() Done")
+ }()
+ logger.Debug("Enable() Start")
+ s.EnableServer = sv
+ if err := s.activateOLT(*sv); err != nil {
+ return err
+ }
+ s.updateState(PRE_ACTIVE)
+
+ coreCtx := context.Background()
+ coreCtx, corecancel := context.WithCancel(coreCtx)
+ s.cancel = corecancel
+ if err := s.StartPktInDaemon(coreCtx, *sv) ; err != nil {
+ return err
+ }
+ return nil
+}
+
+//Non-Blocking
+func (s *Server) Disable() {
+ defer func(){
+ logger.Debug("Disable() Done")
+ }()
+ logger.Debug("Disable() Start")
+ s.StopPktInDaemon()
+}
+
+func (s *Server) updateState(state coreState){
+ s.state = state
+ s.stateChan <- state
+ logger.Debug("State updated to:%d", state)
}
func (s *Server) activateOLT(stream openolt.Openolt_EnableIndicationServer) error {
+ defer logger.Debug("activateOLT() Done")
+ logger.Debug("activateOLT() Start")
// Activate OLT
olt := s.Olt
- oltid := olt.ID
- wg := &sync.WaitGroup{}
-
if err := sendOltIndUp(stream, olt); err != nil {
return err
}
@@ -144,87 +232,59 @@
// OLT Sends OnuInd after waiting all of those ONUs up
for {
- if s.IsAllOnuActive(s.Onumap) {
+ if IsAllOnuActive(s.Onumap) {
+ logger.Debug("All the Onus are Activated.")
break
}
}
for intfid, _ := range s.Onumap {
- sendOnuInd(stream, s.Onumap[intfid], s.Delay)
+ sendOnuInd(stream, s.Onumap[intfid], s.IndInterval)
logger.Info("OLT id:%d sent ONUInd.\n", olt.ID)
}
-
- if s.Mode == DEFAULT {
- //EnableIndication's stream should be kept even after activateOLT() is finished.
- //Otherwise, OpenOLT adapter sends EnableIndication again.
- <-s.Endchan
- logger.Debug("core server thread receives close ")
- } else if s.Mode == AAA || s.Mode == BOTH {
- s.TestFlag = true
- var err error
- s.Ioinfos, s.VethEnv, err = createIoinfos(oltid, s.VethEnv, s.Onumap)
- logger.Debug("s.VethEnv:%v", s.VethEnv)
- if err != nil {
- return err
- }
-
- errchan := make(chan error)
- go func() {
- <-errchan
- close(s.Endchan)
- }()
-
- wg.Add(1)
- go func() {
- defer func() {
- logger.Debug("runPacketInDaemon Done")
- wg.Done()
- }()
-
- err := s.runPacketInDaemon(stream)
- if err != nil {
- errchan <- err
- return
- }
- }()
-
- wg.Add(1)
- go func() {
- defer func() {
- logger.Debug("exeAAATest Done")
- wg.Done()
- }()
-
- err = s.exeAAATest()
- if err != nil {
- errchan <- err
- return
- }
-
- if s.Mode == BOTH {
- go func() {
- defer func() {
- logger.Debug("exeDHCPTest Done")
- }()
-
- err := s.exeDHCPTest()
- if err != nil {
- errchan <- err
- return
- }
- }()
- }
- }()
- wg.Wait()
- cleanUpVeths(s.VethEnv) // Grace teardown
- pnames := s.Processes
- killProcesses(pnames)
- logger.Debug("Grace shutdown down")
- }
return nil
}
-func createIoinfos(oltid uint32, vethenv []string, onumap map[uint32][]*device.Onu) ([]*Ioinfo, []string, error) {
+
+// Blocking
+func (s *Server) StartPktInDaemon(ctx context.Context, stream openolt.Openolt_EnableIndicationServer) error {
+ logger.Debug("StartPktInDaemon() Start")
+ defer func(){
+ RemoveVeths(s.Vethnames)
+ s.Vethnames = []string{}
+ s.Ioinfos = []*Ioinfo{}
+ s.wg.Done()
+ s.updateState(PRE_ACTIVE)
+ logger.Debug("StartPktInDaemon() Done")
+ }()
+ s.wg.Add(1)
+ ioinfos, veths, err := createIoinfos(s.Olt.ID, s.Vethnames, s.Onumap)
+ if err != nil {
+ return err
+ }
+ s.Ioinfos = ioinfos
+ s.Vethnames = veths
+ logger.Debug("Created vethnames:%v", s.Vethnames)
+
+ parent := ctx
+ child, cancel := context.WithCancel(parent)
+ s.cancel = cancel
+
+ if err = s.runPacketInDaemon(child, stream); err != nil {
+ return err
+ }
+ return nil
+}
+
+//Non-Blocking
+func (s *Server) StopPktInDaemon() {
+ if s.cancel != nil {
+ cancel := s.cancel
+ cancel()
+ }
+}
+
+func createIoinfos(oltid uint32, Vethnames []string, onumap map[uint32][]*device.Onu) ([]*Ioinfo, []string, error) {
ioinfos := []*Ioinfo{}
var err error
for intfid, _ := range onumap {
@@ -232,36 +292,37 @@
var handler *pcap.Handle
onuid := onumap[intfid][i].OnuID
uniup, unidw := makeUniName(oltid, intfid, onuid)
- if handler, vethenv, err = setupVethHandler(uniup, unidw, vethenv); err != nil {
- return ioinfos, vethenv, err
+ if handler, Vethnames, err = setupVethHandler(uniup, unidw, Vethnames); err != nil {
+ return ioinfos, Vethnames, err
}
- iinfo := Ioinfo{name: uniup, iotype: "uni", ioloc: "inside", intfid: intfid, onuid: onuid, handler: handler}
+ iinfo := Ioinfo{Name: uniup, iotype: "uni", ioloc: "inside", intfid: intfid, onuid: onuid, handler: handler}
ioinfos = append(ioinfos, &iinfo)
- oinfo := Ioinfo{name: unidw, iotype: "uni", ioloc: "outside", intfid: intfid, onuid: onuid, handler: nil}
+ oinfo := Ioinfo{Name: unidw, iotype: "uni", ioloc: "outside", intfid: intfid, onuid: onuid, handler: nil}
ioinfos = append(ioinfos, &oinfo)
}
}
var handler *pcap.Handle
nniup, nnidw := makeNniName(oltid)
- if handler, vethenv, err = setupVethHandler(nniup, nnidw, vethenv); err != nil {
- return ioinfos, vethenv, err
+ if handler, Vethnames, err = setupVethHandler(nniup, nnidw, Vethnames); err != nil {
+ return ioinfos, Vethnames, err
}
- iinfo := Ioinfo{name: nnidw, iotype: "nni", ioloc: "inside", intfid: 1, handler: handler}
+ iinfo := Ioinfo{Name: nnidw, iotype: "nni", ioloc: "inside", intfid: 1, handler: handler}
ioinfos = append(ioinfos, &iinfo)
- oinfo := Ioinfo{name: nniup, iotype: "nni", ioloc: "outside", intfid: 1, handler: nil}
+ oinfo := Ioinfo{Name: nniup, iotype: "nni", ioloc: "outside", intfid: 1, handler: nil}
ioinfos = append(ioinfos, &oinfo)
- return ioinfos, vethenv, nil
+ return ioinfos, Vethnames, nil
}
-func (s *Server) runPacketInDaemon(stream openolt.Openolt_EnableIndicationServer) error {
+//Blocking
+func (s *Server) runPacketInDaemon(ctx context.Context, stream openolt.Openolt_EnableIndicationServer) error {
logger.Debug("runPacketInDaemon Start")
+ defer logger.Debug("runPacketInDaemon Done")
unichannel := make(chan Packet, 2048)
- flag := false
for intfid, _ := range s.Onumap {
- for _, onu := range s.Onumap[intfid] { //TODO: should be updated for multiple-Interface
+ for _, onu := range s.Onumap[intfid] {
onuid := onu.OnuID
ioinfo, err := s.identifyUniIoinfo("inside", intfid, onuid)
if err != nil {
@@ -269,21 +330,20 @@
return err
}
uhandler := ioinfo.handler
- defer uhandler.Close()
go RecvWorker(ioinfo, uhandler, unichannel)
}
}
- ioinfo, err := s.identifyNniIoinfo("inside")
+ ioinfo, err := s.IdentifyNniIoinfo("inside")
if err != nil {
return err
}
nhandler := ioinfo.handler
- defer nhandler.Close()
nnichannel := make(chan Packet, 32)
go RecvWorker(ioinfo, nhandler, nnichannel)
data := &openolt.Indication_PktInd{}
+ s.updateState(ACTIVE)
for {
select {
case unipkt := <-unichannel:
@@ -309,7 +369,7 @@
logger.Debug("Received upstream packet is DHCP.")
//C-TAG
- onu, _ := s.getOnuByID(onuid)
+ onu, _ := getOnuByID(s.Onumap, onuid)
sn := convB2S(onu.SerialNumber.VendorSpecific)
if ctag, ok := s.CtagMap[sn]; ok == true {
tagpkt, err := PushVLAN(pkt, uint16(ctag))
@@ -348,90 +408,12 @@
return err
}
- case <-s.Endchan:
- if flag == false {
- logger.Debug("PacketInDaemon thread receives close ")
- close(unichannel)
- logger.Debug("Closed unichannel ")
- close(nnichannel)
- logger.Debug("Closed nnichannel ")
- flag = true
- return nil
- }
- }
- }
- return nil
-}
-
-func (s *Server) exeAAATest() error {
- logger.Info("exeAAATest stands by....")
- infos, err := s.getUniIoinfos("outside")
- if err != nil {
- return err
- }
-
- univeths := []string{}
- for _, info := range infos {
- univeths = append(univeths, info.name)
- }
-
- for {
- select {
- case <-s.Endchan:
- logger.Debug("exeAAATest thread receives close ")
- return nil
- case <-time.After(time.Second * time.Duration(s.AAAWait)):
- err = setup.ActivateWPASups(univeths, s.Delay)
- if err != nil {
- return err
- }
- logger.Info("WPA Supplicants are successfully activated ")
- s.Processes = append(s.Processes, "wpa_supplicant")
- logger.Debug("Running Process:%v", s.Processes)
- return nil
- }
- }
- return nil
-}
-
-func (s *Server) exeDHCPTest() error {
- logger.Info("exeDHCPTest stands by....")
- info, err := s.identifyNniIoinfo("outside")
-
- if err != nil {
- return err
- }
-
- err = setup.ActivateDHCPServer(info.name, s.DhcpServerIP)
- if err != nil {
- return err
- }
- s.Processes = append(s.Processes, "dhcpd")
- logger.Debug("Running Process:%v", s.Processes)
-
- infos, err := s.getUniIoinfos("outside")
- if err != nil {
- return err
- }
-
- univeths := []string{}
- for _, info := range infos {
- univeths = append(univeths, info.name)
- }
-
- for {
- select {
- case <-s.Endchan:
- logger.Debug("exeDHCPTest thread receives close ")
- return nil
- case <-time.After(time.Second * time.Duration(s.DhcpWait)):
- err = setup.ActivateDHCPClients(univeths, s.Delay)
- if err != nil {
- return err
- }
- logger.Info("DHCP clients are successfully activated ")
- s.Processes = append(s.Processes, "dhclient")
- logger.Debug("Running Process:%v", s.Processes)
+ case <-ctx.Done():
+ logger.Debug("PacketInDaemon thread receives close ")
+ close(unichannel)
+ logger.Debug("Closed unichannel ")
+ close(nnichannel)
+ logger.Debug("Closed nnichannel ")
return nil
}
}
@@ -473,7 +455,7 @@
logger.Error("%s", err)
return err
}
- ioinfo, err := s.identifyNniIoinfo("inside")
+ ioinfo, err := s.IdentifyNniIoinfo("inside")
if err != nil {
return err
}
@@ -482,8 +464,8 @@
return nil
}
-func (s *Server) IsAllOnuActive(regonus map[uint32][]*device.Onu) bool {
- for _, onus := range regonus {
+func IsAllOnuActive(onumap map[uint32][]*device.Onu) bool {
+ for _, onus := range onumap {
for _, onu := range onus {
if onu.GetIntStatus() != device.ONU_ACTIVATED {
return false
@@ -499,8 +481,8 @@
//return uint32(1032 + 8 * (vid - 1)), nil
}
-func (s *Server) getOnuBySN(sn *openolt.SerialNumber) (*device.Onu, error) {
- for _, onus := range s.Onumap {
+func getOnuBySN(onumap map[uint32][]*device.Onu, sn *openolt.SerialNumber) (*device.Onu, error) {
+ for _, onus := range onumap {
for _, onu := range onus {
if device.ValidateSN(*sn, *onu.SerialNumber) {
return onu, nil
@@ -512,8 +494,8 @@
return nil, err
}
-func (s *Server) getOnuByID(onuid uint32) (*device.Onu, error) {
- for _, onus := range s.Onumap {
+func getOnuByID(onumap map[uint32][]*device.Onu, onuid uint32) (*device.Onu, error) {
+ for _, onus := range onumap {
for _, onu := range onus {
if onu.OnuID == onuid {
return onu, nil
@@ -525,65 +507,6 @@
return nil, err
}
-func makeUniName(oltid uint32, intfid uint32, onuid uint32) (upif string, dwif string) {
- upif = setup.UNI_VETH_UP_PFX + strconv.Itoa(int(oltid)) + "_" + strconv.Itoa(int(intfid)) + "_" + strconv.Itoa(int(onuid))
- dwif = setup.UNI_VETH_DW_PFX + strconv.Itoa(int(oltid)) + "_" + strconv.Itoa(int(intfid)) + "_" + strconv.Itoa(int(onuid))
- return
-}
-
-func makeNniName(oltid uint32) (upif string, dwif string) {
- upif = setup.NNI_VETH_UP_PFX + strconv.Itoa(int(oltid))
- dwif = setup.NNI_VETH_DW_PFX + strconv.Itoa(int(oltid))
- return
-}
-
-func cleanUpVeths(vethenv []string) error {
- if len(vethenv) > 0 {
- logger.Debug("cleanUpVeths called ")
- setup.TearVethDown(vethenv)
- }
- return nil
-}
-
-func killProcesses(pnames []string) error {
- for _, pname := range pnames {
- setup.KillProcess(pname)
- }
- return nil
-}
-
-func setupVethHandler(inveth string, outveth string, vethenv []string) (*pcap.Handle, []string, error) {
- logger.Debug("SetupVethHandler(%s, %s) called ", inveth, outveth)
- err1 := setup.CreateVethPairs(inveth, outveth)
- vethenv = append(vethenv, inveth)
- if err1 != nil {
- setup.RemoveVeths(vethenv)
- return nil, vethenv, err1
- }
- handler, err2 := getVethHandler(inveth)
- if err2 != nil {
- setup.RemoveVeths(vethenv)
- return nil, vethenv, err2
- }
- return handler, vethenv, nil
-}
-
-func getVethHandler(vethname string) (*pcap.Handle, error) {
- var (
- device string = vethname
- snapshot_len int32 = 1518
- promiscuous bool = false
- err error
- timeout time.Duration = pcap.BlockForever
- )
- handle, err := pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
- if err != nil {
- return nil, err
- }
- logger.Debug("Server handle is created for %s\n", vethname)
- return handle, nil
-}
-
func convB2S(b []byte) string {
s := ""
for _, i := range b {
diff --git a/core/grpc_service.go b/core/grpc_service.go
index dce608b..41da7f0 100644
--- a/core/grpc_service.go
+++ b/core/grpc_service.go
@@ -17,16 +17,15 @@
package core
import (
+ "gerrit.opencord.org/voltha-bbsim/common"
"gerrit.opencord.org/voltha-bbsim/device"
"gerrit.opencord.org/voltha-bbsim/protos"
- "gerrit.opencord.org/voltha-bbsim/common"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"golang.org/x/net/context"
"google.golang.org/grpc"
"log"
"net"
- "os/exec"
)
// gRPC Service
@@ -65,7 +64,7 @@
logger.Info("OLT receives ActivateONU()\n")
result := device.ValidateONU(*onu, s.Onumap)
if result == true {
- matched, error := s.getOnuBySN(onu.SerialNumber)
+ matched, error := getOnuBySN(s.Onumap, onu.SerialNumber)
if error != nil {
log.Fatalf("%s\n", error)
}
@@ -147,42 +146,24 @@
func (s *Server) Reboot(c context.Context, empty *openolt.Empty) (*openolt.Empty, error) {
logger.Info("OLT %d receives Reboot ().\n", s.Olt.ID)
// Initialize OLT & Env
- if s.TestFlag == true{
- logger.Debug("Initialized by Reboot")
- cleanUpVeths(s.VethEnv)
- close(s.Endchan)
- processes := s.Processes
- logger.Debug("Runnig Processes:", processes)
- killProcesses(processes)
- exec.Command("rm", "/var/run/dhcpd.pid").Run() //This is for DHCP server activation
- exec.Command("touch", "/var/run/dhcpd.pid").Run() //This is for DHCP server activation
- s.Initialize()
- }
- olt := s.Olt
- olt.InitializeStatus()
- for intfid, _ := range s.Onumap{
- for _, onu := range s.Onumap[intfid] {
- onu.InitializeStatus()
- }
- }
+ logger.Debug("Initialized by Reboot")
+ s.Disable()
return new(openolt.Empty), nil
}
func (s *Server) EnableIndication(empty *openolt.Empty, stream openolt.Openolt_EnableIndicationServer) error {
- defer func() {
- s.gRPCserver.Stop()
- }()
- s.EnableServer = &stream
logger.Info("OLT receives EnableInd.\n")
- if err := s.activateOLT(stream); err != nil {
- logger.Error("Failed to activate OLT: %v\n", err)
+ defer func() {
+ logger.Debug("grpc EnableIndication Done")
+ }()
+ if err := s.Enable(&stream); err != nil {
+ logger.Error("Failed to Enable Core: %v\n", err)
return err
}
- logger.Debug("Core server down.")
return nil
}
-func CreateGrpcServer(oltid uint32, npon uint32, nonus uint32, addrport string) (l net.Listener, g *grpc.Server, e error) {
+func NewGrpcServer(addrport string) (l net.Listener, g *grpc.Server, e error) {
logger.Info("Listening %s ...", addrport)
g = grpc.NewServer()
l, e = net.Listen("tcp", addrport)
diff --git a/core/io_info.go b/core/io_info.go
index 21e1b9a..8f65280 100644
--- a/core/io_info.go
+++ b/core/io_info.go
@@ -17,13 +17,14 @@
package core
import (
- "github.com/google/gopacket/pcap"
- "gerrit.opencord.org/voltha-bbsim/common"
"errors"
+ "gerrit.opencord.org/voltha-bbsim/common"
+ "github.com/google/gopacket/pcap"
+ "os/exec"
)
type Ioinfo struct {
- name string
+ Name string
iotype string //nni or uni
ioloc string //inside or outsode
intfid uint32
@@ -42,7 +43,7 @@
return nil, err
}
-func (s *Server) identifyNniIoinfo(ioloc string) (*Ioinfo, error) {
+func (s *Server) IdentifyNniIoinfo(ioloc string) (*Ioinfo, error) {
for _, ioinfo := range s.Ioinfos {
if ioinfo.iotype == "nni" && ioinfo.ioloc == ioloc {
return ioinfo, nil
@@ -53,7 +54,7 @@
return nil, err
}
-func (s *Server) getUniIoinfos(ioloc string) ([]*Ioinfo, error) {
+func (s *Server) GetUniIoinfos(ioloc string) ([]*Ioinfo, error) {
ioinfos := []*Ioinfo{}
for _, ioinfo := range s.Ioinfos {
if ioinfo.iotype == "uni" && ioinfo.ioloc == ioloc {
@@ -67,3 +68,41 @@
}
return ioinfos, nil
}
+
+func CreateVethPairs(name1 string, name2 string) (err error) {
+ err = exec.Command("ip", "link", "add", name1, "type", "veth", "peer", "name", name2).Run()
+ if err != nil {
+ logger.Error("Fail to createVeth() for %s and %s veth creation error: %s\n", name1, name2, err.Error())
+ return
+ }
+ logger.Info("%s & %s was created.", name1, name2)
+ err = exec.Command("ip", "link", "set", name1, "up").Run()
+ if err != nil {
+ logger.Error("Fail to createVeth() veth1 up", err)
+ return
+ }
+ err = exec.Command("ip", "link", "set", name2, "up").Run()
+ if err != nil {
+ logger.Error("Fail to createVeth() veth2 up", err)
+ return
+ }
+ logger.Info("%s & %s was up.", name1, name2)
+ return
+}
+
+func RemoveVeth(name string) error {
+ err := exec.Command("ip", "link", "del", name).Run()
+ if err != nil {
+ logger.Error("Fail to removeVeth()", err)
+ }
+ logger.Info("%s was removed.", name)
+ return err
+}
+
+func RemoveVeths(names []string) {
+ for _, name := range names {
+ RemoveVeth(name)
+ }
+ logger.Info("RemoveVeths() :%s\n", names)
+ return
+}
diff --git a/core/io_worker.go b/core/io_worker.go
index 1fa97bd..41aec4b 100644
--- a/core/io_worker.go
+++ b/core/io_worker.go
@@ -17,12 +17,14 @@
package core
import (
+ "errors"
+ "gerrit.opencord.org/voltha-bbsim/common"
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/google/gopacket/pcap"
- "gerrit.opencord.org/voltha-bbsim/common"
- "errors"
"net"
+ "strconv"
+ "time"
)
func RecvWorker(io *Ioinfo, handler *pcap.Handle, r chan Packet) {
@@ -49,7 +51,7 @@
func SendNni(handle *pcap.Handle, packet gopacket.Packet) {
err := handle.WritePacketData(packet.Data())
- if err != nil{
+ if err != nil {
logger.Error("Error in send packet to NNI e:%s\n", err)
}
logger.Debug("send packet to NNI-IF: %v \n", *handle)
@@ -139,3 +141,47 @@
}
return hwAddr
}
+
+func makeUniName(oltid uint32, intfid uint32, onuid uint32) (upif string, dwif string) {
+ upif = UNI_VETH_UP_PFX + strconv.Itoa(int(oltid)) + "_" + strconv.Itoa(int(intfid)) + "_" + strconv.Itoa(int(onuid))
+ dwif = UNI_VETH_DW_PFX + strconv.Itoa(int(oltid)) + "_" + strconv.Itoa(int(intfid)) + "_" + strconv.Itoa(int(onuid))
+ return
+}
+
+func makeNniName(oltid uint32) (upif string, dwif string) {
+ upif = NNI_VETH_UP_PFX + strconv.Itoa(int(oltid))
+ dwif = NNI_VETH_DW_PFX + strconv.Itoa(int(oltid))
+ return
+}
+
+func setupVethHandler(inveth string, outveth string, vethnames []string) (*pcap.Handle, []string, error) {
+ logger.Debug("SetupVethHandler(%s, %s) called ", inveth, outveth)
+ err1 := CreateVethPairs(inveth, outveth)
+ vethnames = append(vethnames, inveth)
+ if err1 != nil {
+ RemoveVeths(vethnames)
+ return nil, vethnames, err1
+ }
+ handler, err2 := getVethHandler(inveth)
+ if err2 != nil {
+ RemoveVeths(vethnames)
+ return nil, vethnames, err2
+ }
+ return handler, vethnames, nil
+}
+
+func getVethHandler(vethname string) (*pcap.Handle, error) {
+ var (
+ device string = vethname
+ snapshot_len int32 = 1518
+ promiscuous bool = false
+ err error
+ timeout time.Duration = pcap.BlockForever
+ )
+ handle, err := pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
+ if err != nil {
+ return nil, err
+ }
+ logger.Debug("Server handle is created for %s\n", vethname)
+ return handle, nil
+}
diff --git a/core/mediator.go b/core/mediator.go
new file mode 100644
index 0000000..496621a
--- /dev/null
+++ b/core/mediator.go
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package core
+
+import (
+ "sync"
+ "gerrit.opencord.org/voltha-bbsim/common"
+ "os"
+ "os/signal"
+ "fmt"
+ "flag"
+ "strings"
+ "strconv"
+)
+
+type option struct{
+ address string
+ port uint32
+ oltid uint32
+ npon uint32
+ nonus uint32
+ aaawait int
+ dhcpwait int
+ dhcpservip string
+ intvl int
+ intvl_test int
+ Mode Mode
+}
+
+func GetOptions() *option {
+ o := new(option)
+ addressport := flag.String("H", ":50060", "IP address:port")
+ oltid :=flag.Int("id", 0, "OLT-ID")
+ npon := flag.Int("i", 1, "Number of PON-IF ports")
+ nonus := flag.Int("n", 1, "Number of ONUs per PON-IF port")
+ modeopt := flag.String("m", "default", "Emulation mode (default, aaa, both (aaa & dhcp))")
+ aaawait := flag.Int("aw", 30, "Wait time (sec) for activation WPA supplicants")
+ dhcpwait := flag.Int("dw", 50, "Wait time (sec) for activation DHCP clients")
+ dhcpservip := flag.String("s", "182.21.0.1", "DHCP Server IP Address")
+ intvl := flag.Int("v", 1, "Interval each Indication")
+ intvl_test := flag.Int("V", 1, "Interval each Indication")
+ o.Mode = DEFAULT
+ flag.Parse()
+ if *modeopt == "aaa" {
+ o.Mode = AAA
+ } else if *modeopt == "both" {
+ o.Mode = BOTH
+ }
+ o.oltid = uint32(*oltid)
+ o.npon = uint32(*npon)
+ o.nonus = uint32(*nonus)
+ o.aaawait = *aaawait
+ o.dhcpwait = *dhcpwait
+ o.dhcpservip = *dhcpservip
+ o.intvl = *intvl
+ o.intvl_test = *intvl_test
+ o.address = (strings.Split(*addressport, ":")[0])
+ tmp, _ := strconv.Atoi(strings.Split(*addressport, ":")[1])
+ o.port = uint32(tmp)
+ return o
+}
+
+type stateMachine struct{
+ handlers []*handler
+ state coreState
+}
+
+type handler struct{
+ dst coreState
+ src coreState
+ method func(s *Server) error
+}
+
+func (sm *stateMachine) transit(next coreState) func(s *Server) error {
+ for _, handler := range sm.handlers{
+ if handler.src == sm.state && handler.dst == next {
+ logger.Debug("Hit (src:%d, dst:%d)",handler.src, handler.dst)
+ sm.state = next
+ return handler.method
+ }
+ }
+ sm.state = next
+ return nil
+}
+
+type mediator struct {
+ opt *option
+ sm *stateMachine
+ server *Server
+ tester *Tester
+}
+
+func NewMediator(o *option) *mediator{
+ m := new(mediator)
+ m.opt = o
+ logger.Debug("ip:%s, baseport:%d, npon:%d, nonus:%d, mode:%d\n", o.address, o.port, o.npon, o.nonus, o.Mode)
+ return m
+}
+
+func (m *mediator) Start(){
+ var wg sync.WaitGroup
+ opt := m.opt
+ server := NewCore(opt)
+ wg.Add(1)
+ go func(){
+ if err:= server.Start(); err != nil { //Blocking
+ logger.Error("%s", err)
+ }
+ wg.Done()
+ return
+ }()
+
+ tester := NewTester(opt)
+ m.server = server
+ m.tester = tester
+ m.sm = &stateMachine{
+ state: INACTIVE,
+ handlers: []*handler{
+ &handler{src: PRE_ACTIVE,dst: ACTIVE, method: m.tester.Start},
+ &handler{src: ACTIVE,dst: PRE_ACTIVE, method: m.tester.Stop},
+ },
+ }
+ go func(){
+ m.Mediate()
+ }()
+
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, os.Interrupt)
+ go func() {
+ defer func(){
+ logger.Debug("SIGINT catcher Done")
+ wg.Done()
+ }()
+ for sig := range c {
+ wg.Add(1)
+ fmt.Println("SIGINT", sig)
+ close(c)
+ server.Stop() //Non-blocking
+ tester.Stop(server) //Non-blocking
+ return
+ }
+ }()
+ wg.Wait()
+ logger.Debug("Reach to the end line")
+}
+
+func (m *mediator) Mediate(){
+ wg := sync.WaitGroup{}
+ defer logger.Debug("Mediate Done")
+ for corestat := range m.server.stateChan {
+ logger.Debug("Mediator receives state %d of server", corestat)
+ method := m.sm.transit(corestat)
+ if method != nil {
+ wg.Add(1)
+ defer wg.Done()
+ go func() error {
+ if err := method(m.server); err != nil{ //blocking
+ m.server.Stop()
+ return err
+ }
+ return nil
+ }()
+ }
+ }
+ wg.Wait()
+}
\ No newline at end of file
diff --git a/core/openolt_service.go b/core/openolt_service.go
index ef92704..97047bf 100644
--- a/core/openolt_service.go
+++ b/core/openolt_service.go
@@ -17,10 +17,10 @@
package core
import (
- "time"
- "gerrit.opencord.org/voltha-bbsim/protos"
- "gerrit.opencord.org/voltha-bbsim/device"
"gerrit.opencord.org/voltha-bbsim/common"
+ "gerrit.opencord.org/voltha-bbsim/device"
+ "gerrit.opencord.org/voltha-bbsim/protos"
+ "time"
)
func sendOltIndUp(stream openolt.Openolt_EnableIndicationServer, olt *device.Olt) error {
diff --git a/core/tester.go b/core/tester.go
new file mode 100644
index 0000000..ba4792b
--- /dev/null
+++ b/core/tester.go
@@ -0,0 +1,322 @@
+/*
+ * Copyright 2018-present Open Networking Foundation
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ * http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package core
+
+import (
+ "context"
+ "gerrit.opencord.org/voltha-bbsim/common"
+ "golang.org/x/sync/errgroup"
+ "log"
+ "os/exec"
+ "time"
+ "sync"
+)
+
+const (
+ DEFAULT Mode = iota
+ AAA
+ BOTH
+)
+
+type Mode int
+
+type Tester struct {
+ Mode Mode
+ AAAWait int
+ DhcpWait int
+ DhcpServerIP string
+ Processes []string
+ Intvl int
+ cancel context.CancelFunc
+}
+
+func NewTester(opt *option) *Tester{
+ t := new(Tester)
+ t.AAAWait = opt.aaawait
+ t.DhcpWait = opt.dhcpwait
+ t.DhcpServerIP = opt.dhcpservip
+ t.Intvl = opt.intvl_test
+ t.Mode = opt.Mode
+ return t
+}
+
+//Blocking
+func (t *Tester) Start (s *Server) error {
+ ctx := context.Background()
+ ctx, cancel := context.WithCancel(ctx)
+ t.cancel = cancel
+ defer func(){
+ cancel()
+ t.Initialize()
+ logger.Debug("Tester Done")
+ }()
+ logger.Info("Tester Run() start")
+ if t.Mode == DEFAULT {
+ //Empty
+ } else if t.Mode == AAA || t.Mode == BOTH {
+ eg, child := errgroup.WithContext(ctx)
+ child, cancel := context.WithCancel(child)
+ eg.Go(func() error {
+ defer func() {
+ logger.Debug("exeAAATest Done")
+ }()
+ err := t.exeAAATest(child, s, t.AAAWait)
+ return err
+ })
+
+ if t.Mode == BOTH {
+ eg.Go(func() error {
+ defer func() {
+ logger.Debug("exeDHCPTest Done")
+ }()
+
+ err := t.exeDHCPTest(ctx, s, t.DhcpWait)
+ return err
+ })
+ }
+ if err := eg.Wait(); err != nil {
+ logger.Error("Error happened in tester: %s", err)
+ cancel()
+ return err
+ } else {
+ logger.Debug("Test successfully finished")
+ }
+ }
+ return nil
+}
+
+func (t *Tester) Stop(s *Server) error {
+ if t.cancel != nil {
+ t.cancel()
+ }
+ return nil
+}
+
+func (t *Tester) Initialize (){
+ logger.Info("Tester Initialize () called")
+ processes := t.Processes
+ logger.Debug("Runnig Process: %s", processes)
+ KillProcesses(processes)
+ exec.Command("rm", "/var/run/dhcpd.pid").Run() //This is for DHCP server activation
+ exec.Command("touch", "/var/run/dhcpd.pid").Run() //This is for DHCP server activation
+}
+
+
+func (t *Tester) exeAAATest(ctx context.Context, s *Server, wait int) error {
+ tick := time.NewTicker(time.Second)
+ defer tick.Stop()
+ logger.Info("exeAAATest stands by....")
+ infos, err := s.GetUniIoinfos("outside")
+ if err != nil {
+ return err
+ }
+
+ univeths := []string{}
+ for _, info := range infos {
+ univeths = append(univeths, info.Name)
+ }
+
+ for sec := 1; sec <= wait; sec ++ {
+ select {
+ case <-ctx.Done():
+ logger.Debug("exeAAATest thread receives close ")
+ return nil
+ case <-tick.C:
+ logger.Info("exeAAATest stands by ... %dsec\n", wait - sec)
+ if sec == wait {
+ wg := sync.WaitGroup{}
+ wg.Add(1)
+ go func() error{
+ defer wg.Done()
+ err = activateWPASups(ctx, univeths, t.Intvl)
+ if err != nil {
+ return err
+ }
+ logger.Info("WPA supplicants are successfully activated ")
+ t.Processes = append(t.Processes, "wpa_supplicant")
+ logger.Debug("Running Process:%s", t.Processes)
+ return nil
+ }()
+ wg.Wait()
+ }
+ }
+ }
+ return nil
+}
+
+func (t *Tester) exeDHCPTest(ctx context.Context, s *Server, wait int) error {
+ tick := time.NewTicker(time.Second)
+ defer tick.Stop()
+ logger.Info("exeDHCPTest stands by....")
+ info, err := s.IdentifyNniIoinfo("outside")
+ if err != nil {
+ return err
+ }
+
+ err = activateDHCPServer(info.Name, t.DhcpServerIP)
+ if err != nil {
+ return err
+ }
+ t.Processes = append(t.Processes, "dhcpd")
+ logger.Debug("Running Process:%s", t.Processes)
+
+ infos, err := s.GetUniIoinfos("outside")
+ if err != nil {
+ return err
+ }
+
+ univeths := []string{}
+ for _, info := range infos {
+ univeths = append(univeths, info.Name)
+ }
+
+ for sec := 1; sec <= wait; sec ++ {
+ select {
+ case <- ctx.Done():
+ logger.Debug("exeDHCPTest thread receives close ")
+ return nil
+ case <- tick.C:
+ logger.Info("exeDHCPTest stands by ... %dsec\n", wait- sec)
+ if sec == wait {
+ wg := sync.WaitGroup{}
+ wg.Add(1)
+ go func() error{
+ defer wg.Done()
+ err = activateDHCPClients(ctx, univeths, t.Intvl)
+ if err != nil {
+ return err
+ }
+ logger.Info("DHCP clients are successfully activated ")
+ t.Processes = append(t.Processes, "dhclient")
+ logger.Debug("Running Process:%s", t.Processes)
+ return nil
+ }()
+ wg.Wait()
+ }
+ }
+ }
+ return nil
+}
+
+func KillProcesses(pnames []string) error {
+ for _, pname := range pnames {
+ killProcess(pname)
+ }
+ return nil
+}
+
+func activateWPASups(ctx context.Context, vethnames []string, intvl int) error {
+ tick := time.NewTicker(time.Duration(intvl) * time.Second)
+ defer tick.Stop()
+ i := 0
+ for {
+ select{
+ case <- tick.C:
+ if i < len(vethnames) {
+ vethname := vethnames[i]
+ if err := activateWPASupplicant(vethname); err != nil {
+ return err
+ }
+ logger.Debug("activateWPASupplicant for interface %v\n", vethname)
+ i ++
+ }
+ case <- ctx.Done():
+ logger.Debug("activateWPASups was canceled by context.")
+ return nil
+ }
+ }
+ return nil
+}
+
+func activateDHCPClients(ctx context.Context, vethnames []string, intvl int) error {
+ tick := time.NewTicker(time.Duration(intvl) * time.Second)
+ defer tick.Stop()
+ i := 0
+ for {
+ select{
+ case <- tick.C:
+ if i < len(vethnames){
+ vethname := vethnames[i]
+ if err := activateDHCPClient(vethname); err != nil {
+ return err
+ }
+ logger.Debug("activateDHCPClient for interface %v\n", vethname)
+ i ++
+ }
+ case <- ctx.Done():
+ logger.Debug("activateDHCPClients was canceled by context.")
+ return nil
+ }
+ }
+ return nil
+}
+
+func killProcess(name string) error {
+ err := exec.Command("pkill", name).Run()
+ if err != nil {
+ logger.Error("Fail to pkill %s: %v\n", name, err)
+ return err
+ }
+ logger.Info("Successfully killed %s\n", name)
+ return nil
+}
+
+func activateWPASupplicant(vethname string) (err error) {
+ cmd := "/sbin/wpa_supplicant"
+ conf := "/etc/wpa_supplicant/wpa_supplicant.conf"
+ err = exec.Command(cmd, "-D", "wired", "-i", vethname, "-c", conf).Start()
+ if err != nil {
+ logger.Error("Fail to activateWPASupplicant() for :%s %v\n", vethname, err)
+ return
+ }
+ logger.Info("activateWPASupplicant() for :%s\n", vethname)
+ return
+}
+
+func activateDHCPClient(vethname string) (err error) {
+ logger.Debug("activateDHCPClient() start for: %s\n", vethname)
+ cmd := exec.Command("/usr/local/bin/dhclient", vethname)
+ // if err := cmd.Run(); err != nil {
+ if err := cmd.Start(); err != nil {
+ logger.Error("Fail to activateDHCPClient() for: %s", vethname)
+ log.Panic(err)
+ }
+ logger.Debug("activateDHCPClient() done for: %s\n", vethname)
+ return
+}
+
+func activateDHCPServer(veth string, serverip string) error {
+ err := exec.Command("ip", "addr", "add", serverip, "dev", veth).Run()
+ if err != nil {
+ logger.Error("Fail to add ip to %s address: %s\n", veth, err)
+ return err
+ }
+ err = exec.Command("ip", "link", "set", veth, "up").Run()
+ if err != nil {
+ logger.Error("Fail to set %s up: %s\n", veth, err)
+ return err
+ }
+ cmd := "/usr/local/bin/dhcpd"
+ conf := "/etc/dhcp/dhcpd.conf"
+ err = exec.Command(cmd, "-cf", conf, veth).Run()
+ if err != nil {
+ logger.Error("Fail to activateDHCP Server (): %s\n", err)
+ return err
+ }
+ logger.Info("DHCP Server is successfully activated !\n")
+ return err
+}
diff --git a/device/device_olt.go b/device/device_olt.go
index b87bc53..41df918 100644
--- a/device/device_olt.go
+++ b/device/device_olt.go
@@ -45,7 +45,7 @@
ONU_DISCOVERED
)
-func CreateOlt(oltid uint32, npon uint32, nnni uint32) *Olt {
+func NewOlt(oltid uint32, npon uint32, nnni uint32) *Olt {
olt := Olt{}
olt.ID = oltid
olt.NumPonIntf = npon
@@ -69,7 +69,7 @@
return &olt
}
-func (olt *Olt)InitializeStatus(){
+func (olt *Olt) InitializeStatus() {
*olt.InternalState = PRE_ENABLE
olt.OperState = "up"
for i := uint32(0); i < olt.NumNniIntf; i++ {
diff --git a/device/device_onu.go b/device/device_onu.go
index 92f96b5..de99eb3 100644
--- a/device/device_onu.go
+++ b/device/device_onu.go
@@ -17,10 +17,10 @@
package device
import (
+ "gerrit.opencord.org/voltha-bbsim/common"
+ "gerrit.opencord.org/voltha-bbsim/protos"
"reflect"
"sync"
- "gerrit.opencord.org/voltha-bbsim/protos"
- "gerrit.opencord.org/voltha-bbsim/common"
)
type onuState int
@@ -39,12 +39,12 @@
mu *sync.Mutex
}
-func CreateSN(oltid uint32, intfid uint32, onuid uint32) []byte {
+func NewSN(oltid uint32, intfid uint32, onuid uint32) []byte {
sn := []byte{0, byte(oltid % 256), byte(intfid), byte(onuid)}
return sn
}
-func CreateOnus(oltid uint32, intfid uint32, nonus uint32, nnni uint32) []*Onu {
+func NewOnus(oltid uint32, intfid uint32, nonus uint32, nnni uint32) []*Onu {
onus := []*Onu{}
for i := 0; i < int(nonus); i++ {
onu := Onu{}
@@ -55,7 +55,7 @@
onu.OperState = "up"
onu.SerialNumber = new(openolt.SerialNumber)
onu.SerialNumber.VendorId = []byte("BBSM")
- onu.SerialNumber.VendorSpecific = CreateSN(oltid, intfid, uint32(i))
+ onu.SerialNumber.VendorSpecific = NewSN(oltid, intfid, uint32(i))
onus = append(onus, &onu)
}
return onus
@@ -88,13 +88,13 @@
}
}
-func (onu *Onu) UpdateIntStatus(intstatus onuState){
+func (onu *Onu) UpdateIntStatus(intstatus onuState) {
onu.mu.Lock()
defer onu.mu.Unlock()
*onu.InternalState = intstatus
}
-func (onu *Onu) GetIntStatus() onuState{
+func (onu *Onu) GetIntStatus() onuState {
onu.mu.Lock()
defer onu.mu.Unlock()
return *onu.InternalState
diff --git a/setup/setup_env.go b/setup/setup_env.go
deleted file mode 100644
index ffbc9a0..0000000
--- a/setup/setup_env.go
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright 2018-present Open Networking Foundation
-
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
-
- * http://www.apache.org/licenses/LICENSE-2.0
-
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package setup
-
-import (
- "os/exec"
- "time"
- "log"
- "gerrit.opencord.org/voltha-bbsim/common"
-)
-
-const (
- UNI_VETH_UP_PFX = "sim_uu"
- UNI_VETH_DW_PFX = "sim_ud"
- NNI_VETH_UP_PFX = "sim_nu"
- NNI_VETH_DW_PFX = "sim_nd"
-)
-
-func ActivateWPASups(vethnames []string, delay int) error {
- for _, vethname := range vethnames {
- time.Sleep(time.Duration(delay) * time.Second)
- logger.Debug("ActivateWPASups for interface %v\n", vethname)
- if err := activateWPASupplicant(vethname); err != nil {
- return err
- }
- }
- return nil
-}
-
-func ActivateDHCPClients(vethnames []string, delay int) error {
- for _, vethname := range vethnames {
- time.Sleep(time.Duration(delay) * time.Second)
- logger.Debug("activateDHCPClient for interface %v\n", vethname)
- if err := activateDHCPClient(vethname); err != nil {
- return err
- }
- }
- return nil
-}
-
-func KillProcess(name string) error {
- err := exec.Command("pkill", name).Run()
- if err != nil {
- logger.Error("Fail to pkill %s: %v\n", name, err)
- return err
- }
- logger.Info("Successfully killed %s\n", name)
- return nil
-}
-
-func TearVethDown(veths []string) {
- for _, veth := range veths {
- RemoveVeth(veth)
- }
-}
-
-func CreateVethPairs(name1 string, name2 string) (err error) {
- err = exec.Command("ip", "link", "add", name1, "type", "veth", "peer", "name", name2).Run()
- if err != nil {
- logger.Error("Fail to createVeth() for %s and %s veth creation error: %s\n", name1, name2, err.Error())
- return
- }
- logger.Info("%s & %s was created.", name1, name2)
- err = exec.Command("ip", "link", "set", name1, "up").Run()
- if err != nil {
- logger.Error("Fail to createVeth() veth1 up", err)
- return
- }
- err = exec.Command("ip", "link", "set", name2, "up").Run()
- if err != nil {
- logger.Error("Fail to createVeth() veth2 up", err)
- return
- }
- logger.Info("%s & %s was up.", name1, name2)
- return
-}
-
-func RemoveVeth(name string) {
- err := exec.Command("ip", "link", "del", name).Run()
- if err != nil {
- logger.Error("Fail to removeVeth()", err)
- }
- logger.Info("%s was removed.", name)
-}
-
-func RemoveVeths(names []string) {
- logger.Info("RemoveVeths() :%s\n", names)
- for _, name := range names {
- RemoveVeth(name)
- }
-}
-
-func activateWPASupplicant(vethname string) (err error) {
- cmd := "/sbin/wpa_supplicant"
- conf := "/etc/wpa_supplicant/wpa_supplicant.conf"
- err = exec.Command(cmd, "-D", "wired", "-i", vethname, "-c", conf).Start()
- if err != nil {
- logger.Error("Fail to activateWPASupplicant() for :%s %v\n", vethname, err)
- return
- }
- logger.Info("activateWPASupplicant() for :%s\n", vethname)
- return
-}
-
-func activateDHCPClient(vethname string) (err error) {
- logger.Debug("activateDHCPClient() start for: %s\n", vethname)
- cmd := exec.Command("/usr/local/bin/dhclient", vethname)
- // if err := cmd.Run(); err != nil {
- if err := cmd.Start(); err != nil {
- logger.Error("Fail to activateDHCPClient() for: %s", vethname)
- log.Panic(err)
- }
-
- // if the dhclient commands return we got an IP,
- // so kill it
- // if err := KillProcess("/usr/local/bin/dhclient"); err != nil {
- // log.Printf("[ERROR] Failed to kill activateDHCPClient() for: %s", vethname, err)
- // }
-
- logger.Debug("activateDHCPClient() done for: %s\n", vethname)
- return
-}
-
-func ActivateDHCPServer(veth string, serverip string) error {
- err := exec.Command("ip", "addr", "add", serverip, "dev", veth).Run()
- if err != nil {
- logger.Error("Fail to add ip to %s address: %s\n", veth, err)
- return err
- }
- err = exec.Command("ip", "link", "set", veth, "up").Run()
- if err != nil {
- logger.Error("Fail to set %s up: %s\n", veth, err)
- return err
- }
- cmd := "/usr/local/bin/dhcpd"
- conf := "/etc/dhcp/dhcpd.conf"
- err = exec.Command(cmd, "-cf", conf, veth).Run()
- if err != nil {
- logger.Error("Fail to activateDHCP Server (): %s\n", err)
- return err
- }
- logger.Info("DHCP Server is successfully activated !\n")
- return err
-}