func main() {
if err := rpc.Register(plug); err != nil {
log.Fatal(err)
}
flag.Parse()
config()
bort.PluginInit(cfg.OutboxSize)
listen, err := net.Listen("tcp", cfg.Address)
if err != nil {
log.Fatalln(err)
}
for {
con, err := listen.Accept()
if err != nil {
log.Println(err)
time.Sleep(1 * time.Second)
continue
}
log.Println("connected to bort")
rpc.ServeConn(con)
log.Println("disconnected from bort")
}
}
func (rs *RpcServer) Start() error {
serverAddr, err := net.ResolveTCPAddr(rs.net, rs.addr)
if err != nil {
return err
}
serverListener, err := net.ListenTCP(rs.net, serverAddr)
if err != nil {
return err
}
rs.listener = serverListener
go func(listener *net.TCPListener) {
for {
conn, err := listener.AcceptTCP()
if err != nil {
global.Logger.Warn("the RPC server accept the client link failure: %s", err.Error())
rs.Stop()
global.Logger.Warn("the RPC server has stopped!")
return
}
rpc.ServeConn(conn)
}
}(rs.listener)
return nil
}
func main() {
arith := new(Arith)
rpc.Register(arith)
/*
rpc.HandleHTTP()
err := http.ListenAndServe(":1234", nil)
if err != nil {
fmt.Println(err.Error())
}
*/
tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
if err != nil {
log.Fatal("resovleTCPAddr failed.", err)
return
}
ln, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
log.Fatal("listen failed.", err)
return
}
for {
conn, err := ln.Accept()
if err != nil {
continue
}
// go routine
go rpc.ServeConn(conn)
}
}
func main() {
arith := new(Arith)
rpc.Register(arith)
tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
checkError(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
/* This works:
rpc.Accept(listener)
*/
/* and so does this:
*/
for {
conn, err := listener.Accept()
if err != nil {
continue
}
rpc.ServeConn(conn)
}
}
func (this *daemon) loop() {
conn_in := make(chan net.Conn)
go func() {
for {
c, err := this.listener.Accept()
if err != nil {
panic(err)
}
conn_in <- c
}
}()
timeout := time.Duration(g_config.CloseTimeout) * time.Second
countdown := time.NewTimer(timeout)
for {
// handle connections or server CMDs (currently one CMD)
select {
case c := <-conn_in:
rpc.ServeConn(c)
countdown.Reset(timeout)
runtime.GC()
case cmd := <-this.cmd_in:
switch cmd {
case daemon_close:
return
}
case <-countdown.C:
return
}
}
}
func runServer() {
go processCommands()
go runHTTPServer()
s := new(Server)
rpc.Register(s)
l, err := net.Listen("unix", sock)
defer os.Remove(sock)
if err != nil {
fatal(err)
}
s.quit = make(chan bool)
conns := make(chan net.Conn)
go func() {
for {
c, err := l.Accept()
if err != nil {
fatal(err)
}
conns <- c
}
}()
for {
select {
case c := <-conns:
go rpc.ServeConn(c)
case <-s.quit:
fmt.Println("Quitting.")
// Give shutdown RPC time to return normally.
time.Sleep(10 * time.Millisecond)
return
}
}
}
func main() {
math := new(Math)
rpc.Register(math)
tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
if err != nil {
fmt.Println("Fatal error ", err.Error())
os.Exit(1)
}
listener, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
fmt.Println("Fatal error ", err.Error())
os.Exit(1)
}
for {
conn, err := listener.Accept()
if err != nil {
continue
}
rpc.ServeConn(conn)
}
}
func BenchmarkGOBRPC_pipe(b *testing.B) {
cli, srv := net.Pipe()
go rpc.ServeConn(srv)
client := rpc.NewClient(cli)
defer client.Close()
benchmarkRPC(b, client)
}
func main() {
err := rpc.Register(new(Calc))
if err != nil {
fmt.Println(err)
return
}
listen, err := net.Listen("tcp", ":6000")
if err != nil {
fmt.Println(err)
return
}
defer listen.Close()
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println(err)
continue
}
defer conn.Close()
go rpc.ServeConn(conn)
}
}
func (server *UmgmtServer) Serve() error {
relog.Info("started umgmt server: %v", server.listener.Addr())
for !server.quit {
conn, err := server.listener.Accept()
if err != nil {
if checkError(err, syscall.EINVAL) {
if server.quit {
return nil
}
return err
}
// syscall.EMFILE, syscall.ENFILE could happen here if you run out of file descriptors
relog.Error("accept error %v", err)
continue
}
server.Lock()
server.connMap[conn] = true
server.Unlock()
rpc.ServeConn(conn)
server.Lock()
delete(server.connMap, conn)
server.Unlock()
}
return nil
}
func Start() {
if !g.Config().Rpc.Enabled {
return
}
addr := g.Config().Rpc.Listen
tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
log.Fatalf("net.ResolveTCPAddr fail: %s", err)
}
listener, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
log.Fatalf("listen %s fail: %s", addr, err)
} else {
log.Println("rpc listening", addr)
}
rpc.Register(new(Judge))
for {
conn, err := listener.Accept()
if err != nil {
log.Printf("listener.Accept occur error: %s", err)
continue
}
go rpc.ServeConn(conn)
}
}
func RunCatServerListener(listenURL string) {
println("Server opens connection.")
csr := CatServerRPC{make(map[string]*CatInfo)}
rpc.Register(&csr)
l, e := net.Listen("tcp", ":1887")
if e != nil {
log.Println("listen error:", e)
}
conChan := make(chan *net.Conn, 100)
// Close after 2 seconds, make it flap..
time.AfterFunc(2*time.Second, func() {
println("-- Server flaps connection.")
l.Close()
for a := range conChan {
(*a).Close()
}
})
for {
c, e := l.Accept()
if e != nil {
break // We cause this error.
}
conChan <- &c
go rpc.ServeConn(c)
}
println("Server exiting.")
}
func rpcInit() error {
cmd := new(Cmd)
rpc.Register(cmd)
l, err := net.Listen("unix", GlobalOpt.UnixSocket)
if err != nil {
return err
}
go func() {
var tempDelay time.Duration
for {
conn, err := l.Accept()
if err != nil {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
time.Sleep(tempDelay)
continue
}
tempDelay = 0
go func() {
rpc.ServeConn(conn)
}()
}
}()
return nil
}
func (this *daemon) loop() {
conn_in := make(chan net.Conn)
go func() {
for {
c, err := this.listener.Accept()
if err != nil {
panic(err)
}
conn_in <- c
}
}()
for {
// handle connections or server CMDs (currently one CMD)
select {
case c := <-conn_in:
rpc.ServeConn(c)
runtime.GC()
case cmd := <-this.cmd_in:
switch cmd {
case daemon_close:
return
}
}
}
}
func Serve(c *lemon.CLI) error {
port := c.Port
allowIP := c.Allow
LineEndingOpt = c.LineEnding
ra, err := iprange.New(allowIP)
if err != nil {
return err
}
addr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf(":%d", port))
if err != nil {
return err
}
l, err := net.ListenTCP("tcp", addr)
if err != nil {
return err
}
for {
conn, err := l.Accept()
if err != nil {
log.Println(err)
continue
}
log.Printf("Request from %s", conn.RemoteAddr())
if !ra.InlucdeConn(conn) {
continue
}
connCh <- conn
rpc.ServeConn(conn)
}
}
func Handle(listener *Listener, coordinator Coordinator) {
coordinator.Register()
for {
conn, err := listener.Accept()
if err != nil {
log.Printf("Error: %s\n", err)
continue
}
class, err := readOneByte(conn)
if err != nil {
conn.Close()
}
switch class {
case 'm':
log.Printf("Minion has connected.\n")
mConn := conn.(*Conn)
go coordinator.Handle(rpc.NewClient(conn), mConn)
case 'r':
log.Printf("Administrator has connected.\n")
go rpc.ServeConn(conn)
default:
log.Printf("No idea what that was. Closing. Value %c\n", class)
conn.Close()
}
}
}
func Start() {
if !g.Config().Rpc.Enabled {
return
}
addr := g.Config().Rpc.Listen
tcpAddr, err := net.ResolveTCPAddr("tcp", addr)
if err != nil {
log.Fatalf("net.ResolveTCPAddr fail: %s", err)
}
listener, err := net.ListenTCP("tcp", tcpAddr)
if err != nil {
log.Fatalf("listen %s fail: %s", addr, err)
} else {
log.Println("rpc listening", addr)
}
rpc.Register(new(Graph))
go func() {
var tempDelay time.Duration // how long to sleep on accept failure
for {
conn, err := listener.Accept()
if err != nil {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
time.Sleep(tempDelay)
continue
}
tempDelay = 0
go func() {
e := connects.insert(conn)
defer connects.remove(e)
rpc.ServeConn(conn)
}()
}
}()
select {
case <-Close_chan:
log.Println("api recv sigout and exit...")
listener.Close()
Close_done_chan <- 1
connects.Lock()
for e := connects.list.Front(); e != nil; e = e.Next() {
e.Value.(net.Conn).Close()
}
connects.Unlock()
return
}
}
func Run(configFile string, port string) {
t := new(Job)
resetJob(t)
config := configparser.ParseFile(configFile)
t.NumMap = config.NumMap
t.NumReduce = config.NumReduce
t.Master = config.Master
t.ReduceDataPort = config.ReduceDataPort
os.RemoveAll(config.MapDir)
os.RemoveAll(config.ReduceDir)
os.Mkdir(config.MapDir, 0755)
os.Mkdir(config.ReduceDir, 0755)
rpc.Register(t)
listener, e := net.Listen("tcp", fmt.Sprintf(":%s", port))
Port = port
if e != nil {
log.Fatal("listen error:", e)
}
for {
if conn, err := listener.Accept(); err != nil {
log.Fatal("accept error: " + err.Error())
} else {
go rpc.ServeConn(conn)
}
}
}
func (s *Server) ServeGOB(addr string) {
if !s.rpcEnabled {
return
}
lGOB, e := net.Listen("tcp", addr)
if e != nil {
log.Fatal("ServeGOB listen error:", e)
}
Logger.Info(fmt.Sprintf("Starting CGRateS GOB server at <%s>.", addr))
errCnt := 0
var lastErrorTime time.Time
for {
conn, err := lGOB.Accept()
if err != nil {
Logger.Err(fmt.Sprintf("<CGRServer> GOB accept error: <%s>", err.Error()))
now := time.Now()
if now.Sub(lastErrorTime) > time.Duration(5*time.Second) {
errCnt = 0 // reset error count if last error was more than 5 seconds ago
}
lastErrorTime = time.Now()
errCnt += 1
if errCnt > 50 { // Too many errors in short interval, network buffer failure most probably
break
}
continue
}
//utils.Logger.Info(fmt.Sprintf("<CGRServer> New incoming connection: %v", conn.RemoteAddr()))
go rpc.ServeConn(conn)
}
}
func main() {
log.SetFlags(0)
log.SetPrefix("ogleproxy: ")
flag.Parse()
if *textFlag == "" {
fmt.Printf("OGLE BAD\n")
flag.Usage()
os.Exit(2)
}
s, err := server.New(*textFlag)
if err != nil {
fmt.Printf("OGLE BAD\n%s\n", err)
os.Exit(2)
}
err = rpc.Register(s)
if err != nil {
fmt.Printf("OGLE BAD\n%s\n", err)
os.Exit(2)
}
fmt.Println("OGLE OK")
log.Print("start server")
// TODO: Usually done in a go.
rpc.ServeConn(&rwc{
os.Stdin,
os.Stdout,
})
log.Print("finish server")
}
//启动HTTP服务监控指定端口
func ListenAndServer(port string) { // {{{
executer := new(CmdExecuter)
rpc.Register(executer)
l.Infoln("Worker is running Port:", port)
tcpAddr, err := net.ResolveTCPAddr("tcp", port)
checkErr(err)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkErr(err)
go func() {
for {
conn, err := listener.Accept()
if err != nil {
continue
}
go func() {
rpc.ServeConn(conn)
}()
}
}()
} // }}}
func main() {
tuple := new(Tuple)
hashtable := new(Hashtable)
rpc.Register(tuple)
rpc.Register(hashtable)
tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
checkError(err)
fmt.Println(tcpAddr)
listener, err := net.ListenTCP("tcp", tcpAddr)
checkError(err)
/* This works:
rpc.Accept(listener)
*/
/* and so does this:
*/
for {
conn, err := listener.Accept()
if err != nil {
continue
}
rpc.ServeConn(conn)
}
fmt.Println("END OF MAIN")
}
func (self *Service) Loop() {
listener, err := net.Listen(GetServiceSocket(self.tcpPort))
if err != nil {
panic(err)
}
connInput := make(chan net.Conn, 2)
go func() {
for {
conn, err := listener.Accept()
if err != nil {
log.Printf("Service cannot accept new connections: %v", err)
self.Close()
}
connInput <- conn
}
}()
for {
select {
case conn := <-connInput:
rpc.ServeConn(conn)
runtime.GC()
case command := <-self.commandInput:
if command == SERVICE_COMMAND_CLOSE {
return
} else if command == SERVICE_COMMAND_RELOAD {
self.ReloadImpl()
}
}
}
}
func server(port string) {
fmt.Println("Gosync server starting at port", port)
// create a list of ServFiles on server
fileList = CreateServFileList(".")
// Print the serv file list
fmt.Println("Files being served:")
for _, file := range fileList {
fmt.Println(file.Name, ":", file.Sha1)
}
rpc.Register(new(Server))
listener, err := net.Listen("tcp", ":"+port)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Awaiting connection")
for {
c, err := listener.Accept()
if err != nil {
continue
}
fmt.Println("Accepted connection from", c.RemoteAddr())
go rpc.ServeConn(c)
}
}
func RunReceiverRPC() {
log.Info("Starting Receiver RPC\n")
ln, err := net.ListenUnix("unix", appAddr)
if err != nil {
log.Errorf("Failed to start RPC server: %v", err)
return
}
Receiver = receiverrpc.Receiver{}
rpc.Register(&Receiver)
log.Infof("RPC server is listening on %s\n", appAddr.String())
defer func() {
// close the listener sock
log.Info("Closing listener socket.\n")
ln.Close()
}()
for {
ln.SetDeadline(time.Now().Add(time.Second))
conn, err := ln.AcceptUnix()
if err != nil {
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
// just accept timeout, not an error
continue
}
log.Error("Failed to accept: %s", err.Error())
continue
}
rpc.ServeConn(conn)
}
}
func (ts *TestServer) Start() error {
var err error
ts.stopCh = make(chan struct{})
ts.listener, err = net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return err
}
go func() {
for {
conn, err := ts.listener.Accept()
if err != nil {
select {
case <-ts.stopCh:
return
default:
fmt.Println(err)
}
} else {
go rpc.ServeConn(conn)
}
}
}()
return nil
}
func main() {
var err error
var clientConn net.Conn
var errLoggedListen, errLoggedClientConn = false, false
runtime.GOMAXPROCS(4)
if err = rpc.Register(rpcService); err != nil {
os.Exit(1)
}
for {
if rpcListener == nil {
if rpcListener, err = net.Listen("tcp", ":9669"); err != nil {
rpcListener = nil
if !errLoggedListen {
errLoggedListen = true
logf("Failed to establish TCP listener, will keep retrying. Error: %+v", err)
}
} else {
errLoggedListen = false
logf("TCP listener established.")
}
}
if rpcListener != nil {
if clientConn, err = rpcListener.Accept(); err == nil {
errLoggedClientConn = false
go rpc.ServeConn(clientConn)
} else if !errLoggedClientConn {
errLoggedClientConn = true
rpcListener.Close()
rpcListener = nil
logf("Failed to accept TCP connection, will re-establish TCP listener. Error: %+v", err)
}
}
}
}
func (cli *CliRpcService) Start() error {
var err error
cli.stopCh = make(chan struct{})
cli.listener, err = net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return err
}
go func() {
for {
conn, err := cli.listener.Accept()
if err != nil {
select {
case <-cli.stopCh:
return
default:
fmt.Println(err)
}
} else {
go rpc.ServeConn(conn)
}
}
}()
return nil
}
func acceptorRun(ln net.Listener) {
for {
c, err := ln.Accept()
if err != nil {
continue
}
rpc.ServeConn(c)
}
}
func child() {
logger := log.New(os.Stderr, "child: ", log.Ldate|log.Ltime)
logger.Println("child mode")
echo := new(Echo)
rpc.Register(echo)
m := moreio.NewReadWriteCloser(os.Stdin, os.Stdout)
rpc.ServeConn(m)
}