main.go

package main

import (
	"GoRPC/gorpc"
	"GoRPC/registry"
	"GoRPC/xclient"
	"context"
	"log"
	"net"
	"net/http"
	"sync"
	"time"
)

type Foo int
type Args struct{Num1,Num2 int}
func (f Foo) Sum(args Args,reply *int) error{
	*reply = args.Num1 + args.Num2
	return nil
}

func (f Foo) Sleep(args Args,reply *int) error{
	time.Sleep(time.Second * time.Duration(args.Num1))
	*reply = args.Num2 + args.Num1
	return nil
}

func startRegistry(wg *sync.WaitGroup){
	l,_ := net.Listen("tcp",":3080")
	registry.HandleHTTP()
	wg.Done()
	http.Serve(l,nil)
}

func startServer(registryAddr string,wg *sync.WaitGroup){
	var foo Foo
	l,_ := net.Listen("tcp",":0")
	server := gorpc.NewServer()
	server.Register(&foo)
	registry.Heartbeat(registryAddr,"tcp@"+l.Addr().String(),0)
	wg.Done()
	server.Accept(l)
}

func foo(xc *xclient.XClient,ctx context.Context,typ,serviceMethod string,args *Args){
	var reply int
	var err error
	switch typ {
	case "call":
		err = xc.Call(ctx,serviceMethod,args,&reply)
	case "broadcast":
		err = xc.Broadcast(ctx,serviceMethod,args,&reply)
	}
	if err != nil{
		log.Printf("%s %s error: %v",typ,serviceMethod,err)
	}else{
		log.Printf("%s %s success: %d + %d = %d",typ,serviceMethod,args.Num1,args.Num2,reply)
	}
}

func call(registry string){
	d := xclient.NewGoRegistryDiscovery(registry,0)
	xc := xclient.NewXClient(d,xclient.RandomSelect,nil)

	defer func(){xc.Close()}()

	var wg sync.WaitGroup
	for i:=0;i<5;i++{
		wg.Add(1)
		go func(i int){
			defer wg.Done()
			foo(xc,context.Background(),"call","Foo.Sum",&Args{i,i*i})
		}(i)
	}
	wg.Wait()
}
func broadcast(registry string){
	d := xclient.NewGoRegistryDiscovery(registry,0)
	xc := xclient.NewXClient(d,xclient.RandomSelect,nil)
	defer func(){xc.Close()}()
	var wg sync.WaitGroup
	for i:=0;i<5;i++{
		wg.Add(1)
		go func(i int){
			defer wg.Done()
			foo(xc,context.Background(),"broadcast","Foo.Sum",&Args{i,i*i})
			ctx,_:= context.WithTimeout(context.Background(),time.Second*2)
			foo(xc,ctx,"broadcast","Foo.Sleep",&Args{i,i*i})
		}(i)
	}
	wg.Wait()
}

func main(){
	log.SetFlags(0)
	registryAddr := "http://localhost:3080/_gorpc_/registry"
	var wg sync.WaitGroup
	wg.Add(1)
	go startRegistry(&wg)
	wg.Wait()
	time.Sleep(time.Second)
	wg.Add(2)
	go startServer(registryAddr,&wg)
	go startServer(registryAddr,&wg)

	wg.Wait()
	time.Sleep(time.Second)

	call(registryAddr)
	broadcast(registryAddr)

}