func (client *Client) ConfigureHeartbeat(receiver *protocols.Server, token int64, timeout time.Duration) error {
packet := ConfigureHeartbeatPacket{
Token: token,
TargetServer: receiver.LocalAddr().String(),
Timeout: timeout,
}
reply, err := client.SendRequest(codeConfigureHeartbeat, packet)
if err != nil {
return err
}
return client.CheckReply(reply)
}
func RegisterServer(server *protocols.Server) (*LoadStats, error) {
if err := server.Protocol().CheckIncludesFragment(Protocol.Name()); err != nil {
return nil, err
}
stats := &LoadStats{
server: server,
Received: stats.NewStats("Received"),
Missed: stats.NewStats("Missed"),
}
err := server.RegisterHandlers(protocols.ServerHandlerMap{
codeLoad: stats.handleLoad,
})
if err != nil {
return nil, err
}
return stats, nil
}
func startLoadClient() (port int) {
port = start_rtp_port
var server *protocols.Server
var stats *load.LoadStats
for {
var err error
server, err = protocols.NewServer(net.JoinHostPort(rtp_ip, strconv.Itoa(port)), load.MiniProtocol)
if err != nil {
log.Printf("Failed to start Load server on port %v: %v", port, err)
port += 2
continue
}
stats, err = load.RegisterServer(server)
if err != nil {
log.Printf("Failed to register Load server on port %v: %v", port, err)
port += 2
continue
}
if print_load_packets {
stats.Handler = func(packet *load.LoadPacket) {
packet.PrintReceived()
}
}
break
}
tasks.AddNamed("client", server)
go func() {
for err := range server.Errors() {
log.Println("Error receiving Load:", err)
}
}()
log.Printf("Listening on %v UDP port %v for Load\n", rtp_ip, port)
statistics = append(statistics, stats.Received)
statistics = append(statistics, stats.Missed)
return
}
func RegisterServerHandler(server *protocols.Server, handler HeartbeatServerHandler) error {
if err := server.Protocol().CheckIncludesFragment(Protocol.Name()); err != nil {
return err
}
return server.RegisterHandlers(protocols.ServerHandlerMap{
codeHeartbeat: func(packet *protocols.Packet) *protocols.Packet {
val := packet.Val
if beat, ok := val.(*HeartbeatPacket); ok {
handler.HeartbeatReceived(beat)
} else {
server.LogError(fmt.Errorf("Heartbeat received with wrong payload: (%T) %v", val, val))
}
return nil
},
})
}
func RegisterServer(server *protocols.Server, handler Handler) error {
if err := server.Protocol().CheckIncludesFragment(Protocol.Name()); err != nil {
return err
}
state := &serverState{
Server: server,
handler: handler,
}
if err := server.RegisterHandlers(protocols.ServerHandlerMap{
CodeRedirectStream: state.handleRedirectStream,
CodePauseStream: state.handlePauseStream,
CodeResumeStream: state.handleResumeStream,
}); err != nil {
return err
}
server.RegisterStopHandler(state.stopServer)
return nil
}
func RegisterServer(server *protocols.Server, handler Handler) error {
if err := server.Protocol().CheckIncludesFragment(Protocol.Name()); err != nil {
return err
}
state := &serverState{
Server: server,
handler: handler,
}
if err := server.RegisterHandlers(protocols.ServerHandlerMap{
codeStartProxy: state.handleStartProxy,
codeStopProxy: state.handleStopProxy,
codeStartProxyPair: state.handleStartProxyPair,
codeStopProxyPair: state.handleStopProxyPair,
}); err != nil {
return err
}
server.RegisterStopHandler(state.stopServer)
return nil
}
func printServerErrors(servername string, server *protocols.Server) {
for err := range server.Errors() {
log.Println(servername + " error: " + err.Error())
}
}
func printErrors(server *protocols.Server) {
for err := range server.Errors() {
log.Println("Server error: " + err.Error())
}
}
