Golang persist.SaveFile函數代碼示例

func (g *Gateway) save() error {
	var nodes []modules.NetAddress
	for node := range g.nodes {
		nodes = append(nodes, node)
	}
	return persist.SaveFile(persistMetadata, nodes, filepath.Join(g.persistDir, "nodes.json"))
}

// save stores the current renter data to disk.
func (r *Renter) save() error {
	var files []file
	for _, file := range r.files {
		files = append(files, *file)
	}
	return persist.SaveFile(saveMetadata, files, filepath.Join(r.saveDir, PersistFilename))
}

// save stores all of the persist data to disk.
func (h *Host) save() error {
	p := persistence{
		// RPC Metrics.
		ErroredCalls:      atomic.LoadUint64(&h.atomicErroredCalls),
		UnrecognizedCalls: atomic.LoadUint64(&h.atomicUnrecognizedCalls),
		DownloadCalls:     atomic.LoadUint64(&h.atomicDownloadCalls),
		RenewCalls:        atomic.LoadUint64(&h.atomicRenewCalls),
		ReviseCalls:       atomic.LoadUint64(&h.atomicReviseCalls),
		SettingsCalls:     atomic.LoadUint64(&h.atomicSettingsCalls),
		UploadCalls:       atomic.LoadUint64(&h.atomicUploadCalls),

		// Consensus Tracking.
		BlockHeight:  h.blockHeight,
		RecentChange: h.recentChange,

		// Host Identity.
		NetAddress: h.netAddress,
		PublicKey:  h.publicKey,
		SecretKey:  h.secretKey,

		// File Management.
		Obligations: h.getObligations(),

		// Statistics.
		FileCounter: h.fileCounter,
		LostRevenue: h.lostRevenue,
		Revenue:     h.revenue,

		// Utilities.
		Settings: h.settings,
	}
	return persist.SaveFile(persistMetadata, p, filepath.Join(h.persistDir, settingsFile))
}

// TestPersistCompat04 checks that the compatibility loader for version 0.4.x
// obligations is functioning.
func TestPersistCompat04(t *testing.T) {
	if testing.Short() {
		t.SkipNow()
	}
	ht, err := newHostTester("TestPersistCompat04")
	if err != nil {
		t.Fatal(err)
	}

	// Upload a file and then save the host as a compatibility host.
	_, err = ht.uploadFile("TestPersistCompat04 - 1", renewDisabled)
	if err != nil {
		t.Fatal(err)
	}
	// Mine a block so that the file contract ends up in the blockchain.
	_, err = ht.miner.AddBlock()
	if err != nil {
		t.Fatal(err)
	}
	err = ht.host.Close()
	if err != nil {
		t.Fatal(err)
	}
	c04h := ht.buildCompat04Host()
	if err != nil {
		t.Fatal(err)
	}
	// Save the compatibility file, replacing the usual file with an old
	// format.
	err = persist.SaveFile(compat04Metadata, c04h, filepath.Join(ht.host.persistDir, settingsFile))
	if err != nil {
		t.Fatal(err)
	}

	// Re-open the host, which will be loading from the compatibility file.
	rebootHost, err := New(ht.cs, ht.tpool, ht.wallet, ":0", filepath.Join(ht.persistDir, modules.HostDir))
	if err != nil {
		t.Fatal(err)
	}
	if len(rebootHost.obligationsByID) != 1 {
		t.Fatal(len(rebootHost.obligationsByID))
	}

	// Mine until the storage proof goes through, and the obligation gets
	// cleared.
	for i := types.BlockHeight(0); i <= testUploadDuration+confirmationRequirement+defaultWindowSize; i++ {
		_, err := ht.miner.AddBlock()
		if err != nil {
			t.Fatal(err)
		}
	}
	if len(rebootHost.obligationsByID) != 0 {
		t.Error("obligations did not clear")
	}
	if rebootHost.revenue.IsZero() {
		t.Error("host is reporting no revenue after doing a compatibility storage proof")
	}
}

// save saves the hostdb persistence data to disk.
func (hdb *HostDB) save() error {
	var data struct {
		Contracts []hostContract
	}
	for _, hc := range hdb.contracts {
		data.Contracts = append(data.Contracts, hc)
	}
	return persist.SaveFile(saveMetadata, data, filepath.Join(hdb.persistDir, persistFilename))
}

// save stores the current renter data to disk.
func (r *Renter) save() error {
	data := struct {
		Contracts map[string]types.FileContract
		Entropy   [32]byte
	}{make(map[string]types.FileContract), r.entropy}
	// Convert renter's contract map to a JSON-friendly type.
	for id, fc := range r.contracts {
		b, _ := id.MarshalJSON()
		data.Contracts[string(b)] = fc
	}
	return persist.SaveFile(saveMetadata, data, filepath.Join(r.persistDir, PersistFilename))
}

// recoverSeed integrates a recovery seed into the wallet.
func (w *Wallet) recoverSeed(masterKey crypto.TwofishKey, seed modules.Seed) error {
	// Check that the seed is not already known.
	for _, wSeed := range w.seeds {
		if seed == wSeed {
			return errKnownSeed
		}
	}

	// Encrypt the seed and save the seed file.
	var sfuid SeedFileUID
	_, err := rand.Read(sfuid[:])
	if err != nil {
		return err
	}
	sek := seedFileEncryptionKey(masterKey, sfuid)
	plaintextVerification := make([]byte, encryptionVerificationLen)
	encryptionVerification, err := sek.EncryptBytes(plaintextVerification)
	if err != nil {
		return err
	}
	cryptSeed, err := sek.EncryptBytes(seed[:])
	if err != nil {
		return err
	}
	seedFilename := filepath.Join(w.persistDir, seedFilePrefix+persist.RandomSuffix()+seedFileSuffix)
	seedFile := SeedFile{
		SeedFileUID:            sfuid,
		EncryptionVerification: encryptionVerification,
		Seed: cryptSeed,
	}
	err = persist.SaveFile(seedMetadata, seedFile, seedFilename)
	if err != nil {
		return err
	}

	// Add the seed file to the wallet's set of tracked seeds and save the
	// wallet settings.
	w.settings.AuxiliarySeedFiles = append(w.settings.AuxiliarySeedFiles, seedFile)
	err = w.saveSettings()
	if err != nil {
		return err
	}
	w.integrateSeed(seed)
	return nil

}

func (h *Host) save() error {
	sHost := savedHost{
		SpaceRemaining: h.spaceRemaining,
		FileCounter:    h.fileCounter,
		Profit:         h.profit,
		HostSettings:   h.HostSettings,
		Obligations:    make([]contractObligation, 0, len(h.obligationsByID)),
		SecretKey:      h.secretKey,
		PublicKey:      h.publicKey,
	}
	for _, ob := range h.obligationsByID {
		// to avoid race conditions involving the obligation's mutex, copy it
		// manually into a new object
		obcopy := contractObligation{ID: ob.ID, FileContract: ob.FileContract, LastRevisionTxn: ob.LastRevisionTxn}
		sHost.Obligations = append(sHost.Obligations, obcopy)
	}

	return persist.SaveFile(persistMetadata, sHost, filepath.Join(h.persistDir, "settings.json"))
}

// createSeed creates a wallet seed and encrypts it using a key derived from
// the master key, then addds it to the wallet as the primary seed, while
// making a disk backup.
func (w *Wallet) createSeed(masterKey crypto.TwofishKey, seed modules.Seed) error {
	// Derive the key used to encrypt the seed file, and create the encryption
	// verification object.
	var sfuid SeedFileUID
	_, err := rand.Read(sfuid[:])
	if err != nil {
		return err
	}
	sfek := seedFileEncryptionKey(masterKey, sfuid)
	plaintextVerification := make([]byte, encryptionVerificationLen)
	encryptionVerification, err := sfek.EncryptBytes(plaintextVerification)
	if err != nil {
		return err
	}

	// Encrypt the seed and save the seed file.
	seedName := seedFilePrefix + persist.RandomSuffix() + seedFileSuffix
	filename := filepath.Join(w.persistDir, seedName)
	cryptSeed, err := sfek.EncryptBytes(seed[:])
	if err != nil {
		return err
	}
	w.primarySeed = seed
	w.settings.PrimarySeedFile = SeedFile{
		SeedFileUID:            sfuid,
		EncryptionVerification: encryptionVerification,
		Seed: cryptSeed,
	}
	w.settings.PrimarySeedProgress = 0
	err = persist.SaveFile(seedMetadata, &w.settings.PrimarySeedFile, filename)
	if err != nil {
		return err
	}
	err = w.saveSettings()
	if err != nil {
		return err
	}
	return nil
}

// encryptAndSaveSeedFile encrypts and saves a seed file.
func (w *Wallet) encryptAndSaveSeedFile(masterKey crypto.TwofishKey, seed modules.Seed) (SeedFile, error) {
	var sf SeedFile
	_, err := rand.Read(sf.UID[:])
	if err != nil {
		return SeedFile{}, err
	}
	sek := uidEncryptionKey(masterKey, sf.UID)
	plaintextVerification := make([]byte, encryptionVerificationLen)
	sf.EncryptionVerification, err = sek.EncryptBytes(plaintextVerification)
	if err != nil {
		return SeedFile{}, err
	}
	sf.Seed, err = sek.EncryptBytes(seed[:])
	if err != nil {
		return SeedFile{}, err
	}
	seedFilename := filepath.Join(w.persistDir, seedFilePrefix+persist.RandomSuffix()+seedFileSuffix)
	err = persist.SaveFile(seedMetadata, sf, seedFilename)
	if err != nil {
		return SeedFile{}, err
	}
	return sf, nil
}

func (p *stdPersist) save(data contractorPersist) error {
	return persist.SaveFile(p.meta, data, p.filename)
}

// saveSettings writes the wallet's settings to the wallet's settings file,
// replacing the existing file.
func (w *Wallet) saveSettings() error {
	return persist.SaveFile(settingsMetadata, w.persist, filepath.Join(w.persistDir, settingsFile))
}

// save stores all of the persistent data of the storage manager to disk.
func (sm *StorageManager) save() error {
	return persist.SaveFile(persistMetadata, sm.persistData(), filepath.Join(sm.persistDir, settingsFile))
}

// createBackup creates a backup file at the desired filepath.
func (w *Wallet) createBackup(backupFilepath string) error {
	return persist.SaveFile(settingsMetadata, w.persist, backupFilepath)
}

// save stores the current renter data to disk.
func (r *Renter) save() error {
	data := struct {
		Tracking map[string]trackedFile
	}{r.tracking}
	return persist.SaveFile(saveMetadata, data, filepath.Join(r.persistDir, PersistFilename))
}