| // Copyright (C) 2015 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package main |
| |
| import ( |
| "archive/zip" |
| "bufio" |
| "bytes" |
| "compress/gzip" |
| "encoding/json" |
| "errors" |
| "flag" |
| "io" |
| "io/ioutil" |
| "log" |
| "net" |
| "net/http" |
| "net/url" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "regexp" |
| "strings" |
| "sync" |
| "time" |
| |
| "golang.org/x/tools/godoc/vfs/httpfs" |
| "golang.org/x/tools/godoc/vfs/zipfs" |
| ) |
| |
| var ( |
| plugins = flag.String("plugins", "", "comma seperated plugin paths to serve") |
| port = flag.String("port", "localhost:8081", "address to serve HTTP requests on") |
| host = flag.String("host", "gerrit-review.googlesource.com", "Host to proxy requests to") |
| scheme = flag.String("scheme", "https", "URL scheme") |
| cdnPattern = regexp.MustCompile("https://cdn.googlesource.com/polygerrit_ui/[0-9.]*") |
| ) |
| |
| func main() { |
| flag.Parse() |
| |
| fontsArchive, err := openDataArchive("fonts.zip") |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| workspace := os.Getenv("BUILD_WORKSPACE_DIRECTORY") |
| if err := os.Chdir(filepath.Join(workspace, "polygerrit-ui")); err != nil { |
| log.Fatal(err) |
| } |
| |
| compiledSrcPath := filepath.Join(workspace, "./.ts-out/server-go") |
| |
| tsInstance := newTypescriptInstance( |
| filepath.Join(workspace, "./node_modules/.bin/tsc"), |
| filepath.Join(workspace, "./polygerrit-ui/app/tsconfig.json"), |
| compiledSrcPath, |
| ) |
| |
| if err := tsInstance.StartWatch(); err != nil { |
| log.Fatal(err) |
| } |
| |
| dirListingMux := http.NewServeMux() |
| dirListingMux.Handle("/styles/", http.StripPrefix("/styles/", http.FileServer(http.Dir("app/styles")))) |
| dirListingMux.Handle("/samples/", http.StripPrefix("/samples/", http.FileServer(http.Dir("app/samples")))) |
| dirListingMux.Handle("/elements/", http.StripPrefix("/elements/", http.FileServer(http.Dir("app/elements")))) |
| dirListingMux.Handle("/behaviors/", http.StripPrefix("/behaviors/", http.FileServer(http.Dir("app/behaviors")))) |
| |
| http.HandleFunc("/", |
| func(w http.ResponseWriter, req *http.Request) { |
| // If typescript compiler hasn't finished yet, wait for it |
| tsInstance.WaitForCompilationComplete() |
| handleSrcRequest(compiledSrcPath, dirListingMux, w, req) |
| }) |
| |
| http.Handle("/fonts/", |
| addDevHeadersMiddleware(http.FileServer(httpfs.New(zipfs.New(fontsArchive, "fonts"))))) |
| |
| http.HandleFunc("/index.html", handleIndex) |
| http.HandleFunc("/changes/", handleProxy) |
| http.HandleFunc("/accounts/", handleProxy) |
| http.HandleFunc("/config/", handleProxy) |
| http.HandleFunc("/projects/", handleProxy) |
| http.HandleFunc("/static/", handleProxy) |
| http.HandleFunc("/accounts/self/detail", handleAccountDetail) |
| |
| if len(*plugins) > 0 { |
| http.Handle("/plugins/", http.StripPrefix("/plugins/", |
| http.FileServer(http.Dir("../plugins")))) |
| log.Println("Local plugins from", "../plugins") |
| } else { |
| http.HandleFunc("/plugins/", handleProxy) |
| // Serve local plugins from `plugins_` |
| http.Handle("/plugins_/", http.StripPrefix("/plugins_/", |
| http.FileServer(http.Dir("../plugins")))) |
| } |
| log.Println("Serving on port", *port) |
| log.Fatal(http.ListenAndServe(*port, &server{})) |
| } |
| |
| func addDevHeadersMiddleware(h http.Handler) http.Handler { |
| return http.HandlerFunc(func(writer http.ResponseWriter, req *http.Request) { |
| addDevHeaders(writer) |
| h.ServeHTTP(writer, req) |
| }) |
| } |
| |
| func addDevHeaders(writer http.ResponseWriter) { |
| writer.Header().Set("Access-Control-Allow-Origin", "*") |
| writer.Header().Set("Access-Control-Allow-Headers", "cache-control,x-test-origin") |
| writer.Header().Set("Cache-Control", "public, max-age=10, must-revalidate") |
| } |
| |
| func handleSrcRequest(compiledSrcPath string, dirListingMux *http.ServeMux, writer http.ResponseWriter, originalRequest *http.Request) { |
| parsedUrl, err := url.Parse(originalRequest.RequestURI) |
| if err != nil { |
| writer.WriteHeader(500) |
| return |
| } |
| if parsedUrl.Path != "/" && strings.HasSuffix(parsedUrl.Path, "/") { |
| dirListingMux.ServeHTTP(writer, originalRequest) |
| return |
| } |
| |
| normalizedContentPath := parsedUrl.Path |
| |
| if !strings.HasPrefix(normalizedContentPath, "/") { |
| normalizedContentPath = "/" + normalizedContentPath |
| } |
| |
| isJsFile := strings.HasSuffix(normalizedContentPath, ".js") || strings.HasSuffix(normalizedContentPath, ".mjs") |
| isTsFile := strings.HasSuffix(normalizedContentPath, ".ts") |
| |
| // Source map in a compiled js file point to a file inside /app/... directory |
| // Browser tries to load original file from the directory when debugger is |
| // activated. In this case we return original content without any processing |
| isOriginalFileRequest := strings.HasPrefix(normalizedContentPath, "/polygerrit-ui/app/") && (isTsFile || isJsFile) |
| |
| data, err := getContent(compiledSrcPath, normalizedContentPath, isOriginalFileRequest) |
| if err != nil { |
| if !isOriginalFileRequest { |
| data, err = getContent(compiledSrcPath, normalizedContentPath+".js", false) |
| } |
| if err != nil { |
| writer.WriteHeader(404) |
| return |
| } |
| isJsFile = true |
| } |
| if isOriginalFileRequest { |
| // Explicitly set text/html Content-Type. If live code tries |
| // to import javascript from the /app/ folder accidentally, browser fails |
| // with the import error, so we can catch this problem easily. |
| writer.Header().Set("Content-Type", "text/html") |
| } else if isJsFile { |
| // import ... from '@polymer/decorators' |
| // must be transformed into |
| // import ... from '@polymer/decorators/lib/decorators.js' |
| // The correct way to do it is to use value of the "main" property |
| // from the @polymer/decorators/package.json. However, parsing package.json |
| // is overcomplicated right now, hard-code exact path here. |
| moduleImportRegexp := regexp.MustCompile("(?m)^(import.*)'@polymer/decorators';$") |
| data = moduleImportRegexp.ReplaceAll(data, []byte("$1 '@polymer/decorators/lib/decorators.js';")) |
| |
| // The following code updates import statements. |
| // 1. if an in imported file has .js or .mjs extension, the code keeps |
| // the file extension unchanged. Otherwise, it adds .js extension |
| // 2. For module imports it adds '/node_modules/' prefix. |
| // Examples: |
| // '@polymer/polymer.js' -> '/node_modules/@polymer/polymer.js' |
| // 'page/page.mjs' -> '/node_modules/page.mjs' |
| // '@polymer/iron-icon' -> '/node_modules/@polymer/iron-icon.js' |
| // './element/file' -> './element/file.js' |
| moduleImportRegexp = regexp.MustCompile(`(import[^'";]*|export[^'";]*from ?)['"]([^;\s]*?)(\.(m?)js)?['"];`) |
| data = moduleImportRegexp.ReplaceAll(data, []byte("$1'$2.${4}js';")) |
| |
| moduleImportRegexp = regexp.MustCompile(`(import[^'";]*|export[^'";]*from ?)['"]([^/.;\s][^;\s]*)['"];`) |
| data = moduleImportRegexp.ReplaceAll(data, []byte("$1'/node_modules/$2';")) |
| |
| // The es module version of rxjs can be found in the _esm2015/ directory. |
| moduleImportRegexp = regexp.MustCompile("(?m)^((import|export).*'/node_modules/rxjs)(.*).js(';)$") |
| data = moduleImportRegexp.ReplaceAll(data, []byte("$1/_esm2015$3/index.js$4")) |
| |
| // The es module version of tslib.js can be found in tslib.es6.js. |
| moduleImportRegexp = regexp.MustCompile("(?m)^((import|export).*'/node_modules/)tslib.js';$") |
| data = moduleImportRegexp.ReplaceAll(data, []byte("${1}tslib/tslib.es6.js';")) |
| |
| // 'lit.js' has to be resolved as 'lit/index.js'. |
| moduleImportRegexp = regexp.MustCompile("(?m)^((import|export).*'/node_modules/)lit.js';$") |
| data = moduleImportRegexp.ReplaceAll(data, []byte("${1}lit/index.js';")) |
| // Some lit imports 'a.js' have to be resolved as 'a/a.js'. |
| moduleImportRegexp = regexp.MustCompile(`((import|export)[^'";]*'/node_modules/(@lit/)?)(lit-element|lit-html|reactive-element).js';`) |
| data = moduleImportRegexp.ReplaceAll(data, []byte("${1}${4}/${4}.js';")) |
| |
| // 'immer' imports and exports have to be resolved to 'immer/dist/immer.esm.js'. |
| moduleImportRegexp = regexp.MustCompile("(?m)^((import|export).*'/node_modules/)immer.js';$") |
| data = moduleImportRegexp.ReplaceAll(data, []byte("${1}/immer/dist/immer.esm.js';")) |
| |
| // 'webvital' imports |
| moduleImportRegexp = regexp.MustCompile("(?m)^((import|export).*'/node_modules/)web-vitals.js';$") |
| data = moduleImportRegexp.ReplaceAll(data, []byte("${1}/web-vitals/dist/web-vitals.js';")) |
| |
| if strings.HasSuffix(normalizedContentPath, "/node_modules/page/page.js") { |
| // Can't import page.js directly, because this is undefined. |
| // Replace it with window |
| // The same replace exists in karma.conf.js |
| // Rollup makes this replacement automatically |
| pageJsRegexp := regexp.MustCompile(`(?m)^}\(this, \(function \(\) { 'use strict';$`) |
| newData := pageJsRegexp.ReplaceAll(data, []byte("}(window, (function () { 'use strict';")) |
| if len(newData) == len(data) { |
| log.Fatal("The page.js was updated. Please update regexp/replace accordingly") |
| } |
| data = newData |
| } |
| |
| writer.Header().Set("Content-Type", "application/javascript") |
| } else if strings.HasSuffix(normalizedContentPath, ".css") { |
| writer.Header().Set("Content-Type", "text/css") |
| } else if strings.HasSuffix(normalizedContentPath, "_test.html") { |
| moduleImportRegexp := regexp.MustCompile("(?m)^(import.*)'([^/.].*)';$") |
| data = moduleImportRegexp.ReplaceAll(data, []byte("$1 '/node_modules/$2';")) |
| writer.Header().Set("Content-Type", "text/html") |
| } else if strings.HasSuffix(normalizedContentPath, ".html") { |
| writer.Header().Set("Content-Type", "text/html") |
| } |
| writer.WriteHeader(200) |
| addDevHeaders(writer) |
| writer.Write(data) |
| } |
| |
| func getContent(compiledSrcPath string, normalizedContentPath string, isOriginalFileRequest bool) ([]byte, error) { |
| // normalizedContentPath must always starts with '/' |
| |
| if isOriginalFileRequest { |
| data, err := ioutil.ReadFile(normalizedContentPath[len("/polygerrit-ui/"):]) |
| if err != nil { |
| return nil, errors.New("File not found") |
| } |
| return data, nil |
| } |
| |
| // gerrit loads gr-app.js as an ordinary script, without type="module" attribute. |
| // If server.go serves this file as is, browser shows the error: |
| // Uncaught SyntaxError: Cannot use import statement outside a module |
| // |
| // To load non-bundled gr-app.js as a module, we "virtually" renames original |
| // gr-app.js to gr-app.mjs and load it with dynamic import. |
| // |
| // Another option is to patch rewriteHostPage function and add type="module" attribute |
| // to <script src=".../elements/gr-app.js"> tag, but this solution is incompatible |
| // with --dev-cdn options. If you run local gerrit instance with --dev-cdn parameter, |
| // the server.go is used as cdn and it doesn't handle host page (i.e. rewriteHostPage |
| // method is not called). |
| if normalizedContentPath == "/elements/gr-app.js" { |
| return []byte("import('./gr-app.mjs')"), nil |
| } |
| |
| if normalizedContentPath == "/elements/gr-app.mjs" { |
| normalizedContentPath = "/elements/gr-app.js" |
| } |
| |
| pathsToTry := []string{compiledSrcPath + normalizedContentPath, "app" + normalizedContentPath} |
| bowerComponentsSuffix := "/bower_components/" |
| nodeModulesPrefix := "/node_modules/" |
| testComponentsPrefix := "/components/" |
| |
| if strings.HasPrefix(normalizedContentPath, testComponentsPrefix) { |
| pathsToTry = append(pathsToTry, "node_modules/wct-browser-legacy/node_modules/"+normalizedContentPath[len(testComponentsPrefix):]) |
| pathsToTry = append(pathsToTry, "node_modules/"+normalizedContentPath[len(testComponentsPrefix):]) |
| } |
| |
| if strings.HasPrefix(normalizedContentPath, bowerComponentsSuffix) { |
| pathsToTry = append(pathsToTry, "node_modules/@webcomponents/"+normalizedContentPath[len(bowerComponentsSuffix):]) |
| } |
| |
| if strings.HasPrefix(normalizedContentPath, nodeModulesPrefix) { |
| pathsToTry = append(pathsToTry, "node_modules/"+normalizedContentPath[len(nodeModulesPrefix):]) |
| } |
| |
| for _, path := range pathsToTry { |
| data, err := ioutil.ReadFile(path) |
| if err == nil { |
| return data, nil |
| } |
| } |
| |
| return nil, errors.New("File not found") |
| } |
| |
| func openDataArchive(path string) (*zip.ReadCloser, error) { |
| absBinPath, err := resourceBasePath() |
| if err != nil { |
| return nil, err |
| } |
| return zip.OpenReader(absBinPath + ".runfiles/gerrit/polygerrit-ui/" + path) |
| } |
| |
| func resourceBasePath() (string, error) { |
| return filepath.Abs(os.Args[0]) |
| } |
| |
| func handleIndex(writer http.ResponseWriter, originalRequest *http.Request) { |
| fakeRequest := &http.Request{ |
| URL: &url.URL{ |
| Path: "/", |
| RawQuery: originalRequest.URL.RawQuery, |
| }, |
| } |
| handleProxy(writer, fakeRequest) |
| } |
| |
| func handleProxy(writer http.ResponseWriter, originalRequest *http.Request) { |
| patchedRequest := &http.Request{ |
| Method: "GET", |
| URL: &url.URL{ |
| Scheme: *scheme, |
| Host: *host, |
| Opaque: originalRequest.URL.EscapedPath(), |
| RawQuery: originalRequest.URL.RawQuery, |
| }, |
| } |
| response, err := http.DefaultClient.Do(patchedRequest) |
| if err != nil { |
| http.Error(writer, err.Error(), http.StatusInternalServerError) |
| return |
| } |
| defer response.Body.Close() |
| for name, values := range response.Header { |
| for _, value := range values { |
| if name != "Content-Length" { |
| writer.Header().Add(name, value) |
| } |
| } |
| } |
| writer.WriteHeader(response.StatusCode) |
| if _, err := io.Copy(writer, patchResponse(originalRequest, response)); err != nil { |
| log.Println("Error copying response to ResponseWriter:", err) |
| return |
| } |
| } |
| |
| func getJsonPropByPath(json map[string]interface{}, path []string) interface{} { |
| prop, path := path[0], path[1:] |
| if json[prop] == nil { |
| return nil |
| } |
| switch json[prop].(type) { |
| case map[string]interface{}: // map |
| return getJsonPropByPath(json[prop].(map[string]interface{}), path) |
| case []interface{}: // array |
| return json[prop].([]interface{}) |
| default: |
| return json[prop].(interface{}) |
| } |
| } |
| |
| func setJsonPropByPath(json map[string]interface{}, path []string, value interface{}) { |
| prop, path := path[0], path[1:] |
| if json[prop] == nil { |
| return // path not found |
| } |
| if len(path) > 0 { |
| setJsonPropByPath(json[prop].(map[string]interface{}), path, value) |
| } else { |
| json[prop] = value |
| } |
| } |
| |
| func patchResponse(req *http.Request, res *http.Response) io.Reader { |
| switch req.URL.EscapedPath() { |
| case "/": |
| return rewriteHostPage(res.Body) |
| case "/config/server/info": |
| return injectLocalPlugins(res.Body) |
| default: |
| return res.Body |
| } |
| } |
| |
| func rewriteHostPage(reader io.Reader) io.Reader { |
| buf := new(bytes.Buffer) |
| buf.ReadFrom(reader) |
| original := buf.String() |
| |
| // Simply remove all CDN references, so files are loaded from the local file system or the proxy |
| // server instead. |
| replaced := cdnPattern.ReplaceAllString(original, "") |
| |
| // Modify window.INITIAL_DATA so that it has the same effect as injectLocalPlugins. To achieve |
| // this let's add JavaScript lines at the end of the <script>...</script> snippet that also |
| // contains window.INITIAL_DATA=... |
| // Here we rely on the fact that the <script> snippet that we want to append to is the first one. |
| if len(*plugins) > 0 { |
| insertionPoint := strings.Index(replaced, "</script>") |
| builder := new(strings.Builder) |
| builder.WriteString( |
| "window.INITIAL_DATA['/config/server/info'].plugin.js_resource_paths = []; ") |
| for _, p := range strings.Split(*plugins, ",") { |
| if filepath.Ext(p) == ".js" { |
| builder.WriteString( |
| "window.INITIAL_DATA['/config/server/info'].plugin.js_resource_paths.push('" + p + "'); ") |
| } |
| } |
| replaced = replaced[:insertionPoint] + builder.String() + replaced[insertionPoint:] |
| } |
| |
| return strings.NewReader(replaced) |
| } |
| |
| func injectLocalPlugins(reader io.Reader) io.Reader { |
| if len(*plugins) == 0 { |
| return reader |
| } |
| // Skip escape prefix |
| io.CopyN(ioutil.Discard, reader, 5) |
| dec := json.NewDecoder(reader) |
| |
| var response map[string]interface{} |
| err := dec.Decode(&response) |
| if err != nil { |
| log.Fatal(err) |
| } |
| |
| // Configuration path in the JSON server response |
| jsPluginsPath := []string{"plugin", "js_resource_paths"} |
| jsResources := getJsonPropByPath(response, jsPluginsPath).([]interface{}) |
| |
| for _, p := range strings.Split(*plugins, ",") { |
| if filepath.Ext(p) == ".js" { |
| jsResources = append(jsResources, p) |
| } |
| } |
| |
| setJsonPropByPath(response, jsPluginsPath, jsResources) |
| |
| reader, writer := io.Pipe() |
| go func() { |
| defer writer.Close() |
| io.WriteString(writer, ")]}'") // Write escape prefix |
| err := json.NewEncoder(writer).Encode(&response) |
| if err != nil { |
| log.Fatal(err) |
| } |
| }() |
| return reader |
| } |
| |
| func handleAccountDetail(w http.ResponseWriter, r *http.Request) { |
| http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden) |
| } |
| |
| type gzipResponseWriter struct { |
| io.WriteCloser |
| http.ResponseWriter |
| } |
| |
| func newGzipResponseWriter(w http.ResponseWriter) *gzipResponseWriter { |
| gz := gzip.NewWriter(w) |
| return &gzipResponseWriter{WriteCloser: gz, ResponseWriter: w} |
| } |
| |
| func (w gzipResponseWriter) Write(b []byte) (int, error) { |
| return w.WriteCloser.Write(b) |
| } |
| |
| func (w gzipResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) { |
| h, ok := w.ResponseWriter.(http.Hijacker) |
| if !ok { |
| return nil, nil, errors.New("gzipResponseWriter: ResponseWriter does not satisfy http.Hijacker interface") |
| } |
| return h.Hijack() |
| } |
| |
| type server struct{} |
| |
| // Any path prefixes that should resolve to index.html. |
| var ( |
| fePaths = []string{"/q/", "/c/", "/id/", "/p/", "/x/", "/dashboard/", "/admin/", "/settings/"} |
| issueNumRE = regexp.MustCompile(`^\/\d+\/?$`) |
| ) |
| |
| func (_ *server) ServeHTTP(w http.ResponseWriter, r *http.Request) { |
| log.Printf("%s %s %s %s\n", r.Proto, r.Method, r.RemoteAddr, r.URL) |
| for _, prefix := range fePaths { |
| if strings.HasPrefix(r.URL.Path, prefix) || r.URL.Path == "/" { |
| r.URL.Path = "/index.html" |
| log.Println("Redirecting to /index.html") |
| break |
| } else if match := issueNumRE.Find([]byte(r.URL.Path)); match != nil { |
| r.URL.Path = "/index.html" |
| log.Println("Redirecting to /index.html") |
| break |
| } |
| } |
| if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") { |
| http.DefaultServeMux.ServeHTTP(w, r) |
| return |
| } |
| w.Header().Set("Content-Encoding", "gzip") |
| addDevHeaders(w) |
| gzw := newGzipResponseWriter(w) |
| defer gzw.Close() |
| http.DefaultServeMux.ServeHTTP(gzw, r) |
| } |
| |
| // Typescript compiler support |
| // The code below runs typescript compiler in watch mode and redirect |
| // all output from the compiler to the standard logger with the prefix "TSC -" |
| // Additionally, the code analyzes messages produced by the typescript compiler |
| // and allows to wait until compilation is finished. |
| var ( |
| tsStartingCompilation = "- Starting compilation in watch mode..." |
| tsFileChangeDetectedMsg = "- File change detected. Starting incremental compilation..." |
| // If there is only one error typescript outputs: |
| // Found 1 error |
| // In all other cases it outputs |
| // Found X errors |
| tsStartWatchingMsg = regexp.MustCompile(`^.* - Found \d+ error(s)?\. Watching for file changes\.$`) |
| waitForNextChangeInterval = 1 * time.Second |
| ) |
| |
| // typescriptLogWriter implements Writer interface and receives output |
| // (stdout and stderr) from the typescript compiler. It reads incoming |
| // data line-by-line, analyzes each line and updates compilationDoneWaiter |
| // according to the current compiler state. Additionally, the |
| // typescriptLogWriter passes all incoming lines to the underlying logger. |
| type typescriptLogWriter struct { |
| // unfinishedLine stores the portion of line which was partially received |
| // (i.e. all text received after the last EOL (\n) mark. |
| unfinishedLine string |
| // logger is used to pass-through all received strings |
| logger *log.Logger |
| // when WaitGroup counter is 0 the compilation is complete |
| compilationDoneWaiter *sync.WaitGroup |
| } |
| |
| func newTypescriptLogWriter(compilationCompleteWaiter *sync.WaitGroup) *typescriptLogWriter { |
| return &typescriptLogWriter{ |
| logger: log.New(log.Writer(), "TSC - ", log.Flags()), |
| compilationDoneWaiter: compilationCompleteWaiter, |
| } |
| } |
| |
| func (lw typescriptLogWriter) Write(p []byte) (n int, err error) { |
| // The input p can contain several lines and/or the partial line |
| // Code splits the input by EOL marker (\n) and stores the unfinished line |
| // for the next call to Write. |
| partialText := lw.unfinishedLine + string(p) |
| lines := strings.Split(partialText, "\n") |
| fullLines := lines |
| if strings.HasSuffix(partialText, "\n") { |
| lw.unfinishedLine = "" |
| } else { |
| fullLines = lines[:len(lines)-1] |
| lw.unfinishedLine = lines[len(lines)-1] |
| } |
| for _, fullLine := range fullLines { |
| text := strings.TrimSpace(fullLine) |
| if text == "" { |
| continue |
| } |
| if strings.HasSuffix(text, tsFileChangeDetectedMsg) || |
| strings.HasSuffix(text, tsStartingCompilation) { |
| lw.compilationDoneWaiter.Add(1) |
| } |
| if tsStartWatchingMsg.MatchString(text) { |
| // A source code can be changed while previous compiler run is in progress. |
| // In this case typescript reruns compilation again almost immediately |
| // after the previous run finishes. To detect this situation, we are |
| // waiting waitForNextChangeInterval before decreasing the counter. |
| // If another compiler run is started in this interval, we will wait |
| // again until it finishes. |
| go func() { |
| time.Sleep(waitForNextChangeInterval) |
| lw.compilationDoneWaiter.Done() |
| }() |
| } |
| lw.logger.Print(text) |
| } |
| return len(p), nil |
| } |
| |
| type typescriptInstance struct { |
| cmd *exec.Cmd |
| compilationCompleteWaiter *sync.WaitGroup |
| } |
| |
| func newTypescriptInstance(tscBinaryPath string, projectPath string, outdir string) *typescriptInstance { |
| cmd := exec.Command(tscBinaryPath, |
| "--watch", |
| "--preserveWatchOutput", |
| "--project", |
| projectPath, |
| "--outDir", |
| outdir) |
| |
| compilationCompleteWaiter := &sync.WaitGroup{} |
| logWriter := newTypescriptLogWriter(compilationCompleteWaiter) |
| // Note 1: (from https://golang.org/pkg/os/exec/#Cmd) |
| // If Stdout and Stderr are the same writer, and have a type that can |
| // be compared with ==, at most one goroutine at a time will call Write. |
| // |
| // Note 2: The typescript compiler reports all compilation errors to |
| // stdout by design (see https://github.com/microsoft/TypeScript/issues/615) |
| // It writes to stderr only when something unexpected happens (like internal |
| // exceptions). To print such errors in the same way as standard typescript |
| // error, the same logWriter is used both for Stdout and Stderr. |
| // |
| // If Stderr arrives in the middle of ordinary typescript output (i.e. |
| // something unexpected happens), the server.go can stop respond to http |
| // requests. However, this is not a problem for us: typescript compiler and |
| // server.go must be restarted anyway. |
| cmd.Stdout = logWriter |
| cmd.Stderr = logWriter |
| |
| return &typescriptInstance{ |
| cmd: cmd, |
| compilationCompleteWaiter: compilationCompleteWaiter, |
| } |
| } |
| |
| func (ts *typescriptInstance) StartWatch() error { |
| err := ts.cmd.Start() |
| if err != nil { |
| return err |
| } |
| go func() { |
| ts.cmd.Wait() |
| log.Fatal("Typescript exits unexpected") |
| }() |
| |
| return nil |
| } |
| |
| func (ts *typescriptInstance) WaitForCompilationComplete() { |
| ts.compilationCompleteWaiter.Wait() |
| } |