102 lines
3.6 KiB
Go
102 lines
3.6 KiB
Go
// fakeupstream stands in for a llama-server router in tests and the smoke run. Do not edit.
|
|
//
|
|
// fakeupstream -listen 127.0.0.1:18081 -name alpha -models a,b -down-file /tmp/alpha.down
|
|
//
|
|
// /health answers 503 while the down file exists, 200 otherwise. /v1/models lists -models.
|
|
// /props answers a small JSON object. /v1/chat/completions echoes: a streamed answer of five
|
|
// SSE chunks 200 ms apart when the body has "stream": true, one JSON answer otherwise. Every
|
|
// response carries X-Upstream: <name>.
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func main() {
|
|
listen := flag.String("listen", "127.0.0.1:18081", "address to listen on")
|
|
name := flag.String("name", "fake", "name reported in X-Upstream and answers")
|
|
models := flag.String("models", "m", "comma-separated model ids for /v1/models")
|
|
downFile := flag.String("down-file", "", "while this file exists, /health answers 503")
|
|
flag.Parse()
|
|
|
|
ids := strings.Split(*models, ",")
|
|
mux := http.NewServeMux()
|
|
stamp := func(w http.ResponseWriter) { w.Header().Set("X-Upstream", *name) }
|
|
|
|
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
|
|
stamp(w)
|
|
if *downFile != "" {
|
|
if _, err := os.Stat(*downFile); err == nil {
|
|
http.Error(w, `{"error":{"message":"Loading model"}}`, http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
}
|
|
writeJSON(w, map[string]string{"status": "ok"})
|
|
})
|
|
mux.HandleFunc("/v1/models", func(w http.ResponseWriter, r *http.Request) {
|
|
stamp(w)
|
|
data := []map[string]any{}
|
|
for _, id := range ids {
|
|
data = append(data, map[string]any{"id": id, "object": "model", "owned_by": *name})
|
|
}
|
|
writeJSON(w, map[string]any{"object": "list", "data": data})
|
|
})
|
|
mux.HandleFunc("/props", func(w http.ResponseWriter, r *http.Request) {
|
|
stamp(w)
|
|
writeJSON(w, map[string]any{"default_generation_settings": map[string]any{"n_ctx": 8192}, "total_slots": 2, "model_path": *name})
|
|
})
|
|
mux.HandleFunc("/v1/chat/completions", func(w http.ResponseWriter, r *http.Request) {
|
|
stamp(w)
|
|
body, _ := io.ReadAll(io.LimitReader(r.Body, 1<<20))
|
|
var req struct {
|
|
Model string `json:"model"`
|
|
Stream bool `json:"stream"`
|
|
}
|
|
_ = json.Unmarshal(body, &req)
|
|
if !req.Stream {
|
|
writeJSON(w, map[string]any{
|
|
"id": "chatcmpl-fake", "object": "chat.completion", "model": req.Model,
|
|
"choices": []map[string]any{{"index": 0, "message": map[string]string{"role": "assistant", "content": "hello from " + *name}, "finish_reason": "stop"}},
|
|
"usage": map[string]int{"prompt_tokens": 3, "completion_tokens": 3, "total_tokens": 6},
|
|
})
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
w.Header().Set("Cache-Control", "no-cache")
|
|
w.WriteHeader(http.StatusOK)
|
|
fl, _ := w.(http.Flusher)
|
|
for i := 1; i <= 5; i++ {
|
|
chunk := map[string]any{"id": "chatcmpl-fake", "object": "chat.completion.chunk", "model": req.Model,
|
|
"choices": []map[string]any{{"index": 0, "delta": map[string]string{"content": fmt.Sprintf("%s chunk %d ", *name, i)}}}}
|
|
b, _ := json.Marshal(chunk)
|
|
fmt.Fprintf(w, "data: %s\n\n", b)
|
|
if fl != nil {
|
|
fl.Flush()
|
|
}
|
|
time.Sleep(200 * time.Millisecond)
|
|
}
|
|
fmt.Fprint(w, "data: [DONE]\n\n")
|
|
})
|
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
stamp(w)
|
|
http.Error(w, `{"error":"not found"}`, http.StatusNotFound)
|
|
})
|
|
|
|
log.Printf("fakeupstream %s listening on %s models=%v", *name, *listen, ids)
|
|
srv := &http.Server{Addr: *listen, Handler: mux, ReadHeaderTimeout: 5 * time.Second}
|
|
log.Fatal(srv.ListenAndServe())
|
|
}
|
|
|
|
func writeJSON(w http.ResponseWriter, v any) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_ = json.NewEncoder(w).Encode(v)
|
|
}
|