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) sendRun(query string, args map[string]interface{}) error {
log.Infof("Sending RUN message: query %s (args: %#v)", query, args)
runMessage := messages.NewRunMessage(query, args)
if err := encoding.NewEncoder(c, c.chunkSize).Encode(runMessage); err != nil {
return errors.Wrap(err, "An error occurred running query")
}
return nil
}
func (c *boltConn) sendInit() (interface{}, error) {
log.Infof("Sending INIT Message. ClientID: %s User: %s Password: %s", ClientID, c.user, c.password)
initMessage := messages.NewInitMessage(ClientID, c.user, c.password)
if err := encoding.NewEncoder(c, c.chunkSize).Encode(initMessage); err != nil {
return nil, errors.Wrap(err, "An error occurred sending init message")
}
return c.consume()
}
func (c *boltConn) sendDiscardAll() error {
log.Infof("Sending DISCARD_ALL message")
discardAllMessage := messages.NewDiscardAllMessage()
err := encoding.NewEncoder(c, c.chunkSize).Encode(discardAllMessage)
if err != nil {
return errors.Wrap(err, "An error occurred encoding discard all query")
}
return nil
}
func (c *boltConn) sendPullAll() error {
log.Infof("Sending PULL_ALL message")
pullAllMessage := messages.NewPullAllMessage()
err := encoding.NewEncoder(c, c.chunkSize).Encode(pullAllMessage)
if err != nil {
return errors.Wrap(err, "An error occurred encoding pull all query")
}
return nil
}
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)
}
}
}
