package main import ( "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() logger := log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile) opts := &config.Options{ ConfigPath: *configFlag, Reset: *resetFlag, 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 { return fmt.Errorf("could not read config file '%s'", opts.ConfigPath) } 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 setupAPI(opts config.Options) { a := api.NewAPI(opts) http.HandleFunc("/instance_info", func(w http.ResponseWriter, req *http.Request) { a.Invoke(w, req, a.InstanceInfo) }) http.HandleFunc("/user_register", func(w http.ResponseWriter, req *http.Request) { a.Invoke(w, req, a.UserRegister) }) } /* 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}) })) */