func newSession(
ctx scope.Context, server *Server, conn *websocket.Conn,
roomName string, room proto.Room, client *proto.Client, agentKey *security.ManagedKey) *session {
nextID := atomic.AddUint64(&sessionIDCounter, 1)
sessionCount.WithLabelValues(roomName).Set(float64(nextID))
sessionID := fmt.Sprintf("%x-%08x", client.Agent.IDString(), nextID)
ctx = logging.LoggingContext(ctx, os.Stdout, fmt.Sprintf("[%s] ", sessionID))
session := &session{
id: sessionID,
ctx: ctx,
server: server,
conn: conn,
identity: newMemIdentity(client.UserID(), server.ID, server.Era),
client: client,
agentKey: agentKey,
serverID: server.ID,
serverEra: server.Era,
roomName: roomName,
room: room,
backend: server.b,
kms: server.kms,
heim: server.heim,
incoming: make(chan *proto.Packet),
outgoing: make(chan *proto.Packet, 100),
floodLimiter: ratelimit.NewBucketWithQuantum(time.Second, 50, 10),
}
return session
}
func (j *Job) Exec(ctx scope.Context, f func(scope.Context) error) error {
if j.JobClaim == nil {
return ErrJobNotClaimed
}
w := io.MultiWriter(os.Stdout, j)
prefix := fmt.Sprintf("[%s-%s] ", j.Queue.Name(), j.HandlerID)
deadline := time.Now().Add(j.MaxWorkDuration)
child := logging.LoggingContext(ctx.ForkWithTimeout(j.MaxWorkDuration), w, prefix)
if err := f(child); err != nil {
if err != scope.TimedOut {
delay := time.Duration(j.AttemptsMade+1) * BackoffDuration
if time.Now().Add(delay).After(deadline) {
delay = deadline.Sub(time.Now())
}
time.Sleep(delay)
}
if ferr := j.Fail(ctx, err.Error()); ferr != nil {
return ferr
}
return err
}
if err := j.Complete(ctx); err != nil {
return err
}
return nil
}
func Run(args []string) {
out = tabwriter.NewWriter(os.Stdout, 0, 8, 1, '\t', 0)
if len(args) == 0 {
generalHelp()
return
}
exe := filepath.Base(os.Args[0])
cmd, ok := subcommands[args[0]]
if !ok {
fmt.Fprintf(os.Stderr, "%s: invalid command: %s\n", exe, args[0])
fmt.Fprintf(os.Stderr, "Run '%s help' for usage.\n", exe)
os.Exit(2)
}
flags := cmd.flags()
if err := flags.Parse(args[1:]); err != nil {
fmt.Fprintf(os.Stderr, "%s %s: %s\n", exe, args[0], err)
os.Exit(2)
}
ctx := logging.LoggingContext(scope.New(), os.Stdout, fmt.Sprintf("[%s] ", args[0]))
logging.Logger(ctx).Printf("starting up")
if err := cmd.run(ctx, flags.Args()); err != nil {
fmt.Fprintln(os.Stderr, err.Error())
os.Exit(1)
}
timeout := time.After(10 * time.Second)
completed := make(chan struct{})
go func() {
ctx.WaitGroup().Wait()
close(completed)
}()
fmt.Println("waiting for graceful shutdown...")
select {
case <-timeout:
fmt.Println("timed out")
os.Exit(1)
case <-completed:
fmt.Println("ok")
os.Exit(0)
}
}