func render_import(session *http.Session) {
html, _ := session.RenderTemplate("import.html")
session.Stash["Page"] = "Import"
session.Stash["ImportAvailable"] = config.ImportAvailable
session.Stash["Content"] = template.HTML(html)
session.Render("layout.html")
}
func settings(session *http.Session) {
session.Stash["Title"] = "SmartPAN Settings"
html, _ := session.RenderTemplate("settings.html")
session.Stash["Page"] = "Settings"
session.Stash["Content"] = template.HTML(html)
session.Render("layout.html")
}
func help(session *http.Session) {
session.Stash["Title"] = "SmartPAN Help"
html, _ := session.RenderTemplate("help.html")
session.Stash["Page"] = "Help"
session.Stash["Content"] = template.HTML(html)
session.Render("layout.html")
}
func importstream(session *http.Session) {
job := imports[session.Stash["jobid"].(string)]
session.Stash["Job"] = job
c := session.Response.Chunked()
session.Response.Headers.Add("Content-Type", "text/plain")
raw := false
if _, ok := session.Request.Form()["raw"]; ok {
raw = true
}
if !raw {
header, _ := session.RenderTemplate("layout_streamstart.html")
c <- []byte(header)
}
for _, s := range job.History {
if !raw {
c <- []byte(s + "<br />\n")
} else {
c <- []byte(s + "\n")
}
}
var wg sync.WaitGroup
if !job.Complete {
wg.Add(1)
job.Watchers = append(job.Watchers, func(m string) {
if m == ":DONE" {
wg.Done()
return
}
if !raw {
c <- []byte(m + "<br />\n")
} else {
c <- []byte(m + "\n")
}
})
}
wg.Wait()
if !raw {
footer, _ := session.RenderTemplate("layout_streamend.html")
c <- []byte(footer)
}
c <- make([]byte, 0)
}
func import2(session *http.Session) {
if !config.ImportAvailable {
session.Render("error.html")
session.Stash["GoPANError"] = "Import is currently unavailable"
return
}
session.Stash["Page"] = "Import"
session.Stash["Title"] = "Import job " + session.Stash["jobid"].(string)
job := imports[session.Stash["jobid"].(string)]
session.Stash["Job"] = job
html, _ := session.RenderTemplate("import2.html")
session.Stash["Content"] = template.HTML(html)
session.Render("layout.html")
}
func delete_file(session *http.Session) {
session.Stash["Title"] = "Delete file"
html, _ := session.RenderTemplate("delete.html")
repo := session.Stash["repo"].(string)
file := session.Stash["file"].(string)
auth1 := session.Stash["auth1"].(string)
auth2 := session.Stash["auth2"].(string)
auth3 := session.Stash["auth3"].(string)
fname := config.CacheDir + "/" + repo + "/" + auth1 + "/" + auth2 + "/" + auth3 + "/" + file
if _, err := os.Stat(fname); err != nil {
session.RenderNotFound()
return
}
// Remove file from indexes
for f, _ := range indexes {
if _, ok := indexes[f][repo]; !ok {
continue
}
if _, ok := indexes[f][repo].Authors[auth3]; !ok {
continue
}
if _, ok := indexes[f][repo].Authors[auth3].Packages[file]; !ok {
continue
}
log.Debug("Removing from index: %s", repo)
pkg := indexes[f][repo].Authors[auth3].Packages[file]
delete(indexes[f][repo].Authors[auth3].Packages, file)
if len(indexes[f][repo].Authors[auth3].Packages) == 0 {
log.Debug("Removing author")
delete(indexes[f][repo].Authors, auth3)
}
if len(indexes[f][repo].Authors) == 0 {
log.Debug("Removing index")
delete(indexes[f], repo)
}
if auth, ok := mapped[repo][auth1][auth2][auth3]; ok {
if len(auth.Packages) == 0 {
log.Debug("Removing author from mapped index")
delete(mapped[repo][auth1][auth2], auth3)
delete(mapped[repo]["*"][auth2], auth3)
delete(mapped[repo][auth1]["**"], auth3)
delete(mapped[repo]["*"]["**"], auth3)
}
if len(mapped[repo][auth1][auth2]) == 0 {
log.Debug("Removing auth1/auth2 from mapped index")
delete(mapped[repo][auth1], auth2)
}
if len(mapped[repo]["*"][auth2]) == 0 {
log.Debug("Removing author **/auth2 from mapped index")
delete(mapped[repo][auth1], auth2)
}
if len(mapped[repo][auth1]["**"]) == 0 {
log.Debug("Removing author auth1/** from mapped index")
delete(mapped[repo][auth1], auth2)
}
if len(mapped[repo]["*"]["**"]) == 0 {
log.Debug("Removing author */** from mapped index")
delete(mapped[repo][auth1], auth2)
}
if len(mapped[repo]["*"]) == 0 {
log.Debug("Removing author * from mapped index")
delete(mapped[repo][auth1], auth2)
}
if len(mapped[repo][auth1]) == 1 {
log.Debug("Removing author auth1 from mapped index")
delete(mapped[repo], auth1)
}
if len(mapped[repo]) == 1 {
log.Debug("Removing repo from mapped index")
delete(mapped, repo)
}
}
for _, prov := range pkg.Provides {
parts := strings.Split(prov.Name, "::")
// TODO remove from packages/idxpackages
if ctx, ok := packages[parts[0]]; ok {
parts = parts[1:]
for len(parts) > 0 {
if c, ok := ctx.Children[parts[0]]; ok {
ctx = c
} else {
log.Debug("Package not found in packages: %s", parts)
break
}
parts = parts[1:]
}
if len(parts) == 0 {
for ctx != nil {
for pi, p := range ctx.Packages {
if p.Package == pkg {
log.Debug("Removing package from packages: %s", ctx.FullName())
ctx.Packages = append(ctx.Packages[:pi], ctx.Packages[pi+1:]...)
break
}
}
if len(ctx.Packages) == 0 {
log.Debug("Removing PkgSpace from packages: %s", ctx.FullName())
if ctx.Parent == nil {
delete(packages, ctx.Namespace)
} else {
delete(ctx.Parent.Children, ctx.Namespace)
}
}
ctx = ctx.Parent
}
}
}
parts = strings.Split(prov.Name, "::")
if _, ok := idxpackages[repo]; ok {
if ctx, ok := idxpackages[repo][parts[0]]; ok {
parts = parts[1:]
for len(parts) > 0 {
if c, ok := ctx.Children[parts[0]]; ok {
ctx = c
} else {
log.Debug("PkgSpace not found in idxpackages")
break
}
parts = parts[1:]
}
if len(parts) == 0 {
for ctx != nil {
for pi, p := range ctx.Packages {
if p.Package == pkg {
log.Debug("Removing package from idxpackages")
ctx.Packages = append(ctx.Packages[:pi], ctx.Packages[pi+1:]...)
break
}
}
if len(ctx.Packages) == 0 {
log.Debug("Removing PkgSpace from idxpackages: %s", ctx.FullName())
if ctx.Parent == nil {
delete(idxpackages, ctx.Namespace)
} else {
delete(ctx.Parent.Children, ctx.Namespace)
}
}
ctx = ctx.Parent
}
}
}
}
}
if _, ok := filemap[auth1+"/"+auth2+"/"+auth3+"/"+file]; ok {
log.Debug("Removing file from filemap")
// FIXME filemap should be map[string][]string, so we know if
// the file exists in multiple indexes
delete(filemap, auth1+"/"+auth2+"/"+auth3+"/"+file)
}
// write remove to index
gopan.RemoveModule(config.CacheDir+"/"+config.Index, pkg.Author.Source, pkg.Author, pkg)
}
log.Debug("Removing file from gopancache: %s", fname)
// TODO move file deletion to shared gopan package
if err := os.Remove(fname); err != nil {
log.Error("Error removing file: %s", err)
}
// TODO maybe clean up author tree (is this smartpans responsibility?)
nsrc, nauth, npkg, nprov := gopan.CountIndex(indexes)
// TODO should probably be in the index - needs to udpate when index changes
summary = &Summary{nsrc, nauth, npkg, nprov}
session.Stash["Page"] = "Browse"
session.Stash["Content"] = template.HTML(html)
session.Render("layout.html")
}
func search(session *http.Session) {
if q, ok := session.Request.Form()["q"]; ok {
query := strings.ToLower(q[0])
session.Stash["Query"] = q[0]
results := make([]*SearchResult, 0)
var lock sync.Mutex
tStart := time.Now().UnixNano()
log.Trace("Searching for [%s]", query)
var wg sync.WaitGroup
for fname, _ := range indexes {
log.Trace("=> Searching file: %s", fname)
for _, idx := range indexes[fname] {
log.Trace("=> Searching index: %s", idx.Name)
wg.Add(1)
go func(idx *gopan.Source) {
defer wg.Done()
if strings.Contains(strings.ToLower(idx.Name), query) {
lock.Lock()
results = append(results, &SearchResult{
Name: idx.Name,
Type: "Index",
URL: idx.Name,
Obj: idx,
Glyph: "list",
})
lock.Unlock()
}
for _, auth := range idx.Authors {
wg.Add(1)
go func(idx *gopan.Source, auth *gopan.Author) {
defer wg.Done()
if strings.Contains(strings.ToLower(auth.Name), query) {
lock.Lock()
results = append(results, &SearchResult{
Name: auth.Name,
Type: "Author",
URL: idx.Name + "/authors/id/" + auth.Name[:1] + "/" + auth.Name[:2] + "/" + auth.Name,
Obj: auth,
Glyph: "user",
})
lock.Unlock()
}
for _, pkg := range auth.Packages {
if strings.Contains(strings.ToLower(pkg.Name), query) {
lock.Lock()
results = append(results, &SearchResult{
Name: pkg.Name,
Type: "Module",
URL: idx.Name + "/authors/id/" + auth.Name[:1] + "/" + auth.Name[:2] + "/" + auth.Name + "/" + pkg.Name,
Obj: pkg,
Glyph: "compressed",
})
lock.Unlock()
}
for _, prov := range pkg.Provides {
if strings.Contains(strings.ToLower(prov.Name), query) {
lock.Lock()
results = append(results, &SearchResult{
Name: prov.Name,
Type: "Package",
URL: idx.Name + "/modules/" + strings.Replace(prov.Name, "::", "/", -1),
Obj: prov,
Glyph: "briefcase",
})
lock.Unlock()
}
}
}
}(idx, auth)
}
}(idx)
}
}
wg.Wait()
t := float64(time.Now().UnixNano()-tStart) / 100000 // ms
sort.Sort(ByName(results))
session.Stash["Results"] = results
session.Stash["Duration"] = t
}
session.Stash["Title"] = "SmartPAN"
html, _ := session.RenderTemplate("search.html")
session.Stash["Page"] = "Search"
session.Stash["Content"] = template.HTML(html)
session.Render("layout.html")
}
func browse(session *http.Session) {
session.Stash["Title"] = "SmartPAN"
path := ""
repo := ""
itype := ""
fpath := ""
if r, ok := session.Stash["repo"]; ok {
repo = r.(string)
fpath += repo + "/"
found := false
if repo == "SmartPAN" {
found = true
} else {
for fname, _ := range indexes {
if _, ok := indexes[fname][repo]; ok {
found = true
break
}
}
}
if !found {
session.RenderNotFound()
return
}
}
if i, ok := session.Stash["type"]; ok {
itype = i.(string)
fpath += itype + "/"
}
if p, ok := session.Stash["path"]; ok {
path = p.(string)
fpath += path + "/"
}
fpath = strings.TrimSuffix(fpath, "/")
session.Stash["path"] = fpath
bits := strings.Split(path, "/")
fbits := strings.Split(fpath, "/")
dirs := make(map[string]map[string]string, 0)
files := make(map[string]map[string]string, 0)
log.Info("Path: %s, Bits: %d", path, len(bits))
if repo == "" {
dirs = toplevelRepo()
} else if itype == "" {
dirs, files = tlRepo1(repo)
} else {
switch itype {
case "authors":
if len(path) == 0 {
dirs, files = tlRepo2(repo, itype)
} else {
switch len(bits) {
case 1:
log.Info("tlAuthor1")
dirs = tlAuthor1(repo)
case 2:
log.Info("tlAuthor2: %s", bits[1])
dirs = tlAuthor2(repo, bits[1])
case 3:
log.Info("tlAuthor3: %s, %s", bits[1], bits[2])
dirs = tlAuthor3(repo, bits[1], bits[2])
case 4:
log.Info("tlModuleList: %s, %s", repo, bits[1], bits[2], bits[3])
files = tlModuleList(repo, bits[1], bits[2], bits[3])
default:
log.Info("Invalid path - rendering not found")
session.RenderNotFound()
}
}
case "modules":
if path == "" {
dirs, files = tlRepo2(repo, itype)
} else {
if repo == "SmartPAN" {
rbits := bits[1:]
ctx := packages[bits[0]]
log.Info("Starting with context: %s", ctx.Namespace)
for len(rbits) > 0 {
ctx = ctx.Children[rbits[0]]
rbits = rbits[1:]
}
log.Info("Stashing package context: %s", ctx.Namespace)
session.Stash["Package"] = ctx
for ns, _ := range ctx.Children {
files[ns] = map[string]string{
"Name": ns,
"Path": "/" + repo + "/modules/" + path + "/" + ns,
}
}
} else {
rbits := bits[1:]
ctx := idxpackages[repo][bits[0]]
log.Info("Starting with context: %s", ctx.Namespace)
for len(rbits) > 0 {
ctx = ctx.Children[rbits[0]]
rbits = rbits[1:]
}
session.Stash["Package"] = ctx
log.Info("Stashing package context: %s", ctx.Namespace)
for ns, _ := range ctx.Children {
files[ns] = map[string]string{
"Name": ns,
"Path": "/" + repo + "/modules/" + path + "/" + ns,
}
}
}
}
default:
session.RenderNotFound()
}
}
session.Stash["Dirs"] = dirs
session.Stash["Files"] = files
pp := make([]map[string]string, 0)
cp := ""
for _, b := range fbits {
cp = cp + "/" + b
pp = append(pp, map[string]string{
"Name": b,
"Path": cp,
})
}
if len(pp) > 0 && len(pp[0]["Name"]) > 0 {
session.Stash["PathBits"] = pp
}
html, _ := session.RenderTemplate("browse.html")
session.Stash["Page"] = "Browse"
session.Stash["Content"] = template.HTML(html)
session.Render("layout.html")
}