// 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)
}