[#1069] GGenerate OrderProcessingFailure message on local node

OpenBazaar · Aug 2, 2019 · 8a0a3e2 · 8a0a3e2
1 parent 4568aca
commit 8a0a3e2
Show file tree

Hide file tree

Showing 8 changed files with 518 additions and 357 deletions.
diff --git a/core/disputes.go b/core/disputes.go
@@ -308,6 +308,9 @@ func (n *OpenBazaarNode) ProcessDisputeOpen(rc *pb.RicardianContract, peerID str
 		// Load out version of the contract from the db
 		myContract, state, _, records, _, _, err := n.Datastore.Sales().GetByOrderId(orderID)
 		if err != nil {
+			if err := n.SendProcessingError(DisputerID, orderID, pb.Message_DISPUTE_OPEN, nil); err != nil {
+				log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", DisputerID, err)
+			}
 			return net.OutOfOrderMessage
 		}
 		// Check this order is currently in a state which can be disputed
@@ -365,6 +368,9 @@ func (n *OpenBazaarNode) ProcessDisputeOpen(rc *pb.RicardianContract, peerID str
 			return err
 		}
 		if state == pb.OrderState_AWAITING_PAYMENT || state == pb.OrderState_AWAITING_FULFILLMENT || state == pb.OrderState_PARTIALLY_FULFILLED || state == pb.OrderState_PENDING {
+			if err := n.SendProcessingError(DisputerID, orderID, pb.Message_DISPUTE_OPEN, myContract); err != nil {
+				log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", DisputerID, err)
+			}
 			return net.OutOfOrderMessage
 		}
 		// Check this order is currently in a state which can be disputed

diff --git a/core/errors.go b/core/errors.go
@@ -1,10 +1,16 @@
 package core
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"strconv"
+
+	peer "gx/ipfs/QmYVXrKrKHDC9FobgmcmshCDyWwdrfwfanNQN4oxJ9Fk3h/go-libp2p-peer"
+
+	"github.com/OpenBazaar/openbazaar-go/pb"
+	"github.com/golang/protobuf/ptypes"
 )
 
 var (
@@ -121,3 +127,35 @@ func (e ErrMarketPriceListingIllegalField) Error() string {
 func illegalFieldString(objectType string, field string) string {
 	return fmt.Sprintf("Illegal %s field: %s", objectType, field)
 }
+
+// SendProcessingError will encapsulate the failing state in a message to be sent back to pid
+// When pid receives the OrderProcessingError, it will analyze the contract and send the messages
+// that this node is missing to resynchronize the order
+func (n *OpenBazaarNode) SendProcessingError(pid, oid string, attemptedMessage pb.Message_MessageType, latestContract *pb.RicardianContract) error {
+	log.Debugf("sending ORDER_PROCESSING_ERROR to peer (%s)", pid)
+	var (
+		procErrMsg = &pb.OrderProcessingFailure{
+			OrderID:              oid,
+			AttemptedMessageType: attemptedMessage,
+			Contract:             latestContract,
+		}
+		procErrBytes, mErr = ptypes.MarshalAny(procErrMsg)
+		errMsg             = &pb.Message{
+			MessageType: pb.Message_ORDER_PROCESSING_FAILURE,
+			Payload:     procErrBytes,
+		}
+		p, pErr = peer.IDB58Decode(pid)
+	)
+	if mErr != nil {
+		log.Errorf("failed marshaling OrderProcessingFailure message for order (%s): %s", oid, mErr)
+		return mErr
+	}
+	if pErr != nil {
+		log.Errorf("failed decoding peer ID (%s): %s", pid, pErr)
+		return pErr
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), n.OfflineMessageFailoverTimeout)
+	defer cancel()
+
+	return n.Service.SendMessage(ctx, p, errMsg)
+}
diff --git a/net/retriever/retriever_test.go b/net/retriever/retriever_test.go
@@ -17,11 +17,12 @@ func TestEnsureNoOmissionsInMessageProcessingOrder(t *testing.T) {
 
 	// Add deliberate omissions to this list
 	blackList := map[pb.Message_MessageType]struct{}{
-		pb.Message_PING:          {},
-		pb.Message_OFFLINE_RELAY: {},
-		pb.Message_STORE:         {},
-		pb.Message_BLOCK:         {},
-		pb.Message_ERROR:         {},
+		pb.Message_PING:                     {},
+		pb.Message_OFFLINE_RELAY:            {},
+		pb.Message_STORE:                    {},
+		pb.Message_BLOCK:                    {},
+		pb.Message_ORDER_PROCESSING_FAILURE: {},
+		pb.Message_ERROR:                    {},
 	}
 
 	// Inclusion check

diff --git a/net/service/handlers.go b/net/service/handlers.go
@@ -459,6 +459,9 @@ func (service *OpenBazaarService) handleOrderConfirmation(p peer.ID, pmes *pb.Me
 	// Load the order
 	contract, state, funded, _, _, _, err := service.datastore.Purchases().GetByOrderId(orderId)
 	if err != nil {
+		if err := service.SendProcessingError(p.Pretty(), orderId, pb.Message_ORDER_CONFIRMATION, nil); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
@@ -518,6 +521,9 @@ func (service *OpenBazaarService) handleOrderCancel(p peer.ID, pmes *pb.Message,
 	// Load the order
 	contract, state, _, _, _, _, err := service.datastore.Sales().GetByOrderId(orderId)
 	if err != nil {
+		if err := service.SendProcessingError(p.Pretty(), orderId, pb.Message_ORDER_CANCEL, nil); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
@@ -563,6 +569,9 @@ func (service *OpenBazaarService) handleReject(p peer.ID, pmes *pb.Message, opti
 	// Load the order
 	contract, state, _, records, _, _, err := service.datastore.Purchases().GetByOrderId(rejectMsg.OrderID)
 	if err != nil {
+		if err := service.SendProcessingError(p.Pretty(), rejectMsg.OrderID, pb.Message_ORDER_REJECT, nil); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
@@ -726,6 +735,9 @@ func (service *OpenBazaarService) handleRefund(p peer.ID, pmes *pb.Message, opti
 	// Load the order
 	contract, state, _, records, _, _, err := service.datastore.Purchases().GetByOrderId(rc.Refund.OrderID)
 	if err != nil {
+		if err := service.SendProcessingError(p.Pretty(), rc.Refund.OrderID, pb.Message_REFUND, nil); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
@@ -841,10 +853,16 @@ func (service *OpenBazaarService) handleOrderFulfillment(p peer.ID, pmes *pb.Mes
 	// Load the order
 	contract, state, _, _, _, _, err := service.datastore.Purchases().GetByOrderId(rc.VendorOrderFulfillment[0].OrderId)
 	if err != nil {
+		if err := service.SendProcessingError(p.Pretty(), rc.VendorOrderFulfillment[0].OrderId, pb.Message_ORDER_FULFILLMENT, nil); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
 	if state == pb.OrderState_PENDING || state == pb.OrderState_AWAITING_PAYMENT {
+		if err := service.SendProcessingError(p.Pretty(), rc.VendorOrderFulfillment[0].OrderId, pb.Message_ORDER_FULFILLMENT, contract); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
@@ -910,6 +928,9 @@ func (service *OpenBazaarService) handleOrderCompletion(p peer.ID, pmes *pb.Mess
 	// Load the order
 	contract, state, _, records, _, _, err := service.datastore.Sales().GetByOrderId(rc.BuyerOrderCompletion.OrderId)
 	if err != nil {
+		if err := service.SendProcessingError(p.Pretty(), rc.BuyerOrderCompletion.OrderId, pb.Message_ORDER_COMPLETION, nil); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
@@ -1054,6 +1075,9 @@ func (service *OpenBazaarService) handleDisputeUpdate(p peer.ID, pmes *pb.Messag
 	}
 	dispute, err := service.node.Datastore.Cases().GetByCaseID(update.OrderId)
 	if err != nil {
+		if err := service.SendProcessingError(p.Pretty(), update.OrderId, pb.Message_DISPUTE_UPDATE, nil); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 	rc := new(pb.RicardianContract)
@@ -1142,6 +1166,9 @@ func (service *OpenBazaarService) handleDisputeClose(p peer.ID, pmes *pb.Message
 	if err != nil {
 		contract, state, _, _, _, _, err = service.datastore.Purchases().GetByOrderId(rc.DisputeResolution.OrderId)
 		if err != nil {
+			if err := service.SendProcessingError(p.Pretty(), rc.DisputeResolution.OrderId, pb.Message_DISPUTE_CLOSE, nil); err != nil {
+				log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+			}
 			return nil, net.OutOfOrderMessage
 		}
 		isPurchase = true
@@ -1161,6 +1188,9 @@ func (service *OpenBazaarService) handleDisputeClose(p peer.ID, pmes *pb.Message
 	}
 
 	if state != pb.OrderState_DISPUTED {
+		if err := service.SendProcessingError(p.Pretty(), rc.DisputeResolution.OrderId, pb.Message_DISPUTE_CLOSE, contract); err != nil {
+			log.Errorf("failed sending ORDER_PROCESSING_FAILURE to peer (%s): %s", p.Pretty(), err)
+		}
 		return nil, net.OutOfOrderMessage
 	}
 
@@ -1526,3 +1556,7 @@ func (service *OpenBazaarService) handleError(peer peer.ID, pmes *pb.Message, op
 	service.datastore.Notifications().PutRecord(repo.NewNotification(n, time.Now(), false))
 	return nil, nil
 }
+
+func (service *OpenBazaarService) SendProcessingError(pid, oid string, attemptedMessage pb.Message_MessageType, latestContract *pb.RicardianContract) error {
+	return service.node.SendProcessingError(pid, oid, attemptedMessage, latestContract)
+}