Better concurrent map structure, specify Go 1.18 in mod file for generics support.

module github.com/heroiclabs/nakama/v3

go 1.17

go 1.18

require (

	github.com/blugelabs/bluge v0.1.9

github.com/caio/go-tdigest v3.1.0+incompatible h1:uoVMJ3Q5lXmVLCCqaMGHLBWnbGoN6Lpu7OAUPR60cds=

github.com/caio/go-tdigest v3.1.0+incompatible/go.mod h1:sHQM/ubZStBUmF1WbB8FAm8q9GjDajLC5T7ydxE3JHI=

github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=

github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=

github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=

github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=

github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=

github.com/denisenkom/go-mssqldb v0.9.0/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU=

github.com/dgryski/go-metro v0.0.0-20180109044635-280f6062b5bc h1:8WFBn63wegobsYAX0YjD+8suexZDga5CctH4CCTx2+8=

github.com/dgryski/go-metro v0.0.0-20180109044635-280f6062b5bc/go.mod h1:c9O8+fpSOX1DM8cPNSkX/qsBWdkD4yd2dpciOWQjpBw=

github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91 h1:Izz0+t1Z5nI16/II7vuEo/nHjodOg0p7+OiDpjX5t1E=

github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=

github.com/dlclark/regexp2 v1.7.0 h1:7lJfhqlPssTb1WQx4yvTHN0uElPEv52sbaECrAQxjAo=

github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=

github.com/dop251/goja v0.0.0-20211022113120-dc8c55024d06/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=

github.com/dop251/goja v0.0.0-20220403115030-90825c02072b h1:W/gxdQhJQDARfor8C7DASS0NhcFDzAZmL+XkAEgwnRI=

github.com/dop251/goja v0.0.0-20220403115030-90825c02072b/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk=

github.com/dop251/goja v0.0.0-20220806120448-1444e6b94559 h1:S3U65m9SN2p5CJpT3CDuqhN+rNJZXDoABYPKdQ7DOfY=

github.com/dop251/goja v0.0.0-20220806120448-1444e6b94559/go.mod h1:1jWwHOtOkEqsfX6tYsufUc7BBTuGHH2ekiJabpkN4CA=

github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA7c8pLvoGndExHudxTDKZ84Pyvv+90pbBjbTz0Y=

github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=

github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=

github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=

github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=

github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=

github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 h1:BZHcxBETFHIdVyhyEfOvn/RdU/QGdLI4y34qQGjGWO0=

github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks=

github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=

github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=

github.com/influxdata/influxdb v1.7.6/go.mod h1:qZna6X/4elxqT3yI9iZYdZrWWdeFOOprn86kgg4+IzY=

github.com/jackc/chunkreader v1.0.0 h1:4s39bBR8ByfqH+DKm8rQA3E1LHZWB9XWcrz8fqaZbe0=

github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=

github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=

github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8=

github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak=

github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=

github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=

github.com/jackc/pgproto3 v1.1.0 h1:FYYE4yRw+AgI8wXIinMlNjBbp/UitDJwfj5LqqewP1A=

github.com/jackc/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78=

github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA=

github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg=

github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=

github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=

github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=

github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI=

github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=

github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=

github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=

github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=

github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw=

github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=

github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=

github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=

github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=

github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=

github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ=

github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU=

// Copyright 2016 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// Retrieved from: https://github.com/SaveTheRbtz/generic-sync-map-go

// August 10th, 2022 at 22:00 UTC

// BSD license derived from Go standard library sync.Map source.

package server

import (

	"sync"

	"sync/atomic"

	"unsafe"

)

// MapOf is like a Go map[interface{}]interface{} but is safe for concurrent use

// by multiple goroutines without additional locking or coordination.

// Loads, stores, and deletes run in amortized constant time.

//

// The MapOf type is specialized. Most code should use a plain Go map instead,

// with separate locking or coordination, for better type safety and to make it

// easier to maintain other invariants along with the map content.

//

// The MapOf type is optimized for two common use cases: (1) when the entry for a given

// key is only ever written once but read many times, as in caches that only grow,

// or (2) when multiple goroutines read, write, and overwrite entries for disjoint

// sets of keys. In these two cases, use of a MapOf may significantly reduce lock

// contention compared to a Go map paired with a separate Mutex or RWMutex.

//

// The zero MapOf is empty and ready for use. A MapOf must not be copied after first use.

type MapOf[K comparable, V any] struct {

	mu sync.Mutex

	// read contains the portion of the map's contents that are safe for

	// concurrent access (with or without mu held).

	//

	// The read field itself is always safe to load, but must only be stored with

	// mu held.

	//

	// Entries stored in read may be updated concurrently without mu, but updating

	// a previously-expunged entry requires that the entry be copied to the dirty

	// map and unexpunged with mu held.

	read atomic.Value // readOnly

	// dirty contains the portion of the map's contents that require mu to be

	// held. To ensure that the dirty map can be promoted to the read map quickly,

	// it also includes all of the non-expunged entries in the read map.

	//

	// Expunged entries are not stored in the dirty map. An expunged entry in the

	// clean map must be unexpunged and added to the dirty map before a new value

	// can be stored to it.

	//

	// If the dirty map is nil, the next write to the map will initialize it by

	// making a shallow copy of the clean map, omitting stale entries.

	dirty map[K]*entry[V]

	// misses counts the number of loads since the read map was last updated that

	// needed to lock mu to determine whether the key was present.

	//

	// Once enough misses have occurred to cover the cost of copying the dirty

	// map, the dirty map will be promoted to the read map (in the unamended

	// state) and the next store to the map will make a new dirty copy.

	misses int

}

// readOnly is an immutable struct stored atomically in the MapOf.read field.

type readOnly[K comparable, V any] struct {

	m       map[K]*entry[V]

	amended bool // true if the dirty map contains some key not in m.

}

// expunged is an arbitrary pointer that marks entries which have been deleted

// from the dirty map.

var expunged = unsafe.Pointer(new(interface{}))

// An entry is a slot in the map corresponding to a particular key.

type entry[V any] struct {

	// p points to the interface{} value stored for the entry.

	//

	// If p == nil, the entry has been deleted and m.dirty == nil.

	//

	// If p == expunged, the entry has been deleted, m.dirty != nil, and the entry

	// is missing from m.dirty.

	//

	// Otherwise, the entry is valid and recorded in m.read.m[key] and, if m.dirty

	// != nil, in m.dirty[key].

	//

	// An entry can be deleted by atomic replacement with nil: when m.dirty is

	// next created, it will atomically replace nil with expunged and leave

	// m.dirty[key] unset.

	//

	// An entry's associated value can be updated by atomic replacement, provided

	// p != expunged. If p == expunged, an entry's associated value can be updated

	// only after first setting m.dirty[key] = e so that lookups using the dirty

	// map find the entry.

	p unsafe.Pointer // *interface{}

}

func newEntry[V any](i V) *entry[V] {

	return &entry[V]{p: unsafe.Pointer(&i)}

}

// Load returns the value stored in the map for a key, or nil if no

// value is present.

// The ok result indicates whether value was found in the map.

func (m *MapOf[K, V]) Load(key K) (value V, ok bool) {

	read, _ := m.read.Load().(readOnly[K, V])

	e, ok := read.m[key]

	if !ok && read.amended {

		m.mu.Lock()

		// Avoid reporting a spurious miss if m.dirty got promoted while we were

		// blocked on m.mu. (If further loads of the same key will not miss, it's

		// not worth copying the dirty map for this key.)

		read, _ = m.read.Load().(readOnly[K, V])

		e, ok = read.m[key]

		if !ok && read.amended {

			e, ok = m.dirty[key]

			// Regardless of whether the entry was present, record a miss: this key

			// will take the slow path until the dirty map is promoted to the read

			// map.

			m.missLocked()

		}

		m.mu.Unlock()

	}

	if !ok {

		return value, false

	}

	return e.load()

}

func (e *entry[V]) load() (value V, ok bool) {

	p := atomic.LoadPointer(&e.p)

	if p == nil || p == expunged {

		return value, false

	}

	return *(*V)(p), true

}

// Store sets the value for a key.

func (m *MapOf[K, V]) Store(key K, value V) {

	read, _ := m.read.Load().(readOnly[K, V])

	if e, ok := read.m[key]; ok && e.tryStore(&value) {

		return

	}

	m.mu.Lock()

	read, _ = m.read.Load().(readOnly[K, V])

	if e, ok := read.m[key]; ok {

		if e.unexpungeLocked() {

			// The entry was previously expunged, which implies that there is a

			// non-nil dirty map and this entry is not in it.

			m.dirty[key] = e

		}

		e.storeLocked(&value)

	} else if e, ok := m.dirty[key]; ok {

		e.storeLocked(&value)

	} else {

		if !read.amended {

			// We're adding the first new key to the dirty map.

			// Make sure it is allocated and mark the read-only map as incomplete.

			m.dirtyLocked()

			m.read.Store(readOnly[K, V]{m: read.m, amended: true})

		}

		m.dirty[key] = newEntry(value)

	}

	m.mu.Unlock()

}

// tryStore stores a value if the entry has not been expunged.

//

// If the entry is expunged, tryStore returns false and leaves the entry

// unchanged.

func (e *entry[V]) tryStore(i *V) bool {

	for {

		p := atomic.LoadPointer(&e.p)

		if p == expunged {

			return false

		}

		if atomic.CompareAndSwapPointer(&e.p, p, unsafe.Pointer(i)) {

			return true

		}

	}

}

// unexpungeLocked ensures that the entry is not marked as expunged.

//

// If the entry was previously expunged, it must be added to the dirty map

// before m.mu is unlocked.

func (e *entry[V]) unexpungeLocked() (wasExpunged bool) {

	return atomic.CompareAndSwapPointer(&e.p, expunged, nil)

}

// storeLocked unconditionally stores a value to the entry.

//

// The entry must be known not to be expunged.

func (e *entry[V]) storeLocked(i *V) {

	atomic.StorePointer(&e.p, unsafe.Pointer(i))

}

// LoadOrStore returns the existing value for the key if present.

// Otherwise, it stores and returns the given value.

// The loaded result is true if the value was loaded, false if stored.

func (m *MapOf[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {

	// Avoid locking if it's a clean hit.

	read, _ := m.read.Load().(readOnly[K, V])

	if e, ok := read.m[key]; ok {

		actual, loaded, ok := e.tryLoadOrStore(value)

		if ok {

			return actual, loaded

		}

	}

	m.mu.Lock()

	read, _ = m.read.Load().(readOnly[K, V])

	if e, ok := read.m[key]; ok {

		if e.unexpungeLocked() {

			m.dirty[key] = e

		}

		actual, loaded, _ = e.tryLoadOrStore(value)

	} else if e, ok := m.dirty[key]; ok {

		actual, loaded, _ = e.tryLoadOrStore(value)

		m.missLocked()

	} else {

		if !read.amended {

			// We're adding the first new key to the dirty map.

			// Make sure it is allocated and mark the read-only map as incomplete.

			m.dirtyLocked()

			m.read.Store(readOnly[K, V]{m: read.m, amended: true})

		}

		m.dirty[key] = newEntry(value)

		actual, loaded = value, false

	}

	m.mu.Unlock()

	return actual, loaded

}

// tryLoadOrStore atomically loads or stores a value if the entry is not

// expunged.

//

// If the entry is expunged, tryLoadOrStore leaves the entry unchanged and

// returns with ok==false.

func (e *entry[V]) tryLoadOrStore(i V) (actual V, loaded, ok bool) {

	p := atomic.LoadPointer(&e.p)

	if p == expunged {

		return actual, false, false

	}

	if p != nil {

		return *(*V)(p), true, true

	}

	// Copy the interface after the first load to make this method more amenable

	// to escape analysis: if we hit the "load" path or the entry is expunged, we

	// shouldn't bother heap-allocating.

	ic := i

	for {

		if atomic.CompareAndSwapPointer(&e.p, nil, unsafe.Pointer(&ic)) {

			return i, false, true

		}

		p = atomic.LoadPointer(&e.p)

		if p == expunged {

			return actual, false, false

		}

		if p != nil {

			return *(*V)(p), true, true

		}

	}

}

// LoadAndDelete deletes the value for a key, returning the previous value if any.

// The loaded result reports whether the key was present.

func (m *MapOf[K, V]) LoadAndDelete(key K) (value V, loaded bool) {

	read, _ := m.read.Load().(readOnly[K, V])

	e, ok := read.m[key]

	if !ok && read.amended {

		m.mu.Lock()

		read, _ = m.read.Load().(readOnly[K, V])

		e, ok = read.m[key]

		if !ok && read.amended {

			e, ok = m.dirty[key]

			delete(m.dirty, key)

			// Regardless of whether the entry was present, record a miss: this key

			// will take the slow path until the dirty map is promoted to the read

			// map.

			m.missLocked()

		}

		m.mu.Unlock()

	}

	if ok {

		return e.delete()

	}

	return value, false

}

// Delete deletes the value for a key.

func (m *MapOf[K, V]) Delete(key K) {

	m.LoadAndDelete(key)

}

func (e *entry[V]) delete() (value V, ok bool) {

	for {

		p := atomic.LoadPointer(&e.p)

		if p == nil || p == expunged {

			return value, false

		}

		if atomic.CompareAndSwapPointer(&e.p, p, nil) {

			return *(*V)(p), true

		}

	}

}

// Range calls f sequentially for each key and value present in the map.

// If f returns false, range stops the iteration.

//

// Range does not necessarily correspond to any consistent snapshot of the MapOf's

// contents: no key will be visited more than once, but if the value for any key

// is stored or deleted concurrently, Range may reflect any mapping for that key

// from any point during the Range call.

//

// Range may be O(N) with the number of elements in the map even if f returns

// false after a constant number of calls.

func (m *MapOf[K, V]) Range(f func(key K, value V) bool) {

	// We need to be able to iterate over all of the keys that were already

	// present at the start of the call to Range.

	// If read.amended is false, then read.m satisfies that property without

	// requiring us to hold m.mu for a long time.

	read, _ := m.read.Load().(readOnly[K, V])

	if read.amended {

		// m.dirty contains keys not in read.m. Fortunately, Range is already O(N)

		// (assuming the caller does not break out early), so a call to Range

		// amortizes an entire copy of the map: we can promote the dirty copy

		// immediately!

		m.mu.Lock()

		read, _ = m.read.Load().(readOnly[K, V])

		if read.amended {

			read = readOnly[K, V]{m: m.dirty}

			m.read.Store(read)

			m.dirty = nil

			m.misses = 0

		}

		m.mu.Unlock()

	}

	for k, e := range read.m {

		v, ok := e.load()

		if !ok {

			continue

		}

		if !f(k, v) {

			break

		}

	}

}

func (m *MapOf[K, V]) missLocked() {

	m.misses++

	if m.misses < len(m.dirty) {

		return

	}

	m.read.Store(readOnly[K, V]{m: m.dirty})

	m.dirty = nil

	m.misses = 0

}

func (m *MapOf[K, V]) dirtyLocked() {

	if m.dirty != nil {

		return

	}

	read, _ := m.read.Load().(readOnly[K, V])

	m.dirty = make(map[K]*entry[V], len(read.m))

	for k, e := range read.m {

		if !e.tryExpungeLocked() {

			m.dirty[k] = e

		}

	}

}

func (e *entry[V]) tryExpungeLocked() (isExpunged bool) {

	p := atomic.LoadPointer(&e.p)

	for p == nil {

		if atomic.CompareAndSwapPointer(&e.p, nil, expunged) {

			return true

		}

		p = atomic.LoadPointer(&e.p)

	}

	return p == expunged

}

	ctx         context.Context

	ctxCancelFn context.CancelFunc

	matches     *sync.Map

	matches     *MapOf[uuid.UUID, *MatchHandler]

	matchCount  *atomic.Int64

	indexWriter *bluge.Writer

		ctx:         ctx,

		ctxCancelFn: ctxCancelFn,

		matches:     &sync.Map{},

		matches:     &MapOf[uuid.UUID, *MatchHandler]{},

		matchCount:  atomic.NewInt64(0),

		indexWriter: indexWriter,

			batch.Delete(bluge.Identifier(id))

			continue

		}

		doc, err := MapMatchIndexEntry(id, op, r.logger)

		doc, err := MapMatchIndexEntry(id, op)

		if err != nil {

			r.logger.Error("error mapping match index entry to doc: %v", zap.Error(err))

		}

	if !ok {

		return nil, "", nil

	}

	handler := mh.(*MatchHandler)

	return &api.Match{

		MatchId:       handler.IDStr,

		MatchId:       mh.IDStr,

		Authoritative: true,

		Label:         &wrapperspb.StringValue{Value: handler.Label()},

		Size:          int32(handler.PresenceList.Size()),

		TickRate:      int32(handler.Rate),

		HandlerName:   handler.Core.HandlerName(),

		Label:         &wrapperspb.StringValue{Value: mh.Label()},

		Size:          int32(mh.PresenceList.Size()),

		TickRate:      int32(mh.Rate),

		HandlerName:   mh.Core.HandlerName(),

	}, r.node, nil

}

			if !ok {

				continue

			}

			size := int32(mh.(*MatchHandler).PresenceList.Size())

			size := int32(mh.PresenceList.Size())

			if minSize != nil && minSize.Value > size {

				// Not eligible based on minimum size.

		// If grace period is 0 stop match label processing immediately.

		r.ctxCancelFn()

		r.matches.Range(func(id, mh interface{}) bool {

			mh.(*MatchHandler).Stop()

		r.matches.Range(func(id uuid.UUID, mh *MatchHandler) bool {

			mh.Stop()

			return true

		})

		// Termination was triggered and there are no active matches.

	}

	var anyRunning bool

	r.matches.Range(func(id, mh interface{}) bool {

	r.matches.Range(func(id uuid.UUID, mh *MatchHandler) bool {

		anyRunning = true

		// Don't care if the call queue is full, match is supposed to end anyway.

		mh.(*MatchHandler).QueueTerminate(graceSeconds)

		mh.QueueTerminate(graceSeconds)

		return true

	})

		return false, false, false, "", "", nil

	}

	m, ok := r.matches.Load(id)

	mh, ok := r.matches.Load(id)

	if !ok {

		return false, false, false, "", "", nil

	}

	mh := m.(*MatchHandler)

	if mh.PresenceList.Contains(&PresenceID{Node: fromNode, SessionID: sessionID}) {

		// The user is already part of this match.

	}

	// Doesn't matter if the call queue was full here. If the match is being closed then joins don't matter anyway.

	mh.(*MatchHandler).QueueJoin(presences, true)

	mh.QueueJoin(presences, true)

}

func (r *LocalMatchRegistry) Leave(id uuid.UUID, presences []*MatchPresence) {

	}

	// Doesn't matter if the call queue was full here. If the match is being closed then leaves don't matter anyway.

	mh.(*MatchHandler).QueueLeave(presences)

	mh.QueueLeave(presences)

}

func (r *LocalMatchRegistry) Kick(stream PresenceStream, presences []*MatchPresence) {

		return

	}

	mh.(*MatchHandler).QueueData(&MatchDataMessage{

	mh.QueueData(&MatchDataMessage{

		UserID:      userID,

		SessionID:   sessionID,

		Username:    username,

		return "", runtime.ErrMatchNotFound

	}

	m, ok := r.matches.Load(matchID)

	mh, ok := r.matches.Load(matchID)

	if !ok {

		return "", runtime.ErrMatchNotFound

	}

	mh := m.(*MatchHandler)

	resultCh := make(chan *MatchSignalResult, 1)

	if !mh.QueueSignal(ctx, resultCh, data) {

		return nil, 0, "", nil

	}

	m, ok := r.matches.Load(id)

	mh, ok := r.matches.Load(id)

	if !ok {

		return nil, 0, "", runtime.ErrMatchNotFound

	}

	mh := m.(*MatchHandler)

	resultCh := make(chan *MatchGetStateResult, 1)

	if !mh.QueueGetState(ctx, resultCh) {

	}

}

func MapMatchIndexEntry(id string, in *MatchIndexEntry, logger *zap.Logger) (*bluge.Document, error) {

func MapMatchIndexEntry(id string, in *MatchIndexEntry) (*bluge.Document, error) {

	rv := bluge.NewDocument(id)

	rv.AddField(bluge.NewKeywordField("node", in.Node).StoreValue())