Encode versioning in XDR

Makefile

@@ -6,7 +6,8 @@ xdr/Stellar-ledger-entries.x \
 xdr/Stellar-ledger.x \
 xdr/Stellar-overlay.x \
 xdr/Stellar-transaction.x \
-xdr/Stellar-types.x
+xdr/Stellar-types.x \
+xdr/Stellar-lighthorizon.x
 
 XDRGEN_COMMIT=3f6808cd161d72474ffbe9eedbd7013de7f92748
 

exp/services/ledgerexporter/main.go

@@ -141,12 +141,15 @@ func readLatestLedger(backend historyarchive.ArchiveBackend) uint32 {
 // /ledgers/<seqNum> path. If an error is returned, it may be transient so you
 // should attempt to retry.
 func writeLedger(backend historyarchive.ArchiveBackend, ledger xdr.LedgerCloseMeta) error {
-	blob, err := ledger.MarshalBinary()
+	toSerialize := xdr.SerializedLedgerCloseMeta{
+		V:  0,
+		V0: &ledger,
+	}
+	blob, err := toSerialize.MarshalBinary()
 	logFatalIf(err, "could not serialize ledger %v", ledger.LedgerSequence())
-	var versionHeader = [...]byte{ledgerbackend.CurrentLedgerFileVersion}
 	return backend.PutFile(
 		"ledgers/"+strconv.FormatUint(uint64(ledger.LedgerSequence()), 10),
-		io.NopCloser(io.MultiReader(bytes.NewReader(versionHeader[:]), bytes.NewReader(blob))),
+		io.NopCloser(bytes.NewReader(blob)),
 	)
 }
 

ingest/ledgerbackend/history_archive_backend.go

@@ -13,8 +13,6 @@ import (
 	"github.com/stellar/go/xdr"
 )
 
-const CurrentLedgerFileVersion = 0x01
-
 type HistoryArchiveBackend struct {
 	historyarchive.ArchiveBackend
 }
@@ -55,28 +53,22 @@ func (b *HistoryArchiveBackend) IsPrepared(ctx context.Context, ledgerRange Rang
 }
 
 func (b *HistoryArchiveBackend) GetLedger(ctx context.Context, sequence uint32) (xdr.LedgerCloseMeta, error) {
-	var ledger xdr.LedgerCloseMeta
+	var ledger xdr.SerializedLedgerCloseMeta
 	r, err := b.GetFile("ledgers/" + strconv.FormatUint(uint64(sequence), 10))
 	if err != nil {
-		return ledger, err
+		return xdr.LedgerCloseMeta{}, err
 	}
 	defer r.Close()
 	var buf bytes.Buffer
-	// read and check version header
-	var version [1]byte
-	l, err := r.Read(version[:])
-	if err != nil {
-		return xdr.LedgerCloseMeta{}, err
-	}
-	if l != 1 || version[0] != CurrentLedgerFileVersion {
-		return xdr.LedgerCloseMeta{}, fmt.Errorf("unexpected ledger header version number (0x%x)", version[0])
-	}
-
 	if _, err = io.Copy(&buf, r); err != nil {
-		return ledger, err
+		return xdr.LedgerCloseMeta{}, err
 	}
 	if err = ledger.UnmarshalBinary(buf.Bytes()); err != nil {
-		return ledger, err
+		return xdr.LedgerCloseMeta{}, err
+	}
+	output, isV0 := ledger.GetV0()
+	if !isV0 {
+		fmt.Errorf("unexpected serialized ledger version number (0x%x)", ledger.V)
 	}
-	return ledger, nil
+	return output, nil
 }

xdr/Stellar-lighthorizon.x

@@ -0,0 +1,15 @@
+// Copyright 2022 Stellar Development Foundation and contributors. Licensed
+// under the Apache License, Version 2.0. See the COPYING file at the root
+// of this distribution or at http://www.apache.org/licenses/LICENSE-2.0
+
+%#include "xdr/Stellar-ledger.h"
+
+namespace stellar
+{
+
+union SerializedLedgerCloseMeta switch (int v)
+{
+case 0:
+    LedgerCloseMeta v0;
+};
+}

xdr/xdr_generated.go

@@ -9,6 +9,7 @@
 //  xdr/Stellar-overlay.x
 //  xdr/Stellar-transaction.x
 //  xdr/Stellar-types.x
+//  xdr/Stellar-lighthorizon.x
 //
 // DO NOT EDIT or your changes may be overwritten
 package xdr
@@ -35864,4 +35865,140 @@ func (s HmacSha256Mac) xdrType() {}
 
 var _ xdrType = (*HmacSha256Mac)(nil)
 
+// SerializedLedgerCloseMeta is an XDR Union defines as:
+//
+//   union SerializedLedgerCloseMeta switch (int v)
+//    {
+//    case 0:
+//        LedgerCloseMeta v0;
+//    };
+//
+type SerializedLedgerCloseMeta struct {
+	V  int32
+	V0 *LedgerCloseMeta
+}
+
+// SwitchFieldName returns the field name in which this union's
+// discriminant is stored
+func (u SerializedLedgerCloseMeta) SwitchFieldName() string {
+	return "V"
+}
+
+// ArmForSwitch returns which field name should be used for storing
+// the value for an instance of SerializedLedgerCloseMeta
+func (u SerializedLedgerCloseMeta) ArmForSwitch(sw int32) (string, bool) {
+	switch int32(sw) {
+	case 0:
+		return "V0", true
+	}
+	return "-", false
+}
+
+// NewSerializedLedgerCloseMeta creates a new  SerializedLedgerCloseMeta.
+func NewSerializedLedgerCloseMeta(v int32, value interface{}) (result SerializedLedgerCloseMeta, err error) {
+	result.V = v
+	switch int32(v) {
+	case 0:
+		tv, ok := value.(LedgerCloseMeta)
+		if !ok {
+			err = fmt.Errorf("invalid value, must be LedgerCloseMeta")
+			return
+		}
+		result.V0 = &tv
+	}
+	return
+}
+
+// MustV0 retrieves the V0 value from the union,
+// panicing if the value is not set.
+func (u SerializedLedgerCloseMeta) MustV0() LedgerCloseMeta {
+	val, ok := u.GetV0()
+
+	if !ok {
+		panic("arm V0 is not set")
+	}
+
+	return val
+}
+
+// GetV0 retrieves the V0 value from the union,
+// returning ok if the union's switch indicated the value is valid.
+func (u SerializedLedgerCloseMeta) GetV0() (result LedgerCloseMeta, ok bool) {
+	armName, _ := u.ArmForSwitch(int32(u.V))
+
+	if armName == "V0" {
+		result = *u.V0
+		ok = true
+	}
+
+	return
+}
+
+// EncodeTo encodes this value using the Encoder.
+func (u SerializedLedgerCloseMeta) EncodeTo(e *xdr.Encoder) error {
+	var err error
+	if _, err = e.EncodeInt(int32(u.V)); err != nil {
+		return err
+	}
+	switch int32(u.V) {
+	case 0:
+		if err = (*u.V0).EncodeTo(e); err != nil {
+			return err
+		}
+		return nil
+	}
+	return fmt.Errorf("V (int32) switch value '%d' is not valid for union SerializedLedgerCloseMeta", u.V)
+}
+
+var _ decoderFrom = (*SerializedLedgerCloseMeta)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *SerializedLedgerCloseMeta) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		u.V0 = new(LedgerCloseMeta)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerCloseMeta: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union SerializedLedgerCloseMeta has invalid V (int32) switch value '%d'", u.V)
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (s SerializedLedgerCloseMeta) MarshalBinary() ([]byte, error) {
+	b := bytes.Buffer{}
+	e := xdr.NewEncoder(&b)
+	err := s.EncodeTo(e)
+	return b.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler.
+func (s *SerializedLedgerCloseMeta) UnmarshalBinary(inp []byte) error {
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
+	return err
+}
+
+var (
+	_ encoding.BinaryMarshaler   = (*SerializedLedgerCloseMeta)(nil)
+	_ encoding.BinaryUnmarshaler = (*SerializedLedgerCloseMeta)(nil)
+)
+
+// xdrType signals that this type is an type representing
+// representing XDR values defined by this package.
+func (s SerializedLedgerCloseMeta) xdrType() {}
+
+var _ xdrType = (*SerializedLedgerCloseMeta)(nil)
+
 var fmtTest = fmt.Sprint("this is a dummy usage of fmt")