use of closed network connection

[dxvgef]

I use SCS to implement session functionality in the echo framework, but I delete the sessionid in cookie and then refresh the browser and output the error:

redigo: unexpected type for Bytes, got type []interface {}
redigo: unexpected response line (possible server error or unsupported concurrent read by application)
write tcp 127.0.0.1:49741->127.0.0.1:6379: use of closed network connection

My code:

//Connect Redis
func connectRedis() (redis.Conn, error) {
	conn, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		return nil, err
	}
	return conn, err
}

//Configure SCS
func SetSession() error {
	redisConn, err := connectRedis()
	if err != nil {
		return err
	}
	redisPool := redisstore.New(redis.NewPool(func() (redis.Conn, error) {
		return redisConn, nil
	}, 1))

	SessionManager = scs.NewManager(redisPool)
	SessionManager.Name("sessionid")
	SessionManager.Path("/")
	SessionManager.Lifetime(60 * time.Minute)
	SessionManager.Secure(false)
	SessionManager.HttpOnly(true)
	SessionManager.IdleTimeout(20 * time.Minute)
	SessionManager.Persist(true)
	return nil
}

//Echo middleware
func SessionMiddleware() echo.MiddlewareFunc {
	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(ctx echo.Context) error {
			//update session idletime
			session := SessionManager.Load(ctx.Request())
			err := session.Touch(ctx.Response().Writer)
			if err != nil {
				return err
			}
			return next(ctx)
		}
	}
}

[jpfluger]

I could not replicate your error. I tried a version of your code (see below) that I tested by

1. deleting the session id in redis, and
2. in the browser (via clearing all cookies - using Chrome).
3. then stress-tested with vagera for good-measure

Maybe...

• your Redis instance crashed? (I tested with redis docker image "4.0.6-alpine".)
• using an older version of scs?

Here's the middleware I used for testing:

package midware

import (
	"github.com/labstack/echo"
	"github.com/labstack/echo/middleware"
	"github.com/alexedwards/scs"
	"fmt"
	"github.com/alexedwards/scs/stores/redisstore"
	"github.com/garyburd/redigo/redis"
	"time"
        "net/http/httputil"
)

type SessionInitializeConfig struct {
	// Skipper defines a function to skip middleware.
	Skipper middleware.Skipper
	// the scs session manager
	SessionManager *scs.Manager
}

var (
	DefaultSessionInitializeConfig = SessionInitializeConfig{
		Skipper: middleware.DefaultSkipper,
		// hardcoded encryption key for testing - not production
		// https://github.com/alexedwards/scs
		// to create random key: https://stackoverflow.com/questions/22892120/how-to-generate-a-random-string-of-a-fixed-length-in-golang
		SessionManager: scs.NewCookieManager("u46IpCV9y5Vlur8YvODJEhgOY8m9JVE4"),
	}
)

func SessionInitialize() echo.MiddlewareFunc {
	return SessionInitializeWithConfig(DefaultSessionInitializeConfig)
}

func NewSessionManagerRedis() *scs.Manager {
	engine := redisstore.New(
		&redis.Pool{
			MaxIdle: 10,
			Dial: func() (redis.Conn, error) {
				return redis.Dial("tcp", "127.0.0.1:6379")
			},
		},
	)

	sessionManager := scs.NewManager(engine)
	sessionManager.Name("sessionid")
	sessionManager.Path("/")
	sessionManager.Lifetime(60 * time.Minute)
	sessionManager.Secure(false)
	sessionManager.HttpOnly(true)
	sessionManager.IdleTimeout(20 * time.Minute)
	sessionManager.Persist(true)

	return sessionManager
}

func SessionInitializeWithConfig(config SessionInitializeConfig) echo.MiddlewareFunc {
	// Defaults
	if config.Skipper == nil {
		config.Skipper = DefaultSessionInitializeConfig.Skipper
	}
	if config.SessionManager == nil {
		config.SessionManager = DefaultSessionInitializeConfig.SessionManager
	}

	return func(next echo.HandlerFunc) echo.HandlerFunc {
		return func(c echo.Context) error {
			if config.Skipper(c) {
				return next(c)
			}

			session := config.SessionManager.Load(c.Request())
			session.Touch(c.Response())

			// NOTE: this is enough to initialize the cookie
			// return next(c)

			// ----------------
			// Begin tests

			counter, err := session.GetInt64("counter")
			if err != nil {
				counter = 0
			}
			counter++

			session.PutInt64(c.Response(), "counter", counter)
			session.PutString(c.Response(), "count-as-string", fmt.Sprintf("count is %d", counter))

			fmt.Printf("%+v\n", session)

			requestDump, err := httputil.DumpRequest(c.Request(), true)
			if err != nil {
				fmt.Println(err)
			}
			fmt.Println(string(requestDump))

			// End tests
			// ----------------

			return next(c)
		}
	}
}

Create the redis store and invoke with

sessionManager := midware.NewSessionManagerRedis()
e.Use(midware.SessionInitializeWithConfig(midware.SessionInitializeConfig{SessionManager: sessionManager}))

[jpfluger]

As I'm getting familiar with this software, I hadn't seen Use. Good reference as well, which can be wrapped in an echo function as discussed in #15. The one I volunteered follows the default echo middleware paradigm.

[jpfluger]

Also because the Opts is not exposed with a public Idletimeout, we can't write the equivalent of Use for echo using the default echo Logger.

[alexedwards]

I haven't been able to replicate this either. Is it still causing a problem?

[alexedwards]

Closing due to age and lack of further information. Please reopen if it continues to be a problem with the latest version.