defer func() {
if err := w.Close(); err != nil {
fmt.Printf("Failed to close backend blob writer: %v", err)
}
}()
r := io.LimitReader(&blobstore.OffsetReader{be.cachebh, 0}, be.cachebh.Size())
if _, err := io.Copy(w, r); err != nil {
return fmt.Errorf("Failed to copy dirty data to backend blob writer: %v", err)
}
be.cbs.bever.Set(be.blobpath, cachever)
be.state = cacheEntryClean
return nil
}
var _ = util.Syncer(&CachedBlobEntry{})
func (be *CachedBlobEntry) Sync() error {
be.mu.Lock()
defer be.mu.Unlock()
// Wait for invalidation to complete
for be.state == cacheEntryInvalidating {
logger.Infof(mylog, "Waiting for cache to be fully invalidated before sync.")
be.validlenExtended.Wait()
}
if !be.state.IsActive() {
logger.Warningf(mylog, "Attempted to sync already uninitialized/closed entry: %+v", be.infoWithLock())
return nil
}
return bh.be.PWrite(p, offset)
}
func (bh *CachedBlobHandle) Size() int64 {
return bh.be.Size()
}
func (bh *CachedBlobHandle) Truncate(newsize int64) error {
if !fl.IsWriteAllowed(bh.flags) {
return EPERM
}
return bh.be.Truncate(newsize)
}
var _ = util.Syncer(&CachedBlobHandle{})
func (bh *CachedBlobHandle) Sync() error {
if !fl.IsWriteAllowed(bh.flags) {
return nil
}
return bh.be.Sync()
}
func (bh *CachedBlobHandle) Close() error {
bh.be.CloseHandle(bh)
return nil
}
"fmt"
"github.com/nyaxt/otaru/util"
)
// DBService serializes requests to DBHandler
type DBService struct {
reqC chan func()
quitC chan struct{}
exitedC chan struct{}
h DBHandler
}
var _ = DBHandler(&DBService{})
var _ = util.Syncer(&DBService{})
func NewDBService(h DBHandler) *DBService {
s := &DBService{
reqC: make(chan func()),
quitC: make(chan struct{}),
exitedC: make(chan struct{}),
h: h,
}
go s.run()
return s
}
func (srv *DBService) run() {
defer func() {
if err := w.Close(); err != nil {
fmt.Printf("Failed to close backend blob writer: %v", err)
}
}()
r := io.LimitReader(&blobstore.OffsetReader{be.cachebh, 0}, be.cachebh.Size())
if _, err := io.Copy(w, r); err != nil {
return fmt.Errorf("Failed to copy dirty data to backend blob writer: %v", err)
}
be.cbs.bever.Set(be.blobpath, cachever)
be.state = cacheEntryClean
return nil
}
var _ = util.Syncer(&CachedBlobEntry{})
func (be *CachedBlobEntry) Sync() error {
be.mu.Lock()
defer be.mu.Unlock()
// Wait for invalidation to complete
for be.state == cacheEntryInvalidating {
log.Printf("Waiting for cache to be fully invalidated before sync.")
be.validlenExtended.Wait()
}
if !be.state.IsActive() {
log.Printf("Attempted to sync already uninitialized/closed entry: %+v", be.infoWithLock())
return nil
}