--- a/pkg/auth/store.go	Fri Aug 24 18:04:25 2018 +0200
+++ b/pkg/auth/store.go	Fri Aug 24 18:06:24 2018 +0200
@@ -17,26 +17,26 @@
 type SessionStore struct {
 	storage  *bolt.DB
 	sessions map[string]*Session
-	cmds     chan func(*SessionStore)
+	cmds     chan func()
 }
 
 var sessionsBucket = []byte("sessions")
 
 func NewSessionStore(filename string) (*SessionStore, error) {
 
-	pcp := &SessionStore{
+	ss := &SessionStore{
 		sessions: make(map[string]*Session),
-		cmds:     make(chan func(*SessionStore)),
+		cmds:     make(chan func()),
 	}
-	if err := pcp.openStorage(filename); err != nil {
+	if err := ss.openStorage(filename); err != nil {
 		return nil, err
 	}
-	go pcp.run()
-	return pcp, nil
+	go ss.run()
+	return ss, nil
 }
 
 // openStorage opens a storage file.
-func (pcp *SessionStore) openStorage(filename string) error {
+func (ss *SessionStore) openStorage(filename string) error {
 
 	// No file, nothing to restore/persist.
 	if filename == "" {
@@ -62,7 +62,7 @@
 			if err := session.deserialize(bytes.NewReader(v)); err != nil {
 				return err
 			}
-			pcp.sessions[string(k)] = &session
+			ss.sessions[string(k)] = &session
 		}
 
 		return nil
@@ -73,37 +73,37 @@
 		return err
 	}
 
-	pcp.storage = db
+	ss.storage = db
 	return nil
 }
 
-func (pcp *SessionStore) run() {
+func (ss *SessionStore) run() {
 	for {
 		select {
-		case cmd := <-pcp.cmds:
-			cmd(pcp)
+		case cmd := <-ss.cmds:
+			cmd()
 		case <-time.After(time.Minute * 5):
-			pcp.cleanToken()
+			ss.cleanToken()
 		}
 	}
 }
 
-func (pcp *SessionStore) cleanToken() {
+func (ss *SessionStore) cleanToken() {
 	now := time.Now()
-	for token, session := range pcp.sessions {
+	for token, session := range ss.sessions {
 		expires := time.Unix(session.ExpiresAt, 0)
 		if expires.Before(now) {
-			delete(pcp.sessions, token)
-			pcp.remove(token)
+			delete(ss.sessions, token)
+			ss.remove(token)
 		}
 	}
 }
 
-func (pcp *SessionStore) remove(token string) {
-	if pcp.storage == nil {
+func (ss *SessionStore) remove(token string) {
+	if ss.storage == nil {
 		return
 	}
-	err := pcp.storage.Update(func(tx *bolt.Tx) error {
+	err := ss.storage.Update(func(tx *bolt.Tx) error {
 		b := tx.Bucket(sessionsBucket)
 		return b.Delete([]byte(token))
 	})
@@ -112,25 +112,25 @@
 	}
 }
 
-func (pcp *SessionStore) Delete(token string) bool {
+func (ss *SessionStore) Delete(token string) bool {
 	res := make(chan bool)
-	pcp.cmds <- func(pcp *SessionStore) {
-		if _, found := pcp.sessions[token]; !found {
+	ss.cmds <- func() {
+		if _, found := ss.sessions[token]; !found {
 			res <- false
 			return
 		}
-		delete(pcp.sessions, token)
-		pcp.remove(token)
+		delete(ss.sessions, token)
+		ss.remove(token)
 		res <- true
 	}
 	return <-res
 }
 
-func (pcp *SessionStore) store(token string, session *Session) {
-	if pcp.storage == nil {
+func (ss *SessionStore) store(token string, session *Session) {
+	if ss.storage == nil {
 		return
 	}
-	err := pcp.storage.Update(func(tx *bolt.Tx) error {
+	err := ss.storage.Update(func(tx *bolt.Tx) error {
 		b := tx.Bucket(sessionsBucket)
 		var buf bytes.Buffer
 		if err := session.serialize(&buf); err != nil {
@@ -143,25 +143,24 @@
 	}
 }
 
-func (pcp *SessionStore) Add(token string, session *Session) *Session {
-	res := make(chan *Session)
+func (ss *SessionStore) Add(token string, session *Session) {
+	res := make(chan struct{})
 
-	pcp.cmds <- func(cp *SessionStore) {
-		s := pcp.sessions[token]
+	ss.cmds <- func() {
+		defer close(res)
+		s := ss.sessions[token]
 		if s == nil {
 			s = session
-			pcp.sessions[token] = session
+			ss.sessions[token] = session
 		}
 		s.touch()
-		pcp.store(token, s)
-		res <- s
+		ss.store(token, s)
 	}
 
-	s := <-res
-	return s
+	<-res
 }
 
-func (pcp *SessionStore) Renew(token string) (string, error) {
+func (ss *SessionStore) Renew(token string) (string, error) {
 
 	type result struct {
 		newToken string
@@ -170,18 +169,18 @@
 
 	resCh := make(chan result)
 
-	pcp.cmds <- func(cp *SessionStore) {
-		session := pcp.sessions[token]
+	ss.cmds <- func() {
+		session := ss.sessions[token]
 		if session == nil {
 			resCh <- result{err: ErrNoSuchToken}
 		} else {
-			delete(pcp.sessions, token)
-			pcp.remove(token)
+			delete(ss.sessions, token)
+			ss.remove(token)
 			newToken := GenerateSessionKey()
 			// TODO: Ensure that this is not racy!
 			session.ExpiresAt = time.Now().Add(maxTokenValid).Unix()
-			pcp.sessions[newToken] = session
-			pcp.store(newToken, session)
+			ss.sessions[newToken] = session
+			ss.store(newToken, session)
 			resCh <- result{newToken: newToken}
 		}
 	}
@@ -190,36 +189,36 @@
 	return r.newToken, r.err
 }
 
-func (pcp *SessionStore) Session(token string) *Session {
+func (ss *SessionStore) Session(token string) *Session {
 	res := make(chan *Session)
-	pcp.cmds <- func(pcp *SessionStore) {
-		session := pcp.sessions[token]
+	ss.cmds <- func() {
+		session := ss.sessions[token]
 		if session == nil {
 			res <- nil
 		} else {
 			session.touch()
-			pcp.store(token, session)
+			ss.store(token, session)
 			res <- session
 		}
 	}
 	return <-res
 }
 
-func (pcp *SessionStore) Logout(user string) {
-	pcp.cmds <- func(pcp *SessionStore) {
-		for token, session := range pcp.sessions {
+func (ss *SessionStore) Logout(user string) {
+	ss.cmds <- func() {
+		for token, session := range ss.sessions {
 			if session.User == user {
-				delete(pcp.sessions, token)
-				pcp.remove(token)
+				delete(ss.sessions, token)
+				ss.remove(token)
 			}
 		}
 	}
 }
 
-func (pcp *SessionStore) Shutdown() error {
-	if db := pcp.storage; db != nil {
+func (ss *SessionStore) Shutdown() error {
+	if db := ss.storage; db != nil {
 		log.Println("info: shutdown persistent connection pool.")
-		pcp.storage = nil
+		ss.storage = nil
 		return db.Close()
 	}
 	log.Println("info: shutdown in-memory connection pool.")