github.com/lirm/aeron-go@v0.0.0-20230415210743-920325491dc4/cluster/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  	"github.com/lirm/aeron-go/aeron/atomic"
    22  )
    23  
    24  // Encoders for all cluster protocol packets
    25  //
    26  // Each of these functions creates a []byte suitable for sending over
    27  // the wire by using the generated encoders created using
    28  // simple-binary-encoding.
    29  //
    30  // All the packet specificationss are defined in the aeron-cluster protocol
    31  // maintained at:
    32  // http://github.com/real-logic/aeron/blob/master/aeron-cluster/src/main/resources/cluster/aeron-cluster-codecs.xml)
    33  //
    34  // The codecs are generated from that specification using Simple
    35  // Binary Encoding (SBE) from https://github.com/real-logic/simple-binary-encoding
    36  
    37  func ServiceAckRequestPacket(
    38  	marshaller *SbeGoMarshaller,
    39  	rangeChecking bool,
    40  	logPosition int64,
    41  	timestamp int64,
    42  	ackID int64,
    43  	relevantID int64,
    44  	serviceID int32,
    45  ) ([]byte, error) {
    46  	request := ServiceAck{
    47  		LogPosition: logPosition,
    48  		Timestamp:   timestamp,
    49  		AckId:       ackID,
    50  		RelevantId:  relevantID,
    51  		ServiceId:   serviceID,
    52  	}
    53  
    54  	// Marshal it
    55  	header := MessageHeader{
    56  		BlockLength: request.SbeBlockLength(),
    57  		TemplateId:  request.SbeTemplateId(),
    58  		SchemaId:    request.SbeSchemaId(),
    59  		Version:     request.SbeSchemaVersion(),
    60  	}
    61  
    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  func SnapshotMarkerPacket(
    74  	marshaller *SbeGoMarshaller,
    75  	rangeChecking bool,
    76  	typeId int64,
    77  	logPosition int64,
    78  	leadershipTermId int64,
    79  	index int32,
    80  	mark SnapshotMarkEnum,
    81  	timeUnit ClusterTimeUnitEnum,
    82  	appVersion int32,
    83  ) ([]byte, error) {
    84  	request := SnapshotMarker{
    85  		TypeId:           typeId,
    86  		LogPosition:      logPosition,
    87  		LeadershipTermId: leadershipTermId,
    88  		Index:            index,
    89  		Mark:             mark,
    90  		TimeUnit:         timeUnit,
    91  		AppVersion:       appVersion,
    92  	}
    93  	header := MessageHeader{
    94  		BlockLength: request.SbeBlockLength(),
    95  		TemplateId:  request.SbeTemplateId(),
    96  		SchemaId:    request.SbeSchemaId(),
    97  		Version:     request.SbeSchemaVersion(),
    98  	}
    99  
   100  	buffer := new(bytes.Buffer)
   101  	if err := header.Encode(marshaller, buffer); err != nil {
   102  		return nil, err
   103  	}
   104  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   105  		return nil, err
   106  	}
   107  	return buffer.Bytes(), nil
   108  }
   109  
   110  func ClientSessionPacket(
   111  	marshaller *SbeGoMarshaller,
   112  	rangeChecking bool,
   113  	clusterSessionId int64,
   114  	responseStreamId int32,
   115  	responseChannel []byte,
   116  	encodedPrincipal []byte,
   117  ) ([]byte, error) {
   118  	request := ClientSession{
   119  		ClusterSessionId: clusterSessionId,
   120  		ResponseStreamId: responseStreamId,
   121  		ResponseChannel:  responseChannel,
   122  		EncodedPrincipal: encodedPrincipal,
   123  	}
   124  	header := MessageHeader{
   125  		BlockLength: request.SbeBlockLength(),
   126  		TemplateId:  request.SbeTemplateId(),
   127  		SchemaId:    request.SbeSchemaId(),
   128  		Version:     request.SbeSchemaVersion(),
   129  	}
   130  
   131  	buffer := new(bytes.Buffer)
   132  	if err := header.Encode(marshaller, buffer); err != nil {
   133  		return nil, err
   134  	}
   135  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   136  		return nil, err
   137  	}
   138  	return buffer.Bytes(), nil
   139  }
   140  
   141  func CloseSessionRequestPacket(
   142  	marshaller *SbeGoMarshaller,
   143  	rangeChecking bool,
   144  	clusterSessionId int64,
   145  ) ([]byte, error) {
   146  	request := CloseSession{
   147  		ClusterSessionId: clusterSessionId,
   148  	}
   149  
   150  	// Marshal it
   151  	header := MessageHeader{
   152  		BlockLength: request.SbeBlockLength(),
   153  		TemplateId:  request.SbeTemplateId(),
   154  		SchemaId:    request.SbeSchemaId(),
   155  		Version:     request.SbeSchemaVersion(),
   156  	}
   157  
   158  	buffer := new(bytes.Buffer)
   159  	if err := header.Encode(marshaller, buffer); err != nil {
   160  		return nil, err
   161  	}
   162  	if err := request.Encode(marshaller, buffer, rangeChecking); err != nil {
   163  		return nil, err
   164  	}
   165  
   166  	return buffer.Bytes(), nil
   167  }
   168  
   169  func MakeClusterMessageBuffer(templateId, blockLength uint16) *atomic.Buffer {
   170  	buf := atomic.MakeBuffer(make([]byte, 8+blockLength))
   171  	buf.PutUInt16(0, blockLength)
   172  	buf.PutUInt16(2, templateId)
   173  	buf.PutUInt16(4, 111) // schemaId
   174  	buf.PutUInt16(6, 8)   // schemaVersion
   175  	return buf
   176  }