// Handle incoming requests.
func (this *ServerServer) handleFunc(c *gin.Context) {
log.Debug("Incoming message")
r := c.Request
var buf bytes.Buffer
n, errR := buf.ReadFrom(r.Body)
if errR != nil || n == 0 {
http.Error(c.Writer, "Bad request.", 400)
return
}
bts := buf.Bytes()
var errDC error
reqData := &RequestData{}
wire.ReadJSON(reqData, bts, &errDC)
if errDC != nil {
http.Error(c.Writer, "Failed to decode json.", 400)
return
}
log.Debug("Starting to add.")
resp, errA := this.serverManager.add(reqData)
if errA != nil {
http.Error(c.Writer, "Internal error: "+errA.Error(), 500)
return
}
log.Debug("Work done.", "PORT", resp.Port)
w := c.Writer
enc := json.NewEncoder(w)
enc.Encode(resp)
w.WriteHeader(200)
}
func unmarshalValidateCall(origin, returnCode []byte, txid *[]byte) func(string, []byte) error {
return func(eid string, b []byte) error {
// unmarshall and assert somethings
var response ctypes.Response
var err error
wire.ReadJSON(&response, b, &err)
if err != nil {
return err
}
if response.Error != "" {
return fmt.Errorf(response.Error)
}
var data = response.Result.(*ctypes.ResultEvent).Data.(types.EventDataCall)
if data.Exception != "" {
return fmt.Errorf(data.Exception)
}
if !bytes.Equal(data.Origin, origin) {
return fmt.Errorf("Origin does not match up! Got %x, expected %x",
data.Origin, origin)
}
ret := data.Return
if !bytes.Equal(ret, returnCode) {
return fmt.Errorf("Call did not return correctly. Got %x, expected %x", ret, returnCode)
}
if !bytes.Equal(data.TxID, *txid) {
return fmt.Errorf("TxIDs do not match up! Got %x, expected %x",
data.TxID, *txid)
}
return nil
}
}
func unmarshalValidateTx(amt int64, returnCode []byte) func(string, []byte) error {
return func(eid string, b []byte) error {
// unmarshall and assert somethings
var response ctypes.Response
var err error
wire.ReadJSON(&response, b, &err)
if err != nil {
return err
}
if response.Error != "" {
return fmt.Errorf(response.Error)
}
var data = response.Result.(*ctypes.ResultEvent).Data.(types.EventDataTx)
if data.Exception != "" {
return fmt.Errorf(data.Exception)
}
tx := data.Tx.(*types.CallTx)
if !bytes.Equal(tx.Input.Address, user[0].Address) {
return fmt.Errorf("Senders do not match up! Got %x, expected %x",
tx.Input.Address, user[0].Address)
}
if tx.Input.Amount != amt {
return fmt.Errorf("Amt does not match up! Got %d, expected %d",
tx.Input.Amount, amt)
}
ret := data.Return
if !bytes.Equal(ret, returnCode) {
return fmt.Errorf("Tx did not return correctly. Got %x, expected %x", ret, returnCode)
}
return nil
}
}
func unmarshalValidateSend(amt int64, toAddr []byte) func(string, []byte) error {
return func(eid string, b []byte) error {
// unmarshal and assert correctness
var response ctypes.Response
var err error
wire.ReadJSON(&response, b, &err)
if err != nil {
return err
}
if response.Error != "" {
return fmt.Errorf(response.Error)
}
if eid != response.Result.(*ctypes.ResultEvent).Event {
return fmt.Errorf("Eventid is not correct. Got %s, expected %s", response.Result.(*ctypes.ResultEvent).Event, eid)
}
tx := response.Result.(*ctypes.ResultEvent).Data.(types.EventDataTx).Tx.(*types.SendTx)
if !bytes.Equal(tx.Inputs[0].Address, user[0].Address) {
return fmt.Errorf("Senders do not match up! Got %x, expected %x", tx.Inputs[0].Address, user[0].Address)
}
if tx.Inputs[0].Amount != amt {
return fmt.Errorf("Amt does not match up! Got %d, expected %d", tx.Inputs[0].Amount, amt)
}
if !bytes.Equal(tx.Outputs[0].Address, toAddr) {
return fmt.Errorf("Receivers do not match up! Got %x, expected %x", tx.Outputs[0].Address, user[0].Address)
}
return nil
}
}
// Decode from an io.Reader.
func (this *TCodec) Decode(v interface{}, r io.Reader) error {
bts, errR := ioutil.ReadAll(r)
if errR != nil {
return errR
}
var err error
wire.ReadJSON(v, bts, &err)
return err
}
func unmarshalCheckResponse(body []byte) (response *ctypes.Response, err error) {
response = new(ctypes.Response)
wire.ReadJSON(response, body, &err)
if err != nil {
return nil, err
}
if response.Error != "" {
return nil, fmt.Errorf(response.Error)
}
return response, nil
}
func LoadPrivValidator(filePath string) *PrivValidator {
privValJSONBytes, err := ioutil.ReadFile(filePath)
if err != nil {
Exit(err.Error())
}
privVal := wire.ReadJSON(&PrivValidator{}, privValJSONBytes, &err).(*PrivValidator)
if err != nil {
Exit(Fmt("Error reading PrivValidator from %v: %v\n", filePath, err))
}
privVal.filePath = filePath
return privVal
}
func unmarshalResponseNameReg(b []byte) (*types.NameTx, error) {
// unmarshall and assert somethings
var response ctypes.Response
var err error
wire.ReadJSON(&response, b, &err)
if err != nil {
return nil, err
}
if response.Error != "" {
return nil, fmt.Errorf(response.Error)
}
tx := response.Result.(*ctypes.ResultEvent).Data.(types.EventDataTx).Tx.(*types.NameTx)
return tx, nil
}
func unmarshalResponseNewBlock(b []byte) (*types.Block, error) {
// unmarshall and assert somethings
var response ctypes.Response
var err error
wire.ReadJSON(&response, b, &err)
if err != nil {
return nil, err
}
if response.Error != "" {
return nil, fmt.Errorf(response.Error)
}
block := response.Result.(*ctypes.ResultEvent).Data.(types.EventDataNewBlock).Block
return block, nil
}
func (wsc *WSClient) receiveEventsRoutine() {
for {
_, data, err := wsc.ReadMessage()
if err != nil {
log.Info("WSClient failed to read message", "error", err, "data", string(data))
wsc.Stop()
break
} else {
var response ctypes.Response
wire.ReadJSON(&response, data, &err)
if err != nil {
log.Info("WSClient failed to parse message", "error", err)
wsc.Stop()
break
}
if strings.HasSuffix(response.ID, "#event") {
wsc.EventsCh <- *response.Result.(*ctypes.ResultEvent)
} else {
wsc.ResultsCh <- response.Result
}
}
}
}
// Decode from a byte array.
func (this *TCodec) DecodeBytes(v interface{}, bts []byte) error {
var err error
wire.ReadJSON(v, bts, &err)
return err
}
// wait for an event; do things that might trigger events, and check them when they are received
// the check function takes an event id and the byte slice read off the ws
func waitForEvent(t *testing.T, con *websocket.Conn, eventid string, dieOnTimeout bool, f func(), check func(string, []byte) error) {
// go routine to wait for webscoket msg
goodCh := make(chan []byte)
errCh := make(chan error)
quitCh := make(chan struct{})
defer close(quitCh)
// Read message
go func() {
for {
_, p, err := con.ReadMessage()
if err != nil {
errCh <- err
break
} else {
// if the event id isnt what we're waiting on
// ignore it
var response ctypes.Response
var err error
wire.ReadJSON(&response, p, &err)
if err != nil {
errCh <- err
break
}
event, ok := response.Result.(*ctypes.ResultEvent)
if ok && event.Event == eventid {
goodCh <- p
break
}
}
}
}()
// do stuff (transactions)
f()
// wait for an event or timeout
timeout := time.NewTimer(10 * time.Second)
select {
case <-timeout.C:
if dieOnTimeout {
con.Close()
t.Fatalf("%s event was not received in time", eventid)
}
// else that's great, we didn't hear the event
// and we shouldn't have
case p := <-goodCh:
if dieOnTimeout {
// message was received and expected
// run the check
err := check(eventid, p)
if err != nil {
t.Fatal(err)
panic(err) // Show the stack trace.
}
} else {
con.Close()
t.Fatalf("%s event was not expected", eventid)
}
case err := <-errCh:
t.Fatal(err)
panic(err) // Show the stack trace.
}
}