reter ready

cmd/cgr-rater/cgr-rater.go

@@ -80,18 +80,22 @@ func readConfig(configFn string) {
 	}
 	redis_server, _ = c.GetString("global", "redis_server")
 	redis_db, _ = c.GetInt("global", "redis_db")
+
 	rater_standalone, _ = c.GetBool("rater", "standalone")
 	rater_balancer_server, _ = c.GetString("rater", "balancer_server")
 	rater_listen, _ = c.GetString("rater", "listen_api")
 	rater_json, _ = c.GetBool("rater", "json")
+
 	balancer_enabled, _ = c.GetBool("balancer", "enabled")
 	balancer_standalone, _ = c.GetBool("balancer", "standalone")
 	balancer_listen_rater, _ = c.GetString("balancer", "listen_rater")
 	balancer_listen_api, _ = c.GetString("balancer", "listen_api")
 	balancer_json, _ = c.GetBool("balancer", "json")
+
 	scheduler_enabled, _ = c.GetBool("scheduler", "enabled")
 	scheduler_standalone, _ = c.GetBool("scheduler", "standalone")
 	scheduler_json, _ = c.GetBool("scheduler", "json")
+
 	sm_enabled, _ = c.GetBool("session_manager", "enabled")
 	sm_standalone, _ = c.GetBool("session_manager", "standalone")
 	sm_api_server, _ = c.GetString("session_manager", "api_server")
@@ -179,16 +183,10 @@ func main() {
 	defer getter.Close()
 	timespans.SetStorageGetter(getter)
 
+	if !rater_standalone {
+		go registerToBalancer(rater_balancer_server, rater_listen)
+		go stopRaterSingnalHandler(rater_balancer_server, rater_listen, getter)
+	}
 	go listenToRPCRequests(&Responder{new(DirectResponder)}, rater_listen, false)
 	<-exitChan
 }
-
-/*	if *freeswitch {
-		sm := &sessionmanager.FSSessionManager{}
-		sm.Connect(sessionmanager.NewDirectSessionDelegate(getter), *freeswitchsrv, *freeswitchpass)
-	}
-	if !*standalone {
-		go RegisterToServer(balancer, listen)
-		go StopSingnalHandler(balancer, listen, getter)
-	}
-*/

cmd/cgr-rater/rater_test.go

@@ -19,6 +19,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 package main
 
 import (
+	"net/rpc"
 	"testing"
 )
 

cmd/cgr-rater/registration.go

@@ -43,7 +43,7 @@ func stopSingnalHandler() {
 	sig := <-c
 	log.Printf("Caught signal %v, sending shutdownto raters\n", sig)
 	bal.Shutdown()
-	os.Exit(1)
+	exitChan <- true
 }
 
 /*
@@ -80,7 +80,7 @@ func (rs *RaterServer) UnRegisterRater(clientAddress string, replay *int) error
 /*
 Listens for the SIGTERM, SIGINT, SIGQUIT system signals and  gracefuly unregister from balancer and closes the storage before exiting.
 */
-func stopRaterSingnalHandler(server, listen *string, sg timespans.StorageGetter) {
+func stopRaterSingnalHandler(server, listen string, sg timespans.StorageGetter) {
 	log.Print("Handling stop signals...")
 	c := make(chan os.Signal)
 	signal.Notify(c, syscall.SIGTERM, syscall.SIGINT, syscall.SIGQUIT)
@@ -89,42 +89,42 @@ func stopRaterSingnalHandler(server, listen *string, sg timespans.StorageGetter)
 	log.Printf("Caught signal %v, unregistering from balancer\n", sig)
 	unregisterFromBalancer(server, listen)
 	sg.Close()
-	os.Exit(1)
+	exitChan <- true
 }
 
 /*
 Connects to the balancer and calls unregister RPC method.
 */
-func unregisterFromBalancer(server, listen *string) {
-	client, err := rpc.DialHTTP("tcp", *server)
+func unregisterFromBalancer(server, listen string) {
+	client, err := rpc.DialHTTP("tcp", server)
 	if err != nil {
 		log.Print("Cannot contact the balancer!")
 		os.Exit(1)
 	}
 	var reply int
-	log.Print("Unregistering from balancer ", *server)
-	client.Call("RaterServer.UnRegisterRater", *listen, &reply)
+	log.Print("Unregistering from balancer ", server)
+	client.Call("RaterServer.UnRegisterRater", listen, &reply)
 	if err := client.Close(); err != nil {
 		log.Print("Could not close balancer unregistration!")
-		os.Exit(1)
+		exitChan <- true
 	}
 }
 
 /*
 Connects to the balancer and rehisters the rater to the server.
 */
-func registerToBalancer(server, listen *string) {
-	client, err := rpc.DialHTTP("tcp", *server)
+func registerToBalancer(server, listen string) {
+	client, err := rpc.DialHTTP("tcp", server)
 	if err != nil {
 		log.Print("Cannot contact the balancer!")
-		os.Exit(1)
+		exitChan <- true
 	}
 	var reply int
-	log.Print("Registering to balancer ", *server)
-	client.Call("RaterServer.RegisterRater", *listen, &reply)
+	log.Print("Registering to balancer ", server)
+	client.Call("RaterServer.RegisterRater", listen, &reply)
 	if err := client.Close(); err != nil {
 		log.Print("Could not close balancer registration!")
-		os.Exit(1)
+		exitChan <- true
 	}
 	log.Print("Registration finished!")
 }

cmd/cgr-rater/responder_direct.go

@@ -21,7 +21,6 @@ package main
 import (
 	"fmt"
 	"github.com/cgrates/cgrates/timespans"
-	"os"
 	"runtime"
 )
 
@@ -100,7 +99,7 @@ RPC method that triggers rater shutdown in case of balancer exit.
 */
 func (s *DirectResponder) Shutdown(args string, reply *string) (err error) {
 	s.sg.Close()
-	defer os.Exit(0)
+	defer func() { exitChan <- true }()
 	*reply = "Done!"
 	return nil
 }

cmd/cgr-rater/responder_rpc.go

@@ -81,6 +81,18 @@ func (r *RpcResponder) Status(arg timespans.CallDescriptor, replay *string) (err
 	return
 }
 
+func (r *RpcResponder) Shutdown(arg string, replay *string) (err error) {
+	memstats := new(runtime.MemStats)
+	runtime.ReadMemStats(memstats)
+	*replay = "Connected raters:\n"
+	for _, rater := range bal.GetClientAddresses() {
+		log.Print(rater)
+		*replay += fmt.Sprintf("%v\n", rater)
+	}
+	*replay += fmt.Sprintf("memstats before GC: %dKb footprint: %dKb", memstats.HeapAlloc/1024, memstats.Sys/1024)
+	return
+}
+
 /*
 The function that gets the information from the raters using balancer.
 */