func (s *queueServer) doUpload(w http.ResponseWriter, file multipart.File, jid int64, filename string) error {
conn, err := cfg.NewRabbitmqConn()
if err != nil {
glog.Errorln("Couldn't connect to rabbitmq", err)
error500(w)
return err
}
defer conn.Close()
ch, err := conn.Channel()
if err != nil {
glog.Errorln("Couldn't open rabbitmq channel", err)
error500(w)
return err
}
defer ch.Close()
f, err := createJobInputFile(jid)
if err != nil {
glog.Errorln("couldn't create file", err)
error500(w)
return err
}
defer f.Close()
fpath := f.Name()
h := sha1.New()
limit := int64(s.SizeLimit)
glog.Infoln("job file name ", filename)
n, err := io.Copy(io.MultiWriter(f, h), io.LimitReader(file, limit))
if n == limit {
glog.Errorln("Error body too long", filename, err)
http.Error(w, "Request body too long", http.StatusBadRequest)
os.Remove(fpath)
return errors.New("Error body too long")
}
if err != nil {
glog.Errorln("Error writing request to file", fpath, err)
error500(w)
return err
}
err = f.Close()
if err != nil {
glog.Errorln("Error closing file", fpath, err)
error500(w)
return err
}
glog.Infoln("job file", s.Name, filename, "wrote bytes", n)
hash := hex.EncodeToString(h.Sum(nil))
glog.Infoln("Wrote job with hash", hash, "to file", fpath)
// TODO check if hash is already queued and if it is abort and return the job id
// TODO store hash state in db
// TODO configurable ttr?
q, err := ch.QueueDeclare(
s.Name, // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
if err != nil {
glog.Errorln("Couldn't open rabbitmq queue", s.Name, err)
error500(w)
return err
}
qe := QueueEntry{JobId: fmt.Sprint(jid), Filename: filename}
qem, err := json.Marshal(qe)
glog.Infoln("job file name ", filename)
if err != nil {
glog.Errorln("could not marshal queue entry to json", err)
error500(w)
return err
}
err = ch.Publish(
"", // exchange
q.Name, // routing key
false, // mandatory
false,
amqp.Publishing{
DeliveryMode: amqp.Persistent,
ContentType: "application/json",
Body: qem,
})
if err != nil {
glog.Errorln("Error storing job for file", fpath, "with hash", hash, "to rabbitmq")
return err
}
response := UploadRensponse{JobId: fmt.Sprint(jid)}
json_response, err := json.Marshal(response)
if err != nil {
glog.Errorln("json response", err)
error500(w)
return err
}
glog.Infoln("json response", string(json_response))
w.Write(json_response)
w.Header().Set("Content-Type", "application/json")
return nil
}
func main() {
cfg.Init()
defer cfg.Finalize()
engine = NewEngineContainerWrap(*engineType, *workerIndex)
// TODO: pull image before reading from the queue
conn, err := cfg.NewRabbitmqConn()
if err != nil {
glog.Errorln("Couldn't connect to rabbitmq", err)
return
}
defer conn.Close()
ch, err := conn.Channel()
if err != nil {
glog.Errorln("Couldn't open rabbitmq channel", err)
return
}
defer ch.Close()
q, err := ch.QueueDeclare(
*engineType, // name
true, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
if err != nil {
glog.Errorln("Couldn't open rabbitmq queue", *engineType, err)
return
}
// make sure we fetch one at a time
err = ch.Qos(
1, // prefetch count
0, // prefetch size
false, // global
)
if err != nil {
glog.Errorln("Failed to set QoS to RmQ channel")
return
}
consumer := fmt.Sprintf("pid-%d", os.Getpid())
msgs, err := ch.Consume(
q.Name, // queue
consumer, // consumer string
false, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
if err != nil {
glog.Errorln("Failed to start RmQ consumption loop")
return
}
for i := 0; i < *joblimit || *joblimit == 0; i++ {
if d, gotMsg := <-msgs; gotMsg {
work(d)
} else {
glog.Warningln("Message channel closed. Exiting.")
break
}
}
ch.Cancel(consumer, true)
}