mirror of
https://github.com/go-gitea/gitea.git
synced 2024-08-25 21:57:29 +02:00
* update github.com/blevesearch/bleve v2.0.2 -> v2.0.3 * github.com/denisenkom/go-mssqldb v0.9.0 -> v0.10.0 * github.com/editorconfig/editorconfig-core-go v2.4.1 -> v2.4.2 * github.com/go-chi/cors v1.1.1 -> v1.2.0 * github.com/go-git/go-billy v5.0.0 -> v5.1.0 * github.com/go-git/go-git v5.2.0 -> v5.3.0 * github.com/go-ldap/ldap v3.2.4 -> v3.3.0 * github.com/go-redis/redis v8.6.0 -> v8.8.2 * github.com/go-sql-driver/mysql v1.5.0 -> v1.6.0 * github.com/go-swagger/go-swagger v0.26.1 -> v0.27.0 * github.com/lib/pq v1.9.0 -> v1.10.1 * github.com/mattn/go-sqlite3 v1.14.6 -> v1.14.7 * github.com/go-testfixtures/testfixtures v3.5.0 -> v3.6.0 * github.com/issue9/identicon v1.0.1 -> v1.2.0 * github.com/klauspost/compress v1.11.8 -> v1.12.1 * github.com/mgechev/revive v1.0.3 -> v1.0.6 * github.com/microcosm-cc/bluemonday v1.0.7 -> v1.0.8 * github.com/niklasfasching/go-org v1.4.0 -> v1.5.0 * github.com/olivere/elastic v7.0.22 -> v7.0.24 * github.com/pelletier/go-toml v1.8.1 -> v1.9.0 * github.com/prometheus/client_golang v1.9.0 -> v1.10.0 * github.com/xanzy/go-gitlab v0.44.0 -> v0.48.0 * github.com/yuin/goldmark v1.3.3 -> v1.3.5 * github.com/6543/go-version v1.2.4 -> v1.3.1 * do github.com/lib/pq v1.10.0 -> v1.10.1 again ...
202 lines
3.9 KiB
Go
Vendored
202 lines
3.9 KiB
Go
Vendored
package pool
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"sync/atomic"
|
|
)
|
|
|
|
const (
|
|
stateDefault = 0
|
|
stateInited = 1
|
|
stateClosed = 2
|
|
)
|
|
|
|
type BadConnError struct {
|
|
wrapped error
|
|
}
|
|
|
|
var _ error = (*BadConnError)(nil)
|
|
|
|
func (e BadConnError) Error() string {
|
|
s := "redis: Conn is in a bad state"
|
|
if e.wrapped != nil {
|
|
s += ": " + e.wrapped.Error()
|
|
}
|
|
return s
|
|
}
|
|
|
|
func (e BadConnError) Unwrap() error {
|
|
return e.wrapped
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
type StickyConnPool struct {
|
|
pool Pooler
|
|
shared int32 // atomic
|
|
|
|
state uint32 // atomic
|
|
ch chan *Conn
|
|
|
|
_badConnError atomic.Value
|
|
}
|
|
|
|
var _ Pooler = (*StickyConnPool)(nil)
|
|
|
|
func NewStickyConnPool(pool Pooler) *StickyConnPool {
|
|
p, ok := pool.(*StickyConnPool)
|
|
if !ok {
|
|
p = &StickyConnPool{
|
|
pool: pool,
|
|
ch: make(chan *Conn, 1),
|
|
}
|
|
}
|
|
atomic.AddInt32(&p.shared, 1)
|
|
return p
|
|
}
|
|
|
|
func (p *StickyConnPool) NewConn(ctx context.Context) (*Conn, error) {
|
|
return p.pool.NewConn(ctx)
|
|
}
|
|
|
|
func (p *StickyConnPool) CloseConn(cn *Conn) error {
|
|
return p.pool.CloseConn(cn)
|
|
}
|
|
|
|
func (p *StickyConnPool) Get(ctx context.Context) (*Conn, error) {
|
|
// In worst case this races with Close which is not a very common operation.
|
|
for i := 0; i < 1000; i++ {
|
|
switch atomic.LoadUint32(&p.state) {
|
|
case stateDefault:
|
|
cn, err := p.pool.Get(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if atomic.CompareAndSwapUint32(&p.state, stateDefault, stateInited) {
|
|
return cn, nil
|
|
}
|
|
p.pool.Remove(ctx, cn, ErrClosed)
|
|
case stateInited:
|
|
if err := p.badConnError(); err != nil {
|
|
return nil, err
|
|
}
|
|
cn, ok := <-p.ch
|
|
if !ok {
|
|
return nil, ErrClosed
|
|
}
|
|
return cn, nil
|
|
case stateClosed:
|
|
return nil, ErrClosed
|
|
default:
|
|
panic("not reached")
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("redis: StickyConnPool.Get: infinite loop")
|
|
}
|
|
|
|
func (p *StickyConnPool) Put(ctx context.Context, cn *Conn) {
|
|
defer func() {
|
|
if recover() != nil {
|
|
p.freeConn(ctx, cn)
|
|
}
|
|
}()
|
|
p.ch <- cn
|
|
}
|
|
|
|
func (p *StickyConnPool) freeConn(ctx context.Context, cn *Conn) {
|
|
if err := p.badConnError(); err != nil {
|
|
p.pool.Remove(ctx, cn, err)
|
|
} else {
|
|
p.pool.Put(ctx, cn)
|
|
}
|
|
}
|
|
|
|
func (p *StickyConnPool) Remove(ctx context.Context, cn *Conn, reason error) {
|
|
defer func() {
|
|
if recover() != nil {
|
|
p.pool.Remove(ctx, cn, ErrClosed)
|
|
}
|
|
}()
|
|
p._badConnError.Store(BadConnError{wrapped: reason})
|
|
p.ch <- cn
|
|
}
|
|
|
|
func (p *StickyConnPool) Close() error {
|
|
if shared := atomic.AddInt32(&p.shared, -1); shared > 0 {
|
|
return nil
|
|
}
|
|
|
|
for i := 0; i < 1000; i++ {
|
|
state := atomic.LoadUint32(&p.state)
|
|
if state == stateClosed {
|
|
return ErrClosed
|
|
}
|
|
if atomic.CompareAndSwapUint32(&p.state, state, stateClosed) {
|
|
close(p.ch)
|
|
cn, ok := <-p.ch
|
|
if ok {
|
|
p.freeConn(context.TODO(), cn)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
return errors.New("redis: StickyConnPool.Close: infinite loop")
|
|
}
|
|
|
|
func (p *StickyConnPool) Reset(ctx context.Context) error {
|
|
if p.badConnError() == nil {
|
|
return nil
|
|
}
|
|
|
|
select {
|
|
case cn, ok := <-p.ch:
|
|
if !ok {
|
|
return ErrClosed
|
|
}
|
|
p.pool.Remove(ctx, cn, ErrClosed)
|
|
p._badConnError.Store(BadConnError{wrapped: nil})
|
|
default:
|
|
return errors.New("redis: StickyConnPool does not have a Conn")
|
|
}
|
|
|
|
if !atomic.CompareAndSwapUint32(&p.state, stateInited, stateDefault) {
|
|
state := atomic.LoadUint32(&p.state)
|
|
return fmt.Errorf("redis: invalid StickyConnPool state: %d", state)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *StickyConnPool) badConnError() error {
|
|
if v := p._badConnError.Load(); v != nil {
|
|
if err := v.(BadConnError); err.wrapped != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *StickyConnPool) Len() int {
|
|
switch atomic.LoadUint32(&p.state) {
|
|
case stateDefault:
|
|
return 0
|
|
case stateInited:
|
|
return 1
|
|
case stateClosed:
|
|
return 0
|
|
default:
|
|
panic("not reached")
|
|
}
|
|
}
|
|
|
|
func (p *StickyConnPool) IdleLen() int {
|
|
return len(p.ch)
|
|
}
|
|
|
|
func (p *StickyConnPool) Stats() *Stats {
|
|
return &Stats{}
|
|
}
|