func (self *FalconClient) insureConn() error {
if self.rpcClient != nil {
return nil
}
var err error
var retry int = 1
for {
if self.rpcClient != nil {
return nil
}
self.rpcClient, err = net.JsonRpcClient("tcp", self.RpcServer, self.Timeout)
if err == nil {
return nil
}
glog.Warningf("Metrics rpc dial fail %s", err)
if retry > 5 {
return err
}
time.Sleep(time.Duration(math.Pow(2.0, float64(retry))) * time.Second)
retry++
}
}
func (this *SingleConnRpcClient) insureConn() {
if this.rpcClient != nil {
return
}
var err error
var retry int = 1
for {
if this.rpcClient != nil {
return
}
this.rpcClient, err = net.JsonRpcClient("tcp", this.RpcServer, this.Timeout)
if err == nil {
return
}
glog.Warningf("dial %s fail: %v", this.RpcServer, err)
if retry > 6 {
retry = 1
}
time.Sleep(time.Duration(math.Pow(2.0, float64(retry))) * time.Second)
retry++
}
}
func (this *SingleConnRpcClient) serverConn() error {
if this.rpcClient != nil {
return nil
}
var err error
var retry int = 1
for {
if this.rpcClient != nil {
return nil
}
this.rpcClient, err = net.JsonRpcClient("tcp", this.RpcServer, this.Timeout)
if err != nil {
log.Printf("dial %s fail: %v", this.RpcServer, err)
if retry > 3 {
return err
}
time.Sleep(time.Duration(math.Pow(2.0, float64(retry))) * time.Second)
retry++
continue
}
return err
}
}
func (this *SingleConnRpcClient) insureConn() {
if this.rpcClient != nil {
return
}
var err error
var retry int = 1
for {
if this.rpcClient != nil {
return
}
this.rpcClient, err = net.JsonRpcClient("tcp", this.RpcServer, this.Timeout)
if err == nil {
return
}
log.Println("[ hbs ] Error on query:", err)
if retry > 6 {
retry = 1
}
time.Sleep(time.Duration(math.Pow(2.0, float64(retry))) * time.Second)
retry++
}
}
func (this *SingleConnRpcClient) insureConn() error {
if this.rpcClient != nil {
return nil
}
var err error
var retry int = 1
for {
if this.rpcClient != nil {
return nil
}
this.rpcClient, err = net.JsonRpcClient("tcp", this.RpcServer, this.Timeout)
if err == nil {
return nil
}
logs.Info("Metrics rpc dial fail", err)
if retry > 5 {
return err
}
time.Sleep(time.Duration(math.Pow(2.0, float64(retry))) * time.Second)
retry++
}
return nil
}
func (this *SingleConnRpcClient) insureConn() {
if this.rpcClient != nil {
return
}
var err error
var retry int = 1
for {
if this.rpcClient != nil {
return
}
for _, s := range this.RpcServers {
this.rpcClient, err = net.JsonRpcClient("tcp", s, this.Timeout)
if err == nil {
return
}
log.Printf("dial %s fail: %s", s, err)
}
if retry > 6 {
retry = 1
}
time.Sleep(time.Duration(math.Pow(2.0, float64(retry))) * time.Second)
retry++
}
}
func (rpcTestEnvInstance *RpcTestEnv) ListenAndExecute(
rcvr interface{}, rpcCallback func(*RpcTestEnv),
) {
server := rpc.NewServer()
server.Register(rcvr)
var address = fmt.Sprintf("localhost:%d", rpcTestEnvInstance.Port)
/**
* Listening RPC
*/
listener, err := net.Listen("tcp", address)
if err != nil {
panic(fmt.Errorf("Cannot listen TCP[%d]. Error: %v", rpcTestEnvInstance.Port, err))
}
log.Printf("Listen RPC at port [%d]", rpcTestEnvInstance.Port)
// :~)
go func() {
for {
conn, err := listener.Accept()
if err != nil {
if rpcTestEnvInstance.stop {
log.Printf("Stop RPC server")
rpcTestEnvInstance.wait <- true
}
break
}
go server.ServeCodec(jsonrpc.NewServerCodec(conn))
}
}()
/**
* Initialize RPC client
*/
rpcTestEnvInstance.RpcClient, err = tknet.JsonRpcClient("tcp", address, time.Second*3)
if err != nil {
panic(fmt.Errorf("Initialize RPC client error: %v", err))
}
log.Printf("Construct RPC Client")
// :~)
defer func() {
rpcTestEnvInstance.RpcClient.Close()
rpcTestEnvInstance.stop = true
listener.Close()
<-rpcTestEnvInstance.wait
}()
rpcCallback(rpcTestEnvInstance)
}