From 7eef6ae5d0755f57aff1de0760ae9c0894fbc81c Mon Sep 17 00:00:00 2001 From: Ted Unangst Date: Sun, 6 Feb 2022 00:42:13 -0500 Subject: [PATCH] flexible logging --- activity.go | 183 ++++++++++++++++++++++---------------------- admin.go | 4 +- avatar.go | 3 +- backend.go | 15 ++-- backupdb.go | 21 +++--- database.go | 105 +++++++++++++------------- deliverator.go | 23 +++--- fun.go | 17 ++--- hfcs.go | 21 +++--- honk.go | 21 ++++-- hoot.go | 15 ++-- import.go | 23 +++--- log.go | 69 +++++++++++++++++ upgradedb.go | 27 ++++--- util.go | 51 ++++++------- web.go | 201 ++++++++++++++++++++++++------------------------- 16 files changed, 430 insertions(+), 369 deletions(-) create mode 100644 log.go diff --git a/activity.go b/activity.go index e20db98..b6ab476 100644 --- a/activity.go +++ b/activity.go @@ -23,7 +23,6 @@ import ( "fmt" "html" "io" - "log" notrand "math/rand" "net/http" "net/url" @@ -96,7 +95,7 @@ func PostMsg(keyname string, key httpsig.PrivateKey, url string, msg []byte) err default: return fmt.Errorf("http post status: %d", resp.StatusCode) } - log.Printf("successful post: %s %d", url, resp.StatusCode) + ilog.Printf("successful post: %s %d", url, resp.StatusCode) return nil } @@ -113,13 +112,13 @@ func GetJunkHardMode(url string) (junk.Junk, error) { if err != nil { emsg := err.Error() if emsg == "http get status: 502" || strings.Contains(emsg, "timeout") { - log.Printf("trying again after error: %s", emsg) + ilog.Printf("trying again after error: %s", emsg) time.Sleep(time.Duration(60+notrand.Int63n(60)) * time.Second) j, err = GetJunk(url) if err != nil { - log.Printf("still couldn't get it") + ilog.Printf("still couldn't get it") } else { - log.Printf("retry success!") + ilog.Printf("retry success!") } } } @@ -158,7 +157,7 @@ func fetchsome(url string) ([]byte, error) { } req, err := http.NewRequest("GET", url, nil) if err != nil { - log.Printf("error fetching %s: %s", url, err) + ilog.Printf("error fetching %s: %s", url, err) return nil, err } req.Header.Set("User-Agent", "honksnonk/5.0; "+serverName) @@ -167,7 +166,7 @@ func fetchsome(url string) ([]byte, error) { req = req.WithContext(ctx) resp, err := client.Do(req) if err != nil { - log.Printf("error fetching %s: %s", url, err) + ilog.Printf("error fetching %s: %s", url, err) return nil, err } defer resp.Body.Close() @@ -191,7 +190,7 @@ func savedonk(url string, name, desc, media string, localize bool) *Donk { if donk := finddonk(url); donk != nil { return donk } - log.Printf("saving donk: %s", url) + ilog.Printf("saving donk: %s", url) data := []byte{} if localize { fn := func() (interface{}, error) { @@ -199,19 +198,19 @@ func savedonk(url string, name, desc, media string, localize bool) *Donk { } ii, err := flightdeck.Call(url, fn) if err != nil { - log.Printf("error fetching donk: %s", err) + ilog.Printf("error fetching donk: %s", err) localize = false goto saveit } data = ii.([]byte) if len(data) == 10*1024*1024 { - log.Printf("truncation likely") + ilog.Printf("truncation likely") } if strings.HasPrefix(media, "image") { img, err := shrinkit(data) if err != nil { - log.Printf("unable to decode image: %s", err) + ilog.Printf("unable to decode image: %s", err) localize = false data = []byte{} goto saveit @@ -220,12 +219,12 @@ func savedonk(url string, name, desc, media string, localize bool) *Donk { media = "image/" + img.Format } else if media == "application/pdf" { if len(data) > 1000000 { - log.Printf("not saving large pdf") + ilog.Printf("not saving large pdf") localize = false data = []byte{} } } else if len(data) > 100000 { - log.Printf("not saving large attachment") + ilog.Printf("not saving large attachment") localize = false data = []byte{} } @@ -233,7 +232,7 @@ func savedonk(url string, name, desc, media string, localize bool) *Donk { saveit: fileid, err := savefile(name, desc, url, media, localize, data) if err != nil { - log.Printf("error saving file %s: %s", url, err) + elog.Printf("error saving file %s: %s", url, err) return nil } donk := new(Donk) @@ -249,7 +248,7 @@ func iszonked(userid int64, xid string) bool { return true } if err != sql.ErrNoRows { - log.Printf("error querying zonk: %s", err) + ilog.Printf("error querying zonk: %s", err) } return false } @@ -274,11 +273,11 @@ func needxonkidX(user *WhatAbout, xid string, isannounce bool) bool { return false } if rejectorigin(user.ID, xid, isannounce) { - log.Printf("rejecting origin: %s", xid) + ilog.Printf("rejecting origin: %s", xid) return false } if iszonked(user.ID, xid) { - log.Printf("already zonked: %s", xid) + ilog.Printf("already zonked: %s", xid) return false } var id int64 @@ -288,7 +287,7 @@ func needxonkidX(user *WhatAbout, xid string, isannounce bool) bool { return false } if err != sql.ErrNoRows { - log.Printf("error querying xonk: %s", err) + ilog.Printf("error querying xonk: %s", err) } return true } @@ -300,12 +299,12 @@ func eradicatexonk(userid int64, xid string) { } _, err := stmtSaveZonker.Exec(userid, xid, "zonk") if err != nil { - log.Printf("error eradicating: %s", err) + elog.Printf("error eradicating: %s", err) } } func savexonk(x *Honk) { - log.Printf("saving xonk: %s", x.XID) + ilog.Printf("saving xonk: %s", x.XID) go handles(x.Honker) go handles(x.Oonker) savehonk(x) @@ -322,11 +321,11 @@ var boxofboxes = cache.New(cache.Options{Filler: func(ident string) (*Box, bool) row := stmtGetXonker.QueryRow(ident, "boxes") err := row.Scan(&info) if err != nil { - log.Printf("need to get boxes for %s", ident) + dlog.Printf("need to get boxes for %s", ident) var j junk.Junk j, err = GetJunk(ident) if err != nil { - log.Printf("error getting boxes: %s", err) + dlog.Printf("error getting boxes: %s", err) return nil, false } allinjest(originate(ident), j) @@ -342,10 +341,10 @@ var boxofboxes = cache.New(cache.Options{Filler: func(ident string) (*Box, bool) }}) func gimmexonks(user *WhatAbout, outbox string) { - log.Printf("getting outbox: %s", outbox) + dlog.Printf("getting outbox: %s", outbox) j, err := GetJunk(outbox) if err != nil { - log.Printf("error getting outbox: %s", err) + ilog.Printf("error getting outbox: %s", err) return } t, _ := j.GetString("type") @@ -364,7 +363,7 @@ func gimmexonks(user *WhatAbout, outbox string) { if ok { j, err = GetJunk(page1) if err != nil { - log.Printf("error gettings page1: %s", err) + ilog.Printf("error gettings page1: %s", err) return } items, _ = j.GetArray("orderedItems") @@ -390,7 +389,7 @@ func gimmexonks(user *WhatAbout, outbox string) { } obj, err = GetJunk(xid) if err != nil { - log.Printf("error getting item: %s", err) + ilog.Printf("error getting item: %s", err) continue } xonksaver(user, obj, originate(xid)) @@ -467,14 +466,14 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { var xonkxonkfn func(item junk.Junk, origin string, isUpdate bool) *Honk saveonemore := func(xid string) { - log.Printf("getting onemore: %s", xid) + dlog.Printf("getting onemore: %s", xid) if depth >= maxdepth { - log.Printf("in too deep") + ilog.Printf("in too deep") return } obj, err := GetJunkHardMode(xid) if err != nil { - log.Printf("error getting onemore: %s: %s", xid, err) + ilog.Printf("error getting onemore: %s: %s", xid, err) return } depth++ @@ -506,16 +505,16 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { return nil } if originate(xid) != origin { - log.Printf("forged delete: %s", xid) + ilog.Printf("forged delete: %s", xid) return nil } - log.Printf("eradicating %s", xid) + ilog.Printf("eradicating %s", xid) eradicatexonk(user.ID, xid) return nil case "Remove": xid, _ = item.GetString("object") targ, _ := obj.GetString("target") - log.Printf("remove %s from %s", obj, targ) + ilog.Printf("remove %s from %s", obj, targ) return nil case "Tombstone": xid, _ = item.GetString("id") @@ -523,10 +522,10 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { return nil } if originate(xid) != origin { - log.Printf("forged delete: %s", xid) + ilog.Printf("forged delete: %s", xid) return nil } - log.Printf("eradicating %s", xid) + ilog.Printf("eradicating %s", xid) eradicatexonk(user.ID, xid) return nil case "Announce": @@ -539,10 +538,10 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { if !needbonkid(user, xid) { return nil } - log.Printf("getting bonk: %s", xid) + dlog.Printf("getting bonk: %s", xid) obj, err = GetJunkHardMode(xid) if err != nil { - log.Printf("error getting bonk: %s: %s", xid, err) + ilog.Printf("error getting bonk: %s: %s", xid, err) } origin = originate(xid) what = "bonk" @@ -553,18 +552,18 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { obj, ok = item.GetMap("object") if !ok { xid, _ = item.GetString("object") - log.Printf("getting created honk: %s", xid) + dlog.Printf("getting created honk: %s", xid) if originate(xid) != origin { - log.Printf("out of bounds %s not from %s", xid, origin) + ilog.Printf("out of bounds %s not from %s", xid, origin) return nil } obj, err = GetJunkHardMode(xid) if err != nil { - log.Printf("error getting creation: %s", err) + ilog.Printf("error getting creation: %s", err) } } if obj == nil { - log.Printf("no object for creation %s", id) + ilog.Printf("no object for creation %s", id) return nil } return xonkxonkfn(obj, origin, isUpdate) @@ -572,12 +571,12 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { xid, ok = item.GetString("object") if ok { if !needxonkid(user, xid) { - log.Printf("don't need read obj: %s", xid) + dlog.Printf("don't need read obj: %s", xid) return nil } obj, err = GetJunkHardMode(xid) if err != nil { - log.Printf("error getting read: %s", err) + ilog.Printf("error getting read: %s", err) return nil } return xonkxonkfn(obj, originate(xid), false) @@ -588,12 +587,12 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { if ok { // check target... if !needxonkid(user, xid) { - log.Printf("don't need added obj: %s", xid) + dlog.Printf("don't need added obj: %s", xid) return nil } obj, err = GetJunkHardMode(xid) if err != nil { - log.Printf("error getting add: %s", err) + ilog.Printf("error getting add: %s", err) return nil } return xonkxonkfn(obj, originate(xid), false) @@ -624,7 +623,7 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { obj = item what = "chonk" default: - log.Printf("unknown activity: %s", what) + ilog.Printf("unknown activity: %s", what) dumpactivity(item) return nil } @@ -634,13 +633,13 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { } if xid == "" { - log.Printf("don't know what xid is") - item.Write(os.Stdout) + ilog.Printf("don't know what xid is") + item.Write(ilog.Writer()) return nil } if originate(xid) != origin { - log.Printf("original sin: %s not from %s", xid, origin) - item.Write(os.Stdout) + ilog.Printf("original sin: %s not from %s", xid, origin) + item.Write(ilog.Writer()) return nil } @@ -729,14 +728,14 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { what = "tonk" } if len(content) > 90001 { - log.Printf("content too long. truncating") + ilog.Printf("content too long. truncating") content = content[:90001] } xonk.Noise = content xonk.Precis = precis if rejectxonk(&xonk) { - log.Printf("fast reject: %s", xid) + dlog.Printf("fast reject: %s", xid) return nil } @@ -771,16 +770,16 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { } localize := false if numatts > 4 { - log.Printf("excessive attachment: %s", at) + ilog.Printf("excessive attachment: %s", at) } else if at == "Document" || at == "Image" { mt = strings.ToLower(mt) - log.Printf("attachment: %s %s", mt, u) + dlog.Printf("attachment: %s %s", mt, u) if mt == "text/plain" || mt == "application/pdf" || strings.HasPrefix(mt, "image") { localize = true } } else { - log.Printf("unknown attachment: %s", at) + ilog.Printf("unknown attachment: %s", at) } if skipMedia(&xonk) { localize = false @@ -795,7 +794,7 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { for _, atti := range atts { att, ok := atti.(junk.Junk) if !ok { - log.Printf("attachment that wasn't map?") + ilog.Printf("attachment that wasn't map?") continue } procatt(att) @@ -934,10 +933,10 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { } if isUpdate { - log.Printf("something has changed! %s", xonk.XID) + dlog.Printf("something has changed! %s", xonk.XID) prev := getxonk(user.ID, xonk.XID) if prev == nil { - log.Printf("didn't find old version for update: %s", xonk.XID) + ilog.Printf("didn't find old version for update: %s", xonk.XID) isUpdate = false } else { xonk.ID = prev.ID @@ -971,7 +970,7 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { if goingup == 0 { for _, replid := range replies { if needxonkid(user, replid) { - log.Printf("missing a reply: %s", replid) + dlog.Printf("missing a reply: %s", replid) saveonemore(replid) } } @@ -985,7 +984,7 @@ func xonksaver(user *WhatAbout, item junk.Junk, origin string) *Honk { func dumpactivity(item junk.Junk) { fd, err := os.OpenFile("savedinbox.json", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) if err != nil { - log.Printf("error opening inbox! %s", err) + elog.Printf("error opening inbox! %s", err) return } defer fd.Close() @@ -1028,7 +1027,7 @@ func itakeitallback(user *WhatAbout, xid string, owner string, folxid string) { func subsub(user *WhatAbout, xid string, owner string, folxid string) { if xid == "" { - log.Printf("can't subscribe to empty") + ilog.Printf("can't subscribe to empty") return } j := junk.New() @@ -1508,7 +1507,7 @@ func asjonker(name string) ([]byte, bool) { var handfull = cache.New(cache.Options{Filler: func(name string) (string, bool) { m := strings.Split(name, "@") if len(m) != 2 { - log.Printf("bad fish name: %s", name) + dlog.Printf("bad fish name: %s", name) return "", true } var href string @@ -1517,10 +1516,10 @@ var handfull = cache.New(cache.Options{Filler: func(name string) (string, bool) if err == nil { return href, true } - log.Printf("fishing for %s", name) + dlog.Printf("fishing for %s", name) j, err := GetJunkFast(fmt.Sprintf("https://%s/.well-known/webfinger?resource=acct:%s", m[1], name)) if err != nil { - log.Printf("failed to go fish %s: %s", name, err) + ilog.Printf("failed to go fish %s: %s", name, err) return "", true } links, _ := j.GetArray("links") @@ -1536,7 +1535,7 @@ var handfull = cache.New(cache.Options{Filler: func(name string) (string, bool) when := time.Now().UTC().Format(dbtimeformat) _, err := stmtSaveXonker.Exec(name, href, "fishname", when) if err != nil { - log.Printf("error saving fishname: %s", err) + elog.Printf("error saving fishname: %s", err) } return href, true } @@ -1624,33 +1623,33 @@ func ingestpubkey(origin string, obj junk.Junk) { return } if !ok || origin != originate(keyname) { - log.Printf("bad key origin %s <> %s", origin, keyname) + ilog.Printf("bad key origin %s <> %s", origin, keyname) return } - log.Printf("ingesting a needed pubkey: %s", keyname) + dlog.Printf("ingesting a needed pubkey: %s", keyname) owner, ok := obj.GetString("owner") if !ok { - log.Printf("error finding %s pubkey owner", keyname) + ilog.Printf("error finding %s pubkey owner", keyname) return } data, ok = obj.GetString("publicKeyPem") if !ok { - log.Printf("error finding %s pubkey", keyname) + ilog.Printf("error finding %s pubkey", keyname) return } if originate(owner) != origin { - log.Printf("bad key owner: %s <> %s", owner, origin) + ilog.Printf("bad key owner: %s <> %s", owner, origin) return } _, _, err = httpsig.DecodeKey(data) if err != nil { - log.Printf("error decoding %s pubkey: %s", keyname, err) + ilog.Printf("error decoding %s pubkey: %s", keyname, err) return } when := time.Now().UTC().Format(dbtimeformat) _, err = stmtSaveXonker.Exec(keyname, data, "pubkey", when) if err != nil { - log.Printf("error saving key: %s", err) + elog.Printf("error saving key: %s", err) } } @@ -1668,7 +1667,7 @@ func ingestboxes(origin string, obj junk.Junk) { if err == nil { return } - log.Printf("ingesting boxes: %s", ident) + dlog.Printf("ingesting boxes: %s", ident) inbox, _ := obj.GetString("inbox") outbox, _ := obj.GetString("outbox") sbox, _ := obj.GetString("endpoints", "sharedInbox") @@ -1677,7 +1676,7 @@ func ingestboxes(origin string, obj junk.Junk) { m := strings.Join([]string{inbox, outbox, sbox}, " ") _, err = stmtSaveXonker.Exec(ident, m, "boxes", when) if err != nil { - log.Printf("error saving boxes: %s", err) + elog.Printf("error saving boxes: %s", err) } } } @@ -1701,7 +1700,7 @@ func ingesthandle(origin string, obj junk.Junk) { when := time.Now().UTC().Format(dbtimeformat) _, err = stmtSaveXonker.Exec(xid, handle, "handle", when) if err != nil { - log.Printf("error saving handle: %s", err) + elog.Printf("error saving handle: %s", err) } } } @@ -1742,17 +1741,17 @@ func updateMe(username string) { func followme(user *WhatAbout, who string, name string, j junk.Junk) { folxid, _ := j.GetString("id") - log.Printf("updating honker follow: %s %s", who, folxid) + ilog.Printf("updating honker follow: %s %s", who, folxid) var x string db := opendatabase() row := db.QueryRow("select xid from honkers where name = ? and xid = ? and userid = ? and flavor in ('dub', 'undub')", name, who, user.ID) err := row.Scan(&x) if err != sql.ErrNoRows { - log.Printf("duplicate follow request: %s", who) + ilog.Printf("duplicate follow request: %s", who) _, err = stmtUpdateFlavor.Exec("dub", folxid, user.ID, name, who, "undub") if err != nil { - log.Printf("error updating honker: %s", err) + elog.Printf("error updating honker: %s", err) } } else { stmtSaveDub.Exec(user.ID, name, who, "dub", folxid) @@ -1770,16 +1769,16 @@ func unfollowme(user *WhatAbout, who string, name string, j junk.Junk) { err := row.Scan(&who, &name) if err != nil { if err != sql.ErrNoRows { - log.Printf("error scanning honker: %s", err) + elog.Printf("error scanning honker: %s", err) } return } } - log.Printf("updating honker undo: %s %s", who, folxid) + ilog.Printf("updating honker undo: %s %s", who, folxid) _, err := stmtUpdateFlavor.Exec("undub", folxid, user.ID, name, who, "dub") if err != nil { - log.Printf("error updating honker: %s", err) + elog.Printf("error updating honker: %s", err) return } } @@ -1791,14 +1790,14 @@ func followyou(user *WhatAbout, honkerid int64) { honkerid, user.ID) err := row.Scan(&url, &owner) if err != nil { - log.Printf("can't get honker xid: %s", err) + elog.Printf("can't get honker xid: %s", err) return } folxid := xfiltrate() - log.Printf("subscribing to %s", url) + ilog.Printf("subscribing to %s", url) _, err = db.Exec("update honkers set flavor = ?, folxid = ? where honkerid = ?", "presub", folxid, honkerid) if err != nil { - log.Printf("error updating honker: %s", err) + elog.Printf("error updating honker: %s", err) return } go subsub(user, url, owner, folxid) @@ -1811,13 +1810,13 @@ func unfollowyou(user *WhatAbout, honkerid int64) { var url, owner, folxid string err := row.Scan(&url, &owner, &folxid) if err != nil { - log.Printf("can't get honker xid: %s", err) + elog.Printf("can't get honker xid: %s", err) return } - log.Printf("unsubscribing from %s", url) + ilog.Printf("unsubscribing from %s", url) _, err = db.Exec("update honkers set flavor = ? where honkerid = ?", "unsub", honkerid) if err != nil { - log.Printf("error updating honker: %s", err) + elog.Printf("error updating honker: %s", err) return } go itakeitallback(user, url, owner, folxid) @@ -1826,19 +1825,19 @@ func unfollowyou(user *WhatAbout, honkerid int64) { func followyou2(user *WhatAbout, j junk.Junk) { who, _ := j.GetString("actor") - log.Printf("updating honker accept: %s", who) + ilog.Printf("updating honker accept: %s", who) db := opendatabase() row := db.QueryRow("select name, folxid from honkers where userid = ? and xid = ? and flavor in ('presub')", user.ID, who) var name, folxid string err := row.Scan(&name, &folxid) if err != nil { - log.Printf("can't get honker name: %s", err) + elog.Printf("can't get honker name: %s", err) return } _, err = stmtUpdateFlavor.Exec("sub", folxid, user.ID, name, who, "presub") if err != nil { - log.Printf("error updating honker: %s", err) + elog.Printf("error updating honker: %s", err) return } } @@ -1846,20 +1845,20 @@ func followyou2(user *WhatAbout, j junk.Junk) { func nofollowyou2(user *WhatAbout, j junk.Junk) { who, _ := j.GetString("actor") - log.Printf("updating honker reject: %s", who) + ilog.Printf("updating honker reject: %s", who) db := opendatabase() row := db.QueryRow("select name, folxid from honkers where userid = ? and xid = ? and flavor in ('presub', 'sub')", user.ID, who) var name, folxid string err := row.Scan(&name, &folxid) if err != nil { - log.Printf("can't get honker name: %s", err) + elog.Printf("can't get honker name: %s", err) return } _, err = stmtUpdateFlavor.Exec("unsub", folxid, user.ID, name, who, "presub") _, err = stmtUpdateFlavor.Exec("unsub", folxid, user.ID, name, who, "sub") if err != nil { - log.Printf("error updating honker: %s", err) + elog.Printf("error updating honker: %s", err) return } } diff --git a/admin.go b/admin.go index 10938d0..54a611b 100644 --- a/admin.go +++ b/admin.go @@ -27,15 +27,13 @@ import "C" import ( "bufio" "fmt" - "io/ioutil" - "log" "os" "os/signal" "strings" ) func adminscreen() { - log.SetOutput(ioutil.Discard) + initLogging("null", "null", "null") stdout := bufio.NewWriter(os.Stdout) esc := "\x1b" smcup := esc + "[?1049h" diff --git a/avatar.go b/avatar.go index bfba151..7c7d615 100644 --- a/avatar.go +++ b/avatar.go @@ -22,7 +22,6 @@ import ( "fmt" "image" "image/png" - "log" "net/http" "regexp" "strconv" @@ -56,7 +55,7 @@ func loadAvatarColors() { } c, err := strconv.ParseUint(l, 16, 32) if err != nil { - log.Printf("error reading avatar color %d: %s", i, err) + elog.Printf("error reading avatar color %d: %s", i, err) continue } avatarcolors[i][0] = byte(c >> 24 & 0xff) diff --git a/backend.go b/backend.go index 2ca1d1a..ad74e22 100644 --- a/backend.go +++ b/backend.go @@ -17,7 +17,6 @@ package main import ( "bytes" - "log" "net" "net/rpc" "os" @@ -76,27 +75,27 @@ func shrinkit(data []byte) (*image.Image, error) { var backendhooks []func() func backendServer() { - log.Printf("backend server running") + dlog.Printf("backend server running") shrinker := new(Shrinker) srv := rpc.NewServer() err := srv.Register(shrinker) if err != nil { - log.Panicf("unable to register shrinker: %s", err) + elog.Panicf("unable to register shrinker: %s", err) } sockname := backendSockname() err = os.Remove(sockname) if err != nil && !os.IsNotExist(err) { - log.Panicf("unable to unlink socket: %s", err) + elog.Panicf("unable to unlink socket: %s", err) } lis, err := net.Listen("unix", sockname) if err != nil { - log.Panicf("unable to register shrinker: %s", err) + elog.Panicf("unable to register shrinker: %s", err) } err = setLimits() if err != nil { - log.Printf("error setting backend limits: %s", err) + elog.Printf("error setting backend limits: %s", err) } for _, h := range backendhooks { h() @@ -110,8 +109,8 @@ func runBackendServer() { proc.Stderr = os.Stderr err := proc.Start() if err != nil { - log.Panicf("can't exec backend: %s", err) + elog.Panicf("can't exec backend: %s", err) } err = proc.Wait() - log.Printf("lost the backend: %s", err) + elog.Printf("lost the backend: %s", err) } diff --git a/backupdb.go b/backupdb.go index 088cb54..10d1853 100644 --- a/backupdb.go +++ b/backupdb.go @@ -3,7 +3,6 @@ package main import ( "database/sql" "fmt" - "log" "os" "time" @@ -13,7 +12,7 @@ import ( func qordie(db *sql.DB, s string, args ...interface{}) *sql.Rows { rows, err := db.Query(s, args...) if err != nil { - log.Fatalf("can't query %s: %s", s, err) + elog.Fatalf("can't query %s: %s", s, err) } return rows } @@ -21,31 +20,31 @@ func qordie(db *sql.DB, s string, args ...interface{}) *sql.Rows { func scanordie(rows *sql.Rows, args ...interface{}) { err := rows.Scan(args...) if err != nil { - log.Fatalf("can't scan: %s", err) + elog.Fatalf("can't scan: %s", err) } } func svalbard(dirname string) { err := os.Mkdir(dirname, 0700) if err != nil && !os.IsExist(err) { - log.Fatalf("can't create directory: %s", dirname) + elog.Fatalf("can't create directory: %s", dirname) } now := time.Now().Unix() backupdbname := fmt.Sprintf("%s/honk-%d.db", dirname, now) backup, err := sql.Open("sqlite3", backupdbname) if err != nil { - log.Fatalf("can't open backup database") + elog.Fatalf("can't open backup database") } for _, line := range strings.Split(sqlSchema, ";") { _, err = backup.Exec(line) if err != nil { - log.Fatal(err) + elog.Fatal(err) return } } tx, err := backup.Begin() if err != nil { - log.Fatal(err) + elog.Fatal(err) } orig := opendatabase() rows := qordie(orig, "select userid, username, hash, displayname, about, pubkey, seckey, options from users") @@ -161,21 +160,21 @@ func svalbard(dirname string) { err = tx.Commit() if err != nil { - log.Fatalf("can't commit backp: %s", err) + elog.Fatalf("can't commit backp: %s", err) } backup.Close() backupblobname := fmt.Sprintf("%s/blob-%d.db", dirname, now) blob, err := sql.Open("sqlite3", backupblobname) if err != nil { - log.Fatalf("can't open backup blob database") + elog.Fatalf("can't open backup blob database") } doordie(blob, "create table filedata (xid text, media text, hash text, content blob)") doordie(blob, "create index idx_filexid on filedata(xid)") doordie(blob, "create index idx_filehash on filedata(hash)") tx, err = blob.Begin() if err != nil { - log.Fatalf("can't start transaction: %s", err) + elog.Fatalf("can't start transaction: %s", err) } origblob := openblobdb() for x := range filexids { @@ -191,7 +190,7 @@ func svalbard(dirname string) { err = tx.Commit() if err != nil { - log.Fatalf("can't commit blobs: %s", err) + elog.Fatalf("can't commit blobs: %s", err) } blob.Close() } diff --git a/database.go b/database.go index a78d36f..614d17e 100644 --- a/database.go +++ b/database.go @@ -22,7 +22,6 @@ import ( "encoding/json" "fmt" "html/template" - "log" "sort" "strconv" "strings" @@ -49,7 +48,7 @@ func userfromrow(row *sql.Row) (*WhatAbout, error) { user.URL = fmt.Sprintf("https://%s/%s/%s", serverName, userSep, user.Name) err = unjsonify(options, &user.Options) if err != nil { - log.Printf("error processing user options: %s", err) + elog.Printf("error processing user options: %s", err) } } else { user.URL = fmt.Sprintf("https://%s/%s", serverName, user.Name) @@ -88,7 +87,7 @@ func getserveruser() *WhatAbout { var user *WhatAbout ok := somenumberedusers.Get(serverUID, &user) if !ok { - log.Panicf("lost server user") + elog.Panicf("lost server user") } return user } @@ -107,7 +106,7 @@ var honkerinvalidator cache.Invalidator func gethonkers(userid int64) []*Honker { rows, err := stmtHonkers.Query(userid) if err != nil { - log.Printf("error querying honkers: %s", err) + elog.Printf("error querying honkers: %s", err) return nil } defer rows.Close() @@ -120,7 +119,7 @@ func gethonkers(userid int64) []*Honker { err = unjsonify(meta, &h.Meta) } if err != nil { - log.Printf("error scanning honker: %s", err) + elog.Printf("error scanning honker: %s", err) continue } h.Combos = strings.Split(strings.TrimSpace(combos), " ") @@ -141,7 +140,7 @@ func getnameddubs(userid int64, name string) []*Honker { func dubsfromrows(rows *sql.Rows, err error) []*Honker { if err != nil { - log.Printf("error querying dubs: %s", err) + elog.Printf("error querying dubs: %s", err) return nil } defer rows.Close() @@ -150,7 +149,7 @@ func dubsfromrows(rows *sql.Rows, err error) []*Honker { h := new(Honker) err = rows.Scan(&h.ID, &h.UserID, &h.Name, &h.XID, &h.Flavor) if err != nil { - log.Printf("error scanning honker: %s", err) + elog.Printf("error scanning honker: %s", err) return nil } honkers = append(honkers, h) @@ -340,7 +339,7 @@ func reversehonks(honks []*Honk) { func getsomehonks(rows *sql.Rows, err error) []*Honk { if err != nil { - log.Printf("error querying honks: %s", err) + elog.Printf("error querying honks: %s", err) return nil } defer rows.Close() @@ -367,7 +366,7 @@ func scanhonk(row RowLike) *Honk { &dt, &h.URL, &aud, &h.Noise, &h.Precis, &h.Format, &h.Convoy, &h.Whofore, &h.Flags) if err != nil { if err != sql.ErrNoRows { - log.Printf("error scanning honk: %s", err) + elog.Printf("error scanning honk: %s", err) } return nil } @@ -390,7 +389,7 @@ func donksforhonks(honks []*Honk) { q := fmt.Sprintf("select honkid, donks.fileid, xid, name, description, url, media, local from donks join filemeta on donks.fileid = filemeta.fileid where honkid in (%s)", idset) rows, err := db.Query(q) if err != nil { - log.Printf("error querying donks: %s", err) + elog.Printf("error querying donks: %s", err) return } defer rows.Close() @@ -399,7 +398,7 @@ func donksforhonks(honks []*Honk) { d := new(Donk) err = rows.Scan(&hid, &d.FileID, &d.XID, &d.Name, &d.Desc, &d.URL, &d.Media, &d.Local) if err != nil { - log.Printf("error scanning donk: %s", err) + elog.Printf("error scanning donk: %s", err) continue } d.External = !strings.HasPrefix(d.URL, serverPrefix) @@ -412,7 +411,7 @@ func donksforhonks(honks []*Honk) { q = fmt.Sprintf("select honkid, ontology from onts where honkid in (%s)", idset) rows, err = db.Query(q) if err != nil { - log.Printf("error querying onts: %s", err) + elog.Printf("error querying onts: %s", err) return } defer rows.Close() @@ -421,7 +420,7 @@ func donksforhonks(honks []*Honk) { var o string err = rows.Scan(&hid, &o) if err != nil { - log.Printf("error scanning donk: %s", err) + elog.Printf("error scanning donk: %s", err) continue } h := hmap[hid] @@ -433,7 +432,7 @@ func donksforhonks(honks []*Honk) { q = fmt.Sprintf("select honkid, genus, json from honkmeta where honkid in (%s)", idset) rows, err = db.Query(q) if err != nil { - log.Printf("error querying honkmeta: %s", err) + elog.Printf("error querying honkmeta: %s", err) return } defer rows.Close() @@ -442,7 +441,7 @@ func donksforhonks(honks []*Honk) { var genus, j string err = rows.Scan(&hid, &genus, &j) if err != nil { - log.Printf("error scanning honkmeta: %s", err) + elog.Printf("error scanning honkmeta: %s", err) continue } h := hmap[hid] @@ -451,7 +450,7 @@ func donksforhonks(honks []*Honk) { p := new(Place) err = unjsonify(j, p) if err != nil { - log.Printf("error parsing place: %s", err) + elog.Printf("error parsing place: %s", err) continue } h.Place = p @@ -459,25 +458,25 @@ func donksforhonks(honks []*Honk) { t := new(Time) err = unjsonify(j, t) if err != nil { - log.Printf("error parsing time: %s", err) + elog.Printf("error parsing time: %s", err) continue } h.Time = t case "mentions": err = unjsonify(j, &h.Mentions) if err != nil { - log.Printf("error parsing mentions: %s", err) + elog.Printf("error parsing mentions: %s", err) continue } case "badonks": err = unjsonify(j, &h.Badonks) if err != nil { - log.Printf("error parsing badonks: %s", err) + elog.Printf("error parsing badonks: %s", err) continue } case "oldrev": default: - log.Printf("unknown meta genus: %s", genus) + elog.Printf("unknown meta genus: %s", genus) } } rows.Close() @@ -496,7 +495,7 @@ func donksforchonks(chonks []*Chonk) { q := fmt.Sprintf("select chonkid, donks.fileid, xid, name, description, url, media, local from donks join filemeta on donks.fileid = filemeta.fileid where chonkid in (%s)", idset) rows, err := db.Query(q) if err != nil { - log.Printf("error querying donks: %s", err) + elog.Printf("error querying donks: %s", err) return } defer rows.Close() @@ -505,7 +504,7 @@ func donksforchonks(chonks []*Chonk) { d := new(Donk) err = rows.Scan(&chid, &d.FileID, &d.XID, &d.Name, &d.Desc, &d.URL, &d.Media, &d.Local) if err != nil { - log.Printf("error scanning donk: %s", err) + elog.Printf("error scanning donk: %s", err) continue } ch := chmap[chid] @@ -547,7 +546,7 @@ func savefileandxid(name string, desc string, url string, media string, local bo return 0, "", err } } else if err != nil { - log.Printf("error checking file hash: %s", err) + elog.Printf("error checking file hash: %s", err) return 0, "", err } if url == "" { @@ -571,7 +570,7 @@ func finddonk(url string) *Donk { return donk } if err != sql.ErrNoRows { - log.Printf("error finding file: %s", err) + elog.Printf("error finding file: %s", err) } return nil } @@ -581,7 +580,7 @@ func savechonk(ch *Chonk) error { db := opendatabase() tx, err := db.Begin() if err != nil { - log.Printf("can't begin tx: %s", err) + elog.Printf("can't begin tx: %s", err) return err } @@ -591,7 +590,7 @@ func savechonk(ch *Chonk) error { for _, d := range ch.Donks { _, err := tx.Stmt(stmtSaveDonk).Exec(-1, ch.ID, d.FileID) if err != nil { - log.Printf("error saving donk: %s", err) + elog.Printf("error saving donk: %s", err) break } } @@ -616,7 +615,7 @@ func chatplusone(tx *sql.Tx, userid int64) { _, err = tx.Exec("update users set options = ? where username = ?", j, user.Name) } if err != nil { - log.Printf("error plussing chat: %s", err) + elog.Printf("error plussing chat: %s", err) } somenamedusers.Clear(user.Name) somenumberedusers.Clear(user.ID) @@ -636,7 +635,7 @@ func chatnewnone(userid int64) { _, err = db.Exec("update users set options = ? where username = ?", j, user.Name) } if err != nil { - log.Printf("error noneing chat: %s", err) + elog.Printf("error noneing chat: %s", err) } somenamedusers.Clear(user.Name) somenumberedusers.Clear(user.ID) @@ -655,7 +654,7 @@ func meplusone(tx *sql.Tx, userid int64) { _, err = tx.Exec("update users set options = ? where username = ?", j, user.Name) } if err != nil { - log.Printf("error plussing me: %s", err) + elog.Printf("error plussing me: %s", err) } somenamedusers.Clear(user.Name) somenumberedusers.Clear(user.ID) @@ -675,7 +674,7 @@ func menewnone(userid int64) { _, err = db.Exec("update users set options = ? where username = ?", j, user.Name) } if err != nil { - log.Printf("error noneing me: %s", err) + elog.Printf("error noneing me: %s", err) } somenamedusers.Clear(user.Name) somenumberedusers.Clear(user.ID) @@ -685,7 +684,7 @@ func loadchatter(userid int64) []*Chatter { duedt := time.Now().Add(-3 * 24 * time.Hour).UTC().Format(dbtimeformat) rows, err := stmtLoadChonks.Query(userid, duedt) if err != nil { - log.Printf("error loading chonks: %s", err) + elog.Printf("error loading chonks: %s", err) return nil } defer rows.Close() @@ -696,7 +695,7 @@ func loadchatter(userid int64) []*Chatter { var dt string err = rows.Scan(&ch.ID, &ch.UserID, &ch.XID, &ch.Who, &ch.Target, &dt, &ch.Noise, &ch.Format) if err != nil { - log.Printf("error scanning chonk: %s", err) + elog.Printf("error scanning chonk: %s", err) continue } ch.Date, _ = time.Parse(dbtimeformat, dt) @@ -707,14 +706,14 @@ func loadchatter(userid int64) []*Chatter { rows.Close() rows, err = stmtGetChatters.Query(userid) if err != nil { - log.Printf("error getting chatters: %s", err) + elog.Printf("error getting chatters: %s", err) return nil } for rows.Next() { var target string err = rows.Scan(&target) if err != nil { - log.Printf("error scanning chatter: %s", target) + elog.Printf("error scanning chatter: %s", target) continue } if _, ok := chonks[target]; !ok { @@ -750,7 +749,7 @@ func savehonk(h *Honk) error { db := opendatabase() tx, err := db.Begin() if err != nil { - log.Printf("can't begin tx: %s", err) + elog.Printf("can't begin tx: %s", err) return err } @@ -770,7 +769,7 @@ func savehonk(h *Honk) error { tx.Rollback() } if err != nil { - log.Printf("error saving honk: %s", err) + elog.Printf("error saving honk: %s", err) } honkhonkline() return err @@ -784,7 +783,7 @@ func updatehonk(h *Honk) error { db := opendatabase() tx, err := db.Begin() if err != nil { - log.Printf("can't begin tx: %s", err) + elog.Printf("can't begin tx: %s", err) return err } @@ -802,7 +801,7 @@ func updatehonk(h *Honk) error { _, err = tx.Stmt(stmtSaveMeta).Exec(old.ID, "oldrev", j) } if err != nil { - log.Printf("error saving oldrev: %s", err) + elog.Printf("error saving oldrev: %s", err) } } if err == nil { @@ -811,7 +810,7 @@ func updatehonk(h *Honk) error { tx.Rollback() } if err != nil { - log.Printf("error updating honk %d: %s", h.ID, err) + elog.Printf("error updating honk %d: %s", h.ID, err) } return err } @@ -820,7 +819,7 @@ func deletehonk(honkid int64) error { db := opendatabase() tx, err := db.Begin() if err != nil { - log.Printf("can't begin tx: %s", err) + elog.Printf("can't begin tx: %s", err) return err } @@ -834,7 +833,7 @@ func deletehonk(honkid int64) error { tx.Rollback() } if err != nil { - log.Printf("error deleting honk %d: %s", honkid, err) + elog.Printf("error deleting honk %d: %s", honkid, err) } return err } @@ -843,14 +842,14 @@ func saveextras(tx *sql.Tx, h *Honk) error { for _, d := range h.Donks { _, err := tx.Stmt(stmtSaveDonk).Exec(h.ID, -1, d.FileID) if err != nil { - log.Printf("error saving donk: %s", err) + elog.Printf("error saving donk: %s", err) return err } } for _, o := range h.Onts { _, err := tx.Stmt(stmtSaveOnt).Exec(strings.ToLower(o), h.ID) if err != nil { - log.Printf("error saving ont: %s", err) + elog.Printf("error saving ont: %s", err) return err } } @@ -860,7 +859,7 @@ func saveextras(tx *sql.Tx, h *Honk) error { _, err = tx.Stmt(stmtSaveMeta).Exec(h.ID, "place", j) } if err != nil { - log.Printf("error saving place: %s", err) + elog.Printf("error saving place: %s", err) return err } } @@ -870,7 +869,7 @@ func saveextras(tx *sql.Tx, h *Honk) error { _, err = tx.Stmt(stmtSaveMeta).Exec(h.ID, "time", j) } if err != nil { - log.Printf("error saving time: %s", err) + elog.Printf("error saving time: %s", err) return err } } @@ -880,7 +879,7 @@ func saveextras(tx *sql.Tx, h *Honk) error { _, err = tx.Stmt(stmtSaveMeta).Exec(h.ID, "mentions", j) } if err != nil { - log.Printf("error saving mentions: %s", err) + elog.Printf("error saving mentions: %s", err) return err } } @@ -970,13 +969,13 @@ func cleanupdb(arg string) { blobdb := openblobdb() rows, err := blobdb.Query("select xid from filedata") if err != nil { - log.Fatal(err) + elog.Fatal(err) } for rows.Next() { var xid string err = rows.Scan(&xid) if err != nil { - log.Fatal(err) + elog.Fatal(err) } filexids[xid] = true } @@ -986,24 +985,24 @@ func cleanupdb(arg string) { var xid string err = rows.Scan(&xid) if err != nil { - log.Fatal(err) + elog.Fatal(err) } delete(filexids, xid) } rows.Close() tx, err := blobdb.Begin() if err != nil { - log.Fatal(err) + elog.Fatal(err) } for xid, _ := range filexids { _, err = tx.Exec("delete from filedata where xid = ?", xid) if err != nil { - log.Fatal(err) + elog.Fatal(err) } } err = tx.Commit() if err != nil { - log.Fatal(err) + elog.Fatal(err) } } @@ -1029,7 +1028,7 @@ var stmtSaveChonk, stmtLoadChonks, stmtGetChatters *sql.Stmt func preparetodie(db *sql.DB, s string) *sql.Stmt { stmt, err := db.Prepare(s) if err != nil { - log.Fatalf("error %s: %s", err, s) + elog.Fatalf("error %s: %s", err, s) } return stmt } diff --git a/deliverator.go b/deliverator.go index 6f7a08a..4b6303f 100644 --- a/deliverator.go +++ b/deliverator.go @@ -17,7 +17,6 @@ package main import ( "fmt" - "log" notrand "math/rand" "time" @@ -43,7 +42,7 @@ func sayitagain(goarounds int64, userid int64, rcpt string, msg []byte) { case 5: drift = 24 * time.Hour default: - log.Printf("he's dead jim: %s", rcpt) + ilog.Printf("he's dead jim: %s", rcpt) clearoutbound(rcpt) return } @@ -51,7 +50,7 @@ func sayitagain(goarounds int64, userid int64, rcpt string, msg []byte) { when := time.Now().UTC().Add(drift) _, err := stmtAddDoover.Exec(when.Format(dbtimeformat), goarounds, userid, rcpt, msg) if err != nil { - log.Printf("error saving doover: %s", err) + elog.Printf("error saving doover: %s", err) } select { case pokechan <- 0: @@ -65,7 +64,7 @@ func clearoutbound(rcpt string) { return } xid := fmt.Sprintf("%%https://%s/%%", hostname) - log.Printf("clearing outbound for %s", xid) + ilog.Printf("clearing outbound for %s", xid) db := opendatabase() db.Exec("delete from doovers where rcpt like ?", xid) } @@ -79,7 +78,7 @@ func deliverate(goarounds int64, userid int64, rcpt string, msg []byte, prio boo var ki *KeyInfo ok := ziggies.Get(userid, &ki) if !ok { - log.Printf("lost key for delivery") + elog.Printf("lost key for delivery") return } var inbox string @@ -90,7 +89,7 @@ func deliverate(goarounds int64, userid int64, rcpt string, msg []byte, prio boo var box *Box ok := boxofboxes.Get(rcpt, &box) if !ok { - log.Printf("failed getting inbox for %s", rcpt) + ilog.Printf("failed getting inbox for %s", rcpt) sayitagain(goarounds+1, userid, rcpt, msg) return } @@ -98,7 +97,7 @@ func deliverate(goarounds int64, userid int64, rcpt string, msg []byte, prio boo } err := PostMsg(ki.keyname, ki.seckey, inbox, msg) if err != nil { - log.Printf("failed to post json to %s: %s", inbox, err) + ilog.Printf("failed to post json to %s: %s", inbox, err) if prio { sayitagain(goarounds+1, userid, rcpt, msg) } @@ -111,7 +110,7 @@ var pokechan = make(chan int, 1) func getdoovers() []Doover { rows, err := stmtGetDoovers.Query() if err != nil { - log.Printf("wat?") + elog.Printf("wat?") time.Sleep(1 * time.Minute) return nil } @@ -122,7 +121,7 @@ func getdoovers() []Doover { var dt string err := rows.Scan(&d.ID, &dt) if err != nil { - log.Printf("error scanning dooverid: %s", err) + elog.Printf("error scanning dooverid: %s", err) continue } d.When, _ = time.Parse(dbtimeformat, dt) @@ -155,15 +154,15 @@ func redeliverator() { row := stmtLoadDoover.QueryRow(d.ID) err := row.Scan(&goarounds, &userid, &rcpt, &msg) if err != nil { - log.Printf("error scanning doover: %s", err) + elog.Printf("error scanning doover: %s", err) continue } _, err = stmtZapDoover.Exec(d.ID) if err != nil { - log.Printf("error deleting doover: %s", err) + elog.Printf("error deleting doover: %s", err) continue } - log.Printf("redeliverating %s try %d", rcpt, goarounds) + ilog.Printf("redeliverating %s try %d", rcpt, goarounds) deliverate(goarounds, userid, rcpt, msg, true) } else if d.When.Before(nexttime) { nexttime = d.When diff --git a/fun.go b/fun.go index be27d07..0a41b56 100644 --- a/fun.go +++ b/fun.go @@ -21,7 +21,6 @@ import ( "fmt" "html/template" "io" - "log" "net/http" "net/url" "os" @@ -265,7 +264,7 @@ func inlineimgsfor(honk *Honk) func(node *html.Node) string { if d != nil { honk.Donks = append(honk.Donks, d) } - log.Printf("inline img with src: %s", src) + dlog.Printf("inline img with src: %s", src) return "" } } @@ -411,7 +410,7 @@ func memetize(honk *Honk) { } fd, err := os.Open(dataDir + "/memes/" + name) if err != nil { - log.Printf("no meme for %s", name) + ilog.Printf("no meme for %s", name) return x } var peek [512]byte @@ -422,7 +421,7 @@ func memetize(honk *Honk) { url := fmt.Sprintf("https://%s/meme/%s", serverName, name) fileid, err := savefile(name, name, url, ct, false, nil) if err != nil { - log.Printf("error saving meme: %s", err) + elog.Printf("error saving meme: %s", err) return x } d := &Donk{ @@ -540,7 +539,7 @@ var allhandles = cache.New(cache.Options{Filler: func(xid string) (string, bool) row := stmtGetXonker.QueryRow(xid, "handle") err := row.Scan(&handle) if err != nil { - log.Printf("need to get a handle: %s", xid) + dlog.Printf("need to get a handle: %s", xid) info, err := investigate(xid) if err != nil { m := re_unurl.FindStringSubmatch(xid) @@ -628,10 +627,10 @@ var zaggies = cache.New(cache.Options{Filler: func(keyname string) (httpsig.Publ err := row.Scan(&data) var key httpsig.PublicKey if err != nil { - log.Printf("hitting the webs for missing pubkey: %s", keyname) + dlog.Printf("hitting the webs for missing pubkey: %s", keyname) j, err := GetJunk(keyname) if err != nil { - log.Printf("error getting %s pubkey: %s", keyname, err) + ilog.Printf("error getting %s pubkey: %s", keyname, err) when := time.Now().UTC().Format(dbtimeformat) stmtSaveXonker.Exec(keyname, "failed", "pubkey", when) return key, true @@ -640,7 +639,7 @@ var zaggies = cache.New(cache.Options{Filler: func(keyname string) (httpsig.Publ row = stmtGetXonker.QueryRow(keyname, "pubkey") err = row.Scan(&data) if err != nil { - log.Printf("key not found after ingesting") + ilog.Printf("key not found after ingesting") when := time.Now().UTC().Format(dbtimeformat) stmtSaveXonker.Exec(keyname, "failed", "pubkey", when) return key, true @@ -648,7 +647,7 @@ var zaggies = cache.New(cache.Options{Filler: func(keyname string) (httpsig.Publ } _, key, err = httpsig.DecodeKey(data) if err != nil { - log.Printf("error decoding %s pubkey: %s", keyname, err) + ilog.Printf("error decoding %s pubkey: %s", keyname, err) return key, true } return key, true diff --git a/hfcs.go b/hfcs.go index 5584d19..610cef2 100644 --- a/hfcs.go +++ b/hfcs.go @@ -16,7 +16,6 @@ package main import ( - "log" "net/http" "regexp" "sort" @@ -78,7 +77,7 @@ func init() { func filtcachefiller(userid int64) (afiltermap, bool) { rows, err := stmtGetFilters.Query(userid) if err != nil { - log.Printf("error querying filters: %s", err) + elog.Printf("error querying filters: %s", err) return nil, false } defer rows.Close() @@ -97,7 +96,7 @@ func filtcachefiller(userid int64) (afiltermap, bool) { err = unjsonify(j, filt) } if err != nil { - log.Printf("error scanning filter: %s", err) + elog.Printf("error scanning filter: %s", err) continue } if !filt.Expiration.IsZero() { @@ -120,7 +119,7 @@ func filtcachefiller(userid int64) (afiltermap, bool) { } filt.re_text, err = regexp.Compile(t) if err != nil { - log.Printf("error compiling filter text: %s", err) + elog.Printf("error compiling filter text: %s", err) continue } } @@ -136,7 +135,7 @@ func filtcachefiller(userid int64) (afiltermap, bool) { } filt.re_rewrite, err = regexp.Compile(t) if err != nil { - log.Printf("error compiling filter rewrite: %s", err) + elog.Printf("error compiling filter rewrite: %s", err) continue } } @@ -244,7 +243,7 @@ func rejectactor(userid int64, actor string) bool { continue } if f.Actor == actor { - log.Printf("rejecting actor: %s", actor) + ilog.Printf("rejecting actor: %s", actor) return true } } @@ -258,7 +257,7 @@ func rejectactor(userid int64, actor string) bool { continue } if f.Actor == origin { - log.Printf("rejecting actor: %s", actor) + ilog.Printf("rejecting actor: %s", actor) return true } } @@ -271,7 +270,7 @@ func stealthmode(userid int64, r *http.Request) bool { if agent != "" { fake := rejectorigin(userid, agent, false) if fake { - log.Printf("faking 404 for %s", agent) + ilog.Printf("faking 404 for %s", agent) return true } } @@ -355,7 +354,7 @@ func rejectxonk(xonk *Honk) bool { } for _, f := range filts { if cause := matchfilterX(xonk, f); cause != "" { - log.Printf("rejecting %s because %s", xonk.XID, cause) + ilog.Printf("rejecting %s because %s", xonk.XID, cause) return true } } @@ -407,7 +406,7 @@ func unsee(honks []*Honk, userid int64) { var untagged = cache.New(cache.Options{Filler: func(userid int64) (map[string]bool, bool) { rows, err := stmtUntagged.Query(userid) if err != nil { - log.Printf("error query untagged: %s", err) + elog.Printf("error query untagged: %s", err) return nil, false } defer rows.Close() @@ -417,7 +416,7 @@ var untagged = cache.New(cache.Options{Filler: func(userid int64) (map[string]bo var flags int64 err = rows.Scan(&xid, &rid, &flags) if err != nil { - log.Printf("error scanning untag: %s", err) + elog.Printf("error scanning untag: %s", err) continue } if flags&flagIsUntagged != 0 { diff --git a/honk.go b/honk.go index d2e4140..8027fbb 100644 --- a/honk.go +++ b/honk.go @@ -19,7 +19,6 @@ import ( "flag" "fmt" "html/template" - "log" notrand "math/rand" "os" "strconv" @@ -264,6 +263,14 @@ func main() { flag.StringVar(&dataDir, "datadir", dataDir, "data directory") flag.StringVar(&viewDir, "viewdir", viewDir, "view directory") flag.Parse() + + if alllogname != "stderr" { + elogname = alllogname + ilogname = alllogname + dlogname = alllogname + } + initLogging(elogname, ilogname, dlogname) + args := flag.Args() cmd := "run" if len(args) > 0 { @@ -282,7 +289,7 @@ func main() { dbversion := 0 getconfig("dbversion", &dbversion) if dbversion != myVersion { - log.Fatal("incorrect database version. run upgrade.") + elog.Fatal("incorrect database version. run upgrade.") } getconfig("servermsg", &serverMsg) getconfig("aboutmsg", &aboutMsg) @@ -302,12 +309,12 @@ func main() { adminscreen() case "import": if len(args) != 4 { - log.Fatal("import username mastodon|twitter srcdir") + elog.Fatal("import username mastodon|twitter srcdir") } importMain(args[1], args[2], args[3]) case "debug": if len(args) != 2 { - log.Fatal("need an argument: debug (on|off)") + elog.Fatal("need an argument: debug (on|off)") } switch args[1] { case "on": @@ -315,7 +322,7 @@ func main() { case "off": setconfig("debug", 0) default: - log.Fatal("argument must be on or off") + elog.Fatal("argument must be on or off") } case "adduser": adduser() @@ -356,7 +363,7 @@ func main() { targ := args[2] user, err := butwhatabout(name) if err != nil { - log.Printf("unknown user") + elog.Printf("unknown user") return } ping(user, targ) @@ -367,6 +374,6 @@ func main() { case "test": ElaborateUnitTests() default: - log.Fatal("unknown command") + elog.Fatal("unknown command") } } diff --git a/hoot.go b/hoot.go index 1b053db..5f2e2e0 100644 --- a/hoot.go +++ b/hoot.go @@ -18,7 +18,6 @@ package main import ( "fmt" "io" - "log" "net/http" "os" "regexp" @@ -41,7 +40,7 @@ var re_removepics = regexp.MustCompile(`pic\.twitter\.com/[[:alnum:]]+`) func hootextractor(r io.Reader, url string, seen map[string]bool) string { root, err := html.Parse(r) if err != nil { - log.Printf("error parsing hoot: %s", err) + elog.Printf("error parsing hoot: %s", err) return url } @@ -67,7 +66,7 @@ func hootextractor(r io.Reader, url string, seen map[string]bool) string { alink := linksel.MatchFirst(twp) if alink == nil { if i != 0 { - log.Printf("missing link") + dlog.Printf("missing link") continue } } else { @@ -79,7 +78,7 @@ func hootextractor(r io.Reader, url string, seen map[string]bool) string { } authormatch := authorregex.FindStringSubmatch(link) if len(authormatch) < 2 { - log.Printf("no author?: %s", link) + dlog.Printf("no author?: %s", link) continue } author := authormatch[1] @@ -116,10 +115,10 @@ func hooterize(noise string) string { url = url[1:] } url = strings.Replace(url, "mobile.twitter.com", "twitter.com", -1) - log.Printf("hooterizing %s", url) + dlog.Printf("hooterizing %s", url) req, err := http.NewRequest("GET", url, nil) if err != nil { - log.Printf("error: %s", err) + ilog.Printf("error: %s", err) return hoot } req.Header.Set("User-Agent", "Bot") @@ -127,12 +126,12 @@ func hooterize(noise string) string { req.Header.Set("Accept-Language", "en-US,en;q=0.9") resp, err := http.DefaultClient.Do(req) if err != nil { - log.Printf("error: %s", err) + ilog.Printf("error: %s", err) return hoot } defer resp.Body.Close() if resp.StatusCode != 200 { - log.Printf("error getting %s: %d", url, resp.StatusCode) + ilog.Printf("error getting %s: %d", url, resp.StatusCode) return hoot } ld, _ := os.Create("lasthoot.html") diff --git a/import.go b/import.go index 2d8b6ac..2679905 100644 --- a/import.go +++ b/import.go @@ -20,7 +20,6 @@ import ( "fmt" "html" "io/ioutil" - "log" "os" "regexp" "sort" @@ -35,7 +34,7 @@ func importMain(username, flavor, source string) { case "twitter": importTwitter(username, source) default: - log.Fatal("unknown source flavor") + elog.Fatal("unknown source flavor") } } @@ -68,7 +67,7 @@ func (obj *TootObject) UnmarshalJSON(b []byte) error { func importMastodon(username, source string) { user, err := butwhatabout(username) if err != nil { - log.Fatal(err) + elog.Fatal(err) } type Toot struct { Id string @@ -82,12 +81,12 @@ func importMastodon(username, source string) { } fd, err := os.Open(source + "/outbox.json") if err != nil { - log.Fatal(err) + elog.Fatal(err) } dec := json.NewDecoder(fd) err = dec.Decode(&outbox) if err != nil { - log.Fatalf("error parsing json: %s", err) + elog.Fatalf("error parsing json: %s", err) } fd.Close() @@ -139,7 +138,7 @@ func importMastodon(username, source string) { fname := fmt.Sprintf("%s/%s", source, att.Url) data, err := ioutil.ReadFile(fname) if err != nil { - log.Printf("error reading media: %s", fname) + elog.Printf("error reading media: %s", fname) continue } u := xfiltrate() @@ -148,7 +147,7 @@ func importMastodon(username, source string) { newurl := fmt.Sprintf("https://%s/d/%s", serverName, u) fileid, err := savefile(name, desc, newurl, att.MediaType, true, data) if err != nil { - log.Printf("error saving media: %s", fname) + elog.Printf("error saving media: %s", fname) continue } donk := &Donk{ @@ -170,7 +169,7 @@ func importMastodon(username, source string) { func importTwitter(username, source string) { user, err := butwhatabout(username) if err != nil { - log.Fatal(err) + elog.Fatal(err) } type Tweet struct { @@ -199,14 +198,14 @@ func importTwitter(username, source string) { var tweets []*Tweet fd, err := os.Open(source + "/tweet.js") if err != nil { - log.Fatal(err) + elog.Fatal(err) } // skip past window.YTD.tweet.part0 = fd.Seek(25, 0) dec := json.NewDecoder(fd) err = dec.Decode(&tweets) if err != nil { - log.Fatalf("error parsing json: %s", err) + elog.Fatalf("error parsing json: %s", err) } fd.Close() tweetmap := make(map[string]*Tweet) @@ -272,14 +271,14 @@ func importTwitter(username, source string) { fname := fmt.Sprintf("%s/tweet_media/%s-%s", source, t.ID_str, u) data, err := ioutil.ReadFile(fname) if err != nil { - log.Printf("error reading media: %s", fname) + elog.Printf("error reading media: %s", fname) continue } newurl := fmt.Sprintf("https://%s/d/%s", serverName, u) fileid, err := savefile(u, u, newurl, "image/jpg", true, data) if err != nil { - log.Printf("error saving media: %s", fname) + elog.Printf("error saving media: %s", fname) continue } donk := &Donk{ diff --git a/log.go b/log.go new file mode 100644 index 0000000..d100109 --- /dev/null +++ b/log.go @@ -0,0 +1,69 @@ +// +// Copyright (c) 2022 Ted Unangst +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +package main + +import ( + "flag" + "io/ioutil" + "log" + "log/syslog" + "os" +) + +var elog = log.Default() +var ilog = log.Default() +var dlog = log.Default() + +var elogname, ilogname, dlogname, alllogname string + +func init() { + flag.StringVar(&elogname, "errorlog", "stderr", "error log file (or stderr, null, syslog)") + flag.StringVar(&ilogname, "infolog", "stderr", "info log file (or stderr, null, syslog)") + flag.StringVar(&dlogname, "debuglog", "stderr", "debug log file (or stderr, null, syslog)") + flag.StringVar(&alllogname, "log", "stderr", "combined log file (or stderr, null, syslog)") + +} + +func initLogging(elogname, ilogname, dlogname string) { + elog = openlog(elogname, syslog.LOG_ERR) + ilog = openlog(ilogname, syslog.LOG_INFO) + dlog = openlog(dlogname, syslog.LOG_DEBUG) +} + +func openlog(name string, prio syslog.Priority) *log.Logger { + if name == "stderr" { + return log.Default() + } + if name == "syslog" { + logger, err := syslog.NewLogger(syslog.LOG_UUCP|prio, 0) + if err != nil { + elog.Printf("can't create syslog: %s", err) + return log.Default() + } + return logger + } + if name == "null" { + return log.New(ioutil.Discard, os.Args[0], log.LstdFlags) + } + fd, err := os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0600) + if err != nil { + elog.Printf("can't open log file %s: %s", name, err) + return log.Default() + } + logger := log.New(fd, os.Args[0], log.LstdFlags) + logger.Printf("new log started") + return logger +} diff --git a/upgradedb.go b/upgradedb.go index 8015b1a..04a2442 100644 --- a/upgradedb.go +++ b/upgradedb.go @@ -17,7 +17,6 @@ package main import ( "database/sql" - "log" "os" "strings" "time" @@ -32,7 +31,7 @@ type dbexecer interface { func doordie(db dbexecer, s string, args ...interface{}) { _, err := db.Exec(s, args...) if err != nil { - log.Fatalf("can't run %s: %s", s, err) + elog.Fatalf("can't run %s: %s", s, err) } } @@ -43,7 +42,7 @@ func upgradedb() { getconfig("servername", &serverName) if dbversion < 13 { - log.Fatal("database is too old to upgrade") + elog.Fatal("database is too old to upgrade") } switch dbversion { case 25: @@ -91,11 +90,11 @@ func upgradedb() { case 30: tx, err := db.Begin() if err != nil { - log.Fatal(err) + elog.Fatal(err) } rows, err := tx.Query("select userid, options from users") if err != nil { - log.Fatal(err) + elog.Fatal(err) } m := make(map[int64]string) for rows.Next() { @@ -103,25 +102,25 @@ func upgradedb() { var options string err = rows.Scan(&userid, &options) if err != nil { - log.Fatal(err) + elog.Fatal(err) } var uo UserOptions uo.SkinnyCSS = strings.Contains(options, " skinny ") m[userid], err = jsonify(uo) if err != nil { - log.Fatal(err) + elog.Fatal(err) } } rows.Close() for u, o := range m { _, err = tx.Exec("update users set options = ? where userid = ?", o, u) if err != nil { - log.Fatal(err) + elog.Fatal(err) } } err = tx.Commit() if err != nil { - log.Fatal(err) + elog.Fatal(err) } doordie(db, "update config set value = 31 where key = 'dbversion'") fallthrough @@ -173,7 +172,7 @@ func upgradedb() { doordie(blobdb, "create index idx_filehash on filedata(hash)") rows, err := blobdb.Query("select xid, content from filedata") if err != nil { - log.Fatal(err) + elog.Fatal(err) } m := make(map[string]string) for rows.Next() { @@ -181,7 +180,7 @@ func upgradedb() { var data sql.RawBytes err := rows.Scan(&xid, &data) if err != nil { - log.Fatal(err) + elog.Fatal(err) } hash := hashfiledata(data) m[xid] = hash @@ -189,21 +188,21 @@ func upgradedb() { rows.Close() tx, err := blobdb.Begin() if err != nil { - log.Fatal(err) + elog.Fatal(err) } for xid, hash := range m { doordie(tx, "update filedata set hash = ? where xid = ?", hash, xid) } err = tx.Commit() if err != nil { - log.Fatal(err) + elog.Fatal(err) } doordie(db, "update config set value = 40 where key = 'dbversion'") fallthrough case 40: default: - log.Fatalf("can't upgrade unknown version %d", dbversion) + elog.Fatalf("can't upgrade unknown version %d", dbversion) } os.Exit(0) } diff --git a/util.go b/util.go index f034989..5a524b5 100644 --- a/util.go +++ b/util.go @@ -40,7 +40,6 @@ import ( "database/sql" "fmt" "io/ioutil" - "log" "net" "os" "os/signal" @@ -80,11 +79,11 @@ func initdb() { dbname := dataDir + "/honk.db" _, err := os.Stat(dbname) if err == nil { - log.Fatalf("%s already exists", dbname) + elog.Fatalf("%s already exists", dbname) } db, err := sql.Open("sqlite3", dbname) if err != nil { - log.Fatal(err) + elog.Fatal(err) } alreadyopendb = db defer func() { @@ -104,7 +103,7 @@ func initdb() { for _, line := range strings.Split(sqlSchema, ";") { _, err = db.Exec(line) if err != nil { - log.Print(err) + elog.Print(err) return } } @@ -116,37 +115,37 @@ func initdb() { err = createuser(db, r) if err != nil { - log.Print(err) + elog.Print(err) return } // must came later or user above will have negative id err = createserveruser(db) if err != nil { - log.Print(err) + elog.Print(err) return } fmt.Printf("listen address: ") addr, err := r.ReadString('\n') if err != nil { - log.Print(err) + elog.Print(err) return } addr = addr[:len(addr)-1] if len(addr) < 1 { - log.Print("that's way too short") + elog.Print("that's way too short") return } setconfig("listenaddr", addr) fmt.Printf("server name: ") addr, err = r.ReadString('\n') if err != nil { - log.Print(err) + elog.Print(err) return } addr = addr[:len(addr)-1] if len(addr) < 1 { - log.Print("that's way too short") + elog.Print("that's way too short") return } setconfig("servername", addr) @@ -170,26 +169,26 @@ func initblobdb() { blobdbname := dataDir + "/blob.db" _, err := os.Stat(blobdbname) if err == nil { - log.Fatalf("%s already exists", blobdbname) + elog.Fatalf("%s already exists", blobdbname) } blobdb, err := sql.Open("sqlite3", blobdbname) if err != nil { - log.Print(err) + elog.Print(err) return } _, err = blobdb.Exec("create table filedata (xid text, media text, hash text, content blob)") if err != nil { - log.Print(err) + elog.Print(err) return } _, err = blobdb.Exec("create index idx_filexid on filedata(xid)") if err != nil { - log.Print(err) + elog.Print(err) return } _, err = blobdb.Exec("create index idx_filehash on filedata(hash)") if err != nil { - log.Print(err) + elog.Print(err) return } blobdb.Close() @@ -213,7 +212,7 @@ func adduser() { err := createuser(db, r) if err != nil { - log.Print(err) + elog.Print(err) return } @@ -223,7 +222,7 @@ func adduser() { func deluser(username string) { user, _ := butwhatabout(username) if user == nil { - log.Printf("no userfound") + elog.Printf("no userfound") return } userid := user.ID @@ -253,7 +252,7 @@ func chpass() { } user, err := butwhatabout(os.Args[2]) if err != nil { - log.Fatal(err) + elog.Fatal(err) } defer func() { os.Exit(1) @@ -274,12 +273,12 @@ func chpass() { pass, err := askpassword(r) if err != nil { - log.Print(err) + elog.Print(err) return } err = login.SetPassword(user.ID, pass) if err != nil { - log.Print(err) + elog.Print(err) return } fmt.Printf("done\n") @@ -376,15 +375,15 @@ func opendatabase() *sql.DB { dbname := dataDir + "/honk.db" _, err := os.Stat(dbname) if err != nil { - log.Fatalf("unable to open database: %s", err) + elog.Fatalf("unable to open database: %s", err) } db, err := sql.Open("sqlite3", dbname) if err != nil { - log.Fatalf("unable to open database: %s", err) + elog.Fatalf("unable to open database: %s", err) } stmtConfig, err = db.Prepare("select value from config where key = ?") if err != nil { - log.Fatal(err) + elog.Fatal(err) } alreadyopendb = db return db @@ -394,11 +393,11 @@ func openblobdb() *sql.DB { blobdbname := dataDir + "/blob.db" _, err := os.Stat(blobdbname) if err != nil { - log.Fatalf("unable to open database: %s", err) + elog.Fatalf("unable to open database: %s", err) } db, err := sql.Open("sqlite3", blobdbname) if err != nil { - log.Fatalf("unable to open database: %s", err) + elog.Fatalf("unable to open database: %s", err) } return db } @@ -450,7 +449,7 @@ func openListener() (net.Listener, error) { proto = "unix" err := os.Remove(listenAddr) if err != nil && !os.IsNotExist(err) { - log.Printf("unable to unlink socket: %s", err) + elog.Printf("unable to unlink socket: %s", err) } } listener, err := net.Listen(proto, listenAddr) diff --git a/web.go b/web.go index 7c7e9f8..fb4fd3d 100644 --- a/web.go +++ b/web.go @@ -21,7 +21,6 @@ import ( "fmt" "html/template" "io" - "log" notrand "math/rand" "net/http" "net/url" @@ -170,7 +169,7 @@ func showfunzone(w http.ResponseWriter, r *http.Request) { templinfo["Memes"] = memenames err = readviews.Execute(w, "funzone.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -243,7 +242,7 @@ func showrss(w http.ResponseWriter, r *http.Request) { err := feed.Write(w) if err != nil { - log.Printf("error writing rss: %s", err) + elog.Printf("error writing rss: %s", err) } } @@ -252,7 +251,7 @@ func crappola(j junk.Junk) bool { a, _ := j.GetString("actor") o, _ := j.GetString("object") if t == "Delete" && a == o { - log.Printf("crappola from %s", a) + dlog.Printf("crappola from %s", a) return true } return false @@ -266,16 +265,16 @@ func ping(user *WhatAbout, who string) { who = gofish(who) } if who == "" { - log.Printf("nobody to ping!") + ilog.Printf("nobody to ping!") return } var box *Box ok := boxofboxes.Get(who, &box) if !ok { - log.Printf("no inbox to ping %s", who) + ilog.Printf("no inbox to ping %s", who) return } - log.Printf("sending ping to %s", box.In) + ilog.Printf("sending ping to %s", box.In) j := junk.New() j["@context"] = itiswhatitis j["type"] = "Ping" @@ -288,17 +287,17 @@ func ping(user *WhatAbout, who string) { } err := PostJunk(ki.keyname, ki.seckey, box.In, j) if err != nil { - log.Printf("can't send ping: %s", err) + elog.Printf("can't send ping: %s", err) return } - log.Printf("sent ping to %s: %s", who, j["id"]) + ilog.Printf("sent ping to %s: %s", who, j["id"]) } func pong(user *WhatAbout, who string, obj string) { var box *Box ok := boxofboxes.Get(who, &box) if !ok { - log.Printf("no inbox to pong %s", who) + ilog.Printf("no inbox to pong %s", who) return } j := junk.New() @@ -314,7 +313,7 @@ func pong(user *WhatAbout, who string, obj string) { } err := PostJunk(ki.keyname, ki.seckey, box.In, j) if err != nil { - log.Printf("can't send pong: %s", err) + elog.Printf("can't send pong: %s", err) return } } @@ -336,7 +335,7 @@ func inbox(w http.ResponseWriter, r *http.Request) { payload := buf.Bytes() j, err := junk.FromBytes(payload) if err != nil { - log.Printf("bad payload: %s", err) + ilog.Printf("bad payload: %s", err) io.WriteString(os.Stdout, "bad payload\n") os.Stdout.Write(payload) io.WriteString(os.Stdout, "\n") @@ -362,9 +361,9 @@ func inbox(w http.ResponseWriter, r *http.Request) { keyname, err = httpsig.VerifyRequest(r, payload, zaggy) } if err != nil { - log.Printf("inbox message failed signature for %s from %s: %s", keyname, r.Header.Get("X-Forwarded-For"), err) + ilog.Printf("inbox message failed signature for %s from %s: %s", keyname, r.Header.Get("X-Forwarded-For"), err) if keyname != "" { - log.Printf("bad signature from %s", keyname) + ilog.Printf("bad signature from %s", keyname) io.WriteString(os.Stdout, "bad payload\n") os.Stdout.Write(payload) io.WriteString(os.Stdout, "\n") @@ -374,20 +373,20 @@ func inbox(w http.ResponseWriter, r *http.Request) { } origin := keymatch(keyname, who) if origin == "" { - log.Printf("keyname actor mismatch: %s <> %s", keyname, who) + ilog.Printf("keyname actor mismatch: %s <> %s", keyname, who) return } switch what { case "Ping": id, _ := j.GetString("id") - log.Printf("ping from %s: %s", who, id) + ilog.Printf("ping from %s: %s", who, id) pong(user, who, obj) case "Pong": - log.Printf("pong from %s: %s", who, obj) + ilog.Printf("pong from %s: %s", who, obj) case "Follow": if obj != user.URL { - log.Printf("can't follow %s", obj) + ilog.Printf("can't follow %s", obj) return } followme(user, who, who, j) @@ -411,7 +410,7 @@ func inbox(w http.ResponseWriter, r *http.Request) { return } } - log.Printf("unknown Update activity") + ilog.Printf("unknown Update activity") dumpactivity(j) case "Undo": obj, ok := j.GetMap("object") @@ -428,10 +427,10 @@ func inbox(w http.ResponseWriter, r *http.Request) { unfollowme(user, who, who, j) case "Announce": xid, _ := obj.GetString("object") - log.Printf("undo announce: %s", xid) + dlog.Printf("undo announce: %s", xid) case "Like": default: - log.Printf("unknown undo: %s", what) + ilog.Printf("unknown undo: %s", what) } case "EmojiReact": obj, ok := j.GetString("object") @@ -455,7 +454,7 @@ func serverinbox(w http.ResponseWriter, r *http.Request) { payload := buf.Bytes() j, err := junk.FromBytes(payload) if err != nil { - log.Printf("bad payload: %s", err) + ilog.Printf("bad payload: %s", err) io.WriteString(os.Stdout, "bad payload\n") os.Stdout.Write(payload) io.WriteString(os.Stdout, "\n") @@ -470,9 +469,9 @@ func serverinbox(w http.ResponseWriter, r *http.Request) { keyname, err = httpsig.VerifyRequest(r, payload, zaggy) } if err != nil { - log.Printf("inbox message failed signature for %s from %s: %s", keyname, r.Header.Get("X-Forwarded-For"), err) + ilog.Printf("inbox message failed signature for %s from %s: %s", keyname, r.Header.Get("X-Forwarded-For"), err) if keyname != "" { - log.Printf("bad signature from %s", keyname) + ilog.Printf("bad signature from %s", keyname) io.WriteString(os.Stdout, "bad payload\n") os.Stdout.Write(payload) io.WriteString(os.Stdout, "\n") @@ -483,7 +482,7 @@ func serverinbox(w http.ResponseWriter, r *http.Request) { who, _ := j.GetString("actor") origin := keymatch(keyname, who) if origin == "" { - log.Printf("keyname actor mismatch: %s <> %s", keyname, who) + ilog.Printf("keyname actor mismatch: %s <> %s", keyname, who) return } if rejectactor(user.ID, who) { @@ -491,17 +490,17 @@ func serverinbox(w http.ResponseWriter, r *http.Request) { } re_ont := regexp.MustCompile("https://" + serverName + "/o/([[:alnum:]]+)") what, _ := j.GetString("type") - log.Printf("server got a %s", what) + dlog.Printf("server got a %s", what) switch what { case "Follow": obj, _ := j.GetString("object") if obj == user.URL { - log.Printf("can't follow the server!") + ilog.Printf("can't follow the server!") return } m := re_ont.FindStringSubmatch(obj) if len(m) != 2 { - log.Printf("not sure how to handle this") + ilog.Printf("not sure how to handle this") return } ont := "#" + m[1] @@ -510,24 +509,24 @@ func serverinbox(w http.ResponseWriter, r *http.Request) { case "Undo": obj, ok := j.GetMap("object") if !ok { - log.Printf("unknown undo no object") + ilog.Printf("unknown undo no object") return } what, _ := obj.GetString("type") if what != "Follow" { - log.Printf("unknown undo: %s", what) + ilog.Printf("unknown undo: %s", what) return } targ, _ := obj.GetString("object") m := re_ont.FindStringSubmatch(targ) if len(m) != 2 { - log.Printf("not sure how to handle this") + ilog.Printf("not sure how to handle this") return } ont := "#" + m[1] unfollowme(user, who, ont, j) default: - log.Printf("unhandled server activity: %s", what) + ilog.Printf("unhandled server activity: %s", what) dumpactivity(j) } } @@ -554,11 +553,11 @@ func ximport(w http.ResponseWriter, r *http.Request) { j, err := GetJunk(xid) if err != nil { http.Error(w, "error getting external object", http.StatusInternalServerError) - log.Printf("error getting external object: %s", err) + ilog.Printf("error getting external object: %s", err) return } allinjest(originate(xid), j) - log.Printf("importing %s", xid) + dlog.Printf("importing %s", xid) user, _ := butwhatabout(u.Username) info, _ := somethingabout(j) @@ -586,7 +585,7 @@ func xzone(w http.ResponseWriter, r *http.Request) { u := login.GetUserInfo(r) rows, err := stmtRecentHonkers.Query(u.UserID, u.UserID) if err != nil { - log.Printf("query err: %s", err) + elog.Printf("query err: %s", err) return } defer rows.Close() @@ -605,7 +604,7 @@ func xzone(w http.ResponseWriter, r *http.Request) { templinfo["Honkers"] = honkers err = readviews.Execute(w, "xzone.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -699,7 +698,7 @@ func showuser(w http.ResponseWriter, r *http.Request) { name := mux.Vars(r)["name"] user, err := butwhatabout(name) if err != nil { - log.Printf("user not found %s: %s", name, err) + ilog.Printf("user not found %s: %s", name, err) http.NotFound(w, r) return } @@ -842,7 +841,7 @@ func thelistingoftheontologies(w http.ResponseWriter, r *http.Request) { } rows, err := stmtAllOnts.Query(userid) if err != nil { - log.Printf("selection error: %s", err) + elog.Printf("selection error: %s", err) return } defer rows.Close() @@ -851,7 +850,7 @@ func thelistingoftheontologies(w http.ResponseWriter, r *http.Request) { var o Ont err := rows.Scan(&o.Name, &o.Count) if err != nil { - log.Printf("error scanning ont: %s", err) + elog.Printf("error scanning ont: %s", err) continue } if len(o.Name) > 24 { @@ -870,7 +869,7 @@ func thelistingoftheontologies(w http.ResponseWriter, r *http.Request) { templinfo["Onts"] = onts err = readviews.Execute(w, "onts.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -888,7 +887,7 @@ func getbacktracks(xid string) []string { err := row.Scan(&rawtracks) if err != nil { if err != sql.ErrNoRows { - log.Printf("error scanning tracks: %s", err) + elog.Printf("error scanning tracks: %s", err) } return nil } @@ -910,29 +909,29 @@ func savetracks(tracks map[string][]string) { db := opendatabase() tx, err := db.Begin() if err != nil { - log.Printf("savetracks begin error: %s", err) + elog.Printf("savetracks begin error: %s", err) return } defer func() { err := tx.Commit() if err != nil { - log.Printf("savetracks commit error: %s", err) + elog.Printf("savetracks commit error: %s", err) } }() stmtGetTracks, err := tx.Prepare("select fetches from tracks where xid = ?") if err != nil { - log.Printf("savetracks error: %s", err) + elog.Printf("savetracks error: %s", err) return } stmtNewTracks, err := tx.Prepare("insert into tracks (xid, fetches) values (?, ?)") if err != nil { - log.Printf("savetracks error: %s", err) + elog.Printf("savetracks error: %s", err) return } stmtUpdateTracks, err := tx.Prepare("update tracks set fetches = ? where xid = ?") if err != nil { - log.Printf("savetracks error: %s", err) + elog.Printf("savetracks error: %s", err) return } count := 0 @@ -949,10 +948,10 @@ func savetracks(tracks map[string][]string) { all = oneofakind(all) stmtUpdateTracks.Exec(strings.Join(all, " ")) } else { - log.Printf("savetracks error: %s", err) + elog.Printf("savetracks error: %s", err) } } - log.Printf("saved %d new fetches", count) + dlog.Printf("saved %d new fetches", count) } var trackchan = make(chan Track) @@ -1091,7 +1090,7 @@ func honkpage(w http.ResponseWriter, u *login.UserInfo, honks []*Honk, templinfo } err := readviews.Execute(w, "honkpage.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -1153,7 +1152,7 @@ func saveuser(w http.ResponseWriter, r *http.Request) { _, err = db.Exec("update users set about = ?, options = ? where username = ?", whatabout, j, u.Username) } if err != nil { - log.Printf("error bouting what: %s", err) + elog.Printf("error bouting what: %s", err) } somenamedusers.Clear(u.Username) somenumberedusers.Clear(u.UserID) @@ -1167,7 +1166,7 @@ func saveuser(w http.ResponseWriter, r *http.Request) { } func bonkit(xid string, user *WhatAbout) { - log.Printf("bonking %s", xid) + dlog.Printf("bonking %s", xid) xonk := getxonk(user.ID, xid) if xonk == nil { @@ -1183,7 +1182,7 @@ func bonkit(xid string, user *WhatAbout) { _, err := stmtUpdateFlags.Exec(flagIsBonked, xonk.ID) if err != nil { - log.Printf("error acking bonk: %s", err) + elog.Printf("error acking bonk: %s", err) } oonker := xonk.Oonker @@ -1216,7 +1215,7 @@ func bonkit(xid string, user *WhatAbout) { err = savehonk(bonk) if err != nil { - log.Printf("uh oh") + elog.Printf("uh oh") return } @@ -1235,7 +1234,7 @@ func submitbonk(w http.ResponseWriter, r *http.Request) { templinfo["ServerMessage"] = "Bonked!" err := readviews.Execute(w, "msg.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } } @@ -1250,7 +1249,7 @@ func sendzonkofsorts(xonk *Honk, user *WhatAbout, what string, aux string) { } zonk.Public = loudandproud(zonk.Audience) - log.Printf("announcing %sed honk: %s", what, xonk.XID) + dlog.Printf("announcing %sed honk: %s", what, xonk.XID) go honkworldwide(user, zonk) } @@ -1265,7 +1264,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { if xonk != nil { _, err := stmtUpdateFlags.Exec(flagIsSaved, xonk.ID) if err != nil { - log.Printf("error saving: %s", err) + elog.Printf("error saving: %s", err) } } return @@ -1276,7 +1275,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { if xonk != nil { _, err := stmtClearFlags.Exec(flagIsSaved, xonk.ID) if err != nil { - log.Printf("error unsaving: %s", err) + elog.Printf("error unsaving: %s", err) } } return @@ -1294,7 +1293,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { if xonk != nil { _, err := stmtUpdateFlags.Exec(flagIsReacted, xonk.ID) if err != nil { - log.Printf("error saving: %s", err) + elog.Printf("error saving: %s", err) } sendzonkofsorts(xonk, user, "react", reaction) } @@ -1309,7 +1308,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { if xonk != nil && !xonk.IsAcked() { _, err := stmtUpdateFlags.Exec(flagIsAcked, xonk.ID) if err != nil { - log.Printf("error acking: %s", err) + elog.Printf("error acking: %s", err) } sendzonkofsorts(xonk, user, "ack", "") } @@ -1321,7 +1320,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { if xonk != nil && xonk.IsAcked() { _, err := stmtClearFlags.Exec(flagIsAcked, xonk.ID) if err != nil { - log.Printf("error deacking: %s", err) + elog.Printf("error deacking: %s", err) } sendzonkofsorts(xonk, user, "deack", "") } @@ -1341,7 +1340,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { xonk = getxonk(userinfo.UserID, what) _, err := stmtClearFlags.Exec(flagIsBonked, xonk.ID) if err != nil { - log.Printf("error unbonking: %s", err) + elog.Printf("error unbonking: %s", err) } sendzonkofsorts(xonk, user, "unbonk", "") } @@ -1353,7 +1352,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { if xonk != nil { _, err := stmtUpdateFlags.Exec(flagIsUntagged, xonk.ID) if err != nil { - log.Printf("error untagging: %s", err) + elog.Printf("error untagging: %s", err) } } var badparents map[string]bool @@ -1363,7 +1362,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { return } - log.Printf("zonking %s %s", wherefore, what) + ilog.Printf("zonking %s %s", wherefore, what) if wherefore == "zonk" { xonk := getxonk(userinfo.UserID, what) if xonk != nil { @@ -1375,7 +1374,7 @@ func zonkit(w http.ResponseWriter, r *http.Request) { } _, err := stmtSaveZonker.Exec(userinfo.UserID, what, wherefore) if err != nil { - log.Printf("error saving zonker: %s", err) + elog.Printf("error saving zonker: %s", err) return } } @@ -1416,7 +1415,7 @@ func edithonkpage(w http.ResponseWriter, r *http.Request) { } err := readviews.Execute(w, "honkpage.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -1441,7 +1440,7 @@ func newhonkpage(w http.ResponseWriter, r *http.Request) { templinfo["IsPreview"] = true err := readviews.Execute(w, "honkpage.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -1461,7 +1460,7 @@ func submitdonk(w http.ResponseWriter, r *http.Request) (*Donk, error) { if err == http.ErrMissingFile { return nil, nil } - log.Printf("error reading donk: %s", err) + elog.Printf("error reading donk: %s", err) http.Error(w, "error reading donk", http.StatusUnsupportedMediaType) return nil, err } @@ -1485,7 +1484,7 @@ func submitdonk(w http.ResponseWriter, r *http.Request) (*Donk, error) { case "application/pdf": maxsize := 10000000 if len(data) > maxsize { - log.Printf("bad image: %s too much pdf: %d", err, len(data)) + ilog.Printf("bad image: %s too much pdf: %d", err, len(data)) http.Error(w, "didn't like your attachment", http.StatusUnsupportedMediaType) return nil, err } @@ -1497,13 +1496,13 @@ func submitdonk(w http.ResponseWriter, r *http.Request) (*Donk, error) { default: maxsize := 100000 if len(data) > maxsize { - log.Printf("bad image: %s too much text: %d", err, len(data)) + ilog.Printf("bad image: %s too much text: %d", err, len(data)) http.Error(w, "didn't like your attachment", http.StatusUnsupportedMediaType) return nil, err } for i := 0; i < len(data); i++ { if data[i] < 32 && data[i] != '\t' && data[i] != '\r' && data[i] != '\n' { - log.Printf("bad image: %s not text: %d", err, data[i]) + ilog.Printf("bad image: %s not text: %d", err, data[i]) http.Error(w, "didn't like your attachment", http.StatusUnsupportedMediaType) return nil, err } @@ -1521,7 +1520,7 @@ func submitdonk(w http.ResponseWriter, r *http.Request) (*Donk, error) { } fileid, xid, err := savefileandxid(name, desc, "", media, true, data) if err != nil { - log.Printf("unable to save image: %s", err) + elog.Printf("unable to save image: %s", err) http.Error(w, "failed to save attachment", http.StatusUnsupportedMediaType) return nil, err } @@ -1632,7 +1631,7 @@ func submithonk(w http.ResponseWriter, r *http.Request) *Honk { butnottooloud(honk.Audience) honk.Audience = oneofakind(honk.Audience) if len(honk.Audience) == 0 { - log.Printf("honk to nowhere") + ilog.Printf("honk to nowhere") http.Error(w, "honk to nowhere...", http.StatusNotFound) return nil } @@ -1656,7 +1655,7 @@ func submithonk(w http.ResponseWriter, r *http.Request) *Honk { if donk != nil { honk.Donks = append(honk.Donks, donk) } else { - log.Printf("can't find file: %s", xid) + ilog.Printf("can't find file: %s", xid) } } memetize(honk) @@ -1730,7 +1729,7 @@ func submithonk(w http.ResponseWriter, r *http.Request) *Honk { templinfo["ServerMessage"] = "honk preview" err := readviews.Execute(w, "honkpage.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } return nil } @@ -1741,7 +1740,7 @@ func submithonk(w http.ResponseWriter, r *http.Request) *Honk { } else { err := savehonk(honk) if err != nil { - log.Printf("uh oh") + elog.Printf("uh oh") return nil } } @@ -1762,7 +1761,7 @@ func showhonkers(w http.ResponseWriter, r *http.Request) { templinfo["HonkerCSRF"] = login.GetCSRF("submithonker", r) err := readviews.Execute(w, "honkers.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -1781,7 +1780,7 @@ func showchatter(w http.ResponseWriter, r *http.Request) { templinfo["ChonkCSRF"] = login.GetCSRF("sendchonk", r) err := readviews.Execute(w, "chatter.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -1851,7 +1850,7 @@ func showcombos(w http.ResponseWriter, r *http.Request) { templinfo := getInfo(r) err := readviews.Execute(w, "combos.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -1892,7 +1891,7 @@ func submithonker(w http.ResponseWriter, r *http.Request) { } _, err := stmtUpdateHonker.Exec(name, combos, mj, honkerid, u.UserID) if err != nil { - log.Printf("update honker err: %s", err) + elog.Printf("update honker err: %s", err) return } http.Redirect(w, r, "/honkers", http.StatusSeeOther) @@ -1916,7 +1915,7 @@ func submithonker(w http.ResponseWriter, r *http.Request) { } _, err := stmtSaveHonker.Exec(u.UserID, name, url, flavor, combos, url, mj) if err != nil { - log.Print(err) + elog.Print(err) return } http.Redirect(w, r, "/honkers", http.StatusSeeOther) @@ -1926,7 +1925,7 @@ func submithonker(w http.ResponseWriter, r *http.Request) { info, err := investigate(url) if err != nil { http.Error(w, "error investigating: "+err.Error(), http.StatusInternalServerError) - log.Printf("failed to investigate honker: %s", err) + ilog.Printf("failed to investigate honker: %s", err) return } url = info.XID @@ -1942,14 +1941,14 @@ func submithonker(w http.ResponseWriter, r *http.Request) { if err != sql.ErrNoRows { http.Error(w, "it seems you are already subscribed to them", http.StatusInternalServerError) if err != nil { - log.Printf("honker scan err: %s", err) + elog.Printf("honker scan err: %s", err) } return } res, err := stmtSaveHonker.Exec(u.UserID, name, url, flavor, combos, info.Owner, mj) if err != nil { - log.Print(err) + elog.Print(err) return } honkerid, _ = res.LastInsertId() @@ -1969,7 +1968,7 @@ func hfcspage(w http.ResponseWriter, r *http.Request) { templinfo["FilterCSRF"] = login.GetCSRF("filter", r) err := readviews.Execute(w, "hfcs.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } @@ -1980,7 +1979,7 @@ func savehfcs(w http.ResponseWriter, r *http.Request) { hfcsid, _ := strconv.ParseInt(r.FormValue("hfcsid"), 10, 0) _, err := stmtDeleteFilter.Exec(userinfo.UserID, hfcsid) if err != nil { - log.Printf("error deleting filter: %s", err) + elog.Printf("error deleting filter: %s", err) } filtInvalidator.Clear(userinfo.UserID) http.Redirect(w, r, "/hfcs", http.StatusSeeOther) @@ -2007,7 +2006,7 @@ func savehfcs(w http.ResponseWriter, r *http.Request) { filt.Notes = strings.TrimSpace(r.FormValue("filtnotes")) if filt.Actor == "" && filt.Text == "" && !filt.IsAnnounce { - log.Printf("blank filter") + ilog.Printf("blank filter") http.Error(w, "can't save a blank filter", http.StatusInternalServerError) return } @@ -2017,7 +2016,7 @@ func savehfcs(w http.ResponseWriter, r *http.Request) { _, err = stmtSaveFilter.Exec(userinfo.UserID, j) } if err != nil { - log.Printf("error saving filter: %s", err) + elog.Printf("error saving filter: %s", err) } filtInvalidator.Clear(userinfo.UserID) @@ -2038,14 +2037,14 @@ func accountpage(w http.ResponseWriter, r *http.Request) { templinfo["WhatAbout"] = about err := readviews.Execute(w, "account.html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } func dochpass(w http.ResponseWriter, r *http.Request) { err := login.ChangePassword(w, r) if err != nil { - log.Printf("error changing password: %s", err) + elog.Printf("error changing password: %s", err) } http.Redirect(w, r, "/account", http.StatusSeeOther) } @@ -2053,7 +2052,7 @@ func dochpass(w http.ResponseWriter, r *http.Request) { func fingerlicker(w http.ResponseWriter, r *http.Request) { orig := r.FormValue("resource") - log.Printf("finger lick: %s", orig) + dlog.Printf("finger lick: %s", orig) if strings.HasPrefix(orig, "acct:") { orig = orig[5:] @@ -2064,7 +2063,7 @@ func fingerlicker(w http.ResponseWriter, r *http.Request) { if idx != -1 { name = name[idx+1:] if fmt.Sprintf("https://%s/%s/%s", serverName, userSep, name) != orig { - log.Printf("foreign request rejected") + ilog.Printf("foreign request rejected") name = "" } } else { @@ -2072,7 +2071,7 @@ func fingerlicker(w http.ResponseWriter, r *http.Request) { if idx != -1 { name = name[:idx] if !(name+"@"+serverName == orig || name+"@"+masqName == orig) { - log.Printf("foreign request rejected") + ilog.Printf("foreign request rejected") name = "" } } @@ -2149,7 +2148,7 @@ func servehtml(w http.ResponseWriter, r *http.Request) { } err := readviews.Execute(w, r.URL.Path[1:]+".html", templinfo) if err != nil { - log.Print(err) + elog.Print(err) } } func serveemu(w http.ResponseWriter, r *http.Request) { @@ -2172,7 +2171,7 @@ func servefile(w http.ResponseWriter, r *http.Request) { row := stmtGetFileData.QueryRow(xid) err := row.Scan(&media, &data) if err != nil { - log.Printf("error loading file: %s", err) + elog.Printf("error loading file: %s", err) http.NotFound(w, r) return } @@ -2276,7 +2275,7 @@ func webhydra(w http.ResponseWriter, r *http.Request) { templinfo["User"], _ = butwhatabout(u.Username) err := readviews.Execute(&buf, "honkfrags.html", templinfo) if err != nil { - log.Printf("frag error: %s", err) + elog.Printf("frag error: %s", err) return } hydra.Honks = buf.String() @@ -2304,7 +2303,7 @@ func apihandler(w http.ResponseWriter, r *http.Request) { userid := u.UserID action := r.FormValue("action") wait, _ := strconv.ParseInt(r.FormValue("wait"), 10, 0) - log.Printf("api request '%s' on behalf of %s", action, u.Username) + dlog.Printf("api request '%s' on behalf of %s", action, u.Username) switch action { case "honk": h := submithonk(w, r) @@ -2383,15 +2382,15 @@ func enditall() { signal.Notify(sig, os.Interrupt) signal.Notify(sig, syscall.SIGTERM) <-sig - log.Printf("stopping...") + ilog.Printf("stopping...") for i := 0; i < workinprogress; i++ { endoftheworld <- true } - log.Printf("waiting...") + ilog.Printf("waiting...") for i := 0; i < workinprogress; i++ { <-readyalready } - log.Printf("apocalypse") + ilog.Printf("apocalypse") os.Exit(0) } @@ -2418,7 +2417,7 @@ func serve() { listener, err := openListener() if err != nil { - log.Fatal(err) + elog.Fatal(err) } go runBackendServer() go enditall() @@ -2537,6 +2536,6 @@ func serve() { err = http.Serve(listener, mux) if err != nil { - log.Fatal(err) + elog.Fatal(err) } }