github.com/lirm/aeron-go@v0.0.0-20230415210743-920325491dc4/archive/codecs/encoders.go (about)

     1  // Copyright (C) 2021-2022 Talos, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  // http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  // Package codecs contains the archive protocol packet encoding and decoding
    16  package codecs
    17  
    18  import (
    19  	"bytes"
    20  )
    21  
    22  // Encoders for all the protocol packets
    23  //
    24  // Each of these functions creates a []byte suitable for sending over
    25  // the wire by using the generated encoders created using
    26  // simple-binary-encoding.
    27  //
    28  // All the packet specificationss are defined in the aeron-archive protocol
    29  // maintained at:
    30  // http://github.com/real-logic/aeron/blob/master/aeron-archive/src/main/resources/archive/aeron-archive-codecs.xml)
    31  //
    32  // The codecs are generated from that specification using Simple
    33  // Binary Encoding (SBE) from https://github.com/real-logic/simple-binary-encoding
    34  func ConnectRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, correlationID int64, responseStream int32, responseChannel string) ([]byte, error) {
    35  	var request ConnectRequest
    36  
    37  	request.CorrelationId = correlationID
    38  	request.Version = SemanticVersion()
    39  	request.ResponseStreamId = responseStream
    40  	request.ResponseChannel = []uint8(responseChannel)
    41  
    42  	// Marshal it
    43  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
    44  	buffer := new(bytes.Buffer)
    45  	if err := header.Encode(marshaller, buffer); err != nil {
    46  		return nil, err
    47  	}
    48  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
    49  		return nil, err
    50  	}
    51  
    52  	return buffer.Bytes(), nil
    53  }
    54  
    55  func CloseSessionRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64) ([]byte, error) {
    56  	var request CloseSessionRequest
    57  
    58  	request.ControlSessionId = controlSessionId
    59  
    60  	// Marshal it
    61  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
    62  	buffer := new(bytes.Buffer)
    63  	if err := header.Encode(marshaller, buffer); err != nil {
    64  		return nil, err
    65  	}
    66  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
    67  		return nil, err
    68  	}
    69  
    70  	return buffer.Bytes(), nil
    71  }
    72  
    73  // deprecated
    74  func StartRecordingRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, stream int32, isLocal bool, channel string) ([]byte, error) {
    75  	return StartRecordingRequest2Packet(marshaller, rangeChecking, controlSessionId, correlationId, stream, isLocal, false, channel)
    76  }
    77  
    78  func StartRecordingRequest2Packet(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, stream int32, isLocal bool, autoStop bool, channel string) ([]byte, error) {
    79  	var request StartRecordingRequest2
    80  
    81  	request.Channel = []uint8(channel)
    82  	request.StreamId = stream
    83  	if isLocal {
    84  		request.SourceLocation = SourceLocation.LOCAL
    85  	} else {
    86  		request.SourceLocation = SourceLocation.REMOTE
    87  	}
    88  	if autoStop {
    89  		request.AutoStop = BooleanType.TRUE
    90  	} // else FALSE by default
    91  	request.CorrelationId = correlationId
    92  	request.ControlSessionId = controlSessionId
    93  
    94  	// Marshal it
    95  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
    96  	buffer := new(bytes.Buffer)
    97  	if err := header.Encode(marshaller, buffer); err != nil {
    98  		return nil, err
    99  	}
   100  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   101  		return nil, err
   102  	}
   103  
   104  	return buffer.Bytes(), nil
   105  }
   106  
   107  func StopRecordingRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, stream int32, channel string) ([]byte, error) {
   108  	var request StopRecordingRequest
   109  
   110  	request.ControlSessionId = controlSessionId
   111  	request.CorrelationId = correlationId
   112  	request.StreamId = stream
   113  	request.Channel = []uint8(channel)
   114  
   115  	// Marshal it
   116  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   117  	buffer := new(bytes.Buffer)
   118  	if err := header.Encode(marshaller, buffer); err != nil {
   119  		return nil, err
   120  	}
   121  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   122  		return nil, err
   123  	}
   124  
   125  	return buffer.Bytes(), nil
   126  }
   127  
   128  func ReplayRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64, position int64, length int64, replayStream int32, replayChannel string) ([]byte, error) {
   129  	var request ReplayRequest
   130  	request.ControlSessionId = controlSessionId
   131  	request.CorrelationId = correlationId
   132  	request.RecordingId = recordingId
   133  	request.Position = position
   134  	request.Length = length
   135  	request.ReplayStreamId = replayStream
   136  	request.ReplayChannel = []uint8(replayChannel)
   137  
   138  	// Marshal it
   139  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   140  	buffer := new(bytes.Buffer)
   141  	if err := header.Encode(marshaller, buffer); err != nil {
   142  		return nil, err
   143  	}
   144  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   145  		return nil, err
   146  	}
   147  
   148  	return buffer.Bytes(), nil
   149  }
   150  
   151  func StopReplayRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, replaySessionId int64) ([]byte, error) {
   152  	var request StopReplayRequest
   153  	request.ControlSessionId = controlSessionId
   154  	request.CorrelationId = correlationId
   155  	request.ReplaySessionId = replaySessionId
   156  
   157  	// Marshal it
   158  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   159  	buffer := new(bytes.Buffer)
   160  	if err := header.Encode(marshaller, buffer); err != nil {
   161  		return nil, err
   162  	}
   163  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   164  		return nil, err
   165  	}
   166  
   167  	return buffer.Bytes(), nil
   168  }
   169  
   170  func ListRecordingsRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, fromRecordingId int64, recordCount int32) ([]byte, error) {
   171  	var request ListRecordingsRequest
   172  	request.ControlSessionId = controlSessionId
   173  	request.CorrelationId = correlationId
   174  	request.FromRecordingId = fromRecordingId
   175  	request.RecordCount = recordCount
   176  
   177  	// Marshal it
   178  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   179  	buffer := new(bytes.Buffer)
   180  	if err := header.Encode(marshaller, buffer); err != nil {
   181  		return nil, err
   182  	}
   183  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   184  		return nil, err
   185  	}
   186  
   187  	return buffer.Bytes(), nil
   188  }
   189  
   190  func ListRecordingsForUriRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, fromRecordingId int64, recordCount int32, stream int32, channel string) ([]byte, error) {
   191  	var request ListRecordingsForUriRequest
   192  	request.ControlSessionId = controlSessionId
   193  	request.CorrelationId = correlationId
   194  	request.FromRecordingId = fromRecordingId
   195  	request.RecordCount = recordCount
   196  	request.StreamId = stream
   197  	request.Channel = []uint8(channel)
   198  
   199  	// Marshal it
   200  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   201  	buffer := new(bytes.Buffer)
   202  	if err := header.Encode(marshaller, buffer); err != nil {
   203  		return nil, err
   204  	}
   205  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   206  		return nil, err
   207  	}
   208  
   209  	return buffer.Bytes(), nil
   210  }
   211  
   212  func ListRecordingRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   213  	var request ListRecordingRequest
   214  	request.ControlSessionId = controlSessionId
   215  	request.CorrelationId = correlationId
   216  	request.RecordingId = recordingId
   217  
   218  	// Marshal it
   219  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   220  	buffer := new(bytes.Buffer)
   221  	if err := header.Encode(marshaller, buffer); err != nil {
   222  		return nil, err
   223  	}
   224  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   225  		return nil, err
   226  	}
   227  
   228  	return buffer.Bytes(), nil
   229  }
   230  
   231  // deprecated
   232  func ExtendRecordingRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64, stream int32, sourceLocation SourceLocationEnum, channel string) ([]byte, error) {
   233  	return ExtendRecordingRequest2Packet(marshaller, rangeChecking, controlSessionId, correlationId, recordingId, stream, sourceLocation, false, channel)
   234  }
   235  
   236  func ExtendRecordingRequest2Packet(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64, stream int32, sourceLocation SourceLocationEnum, autoStop bool, channel string) ([]byte, error) {
   237  	var request ExtendRecordingRequest2
   238  	request.ControlSessionId = controlSessionId
   239  	request.CorrelationId = correlationId
   240  	request.RecordingId = recordingId
   241  	request.StreamId = stream
   242  	request.SourceLocation = sourceLocation
   243  	if autoStop {
   244  		request.AutoStop = BooleanType.TRUE
   245  	} // else FALSE by default
   246  	request.Channel = []uint8(channel)
   247  
   248  	// Marshal it
   249  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   250  	buffer := new(bytes.Buffer)
   251  	if err := header.Encode(marshaller, buffer); err != nil {
   252  		return nil, err
   253  	}
   254  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   255  		return nil, err
   256  	}
   257  
   258  	return buffer.Bytes(), nil
   259  }
   260  
   261  func RecordingPositionRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   262  	var request RecordingPositionRequest
   263  	request.ControlSessionId = controlSessionId
   264  	request.CorrelationId = correlationId
   265  	request.RecordingId = recordingId
   266  
   267  	// Marshal it
   268  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   269  	buffer := new(bytes.Buffer)
   270  	if err := header.Encode(marshaller, buffer); err != nil {
   271  		return nil, err
   272  	}
   273  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   274  		return nil, err
   275  	}
   276  
   277  	return buffer.Bytes(), nil
   278  }
   279  
   280  func TruncateRecordingRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64, position int64) ([]byte, error) {
   281  	var request TruncateRecordingRequest
   282  	request.ControlSessionId = controlSessionId
   283  	request.CorrelationId = correlationId
   284  	request.RecordingId = recordingId
   285  	request.Position = position
   286  
   287  	// Marshal it
   288  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   289  	buffer := new(bytes.Buffer)
   290  	if err := header.Encode(marshaller, buffer); err != nil {
   291  		return nil, err
   292  	}
   293  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   294  		return nil, err
   295  	}
   296  
   297  	return buffer.Bytes(), nil
   298  }
   299  
   300  func StopRecordingSubscriptionPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, subscriptionId int64) ([]byte, error) {
   301  	var request StopRecordingSubscriptionRequest
   302  	request.ControlSessionId = controlSessionId
   303  	request.CorrelationId = correlationId
   304  	request.SubscriptionId = subscriptionId
   305  
   306  	// Marshal it
   307  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   308  	buffer := new(bytes.Buffer)
   309  	if err := header.Encode(marshaller, buffer); err != nil {
   310  		return nil, err
   311  	}
   312  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   313  		return nil, err
   314  	}
   315  
   316  	return buffer.Bytes(), nil
   317  }
   318  
   319  func StopRecordingByIdentityPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   320  	var request StopRecordingByIdentityRequest
   321  	request.ControlSessionId = controlSessionId
   322  	request.CorrelationId = correlationId
   323  	request.RecordingId = recordingId
   324  
   325  	// Marshal it
   326  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   327  	buffer := new(bytes.Buffer)
   328  	if err := header.Encode(marshaller, buffer); err != nil {
   329  		return nil, err
   330  	}
   331  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   332  		return nil, err
   333  	}
   334  
   335  	return buffer.Bytes(), nil
   336  }
   337  
   338  func StopPositionPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   339  	var request StopPositionRequest
   340  	request.ControlSessionId = controlSessionId
   341  	request.CorrelationId = correlationId
   342  	request.RecordingId = recordingId
   343  
   344  	// Marshal it
   345  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   346  	buffer := new(bytes.Buffer)
   347  	if err := header.Encode(marshaller, buffer); err != nil {
   348  		return nil, err
   349  	}
   350  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   351  		return nil, err
   352  	}
   353  
   354  	return buffer.Bytes(), nil
   355  }
   356  
   357  func FindLastMatchingRecordingPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, minRecordingId int64, sessionId int32, stream int32, channel string) ([]byte, error) {
   358  	var request FindLastMatchingRecordingRequest
   359  	request.ControlSessionId = controlSessionId
   360  	request.CorrelationId = correlationId
   361  	request.MinRecordingId = minRecordingId
   362  	request.SessionId = sessionId
   363  	request.StreamId = stream
   364  	request.Channel = []uint8(channel)
   365  
   366  	// Marshal it
   367  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   368  	buffer := new(bytes.Buffer)
   369  	if err := header.Encode(marshaller, buffer); err != nil {
   370  		return nil, err
   371  	}
   372  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   373  		return nil, err
   374  	}
   375  
   376  	return buffer.Bytes(), nil
   377  }
   378  
   379  func ListRecordingSubscriptionsPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, pseudoIndex int32, subscriptionCount int32, applyStreamId bool, stream int32, channel string) ([]byte, error) {
   380  	var request ListRecordingSubscriptionsRequest
   381  	request.ControlSessionId = controlSessionId
   382  	request.CorrelationId = correlationId
   383  	request.PseudoIndex = pseudoIndex
   384  	request.SubscriptionCount = subscriptionCount
   385  	if applyStreamId {
   386  		request.ApplyStreamId = BooleanType.TRUE
   387  	} // else FALSE by default
   388  	request.StreamId = stream
   389  	request.Channel = []uint8(channel)
   390  
   391  	// Marshal it
   392  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   393  	buffer := new(bytes.Buffer)
   394  	if err := header.Encode(marshaller, buffer); err != nil {
   395  		return nil, err
   396  	}
   397  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   398  		return nil, err
   399  	}
   400  
   401  	return buffer.Bytes(), nil
   402  }
   403  
   404  func BoundedReplayPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64, position int64, length int64, limitCounterId int32, replayStream int32, replayChannel string) ([]byte, error) {
   405  	var request BoundedReplayRequest
   406  	request.ControlSessionId = controlSessionId
   407  	request.CorrelationId = correlationId
   408  	request.RecordingId = recordingId
   409  	request.Position = position
   410  	request.Length = length
   411  	request.LimitCounterId = limitCounterId
   412  	request.ReplayStreamId = replayStream
   413  	request.ReplayChannel = []uint8(replayChannel)
   414  
   415  	// Marshal it
   416  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   417  	buffer := new(bytes.Buffer)
   418  	if err := header.Encode(marshaller, buffer); err != nil {
   419  		return nil, err
   420  	}
   421  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   422  		return nil, err
   423  	}
   424  
   425  	return buffer.Bytes(), nil
   426  }
   427  
   428  func StopAllReplaysPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   429  	var request StopAllReplaysRequest
   430  	request.ControlSessionId = controlSessionId
   431  	request.CorrelationId = correlationId
   432  	request.RecordingId = recordingId
   433  
   434  	// Marshal it
   435  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   436  	buffer := new(bytes.Buffer)
   437  	if err := header.Encode(marshaller, buffer); err != nil {
   438  		return nil, err
   439  	}
   440  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   441  		return nil, err
   442  	}
   443  
   444  	return buffer.Bytes(), nil
   445  }
   446  
   447  func CatalogHeaderPacket(marshaller *SbeGoMarshaller, rangeChecking bool, version int32, length int32, nextRecordingId int64, alignment int32) ([]byte, error) {
   448  	var request CatalogHeader
   449  	request.Version = version
   450  	request.Length = length
   451  	request.NextRecordingId = nextRecordingId
   452  	request.Alignment = alignment
   453  
   454  	// Marshal it
   455  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   456  	buffer := new(bytes.Buffer)
   457  	if err := header.Encode(marshaller, buffer); err != nil {
   458  		return nil, err
   459  	}
   460  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   461  		return nil, err
   462  	}
   463  
   464  	return buffer.Bytes(), nil
   465  }
   466  
   467  func ReplicateRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, srcRecordingId int64, dstRecordingId int64, srcControlStreamId int32, srcControlChannel string, liveDestination string) ([]byte, error) {
   468  	var request ReplicateRequest
   469  	request.ControlSessionId = controlSessionId
   470  	request.CorrelationId = correlationId
   471  	request.SrcRecordingId = srcRecordingId
   472  	request.DstRecordingId = dstRecordingId
   473  	request.SrcControlStreamId = srcControlStreamId
   474  	request.SrcControlChannel = []uint8(srcControlChannel)
   475  	request.LiveDestination = []uint8(liveDestination)
   476  
   477  	// Marshal it
   478  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   479  	buffer := new(bytes.Buffer)
   480  	if err := header.Encode(marshaller, buffer); err != nil {
   481  		return nil, err
   482  	}
   483  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   484  		return nil, err
   485  	}
   486  
   487  	return buffer.Bytes(), nil
   488  }
   489  
   490  func StopReplicationRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, replicationId int64) ([]byte, error) {
   491  	var request StopReplicationRequest
   492  	request.ControlSessionId = controlSessionId
   493  	request.CorrelationId = correlationId
   494  	request.ReplicationId = replicationId
   495  
   496  	// Marshal it
   497  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   498  	buffer := new(bytes.Buffer)
   499  	if err := header.Encode(marshaller, buffer); err != nil {
   500  		return nil, err
   501  	}
   502  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   503  		return nil, err
   504  	}
   505  
   506  	return buffer.Bytes(), nil
   507  }
   508  
   509  func StartPositionRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   510  	var request StartPositionRequest
   511  	request.ControlSessionId = controlSessionId
   512  	request.CorrelationId = correlationId
   513  	request.RecordingId = recordingId
   514  
   515  	// Marshal it
   516  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   517  	buffer := new(bytes.Buffer)
   518  	if err := header.Encode(marshaller, buffer); err != nil {
   519  		return nil, err
   520  	}
   521  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   522  		return nil, err
   523  	}
   524  
   525  	return buffer.Bytes(), nil
   526  }
   527  
   528  func DetachSegmentsRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64, newStartPosition int64) ([]byte, error) {
   529  	var request DetachSegmentsRequest
   530  	request.ControlSessionId = controlSessionId
   531  	request.CorrelationId = correlationId
   532  	request.RecordingId = recordingId
   533  	request.NewStartPosition = newStartPosition
   534  
   535  	// Marshal it
   536  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   537  	buffer := new(bytes.Buffer)
   538  	if err := header.Encode(marshaller, buffer); err != nil {
   539  		return nil, err
   540  	}
   541  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   542  		return nil, err
   543  	}
   544  
   545  	return buffer.Bytes(), nil
   546  }
   547  
   548  func DeleteDetachedSegmentsRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   549  	var request DeleteDetachedSegmentsRequest
   550  	request.ControlSessionId = controlSessionId
   551  	request.CorrelationId = correlationId
   552  	request.RecordingId = recordingId
   553  
   554  	// Marshal it
   555  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   556  	buffer := new(bytes.Buffer)
   557  	if err := header.Encode(marshaller, buffer); err != nil {
   558  		return nil, err
   559  	}
   560  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   561  		return nil, err
   562  	}
   563  
   564  	return buffer.Bytes(), nil
   565  }
   566  
   567  func PurgeSegmentsRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64, newStartPosition int64) ([]byte, error) {
   568  	var request PurgeSegmentsRequest
   569  	request.ControlSessionId = controlSessionId
   570  	request.CorrelationId = correlationId
   571  	request.RecordingId = recordingId
   572  	request.NewStartPosition = newStartPosition
   573  
   574  	// Marshal it
   575  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   576  	buffer := new(bytes.Buffer)
   577  	if err := header.Encode(marshaller, buffer); err != nil {
   578  		return nil, err
   579  	}
   580  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   581  		return nil, err
   582  	}
   583  
   584  	return buffer.Bytes(), nil
   585  }
   586  
   587  func AttachSegmentsRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   588  	var request AttachSegmentsRequest
   589  	request.ControlSessionId = controlSessionId
   590  	request.CorrelationId = correlationId
   591  	request.RecordingId = recordingId
   592  
   593  	// Marshal it
   594  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   595  	buffer := new(bytes.Buffer)
   596  	if err := header.Encode(marshaller, buffer); err != nil {
   597  		return nil, err
   598  	}
   599  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   600  		return nil, err
   601  	}
   602  
   603  	return buffer.Bytes(), nil
   604  }
   605  
   606  func AuthConnectRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, correlationID int64, responseStream int32, responseChannel string, encodedCredentials []uint8) ([]byte, error) {
   607  	var request AuthConnectRequest
   608  
   609  	request.CorrelationId = correlationID
   610  	request.Version = SemanticVersion()
   611  	request.ResponseStreamId = responseStream
   612  	request.ResponseChannel = []uint8(responseChannel)
   613  	request.EncodedCredentials = encodedCredentials
   614  
   615  	// Marshal it
   616  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   617  	buffer := new(bytes.Buffer)
   618  	if err := header.Encode(marshaller, buffer); err != nil {
   619  		return nil, err
   620  	}
   621  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   622  		return nil, err
   623  	}
   624  
   625  	return buffer.Bytes(), nil
   626  }
   627  
   628  func ChallengeResponsePacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, encodedCredentials []uint8) ([]byte, error) {
   629  	var request ChallengeResponse
   630  	request.ControlSessionId = controlSessionId
   631  	request.CorrelationId = correlationId
   632  	request.EncodedCredentials = encodedCredentials
   633  
   634  	// Marshal it
   635  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   636  	buffer := new(bytes.Buffer)
   637  	if err := header.Encode(marshaller, buffer); err != nil {
   638  		return nil, err
   639  	}
   640  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   641  		return nil, err
   642  	}
   643  
   644  	return buffer.Bytes(), nil
   645  }
   646  
   647  func MigrateSegmentsRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, srcRecordingId int64, destRecordingId int64) ([]byte, error) {
   648  	var request MigrateSegmentsRequest
   649  	request.ControlSessionId = controlSessionId
   650  	request.CorrelationId = correlationId
   651  	request.SrcRecordingId = srcRecordingId
   652  	request.DstRecordingId = destRecordingId
   653  
   654  	// Marshal it
   655  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   656  	buffer := new(bytes.Buffer)
   657  	if err := header.Encode(marshaller, buffer); err != nil {
   658  		return nil, err
   659  	}
   660  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   661  		return nil, err
   662  	}
   663  
   664  	return buffer.Bytes(), nil
   665  }
   666  
   667  func KeepAliveRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64) ([]byte, error) {
   668  	var request KeepAliveRequest
   669  	request.ControlSessionId = controlSessionId
   670  	request.CorrelationId = correlationId
   671  
   672  	// Marshal it
   673  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   674  	buffer := new(bytes.Buffer)
   675  	if err := header.Encode(marshaller, buffer); err != nil {
   676  		return nil, err
   677  	}
   678  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   679  		return nil, err
   680  	}
   681  
   682  	return buffer.Bytes(), nil
   683  }
   684  
   685  func TaggedReplicateRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, srcRecordingId int64, dstRecordingId int64, channelTagId int64, subscriptionTagId int64, srcControlStreamId int32, srcControlChannel string, liveDestination string) ([]byte, error) {
   686  	var request TaggedReplicateRequest
   687  	request.ControlSessionId = controlSessionId
   688  	request.CorrelationId = correlationId
   689  	request.SrcRecordingId = srcRecordingId
   690  	request.DstRecordingId = dstRecordingId
   691  	request.ChannelTagId = channelTagId
   692  	request.SubscriptionTagId = subscriptionTagId
   693  	request.SrcControlStreamId = srcControlStreamId
   694  	request.SrcControlChannel = []uint8(srcControlChannel)
   695  	request.LiveDestination = []uint8(liveDestination)
   696  
   697  	// Marshal it
   698  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   699  	buffer := new(bytes.Buffer)
   700  	if err := header.Encode(marshaller, buffer); err != nil {
   701  		return nil, err
   702  	}
   703  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   704  		return nil, err
   705  	}
   706  
   707  	return buffer.Bytes(), nil
   708  }
   709  
   710  func ReplicateRequest2Packet(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, srcRecordingId int64, dstRecordingId int64, stopPosition int64, channelTagId int64, srcControlStreamId int32, srcControlChannel string, liveDestination string, replicationChannel string) ([]byte, error) {
   711  	var request ReplicateRequest2
   712  	request.ControlSessionId = controlSessionId
   713  	request.CorrelationId = correlationId
   714  	request.SrcRecordingId = srcRecordingId
   715  	request.DstRecordingId = dstRecordingId
   716  	request.StopPosition = stopPosition
   717  	request.ChannelTagId = channelTagId
   718  	request.SrcControlStreamId = srcControlStreamId
   719  	request.SrcControlChannel = []uint8(srcControlChannel)
   720  	request.LiveDestination = []uint8(liveDestination)
   721  	request.ReplicationChannel = []uint8(replicationChannel)
   722  
   723  	// Marshal it
   724  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   725  	buffer := new(bytes.Buffer)
   726  	if err := header.Encode(marshaller, buffer); err != nil {
   727  		return nil, err
   728  	}
   729  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   730  		return nil, err
   731  	}
   732  
   733  	return buffer.Bytes(), nil
   734  }
   735  
   736  func PurgeRecordingRequestPacket(marshaller *SbeGoMarshaller, rangeChecking bool, controlSessionId int64, correlationId int64, recordingId int64) ([]byte, error) {
   737  	var request PurgeRecordingRequest
   738  	request.ControlSessionId = controlSessionId
   739  	request.CorrelationId = correlationId
   740  	request.RecordingId = recordingId
   741  
   742  	// Marshal it
   743  	header := MessageHeader{BlockLength: request.SbeBlockLength(), TemplateId: request.SbeTemplateId(), SchemaId: request.SbeSchemaId(), Version: request.SbeSchemaVersion()}
   744  	buffer := new(bytes.Buffer)
   745  	if err := header.Encode(marshaller, buffer); err != nil {
   746  		return nil, err
   747  	}
   748  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   749  		return nil, err
   750  	}
   751  
   752  	return buffer.Bytes(), nil
   753  }