func (s *Server) listenAndServeScgi(addr string) error {
var l net.Listener
var err error
//if the path begins with a "/", assume it's a unix address
if strings.HasPrefix(addr, "/") {
l, err = net.Listen("unix", addr)
} else {
l, err = net.Listen("tcp", addr)
}
//save the listener so it can be closed
s.l = l
if err != nil {
s.Logger.Println("SCGI listen error", err.Error())
return err
}
for {
fd, err := l.Accept()
if err != nil {
s.Logger.Println("SCGI accept error", err.Error())
return err
}
go s.handleScgiRequest(fd)
}
return nil
}
func (this *TcpServer) doAcceptTcpClients(hServer net.Listener) {
for {
conn, err := hServer.Accept()
if this.beNotifiedToShutDown {
break
}
this.initClientWithConnection(conn)
if err != nil {
//回调accept失败
if nil != this.delegate {
_, implemented := this.delegate.(ITcpServerDelegate)
if implemented {
this.delegate.TcpServerAcceptClientError(this.getClientInfoMapClient(conn), err.Error())
break
}
}
} else {
handlerThread := this.createHandlerThread(conn)
this.addHandlerThreadToQueue(handlerThread)
this.setClientInfoMapConnectionThread(conn, handlerThread)
if nil != this.delegate {
_, implemented := this.delegate.(ITcpServerDelegate)
if implemented {
this.delegate.TcpServerClientConnected(this.getClientInfoMapClient(conn))
}
}
}
}
}
// Test state transitions from new->active->-idle->closed using an actual
// network connection and make sure the waitgroup count is correct at the end.
func TestStateTransitionActiveIdleClosed(t *testing.T) {
var (
listener net.Listener
exitchan chan error
)
keyFile, err1 := helpers.NewTempFile(helpers.Key)
certFile, err2 := helpers.NewTempFile(helpers.Cert)
defer keyFile.Unlink()
defer certFile.Unlink()
if err1 != nil || err2 != nil {
t.Fatal("Failed to create temporary files", err1, err2)
}
for _, withTLS := range []bool{false, true} {
server := NewServer()
wg := helpers.NewWaitGroup()
statechanged := make(chan http.ConnState)
server.wg = wg
if withTLS {
listener, exitchan = startTLSServer(t, server, certFile.Name(), keyFile.Name(), statechanged)
} else {
listener, exitchan = startServer(t, server, statechanged)
}
client := newClient(listener.Addr(), withTLS)
client.Run()
// wait for client to connect, but don't let it send the request
if err := <-client.connected; err != nil {
t.Fatal("Client failed to connect to server", err)
}
client.sendrequest <- true
waitForState(t, statechanged, http.StateActive, "Client failed to reach active state")
rr := <-client.response
if rr.err != nil {
t.Fatalf("tls=%t unexpected error from client %s", withTLS, rr.err)
}
waitForState(t, statechanged, http.StateIdle, "Client failed to reach idle state")
// client is now in an idle state
close(client.sendrequest)
<-client.closed
waitForState(t, statechanged, http.StateClosed, "Client failed to reach closed state")
server.Close()
waiting := <-wg.WaitCalled
if waiting != 0 {
t.Errorf("Waitcount should be zero, got %d", waiting)
}
if err := <-exitchan; err != nil {
t.Error("Unexpected error during shutdown", err)
}
}
}
func (srv *Server) Serve(l net.Listener) error {
defer l.Close()
var tempDelay time.Duration
for {
rw, e := l.Accept()
if e != nil {
if ne, ok := e.(net.Error); ok && ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
srv.logf("smtp: Accept error: %v; retrying in %v", e, tempDelay)
time.Sleep(tempDelay)
continue
}
return e
}
tempDelay = 0
c, err := srv.newConn(rw)
if err != nil {
continue
}
go c.serve()
}
}
func (c *controller) acceptClientConnections(sock string, l net.Listener) {
for {
conn, err := l.Accept()
if err != nil {
if _, err1 := os.Stat(sock); os.IsNotExist(err1) {
logrus.Debugf("Unix socket %s doesn't exist. cannot accept client connections", sock)
return
}
logrus.Errorf("Error accepting connection %v", err)
continue
}
go func() {
defer conn.Close()
err := c.processExternalKey(conn)
ret := success
if err != nil {
ret = err.Error()
}
_, err = conn.Write([]byte(ret))
if err != nil {
logrus.Errorf("Error returning to the client %v", err)
}
}()
}
}
func runBackendInstance(ln net.Listener, handler connHandler) {
var tempDelay time.Duration // how long to sleep on accept failure
for {
conn, err := ln.Accept()
if err != nil {
if ne, ok := err.(net.Error); ok && ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
fmt.Printf("http: Accept error: %v; retrying in %v\n", err, tempDelay)
time.Sleep(tempDelay)
continue
}
break
}
go func() {
defer GinkgoRecover()
handler(test_util.NewHttpConn(conn))
}()
}
}
// ListenAndServe listens on l, accepts network connections, and
// handles requests according to the doozer protocol.
func ListenAndServe(l net.Listener, canWrite chan bool, st *store.Store, p consensus.Proposer, rwsk, rosk string, self string) {
var w bool
for {
c, err := l.Accept()
if err != nil {
if err == syscall.EINVAL {
break
}
if e, ok := err.(*net.OpError); ok && !e.Temporary() {
break
}
log.Println(err)
continue
}
// has this server become writable?
select {
case w = <-canWrite:
canWrite = nil
default:
}
go serve(c, st, p, w, rwsk, rosk, self)
}
}
func serve(listener net.Listener) {
certificate, err := tls.LoadX509KeyPair("server.crt", "server.key")
if err != nil {
panic(err)
}
for {
c, err := listener.Accept()
if err != nil {
log.Printf("accept: %s", err)
}
tlsConn := tls.Server(c, &tls.Config{
Certificates: []tls.Certificate{certificate},
})
if err := tlsConn.Handshake(); err != nil {
log.Printf("tls: %s", err)
}
go func() {
io.Copy(os.Stdout, tlsConn)
c.Close()
}()
go func() {
io.Copy(tlsConn, os.Stdin)
c.Close()
}()
}
}
// serve connections on this listener until it is closed.
func (s *Server) serve(ln net.Listener) {
for {
conn, err := ln.Accept()
if err != nil {
if !s.isClosing() {
log.Error(err)
}
return
}
s.mu.Lock()
s.conns[conn] = struct{}{}
s.mu.Unlock()
go func() {
defer func() {
s.mu.Lock()
delete(s.conns, conn)
s.mu.Unlock()
conn.Close()
}()
if err := s.serveConn(conn); err != nil {
if err != io.EOF && !s.isClosing() {
log.Error(err)
}
}
}()
}
}
func httpServer(listener net.Listener) {
var err error
templates, err = template.ParseGlob(fmt.Sprintf("%s/*.html", *templateDir))
if err != nil {
log.Printf("ERROR: %s", err.Error())
}
log.Printf("HTTP: listening on %s", listener.Addr().String())
handler := http.NewServeMux()
handler.HandleFunc("/ping", pingHandler)
handler.HandleFunc("/", indexHandler)
handler.HandleFunc("/nodes", nodesHandler)
handler.HandleFunc("/topic/", topicHandler)
handler.HandleFunc("/delete_topic", deleteTopicHandler)
handler.HandleFunc("/delete_channel", deleteChannelHandler)
handler.HandleFunc("/empty_channel", emptyChannelHandler)
server := &http.Server{
Handler: handler,
}
err = server.Serve(listener)
// theres no direct way to detect this error because it is not exposed
if err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
log.Printf("ERROR: http.Serve() - %s", err.Error())
}
log.Printf("HTTP: closing %s", listener.Addr().String())
}
func transponder(t *testing.T, ln net.Listener, done chan<- int) {
defer func() { done <- 1 }()
c, err := ln.Accept()
if err != nil {
t.Errorf("net.Listener.Accept failed: %v", err)
return
}
c.LocalAddr()
c.RemoteAddr()
c.SetDeadline(time.Now().Add(100 * time.Millisecond))
c.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
c.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
defer c.Close()
b := make([]byte, 128)
n, err := c.Read(b)
if err != nil {
t.Errorf("net.Conn.Read failed: %v", err)
return
}
if _, err := c.Write(b[:n]); err != nil {
t.Errorf("net.Conn.Write failed: %v", err)
return
}
}
func (cl *Client) acceptConnections(l net.Listener, utp bool) {
for {
cl.waitAccept()
conn, err := l.Accept()
conn = pproffd.WrapNetConn(conn)
if cl.closed.IsSet() {
if conn != nil {
conn.Close()
}
return
}
if err != nil {
log.Print(err)
// I think something harsher should happen here? Our accept
// routine just f****d off.
return
}
if utp {
acceptUTP.Add(1)
} else {
acceptTCP.Add(1)
}
cl.mu.RLock()
reject := cl.badPeerIPPort(
missinggo.AddrIP(conn.RemoteAddr()),
missinggo.AddrPort(conn.RemoteAddr()))
cl.mu.RUnlock()
if reject {
acceptReject.Add(1)
conn.Close()
continue
}
go cl.incomingConnection(conn, utp)
}
}
func (proc *requestProcessor) Listen(l net.Listener) {
config := newConfig(proc.server)
timeout := time.Duration(0) // how long to sleep on accept failure
for {
rw, err := l.Accept()
if err != nil {
if netErr, ok := err.(net.Error); ok && netErr.Temporary() {
if timeout == 0 {
timeout = 5 * time.Millisecond
} else {
timeout *= 2
}
if max := 5 * time.Second; timeout > max {
timeout = max
}
log.Printf("stomp: Accept error: %v; retrying in %v", err, timeout)
time.Sleep(timeout)
continue
}
return
}
timeout = 0
// TODO: need to pass Server to connection so it has access to
// configuration parameters.
_ = client.NewConn(config, rw, proc.ch)
}
// This is no longer required for go 1.1
panic("not reached")
}
// server accepts incoming connections
func (s *ServerState) Serve(ln net.Listener) {
// Start sending worker updates at 1Hz
go s.sendWorkState(1)
// Start up our auto discover server
var a *discoveryServer
addr := ln.Addr()
if taddr, ok := addr.(*net.TCPAddr); ok {
var err error
a, err = newDiscoveryServer(taddr.Port)
if err != nil {
log.Print("Error starting auto-discovery", err)
return
}
defer a.stop()
}
// Incoming connections
for {
DebugPrint("Server accepting...")
conn, err := ln.Accept()
if err != nil {
log.Print(err)
continue
}
// Turn into a message conn
mc := NewMessageConn(conn, time.Duration(10)*time.Second)
// Spin off thread to handle the new connection
go s.handleConnection(mc)
}
}
func serveSingleCopy(name string, l net.Listener, dst io.Writer, src io.Reader) {
defer l.Close()
conn, err := l.Accept()
if err != nil {
log.Printf("'%s' accept error: %s", name, err)
return
}
// Be sure to close the connection after we're done copying so
// that an EOF will successfully be sent to the remote side
defer conn.Close()
// The connection is the destination/source that is nil
if dst == nil {
dst = conn
} else {
src = conn
}
written, err := io.Copy(dst, src)
log.Printf("%d bytes written for '%s'", written, name)
if err != nil {
log.Printf("'%s' copy error: %s", name, err)
}
}
func AcceptConns(listener net.Listener, socketChan chan net.Conn, errChan chan error) {
defer close(socketChan)
defer close(errChan)
var acceptDelay time.Duration
maxDelay := 1 * time.Second
for ok := true; ok; {
socket, err := listener.Accept()
if err == nil {
acceptDelay = 0
socketChan <- socket
continue
}
if netErr, ok := err.(net.Error); ok && netErr.Temporary() {
// Sleep on `Accept()` failures. Taken from `net/http/server.go`,
// Copyright 2009, The Go Authors.
if acceptDelay == 0 {
acceptDelay = 5 * time.Millisecond
} else {
acceptDelay *= 2
}
if acceptDelay > maxDelay {
acceptDelay = maxDelay
}
time.Sleep(acceptDelay)
continue
}
ok = false
errChan <- err
}
}
// Serve accepts incoming connections on the Listener l, creating a
// new service thread for each. The service threads read requests and
// then call srv.Handler to reply to them.
func (srv *Server) Serve(l net.Listener) error {
defer l.Close()
handler := srv.Handler
if handler == nil {
handler = DefaultServeMux
}
for {
rw, e := l.Accept()
if e != nil {
if ne, ok := e.(net.Error); ok && ne.Temporary() {
log.Printf("icap: Accept error: %v", e)
continue
}
return e
}
if srv.ReadTimeout != 0 {
rw.SetReadDeadline(time.Now().Add(srv.ReadTimeout))
}
if srv.WriteTimeout != 0 {
rw.SetWriteDeadline(time.Now().Add(srv.WriteTimeout))
}
c, err := newConn(rw, handler)
if err != nil {
continue
}
go c.serve()
}
panic("not reached")
}
func GoServe(t *testing.T, tr smux.Transport, l net.Listener) (done func()) {
closed := make(chan struct{}, 1)
go func() {
for {
c1, err := l.Accept()
if err != nil {
select {
case <-closed:
return // closed naturally.
default:
checkErr(t, err)
}
}
log("accepted connection")
sc1, err := tr.NewConn(c1, true)
checkErr(t, err)
go sc1.Serve(echoStream)
}
}()
return func() {
closed <- struct{}{}
}
}
func RunServer(cfg Config) {
memoryStore := NewStore()
var ln net.Listener
var err error
if cfg.TLSEnabled() {
ln, err = tls.Listen("tcp", ":"+cfg.Port, cfg.TLSConfig())
} else {
ln, err = net.Listen("tcp", ":"+cfg.Port)
}
if err != nil {
log.Println("Failed to start server:", err.Error())
}
for {
conn, err := ln.Accept()
if err != nil {
log.Println("Client failed to open new connection:", err.Error())
}
id, err := newUUID()
if err != nil {
log.Println("Failed to create unique ID for new client")
conn.Close()
continue
}
log.Printf("New connection opened clientId=%s", id)
c := NewClient(id, conn, memoryStore)
go c.Handle()
}
}
func (srv *Server) Serve(l net.Listener) error {
l = WrapListener(l)
// Spawn a shadow http.Server to do the actual servering. We do this
// because we need to sketch on some of the parameters you passed in,
// and it's nice to keep our sketching to ourselves.
shadow := *(*http.Server)(srv)
if shadow.ReadTimeout == 0 {
shadow.ReadTimeout = forever
}
go func() {
<-kill
shadow.SetKeepAlivesEnabled(false)
l.Close()
}()
err := shadow.Serve(l)
// We expect an error when we close the listener, so we indiscriminately
// swallow Serve errors when we're in a shutdown state.
select {
case <-kill:
return nil
default:
return err
}
}
func (s *RaftServer) Serve(l net.Listener) error {
s.port = l.Addr().(*net.TCPAddr).Port
s.listener = l
log.Info("Initializing Raft HTTP server")
// Initialize and start HTTP server.
s.httpServer = &http.Server{
Handler: s.router,
}
s.router.HandleFunc("/cluster_config", s.configHandler).Methods("GET")
s.router.HandleFunc("/join", s.joinHandler).Methods("POST")
s.router.HandleFunc("/process_command/{command_type}", s.processCommandHandler).Methods("POST")
log.Info("Raft Server Listening at %s", s.connectionString())
go func() {
err := s.httpServer.Serve(l)
if !strings.Contains(err.Error(), "closed network") {
panic(err)
}
}()
started := make(chan error)
go func() {
started <- s.startRaft()
}()
err := <-started
// time.Sleep(3 * time.Second)
return err
}
func (srv *Server) handleInterrupt(interrupt chan os.Signal, quitting chan struct{}, listener net.Listener) {
for _ = range interrupt {
if srv.Interrupted {
srv.logf("already shutting down")
continue
}
srv.logf("shutdown initiated")
srv.Interrupted = true
if srv.BeforeShutdown != nil {
if !srv.BeforeShutdown() {
srv.Interrupted = false
continue
}
}
close(quitting)
srv.SetKeepAlivesEnabled(false)
if err := listener.Close(); err != nil {
srv.logf("[ERROR] %s", err)
}
if srv.ShutdownInitiated != nil {
srv.ShutdownInitiated()
}
}
}
func httpServer(listener net.Listener) {
log.Printf("HTTP: listening on %s", listener.Addr().String())
handler := http.NewServeMux()
handler.HandleFunc("/info", infoHandler)
handler.HandleFunc("/ping", pingHandler)
handler.HandleFunc("/lookup", lookupHandler)
handler.HandleFunc("/topics", topicsHandler)
handler.HandleFunc("/channels", channelsHandler)
handler.HandleFunc("/nodes", nodesHandler)
handler.HandleFunc("/delete_topic", deleteTopicHandler)
handler.HandleFunc("/delete_channel", deleteChannelHandler)
handler.HandleFunc("/tombstone_topic_producer", tombstoneTopicProducerHandler)
handler.HandleFunc("/create_topic", createTopicHandler)
handler.HandleFunc("/create_channel", createChannelHandler)
handler.HandleFunc("/debug", debugHandler)
server := &http.Server{
Handler: handler,
}
err := server.Serve(listener)
// theres no direct way to detect this error because it is not exposed
if err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
log.Printf("ERROR: http.Serve() - %s", err.Error())
}
log.Printf("HTTP: closing %s", listener.Addr().String())
}
func asyncAcceptTCP(serverfd net.Listener, timeout time.Duration) (net.Conn, error) {
t := time.NewTimer(timeout)
defer t.Stop()
if asynctcpconn == nil {
asynctcpconn = make(chan tcpconn, 1)
go func() {
connfd, err := serverfd.Accept()
if err != nil {
asynctcpconn <- tcpconn{err, nil}
} else {
asynctcpconn <- tcpconn{nil, connfd}
}
}()
}
select {
case p := <-asynctcpconn:
asynctcpconn = nil
return p.fd, p.err
case <-t.C:
return nil, ErrTimeout
}
panic("Oops, unreachable")
}
func httpServer(listener net.Listener) {
log.Printf("HTTP: listening on %s", listener.Addr().String())
handler := http.NewServeMux()
handler.HandleFunc("/ping", pingHandler)
handler.HandleFunc("/info", infoHandler)
handler.HandleFunc("/put", putHandler)
handler.HandleFunc("/mput", mputHandler)
handler.HandleFunc("/stats", statsHandler)
handler.HandleFunc("/delete_topic", deleteTopicHandler)
handler.HandleFunc("/empty_channel", emptyChannelHandler)
handler.HandleFunc("/delete_channel", deleteChannelHandler)
handler.HandleFunc("/mem_profile", memProfileHandler)
handler.HandleFunc("/cpu_profile", httpprof.Profile)
handler.HandleFunc("/dump_inflight", dumpInFlightHandler)
// these timeouts are absolute per server connection NOT per request
// this means that a single persistent connection will only last N seconds
server := &http.Server{
Handler: handler,
}
err := server.Serve(listener)
// theres no direct way to detect this error because it is not exposed
if err != nil && !strings.Contains(err.Error(), "use of closed network connection") {
log.Printf("ERROR: http.Serve() - %s", err.Error())
}
log.Printf("HTTP: closing %s", listener.Addr().String())
}
func (s *server) Run(ready chan struct{}, externalListener chan error) (err error) {
var listener net.Listener
o := SimpleLogOutput{}
lf := NewSimpleLogFactory(o, nil)
o.Info(fmt.Sprintf("Listening on port %d...", s.port))
if listener, err = net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", s.port)); err != nil {
return
}
closeListener := make(chan error)
go func() {
<-closeListener
listener.Close()
}()
close(ready)
for {
var c net.Conn
if c, err = listener.Accept(); err != nil {
externalListener <- io.EOF
return
}
xp := NewTransport(c, lf, nil)
srv := NewServer(xp, nil)
srv.Register(createTestProtocol(newTestProtocol(c)))
srv.AddCloseListener(closeListener)
srv.Run(true)
}
return nil
}
func (srv *Server) Serve(l net.Listener) error {
defer l.Close()
var tempDelay time.Duration // how long to sleep on accept failure
for {
rw, e := l.Accept()
if e != nil {
if ne, ok := e.(net.Error); ok && ne.Temporary() {
if tempDelay == 0 {
tempDelay = 5 * time.Millisecond
} else {
tempDelay *= 2
}
if max := 1 * time.Second; tempDelay > max {
tempDelay = max
}
// srv.logf("http: Accept error: %v; retrying in %v", e, tempDelay)
time.Sleep(tempDelay)
continue
}
return e
}
tempDelay = 0
c, err := srv.newConn(rw)
if err != nil {
continue
}
// c.setState(c.rwc, StateNew) // before Serve can return
go c.serve()
}
}
func (mockLive *MockLivestatus) StartMockLivestatus() {
var listener net.Listener
var err error
switch mockLive.ConnectionType {
case "tcp":
listener, err = net.Listen("tcp", mockLive.LivestatusAddress)
case "file":
listener, err = net.Listen("unix", mockLive.LivestatusAddress)
default:
log.Panic("ConnectionType undefined")
return
}
if err != nil {
log.Panic(err)
}
isRunning := true
for isRunning {
conn, err := listener.Accept()
if err != nil {
//log.Println(err)
continue
}
go mockLive.handle(conn)
mutex.Lock()
isRunning = mockLive.isRunning
mutex.Unlock()
}
}
// Serve accepts incoming connections on the listener lis, creating a new
// ServerTransport and service goroutine for each. The service goroutines
// read gRPC requests and then call the registered handlers to reply to them.
// Service returns when lis.Accept fails.
func (s *Server) Serve(lis net.Listener) error {
s.mu.Lock()
s.printf("serving")
if s.lis == nil {
s.mu.Unlock()
return ErrServerStopped
}
s.lis[lis] = true
s.mu.Unlock()
defer func() {
lis.Close()
s.mu.Lock()
delete(s.lis, lis)
s.mu.Unlock()
}()
for {
rawConn, err := lis.Accept()
if err != nil {
s.mu.Lock()
s.printf("done serving; Accept = %v", err)
s.mu.Unlock()
return err
}
// Start a new goroutine to deal with rawConn
// so we don't stall this Accept loop goroutine.
go s.handleRawConn(rawConn)
}
}
// ListenAndServe services SPDY requests using the given listener.
// If the handler is nil, then http.DefaultServeMux is used.
func (srv *Server) Serve(l net.Listener) error {
defer l.Close()
handler := srv.Handler
if handler == nil {
handler = http.DefaultServeMux
}
for {
fmt.Println("Spdy waiting for connections...")
conn, err := l.Accept()
fmt.Println("...Spdy accepted connection... %v->%v", conn.RemoteAddr(), conn.LocalAddr())
if err != nil {
return err
}
go func(c net.Conn) {
// Echo all incoming data.
fmt.Println("echoing data...")
bb := new(bytes.Buffer)
io.Copy(bb, c)
// Shut down the connection.
fmt.Println("spdyrequest: %s", bb.String())
fmt.Println("closing conn...")
c.Close()
}(conn)
// s, err := newSession(c, handler)
// if err != nil {
// return err
// }
// go s.serve()
}
/*
*/
return nil
}