17101605539

Committed 20 Aug 2025 02:35PM UTC coverage: 57.321% (-9.4%) from 66.68%

Build # 17101605539

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #10102 from yyforyongyu/fix-UpdatesInHorizon

Catch bad gossip peer and fix `UpdatesInHorizon`

Run Details

28 of 89 new or added lines in 4 files covered. (31.46%)

29163 existing lines in 459 files now uncovered.

99187 of 173038 relevant lines covered (57.32%)

1.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.0

/payments/db/codec.go

package paymentsdb

import (
        "encoding/binary"
        "errors"
        "io"
        "time"

        "github.com/lightningnetwork/lnd/channeldb"
)

// Big endian is the preferred byte order, due to cursor scans over
// integer keys iterating in order.
var byteOrder = binary.BigEndian

// UnknownElementType is an alias for channeldb.UnknownElementType.
type UnknownElementType = channeldb.UnknownElementType

// ReadElement deserializes a single element from the provided io.Reader.
func ReadElement(r io.Reader, element interface{}) error {
        err := channeldb.ReadElement(r, element)
        switch {
        // Known to channeldb codec.
        case err == nil:
                return nil

        // Fail if error is not UnknownElementType.
        default:
                var unknownElementType UnknownElementType
                if !errors.As(err, &unknownElementType) {
                        return err
                }
        }

        // Process any paymentsdb-specific extensions to the codec.
        switch e := element.(type) {
        case *paymentIndexType:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        // Type is still unknown to paymentsdb extensions, fail.
        default:
                return channeldb.NewUnknownElementType(
                        "ReadElement", element,
                )
        }

        return nil
}

// WriteElement serializes a single element into the provided io.Writer.
func WriteElement(w io.Writer, element interface{}) error {
        err := channeldb.WriteElement(w, element)
        switch {
        // Known to channeldb codec.
        case err == nil:
                return nil

        // Fail if error is not UnknownElementType.
        default:
                var unknownElementType UnknownElementType
                if !errors.As(err, &unknownElementType) {
                        return err
                }
        }

        // Process any paymentsdb-specific extensions to the codec.
        switch e := element.(type) {
        case paymentIndexType:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        // Type is still unknown to paymentsdb extensions, fail.
        default:
                return channeldb.NewUnknownElementType(
                        "WriteElement", element,
                )
        }

        return nil
}

// WriteElements serializes a variadic list of elements into the given
// io.Writer.
func WriteElements(w io.Writer, elements ...interface{}) error {
        for _, element := range elements {
                if err := WriteElement(w, element); err != nil {
                        return err
                }
        }

        return nil
}

// ReadElements deserializes the provided io.Reader into a variadic list of
// target elements.
func ReadElements(r io.Reader, elements ...interface{}) error {
        for _, element := range elements {
                if err := ReadElement(r, element); err != nil {
                        return err
                }
        }

        return nil
}

// deserializeTime deserializes time as unix nanoseconds.
func deserializeTime(r io.Reader) (time.Time, error) {
        var scratch [8]byte
        if _, err := io.ReadFull(r, scratch[:]); err != nil {
                return time.Time{}, err
        }

        // Convert to time.Time. Interpret unix nano time zero as a zero
        // time.Time value.
        unixNano := byteOrder.Uint64(scratch[:])
        if unixNano == 0 {
                return time.Time{}, nil
        }

        return time.Unix(0, int64(unixNano)), nil
}

// serializeTime serializes time as unix nanoseconds.
func serializeTime(w io.Writer, t time.Time) error {
        var scratch [8]byte

        // Convert to unix nano seconds, but only if time is non-zero. Calling
        // UnixNano() on a zero time yields an undefined result.
        var unixNano int64
        if !t.IsZero() {
                unixNano = t.UnixNano()
        }

        byteOrder.PutUint64(scratch[:], uint64(unixNano))
        _, err := w.Write(scratch[:])

        return err
}

1	package paymentsdb
2
3	import (
4	"encoding/binary"
5	"errors"
6	"io"
7	"time"
8
9	"github.com/lightningnetwork/lnd/channeldb"
10	)
11
12	// Big endian is the preferred byte order, due to cursor scans over
13	// integer keys iterating in order.
14	var byteOrder = binary.BigEndian
15
16	// UnknownElementType is an alias for channeldb.UnknownElementType.
17	type UnknownElementType = channeldb.UnknownElementType
18
19	// ReadElement deserializes a single element from the provided io.Reader.
20	func ReadElement(r io.Reader, element interface{}) error {	3✔
21	err := channeldb.ReadElement(r, element)	3✔
22	switch {	3✔
23	// Known to channeldb codec.
24	case err == nil:	3✔
25	return nil	3✔
26
27	// Fail if error is not UnknownElementType.
28	default:	3✔
29	var unknownElementType UnknownElementType	3✔
30	if !errors.As(err, &unknownElementType) {	3✔
31	return err	×
32	}	×
33	}
34
35	// Process any paymentsdb-specific extensions to the codec.
36	switch e := element.(type) {	3✔
37	case *paymentIndexType:	3✔
38	if err := binary.Read(r, byteOrder, e); err != nil {	3✔
39	return err	×
40	}	×
41
42	// Type is still unknown to paymentsdb extensions, fail.
43	default:	×
44	return channeldb.NewUnknownElementType(	×
45	"ReadElement", element,	×
46	)	×
47	}
48
49	return nil	3✔
50	}
51
52	// WriteElement serializes a single element into the provided io.Writer.
53	func WriteElement(w io.Writer, element interface{}) error {	3✔
54	err := channeldb.WriteElement(w, element)	3✔
55	switch {	3✔
56	// Known to channeldb codec.
57	case err == nil:	3✔
58	return nil	3✔
59
60	// Fail if error is not UnknownElementType.
61	default:	3✔
62	var unknownElementType UnknownElementType	3✔
63	if !errors.As(err, &unknownElementType) {	3✔
64	return err	×
65	}	×
66	}
67
68	// Process any paymentsdb-specific extensions to the codec.
69	switch e := element.(type) {	3✔
70	case paymentIndexType:	3✔
71	if err := binary.Write(w, byteOrder, e); err != nil {	3✔
72	return err	×
73	}	×
74
75	// Type is still unknown to paymentsdb extensions, fail.
76	default:	×
77	return channeldb.NewUnknownElementType(	×
78	"WriteElement", element,	×
79	)	×
80	}
81
82	return nil	3✔
83	}
84
85	// WriteElements serializes a variadic list of elements into the given
86	// io.Writer.
87	func WriteElements(w io.Writer, elements ...interface{}) error {	3✔
88	for _, element := range elements {	6✔
89	if err := WriteElement(w, element); err != nil {	3✔
90	return err	×
91	}	×
92	}
93
94	return nil	3✔
95	}
96
97	// ReadElements deserializes the provided io.Reader into a variadic list of
98	// target elements.
99	func ReadElements(r io.Reader, elements ...interface{}) error {	3✔
100	for _, element := range elements {	6✔
101	if err := ReadElement(r, element); err != nil {	3✔
102	return err	×
103	}	×
104	}
105
106	return nil	3✔
107	}
108
109	// deserializeTime deserializes time as unix nanoseconds.
110	func deserializeTime(r io.Reader) (time.Time, error) {	3✔
111	var scratch [8]byte	3✔
112	if _, err := io.ReadFull(r, scratch[:]); err != nil {	3✔
113	return time.Time{}, err	×
114	}	×
115
116	// Convert to time.Time. Interpret unix nano time zero as a zero
117	// time.Time value.
118	unixNano := byteOrder.Uint64(scratch[:])	3✔
119	if unixNano == 0 {	3✔
UNCOV 120	return time.Time{}, nil	×
UNCOV 121	}	×
122
123	return time.Unix(0, int64(unixNano)), nil	3✔
124	}
125
126	// serializeTime serializes time as unix nanoseconds.
127	func serializeTime(w io.Writer, t time.Time) error {	3✔
128	var scratch [8]byte	3✔
129		3✔
130	// Convert to unix nano seconds, but only if time is non-zero. Calling	3✔
131	// UnixNano() on a zero time yields an undefined result.	3✔
132	var unixNano int64	3✔
133	if !t.IsZero() {	6✔
134	unixNano = t.UnixNano()	3✔
135	}	3✔
136
137	byteOrder.PutUint64(scratch[:], uint64(unixNano))	3✔
138	_, err := w.Write(scratch[:])	3✔
139		3✔
140	return err	3✔
141	}

lightningnetwork / lnd / 17101605539

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous