Fix session restoration

Fix broken session restoration by using the session info parser
during session deserialization (from a file or a database).
Also use the parser when receiving the session on the client.

client.go

@@ -135,11 +135,7 @@ func (clt *Client) notifySessionCreated(newSession *Session) error {
 		}
 	}
 
-	encoded, err := json.Marshal(struct {
-		Key      string                 `json:"k"`
-		Creation time.Time              `json:"c"`
-		Info     map[string]interface{} `json:"i"`
-	}{
+	encoded, err := json.Marshal(JSONEncodedSession{
 		newSession.Key,
 		newSession.Creation,
 		sessionInfo,

client/client.go

@@ -40,7 +40,7 @@ const (
 type Client struct {
 	serverAddr        string
 	impl              Implementation
-	sessionInfoParser SessionInfoParser
+	sessionInfoParser webwire.SessionInfoParser
 	status            Status
 	defaultReqTimeout time.Duration
 	reconnInterval    time.Duration
@@ -279,6 +279,7 @@ func (clt *Client) RestoreSession(sessionKey []byte) error {
 	if err != nil {
 		return err
 	}
+
 	clt.sessionLock.Lock()
 	clt.session = restoredSession
 	clt.sessionLock.Unlock()

client/handle.go

@@ -2,18 +2,12 @@ package client
 
 import (
 	"encoding/json"
-	"time"
 
 	webwire "github.com/qbeon/webwire-go"
 )
 
 func (clt *Client) handleSessionCreated(msgPayload webwire.Payload) {
-	var encoded struct {
-		Key      string                 `json:"k"`
-		Creation time.Time              `json:"c"`
-		Info     map[string]interface{} `json:"i"`
-	}
-
+	var encoded webwire.JSONEncodedSession
 	if err := json.Unmarshal(msgPayload.Data, &encoded); err != nil {
 		clt.errorLog.Printf("Failed unmarshalling session object: %s", err)
 		return

client/interfaces.go

@@ -19,7 +19,3 @@ type Implementation interface {
 	// either by the server or the client itself
 	OnSessionClosed()
 }
-
-// SessionInfoParser is invoked during the parsing of a newly assigned
-// session, it must return a webwire.SessionInfo compliant object
-type SessionInfoParser func(data map[string]interface{}) webwire.SessionInfo

client/options.go

@@ -25,7 +25,7 @@ const (
 // Options represents the options used during the creation a new client instance
 type Options struct {
 	// SessionInfoParser defines the optional session info parser function
-	SessionInfoParser func(map[string]interface{}) webwire.SessionInfo
+	SessionInfoParser webwire.SessionInfoParser
 
 	// DefaultRequestTimeout defines the default request timeout duration
 	// used by client.Request and client.RestoreSession
@@ -57,7 +57,7 @@ type Options struct {
 // SetDefaults sets default values for undefined required options
 func (opts *Options) SetDefaults() {
 	if opts.SessionInfoParser == nil {
-		opts.SessionInfoParser = GenericSessionInfoParser
+		opts.SessionInfoParser = webwire.GenericSessionInfoParser
 	}
 
 	if opts.DefaultRequestTimeout < 1 {

client/requestSessionRestoration.go

@@ -10,7 +10,10 @@ import (
 // requestSessionRestoration sends a session restoration request
 // and decodes the session object from the received reply.
 // Expects the client to be connected beforehand
-func (clt *Client) requestSessionRestoration(sessionKey []byte) (*webwire.Session, error) {
+func (clt *Client) requestSessionRestoration(sessionKey []byte) (
+	*webwire.Session,
+	error,
+) {
 	reply, err := clt.sendNamelessRequest(
 		webwire.MsgRestoreSession,
 		webwire.Payload{
@@ -23,14 +26,25 @@ func (clt *Client) requestSessionRestoration(sessionKey []byte) (*webwire.Sessio
 		return nil, err
 	}
 
-	var session webwire.Session
-	if err := json.Unmarshal(reply.Data, &session); err != nil {
+	// Unmarshal JSON encoded session object
+	var encodedSessionObj webwire.JSONEncodedSession
+	if err := json.Unmarshal(reply.Data, &encodedSessionObj); err != nil {
 		return nil, fmt.Errorf(
 			"Couldn't unmarshal restored session from reply('%s'): %s",
 			string(reply.Data),
 			err,
 		)
 	}
 
-	return &session, nil
+	// Parse session info object
+	var decodedInfo webwire.SessionInfo
+	if encodedSessionObj.Info != nil {
+		decodedInfo = clt.sessionInfoParser(encodedSessionObj.Info)
+	}
+
+	return &webwire.Session{
+		Key:      encodedSessionObj.Key,
+		Creation: encodedSessionObj.Creation,
+		Info:     decodedInfo,
+	}, nil
 }

defaultSessionManager.go

@@ -11,8 +11,8 @@ import (
 
 // SessionFile represents the serialization structure of a default session file
 type SessionFile struct {
-	Creation time.Time   `json:"c"`
-	Info     SessionInfo `json:"i"`
+	Creation time.Time              `json:"c"`
+	Info     map[string]interface{} `json:"i"`
 }
 
 // Parse parses the session file from a file
@@ -94,32 +94,39 @@ func (mng *DefaultSessionManager) OnSessionCreated(client *Client) error {
 	sess := client.Session()
 	sessFile := SessionFile{
 		Creation: sess.Creation,
-		Info:     sess.Info,
+		Info:     SessionInfoToVarMap(sess.Info),
 	}
 	return sessFile.WriteFile(mng.filePath(client.SessionKey()))
 }
 
 // OnSessionLookup implements the session manager interface.
 // It searches the session file directory for the session file and loads it
-func (mng *DefaultSessionManager) OnSessionLookup(key string) (*Session, error) {
+func (mng *DefaultSessionManager) OnSessionLookup(key string) (
+	bool,
+	time.Time,
+	map[string]interface{},
+	error,
+) {
 	path := mng.filePath(key)
 	_, err := os.Stat(path)
 	if os.IsNotExist(err) {
-		return nil, nil
+		return false, time.Time{}, nil, nil
 	} else if err != nil {
-		return nil, fmt.Errorf("Unexpected error during file lookup: %s", err)
+		return false, time.Time{}, nil, fmt.Errorf(
+			"Unexpected error during file lookup: %s",
+			err,
+		)
 	}
 
 	var file SessionFile
 	if err := file.Parse(path); err != nil {
-		return nil, fmt.Errorf("Couldn't parse session file: %s", err)
+		return false, time.Time{}, nil, fmt.Errorf(
+			"Couldn't parse session file: %s",
+			err,
+		)
 	}
 
-	return &Session{
-		Key:      key,
-		Creation: file.Creation,
-		Info:     file.Info,
-	}, nil
+	return true, file.Creation, file.Info, nil
 }
 
 // OnSessionClosed implements the session manager interface.

client/genericSessionInfo.go → genericSessionInfo.go

@@ -1,9 +1,7 @@
-package client
+package webwire
 
 import (
 	"reflect"
-
-	webwire "github.com/qbeon/webwire-go"
 )
 
 func deepCopy(src interface{}) interface{} {
@@ -81,7 +79,7 @@ type GenericSessionInfo struct {
 
 // Copy implements the webwire.SessionInfo interface.
 // It deep-copies the object and returns it's exact clone
-func (sinf *GenericSessionInfo) Copy() webwire.SessionInfo {
+func (sinf *GenericSessionInfo) Copy() SessionInfo {
 	return &GenericSessionInfo{
 		data: deepCopy(sinf.data).(map[string]interface{}),
 	}
@@ -117,6 +115,6 @@ func (sinf *GenericSessionInfo) Value(fieldName string) interface{} {
 // GenericSessionInfoParser represents a default implementation of a
 // session info object parser. It parses the info object into a generic
 // session info type implementing the webwire.SessionInfo interface
-func GenericSessionInfoParser(data map[string]interface{}) webwire.SessionInfo {
+func GenericSessionInfoParser(data map[string]interface{}) SessionInfo {
 	return &GenericSessionInfo{data}
 }

interfaces.go

@@ -3,6 +3,7 @@ package webwire
 import (
 	"context"
 	"net/http"
+	"time"
 )
 
 // ServerImplementation defines the interface of a webwire server implementation
@@ -61,25 +62,33 @@ type ServerImplementation interface {
 type SessionManager interface {
 	// OnSessionCreated is invoked after the synchronization of the new session
 	// to the remote client.
-	// The actual created session can be retrieved from the provided client agent.
+	// The actual created session is retrieved from the provided client agent.
 	// If OnSessionCreated returns an error then this error is logged
 	// but the session will not be destroyed and will remain active!
-	// The only consequence of OnSessionCreation failing is that the server won't be able
-	// to restore the session after the client is disconnected.
+	// The only consequence of OnSessionCreation failing is that the server
+	// won't be able to restore the session after the client is disconnected.
 	//
-	// This hook will be invoked by the goroutine calling the client.CreateSession
-	// client agent method
+	// This hook will be invoked by the goroutine calling the
+	// client.CreateSession client agent method
 	OnSessionCreated(client *Client) error
 
-	// OnSessionLookup is invoked when the server is looking for a specific session given its key.
-	// It must return the exact copy of the session object associated with the given key
-	// for sessions to be properly restorable. If no session is found it must return nil
-	// instead of the session and must not return any error.
-	// If an error is returned then the it'll be logged and the session restoration will fail.
+	// OnSessionLookup is invoked when the server is looking for a specific
+	// session given its key.
+	// If the session was found it must return true, the time of its creation
+	// and the exact copy of the session info object. Otherwise false must be
+	// returned and all other return fields can be left empty.
 	//
-	// This hook will be invoked by the goroutine serving the associated client and will block any
-	// other interactions with this client while executing
-	OnSessionLookup(key string) (*Session, error)
+	// If an error is returned then it'll be logged and the session restoration
+	// will fail. An error should not be returned when the session wasn't found.
+	//
+	// This hook will be invoked by the goroutine serving the associated client
+	// and will block any other interactions with this client while executing
+	OnSessionLookup(key string) (
+		exists bool,
+		creation time.Time,
+		info map[string]interface{},
+		err error,
+	)
 
 	// OnSessionClosed is invoked when the active session of the given client
 	// is closed (thus destroyed) either by the server or the client through a
@@ -89,8 +98,9 @@ type SessionManager interface {
 	// If an error is returned then the it is logged.
 	//
 	// This hook is invoked by either a goroutine calling the client.CloseSession()
-	// client agent method, or the goroutine serving the associated client, in the case of which
-	// it will block any other interactions with this client while executing
+	// client agent method, or the goroutine serving the associated client,
+	// in the case of which it will block any other interactions with
+	// this client while executing
 	OnSessionClosed(client *Client) error
 }
 
@@ -128,3 +138,10 @@ type SessionInfo interface {
 	// race conditions and undefined behavior
 	Copy() SessionInfo
 }
+
+// SessionInfoParser represents the type of a session info parser function.
+// The session info parser is invoked during the parsing of a newly assigned
+// session on the client, as well as during the parsing of a saved serialized
+// session. It must return a webwire.SessionInfo compliant object constructed
+// from the data given
+type SessionInfoParser func(map[string]interface{}) SessionInfo

options.go

@@ -10,6 +10,7 @@ type ServerOptions struct {
 	SessionsEnabled       bool
 	SessionManager        SessionManager
 	SessionKeyGenerator   SessionKeyGenerator
+	SessionInfoParser     SessionInfoParser
 	MaxSessionConnections uint
 	WarnLog               io.Writer
 	ErrorLog              io.Writer
@@ -26,6 +27,10 @@ func (srvOpt *ServerOptions) SetDefaults() {
 		srvOpt.SessionKeyGenerator = NewDefaultSessionKeyGenerator()
 	}
 
+	if srvOpt.SessionInfoParser == nil {
+		srvOpt.SessionInfoParser = GenericSessionInfoParser
+	}
+
 	if srvOpt.WarnLog == nil {
 		srvOpt.WarnLog = os.Stdout
 	}

server.go

@@ -14,9 +14,10 @@ const protocolVersion = "1.3"
 // Server represents a headless WebWire server instance,
 // where headless means there's no HTTP server that's hosting it
 type Server struct {
-	impl           ServerImplementation
-	sessionManager SessionManager
-	sessionKeyGen  SessionKeyGenerator
+	impl              ServerImplementation
+	sessionManager    SessionManager
+	sessionKeyGen     SessionKeyGenerator
+	sessionInfoParser SessionInfoParser
 
 	// State
 	shutdown        bool
@@ -43,9 +44,10 @@ func NewServer(implementation ServerImplementation, opts ServerOptions) *Server
 	opts.SetDefaults()
 
 	srv := Server{
-		impl:           implementation,
-		sessionManager: opts.SessionManager,
-		sessionKeyGen:  opts.SessionKeyGenerator,
+		impl:              implementation,
+		sessionManager:    opts.SessionManager,
+		sessionKeyGen:     opts.SessionKeyGenerator,
+		sessionInfoParser: opts.SessionInfoParser,
 
 		// State
 		shutdown:        false,
@@ -90,28 +92,50 @@ func (srv *Server) handleSessionRestore(clt *Client, msg *Message) error {
 		return nil
 	}
 
-	session, err := srv.sessionManager.OnSessionLookup(key)
+	//session, err := srv.sessionManager.OnSessionLookup(key)
+	exists, creation, info, err := srv.sessionManager.OnSessionLookup(key)
 	if err != nil {
-		// TODO: return internal server error and log it
 		srv.failMsg(clt, msg, nil)
 		return fmt.Errorf("CRITICAL: Session search handler failed: %s", err)
 	}
-	if session == nil {
+	if !exists {
 		srv.failMsg(clt, msg, SessNotFoundErr{})
 		return nil
 	}
 
+	encodedSessionObj := JSONEncodedSession{
+		Key:      key,
+		Creation: creation,
+		Info:     info,
+	}
+
 	// JSON encode the session
-	encodedSession, err := json.Marshal(session)
+	encodedSession, err := json.Marshal(&encodedSessionObj)
 	if err != nil {
 		// TODO: return internal server error and log it
 		srv.failMsg(clt, msg, nil)
-		return fmt.Errorf("Couldn't encode session object (%v): %s", session, err)
+		return fmt.Errorf(
+			"Couldn't encode session object (%v): %s",
+			encodedSessionObj,
+			err,
+		)
+	}
+
+	// parse attached session info
+	var parsedSessInfo SessionInfo
+	if info != nil && srv.sessionInfoParser != nil {
+		parsedSessInfo = srv.sessionInfoParser(info)
 	}
 
-	clt.setSession(session)
+	clt.setSession(&Session{
+		Key:      key,
+		Creation: creation,
+		Info:     parsedSessInfo,
+	})
 	if okay := srv.sessionRegistry.register(clt); !okay {
-		panic(fmt.Errorf("The number of concurrent session connections was unexpectedly exceeded"))
+		panic(fmt.Errorf("The number of concurrent session connections was " +
+			"unexpectedly exceeded",
+		))
 	}
 
 	srv.fulfillMsg(clt, msg, Payload{