golang http graceful shutdown

Comment

0

package main

import (
	"context"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func createChannel() (chan os.Signal, func()) {
	stopCh := make(chan os.Signal, 1)
	signal.Notify(stopCh, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)

	return stopCh, func() {
		close(stopCh)
	}
}

func start(server *http.Server) {
	log.Println("application started")
	if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
		panic(err)
	} else {
		log.Println("application stopped gracefully")
	}
}

func shutdown(ctx context.Context, server *http.Server) {
	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()

	if err := server.Shutdown(ctx); err != nil {
		panic(err)
	} else {
		log.Println("application shutdowned")
	}
}

func main() {
	log.SetFlags(log.Lshortfile)
	s := &http.Server{}
	go start(s)

	stopCh, closeCh := createChannel()
	defer closeCh()
	log.Println("notified:", <-stopCh)

	shutdown(context.Background(), s)
}

Popularity 7/10 Helpfulness 2/10 Language go

Source: Grepper

Tags: go graceful-shutdown http

Share

Link to this answer
Share Copy Link

Contributed on Apr 15 2022

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang http graceful shutdown

Comment

1

func main() {
	srv := &http.Server{
		Addr:    ":8080",
		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			time.Sleep(5 * time.Second)
			_, _ = w.Write([]byte("hello"))
		}),
	}

	if err := gracefulShutdown(srv, 10*time.Second); err != nil {
		log.Println(err)
	}
}

// gracefulShutdown stops the given HTTP server on
// receiving a stop signal and waits for the active connections
// to be closed for {timeout} period of time.
func gracefulShutdown(srv *http.Server, timeout time.Duration) error {
	done := make(chan error, 1)
	go func() {
		c := make(chan os.Signal, 1)
		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
		<-c

		ctx := context.Background()
		var cancel context.CancelFunc
		if timeout > 0 {
			ctx, cancel = context.WithTimeout(ctx, timeout)
			defer cancel()
		}

		done <- srv.Shutdown(ctx)
	}()

	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		return err
	}

	return <-done
}

Popularity 8/10 Helpfulness 5/10 Language go

Source: Grepper

Tags: go graceful-shutdown gracefu

Share

Link to this answer
Share Copy Link

Contributed on Apr 15 2022

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang example graceful shutdown

Comment

1

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"time"
)

const (
	service = "fooapi"
)

var (
	port            = flag.Int("port", 3333, "http port to listen on")
	shutdownTimeout = flag.Duration("shutdown-timeout", 10*time.Second,
		"shutdown timeout (5s,5m,5h) before connections are cancelled")
)

func main() {
	flag.Parse()

	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	})

	srv := &http.Server{
		Addr:    fmt.Sprintf(":%d", *port),
		Handler: mux,
	}

	stop := make(chan os.Signal)
	signal.Notify(stop, os.Interrupt)

	go func() {
		log.Printf("%s listening on 0.0.0.0:%d with %v timeout", service, *port, *shutdownTimeout)
		if err := srv.ListenAndServe(); err != nil {
			if err != http.ErrServerClosed {
				log.Fatal(err)
			}
		}
	}()

	<-stop

	log.Printf("%s shutting down ...\n", service)

	ctx, cancel := context.WithTimeout(context.Background(), *shutdownTimeout)
	defer cancel()

	if err := srv.Shutdown(ctx); err != nil {
		log.Fatal(err)
	}

	log.Printf("%s down\n", service)
}

Popularity 9/10 Helpfulness 5/10 Language go

Source: Grepper

Tags: go graceful-shutdown grac

Share

Link to this answer
Share Copy Link

Contributed on Apr 15 2022

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang example graceful shutdown

Comment

0

package main

import (
    "context"
    "errors"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func createChannel() (chan os.Signal, func()) {
    stopCh := make(chan os.Signal, 1)
    signal.Notify(stopCh, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)

    return stopCh, func() {
        close(stopCh)
    }
}

func start(server *http.Server) {
    log.Println("application started")
    if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
        panic(err)
    } else {
        log.Println("application stopped gracefully")
    }
}

func shutdown(ctx context.Context, server *http.Server) {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    if err := server.Shutdown(ctx); err != nil {
        panic(err)
    } else {
        log.Println("application shutdowned")
    }
}

func main() {
    log.SetFlags(log.Lshortfile)
    s := &http.Server{}
    go start(s)

    stopCh, closeCh := createChannel()
    defer closeCh()
    log.Println("notified:", <-stopCh)

    shutdown(context.Background(), s)
}

Popularity 7/10 Helpfulness 1/10 Language go

Source: dev.to

Tags: go graceful-shutdown graceful-shutdow

Share

Link to this answer
Share Copy Link

Contributed on Apr 15 2022

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang gracefull shutdown

Comment

0

func SetupGraceFullShutdown(handler *http.ServeMux) {
var wg sync.WaitGroup
	httpServer := http.Server{
		Addr:           fmt.Sprintf(":%s", port),
		ReadTimeout:    time.Duration(time.Second) * 60,
		WriteTimeout:   time.Duration(time.Second) * 30,
		IdleTimeout:    time.Duration(time.Second) * 15,
		MaxHeaderBytes: http.DefaultMaxHeaderBytes,
		Handler:        handler,
	}

	runtime.GOMAXPROCS(runtime.NumCPU())
	wg.Add(1)
	go func() {
		if err := httpServer.ListenAndServe(); errors.Is(err, http.ErrServerClosed) {
			log.Printf("Server not runnings: %s", err.Error())
		}
		log.Printf("Server running on port: %s", port)

		stop := make(chan os.Signal, 1)
		signal.Notify(stop, os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

		if sig, ok := <-stop; ok {
			log.Printf("Signal received: %v \n", sig)

			ctx, cancel := context.WithTimeout(context.Background(), time.Duration(time.Second*10))
			defer cancel()

			if _, ok := <-ctx.Done(); !ok {
				log.Println("Waiting to HTTP server shutdown...")

				if err := db.Close(); err != nil {
					log.Printf("Database shutdown error: %s", err.Error())
				}

				if err := httpServer.Shutdown(ctx); err != nil {
					log.Printf("HTTP server shutdown error: %s", err.Error())
				}

				defer close(stop)
				log.Println("HTTP server shutdown success")
			}
		}

		wg.Done()
	}()
	wg.Wait()
}

Popularity 6/10 Helpfulness 1/10 Language go

Source: Grepper

Tags: go shutdown

Share

Link to this answer
Share Copy Link

Contributed on Dec 19 2022

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang grpc graceful shutdown

Comment

0

package helpers

import (
	"context"
	"fmt"
	"net"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/sirupsen/logrus"
	"google.golang.org/grpc"
)

const (
	TCP        = "tcp"
	UDPConn    = "udp"
	UNIXConn   = "unix"
	UNIXPACKET = "unixpacket"
)

type GracefulOptions struct {
	Ctx     context.Context
	Server  *grpc.Server
	Address string
	Port    string
}

func Graceful(options *GracefulOptions) {
	var (
		nlc        net.ListenConfig = net.ListenConfig{}
		signalChan chan os.Signal   = make(chan os.Signal, 1)
	)

	ctx, cancel := context.WithTimeout(options.Ctx, time.Duration(time.Second*120))
	defer cancel()

	signal.Notify(signalChan, syscall.SIGTERM, syscall.SIGABRT, syscall.SIGKILL, syscall.SIGINT, syscall.SIGALRM)

	go func() {
		sig := <-signalChan
		logrus.Infof("Signal received %s", sig.String())
		os.Exit(0)

	}()

	nls, err := nlc.Listen(ctx, "tcp", fmt.Sprintf("%s:%s", options.Address, options.Port))
	if err != nil {
		logrus.Fatal(err)
		return
	}

	logrus.Print("\n")
	logrus.Infof("Server listening on port %s", options.Port)

	if err := options.Server.Serve(nls); err != nil && err != http.ErrServerClosed {
		logrus.Fatal(err)
		return
	}
}

Popularity 3/10 Helpfulness 1/10 Language go

Source: Grepper

Tags: go graceful-shutdown grpc

Share

Link to this answer
Share Copy Link

Contributed on Jun 09 2024

Restu Wahyu Saputra

0 Answers Avg Quality 2/10

golang http graceful shutdown

Contents

More Related Answers

golang http graceful shutdown

Closely Related Answers

golang http graceful shutdown

golang example graceful shutdown

golang example graceful shutdown

golang gracefull shutdown

golang grpc graceful shutdown

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.