Provided facility for template set bundle to be sent in serverless environments, where the ability to write to disk is not available.

serversidehandlers.go

+// +build !clientonly
+
+package isokit
+
+import (
+	"bytes"
+	"encoding/gob"
+	"log"
+	"net/http"
+)
+
+func TemplateBundleHandler(ts *TemplateSet) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var templateContentItemsBuffer bytes.Buffer
+		enc := gob.NewEncoder(&templateContentItemsBuffer)
+		m := ts.Bundle().Items()
+		err := enc.Encode(&m)
+		if err != nil {
+			log.Print("encoding err: ", err)
+		}
+		w.Header().Set("Content-Type", "application/octet-stream")
+		w.Write(templateContentItemsBuffer.Bytes())
+	})
+}

template.go

 	TemplateFileExtension        = ".tmpl"
 	TemplateFilesPath            = "./templates"
 	UseStaticTemplateBundleFile  = false
+	UseTemplateBundleFromBuffer  = false
 	StaticTemplateBundleFilePath = ""
 	ShouldBundleStaticAssets     = true
 )

templateset.go

 	Funcs             template.FuncMap
 	bundle            *TemplateBundle
 	TemplateFilesPath string
+	bundleBuffer      bytes.Buffer
 }
 
 func NewTemplateSet() *TemplateSet {
 
 }
 
+func (t *TemplateSet) PersistTemplateBundleToTemplateSetBuffer() error {
+
+	dirPath := filepath.Dir(StaticTemplateBundleFilePath)
+	if _, err := os.Stat(dirPath); os.IsNotExist(err) {
+
+		return errors.New("The specified directory for the StaticTemplateBundleFilePath, " + dirPath + ", does not exist!")
+
+	} else {
+
+		enc := gob.NewEncoder(&t.bundleBuffer)
+		m := t.bundle.Items()
+		err := enc.Encode(&m)
+		if err != nil {
+			return err
+		} else {
+			return nil
+		}
+	}
+
+}
+
 func (t *TemplateSet) RestoreTemplateBundleFromDisk() error {
 
 	if _, err := os.Stat(StaticTemplateBundleFilePath); os.IsNotExist(err) {
 	}
 }
 
+func (t *TemplateSet) RestoreTemplateBundleFromTemplateSetBuffer() error {
+
+	if _, err := os.Stat(StaticTemplateBundleFilePath); os.IsNotExist(err) {
+		return errors.New("The StaticTemplateBundleFilePath, " + StaticTemplateBundleFilePath + ", does not exist")
+	} else {
+
+		data := t.bundleBuffer.Bytes()
+		if err != nil {
+			return err
+		}
+
+		var templateBundleMap map[string]string
+		var templateBundleMapBuffer bytes.Buffer
+		dec := gob.NewDecoder(&templateBundleMapBuffer)
+		templateBundleMapBuffer = *bytes.NewBuffer(data)
+		err = dec.Decode(&templateBundleMap)
+
+		if err != nil {
+			return err
+		}
+
+		t.ImportTemplatesFromMap(templateBundleMap)
+		bundle := &TemplateBundle{items: templateBundleMap}
+		t.bundle = bundle
+
+		return nil
+	}
+}
+
 func (t *TemplateSet) GatherTemplates() {
 
 	if UseStaticTemplateBundleFile == true {
 		}
 	}
 
+	if UseTemplateBundleFromBuffer == true && UseStaticTemplateBundleFile == false {
+		err := t.RestoreTemplateBundleFromTemplateSetBuffer()
+		if err != nil {
+			log.Println("Didn't find a template bundle from the template set buffer, will generate a new template bundle.")
+		} else {
+			return
+		}
+	}
+
 	bundle := NewTemplateBundle()
 
 	templatesPath := t.TemplateFilesPath
 		}
 	}
 
+	if UseTemplateBundleFromBuffer == true && StaticTemplateBundleFilePath == "" {
+		err := t.PersistTemplateBundleToTemplateSetBuffer()
+		if err != nil {
+			log.Println("Failed to persist the template bundle to disk, in GatherTemplates, with error: ", err)
+		}
+	}
+
 }
 
 func (t *TemplateSet) GatherCogTemplates(cogTemplatePath string, prefixName string, templateFileExtension string) {