Added some diff functions

2026-02-25 00:58:45 +05:00 · 2021-04-21 12:23:08 +03:00
parent 52365ce558
commit 099ae99836
22 changed files with 744 additions and 295 deletions
--- 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,
 		)
 	}
--- 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
+}
--- 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
 }
--- 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)
 	}
 }

--- 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
+}
--- 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))
--- 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
+}
--- 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
+}
--- 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
+}
--- 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
+}
--- 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")
 	}
 }
--- 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
--- 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
+}
--- 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 {
--- 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
+}
--- 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
+}
--- 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()
--- 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
--- 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:
--- 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)
--- 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
+}
--- 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
+}