github.com/MetalBlockchain/metalgo@v1.11.9/message/inbound_msg_builder.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package message
     5  
     6  import (
     7  	"time"
     8  
     9  	"github.com/MetalBlockchain/metalgo/ids"
    10  	"github.com/MetalBlockchain/metalgo/proto/pb/p2p"
    11  	"github.com/MetalBlockchain/metalgo/utils/timer/mockable"
    12  )
    13  
    14  var _ InboundMsgBuilder = (*inMsgBuilder)(nil)
    15  
    16  type InboundMsgBuilder interface {
    17  	// Parse reads given bytes as InboundMessage
    18  	Parse(
    19  		bytes []byte,
    20  		nodeID ids.NodeID,
    21  		onFinishedHandling func(),
    22  	) (InboundMessage, error)
    23  }
    24  
    25  type inMsgBuilder struct {
    26  	builder *msgBuilder
    27  }
    28  
    29  func newInboundBuilder(builder *msgBuilder) InboundMsgBuilder {
    30  	return &inMsgBuilder{
    31  		builder: builder,
    32  	}
    33  }
    34  
    35  func (b *inMsgBuilder) Parse(bytes []byte, nodeID ids.NodeID, onFinishedHandling func()) (InboundMessage, error) {
    36  	return b.builder.parseInbound(bytes, nodeID, onFinishedHandling)
    37  }
    38  
    39  func InboundGetStateSummaryFrontier(
    40  	chainID ids.ID,
    41  	requestID uint32,
    42  	deadline time.Duration,
    43  	nodeID ids.NodeID,
    44  ) InboundMessage {
    45  	return &inboundMessage{
    46  		nodeID: nodeID,
    47  		op:     GetStateSummaryFrontierOp,
    48  		message: &p2p.GetStateSummaryFrontier{
    49  			ChainId:   chainID[:],
    50  			RequestId: requestID,
    51  			Deadline:  uint64(deadline),
    52  		},
    53  		expiration: time.Now().Add(deadline),
    54  	}
    55  }
    56  
    57  func InboundStateSummaryFrontier(
    58  	chainID ids.ID,
    59  	requestID uint32,
    60  	summary []byte,
    61  	nodeID ids.NodeID,
    62  ) InboundMessage {
    63  	return &inboundMessage{
    64  		nodeID: nodeID,
    65  		op:     StateSummaryFrontierOp,
    66  		message: &p2p.StateSummaryFrontier{
    67  			ChainId:   chainID[:],
    68  			RequestId: requestID,
    69  			Summary:   summary,
    70  		},
    71  		expiration: mockable.MaxTime,
    72  	}
    73  }
    74  
    75  func InboundGetAcceptedStateSummary(
    76  	chainID ids.ID,
    77  	requestID uint32,
    78  	heights []uint64,
    79  	deadline time.Duration,
    80  	nodeID ids.NodeID,
    81  ) InboundMessage {
    82  	return &inboundMessage{
    83  		nodeID: nodeID,
    84  		op:     GetAcceptedStateSummaryOp,
    85  		message: &p2p.GetAcceptedStateSummary{
    86  			ChainId:   chainID[:],
    87  			RequestId: requestID,
    88  			Deadline:  uint64(deadline),
    89  			Heights:   heights,
    90  		},
    91  		expiration: time.Now().Add(deadline),
    92  	}
    93  }
    94  
    95  func InboundAcceptedStateSummary(
    96  	chainID ids.ID,
    97  	requestID uint32,
    98  	summaryIDs []ids.ID,
    99  	nodeID ids.NodeID,
   100  ) InboundMessage {
   101  	summaryIDBytes := make([][]byte, len(summaryIDs))
   102  	encodeIDs(summaryIDs, summaryIDBytes)
   103  	return &inboundMessage{
   104  		nodeID: nodeID,
   105  		op:     AcceptedStateSummaryOp,
   106  		message: &p2p.AcceptedStateSummary{
   107  			ChainId:    chainID[:],
   108  			RequestId:  requestID,
   109  			SummaryIds: summaryIDBytes,
   110  		},
   111  		expiration: mockable.MaxTime,
   112  	}
   113  }
   114  
   115  func InboundGetAcceptedFrontier(
   116  	chainID ids.ID,
   117  	requestID uint32,
   118  	deadline time.Duration,
   119  	nodeID ids.NodeID,
   120  ) InboundMessage {
   121  	return &inboundMessage{
   122  		nodeID: nodeID,
   123  		op:     GetAcceptedFrontierOp,
   124  		message: &p2p.GetAcceptedFrontier{
   125  			ChainId:   chainID[:],
   126  			RequestId: requestID,
   127  			Deadline:  uint64(deadline),
   128  		},
   129  		expiration: time.Now().Add(deadline),
   130  	}
   131  }
   132  
   133  func InboundAcceptedFrontier(
   134  	chainID ids.ID,
   135  	requestID uint32,
   136  	containerID ids.ID,
   137  	nodeID ids.NodeID,
   138  ) InboundMessage {
   139  	return &inboundMessage{
   140  		nodeID: nodeID,
   141  		op:     AcceptedFrontierOp,
   142  		message: &p2p.AcceptedFrontier{
   143  			ChainId:     chainID[:],
   144  			RequestId:   requestID,
   145  			ContainerId: containerID[:],
   146  		},
   147  		expiration: mockable.MaxTime,
   148  	}
   149  }
   150  
   151  func InboundGetAccepted(
   152  	chainID ids.ID,
   153  	requestID uint32,
   154  	deadline time.Duration,
   155  	containerIDs []ids.ID,
   156  	nodeID ids.NodeID,
   157  ) InboundMessage {
   158  	containerIDBytes := make([][]byte, len(containerIDs))
   159  	encodeIDs(containerIDs, containerIDBytes)
   160  	return &inboundMessage{
   161  		nodeID: nodeID,
   162  		op:     GetAcceptedOp,
   163  		message: &p2p.GetAccepted{
   164  			ChainId:      chainID[:],
   165  			RequestId:    requestID,
   166  			Deadline:     uint64(deadline),
   167  			ContainerIds: containerIDBytes,
   168  		},
   169  		expiration: time.Now().Add(deadline),
   170  	}
   171  }
   172  
   173  func InboundAccepted(
   174  	chainID ids.ID,
   175  	requestID uint32,
   176  	containerIDs []ids.ID,
   177  	nodeID ids.NodeID,
   178  ) InboundMessage {
   179  	containerIDBytes := make([][]byte, len(containerIDs))
   180  	encodeIDs(containerIDs, containerIDBytes)
   181  	return &inboundMessage{
   182  		nodeID: nodeID,
   183  		op:     AcceptedOp,
   184  		message: &p2p.Accepted{
   185  			ChainId:      chainID[:],
   186  			RequestId:    requestID,
   187  			ContainerIds: containerIDBytes,
   188  		},
   189  		expiration: mockable.MaxTime,
   190  	}
   191  }
   192  
   193  func InboundPushQuery(
   194  	chainID ids.ID,
   195  	requestID uint32,
   196  	deadline time.Duration,
   197  	container []byte,
   198  	requestedHeight uint64,
   199  	nodeID ids.NodeID,
   200  ) InboundMessage {
   201  	return &inboundMessage{
   202  		nodeID: nodeID,
   203  		op:     PushQueryOp,
   204  		message: &p2p.PushQuery{
   205  			ChainId:         chainID[:],
   206  			RequestId:       requestID,
   207  			Deadline:        uint64(deadline),
   208  			Container:       container,
   209  			RequestedHeight: requestedHeight,
   210  		},
   211  		expiration: time.Now().Add(deadline),
   212  	}
   213  }
   214  
   215  func InboundPullQuery(
   216  	chainID ids.ID,
   217  	requestID uint32,
   218  	deadline time.Duration,
   219  	containerID ids.ID,
   220  	requestedHeight uint64,
   221  	nodeID ids.NodeID,
   222  ) InboundMessage {
   223  	return &inboundMessage{
   224  		nodeID: nodeID,
   225  		op:     PullQueryOp,
   226  		message: &p2p.PullQuery{
   227  			ChainId:         chainID[:],
   228  			RequestId:       requestID,
   229  			Deadline:        uint64(deadline),
   230  			ContainerId:     containerID[:],
   231  			RequestedHeight: requestedHeight,
   232  		},
   233  		expiration: time.Now().Add(deadline),
   234  	}
   235  }
   236  
   237  func InboundChits(
   238  	chainID ids.ID,
   239  	requestID uint32,
   240  	preferredID ids.ID,
   241  	preferredIDAtHeight ids.ID,
   242  	acceptedID ids.ID,
   243  	nodeID ids.NodeID,
   244  ) InboundMessage {
   245  	return &inboundMessage{
   246  		nodeID: nodeID,
   247  		op:     ChitsOp,
   248  		message: &p2p.Chits{
   249  			ChainId:             chainID[:],
   250  			RequestId:           requestID,
   251  			PreferredId:         preferredID[:],
   252  			PreferredIdAtHeight: preferredIDAtHeight[:],
   253  			AcceptedId:          acceptedID[:],
   254  		},
   255  		expiration: mockable.MaxTime,
   256  	}
   257  }
   258  
   259  func InboundAppRequest(
   260  	chainID ids.ID,
   261  	requestID uint32,
   262  	deadline time.Duration,
   263  	msg []byte,
   264  	nodeID ids.NodeID,
   265  ) InboundMessage {
   266  	return &inboundMessage{
   267  		nodeID: nodeID,
   268  		op:     AppRequestOp,
   269  		message: &p2p.AppRequest{
   270  			ChainId:   chainID[:],
   271  			RequestId: requestID,
   272  			Deadline:  uint64(deadline),
   273  			AppBytes:  msg,
   274  		},
   275  		expiration: time.Now().Add(deadline),
   276  	}
   277  }
   278  
   279  func InboundAppError(
   280  	nodeID ids.NodeID,
   281  	chainID ids.ID,
   282  	requestID uint32,
   283  	errorCode int32,
   284  	errorMessage string,
   285  ) InboundMessage {
   286  	return &inboundMessage{
   287  		nodeID: nodeID,
   288  		op:     AppErrorOp,
   289  		message: &p2p.AppError{
   290  			ChainId:      chainID[:],
   291  			RequestId:    requestID,
   292  			ErrorCode:    errorCode,
   293  			ErrorMessage: errorMessage,
   294  		},
   295  		expiration: mockable.MaxTime,
   296  	}
   297  }
   298  
   299  func InboundAppResponse(
   300  	chainID ids.ID,
   301  	requestID uint32,
   302  	msg []byte,
   303  	nodeID ids.NodeID,
   304  ) InboundMessage {
   305  	return &inboundMessage{
   306  		nodeID: nodeID,
   307  		op:     AppResponseOp,
   308  		message: &p2p.AppResponse{
   309  			ChainId:   chainID[:],
   310  			RequestId: requestID,
   311  			AppBytes:  msg,
   312  		},
   313  		expiration: mockable.MaxTime,
   314  	}
   315  }
   316  
   317  func encodeIDs(ids []ids.ID, result [][]byte) {
   318  	for i, id := range ids {
   319  		id := id
   320  		result[i] = id[:]
   321  	}
   322  }