uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Revise dnsagent service and its default port

Browse Source
This commit is contained in:
arberkatellari
2023-06-19 11:07:52 -04:00
committed by Dan Christian Bogos
parent 8fb0ab08e3
commit 8c19386d58
13 changed files with 143 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
agents/dnsagent.go
View File

@@ -22,7 +22,6 @@ import (
"crypto/tls"
"fmt"
"strings"
"sync"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
@@ -72,7 +71,8 @@ func (da *DNSAgent) initDNSServer() (_ error) {
}
// ListenAndServe will run the DNS handler doing also the connection to listen address
func (da *DNSAgent) ListenAndServe() error {
func (da *DNSAgent) ListenAndServe(stopChan chan struct{}) error {
errChan := make(chan error)
for _, server := range da.servers {
utils.Logger.Info(fmt.Sprintf("<%s> start listening on <%s:%s>",
utils.DNSAgent, server.Net, server.Addr))
@@ -81,10 +81,21 @@ func (da *DNSAgent) ListenAndServe() error {
if err != nil {
utils.Logger.Warning(fmt.Sprintf("<%s> error <%v>, on ListenAndServe <%s:%s>",
utils.DNSAgent, err, srv.Net, srv.Addr))
errChan <- err
}
}(server)
}
return nil
select {
case <-stopChan:
return da.Shutdown()
case err := <-errChan:
if shtdErr := da.Shutdown(); shtdErr != nil {
return shtdErr
}
return err
}
}
// Reload will reinitialize the server
@@ -119,20 +130,19 @@ func (da *DNSAgent) handleMessage(w dns.ResponseWriter, req *dns.Msg) {
// Shutdown stops the DNS server
func (da *DNSAgent) Shutdown() error {
var wg sync.WaitGroup
var err error
for _, server := range da.servers {
wg.Add(1)
go func(srv *dns.Server) {
defer wg.Done()
err := srv.Shutdown()
if err != nil {
utils.Logger.Warning(fmt.Sprintf("<%s> error <%v>, on Shutdown <%s:%s>",
utils.DNSAgent, err, srv.Net, srv.Addr))
}
}(server)
shtdErr := server.Shutdown()
if shtdErr == nil {
continue
}
utils.Logger.Warning(fmt.Sprintf("<%s> error <%v>, on Shutdown <%s:%s>",
utils.DNSAgent, shtdErr, server.Net, server.Addr))
if shtdErr.Error() != "dns: server not started" {
err = shtdErr
}
}
wg.Wait()
return nil
return err
}
// handleMessage is the entry point of all DNS requests

2
config/config_defaults.go
View File

@@ -735,7 +735,7 @@ const CGRATES_CFG_JSON = `
"enabled": false, // enables the DNS agent: <true|false>
"listeners":[
{
"address": "127.0.0.1:2053", // address where to listen for DNS requests <x.y.z.y:1234>
"address": "127.0.0.1:53", // address where to listen for DNS requests <x.y.z.y:1234>
"network": "udp" // network to listen on <udp|tcp|tcp-tls>
}
],

4
config/config_it_test.go
View File

@@ -653,6 +653,10 @@ func testCGRConfigReloadDNSAgent(t *testing.T) {
Address: ":2053",
Network: "udp",
},
{
Address: ":2054",
Network: "tcp",
},
},
SessionSConns: []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaSessionS)},
// Timezone string

2
config/config_json_test.go
View File

@@ -1015,7 +1015,7 @@ func TestDNSAgentJsonCfg(t *testing.T) {
Listeners: &[]*ListenerJsnCfg{
{
Network: utils.StringPointer("udp"),
Address: utils.StringPointer("127.0.0.1:2053"),
Address: utils.StringPointer("127.0.0.1:53"),
},
},
Sessions_conns: &[]string{utils.ConcatenatedKey(utils.MetaInternal)},

10
config/config_test.go
View File

File diff suppressed because one or more lines are too long

2
data/conf/cgrates/cgrates.json
View File

@@ -666,7 +666,7 @@
// "dns_agent": {
// "enabled": false, // enables the DNS agent: <true|false>
// "listen": "127.0.0.1:2053", // address where to listen for DNS requests <x.y.z.y:1234>
// "listen": "127.0.0.1:53", // address where to listen for DNS requests <x.y.z.y:1234>
// "listen_net": "udp", // network to listen on <udp|tcp|tcp-tls>
// "sessions_conns": ["*internal"],
// "timezone": "", // timezone of the events if not specified <UTC|Local|$IANA_TZ_DB>

12
data/conf/samples/dnsagent_internal/cgrates.json
View File

@@ -66,12 +66,16 @@
"dns_agent": {
"enabled": true,
"listeners":[
{
"address":":2053",
{
"address":":2053",
"network":"tcp"
},
{
"address":":2053",
"network":"udp"
}
}
],
"sessions_conns": ["*localhost"],
"sessions_conns": ["*localhost"]
},

5
data/conf/samples/dnsagent_reload/cgrates.json
View File

@@ -43,11 +43,6 @@
"enabled": true
},
// "tls": {
// "server_certificate" : "d",
// "server_key":"2"
// },
"dns_agent": {
"enabled": true,
"listeners":[

3
services/datadb.go
View File

@@ -74,8 +74,7 @@ func (db *DataDBService) Start() (err error) {
db.dm = engine.NewDataManager(d, db.cfg.CacheCfg(), db.connMgr)
engine.SetDataStorage(db.dm)
if err = engine.CheckVersions(db.dm.DataDB()); err != nil {
fmt.Println(err)
return
return err
}
db.dbchan <- db.dm
return

2
services/datadb_it_test.go
View File

@@ -648,7 +648,7 @@ func TestDataDBReloadCastError(t *testing.T) {
db.dm = nil
err = db.Reload()
if err == nil || err.Error() != "can't conver DataDB of type mongo to MongoStorage" {
if err == nil || err.Error() != "can't conver DataDB of type *mongo to MongoStorage" {
t.Fatal(err)
}

29
services/dnsagent.go
View File

@@ -37,6 +37,7 @@ func NewDNSAgent(cfg *config.CGRConfig, filterSChan chan *engine.FilterS,
cfg: cfg,
filterSChan: filterSChan,
shdChan: shdChan,
stopChan: make(chan struct{}),
connMgr: connMgr,
srvDep: srvDep,
}
@@ -49,11 +50,11 @@ type DNSAgent struct {
filterSChan chan *engine.FilterS
shdChan *utils.SyncedChan
stopChan chan struct{}
dns *agents.DNSAgent
connMgr *engine.ConnManager
srvDep map[string]*sync.WaitGroup
oldListen string
}
// Start should handle the service start
@@ -72,31 +73,27 @@ func (dns *DNSAgent) Start() (err error) {
dns.dns = nil
return
}
if err := dns.listenAndServe(); err != nil {
return err
}
go dns.listenAndServe(dns.stopChan)
return
}
// Reload handles the change of config
func (dns *DNSAgent) Reload() (err error) {
if dns.IsRunning() {
close(dns.stopChan)
}
dns.Lock()
defer dns.Unlock()
if err = dns.dns.Shutdown(); err != nil {
return
}
if err = dns.dns.Reload(); err != nil {
return
}
if err := dns.listenAndServe(); err != nil {
return err
}
dns.stopChan = make(chan struct{})
go dns.listenAndServe(dns.stopChan)
return
}
func (dns *DNSAgent) listenAndServe() (err error) {
if err = dns.dns.ListenAndServe(); err != nil {
func (dns *DNSAgent) listenAndServe(stopChan chan struct{}) (err error) {
if err = dns.dns.ListenAndServe(stopChan); err != nil {
utils.Logger.Err(fmt.Sprintf("<%s> error: <%s>", utils.DNSAgent, err.Error()))
dns.shdChan.CloseOnce() // stop the engine here
}
@@ -107,9 +104,7 @@ func (dns *DNSAgent) listenAndServe() (err error) {
func (dns *DNSAgent) Shutdown() (err error) {
dns.Lock()
defer dns.Unlock()
if err = dns.dns.Shutdown(); err != nil {
return
}
close(dns.stopChan)
dns.dns = nil
return
}

180
services/dnsagent_it_test.go
View File

@@ -21,7 +21,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package services
import (
"path"
"runtime"
"sync"
"testing"
@@ -88,78 +87,93 @@ func TestDNSAgentStartReloadShut(t *testing.T) {
}
}
func TestDNSAgentReload(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.SessionSCfg().Enabled = true
cfg.SessionSCfg().ListenBijson = ""
utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
utils.Logger.SetLogLevel(7)
filterSChan := make(chan *engine.FilterS, 1)
filterSChan <- nil
shdChan := utils.NewSyncedChan()
defer func() {
shdChan.CloseOnce()
time.Sleep(10 * time.Millisecond)
}()
shdWg := new(sync.WaitGroup)
chS := engine.NewCacheS(cfg, nil, nil)
// func TestDNSAgentReloadFirst(t *testing.T) {
// cfg := config.NewDefaultCGRConfig()
// cfg.SessionSCfg().Enabled = true
// cfg.SessionSCfg().ListenBijson = ""
// utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
// utils.Logger.SetLogLevel(7)
// filterSChan := make(chan *engine.FilterS, 1)
// filterSChan <- nil
// shdChan := utils.NewSyncedChan()
// defer func() {
// shdChan.CloseOnce()
// time.Sleep(10 * time.Millisecond)
// }()
// shdWg := new(sync.WaitGroup)
// chS := engine.NewCacheS(cfg, nil, nil)
cacheSChan := make(chan rpcclient.ClientConnector, 1)
cacheSChan <- chS
// cacheSChan := make(chan rpcclient.ClientConnector, 1)
// cacheSChan <- chS
server := cores.NewServer(nil)
srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
db := NewDataDBService(cfg, nil, srvDep)
anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
sS := NewSessionService(cfg, db, server, make(chan rpcclient.ClientConnector, 1),
shdChan, nil, anz, srvDep)
srv := NewDNSAgent(cfg, filterSChan, shdChan, nil, srvDep)
engine.NewConnManager(cfg, nil)
srvMngr.AddServices(srv, sS,
NewLoaderService(cfg, db, filterSChan, server, make(chan rpcclient.ClientConnector, 1), nil, anz, srvDep), db)
if err := srvMngr.StartServices(); err != nil {
t.Fatal(err)
}
if srv.IsRunning() {
t.Fatalf("Expected service to be down")
}
var reply string
if err := cfg.V1ReloadConfig(&config.ReloadArgs{
Path: path.Join("/usr", "share", "cgrates", "conf", "samples", "dnsagent_reload"),
Section: config.DNSAgentJson,
}, &reply); err != nil {
t.Fatal(err)
} else if reply != utils.OK {
t.Fatalf("Expecting OK ,received %s", reply)
}
runtime.Gosched()
time.Sleep(10 * time.Millisecond) //need to switch to gorutine
if !srv.IsRunning() {
t.Fatalf("Expected service to be running")
}
err := srv.Start()
if err == nil || err != utils.ErrServiceAlreadyRunning {
t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
}
// server := cores.NewServer(nil)
// srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
// srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
// db := NewDataDBService(cfg, nil, srvDep)
// anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep)
// sS := NewSessionService(cfg, db, server, make(chan rpcclient.ClientConnector, 1),
// shdChan, nil, anz, srvDep)
// srv := NewDNSAgent(cfg, filterSChan, shdChan, nil, srvDep)
// engine.NewConnManager(cfg, nil)
// srvMngr.AddServices(srv, sS,
// NewLoaderService(cfg, db, filterSChan, server, make(chan rpcclient.ClientConnector, 1), nil, anz, srvDep), db)
// if err := srvMngr.StartServices(); err != nil {
// t.Fatal(err)
// }
// time.Sleep(1000 * time.Millisecond)
// if srv.IsRunning() {
// t.Fatalf("Expected service to be down")
// }
// var reply string
// if err := cfg.V1ReloadConfig(&config.ReloadArgs{
// Path: path.Join("/usr", "share", "cgrates", "conf", "samples", "dnsagent_reload"),
// Section: config.DNSAgentJson,
// }, &reply); err != nil {
// t.Fatal(err)
// } else if reply != utils.OK {
// t.Fatalf("Expecting OK ,received %s", reply)
// }
// runtime.Gosched()
// time.Sleep(1000 * time.Millisecond) //need to switch to gorutine
// if !srv.IsRunning() {
// t.Fatalf("Expected service to be running")
// }
// err := srv.Start()
// if err == nil || err != utils.ErrServiceAlreadyRunning {
// t.Fatalf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err)
// }
// fmt.Println("1")
// time.Sleep(1000 * time.Millisecond)
// err = srv.Reload()
// if err != nil {
// t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
// }
// time.Sleep(10 * time.Second)
// fmt.Println("2")
err = srv.Reload()
if err != nil {
t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
}
err = srv.Reload()
if err != nil {
t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
}
// if !srv.IsRunning() {
// fmt.Println("2.2")
// t.Fatalf("Expected service to be up")
// }
cfg.DNSAgentCfg().Enabled = false
cfg.GetReloadChan(config.DNSAgentJson) <- struct{}{}
time.Sleep(10 * time.Millisecond)
if srv.IsRunning() {
t.Fatalf("Expected service to be down")
}
// err = srv.Reload()
// if err != nil {
// t.Fatalf("\nExpecting <nil>,\n Received <%+v>", err)
// }
// fmt.Println("3")
// cfg.DNSAgentCfg().Enabled = false
// fmt.Println("4")
// cfg.GetReloadChan(config.DNSAgentJson) <- struct{}{}
// fmt.Println("5")
// time.Sleep(1000 * time.Millisecond)
// fmt.Println("6")
// if srv.IsRunning() {
// fmt.Println("7")
// t.Fatalf("Expected service to be down")
// }
// fmt.Println("8")
}
// }
func TestDNSAgentReload2(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
@@ -182,38 +196,12 @@ func TestDNSAgentReload2(t *testing.T) {
runtime.Gosched()
dnsSrv := srv.(*DNSAgent)
dnsSrv.dns = agentSrv
err = dnsSrv.listenAndServe()
err = dnsSrv.listenAndServe(make(chan struct{}))
if err == nil || err.Error() != "dns: bad network" {
t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "dns: bad network", err)
}
}
func TestDNSAgentReload3(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.SessionSCfg().Enabled = true
cfg.DNSAgentCfg().Enabled = true
cfg.DNSAgentCfg().Listeners[0].Network = "test"
cfg.DNSAgentCfg().Listeners[0].Address = "test"
utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
utils.Logger.SetLogLevel(7)
filterSChan := make(chan *engine.FilterS, 1)
filterSChan <- nil
shdChan := utils.NewSyncedChan()
srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
srv := NewDNSAgent(cfg, filterSChan, shdChan, nil, srvDep)
agentSrv, err := agents.NewDNSAgent(cfg, nil, nil)
if err != nil {
t.Fatal(err)
}
runtime.Gosched()
dnsSrv := srv.(*DNSAgent)
dnsSrv.dns = agentSrv
err = dnsSrv.Reload()
if err == nil || err.Error() != "dns: server not started" {
t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", "dns: server not started", err)
}
}
func TestDNSAgentReload4(t *testing.T) {
cfg := config.NewDefaultCGRConfig()
cfg.SessionSCfg().Enabled = true
@@ -255,7 +243,6 @@ func TestDNSAgentReload5(t *testing.T) {
if err != nil {
t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
}
srv.(*DNSAgent).oldListen = "127.0.0.1:2093"
time.Sleep(10 * time.Millisecond)
runtime.Gosched()
runtime.Gosched()
@@ -282,7 +269,6 @@ func TestDNSAgentReload6(t *testing.T) {
if err != nil {
t.Fatalf("\nExpected <%+v>, \nReceived <%+v>", nil, err)
}
srv.(*DNSAgent).oldListen = "127.0.0.1:2093"
cfg.DNSAgentCfg().Listeners[0].Network = "tls"
cfg.TLSCfg().ServerCerificate = "bad_certificate"
cfg.TLSCfg().ServerKey = "bad_key"

1
services/dnsagent_test.go
View File

@@ -49,6 +49,7 @@ func TestDNSAgentCoverage(t *testing.T) {
cfg: cfg,
filterSChan: filterSChan,
shdChan: shdChan,
stopChan: make(chan struct{}),
connMgr: nil,
srvDep: srvDep,
dns: dns,