| // Copyright (c) 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| /* |
| Serves a webpage for easy management of Skia bugs. |
| |
| WARNING: This server is NOT secure and should not be made publicly |
| accessible. |
| */ |
| |
| package main |
| |
| import ( |
| "encoding/json" |
| "flag" |
| "fmt" |
| "html/template" |
| "issue_tracker" |
| "log" |
| "net/http" |
| "net/url" |
| "path" |
| "path/filepath" |
| "strconv" |
| "strings" |
| "time" |
| ) |
| |
| import "github.com/gorilla/securecookie" |
| |
| const certFile = "certs/cert.pem" |
| const keyFile = "certs/key.pem" |
| const issueComment = "Edited by BugChomper" |
| const oauthCallbackPath = "/oauth2callback" |
| const oauthConfigFile = "oauth_client_secret.json" |
| const defaultPort = 8000 |
| const localHost = "127.0.0.1" |
| const maxSessionLen = time.Duration(3600 * time.Second) |
| const priorityPrefix = "Priority-" |
| const project = "skia" |
| const cookieName = "BugChomperCookie" |
| |
| var scheme = "http" |
| |
| var curdir, _ = filepath.Abs(".") |
| var templatePath, _ = filepath.Abs("templates") |
| var templates = template.Must(template.ParseFiles( |
| path.Join(templatePath, "bug_chomper.html"), |
| path.Join(templatePath, "submitted.html"), |
| path.Join(templatePath, "error.html"))) |
| |
| var hashKey = securecookie.GenerateRandomKey(32) |
| var blockKey = securecookie.GenerateRandomKey(32) |
| var secureCookie = securecookie.New(hashKey, blockKey) |
| |
| // SessionState contains data for a given session. |
| type SessionState struct { |
| IssueTracker *issue_tracker.IssueTracker |
| OrigRequestURL string |
| SessionStart time.Time |
| } |
| |
| // getAbsoluteURL returns the absolute URL of the given Request. |
| func getAbsoluteURL(r *http.Request) string { |
| return scheme + "://" + r.Host + r.URL.Path |
| } |
| |
| // getOAuth2CallbackURL returns a callback URL to be used by the OAuth2 login |
| // page. |
| func getOAuth2CallbackURL(r *http.Request) string { |
| return scheme + "://" + r.Host + oauthCallbackPath |
| } |
| |
| func saveSession(session *SessionState, w http.ResponseWriter, r *http.Request) error { |
| encodedSession, err := secureCookie.Encode(cookieName, session) |
| if err != nil { |
| return fmt.Errorf("unable to encode session state: %s", err) |
| } |
| cookie := &http.Cookie{ |
| Name: cookieName, |
| Value: encodedSession, |
| Domain: strings.Split(r.Host, ":")[0], |
| Path: "/", |
| HttpOnly: true, |
| } |
| http.SetCookie(w, cookie) |
| return nil |
| } |
| |
| // makeSession creates a new session for the Request. |
| func makeSession(w http.ResponseWriter, r *http.Request) (*SessionState, error) { |
| log.Println("Creating new session.") |
| // Create the session state. |
| issueTracker, err := issue_tracker.MakeIssueTracker( |
| oauthConfigFile, getOAuth2CallbackURL(r)) |
| if err != nil { |
| return nil, fmt.Errorf("unable to create IssueTracker for session: %s", err) |
| } |
| session := SessionState{ |
| IssueTracker: issueTracker, |
| OrigRequestURL: getAbsoluteURL(r), |
| SessionStart: time.Now(), |
| } |
| |
| // Encode and store the session state. |
| if err := saveSession(&session, w, r); err != nil { |
| return nil, err |
| } |
| |
| return &session, nil |
| } |
| |
| // getSession retrieves the active SessionState or creates and returns a new |
| // SessionState. |
| func getSession(w http.ResponseWriter, r *http.Request) (*SessionState, error) { |
| cookie, err := r.Cookie(cookieName) |
| if err != nil { |
| log.Println("No cookie found! Starting new session.") |
| return makeSession(w, r) |
| } |
| var session SessionState |
| if err := secureCookie.Decode(cookieName, cookie.Value, &session); err != nil { |
| log.Printf("Invalid or corrupted session. Starting another: %s", err.Error()) |
| return makeSession(w, r) |
| } |
| |
| currentTime := time.Now() |
| if currentTime.Sub(session.SessionStart) > maxSessionLen { |
| log.Printf("Session starting at %s is expired. Starting another.", |
| session.SessionStart.Format(time.RFC822)) |
| return makeSession(w, r) |
| } |
| saveSession(&session, w, r) |
| return &session, nil |
| } |
| |
| // reportError serves the error page with the given message. |
| func reportError(w http.ResponseWriter, msg string, code int) { |
| errData := struct { |
| Code int |
| CodeString string |
| Message string |
| }{ |
| Code: code, |
| CodeString: http.StatusText(code), |
| Message: msg, |
| } |
| w.WriteHeader(code) |
| err := templates.ExecuteTemplate(w, "error.html", errData) |
| if err != nil { |
| log.Println("Failed to display error.html!!") |
| } |
| } |
| |
| // makeBugChomperPage builds and serves the BugChomper page. |
| func makeBugChomperPage(w http.ResponseWriter, r *http.Request) { |
| session, err := getSession(w, r) |
| if err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| issueTracker := session.IssueTracker |
| user, err := issueTracker.GetLoggedInUser() |
| if err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| log.Println("Loading bugs for " + user) |
| bugList, err := issueTracker.GetBugs(project, user) |
| if err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| bugsById := make(map[string]*issue_tracker.Issue) |
| bugsByPriority := make(map[string][]*issue_tracker.Issue) |
| for _, bug := range bugList.Items { |
| bugsById[strconv.Itoa(bug.Id)] = bug |
| var bugPriority string |
| for _, label := range bug.Labels { |
| if strings.HasPrefix(label, priorityPrefix) { |
| bugPriority = label[len(priorityPrefix):] |
| } |
| } |
| if _, ok := bugsByPriority[bugPriority]; !ok { |
| bugsByPriority[bugPriority] = make( |
| []*issue_tracker.Issue, 0) |
| } |
| bugsByPriority[bugPriority] = append( |
| bugsByPriority[bugPriority], bug) |
| } |
| bugsJson, err := json.Marshal(bugsById) |
| if err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| data := struct { |
| Title string |
| User string |
| BugsJson template.JS |
| BugsByPriority *map[string][]*issue_tracker.Issue |
| Priorities []string |
| PriorityPrefix string |
| }{ |
| Title: "BugChomper", |
| User: user, |
| BugsJson: template.JS(string(bugsJson)), |
| BugsByPriority: &bugsByPriority, |
| Priorities: issue_tracker.BugPriorities, |
| PriorityPrefix: priorityPrefix, |
| } |
| |
| if err := templates.ExecuteTemplate(w, "bug_chomper.html", data); err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| } |
| |
| // authIfNeeded determines whether the current user is logged in. If not, it |
| // redirects to a login page. Returns true if the user is redirected and false |
| // otherwise. |
| func authIfNeeded(w http.ResponseWriter, r *http.Request) bool { |
| session, err := getSession(w, r) |
| if err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return false |
| } |
| issueTracker := session.IssueTracker |
| if !issueTracker.IsAuthenticated() { |
| loginURL := issueTracker.MakeAuthRequestURL() |
| log.Println("Redirecting for login:", loginURL) |
| http.Redirect(w, r, loginURL, http.StatusTemporaryRedirect) |
| return true |
| } |
| return false |
| } |
| |
| // submitData attempts to submit data from a POST request to the IssueTracker. |
| func submitData(w http.ResponseWriter, r *http.Request) { |
| session, err := getSession(w, r) |
| if err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| issueTracker := session.IssueTracker |
| edits := r.FormValue("all_edits") |
| var editsMap map[string]*issue_tracker.Issue |
| if err := json.Unmarshal([]byte(edits), &editsMap); err != nil { |
| errMsg := "Could not parse edits from form response: " + err.Error() |
| reportError(w, errMsg, http.StatusInternalServerError) |
| return |
| } |
| data := struct { |
| Title string |
| Message string |
| BackLink string |
| }{} |
| if len(editsMap) == 0 { |
| data.Title = "No Changes Submitted" |
| data.Message = "You didn't change anything!" |
| data.BackLink = "" |
| if err := templates.ExecuteTemplate(w, "submitted.html", data); err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| return |
| } |
| errorList := make([]error, 0) |
| for issueId, newIssue := range editsMap { |
| log.Println("Editing issue " + issueId) |
| if err := issueTracker.SubmitIssueChanges(newIssue, issueComment); err != nil { |
| errorList = append(errorList, err) |
| } |
| } |
| if len(errorList) > 0 { |
| errorStrings := "" |
| for _, err := range errorList { |
| errorStrings += err.Error() + "\n" |
| } |
| errMsg := "Not all changes could be submitted: \n" + errorStrings |
| reportError(w, errMsg, http.StatusInternalServerError) |
| return |
| } |
| data.Title = "Submitted Changes" |
| data.Message = "Your changes were submitted to the issue tracker." |
| data.BackLink = "" |
| if err := templates.ExecuteTemplate(w, "submitted.html", data); err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| return |
| } |
| |
| // handleBugChomper handles HTTP requests for the bug_chomper page. |
| func handleBugChomper(w http.ResponseWriter, r *http.Request) { |
| if authIfNeeded(w, r) { |
| return |
| } |
| switch r.Method { |
| case "GET": |
| makeBugChomperPage(w, r) |
| case "POST": |
| submitData(w, r) |
| } |
| } |
| |
| // handleOAuth2Callback handles callbacks from the OAuth2 sign-in. |
| func handleOAuth2Callback(w http.ResponseWriter, r *http.Request) { |
| session, err := getSession(w, r) |
| if err != nil { |
| reportError(w, err.Error(), http.StatusInternalServerError) |
| } |
| issueTracker := session.IssueTracker |
| invalidLogin := "Invalid login credentials" |
| params, err := url.ParseQuery(r.URL.RawQuery) |
| if err != nil { |
| reportError(w, invalidLogin+": "+err.Error(), http.StatusForbidden) |
| return |
| } |
| code, ok := params["code"] |
| if !ok { |
| reportError(w, invalidLogin+": redirect did not include auth code.", |
| http.StatusForbidden) |
| return |
| } |
| log.Println("Upgrading auth token:", code[0]) |
| if err := issueTracker.UpgradeCode(code[0]); err != nil { |
| errMsg := "failed to upgrade token: " + err.Error() |
| reportError(w, errMsg, http.StatusForbidden) |
| return |
| } |
| if err := saveSession(session, w, r); err != nil { |
| reportError(w, "failed to save session: "+err.Error(), |
| http.StatusInternalServerError) |
| return |
| } |
| http.Redirect(w, r, session.OrigRequestURL, http.StatusTemporaryRedirect) |
| return |
| } |
| |
| // handleRoot is the handler function for all HTTP requests at the root level. |
| func handleRoot(w http.ResponseWriter, r *http.Request) { |
| log.Println("Fetching " + r.URL.Path) |
| if r.URL.Path == "/" || r.URL.Path == "/index.html" { |
| handleBugChomper(w, r) |
| return |
| } |
| http.NotFound(w, r) |
| } |
| |
| // Run the BugChomper server. |
| func main() { |
| var public bool |
| flag.BoolVar( |
| &public, "public", false, "Make this server publicly accessible.") |
| flag.Parse() |
| |
| http.HandleFunc("/", handleRoot) |
| http.HandleFunc(oauthCallbackPath, handleOAuth2Callback) |
| http.Handle("/res/", http.FileServer(http.Dir(curdir))) |
| port := ":" + strconv.Itoa(defaultPort) |
| log.Println("Server is running at " + scheme + "://" + localHost + port) |
| var err error |
| if public { |
| log.Println("WARNING: This server is not secure and should not be made " + |
| "publicly accessible.") |
| scheme = "https" |
| err = http.ListenAndServeTLS(port, certFile, keyFile, nil) |
| } else { |
| scheme = "http" |
| err = http.ListenAndServe(localHost+port, nil) |
| } |
| if err != nil { |
| log.Println(err.Error()) |
| } |
| } |