mirror of
https://github.com/gomods/athens
synced 2026-02-03 11:00:32 +00:00
0ef761cc8b
* gcp/saver: Only return errors.KindAlreadyExists if all three exist In #1124, a GCP lock type was added as a singleflight backend. As part of this work, the GCP backend's Save() was made serial, likely because moduploader.Upload requires a call to Exists() before it, rendering the GCP lock less useful, by doubling the calls to GCS. However, by doing this, the existence check was now only checking the existence of the mod file, and not the info or zip. This meant that if during a Save, the zip or info uploads failed, on subsequent rquests, that when using the GCP singleflight backend, Athens would assume everything had been stashed and saved properly, and then fail to serve up the info or zip that had failed upload, meaning the cache was in an unhealable broklen state, requiring a manual intervention. To fix this, without breaking the singleflight behavior, introduce a metadata key that is set on the mod file during its initial upload, indicating that a Stash is still in progress on subsequent files, which gets removed once all three files are uploaded successfully, which can be checked if it it is determined that the mod file already exists. That way we can return a errors.KindAlreadyExists if a Stash is in progress, but also properly return it when a Stash is *not* currently in progress if and only if all three files exist on GCS, which prevents the cache from becoming permanently poisoned. One note is that it is possible the GCS call to remove the metadata key fails, which would mean it is left on the mod object forever. To avoid this, consider it stale after 2 minutes. --------- Signed-off-by: Derek Buitenhuis <derek.buitenhuis@gmail.com> Co-authored-by: Matt <matt.ouille@protonmail.com>
51 lines
1.4 KiB
Go
51 lines
1.4 KiB
Go
package stash
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/gomods/athens/pkg/errors"
|
|
"github.com/gomods/athens/pkg/observ"
|
|
"github.com/gomods/athens/pkg/storage"
|
|
"github.com/gomods/athens/pkg/storage/gcp"
|
|
)
|
|
|
|
// WithGCSLock returns a distributed singleflight
|
|
// using a GCS backend. See the config.toml documentation for details.
|
|
func WithGCSLock(staleThreshold int, s storage.Backend) (Wrapper, error) {
|
|
if staleThreshold <= 0 {
|
|
return nil, errors.E("stash.WithGCSLock", fmt.Errorf("invalid stale threshold"))
|
|
}
|
|
// Since we *must* be using a GCP stoagfe backend, we can abuse this
|
|
// fact to mutate it, so that we can get our threshold into Save().
|
|
// Your instincts are correct, this is kind of gross.
|
|
gs, ok := s.(*gcp.Storage)
|
|
if !ok {
|
|
return nil, errors.E("stash.WithGCSLock", fmt.Errorf("GCP singleflight can only be used with GCP storage"))
|
|
}
|
|
gs.SetStaleThreshold(time.Duration(staleThreshold) * time.Second)
|
|
return func(s Stasher) Stasher {
|
|
return &gcsLock{s}
|
|
}, nil
|
|
}
|
|
|
|
type gcsLock struct {
|
|
stasher Stasher
|
|
}
|
|
|
|
func (s *gcsLock) Stash(ctx context.Context, mod, ver string) (newVer string, err error) {
|
|
const op errors.Op = "gcslock.Stash"
|
|
ctx, span := observ.StartSpan(ctx, op.String())
|
|
defer span.End()
|
|
newVer, err = s.stasher.Stash(ctx, mod, ver)
|
|
if err != nil {
|
|
// already been saved before, move on.
|
|
if errors.Is(err, errors.KindAlreadyExists) {
|
|
return ver, nil
|
|
}
|
|
return ver, errors.E(op, err)
|
|
}
|
|
return newVer, nil
|
|
}
|