import (
"bytes"
"crypto/openpgp"
- "crypto/rand"
"epoint/document"
"epoint/key"
"epoint/store"
"fmt"
+ "log"
"time"
)
var db *store.Conn
var serverkey *openpgp.Entity
var newchan chan *work
-var delchan chan string
+var delchan chan *work
type worklist struct {
head *work
func setserverkey(e *openpgp.Entity) (err error) {
serverkey = e
-
- // TODO: maybe Serialize should do this internally
- for _, ident := range e.Identities {
- err = ident.SelfSignature.SignUserId(rand.Reader, ident.UserId.Id, e.PrimaryKey, e.PrivateKey)
- if err != nil {
- return
- }
- }
- for _, subkey := range e.Subkeys {
- err = subkey.Sig.SignKey(rand.Reader, subkey.PublicKey, e.PrivateKey)
- if err != nil {
- return
- }
+ err = key.SelfSign(e)
+ if err != nil {
+ return
}
-
- b := new(bytes.Buffer)
- err = e.Serialize(b)
+ d, err := key.Format(e)
if err != nil {
return
}
- err = db.Set("key", key.Id(e), b.Bytes())
+ err = db.Set("key", key.Id(e), d)
if err != nil {
return
}
- err = db.Set("", "serverkey", b.Bytes())
+ err = db.Set("", "serverkey", d)
return
}
w.signed = signed
w.draft = draft
w.sync = make(chan int)
+ log.Printf("add draft work: %s", w.account)
newchan <- w
<-w.sync
return w.out, w.err
w.signed = signed
w.debit = cert
w.sync = make(chan int)
+ log.Printf("add debit work: %s", w.account)
newchan <- w
<-w.sync
return w.out, w.err
}
func dispatch() {
+ log.Printf("start dispatch")
works := make(map[string]*worklist)
for {
select {
case w := <-newchan:
+ log.Printf("queue work: %s", w.account)
ws := works[w.account]
if ws == nil {
// TODO: unnecessary alloc
} else {
pushwork(ws, w)
}
- case account := <-delchan:
- ws := works[account]
- w := popwork(ws)
- if w == nil {
- delete(works, account)
+ case w := <-delchan:
+ log.Printf("unqueue work: %s", w.account)
+ ws := works[w.account]
+ wnext := popwork(ws)
+ if wnext == nil {
+ delete(works, w.account)
} else {
- go handle(w)
+ go handle(wnext)
}
}
}
}
func handle(w *work) {
+ log.Printf("start work: %s", w.account)
if w.debit != nil {
handleDebit(w)
} else if w.draft != nil {
} else {
panic("unreachable")
}
- delchan <- w.account
+ log.Printf("finish work: %s outlen: %d, errtype: %T", w.account, len(w.out), w.err)
+ delchan <- w
w.sync <- 0
}
if err != nil {
return
}
- certid := document.Id(signed)
w.out = c
+ certid := document.Id(signed)
err = db.Set("cert", certid, c)
if err != nil {
// internal error
// internal error
return
}
+ w.out = c
certid := document.Id(signed)
err = db.Set("cert", certid, c)
if err != nil {
if err != nil {
return
}
+ newchan = make(chan *work)
+ delchan = make(chan *work)
go dispatch()
return
}