12313002221

Committed 13 Dec 2024 09:25AM UTC coverage: 57.486% (+8.6%) from 48.92%

Build # 12313002221

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9343 from ellemouton/contextGuard

fn: expand the ContextGuard and add tests

Run Details

101902 of 177264 relevant lines covered (57.49%)

24909.26 hits per line

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

82.86

/chanbackup/backupfile.go

package chanbackup

import (
        "fmt"
        "os"
        "path/filepath"

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

const (
        // DefaultBackupFileName is the default name of the auto updated static
        // channel backup fie.
        DefaultBackupFileName = "channel.backup"

        // DefaultTempBackupFileName is the default name of the temporary SCB
        // file that we'll use to atomically update the primary back up file
        // when new channel are detected.
        DefaultTempBackupFileName = "temp-dont-use.backup"
)

var (
        // ErrNoBackupFileExists is returned if caller attempts to call
        // UpdateAndSwap with the file name not set.
        ErrNoBackupFileExists = fmt.Errorf("back up file name not set")

        // ErrNoTempBackupFile is returned if caller attempts to call
        // UpdateAndSwap with the temp back up file name not set.
        ErrNoTempBackupFile = fmt.Errorf("temp backup file not set")
)

// MultiFile represents a file on disk that a caller can use to read the packed
// multi backup into an unpacked one, and also atomically update the contents
// on disk once new channels have been opened, and old ones closed. This struct
// relies on an atomic file rename property which most widely use file systems
// have.
type MultiFile struct {
        // fileName is the file name of the main back up file.
        fileName string

        // tempFileName is the name of the file that we'll use to stage a new
        // packed multi-chan backup, and the rename to the main back up file.
        tempFileName string

        // tempFile is an open handle to the temp back up file.
        tempFile *os.File
}

// NewMultiFile create a new multi-file instance at the target location on the
// file system.
func NewMultiFile(fileName string) *MultiFile {

        // We'll our temporary backup file in the very same directory as the
        // main backup file.
        backupFileDir := filepath.Dir(fileName)
        tempFileName := filepath.Join(
                backupFileDir, DefaultTempBackupFileName,
        )

        return &MultiFile{
                fileName:     fileName,
                tempFileName: tempFileName,
        }
}

// UpdateAndSwap will attempt write a new temporary backup file to disk with
// the newBackup encoded, then atomically swap (via rename) the old file for
// the new file by updating the name of the new file to the old.
func (b *MultiFile) UpdateAndSwap(newBackup PackedMulti) error {
        // If the main backup file isn't set, then we can't proceed.
        if b.fileName == "" {
                return ErrNoBackupFileExists
        }

        log.Infof("Updating backup file at %v", b.fileName)

        // If the old back up file still exists, then we'll delete it before
        // proceeding.
        if _, err := os.Stat(b.tempFileName); err == nil {
                log.Infof("Found old temp backup @ %v, removing before swap",
                        b.tempFileName)

                err = os.Remove(b.tempFileName)
                if err != nil {
                        return fmt.Errorf("unable to remove temp "+
                                "backup file: %v", err)
                }
        }

        // Now that we know the staging area is clear, we'll create the new
        // temporary back up file.
        var err error
        b.tempFile, err = os.Create(b.tempFileName)
        if err != nil {
                return fmt.Errorf("unable to create temp file: %w", err)
        }

        // With the file created, we'll write the new packed multi backup and
        // remove the temporary file all together once this method exits.
        _, err = b.tempFile.Write([]byte(newBackup))
        if err != nil {
                return fmt.Errorf("unable to write backup to temp file: %w",
                        err)
        }
        if err := b.tempFile.Sync(); err != nil {
                return fmt.Errorf("unable to sync temp file: %w", err)
        }
        defer os.Remove(b.tempFileName)

        log.Infof("Swapping old multi backup file from %v to %v",
                b.tempFileName, b.fileName)

        // Before we rename the swap (atomic name swap), we'll make
        // sure to close the current file as some OSes don't support
        // renaming a file that's already open (Windows).
        if err := b.tempFile.Close(); err != nil {
                return fmt.Errorf("unable to close file: %w", err)
        }

        // Finally, we'll attempt to atomically rename the temporary file to
        // the main back up file. If this succeeds, then we'll only have a
        // single file on disk once this method exits.
        return os.Rename(b.tempFileName, b.fileName)
}

// ExtractMulti attempts to extract the packed multi backup we currently point
// to into an unpacked version. This method will fail if no backup file
// currently exists as the specified location.
func (b *MultiFile) ExtractMulti(keyChain keychain.KeyRing) (*Multi, error) {
        var err error

        // We'll return an error if the main file isn't currently set.
        if b.fileName == "" {
                return nil, ErrNoBackupFileExists
        }

        // Now that we've confirmed the target file is populated, we'll read
        // all the contents of the file. This function ensures that file is
        // always closed, even if we can't read the contents.
        multiBytes, err := os.ReadFile(b.fileName)
        if err != nil {
                return nil, err
        }

        // Finally, we'll attempt to unpack the file and return the unpack
        // version to the caller.
        packedMulti := PackedMulti(multiBytes)
        return packedMulti.Unpack(keyChain)
}

1	package chanbackup
2
3	import (
4	"fmt"
5	"os"
6	"path/filepath"
7
8	"github.com/lightningnetwork/lnd/keychain"
9	)
10
11	const (
12	// DefaultBackupFileName is the default name of the auto updated static
13	// channel backup fie.
14	DefaultBackupFileName = "channel.backup"
15
16	// DefaultTempBackupFileName is the default name of the temporary SCB
17	// file that we'll use to atomically update the primary back up file
18	// when new channel are detected.
19	DefaultTempBackupFileName = "temp-dont-use.backup"
20	)
21
22	var (
23	// ErrNoBackupFileExists is returned if caller attempts to call
24	// UpdateAndSwap with the file name not set.
25	ErrNoBackupFileExists = fmt.Errorf("back up file name not set")
26
27	// ErrNoTempBackupFile is returned if caller attempts to call
28	// UpdateAndSwap with the temp back up file name not set.
29	ErrNoTempBackupFile = fmt.Errorf("temp backup file not set")
30	)
31
32	// MultiFile represents a file on disk that a caller can use to read the packed
33	// multi backup into an unpacked one, and also atomically update the contents
34	// on disk once new channels have been opened, and old ones closed. This struct
35	// relies on an atomic file rename property which most widely use file systems
36	// have.
37	type MultiFile struct {
38	// fileName is the file name of the main back up file.
39	fileName string
40
41	// tempFileName is the name of the file that we'll use to stage a new
42	// packed multi-chan backup, and the rename to the main back up file.
43	tempFileName string
44
45	// tempFile is an open handle to the temp back up file.
46	tempFile *os.File
47	}
48
49	// NewMultiFile create a new multi-file instance at the target location on the
50	// file system.
51	func NewMultiFile(fileName string) *MultiFile {	6✔
52		6✔
53	// We'll our temporary backup file in the very same directory as the	6✔
54	// main backup file.	6✔
55	backupFileDir := filepath.Dir(fileName)	6✔
56	tempFileName := filepath.Join(	6✔
57	backupFileDir, DefaultTempBackupFileName,	6✔
58	)	6✔
59		6✔
60	return &MultiFile{	6✔
61	fileName: fileName,	6✔
62	tempFileName: tempFileName,	6✔
63	}	6✔
64	}	6✔
65
66	// UpdateAndSwap will attempt write a new temporary backup file to disk with
67	// the newBackup encoded, then atomically swap (via rename) the old file for
68	// the new file by updating the name of the new file to the old.
69	func (b *MultiFile) UpdateAndSwap(newBackup PackedMulti) error {	5✔
70	// If the main backup file isn't set, then we can't proceed.	5✔
71	if b.fileName == "" {	6✔
72	return ErrNoBackupFileExists	1✔
73	}	1✔
74
75	log.Infof("Updating backup file at %v", b.fileName)	4✔
76		4✔
77	// If the old back up file still exists, then we'll delete it before	4✔
78	// proceeding.	4✔
79	if _, err := os.Stat(b.tempFileName); err == nil {	5✔
80	log.Infof("Found old temp backup @ %v, removing before swap",	1✔
81	b.tempFileName)	1✔
82		1✔
83	err = os.Remove(b.tempFileName)	1✔
84	if err != nil {	1✔
85	return fmt.Errorf("unable to remove temp "+	×
86	"backup file: %v", err)	×
87	}	×
88	}
89
90	// Now that we know the staging area is clear, we'll create the new
91	// temporary back up file.
92	var err error	4✔
93	b.tempFile, err = os.Create(b.tempFileName)	4✔
94	if err != nil {	4✔
95	return fmt.Errorf("unable to create temp file: %w", err)	×
96	}	×
97
98	// With the file created, we'll write the new packed multi backup and
99	// remove the temporary file all together once this method exits.
100	_, err = b.tempFile.Write([]byte(newBackup))	4✔
101	if err != nil {	4✔
102	return fmt.Errorf("unable to write backup to temp file: %w",	×
103	err)	×
104	}	×
105	if err := b.tempFile.Sync(); err != nil {	4✔
106	return fmt.Errorf("unable to sync temp file: %w", err)	×
107	}	×
108	defer os.Remove(b.tempFileName)	4✔
109		4✔
110	log.Infof("Swapping old multi backup file from %v to %v",	4✔
111	b.tempFileName, b.fileName)	4✔
112		4✔
113	// Before we rename the swap (atomic name swap), we'll make	4✔
114	// sure to close the current file as some OSes don't support	4✔
115	// renaming a file that's already open (Windows).	4✔
116	if err := b.tempFile.Close(); err != nil {	4✔
117	return fmt.Errorf("unable to close file: %w", err)	×
118	}	×
119
120	// Finally, we'll attempt to atomically rename the temporary file to
121	// the main back up file. If this succeeds, then we'll only have a
122	// single file on disk once this method exits.
123	return os.Rename(b.tempFileName, b.fileName)	4✔
124	}
125
126	// ExtractMulti attempts to extract the packed multi backup we currently point
127	// to into an unpacked version. This method will fail if no backup file
128	// currently exists as the specified location.
129	func (b MultiFile) ExtractMulti(keyChain keychain.KeyRing) (Multi, error) {	4✔
130	var err error	4✔
131		4✔
132	// We'll return an error if the main file isn't currently set.	4✔
133	if b.fileName == "" {	5✔
134	return nil, ErrNoBackupFileExists	1✔
135	}	1✔
136
137	// Now that we've confirmed the target file is populated, we'll read
138	// all the contents of the file. This function ensures that file is
139	// always closed, even if we can't read the contents.
140	multiBytes, err := os.ReadFile(b.fileName)	3✔
141	if err != nil {	4✔
142	return nil, err	1✔
143	}	1✔
144
145	// Finally, we'll attempt to unpack the file and return the unpack
146	// version to the caller.
147	packedMulti := PackedMulti(multiBytes)	2✔
148	return packedMulti.Unpack(keyChain)	2✔
149	}

lightningnetwork / lnd / 12313002221

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