Golang Server.SetKeepAlivesEnabled方法代码示例

func (s *fakeServer) Start(readyErrCh chan error) {
	var err error
	s.Listener, err = net.Listen("tcp", s.endpoint)
	if err != nil {
		readyErrCh <- err
		return
	}

	readyErrCh <- nil

	httpServer := http.Server{}
	httpServer.SetKeepAlivesEnabled(false)
	mux := http.NewServeMux()
	httpServer.Handler = mux

	mux.HandleFunc("/fake-path", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(s.responseStatus)

		requestBody, _ := ioutil.ReadAll(r.Body)
		defer r.Body.Close()

		receivedRequest := receivedRequest{
			Body:   requestBody,
			Method: r.Method,
		}

		s.ReceivedRequests = append(s.ReceivedRequests, receivedRequest)
		w.Write([]byte(s.responseBody))
	})

	httpServer.Serve(s.Listener)
}

func RunFunc() {
	r := render.New()
	mux, store := InitServerMux(r)
	n := negroni.Classic()
	n.Use(negroni.HandlerFunc(CookieMiddleware(store)))
	n.Use(negroni.HandlerFunc(RecoveryErr()))
	timeourHandler := http.TimeoutHandler(context.ClearHandler(mux), time.Duration(3*time.Second), timeoutErrMessage)
	n.UseHandler(timeourHandler)
	//All the middlerware we used
	l := log.New(os.Stdout, "[negroni] ", 0)
	l.Printf("listening on :80")
	server := http.Server{Addr: ":80", Handler: n}
	server.SetKeepAlivesEnabled(true)
	go MainMonitor()
	InitSchoolDB()
	InitCourseMap()
	InitSchoolStructs()
	l.Fatal(server.ListenAndServe())
}

func main() {
	flag.Parse()

	if *target == "" {
		fmt.Fprintf(os.Stderr, "No target URL provided\n")
		flag.Usage()
		return
	}
	// Check that we can build requests using the provided URL
	_, err := url.Parse(*target)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error creating request with '%s': %s\n", *target, err)
		return
	}
	// Check that we can parse the timeout duration
	t, err := time.ParseDuration(*timeout)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error parsing duration '%s': %s\n", *timeout, err)
		return
	}
	// Set timeout for http.DefaultClient
	http.DefaultClient.Timeout = t

	// Add our http handler
	http.HandleFunc("/endpoints", endpointsHandler)
	http.HandleFunc("/namespaces", namespacesHandler)

	// Initialize allocatedAddressDir
	err = os.MkdirAll(allocatedAddressDir, 0700)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error creating '%s': %s\n", allocatedAddressDir, err)
		return
	}

	// Set up server
	server := http.Server{Addr: fmt.Sprintf(":%d", *port)}
	server.SetKeepAlivesEnabled(false)

	// Launch server, report initialization errors.
	errCh := make(chan struct{})
	go func() {
		defer close(errCh)
		ln, err := net.Listen("tcp", server.Addr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error from net.Listen: %s\n", err)
			return
		}
		err = server.Serve(ln)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error from server.Serve: %s\n", err)
			return
		}
	}()

	// Add signal handler for Ctrl-C
	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, os.Interrupt, os.Kill)

	// Block until error or Ctrl-C
	select {
	case <-sigCh:
	case <-errCh:
	}
}

// Implements zero-downtime application reload.
func reload(l net.Listener, httpServer *http.Server) error {
	const errLoc = "main.reload()"

	// Making duplicate for socket descriptor
	// to use them in child process.
	file, err := (l.(*net.TCPListener)).File()
	if err != nil {
		return fmt.Errorf(
			"%s: failed to get file of listener, reason -> %s",
			errLoc, err.Error(),
		)
	}
	fd, err := syscall.Dup(int(file.Fd()))
	file.Close()
	if err != nil {
		return fmt.Errorf(
			"%s: failed to dup(2) listener, reason -> %s", errLoc, err.Error(),
		)
	}
	if err := os.Setenv(envVarName, fmt.Sprint(fd)); err != nil {
		return fmt.Errorf(
			"%s: failed to write fd into environment variable, reason -> %s",
			errLoc, err.Error(),
		)
	}

	// Unlock PID file to start normally child process.
	daemon.UnlockPidFile()

	// Start child process.
	cmd := exec.Command(daemon.AppPath)
	if err := cmd.Start(); err != nil {
		return fmt.Errorf(
			"%s: failed to start child process, reason -> %s",
			errLoc, err.Error(),
		)
	}

	select {
	// Waiting for notification from child process that it starts successfully.
	// In real application it's better to move generation of chan for this case
	// before calling cmd.Start() to be sure to catch signal in any case.
	case <-func() <-chan os.Signal {
		sig := make(chan os.Signal)
		signal.Notify(sig, syscall.SIGUSR1)
		return sig
	}():
	// If child process stopped without sending signal.
	case <-func() chan struct{} {
		ch := make(chan struct{}, 1)
		go func() {
			cmd.Wait()
			ch <- struct{}{}
		}()
		return ch
	}():
		err = fmt.Errorf("%s: child process stopped unexpectably", errLoc)
	// Timeout for waiting signal from child process.
	case <-time.After(10 * time.Second):
		err = fmt.Errorf(
			"%s: child process is not responding, closing by timeout", errLoc,
		)
	}

	// Dealing with keep-alive connections.
	httpServer.SetKeepAlivesEnabled(false)
	time.Sleep(100 * time.Millisecond)

	// Close current listener (stop server in fact).
	l.Close()
	return err
}

// Daemon starts the volplugin service.
func (dc *DaemonConfig) Daemon() error {
	global, err := dc.Client.GetGlobal()
	if err != nil {
		logrus.Errorf("Error fetching global configuration: %v", err)
		logrus.Infof("No global configuration. Proceeding with defaults...")
		global = config.NewGlobalConfig()
	}

	dc.Global = global
	errored.AlwaysDebug = dc.Global.Debug
	errored.AlwaysTrace = dc.Global.Debug
	if dc.Global.Debug {
		logrus.SetLevel(logrus.DebugLevel)
	}

	go info.HandleDebugSignal()

	activity := make(chan *watch.Watch)
	dc.Client.WatchGlobal(activity)
	go func() {
		for {
			dc.Global = (<-activity).Config.(*config.Global)

			logrus.Debugf("Received global %#v", dc.Global)

			errored.AlwaysDebug = dc.Global.Debug
			errored.AlwaysTrace = dc.Global.Debug
			if dc.Global.Debug {
				logrus.SetLevel(logrus.DebugLevel)
			}
		}
	}()

	dc.API = api.NewAPI(docker.NewVolplugin(), dc.Hostname, dc.Client, &dc.Global)

	if err := dc.updateMounts(); err != nil {
		return err
	}

	go dc.pollRuntime()

	driverPath := path.Join(basePath, fmt.Sprintf("%s.sock", dc.PluginName))
	if err := os.Remove(driverPath); err != nil && !os.IsNotExist(err) {
		return err
	}
	if err := os.MkdirAll(basePath, 0700); err != nil {
		return err
	}

	l, err := net.ListenUnix("unix", &net.UnixAddr{Name: driverPath, Net: "unix"})
	if err != nil {
		return err
	}

	srv := http.Server{Handler: dc.API.Router(dc.API)}
	srv.SetKeepAlivesEnabled(false)
	if err := srv.Serve(l); err != nil {
		logrus.Fatalf("Fatal error serving volplugin: %v", err)
	}
	l.Close()
	return os.Remove(driverPath)
}