code.gitea.io/gitea@v1.22.3/modules/queue/base_levelqueue_unique.go (about)

     1  // Copyright 2023 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package queue
     5  
     6  import (
     7  	"context"
     8  	"sync"
     9  	"sync/atomic"
    10  
    11  	"code.gitea.io/gitea/modules/nosql"
    12  	"code.gitea.io/gitea/modules/queue/lqinternal"
    13  
    14  	"gitea.com/lunny/levelqueue"
    15  	"github.com/syndtr/goleveldb/leveldb"
    16  )
    17  
    18  type baseLevelQueueUnique struct {
    19  	internal atomic.Pointer[levelqueue.UniqueQueue]
    20  
    21  	conn string
    22  	cfg  *BaseConfig
    23  	db   *leveldb.DB
    24  
    25  	mu sync.Mutex // the levelqueue.UniqueQueue is not thread-safe, there is no mutex protecting the underlying queue&set together
    26  }
    27  
    28  var _ baseQueue = (*baseLevelQueueUnique)(nil)
    29  
    30  func newBaseLevelQueueUnique(cfg *BaseConfig) (baseQueue, error) {
    31  	conn, db, err := prepareLevelDB(cfg)
    32  	if err != nil {
    33  		return nil, err
    34  	}
    35  	q := &baseLevelQueueUnique{conn: conn, cfg: cfg, db: db}
    36  	lq, err := levelqueue.NewUniqueQueue(db, []byte(cfg.QueueFullName), []byte(cfg.SetFullName), false)
    37  	if err != nil {
    38  		return nil, err
    39  	}
    40  	q.internal.Store(lq)
    41  	return q, nil
    42  }
    43  
    44  func (q *baseLevelQueueUnique) PushItem(ctx context.Context, data []byte) error {
    45  	c := baseLevelQueueCommon(q.cfg, &q.mu, func() baseLevelQueuePushPoper { return q.internal.Load() })
    46  	return c.PushItem(ctx, data)
    47  }
    48  
    49  func (q *baseLevelQueueUnique) PopItem(ctx context.Context) ([]byte, error) {
    50  	c := baseLevelQueueCommon(q.cfg, &q.mu, func() baseLevelQueuePushPoper { return q.internal.Load() })
    51  	return c.PopItem(ctx)
    52  }
    53  
    54  func (q *baseLevelQueueUnique) HasItem(ctx context.Context, data []byte) (bool, error) {
    55  	q.mu.Lock()
    56  	defer q.mu.Unlock()
    57  	return q.internal.Load().Has(data)
    58  }
    59  
    60  func (q *baseLevelQueueUnique) Len(ctx context.Context) (int, error) {
    61  	q.mu.Lock()
    62  	defer q.mu.Unlock()
    63  	return int(q.internal.Load().Len()), nil
    64  }
    65  
    66  func (q *baseLevelQueueUnique) Close() error {
    67  	q.mu.Lock()
    68  	defer q.mu.Unlock()
    69  	err := q.internal.Load().Close()
    70  	q.db = nil // the db is not managed by us, it's managed by the nosql manager
    71  	_ = nosql.GetManager().CloseLevelDB(q.conn)
    72  	return err
    73  }
    74  
    75  func (q *baseLevelQueueUnique) RemoveAll(ctx context.Context) error {
    76  	q.mu.Lock()
    77  	defer q.mu.Unlock()
    78  	lqinternal.RemoveLevelQueueKeys(q.db, []byte(q.cfg.QueueFullName))
    79  	lqinternal.RemoveLevelQueueKeys(q.db, []byte(q.cfg.SetFullName))
    80  	lq, err := levelqueue.NewUniqueQueue(q.db, []byte(q.cfg.QueueFullName), []byte(q.cfg.SetFullName), false)
    81  	if err != nil {
    82  		return err
    83  	}
    84  	old := q.internal.Load()
    85  	q.internal.Store(lq)
    86  	_ = old.Close() // Not ideal for concurrency. Luckily, the levelqueue only sets its db=nil because it doesn't manage the db, so far so good
    87  	return nil
    88  }