// Manages the complete lifecycle of a buy.
// When a bool can be read from interrupt, the buy is aborted.
func (a *BuyActivity) PerformBuy(log bitwrk.Logger, interrupt <-chan bool, workFile cafs.File) (cafs.File, error) {
a.workFile = workFile.Duplicate()
file, err := a.doPerformBuy(log, interrupt)
if err != nil {
a.execSync(func() { a.lastError = err })
}
return file, err
}
func (a *SellActivity) dispatchWorkAndSaveEncryptedResult(log bitwrk.Logger, workFile cafs.File) error {
// Watch transaction state and close connection to worker when transaction expires
connChan := make(chan io.Closer)
exitChan := make(chan bool)
go a.watchdog(log, exitChan, connChan, func() bool { return a.tx.State == bitwrk.StateActive })
defer func() {
exitChan <- true
}()
st := NewScopedTransport()
connChan <- st
defer st.Close()
reader := workFile.Open()
defer reader.Close()
result, err := a.worker.DoWork(reader, NewClient(&st.Transport))
if err != nil {
return err
}
defer result.Close()
temp := a.manager.storage.Create(fmt.Sprintf("Sell #%v: encrypted result", a.GetKey()))
defer temp.Dispose()
// Use AES-256 to encrypt the result
block, err := aes.NewCipher(a.encResultKey[:])
if err != nil {
return err
}
// Create OFB stream with null initialization vector (ok for one-time key)
var iv [aes.BlockSize]byte
stream := cipher.NewOFB(block, iv[:])
writer := &cipher.StreamWriter{S: stream, W: temp}
_, err = io.Copy(writer, result)
if err != nil {
return err
}
if err := temp.Close(); err != nil {
return err
}
if err := result.Close(); err != nil {
return err
}
a.execSync(func() { a.encResultFile = temp.File() })
return nil
}
func (a *SellActivity) HandleWork(log bitwrk.Logger, workFile cafs.File, buyerSecret bitwrk.Thash) (io.ReadCloser, error) {
// Wait for buyer to establish
active := true
var workHash, workSecretHash *bitwrk.Thash
log.Printf("Watching transaction state...")
a.waitWhile(func() bool {
active = a.tx.State == bitwrk.StateActive
workHash, workSecretHash = a.tx.WorkHash, a.tx.WorkSecretHash
log.Printf(" state: %v phase: %v", a.tx.State, a.tx.Phase)
return active && a.tx.Phase != bitwrk.PhaseTransmitting
})
if !active {
return nil, fmt.Errorf("Transaction timed out waiting for buyer to establish")
}
// Verify work hash
if *workHash != bitwrk.Thash(workFile.Key()) {
return nil, fmt.Errorf("WorkHash and received data do not match")
}
if err := verifyBuyerSecret(workHash, workSecretHash, &buyerSecret); err != nil {
return nil, err
}
log.Println("Got valid work data. Publishing buyer's secret.")
if err := SendTxMessagePublishBuyerSecret(a.txId, a.identity, &buyerSecret); err != nil {
return nil, fmt.Errorf("Error publishing buyer's secret: %v", err)
}
log.Println("Starting to work...")
r, err := a.dispatchWork(log, workFile)
if err != nil {
log.Printf("Rejecting work because of error '%v'", err)
if err := SendTxMessageRejectWork(a.txId, a.identity); err != nil {
log.Printf("Rejecting work failed: %v", err)
}
}
return r, err
}
func (a *SellActivity) dispatchWork(log bitwrk.Logger, workFile cafs.File) (io.ReadCloser, error) {
// Watch transaction state and close connection to worker when transaction expires
connChan := make(chan io.Closer)
exitChan := make(chan bool)
go a.watchdog(log, exitChan, connChan, func() bool { return a.tx.State == bitwrk.StateActive })
defer func() {
exitChan <- true
}()
reader := workFile.Open()
defer reader.Close()
st := NewScopedTransport()
connChan <- st
defer st.Close()
r, err := a.worker.DoWork(reader, NewClient(&st.Transport))
if err == nil {
// Defuse connection closing mechanism
st.DisownConnections()
}
return r, err
}
func handleBuy(w http.ResponseWriter, r *http.Request) {
article := r.URL.Path[5:]
log.Printf("Handling buy for %#v from %v", article, r.RemoteAddr)
if r.Method != "POST" {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var buy *client.BuyActivity
if _buy, err := client.GetActivityManager().NewBuy(bitwrk.ArticleId(article)); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Printf("Error creating buy activity: %v", err)
return
} else {
buy = _buy
}
defer buy.Dispose()
log := bitwrk.Root().Newf("Buy #%v", buy.GetKey())
var reader io.Reader
if multipart, err := r.MultipartReader(); err != nil {
// read directly from body
reader = r.Body
} else {
// Iterate through parts of multipart body, find the one called "data"
for {
if part, err := multipart.NextPart(); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Printf("Error iterating through multipart content: %v", err)
return
} else {
if part.FormName() == "data" {
reader = part
break
} else {
log.Printf("Skipping form part %v", part)
}
}
}
}
workTemp := client.GetActivityManager().GetStorage().Create(fmt.Sprintf("buy #%v: work", buy.GetKey()))
defer workTemp.Dispose()
if _, err := io.Copy(workTemp, reader); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Printf("Error receiving work data from client: %v", err)
return
} else {
if err := workTemp.Close(); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Printf("Error writing work data to storage: %v", err)
return
}
}
// Listen for close notfications
interrupt := w.(http.CloseNotifier).CloseNotify()
workFile := workTemp.File()
defer workFile.Dispose()
var result cafs.File
if res, err := buy.PerformBuy(log, interrupt, workFile); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Printf("Error receiving result from BitWrk network: %v", err)
return
} else {
result = res
}
http.Redirect(w, r, "/file/"+result.Key().String(), http.StatusSeeOther)
}