dedicated_server_manager.h

Go to the documentation of this file.

    // Copyright (C) 2013-2020 iFunFactory Inc. All Rights Reserved.
//
// This work is confidential and proprietary to iFunFactory Inc. and
// must not be used, disclosed, copied, or distributed without the prior
// consent of iFunFactory Inc.

#ifndef INCLUDE_FUNAPI_SERVICE_DEDICATED_SERVER_MANAGER_H_
#define INCLUDE_FUNAPI_SERVICE_DEDICATED_SERVER_MANAGER_H_

#include <string>
#include <vector>

#include <boost/function.hpp>
#include <boost/noncopyable.hpp>

#include <funapi/types.h>


namespace fun {

class FUNAPI_DLL_VISIBILITY DedicatedServerManager
    : private boost::noncopyable {
 public:
  typedef boost::function<void (const fun::Uuid &, /* match_id */
                                const std::vector<std::string> &, /* users */
                                bool /* success */)> SendCallback;

  typedef boost::function<void (const fun::Uuid &, /* match_id */
                                const fun::Json &, /* match_data */
                                bool /* success */)> MatchResultCallback;

  typedef boost::function<void (const fun::Uuid &, /* match_id */
                                const fun::Json &, /* game_state */
                                bool /* success */)> GetGameStateCallback;

  typedef boost::function<void (const fun::Uuid &match_id,
                                const std::string &account)> UserJoinedCallback;

  typedef boost::function<void (const fun::Uuid &match_id,
                                const std::string &account)> UserLeftCallback;

  typedef boost::function<void (const fun::Uuid &match_id,
                                const fun::Json &data)> CustomCallback;

  // NOTE: `reserved_instance_count` is a value from MANIFEST file.
  typedef boost::function<uint32_t (uint32_t current_instance_count,
                                    uint32_t idle_instance_count,
                                    uint32_t min_instance_count,
                                    uint32_t max_instance_count,
                                    uint32_t reserved_instance_count)>
      ConfigureReservedInstanceCountCallback;

  // Authorization callback type (for JWT enforced APIs)
  typedef boost::function<bool (
      const std::string &uri, const fun::Json &claim)> JwtAuthorizationCallback;

  // Pre hook for a function that sending the redirection message
  typedef boost::function<bool (const std::string &account_id,
                                const std::string &host,
                                const uint16_t port,
                                const std::string &token)> PreRedirectionHook;

  /*
   * Spawn a dedicated server instance on a remote server.
   * After spwaning a instance, selected users will be redirected to the
   * newly spawned instance.
   * After getting response from the dedicated server, result will be
   * passed to the `callback` function.
   *
   * You may send additional data in JSON format using `match_data` and
   * `user_data.` `match_data` should contain per-match game data and
   * `user_data` should have per-user game data.
   *
   * Also, you could pass arguments for a dedicated server using
   * `dedicated_server_args' parameter. These arguments will be passed when
   * dedicated server manager executes dedicated server excutable.
   *
   * Note: user_data should be given in the same order as `accounts` parameter.
   */
  static void Spawn(const fun::Uuid &match_id,
                    const fun::Json &match_data,
                    const std::vector<std::string> &dedicated_server_args,
                    const std::vector<std::string> &accounts,
                    const std::vector<fun::Json> &user_data,
                    const SendCallback &callback);

  // Additional parameter `region_preference` may given to prioritize certain
  // EC2 regions.
  static void Spawn(const fun::Uuid &match_id,
                    const fun::Json &match_data,
                    const std::vector<std::string> &dedicated_server_args,
                    const std::vector<std::string> &accounts,
                    const std::vector<fun::Json> &user_data,
                    const std::vector<std::string> &region_preference,
                    const SendCallback &callback);

  /*
   * Cancels a spawn request corresponding to `match_id`.
   * If the spawn request was successfully canceled, it returns true.
   * Otherwise false.
   * Also, you can get the parameters that was passed into Spawn() by
   * passing non-null pointer arguments.
  */
  static bool Cancel(const fun::Uuid &match_id,
                     fun::Json *match_data = NULL,
                     std::vector<std::string> *dedicated_server_args = NULL,
                     std::vector<std::string> *accounts = NULL,
                     std::vector<fun::Json> *user_data = NULL);

  /*
   * Sends users in `accounts' to a existing dedicated server instance.
   * You may send additional per-user data in JSON format using user_data.
   *
   * After getting response from the dedicated server, result will be
   * called back using `callback' function.
   */
  static void SendUsers(const fun::Uuid &match_id,
                        const fun::Json &match_data,
                        const std::vector<std::string> &accounts,
                        const std::vector<fun::Json> &user_data,
                        const SendCallback &callback);

  /*
   * Registers handler function for match result.
   *
   * If the match result from the dedicated server instance received,
   * register callback function `callback' would be called.
   */
  static void RegisterMatchResultCallback(const MatchResultCallback &callback);

  /*
   * Registers handler function, which would be called when user enters/leaves
   * the dedicated server.
   */
  static void RegisterUserEnteredCallback(const UserJoinedCallback &callback);
  static void RegisterUserLeftCallback(const UserLeftCallback &callback);

  /*
   * Controls desired # of reserved instance count.
   * If set, iFunEngine will use the callback to determine how many reserved
   * instance should be spawned.
   *
   * If not set, iFunEngine will use the `reserved_instances` value from
   * the MANIFEST file(s).
   */
  static void RegisterConfigureReservedInstanceCountCallback(
      const ConfigureReservedInstanceCountCallback &callback);

  /*
   * Registers callback function. It would be called whenever a dedicated
   * server instance sends any message to the iFunEngine game server.
   */
  static void RegisterCustomCallback(const CustomCallback &callback);

  /*
  * Get state of game that is running on dedicated server
  */
  static void GetGameState(const fun::Uuid &match_id,
                           const GetGameStateCallback &callback);

  // Register callback function to authorize a JWT claims
  static void RegisterJwtAuthorizationCallback(
      const JwtAuthorizationCallback &callback);

  /*
  * Register a pre hook for a function that sending redirection message to the
  * client. The server will not send the message if pre hook returns 'false',
  * you can potentially ignore it, or send the message to your application.
  */
  static void RegisterPreRedirectionHook(const PreRedirectionHook &hook);

  static bool ExistsAvailableHost();

  static bool ExistsAvailableHost(
      const std::vector<std::string> &region_preference);
};

}  // namespace fun

#endif  // INCLUDE_FUNAPI_SERVICE_DEDICATED_SERVER_MANAGER_H_