package main import ( "encoding/json" "flag" "fmt" "log" "net/http" "os" "git.tilde.town/tildetown/bbj2/server/cmd/api" "git.tilde.town/tildetown/bbj2/server/cmd/config" "git.tilde.town/tildetown/bbj2/server/cmd/db" _ "github.com/mattn/go-sqlite3" ) // TODO tests func main() { var configFlag = flag.String("config", "config.yml", "A path to a config file.") var resetFlag = flag.Bool("reset", false, "reset the database. WARNING this wipes everything.") flag.Parse() io := config.IOStreams{ Err: os.Stderr, Out: os.Stdout, } logger := log.New(io.Out, "", log.Ldate|log.Ltime|log.Lshortfile) opts := &config.Options{ ConfigPath: *configFlag, Reset: *resetFlag, IO: io, Logger: logger, } err := _main(opts) if err != nil { logger.Fatalln(err.Error()) } } /* TODO my next initiative is doing /something/ about the database layer. The amount of boiler plate involved in: - prepare a statement - prepare a result struct - execute statement - scan into result is wild; the error handling is really out of control. I need to think of abstractions for this. The "easiest" is just making blunt, non performant functions that return structs and a single error, but that could get out of control too. In general I think not having raw sql ever in application code is a good place to start. */ func _main(opts *config.Options) error { cfg, err := config.ParseConfig(opts.ConfigPath) if err != nil { fmt.Fprintf(os.Stderr, "could not read config file '%s'", opts.ConfigPath) os.Exit(1) } opts.Config = *cfg teardown, err := db.Setup(*opts) if err != nil { return fmt.Errorf("could not initialize DB: %w", err) } defer teardown() err = db.EnsureSchema(*opts) if err != nil { return err } setupAPI(*opts) // TODO TLS or SSL or something opts.Logger.Printf("starting server at %s:%d", cfg.Host, cfg.Port) if err := http.ListenAndServe(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port), nil); err != nil { return fmt.Errorf("http server exited with error: %w", err) } return nil } func handler(opts config.Options, f http.HandlerFunc) http.HandlerFunc { // TODO make this more real return func(w http.ResponseWriter, req *http.Request) { opts.Logger.Printf("<- %s", req.URL.Path) // TODO add user info to opts f(w, req) } } func setupAPI(opts config.Options) { handleFailedAPICreate := func(w http.ResponseWriter, err error) { opts.Logger.Printf("failed to create API: %s", err.Error()) w.WriteHeader(500) w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(api.BBJResponse{ Error: true, Data: "server error check logs", }) } // TODO could probably generalize this even further but it's fine for now http.HandleFunc("/instance_info", handler(opts, func(w http.ResponseWriter, req *http.Request) { a, err := api.NewAPI(opts, req) if err != nil { handleFailedAPICreate(w, err) return } api.Invoke(w, a.InstanceInfo) })) http.HandleFunc("/user_register", handler(opts, func(w http.ResponseWriter, req *http.Request) { a, err := api.NewAPI(opts, req) if err != nil { handleFailedAPICreate(w, err) return } api.Invoke(w, a.UserRegister) })) /* func checkAuth(opts config.Options, username, hash string) error { db := opts.DB stmt, err := db.Prepare("select auth_hash from users where user_name = ?") if err != nil { return fmt.Errorf("db error: %w", err) } defer stmt.Close() opts.Logger.Printf("querying for %s", username) var authHash string if err = stmt.QueryRow(username).Scan(&authHash); err != nil { if strings.Contains(err.Error(), "no rows in result") { return errors.New("no such user") } return fmt.Errorf("db error: %w", err) } if authHash != hash { return errors.New("bad credentials") } return nil } http.HandleFunc("/user_register", handler(opts, func(w http.ResponseWriter, req *http.Request) { if req.Method != "POST" { badMethod(w) return } type AuthArgs struct { Username string `json:"user_name"` Hash string `json:"auth_hash"` } var args AuthArgs if err := json.NewDecoder(req.Body).Decode(&args); err != nil { invalidArgs(w) return } if args.Hash == "" || args.Username == "" { invalidArgs(w) return } opts.Logf("querying for %s", args.Username) if err := checkAuth(opts, args.Username, args.Hash); err == nil { opts.Logf("found %s", args.Username) // code 4 apparently writeErrorResponse(w, 403, BBJResponse{ Error: true, Data: "user already exists", }) } else if err.Error() != "no such user" { serverErr(w, err) return } db := opts.DB stmt, err := db.Prepare(`INSERT INTO users VALUES (?, ?, ?, "", "", 0, 0, ?)`) id, err := uuid.NewRandom() if err != nil { serverErr(w, err) return } _, err = stmt.Exec(id, args.Username, args.Hash, time.Now()) if err != nil { serverErr(w, err) } writeResponse(w, BBJResponse{ Data: true, // TODO probably something else // TODO prob usermap }) })) http.HandleFunc("/check_auth", handler(opts, func(w http.ResponseWriter, req *http.Request) { if req.Method != "POST" { badMethod(w) return } type AuthArgs struct { Username string `json:"target_user"` AuthHash string `json:"target_hash"` } var args AuthArgs if err := json.NewDecoder(req.Body).Decode(&args); err != nil { invalidArgs(w) return } opts.Logf("got %s %s", args.Username, args.AuthHash) db := opts.DB stmt, err := db.Prepare("select auth_hash from users where user_name = ?") if err != nil { serverErr(w, err) return } defer stmt.Close() var authHash string err = stmt.QueryRow(args.Username).Scan(&authHash) if err != nil { if strings.Contains(err.Error(), "no rows in result") { opts.Logf("user not found") writeErrorResponse(w, 404, BBJResponse{ Error: true, Data: "user not found", }) } else { serverErr(w, err) } return } // TODO unique constraint on user_name if authHash != args.AuthHash { http.Error(w, "incorrect password", 403) writeErrorResponse(w, 403, BBJResponse{ Error: true, Data: "incorrect password", }) return } // TODO include usermap? writeResponse(w, BBJResponse{ Data: true, }) })) http.HandleFunc("/thread_index", handler(opts, func(w http.ResponseWriter, req *http.Request) { db := opts.DB rows, err := db.Query("SELECT * FROM threads JOIN messages ON threads.thread_id = messages.thread_id") if err != nil { serverErr(w, err) return } defer rows.Close() for rows.Next() { var id string err = rows.Scan(&id) if err != nil { serverErr(w, err) return } opts.Log(id) } writeResponse(w, BBJResponse{Data: "TODO"}) // TODO })) http.HandleFunc("/thread_create", handler(opts, func(w http.ResponseWriter, req *http.Request) { if req.Method != "POST" { badMethod(w) return } // TODO make this getUserInfoFromReq or similar so we can use the user ID later user, err := getUserFromReq(opts, req) if err != nil { writeErrorResponse(w, 403, BBJResponse{ Error: true, Data: err.Error(), }) return } type threadCreateArgs struct { Title string Body string SendRaw bool `json:"send_raw"` } var args threadCreateArgs if err := json.NewDecoder(req.Body).Decode(&args); err != nil { invalidArgs(w) return } if args.Title == "" || args.Body == "" { invalidArgs(w) return } db := opts.DB tx, err := db.Begin() if err != nil { serverErr(w, err) return } stmt, err := tx.Prepare("insert into threads VALUES ( ?, ?, ?, ?, ?, 0, 0, ? )") if err != nil { serverErr(w, err) return } defer stmt.Close() threadID, err := uuid.NewRandom() if err != nil { serverErr(w, err) return } now := time.Now() if _, err = stmt.Exec( threadID, user.ID, args.Title, now, now, user.Username, ); err != nil { serverErr(w, err) return } stmt, err = tx.Prepare("insert into messages values ( ?, 1, ?, ?, 0, ?, ? )") if err != nil { serverErr(w, err) return } defer stmt.Close() if _, err = stmt.Exec( threadID, user.ID, now, args.Body, args.SendRaw, ); err != nil { serverErr(w, err) return } if err = tx.Commit(); err != nil { serverErr(w, err) return } stmt, err = db.Prepare("select * from threads where thread_id = ? limit 1") if err != nil { serverErr(w, err) return } defer stmt.Close() t := &Thread{} // TODO fill in rest of thread if err = stmt.QueryRow(threadID).Scan( t.ID, t.Author, t.Title, t.LastMod, t.Created, t.ReplyCount, t.Pinned, t.LastAuthor, ); err != nil { serverErr(w, err) return } stmt, err = db.Prepare("select * from messages where thread_id = ?") if err != nil { serverErr(w, err) return } defer stmt.Close() rows, err := stmt.Query(threadID) if err != nil { serverErr(w, err) return } t.Messages = []Message{} for rows.Next() { m := &Message{} if err := rows.Scan( m.ThreadID, m.PostID, m.Author, m.Created, m.Edited, m.Body, m.SendRaw, ); err != nil { serverErr(w, err) return } t.Messages = append(t.Messages, *m) } writeResponse(w, BBJResponse{Data: t}) })) */ }