diff --git a/config/smconfig.go b/config/smconfig.go index 00a011435..05cf5eb7c 100644 --- a/config/smconfig.go +++ b/config/smconfig.go @@ -88,99 +88,99 @@ type SessionSCfg struct { TerminateAttempts int } -func (self *SessionSCfg) loadFromJsonCfg(jsnCfg *SessionSJsonCfg) (err error) { +func (scfg *SessionSCfg) loadFromJsonCfg(jsnCfg *SessionSJsonCfg) (err error) { if jsnCfg == nil { return nil } if jsnCfg.Enabled != nil { - self.Enabled = *jsnCfg.Enabled + scfg.Enabled = *jsnCfg.Enabled } if jsnCfg.Listen_bijson != nil { - self.ListenBijson = *jsnCfg.Listen_bijson + scfg.ListenBijson = *jsnCfg.Listen_bijson } if jsnCfg.Chargers_conns != nil { - self.ChargerSConns = make([]*RemoteHost, len(*jsnCfg.Chargers_conns)) + scfg.ChargerSConns = make([]*RemoteHost, len(*jsnCfg.Chargers_conns)) for idx, jsnHaCfg := range *jsnCfg.Chargers_conns { - self.ChargerSConns[idx] = NewDfltRemoteHost() - self.ChargerSConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.ChargerSConns[idx] = NewDfltRemoteHost() + scfg.ChargerSConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Rals_conns != nil { - self.RALsConns = make([]*RemoteHost, len(*jsnCfg.Rals_conns)) + scfg.RALsConns = make([]*RemoteHost, len(*jsnCfg.Rals_conns)) for idx, jsnHaCfg := range *jsnCfg.Rals_conns { - self.RALsConns[idx] = NewDfltRemoteHost() - self.RALsConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.RALsConns[idx] = NewDfltRemoteHost() + scfg.RALsConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Resources_conns != nil { - self.ResSConns = make([]*RemoteHost, len(*jsnCfg.Resources_conns)) + scfg.ResSConns = make([]*RemoteHost, len(*jsnCfg.Resources_conns)) for idx, jsnHaCfg := range *jsnCfg.Resources_conns { - self.ResSConns[idx] = NewDfltRemoteHost() - self.ResSConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.ResSConns[idx] = NewDfltRemoteHost() + scfg.ResSConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Thresholds_conns != nil { - self.ThreshSConns = make([]*RemoteHost, len(*jsnCfg.Thresholds_conns)) + scfg.ThreshSConns = make([]*RemoteHost, len(*jsnCfg.Thresholds_conns)) for idx, jsnHaCfg := range *jsnCfg.Thresholds_conns { - self.ThreshSConns[idx] = NewDfltRemoteHost() - self.ThreshSConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.ThreshSConns[idx] = NewDfltRemoteHost() + scfg.ThreshSConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Stats_conns != nil { - self.StatSConns = make([]*RemoteHost, len(*jsnCfg.Stats_conns)) + scfg.StatSConns = make([]*RemoteHost, len(*jsnCfg.Stats_conns)) for idx, jsnHaCfg := range *jsnCfg.Stats_conns { - self.StatSConns[idx] = NewDfltRemoteHost() - self.StatSConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.StatSConns[idx] = NewDfltRemoteHost() + scfg.StatSConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Suppliers_conns != nil { - self.SupplSConns = make([]*RemoteHost, len(*jsnCfg.Suppliers_conns)) + scfg.SupplSConns = make([]*RemoteHost, len(*jsnCfg.Suppliers_conns)) for idx, jsnHaCfg := range *jsnCfg.Suppliers_conns { - self.SupplSConns[idx] = NewDfltRemoteHost() - self.SupplSConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.SupplSConns[idx] = NewDfltRemoteHost() + scfg.SupplSConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Attributes_conns != nil { - self.AttrSConns = make([]*RemoteHost, len(*jsnCfg.Attributes_conns)) + scfg.AttrSConns = make([]*RemoteHost, len(*jsnCfg.Attributes_conns)) for idx, jsnHaCfg := range *jsnCfg.Attributes_conns { - self.AttrSConns[idx] = NewDfltRemoteHost() - self.AttrSConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.AttrSConns[idx] = NewDfltRemoteHost() + scfg.AttrSConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Cdrs_conns != nil { - self.CDRsConns = make([]*RemoteHost, len(*jsnCfg.Cdrs_conns)) + scfg.CDRsConns = make([]*RemoteHost, len(*jsnCfg.Cdrs_conns)) for idx, jsnHaCfg := range *jsnCfg.Cdrs_conns { - self.CDRsConns[idx] = NewDfltRemoteHost() - self.CDRsConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.CDRsConns[idx] = NewDfltRemoteHost() + scfg.CDRsConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Replication_conns != nil { - self.ReplicationConns = make([]*RemoteHost, len(*jsnCfg.Replication_conns)) + scfg.ReplicationConns = make([]*RemoteHost, len(*jsnCfg.Replication_conns)) for idx, jsnHaCfg := range *jsnCfg.Replication_conns { - self.ReplicationConns[idx] = NewDfltRemoteHost() - self.ReplicationConns[idx].loadFromJsonCfg(jsnHaCfg) + scfg.ReplicationConns[idx] = NewDfltRemoteHost() + scfg.ReplicationConns[idx].loadFromJsonCfg(jsnHaCfg) } } if jsnCfg.Debit_interval != nil { - if self.DebitInterval, err = utils.ParseDurationWithNanosecs(*jsnCfg.Debit_interval); err != nil { + if scfg.DebitInterval, err = utils.ParseDurationWithNanosecs(*jsnCfg.Debit_interval); err != nil { return err } } if jsnCfg.Store_session_costs != nil { - self.StoreSCosts = *jsnCfg.Store_session_costs + scfg.StoreSCosts = *jsnCfg.Store_session_costs } if jsnCfg.Min_call_duration != nil { - if self.MinCallDuration, err = utils.ParseDurationWithNanosecs(*jsnCfg.Min_call_duration); err != nil { + if scfg.MinCallDuration, err = utils.ParseDurationWithNanosecs(*jsnCfg.Min_call_duration); err != nil { return err } } if jsnCfg.Max_call_duration != nil { - if self.MaxCallDuration, err = utils.ParseDurationWithNanosecs(*jsnCfg.Max_call_duration); err != nil { + if scfg.MaxCallDuration, err = utils.ParseDurationWithNanosecs(*jsnCfg.Max_call_duration); err != nil { return err } } if jsnCfg.Session_ttl != nil { - if self.SessionTTL, err = utils.ParseDurationWithNanosecs(*jsnCfg.Session_ttl); err != nil { + if scfg.SessionTTL, err = utils.ParseDurationWithNanosecs(*jsnCfg.Session_ttl); err != nil { return err } } @@ -188,29 +188,29 @@ func (self *SessionSCfg) loadFromJsonCfg(jsnCfg *SessionSJsonCfg) (err error) { if maxTTLDelay, err := utils.ParseDurationWithNanosecs(*jsnCfg.Session_ttl_max_delay); err != nil { return err } else { - self.SessionTTLMaxDelay = &maxTTLDelay + scfg.SessionTTLMaxDelay = &maxTTLDelay } } if jsnCfg.Session_ttl_last_used != nil { if sessionTTLLastUsed, err := utils.ParseDurationWithNanosecs(*jsnCfg.Session_ttl_last_used); err != nil { return err } else { - self.SessionTTLLastUsed = &sessionTTLLastUsed + scfg.SessionTTLLastUsed = &sessionTTLLastUsed } } if jsnCfg.Session_indexes != nil { - self.SessionIndexes = utils.StringMapFromSlice(*jsnCfg.Session_indexes) + scfg.SessionIndexes = utils.StringMapFromSlice(*jsnCfg.Session_indexes) } if jsnCfg.Client_protocol != nil { - self.ClientProtocol = *jsnCfg.Client_protocol + scfg.ClientProtocol = *jsnCfg.Client_protocol } if jsnCfg.Channel_sync_interval != nil { - if self.ChannelSyncInterval, err = utils.ParseDurationWithNanosecs(*jsnCfg.Channel_sync_interval); err != nil { + if scfg.ChannelSyncInterval, err = utils.ParseDurationWithNanosecs(*jsnCfg.Channel_sync_interval); err != nil { return err } } if jsnCfg.Terminate_attempts != nil { - self.TerminateAttempts = *jsnCfg.Terminate_attempts + scfg.TerminateAttempts = *jsnCfg.Terminate_attempts } return nil } diff --git a/data/conf/samples/gob/cdrsv2mysql/cdrsv2mysql.json b/data/conf/samples/gob/cdrsv2mysql/cdrsv2mysql.json new file mode 100644 index 000000000..cfd45f855 --- /dev/null +++ b/data/conf/samples/gob/cdrsv2mysql/cdrsv2mysql.json @@ -0,0 +1,77 @@ +{ +// CGRateS Configuration file +// +// Used in apier_local_tests +// Starts rater, cdrs and mediator connecting over internal channel + +"general": { + "log_level": 7, +}, + + +"stor_db": { + "db_password": "CGRateS.org", +}, + + +"rals": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + +"scheduler": { + "enabled": true, +}, + +"cdrs": { + "enabled": true, + "attributes_conns":[ + {"address": "*internal"}, + ], + "chargers_conns":[ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "rals_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "stats_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + +"attributes": { + "enabled": true, +}, + +"stats": { + "enabled": true, + "store_interval": "1s", + "thresholds_conns": [ + {"address": "*internal"} + ], +}, + +"thresholds": { + "enabled": true, + "store_interval": "1s", +}, + +"chargers": { + "enabled": true, + "attributes_conns": [ + {"address": "*internal"}, + ], +}, + +"apier": { + "scheduler_conns": [ // connections to SchedulerS for reloads + {"address": "*internal"}, + ], +}, + +} diff --git a/data/conf/samples/gob/filters/cgrates.json b/data/conf/samples/gob/filters/cgrates.json new file mode 100644 index 000000000..0ad8dfdef --- /dev/null +++ b/data/conf/samples/gob/filters/cgrates.json @@ -0,0 +1,85 @@ +{ +// CGRateS Configuration file +// + + +"general": { + "log_level": 7, + "node_id": "CGRFilterS", +}, + + +"liste3": { + "rpc_gob": ":2012", + "rpc_gob": ":2013", + "http": ":2080", +}, + + +"data_db": { // database used to store runtime data (eg: accounts, cdr stats) + "db_type": "redis", // data_db type: + "db_port": 6379, // data_db port to reach the database + "db_name": "10", // data_db database name to connect to +}, + + +"stor_db": { + "db_password": "CGRateS.org", +}, + + +"rals": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + +"scheduler": { + "enabled": true, +}, + +"filters": { + "stats_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "resources_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "rals_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + + +"resources": { + "enabled": true, + "indexed_selects":false, + "store_interval": "1s", +}, + + +"stats": { + "enabled": true, + "indexed_selects":false, + "store_interval": "1s", +}, + + +"thresholds": { + "enabled": true, + "indexed_selects":false, + "store_interval": "1s", +}, + +"apier": { + "caches_conns":[ // connections to CacheS for reloads + {"address": "127.0.0.1:2012",3"transport": "*gob"}, + ], + "scheduler_conns": [ // connections to SchedulerS for reloads + {"address": "*internal"}, + ], +}, + + +} diff --git a/data/conf/samples/gob/tls/cgrates.json b/data/conf/samples/gob/tls/cgrates.json new file mode 100755 index 000000000..0acb7b5bd --- /dev/null +++ b/data/conf/samples/gob/tls/cgrates.json @@ -0,0 +1,109 @@ +{ +// CGRateS Configuration file +// + + +"general": { + "log_level": 7, +}, + + +"listen": { + "rpc_json": ":2012", + "rpc_gob": ":2013", + "http": ":2080", + "rpc_json_tls":":2022", + "rpc_gob_tls":":2023", + "http_tls": ":2280", +}, + +"tls": { + "server_certificate" : "/usr/share/cgrates/tls/server.crt", // path to server certificate(must conatin server.crt + ca.crt) + "server_key":"/usr/share/cgrates/tls/server.key", // path to server key + "client_certificate" : "/usr/share/cgrates/tls/client.crt", // path to client certificate(must conatin client.crt + ca.crt) + "client_key":"/usr/share/cgrates/tls/client.key", // path to client key + "ca_certificate":"/usr/share/cgrates/tls/ca.crt", +}, + + +"http": { // HTTP server configuration + "json_rpc_url": "/jsonrpc", // JSON RPC relative URL ("" to disable) + "ws_url": "/ws", // WebSockets relative URL ("" to disable) + "freeswitch_cdrs_url": "/freeswitch_json", // Freeswitch CDRS relative URL ("" to disable) + "http_cdrs": "/cdr_http", // CDRS relative URL ("" to disable) + "use_basic_auth": false, // use basic authentication + "auth_users": {}, // basic authentication usernames and base64-encoded passwords (eg: { "username1": "cGFzc3dvcmQ=", "username2": "cGFzc3dvcmQy "}) +}, + + +"data_db": { // database used to store runtime data (eg: accounts, cdr stats) + "db_type": "redis", // data_db type: + "db_port": 6379, // data_db port to reach the database + "db_name": "10", // data_db database name to connect to +}, + + +"stor_db": { + "db_password": "CGRateS.org", +}, + + +"rals": { + "enabled": true, +}, + + +"resources": { + "enabled": true, + "store_interval": "1s", + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport": "*gob"} + ], +}, + + +"stats": { + "enabled": true, + "store_interval": "1s", + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport": "*gob"} + ], +}, + +"thresholds": { + "enabled": true, + "store_interval": "1s", +}, + +"sessions": { + "enabled": true, + "rals_conns": [ + {"address": "127.0.0.1:2013", "transport": "*gob"} + ], + "resources_conns": [ + {"address": "127.0.0.1:2013", "transport": "*gob"} + ], + "attributes_conns": [ + {"address": "127.0.0.1:2013", "transport": "*gob"} + ], +}, + +"attributes": { + "enabled": true, +}, + +"cdrs": { + "enabled": true, + "chargers_conns":[ + {"address": "*internal"} + ], +}, + +"chargers": { + "enabled": true, + "attributes_conns": [ + {"address": "*internal"} + ], +}, + +} diff --git a/data/conf/samples/gob/tutmongo2/cgrates.json b/data/conf/samples/gob/tutmongo2/cgrates.json new file mode 100644 index 000000000..03b5aa7b8 --- /dev/null +++ b/data/conf/samples/gob/tutmongo2/cgrates.json @@ -0,0 +1,182 @@ +{ +// CGRateS Configuration file +// + + +"general": { + "node_id": "CGRateSTutorial", + "log_level": 7 +}, + + +"listen": { + "rpc_json": ":2012", + "rpc_gob": ":2013", + "http": ":2080", +}, + + +"data_db": { + "db_type": "mongo", + "db_port": 27017, +}, + + +"stor_db": { + "db_type": "mongo", + "db_port": 27017, +}, + + + +"scheduler": { + "enabled": true, + "cdrs_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + + +"rals": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "stats_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + + +"cdrs": { + "enabled": true, + "extra_fields": ["PayPalAccount", "LCRProfile", "ResourceID"], + "chargers_conns":[ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "store_cdrs": true, + "online_cdr_exports": [] +}, + + +"cdre": { + "amqp_localhost": { + "export_format": "*amqp_json_map", + "export_path": "amqp://guest:guest@localhost:5672/?queue_id=cgrates_cdrs", + "content_fields": [ + {"field_id": "CGRID", "type": "*variable", "value": "~CGRID"}, + {"field_id": "RunID", "type": "*variable", "value": "~RunID"}, + {"field_id": "ToR", "type": "*variable", "value": "~ToR"}, + {"field_id": "OriginID", "type": "*variable", "value": "~OriginID"}, + {"field_id": "OriginHost", "type": "*variable", "value": "~OriginHost"}, + {"field_id": "RequestType", "type": "*variable", "value": "~RequestType", }, + {"field_id": "Tenant", "type": "*variable", "value": "~Tenant"}, + {"field_id": "Category", "type": "*variable", "value": "~Category"}, + {"field_id": "Account", "type": "*variable", "value": "~Account"}, + {"field_id": "Destination", "type": "*variable", "value": "~Destination"}, + {"field_id": "SetupTime", "type": "*variable", "value": "~SetupTime"}, + {"field_id": "AnswerTime", "type": "*variable", "value": "~AnswerTime"}, + {"field_id": "Usage", "type": "*variable", "value": "~Usage"}, + {"field_id": "Cost", "type": "*variable", "value": "~Cost"}, + {"field_id": "PayPalAccount", "type": "*variable", "value": "~PayPalAccount"}, + {"field_id": "LCRProfile", "type": "*variable", "value": "~LCRProfile", }, + {"field_id": "ResourceID", "type": "*variable", "value": "~ResourceID", }, + ], + }, +}, + + +"cdrc": [ + { + "id": "tutorial_csv_cdr", + "enabled": true, + "cdr_source_id": "cgr_tutorial", + "content_fields":[ + {"field_id": "OriginID", "type": "*composed", "value": "~3", "mandatory": true}, + {"field_id": "Account", "type": "*composed", "value": "~8", "mandatory": true}, + {"field_id": "Destination", "type": "*composed", "value": "~10", "mandatory": true}, + {"field_id": "SetupTime", "type": "*composed", "value": "~11", "mandatory": true}, + {"field_id": "AnswerTime", "type": "*composed", "value": "~12", "mandatory": true}, + {"field_id": "Usage", "type": "*composed", "value": "~13", "mandatory": true}, + ], + }, +], + + +"sessions": { + "enabled": true, + "resources_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "suppliers_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "attributes_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "rals_conns": [ + {"address": "*internal"} + ], + "cdrs_conns": [ + {"address": "*internal"} + ], + "chargers_conns": [ + {"address": "*internal"} + ], +}, + + +"attributes": { + "enabled": true, + "string_indexed_fields": ["Account"] +}, + + +"chargers": { + "enabled": true, + "attributes_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "string_indexed_fields": ["Account"] +}, + + +"resources": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "string_indexed_fields": ["Account"] +}, + + +"stats": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "string_indexed_fields": ["Account"] +}, + + +"thresholds": { + "enabled": true, + "string_indexed_fields": ["Account"] +}, + + +"suppliers": { + "enabled": true, + "string_indexed_fields": ["LCRProfile"], + "prefix_indexed_fields":["Destination"], +}, + + +"apier": { + "scheduler_conns": [ // connections to SchedulerS for reloads + {"address": "*internal"}, + ], +}, + + +} diff --git a/data/conf/samples/gob/tutmysql2/cgrates.json b/data/conf/samples/gob/tutmysql2/cgrates.json new file mode 100644 index 000000000..6a82a1bfb --- /dev/null +++ b/data/conf/samples/gob/tutmysql2/cgrates.json @@ -0,0 +1,146 @@ +{ +// CGRateS Configuration file +// + + +"general": { + "node_id": "CGRateSTutorial", + "log_level": 7 +}, + + +"listen": { + "rpc_json": ":2012", + "rpc_gob": ":2013", + "http": ":2080", +}, + + +"stor_db": { + "db_password": "CGRateS.org", +}, + + +"scheduler": { + "enabled": true, + "cdrs_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + + +"rals": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "stats_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], +}, + + +"cdrs": { + "enabled": true, + "extra_fields": ["PayPalAccount", "LCRProfile", "ResourceID"], + "chargers_conns":[ + {"address": "127.0.0.1:2013", "transport":"*gob"}, + ], + "store_cdrs": true, + "online_cdr_exports": [] +}, + + +"cdrc": [ + { + "id": "tutorial_csv_cdr", + "enabled": true, + "cdr_source_id": "cgr_tutorial", + "content_fields":[ + {"field_id": "OriginID", "type": "*composed", "value": "~3", "mandatory": true}, + {"field_id": "Account", "type": "*composed", "value": "~8", "mandatory": true}, + {"field_id": "Destination", "type": "*composed", "value": "~10", "mandatory": true}, + {"field_id": "SetupTime", "type": "*composed", "value": "~11", "mandatory": true}, + {"field_id": "AnswerTime", "type": "*composed", "value": "~12", "mandatory": true}, + {"field_id": "Usage", "type": "*composed", "value": "~13", "mandatory": true}, + ], + }, +], + + +"sessions": { + "enabled": true, + "resources_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "suppliers_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "attributes_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "rals_conns": [ + {"address": "*internal"} + ], + "cdrs_conns": [ + {"address": "*internal"} + ], + "chargers_conns": [ + {"address": "*internal"} + ], +}, + + +"attributes": { + "enabled": true, + "string_indexed_fields": ["Account"] +}, + + +"chargers": { + "enabled": true, + "attributes_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "string_indexed_fields": ["Account"] +}, + + +"resources": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "string_indexed_fields": ["Account"] +}, + + +"stats": { + "enabled": true, + "thresholds_conns": [ + {"address": "127.0.0.1:2013", "transport":"*gob"} + ], + "string_indexed_fields": ["Account"] +}, + + +"thresholds": { + "enabled": true, + "string_indexed_fields": ["Account"] +}, + + +"suppliers": { + "enabled": true, + "string_indexed_fields": ["LCRProfile"], + "prefix_indexed_fields":["Destination"], +}, + + + +"apier": { + "scheduler_conns": [ // connections to SchedulerS for reloads + {"address": "*internal"}, + ], +}, +} diff --git a/general_tests/cdrs_it_test.go b/general_tests/cdrs_it_test.go index b7ff4ccbd..4211702f3 100644 --- a/general_tests/cdrs_it_test.go +++ b/general_tests/cdrs_it_test.go @@ -96,6 +96,9 @@ func TestCDRsITMongo(t *testing.T) { func testV2CDRsInitConfig(t *testing.T) { var err error cdrsCfgPath = path.Join(*dataDir, "conf", "samples", cdrsConfDIR) + if *encoding == utils.MetaGOB { + cdrsCfgPath = path.Join(*dataDir, "conf", "samples", "gob", cdrsConfDIR) + } if cdrsCfg, err = config.NewCGRConfigFromPath(cdrsCfgPath); err != nil { t.Fatal("Got config error: ", err.Error()) } diff --git a/general_tests/filters_it_test.go b/general_tests/filters_it_test.go index 092e62c6b..52c95ba7e 100644 --- a/general_tests/filters_it_test.go +++ b/general_tests/filters_it_test.go @@ -68,6 +68,9 @@ func TestFltrIT(t *testing.T) { func testV1FltrLoadConfig(t *testing.T) { var err error fltrCfgPath = path.Join(*dataDir, "conf", "samples", fltrConfDIR) + if *encoding == utils.MetaGOB { + cdrsCfgPath = path.Join(*dataDir, "conf", "samples", "gob", fltrConfDIR) + } if fltrCfg, err = config.NewCGRConfigFromPath(fltrCfgPath); err != nil { t.Error(err) } diff --git a/general_tests/tls_it_test.go b/general_tests/tls_it_test.go index 02ae36b85..99c6d2c02 100755 --- a/general_tests/tls_it_test.go +++ b/general_tests/tls_it_test.go @@ -61,6 +61,9 @@ func TestTLS(t *testing.T) { func testTLSLoadConfig(t *testing.T) { var err error tlsCfgPath = path.Join(*dataDir, "conf", "samples", tlsConfDIR) + if *encoding == utils.MetaGOB { + tlsCfgPath = path.Join(*dataDir, "conf", "samples", "gob", tlsConfDIR) + } if tlsCfg, err = config.NewCGRConfigFromPath(tlsCfgPath); err != nil { t.Error(err) } diff --git a/general_tests/tutorial2_it_test.go b/general_tests/tutorial2_it_test.go index 9a44b7537..7ca7b1df6 100644 --- a/general_tests/tutorial2_it_test.go +++ b/general_tests/tutorial2_it_test.go @@ -70,6 +70,9 @@ func TestTutorial2Mongo(t *testing.T) { func testTutLoadConfig(t *testing.T) { var err error tutCfgPath = path.Join(*dataDir, "conf", "samples", tutCfgDir) + if *encoding == utils.MetaGOB { + tutCfgPath = path.Join(*dataDir, "conf", "samples", "gob", tutCfgDir) + } if tutCfg, err = config.NewCGRConfigFromPath(tutCfgPath); err != nil { t.Error(err) } diff --git a/gob_integration_test.sh b/gob_integration_test.sh index fd49dff59..f7a77471a 100755 --- a/gob_integration_test.sh +++ b/gob_integration_test.sh @@ -23,9 +23,9 @@ gnr=$? # echo 'go test github.com/cgrates/cgrates/agents -tags=integration' # go test github.com/cgrates/cgrates/agents -tags=integration # agts=$? -# echo 'go test github.com/cgrates/cgrates/sessions -tags=integration' -# go test github.com/cgrates/cgrates/sessions -tags=integration -# smg=$? +echo 'go test github.com/cgrates/cgrates/sessions -tags=integration -rpc=*gob' +go test github.com/cgrates/cgrates/sessions -tags=integration -rpc=*gob +smg=$? # echo 'go test github.com/cgrates/cgrates/dispatchers -tags=integration' # go test github.com/cgrates/cgrates/dispatchers -tags=integration # dis=$? diff --git a/sessions/session.go b/sessions/session.go index 7bb921c68..ee16f2702 100644 --- a/sessions/session.go +++ b/sessions/session.go @@ -67,7 +67,7 @@ type ExternalSession struct { // Session is the main structure to describe a call type Session struct { - sync.RWMutex + lk sync.RWMutex CGRID string Tenant string @@ -82,6 +82,26 @@ type Session struct { *utils.ArgDispatcher } +// Lock exported function from sync.RWMutex +func (s *Session) Lock() { + s.lk.Lock() +} + +// Unlock exported function from sync.RWMutex +func (s *Session) Unlock() { + s.lk.Unlock() +} + +// RLock exported function from sync.RWMutex +func (s *Session) RLock() { + s.lk.RLock() +} + +// RUnlock exported function from sync.RWMutex +func (s *Session) RUnlock() { + s.lk.RUnlock() +} + // cgrID is method to return the CGRID of a session // not thread safe func (s *Session) cgrID() (cgrID string) { diff --git a/sessions/sessions_birpc_it_test.go b/sessions/sessions_birpc_it_test.go index 1b38a50bd..4481f3733 100644 --- a/sessions/sessions_birpc_it_test.go +++ b/sessions/sessions_birpc_it_test.go @@ -21,7 +21,6 @@ along with this program. If not, see package sessions import ( - "net/rpc/jsonrpc" "path" "testing" "time" @@ -91,7 +90,7 @@ func TestSessionsBiRPCApierRpcConn(t *testing.T) { clntHandlers); err != nil { t.Fatal(err) } - if sessionsRPC, err = jsonrpc.Dial("tcp", sessionsBiRPCCfg.ListenCfg().RPCJSONListen); err != nil { // Connect also simple RPC so we can check accounts and such + if sessionsRPC, err = newRPCClient(sessionsBiRPCCfg.ListenCfg()); err != nil { // Connect also simple RPC so we can check accounts and such t.Fatal(err) } dummyClnt.Close() // close so we don't get EOF error when disconnecting server @@ -329,7 +328,7 @@ func TestSessionsBiRPCSessionOriginatorTerminate(t *testing.T) { t.Errorf("Balance value: %f", acnt.BalanceMap[utils.VOICE].GetTotalValue()) } - if err := sessionsRPC.Call(utils.SessionSv1ProcessCDR, termArgs.CGREvent, &reply); err != nil { + if err := sessionsRPC.Call(utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: termArgs.CGREvent}, &reply); err != nil { t.Error(err) } else if reply != utils.OK { t.Errorf("Received reply: %s", reply) diff --git a/sessions/sessions_data_it_test.go b/sessions/sessions_data_it_test.go index efbbe5c74..b8fdfe24d 100644 --- a/sessions/sessions_data_it_test.go +++ b/sessions/sessions_data_it_test.go @@ -21,7 +21,6 @@ package sessions import ( "net/rpc" - "net/rpc/jsonrpc" "path" "testing" "time" @@ -71,7 +70,7 @@ func TestSessionsDataStartEngine(t *testing.T) { // Connect rpc client to rater func TestSessionsDataApierRpcConn(t *testing.T) { var err error - sDataRPC, err = jsonrpc.Dial("tcp", dataCfg.ListenCfg().RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed + sDataRPC, err = newRPCClient(dataCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed if err != nil { t.Fatal(err) } @@ -109,7 +108,7 @@ func TestSessionsDataLastUsedData(t *testing.T) { } var cc engine.CallCost // Make sure the cost is what we expect to be for 1MB of data - if err := sDataRPC.Call(utils.ResponderGetCost, cd, &cc); err != nil { + if err := sDataRPC.Call(utils.ResponderGetCost, &engine.CallDescriptorWithArgDispatcher{CallDescriptor: &cd}, &cc); err != nil { t.Error("Got error on Responder.GetCost: ", err.Error()) } else if cc.Cost != 1024 { t.Errorf("Calling Responder.GetCost got callcost: %v", cc.Cost) @@ -292,7 +291,7 @@ func TestSessionsDataLastUsedMultipleUpdates(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal) } aSessions := make([]*ExternalSession, 0) - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || aSessions[0].Usage != time.Duration(6144) { @@ -337,7 +336,7 @@ func TestSessionsDataLastUsedMultipleUpdates(t *testing.T) { } else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal { t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal) } - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || aSessions[0].Usage != time.Duration(15360) { @@ -381,7 +380,7 @@ func TestSessionsDataLastUsedMultipleUpdates(t *testing.T) { } else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal { t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal) } - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || aSessions[0].Usage != time.Duration(13312) { // 14MB in used, 2MB extra reserved @@ -424,7 +423,7 @@ func TestSessionsDataLastUsedMultipleUpdates(t *testing.T) { } else if totalVal := acnt.BalanceMap[utils.DATA].GetTotalValue(); totalVal != eAcntVal { t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal) } - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || aSessions[0].Usage != time.Duration(14336) { // 14MB in use @@ -465,10 +464,10 @@ func TestSessionsDataLastUsedMultipleUpdates(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, totalVal) } if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, - nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } - if err := sDataRPC.Call(utils.SessionSv1ProcessCDR, termArgs.CGREvent, &reply); err != nil { + if err := sDataRPC.Call(utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: termArgs.CGREvent}, &reply); err != nil { t.Error(err) } else if reply != utils.OK { t.Errorf("Received reply: %s", reply) @@ -632,7 +631,7 @@ func TestSessionsDataTTLExpMultiUpdates(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, dataVal) } aSessions := make([]*ExternalSession, 0) - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || int64(aSessions[0].Usage) != 4096 { @@ -688,7 +687,7 @@ func TestSessionsDataTTLExpMultiUpdates(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, dataVal) } if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, - nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } } @@ -757,7 +756,7 @@ func TestSessionsDataMultipleDataNoUsage(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, dataVal) } aSessions := make([]*ExternalSession, 0) - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || int64(aSessions[0].Usage) != 2048 { @@ -804,7 +803,7 @@ func TestSessionsDataMultipleDataNoUsage(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, dataVal) } aSessions = make([]*ExternalSession, 0) - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || int64(aSessions[0].Usage) != 2048 { @@ -836,6 +835,7 @@ func TestSessionsDataMultipleDataNoUsage(t *testing.T) { }, } + updateRpl = new(V1UpdateSessionReply) // because gob doesn't overwrite 0 value fields if err := sDataRPC.Call(utils.SessionSv1UpdateSession, updateArgs, &updateRpl); err != nil { t.Error(err) } @@ -850,7 +850,7 @@ func TestSessionsDataMultipleDataNoUsage(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, dataVal) } aSessions = make([]*ExternalSession, 0) - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || int64(aSessions[0].Usage) != 1024 { @@ -892,7 +892,7 @@ func TestSessionsDataMultipleDataNoUsage(t *testing.T) { eAcntVal, acnt.BalanceMap[utils.DATA].GetTotalValue()) } if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, - nil, &aSessions); err == nil || + new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } @@ -964,7 +964,7 @@ func TestSessionsDataTTLUsageProtection(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, dataVal) } aSessions := make([]*ExternalSession, 0) - if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 1 || int64(aSessions[0].Usage) != 2048 { @@ -972,7 +972,7 @@ func TestSessionsDataTTLUsageProtection(t *testing.T) { } time.Sleep(60 * time.Millisecond) if err := sDataRPC.Call(utils.SessionSv1GetActiveSessions, - nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } } diff --git a/sessions/sessions_it_test.go b/sessions/sessions_it_test.go index 2cc008e48..614ee1701 100644 --- a/sessions/sessions_it_test.go +++ b/sessions/sessions_it_test.go @@ -22,7 +22,6 @@ package sessions import ( "fmt" "net/rpc" - "net/rpc/jsonrpc" "path" "testing" "time" @@ -72,7 +71,7 @@ func TestSessionsItStartEngine(t *testing.T) { // Connect rpc client to rater func TestSessionsItApierRpcConn(t *testing.T) { var err error - sItRPC, err = jsonrpc.Dial("tcp", sItCfg.ListenCfg().RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed + sItRPC, err = newRPCClient(sItCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed if err != nil { t.Fatal(err) } @@ -135,7 +134,7 @@ func TestSessionsItTerminatUnexist(t *testing.T) { t.Errorf("Expected: %f, received: %f", eAcntVal, acnt.BalanceMap[utils.MONETARY].GetTotalValue()) } time.Sleep(100 * time.Millisecond) - if err := sItRPC.Call(utils.SessionSv1ProcessCDR, termArgs.CGREvent, &rpl); err != nil { + if err := sItRPC.Call(utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: termArgs.CGREvent}, &rpl); err != nil { t.Error(err) } else if rpl != utils.OK { t.Errorf("Received reply: %s", rpl) @@ -280,7 +279,7 @@ func TestSessionsItTerminatePassive(t *testing.T) { var pSessions []*ExternalSession //check if the passive session was created if err := sItRPC.Call(utils.SessionSv1GetPassiveSessions, - utils.SessionFilter{ + &utils.SessionFilter{ Filters: []string{ fmt.Sprintf("*string:~%s:%s", utils.OriginID, "123789"), }, @@ -420,7 +419,7 @@ func TestSessionsItEventCostCompressing(t *testing.T) { t.Error(err) } if err := sItRPC.Call(utils.SessionSv1ProcessCDR, - termArgs.CGREvent, &reply); err != nil { + &utils.CGREventWithArgDispatcher{CGREvent: termArgs.CGREvent}, &reply); err != nil { t.Error(err) } time.Sleep(20 * time.Millisecond) diff --git a/sessions/sessions_rpl_it_test.go b/sessions/sessions_rpl_it_test.go index 91c47e018..02b7f95cf 100644 --- a/sessions/sessions_rpl_it_test.go +++ b/sessions/sessions_rpl_it_test.go @@ -22,7 +22,6 @@ package sessions import ( "fmt" "net/rpc" - "net/rpc/jsonrpc" "path" "testing" "time" @@ -71,10 +70,10 @@ func TestSessionSRplStartEngine(t *testing.T) { // Connect rpc client to rater func TestSessionSRplApierRpcConn(t *testing.T) { - if smgRplcMstrRPC, err = jsonrpc.Dial("tcp", smgRplcMasterCfg.ListenCfg().RPCJSONListen); err != nil { + if smgRplcMstrRPC, err = newRPCClient(smgRplcMasterCfg.ListenCfg()); err != nil { t.Fatal(err) } - if smgRplcSlvRPC, err = jsonrpc.Dial("tcp", smgRplcSlaveCfg.ListenCfg().RPCJSONListen); err != nil { + if smgRplcSlvRPC, err = newRPCClient(smgRplcSlaveCfg.ListenCfg()); err != nil { t.Fatal(err) } } @@ -93,11 +92,11 @@ func TestSessionSRplInitiate(t *testing.T) { var aSessions []*ExternalSession //make sure we don't have active sessions on master and passive on slave if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions, - nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err) } if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, - nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err) } @@ -215,7 +214,7 @@ func TestSessionSRplUpdate(t *testing.T) { var pSessions []*ExternalSession // Make sure we don't have passive session on active host - if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, nil, + if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err) } @@ -234,7 +233,7 @@ func TestSessionSRplUpdate(t *testing.T) { cgrID := GetSetCGRID(engine.NewMapEvent(argsUpdate.Event)) // Make sure session was replicated if err := smgRplcMstrRPC.Call(utils.SessionSv1GetPassiveSessions, - nil, &pSessions); err != nil { + new(utils.SessionFilter), &pSessions); err != nil { t.Error(err) } else if len(pSessions) != 1 { t.Errorf("PassiveSessions: %+v", pSessions) @@ -285,16 +284,16 @@ func TestSessionSRplTerminate(t *testing.T) { } //check if the session was terminated on slave if err := smgRplcSlvRPC.Call(utils.SessionSv1GetActiveSessions, - nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Errorf("Error: %v with len(aSessions)=%v , session : %+v", err, len(aSessions), utils.ToIJSON(aSessions)) } // check to don't have passive session on master and slave var pSessions []*ExternalSession - if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, nil, + if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Errorf("Error: %v with len(pSessions)=%v , session : %+v", err, len(pSessions), utils.ToIJSON(pSessions)) } - if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, nil, + if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &pSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Errorf("Error: %v with len(pSessions)=%v , session : %+v", err, len(pSessions), utils.ToIJSON(pSessions)) } @@ -305,7 +304,7 @@ func TestSessionSRplManualReplicate(t *testing.T) { if err != nil { // Kill both and start Master t.Fatal(err) } - if smgRplcMstrRPC, err = jsonrpc.Dial("tcp", smgRplcMasterCfg.ListenCfg().RPCJSONListen); err != nil { + if smgRplcMstrRPC, err = newRPCClient(smgRplcMasterCfg.ListenCfg()); err != nil { t.Fatal(err) } // create two sessions @@ -364,7 +363,7 @@ func TestSessionSRplManualReplicate(t *testing.T) { } //verify if the sessions was created on master and are active var aSessions []*ExternalSession - if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err != nil { + if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 2 { t.Errorf("Unexpected number of sessions received: %+v", utils.ToJSON(aSessions)) @@ -382,11 +381,11 @@ func TestSessionSRplManualReplicate(t *testing.T) { if _, err := engine.StartEngine(smgRplcSlaveCfgPath, *waitRater); err != nil { t.Fatal(err) } - if smgRplcSlvRPC, err = jsonrpc.Dial("tcp", smgRplcSlaveCfg.ListenCfg().RPCJSONListen); err != nil { + if smgRplcSlvRPC, err = newRPCClient(smgRplcSlaveCfg.ListenCfg()); err != nil { t.Fatal(err) } // when we start slave after master we expect to don't have sessions - if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, nil, &aSessions); err == nil || + if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } @@ -404,7 +403,7 @@ func TestSessionSRplManualReplicate(t *testing.T) { t.Error(err) } time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated - if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, nil, &aSessions); err != nil { + if err := smgRplcSlvRPC.Call(utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 2 { t.Errorf("Unexpected number of sessions received: %+v", aSessions) @@ -426,14 +425,14 @@ func TestSessionSRplManualReplicate(t *testing.T) { if _, err := engine.StartEngine(smgRplcMasterCfgPath, *waitRater); err != nil { t.Fatal(err) } - if smgRplcMstrRPC, err = jsonrpc.Dial("tcp", smgRplcMasterCfg.ListenCfg().RPCJSONListen); err != nil { + if smgRplcMstrRPC, err = newRPCClient(smgRplcMasterCfg.ListenCfg()); err != nil { t.Fatal(err) } // Master should have no session active/passive - if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } - if err := smgRplcMstrRPC.Call(utils.SessionSv1GetPassiveSessions, nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + if err := smgRplcMstrRPC.Call(utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } // recover passive sessions from slave @@ -450,10 +449,10 @@ func TestSessionSRplManualReplicate(t *testing.T) { } time.Sleep(time.Duration(*waitRater) * time.Millisecond) // Wait for the sessions to be populated // Master should have no session active/passive - if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions, nil, &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { + if err := smgRplcMstrRPC.Call(utils.SessionSv1GetActiveSessions, new(utils.SessionFilter), &aSessions); err == nil || err.Error() != utils.ErrNotFound.Error() { t.Error(err, aSessions) } - if err := smgRplcMstrRPC.Call(utils.SessionSv1GetPassiveSessions, nil, &aSessions); err != nil { + if err := smgRplcMstrRPC.Call(utils.SessionSv1GetPassiveSessions, new(utils.SessionFilter), &aSessions); err != nil { t.Error(err) } else if len(aSessions) != 2 { t.Errorf("Unexpected number of sessions received: %+v", aSessions) diff --git a/sessions/sessions_voice_it_test.go b/sessions/sessions_voice_it_test.go index 8b21a811c..078accc50 100644 --- a/sessions/sessions_voice_it_test.go +++ b/sessions/sessions_voice_it_test.go @@ -20,6 +20,7 @@ along with this program. If not, see package sessions import ( + "errors" "flag" "fmt" "net/rpc" @@ -33,12 +34,26 @@ import ( "github.com/cgrates/cgrates/utils" ) -var waitRater = flag.Int("wait_rater", 150, "Number of miliseconds to wait for rater to start and cache") -var dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") +var ( + waitRater = flag.Int("wait_rater", 150, "Number of miliseconds to wait for rater to start and cache") + dataDir = flag.String("data_dir", "/usr/share/cgrates", "CGR data dir path here") -var voiceCfgPath string -var voiceCfg *config.CGRConfig -var sessionsRPC *rpc.Client + voiceCfgPath string + voiceCfg *config.CGRConfig + sessionsRPC *rpc.Client + encoding = flag.String("rpc", utils.MetaJSON, "what encoding whould be uused for rpc comunication") +) + +func newRPCClient(cfg *config.ListenCfg) (c *rpc.Client, err error) { + switch *encoding { + case utils.MetaJSON: + return jsonrpc.Dial(utils.TCP, cfg.RPCJSONListen) + case utils.MetaGOB: + return rpc.Dial(utils.TCP, cfg.RPCGOBListen) + default: + return nil, errors.New("UNSUPPORTED_RPC") + } +} func TestSessionsVoiceInitCfg(t *testing.T) { voiceCfgPath = path.Join(*dataDir, "conf", "samples", "smg") @@ -76,7 +91,7 @@ func TestSessionsVoiceStartEngine(t *testing.T) { // Connect rpc client to rater func TestSessionsVoiceApierRpcConn(t *testing.T) { var err error - sessionsRPC, err = jsonrpc.Dial("tcp", voiceCfg.ListenCfg().RPCJSONListen) // We connect over JSON so we can also troubleshoot if needed + sessionsRPC, err = newRPCClient(voiceCfg.ListenCfg()) // We connect over JSON so we can also troubleshoot if needed if err != nil { t.Fatal(err) } @@ -1253,7 +1268,7 @@ func TestSessionsVoiceRelocateWithOriginIDPrefix(t *testing.T) { eAcntVal, acnt.BalanceMap[utils.VOICE].GetTotalValue()) } - if err := sessionsRPC.Call(utils.SessionSv1ProcessCDR, termArgs.CGREvent, &reply); err != nil { + if err := sessionsRPC.Call(utils.SessionSv1ProcessCDR, &utils.CGREventWithArgDispatcher{CGREvent: termArgs.CGREvent}, &reply); err != nil { t.Error(err) } else if reply != utils.OK { t.Errorf("Received reply: %s", reply)