Adding task and routines to generate pages faster

Author: marcomilon

.gitignore

@@ -23,4 +23,5 @@ build-linux
 build-win 
 build-macos
 
-dist
+dist
+nextgen

internal/gstatic/executor.go

@@ -0,0 +1,42 @@
+package gstatic
+
+import (
+	"fmt"
+	"time"
+)
+
+type elapsedTime struct {
+	identifier string
+	start      time.Time
+	end        time.Time
+}
+
+type worker interface {
+	execute() error
+}
+
+func executor(identifier string, w worker, debug bool) {
+	var err error
+
+	if debug {
+		enlapsedTime := StartTimer(identifier)
+		err = w.execute()
+		EndTimer(enlapsedTime)
+	} else {
+		err = w.execute()
+	}
+
+	if err != nil {
+		fmt.Printf("Something went wrong: %v\n", err.Error())
+	}
+}
+
+func StartTimer(identifier string) elapsedTime {
+	return elapsedTime{identifier, time.Now(), time.Time{}}
+}
+
+func EndTimer(elapsedTime elapsedTime) {
+	elapsedTime.end = time.Now()
+	elapsed := elapsedTime.end.Sub(elapsedTime.start)
+	fmt.Printf("[%s]: %v\n", elapsedTime.identifier, elapsed)
+}

internal/gstatic/generator.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 )
 
 type generator struct {
@@ -13,6 +14,34 @@ type generator struct {
 	targetPath string
 }
 
+type task struct {
+	generator  generator
+	targetPath string
+}
+
+type copyFileWorker task
+type layoutRenderWorker task
+type simpleRenderWorker task
+
+func (copyFileWorker copyFileWorker) execute() error {
+	targetAssetname := getTargetDirname(copyFileWorker.generator.sourcePath, copyFileWorker.targetPath)
+	targetFile := filepath.Join(copyFileWorker.generator.targetPath, targetAssetname)
+
+	return copyFile(copyFileWorker.targetPath, targetFile)
+}
+
+func (layoutRenderWorker layoutRenderWorker) execute() error {
+	targetAssetname := getTargetDirname(layoutRenderWorker.generator.sourcePath, layoutRenderWorker.targetPath)
+	targetFile := filepath.Join(layoutRenderWorker.generator.targetPath, targetAssetname)
+	tpl := gstaticLayoutTpl{layoutRenderWorker.generator.layoutPath, layoutRenderWorker.targetPath, targetFile}
+	return tpl.render()
+}
+
+func (simpleRenderWorker simpleRenderWorker) execute() error {
+	tpl := gstaticSimpleTpl{simpleRenderWorker.generator.sourcePath, simpleRenderWorker.generator.targetPath}
+	return tpl.render()
+}
+
 func findLayout(sourcePath string) (string, error) {
 
 	sourceFile := filepath.Join(sourcePath, "/layout/layout.html")
@@ -31,19 +60,25 @@ func findLayout(sourcePath string) (string, error) {
 
 func Generate(srcFolder string, targetFolder string) error {
 
+	var wg sync.WaitGroup
+
 	layoutFile, err := findLayout(srcFolder)
 	if err != nil {
 		return fmt.Errorf("[%s] %v", "generate", err)
 	}
 
 	generator := generator{layoutFile, srcFolder, targetFolder}
 
-	resolver := resolver(generator)
+	resolver := resolver(generator, &wg)
+
+	err = filepath.Walk(srcFolder, resolver)
+	wg.Wait()
+
+	return err
 
-	return filepath.Walk(srcFolder, resolver)
 }
 
-func resolver(generator generator) filepath.WalkFunc {
+func resolver(generator generator, wg *sync.WaitGroup) filepath.WalkFunc {
 
 	useLayout := generator.layoutPath != ""
 
@@ -83,22 +118,36 @@ func resolver(generator generator) filepath.WalkFunc {
 
 			if useLayout {
 
-				targetAssetname := getTargetDirname(generator.sourcePath, path)
-				targetFile := filepath.Join(generator.targetPath, targetAssetname)
-				tpl := gstaticLayoutTpl{generator.layoutPath, path, targetFile}
-				return tpl.render()
+				go func() {
+					defer wg.Done()
+					wg.Add(1)
+					identifier := fmt.Sprintf("layoutRenderWorker: %s", path)
+					executor(identifier, layoutRenderWorker{generator, path}, false)
+				}()
+
+				return nil
 
 			}
 
-			tpl := gstaticSimpleTpl{generator.sourcePath, generator.targetPath}
-			return tpl.render()
+			go func() {
+				defer wg.Done()
+				wg.Add(1)
+				identifier := fmt.Sprintf("simpleRenderWorker: %s", path)
+				executor(identifier, simpleRenderWorker{generator, path}, false)
+			}()
+
+			return nil
 
 		}
 
-		targetAssetname := getTargetDirname(generator.sourcePath, path)
-		targetFile := filepath.Join(generator.targetPath, targetAssetname)
+		go func() {
+			defer wg.Done()
+			wg.Add(1)
+			identifier := fmt.Sprintf("copyFileWorker: %s", path)
+			executor(identifier, copyFileWorker{generator, path}, false)
+		}()
 
-		return copyFile(path, targetFile)
+		return nil
 
 	}
 

main.go

@@ -18,12 +18,13 @@ func main() {
 	srcFolder := argsWithoutProg[0]
 	targetFolder := argsWithoutProg[1]
 
+	elapsedTime := gstatic.StartTimer("gstatic")
 	err := gstatic.Generate(srcFolder, targetFolder)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Something went wrong: %v\n", err.Error())
 		os.Exit(1)
 	}
-
+	gstatic.EndTimer(elapsedTime)
 }
 
 func usage() {