func (c *boltConn) ackFailure(failure messages.FailureMessage) error {
log.Infof("Acknowledging Failure: %#v", failure)
ack := messages.NewAckFailureMessage()
err := encoding.NewEncoder(c, c.chunkSize).Encode(ack)
if err != nil {
return errors.Wrap(err, "An error occurred encoding ack failure message")
}
for {
respInt, err := encoding.NewDecoder(c).Decode()
if err != nil {
return errors.Wrap(err, "An error occurred decoding ack failure message response")
}
switch resp := respInt.(type) {
case messages.IgnoredMessage:
log.Infof("Got ignored message when acking failure: %#v", resp)
continue
case messages.SuccessMessage:
log.Infof("Got success message when acking failure: %#v", resp)
return nil
case messages.FailureMessage:
log.Errorf("Got failure message when acking failure: %#v", resp)
return c.reset()
default:
log.Errorf("Got unrecognized response from acking failure: %#v", resp)
err := c.Close()
if err != nil {
log.Errorf("An error occurred closing the session: %s", err)
}
return errors.New("Got unrecognized response from acking failure: %#v. CLOSING SESSION!", resp)
}
}
}
func (c *boltConn) reset() error {
log.Info("Resetting session")
reset := messages.NewResetMessage()
err := encoding.NewEncoder(c, c.chunkSize).Encode(reset)
if err != nil {
return errors.Wrap(err, "An error occurred encoding reset message")
}
for {
respInt, err := encoding.NewDecoder(c).Decode()
if err != nil {
return errors.Wrap(err, "An error occurred decoding reset message response")
}
switch resp := respInt.(type) {
case messages.IgnoredMessage:
log.Infof("Got ignored message when resetting session: %#v", resp)
continue
case messages.SuccessMessage:
log.Infof("Got success message when resetting session: %#v", resp)
return nil
case messages.FailureMessage:
log.Errorf("Got failure message when resetting session: %#v", resp)
err = c.Close()
if err != nil {
log.Errorf("An error occurred closing the session: %s", err)
}
return errors.New("Error resetting session: %#v. CLOSING SESSION!", resp)
default:
log.Errorf("Got unrecognized response from resetting session: %#v", resp)
err = c.Close()
if err != nil {
log.Errorf("An error occurred closing the session: %s", err)
}
return errors.New("Got unrecognized response from resetting session: %#v. CLOSING SESSION!", resp)
}
}
}
func (c *boltConn) consume() (interface{}, error) {
log.Info("Consuming response from bolt stream")
respInt, err := encoding.NewDecoder(c).Decode()
if err != nil {
return respInt, err
}
if log.GetLevel() >= log.TraceLevel {
log.Tracef("Consumed Response: %#v", respInt)
}
if failure, isFail := respInt.(messages.FailureMessage); isFail {
log.Errorf("Got failure message: %#v", failure)
err := c.ackFailure(failure)
if err != nil {
return nil, err
}
return failure, errors.New("Got failure message: %#v", failure)
}
return respInt, err
}
func (r *recorder) print() {
fmt.Println("PRINTING RECORDING " + r.name)
for _, event := range r.events {
fmt.Println()
fmt.Println()
typee := "READ"
if event.IsWrite {
typee = "WRITE"
}
fmt.Printf("%s @ %d:\n\n", typee, event.Timestamp)
decoded, err := encoding.NewDecoder(bytes.NewBuffer(event.Event)).Decode()
if err != nil {
fmt.Printf("Error decoding data! Error: %s\n", err)
} else {
fmt.Printf("Decoded Data:\n\n%+v\n\n", decoded)
}
fmt.Print("Encoded Bytes:\n\n")
fmt.Print(sprintByteHex(event.Event))
if !event.Completed {
fmt.Println("EVENT NEVER COMPLETED!!!!!!!!!!!!!!!")
}
if event.Error != nil {
fmt.Printf("ERROR OCCURRED DURING EVENT!!!!!!!\n\nError: %s\n", event.Error)
}
fmt.Println()
fmt.Println()
}
fmt.Println("RECORDING END " + r.name)
}