2017-07-28 08:09:39 -05:00
|
|
|
// Copyright 2017 The go-ethereum Authors
|
|
|
|
// This file is part of the go-ethereum library.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
package core
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"io"
|
2022-08-17 06:16:18 -05:00
|
|
|
"io/fs"
|
2017-07-28 08:09:39 -05:00
|
|
|
"os"
|
|
|
|
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
|
|
"github.com/ethereum/go-ethereum/log"
|
|
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
|
|
)
|
|
|
|
|
|
|
|
// errNoActiveJournal is returned if a transaction is attempted to be inserted
|
|
|
|
// into the journal, but no such file is currently open.
|
|
|
|
var errNoActiveJournal = errors.New("no active journal")
|
|
|
|
|
2017-10-20 06:31:29 -05:00
|
|
|
// devNull is a WriteCloser that just discards anything written into it. Its
|
|
|
|
// goal is to allow the transaction journal to write into a fake journal when
|
|
|
|
// loading transactions on startup without printing warnings due to no file
|
2018-08-28 02:04:33 -05:00
|
|
|
// being read for write.
|
2017-10-20 06:31:29 -05:00
|
|
|
type devNull struct{}
|
|
|
|
|
|
|
|
func (*devNull) Write(p []byte) (n int, err error) { return len(p), nil }
|
|
|
|
func (*devNull) Close() error { return nil }
|
|
|
|
|
2017-07-28 08:09:39 -05:00
|
|
|
// txJournal is a rotating log of transactions with the aim of storing locally
|
|
|
|
// created transactions to allow non-executed ones to survive node restarts.
|
|
|
|
type txJournal struct {
|
|
|
|
path string // Filesystem path to store the transactions at
|
|
|
|
writer io.WriteCloser // Output stream to write new transactions into
|
|
|
|
}
|
|
|
|
|
|
|
|
// newTxJournal creates a new transaction journal to
|
|
|
|
func newTxJournal(path string) *txJournal {
|
|
|
|
return &txJournal{
|
|
|
|
path: path,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// load parses a transaction journal dump from disk, loading its contents into
|
|
|
|
// the specified pool.
|
2018-05-10 02:04:45 -05:00
|
|
|
func (journal *txJournal) load(add func([]*types.Transaction) []error) error {
|
2017-07-28 08:09:39 -05:00
|
|
|
// Open the journal for loading any past transactions
|
|
|
|
input, err := os.Open(journal.path)
|
2022-08-17 06:16:18 -05:00
|
|
|
if errors.Is(err, fs.ErrNotExist) {
|
|
|
|
// Skip the parsing if the journal file doesn't exist at all
|
|
|
|
return nil
|
|
|
|
}
|
2017-07-28 08:09:39 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
defer input.Close()
|
|
|
|
|
2017-10-29 19:23:23 -05:00
|
|
|
// Temporarily discard any journal additions (don't double add on load)
|
2017-10-20 06:31:29 -05:00
|
|
|
journal.writer = new(devNull)
|
|
|
|
defer func() { journal.writer = nil }()
|
|
|
|
|
2017-07-28 08:09:39 -05:00
|
|
|
// Inject all transactions from the journal into the pool
|
|
|
|
stream := rlp.NewStream(input, 0)
|
|
|
|
total, dropped := 0, 0
|
|
|
|
|
2018-05-18 03:45:52 -05:00
|
|
|
// Create a method to load a limited batch of transactions and bump the
|
|
|
|
// appropriate progress counters. Then use this method to load all the
|
2018-08-28 02:04:33 -05:00
|
|
|
// journaled transactions in small-ish batches.
|
2018-05-18 03:45:52 -05:00
|
|
|
loadBatch := func(txs types.Transactions) {
|
|
|
|
for _, err := range add(txs) {
|
2018-05-10 02:04:45 -05:00
|
|
|
if err != nil {
|
|
|
|
log.Debug("Failed to add journaled transaction", "err", err)
|
|
|
|
dropped++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var (
|
|
|
|
failure error
|
2018-05-18 03:45:52 -05:00
|
|
|
batch types.Transactions
|
2018-05-10 02:04:45 -05:00
|
|
|
)
|
2017-07-28 08:09:39 -05:00
|
|
|
for {
|
|
|
|
// Parse the next transaction and terminate on error
|
|
|
|
tx := new(types.Transaction)
|
|
|
|
if err = stream.Decode(tx); err != nil {
|
|
|
|
if err != io.EOF {
|
|
|
|
failure = err
|
|
|
|
}
|
2018-05-18 03:45:52 -05:00
|
|
|
if batch.Len() > 0 {
|
|
|
|
loadBatch(batch)
|
|
|
|
}
|
2017-07-28 08:09:39 -05:00
|
|
|
break
|
|
|
|
}
|
2018-08-28 02:04:33 -05:00
|
|
|
// New transaction parsed, queue up for later, import if threshold is reached
|
2017-07-28 08:09:39 -05:00
|
|
|
total++
|
2018-05-18 03:45:52 -05:00
|
|
|
|
|
|
|
if batch = append(batch, tx); batch.Len() > 1024 {
|
|
|
|
loadBatch(batch)
|
|
|
|
batch = batch[:0]
|
2017-07-28 08:09:39 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
log.Info("Loaded local transaction journal", "transactions", total, "dropped", dropped)
|
|
|
|
|
|
|
|
return failure
|
|
|
|
}
|
|
|
|
|
|
|
|
// insert adds the specified transaction to the local disk journal.
|
|
|
|
func (journal *txJournal) insert(tx *types.Transaction) error {
|
|
|
|
if journal.writer == nil {
|
|
|
|
return errNoActiveJournal
|
|
|
|
}
|
|
|
|
if err := rlp.Encode(journal.writer, tx); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// rotate regenerates the transaction journal based on the current contents of
|
|
|
|
// the transaction pool.
|
|
|
|
func (journal *txJournal) rotate(all map[common.Address]types.Transactions) error {
|
|
|
|
// Close the current journal (if any is open)
|
|
|
|
if journal.writer != nil {
|
|
|
|
if err := journal.writer.Close(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
journal.writer = nil
|
|
|
|
}
|
|
|
|
// Generate a new journal with the contents of the current pool
|
2021-06-22 23:29:20 -05:00
|
|
|
replacement, err := os.OpenFile(journal.path+".new", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
|
2017-07-28 08:09:39 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
journaled := 0
|
|
|
|
for _, txs := range all {
|
|
|
|
for _, tx := range txs {
|
|
|
|
if err = rlp.Encode(replacement, tx); err != nil {
|
|
|
|
replacement.Close()
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
journaled += len(txs)
|
|
|
|
}
|
|
|
|
replacement.Close()
|
|
|
|
|
|
|
|
// Replace the live journal with the newly generated one
|
|
|
|
if err = os.Rename(journal.path+".new", journal.path); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2021-06-22 23:29:20 -05:00
|
|
|
sink, err := os.OpenFile(journal.path, os.O_WRONLY|os.O_APPEND, 0644)
|
2017-07-28 08:09:39 -05:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
journal.writer = sink
|
|
|
|
log.Info("Regenerated local transaction journal", "transactions", journaled, "accounts", len(all))
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// close flushes the transaction journal contents to disk and closes the file.
|
|
|
|
func (journal *txJournal) close() error {
|
|
|
|
var err error
|
|
|
|
|
|
|
|
if journal.writer != nil {
|
|
|
|
err = journal.writer.Close()
|
|
|
|
journal.writer = nil
|
|
|
|
}
|
|
|
|
return err
|
|
|
|
}
|