elura-cli 0.2.10

Project scaffold generator for Elura applications
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#pragma once

#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>

namespace elura {

inline constexpr std::uint32_t kElr2Magic = 0x454c5232U;
inline constexpr std::uint16_t kElr2Version = {{ELR2_VERSION}};
inline constexpr std::size_t kElr2HeaderLength = 28;
inline constexpr std::size_t kDefaultMaxPayload = 1U << 20U;
inline constexpr std::size_t kAbsoluteMaxPayload = 64U << 20U;
inline constexpr const char* kProtocolIdentifier = "{{PROTOCOL_IDENTIFIER}}";

struct EluraRoutes {
  static constexpr std::uint32_t Authenticate = 1;
  static constexpr std::uint32_t Heartbeat = 2;
  static constexpr std::uint32_t RenewReconnectTicket = 3;
  static constexpr std::uint32_t SessionControl = 4;
  static constexpr std::uint32_t FirstApplication = 100;
};

enum class FrameKind : std::uint8_t {
  Request = 1,
  Response = 2,
  Push = 3,
  Error = 4,
};

using Bytes = std::vector<std::uint8_t>;

[[nodiscard]] Bytes to_bytes(std::string_view text);
[[nodiscard]] std::string_view as_string(std::span<const std::uint8_t> bytes) noexcept;

struct Elr2Frame {
  FrameKind kind = FrameKind::Request;
  std::uint8_t flags = 0;
  std::uint32_t route = 0;
  std::uint64_t request_id = 0;
  std::uint32_t sequence = 0;
  Bytes payload;

  [[nodiscard]] static Elr2Frame request(
      std::uint32_t route, std::uint64_t request_id, Bytes payload = {},
      std::uint32_t sequence = 0);
  [[nodiscard]] static Elr2Frame response(const Elr2Frame& request, Bytes payload = {});
  [[nodiscard]] static Elr2Frame error(const Elr2Frame& request, Bytes payload = {});
  [[nodiscard]] static Elr2Frame push(
      std::uint32_t route, Bytes payload = {}, std::uint32_t sequence = 0);

  bool operator==(const Elr2Frame&) const = default;
};

class Elr2ProtocolError : public std::runtime_error {
 public:
  using std::runtime_error::runtime_error;
};

class Elr2Codec {
 public:
  static void validate(
      const Elr2Frame& frame, std::size_t max_payload = kDefaultMaxPayload);
  [[nodiscard]] static Bytes encode(
      const Elr2Frame& frame, std::size_t max_payload = kDefaultMaxPayload);
  [[nodiscard]] static Elr2Frame decode(
      std::span<const std::uint8_t> bytes,
      std::size_t max_payload = kDefaultMaxPayload);
};

class Elr2StreamDecoder {
 public:
  explicit Elr2StreamDecoder(std::size_t max_payload = kDefaultMaxPayload);
  void append(std::span<const std::uint8_t> bytes);
  [[nodiscard]] std::optional<Elr2Frame> next();
  [[nodiscard]] std::size_t buffered() const noexcept { return buffer_.size(); }
  [[nodiscard]] bool empty() const noexcept { return buffer_.empty(); }

 private:
  std::size_t max_payload_;
  Bytes buffer_;
};

// JSON payload models. Serialized field names are the snake_case names shown below.
struct Identity {
  std::int64_t account_id = 0;
  std::int64_t user_id = 0;
  std::uint32_t region_id = 0;
  std::uint32_t realm_id = 0;
  std::uint64_t generation = 0;
};

struct AuthenticateRequest { std::string ticket; };
struct ReconnectTicketRenewalRequest { std::string ticket; };
struct ReconnectTicketResponse {
  std::string ticket;
  std::uint64_t expires_in_seconds = 0;
};
struct AuthenticateResponse {
  std::string session_id;
  Identity identity;
  ReconnectTicketResponse reconnect;
};
struct ErrorEnvelope {
  std::string code;
  std::string message;
  bool retryable = false;
  std::optional<std::uint64_t> retry_after_ms;
};

void validate_identity(const Identity& identity);
void validate_error_envelope(const ErrorEnvelope& envelope);
class EluraProtocol {
 public:
  static void validate_client_frame(
      const Elr2Frame& frame, bool authenticated,
      std::optional<std::uint64_t> pending_heartbeat = std::nullopt);
  [[nodiscard]] static Elr2Frame heartbeat_response(const Elr2Frame& request);
};

enum class SessionControlAction : std::int32_t {
  Kick = 1,
  AccountVersionChanged = 2,
  DuplicateLogin = 3,
  ForceLogout = 4,
  ServerDraining = 5,
};

struct SessionControl {
  SessionControlAction action = SessionControlAction::Kick;
  std::string reason;
};

[[nodiscard]] Bytes encode_session_control(const SessionControl& control);
[[nodiscard]] SessionControl decode_session_control(std::span<const std::uint8_t> bytes);

}  // namespace elura