// POST: /node
func (cr *Controller) Create(cx *goweb.Context) {
// Log Request and check for Auth
request.Log(cx.Request)
u, err := request.Authenticate(cx.Request)
if err != nil && err.Error() != e.NoAuth {
request.AuthError(err, cx)
return
}
// Fake public user
if u == nil {
if conf.Bool(conf.Conf["anon-write"]) {
u = &user.User{Uuid: ""}
} else {
cx.RespondWithErrorMessage(e.NoAuth, http.StatusUnauthorized)
return
}
}
// Parse uploaded form
params, files, err := request.ParseMultipartForm(cx.Request)
if err != nil {
// If not multipart/form-data it will create an empty node.
// TODO: create another request parser for non-multipart request
// to handle this cleaner.
if err.Error() == "request Content-Type isn't multipart/form-data" {
n, err := node.CreateNodeUpload(u, params, files)
if err != nil {
logger.Error("Error at create empty: " + err.Error())
cx.RespondWithError(http.StatusInternalServerError)
return
}
if n == nil {
// Not sure how you could get an empty node with no error
// Assume it's the user's fault
cx.RespondWithError(http.StatusBadRequest)
return
} else {
cx.RespondWithData(n)
return
}
} else {
// Some error other than request encoding. Theoretically
// could be a lost db connection between user lookup and parsing.
// Blame the user, Its probaby their fault anyway.
logger.Error("Error parsing form: " + err.Error())
cx.RespondWithError(http.StatusBadRequest)
return
}
}
// Create node
n, err := node.CreateNodeUpload(u, params, files)
if err != nil {
logger.Error("err@node_CreateNodeUpload: " + err.Error())
cx.RespondWithErrorMessage(err.Error(), http.StatusBadRequest)
return
}
cx.RespondWithData(n)
return
}
// DELETE: /node/{id}
func (cr *Controller) Delete(id string, cx *goweb.Context) {
request.Log(cx.Request)
u, err := request.Authenticate(cx.Request)
if err != nil && err.Error() != e.NoAuth {
request.AuthError(err, cx)
return
}
if u == nil {
cx.RespondWithErrorMessage(e.NoAuth, http.StatusUnauthorized)
return
}
// Load node and handle user unauthorized
n, err := node.Load(id, u.Uuid)
if err != nil {
if err.Error() == e.UnAuth {
cx.RespondWithError(http.StatusUnauthorized)
return
} else if err.Error() == e.MongoDocNotFound {
cx.RespondWithNotFound()
return
} else {
// In theory the db connection could be lost between
// checking user and load but seems unlikely.
logger.Error("Err@node_Read:Delete: " + err.Error())
cx.RespondWithError(http.StatusInternalServerError)
return
}
}
if err := n.Delete(); err == nil {
cx.RespondWithOK()
return
} else {
logger.Error("Err@node_Delet:Delete: " + err.Error())
cx.RespondWithError(http.StatusInternalServerError)
}
return
}
// DELETE: /node
func (cr *Controller) DeleteMany(cx *goweb.Context) {
request.Log(cx.Request)
cx.RespondWithError(http.StatusNotImplemented)
}
// Options: /node
func (cr *Controller) Options(cx *goweb.Context) {
request.Log(cx.Request)
cx.RespondWithOK()
return
}
"github.com/MG-RAST/Shock/shock-server/util"
"github.com/jaredwilkening/goweb"
"net/http"
"os"
)
type getRes struct {
I interface{} `json:"indexes"`
A interface{} `json:"available_indexers"`
}
type m map[string]string
// GET, POST, PUT, DELETE: /node/{nid}/index/{idxType}
var Controller goweb.ControllerFunc = func(cx *goweb.Context) {
request.Log(cx.Request)
u, err := request.Authenticate(cx.Request)
if err != nil && err.Error() != e.NoAuth {
request.AuthError(err, cx)
return
}
// Fake public user
if u == nil {
u = &user.User{Uuid: ""}
}
// Load node and handle user unauthorized
id := cx.PathParams["nid"]
n, err := node.Load(id, u.Uuid)
if err != nil {
// PUT: /node/{id} -> multipart-form
func (cr *Controller) Update(id string, cx *goweb.Context) {
// Log Request and check for Auth
request.Log(cx.Request)
u, err := request.Authenticate(cx.Request)
if err != nil && err.Error() != e.NoAuth {
request.AuthError(err, cx)
return
}
// Gather query params
query := util.Q(cx.Request.URL.Query())
// Fake public user
if u == nil {
u = &user.User{Uuid: ""}
}
n, err := node.Load(id, u.Uuid)
if err != nil {
if err.Error() == e.UnAuth {
cx.RespondWithError(http.StatusUnauthorized)
return
} else if err.Error() == e.MongoDocNotFound {
cx.RespondWithNotFound()
return
} else {
// In theory the db connection could be lost between
// checking user and load but seems unlikely.
logger.Error("Err@node_Update:LoadNode: " + err.Error())
cx.RespondWithError(http.StatusInternalServerError)
return
}
}
if query.Has("index") {
if conf.Bool(conf.Conf["perf-log"]) {
logger.Perf("START indexing: " + id)
}
if !n.HasFile() {
cx.RespondWithErrorMessage("node file empty", http.StatusBadRequest)
return
}
if query.Value("index") == "bai" {
//bam index is created by the command-line tool samtools
if ext := n.FileExt(); ext == ".bam" {
if err := index.CreateBamIndex(n.FilePath()); err != nil {
cx.RespondWithErrorMessage("Error while creating bam index", http.StatusBadRequest)
return
}
return
} else {
cx.RespondWithErrorMessage("Index type bai requires .bam file", http.StatusBadRequest)
return
}
}
idxtype := query.Value("index")
if _, ok := index.Indexers[idxtype]; !ok {
cx.RespondWithErrorMessage("invalid index type", http.StatusBadRequest)
return
}
newIndexer := index.Indexers[idxtype]
f, _ := os.Open(n.FilePath())
defer f.Close()
idxer := newIndexer(f)
count, err := idxer.Create()
if err != nil {
logger.Error("err " + err.Error())
cx.RespondWithErrorMessage(err.Error(), http.StatusBadRequest)
return
}
if err := idxer.Dump(n.IndexPath() + "/" + query.Value("index") + ".idx"); err != nil {
logger.Error("err " + err.Error())
cx.RespondWithErrorMessage(err.Error(), http.StatusBadRequest)
return
}
idxInfo := node.IdxInfo{
Type: query.Value("index"),
TotalUnits: count,
AvgUnitSize: n.File.Size / count,
}
if idxtype == "chunkrecord" {
idxInfo.AvgUnitSize = conf.CHUNK_SIZE
}
if err := n.SetIndexInfo(query.Value("index"), idxInfo); err != nil {
logger.Error("[email protected]: " + err.Error())
}
if conf.Bool(conf.Conf["perf-log"]) {
logger.Perf("END indexing: " + id)
}
cx.RespondWithOK()
return
} else {
if conf.Bool(conf.Conf["perf-log"]) {
logger.Perf("START PUT data: " + id)
}
params, files, err := request.ParseMultipartForm(cx.Request)
if err != nil {
logger.Error("err@node_ParseMultipartForm: " + err.Error())
cx.RespondWithError(http.StatusBadRequest)
return
}
err = n.Update(params, files)
if err != nil {
errors := []string{e.FileImut, e.AttrImut, "parts cannot be less than 1"}
for e := range errors {
if err.Error() == errors[e] {
cx.RespondWithErrorMessage(err.Error(), http.StatusBadRequest)
return
}
}
logger.Error("err@node_Update: " + id + ":" + err.Error())
cx.RespondWithErrorMessage(err.Error(), http.StatusBadRequest)
return
}
cx.RespondWithData(n)
if conf.Bool(conf.Conf["perf-log"]) {
logger.Perf("END PUT data: " + id)
}
}
return
}
