go 快速入门2 ： 搭建简单RPC服务器部署，子服务器通过心跳保持长连接。

将client代码部署在各个服务器，通过心跳与monitor保持联系，
monitor统一任务下放，简单的例子，还没有具体实现。

//agent
package main

import (
    "fmt"
    "net/rpc/jsonrpc"
    "log"
    "time"
    "net/rpc"
    "strconv"
    "domain"
)

var Clo chan bool

func main() {
    Clo = make(chan bool)
    client, err := jsonrpc.Dial("tcp", "127.0.0.1:8088")
    if err != nil {
        log.Fatal("dialhttp: ", err)
    }
    defer client.Close()
    go Handler(client)
    select {
    case <- Clo:
        fmt.Println("关闭连接")
    }
}

func Handler(client *rpc.Client) {
    go heartBeat(client)
}

func GetTask(client *rpc.Client) {
    var reply *domain.DeployTaskJob
    err := client.Call("MyRPC.DeployJob", "agent1", &reply)
    if err != nil {
        log.Fatal("call DeployJob: ", err)
    }
    fmt.Println("getTask success")
    fmt.Println(*reply)
}

func heartBeat(client *rpc.Client) {
    i :=0
    for {
        time.Sleep(5 * time.Second)
        var reply *domain.ReplyMessage
        fmt.Println("send HeartBeat"+strconv.Itoa(i))
        m := domain.HeartMessage{"agent1", "heart"}
        err := client.Call("MyRPC.HeartBeat", m, &reply)
        fmt.Println(*reply)
        if err != nil {
            log.Fatal("call heartBeat: ", err)
        }
        if reply.Ack{
            fmt.Println("heartBeat normal")
        }
        if reply.TaskStatus{
            fmt.Println("need to get task")
        }
        i++
        go GetTask(client);
    }
}

 

//SERVER
package main

import (
"fmt"
"net"
"net/rpc"
"net/rpc/jsonrpc"
"os"
    "domain"
)


type MyRPC int

func (r *MyRPC) HeartBeat(M domain.HeartMessage, reply *domain.ReplyMessage) error {
    fmt.Println(M)
    reply.Ack = true

    //此处遍历任务队列
    reply.TaskStatus = true
    return nil
}

func (r *MyRPC) DeployJob(name string, deployTaskJob *domain.DeployTaskJob) error {
    fmt.Println(name)
    //此处根据agent name取出对应的任务
    deployTaskJob.TaskName = "epoch"
    deployTaskJob.ShCommand = "ls -a"
    deployTaskJob.TaskRemotePath = "/opt/test"
    return nil
}

func main() {
    r := new(MyRPC)
    rpc.Register(r)

    tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8088")
    checkError(err)

    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)

    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        jsonrpc.ServeConn(conn)
        fmt.Println("开始监听")
    }

}

func checkError(err error) {
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
        os.Exit(1)
    }
}

 

转载于:https://www.cnblogs.com/hzk0413/p/7159083.html