feat(serverHandler): split sessionContext from responseData

For data that needed by handler's process but not necessary for
rendering, move to sessionContext. Otherwise keep stay in responseData.

Author: marjune163

src/serverHandler/aliasHandler.go

@@ -103,79 +103,79 @@ func (h *aliasHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// data
-	data, fsPath := h.getResponseData(r)
-	h.logErrors(data.errors)
-	if data.File != nil {
+	session, data := h.getSessionData(r)
+	h.logErrors(session.errors)
+	if session.file != nil {
 		defer func() {
-			data.File.Close()
+			session.file.Close()
 		}()
 	}
 
-	if h.applyMiddlewares(h.inMiddlewares, w, r, data, fsPath) {
+	if h.applyMiddlewares(h.inMiddlewares, w, r, session, data) {
 		return
 	}
 
-	if !data.AllowAccess {
-		if !h.applyMiddlewares(h.postMiddlewares, w, r, data, fsPath) {
+	if !session.allowAccess {
+		if !h.applyMiddlewares(h.postMiddlewares, w, r, session, data) {
 			h.page(w, r, data)
 		}
 		return
 	}
 
-	if data.NeedAuth {
+	if session.needAuth {
 		h.notifyAuth(w, r)
 	}
 
-	if data.AuthSuccess {
-		if data.requestAuth {
-			h.redirectWithoutRequestAuth(w, r, data)
+	if session.authSuccess {
+		if session.requestAuth {
+			h.redirectWithoutRequestAuth(w, r, session, data)
 			return
 		}
 
-		if data.redirectAction == addSlashSuffix {
-			redirect(w, r, data.prefixReqPath+"/", h.autoDirSlash)
+		if session.redirectAction == addSlashSuffix {
+			redirect(w, r, session.prefixReqPath+"/", h.autoDirSlash)
 			return
-		} else if data.redirectAction == removeSlashSuffix {
-			redirect(w, r, data.prefixReqPath[:len(data.prefixReqPath)-1], h.autoDirSlash)
+		} else if session.redirectAction == removeSlashSuffix {
+			redirect(w, r, session.prefixReqPath[:len(session.prefixReqPath)-1], h.autoDirSlash)
 			return
 		}
 
 		if data.CanCors {
 			cors(w)
 		}
 
-		header(w, data.Headers)
+		header(w, session.headers)
 
 		if data.IsMutate {
-			h.mutate(w, r, data)
+			h.mutate(w, r, session, data)
 			return
 		}
 
 		// archive
 		if len(r.URL.RawQuery) >= 3 {
 			switch r.URL.RawQuery[:3] {
 			case "tar":
-				h.tar(w, r, data)
+				h.tar(w, r, session, data)
 				return
 			case "tgz":
-				h.tgz(w, r, data)
+				h.tgz(w, r, session, data)
 				return
 			case "zip":
-				h.zip(w, r, data)
+				h.zip(w, r, session, data)
 				return
 			}
 		}
 	}
 
-	if h.applyMiddlewares(h.postMiddlewares, w, r, data, fsPath) {
+	if h.applyMiddlewares(h.postMiddlewares, w, r, session, data) {
 		return
 	}
 
 	// final process
-	if data.wantJson {
+	if session.wantJson {
 		h.json(w, r, data)
-	} else if shouldServeAsContent(data.File, data.Item) {
-		h.content(w, r, data)
+	} else if shouldServeAsContent(session.file, data.Item) {
+		h.content(w, r, session, data)
 	} else {
 		h.page(w, r, data)
 	}

src/serverHandler/archive.go

@@ -132,19 +132,20 @@ func (h *aliasHandler) visitTreeNode(
 func (h *aliasHandler) archive(
 	w http.ResponseWriter,
 	r *http.Request,
-	pageData *responseData,
+	session *sessionContext,
+	data *responseData,
 	selections []string,
 	fileSuffix string,
 	contentType string,
 	cbWriteFile archiveCallback,
 ) {
 	var itemName string
-	_, hasAlias := h.aliases.byUrlPath(pageData.rawReqPath)
+	_, hasAlias := h.aliases.byUrlPath(session.vhostReqPath)
 	if hasAlias {
-		itemName = path.Base(pageData.rawReqPath)
+		itemName = path.Base(session.vhostReqPath)
 	}
 	if len(itemName) == 0 || itemName == "/" {
-		itemName = pageData.ItemName
+		itemName = data.ItemName
 	}
 
 	targetFilename := itemName + fileSuffix
@@ -156,10 +157,10 @@ func (h *aliasHandler) archive(
 
 	h.visitTreeNode(
 		r,
-		pageData.rawReqPath,
-		path.Clean(h.root+pageData.handlerReqPath),
+		session.vhostReqPath,
+		path.Clean(h.root+session.aliasReqPath),
 		"",
-		pageData.Item != nil, // not empty root
+		data.Item != nil, // not empty root
 		selections,
 		func(f *os.File, fInfo os.FileInfo, relPath string) error {
 			h.logArchive(targetFilename, relPath, r)

src/serverHandler/archiveTar.go

@@ -52,8 +52,8 @@ func writeTar(tw *tar.Writer, f *os.File, fInfo os.FileInfo, archivePath string)
 	return nil
 }
 
-func (h *aliasHandler) tar(w http.ResponseWriter, r *http.Request, pageData *responseData) {
-	if !pageData.CanArchive {
+func (h *aliasHandler) tar(w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) {
+	if !data.CanArchive {
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -72,7 +72,8 @@ func (h *aliasHandler) tar(w http.ResponseWriter, r *http.Request, pageData *res
 	h.archive(
 		w,
 		r,
-		pageData,
+		session,
+		data,
 		selections,
 		".tar",
 		"application/octet-stream",
@@ -82,8 +83,8 @@ func (h *aliasHandler) tar(w http.ResponseWriter, r *http.Request, pageData *res
 	)
 }
 
-func (h *aliasHandler) tgz(w http.ResponseWriter, r *http.Request, pageData *responseData) {
-	if !pageData.CanArchive {
+func (h *aliasHandler) tgz(w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) {
+	if !data.CanArchive {
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -111,7 +112,8 @@ func (h *aliasHandler) tgz(w http.ResponseWriter, r *http.Request, pageData *res
 	h.archive(
 		w,
 		r,
-		pageData,
+		session,
+		data,
 		selections,
 		".tar.gz",
 		"application/octet-stream",

src/serverHandler/archiveZip.go

@@ -37,8 +37,8 @@ func writeZip(zw *zip.Writer, f *os.File, fInfo os.FileInfo, archivePath string)
 	return nil
 }
 
-func (h *aliasHandler) zip(w http.ResponseWriter, r *http.Request, pageData *responseData) {
-	if !pageData.CanArchive {
+func (h *aliasHandler) zip(w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) {
+	if !data.CanArchive {
 		w.WriteHeader(http.StatusBadRequest)
 		return
 	}
@@ -57,7 +57,8 @@ func (h *aliasHandler) zip(w http.ResponseWriter, r *http.Request, pageData *res
 	h.archive(
 		w,
 		r,
-		pageData,
+		session,
+		data,
 		selections,
 		".zip",
 		"application/zip",

src/serverHandler/content.go

@@ -5,7 +5,7 @@ import (
 	"net/url"
 )
 
-func (h *aliasHandler) content(w http.ResponseWriter, r *http.Request, data *responseData) {
+func (h *aliasHandler) content(w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) {
 	header := w.Header()
 	header.Set("Vary", h.vary)
 	header.Set("X-Content-Type-Options", "nosniff")
@@ -14,7 +14,7 @@ func (h *aliasHandler) content(w http.ResponseWriter, r *http.Request, data *res
 	}
 
 	item := data.Item
-	file := data.File
+	file := session.file
 
 	http.ServeContent(w, r, item.Name(), item.ModTime(), file)
 }

src/serverHandler/json.go

@@ -56,9 +56,6 @@ func getJsonData(data *responseData) *jsonResponseData {
 	}
 
 	return &jsonResponseData{
-		NeedAuth:           data.NeedAuth,
-		AuthUserName:       data.AuthUserName,
-		AuthSuccess:        data.AuthSuccess,
 		IsRoot:             data.IsRoot,
 		Path:               data.Path,
 		Paths:              data.Paths,

src/serverHandler/middleware.go

@@ -5,26 +5,25 @@ import (
 	"net/http"
 )
 
-func (h *aliasHandler) applyMiddlewares(mids []middleware.Middleware, w http.ResponseWriter, r *http.Request, data *responseData, fsPath string) (processed bool) {
+func (h *aliasHandler) applyMiddlewares(mids []middleware.Middleware, w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) (processed bool) {
 	if len(mids) == 0 {
 		return
 	}
 
 	context := &middleware.Context{
-		PrefixReqPath: data.prefixReqPath,
-		VhostReqPath:  data.rawReqPath,
-		AliasReqPath:  data.handlerReqPath,
-		AliasFsPath:   fsPath,
+		PrefixReqPath: session.prefixReqPath,
+		VhostReqPath:  session.vhostReqPath,
+		AliasReqPath:  session.aliasReqPath,
+		AliasFsPath:   session.fsPath,
 		AliasFsRoot:   h.root,
 
-		WantJson: data.wantJson,
+		WantJson: session.wantJson,
 
-		RestrictAccess: data.RestrictAccess,
-		AllowAccess:    data.AllowAccess,
+		AllowAccess: session.allowAccess,
 
-		NeedAuth:     data.NeedAuth,
-		AuthUserName: data.AuthUserName,
-		AuthSuccess:  data.AuthSuccess,
+		NeedAuth:     session.needAuth,
+		AuthUserName: session.authUserName,
+		AuthSuccess:  session.authSuccess,
 
 		CanUpload:  &data.CanUpload,
 		CanMkdir:   &data.CanMkdir,
@@ -37,8 +36,8 @@ func (h *aliasHandler) applyMiddlewares(mids []middleware.Middleware, w http.Res
 		Logger: h.logger,
 	}
 
-	if data.File != nil {
-		context.File = &data.File
+	if session.file != nil {
+		context.File = &session.file
 	}
 	if data.Item != nil {
 		context.FileInfo = &data.Item

src/serverHandler/mutate.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 )
 
-func (h *aliasHandler) mutate(w http.ResponseWriter, r *http.Request, data *responseData) {
+func (h *aliasHandler) mutate(w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) {
 	if r.Method != http.MethodPost {
 		w.WriteHeader(http.StatusMethodNotAllowed)
 		return
@@ -16,19 +16,19 @@ func (h *aliasHandler) mutate(w http.ResponseWriter, r *http.Request, data *resp
 	switch {
 	case data.IsUpload:
 		if data.CanUpload {
-			success = h.saveUploadFiles(data.AuthUserName, h.root+data.handlerReqPath, data.CanMkdir, data.CanDelete, data.AliasSubItems, r)
+			success = h.saveUploadFiles(session.authUserName, h.root+session.aliasReqPath, data.CanMkdir, data.CanDelete, data.AliasSubItems, r)
 		}
 	case data.IsMkdir:
 		if data.CanMkdir && !h.logError(r.ParseForm()) {
-			success = h.mkdirs(data.AuthUserName, h.root+data.handlerReqPath, r.Form["name"], data.AliasSubItems, r)
+			success = h.mkdirs(session.authUserName, h.root+session.aliasReqPath, r.Form["name"], data.AliasSubItems, r)
 		}
 	case data.IsDelete:
 		if data.CanDelete && !h.logError(r.ParseForm()) {
-			success = h.deleteItems(data.AuthUserName, h.root+data.handlerReqPath, r.Form["name"], data.AliasSubItems, r)
+			success = h.deleteItems(session.authUserName, h.root+session.aliasReqPath, r.Form["name"], data.AliasSubItems, r)
 		}
 	}
 
-	if data.wantJson {
+	if session.wantJson {
 		header := w.Header()
 		header.Set("Content-Type", "application/json; charset=utf-8")
 		header.Set("Cache-Control", "public, max-age=0")

src/serverHandler/redirect.go

@@ -10,10 +10,10 @@ func redirect(w http.ResponseWriter, r *http.Request, path string, code int) {
 	http.Redirect(w, r, target, code)
 }
 
-func (h *aliasHandler) redirectWithoutRequestAuth(w http.ResponseWriter, r *http.Request, data *responseData) {
+func (h *aliasHandler) redirectWithoutRequestAuth(w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) {
 	returnUrl := r.Header.Get("Referer")
 	if len(returnUrl) == 0 {
-		returnUrl = data.prefixReqPath + data.Context.QueryString()
+		returnUrl = session.prefixReqPath + data.Context.QueryString()
 	}
 
 	http.Redirect(w, r, returnUrl, http.StatusFound)