func (h *DeQHTTPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
q, ok := mux.Vars(r)["queue"]
if !ok {
http.Error(w, "unkown queue", http.StatusBadRequest)
return
}
ctx, cnl := context.WithTimeout(context.Background(), httpTimeout)
defer cnl()
d := Deque{Queue: Queue(q)}
res, err := h.Hive.Sync(ctx, d)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
switch res := res.(type) {
case Error:
http.Error(w, res.Message, http.StatusInternalServerError)
case Dequed:
if err = json.NewEncoder(w).Encode(res.Task); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
}
func (h *EnQHTTPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
q, ok := mux.Vars(r)["queue"]
if !ok {
http.Error(w, "unkown queue", http.StatusBadRequest)
return
}
b, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, "cannot read request body", http.StatusBadRequest)
return
}
e := Enque{
Queue: Queue(q),
Body: b,
}
ctx, cnl := context.WithTimeout(context.Background(), httpTimeout)
defer cnl()
res, err := h.Hive.Sync(ctx, e)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
switch res := res.(type) {
case Error:
http.Error(w, res.Message, http.StatusInternalServerError)
case Enqued:
fmt.Fprintf(w, "task %v enqueued\n", res.TaskID)
}
}
func (s *KVStore) ServeHTTP(w http.ResponseWriter, r *http.Request) {
k, ok := mux.Vars(r)["key"]
if !ok {
http.Error(w, "no key in the url", http.StatusBadRequest)
return
}
ctx, cnl := context.WithTimeout(context.Background(), 30*time.Second)
var res interface{}
var err error
switch r.Method {
case "GET":
res, err = s.Hive.Sync(ctx, Get(k))
case "PUT":
var v []byte
v, err = ioutil.ReadAll(r.Body)
if err != nil {
break
}
res, err = s.Hive.Sync(ctx, Put{Key: k, Val: string(v)})
case "DELETE":
res, err = s.Hive.Sync(ctx, Del(k))
}
cnl()
if err != nil {
switch {
case err.Error() == errKeyNotFound.Error():
http.Error(w, err.Error(), http.StatusNotFound)
return
case err.Error() == errInternal.Error():
http.Error(w, err.Error(), http.StatusInternalServerError)
return
case err.Error() == errInvalid.Error():
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
}
if res == nil {
return
}
js, err := json.Marshal(res)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(js)
}
func (h *HelloHTTPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
name, ok := vars["name"]
if !ok {
http.Error(w, "no name", http.StatusBadRequest)
return
}
res, err := beehive.Sync(context.TODO(), HelloHTTP{Name: name})
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
fmt.Fprintf(w, "hello %s (%d)\n", name, res.(int))
}
func defaultHTTPHandler(w http.ResponseWriter, r *http.Request, h bh.Hive) {
w.Header().Set("Server", "Beehive-netctrl-HTTP-Server")
vars := mux.Vars(r)
submodule, ok := vars["submodule"]
if !ok {
/* This should not happened :) */
http.Error(w, "Invalid request", http.StatusBadRequest)
return
}
verb, ok := vars["verb"]
if !ok {
/* This should not happened :) */
http.Error(w, "Invalid request", http.StatusBadRequest)
return
}
creq := HTTPRequest{
AppName: submodule,
Verb: verb,
}
// Read content data if available :)
if r.ContentLength > 0 {
data, err := ioutil.ReadAll(r.Body)
if err == nil {
creq.Data = data
}
}
cres, err := h.Sync(context.TODO(), creq)
if err == nil && cres != nil {
w.Write(cres.(HTTPResponse).Data)
w.WriteHeader(http.StatusOK)
return
} else {
http.Error(w, err.Error(), http.StatusInternalServerError)
fmt.Errorf("defaultTTPHandler: %v\n", err)
return
}
}
func (httpReceiver *HTTPReceiver) ServeHTTP(
responseWriter http.ResponseWriter,
httpRequest *http.Request) {
logger.Info.Printf("[HTTPReceiver] ServeHTTP %s %s \n",
httpRequest.Method,
httpRequest.URL)
vars := mux.Vars(httpRequest)
destinationBee, ok := vars["destinationBee"]
if !ok {
BadRequest(responseWriter, "No destinationBee")
return
}
fibNumberStr, ok := vars["fibNumber"]
if !ok {
BadRequest(responseWriter, "No fibNumber")
return
}
fibNumber, err := strconv.Atoi(fibNumberStr)
if err != nil {
BadRequest(responseWriter, "FibNumber must be number")
return
}
message := MessageToBee{
DestinationBee: destinationBee,
FibNumber: fibNumber,
}
logger.Trace.Printf("[HTTPReceiver] Message to bee %+v \n", message)
beeRespond, err := beehive.Sync(context.TODO(), message)
if err != nil {
logger.Error.Printf("[HTTPReceiver] %s \n", err.Error())
http.Error(responseWriter, err.Error(), http.StatusInternalServerError)
return
}
fmt.Fprintf(responseWriter, "%d", beeRespond.(int))
logger.Trace.Println("[HTTPReceiver] Done sending message to bee")
}
func (h *AckHTTPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
q, ok := vars["queue"]
if !ok {
http.Error(w, "unkown queue", http.StatusBadRequest)
return
}
t, ok := vars["id"]
if !ok {
http.Error(w, "unkown task", http.StatusBadRequest)
return
}
id, err := strconv.ParseUint(t, 10, 64)
if err != nil {
http.Error(w, fmt.Sprintf("invalid task id: %v", err),
http.StatusBadRequest)
return
}
ctx, cnl := context.WithTimeout(context.Background(), httpTimeout)
defer cnl()
a := Ack{
TaskID: TaskID(id),
Queue: Queue(q),
}
res, err := h.Hive.Sync(ctx, a)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
switch res := res.(type) {
case Error:
http.Error(w, res.Message, http.StatusInternalServerError)
case Acked:
fmt.Fprintf(w, "task %v acknowledged\n", id)
}
}
