Ilia Denisov
6aeb529f13
CI / changes (pull_request) Successful in 2s
CI / unit (pull_request) Successful in 10s
CI / integration (pull_request) Successful in 15s
CI / ui (pull_request) Successful in 53s
CI / gate (pull_request) Successful in 1s
CI / deploy (pull_request) Failing after 2m6s
Move all Telegram egress off the main host. The single connector held the bot token, long-polled Telegram and answered the gateway/backend over the trusted internal network, so the whole component (including login validation) shared fate with its VPN sidecar. Split it into two binaries that share the token: - cmd/validator (home, no VPN): Mini App initData + Login Widget HMAC only, never calls the Bot API. The gateway dials it for Telegram auth, so game login is now independent of Telegram reachability. - cmd/bot (remote): Bot API long-poll + sendMessage, the only component reaching Telegram. It holds no inbound port — it dials the gateway over a new reverse mTLS bot-link (pkg/proto/botlink/v1) and executes the send commands the gateway pushes. The gateway funnels sends to the bot-link: out-of-app push is fire-and-forget (at-most-once, dropped if no bot is connected); the backend admin broadcasts reach a gateway-served relay that forwards them and awaits the bot's ack (SendToUser/SendToGameChannel contract preserved). mTLS (pkg/mtls) is the one inter-service link that leaves the trusted segment; validator<->gateway and the relay stay plaintext internal. The bot is Telegram-rate-limited. One bot now; the gateway bot registry, an owns_updates flag and per-command ids leave seams for N later. Webhook rejected (one URL per token, adds inbound + a static address). The unified test contour runs the split (the bot keeps its VPN sidecar and dials the gateway by its internal name; bot-link certs from deploy/gen-certs.sh, generated in CI). The prod wiring — the bot on a separate host (no VPN), the gateway bot-link port published, PROD_ certs with scheduled rotation, an SSH deploy of both hosts together — is the deferred final stage (PRERELEASE.md TX, Stage 18). Docs: ARCHITECTURE, PRERELEASE (phase TX), platform/telegram + gateway + backend + deploy READMEs, FUNCTIONAL(+ru), CLAUDE.md, .env.example.
68 lines
2.5 KiB
Go
68 lines
2.5 KiB
Go
package botlink
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
|
|
botlinkv1 "scrabble/pkg/proto/botlink/v1"
|
|
telegramv1 "scrabble/pkg/proto/telegram/v1"
|
|
)
|
|
|
|
// RelayServer lets the backend's admin console reach the remote bot through the
|
|
// gateway: it implements the two admin delivery methods of the Telegram service by
|
|
// forwarding them onto the bot-link and awaiting the bot's Ack. The validation and
|
|
// out-of-app push methods are intentionally unimplemented here — login validation
|
|
// runs against the home validator and out-of-app push goes straight to the Hub.
|
|
type RelayServer struct {
|
|
telegramv1.UnimplementedTelegramServer
|
|
hub *Hub
|
|
deadline time.Duration
|
|
}
|
|
|
|
// NewRelayServer builds the relay over hub. deadline bounds the wait for the bot's
|
|
// Ack before reporting the send as not delivered.
|
|
func NewRelayServer(hub *Hub, deadline time.Duration) *RelayServer {
|
|
return &RelayServer{hub: hub, deadline: deadline}
|
|
}
|
|
|
|
// SendToUser forwards an admin message for one user to the bot and reports whether
|
|
// it was delivered. A missing bot maps to Unavailable (parity with an unreachable
|
|
// connector); a deadline before the Ack reports delivered=false.
|
|
func (r *RelayServer) SendToUser(ctx context.Context, req *telegramv1.SendToUserRequest) (*telegramv1.SendResponse, error) {
|
|
delivered, err := r.await(ctx, SendToUserCommand(req.GetExternalId(), req.GetText()))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &telegramv1.SendResponse{Delivered: delivered}, nil
|
|
}
|
|
|
|
// SendToGameChannel forwards an admin message for the game channel to the bot and
|
|
// reports whether it was delivered.
|
|
func (r *RelayServer) SendToGameChannel(ctx context.Context, req *telegramv1.SendToGameChannelRequest) (*telegramv1.SendResponse, error) {
|
|
delivered, err := r.await(ctx, SendToGameChannelCommand(req.GetText()))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &telegramv1.SendResponse{Delivered: delivered}, nil
|
|
}
|
|
|
|
// await sends cmd with the relay deadline and translates the Hub outcome into the
|
|
// gRPC contract the backend client expects.
|
|
func (r *RelayServer) await(ctx context.Context, cmd *botlinkv1.Command) (bool, error) {
|
|
cctx, cancel := context.WithTimeout(ctx, r.deadline)
|
|
defer cancel()
|
|
delivered, err := r.hub.SendAwait(cctx, cmd)
|
|
switch {
|
|
case errors.Is(err, ErrNoBot):
|
|
return false, status.Error(codes.Unavailable, "no telegram bot connected")
|
|
case err != nil:
|
|
return false, status.Error(codes.Internal, err.Error())
|
|
default:
|
|
return delivered, nil
|
|
}
|
|
}
|