func (c *Cluster) saveState() error { dt, err := json.Marshal(state{ListenAddr: c.listenAddr}) if err != nil { return err } return ioutils.AtomicWriteFile(filepath.Join(c.root, stateFile), dt, 0600) }
func calculateLayerChecksum(graphDir, id string, ls checksumCalculator) error { diffIDFile := filepath.Join(graphDir, id, migrationDiffIDFileName) if _, err := os.Lstat(diffIDFile); err == nil { return nil } else if !os.IsNotExist(err) { return err } parent, err := getParent(filepath.Join(graphDir, id)) if err != nil { return err } diffID, size, err := ls.ChecksumForGraphID(id, parent, filepath.Join(graphDir, id, tarDataFileName), filepath.Join(graphDir, id, migrationTarDataFileName)) if err != nil { return err } if err := ioutil.WriteFile(filepath.Join(graphDir, id, migrationSizeFileName), []byte(strconv.Itoa(int(size))), 0600); err != nil { return err } if err := ioutils.AtomicWriteFile(filepath.Join(graphDir, id, migrationDiffIDFileName), []byte(diffID), 0600); err != nil { return err } logrus.Infof("calculated checksum for layer %s: %s", id, diffID) return nil }
func (c *Cluster) saveState(config nodeStartConfig) error { dt, err := json.Marshal(config) if err != nil { return err } return ioutils.AtomicWriteFile(filepath.Join(c.root, stateFile), dt, 0600) }
func savePersistentState(root string, config nodeStartConfig) error { dt, err := json.Marshal(config) if err != nil { return err } return ioutils.AtomicWriteFile(filepath.Join(root, stateFile), dt, 0600) }
func (store *store) save() error { // Store the json jsonData, err := json.Marshal(store) if err != nil { return err } return ioutils.AtomicWriteFile(store.jsonPath, jsonData, 0600) }
// Callers are expected to hold the store lock. func (ps *Store) updatePluginDB() error { jsonData, err := json.Marshal(ps.plugins) if err != nil { logrus.Debugf("Error in json.Marshal: %v", err) return err } ioutils.AtomicWriteFile(ps.plugindb, jsonData, 0600) return nil }
// Set writes data indexed by namespace and key. The data is written to a file // named after the key, stored in the namespace's directory. func (store *FSMetadataStore) Set(namespace, key string, value []byte) error { store.Lock() defer store.Unlock() path := store.path(namespace, key) if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil { return err } return ioutils.AtomicWriteFile(path, value, 0644) }
func (pm *Manager) save(p *v2.Plugin) error { pluginJSON, err := json.Marshal(p) if err != nil { return errors.Wrap(err, "failed to marshal plugin json") } if err := ioutils.AtomicWriteFile(filepath.Join(pm.config.Root, p.GetID(), configFileName), pluginJSON, 0600); err != nil { return err } return nil }
// fixme: not safe func (pm *Manager) save() error { filePath := filepath.Join(pm.libRoot, "plugins.json") jsonData, err := json.Marshal(pm.plugins) if err != nil { logrus.Debugf("Error in json.Marshal: %v", err) return err } ioutils.AtomicWriteFile(filePath, jsonData, 0600) return nil }
func (c *Cluster) saveState() error { dt, err := json.Marshal(state{ LocalAddr: c.localAddr, RemoteAddr: c.remoteAddr, ListenAddr: c.listenAddr, AdvertiseAddr: c.advertiseAddr, }) if err != nil { return err } return ioutils.AtomicWriteFile(filepath.Join(c.root, stateFile), dt, 0600) }
// SetMetadata sets metadata for a given ID. It fails if there's no base file. func (s *fs) SetMetadata(dgst digest.Digest, key string, data []byte) error { s.Lock() defer s.Unlock() if _, err := s.get(dgst); err != nil { return err } baseDir := filepath.Join(s.metadataDir(dgst)) if err := os.MkdirAll(baseDir, 0700); err != nil { return err } return ioutils.AtomicWriteFile(filepath.Join(s.metadataDir(dgst), key), data, 0600) }
// Set stores content by checksum. func (s *fs) Set(data []byte) (digest.Digest, error) { s.Lock() defer s.Unlock() if len(data) == 0 { return "", fmt.Errorf("invalid empty data") } dgst := digest.FromBytes(data) if err := ioutils.AtomicWriteFile(s.contentFile(dgst), data, 0600); err != nil { return "", err } return dgst, nil }
// Set stores content under a given ID. func (s *fs) Set(data []byte) (ID, error) { s.Lock() defer s.Unlock() if len(data) == 0 { return "", fmt.Errorf("Invalid empty data") } id := ID(digest.FromBytes(data)) if err := ioutils.AtomicWriteFile(s.contentFile(id), data, 0600); err != nil { return "", err } return id, nil }
// LoadOrCreateTrustKey attempts to load the libtrust key at the given path, // otherwise generates a new one func LoadOrCreateTrustKey(trustKeyPath string) (libtrust.PrivateKey, error) { err := system.MkdirAll(filepath.Dir(trustKeyPath), 0700) if err != nil { return nil, err } trustKey, err := libtrust.LoadKeyFile(trustKeyPath) if err == libtrust.ErrKeyFileDoesNotExist { trustKey, err = libtrust.GenerateECP256PrivateKey() if err != nil { return nil, fmt.Errorf("Error generating key: %s", err) } encodedKey, err := serializePrivateKey(trustKey, filepath.Ext(trustKeyPath)) if err != nil { return nil, fmt.Errorf("Error serializing key: %s", err) } if err := ioutils.AtomicWriteFile(trustKeyPath, encodedKey, os.FileMode(0600)); err != nil { return nil, fmt.Errorf("Error saving key file: %s", err) } } else if err != nil { return nil, fmt.Errorf("Error loading key file %s: %s", trustKeyPath, err) } return trustKey, nil }