killed error eater. it changed the interface, so it's not a safe change

sessions.go

@@ -36,23 +36,23 @@ type Options struct {
 // Session stores the values and optional configuration for a session.
 type Session interface {
 	// Get returns the session value associated to the given key.
-	Get(key interface{}) interface{}
+	Get(key interface{}) (interface{}, error)
 	// Set sets the session value associated to the given key.
-	Set(key interface{}, val interface{})
+	Set(key interface{}, val interface{}) error
 	// Delete removes the session value associated to the given key.
-	Delete(key interface{})
+	Delete(key interface{}) error
 	// Clear deletes all values in the session.
-	Clear()
+	Clear() error
 	// AddFlash adds a flash message to the session.
 	// A single variadic argument is accepted, and it is optional: it defines the flash key.
 	// If not defined "_flash" is used by default.
-	AddFlash(value interface{}, vars ...string)
+	AddFlash(value interface{}, vars ...string) error
 	// Flashes returns a slice of flash messages from the session.
 	// A single variadic argument is accepted, and it is optional: it defines the flash key.
 	// If not defined "_flash" is used by default.
-	Flashes(vars ...string) []interface{}
+	Flashes(vars ...string) ([]interface{}, error)
 	// Options sets confuguration for a session.
-	Options(Options)
+	Options(Options) error
 	// Save saves all sessions used during the current request.
 	Save() error
 }
@@ -75,49 +75,86 @@ type session struct {
 	writer  http.ResponseWriter
 }
 
-func (s *session) Get(key interface{}) interface{} {
-	return s.Session().Values[key]
+func (s *session) Get(key interface{}) (interface{}, error) {
+	v, err := s.Session()
+	if err != nil{
+		return nil, err
+	}
+	return v.Values[key], nil
 }
 
-func (s *session) Set(key interface{}, val interface{}) {
-	s.Session().Values[key] = val
+func (s *session) Set(key interface{}, val interface{}) error {
+	v, err := s.Session()
+	if err != nil{
+		return err
+	}
+	v.Values[key] = val
 	s.written = true
+	return nil
 }
 
-func (s *session) Delete(key interface{}) {
-	delete(s.Session().Values, key)
+func (s *session) Delete(key interface{}) error {
+	v, err := s.Session()
+	if err != nil{
+		return err
+	}
+	delete(v.Values, key)
 	s.written = true
+	return nil
 }
 
-func (s *session) Clear() {
-	for key := range s.Session().Values {
+func (s *session) Clear() error {
+	v, err := s.Session()
+	if err != nil{
+		return err
+	}
+	for key := range v.Values {
 		s.Delete(key)
 	}
+	return nil
 }
 
-func (s *session) AddFlash(value interface{}, vars ...string) {
-	s.Session().AddFlash(value, vars...)
+func (s *session) AddFlash(value interface{}, vars ...string) error {
+	v, err := s.Session()
+	if err != nil{
+		return err
+	}
+	v.AddFlash(value, vars...)
 	s.written = true
+	return nil
 }
 
-func (s *session) Flashes(vars ...string) []interface{} {
+func (s *session) Flashes(vars ...string) ([]interface{}, error) {
 	s.written = true
-	return s.Session().Flashes(vars...)
+	v, err := s.Session()
+	if err != nil{
+		return nil, err
+	}
+	return v.Flashes(vars...), nil
 }
 
-func (s *session) Options(options Options) {
-	s.Session().Options = &sessions.Options{
+func (s *session) Options(options Options) error {
+	v, err := s.Session()
+	if err != nil{
+		return err
+	}
+	v.Options = &sessions.Options{
 		Path:     options.Path,
 		Domain:   options.Domain,
 		MaxAge:   options.MaxAge,
 		Secure:   options.Secure,
 		HttpOnly: options.HttpOnly,
 	}
+	return nil
 }
 
 func (s *session) Save() error {
 	if s.Written() {
-		e := s.Session().Save(s.request, s.writer)
+		v, err := s.Session()
+		if err != nil{
+			return err
+		}
+		e := v.Save(s.request, s.writer)
 		if e == nil {
 			s.written = false
 		}
@@ -126,15 +163,15 @@ func (s *session) Save() error {
 	return nil
 }
 
-func (s *session) Session() *sessions.Session {
+func (s *session) Session() (*sessions.Session, error) {
+	var err error
 	if s.session == nil {
-		var err error
 		s.session, err = s.store.Get(s.request, s.name)
 		if err != nil {
 			log.Printf(errorFormat, err)
 		}
 	}
-	return s.session
+	return s.session, err
 }
 
 func (s *session) Written() bool {