func fileDump(lg loghttp.FuncBufUniv, fs fsi.FileSystem,
content interface{}, fNamer func() string, secondPart string) {
if fNamer != nil {
fn := fNamer() + secondPart
switch casted := content.(type) {
case *html.Node:
var b bytes.Buffer
err := html.Render(&b, casted)
lg(err)
if err != nil {
return
}
err = common.WriteFile(fs, fn, b.Bytes())
lg(err)
case []byte:
err := common.WriteFile(fs, fn, casted)
lg(err)
}
}
}
func similaritiesToFile(fs fsi.FileSystem, logdir string, frags []TextifiedTree, stage int) {
// bfrags := stringspb.IndentedDumpBytes(frags)
b := new(bytes.Buffer)
for _, v := range frags {
b.WriteString(fmt.Sprintf("%v %2v ", v.SourceID, v.Lvl))
b.WriteString(fmt.Sprintf("%-8v ", v.Outline))
b.Write(v.Text)
b.WriteString("\n")
for _, v1 := range v.Similars {
b.WriteString(fmt.Sprintf("%v %2v ", v1.SourceID, v1.Lvl))
b.WriteString(fmt.Sprintf("%-8v ", string(v1.Outline)))
b.WriteString(spf("%2v ", v1.AbsLevenshtein))
b.WriteString(spf("%-5.2v ", v1.RelLevenshtein))
b.Write(v1.Text)
b.WriteByte(10)
}
b.WriteByte(10)
}
common.WriteFile(fs, spf("%v/outp_fragments_st%v.txt", logdir, stage), b.Bytes())
}
func receiveUpload(w http.ResponseWriter, r *http.Request, m map[string]interface{}) {
lg, _ := loghttp.Logger(w, r)
c := appengine.NewContext(r)
// parsing multipart before anything else
err := r.ParseMultipartForm(1024 * 1024 * 2)
if err != nil {
lg("Multipart parsing failed: %v", err)
return
}
wpf(w, tplx.ExecTplHelper(tplx.Head, map[string]interface{}{"HtmlTitle": "Receive an Upload"}))
defer wpf(w, tplx.Foot)
wpf(w, "<pre>")
defer wpf(w, "</pre>")
fields := []string{"getparam1", "mountname", "description"}
for _, v := range fields {
lg("%12v => %q", v, r.FormValue(v))
}
mountPoint := dsfs.MountPointLast()
if len(r.FormValue("mountname")) > 0 {
mountPoint = r.FormValue("mountname")
}
lg("mount point is %v", mountPoint)
fs1 := dsfs.New(
dsfs.MountName(mountPoint),
dsfs.AeContext(c),
)
// As closure, since we cannot define dsfs.dsFileSys as parameter
funcSave := func(argName string, data []byte) (error, *bytes.Buffer) {
b1 := new(bytes.Buffer)
fs1 := dsfs.New(
dsfs.MountName(mountPoint),
dsfs.AeContext(c),
)
dir, bname := fs1.SplitX(argName)
err := fs1.MkdirAll(dir, 0777)
wpf(b1, "mkdir %v - %v\n", dir, err)
if err != nil {
return err, b1
}
err = fs1.WriteFile(path.Join(dir, bname), data, 0777)
wpf(b1, "saved file content to %v - %v\n", argName, err)
return err, b1
}
ff := "filefield"
file, handler, err := r.FormFile(ff)
if err != nil {
lg("error calling FormFile from %q => %v", ff, err)
return
}
if handler == nil {
lg("no multipart file %q", ff)
} else {
lg("extracted file %v", handler.Filename)
data, err := ioutil.ReadAll(file)
if err != nil {
lg("ReadAll on uploaded file failed: %v", err)
return
}
defer file.Close()
lg("extracted file content; %v bytes", len(data))
newFilename := docRootDataStore + handler.Filename
ext := path.Ext(newFilename)
if ext == ".zip" {
lg("found zip - treat as dir-tree %q", newFilename)
r, err := zip.NewReader(file, int64(len(data)))
if err != nil {
lg("open as zip failed: %v", err)
return
}
for _, f := range r.File {
newFilename = docRootDataStore + f.Name
dir, bname := fs1.SplitX(newFilename)
if f.FileInfo().IsDir() {
lg("\t dir %s", newFilename)
err := fs1.MkdirAll(path.Join(dir, bname), 0777)
if err != nil {
lg("MkdirAll %v failed: %v", newFilename, err)
return
}
} else {
lg("\t file %s", newFilename)
rc, err := f.Open()
if err != nil {
return
}
defer func(rc io.ReadCloser) {
if err := rc.Close(); err != nil {
panic(err)
}
}(rc)
bts := new(bytes.Buffer)
size, err := io.Copy(bts, rc)
if err != nil {
lg("Could not copy from zipped file %v: %v", newFilename, err)
return
}
err = common.WriteFile(fsi.FileSystem(fs1), path.Join(dir, bname), bts.Bytes())
// err = fs1.WriteFile(path.Join(dir, bname), bts.Bytes(), 0777)
if err != nil {
lg("WriteFile of zipped file %v failed: %v", newFilename, err)
return
}
lg("\t saved %v - %v Bytes", newFilename, size)
}
}
} else {
err, b2 := funcSave(newFilename, data)
lg("%s", b2)
if err != nil {
return
}
}
errMc := memcache.Flush(appengine.NewContext(r))
if errMc != nil {
lg("Error flushing memache: %v", errMc)
return
}
lg("--------------------\n")
}
}