func NewServer(local_addr string) (server *Server, err error) { server = new(Server) server.Server, err = protocols.NewServer(local_addr, MiniProtocol) server.Server.RegisterHandlers(protocols.ServerHandlerMap{ CodeMeasureLatency: server.HandleMeasureLatency, }) if err != nil { server = nil } return }
func NewHeartbeatServer(local_addr string) (*HeartbeatServer, error) { heartbeatServer := &HeartbeatServer{ detectors: make(map[int64]*HeartbeatFaultDetector), } if server, err := protocols.NewServer(local_addr, &serverStopper{MiniProtocol, heartbeatServer}); err == nil { heartbeatServer.Server = server if err = RegisterServerHandler(server, heartbeatServer); err == nil { return heartbeatServer, nil } else { return nil, err } } else { return nil, err } }
func main() { payloadSize := flag.Uint("payload", 0, "Additional payload to append to Load packets") amp_addr := protocols.ParseServerFlags("0.0.0.0", 7770) proto, err := protocols.NewProtocol("AMP/Load", amp.Protocol, amp_control.Protocol, ping.Protocol, heartbeat.Protocol) golib.Checkerr(err) server, err := protocols.NewServer(amp_addr, proto) golib.Checkerr(err) loadServer, err := RegisterLoadServer(server) golib.Checkerr(err) loadServer.PayloadSize = *payloadSize go printErrors(server) log.Println("Listening:", server) log.Println("Press Ctrl-C to close") golib.NewTaskGroup( server, &golib.NoopTask{golib.ExternalInterrupt(), "external interrupt"}, ).WaitAndExit() }
func main() { proxies.UdpProxyFlags() pcp_addr := protocols.ParseServerFlags("0.0.0.0", 7778) proto, err := protocols.NewProtocol("PCP", pcp.Protocol, ping.Protocol, heartbeat.Protocol) golib.Checkerr(err) server, err := protocols.NewServer(pcp_addr, proto) golib.Checkerr(err) proxy, err := proxies.RegisterPcpProxy(server) golib.Checkerr(err) go printPcpErrors(proxy) proxy.ProxyStartedCallback = proxyStarted proxy.ProxyStoppedCallback = proxyStopped log.Println("Listening:", server) log.Println("Press Ctrl-C to close") golib.NewTaskGroup( server, &golib.NoopTask{golib.ExternalInterrupt(), "external interrupt"}, ).WaitAndExit() }
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 main() { loadBackend := flag.Bool("load", false, "Use Load servers to create the streams, instead of regular AMP Media servers") useHeartbeat := flag.Bool("heartbeat", false, "Use heartbeat-based fault detection instead of active ping-based detection") _heartbeat_frequency := flag.Uint("heartbeat_frequency", 200, "Time between two heartbeats which observers will send (milliseconds)") _heartbeat_timeout := flag.Uint("heartbeat_timeout", 350, "Time between two heartbeats before assuming offline server (milliseconds)") amp_addr := protocols.ParseServerFlags("0.0.0.0", 7779) heartbeat_frequency := time.Duration(*_heartbeat_frequency) * time.Millisecond heartbeat_timeout := time.Duration(*_heartbeat_timeout) * time.Millisecond var detector_factory balancer.FaultDetectorFactory tasks := golib.NewTaskGroup() var heartbeatServer *heartbeat.HeartbeatServer if *useHeartbeat { var err error heartbeatServer, err = heartbeat.NewHeartbeatServer(heartbeat_server) golib.Checkerr(err) go printServerErrors("Heartbeat", heartbeatServer.Server) log.Println("Listening for Heartbeats on", heartbeatServer.LocalAddr()) detector_factory = func(endpoint string) (protocols.FaultDetector, error) { return heartbeatServer.ObserveServer(endpoint, heartbeat_frequency, heartbeat_timeout) } tasks.AddNamed("heartbeat", heartbeatServer) } else { detector_factory = func(endpoint string) (protocols.FaultDetector, error) { detector, err := ping.DialNewFaultDetector(endpoint) if err != nil { return nil, err } detector.Start() return detector, nil } } protocol, err := protocols.NewProtocol("AMP", amp.Protocol, ping.Protocol, heartbeat.Protocol) golib.Checkerr(err) baseServer, err := protocols.NewServer(amp_addr, protocol) golib.Checkerr(err) server, err := amp_balancer.RegisterPluginServer(baseServer) golib.Checkerr(err) tasks.AddNamed("server", server) ampPlugin := amp_balancer.NewAmpBalancingPlugin(detector_factory) server.AddPlugin(ampPlugin) pcpPlugin := amp_balancer.NewPcpBalancingPlugin(detector_factory) server.AddPlugin(pcpPlugin) if *loadBackend { for _, load := range load_servers { err := ampPlugin.AddBackendServer(load, stateChangePrinter) golib.Checkerr(err) } } else { for _, amp := range amp_servers { err := ampPlugin.AddBackendServer(amp, stateChangePrinter) golib.Checkerr(err) } } for _, pcp := range pcp_servers { err := pcpPlugin.AddBackendServer(pcp, stateChangePrinter) golib.Checkerr(err) } go printServerErrors("Server", server.Server) server.SessionStartedCallback = printSessionStarted server.SessionStoppedCallback = printSessionStopped log.Println("Listening to AMP on " + amp_addr) log.Println("Press Ctrl-C to close") if heartbeatServer != nil { tasks.Add(heartbeatServer) } tasks.Add(&golib.NoopTask{golib.ExternalInterrupt(), "external interrupt"}) tasks.WaitAndExit() }