Ilia Denisov
145 lines
4.3 KiB
Go
145 lines
4.3 KiB
Go
// Package idgen provides the default crypto/rand-backed implementation of
|
|
// ports.IDGenerator for Game Lobby Service.
|
|
package idgen
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/base32"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
"galaxy/lobby/internal/domain/common"
|
|
)
|
|
|
|
// gameIDTokenBytes stores the number of random bytes consumed per
|
|
// NewGameID call. Ten bytes produce a 16-character base32 suffix, which
|
|
// gives 80 bits of entropy — well above the birthday-collision bound for the
|
|
// expected Game Lobby record volume.
|
|
const gameIDTokenBytes = 10
|
|
|
|
// applicationIDTokenBytes mirrors gameIDTokenBytes for application records.
|
|
// 80 bits of entropy is well above the birthday-collision bound for the
|
|
// expected application volume.
|
|
const applicationIDTokenBytes = 10
|
|
|
|
// inviteIDTokenBytes mirrors gameIDTokenBytes for invite records.
|
|
const inviteIDTokenBytes = 10
|
|
|
|
// membershipIDTokenBytes mirrors gameIDTokenBytes for membership records.
|
|
const membershipIDTokenBytes = 10
|
|
|
|
// base32NoPadding is the standard RFC 4648 base32 alphabet without padding,
|
|
// matching the identifier shape used by `galaxy/user/internal/adapters/local`.
|
|
var base32NoPadding = base32.StdEncoding.WithPadding(base32.NoPadding)
|
|
|
|
// Generator is the default opaque-identifier generator for Game Lobby
|
|
// records. Zero value is ready for use and draws randomness from
|
|
// crypto/rand.Reader.
|
|
type Generator struct {
|
|
// reader stores the cryptographic randomness source. A nil reader falls
|
|
// back to crypto/rand.Reader.
|
|
reader io.Reader
|
|
}
|
|
|
|
// Option configures an optional Generator setting.
|
|
type Option func(*Generator)
|
|
|
|
// WithRandomSource overrides the cryptographic randomness source. It is
|
|
// intended for deterministic tests; production code relies on the default
|
|
// crypto/rand.Reader.
|
|
func WithRandomSource(reader io.Reader) Option {
|
|
return func(gen *Generator) {
|
|
gen.reader = reader
|
|
}
|
|
}
|
|
|
|
// NewGenerator constructs one Generator with the supplied options applied.
|
|
func NewGenerator(opts ...Option) *Generator {
|
|
gen := &Generator{}
|
|
for _, opt := range opts {
|
|
opt(gen)
|
|
}
|
|
|
|
return gen
|
|
}
|
|
|
|
// NewGameID returns one newly generated opaque game identifier with the
|
|
// frozen `game-*` prefix.
|
|
func (gen *Generator) NewGameID() (common.GameID, error) {
|
|
token, err := gen.randomToken(gameIDTokenBytes)
|
|
if err != nil {
|
|
return "", fmt.Errorf("generate game id: %w", err)
|
|
}
|
|
|
|
gameID := common.GameID("game-" + token)
|
|
if err := gameID.Validate(); err != nil {
|
|
return "", fmt.Errorf("generate game id: %w", err)
|
|
}
|
|
|
|
return gameID, nil
|
|
}
|
|
|
|
// NewApplicationID returns one newly generated opaque application
|
|
// identifier with the frozen `application-*` prefix.
|
|
func (gen *Generator) NewApplicationID() (common.ApplicationID, error) {
|
|
token, err := gen.randomToken(applicationIDTokenBytes)
|
|
if err != nil {
|
|
return "", fmt.Errorf("generate application id: %w", err)
|
|
}
|
|
|
|
applicationID := common.ApplicationID("application-" + token)
|
|
if err := applicationID.Validate(); err != nil {
|
|
return "", fmt.Errorf("generate application id: %w", err)
|
|
}
|
|
|
|
return applicationID, nil
|
|
}
|
|
|
|
// NewInviteID returns one newly generated opaque invite identifier with the
|
|
// frozen `invite-*` prefix.
|
|
func (gen *Generator) NewInviteID() (common.InviteID, error) {
|
|
token, err := gen.randomToken(inviteIDTokenBytes)
|
|
if err != nil {
|
|
return "", fmt.Errorf("generate invite id: %w", err)
|
|
}
|
|
|
|
inviteID := common.InviteID("invite-" + token)
|
|
if err := inviteID.Validate(); err != nil {
|
|
return "", fmt.Errorf("generate invite id: %w", err)
|
|
}
|
|
|
|
return inviteID, nil
|
|
}
|
|
|
|
// NewMembershipID returns one newly generated opaque membership identifier
|
|
// with the frozen `membership-*` prefix.
|
|
func (gen *Generator) NewMembershipID() (common.MembershipID, error) {
|
|
token, err := gen.randomToken(membershipIDTokenBytes)
|
|
if err != nil {
|
|
return "", fmt.Errorf("generate membership id: %w", err)
|
|
}
|
|
|
|
membershipID := common.MembershipID("membership-" + token)
|
|
if err := membershipID.Validate(); err != nil {
|
|
return "", fmt.Errorf("generate membership id: %w", err)
|
|
}
|
|
|
|
return membershipID, nil
|
|
}
|
|
|
|
// randomToken returns one lowercase base32 token of the specified byte
|
|
// entropy.
|
|
func (gen *Generator) randomToken(byteCount int) (string, error) {
|
|
buffer := make([]byte, byteCount)
|
|
reader := gen.reader
|
|
if reader == nil {
|
|
reader = rand.Reader
|
|
}
|
|
if _, err := io.ReadFull(reader, buffer); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return strings.ToLower(base32NoPadding.EncodeToString(buffer)), nil
|
|
}
|