// Get returns the charm referenced by curl. // CacheDir must have been set, otherwise Get will panic. func (s *CharmStore) Get(curl *URL) (Charm, error) { // The cache location must have been previously set. if CacheDir == "" { panic("charm cache directory path is empty") } if err := os.MkdirAll(CacheDir, os.FileMode(0755)); err != nil { return nil, err } revInfo, err := s.revisions(curl) if err != nil { return nil, err } if len(revInfo) != 1 { return nil, fmt.Errorf("expected 1 result, got %d", len(revInfo)) } if revInfo[0].Err != nil { return nil, revInfo[0].Err } rev, digest := revInfo[0].Revision, revInfo[0].Sha256 if curl.Revision == -1 { curl = curl.WithRevision(rev) } else if curl.Revision != rev { return nil, fmt.Errorf("store returned charm with wrong revision %d for %q", rev, curl.String()) } path := filepath.Join(CacheDir, Quote(curl.String())+".charm") if verify(path, digest) != nil { store_url := s.BaseURL + "/charm/" + url.QueryEscape(curl.Path()) if s.testMode { store_url = store_url + "?stats=0" } resp, err := s.get(store_url) if err != nil { return nil, err } defer resp.Body.Close() f, err := ioutil.TempFile(CacheDir, "charm-download") if err != nil { return nil, err } dlPath := f.Name() _, err = io.Copy(f, resp.Body) if cerr := f.Close(); err == nil { err = cerr } if err != nil { os.Remove(dlPath) return nil, err } if err := utils.ReplaceFile(dlPath, path); err != nil { return nil, err } } if err := verify(path, digest); err != nil { return nil, err } return ReadBundle(path) }
// Unlock releases a held lock. If the lock is not held ErrLockNotHeld is // returned. func (lock *Lock) Unlock() error { if !lock.IsLockHeld() { return ErrLockNotHeld } // To ensure reasonable unlocking, we should rename to a temp name, and delete that. tempLockName := fmt.Sprintf(".%s.%x", lock.name, lock.nonce) tempDirName := path.Join(lock.parent, tempLockName) // Now move the lock directory to the temp directory to release the lock. if err := utils.ReplaceFile(lock.lockDir(), tempDirName); err != nil { return err } // And now cleanup. return os.RemoveAll(tempDirName) }
// If message is set, it will write the message to the lock directory as the // lock is taken. func (lock *Lock) acquire(message string) (bool, error) { // If the lockDir exists, then the lock is held by someone else. _, err := os.Stat(lock.lockDir()) if err == nil { return false, nil } if !os.IsNotExist(err) { return false, err } // Create a temporary directory (in the parent dir), and then move it to // the right name. Using the same directory to make sure the directories // are on the same filesystem. Use a directory name starting with "." as // it isn't a valid lock name. tempLockName := fmt.Sprintf(".%x", lock.nonce) tempDirName, err := ioutil.TempDir(lock.parent, tempLockName) if err != nil { return false, err // this shouldn't really fail... } // write nonce into the temp dir err = ioutil.WriteFile(path.Join(tempDirName, heldFilename), lock.nonce, 0755) if err != nil { return false, err } if message != "" { err = ioutil.WriteFile(path.Join(tempDirName, messageFilename), []byte(message), 0755) if err != nil { return false, err } } // Now move the temp directory to the lock directory. err = utils.ReplaceFile(tempDirName, lock.lockDir()) if err != nil { // Any error on rename means we failed. // Beaten to it, clean up temporary directory. os.RemoveAll(tempDirName) return false, nil } // We now have the lock. return true, nil }
// finishDeploy persists the fact that we've finished deploying the staged bundle. func (d *manifestDeployer) finishDeploy() error { logger.Debugf("finishing deploy of charm %q", d.staged.url) oldPath := d.CharmPath(deployingURLPath) newPath := d.CharmPath(charmURLPath) return utils.ReplaceFile(oldPath, newPath) }