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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

use crate::{
    entity::{
        DescribePlayerSessionsResult, GetInstanceCertificateResult, StartMatchBackfillResult,
    },
    error::GameLiftErrorType,
};

pub const SDK_VERSION: &str = "4.0.2";

#[derive(Default)]
pub struct Api {
    state: crate::server_state::ServerState,
}

impl Api {
    /// Returns the current version number of the SDK built into the server
    /// process.
    pub fn get_sdk_version() -> &'static str {
        SDK_VERSION
    }

    /// Initializes the GameLift SDK. This method should be called on launch,
    /// before any other GameLift-related initialization occurs.
    pub async fn init_sdk(&mut self) -> Result<(), GameLiftErrorType> {
        self.state.initialize_networking().await
    }

    /// Notifies the GameLift service that the server process is ready to host
    /// game sessions. Call this method after successfully invoking
    /// [init_sdk](crate::api::Api::init_sdk) and completing setup tasks
    /// that are required before the server process can host a game session.
    /// This method should be called only once per process.
    pub async fn process_ready(
        &mut self,
        process_parameters: crate::process_parameters::ProcessParameters,
    ) -> Result<(), GameLiftErrorType> {
        self.state.process_ready(process_parameters).await
    }

    /// Notifies the GameLift service that the server process is shutting down.
    /// This method should be called after all other cleanup tasks, including
    /// shutting down all active game sessions. This method should exit with an
    /// exit code of 0; a non-zero exit code results in an event message that
    /// the process did not exit cleanly.
    pub async fn process_ending(&mut self) -> Result<(), GameLiftErrorType> {
        self.state.process_ending().await
    }

    /// Notifies the GameLift service that the server process has activated a
    /// game session and is now ready to receive player connections. This action
    /// should be called as part of the on_start_game_session() callback
    /// function, after all game session initialization has been completed.
    pub async fn activate_game_session(&self) -> Result<(), GameLiftErrorType> {
        self.state.activate_game_session().await
    }

    /// Notifies the GameLift service that the server process has ended the
    /// current game session. This action is called when the server process will
    /// remain active and ready to host a new game session. It should be called
    /// only after your game session termination procedure is complete, because
    /// it signals to GameLift that the server process is immediately available
    /// to host a new game session.
    ///
    /// This action is not called if the server process will be shut down after
    /// the game session stops. Instead, call
    /// [process_ending](crate::api::Api::process_ending) to signal that
    /// both the game session and the server process are ending.
    #[deprecated(
        since = "4.0.1",
        note = "Instead, the server process should call process_ending() after a game session has \
                ended"
    )]
    pub async fn terminate_game_session(&self) -> Result<(), GameLiftErrorType> {
        self.state.terminate_game_session().await
    }

    /// Updates the current game session's ability to accept new player
    /// sessions. A game session can be set to either accept or deny all new
    /// player sessions. (See also the update_game_session() action in the
    /// GameLift Service API Reference).
    pub async fn update_player_session_creation_policy(
        &self,
        player_session_policy: crate::entity::PlayerSessionCreationPolicy,
    ) -> Result<(), GameLiftErrorType> {
        self.state.update_player_session_creation_policy(player_session_policy).await
    }

    /// Retrieves the ID of the game session currently being hosted by the
    /// server process, if the server process is active.
    pub async fn get_game_session_id(
        &self,
    ) -> Result<crate::entity::GameSessionId, crate::error::GameLiftErrorType> {
        self.state.get_game_session_id().await
    }

    /// Returns the time that a server process is scheduled to be shut down, if
    /// a termination time is available. A server process takes this action
    /// after receiving an on_process_terminate() callback from the GameLift
    /// service. GameLift may call on_process_terminate() for the following
    /// reasons: (1) for poor health (the server process has reported port
    /// health or has not responded to GameLift, (2) when terminating the
    /// instance during a scale-down event, or (3) when an instance is being
    /// terminated due to a spot-instance interruption.
    ///
    /// If the process has received an on_process_terminate() callback, the
    /// value returned is the estimated termination time. If the process has
    /// not received an on_process_terminate() callback, an error message is
    /// returned. Learn more about shutting down a server process.
    pub async fn get_termination_time(
        &self,
    ) -> Result<crate::entity::TerminationTimeType, crate::error::GameLiftErrorType> {
        self.state.get_termination_time().await
    }

    /// Notifies the GameLift service that a player with the specified player
    /// session ID has connected to the server process and needs validation.
    /// GameLift verifies that the player session ID is valid—that is, that the
    /// player ID has reserved a player slot in the game session. Once
    /// validated, GameLift changes the status of the player slot from RESERVED
    /// to ACTIVE.
    pub async fn accept_player_session(
        &self,
        player_session_id: crate::entity::PlayerSessionId,
    ) -> Result<(), GameLiftErrorType> {
        self.state.accept_player_session(player_session_id).await
    }

    /// Notifies the GameLift service that a player with the specified player
    /// session ID has disconnected from the server process. In response,
    /// GameLift changes the player slot to available, which allows it to be
    /// assigned to a new player.
    pub async fn remove_player_session(
        &self,
        player_session_id: crate::entity::PlayerSessionId,
    ) -> Result<(), GameLiftErrorType> {
        self.state.remove_player_session(player_session_id).await
    }

    /// Retrieves player session data, including settings, session metadata, and
    /// player data. Use this action to get information for a single player
    /// session, for all player sessions in a game session, or for all player
    /// sessions associated with a single player ID.
    pub async fn describe_player_sessions(
        &self,
        describe_player_sessions_request: crate::entity::DescribePlayerSessionsRequest,
    ) -> Result<DescribePlayerSessionsResult, GameLiftErrorType> {
        self.state.describe_player_sessions(describe_player_sessions_request).await
    }

    /// Sends a request to find new players for open slots in a game session
    /// created with FlexMatch. See also the AWS SDK action
    /// [start_match_backfill](crate::api::Api::start_match_backfill). With this
    /// action, match backfill requests can be initiated by a game server
    /// process that is hosting the game session. Learn more about the
    /// FlexMatch backfill feature.
    ///
    /// This action is asynchronous. If new players are successfully matched,
    /// the GameLift service delivers updated matchmaker data using the callback
    /// function on_update_game_session().
    ///
    /// A server process can have only one active match backfill request at a
    /// time. To send a new request, first call
    /// [stop_match_backfill](crate::api::Api::stop_match_backfill) to cancel
    /// the original request.
    pub async fn start_match_backfill(
        &self,
        request: crate::entity::StartMatchBackfillRequest,
    ) -> Result<StartMatchBackfillResult, GameLiftErrorType> {
        self.state.backfill_matchmaking(request).await
    }

    /// Cancels an active match backfill request that was created with
    /// [start_match_backfill](crate::api::Api::start_match_backfill). See also
    /// the AWS SDK action StopMatchmaking(). Learn more about the FlexMatch
    /// backfill feature.
    pub async fn stop_match_backfill(
        &self,
        request: crate::entity::StopMatchBackfillRequest,
    ) -> Result<(), GameLiftErrorType> {
        self.state.stop_matchmaking(request).await
    }

    /// Retrieves the file location of a pem-encoded TLS certificate that is
    /// associated with the fleet and its instances. This certificate is
    /// generated when a new fleet is created with the certificate configuration
    /// set to GENERATED. Use this certificate to establish a secure connection
    /// with a game client and to encrypt client/server communication.
    pub async fn get_instance_certificate(
        &self,
    ) -> Result<GetInstanceCertificateResult, GameLiftErrorType> {
        self.state.get_instance_certificate().await
    }

    pub async fn destroy(&self) -> bool {
        self.state.shutdown().await
    }
}