func parseAclRequestTyped(cx *goweb.Context) (ids []string, err error) {
var users []string
query := util.Q(cx.Request.URL.Query())
params, _, err := request.ParseMultipartForm(cx.Request)
if err != nil && err.Error() == "request Content-Type isn't multipart/form-data" && query.Has("users") {
users = strings.Split(query.Value("users"), ",")
} else if params["users"] != "" {
users = strings.Split(params["users"], ",")
} else {
return nil, errors.New("Action requires list of comma seperated email address in 'users' parameter")
}
for _, v := range users {
if isEmail(v) {
u := user.User{Username: v, Email: v}
if err := u.SetUuid(); err != nil {
return nil, err
}
ids = append(ids, u.Uuid)
} else if isUuid(v) {
ids = append(ids, v)
} else {
return nil, errors.New("Unknown user id. Must be uuid or email address")
}
}
return ids, nil
}
func parseAclRequest(cx *goweb.Context) (ids map[string][]string, err error) {
ids = map[string][]string{}
users := map[string][]string{}
query := util.Q(cx.Request.URL.Query())
params, _, err := request.ParseMultipartForm(cx.Request)
if err != nil && err.Error() == "request Content-Type isn't multipart/form-data" && (query.Has("all") || query.Has("read") || query.Has("write") || query.Has("delete")) {
if query.Has("all") {
users["all"] = strings.Split(query.Value("all"), ",")
}
if query.Has("read") {
users["read"] = strings.Split(query.Value("read"), ",")
}
if query.Has("write") {
users["write"] = strings.Split(query.Value("write"), ",")
}
if query.Has("delete") {
users["delete"] = strings.Split(query.Value("delete"), ",")
}
} else if params["all"] != "" || params["read"] != "" || params["write"] != "" || params["delete"] != "" {
users["all"] = strings.Split(params["all"], ",")
users["read"] = strings.Split(params["read"], ",")
users["write"] = strings.Split(params["write"], ",")
users["delete"] = strings.Split(params["delete"], ",")
} else {
return nil, errors.New("Action requires list of comma seperated email address in 'all', 'read', 'write', and/or 'delete' parameter")
}
for k, _ := range users {
for _, v := range users[k] {
if v != "" {
if isEmail(v) {
u := user.User{Username: v, Email: v}
if err := u.SetUuid(); err != nil {
return nil, err
}
ids[k] = append(ids[k], u.Uuid)
} else if isUuid(v) {
ids[k] = append(ids[k], v)
} else {
return nil, errors.New("Unknown user id. Must be uuid or email address")
}
}
}
}
if len(ids["all"]) > 0 {
ids["read"] = append(ids["read"], ids["all"]...)
ids["write"] = append(ids["write"], ids["all"]...)
ids["delete"] = append(ids["delete"], ids["all"]...)
}
delete(ids, "all")
return ids, nil
}
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@index:LoadNode: " + err.Error())
cx.RespondWithError(http.StatusInternalServerError)
return
}
}
idxType, hasType := cx.PathParams["type"]
query := util.Q(cx.Request.URL.Query())
switch cx.Request.Method {
case "GET":
if hasType {
if v, has := n.Indexes[idxType]; has {
cx.RespondWithData(map[string]interface{}{idxType: v})
} else {
cx.RespondWithErrorMessage(fmt.Sprintf("Node %s does not have index of type %s.", n.Id, idxType), http.StatusBadRequest)
}
} else {
cx.RespondWithData(getRes{I: n.Indexes, A: filteredIndexes(n.Indexes)})
}
case "POST", "PUT":
if !n.HasFile() {
cx.RespondWithErrorMessage("Node has no file", http.StatusBadRequest)
// 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
}
