FilesExpand file tree

main

/

legacy.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

76 lines (69 loc) · 1.83 KB

main

/

legacy.go

Copy path

Top

File metadata and controls

• Code
• Blame

76 lines (69 loc) · 1.83 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

package session

import (

"errors"

"sync/atomic"

"time"

)

type legacyState struct{ nextPlayerID atomic.Uint64 }

// NewManager 保留旧自动编号入口。

//

// Deprecated: 使用 New(Options)，由应用提供 PlayerID。

func NewManager(startPlayerID uint64) *Manager {

m, _ := New(Options{AccountPolicy: ReplaceExisting})

m.legacy = &legacyState{}

m.legacy.nextPlayerID.Store(startPlayerID)

return m

}

// Login 保留旧自动编号登录行为。

//

// Deprecated: 应用分配 PlayerID 后调用 Issue 和 Bind。

func (m *Manager) Login(accountID string, connID uint32) (*Session, *Session, error) {

if m == nil {

return nil, nil, errors.New("session manager is nil")

}

if m.legacy == nil {

return nil, nil, errors.New("automatic player IDs require the deprecated NewManager constructor")

}

if accountID == "" {

return nil, nil, errors.New("account id is empty")

}

token, err := createToken()

if err != nil {

return nil, nil, err

}

m.lock.Lock()

defer m.lock.Unlock()

now := time.Now()

session := &Session{

Token: token,

AccountID: accountID,

PlayerID: m.legacy.nextPlayerID.Add(1),

ConnID: connID,

Bound: true,

CreatedAt: now,

UpdatedAt: now,

}

var replaced *Session

if oldToken, ok := m.byAccountID[accountID]; ok {

replaced = sessionCopy(m.byToken[oldToken])

m.removeLocked(oldToken)

}

if oldToken, ok := m.byConnID[connID]; ok {

m.removeLocked(oldToken)

}

m.byToken[token] = session

m.byAccountID[accountID] = token

m.byPlayerID[session.PlayerID] = token

m.byConnID[connID] = token

return sessionCopy(session), replaced, nil

}

func (m *Manager) observeLegacyID(id uint64) {

if m.legacy == nil {

return

}

for current := m.legacy.nextPlayerID.Load(); current < id; current = m.legacy.nextPlayerID.Load() {

if m.legacy.nextPlayerID.CompareAndSwap(current, id) {

break

}

}

}