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

changed project structure

Browse Source
This commit is contained in:
Radu Ioan Fericean
2012-01-25 13:49:39 +02:00
parent 1d2e20a7e6
commit e4982d248d
4 changed files with 0 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/cmd/inquirer.go
View File

@@ -1,48 +0,0 @@
package main
import (
"fmt"
"log"
"net/http"
"net/rpc"
"time"
"registration"
)
var raterList *registration.RaterList
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "<html><body><ol>")
for addr, _ := range raterList.Clients {
fmt.Fprint(w, fmt.Sprintf("<li>%s</li>", addr))
}
fmt.Fprint(w, "</ol></body></html>")
}
func callRater(rl *registration.RaterList) {
var reply float64
arg := 9.0
log.Print("Starting client polling.")
for {
for addr, client := range rl.Clients {
err := client.Call("Sumer.Square", arg, &reply)
if err != nil {
log.Print("Closing client!")
delete(rl.Clients, addr)
}
fmt.Println(fmt.Sprintf("Result from rater(%v): %v", addr, reply))
}
time.Sleep(5 * time.Second)
}
}
func main() {
raterList = &registration.RaterList{Clients: make(map[string]*rpc.Client)}
go callRater(raterList)
rpc.Register(raterList)
rpc.HandleHTTP()
http.HandleFunc("/", handler)
log.Print("The server is listening...")
http.ListenAndServe(":2000", nil)
}

37
src/cmd/rater.go
View File

@@ -1,37 +0,0 @@
package main
import (
"flag"
"log"
"math"
"net"
"net/rpc"
"registration"
)
var (
server = flag.String("server", "127.0.0.1:2000", "target host:port")
listen = flag.String("listen", "127.0.0.1:1234", "target host:port")
)
type Sumer int
func (t *Sumer) Square(n float64, reply *float64) error {
*reply = math.Sqrt(n)
return nil
}
func main() {
flag.Parse()
arith := new(Sumer)
rpc.Register(arith)
rpc.HandleHTTP()
go registration.RegisterToServer(server, listen)
go registration.StopSingnalHandler(server, listen)
addr, err1 := net.ResolveTCPAddr("tcp", *listen)
l, err2 := net.ListenTCP("tcp", addr)
if err1 != nil || err2 != nil {
log.Panic("cannot create listener for specified address ", *listen)
}
rpc.Accept(l)
}

31
src/pkg/registration/inquirerregistration.go
View File

@@ -1,31 +0,0 @@
package registration
import (
"fmt"
"log"
"net/rpc"
"time"
)
type RaterList struct {
Clients map[string]*rpc.Client
}
func (rl *RaterList) RegisterRater(clientAddress string, replay *byte) error {
time.Sleep(1 * time.Second) // wait a second for Rater to start serving
client, err := rpc.Dial("tcp", clientAddress)
if err != nil {
log.Panic("Could not connect to client!")
}
rl.Clients[clientAddress] = client
log.Print(fmt.Sprintf("Server %v registered succesfully", clientAddress))
return nil
}
func (rl *RaterList) UnRegisterRater(clientAddress string, replay *byte) error {
client := rl.Clients[clientAddress]
client.Close()
delete(rl.Clients, clientAddress)
log.Print(fmt.Sprintf("Server %v unregistered succesfully", clientAddress))
return nil
}

47
src/pkg/registration/raterregistration.go
View File

@@ -1,47 +0,0 @@
package registration
import (
"log"
"net/rpc"
"os"
"os/signal"
"syscall"
)
func StopSingnalHandler(server, listen *string) {
sig := <-signal.Incoming
if usig, ok := sig.(os.UnixSignal); ok {
switch usig {
case syscall.SIGTERM, syscall.SIGINT, syscall.SIGQUIT:
log.Printf("Caught signal %v, unregistering from server\n", usig)
unregisterFromServer(server, listen)
os.Exit(1)
}
}
}
func unregisterFromServer(server, listen *string) {
client, err := rpc.DialHTTP("tcp", *server)
if err != nil {
log.Panic("Cannot register to server!")
}
var reply byte
log.Print("Unregistering from server ", *server)
client.Call("RaterList.UnRegisterRater", *listen, &reply)
if err := client.Close(); err != nil {
log.Panic("Could not close server unregistration!")
}
}
func RegisterToServer(server, listen *string) {
client, err := rpc.DialHTTP("tcp", *server)
if err != nil {
log.Panic("Cannot register to server!")
}
var reply byte
log.Print("Registering to server ", *server)
client.Call("RaterList.RegisterRater", *listen, &reply)
if err := client.Close(); err != nil {
log.Panic("Could not close server registration!")
}
}