From 099ae99836a237794988dac40f4398e4a00e6486 Mon Sep 17 00:00:00 2001 From: Trial97 Date: Wed, 21 Apr 2021 12:23:08 +0300 Subject: [PATCH] Added some diff functions --- cmd/cgr-engine/cgr-engine.go | 16 ++-- config/cdrscfg.go | 93 +++++++++++++++------- config/config.go | 2 +- config/config_test.go | 24 +++--- config/datadbcfg.go | 122 ++++++++++++++++++++++++++--- config/erscfg.go | 14 ++-- config/fctemplate.go | 121 ++++++++++++++++++++++++++++ config/filterscfg.go | 38 ++++++--- config/generalcfg.go | 104 +++++++++++++++++++++++++ config/httpcfg.go | 114 ++++++++++++++++++++------- config/httpcfg_test.go | 30 +++---- config/libconfig_json.go | 130 ------------------------------- config/listencfg.go | 35 +++++++++ config/rsrparser.go | 8 ++ config/stordbcfg.go | 46 ++++++++++- config/tlscfg.go | 38 +++++++++ cores/server_it_test.go | 72 ++++++++--------- engine/cdrs.go | 4 +- registrarc/libregistrarc.go | 2 +- registrarc/libregistrarc_test.go | 2 +- utils/map.go | 12 +++ utils/slice.go | 12 +++ 22 files changed, 744 insertions(+), 295 deletions(-) diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go index 04fc4ad9b..370f18b06 100644 --- a/cmd/cgr-engine/cgr-engine.go +++ b/cmd/cgr-engine/cgr-engine.go @@ -202,10 +202,10 @@ func startRPC(server *cores.Server, internalAdminSChan, go server.ServeGOB(cfg.ListenCfg().RPCGOBListen, shdChan) go server.ServeHTTP( cfg.ListenCfg().HTTPListen, - cfg.HTTPCfg().HTTPJsonRPCURL, - cfg.HTTPCfg().HTTPWSURL, - cfg.HTTPCfg().HTTPUseBasicAuth, - cfg.HTTPCfg().HTTPAuthUsers, + cfg.HTTPCfg().JsonRPCURL, + cfg.HTTPCfg().WSURL, + cfg.HTTPCfg().UseBasicAuth, + cfg.HTTPCfg().AuthUsers, shdChan, ) if (len(cfg.ListenCfg().RPCGOBTLSListen) != 0 || @@ -246,10 +246,10 @@ func startRPC(server *cores.Server, internalAdminSChan, cfg.TLSCfg().CaCertificate, cfg.TLSCfg().ServerPolicy, cfg.TLSCfg().ServerName, - cfg.HTTPCfg().HTTPJsonRPCURL, - cfg.HTTPCfg().HTTPWSURL, - cfg.HTTPCfg().HTTPUseBasicAuth, - cfg.HTTPCfg().HTTPAuthUsers, + cfg.HTTPCfg().JsonRPCURL, + cfg.HTTPCfg().WSURL, + cfg.HTTPCfg().UseBasicAuth, + cfg.HTTPCfg().AuthUsers, shdChan, ) } diff --git a/config/cdrscfg.go b/config/cdrscfg.go index dd1374973..d20f94711 100644 --- a/config/cdrscfg.go +++ b/config/cdrscfg.go @@ -215,47 +215,84 @@ func (cdrscfg CdrsCfg) Clone() (cln *CdrsCfg) { SMCostRetries: cdrscfg.SMCostRetries, } if cdrscfg.ChargerSConns != nil { - cln.ChargerSConns = make([]string, len(cdrscfg.ChargerSConns)) - for i, con := range cdrscfg.ChargerSConns { - cln.ChargerSConns[i] = con - } + cln.ChargerSConns = utils.CloneStringSlice(cdrscfg.ChargerSConns) } if cdrscfg.AttributeSConns != nil { - cln.AttributeSConns = make([]string, len(cdrscfg.AttributeSConns)) - for i, con := range cdrscfg.AttributeSConns { - cln.AttributeSConns[i] = con - } + cln.AttributeSConns = utils.CloneStringSlice(cdrscfg.AttributeSConns) } if cdrscfg.ThresholdSConns != nil { - cln.ThresholdSConns = make([]string, len(cdrscfg.ThresholdSConns)) - for i, con := range cdrscfg.ThresholdSConns { - cln.ThresholdSConns[i] = con - } + cln.ThresholdSConns = utils.CloneStringSlice(cdrscfg.ThresholdSConns) } if cdrscfg.StatSConns != nil { - cln.StatSConns = make([]string, len(cdrscfg.StatSConns)) - for i, con := range cdrscfg.StatSConns { - cln.StatSConns[i] = con - } + cln.StatSConns = utils.CloneStringSlice(cdrscfg.StatSConns) } if cdrscfg.OnlineCDRExports != nil { - cln.OnlineCDRExports = make([]string, len(cdrscfg.OnlineCDRExports)) - for i, con := range cdrscfg.OnlineCDRExports { - cln.OnlineCDRExports[i] = con - } + cln.OnlineCDRExports = utils.CloneStringSlice(cdrscfg.OnlineCDRExports) } if cdrscfg.ActionSConns != nil { - cln.ActionSConns = make([]string, len(cdrscfg.ActionSConns)) - for i, con := range cdrscfg.ActionSConns { - cln.ActionSConns[i] = con - } + cln.ActionSConns = utils.CloneStringSlice(cdrscfg.ActionSConns) } if cdrscfg.EEsConns != nil { - cln.EEsConns = make([]string, len(cdrscfg.EEsConns)) - for i, con := range cdrscfg.EEsConns { - cln.EEsConns[i] = con - } + cln.EEsConns = utils.CloneStringSlice(cdrscfg.EEsConns) } return } + +// Cdrs config section +type CdrsJsonCfg struct { + Enabled *bool + Extra_fields *[]string + Store_cdrs *bool + Session_cost_retries *int + Chargers_conns *[]string + Attributes_conns *[]string + Thresholds_conns *[]string + Stats_conns *[]string + Online_cdr_exports *[]string + Actions_conns *[]string + Ees_conns *[]string +} + +func diffCdrsJsonCfg(d *CdrsJsonCfg, v1, v2 *CdrsCfg) *CdrsJsonCfg { + if d == nil { + d = new(CdrsJsonCfg) + } + + if v1.Enabled != v2.Enabled { + d.Enabled = utils.BoolPointer(v2.Enabled) + } + extra1 := v1.ExtraFields.AsStringSlice() + extra2 := v2.ExtraFields.AsStringSlice() + if !utils.SliceStringEqual(extra1, extra2) { + d.Extra_fields = &extra2 + } + if v1.StoreCdrs != v2.StoreCdrs { + d.Store_cdrs = utils.BoolPointer(v2.StoreCdrs) + } + if v1.SMCostRetries != v2.SMCostRetries { + d.Session_cost_retries = utils.IntPointer(v2.SMCostRetries) + } + if !utils.SliceStringEqual(v1.ChargerSConns, v2.ChargerSConns) { + d.Chargers_conns = &v2.ChargerSConns + } + if !utils.SliceStringEqual(v1.AttributeSConns, v2.AttributeSConns) { + d.Attributes_conns = &v2.AttributeSConns + } + if !utils.SliceStringEqual(v1.ThresholdSConns, v2.ThresholdSConns) { + d.Thresholds_conns = &v2.ThresholdSConns + } + if !utils.SliceStringEqual(v1.StatSConns, v2.StatSConns) { + d.Stats_conns = &v2.StatSConns + } + if !utils.SliceStringEqual(v1.OnlineCDRExports, v2.OnlineCDRExports) { + d.Online_cdr_exports = &v2.OnlineCDRExports + } + if !utils.SliceStringEqual(v1.ActionSConns, v2.ActionSConns) { + d.Actions_conns = &v2.ActionSConns + } + if !utils.SliceStringEqual(v1.EEsConns, v2.EEsConns) { + d.Ees_conns = &v2.EEsConns + } + return d +} diff --git a/config/config.go b/config/config.go index 9094de40c..31bd3fd29 100644 --- a/config/config.go +++ b/config/config.go @@ -1653,6 +1653,6 @@ func (cfg *CGRConfig) GetDataProvider() utils.DataProvider { cfg.cacheDP = cfg.AsMapInterface(cfg.GeneralCfg().RSRSep) } mp := cfg.cacheDP.Clone() - cfg.cacheDPMux.Unlock() + cfg.cacheDPMux.RUnlock() return mp } diff --git a/config/config_test.go b/config/config_test.go index 57bbc5b10..798d97871 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -852,23 +852,23 @@ func TestCgrCfgJSONDefaultsSureTax(t *testing.T) { } func TestCgrCfgJSONDefaultsHTTP(t *testing.T) { - if cgrCfg.HTTPCfg().HTTPJsonRPCURL != "/jsonrpc" { - t.Errorf("expecting: /jsonrpc , received: %+v", cgrCfg.HTTPCfg().HTTPJsonRPCURL) + if cgrCfg.HTTPCfg().JsonRPCURL != "/jsonrpc" { + t.Errorf("expecting: /jsonrpc , received: %+v", cgrCfg.HTTPCfg().JsonRPCURL) } - if cgrCfg.HTTPCfg().HTTPWSURL != "/ws" { - t.Errorf("expecting: /ws , received: %+v", cgrCfg.HTTPCfg().HTTPWSURL) + if cgrCfg.HTTPCfg().WSURL != "/ws" { + t.Errorf("expecting: /ws , received: %+v", cgrCfg.HTTPCfg().WSURL) } - if cgrCfg.HTTPCfg().HTTPFreeswitchCDRsURL != "/freeswitch_json" { - t.Errorf("expecting: /freeswitch_json , received: %+v", cgrCfg.HTTPCfg().HTTPFreeswitchCDRsURL) + if cgrCfg.HTTPCfg().FreeswitchCDRsURL != "/freeswitch_json" { + t.Errorf("expecting: /freeswitch_json , received: %+v", cgrCfg.HTTPCfg().FreeswitchCDRsURL) } - if cgrCfg.HTTPCfg().HTTPCDRsURL != "/cdr_http" { - t.Errorf("expecting: /cdr_http , received: %+v", cgrCfg.HTTPCfg().HTTPCDRsURL) + if cgrCfg.HTTPCfg().CDRsURL != "/cdr_http" { + t.Errorf("expecting: /cdr_http , received: %+v", cgrCfg.HTTPCfg().CDRsURL) } - if cgrCfg.HTTPCfg().HTTPUseBasicAuth != false { - t.Errorf("expecting: false , received: %+v", cgrCfg.HTTPCfg().HTTPUseBasicAuth) + if cgrCfg.HTTPCfg().UseBasicAuth != false { + t.Errorf("expecting: false , received: %+v", cgrCfg.HTTPCfg().UseBasicAuth) } - if !reflect.DeepEqual(cgrCfg.HTTPCfg().HTTPAuthUsers, map[string]string{}) { - t.Errorf("expecting: %+v , received: %+v", map[string]string{}, cgrCfg.HTTPCfg().HTTPAuthUsers) + if !reflect.DeepEqual(cgrCfg.HTTPCfg().AuthUsers, map[string]string{}) { + t.Errorf("expecting: %+v , received: %+v", map[string]string{}, cgrCfg.HTTPCfg().AuthUsers) } } diff --git a/config/datadbcfg.go b/config/datadbcfg.go index 903ea3160..ac14b13b8 100644 --- a/config/datadbcfg.go +++ b/config/datadbcfg.go @@ -91,7 +91,7 @@ func (dbcfg *DataDbCfg) loadFromJSONCfg(jsnDbCfg *DbJsonCfg) (err error) { } } if jsnDbCfg.Items != nil { - for kJsn, vJsn := range *jsnDbCfg.Items { + for kJsn, vJsn := range jsnDbCfg.Items { val, has := dbcfg.Items[kJsn] if val == nil || !has { val = new(ItemOpt) @@ -140,16 +140,10 @@ func (dbcfg *DataDbCfg) Clone() (cln *DataDbCfg) { } if dbcfg.RmtConns != nil { - cln.RmtConns = make([]string, len(dbcfg.RmtConns)) - for i, conn := range dbcfg.RmtConns { - cln.RmtConns[i] = conn - } + cln.RmtConns = utils.CloneStringSlice(dbcfg.RmtConns) } if dbcfg.RplConns != nil { - cln.RplConns = make([]string, len(dbcfg.RplConns)) - for i, conn := range dbcfg.RplConns { - cln.RplConns[i] = conn - } + cln.RplConns = utils.CloneStringSlice(dbcfg.RplConns) } return } @@ -237,3 +231,113 @@ func (itm *ItemOpt) Clone() *ItemOpt { RouteID: itm.RouteID, } } + +func (itm *ItemOpt) Equals(itm2 *ItemOpt) bool { + return (itm == nil && itm2 == nil) || + (itm != nil && itm2 != nil && + itm.Remote != itm2.Remote && + itm.Replicate != itm2.Replicate && + itm.RouteID != itm2.RouteID && + itm.APIKey != itm2.APIKey) +} + +type ItemOptJson struct { + Remote *bool + Replicate *bool + // used for ArgDispatcher in case we send this to a dispatcher engine + Route_id *string + Api_key *string +} + +func diffItemOptJson(d *ItemOptJson, v1, v2 *ItemOpt) *ItemOptJson { + if d == nil { + d = new(ItemOptJson) + } + if v2.Remote != v1.Remote { + d.Remote = utils.BoolPointer(v2.Remote) + } + if v2.Replicate != v1.Replicate { + d.Replicate = utils.BoolPointer(v2.Replicate) + } + if v2.RouteID != v1.RouteID { + d.Route_id = utils.StringPointer(v2.RouteID) + } + if v2.APIKey != v1.APIKey { + d.Api_key = utils.StringPointer(v2.APIKey) + } + return d +} + +func diffMapItemOptJson(d map[string]*ItemOptJson, v1, v2 map[string]*ItemOpt) map[string]*ItemOptJson { + if d == nil { + d = make(map[string]*ItemOptJson) + } + for k, val2 := range v2 { + if val1, has := v1[k]; !has || !val1.Equals(val2) { + d[k] = diffItemOptJson(d[k], val2, val2) + } + } + return d +} + +// Database config +type DbJsonCfg struct { + Db_type *string + Db_host *string + Db_port *int + Db_name *string + Db_user *string + Db_password *string + String_indexed_fields *[]string + Prefix_indexed_fields *[]string + Remote_conns *[]string + Remote_conn_id *string + Replication_conns *[]string + Replication_filtered *bool + Replication_cache *string + Items map[string]*ItemOptJson + Opts map[string]interface{} +} + +func diffDataDbJsonCfg(d *DbJsonCfg, v1, v2 *DataDbCfg) *DbJsonCfg { + if d == nil { + d = new(DbJsonCfg) + } + if v1.Type != v2.Type { + d.Db_type = utils.StringPointer(v2.Type) + } + if v1.Host != v2.Host { + d.Db_host = utils.StringPointer(v2.Host) + } + if v1.Port != v2.Port { + port, _ := strconv.Atoi(v2.Port) + d.Db_port = utils.IntPointer(port) + } + if v1.Name != v2.Name { + d.Db_name = utils.StringPointer(v2.Name) + } + if v1.User != v2.User { + d.Db_user = utils.StringPointer(v2.User) + } + if v1.Password != v2.Password { + d.Db_password = utils.StringPointer(v2.Password) + } + if !utils.SliceStringEqual(v1.RmtConns, v2.RmtConns) { + d.Remote_conns = &v2.RmtConns + } + if v1.RmtConnID != v2.RmtConnID { + d.Remote_conn_id = utils.StringPointer(v2.RmtConnID) + } + if !utils.SliceStringEqual(v1.RplConns, v2.RplConns) { + d.Replication_conns = &v2.RplConns + } + if v1.RplFiltered != v2.RplFiltered { + d.Replication_filtered = utils.BoolPointer(v2.RplFiltered) + } + if v1.RplCache != v2.RplCache { + d.Replication_cache = utils.StringPointer(v2.RplCache) + } + d.Items = diffMapItemOptJson(d.Items, v1.Items, v2.Items) + d.Opts = diffMap(d.Opts, v1.Opts, v2.Opts) + return d +} diff --git a/config/erscfg.go b/config/erscfg.go index b820e5d5a..65d08bde5 100644 --- a/config/erscfg.go +++ b/config/erscfg.go @@ -86,12 +86,11 @@ func (erS *ERsCfg) appendERsReaders(jsnReaders *[]*EventReaderJsonCfg, msgTempla // Clone returns a deep copy of ERsCfg func (erS *ERsCfg) Clone() (cln *ERsCfg) { cln = &ERsCfg{ - Enabled: erS.Enabled, - SessionSConns: make([]string, len(erS.SessionSConns)), - Readers: make([]*EventReaderCfg, len(erS.Readers)), + Enabled: erS.Enabled, + Readers: make([]*EventReaderCfg, len(erS.Readers)), } - for idx, sConn := range erS.SessionSConns { - cln.SessionSConns[idx] = sConn + if erS.SessionSConns != nil { + cln.SessionSConns = utils.CloneStringSlice(erS.SessionSConns) } for idx, rdr := range erS.Readers { cln.Readers[idx] = rdr.Clone() @@ -261,10 +260,7 @@ func (er EventReaderCfg) Clone() (cln *EventReaderCfg) { Opts: make(map[string]interface{}), } if er.Filters != nil { - cln.Filters = make([]string, len(er.Filters)) - for idx, val := range er.Filters { - cln.Filters[idx] = val - } + cln.Filters = utils.CloneStringSlice(er.Filters) } if er.Fields != nil { cln.Fields = make([]*FCTemplate, len(er.Fields)) diff --git a/config/fctemplate.go b/config/fctemplate.go index 9712903ab..5f9474014 100644 --- a/config/fctemplate.go +++ b/config/fctemplate.go @@ -290,3 +290,124 @@ func (sCft FcTemplates) Clone() (cln FcTemplates) { } return } + +func (fc *FCTemplate) Equals(fc2 *FCTemplate) bool { + return (fc == nil && fc2 == nil) || + (fc != nil && fc2 != nil && + fc.Tag != fc2.Tag && + fc.Type != fc2.Type && + fc.Path != fc2.Path && + utils.SliceStringEqual(fc.Filters, fc2.Filters) && + utils.SliceStringEqual(fc.Value.AsStringSlice(), fc2.Value.AsStringSlice()) && + fc.Width != fc2.Width && + fc.Strip != fc2.Strip && + fc.Padding != fc2.Padding && + fc.Mandatory != fc2.Mandatory && + fc.AttributeID != fc2.AttributeID && + fc.NewBranch != fc2.NewBranch && + fc.Timezone != fc2.Timezone && + fc.Blocker != fc2.Blocker && + fc.Layout != fc2.Layout && + fc.CostShiftDigits != fc2.CostShiftDigits && + fc.RoundingDecimals != fc2.RoundingDecimals && + fc.MaskDestID != fc2.MaskDestID && + fc.MaskLen != fc2.MaskLen) +} + +type FcTemplatesJsonCfg map[string][]*FcTemplateJsonCfg +type FcTemplateJsonCfg struct { + Tag *string + Type *string + Path *string + Attribute_id *string + Filters *[]string + Value *string + Width *int + Strip *string + Padding *string + Mandatory *bool + New_branch *bool + Timezone *string + Blocker *bool + Layout *string + Cost_shift_digits *int + Rounding_decimals *int + Mask_destinationd_id *string + Mask_length *int +} + +func fcTemplatesEqual(v1, v2 []*FCTemplate) bool { + if len(v1) != len(v2) { + return false + } + for i := range v1 { + if !v1[i].Equals(v2[i]) { + return false + } + } + return true +} + +func diffFcTemplateJsonCfg(d []*FcTemplateJsonCfg, v1, v2 []*FCTemplate, separator string) []*FcTemplateJsonCfg { + if !fcTemplatesEqual(v1, v2) { + d = make([]*FcTemplateJsonCfg, len(v2)) + for i, v := range v2 { + d[i] = new(FcTemplateJsonCfg) + if v.Tag != utils.EmptyString { + d[i].Tag = utils.StringPointer(v.Tag) + } + if v.Type != utils.EmptyString { + d[i].Type = utils.StringPointer(v.Type) + } + if v.Path != utils.EmptyString { + d[i].Path = utils.StringPointer(v.Path) + } + if v.Filters != nil { + d[i].Filters = &v.Filters + } + if v.Value != nil { + d[i].Value = utils.StringPointer(v.Value.GetRule(separator)) + } + if v.Width != 0 { + d[i].Width = utils.IntPointer(v.Width) + } + if v.Strip != utils.EmptyString { + d[i].Strip = utils.StringPointer(v.Strip) + } + if v.Padding != utils.EmptyString { + d[i].Padding = utils.StringPointer(v.Padding) + } + if v.Mandatory { + d[i].Mandatory = utils.BoolPointer(v.Mandatory) + } + if v.AttributeID != utils.EmptyString { + d[i].Attribute_id = utils.StringPointer(v.AttributeID) + } + if v.NewBranch { + d[i].New_branch = utils.BoolPointer(v.NewBranch) + } + if v.Timezone != utils.EmptyString { + d[i].Timezone = utils.StringPointer(v.Timezone) + } + if v.Blocker { + d[i].Blocker = utils.BoolPointer(v.Blocker) + } + if v.Layout != time.RFC3339 { + d[i].Layout = utils.StringPointer(v.Layout) + } + if v.CostShiftDigits != 0 { + d[i].Cost_shift_digits = utils.IntPointer(v.CostShiftDigits) + } + if v.RoundingDecimals != nil { + d[i].Rounding_decimals = utils.IntPointer(*v.RoundingDecimals) + } + if v.MaskDestID != utils.EmptyString { + d[i].Mask_destinationd_id = utils.StringPointer(v.MaskDestID) + } + if v.MaskLen != 0 { + d[i].Mask_length = utils.IntPointer(v.MaskLen) + } + } + } + return d +} diff --git a/config/filterscfg.go b/config/filterscfg.go index 803e02339..ae0c75d0c 100644 --- a/config/filterscfg.go +++ b/config/filterscfg.go @@ -106,22 +106,36 @@ func (fSCfg *FilterSCfg) AsMapInterface() (initialMP map[string]interface{}) { func (fSCfg FilterSCfg) Clone() (cln *FilterSCfg) { cln = new(FilterSCfg) if fSCfg.StatSConns != nil { - cln.StatSConns = make([]string, len(fSCfg.StatSConns)) - for i, con := range fSCfg.StatSConns { - cln.StatSConns[i] = con - } + cln.StatSConns = utils.CloneStringSlice(fSCfg.StatSConns) } if fSCfg.ResourceSConns != nil { - cln.ResourceSConns = make([]string, len(fSCfg.ResourceSConns)) - for i, con := range fSCfg.ResourceSConns { - cln.ResourceSConns[i] = con - } + cln.ResourceSConns = utils.CloneStringSlice(fSCfg.ResourceSConns) } if fSCfg.ApierSConns != nil { - cln.ApierSConns = make([]string, len(fSCfg.ApierSConns)) - for i, con := range fSCfg.ApierSConns { - cln.ApierSConns[i] = con - } + cln.ApierSConns = utils.CloneStringSlice(fSCfg.ApierSConns) } return } + +// Filters config +type FilterSJsonCfg struct { + Stats_conns *[]string + Resources_conns *[]string + Apiers_conns *[]string +} + +func diffFilterSJsonCfg(d *FilterSJsonCfg, v1, v2 *FilterSCfg) *FilterSJsonCfg { + if d == nil { + d = new(FilterSJsonCfg) + } + if !utils.SliceStringEqual(v1.StatSConns, v2.StatSConns) { + d.Stats_conns = &v2.StatSConns + } + if !utils.SliceStringEqual(v1.ResourceSConns, v2.ResourceSConns) { + d.Resources_conns = &v2.ResourceSConns + } + if !utils.SliceStringEqual(v1.ApierSConns, v2.ApierSConns) { + d.Apiers_conns = &v2.ApierSConns + } + return d +} diff --git a/config/generalcfg.go b/config/generalcfg.go index 9ef0c4e77..5131cde0c 100644 --- a/config/generalcfg.go +++ b/config/generalcfg.go @@ -214,3 +214,107 @@ func (gencfg GeneralCfg) Clone() *GeneralCfg { MaxParallelConns: gencfg.MaxParallelConns, } } + +// General config section +type GeneralJsonCfg struct { + Node_id *string + Logger *string + Log_level *int + Rounding_decimals *int + Dbdata_encoding *string + Tpexport_dir *string + Poster_attempts *int + Failed_posts_dir *string + Failed_posts_ttl *string + Default_request_type *string + Default_category *string + Default_tenant *string + Default_timezone *string + Default_caching *string + Connect_attempts *int + Reconnects *int + Connect_timeout *string + Reply_timeout *string + Locking_timeout *string + Digest_separator *string + Digest_equal *string + Rsr_separator *string + Max_parallel_conns *int +} + +func diffGeneralJsonCfg(d *GeneralJsonCfg, v1, v2 *GeneralCfg) *GeneralJsonCfg { + if d == nil { + d = new(GeneralJsonCfg) + } + + if v1.NodeID != v2.NodeID { + d.Node_id = utils.StringPointer(v2.NodeID) + } + if v1.Logger != v2.Logger { + d.Logger = utils.StringPointer(v2.Logger) + } + if v1.LogLevel != v2.LogLevel { + d.Log_level = utils.IntPointer(v2.LogLevel) + } + if v1.RoundingDecimals != v2.RoundingDecimals { + d.Rounding_decimals = utils.IntPointer(v2.RoundingDecimals) + } + if v1.DBDataEncoding != v2.DBDataEncoding { + d.Dbdata_encoding = utils.StringPointer(v2.DBDataEncoding) + } + if v1.TpExportPath != v2.TpExportPath { + d.Tpexport_dir = utils.StringPointer(v2.TpExportPath) + } + if v1.PosterAttempts != v2.PosterAttempts { + d.Poster_attempts = utils.IntPointer(v2.PosterAttempts) + } + if v1.FailedPostsDir != v2.FailedPostsDir { + d.Failed_posts_dir = utils.StringPointer(v2.FailedPostsDir) + } + if v1.FailedPostsTTL != v2.FailedPostsTTL { + d.Failed_posts_ttl = utils.StringPointer(v2.FailedPostsTTL.String()) + } + if v1.DefaultReqType != v2.DefaultReqType { + d.Default_request_type = utils.StringPointer(v2.DefaultReqType) + } + if v1.DefaultCategory != v2.DefaultCategory { + d.Default_category = utils.StringPointer(v2.DefaultCategory) + } + if v1.DefaultTenant != v2.DefaultTenant { + d.Default_tenant = utils.StringPointer(v2.DefaultTenant) + } + if v1.DefaultTimezone != v2.DefaultTimezone { + d.Default_timezone = utils.StringPointer(v2.DefaultTimezone) + } + if v1.DefaultCaching != v2.DefaultCaching { + d.Default_caching = utils.StringPointer(v2.DefaultCaching) + } + if v1.ConnectAttempts != v2.ConnectAttempts { + d.Connect_attempts = utils.IntPointer(v2.ConnectAttempts) + } + if v1.Reconnects != v2.Reconnects { + d.Reconnects = utils.IntPointer(v2.Reconnects) + } + if v1.ConnectTimeout != v2.ConnectTimeout { + d.Connect_timeout = utils.StringPointer(v2.ConnectTimeout.String()) + } + if v1.ReplyTimeout != v2.ReplyTimeout { + d.Reply_timeout = utils.StringPointer(v2.ReplyTimeout.String()) + } + if v1.LockingTimeout != v2.LockingTimeout { + d.Locking_timeout = utils.StringPointer(v2.LockingTimeout.String()) + } + if v1.DigestSeparator != v2.DigestSeparator { + d.Digest_separator = utils.StringPointer(v2.DigestSeparator) + } + if v1.DigestEqual != v2.DigestEqual { + d.Digest_equal = utils.StringPointer(v2.DigestEqual) + } + if v1.RSRSep != v2.RSRSep { + d.Rsr_separator = utils.StringPointer(v2.RSRSep) + } + if v1.MaxParallelConns != v2.MaxParallelConns { + d.Max_parallel_conns = utils.IntPointer(v2.MaxParallelConns) + } + return d +} diff --git a/config/httpcfg.go b/config/httpcfg.go index ba83e5f7b..aa15e5399 100644 --- a/config/httpcfg.go +++ b/config/httpcfg.go @@ -24,14 +24,14 @@ import ( // HTTPCfg is the HTTP config section type HTTPCfg struct { - HTTPJsonRPCURL string // JSON RPC relative URL ("" to disable) - RegistrarSURL string // registrar service relative URL - HTTPWSURL string // WebSocket relative URL ("" to disable) - HTTPFreeswitchCDRsURL string // Freeswitch CDRS relative URL ("" to disable) - HTTPCDRsURL string // CDRS relative URL ("" to disable) - HTTPUseBasicAuth bool // Use basic auth for HTTP API - HTTPAuthUsers map[string]string // Basic auth user:password map (base64 passwords) - ClientOpts map[string]interface{} + JsonRPCURL string // JSON RPC relative URL ("" to disable) + RegistrarSURL string // registrar service relative URL + WSURL string // WebSocket relative URL ("" to disable) + FreeswitchCDRsURL string // Freeswitch CDRS relative URL ("" to disable) + CDRsURL string // CDRS relative URL ("" to disable) + UseBasicAuth bool // Use basic auth for HTTP API + AuthUsers map[string]string // Basic auth user:password map (base64 passwords) + ClientOpts map[string]interface{} } // loadFromJSONCfg loads Database config from JsonCfg @@ -40,25 +40,25 @@ func (httpcfg *HTTPCfg) loadFromJSONCfg(jsnHTTPCfg *HTTPJsonCfg) (err error) { return nil } if jsnHTTPCfg.Json_rpc_url != nil { - httpcfg.HTTPJsonRPCURL = *jsnHTTPCfg.Json_rpc_url + httpcfg.JsonRPCURL = *jsnHTTPCfg.Json_rpc_url } if jsnHTTPCfg.Registrars_url != nil { httpcfg.RegistrarSURL = *jsnHTTPCfg.Registrars_url } if jsnHTTPCfg.Ws_url != nil { - httpcfg.HTTPWSURL = *jsnHTTPCfg.Ws_url + httpcfg.WSURL = *jsnHTTPCfg.Ws_url } if jsnHTTPCfg.Freeswitch_cdrs_url != nil { - httpcfg.HTTPFreeswitchCDRsURL = *jsnHTTPCfg.Freeswitch_cdrs_url + httpcfg.FreeswitchCDRsURL = *jsnHTTPCfg.Freeswitch_cdrs_url } if jsnHTTPCfg.Http_Cdrs != nil { - httpcfg.HTTPCDRsURL = *jsnHTTPCfg.Http_Cdrs + httpcfg.CDRsURL = *jsnHTTPCfg.Http_Cdrs } if jsnHTTPCfg.Use_basic_auth != nil { - httpcfg.HTTPUseBasicAuth = *jsnHTTPCfg.Use_basic_auth + httpcfg.UseBasicAuth = *jsnHTTPCfg.Use_basic_auth } if jsnHTTPCfg.Auth_users != nil { - httpcfg.HTTPAuthUsers = *jsnHTTPCfg.Auth_users + httpcfg.AuthUsers = *jsnHTTPCfg.Auth_users } if jsnHTTPCfg.Client_opts != nil { for k, v := range jsnHTTPCfg.Client_opts { @@ -75,13 +75,13 @@ func (httpcfg *HTTPCfg) AsMapInterface() map[string]interface{} { clientOpts[k] = v } return map[string]interface{}{ - utils.HTTPJsonRPCURLCfg: httpcfg.HTTPJsonRPCURL, + utils.HTTPJsonRPCURLCfg: httpcfg.JsonRPCURL, utils.RegistrarSURLCfg: httpcfg.RegistrarSURL, - utils.HTTPWSURLCfg: httpcfg.HTTPWSURL, - utils.HTTPFreeswitchCDRsURLCfg: httpcfg.HTTPFreeswitchCDRsURL, - utils.HTTPCDRsURLCfg: httpcfg.HTTPCDRsURL, - utils.HTTPUseBasicAuthCfg: httpcfg.HTTPUseBasicAuth, - utils.HTTPAuthUsersCfg: httpcfg.HTTPAuthUsers, + utils.HTTPWSURLCfg: httpcfg.WSURL, + utils.HTTPFreeswitchCDRsURLCfg: httpcfg.FreeswitchCDRsURL, + utils.HTTPCDRsURLCfg: httpcfg.CDRsURL, + utils.HTTPUseBasicAuthCfg: httpcfg.UseBasicAuth, + utils.HTTPAuthUsersCfg: httpcfg.AuthUsers, utils.HTTPClientOptsCfg: clientOpts, } } @@ -89,20 +89,74 @@ func (httpcfg *HTTPCfg) AsMapInterface() map[string]interface{} { // Clone returns a deep copy of HTTPCfg func (httpcfg HTTPCfg) Clone() (cln *HTTPCfg) { cln = &HTTPCfg{ - HTTPJsonRPCURL: httpcfg.HTTPJsonRPCURL, - RegistrarSURL: httpcfg.RegistrarSURL, - HTTPWSURL: httpcfg.HTTPWSURL, - HTTPFreeswitchCDRsURL: httpcfg.HTTPFreeswitchCDRsURL, - HTTPCDRsURL: httpcfg.HTTPCDRsURL, - HTTPUseBasicAuth: httpcfg.HTTPUseBasicAuth, - HTTPAuthUsers: make(map[string]string), - ClientOpts: make(map[string]interface{}), + JsonRPCURL: httpcfg.JsonRPCURL, + RegistrarSURL: httpcfg.RegistrarSURL, + WSURL: httpcfg.WSURL, + FreeswitchCDRsURL: httpcfg.FreeswitchCDRsURL, + CDRsURL: httpcfg.CDRsURL, + UseBasicAuth: httpcfg.UseBasicAuth, + AuthUsers: make(map[string]string), + ClientOpts: make(map[string]interface{}), } - for u, a := range httpcfg.HTTPAuthUsers { - cln.HTTPAuthUsers[u] = a + for u, a := range httpcfg.AuthUsers { + cln.AuthUsers[u] = a } for o, val := range httpcfg.ClientOpts { cln.ClientOpts[o] = val } return } + +// HTTP config section +type HTTPJsonCfg struct { + Json_rpc_url *string + Registrars_url *string + Ws_url *string + Freeswitch_cdrs_url *string + Http_Cdrs *string + Use_basic_auth *bool + Auth_users *map[string]string + Client_opts map[string]interface{} +} + +func diffHTTPJsonCfg(d *HTTPJsonCfg, v1, v2 *HTTPCfg) *HTTPJsonCfg { + if d == nil { + d = new(HTTPJsonCfg) + } + + if v1.JsonRPCURL != v2.JsonRPCURL { + d.Json_rpc_url = utils.StringPointer(v2.JsonRPCURL) + } + if v1.RegistrarSURL != v2.RegistrarSURL { + d.Registrars_url = utils.StringPointer(v2.RegistrarSURL) + } + if v1.WSURL != v2.WSURL { + d.Ws_url = utils.StringPointer(v2.WSURL) + } + if v1.FreeswitchCDRsURL != v2.FreeswitchCDRsURL { + d.Freeswitch_cdrs_url = utils.StringPointer(v2.FreeswitchCDRsURL) + } + if v1.CDRsURL != v2.CDRsURL { + d.Http_Cdrs = utils.StringPointer(v2.CDRsURL) + } + if v1.UseBasicAuth != v2.UseBasicAuth { + d.Use_basic_auth = utils.BoolPointer(v2.UseBasicAuth) + } + if utils.MapStringStringEqual(v1.AuthUsers, v2.AuthUsers) { + d.Auth_users = &v2.AuthUsers + } + d.Client_opts = diffMap(d.Client_opts, v1.ClientOpts, v2.ClientOpts) + return d +} + +func diffMap(d, v1, v2 map[string]interface{}) map[string]interface{} { + if d == nil { + d = make(map[string]interface{}) + } + for k, v := range v2 { + if val, has := v1[k]; !has || val != v { + d[k] = v + } + } + return d +} diff --git a/config/httpcfg_test.go b/config/httpcfg_test.go index e48001caa..520c011a9 100644 --- a/config/httpcfg_test.go +++ b/config/httpcfg_test.go @@ -35,13 +35,13 @@ func TestHTTPCfgloadFromJsonCfg(t *testing.T) { Auth_users: utils.MapStringStringPointer(map[string]string{}), } expected := &HTTPCfg{ - HTTPJsonRPCURL: "/jsonrpc", - HTTPWSURL: "/ws", - RegistrarSURL: "/randomUrl", - HTTPFreeswitchCDRsURL: "/freeswitch_json", - HTTPCDRsURL: "/cdr_http", - HTTPUseBasicAuth: false, - HTTPAuthUsers: map[string]string{}, + JsonRPCURL: "/jsonrpc", + WSURL: "/ws", + RegistrarSURL: "/randomUrl", + FreeswitchCDRsURL: "/freeswitch_json", + CDRsURL: "/cdr_http", + UseBasicAuth: false, + AuthUsers: map[string]string{}, ClientOpts: map[string]interface{}{ utils.HTTPClientTLSClientConfigCfg: false, utils.HTTPClientTLSHandshakeTimeoutCfg: "10s", @@ -149,13 +149,13 @@ func TestHTTPCfgAsMapInterface1(t *testing.T) { func TestHTTPCfgClone(t *testing.T) { ban := &HTTPCfg{ - HTTPJsonRPCURL: "/jsonrpc", - HTTPWSURL: "/ws", - RegistrarSURL: "/randomUrl", - HTTPFreeswitchCDRsURL: "/freeswitch_json", - HTTPCDRsURL: "/cdr_http", - HTTPUseBasicAuth: false, - HTTPAuthUsers: map[string]string{ + JsonRPCURL: "/jsonrpc", + WSURL: "/ws", + RegistrarSURL: "/randomUrl", + FreeswitchCDRsURL: "/freeswitch_json", + CDRsURL: "/cdr_http", + UseBasicAuth: false, + AuthUsers: map[string]string{ "user": "pass", }, ClientOpts: map[string]interface{}{ @@ -169,7 +169,7 @@ func TestHTTPCfgClone(t *testing.T) { if rcv.ClientOpts[utils.HTTPClientTLSClientConfigCfg] = ""; ban.ClientOpts[utils.HTTPClientTLSClientConfigCfg] != false { t.Errorf("Expected clone to not modify the cloned") } - if rcv.HTTPAuthUsers["user"] = ""; ban.HTTPAuthUsers["user"] != "pass" { + if rcv.AuthUsers["user"] = ""; ban.AuthUsers["user"] != "pass" { t.Errorf("Expected clone to not modify the cloned") } } diff --git a/config/libconfig_json.go b/config/libconfig_json.go index 0106c2446..df292ae5c 100644 --- a/config/libconfig_json.go +++ b/config/libconfig_json.go @@ -22,114 +22,6 @@ import ( "encoding/json" ) -// General config section -type GeneralJsonCfg struct { - Node_id *string - Logger *string - Log_level *int - Rounding_decimals *int - Dbdata_encoding *string - Tpexport_dir *string - Poster_attempts *int - Failed_posts_dir *string - Failed_posts_ttl *string - Default_request_type *string - Default_category *string - Default_tenant *string - Default_timezone *string - Default_caching *string - Connect_attempts *int - Reconnects *int - Connect_timeout *string - Reply_timeout *string - Locking_timeout *string - Digest_separator *string - Digest_equal *string - Rsr_separator *string - Max_parallel_conns *int -} - -// Listen config section -type ListenJsonCfg struct { - Rpc_json *string - Rpc_gob *string - Http *string - Rpc_json_tls *string - Rpc_gob_tls *string - Http_tls *string -} - -// HTTP config section -type HTTPJsonCfg struct { - Json_rpc_url *string - Registrars_url *string - Ws_url *string - Freeswitch_cdrs_url *string - Http_Cdrs *string - Use_basic_auth *bool - Auth_users *map[string]string - Client_opts map[string]interface{} -} - -type TlsJsonCfg struct { - Server_certificate *string - Server_key *string - Server_policy *int - Server_name *string - Client_certificate *string - Client_key *string - Ca_certificate *string -} - -// Database config -type DbJsonCfg struct { - Db_type *string - Db_host *string - Db_port *int - Db_name *string - Db_user *string - Db_password *string - String_indexed_fields *[]string - Prefix_indexed_fields *[]string - Remote_conns *[]string - Remote_conn_id *string - Replication_conns *[]string - Replication_filtered *bool - Replication_cache *string - Items *map[string]*ItemOptJson - Opts map[string]interface{} -} - -type ItemOptJson struct { - Remote *bool - Replicate *bool - // used for ArgDispatcher in case we send this to a dispatcher engine - Route_id *string - Api_key *string -} - -// Filters config -type FilterSJsonCfg struct { - Stats_conns *[]string - Resources_conns *[]string - Apiers_conns *[]string -} - -// Cdrs config section -type CdrsJsonCfg struct { - Enabled *bool - Extra_fields *[]string - Store_cdrs *bool - Session_cost_retries *int - Chargers_conns *[]string - Attributes_conns *[]string - Thresholds_conns *[]string - Stats_conns *[]string - Online_cdr_exports *[]string - Actions_conns *[]string - Ees_conns *[]string -} - // EventReaderSJsonCfg contains the configuration of EventReaderService type ERsJsonCfg struct { Enabled *bool @@ -555,28 +447,6 @@ type MigratorCfgJson struct { Out_storDB_opts map[string]interface{} } -type FcTemplatesJsonCfg map[string][]*FcTemplateJsonCfg -type FcTemplateJsonCfg struct { - Tag *string - Type *string - Path *string - Attribute_id *string - Filters *[]string - Value *string - Width *int - Strip *string - Padding *string - Mandatory *bool - New_branch *bool - Timezone *string - Blocker *bool - Layout *string - Cost_shift_digits *int - Rounding_decimals *int - Mask_destinationd_id *string - Mask_length *int -} - // Analyzer service json config section type AnalyzerSJsonCfg struct { Enabled *bool diff --git a/config/listencfg.go b/config/listencfg.go index 95114b2a5..8a69d95f4 100644 --- a/config/listencfg.go +++ b/config/listencfg.go @@ -79,3 +79,38 @@ func (lstcfg ListenCfg) Clone() *ListenCfg { HTTPTLSListen: lstcfg.HTTPTLSListen, } } + +// Listen config section +type ListenJsonCfg struct { + Rpc_json *string + Rpc_gob *string + Http *string + Rpc_json_tls *string + Rpc_gob_tls *string + Http_tls *string +} + +func diffListenJsonCfg(d *ListenJsonCfg, v1, v2 *ListenCfg) *ListenJsonCfg { + if d == nil { + d = new(ListenJsonCfg) + } + if v1.RPCJSONListen != v2.RPCJSONListen { + d.Rpc_json = utils.StringPointer(v2.RPCJSONListen) + } + if v1.RPCGOBListen != v2.RPCGOBListen { + d.Rpc_gob = utils.StringPointer(v2.RPCGOBListen) + } + if v1.HTTPListen != v2.HTTPListen { + d.Http = utils.StringPointer(v2.HTTPListen) + } + if v1.RPCJSONTLSListen != v2.RPCJSONTLSListen { + d.Rpc_json_tls = utils.StringPointer(v2.RPCJSONTLSListen) + } + if v1.RPCGOBTLSListen != v2.RPCGOBTLSListen { + d.Rpc_gob_tls = utils.StringPointer(v2.RPCGOBTLSListen) + } + if v1.HTTPTLSListen != v2.HTTPTLSListen { + d.Http_tls = utils.StringPointer(v2.HTTPTLSListen) + } + return d +} diff --git a/config/rsrparser.go b/config/rsrparser.go index 1186dfbb4..1a8543e48 100644 --- a/config/rsrparser.go +++ b/config/rsrparser.go @@ -192,6 +192,14 @@ func (prsrs RSRParsers) Clone() (cln RSRParsers) { return } +func (prsrs RSRParsers) AsStringSlice() (v []string) { + v = make([]string, len(prsrs)) + for i, val := range prsrs { + v[i] = val.Rules + } + return +} + // NewRSRParser builds one RSRParser func NewRSRParser(parserRules string) (rsrParser *RSRParser, err error) { if len(parserRules) == 0 { diff --git a/config/stordbcfg.go b/config/stordbcfg.go index 9198f38a5..fe2e73213 100644 --- a/config/stordbcfg.go +++ b/config/stordbcfg.go @@ -99,7 +99,7 @@ func (dbcfg *StorDbCfg) loadFromJSONCfg(jsnDbCfg *DbJsonCfg) (err error) { } } if jsnDbCfg.Items != nil { - for kJsn, vJsn := range *jsnDbCfg.Items { + for kJsn, vJsn := range jsnDbCfg.Items { val := new(ItemOpt) val.loadFromJSONCfg(vJsn) //To review if the function signature changes dbcfg.Items[kJsn] = val @@ -185,3 +185,47 @@ func (dbcfg *StorDbCfg) AsMapInterface() (initialMP map[string]interface{}) { } return } + +func diffStorDBDbJsonCfg(d *DbJsonCfg, v1, v2 *StorDbCfg) *DbJsonCfg { + if d == nil { + d = new(DbJsonCfg) + } + if v1.Type != v2.Type { + d.Db_type = utils.StringPointer(v2.Type) + } + if v1.Host != v2.Host { + d.Db_host = utils.StringPointer(v2.Host) + } + if v1.Port != v2.Port { + port, _ := strconv.Atoi(v2.Port) + d.Db_port = utils.IntPointer(port) + } + if v1.Name != v2.Name { + d.Db_name = utils.StringPointer(v2.Name) + } + if v1.User != v2.User { + d.Db_user = utils.StringPointer(v2.User) + } + if v1.Password != v2.Password { + d.Db_password = utils.StringPointer(v2.Password) + } + if !utils.SliceStringEqual(v1.RmtConns, v2.RmtConns) { + d.Remote_conns = &v2.RmtConns + } + + if !utils.SliceStringEqual(v1.RplConns, v2.RplConns) { + d.Replication_conns = &v2.RplConns + } + + if !utils.SliceStringEqual(v1.StringIndexedFields, v2.StringIndexedFields) { + d.String_indexed_fields = &v2.StringIndexedFields + } + if !utils.SliceStringEqual(v1.PrefixIndexedFields, v2.PrefixIndexedFields) { + d.Prefix_indexed_fields = &v2.PrefixIndexedFields + } + + d.Items = diffMapItemOptJson(d.Items, v1.Items, v2.Items) + d.Opts = diffMap(d.Opts, v1.Opts, v2.Opts) + + return d +} diff --git a/config/tlscfg.go b/config/tlscfg.go index 8fe87332c..cfef16f46 100644 --- a/config/tlscfg.go +++ b/config/tlscfg.go @@ -85,3 +85,41 @@ func (tls TLSCfg) Clone() *TLSCfg { CaCertificate: tls.CaCertificate, } } + +type TlsJsonCfg struct { + Server_certificate *string + Server_key *string + Server_policy *int + Server_name *string + Client_certificate *string + Client_key *string + Ca_certificate *string +} + +func diffTlsJsonCfg(d *TlsJsonCfg, v1, v2 *TLSCfg) *TlsJsonCfg { + if d == nil { + d = new(TlsJsonCfg) + } + if v2.ServerCerificate != v1.ServerCerificate { + d.Server_certificate = utils.StringPointer(v2.ServerCerificate) + } + if v2.ServerKey != v1.ServerKey { + d.Server_key = utils.StringPointer(v2.ServerKey) + } + if v2.ServerPolicy != v1.ServerPolicy { + d.Server_policy = utils.IntPointer(v2.ServerPolicy) + } + if v2.ServerName != v1.ServerName { + d.Server_name = utils.StringPointer(v2.ServerName) + } + if v2.ClientCerificate != v1.ClientCerificate { + d.Client_certificate = utils.StringPointer(v2.ClientCerificate) + } + if v2.ClientKey != v1.ClientKey { + d.Client_key = utils.StringPointer(v2.ClientKey) + } + if v2.CaCertificate != v1.CaCertificate { + d.Ca_certificate = utils.StringPointer(v2.CaCertificate) + } + return d +} diff --git a/cores/server_it_test.go b/cores/server_it_test.go index f32cbc653..f75b37498 100644 --- a/cores/server_it_test.go +++ b/cores/server_it_test.go @@ -226,10 +226,10 @@ func testServeHHTPPass(t *testing.T) { go server.ServeHTTP( ":6555", - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) runtime.Gosched() @@ -247,10 +247,10 @@ func testServeHHTPPassUseBasicAuth(t *testing.T) { go server.ServeHTTP( ":56432", - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - !cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + !cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) runtime.Gosched() @@ -270,8 +270,8 @@ func testServeHHTPEnableHttp(t *testing.T) { ":45779", utils.EmptyString, utils.EmptyString, - !cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + !cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) runtime.Gosched() @@ -289,10 +289,10 @@ func testServeHHTPFail(t *testing.T) { go server.ServeHTTP( "invalid_port_format", - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) runtime.Gosched() @@ -313,10 +313,10 @@ func testServeHHTPFailEnableRpc(t *testing.T) { server.rpcEnabled = false go server.ServeHTTP(":1000", - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) shdChan.CloseOnce() @@ -623,10 +623,10 @@ func testServeHTTPTLS(t *testing.T) { "/usr/share/cgrates/tls/ca.crt", cfgDflt.TLSCfg().ServerPolicy, cfgDflt.TLSCfg().ServerName, - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) //Invalid port address @@ -638,10 +638,10 @@ func testServeHTTPTLS(t *testing.T) { "/usr/share/cgrates/tls/ca.crt", cfgDflt.TLSCfg().ServerPolicy, cfgDflt.TLSCfg().ServerName, - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) runtime.Gosched() @@ -668,10 +668,10 @@ func testServeHTTPTLSWithBasicAuth(t *testing.T) { "/usr/share/cgrates/tls/ca.crt", cfgDflt.TLSCfg().ServerPolicy, cfgDflt.TLSCfg().ServerName, - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - !cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + !cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) runtime.Gosched() @@ -697,10 +697,10 @@ func testServeHTTPTLSError(t *testing.T) { "/usr/share/cgrates/tls/ca.crt", cfgDflt.TLSCfg().ServerPolicy, cfgDflt.TLSCfg().ServerName, - cfgDflt.HTTPCfg().HTTPJsonRPCURL, - cfgDflt.HTTPCfg().HTTPWSURL, - !cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().JsonRPCURL, + cfgDflt.HTTPCfg().WSURL, + !cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) runtime.Gosched() @@ -728,8 +728,8 @@ func testServeHTTPTLSHttpNotEnabled(t *testing.T) { cfgDflt.TLSCfg().ServerName, utils.EmptyString, utils.EmptyString, - cfgDflt.HTTPCfg().HTTPUseBasicAuth, - cfgDflt.HTTPCfg().HTTPAuthUsers, + cfgDflt.HTTPCfg().UseBasicAuth, + cfgDflt.HTTPCfg().AuthUsers, shdChan) shdChan.CloseOnce() diff --git a/engine/cdrs.go b/engine/cdrs.go index 3e6f8f2e0..3cd043b29 100644 --- a/engine/cdrs.go +++ b/engine/cdrs.go @@ -126,8 +126,8 @@ func (cdrS *CDRServer) ListenAndServe(stopChan chan struct{}) { // RegisterHandlersToServer is called by cgr-engine to register HTTP URL handlers func (cdrS *CDRServer) RegisterHandlersToServer(server utils.Server) { - server.RegisterHTTPFunc(cdrS.cgrCfg.HTTPCfg().HTTPCDRsURL, cdrS.cgrCdrHandler) - server.RegisterHTTPFunc(cdrS.cgrCfg.HTTPCfg().HTTPFreeswitchCDRsURL, cdrS.fsCdrHandler) + server.RegisterHTTPFunc(cdrS.cgrCfg.HTTPCfg().CDRsURL, cdrS.cgrCdrHandler) + server.RegisterHTTPFunc(cdrS.cgrCfg.HTTPCfg().FreeswitchCDRsURL, cdrS.fsCdrHandler) } // chrgrSProcessEvent forks CGREventWithOpts into multiples based on matching ChargerS profiles diff --git a/registrarc/libregistrarc.go b/registrarc/libregistrarc.go index 5f467b0c2..0a3f360db 100644 --- a/registrarc/libregistrarc.go +++ b/registrarc/libregistrarc.go @@ -249,7 +249,7 @@ func getConnPort(cfg *config.CGRConfig, transport string, tls bool) (port string } else { address = cfg.ListenCfg().HTTPListen } - extraPath = cfg.HTTPCfg().HTTPJsonRPCURL + extraPath = cfg.HTTPCfg().JsonRPCURL case rpcclient.BiRPCJSON: address = cfg.SessionSCfg().ListenBijson case rpcclient.BiRPCGOB: diff --git a/registrarc/libregistrarc_test.go b/registrarc/libregistrarc_test.go index 7fe201104..5ab792299 100644 --- a/registrarc/libregistrarc_test.go +++ b/registrarc/libregistrarc_test.go @@ -87,7 +87,7 @@ func TestGetConnPort(t *testing.T) { cfg.ListenCfg().RPCGOBListen = ":2013" cfg.ListenCfg().HTTPTLSListen = ":2081" cfg.ListenCfg().HTTPListen = ":2080" - cfg.HTTPCfg().HTTPJsonRPCURL = "/json_rpc" + cfg.HTTPCfg().JsonRPCURL = "/json_rpc" if port, err := getConnPort(cfg, utils.MetaJSON, false); err != nil { t.Fatal(err) diff --git a/utils/map.go b/utils/map.go index aa7c720c5..525506b87 100644 --- a/utils/map.go +++ b/utils/map.go @@ -178,3 +178,15 @@ func (fWp FlagsWithParams) Clone() (cln FlagsWithParams) { } return } + +func MapStringStringEqual(v1, v2 map[string]string) bool { + if len(v1) != len(v2) { + return false + } + for k, val2 := range v2 { + if val1, has := v1[k]; !has || val1 != val2 { + return false + } + } + return true +} diff --git a/utils/slice.go b/utils/slice.go index 2260ac3a3..808213068 100644 --- a/utils/slice.go +++ b/utils/slice.go @@ -76,3 +76,15 @@ func CloneStringSlice(in []string) (cl []string) { copy(cl, in) return } + +func SliceStringEqual(v1, v2 []string) bool { + if len(v1) != len(v2) { + return false + } + for i := range v1 { + if v1[i] != v2[i] { + return false + } + } + return true +}