Is it possible to wrap http.ServeHttp in go to add sessions using alexedwards/scs/v2

I am trying to add sessions to an existing http server written in go. I have code like the following

type HttpServer struct {
	getRoutes  map[string]http.HandlerFunc // pattern => handler
	postRoutes map[string]http.HandlerFunc
	server     http.Server
}
func (s *HttpServer) Run() {
	address := "127.0.0.1:8080"
	s.server = http.Server{
		Addr:           address,
		Handler:        s,
		ReadTimeout:    10 * time.Second,
		WriteTimeout:   10 * time.Second,
		MaxHeaderBytes: 1 << 20,
	}
	log.Fatal(s.server.ListenAndServe())
}
func (s *HttpServer) ServeHTTP(writer http.ResponseWriter, r *http.Request) {
     ...
}

I would like to add sessions using
https://pkg.go.dev/github.com/alexedwards/scs/v2#SessionManager.LoadAndSave

The example code in the link is

	mux := http.NewServeMux()
	mux.HandleFunc("/put", putHandler)
	mux.HandleFunc("/get", getHandler)

	// Wrap your handlers with the LoadAndSave() middleware.
	http.ListenAndServe(":4000", sessionManager.LoadAndSave(mux))

The example code passes mux into LoadAndSave, then passes the new handler into http.ListenAndServe(port, newHandler). In my case the handler comes from a ServeHttp method I added to the *HttpServer struct. The handler in the example case comes from the mux.

I am new to go. Is it possible to pass my ServeHTTP method into LoadAndSave and use the handler returned from LoadAndSave? If not, is there a way to pass the http.Server struct fields used in my example into http.ListenAndServe(Port, handler)?

Yes. *HttpServer implements the http.Handler interface so you can pass it to LoadAndSave:

func (s *HttpServer) Run() {
    address := "127.0.0.1:8080"
    s.server = http.Server{
        Addr:           address,
        Handler:        sessionManager.LoadAndSave(s),
        ReadTimeout:    10 * time.Second,
        WriteTimeout:   10 * time.Second,
        MaxHeaderBytes: 1 << 20,
    }
    log.Fatal(s.server.ListenAndServe())
}

As noted in Peter's answer, the LoadAndSave() method from alexedwards/scs/v2 expects an http.Handler interface as an argument.
Since your HttpServer type has a ServeHTTP method with the correct signature, it satisfies the http.Handler interface, and you can pass an instance of your HttpServer type to the LoadAndSave method.

But your Run() method should have a sessionManager *scs.SessionManager as parameter:

func (s *HttpServer) Run(sessionManager *scs.SessionManager) {
    address := "127.0.0.1:8080"
    
    // Wrap your HttpServer with the LoadAndSave middleware.
    handlerWithSessions := sessionManager.LoadAndSave(s)
    
    ...
}

That means creating and configuring the SessionManager outside this method (with scs.New()), and passing it in when you call Run.
There, you can set sessionManager as a field in the HttpServer struct.
That will allow your (s *HttpServer) ServeHTTP(writer http.ResponseWriter, r *http.Request) to retrieve it.

For instance:

package main

import (
    "github.com/alexedwards/scs/v2"
    "log"
    "net/http"
    "time"
)

type HttpServer struct {
    getRoutes     map[string]http.HandlerFunc // pattern => handler
    postRoutes    map[string]http.HandlerFunc
    server        http.Server
    sessionManager *scs.SessionManager
}

func (s *HttpServer) Run(sessionManager *scs.SessionManager) {
    address := "127.0.0.1:8080"
    
    // Set the sessionManager field
    s.sessionManager = sessionManager
    
    // Wrap your HttpServer with the LoadAndSave middleware.
    handlerWithSessions := sessionManager.LoadAndSave(s)
    
    s.server = http.Server{
        Addr:           address,
        Handler:        handlerWithSessions, // Use the wrapped handler
        ReadTimeout:    10 * time.Second,
        WriteTimeout:   10 * time.Second,
        MaxHeaderBytes: 1 << 20,
    }
    
    log.Fatal(s.server.ListenAndServe())
}

func (s *HttpServer) ServeHTTP(writer http.ResponseWriter, r *http.Request) {
    // Access the session via the sessionManager field
    session := s.sessionManager.Load(r)
    
    // Use the session, e.g. session.Put, session.Get, etc.
    // ...
}

func main() {
    // Create and configure the session manager
    sessionManager := scs.New()
    sessionManager.Lifetime = 24 * time.Hour
    
    // Create your custom HttpServer
    httpServer := &HttpServer{
        getRoutes:  make(map[string]http.HandlerFunc),
        postRoutes: make(map[string]http.HandlerFunc),
    }
    
    // Start the server with the session manager
    httpServer.Run(sessionManager)
}