func (h *Host) load() error {
var sHost savedHost
err := persist.LoadFile(persistMetadata, &sHost, filepath.Join(h.persistDir, "settings.json"))
if err != nil {
return err
}
h.spaceRemaining = sHost.HostSettings.TotalStorage
h.fileCounter = sHost.FileCounter
h.HostSettings = sHost.HostSettings
h.profit = sHost.Profit
// recreate maps
for i := range sHost.Obligations {
obligation := &sHost.Obligations[i] // both maps should use same pointer
height := obligation.FileContract.WindowStart + StorageProofReorgDepth
h.obligationsByHeight[height] = append(h.obligationsByHeight[height], obligation)
h.obligationsByID[obligation.ID] = obligation
// update spaceRemaining
h.spaceRemaining -= int64(obligation.LastRevisionTxn.FileContractRevisions[0].NewFileSize)
}
h.secretKey = sHost.SecretKey
h.publicKey = sHost.PublicKey
return nil
}
// load fetches the saved renter data from disk.
func (r *Renter) load() error {
// Load all files found in renter directory.
dir, err := os.Open(r.persistDir) // TODO: store in a subdir?
if err != nil {
return err
}
defer dir.Close()
filenames, err := dir.Readdirnames(-1)
if err != nil {
return err
}
for _, path := range filenames {
// Skip non-sia files.
if filepath.Ext(path) != ShareExtension {
continue
}
file, err := os.Open(filepath.Join(r.persistDir, path))
if err != nil {
// maybe just skip?
return err
}
_, err = r.loadSharedFiles(file)
file.Close() // defer is probably a bad idea
if err != nil {
// maybe just skip?
return err
}
}
// Load contracts, repair set, and entropy.
data := struct {
Contracts map[string]types.FileContract
Tracking map[string]trackedFile
Repairing map[string]string // COMPATv0.4.8
Entropy [32]byte
}{}
err = persist.LoadFile(saveMetadata, &data, filepath.Join(r.persistDir, PersistFilename))
if err != nil {
return err
}
if data.Tracking != nil {
r.tracking = data.Tracking
} else if data.Repairing != nil {
// COMPATv0.4.8
for nick, path := range data.Repairing {
// these files will be renewed indefinitely
r.tracking[nick] = trackedFile{RepairPath: path, EndHeight: 0}
}
}
r.entropy = data.Entropy
var fcid types.FileContractID
for id, fc := range data.Contracts {
fcid.UnmarshalJSON([]byte(id))
r.contracts[fcid] = fc
}
return nil
}
// load fetches the saved renter data from disk.
func (r *Renter) load() error {
// Recursively load all files found in renter directory. Errors
// encountered during loading are logged, but are not considered fatal.
err := filepath.Walk(r.persistDir, func(path string, info os.FileInfo, err error) error {
// This error is non-nil if filepath.Walk couldn't stat a file or
// folder. This generally indicates a serious error.
if err != nil {
return err
}
// Skip folders and non-sia files.
if info.IsDir() || filepath.Ext(path) != ShareExtension {
return nil
}
// Open the file.
file, err := os.Open(path)
if err != nil {
r.log.Println("ERROR: could not open .sia file:", err)
return nil
}
defer file.Close()
// Load the file contents into the renter.
_, err = r.loadSharedFiles(file)
if err != nil {
r.log.Println("ERROR: could not load .sia file:", err)
return nil
}
return nil
})
if err != nil {
return err
}
// Load contracts, repair set, and entropy.
data := struct {
Tracking map[string]trackedFile
Repairing map[string]string // COMPATv0.4.8
}{}
err = persist.LoadFile(saveMetadata, &data, filepath.Join(r.persistDir, PersistFilename))
if err != nil {
return err
}
if data.Tracking != nil {
r.tracking = data.Tracking
} else if data.Repairing != nil {
// COMPATv0.4.8
for nick, path := range data.Repairing {
// these files will be renewed indefinitely
r.tracking[nick] = trackedFile{RepairPath: path, Renew: true}
}
}
return nil
}
func (g *Gateway) load() error {
var nodes []modules.NetAddress
err := persist.LoadFile(persistMetadata, &nodes, filepath.Join(g.persistDir, "nodes.json"))
if err != nil {
return err
}
for _, node := range nodes {
g.addNode(node)
}
return nil
}
// load fetches the saved renter data from disk.
func (r *Renter) load() error {
var files []file
err := persist.LoadFile(saveMetadata, &files, filepath.Join(r.saveDir, PersistFilename))
if err != nil {
return err
}
for i := range files {
files[i].renter = r
r.files[files[i].Name] = &files[i]
}
return nil
}
// load extrats the save data from disk and populates the host.
func (h *Host) load() error {
p := new(persistence)
err := persist.LoadFile(persistMetadata, p, filepath.Join(h.persistDir, "settings.json"))
if err == persist.ErrBadVersion {
// COMPATv0.4.8 - try the compatibility loader.
return h.compatibilityLoad()
} else if os.IsNotExist(err) {
// This is the host's first run, set up the default values.
return h.establishDefaults()
} else if err != nil {
return err
}
// Copy over consensus tracking.
h.blockHeight = p.BlockHeight
h.recentChange = p.RecentChange
// Copy over host identity.
h.netAddress = p.NetAddress
h.publicKey = p.PublicKey
h.secretKey = p.SecretKey
// Copy over the file management. The space remaining is recalculated from
// disk instead of being saved, to maximize the potential usefulness of
// restarting Sia as a means of eliminating unkonwn errors.
h.fileCounter = p.FileCounter
h.spaceRemaining = p.Settings.TotalStorage
h.loadObligations(p.Obligations)
// Copy over statistics.
h.revenue = p.Revenue
h.lostRevenue = p.LostRevenue
// Copy over rpc tracking.
atomic.StoreUint64(&h.atomicErroredCalls, p.ErroredCalls)
atomic.StoreUint64(&h.atomicUnrecognizedCalls, p.UnrecognizedCalls)
atomic.StoreUint64(&h.atomicDownloadCalls, p.DownloadCalls)
atomic.StoreUint64(&h.atomicRenewCalls, p.RenewCalls)
atomic.StoreUint64(&h.atomicReviseCalls, p.ReviseCalls)
atomic.StoreUint64(&h.atomicSettingsCalls, p.SettingsCalls)
atomic.StoreUint64(&h.atomicUploadCalls, p.UploadCalls)
// Utilities.
h.settings = p.Settings
// Subscribe to the consensus set.
err = h.initConsensusSubscription()
if err != nil {
return err
}
return nil
}
// load loads the hostdb persistence data from disk.
func (hdb *HostDB) load() error {
var data struct {
Contracts []hostContract
}
err := persist.LoadFile(saveMetadata, &data, filepath.Join(hdb.persistDir, persistFilename))
if err != nil {
return err
}
for _, hc := range data.Contracts {
hdb.contracts[hc.ID] = hc
}
return nil
}
// load loads the Gateway's persistent data from disk.
func (g *Gateway) load() error {
var nodes []modules.NetAddress
err := persist.LoadFile(persistMetadata, &nodes, filepath.Join(g.persistDir, nodesFile))
if err != nil {
return err
}
for _, node := range nodes {
err := g.addNode(node)
if err != nil {
g.log.Printf("WARN: error loading node '%v' from persist: %v", node, err)
}
}
return nil
}
// load fetches the saved renter data from disk.
func (r *Renter) load() error {
// Load all files found in renter directory.
dir, err := os.Open(r.persistDir) // TODO: store in a subdir?
if err != nil {
return err
}
filenames, err := dir.Readdirnames(-1)
if err != nil {
return err
}
for _, path := range filenames {
// Skip non-sia files.
if filepath.Ext(path) != ShareExtension {
continue
}
file, err := os.Open(filepath.Join(r.persistDir, path))
if err != nil {
// maybe just skip?
return err
}
_, err = r.loadSharedFiles(file)
if err != nil {
// maybe just skip?
return err
}
}
// Load contracts, repair set, and entropy.
data := struct {
Contracts map[string]types.FileContract
Repairing map[string]string
Entropy [32]byte
}{}
err = persist.LoadFile(saveMetadata, &data, filepath.Join(r.persistDir, PersistFilename))
if err != nil {
return err
}
r.repairSet = data.Repairing
r.entropy = data.Entropy
var fcid types.FileContractID
for id, fc := range data.Contracts {
fcid.UnmarshalJSON([]byte(id))
r.contracts[fcid] = fc
}
return nil
}
func (h *Host) load() error {
var sHost savedHost
err := persist.LoadFile(persistMetadata, &sHost, filepath.Join(h.saveDir, "settings.json"))
if err != nil {
return err
}
h.spaceRemaining = sHost.HostSettings.TotalStorage
h.fileCounter = sHost.FileCounter
h.HostSettings = sHost.HostSettings
h.profit = sHost.Profit
// recreate maps
for _, obligation := range sHost.Obligations {
height := obligation.FileContract.WindowStart + StorageProofReorgDepth
h.obligationsByHeight[height] = append(h.obligationsByHeight[height], obligation)
h.obligationsByID[obligation.ID] = obligation
// update spaceRemaining
h.spaceRemaining -= int64(obligation.FileContract.FileSize)
}
return nil
}
// loadFile allows the host to load a persistence structure form disk.
func (productionDependencies) loadFile(m persist.Metadata, i interface{}, s string) error {
return persist.LoadFile(m, i, s)
}
func (p *stdPersist) load(data *contractorPersist) error {
return persist.LoadFile(p.meta, data, p.filename)
}
// loadSettings reads the wallet's settings from the wallet's settings file,
// overwriting the settings object in memory. loadSettings should only be
// called at startup.
func (w *Wallet) loadSettings() error {
return persist.LoadFile(settingsMetadata, &w.persist, filepath.Join(w.persistDir, settingsFile))
}
// load loads the miner persistence from disk.
func (m *Miner) load() error {
return persist.LoadFile(settingsMetadata, &m.persist, filepath.Join(m.persistDir, settingsFile))
}
// load extrats the save data from disk and populates the host.
func (h *Host) load() error {
p := new(persistence)
err := persist.LoadFile(persistMetadata, p, filepath.Join(h.persistDir, "settings.json"))
if err == persist.ErrBadVersion {
// COMPATv0.4.8 - try the compatibility loader.
return h.compatibilityLoad()
} else if os.IsNotExist(err) {
// There is no host.json file, set up sane defaults.
return h.establishDefaults()
} else if err != nil {
return err
}
// Copy over rpc tracking.
atomic.StoreUint64(&h.atomicErroredCalls, p.ErroredCalls)
atomic.StoreUint64(&h.atomicUnrecognizedCalls, p.UnrecognizedCalls)
atomic.StoreUint64(&h.atomicDownloadCalls, p.DownloadCalls)
atomic.StoreUint64(&h.atomicRenewCalls, p.RenewCalls)
atomic.StoreUint64(&h.atomicReviseCalls, p.ReviseCalls)
atomic.StoreUint64(&h.atomicSettingsCalls, p.SettingsCalls)
atomic.StoreUint64(&h.atomicUploadCalls, p.UploadCalls)
// Copy over consensus tracking.
h.blockHeight = p.BlockHeight
h.recentChange = p.RecentChange
// Copy over host identity.
h.netAddress = p.NetAddress
h.publicKey = p.PublicKey
h.secretKey = p.SecretKey
// Copy over statistics.
h.revenue = p.Revenue
h.lostRevenue = p.LostRevenue
// Utilities.
h.settings = p.Settings
// Copy over the file management. The space remaining is recalculated from
// disk instead of being saved, to maximize the potential usefulness of
// restarting Sia as a means of eliminating unkonwn errors.
h.fileCounter = p.FileCounter
h.spaceRemaining = p.Settings.TotalStorage
// Copy over the obligations and then subscribe to the consensus set.
for _, obligation := range p.Obligations {
// Store the obligation in the obligations list.
h.obligationsByID[obligation.ID] = obligation
// Update spaceRemaining to account for the storage held by this
// obligation.
h.spaceRemaining -= int64(obligation.fileSize())
// Update anticipated revenue to reflect the revenue in this file
// contract.
h.anticipatedRevenue = h.anticipatedRevenue.Add(obligation.value())
}
err = h.initConsensusSubscription()
if err != nil {
return err
}
for _, obligation := range h.obligationsByID {
h.handleActionItem(obligation)
}
return nil
}
// compatibilityLoad tries to load the file as a compatible version.
func (h *Host) compatibilityLoad() error {
// Try loading the file as a 0.4 file.
c04h := new(compat04Host)
err := persist.LoadFile(compat04Metadata, c04h, filepath.Join(h.persistDir, "settings.json"))
if err != nil {
// 0.4.x is the only backwards compatibility provided. File could not
// be loaded.
return err
}
// Copy over host identity.
h.publicKey = c04h.PublicKey
h.secretKey = c04h.SecretKey
// Copy file management, including providing compatibility for old
// obligations.
h.fileCounter = int64(c04h.FileCounter)
h.spaceRemaining = c04h.HostSettings.TotalStorage
upgradedObligations := h.loadCompat04Obligations(c04h.Obligations)
// Copy over statistics.
h.revenue = c04h.Profit
// Copy over utilities.
h.settings = c04h.HostSettings
// AcceptingContracts should be true by default
h.settings.AcceptingContracts = true
// Subscribe to the consensus set.
if build.DEBUG && h.recentChange != (modules.ConsensusChangeID{}) {
panic("compatibility loading is not starting from blank consensus?")
}
// initConsensusSubscription will scan through the consensus set and set
// 'OriginConfirmed' and 'RevisionConfirmed' when the accociated file
// contract and file contract revisions are found.
err = h.initConsensusSubscription()
if err != nil {
return err
}
// Remove all obligations that have not had their origin transactions
// confirmed on the blockchain, and add action items for the rest.
for _, uo := range upgradedObligations {
if !uo.OriginConfirmed {
// Because there is no transaction on the blockchain, and because
// the old host did not keep the transaction, it's highly unlikely
// that a transaction will appear - the obligation should be
// removed.
h.removeObligation(uo, obligationUnconfirmed)
continue
}
// Check that the file Merkle root matches the Merkle root found in the
// blockchain.
file, err := os.Open(uo.Path)
if err != nil {
h.log.Println("Compatibility contract file could not be opened.")
h.removeObligation(uo, obligationFailed)
continue
}
merkleRoot, err := crypto.ReaderMerkleRoot(file)
file.Close() // Close the file after use, to prevent buildup if the loop iterates many times.
if err != nil {
h.log.Println("Compatibility contract file could not be checksummed")
h.removeObligation(uo, obligationFailed)
continue
}
if merkleRoot != uo.merkleRoot() {
h.log.Println("Compatibility contract file has the wrong merkle root")
h.removeObligation(uo, obligationFailed)
continue
}
}
return nil
}